Struct iced_x86::code_asm::AsmRegisterXmm

pub struct AsmRegisterXmm { /* private fields */ }

All 128-bit vector registers (XMM).

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

Implementations

impl AsmRegisterXmm

pub fn k1(self) -> Self

Adds a {k1} opmask register

pub fn k2(self) -> Self

Adds a {k2} opmask register

pub fn k3(self) -> Self

Adds a {k3} opmask register

pub fn k4(self) -> Self

Adds a {k4} opmask register

pub fn k5(self) -> Self

Adds a {k5} opmask register

pub fn k6(self) -> Self

Adds a {k6} opmask register

pub fn k7(self) -> Self

Adds a {k7} opmask register

pub fn z(self) -> Self

Enables zeroing masking {z}

pub fn sae(self) -> Self

Enables suppress all exceptions {sae}

pub fn rn_sae(self) -> Self

Round to nearest (even)

pub fn rd_sae(self) -> Self

Round down (toward -inf)

pub fn ru_sae(self) -> Self

Round up (toward +inf)

pub fn rz_sae(self) -> Self

Round toward zero (truncate)

Trait Implementations

impl Add<AsmRegister32> for AsmRegisterXmm

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<AsmRegister64> for AsmRegisterXmm

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<AsmRegisterXmm> for AsmRegister32

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<AsmRegisterXmm> for AsmRegister64

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Clone for AsmRegisterXmm

fn clone(&self) -> AsmRegisterXmm

Returns a copy of the value.

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

Performs copy-assignment from source.

impl CodeAsmAddpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmAddpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmAddps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmAddps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmAddsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmAddsd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmAddss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmAddss<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmAddsubpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmAddsubpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmAddsubps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmAddsubps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmAesdec<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmAesdec<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmAesdec128kl<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmAesdec256kl<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmAesdeclast<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmAesdeclast<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmAesenc<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmAesenc<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmAesenc128kl<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmAesenc256kl<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmAesenclast<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmAesenclast<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmAesimc<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmAesimc<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmAeskeygenassist<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmAeskeygenassist<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmAeskeygenassist<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmAeskeygenassist<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmAndnpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmAndnpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmAndnps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmAndnps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmAndpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmAndpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmAndps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmAndps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmBlendpd<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmBlendpd<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmBlendpd<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmBlendpd<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmBlendps<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmBlendps<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmBlendps<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmBlendps<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmBlendvpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmBlendvpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmBlendvps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmBlendvps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmCmpeqpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmpeqpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmCmpeqps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmpeqps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmCmpeqsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmpeqsd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmCmpeqss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmpeqss<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmCmplepd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmplepd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmCmpleps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmpleps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmCmplesd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmplesd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmCmpless<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmpless<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmCmpltpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmpltpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmCmpltps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmpltps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmCmpltsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmpltsd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmCmpltss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmpltss<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmCmpneqpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmpneqpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmCmpneqps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmpneqps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmCmpneqsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmpneqsd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmCmpneqss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmpneqss<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmCmpnlepd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmpnlepd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmCmpnleps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmpnleps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmCmpnlesd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmpnlesd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmCmpnless<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmpnless<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmCmpnltpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmpnltpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmCmpnltps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmpnltps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmCmpnltsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmpnltsd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmCmpnltss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmpnltss<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmCmpordpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmpordpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmCmpordps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmpordps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmCmpordsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmpordsd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmCmpordss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmpordss<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmCmppd<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmCmppd<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmCmppd<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmCmppd<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmCmpps<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmCmpps<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmCmpps<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmCmpps<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmCmpsd3<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmCmpsd3<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmCmpsd3<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmCmpsd3<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmCmpss<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmCmpss<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmCmpss<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmCmpss<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmCmpunordpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmpunordpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmCmpunordps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmpunordps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmCmpunordsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmpunordsd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmCmpunordss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmpunordss<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmComisd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmComisd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmComiss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmComiss<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmCvtdq2pd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCvtdq2pd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmCvtdq2ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCvtdq2ps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmCvtpd2dq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCvtpd2dq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmCvtpd2pi<AsmRegisterMm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmCvtpd2ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCvtpd2ps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmCvtpi2pd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCvtpi2pd<AsmRegisterXmm, AsmRegisterMm> for CodeAssembler

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

impl CodeAsmCvtpi2ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCvtpi2ps<AsmRegisterXmm, AsmRegisterMm> for CodeAssembler

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

impl CodeAsmCvtps2dq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCvtps2dq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmCvtps2pd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCvtps2pd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmCvtps2pi<AsmRegisterMm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmCvtsd2si<AsmRegister32, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmCvtsd2si<AsmRegister64, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmCvtsd2ss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCvtsd2ss<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmCvtsi2sd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCvtsi2sd<AsmRegisterXmm, AsmRegister32> for CodeAssembler

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

impl CodeAsmCvtsi2sd<AsmRegisterXmm, AsmRegister64> for CodeAssembler

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

impl CodeAsmCvtsi2ss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCvtsi2ss<AsmRegisterXmm, AsmRegister32> for CodeAssembler

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

impl CodeAsmCvtsi2ss<AsmRegisterXmm, AsmRegister64> for CodeAssembler

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

impl CodeAsmCvtss2sd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCvtss2sd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmCvtss2si<AsmRegister32, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmCvtss2si<AsmRegister64, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmCvttpd2dq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCvttpd2dq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmCvttpd2pi<AsmRegisterMm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmCvttps2dq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCvttps2dq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmCvttps2pi<AsmRegisterMm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmCvttsd2si<AsmRegister32, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmCvttsd2si<AsmRegister64, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmCvttss2si<AsmRegister32, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmCvttss2si<AsmRegister64, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmDivpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmDivpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmDivps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmDivps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmDivsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmDivsd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmDivss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmDivss<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmDppd<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmDppd<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmDppd<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmDppd<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmDpps<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmDpps<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmDpps<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmDpps<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmExtractps<AsmMemoryOperand, AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmExtractps<AsmMemoryOperand, AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmExtractps<AsmRegister32, AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmExtractps<AsmRegister32, AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmExtractps<AsmRegister64, AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmExtractps<AsmRegister64, AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmExtrq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmExtrq3<AsmRegisterXmm, i32, i32> for CodeAssembler

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

impl CodeAsmExtrq3<AsmRegisterXmm, u32, u32> for CodeAssembler

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

impl CodeAsmGf2p8affineinvqb<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmGf2p8affineinvqb<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmGf2p8affineinvqb<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmGf2p8affineinvqb<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmGf2p8affineqb<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmGf2p8affineqb<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmGf2p8affineqb<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmGf2p8affineqb<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmGf2p8mulb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmGf2p8mulb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmHaddpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmHaddpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmHaddps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmHaddps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmHsubpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmHsubpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmHsubps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmHsubps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmInsertps<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmInsertps<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmInsertps<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmInsertps<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmInsertq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmInsertq4<AsmRegisterXmm, AsmRegisterXmm, i32, i32> for CodeAssembler

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

impl CodeAsmInsertq4<AsmRegisterXmm, AsmRegisterXmm, u32, u32> for CodeAssembler

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

impl CodeAsmLddqu<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmLoadiwkey<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmMaskmovdqu<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmMaxpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMaxpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmMaxps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMaxps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmMaxsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMaxsd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmMaxss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMaxss<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmMinpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMinpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmMinps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMinps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmMinsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMinsd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmMinss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMinss<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmMovapd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmMovapd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMovapd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmMovaps<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmMovaps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMovaps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmMovd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmMovd<AsmRegister32, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmMovd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMovd<AsmRegisterXmm, AsmRegister32> for CodeAssembler

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

impl CodeAsmMovddup<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMovddup<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmMovdq2q<AsmRegisterMm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmMovdqa<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmMovdqa<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMovdqa<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmMovdqu<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmMovdqu<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMovdqu<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmMovhlps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmMovhpd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmMovhpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMovhps<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmMovhps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMovlhps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmMovlpd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmMovlpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMovlps<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmMovlps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMovmskpd<AsmRegister32, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmMovmskpd<AsmRegister64, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmMovmskps<AsmRegister32, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmMovmskps<AsmRegister64, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmMovntdq<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmMovntdqa<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMovntpd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmMovntps<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmMovntsd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmMovntss<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmMovq<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmMovq<AsmRegister64, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmMovq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMovq<AsmRegisterXmm, AsmRegister64> for CodeAssembler

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

impl CodeAsmMovq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmMovq2dq<AsmRegisterXmm, AsmRegisterMm> for CodeAssembler

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

impl CodeAsmMovsd2<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmMovsd2<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMovsd2<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmMovshdup<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMovshdup<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmMovsldup<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMovsldup<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmMovss<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmMovss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMovss<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmMovupd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmMovupd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMovupd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmMovups<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmMovups<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMovups<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmMpsadbw<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmMpsadbw<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmMpsadbw<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmMpsadbw<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmMulpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMulpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmMulps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMulps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmMulsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMulsd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmMulss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMulss<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmOrpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmOrpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmOrps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmOrps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPabsb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPabsb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPabsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPabsd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPabsw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPabsw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPackssdw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPackssdw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPacksswb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPacksswb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPackusdw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPackusdw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPackuswb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPackuswb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPaddb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPaddb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPaddd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPaddd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPaddq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPaddq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPaddsb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPaddsb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPaddsw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPaddsw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPaddusb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPaddusb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPaddusw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPaddusw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPaddw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPaddw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPalignr<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmPalignr<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmPalignr<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmPalignr<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmPand<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPand<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPandn<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPandn<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPavgb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPavgb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPavgw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPavgw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPblendvb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPblendvb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPblendw<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmPblendw<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmPblendw<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmPblendw<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmPclmulhqhqdq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPclmulhqhqdq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPclmulhqlqdq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPclmulhqlqdq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPclmullqhqdq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPclmullqhqdq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPclmullqlqdq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPclmullqlqdq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPclmulqdq<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmPclmulqdq<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmPclmulqdq<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmPclmulqdq<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmPcmpeqb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPcmpeqb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPcmpeqd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPcmpeqd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPcmpeqq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPcmpeqq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPcmpeqw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPcmpeqw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPcmpestri<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmPcmpestri<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmPcmpestri<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmPcmpestri<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmPcmpestri64<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmPcmpestri64<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmPcmpestri64<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmPcmpestri64<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmPcmpestrm<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmPcmpestrm<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmPcmpestrm<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmPcmpestrm<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmPcmpestrm64<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmPcmpestrm64<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmPcmpestrm64<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmPcmpestrm64<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmPcmpgtb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPcmpgtb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPcmpgtd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPcmpgtd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPcmpgtq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPcmpgtq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPcmpgtw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPcmpgtw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPcmpistri<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmPcmpistri<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmPcmpistri<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmPcmpistri<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmPcmpistrm<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmPcmpistrm<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmPcmpistrm<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmPcmpistrm<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmPextrb<AsmMemoryOperand, AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmPextrb<AsmMemoryOperand, AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmPextrb<AsmRegister32, AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmPextrb<AsmRegister32, AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmPextrb<AsmRegister64, AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmPextrb<AsmRegister64, AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmPextrd<AsmMemoryOperand, AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmPextrd<AsmMemoryOperand, AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmPextrd<AsmRegister32, AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmPextrd<AsmRegister32, AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmPextrq<AsmMemoryOperand, AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmPextrq<AsmMemoryOperand, AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmPextrq<AsmRegister64, AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmPextrq<AsmRegister64, AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmPextrw<AsmMemoryOperand, AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmPextrw<AsmMemoryOperand, AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmPextrw<AsmRegister32, AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmPextrw<AsmRegister32, AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmPextrw<AsmRegister64, AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmPextrw<AsmRegister64, AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmPhaddd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPhaddd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPhaddsw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPhaddsw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPhaddw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPhaddw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPhminposuw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPhminposuw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPhsubd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPhsubd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPhsubsw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPhsubsw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPhsubw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPhsubw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPinsrb<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmPinsrb<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmPinsrb<AsmRegisterXmm, AsmRegister32, i32> for CodeAssembler

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

impl CodeAsmPinsrb<AsmRegisterXmm, AsmRegister32, u32> for CodeAssembler

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

impl CodeAsmPinsrb<AsmRegisterXmm, AsmRegister64, i32> for CodeAssembler

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

impl CodeAsmPinsrb<AsmRegisterXmm, AsmRegister64, u32> for CodeAssembler

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

impl CodeAsmPinsrd<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmPinsrd<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmPinsrd<AsmRegisterXmm, AsmRegister32, i32> for CodeAssembler

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

impl CodeAsmPinsrd<AsmRegisterXmm, AsmRegister32, u32> for CodeAssembler

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

impl CodeAsmPinsrq<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmPinsrq<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmPinsrq<AsmRegisterXmm, AsmRegister64, i32> for CodeAssembler

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

impl CodeAsmPinsrq<AsmRegisterXmm, AsmRegister64, u32> for CodeAssembler

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

impl CodeAsmPinsrw<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmPinsrw<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmPinsrw<AsmRegisterXmm, AsmRegister32, i32> for CodeAssembler

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

impl CodeAsmPinsrw<AsmRegisterXmm, AsmRegister32, u32> for CodeAssembler

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

impl CodeAsmPinsrw<AsmRegisterXmm, AsmRegister64, i32> for CodeAssembler

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

impl CodeAsmPinsrw<AsmRegisterXmm, AsmRegister64, u32> for CodeAssembler

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

impl CodeAsmPmaddubsw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPmaddubsw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPmaddwd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPmaddwd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPmaxsb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPmaxsb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPmaxsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPmaxsd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPmaxsw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPmaxsw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPmaxub<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPmaxub<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPmaxud<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPmaxud<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPmaxuw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPmaxuw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPminsb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPminsb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPminsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPminsd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPminsw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPminsw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPminub<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPminub<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPminud<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPminud<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPminuw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPminuw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPmovmskb<AsmRegister32, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPmovmskb<AsmRegister64, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPmovsxbd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPmovsxbd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPmovsxbq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPmovsxbq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPmovsxbw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPmovsxbw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPmovsxdq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPmovsxdq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPmovsxwd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPmovsxwd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPmovsxwq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPmovsxwq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPmovzxbd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPmovzxbd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPmovzxbq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPmovzxbq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPmovzxbw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPmovzxbw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPmovzxdq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPmovzxdq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPmovzxwd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPmovzxwd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPmovzxwq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPmovzxwq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPmuldq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPmuldq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPmulhrsw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPmulhrsw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPmulhuw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPmulhuw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPmulhw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPmulhw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPmulld<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPmulld<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPmullw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPmullw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPmuludq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPmuludq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPor<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPor<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPsadbw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPsadbw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPshufb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPshufb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPshufd<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmPshufd<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmPshufd<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmPshufd<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmPshufhw<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmPshufhw<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmPshufhw<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmPshufhw<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmPshuflw<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmPshuflw<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmPshuflw<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmPshuflw<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmPsignb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPsignb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPsignd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPsignd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPsignw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPsignw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPslld<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPslld<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPslld<AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmPslld<AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmPslldq<AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmPslldq<AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmPsllq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPsllq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPsllq<AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmPsllq<AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmPsllw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPsllw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPsllw<AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmPsllw<AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmPsrad<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPsrad<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPsrad<AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmPsrad<AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmPsraw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPsraw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPsraw<AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmPsraw<AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmPsrld<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPsrld<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPsrld<AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmPsrld<AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmPsrldq<AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmPsrldq<AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmPsrlq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPsrlq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPsrlq<AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmPsrlq<AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmPsrlw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPsrlw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPsrlw<AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmPsrlw<AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmPsubb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPsubb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPsubd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPsubd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPsubq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPsubq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPsubsb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPsubsb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPsubsw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPsubsw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPsubusb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPsubusb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPsubusw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPsubusw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPsubw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPsubw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPtest<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPtest<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPunpckhbw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPunpckhbw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPunpckhdq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPunpckhdq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPunpckhqdq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPunpckhqdq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPunpckhwd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPunpckhwd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPunpcklbw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPunpcklbw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPunpckldq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPunpckldq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPunpcklqdq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPunpcklqdq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPunpcklwd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPunpcklwd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPxor<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPxor<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmRcpps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmRcpps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmRcpss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmRcpss<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmRoundpd<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmRoundpd<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmRoundpd<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmRoundpd<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmRoundps<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmRoundps<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmRoundps<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmRoundps<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmRoundsd<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmRoundsd<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmRoundsd<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmRoundsd<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmRoundss<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmRoundss<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmRoundss<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmRoundss<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmRsqrtps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmRsqrtps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmRsqrtss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmRsqrtss<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmSha1msg1<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmSha1msg1<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmSha1msg2<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmSha1msg2<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmSha1nexte<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmSha1nexte<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmSha1rnds4<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmSha1rnds4<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmSha1rnds4<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmSha1rnds4<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmSha256msg1<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmSha256msg1<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmSha256msg2<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmSha256msg2<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmSha256rnds2<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmSha256rnds2<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmShufpd<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmShufpd<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmShufpd<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmShufpd<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmShufps<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmShufps<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmShufps<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmShufps<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmSqrtpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmSqrtpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmSqrtps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmSqrtps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmSqrtsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmSqrtsd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmSqrtss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmSqrtss<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmSubpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmSubpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmSubps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmSubps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmSubsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmSubsd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmSubss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmSubss<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmUcomisd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmUcomisd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmUcomiss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmUcomiss<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmUnpckhpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmUnpckhpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmUnpckhps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmUnpckhps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmUnpcklpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmUnpcklpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmUnpcklps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmUnpcklps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmV4fmaddss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmV4fnmaddss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVaddpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVaddpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVaddph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVaddph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVaddps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVaddps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVaddsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVaddsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVaddsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVaddsh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVaddss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVaddss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVaddsubpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVaddsubpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVaddsubps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVaddsubps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVaesdec<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVaesdec<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVaesdeclast<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVaesdeclast<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVaesenc<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVaesenc<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVaesenclast<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVaesenclast<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVaesimc<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVaesimc<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVaeskeygenassist<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmVaeskeygenassist<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmVaeskeygenassist<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmVaeskeygenassist<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl CodeAsmVandnpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVandnpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVandnps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVandnps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVandpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVandpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVandps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVandps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVbcstnebf162ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVbcstnesh2ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVblendmpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVblendmpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVblendmps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVblendmps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVblendpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmVblendpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmVblendpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmVblendpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmVblendps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmVblendps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmVblendps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmVblendps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmVblendvpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVblendvpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVblendvps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVblendvps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVbroadcastf32x2<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVbroadcastf32x2<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVbroadcasti32x2<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVbroadcasti32x2<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVbroadcasti32x2<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vbroadcasti32x2( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVbroadcasti32x2<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

fn vbroadcasti32x2( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVbroadcastsd<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vbroadcastsd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVbroadcastsd<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

fn vbroadcastsd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVbroadcastss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vbroadcastss( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVbroadcastss<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vbroadcastss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVbroadcastss<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vbroadcastss( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVbroadcastss<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

fn vbroadcastss( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_ospd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_ospd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_ospd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpeq_ospd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_ospd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_ospd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_ospd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpeq_ospd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_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_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<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_osps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_osps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpeq_osps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_ossd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_ossd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_ossd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpeq_ossd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_ossd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_ossd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_ossd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpeq_ossd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_ossh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_ossh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_ossh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpeq_ossh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_osss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_osss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_osss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpeq_osss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_osss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_osss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_osss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpeq_osss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpeq_uqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uqpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpeq_uqpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_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_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<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uqps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpeq_uqps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uqsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpeq_uqsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uqsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpeq_uqsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uqsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpeq_uqsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uqss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpeq_uqss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uqss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpeq_uqss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uspd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uspd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uspd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpeq_uspd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uspd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uspd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uspd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpeq_uspd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_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_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<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_usps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_usps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpeq_usps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_ussd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_ussd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_ussd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpeq_ussd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_ussd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_ussd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_ussd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpeq_ussd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_ussh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_ussh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_ussh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpeq_ussh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_usss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_usss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_usss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpeq_usss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_usss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_usss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_usss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpeq_usss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpeqpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpeqpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpeqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpeqpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeqpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpeqpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpeqpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl 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 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<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeqps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpeqps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpeqps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpeqsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeqsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpeqsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpeqsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpeqsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeqsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpeqsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpeqsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpeqsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeqsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpeqsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpeqsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpeqss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeqss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpeqss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpeqss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpeqss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeqss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpeqss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpeqss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_ospd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalse_ospd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_ospd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpfalse_ospd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_ospd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalse_ospd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_ospd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpfalse_ospd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_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_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<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalse_osps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_osps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpfalse_osps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_ossd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalse_ossd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_ossd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpfalse_ossd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_ossd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalse_ossd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_ossd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpfalse_ossd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_ossh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalse_ossh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_ossh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpfalse_ossh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_osss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalse_osss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_osss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpfalse_osss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_osss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalse_osss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_osss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpfalse_osss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpfalsepd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalsepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpfalsepd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpfalsepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpfalsepd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalsepd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpfalsepd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpfalsepd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl 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 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<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalseps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpfalseps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpfalseps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpfalsesd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalsesd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpfalsesd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpfalsesd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpfalsesd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalsesd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpfalsesd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpfalsesd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpfalsesh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalsesh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpfalsesh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpfalsesh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpfalsess<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalsess( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpfalsess<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpfalsess( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpfalsess<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalsess( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpfalsess<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpfalsess( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpge_oqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpge_oqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpge_oqpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpge_oqpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpge_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_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<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpge_oqps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpge_oqps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpge_oqsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpge_oqsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpge_oqsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpge_oqsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpge_oqsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpge_oqsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpge_oqss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpge_oqss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpge_oqss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpge_oqss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpgepd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpgepd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpgepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpgepd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgepd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpgepd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpgepd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl 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 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<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgeps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpgeps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpgeps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpgesd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgesd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpgesd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpgesd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpgesd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgesd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpgesd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpgesd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpgesh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgesh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpgesh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpgesh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpgess<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgess( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpgess<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpgess( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpgess<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgess( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpgess<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpgess( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgt_oqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpgt_oqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgt_oqpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpgt_oqpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpgt_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_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<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgt_oqps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpgt_oqps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgt_oqsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpgt_oqsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgt_oqsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpgt_oqsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgt_oqsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpgt_oqsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgt_oqss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpgt_oqss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgt_oqss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpgt_oqss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpgtpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgtpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpgtpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpgtpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpgtpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgtpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpgtpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpgtpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl 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 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<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgtps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpgtps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpgtps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpgtsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgtsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpgtsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpgtsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpgtsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgtsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpgtsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpgtsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpgtsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgtsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpgtsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpgtsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpgtss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgtss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpgtss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpgtss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpgtss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgtss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpgtss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpgtss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmple_oqpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmple_oqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmple_oqpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmple_oqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmple_oqpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmple_oqpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmple_oqpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmple_oqpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmple_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_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<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmple_oqps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmple_oqps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmple_oqps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmple_oqsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmple_oqsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmple_oqsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmple_oqsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmple_oqsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmple_oqsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmple_oqsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmple_oqsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmple_oqsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmple_oqsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmple_oqsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmple_oqsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmple_oqss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmple_oqss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmple_oqss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmple_oqss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmple_oqss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmple_oqss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmple_oqss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmple_oqss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmplepd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmplepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmplepd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmplepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmplepd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmplepd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmplepd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmplepd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl 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 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<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpleps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpleps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpleps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmplesd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmplesd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmplesd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmplesd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmplesd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmplesd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmplesd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmplesd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmplesh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmplesh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmplesh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmplesh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpless<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpless( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpless<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpless( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpless<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpless( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpless<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpless( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmplt_oqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmplt_oqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmplt_oqpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmplt_oqpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmplt_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_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<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmplt_oqps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmplt_oqps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmplt_oqsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmplt_oqsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmplt_oqsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmplt_oqsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmplt_oqsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmplt_oqsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmplt_oqss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmplt_oqss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmplt_oqss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmplt_oqss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpltpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpltpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpltpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpltpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpltpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpltpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpltpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpltpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl 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 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<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpltps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpltps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpltps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpltsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpltsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpltsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpltsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpltsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpltsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpltsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpltsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpltsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpltsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpltsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpltsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpltss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpltss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpltss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpltss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpltss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpltss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpltss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpltss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_oqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpneq_oqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_oqpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpneq_oqpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_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_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<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_oqps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpneq_oqps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_oqsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpneq_oqsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_oqsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpneq_oqsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_oqsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpneq_oqsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_oqss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpneq_oqss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_oqss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpneq_oqss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_ospd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_ospd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_ospd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpneq_ospd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_ospd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_ospd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_ospd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpneq_ospd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_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_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<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_osps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_osps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpneq_osps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_ossd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_ossd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_ossd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpneq_ossd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_ossd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_ossd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_ossd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpneq_ossd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_ossh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_ossh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_ossh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpneq_ossh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_osss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_osss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_osss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpneq_osss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_osss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_osss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_osss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpneq_osss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_uspd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_uspd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_uspd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpneq_uspd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_uspd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_uspd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_uspd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpneq_uspd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_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_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<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_usps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_usps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpneq_usps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_ussd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_ussd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_ussd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpneq_ussd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_ussd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_ussd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_ussd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpneq_ussd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_ussh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_ussh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_ussh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpneq_ussh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_usss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_usss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_usss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpneq_usss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_usss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_usss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_usss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpneq_usss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpneqpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpneqpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpneqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpneqpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneqpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpneqpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpneqpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl 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 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<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneqps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpneqps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpneqps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpneqsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneqsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpneqsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpneqsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpneqsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneqsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpneqsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpneqsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpneqsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneqsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpneqsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpneqsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpneqss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneqss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpneqss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpneqss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpneqss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneqss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpneqss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpneqss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnge_uqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnge_uqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnge_uqpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnge_uqpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpnge_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_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<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnge_uqps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnge_uqps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnge_uqsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnge_uqsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnge_uqsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnge_uqsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnge_uqsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnge_uqsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnge_uqss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnge_uqss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnge_uqss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnge_uqss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpngepd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpngepd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpngepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpngepd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngepd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpngepd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpngepd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl 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 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<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngeps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpngeps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpngeps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpngesd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngesd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpngesd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpngesd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpngesd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngesd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpngesd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpngesd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpngesh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngesh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpngesh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpngesh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpngess<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngess( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpngess<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpngess( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpngess<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngess( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpngess<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpngess( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngt_uqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpngt_uqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngt_uqpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpngt_uqpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpngt_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_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<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngt_uqps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpngt_uqps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngt_uqsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpngt_uqsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngt_uqsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpngt_uqsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngt_uqsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpngt_uqsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngt_uqss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpngt_uqss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngt_uqss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpngt_uqss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpngtpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngtpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpngtpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpngtpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpngtpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngtpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpngtpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpngtpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl 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 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<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngtps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpngtps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpngtps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpngtsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngtsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpngtsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpngtsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpngtsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngtsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpngtsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpngtsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpngtsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngtsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpngtsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpngtsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpngtss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngtss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpngtss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpngtss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpngtss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngtss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpngtss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpngtss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnle_uqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnle_uqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnle_uqpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnle_uqpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpnle_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_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<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnle_uqps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnle_uqps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnle_uqsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnle_uqsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnle_uqsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnle_uqsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnle_uqsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnle_uqsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnle_uqss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnle_uqss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnle_uqss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnle_uqss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpnlepd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpnlepd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnlepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpnlepd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlepd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpnlepd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnlepd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl 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 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<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnleps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpnleps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnleps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpnlesd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlesd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpnlesd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnlesd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpnlesd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlesd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpnlesd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnlesd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpnlesh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlesh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpnlesh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnlesh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpnless<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnless( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpnless<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnless( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpnless<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnless( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpnless<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnless( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlt_uqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnlt_uqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlt_uqpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnlt_uqpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_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_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<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlt_uqps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnlt_uqps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlt_uqsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnlt_uqsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlt_uqsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnlt_uqsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlt_uqsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnlt_uqsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlt_uqss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnlt_uqss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlt_uqss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnlt_uqss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpnltpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnltpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpnltpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnltpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpnltpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnltpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpnltpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnltpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl 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 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<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnltps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpnltps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnltps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpnltsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnltsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpnltsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnltsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpnltsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnltsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpnltsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnltsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpnltsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnltsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpnltsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnltsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpnltss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnltss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpnltss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnltss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpnltss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnltss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpnltss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnltss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpord_spd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpord_spd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpord_spd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpord_spd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpord_spd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpord_spd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpord_spd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpord_spd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpord_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_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<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpord_sps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpord_sps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpord_sps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpord_ssd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpord_ssd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpord_ssd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpord_ssd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpord_ssd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpord_ssd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpord_ssd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpord_ssd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpord_ssh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpord_ssh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpord_ssh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpord_ssh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpord_sss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpord_sss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpord_sss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpord_sss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpord_sss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpord_sss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpord_sss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpord_sss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpordpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpordpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpordpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpordpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpordpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpordpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpordpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpordpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl 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 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<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpordps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpordps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpordps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpordsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpordsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpordsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpordsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpordsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpordsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpordsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpordsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpordsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpordsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpordsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpordsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpordss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpordss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpordss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpordss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpordss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpordss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpordss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpordss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmppd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vcmppd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVcmppd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vcmppd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVcmppd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vcmppd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVcmppd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vcmppd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVcmppd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vcmppd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVcmppd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vcmppd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVcmppd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vcmppd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVcmppd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vcmppd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl 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 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<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vcmpps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVcmpps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vcmpps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVcmpps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vcmpps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVcmpps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vcmpps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVcmpsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vcmpsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVcmpsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vcmpsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVcmpsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vcmpsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVcmpsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vcmpsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVcmpsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vcmpsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVcmpsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vcmpsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVcmpsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vcmpsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVcmpsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vcmpsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVcmpsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vcmpsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVcmpsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vcmpsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVcmpsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vcmpsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVcmpsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vcmpsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVcmpss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vcmpss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVcmpss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vcmpss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVcmpss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vcmpss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVcmpss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vcmpss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVcmpss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vcmpss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVcmpss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vcmpss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVcmpss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vcmpss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVcmpss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vcmpss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_uspd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrue_uspd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_uspd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmptrue_uspd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_uspd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrue_uspd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_uspd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmptrue_uspd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_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_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<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrue_usps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_usps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmptrue_usps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_ussd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrue_ussd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_ussd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmptrue_ussd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_ussd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrue_ussd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_ussd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmptrue_ussd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_ussh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrue_ussh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_ussh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmptrue_ussh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_usss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrue_usss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_usss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmptrue_usss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_usss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrue_usss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_usss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmptrue_usss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmptruepd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptruepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmptruepd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmptruepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmptruepd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptruepd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmptruepd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmptruepd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl 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 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<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrueps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmptrueps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmptrueps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmptruesd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptruesd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmptruesd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmptruesd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmptruesd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptruesd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmptruesd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmptruesd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmptruesh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptruesh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmptruesh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmptruesh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmptruess<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptruess( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmptruess<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmptruess( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmptruess<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptruess( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmptruess<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmptruess( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_spd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunord_spd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_spd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpunord_spd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_spd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunord_spd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_spd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpunord_spd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_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_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<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunord_sps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_sps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpunord_sps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_ssd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunord_ssd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_ssd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpunord_ssd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_ssd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunord_ssd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_ssd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpunord_ssd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_ssh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunord_ssh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_ssh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpunord_ssh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_sss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunord_sss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_sss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpunord_sss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_sss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunord_sss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_sss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpunord_sss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpunordpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpunordpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpunordpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpunordpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpunordpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpunordpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl 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 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<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpunordps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpunordps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpunordsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpunordsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpunordsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpunordsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpunordsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpunordsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpunordsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpunordsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpunordsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpunordss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpunordss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpunordss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpunordss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpunordss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpunordss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcomisd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcomisd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcomisd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcomisd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcomish<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcomish( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcomish<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcomish( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcomiss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcomiss( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcomiss<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcomiss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcompresspd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vcompresspd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcompresspd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcompresspd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcompressps<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vcompressps( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcompressps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcompressps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvtdq2pd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtdq2pd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtdq2pd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtdq2pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvtdq2pd<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vcvtdq2pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvtdq2ph<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtdq2ph( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtdq2ph<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtdq2ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvtdq2ph<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

fn vcvtdq2ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVcvtdq2phx<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtdq2phx( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtdq2phy<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtdq2phy( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtdq2ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtdq2ps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtdq2ps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtdq2ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvtne2ps2bf16<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtne2ps2bf16( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtne2ps2bf16<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtne2ps2bf16( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvtneebf162ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtneebf162ps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtneeph2ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtneeph2ps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtneobf162ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtneobf162ps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtneoph2ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtneoph2ps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtneps2bf16<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtneps2bf16( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtneps2bf16<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtneps2bf16( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvtneps2bf16<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

fn vcvtneps2bf16( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVcvtneps2bf16x<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtneps2bf16x( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtneps2bf16y<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtneps2bf16y( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2dq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtpd2dq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2dq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtpd2dq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2dq<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

fn vcvtpd2dq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2dqx<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtpd2dqx( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2dqy<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtpd2dqy( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2ph<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtpd2ph( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2ph<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtpd2ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2ph<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

fn vcvtpd2ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2ph<AsmRegisterXmm, AsmRegisterZmm> for CodeAssembler

fn vcvtpd2ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2phx<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtpd2phx( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2phy<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtpd2phy( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2phz<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtpd2phz( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtpd2ps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2ps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtpd2ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2ps<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

fn vcvtpd2ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2psx<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtpd2psx( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2psy<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtpd2psy( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2qq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtpd2qq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2qq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtpd2qq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2udq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtpd2udq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2udq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtpd2udq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2udq<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

fn vcvtpd2udq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2udqx<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtpd2udqx( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2udqy<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtpd2udqy( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2uqq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtpd2uqq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2uqq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtpd2uqq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvtph2dq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2dq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtph2dq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtph2dq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvtph2dq<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vcvtph2dq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvtph2pd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2pd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtph2pd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtph2pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvtph2pd<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vcvtph2pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvtph2pd<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

fn vcvtph2pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvtph2ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2ps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtph2ps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtph2ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvtph2ps<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vcvtph2ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvtph2psx<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2psx( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtph2psx<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtph2psx( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvtph2psx<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vcvtph2psx( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvtph2qq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2qq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtph2qq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtph2qq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvtph2qq<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vcvtph2qq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvtph2qq<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

fn vcvtph2qq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvtph2udq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2udq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtph2udq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtph2udq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvtph2udq<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vcvtph2udq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvtph2uqq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2uqq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtph2uqq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtph2uqq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvtph2uqq<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vcvtph2uqq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvtph2uqq<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

fn vcvtph2uqq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvtph2uw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2uw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtph2uw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtph2uw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvtph2w<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2w( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtph2w<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtph2w( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvtps2dq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtps2dq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtps2dq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtps2dq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvtps2pd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtps2pd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtps2pd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtps2pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvtps2pd<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vcvtps2pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvtps2ph<AsmMemoryOperand, AsmRegisterXmm, i32> for CodeAssembler

fn vcvtps2ph( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVcvtps2ph<AsmMemoryOperand, AsmRegisterXmm, u32> for CodeAssembler

fn vcvtps2ph( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVcvtps2ph<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vcvtps2ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVcvtps2ph<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vcvtps2ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVcvtps2ph<AsmRegisterXmm, AsmRegisterYmm, i32> for CodeAssembler

fn vcvtps2ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVcvtps2ph<AsmRegisterXmm, AsmRegisterYmm, u32> for CodeAssembler

fn vcvtps2ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVcvtps2phx<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtps2phx( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtps2phx<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtps2phx( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvtps2phx<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

fn vcvtps2phx( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVcvtps2phxx<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtps2phxx( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtps2phxy<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtps2phxy( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtps2qq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtps2qq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtps2qq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtps2qq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvtps2qq<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vcvtps2qq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvtps2udq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtps2udq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtps2udq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtps2udq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvtps2uqq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtps2uqq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtps2uqq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtps2uqq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvtps2uqq<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vcvtps2uqq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvtqq2pd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtqq2pd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtqq2pd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtqq2pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvtqq2ph<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtqq2ph( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtqq2ph<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtqq2ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvtqq2ph<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

fn vcvtqq2ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVcvtqq2ph<AsmRegisterXmm, AsmRegisterZmm> for CodeAssembler

fn vcvtqq2ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcvtqq2phx<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtqq2phx( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtqq2phy<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtqq2phy( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtqq2phz<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtqq2phz( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtqq2ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtqq2ps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtqq2ps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtqq2ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvtqq2ps<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

fn vcvtqq2ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVcvtqq2psx<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtqq2psx( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtqq2psy<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtqq2psy( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtsd2sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtsd2sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtsd2sh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtsd2sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvtsd2si<AsmRegister32, AsmRegisterXmm> for CodeAssembler

fn vcvtsd2si( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvtsd2si<AsmRegister64, AsmRegisterXmm> for CodeAssembler

fn vcvtsd2si( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvtsd2ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtsd2ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtsd2ss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtsd2ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvtsd2usi<AsmRegister32, AsmRegisterXmm> for CodeAssembler

fn vcvtsd2usi( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvtsd2usi<AsmRegister64, AsmRegisterXmm> for CodeAssembler

fn vcvtsd2usi( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvtsh2sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtsh2sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtsh2sd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtsh2sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvtsh2si<AsmRegister32, AsmRegisterXmm> for CodeAssembler

fn vcvtsh2si( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvtsh2si<AsmRegister64, AsmRegisterXmm> for CodeAssembler

fn vcvtsh2si( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvtsh2ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtsh2ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtsh2ss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtsh2ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvtsh2usi<AsmRegister32, AsmRegisterXmm> for CodeAssembler

fn vcvtsh2usi( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvtsh2usi<AsmRegister64, AsmRegisterXmm> for CodeAssembler

fn vcvtsh2usi( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvtsi2sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtsi2sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtsi2sd<AsmRegisterXmm, AsmRegisterXmm, AsmRegister32> for CodeAssembler

fn vcvtsi2sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegister32 ) -> Result<(), IcedError>

impl CodeAsmVcvtsi2sd<AsmRegisterXmm, AsmRegisterXmm, AsmRegister64> for CodeAssembler

fn vcvtsi2sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegister64 ) -> Result<(), IcedError>

impl CodeAsmVcvtsi2sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtsi2sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtsi2sh<AsmRegisterXmm, AsmRegisterXmm, AsmRegister32> for CodeAssembler

fn vcvtsi2sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegister32 ) -> Result<(), IcedError>

impl CodeAsmVcvtsi2sh<AsmRegisterXmm, AsmRegisterXmm, AsmRegister64> for CodeAssembler

fn vcvtsi2sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegister64 ) -> Result<(), IcedError>

impl CodeAsmVcvtsi2ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtsi2ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtsi2ss<AsmRegisterXmm, AsmRegisterXmm, AsmRegister32> for CodeAssembler

fn vcvtsi2ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegister32 ) -> Result<(), IcedError>

impl CodeAsmVcvtsi2ss<AsmRegisterXmm, AsmRegisterXmm, AsmRegister64> for CodeAssembler

fn vcvtsi2ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegister64 ) -> Result<(), IcedError>

impl CodeAsmVcvtss2sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtss2sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtss2sd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtss2sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvtss2sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtss2sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtss2sh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtss2sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvtss2si<AsmRegister32, AsmRegisterXmm> for CodeAssembler

fn vcvtss2si( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvtss2si<AsmRegister64, AsmRegisterXmm> for CodeAssembler

fn vcvtss2si( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvtss2usi<AsmRegister32, AsmRegisterXmm> for CodeAssembler

fn vcvtss2usi( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvtss2usi<AsmRegister64, AsmRegisterXmm> for CodeAssembler

fn vcvtss2usi( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvttpd2dq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvttpd2dq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvttpd2dq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvttpd2dq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvttpd2dq<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

fn vcvttpd2dq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVcvttpd2dqx<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvttpd2dqx( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvttpd2dqy<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvttpd2dqy( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvttpd2qq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvttpd2qq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvttpd2qq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvttpd2qq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvttpd2udq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvttpd2udq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvttpd2udq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvttpd2udq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvttpd2udq<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

fn vcvttpd2udq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVcvttpd2udqx<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvttpd2udqx( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvttpd2udqy<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvttpd2udqy( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvttpd2uqq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvttpd2uqq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvttpd2uqq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvttpd2uqq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvttph2dq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvttph2dq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvttph2dq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvttph2dq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvttph2dq<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vcvttph2dq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvttph2qq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvttph2qq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvttph2qq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvttph2qq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvttph2qq<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vcvttph2qq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvttph2qq<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

fn vcvttph2qq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvttph2udq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvttph2udq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvttph2udq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvttph2udq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvttph2udq<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vcvttph2udq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvttph2uqq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvttph2uqq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvttph2uqq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvttph2uqq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvttph2uqq<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vcvttph2uqq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvttph2uqq<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

fn vcvttph2uqq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvttph2uw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvttph2uw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvttph2uw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvttph2uw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvttph2w<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvttph2w( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvttph2w<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvttph2w( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvttps2dq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvttps2dq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvttps2dq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvttps2dq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvttps2qq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvttps2qq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvttps2qq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvttps2qq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvttps2qq<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vcvttps2qq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvttps2udq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvttps2udq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvttps2udq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvttps2udq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvttps2uqq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvttps2uqq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvttps2uqq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvttps2uqq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvttps2uqq<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vcvttps2uqq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvttsd2si<AsmRegister32, AsmRegisterXmm> for CodeAssembler

fn vcvttsd2si( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvttsd2si<AsmRegister64, AsmRegisterXmm> for CodeAssembler

fn vcvttsd2si( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvttsd2usi<AsmRegister32, AsmRegisterXmm> for CodeAssembler

fn vcvttsd2usi( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvttsd2usi<AsmRegister64, AsmRegisterXmm> for CodeAssembler

fn vcvttsd2usi( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvttsh2si<AsmRegister32, AsmRegisterXmm> for CodeAssembler

fn vcvttsh2si( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvttsh2si<AsmRegister64, AsmRegisterXmm> for CodeAssembler

fn vcvttsh2si( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvttsh2usi<AsmRegister32, AsmRegisterXmm> for CodeAssembler

fn vcvttsh2usi( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvttsh2usi<AsmRegister64, AsmRegisterXmm> for CodeAssembler

fn vcvttsh2usi( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvttss2si<AsmRegister32, AsmRegisterXmm> for CodeAssembler

fn vcvttss2si( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvttss2si<AsmRegister64, AsmRegisterXmm> for CodeAssembler

fn vcvttss2si( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvttss2usi<AsmRegister32, AsmRegisterXmm> for CodeAssembler

fn vcvttss2usi( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvttss2usi<AsmRegister64, AsmRegisterXmm> for CodeAssembler

fn vcvttss2usi( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvtudq2pd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtudq2pd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtudq2pd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtudq2pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvtudq2pd<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vcvtudq2pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvtudq2ph<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtudq2ph( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtudq2ph<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtudq2ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvtudq2ph<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

fn vcvtudq2ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVcvtudq2phx<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtudq2phx( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtudq2phy<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtudq2phy( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtudq2ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtudq2ps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtudq2ps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtudq2ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvtuqq2pd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtuqq2pd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtuqq2pd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtuqq2pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvtuqq2ph<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtuqq2ph( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtuqq2ph<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtuqq2ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvtuqq2ph<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

fn vcvtuqq2ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVcvtuqq2ph<AsmRegisterXmm, AsmRegisterZmm> for CodeAssembler

fn vcvtuqq2ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcvtuqq2phx<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtuqq2phx( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtuqq2phy<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtuqq2phy( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtuqq2phz<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtuqq2phz( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtuqq2ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtuqq2ps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtuqq2ps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtuqq2ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvtuqq2ps<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

fn vcvtuqq2ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVcvtuqq2psx<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtuqq2psx( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtuqq2psy<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtuqq2psy( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtusi2sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtusi2sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtusi2sd<AsmRegisterXmm, AsmRegisterXmm, AsmRegister32> for CodeAssembler

fn vcvtusi2sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegister32 ) -> Result<(), IcedError>

impl CodeAsmVcvtusi2sd<AsmRegisterXmm, AsmRegisterXmm, AsmRegister64> for CodeAssembler

fn vcvtusi2sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegister64 ) -> Result<(), IcedError>

impl CodeAsmVcvtusi2sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtusi2sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtusi2sh<AsmRegisterXmm, AsmRegisterXmm, AsmRegister32> for CodeAssembler

fn vcvtusi2sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegister32 ) -> Result<(), IcedError>

impl CodeAsmVcvtusi2sh<AsmRegisterXmm, AsmRegisterXmm, AsmRegister64> for CodeAssembler

fn vcvtusi2sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegister64 ) -> Result<(), IcedError>

impl CodeAsmVcvtusi2ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtusi2ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtusi2ss<AsmRegisterXmm, AsmRegisterXmm, AsmRegister32> for CodeAssembler

fn vcvtusi2ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegister32 ) -> Result<(), IcedError>

impl CodeAsmVcvtusi2ss<AsmRegisterXmm, AsmRegisterXmm, AsmRegister64> for CodeAssembler

fn vcvtusi2ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegister64 ) -> Result<(), IcedError>

impl CodeAsmVcvtuw2ph<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtuw2ph( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtuw2ph<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtuw2ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcvtw2ph<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtw2ph( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcvtw2ph<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtw2ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVdbpsadbw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vdbpsadbw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVdbpsadbw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vdbpsadbw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVdbpsadbw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vdbpsadbw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVdbpsadbw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vdbpsadbw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVdivpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vdivpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVdivpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vdivpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVdivph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vdivph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVdivph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vdivph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVdivps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vdivps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVdivps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vdivps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVdivsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vdivsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVdivsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vdivsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVdivsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vdivsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVdivsh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vdivsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVdivss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vdivss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVdivss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vdivss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVdpbf16ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vdpbf16ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVdpbf16ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vdpbf16ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVdppd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vdppd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVdppd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vdppd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVdppd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vdppd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVdppd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vdppd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVdpps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vdpps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVdpps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vdpps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVdpps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vdpps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVdpps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vdpps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVexpandpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vexpandpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVexpandpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vexpandpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVexpandps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vexpandps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVexpandps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vexpandps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVextractf128<AsmRegisterXmm, AsmRegisterYmm, i32> for CodeAssembler

fn vextractf128( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVextractf128<AsmRegisterXmm, AsmRegisterYmm, u32> for CodeAssembler

fn vextractf128( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVextractf32x4<AsmRegisterXmm, AsmRegisterYmm, i32> for CodeAssembler

fn vextractf32x4( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVextractf32x4<AsmRegisterXmm, AsmRegisterYmm, u32> for CodeAssembler

fn vextractf32x4( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVextractf32x4<AsmRegisterXmm, AsmRegisterZmm, i32> for CodeAssembler

fn vextractf32x4( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterZmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVextractf32x4<AsmRegisterXmm, AsmRegisterZmm, u32> for CodeAssembler

fn vextractf32x4( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterZmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVextractf64x2<AsmRegisterXmm, AsmRegisterYmm, i32> for CodeAssembler

fn vextractf64x2( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVextractf64x2<AsmRegisterXmm, AsmRegisterYmm, u32> for CodeAssembler

fn vextractf64x2( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVextractf64x2<AsmRegisterXmm, AsmRegisterZmm, i32> for CodeAssembler

fn vextractf64x2( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterZmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVextractf64x2<AsmRegisterXmm, AsmRegisterZmm, u32> for CodeAssembler

fn vextractf64x2( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterZmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVextracti128<AsmRegisterXmm, AsmRegisterYmm, i32> for CodeAssembler

fn vextracti128( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVextracti128<AsmRegisterXmm, AsmRegisterYmm, u32> for CodeAssembler

fn vextracti128( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVextracti32x4<AsmRegisterXmm, AsmRegisterYmm, i32> for CodeAssembler

fn vextracti32x4( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVextracti32x4<AsmRegisterXmm, AsmRegisterYmm, u32> for CodeAssembler

fn vextracti32x4( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVextracti32x4<AsmRegisterXmm, AsmRegisterZmm, i32> for CodeAssembler

fn vextracti32x4( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterZmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVextracti32x4<AsmRegisterXmm, AsmRegisterZmm, u32> for CodeAssembler

fn vextracti32x4( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterZmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVextracti64x2<AsmRegisterXmm, AsmRegisterYmm, i32> for CodeAssembler

fn vextracti64x2( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVextracti64x2<AsmRegisterXmm, AsmRegisterYmm, u32> for CodeAssembler

fn vextracti64x2( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVextracti64x2<AsmRegisterXmm, AsmRegisterZmm, i32> for CodeAssembler

fn vextracti64x2( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterZmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVextracti64x2<AsmRegisterXmm, AsmRegisterZmm, u32> for CodeAssembler

fn vextracti64x2( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterZmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVextractps<AsmMemoryOperand, AsmRegisterXmm, i32> for CodeAssembler

fn vextractps( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVextractps<AsmMemoryOperand, AsmRegisterXmm, u32> for CodeAssembler

fn vextractps( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVextractps<AsmRegister32, AsmRegisterXmm, i32> for CodeAssembler

fn vextractps( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVextractps<AsmRegister32, AsmRegisterXmm, u32> for CodeAssembler

fn vextractps( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVextractps<AsmRegister64, AsmRegisterXmm, i32> for CodeAssembler

fn vextractps( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVextractps<AsmRegister64, AsmRegisterXmm, u32> for CodeAssembler

fn vextractps( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVfcmaddcph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfcmaddcph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfcmaddcph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfcmaddcph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfcmaddcsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfcmaddcsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfcmaddcsh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfcmaddcsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfcmulcph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfcmulcph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfcmulcph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfcmulcph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfcmulcsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfcmulcsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfcmulcsh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfcmulcsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfixupimmpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vfixupimmpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVfixupimmpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vfixupimmpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVfixupimmpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vfixupimmpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVfixupimmpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vfixupimmpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVfixupimmps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vfixupimmps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVfixupimmps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vfixupimmps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVfixupimmps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vfixupimmps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVfixupimmps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vfixupimmps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVfixupimmsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vfixupimmsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVfixupimmsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vfixupimmsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVfixupimmsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vfixupimmsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVfixupimmsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vfixupimmsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVfixupimmss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vfixupimmss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVfixupimmss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vfixupimmss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVfixupimmss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vfixupimmss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVfixupimmss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vfixupimmss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVfmadd132pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd132pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfmadd132pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmadd132pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmadd132ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd132ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfmadd132ph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmadd132ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmadd132ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd132ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfmadd132ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmadd132ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmadd132sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd132sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfmadd132sd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmadd132sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmadd132sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd132sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfmadd132sh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmadd132sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmadd132ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd132ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfmadd132ss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmadd132ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmadd213pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd213pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfmadd213pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmadd213pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmadd213ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd213ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfmadd213ph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmadd213ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmadd213ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd213ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfmadd213ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmadd213ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmadd213sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd213sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfmadd213sd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmadd213sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmadd213sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd213sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfmadd213sh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmadd213sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmadd213ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd213ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfmadd213ss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmadd213ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmadd231pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd231pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfmadd231pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmadd231pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmadd231ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd231ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfmadd231ph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmadd231ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmadd231ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd231ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfmadd231ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmadd231ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmadd231sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd231sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfmadd231sd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmadd231sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmadd231sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd231sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfmadd231sh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmadd231sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmadd231ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd231ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfmadd231ss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmadd231ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmaddcph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddcph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfmaddcph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmaddcph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmaddcsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddcsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfmaddcsh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmaddcsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmaddpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vfmaddpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmaddpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfmaddpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmaddpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmaddps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vfmaddps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmaddps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfmaddps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmaddps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmaddsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vfmaddsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmaddsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfmaddsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmaddsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmaddss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vfmaddss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmaddss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfmaddss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmaddss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub132pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub132pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub132pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmaddsub132pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub132ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub132ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub132ph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmaddsub132ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub132ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub132ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub132ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmaddsub132ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub213pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub213pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub213pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmaddsub213pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub213ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub213ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub213ph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmaddsub213ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub213ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub213ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub213ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmaddsub213ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub231pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub231pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub231pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmaddsub231pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub231ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub231ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub231ph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmaddsub231ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub231ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub231ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub231ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmaddsub231ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmaddsubpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vfmaddsubpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmaddsubpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsubpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfmaddsubpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmaddsubpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmaddsubps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vfmaddsubps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmaddsubps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsubps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfmaddsubps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmaddsubps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmsub132pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub132pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfmsub132pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmsub132pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmsub132ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub132ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfmsub132ph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmsub132ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmsub132ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub132ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfmsub132ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmsub132ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmsub132sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub132sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfmsub132sd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmsub132sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmsub132sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub132sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfmsub132sh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmsub132sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmsub132ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub132ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfmsub132ss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmsub132ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmsub213pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub213pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfmsub213pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmsub213pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmsub213ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub213ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfmsub213ph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmsub213ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmsub213ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub213ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfmsub213ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmsub213ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmsub213sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub213sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfmsub213sd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmsub213sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmsub213sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub213sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfmsub213sh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmsub213sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmsub213ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub213ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfmsub213ss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmsub213ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmsub231pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub231pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfmsub231pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmsub231pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmsub231ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub231ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfmsub231ph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmsub231ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmsub231ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub231ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfmsub231ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmsub231ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmsub231sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub231sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfmsub231sd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmsub231sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmsub231sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub231sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfmsub231sh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmsub231sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmsub231ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub231ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfmsub231ss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmsub231ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd132pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd132pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd132pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmsubadd132pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd132ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd132ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd132ph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmsubadd132ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd132ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd132ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd132ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmsubadd132ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd213pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd213pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd213pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmsubadd213pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd213ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd213ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd213ph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmsubadd213ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd213ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd213ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd213ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmsubadd213ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd231pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd231pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd231pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmsubadd231pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd231ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd231ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd231ph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmsubadd231ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd231ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd231ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd231ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmsubadd231ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmsubaddpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vfmsubaddpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmsubaddpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubaddpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfmsubaddpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmsubaddpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmsubaddps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vfmsubaddps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmsubaddps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubaddps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfmsubaddps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmsubaddps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmsubpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vfmsubpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmsubpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfmsubpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmsubpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmsubps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vfmsubps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmsubps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfmsubps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmsubps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmsubsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vfmsubsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmsubsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfmsubsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmsubsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmsubss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vfmsubss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmsubss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfmsubss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmsubss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmulcph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmulcph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfmulcph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmulcph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfmulcsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmulcsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfmulcsh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmulcsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfnmadd132pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd132pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfnmadd132pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmadd132pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfnmadd132ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd132ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfnmadd132ph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmadd132ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfnmadd132ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd132ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfnmadd132ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmadd132ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfnmadd132sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd132sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfnmadd132sd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmadd132sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfnmadd132sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd132sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfnmadd132sh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmadd132sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfnmadd132ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd132ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfnmadd132ss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmadd132ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfnmadd213pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd213pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfnmadd213pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmadd213pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfnmadd213ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd213ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfnmadd213ph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmadd213ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfnmadd213ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd213ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfnmadd213ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmadd213ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfnmadd213sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd213sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfnmadd213sd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmadd213sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfnmadd213sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd213sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfnmadd213sh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmadd213sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfnmadd213ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd213ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfnmadd213ss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmadd213ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfnmadd231pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd231pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfnmadd231pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmadd231pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfnmadd231ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd231ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfnmadd231ph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmadd231ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfnmadd231ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd231ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfnmadd231ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmadd231ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfnmadd231sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd231sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfnmadd231sd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmadd231sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfnmadd231sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd231sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfnmadd231sh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmadd231sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfnmadd231ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd231ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfnmadd231ss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmadd231ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfnmaddpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vfnmaddpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfnmaddpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmaddpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfnmaddpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmaddpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfnmaddps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vfnmaddps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfnmaddps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmaddps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfnmaddps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmaddps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfnmaddsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vfnmaddsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfnmaddsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmaddsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfnmaddsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmaddsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfnmaddss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vfnmaddss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfnmaddss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmaddss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfnmaddss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmaddss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfnmsub132pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub132pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfnmsub132pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmsub132pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfnmsub132ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub132ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfnmsub132ph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmsub132ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfnmsub132ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub132ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfnmsub132ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmsub132ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfnmsub132sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub132sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfnmsub132sd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmsub132sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfnmsub132sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub132sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfnmsub132sh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmsub132sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfnmsub132ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub132ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfnmsub132ss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmsub132ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfnmsub213pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub213pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfnmsub213pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmsub213pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfnmsub213ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub213ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfnmsub213ph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmsub213ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfnmsub213ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub213ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfnmsub213ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmsub213ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfnmsub213sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub213sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfnmsub213sd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmsub213sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfnmsub213sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub213sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfnmsub213sh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmsub213sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfnmsub213ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub213ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfnmsub213ss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmsub213ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfnmsub231pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub231pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfnmsub231pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmsub231pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfnmsub231ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub231ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfnmsub231ph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmsub231ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfnmsub231ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub231ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfnmsub231ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmsub231ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfnmsub231sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub231sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfnmsub231sd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmsub231sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfnmsub231sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub231sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfnmsub231sh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmsub231sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfnmsub231ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub231ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfnmsub231ss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmsub231ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfnmsubpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vfnmsubpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfnmsubpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsubpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfnmsubpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmsubpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfnmsubps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vfnmsubps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfnmsubps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsubps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfnmsubps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmsubps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfnmsubsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vfnmsubsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfnmsubsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsubsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfnmsubsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmsubsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfnmsubss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vfnmsubss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfnmsubss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsubss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfnmsubss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmsubss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfpclasspd<AsmRegisterK, 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 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 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 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, 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, AsmRegisterXmm, i32> for CodeAssembler

fn vfpclassss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVfpclassss<AsmRegisterK, AsmRegisterXmm, u32> for CodeAssembler

fn vfpclassss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVfrczpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfrczpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfrczpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfrczpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfrczps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfrczps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfrczps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfrczps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfrczsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfrczsd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfrczsd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfrczsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfrczss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfrczss( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVfrczss<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfrczss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVgatherdpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vgatherdpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVgatherdpd3<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vgatherdpd_3( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVgatherdps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vgatherdps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVgatherdps3<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vgatherdps_3( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVgatherqpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vgatherqpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVgatherqpd3<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vgatherqpd_3( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVgatherqps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vgatherqps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVgatherqps3<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vgatherqps_3( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVgetexppd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vgetexppd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVgetexppd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vgetexppd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVgetexpph<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vgetexpph( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVgetexpph<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vgetexpph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVgetexpps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vgetexpps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVgetexpps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vgetexpps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVgetexpsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vgetexpsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVgetexpsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vgetexpsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVgetexpsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vgetexpsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVgetexpsh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vgetexpsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVgetexpss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vgetexpss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVgetexpss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vgetexpss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVgetmantpd<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vgetmantpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVgetmantpd<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vgetmantpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVgetmantpd<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vgetmantpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVgetmantpd<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vgetmantpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVgetmantph<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vgetmantph( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVgetmantph<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vgetmantph( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVgetmantph<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vgetmantph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVgetmantph<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vgetmantph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVgetmantps<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vgetmantps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVgetmantps<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vgetmantps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVgetmantps<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vgetmantps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVgetmantps<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vgetmantps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVgetmantsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vgetmantsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVgetmantsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vgetmantsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVgetmantsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vgetmantsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVgetmantsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vgetmantsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVgetmantsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vgetmantsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVgetmantsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vgetmantsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVgetmantsh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vgetmantsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVgetmantsh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vgetmantsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVgetmantss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vgetmantss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVgetmantss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vgetmantss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVgetmantss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vgetmantss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVgetmantss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vgetmantss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVgf2p8affineinvqb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vgf2p8affineinvqb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVgf2p8affineinvqb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vgf2p8affineinvqb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVgf2p8affineinvqb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vgf2p8affineinvqb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVgf2p8affineinvqb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vgf2p8affineinvqb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVgf2p8affineqb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vgf2p8affineqb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVgf2p8affineqb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vgf2p8affineqb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVgf2p8affineqb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vgf2p8affineqb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVgf2p8affineqb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vgf2p8affineqb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVgf2p8mulb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vgf2p8mulb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVgf2p8mulb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vgf2p8mulb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVhaddpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vhaddpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVhaddpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vhaddpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVhaddps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vhaddps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVhaddps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vhaddps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVhsubpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vhsubpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVhsubpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vhsubpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVhsubps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vhsubps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVhsubps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vhsubps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVinsertf128<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterXmm, i32> for CodeAssembler

fn vinsertf128( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVinsertf128<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterXmm, u32> for CodeAssembler

fn vinsertf128( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVinsertf32x4<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterXmm, i32> for CodeAssembler

fn vinsertf32x4( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVinsertf32x4<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterXmm, u32> for CodeAssembler

fn vinsertf32x4( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVinsertf32x4<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterXmm, i32> for CodeAssembler

fn vinsertf32x4( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVinsertf32x4<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterXmm, u32> for CodeAssembler

fn vinsertf32x4( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVinsertf64x2<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterXmm, i32> for CodeAssembler

fn vinsertf64x2( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVinsertf64x2<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterXmm, u32> for CodeAssembler

fn vinsertf64x2( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVinsertf64x2<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterXmm, i32> for CodeAssembler

fn vinsertf64x2( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVinsertf64x2<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterXmm, u32> for CodeAssembler

fn vinsertf64x2( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVinserti128<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterXmm, i32> for CodeAssembler

fn vinserti128( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVinserti128<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterXmm, u32> for CodeAssembler

fn vinserti128( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVinserti32x4<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterXmm, i32> for CodeAssembler

fn vinserti32x4( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVinserti32x4<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterXmm, u32> for CodeAssembler

fn vinserti32x4( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVinserti32x4<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterXmm, i32> for CodeAssembler

fn vinserti32x4( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVinserti32x4<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterXmm, u32> for CodeAssembler

fn vinserti32x4( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVinserti64x2<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterXmm, i32> for CodeAssembler

fn vinserti64x2( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVinserti64x2<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterXmm, u32> for CodeAssembler

fn vinserti64x2( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVinserti64x2<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterXmm, i32> for CodeAssembler

fn vinserti64x2( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVinserti64x2<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterXmm, u32> for CodeAssembler

fn vinserti64x2( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVinsertps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vinsertps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVinsertps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vinsertps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVinsertps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vinsertps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVinsertps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vinsertps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVlddqu<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vlddqu( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVmaskmovdqu<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmaskmovdqu( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVmaskmovpd<AsmMemoryOperand, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmaskmovpd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVmaskmovpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmaskmovpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVmaskmovps<AsmMemoryOperand, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmaskmovps( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVmaskmovps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmaskmovps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVmaxpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmaxpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVmaxpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmaxpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVmaxph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmaxph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVmaxph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmaxph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVmaxps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmaxps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVmaxps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmaxps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVmaxsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmaxsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVmaxsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmaxsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVmaxsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmaxsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVmaxsh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmaxsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVmaxss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmaxss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVmaxss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmaxss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVminpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vminpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVminpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vminpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVminph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vminph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVminph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vminph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVminps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vminps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVminps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vminps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVminsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vminsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVminsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vminsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVminsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vminsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVminsh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vminsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVminss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vminss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVminss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vminss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVmovapd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovapd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVmovapd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovapd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVmovapd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmovapd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVmovaps<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovaps( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVmovaps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovaps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVmovaps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmovaps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVmovd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVmovd<AsmRegister32, AsmRegisterXmm> for CodeAssembler

fn vmovd( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVmovd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVmovd<AsmRegisterXmm, AsmRegister32> for CodeAssembler

fn vmovd( &mut self, op0: AsmRegisterXmm, op1: AsmRegister32 ) -> Result<(), IcedError>

impl CodeAsmVmovddup<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovddup( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVmovddup<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmovddup( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVmovdqa<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovdqa( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVmovdqa<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqa( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVmovdqa<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmovdqa( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVmovdqa32<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovdqa32( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVmovdqa32<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqa32( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVmovdqa32<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmovdqa32( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVmovdqa64<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovdqa64( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVmovdqa64<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqa64( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVmovdqa64<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmovdqa64( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVmovdqu<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovdqu( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVmovdqu<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqu( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVmovdqu<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmovdqu( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVmovdqu16<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovdqu16( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVmovdqu16<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqu16( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVmovdqu16<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmovdqu16( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVmovdqu32<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovdqu32( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVmovdqu32<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqu32( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVmovdqu32<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmovdqu32( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVmovdqu64<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovdqu64( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVmovdqu64<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqu64( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVmovdqu64<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmovdqu64( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVmovdqu8<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovdqu8( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVmovdqu8<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqu8( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVmovdqu8<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmovdqu8( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVmovhlps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmovhlps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVmovhpd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovhpd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVmovhpd3<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovhpd_3( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVmovhps<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovhps( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVmovhps3<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovhps_3( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVmovlhps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmovlhps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVmovlpd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovlpd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVmovlpd3<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovlpd_3( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVmovlps<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovlps( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVmovlps3<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovlps_3( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVmovmskpd<AsmRegister32, AsmRegisterXmm> for CodeAssembler

fn vmovmskpd( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVmovmskpd<AsmRegister64, AsmRegisterXmm> for CodeAssembler

fn vmovmskpd( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVmovmskps<AsmRegister32, AsmRegisterXmm> for CodeAssembler

fn vmovmskps( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVmovmskps<AsmRegister64, AsmRegisterXmm> for CodeAssembler

fn vmovmskps( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVmovntdq<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovntdq( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVmovntdqa<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovntdqa( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVmovntpd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovntpd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVmovntps<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovntps( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVmovq<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovq( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVmovq<AsmRegister64, AsmRegisterXmm> for CodeAssembler

fn vmovq( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVmovq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVmovq<AsmRegisterXmm, AsmRegister64> for CodeAssembler

fn vmovq( &mut self, op0: AsmRegisterXmm, op1: AsmRegister64 ) -> Result<(), IcedError>

impl CodeAsmVmovq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmovq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVmovsd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovsd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVmovsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovsd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVmovsd3<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmovsd_3( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVmovsh<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovsh( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVmovsh<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovsh( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVmovsh3<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmovsh_3( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVmovshdup<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovshdup( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVmovshdup<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmovshdup( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVmovsldup<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovsldup( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVmovsldup<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmovsldup( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVmovss<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovss( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVmovss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovss( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVmovss3<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmovss_3( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVmovupd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovupd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVmovupd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovupd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVmovupd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmovupd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVmovups<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovups( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVmovups<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovups( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVmovups<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmovups( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVmovw<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovw( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVmovw<AsmRegister32, AsmRegisterXmm> for CodeAssembler

fn vmovw( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVmovw<AsmRegister64, AsmRegisterXmm> for CodeAssembler

fn vmovw( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVmovw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVmovw<AsmRegisterXmm, AsmRegister32> for CodeAssembler

fn vmovw( &mut self, op0: AsmRegisterXmm, op1: AsmRegister32 ) -> Result<(), IcedError>

impl CodeAsmVmovw<AsmRegisterXmm, AsmRegister64> for CodeAssembler

fn vmovw( &mut self, op0: AsmRegisterXmm, op1: AsmRegister64 ) -> Result<(), IcedError>

impl CodeAsmVmpsadbw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vmpsadbw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVmpsadbw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vmpsadbw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVmpsadbw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vmpsadbw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVmpsadbw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vmpsadbw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVmulpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmulpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVmulpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmulpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVmulph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmulph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVmulph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmulph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVmulps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmulps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVmulps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmulps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVmulsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmulsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVmulsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmulsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVmulsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmulsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVmulsh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmulsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVmulss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmulss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVmulss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmulss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVorpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vorpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVorpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vorpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVorps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vorps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVorps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vorps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl 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 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 CodeAsmVpabsb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpabsb( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpabsb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpabsb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpabsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpabsd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpabsd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpabsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpabsq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpabsq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpabsq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpabsq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpabsw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpabsw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpabsw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpabsw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpackssdw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpackssdw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpackssdw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpackssdw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpacksswb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpacksswb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpacksswb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpacksswb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpackusdw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpackusdw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpackusdw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpackusdw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpackuswb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpackuswb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpackuswb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpackuswb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpaddb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpaddb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpaddb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpaddb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpaddd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpaddd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpaddd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpaddd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpaddq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpaddq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpaddq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpaddq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpaddsb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpaddsb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpaddsb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpaddsb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpaddsw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpaddsw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpaddsw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpaddsw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpaddusb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpaddusb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpaddusb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpaddusb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpaddusw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpaddusw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpaddusw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpaddusw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpaddw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpaddw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpaddw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpaddw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpalignr<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpalignr( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpalignr<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpalignr( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpalignr<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpalignr( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpalignr<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpalignr( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpand<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpand( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpand<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpand( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpandd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpandd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpandd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpandd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpandn<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpandn( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpandn<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpandn( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpandnd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpandnd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpandnd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpandnd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpandnq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpandnq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpandnq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpandnq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpandq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpandq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpandq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpandq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpavgb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpavgb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpavgb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpavgb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpavgw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpavgw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpavgw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpavgw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpblendd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpblendd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpblendd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpblendd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpblendd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpblendd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpblendd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpblendd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpblendmb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpblendmb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpblendmb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpblendmb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpblendmd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpblendmd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpblendmd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpblendmd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpblendmq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpblendmq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpblendmq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpblendmq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpblendmw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpblendmw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpblendmw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpblendmw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpblendvb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpblendvb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpblendvb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpblendvb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpblendw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpblendw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpblendw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpblendw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpblendw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpblendw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpblendw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpblendw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpbroadcastb( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastb<AsmRegisterXmm, AsmRegister32> for CodeAssembler

fn vpbroadcastb( &mut self, op0: AsmRegisterXmm, op1: AsmRegister32 ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpbroadcastb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastb<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vpbroadcastb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastb<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

fn vpbroadcastb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpbroadcastd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastd<AsmRegisterXmm, AsmRegister32> for CodeAssembler

fn vpbroadcastd( &mut self, op0: AsmRegisterXmm, op1: AsmRegister32 ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpbroadcastd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastd<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vpbroadcastd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastd<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

fn vpbroadcastd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastmb2q<AsmRegisterXmm, AsmRegisterK> for CodeAssembler

fn vpbroadcastmb2q( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterK ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastmw2d<AsmRegisterXmm, AsmRegisterK> for CodeAssembler

fn vpbroadcastmw2d( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterK ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpbroadcastq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastq<AsmRegisterXmm, AsmRegister64> for CodeAssembler

fn vpbroadcastq( &mut self, op0: AsmRegisterXmm, op1: AsmRegister64 ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpbroadcastq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastq<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vpbroadcastq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastq<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

fn vpbroadcastq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpbroadcastw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastw<AsmRegisterXmm, AsmRegister32> for CodeAssembler

fn vpbroadcastw( &mut self, op0: AsmRegisterXmm, op1: AsmRegister32 ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpbroadcastw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastw<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vpbroadcastw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastw<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

fn vpbroadcastw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpclmulhqhqdq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpclmulhqhqdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpclmulhqhqdq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpclmulhqhqdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpclmulhqlqdq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpclmulhqlqdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpclmulhqlqdq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpclmulhqlqdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpclmullqhqdq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpclmullqhqdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpclmullqhqdq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpclmullqhqdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpclmullqlqdq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpclmullqlqdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpclmullqlqdq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpclmullqlqdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpclmulqdq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpclmulqdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpclmulqdq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpclmulqdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpclmulqdq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpclmulqdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpclmulqdq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpclmulqdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmov<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpcmov( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcmov<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmov( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmov<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmov( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm ) -> Result<(), IcedError>

impl 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 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 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<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpeqb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl 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<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpeqd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl 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<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpeqq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl 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 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 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 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 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<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpeqw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpestri<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpestri( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpestri<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpestri( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpestri<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpcmpestri( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpestri<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpcmpestri( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpestri64<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpestri64( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpestri64<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpestri64( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpestri64<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpcmpestri64( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpestri64<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpcmpestri64( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpestrm<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpestrm( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpestrm<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpestrm( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpestrm<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpcmpestrm( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpestrm<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpcmpestrm( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpestrm64<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpestrm64( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpestrm64<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpestrm64( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpestrm64<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpcmpestrm64( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpestrm64<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpcmpestrm64( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseb<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpfalseb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl 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 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 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 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 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 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 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 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<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpgtb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl 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<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpgtd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl 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<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpgtq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl 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<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpgtw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpistri<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpistri( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpistri<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpistri( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpistri<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpcmpistri( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpistri<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpcmpistri( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpistrm<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpistrm( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpistrm<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpistrm( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpistrm<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpcmpistrm( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpistrm<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpcmpistrm( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpleb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpleb<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpleb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 CodeAsmVpcomb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcomb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcomb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcomb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcomb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpcomb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcomb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpcomb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcomd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcomd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcomd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcomd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcomd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpcomd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcomd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpcomd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcomeqb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomeqb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcomeqb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomeqb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcomeqd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomeqd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcomeqd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomeqd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcomeqq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomeqq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcomeqq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomeqq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcomequb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomequb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcomequb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomequb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcomequd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomequd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcomequd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomequd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcomequq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomequq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcomequq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomequq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcomequw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomequw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcomequw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomequw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcomeqw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomeqw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcomeqw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomeqw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcomfalseb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomfalseb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcomfalseb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomfalseb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcomfalsed<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomfalsed( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcomfalsed<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomfalsed( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcomfalseq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomfalseq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcomfalseq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomfalseq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcomfalseub<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomfalseub( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcomfalseub<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomfalseub( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcomfalseud<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomfalseud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcomfalseud<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomfalseud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcomfalseuq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomfalseuq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcomfalseuq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomfalseuq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcomfalseuw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomfalseuw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcomfalseuw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomfalseuw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcomfalsew<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomfalsew( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcomfalsew<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomfalsew( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcomgeb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomgeb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcomgeb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomgeb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcomged<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomged( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcomged<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomged( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcomgeq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomgeq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcomgeq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomgeq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcomgeub<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomgeub( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcomgeub<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomgeub( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcomgeud<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomgeud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcomgeud<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomgeud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcomgeuq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomgeuq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcomgeuq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomgeuq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcomgeuw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomgeuw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcomgeuw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomgeuw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcomgew<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomgew( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcomgew<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomgew( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcomgtb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomgtb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcomgtb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomgtb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcomgtd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomgtd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcomgtd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomgtd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcomgtq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomgtq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcomgtq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomgtq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcomgtub<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomgtub( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcomgtub<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomgtub( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcomgtud<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomgtud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcomgtud<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomgtud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcomgtuq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomgtuq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcomgtuq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomgtuq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcomgtuw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomgtuw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcomgtuw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomgtuw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcomgtw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomgtw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcomgtw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomgtw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcomleb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomleb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcomleb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomleb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcomled<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomled( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcomled<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomled( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcomleq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomleq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcomleq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomleq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcomleub<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomleub( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcomleub<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomleub( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcomleud<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomleud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcomleud<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomleud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcomleuq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomleuq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcomleuq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomleuq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcomleuw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomleuw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcomleuw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomleuw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcomlew<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomlew( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcomlew<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomlew( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcomltb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomltb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcomltb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomltb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcomltd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomltd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcomltd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomltd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcomltq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomltq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcomltq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomltq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcomltub<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomltub( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcomltub<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomltub( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcomltud<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomltud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcomltud<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomltud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcomltuq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomltuq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcomltuq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomltuq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcomltuw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomltuw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcomltuw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomltuw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcomltw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomltw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcomltw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomltw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcomneqb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomneqb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcomneqb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomneqb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcomneqd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomneqd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcomneqd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomneqd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcomneqq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomneqq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcomneqq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomneqq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcomnequb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomnequb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcomnequb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomnequb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcomnequd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomnequd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcomnequd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomnequd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcomnequq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomnequq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcomnequq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomnequq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcomnequw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomnequw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcomnequw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomnequw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcomneqw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomneqw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcomneqw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomneqw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcompressb<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpcompressb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcompressb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcompressb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcompressd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpcompressd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcompressd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcompressd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcompressq<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpcompressq( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcompressq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcompressq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcompressw<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpcompressw( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcompressw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcompressw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcomq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcomq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcomq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcomq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcomq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpcomq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcomq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpcomq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcomtrueb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomtrueb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcomtrueb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomtrueb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcomtrued<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomtrued( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcomtrued<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomtrued( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcomtrueq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomtrueq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcomtrueq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomtrueq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcomtrueub<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomtrueub( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcomtrueub<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomtrueub( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcomtrueud<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomtrueud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcomtrueud<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomtrueud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcomtrueuq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomtrueuq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcomtrueuq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomtrueuq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcomtrueuw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomtrueuw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcomtrueuw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomtrueuw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcomtruew<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomtruew( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcomtruew<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomtruew( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcomub<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcomub( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcomub<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcomub( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcomub<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpcomub( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcomub<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpcomub( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcomud<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcomud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcomud<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcomud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcomud<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpcomud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcomud<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpcomud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcomuq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcomuq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcomuq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcomuq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcomuq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpcomuq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcomuq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpcomuq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcomuw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcomuw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcomuw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcomuw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcomuw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpcomuw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcomuw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpcomuw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcomw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcomw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcomw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcomw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcomw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpcomw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcomw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpcomw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpconflictd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpconflictd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpconflictd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpconflictd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpconflictq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpconflictq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpconflictq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpconflictq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpdpbssd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpdpbssd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpdpbssd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpdpbssd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpdpbssds<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpdpbssds( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpdpbssds<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpdpbssds( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpdpbsud<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpdpbsud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpdpbsud<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpdpbsud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpdpbsuds<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpdpbsuds( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpdpbsuds<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpdpbsuds( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpdpbusd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpdpbusd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpdpbusd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpdpbusd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpdpbusds<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpdpbusds( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpdpbusds<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpdpbusds( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpdpbuud<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpdpbuud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpdpbuud<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpdpbuud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpdpbuuds<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpdpbuuds( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpdpbuuds<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpdpbuuds( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpdpwssd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpdpwssd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpdpwssd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpdpwssd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpdpwssds<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpdpwssds( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpdpwssds<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpdpwssds( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpdpwsud<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpdpwsud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpdpwsud<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpdpwsud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpdpwsuds<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpdpwsuds( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpdpwsuds<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpdpwsuds( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpdpwusd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpdpwusd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpdpwusd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpdpwusd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpdpwusds<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpdpwusds( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpdpwusds<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpdpwusds( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpdpwuud<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpdpwuud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpdpwuud<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpdpwuud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpdpwuuds<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpdpwuuds( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpdpwuuds<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpdpwuuds( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpermb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpermb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpermb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpermb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpermi2b<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpermi2b( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpermi2b<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpermi2b( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpermi2d<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpermi2d( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpermi2d<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpermi2d( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpermi2pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpermi2pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpermi2pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpermi2pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpermi2ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpermi2ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpermi2ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpermi2ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpermi2q<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpermi2q( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpermi2q<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpermi2q( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpermi2w<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpermi2w( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpermi2w<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpermi2w( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpermil2pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm, i32> for CodeAssembler

fn vpermil2pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm, op4: i32 ) -> Result<(), IcedError>

impl CodeAsmVpermil2pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm, u32> for CodeAssembler

fn vpermil2pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm, op4: u32 ) -> Result<(), IcedError>

impl CodeAsmVpermil2pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpermil2pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmMemoryOperand, op4: i32 ) -> Result<(), IcedError>

impl CodeAsmVpermil2pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpermil2pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmMemoryOperand, op4: u32 ) -> Result<(), IcedError>

impl CodeAsmVpermil2pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpermil2pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm, op4: i32 ) -> Result<(), IcedError>

impl CodeAsmVpermil2pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpermil2pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm, op4: u32 ) -> Result<(), IcedError>

impl CodeAsmVpermil2ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm, i32> for CodeAssembler

fn vpermil2ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm, op4: i32 ) -> Result<(), IcedError>

impl CodeAsmVpermil2ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm, u32> for CodeAssembler

fn vpermil2ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm, op4: u32 ) -> Result<(), IcedError>

impl CodeAsmVpermil2ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpermil2ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmMemoryOperand, op4: i32 ) -> Result<(), IcedError>

impl CodeAsmVpermil2ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpermil2ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmMemoryOperand, op4: u32 ) -> Result<(), IcedError>

impl CodeAsmVpermil2ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpermil2ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm, op4: i32 ) -> Result<(), IcedError>

impl CodeAsmVpermil2ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpermil2ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm, op4: u32 ) -> Result<(), IcedError>

impl CodeAsmVpermilpd<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpermilpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVpermilpd<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpermilpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVpermilpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpermilpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpermilpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpermilpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpermilpd<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpermilpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVpermilpd<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpermilpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVpermilps<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpermilps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVpermilps<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpermilps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVpermilps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpermilps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpermilps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpermilps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpermilps<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpermilps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVpermilps<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpermilps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVpermt2b<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpermt2b( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpermt2b<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpermt2b( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpermt2d<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpermt2d( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpermt2d<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpermt2d( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpermt2pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpermt2pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpermt2pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpermt2pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpermt2ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpermt2ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpermt2ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpermt2ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpermt2q<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpermt2q( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpermt2q<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpermt2q( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpermt2w<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpermt2w( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpermt2w<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpermt2w( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpermw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpermw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpermw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpermw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpexpandb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpexpandb( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpexpandb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpexpandb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpexpandd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpexpandd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpexpandd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpexpandd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpexpandq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpexpandq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpexpandq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpexpandq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpexpandw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpexpandw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpexpandw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpexpandw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpextrb<AsmMemoryOperand, AsmRegisterXmm, i32> for CodeAssembler

fn vpextrb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVpextrb<AsmMemoryOperand, AsmRegisterXmm, u32> for CodeAssembler

fn vpextrb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVpextrb<AsmRegister32, AsmRegisterXmm, i32> for CodeAssembler

fn vpextrb( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVpextrb<AsmRegister32, AsmRegisterXmm, u32> for CodeAssembler

fn vpextrb( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVpextrb<AsmRegister64, AsmRegisterXmm, i32> for CodeAssembler

fn vpextrb( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVpextrb<AsmRegister64, AsmRegisterXmm, u32> for CodeAssembler

fn vpextrb( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVpextrd<AsmMemoryOperand, AsmRegisterXmm, i32> for CodeAssembler

fn vpextrd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVpextrd<AsmMemoryOperand, AsmRegisterXmm, u32> for CodeAssembler

fn vpextrd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVpextrd<AsmRegister32, AsmRegisterXmm, i32> for CodeAssembler

fn vpextrd( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVpextrd<AsmRegister32, AsmRegisterXmm, u32> for CodeAssembler

fn vpextrd( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVpextrq<AsmMemoryOperand, AsmRegisterXmm, i32> for CodeAssembler

fn vpextrq( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVpextrq<AsmMemoryOperand, AsmRegisterXmm, u32> for CodeAssembler

fn vpextrq( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVpextrq<AsmRegister64, AsmRegisterXmm, i32> for CodeAssembler

fn vpextrq( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVpextrq<AsmRegister64, AsmRegisterXmm, u32> for CodeAssembler

fn vpextrq( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVpextrw<AsmMemoryOperand, AsmRegisterXmm, i32> for CodeAssembler

fn vpextrw( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVpextrw<AsmMemoryOperand, AsmRegisterXmm, u32> for CodeAssembler

fn vpextrw( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVpextrw<AsmRegister32, AsmRegisterXmm, i32> for CodeAssembler

fn vpextrw( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVpextrw<AsmRegister32, AsmRegisterXmm, u32> for CodeAssembler

fn vpextrw( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVpextrw<AsmRegister64, AsmRegisterXmm, i32> for CodeAssembler

fn vpextrw( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVpextrw<AsmRegister64, AsmRegisterXmm, u32> for CodeAssembler

fn vpextrw( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVpgatherdd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpgatherdd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpgatherdd3<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpgatherdd_3( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpgatherdq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpgatherdq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpgatherdq3<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpgatherdq_3( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpgatherqd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpgatherqd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpgatherqd3<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpgatherqd_3( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpgatherqq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpgatherqq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpgatherqq3<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpgatherqq_3( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVphaddbd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphaddbd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVphaddbd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vphaddbd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVphaddbq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphaddbq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVphaddbq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vphaddbq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVphaddbw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphaddbw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVphaddbw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vphaddbw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVphaddd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphaddd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVphaddd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vphaddd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVphadddq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphadddq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVphadddq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vphadddq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVphaddsw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphaddsw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVphaddsw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vphaddsw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVphaddubd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphaddubd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVphaddubd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vphaddubd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVphaddubq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphaddubq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVphaddubq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vphaddubq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVphaddubw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphaddubw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVphaddubw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vphaddubw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVphaddudq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphaddudq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVphaddudq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vphaddudq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVphadduwd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphadduwd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVphadduwd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vphadduwd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVphadduwq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphadduwq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVphadduwq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vphadduwq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVphaddw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphaddw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVphaddw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vphaddw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVphaddwd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphaddwd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVphaddwd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vphaddwd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVphaddwq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphaddwq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVphaddwq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vphaddwq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVphminposuw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphminposuw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVphminposuw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vphminposuw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVphsubbw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphsubbw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVphsubbw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vphsubbw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVphsubd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphsubd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVphsubd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vphsubd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVphsubdq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphsubdq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVphsubdq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vphsubdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVphsubsw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphsubsw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVphsubsw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vphsubsw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVphsubw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphsubw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVphsubw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vphsubw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVphsubwd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphsubwd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVphsubwd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vphsubwd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpinsrb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpinsrb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpinsrb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpinsrb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpinsrb<AsmRegisterXmm, AsmRegisterXmm, AsmRegister32, i32> for CodeAssembler

fn vpinsrb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegister32, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpinsrb<AsmRegisterXmm, AsmRegisterXmm, AsmRegister32, u32> for CodeAssembler

fn vpinsrb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegister32, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpinsrb<AsmRegisterXmm, AsmRegisterXmm, AsmRegister64, i32> for CodeAssembler

fn vpinsrb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegister64, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpinsrb<AsmRegisterXmm, AsmRegisterXmm, AsmRegister64, u32> for CodeAssembler

fn vpinsrb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegister64, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpinsrd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpinsrd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpinsrd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpinsrd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpinsrd<AsmRegisterXmm, AsmRegisterXmm, AsmRegister32, i32> for CodeAssembler

fn vpinsrd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegister32, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpinsrd<AsmRegisterXmm, AsmRegisterXmm, AsmRegister32, u32> for CodeAssembler

fn vpinsrd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegister32, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpinsrq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpinsrq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpinsrq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpinsrq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpinsrq<AsmRegisterXmm, AsmRegisterXmm, AsmRegister64, i32> for CodeAssembler

fn vpinsrq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegister64, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpinsrq<AsmRegisterXmm, AsmRegisterXmm, AsmRegister64, u32> for CodeAssembler

fn vpinsrq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegister64, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpinsrw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpinsrw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpinsrw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpinsrw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpinsrw<AsmRegisterXmm, AsmRegisterXmm, AsmRegister32, i32> for CodeAssembler

fn vpinsrw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegister32, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpinsrw<AsmRegisterXmm, AsmRegisterXmm, AsmRegister32, u32> for CodeAssembler

fn vpinsrw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegister32, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpinsrw<AsmRegisterXmm, AsmRegisterXmm, AsmRegister64, i32> for CodeAssembler

fn vpinsrw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegister64, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpinsrw<AsmRegisterXmm, AsmRegisterXmm, AsmRegister64, u32> for CodeAssembler

fn vpinsrw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegister64, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVplzcntd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vplzcntd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVplzcntd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vplzcntd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVplzcntq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vplzcntq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVplzcntq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vplzcntq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmacsdd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmacsdd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmacsdd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmacsdd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmacsdqh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmacsdqh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmacsdqh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmacsdqh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmacsdql<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmacsdql( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmacsdql<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmacsdql( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmacssdd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmacssdd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmacssdd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmacssdd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmacssdqh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmacssdqh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmacssdqh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmacssdqh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmacssdql<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmacssdql( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmacssdql<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmacssdql( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmacsswd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmacsswd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmacsswd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmacsswd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmacssww<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmacssww( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmacssww<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmacssww( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmacswd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmacswd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmacswd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmacswd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmacsww<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmacsww( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmacsww<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmacsww( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmadcsswd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmadcsswd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmadcsswd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmadcsswd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmadcswd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmadcswd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmadcswd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmadcswd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmadd52huq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmadd52huq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpmadd52huq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmadd52huq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmadd52luq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmadd52luq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpmadd52luq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmadd52luq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmaddubsw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmaddubsw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpmaddubsw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmaddubsw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmaddwd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmaddwd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpmaddwd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmaddwd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmaskmovd<AsmMemoryOperand, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmaskmovd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmaskmovd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmaskmovd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpmaskmovq<AsmMemoryOperand, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmaskmovq( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmaskmovq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmaskmovq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpmaxsb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxsb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpmaxsb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmaxsb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmaxsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpmaxsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmaxsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmaxsq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxsq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpmaxsq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmaxsq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmaxsw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxsw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpmaxsw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmaxsw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmaxub<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxub( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpmaxub<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmaxub( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmaxud<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpmaxud<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmaxud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmaxuq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxuq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpmaxuq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmaxuq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmaxuw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxuw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpmaxuw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmaxuw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpminsb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpminsb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpminsb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpminsb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpminsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpminsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpminsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpminsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpminsq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpminsq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpminsq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpminsq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpminsw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpminsw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpminsw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpminsw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpminub<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpminub( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpminub<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpminub( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpminud<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpminud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpminud<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpminud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpminuq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpminuq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpminuq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpminuq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpminuw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpminuw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpminuw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpminuw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovb2m<AsmRegisterK, AsmRegisterXmm> for CodeAssembler

fn vpmovb2m( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovd2m<AsmRegisterK, AsmRegisterXmm> for CodeAssembler

fn vpmovd2m( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovdb<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmovdb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovdb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmovdb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovdb<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

fn vpmovdb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpmovdb<AsmRegisterXmm, AsmRegisterZmm> for CodeAssembler

fn vpmovdb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpmovdw<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmovdw( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovdw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmovdw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovdw<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

fn vpmovdw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpmovm2b<AsmRegisterXmm, AsmRegisterK> for CodeAssembler

fn vpmovm2b( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterK ) -> Result<(), IcedError>

impl CodeAsmVpmovm2d<AsmRegisterXmm, AsmRegisterK> for CodeAssembler

fn vpmovm2d( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterK ) -> Result<(), IcedError>

impl CodeAsmVpmovm2q<AsmRegisterXmm, AsmRegisterK> for CodeAssembler

fn vpmovm2q( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterK ) -> Result<(), IcedError>

impl CodeAsmVpmovm2w<AsmRegisterXmm, AsmRegisterK> for CodeAssembler

fn vpmovm2w( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterK ) -> Result<(), IcedError>

impl CodeAsmVpmovmskb<AsmRegister32, AsmRegisterXmm> for CodeAssembler

fn vpmovmskb( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovmskb<AsmRegister64, AsmRegisterXmm> for CodeAssembler

fn vpmovmskb( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovq2m<AsmRegisterK, AsmRegisterXmm> for CodeAssembler

fn vpmovq2m( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovqb<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmovqb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovqb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmovqb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovqb<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

fn vpmovqb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpmovqb<AsmRegisterXmm, AsmRegisterZmm> for CodeAssembler

fn vpmovqb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpmovqd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmovqd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovqd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmovqd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovqd<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

fn vpmovqd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpmovqw<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmovqw( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovqw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmovqw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovqw<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

fn vpmovqw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpmovqw<AsmRegisterXmm, AsmRegisterZmm> for CodeAssembler

fn vpmovqw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpmovsdb<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmovsdb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovsdb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmovsdb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovsdb<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

fn vpmovsdb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpmovsdb<AsmRegisterXmm, AsmRegisterZmm> for CodeAssembler

fn vpmovsdb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpmovsdw<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmovsdw( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovsdw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmovsdw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovsdw<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

fn vpmovsdw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpmovsqb<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmovsqb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovsqb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmovsqb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovsqb<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

fn vpmovsqb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpmovsqb<AsmRegisterXmm, AsmRegisterZmm> for CodeAssembler

fn vpmovsqb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpmovsqd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmovsqd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovsqd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmovsqd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovsqd<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

fn vpmovsqd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpmovsqw<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmovsqw( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovsqw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmovsqw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovsqw<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

fn vpmovsqw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpmovsqw<AsmRegisterXmm, AsmRegisterZmm> for CodeAssembler

fn vpmovsqw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpmovswb<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmovswb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovswb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmovswb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovswb<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

fn vpmovswb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpmovsxbd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmovsxbd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpmovsxbd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmovsxbd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovsxbd<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vpmovsxbd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovsxbd<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

fn vpmovsxbd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovsxbq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmovsxbq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpmovsxbq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmovsxbq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovsxbq<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vpmovsxbq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovsxbq<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

fn vpmovsxbq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovsxbw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmovsxbw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpmovsxbw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmovsxbw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovsxbw<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vpmovsxbw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovsxdq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmovsxdq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpmovsxdq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmovsxdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovsxdq<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vpmovsxdq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovsxwd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmovsxwd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpmovsxwd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmovsxwd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovsxwd<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vpmovsxwd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovsxwq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmovsxwq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpmovsxwq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmovsxwq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovsxwq<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vpmovsxwq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovsxwq<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

fn vpmovsxwq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovusdb<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmovusdb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovusdb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmovusdb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovusdb<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

fn vpmovusdb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpmovusdb<AsmRegisterXmm, AsmRegisterZmm> for CodeAssembler

fn vpmovusdb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpmovusdw<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmovusdw( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovusdw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmovusdw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovusdw<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

fn vpmovusdw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpmovusqb<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmovusqb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovusqb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmovusqb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovusqb<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

fn vpmovusqb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpmovusqb<AsmRegisterXmm, AsmRegisterZmm> for CodeAssembler

fn vpmovusqb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpmovusqd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmovusqd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovusqd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmovusqd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovusqd<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

fn vpmovusqd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpmovusqw<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmovusqw( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovusqw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmovusqw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovusqw<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

fn vpmovusqw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpmovusqw<AsmRegisterXmm, AsmRegisterZmm> for CodeAssembler

fn vpmovusqw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpmovuswb<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmovuswb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovuswb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmovuswb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovuswb<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

fn vpmovuswb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpmovw2m<AsmRegisterK, AsmRegisterXmm> for CodeAssembler

fn vpmovw2m( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovwb<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmovwb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovwb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmovwb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovwb<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

fn vpmovwb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpmovzxbd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmovzxbd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpmovzxbd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmovzxbd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovzxbd<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vpmovzxbd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovzxbd<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

fn vpmovzxbd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovzxbq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmovzxbq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpmovzxbq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmovzxbq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovzxbq<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vpmovzxbq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovzxbq<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

fn vpmovzxbq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovzxbw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmovzxbw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpmovzxbw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmovzxbw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovzxbw<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vpmovzxbw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovzxdq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmovzxdq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpmovzxdq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmovzxdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovzxdq<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vpmovzxdq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovzxwd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmovzxwd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpmovzxwd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmovzxwd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovzxwd<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vpmovzxwd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovzxwq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmovzxwq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpmovzxwq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmovzxwq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovzxwq<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vpmovzxwq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovzxwq<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

fn vpmovzxwq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmuldq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmuldq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpmuldq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmuldq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmulhrsw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmulhrsw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpmulhrsw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmulhrsw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmulhuw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmulhuw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpmulhuw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmulhuw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmulhw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmulhw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpmulhw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmulhw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmulld<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmulld( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpmulld<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmulld( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmullq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmullq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpmullq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmullq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmullw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmullw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpmullw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmullw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmultishiftqb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmultishiftqb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpmultishiftqb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmultishiftqb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmuludq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmuludq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpmuludq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmuludq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpopcntb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpopcntb( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpopcntb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpopcntb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpopcntd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpopcntd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpopcntd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpopcntd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpopcntq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpopcntq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpopcntq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpopcntq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpopcntw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpopcntw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpopcntw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpopcntw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpor<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpor( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpor<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpor( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpord<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpord( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpord<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpord( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVporq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vporq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVporq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vporq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpperm<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpperm( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpperm<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpperm( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpperm<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpperm( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVprold<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vprold( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVprold<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vprold( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVprold<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vprold( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVprold<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vprold( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVprolq<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vprolq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVprolq<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vprolq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVprolq<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vprolq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVprolq<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vprolq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVprolvd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vprolvd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVprolvd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vprolvd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVprolvq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vprolvq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVprolvq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vprolvq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVprord<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vprord( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVprord<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vprord( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVprord<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vprord( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVprord<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vprord( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVprorq<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vprorq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVprorq<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vprorq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVprorq<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vprorq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVprorq<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vprorq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVprorvd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vprorvd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVprorvd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vprorvd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVprorvq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vprorvq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVprorvq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vprorvq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVprotb<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vprotb( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVprotb<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vprotb( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVprotb<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vprotb( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVprotb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vprotb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVprotb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vprotb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVprotb<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vprotb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVprotb<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vprotb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVprotd<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vprotd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVprotd<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vprotd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVprotd<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vprotd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVprotd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vprotd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVprotd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vprotd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVprotd<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vprotd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVprotd<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vprotd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVprotq<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vprotq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVprotq<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vprotq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVprotq<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vprotq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVprotq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vprotq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVprotq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vprotq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVprotq<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vprotq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVprotq<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vprotq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVprotw<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vprotw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVprotw<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vprotw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVprotw<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vprotw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVprotw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vprotw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVprotw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vprotw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVprotw<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vprotw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVprotw<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vprotw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVpsadbw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsadbw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpsadbw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpsadbw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpscatterdd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpscatterdd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpscatterdq<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpscatterdq( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpscatterqd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpscatterqd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpscatterqq<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpscatterqq( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpshab<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpshab( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpshab<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpshab( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpshab<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpshab( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpshad<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpshad( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpshad<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpshad( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpshad<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpshad( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpshaq<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpshaq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpshaq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpshaq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpshaq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpshaq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpshaw<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpshaw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpshaw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpshaw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpshaw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpshaw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpshlb<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpshlb( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpshlb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpshlb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpshlb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpshlb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpshld<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpshld( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpshld<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpshld( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpshld<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpshld( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpshldd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshldd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpshldd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshldd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpshldd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpshldd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpshldd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpshldd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpshldq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshldq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpshldq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshldq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpshldq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpshldq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpshldq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpshldq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpshldvd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpshldvd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpshldvd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpshldvd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpshldvq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpshldvq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpshldvq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpshldvq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpshldvw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpshldvw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpshldvw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpshldvw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpshldw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshldw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpshldw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshldw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpshldw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpshldw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpshldw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpshldw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpshlq<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpshlq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpshlq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpshlq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpshlq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpshlq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpshlw<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpshlw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpshlw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpshlw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpshlw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpshlw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpshrdd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshrdd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpshrdd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshrdd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpshrdd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpshrdd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpshrdd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpshrdd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpshrdq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshrdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpshrdq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshrdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpshrdq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpshrdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpshrdq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpshrdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpshrdvd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpshrdvd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpshrdvd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpshrdvd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpshrdvq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpshrdvq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpshrdvq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpshrdvq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpshrdvw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpshrdvw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpshrdvw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpshrdvw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpshrdw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshrdw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpshrdw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshrdw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpshrdw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpshrdw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpshrdw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpshrdw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpshufb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpshufb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpshufb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpshufb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl 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 CodeAsmVpshufd<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshufd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVpshufd<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshufd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVpshufd<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpshufd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVpshufd<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpshufd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVpshufhw<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshufhw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVpshufhw<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshufhw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVpshufhw<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpshufhw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVpshufhw<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpshufhw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVpshuflw<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshuflw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVpshuflw<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshuflw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVpshuflw<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpshuflw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVpshuflw<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpshuflw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVpsignb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsignb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpsignb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpsignb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpsignd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsignd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpsignd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpsignd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpsignw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsignw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpsignw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpsignw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpslld<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpslld( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVpslld<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpslld( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVpslld<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpslld( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpslld<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpslld( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpslld<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpslld( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVpslld<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpslld( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVpslld<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vpslld( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpslld<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

fn vpslld( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpslldq<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpslldq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVpslldq<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpslldq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVpslldq<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpslldq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVpslldq<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpslldq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVpsllq<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsllq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVpsllq<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsllq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVpsllq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsllq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpsllq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpsllq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpsllq<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpsllq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVpsllq<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpsllq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVpsllq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vpsllq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpsllq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

fn vpsllq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpsllvd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsllvd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpsllvd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpsllvd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpsllvq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsllvq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpsllvq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpsllvq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpsllvw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsllvw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpsllvw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpsllvw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpsllw<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsllw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVpsllw<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsllw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVpsllw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsllw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpsllw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpsllw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpsllw<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpsllw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVpsllw<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpsllw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVpsllw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vpsllw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpsllw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

fn vpsllw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpsrad<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsrad( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVpsrad<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsrad( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVpsrad<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsrad( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpsrad<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpsrad( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpsrad<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpsrad( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVpsrad<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpsrad( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVpsrad<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vpsrad( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpsrad<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

fn vpsrad( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpsraq<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsraq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVpsraq<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsraq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVpsraq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsraq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpsraq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpsraq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpsraq<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpsraq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVpsraq<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpsraq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVpsraq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vpsraq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpsraq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

fn vpsraq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpsravd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsravd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpsravd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpsravd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpsravq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsravq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpsravq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpsravq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpsravw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsravw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpsravw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpsravw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpsraw<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsraw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVpsraw<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsraw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVpsraw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsraw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpsraw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpsraw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpsraw<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpsraw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVpsraw<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpsraw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVpsraw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vpsraw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpsraw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

fn vpsraw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpsrld<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsrld( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVpsrld<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsrld( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVpsrld<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsrld( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpsrld<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpsrld( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpsrld<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpsrld( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVpsrld<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpsrld( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVpsrld<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vpsrld( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpsrld<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

fn vpsrld( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpsrldq<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsrldq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVpsrldq<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsrldq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVpsrldq<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpsrldq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVpsrldq<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpsrldq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVpsrlq<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsrlq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVpsrlq<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsrlq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVpsrlq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsrlq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpsrlq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpsrlq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpsrlq<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpsrlq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVpsrlq<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpsrlq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVpsrlq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vpsrlq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpsrlq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

fn vpsrlq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpsrlvd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsrlvd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpsrlvd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpsrlvd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpsrlvq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsrlvq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpsrlvq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpsrlvq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpsrlvw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsrlvw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpsrlvw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpsrlvw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpsrlw<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsrlw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVpsrlw<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsrlw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVpsrlw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsrlw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpsrlw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpsrlw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpsrlw<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpsrlw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVpsrlw<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpsrlw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVpsrlw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vpsrlw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpsrlw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

fn vpsrlw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpsubb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsubb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpsubb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpsubb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpsubd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsubd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpsubd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpsubd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpsubq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsubq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpsubq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpsubq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpsubsb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsubsb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpsubsb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpsubsb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpsubsw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsubsw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpsubsw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpsubsw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpsubusb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsubusb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpsubusb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpsubusb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpsubusw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsubusw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpsubusw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpsubusw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpsubw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsubw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpsubw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpsubw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpternlogd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpternlogd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpternlogd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpternlogd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpternlogd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpternlogd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpternlogd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpternlogd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpternlogq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpternlogq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpternlogq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpternlogq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpternlogq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpternlogq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpternlogq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpternlogq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVptest<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vptest( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVptest<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vptest( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl 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 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 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 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 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 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 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 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 CodeAsmVpunpckhbw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpunpckhbw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpunpckhbw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpunpckhbw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpunpckhdq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpunpckhdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpunpckhdq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpunpckhdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpunpckhqdq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpunpckhqdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpunpckhqdq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpunpckhqdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpunpckhwd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpunpckhwd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpunpckhwd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpunpckhwd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpunpcklbw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpunpcklbw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpunpcklbw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpunpcklbw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpunpckldq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpunpckldq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpunpckldq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpunpckldq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpunpcklqdq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpunpcklqdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpunpcklqdq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpunpcklqdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpunpcklwd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpunpcklwd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpunpcklwd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpunpcklwd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpxor<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpxor( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpxor<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpxor( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpxord<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpxord( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpxord<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpxord( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpxorq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpxorq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpxorq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpxorq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVrangepd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vrangepd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVrangepd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vrangepd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVrangepd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vrangepd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVrangepd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vrangepd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVrangeps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vrangeps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVrangeps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vrangeps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVrangeps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vrangeps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVrangeps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vrangeps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVrangesd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vrangesd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVrangesd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vrangesd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVrangesd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vrangesd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVrangesd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vrangesd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVrangess<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vrangess( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVrangess<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vrangess( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVrangess<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vrangess( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVrangess<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vrangess( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVrcp14pd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrcp14pd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVrcp14pd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vrcp14pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVrcp14ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrcp14ps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVrcp14ps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vrcp14ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVrcp14sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrcp14sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVrcp14sd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vrcp14sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVrcp14ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrcp14ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVrcp14ss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vrcp14ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVrcp28sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrcp28sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVrcp28sd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vrcp28sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVrcp28ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrcp28ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVrcp28ss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vrcp28ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVrcpph<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrcpph( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVrcpph<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vrcpph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVrcpps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrcpps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVrcpps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vrcpps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVrcpsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrcpsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVrcpsh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vrcpsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVrcpss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrcpss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVrcpss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vrcpss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVreducepd<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vreducepd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVreducepd<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vreducepd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVreducepd<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vreducepd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVreducepd<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vreducepd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVreduceph<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vreduceph( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVreduceph<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vreduceph( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVreduceph<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vreduceph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVreduceph<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vreduceph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVreduceps<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vreduceps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVreduceps<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vreduceps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVreduceps<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vreduceps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVreduceps<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vreduceps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVreducesd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vreducesd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVreducesd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vreducesd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVreducesd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vreducesd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVreducesd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vreducesd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVreducesh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vreducesh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVreducesh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vreducesh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVreducesh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vreducesh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVreducesh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vreducesh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVreducess<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vreducess( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVreducess<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vreducess( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVreducess<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vreducess( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVreducess<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vreducess( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVrndscalepd<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vrndscalepd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVrndscalepd<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vrndscalepd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVrndscalepd<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vrndscalepd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVrndscalepd<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vrndscalepd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVrndscaleph<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vrndscaleph( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVrndscaleph<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vrndscaleph( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVrndscaleph<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vrndscaleph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVrndscaleph<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vrndscaleph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVrndscaleps<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vrndscaleps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVrndscaleps<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vrndscaleps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVrndscaleps<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vrndscaleps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVrndscaleps<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vrndscaleps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVrndscalesd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vrndscalesd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVrndscalesd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vrndscalesd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVrndscalesd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vrndscalesd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVrndscalesd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vrndscalesd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVrndscalesh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vrndscalesh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVrndscalesh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vrndscalesh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVrndscalesh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vrndscalesh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVrndscalesh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vrndscalesh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVrndscaless<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vrndscaless( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVrndscaless<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vrndscaless( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVrndscaless<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vrndscaless( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVrndscaless<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vrndscaless( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVroundpd<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vroundpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVroundpd<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vroundpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVroundpd<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vroundpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVroundpd<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vroundpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVroundps<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vroundps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVroundps<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vroundps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVroundps<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vroundps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVroundps<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vroundps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVroundsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vroundsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVroundsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vroundsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVroundsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vroundsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVroundsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vroundsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVroundss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vroundss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVroundss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vroundss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVroundss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vroundss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVroundss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vroundss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVrsqrt14pd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrsqrt14pd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVrsqrt14pd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vrsqrt14pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVrsqrt14ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrsqrt14ps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVrsqrt14ps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vrsqrt14ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVrsqrt14sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrsqrt14sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVrsqrt14sd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vrsqrt14sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVrsqrt14ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrsqrt14ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVrsqrt14ss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vrsqrt14ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVrsqrt28sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrsqrt28sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVrsqrt28sd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vrsqrt28sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVrsqrt28ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrsqrt28ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVrsqrt28ss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vrsqrt28ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVrsqrtph<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrsqrtph( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVrsqrtph<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vrsqrtph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVrsqrtps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrsqrtps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVrsqrtps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vrsqrtps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVrsqrtsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrsqrtsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVrsqrtsh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vrsqrtsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVrsqrtss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrsqrtss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVrsqrtss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vrsqrtss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVscalefpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vscalefpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVscalefpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vscalefpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVscalefph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vscalefph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVscalefph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vscalefph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVscalefps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vscalefps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVscalefps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vscalefps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVscalefsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vscalefsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVscalefsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vscalefsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVscalefsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vscalefsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVscalefsh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vscalefsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVscalefss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vscalefss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVscalefss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vscalefss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVscatterdpd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vscatterdpd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVscatterdps<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vscatterdps( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVscatterqpd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vscatterqpd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVscatterqps<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vscatterqps( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVsha512msg1<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vsha512msg1( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVsha512rnds2<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vsha512rnds2( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVshufpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vshufpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVshufpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vshufpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVshufpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vshufpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVshufpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vshufpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVshufps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vshufps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVshufps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vshufps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVshufps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vshufps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVshufps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vshufps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVsm3msg1<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vsm3msg1( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVsm3msg1<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vsm3msg1( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVsm3msg2<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vsm3msg2( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVsm3msg2<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vsm3msg2( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVsm3rnds2<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vsm3rnds2( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVsm3rnds2<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vsm3rnds2( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVsm3rnds2<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vsm3rnds2( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVsm3rnds2<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vsm3rnds2( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVsm4key4<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vsm4key4( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVsm4key4<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vsm4key4( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVsm4rnds4<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vsm4rnds4( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVsm4rnds4<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vsm4rnds4( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVsqrtpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vsqrtpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVsqrtpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vsqrtpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVsqrtph<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vsqrtph( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVsqrtph<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vsqrtph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVsqrtps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vsqrtps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVsqrtps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vsqrtps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVsqrtsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vsqrtsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVsqrtsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vsqrtsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVsqrtsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vsqrtsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVsqrtsh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vsqrtsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVsqrtss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vsqrtss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVsqrtss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vsqrtss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVsubpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vsubpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVsubpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vsubpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVsubph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vsubph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVsubph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vsubph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVsubps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vsubps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVsubps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vsubps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVsubsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vsubsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVsubsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vsubsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVsubsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vsubsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVsubsh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vsubsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVsubss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vsubss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVsubss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vsubss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVtestpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vtestpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVtestpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vtestpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVtestps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vtestps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVtestps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vtestps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVucomisd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vucomisd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVucomisd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vucomisd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVucomish<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vucomish( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVucomish<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vucomish( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVucomiss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vucomiss( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVucomiss<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vucomiss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVunpckhpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vunpckhpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVunpckhpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vunpckhpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVunpckhps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vunpckhps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVunpckhps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vunpckhps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVunpcklpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vunpcklpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVunpcklpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vunpcklpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVunpcklps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vunpcklps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVunpcklps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vunpcklps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVxorpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vxorpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVxorpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vxorpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVxorps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vxorps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVxorps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vxorps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmXorpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn xorpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmXorpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn xorpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmXorps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn xorps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmXorps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn xorps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl Debug for AsmRegisterXmm

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<AsmRegisterXmm> for Register

fn from(reg: AsmRegisterXmm) -> Self

Converts to this type from the input type.

impl Mul<AsmRegisterXmm> for i16

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

fn mul(self, rhs: AsmRegisterXmm) -> Self::Output

Performs the * operation.

impl Mul<AsmRegisterXmm> for i32

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

fn mul(self, rhs: AsmRegisterXmm) -> Self::Output

Performs the * operation.

impl Mul<AsmRegisterXmm> for i64

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

fn mul(self, rhs: AsmRegisterXmm) -> Self::Output

Performs the * operation.

impl Mul<AsmRegisterXmm> for i8

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

fn mul(self, rhs: AsmRegisterXmm) -> Self::Output

Performs the * operation.

impl Mul<AsmRegisterXmm> for isize

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

fn mul(self, rhs: AsmRegisterXmm) -> Self::Output

Performs the * operation.

impl Mul<AsmRegisterXmm> for u16

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

fn mul(self, rhs: AsmRegisterXmm) -> Self::Output

Performs the * operation.

impl Mul<AsmRegisterXmm> for u32

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

fn mul(self, rhs: AsmRegisterXmm) -> Self::Output

Performs the * operation.

impl Mul<AsmRegisterXmm> for u64

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

fn mul(self, rhs: AsmRegisterXmm) -> Self::Output

Performs the * operation.

impl Mul<AsmRegisterXmm> for u8

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

fn mul(self, rhs: AsmRegisterXmm) -> Self::Output

Performs the * operation.

impl Mul<AsmRegisterXmm> for usize

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

fn mul(self, rhs: AsmRegisterXmm) -> Self::Output

Performs the * operation.

impl Mul<i16> for AsmRegisterXmm

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

fn mul(self, rhs: i16) -> Self::Output

Performs the * operation.

impl Mul<i32> for AsmRegisterXmm

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

fn mul(self, rhs: i32) -> Self::Output

Performs the * operation.

impl Mul<i64> for AsmRegisterXmm

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

fn mul(self, rhs: i64) -> Self::Output

Performs the * operation.

impl Mul<i8> for AsmRegisterXmm

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

fn mul(self, rhs: i8) -> Self::Output

Performs the * operation.

impl Mul<isize> for AsmRegisterXmm

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

fn mul(self, rhs: isize) -> Self::Output

Performs the * operation.

impl Mul<u16> for AsmRegisterXmm

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

fn mul(self, rhs: u16) -> Self::Output

Performs the * operation.

impl Mul<u32> for AsmRegisterXmm

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

fn mul(self, rhs: u32) -> Self::Output

Performs the * operation.

impl Mul<u64> for AsmRegisterXmm

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

fn mul(self, rhs: u64) -> Self::Output

Performs the * operation.

impl Mul<u8> for AsmRegisterXmm

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

fn mul(self, rhs: u8) -> Self::Output

Performs the * operation.

impl Mul<usize> for AsmRegisterXmm

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

fn mul(self, rhs: usize) -> Self::Output

Performs the * operation.

impl PartialEq for AsmRegisterXmm

fn eq(&self, other: &AsmRegisterXmm) -> 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 AsmRegisterXmm

impl Eq for AsmRegisterXmm

impl StructuralEq for AsmRegisterXmm

impl StructuralPartialEq for AsmRegisterXmm