Struct AsmMemoryOperand

pub struct AsmMemoryOperand { /* private fields */ }

A memory operand passed to CodeAssembler methods.

The struct name is not part of the public API. Its methods, however, are part of the public API.

You can create a memory operand in many different ways:

use iced_x86::code_asm::*;

// <???> ptr [rax+rdx*4]
let _ = rax + rdx * 4;
// byte ptr [rax]
let _ = byte_ptr(rax);
// <???> ptr gs:[rcx*4+123]
let _ = ptr(rcx * 4 + 123).gs();
// qword bcst [rdx+xmm0*8+123]
let _ = qword_bcst(rdx + xmm0 * 8 + 123);

Implementations

impl AsmMemoryOperand

pub fn es(self) -> Self

Adds an ES segment override

pub fn cs(self) -> Self

Adds a CS segment override

pub fn ss(self) -> Self

Adds an SS segment override

pub fn ds(self) -> Self

Adds a DS segment override

pub fn fs(self) -> Self

Adds an FS segment override

pub fn gs(self) -> Self

Adds a GS segment override

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

Trait Implementations

impl Add<AsmMemoryOperand> for AsmRegister16

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<AsmMemoryOperand> for AsmRegister32

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<AsmMemoryOperand> for AsmRegister64

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<AsmMemoryOperand> for i16

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<AsmMemoryOperand> for i32

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<AsmMemoryOperand> for i64

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<AsmMemoryOperand> for i8

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<AsmMemoryOperand> for isize

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<AsmMemoryOperand> for u16

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<AsmMemoryOperand> for u32

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<AsmMemoryOperand> for u64

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<AsmMemoryOperand> for u8

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<AsmMemoryOperand> for usize

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<AsmRegister16> for AsmMemoryOperand

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<AsmRegister32> for AsmMemoryOperand

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<AsmRegister64> for AsmMemoryOperand

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<i16> for AsmMemoryOperand

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<i32> for AsmMemoryOperand

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<i64> for AsmMemoryOperand

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<i8> for AsmMemoryOperand

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<isize> for AsmMemoryOperand

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<u16> for AsmMemoryOperand

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<u32> for AsmMemoryOperand

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<u64> for AsmMemoryOperand

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<u8> for AsmMemoryOperand

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<usize> for AsmMemoryOperand

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add for AsmMemoryOperand

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Clone for AsmMemoryOperand

fn clone(&self) -> AsmMemoryOperand

Returns a copy of the value.

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

Performs copy-assignment from source.

impl CodeAsmAadd<AsmMemoryOperand, AsmRegister32> for CodeAssembler

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

impl CodeAsmAadd<AsmMemoryOperand, AsmRegister64> for CodeAssembler

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

impl CodeAsmAand<AsmMemoryOperand, AsmRegister32> for CodeAssembler

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

impl CodeAsmAand<AsmMemoryOperand, AsmRegister64> for CodeAssembler

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

impl CodeAsmAdc<AsmMemoryOperand, AsmRegister16> for CodeAssembler

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

impl CodeAsmAdc<AsmMemoryOperand, AsmRegister32> for CodeAssembler

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

impl CodeAsmAdc<AsmMemoryOperand, AsmRegister64> for CodeAssembler

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

impl CodeAsmAdc<AsmMemoryOperand, AsmRegister8> for CodeAssembler

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

impl CodeAsmAdc<AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmAdc<AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmAdc<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmAdc<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmAdc<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmAdc<AsmRegister8, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmAdcx<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmAdcx<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmAdd<AsmMemoryOperand, AsmRegister16> for CodeAssembler

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

impl CodeAsmAdd<AsmMemoryOperand, AsmRegister32> for CodeAssembler

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

impl CodeAsmAdd<AsmMemoryOperand, AsmRegister64> for CodeAssembler

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

impl CodeAsmAdd<AsmMemoryOperand, AsmRegister8> for CodeAssembler

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

impl CodeAsmAdd<AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmAdd<AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmAdd<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmAdd<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmAdd<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmAdd<AsmRegister8, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmAddpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmAddps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmAddsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmAddss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmAddsubpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmAddsubps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmAdox<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmAdox<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmAesdec<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn aesdec( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> 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 CodeAsmAesdecwide128kl<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmAesdecwide256kl<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmAesenc<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl 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 CodeAsmAesencwide128kl<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmAesencwide256kl<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmAesimc<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl 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 CodeAsmAnd<AsmMemoryOperand, AsmRegister16> for CodeAssembler

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

impl CodeAsmAnd<AsmMemoryOperand, AsmRegister32> for CodeAssembler

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

impl CodeAsmAnd<AsmMemoryOperand, AsmRegister64> for CodeAssembler

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

impl CodeAsmAnd<AsmMemoryOperand, AsmRegister8> for CodeAssembler

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

impl CodeAsmAnd<AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmAnd<AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmAnd<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmAnd<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmAnd<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmAnd<AsmRegister8, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmAndn<AsmRegister32, AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmAndn<AsmRegister64, AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmAndnpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmAndnps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmAndpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmAndps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmAor<AsmMemoryOperand, AsmRegister32> for CodeAssembler

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

impl CodeAsmAor<AsmMemoryOperand, AsmRegister64> for CodeAssembler

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

impl CodeAsmArpl<AsmMemoryOperand, AsmRegister16> for CodeAssembler

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

impl CodeAsmArpl<AsmMemoryOperand, AsmRegister32> for CodeAssembler

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

impl CodeAsmAxor<AsmMemoryOperand, AsmRegister32> for CodeAssembler

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

impl CodeAsmAxor<AsmMemoryOperand, AsmRegister64> for CodeAssembler

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

impl CodeAsmBextr<AsmRegister32, AsmMemoryOperand, AsmRegister32> for CodeAssembler

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

impl CodeAsmBextr<AsmRegister32, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmBextr<AsmRegister32, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmBextr<AsmRegister64, AsmMemoryOperand, AsmRegister64> for CodeAssembler

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

impl CodeAsmBextr<AsmRegister64, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmBextr<AsmRegister64, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmBlcfill<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmBlcfill<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmBlci<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmBlci<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmBlcic<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmBlcic<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmBlcmsk<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmBlcmsk<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmBlcs<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmBlcs<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn blcs( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> 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 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 CodeAsmBlendvpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmBlendvps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmBlsfill<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmBlsfill<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmBlsi<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmBlsi<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmBlsic<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmBlsic<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmBlsmsk<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmBlsmsk<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmBlsr<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmBlsr<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmBndcl<AsmRegisterBnd, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmBndcn<AsmRegisterBnd, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmBndcu<AsmRegisterBnd, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmBndldx<AsmRegisterBnd, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmBndmk<AsmRegisterBnd, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmBndmov<AsmMemoryOperand, AsmRegisterBnd> for CodeAssembler

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

impl CodeAsmBndmov<AsmRegisterBnd, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmBndstx<AsmMemoryOperand, AsmRegisterBnd> for CodeAssembler

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

impl CodeAsmBound<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmBound<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmBsf<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmBsf<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmBsf<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmBsr<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmBsr<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmBsr<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmBt<AsmMemoryOperand, AsmRegister16> for CodeAssembler

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

impl CodeAsmBt<AsmMemoryOperand, AsmRegister32> for CodeAssembler

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

impl CodeAsmBt<AsmMemoryOperand, AsmRegister64> for CodeAssembler

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

impl CodeAsmBt<AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmBt<AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmBtc<AsmMemoryOperand, AsmRegister16> for CodeAssembler

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

impl CodeAsmBtc<AsmMemoryOperand, AsmRegister32> for CodeAssembler

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

impl CodeAsmBtc<AsmMemoryOperand, AsmRegister64> for CodeAssembler

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

impl CodeAsmBtc<AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmBtc<AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmBtr<AsmMemoryOperand, AsmRegister16> for CodeAssembler

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

impl CodeAsmBtr<AsmMemoryOperand, AsmRegister32> for CodeAssembler

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

impl CodeAsmBtr<AsmMemoryOperand, AsmRegister64> for CodeAssembler

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

impl CodeAsmBtr<AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmBtr<AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmBts<AsmMemoryOperand, AsmRegister16> for CodeAssembler

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

impl CodeAsmBts<AsmMemoryOperand, AsmRegister32> for CodeAssembler

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

impl CodeAsmBts<AsmMemoryOperand, AsmRegister64> for CodeAssembler

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

impl CodeAsmBts<AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmBts<AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmBzhi<AsmRegister32, AsmMemoryOperand, AsmRegister32> for CodeAssembler

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

impl CodeAsmBzhi<AsmRegister64, AsmMemoryOperand, AsmRegister64> for CodeAssembler

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

impl CodeAsmCall<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCldemote<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmClflush<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmClflushopt<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmClrssbsy<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmClwb<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmova<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmova<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmova<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovae<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovae<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovae<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovb<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovb<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovb<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovbe<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovbe<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovbe<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovc<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovc<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovc<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmove<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmove<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmove<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovg<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovg<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovg<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovge<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovge<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovge<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovl<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovl<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovl<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovle<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovle<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovle<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovna<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovna<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovna<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovnae<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovnae<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovnae<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovnb<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovnb<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovnb<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovnbe<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovnbe<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovnbe<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovnc<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovnc<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovnc<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovne<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovne<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovne<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovng<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovng<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovng<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovnge<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovnge<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovnge<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovnl<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovnl<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovnl<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovnle<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovnle<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovnle<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovno<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovno<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovno<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovnp<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovnp<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovnp<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovns<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovns<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovns<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovnz<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovnz<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovnz<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovo<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovo<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovo<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovp<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovp<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovp<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovpe<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovpe<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovpe<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovpo<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovpo<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovpo<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovs<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovs<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovs<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovz<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovz<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovz<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmp<AsmMemoryOperand, AsmRegister16> for CodeAssembler

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

impl CodeAsmCmp<AsmMemoryOperand, AsmRegister32> for CodeAssembler

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

impl CodeAsmCmp<AsmMemoryOperand, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmp<AsmMemoryOperand, AsmRegister8> for CodeAssembler

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

impl CodeAsmCmp<AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmCmp<AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmCmp<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmp<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmp<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmp<AsmRegister8, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmpbexadd<AsmMemoryOperand, AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmCmpbexadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmpbxadd<AsmMemoryOperand, AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmCmpbxadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmpcxadd<AsmMemoryOperand, AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmCmpcxadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmpeqpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmpeqps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmpeqsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmpeqss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmplepd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmpleps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmplesd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmpless<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmplexadd<AsmMemoryOperand, AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmCmplexadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmpltpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmpltps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmpltsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmpltss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmplxadd<AsmMemoryOperand, AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmCmplxadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmpnaexadd<AsmMemoryOperand, AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmCmpnaexadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmpnaxadd<AsmMemoryOperand, AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmCmpnaxadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmpnbexadd<AsmMemoryOperand, AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmCmpnbexadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmpnbxadd<AsmMemoryOperand, AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmCmpnbxadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmpncxadd<AsmMemoryOperand, AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmCmpncxadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmpneqpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmpneqps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmpneqsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmpneqss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmpngexadd<AsmMemoryOperand, AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmCmpngexadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmpngxadd<AsmMemoryOperand, AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmCmpngxadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmpnlepd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmpnleps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmpnlesd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmpnless<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmpnlexadd<AsmMemoryOperand, AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmCmpnlexadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmpnltpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmpnltps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmpnltsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmpnltss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmpnlxadd<AsmMemoryOperand, AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmCmpnlxadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmpnoxadd<AsmMemoryOperand, AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmCmpnoxadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmpnpxadd<AsmMemoryOperand, AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmCmpnpxadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmpnsxadd<AsmMemoryOperand, AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmCmpnsxadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmpnzxadd<AsmMemoryOperand, AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmCmpnzxadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmpordpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmpordps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmpordsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmpordss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmpoxadd<AsmMemoryOperand, AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmCmpoxadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmppd<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmCmppd<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmCmppexadd<AsmMemoryOperand, AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmCmppexadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmppoxadd<AsmMemoryOperand, AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmCmppoxadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmpps<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmCmpps<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmCmppxadd<AsmMemoryOperand, AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmCmppxadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

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

impl 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 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 CodeAsmCmpsxadd<AsmMemoryOperand, AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmCmpsxadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmpunordpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmpunordps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmpunordsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmpunordss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmpxchg<AsmMemoryOperand, AsmRegister16> for CodeAssembler

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

impl CodeAsmCmpxchg<AsmMemoryOperand, AsmRegister32> for CodeAssembler

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

impl CodeAsmCmpxchg<AsmMemoryOperand, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmpxchg<AsmMemoryOperand, AsmRegister8> for CodeAssembler

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

impl CodeAsmCmpxchg16b<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmpxchg8b<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmpzxadd<AsmMemoryOperand, AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmCmpzxadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmComisd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmComiss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCrc32<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCrc32<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCvtdq2pd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCvtdq2ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCvtpd2dq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCvtpd2pi<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCvtpd2ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCvtpi2pd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCvtpi2ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCvtps2dq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCvtps2pd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCvtps2pi<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCvtsd2si<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCvtsd2si<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCvtsd2ss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCvtsi2sd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCvtsi2ss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCvtss2sd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCvtss2si<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCvtss2si<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCvttpd2dq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCvttpd2pi<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCvttps2dq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCvttps2pi<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCvttsd2si<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCvttsd2si<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCvttss2si<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCvttss2si<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmDec<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmDiv<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmDivpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmDivps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmDivsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmDivss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn divss( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> 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 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 CodeAsmEnqcmd<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmEnqcmd<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmEnqcmd<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmEnqcmds<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmEnqcmds<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmEnqcmds<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl 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 CodeAsmFadd<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmFbld<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmFbstp<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmFcom<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmFcomp<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmFdiv<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmFdivr<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmFiadd<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmFicom<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmFicomp<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmFidiv<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmFidivr<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmFild<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmFimul<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmFist<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmFistp<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmFisttp<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmFisub<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmFisubr<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmFld<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmFldcw<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmFldenv<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmFmul<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmFnsave<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmFnstcw<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmFnstenv<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmFnstsw<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmFrstor<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmFsave<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmFst<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmFstcw<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmFstenv<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmFstp<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmFstsw<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmFsub<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmFsubr<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmFxrstor<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmFxrstor64<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmFxsave<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmFxsave64<AsmMemoryOperand> for CodeAssembler

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

impl 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 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 CodeAsmGf2p8mulb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmHaddpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmHaddps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmHsubpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmHsubps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmIbts<AsmMemoryOperand, AsmRegister16> for CodeAssembler

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

impl CodeAsmIbts<AsmMemoryOperand, AsmRegister32> for CodeAssembler

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

impl CodeAsmIdiv<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmImul<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmImul2<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmImul2<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmImul2<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmImul3<AsmRegister16, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmImul3<AsmRegister16, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmImul3<AsmRegister32, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmImul3<AsmRegister32, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmImul3<AsmRegister64, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmInc<AsmMemoryOperand> for CodeAssembler

fn inc(&mut self, op0: AsmMemoryOperand) -> 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 CodeAsmInvept<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmInvept<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmInvlpg<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmInvpcid<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmInvpcid<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmInvvpid<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmInvvpid<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmJmp<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmJmpe<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmKmovb<AsmMemoryOperand, AsmRegisterK> for CodeAssembler

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

impl CodeAsmKmovb<AsmRegisterK, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmKmovd<AsmMemoryOperand, AsmRegisterK> for CodeAssembler

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

impl CodeAsmKmovd<AsmRegisterK, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmKmovq<AsmMemoryOperand, AsmRegisterK> for CodeAssembler

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

impl CodeAsmKmovq<AsmRegisterK, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmKmovw<AsmMemoryOperand, AsmRegisterK> for CodeAssembler

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

impl CodeAsmKmovw<AsmRegisterK, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmLar<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmLar<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmLddqu<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmLdmxcsr<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmLds<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmLds<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmLdtilecfg<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmLea<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmLea<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmLea<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmLes<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmLes<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmLfs<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmLfs<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmLfs<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmLgdt<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmLgs<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmLgs<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmLgs<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmLidt<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmLkgs<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmLldt<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmLmsw<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmLsl<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmLsl<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmLss<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmLss<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmLss<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmLtr<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmLwpins<AsmRegister32, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmLwpins<AsmRegister32, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmLwpins<AsmRegister64, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmLwpins<AsmRegister64, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmLwpval<AsmRegister32, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmLwpval<AsmRegister32, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmLwpval<AsmRegister64, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmLwpval<AsmRegister64, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmLzcnt<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmLzcnt<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmLzcnt<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMaxpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMaxps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMaxsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMaxss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMinpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMinps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMinsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMinss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMov<AsmMemoryOperand, AsmRegister16> for CodeAssembler

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

impl CodeAsmMov<AsmMemoryOperand, AsmRegister32> for CodeAssembler

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

impl CodeAsmMov<AsmMemoryOperand, AsmRegister64> for CodeAssembler

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

impl CodeAsmMov<AsmMemoryOperand, AsmRegister8> for CodeAssembler

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

impl CodeAsmMov<AsmMemoryOperand, AsmRegisterSegment> for CodeAssembler

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

impl CodeAsmMov<AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmMov<AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmMov<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMov<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMov<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMov<AsmRegister8, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMov<AsmRegisterSegment, AsmMemoryOperand> for CodeAssembler

fn mov( &mut self, op0: AsmRegisterSegment, op1: AsmMemoryOperand, ) -> 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 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 CodeAsmMovbe<AsmMemoryOperand, AsmRegister16> for CodeAssembler

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

impl CodeAsmMovbe<AsmMemoryOperand, AsmRegister32> for CodeAssembler

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

impl CodeAsmMovbe<AsmMemoryOperand, AsmRegister64> for CodeAssembler

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

impl CodeAsmMovbe<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMovbe<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMovbe<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMovd<AsmMemoryOperand, AsmRegisterMm> for CodeAssembler

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

impl CodeAsmMovd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmMovd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMovd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMovddup<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMovdir64b<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMovdir64b<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMovdir64b<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMovdiri<AsmMemoryOperand, AsmRegister32> for CodeAssembler

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

impl CodeAsmMovdiri<AsmMemoryOperand, AsmRegister64> for CodeAssembler

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

impl 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 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 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 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 CodeAsmMovntdq<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmMovntdqa<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMovnti<AsmMemoryOperand, AsmRegister32> for CodeAssembler

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

impl CodeAsmMovnti<AsmMemoryOperand, AsmRegister64> for CodeAssembler

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

impl CodeAsmMovntpd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmMovntps<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmMovntq<AsmMemoryOperand, AsmRegisterMm> for CodeAssembler

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

impl CodeAsmMovntsd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmMovntss<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmMovq<AsmMemoryOperand, AsmRegisterMm> for CodeAssembler

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

impl CodeAsmMovq<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmMovq<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMovq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn movq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> 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 CodeAsmMovshdup<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMovsldup<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn movsldup( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> 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 CodeAsmMovsx<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMovsx<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMovsx<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMovsxd<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMovsxd<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMovsxd<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn movsxd( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> 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 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 CodeAsmMovzx<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMovzx<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMovzx<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn movzx( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> 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 CodeAsmMul<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMulpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMulps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMulsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMulss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMulx<AsmRegister32, AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMulx<AsmRegister64, AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmNeg<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmNop1<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmNot<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmOr<AsmMemoryOperand, AsmRegister16> for CodeAssembler

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

impl CodeAsmOr<AsmMemoryOperand, AsmRegister32> for CodeAssembler

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

impl CodeAsmOr<AsmMemoryOperand, AsmRegister64> for CodeAssembler

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

impl CodeAsmOr<AsmMemoryOperand, AsmRegister8> for CodeAssembler

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

impl CodeAsmOr<AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmOr<AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmOr<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmOr<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmOr<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmOr<AsmRegister8, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmOrpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmOrps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPabsb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPabsb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPabsd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPabsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPabsw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPabsw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPackssdw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPackssdw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPacksswb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPacksswb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPackusdw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPackuswb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPackuswb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPaddb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPaddb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPaddd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPaddd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPaddq<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPaddq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPaddsb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPaddsb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPaddsiw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPaddsw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPaddsw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPaddusb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPaddusb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPaddusw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPaddusw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPaddw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPaddw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPalignr<AsmRegisterMm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmPalignr<AsmRegisterMm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmPalignr<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 CodeAsmPand<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPand<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPandn<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPandn<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPaveb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPavgb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPavgb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPavgusb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPavgw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPavgw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPblendvb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pblendvb( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> 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 CodeAsmPclmulhqhqdq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPclmulhqlqdq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPclmullqhqdq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPclmullqlqdq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pclmullqlqdq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> 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 CodeAsmPcmpeqb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPcmpeqb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPcmpeqd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPcmpeqd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPcmpeqq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPcmpeqw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPcmpeqw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pcmpeqw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> 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 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 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 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 CodeAsmPcmpgtb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPcmpgtb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPcmpgtd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPcmpgtd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPcmpgtq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPcmpgtw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPcmpgtw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pcmpgtw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> 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 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 CodeAsmPdep<AsmRegister32, AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPdep<AsmRegister64, AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPdistib<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPext<AsmRegister32, AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPext<AsmRegister64, AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn pext( &mut self, op0: AsmRegister64, op1: AsmRegister64, op2: AsmMemoryOperand, ) -> 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 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 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 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 CodeAsmPf2id<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPf2iw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPfacc<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPfadd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPfcmpeq<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPfcmpge<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPfcmpgt<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPfmax<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPfmin<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPfmul<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPfnacc<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPfpnacc<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPfrcp<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPfrcpit1<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPfrcpit2<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPfrcpv<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPfrsqit1<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPfrsqrt<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPfrsqrtv<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPfsub<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPfsubr<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPhaddd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPhaddd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPhaddsw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPhaddsw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPhaddw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPhaddw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPhminposuw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPhsubd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPhsubd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPhsubsw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPhsubsw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPhsubw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPhsubw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPi2fd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPi2fw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pi2fw( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> 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 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 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 CodeAsmPinsrw<AsmRegisterMm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmPinsrw<AsmRegisterMm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmPinsrw<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 CodeAsmPmachriw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPmaddubsw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPmaddubsw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPmaddwd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPmaddwd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPmagw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPmaxsb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPmaxsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPmaxsw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPmaxsw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPmaxub<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPmaxub<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPmaxud<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPmaxuw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPminsb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPminsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPminsw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPminsw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPminub<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPminub<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPminud<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPminuw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPmovsxbd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPmovsxbq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPmovsxbw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPmovsxdq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPmovsxwd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPmovsxwq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPmovzxbd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPmovzxbq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPmovzxbw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPmovzxdq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPmovzxwd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPmovzxwq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPmuldq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPmulhriw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPmulhrsw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPmulhrsw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPmulhrw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPmulhrw_cyrix<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPmulhuw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPmulhuw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPmulhw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPmulhw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPmulld<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPmullw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPmullw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPmuludq<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPmuludq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPmvgezb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPmvlzb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPmvnzb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPmvzb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPop<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPopcnt<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPopcnt<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPopcnt<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPor<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPor<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPrefetch<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPrefetchit0<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPrefetchit1<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPrefetchnta<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPrefetcht0<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPrefetcht1<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPrefetcht2<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPrefetchw<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPrefetchwt1<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPsadbw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPsadbw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPshufb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPshufb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pshufb( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> 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 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 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 CodeAsmPshufw<AsmRegisterMm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmPshufw<AsmRegisterMm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmPsignb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPsignb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPsignd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPsignd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPsignw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPsignw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPslld<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPslld<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPsllq<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPsllq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPsllw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPsllw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPsrad<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPsrad<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPsraw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPsraw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPsrld<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPsrld<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPsrlq<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPsrlq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPsrlw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPsrlw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPsubb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPsubb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPsubd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPsubd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPsubq<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPsubq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPsubsb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPsubsb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPsubsiw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPsubsw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPsubsw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPsubusb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPsubusb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPsubusw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPsubusw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPsubw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPsubw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPswapd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPtest<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPtwrite<AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPunpckhbw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPunpckhbw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPunpckhdq<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPunpckhdq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPunpckhqdq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn punpckhqdq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPunpckhwd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn punpckhwd( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPunpckhwd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn punpckhwd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPunpcklbw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn punpcklbw( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPunpcklbw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn punpcklbw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPunpckldq<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn punpckldq( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPunpckldq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn punpckldq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPunpcklqdq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn punpcklqdq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPunpcklwd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn punpcklwd( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPunpcklwd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn punpcklwd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPush<AsmMemoryOperand> for CodeAssembler

fn push(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmPxor<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pxor( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPxor<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pxor( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmRcl<AsmMemoryOperand, AsmRegister8> for CodeAssembler

fn rcl( &mut self, op0: AsmMemoryOperand, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmRcl<AsmMemoryOperand, i32> for CodeAssembler

fn rcl(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

impl CodeAsmRcl<AsmMemoryOperand, u32> for CodeAssembler

fn rcl(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

impl CodeAsmRcpps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn rcpps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmRcpss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn rcpss( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmRcr<AsmMemoryOperand, AsmRegister8> for CodeAssembler

fn rcr( &mut self, op0: AsmMemoryOperand, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmRcr<AsmMemoryOperand, i32> for CodeAssembler

fn rcr(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

impl CodeAsmRcr<AsmMemoryOperand, u32> for CodeAssembler

fn rcr(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

impl CodeAsmRdshr<AsmMemoryOperand> for CodeAssembler

fn rdshr(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmReservednop_0f0d<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn reservednop_0f0d( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f0d<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn reservednop_0f0d( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f0d<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn reservednop_0f0d( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f18<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn reservednop_0f18( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f18<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn reservednop_0f18( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f18<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn reservednop_0f18( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f19<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn reservednop_0f19( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f19<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn reservednop_0f19( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f19<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn reservednop_0f19( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f1a<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn reservednop_0f1a( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f1a<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn reservednop_0f1a( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f1a<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn reservednop_0f1a( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f1b<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn reservednop_0f1b( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f1b<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn reservednop_0f1b( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f1b<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn reservednop_0f1b( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f1c<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn reservednop_0f1c( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f1c<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn reservednop_0f1c( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f1c<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn reservednop_0f1c( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f1d<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn reservednop_0f1d( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f1d<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn reservednop_0f1d( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f1d<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn reservednop_0f1d( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f1e<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn reservednop_0f1e( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f1e<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn reservednop_0f1e( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f1e<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn reservednop_0f1e( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f1f<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn reservednop_0f1f( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f1f<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn reservednop_0f1f( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f1f<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn reservednop_0f1f( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmRol<AsmMemoryOperand, AsmRegister8> for CodeAssembler

fn rol( &mut self, op0: AsmMemoryOperand, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmRol<AsmMemoryOperand, i32> for CodeAssembler

fn rol(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

impl CodeAsmRol<AsmMemoryOperand, u32> for CodeAssembler

fn rol(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

impl CodeAsmRor<AsmMemoryOperand, AsmRegister8> for CodeAssembler

fn ror( &mut self, op0: AsmMemoryOperand, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmRor<AsmMemoryOperand, i32> for CodeAssembler

fn ror(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

impl CodeAsmRor<AsmMemoryOperand, u32> for CodeAssembler

fn ror(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

impl CodeAsmRorx<AsmRegister32, AsmMemoryOperand, i32> for CodeAssembler

fn rorx( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmRorx<AsmRegister32, AsmMemoryOperand, u32> for CodeAssembler

fn rorx( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmRorx<AsmRegister64, AsmMemoryOperand, i32> for CodeAssembler

fn rorx( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmRorx<AsmRegister64, AsmMemoryOperand, u32> for CodeAssembler

fn rorx( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl 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 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 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 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 CodeAsmRsdc<AsmRegisterSegment, AsmMemoryOperand> for CodeAssembler

fn rsdc( &mut self, op0: AsmRegisterSegment, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmRsldt<AsmMemoryOperand> for CodeAssembler

fn rsldt(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmRsqrtps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn rsqrtps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmRsqrtss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn rsqrtss( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmRstorssp<AsmMemoryOperand> for CodeAssembler

fn rstorssp(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmRsts<AsmMemoryOperand> for CodeAssembler

fn rsts(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSal<AsmMemoryOperand, AsmRegister8> for CodeAssembler

fn sal( &mut self, op0: AsmMemoryOperand, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmSal<AsmMemoryOperand, i32> for CodeAssembler

fn sal(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

impl CodeAsmSal<AsmMemoryOperand, u32> for CodeAssembler

fn sal(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

impl CodeAsmSar<AsmMemoryOperand, AsmRegister8> for CodeAssembler

fn sar( &mut self, op0: AsmMemoryOperand, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmSar<AsmMemoryOperand, i32> for CodeAssembler

fn sar(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

impl CodeAsmSar<AsmMemoryOperand, u32> for CodeAssembler

fn sar(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

impl CodeAsmSarx<AsmRegister32, AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn sarx( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, op2: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmSarx<AsmRegister64, AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn sarx( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, op2: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmSbb<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn sbb( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmSbb<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn sbb( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmSbb<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn sbb( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmSbb<AsmMemoryOperand, AsmRegister8> for CodeAssembler

fn sbb( &mut self, op0: AsmMemoryOperand, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmSbb<AsmMemoryOperand, i32> for CodeAssembler

fn sbb(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

impl CodeAsmSbb<AsmMemoryOperand, u32> for CodeAssembler

fn sbb(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

impl CodeAsmSbb<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn sbb( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmSbb<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn sbb( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmSbb<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn sbb( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmSbb<AsmRegister8, AsmMemoryOperand> for CodeAssembler

fn sbb( &mut self, op0: AsmRegister8, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmSeta<AsmMemoryOperand> for CodeAssembler

fn seta(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetae<AsmMemoryOperand> for CodeAssembler

fn setae(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetb<AsmMemoryOperand> for CodeAssembler

fn setb(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetbe<AsmMemoryOperand> for CodeAssembler

fn setbe(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetc<AsmMemoryOperand> for CodeAssembler

fn setc(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSete<AsmMemoryOperand> for CodeAssembler

fn sete(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetg<AsmMemoryOperand> for CodeAssembler

fn setg(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetge<AsmMemoryOperand> for CodeAssembler

fn setge(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetl<AsmMemoryOperand> for CodeAssembler

fn setl(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetle<AsmMemoryOperand> for CodeAssembler

fn setle(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetna<AsmMemoryOperand> for CodeAssembler

fn setna(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetnae<AsmMemoryOperand> for CodeAssembler

fn setnae(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetnb<AsmMemoryOperand> for CodeAssembler

fn setnb(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetnbe<AsmMemoryOperand> for CodeAssembler

fn setnbe(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetnc<AsmMemoryOperand> for CodeAssembler

fn setnc(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetne<AsmMemoryOperand> for CodeAssembler

fn setne(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetng<AsmMemoryOperand> for CodeAssembler

fn setng(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetnge<AsmMemoryOperand> for CodeAssembler

fn setnge(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetnl<AsmMemoryOperand> for CodeAssembler

fn setnl(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetnle<AsmMemoryOperand> for CodeAssembler

fn setnle(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetno<AsmMemoryOperand> for CodeAssembler

fn setno(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetnp<AsmMemoryOperand> for CodeAssembler

fn setnp(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetns<AsmMemoryOperand> for CodeAssembler

fn setns(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetnz<AsmMemoryOperand> for CodeAssembler

fn setnz(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSeto<AsmMemoryOperand> for CodeAssembler

fn seto(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetp<AsmMemoryOperand> for CodeAssembler

fn setp(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetpe<AsmMemoryOperand> for CodeAssembler

fn setpe(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetpo<AsmMemoryOperand> for CodeAssembler

fn setpo(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSets<AsmMemoryOperand> for CodeAssembler

fn sets(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetz<AsmMemoryOperand> for CodeAssembler

fn setz(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSgdt<AsmMemoryOperand> for CodeAssembler

fn sgdt(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSha1msg1<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn sha1msg1( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmSha1msg2<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn sha1msg2( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmSha1nexte<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn sha1nexte( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> 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 CodeAsmSha256msg1<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn sha256msg1( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmSha256msg2<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn sha256msg2( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmSha256rnds2<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn sha256rnds2( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmShl<AsmMemoryOperand, AsmRegister8> for CodeAssembler

fn shl( &mut self, op0: AsmMemoryOperand, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmShl<AsmMemoryOperand, i32> for CodeAssembler

fn shl(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

impl CodeAsmShl<AsmMemoryOperand, u32> for CodeAssembler

fn shl(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

impl CodeAsmShld<AsmMemoryOperand, AsmRegister16, AsmRegister8> for CodeAssembler

fn shld( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, op2: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmShld<AsmMemoryOperand, AsmRegister16, i32> for CodeAssembler

fn shld( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmShld<AsmMemoryOperand, AsmRegister16, u32> for CodeAssembler

fn shld( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmShld<AsmMemoryOperand, AsmRegister32, AsmRegister8> for CodeAssembler

fn shld( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, op2: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmShld<AsmMemoryOperand, AsmRegister32, i32> for CodeAssembler

fn shld( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmShld<AsmMemoryOperand, AsmRegister32, u32> for CodeAssembler

fn shld( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmShld<AsmMemoryOperand, AsmRegister64, AsmRegister8> for CodeAssembler

fn shld( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, op2: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmShld<AsmMemoryOperand, AsmRegister64, i32> for CodeAssembler

fn shld( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmShld<AsmMemoryOperand, AsmRegister64, u32> for CodeAssembler

fn shld( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmShlx<AsmRegister32, AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn shlx( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, op2: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmShlx<AsmRegister64, AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn shlx( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, op2: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmShr<AsmMemoryOperand, AsmRegister8> for CodeAssembler

fn shr( &mut self, op0: AsmMemoryOperand, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmShr<AsmMemoryOperand, i32> for CodeAssembler

fn shr(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

impl CodeAsmShr<AsmMemoryOperand, u32> for CodeAssembler

fn shr(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

impl CodeAsmShrd<AsmMemoryOperand, AsmRegister16, AsmRegister8> for CodeAssembler

fn shrd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, op2: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmShrd<AsmMemoryOperand, AsmRegister16, i32> for CodeAssembler

fn shrd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmShrd<AsmMemoryOperand, AsmRegister16, u32> for CodeAssembler

fn shrd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmShrd<AsmMemoryOperand, AsmRegister32, AsmRegister8> for CodeAssembler

fn shrd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, op2: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmShrd<AsmMemoryOperand, AsmRegister32, i32> for CodeAssembler

fn shrd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmShrd<AsmMemoryOperand, AsmRegister32, u32> for CodeAssembler

fn shrd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmShrd<AsmMemoryOperand, AsmRegister64, AsmRegister8> for CodeAssembler

fn shrd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, op2: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmShrd<AsmMemoryOperand, AsmRegister64, i32> for CodeAssembler

fn shrd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmShrd<AsmMemoryOperand, AsmRegister64, u32> for CodeAssembler

fn shrd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmShrx<AsmRegister32, AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn shrx( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, op2: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmShrx<AsmRegister64, AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn shrx( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, op2: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmShufpd<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn shufpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmShufpd<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn shufpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl 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 CodeAsmSidt<AsmMemoryOperand> for CodeAssembler

fn sidt(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSldt<AsmMemoryOperand> for CodeAssembler

fn sldt(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSmsw<AsmMemoryOperand> for CodeAssembler

fn smsw(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSqrtpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn sqrtpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmSqrtps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn sqrtps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmSqrtsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn sqrtsd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmSqrtss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn sqrtss( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmStmxcsr<AsmMemoryOperand> for CodeAssembler

fn stmxcsr(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmStr<AsmMemoryOperand> for CodeAssembler

fn str(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSttilecfg<AsmMemoryOperand> for CodeAssembler

fn sttilecfg(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSub<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn sub( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmSub<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn sub( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmSub<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn sub( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmSub<AsmMemoryOperand, AsmRegister8> for CodeAssembler

fn sub( &mut self, op0: AsmMemoryOperand, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmSub<AsmMemoryOperand, i32> for CodeAssembler

fn sub(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

impl CodeAsmSub<AsmMemoryOperand, u32> for CodeAssembler

fn sub(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

impl CodeAsmSub<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn sub( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmSub<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn sub( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmSub<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn sub( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmSub<AsmRegister8, AsmMemoryOperand> for CodeAssembler

fn sub( &mut self, op0: AsmRegister8, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmSubpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn subpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmSubps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn subps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmSubsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn subsd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmSubss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn subss( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmSvdc<AsmMemoryOperand, AsmRegisterSegment> for CodeAssembler

fn svdc( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterSegment, ) -> Result<(), IcedError>

impl CodeAsmSvldt<AsmMemoryOperand> for CodeAssembler

fn svldt(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSvts<AsmMemoryOperand> for CodeAssembler

fn svts(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmT1mskc<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn t1mskc( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmT1mskc<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn t1mskc( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmTest<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn test( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmTest<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn test( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmTest<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn test( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmTest<AsmMemoryOperand, AsmRegister8> for CodeAssembler

fn test( &mut self, op0: AsmMemoryOperand, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmTest<AsmMemoryOperand, i32> for CodeAssembler

fn test(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

impl CodeAsmTest<AsmMemoryOperand, u32> for CodeAssembler

fn test(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

impl CodeAsmTileloadd<AsmRegisterTmm, AsmMemoryOperand> for CodeAssembler

fn tileloadd( &mut self, op0: AsmRegisterTmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmTileloaddt1<AsmRegisterTmm, AsmMemoryOperand> for CodeAssembler

fn tileloaddt1( &mut self, op0: AsmRegisterTmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmTilestored<AsmMemoryOperand, AsmRegisterTmm> for CodeAssembler

fn tilestored( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterTmm, ) -> Result<(), IcedError>

impl CodeAsmTzcnt<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn tzcnt( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmTzcnt<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn tzcnt( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmTzcnt<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn tzcnt( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmTzmsk<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn tzmsk( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmTzmsk<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn tzmsk( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmUcomisd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn ucomisd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmUcomiss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn ucomiss( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmUd02<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn ud0_2( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmUd02<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn ud0_2( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmUd02<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn ud0_2( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmUd1<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn ud1( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmUd1<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn ud1( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmUd1<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn ud1( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmUmov<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn umov( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmUmov<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn umov( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmUmov<AsmMemoryOperand, AsmRegister8> for CodeAssembler

fn umov( &mut self, op0: AsmMemoryOperand, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmUmov<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn umov( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmUmov<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn umov( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmUmov<AsmRegister8, AsmMemoryOperand> for CodeAssembler

fn umov( &mut self, op0: AsmRegister8, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmUnpckhpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn unpckhpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmUnpckhps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn unpckhps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmUnpcklpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn unpcklpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmUnpcklps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn unpcklps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmV4fmaddps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn v4fmaddps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmV4fmaddss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn v4fmaddss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmV4fnmaddps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn v4fnmaddps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmV4fnmaddss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn v4fnmaddss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVaddpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vaddpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVaddpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vaddpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVaddpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vaddpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVaddph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vaddph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVaddph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vaddph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVaddph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vaddph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVaddps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vaddps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVaddps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vaddps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVaddps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vaddps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVaddsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vaddsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVaddsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vaddsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVaddss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vaddss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVaddsubpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vaddsubpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVaddsubpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vaddsubpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVaddsubps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vaddsubps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVaddsubps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vaddsubps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVaesdec<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vaesdec( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVaesdec<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vaesdec( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVaesdec<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vaesdec( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVaesdeclast<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vaesdeclast( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVaesdeclast<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vaesdeclast( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVaesdeclast<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vaesdeclast( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVaesenc<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vaesenc( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVaesenc<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vaesenc( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVaesenc<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vaesenc( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVaesenclast<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vaesenclast( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVaesenclast<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vaesenclast( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVaesenclast<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vaesenclast( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVaesimc<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vaesimc( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> 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 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<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn valignd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmValignd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn valignd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmValignd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn valignd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmValignd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn valignd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl 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<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn valignq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmValignq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn valignq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmValignq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn valignq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmValignq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn valignq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVandnpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vandnpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVandnpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vandnpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVandnpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vandnpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVandnps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vandnps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVandnps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vandnps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVandnps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vandnps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVandpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vandpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVandpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vandpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVandpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vandpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVandps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vandps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVandps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vandps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVandps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vandps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVbcstnebf162ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vbcstnebf162ps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVbcstnebf162ps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vbcstnebf162ps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVbcstnesh2ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vbcstnesh2ps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVbcstnesh2ps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vbcstnesh2ps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVblendmpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vblendmpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVblendmpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vblendmpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVblendmpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vblendmpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVblendmps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vblendmps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVblendmps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vblendmps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVblendmps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vblendmps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> 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<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vblendpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVblendpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vblendpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl 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<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vblendps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVblendps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vblendps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVblendvpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vblendvpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVblendvpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vblendvpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVblendvps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vblendvps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVblendvps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vblendvps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVbroadcastf128<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vbroadcastf128( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVbroadcastf32x2<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vbroadcastf32x2( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVbroadcastf32x2<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vbroadcastf32x2( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVbroadcastf32x4<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vbroadcastf32x4( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVbroadcastf32x4<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vbroadcastf32x4( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVbroadcastf32x8<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vbroadcastf32x8( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVbroadcastf64x2<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vbroadcastf64x2( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVbroadcastf64x2<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vbroadcastf64x2( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVbroadcastf64x4<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vbroadcastf64x4( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVbroadcasti128<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vbroadcasti128( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVbroadcasti32x2<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vbroadcasti32x2( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVbroadcasti32x2<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vbroadcasti32x2( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVbroadcasti32x2<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vbroadcasti32x2( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVbroadcasti32x4<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vbroadcasti32x4( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVbroadcasti32x4<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vbroadcasti32x4( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVbroadcasti32x8<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vbroadcasti32x8( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVbroadcasti64x2<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vbroadcasti64x2( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVbroadcasti64x2<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vbroadcasti64x2( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVbroadcasti64x4<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vbroadcasti64x4( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVbroadcastsd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vbroadcastsd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVbroadcastsd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vbroadcastsd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVbroadcastss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vbroadcastss( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVbroadcastss<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vbroadcastss( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVbroadcastss<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vbroadcastss( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> 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, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_ospd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_ospd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_ospd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_ospd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_ospd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_ospd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_ospd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_osph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_osph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_osph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_osph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_osph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_osph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> 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, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_osps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_osps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_osps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_osps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_osps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_osps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_osps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_ossd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_ossd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> 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_ossh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_ossh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> 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<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_osss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> 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, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uqpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uqpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> 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, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uqps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uqps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uqsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> 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_uqsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uqsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> 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<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uqss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> 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, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uspd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uspd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uspd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uspd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uspd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uspd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uspd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_usph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_usph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_usph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_usph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_usph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_usph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> 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, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_usps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_usps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_usps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_usps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_usps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_usps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_usps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_ussd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_ussd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> 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_ussh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_ussh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> 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<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_usss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeqpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeqpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeqpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeqpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeqpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeqpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeqpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeqph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeqph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeqph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeqps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeqps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeqps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeqps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeqps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeqps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeqps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeqsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeqsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeqsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeqsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeqsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeqsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeqss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeqss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeqss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeqss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> 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, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalse_ospd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_ospd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalse_ospd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_ospd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalse_ospd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_ospd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalse_ospd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_osph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalse_osph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_osph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalse_osph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_osph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalse_osph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> 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, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalse_osps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_osps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalse_osps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_osps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalse_osps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_osps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalse_osps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_ossd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalse_ossd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> 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_ossh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalse_ossh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> 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<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalse_osss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalsepd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalsepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalsepd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalsepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalsepd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalsepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalsepd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalsepd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalsepd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalsepd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalseph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalseph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalseph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalseph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalseph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalseph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalseps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalseps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalseps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalseps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalseps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalseps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalseps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalseps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalseps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalseps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalsesd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalsesd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalsesd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalsesd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalsesh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalsesh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalsess<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalsess( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalsess<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalsess( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> 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, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpge_oqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpge_oqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpge_oqpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpge_oqpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpge_oqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpge_oqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpge_oqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> 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, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpge_oqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpge_oqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpge_oqps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpge_oqps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpge_oqsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> 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_oqsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpge_oqsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> 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<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpge_oqss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgepd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgepd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgepd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgepd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgepd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgepd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgepd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgeph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgeph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgeph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgeph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgeph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgeph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgeps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgeps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgeps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgeps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgeps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgeps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgeps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgeps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgeps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgeps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgesd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgesd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgesd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgesd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgesh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgesh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgess<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgess( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgess<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgess( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> 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, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgt_oqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgt_oqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgt_oqpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgt_oqpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgt_oqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgt_oqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgt_oqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> 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, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgt_oqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgt_oqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgt_oqps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgt_oqps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgt_oqsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> 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_oqsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgt_oqsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> 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<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgt_oqss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgtpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgtpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgtpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgtpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgtpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgtpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgtpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgtpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgtpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgtpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgtph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgtph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgtph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgtph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgtph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgtph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgtps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgtps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgtps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgtps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgtps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgtps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgtps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgtps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgtps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgtps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgtsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgtsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgtsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgtsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgtsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgtsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgtss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgtss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgtss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgtss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> 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, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmple_oqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmple_oqpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmple_oqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmple_oqpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmple_oqpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmple_oqpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmple_oqpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmple_oqph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmple_oqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmple_oqph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmple_oqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmple_oqph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmple_oqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> 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, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmple_oqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmple_oqps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmple_oqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmple_oqps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmple_oqps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmple_oqps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmple_oqps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmple_oqsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmple_oqsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> 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_oqsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmple_oqsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> 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<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmple_oqss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmplepd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmplepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmplepd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmplepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmplepd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmplepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmplepd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmplepd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmplepd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmplepd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpleph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpleph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpleph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpleph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpleph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpleph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpleps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpleps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpleps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpleps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpleps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpleps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpleps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpleps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpleps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpleps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmplesd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmplesd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmplesd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmplesd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmplesh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmplesh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpless<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpless( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpless<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpless( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> 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, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmplt_oqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmplt_oqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmplt_oqpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmplt_oqpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmplt_oqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmplt_oqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmplt_oqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> 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, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmplt_oqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmplt_oqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmplt_oqps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmplt_oqps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmplt_oqsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> 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_oqsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmplt_oqsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> 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<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmplt_oqss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpltpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpltpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpltpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpltpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpltpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpltpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpltpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpltpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpltpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpltpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpltph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpltph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpltph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpltph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpltph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpltph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpltps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpltps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpltps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpltps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpltps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpltps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpltps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpltps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpltps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpltps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpltsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpltsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpltsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpltsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpltsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpltsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpltss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpltss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpltss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpltss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> 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, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_oqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_oqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_oqpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_oqpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_oqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_oqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_oqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> 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, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_oqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_oqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_oqps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_oqps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_oqsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> 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_oqsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_oqsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> 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<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_oqss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> 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, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_ospd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_ospd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_ospd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_ospd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_ospd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_ospd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_ospd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_osph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_osph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_osph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_osph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_osph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_osph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> 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, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_osps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_osps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_osps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_osps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_osps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_osps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_osps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_ossd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_ossd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> 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_ossh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_ossh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> 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<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_osss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> 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, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_uspd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_uspd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_uspd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_uspd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_uspd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_uspd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_uspd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_usph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_usph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_usph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_usph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_usph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_usph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> 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, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_usps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_usps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_usps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_usps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_usps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_usps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_usps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_ussd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_ussd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> 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_ussh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_ussh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> 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<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_usss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneqpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneqpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneqpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneqpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneqpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneqpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneqpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneqph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneqph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneqph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneqps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneqps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneqps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneqps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneqps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneqps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneqps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneqsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneqsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneqsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneqsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneqsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneqsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneqss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneqss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneqss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneqss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> 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, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnge_uqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnge_uqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnge_uqpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnge_uqpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnge_uqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnge_uqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnge_uqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> 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, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnge_uqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnge_uqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnge_uqps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnge_uqps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnge_uqsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> 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_uqsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnge_uqsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> 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<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnge_uqss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngepd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngepd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngepd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngepd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngepd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngepd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngepd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngeph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngeph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngeph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngeph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngeph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngeph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngeps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngeps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngeps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngeps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngeps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngeps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngeps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngeps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngeps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngeps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngesd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngesd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngesd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngesd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngesh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngesh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngess<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngess( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngess<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngess( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> 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, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngt_uqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngt_uqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngt_uqpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngt_uqpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngt_uqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngt_uqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngt_uqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> 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, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngt_uqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngt_uqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngt_uqps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngt_uqps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngt_uqsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> 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_uqsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngt_uqsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> 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<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngt_uqss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngtpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngtpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngtpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngtpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngtpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngtpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngtpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngtpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngtpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngtpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngtph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngtph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngtph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngtph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngtph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngtph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngtps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngtps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngtps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngtps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngtps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngtps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngtps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngtps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngtps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngtps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngtsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngtsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngtsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngtsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngtsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngtsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngtss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngtss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngtss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngtss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> 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, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnle_uqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnle_uqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnle_uqpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnle_uqpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnle_uqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnle_uqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnle_uqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> 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, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnle_uqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnle_uqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnle_uqps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnle_uqps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnle_uqsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> 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_uqsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnle_uqsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> 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<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnle_uqss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnlepd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnlepd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnlepd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnlepd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlepd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnlepd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlepd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnleph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnleph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnleph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnleph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnleph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnleph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnleps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnleps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnleps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnleps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnleps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnleps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnleps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnleps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnleps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnleps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnlesd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlesd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnlesd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlesd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnlesh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlesh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnless<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnless( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnless<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnless( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> 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, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlt_uqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlt_uqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlt_uqpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlt_uqpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlt_uqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlt_uqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlt_uqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> 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, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlt_uqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlt_uqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlt_uqps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlt_uqps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlt_uqsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> 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_uqsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlt_uqsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> 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<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlt_uqss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnltpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnltpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnltpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnltpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnltpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnltpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnltpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnltpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnltpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnltpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnltph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnltph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnltph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnltph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnltph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnltph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnltps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnltps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnltps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnltps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnltps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnltps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnltps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnltps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnltps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnltps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnltsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnltsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnltsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnltsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnltsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnltsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnltss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnltss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnltss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnltss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> 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, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpord_spd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpord_spd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpord_spd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpord_spd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpord_spd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpord_spd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpord_spd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpord_sph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpord_sph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpord_sph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpord_sph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpord_sph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpord_sph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> 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, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpord_sps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpord_sps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpord_sps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpord_sps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpord_sps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpord_sps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpord_sps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpord_ssd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpord_ssd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> 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_ssh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpord_ssh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> 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<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpord_sss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpordpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpordpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpordpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpordpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpordpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpordpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpordpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpordpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpordpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpordpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpordph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpordph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpordph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpordph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpordph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpordph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpordps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpordps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpordps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpordps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpordps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpordps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpordps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpordps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpordps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpordps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpordsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpordsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpordsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpordsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpordsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpordsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpordss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpordss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpordss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpordss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> 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, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vcmppd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVcmppd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vcmppd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVcmppd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vcmppd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVcmppd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vcmppd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVcmppd<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<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vcmppd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVcmppd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vcmppd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl 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, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vcmpph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVcmpph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vcmpph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVcmpph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vcmpph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVcmpph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vcmpph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl 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, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vcmpps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVcmpps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vcmpps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVcmpps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vcmpps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVcmpps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vcmpps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVcmpps<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<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vcmpps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVcmpps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vcmpps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl 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<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 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 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<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 CodeAsmVcmptrue_uspd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrue_uspd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_uspd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrue_uspd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_uspd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrue_uspd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> 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<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrue_uspd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> 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, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrue_usph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_usph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrue_usph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_usps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrue_usps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_usps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrue_usps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_usps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrue_usps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> 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<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrue_usps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> 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<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrue_ussd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> 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_usss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrue_usss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_usss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrue_usss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmptruepd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptruepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmptruepd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmptruepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmptruepd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmptruepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmptruepd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptruepd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmptruepd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmptruepd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmptrueph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrueph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmptrueph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrueph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmptrueph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrueph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmptrueps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrueps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmptrueps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrueps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmptrueps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrueps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmptrueps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrueps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmptrueps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrueps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmptruesd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptruesd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmptruesd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptruesd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmptruesh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptruesh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmptruess<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptruess( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmptruess<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptruess( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> 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, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunord_spd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_spd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunord_spd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_spd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunord_spd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_spd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunord_spd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_sph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunord_sph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_sph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunord_sph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_sph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunord_sph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> 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, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunord_sps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_sps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunord_sps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_sps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunord_sps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_sps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunord_sps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_ssd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunord_ssd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> 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_ssh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunord_ssh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> 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<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunord_sss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpunordpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpunordpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpunordpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpunordpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpunordpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpunordph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpunordph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpunordph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpunordps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpunordps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpunordps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpunordps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpunordps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpunordsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpunordsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpunordsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpunordss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpunordss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcomisd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcomisd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcomish<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcomish( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcomiss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcomiss( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcompresspd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vcompresspd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcompresspd<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vcompresspd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcompresspd<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vcompresspd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcompressps<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vcompressps( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcompressps<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vcompressps( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcompressps<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vcompressps( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtdq2pd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtdq2pd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtdq2pd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtdq2pd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtdq2pd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtdq2pd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtdq2ph<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtdq2ph( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtdq2ph<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtdq2ph( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> 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<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtdq2ps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtdq2ps<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtdq2ps( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtne2ps2bf16<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtne2ps2bf16( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtne2ps2bf16<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtne2ps2bf16( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtne2ps2bf16<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtne2ps2bf16( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtneebf162ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtneebf162ps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtneebf162ps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtneebf162ps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtneeph2ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtneeph2ps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtneeph2ps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtneeph2ps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtneobf162ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtneobf162ps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtneobf162ps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtneobf162ps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtneoph2ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtneoph2ps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtneoph2ps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtneoph2ps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtneps2bf16<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtneps2bf16( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtneps2bf16<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtneps2bf16( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> 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<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtpd2dq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> 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 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<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtpd2ps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> 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<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtpd2qq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2qq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtpd2qq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2udq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtpd2udq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2udq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtpd2udq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> 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<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtpd2uqq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2uqq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtpd2uqq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2dq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2dq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2dq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2dq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2dq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2dq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2pd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2pd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2pd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2pd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2pd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2pd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2ps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2ps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2ps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2ps<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2ps( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2psx<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2psx( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2psx<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2psx( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2psx<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2psx( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2qq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2qq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2qq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2qq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2qq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2qq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2udq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2udq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2udq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2udq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2udq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2udq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2uqq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2uqq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2uqq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2uqq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2uqq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2uqq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2uw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2uw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2uw<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2uw( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2uw<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2uw( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2w<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2w( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2w<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2w( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2w<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2w( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtps2dq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtps2dq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtps2dq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtps2dq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtps2dq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtps2dq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtps2pd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtps2pd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtps2pd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtps2pd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtps2pd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtps2pd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtps2ph<AsmMemoryOperand, AsmRegisterXmm, i32> for CodeAssembler

fn vcvtps2ph( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVcvtps2ph<AsmMemoryOperand, AsmRegisterXmm, u32> for CodeAssembler

fn vcvtps2ph( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVcvtps2ph<AsmMemoryOperand, AsmRegisterYmm, i32> for CodeAssembler

fn vcvtps2ph( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVcvtps2ph<AsmMemoryOperand, AsmRegisterYmm, u32> for CodeAssembler

fn vcvtps2ph( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVcvtps2ph<AsmMemoryOperand, AsmRegisterZmm, i32> for CodeAssembler

fn vcvtps2ph( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVcvtps2ph<AsmMemoryOperand, AsmRegisterZmm, u32> for CodeAssembler

fn vcvtps2ph( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVcvtps2phx<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtps2phx( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtps2phx<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtps2phx( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> 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<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtps2qq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtps2qq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtps2qq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtps2udq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtps2udq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtps2udq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtps2udq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtps2udq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtps2udq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtps2uqq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtps2uqq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtps2uqq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtps2uqq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtps2uqq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtps2uqq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtqq2pd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtqq2pd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtqq2pd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtqq2pd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtqq2pd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtqq2pd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtqq2ph<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtqq2ph( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> 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<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtqq2ps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> 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 CodeAsmVcvtsd2si<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn vcvtsd2si( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtsd2si<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn vcvtsd2si( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtsd2ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtsd2ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtsd2usi<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn vcvtsd2usi( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtsd2usi<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn vcvtsd2usi( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtsh2sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtsh2sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtsh2si<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn vcvtsh2si( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtsh2si<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn vcvtsh2si( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtsh2ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtsh2ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtsh2usi<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn vcvtsh2usi( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtsh2usi<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn vcvtsh2usi( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtsi2sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtsi2sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtsi2sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtsi2sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtsi2ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtsi2ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtss2sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtss2sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtss2sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtss2sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtss2si<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn vcvtss2si( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtss2si<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn vcvtss2si( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtss2usi<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn vcvtss2usi( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtss2usi<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn vcvtss2usi( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttpd2dq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvttpd2dq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttpd2dq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvttpd2dq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> 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<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvttpd2qq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttpd2qq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvttpd2qq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttpd2udq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvttpd2udq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttpd2udq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvttpd2udq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> 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<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvttpd2uqq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttpd2uqq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvttpd2uqq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttph2dq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvttph2dq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttph2dq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvttph2dq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttph2dq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvttph2dq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttph2qq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvttph2qq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttph2qq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvttph2qq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttph2qq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvttph2qq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttph2udq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvttph2udq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttph2udq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvttph2udq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttph2udq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvttph2udq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttph2uqq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvttph2uqq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttph2uqq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvttph2uqq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttph2uqq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvttph2uqq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttph2uw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvttph2uw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttph2uw<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvttph2uw( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttph2uw<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvttph2uw( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttph2w<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvttph2w( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttph2w<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvttph2w( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttph2w<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvttph2w( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttps2dq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvttps2dq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttps2dq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvttps2dq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttps2dq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvttps2dq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttps2qq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvttps2qq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttps2qq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvttps2qq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttps2qq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvttps2qq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttps2udq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvttps2udq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttps2udq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvttps2udq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttps2udq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvttps2udq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttps2uqq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvttps2uqq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttps2uqq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvttps2uqq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttps2uqq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvttps2uqq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttsd2si<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn vcvttsd2si( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttsd2si<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn vcvttsd2si( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttsd2usi<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn vcvttsd2usi( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttsd2usi<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn vcvttsd2usi( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttsh2si<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn vcvttsh2si( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttsh2si<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn vcvttsh2si( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttsh2usi<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn vcvttsh2usi( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttsh2usi<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn vcvttsh2usi( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttss2si<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn vcvttss2si( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttss2si<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn vcvttss2si( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttss2usi<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn vcvttss2usi( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttss2usi<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn vcvttss2usi( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtudq2pd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtudq2pd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtudq2pd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtudq2pd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtudq2pd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtudq2pd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtudq2ph<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtudq2ph( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtudq2ph<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtudq2ph( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> 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<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtudq2ps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtudq2ps<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtudq2ps( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtuqq2pd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtuqq2pd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtuqq2pd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtuqq2pd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtuqq2pd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtuqq2pd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtuqq2ph<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtuqq2ph( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> 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<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtuqq2ps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> 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 CodeAsmVcvtusi2sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtusi2sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtusi2ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtusi2ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtuw2ph<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtuw2ph( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtuw2ph<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtuw2ph( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtuw2ph<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtuw2ph( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtw2ph<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtw2ph( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtw2ph<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtw2ph( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtw2ph<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtw2ph( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> 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<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vdbpsadbw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVdbpsadbw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vdbpsadbw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVdbpsadbw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vdbpsadbw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVdbpsadbw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vdbpsadbw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVdivpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vdivpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVdivpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vdivpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVdivpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vdivpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVdivph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vdivph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVdivph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vdivph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVdivph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vdivph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVdivps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vdivps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVdivps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vdivps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVdivps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vdivps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVdivsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vdivsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVdivsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vdivsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVdivss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vdivss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVdpbf16ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vdpbf16ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVdpbf16ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vdpbf16ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVdpbf16ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vdpbf16ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> 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 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<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vdpps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVdpps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vdpps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVerr<AsmMemoryOperand> for CodeAssembler

fn verr(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmVerw<AsmMemoryOperand> for CodeAssembler

fn verw(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmVexp2pd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vexp2pd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVexp2ps<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vexp2ps( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVexpandpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vexpandpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVexpandpd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vexpandpd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVexpandpd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vexpandpd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVexpandps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vexpandps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVexpandps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vexpandps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVexpandps<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vexpandps( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVextractf128<AsmMemoryOperand, AsmRegisterYmm, i32> for CodeAssembler

fn vextractf128( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVextractf128<AsmMemoryOperand, AsmRegisterYmm, u32> for CodeAssembler

fn vextractf128( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVextractf32x4<AsmMemoryOperand, AsmRegisterYmm, i32> for CodeAssembler

fn vextractf32x4( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVextractf32x4<AsmMemoryOperand, AsmRegisterYmm, u32> for CodeAssembler

fn vextractf32x4( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVextractf32x4<AsmMemoryOperand, AsmRegisterZmm, i32> for CodeAssembler

fn vextractf32x4( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVextractf32x4<AsmMemoryOperand, AsmRegisterZmm, u32> for CodeAssembler

fn vextractf32x4( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVextractf32x8<AsmMemoryOperand, AsmRegisterZmm, i32> for CodeAssembler

fn vextractf32x8( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVextractf32x8<AsmMemoryOperand, AsmRegisterZmm, u32> for CodeAssembler

fn vextractf32x8( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVextractf64x2<AsmMemoryOperand, AsmRegisterYmm, i32> for CodeAssembler

fn vextractf64x2( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVextractf64x2<AsmMemoryOperand, AsmRegisterYmm, u32> for CodeAssembler

fn vextractf64x2( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVextractf64x2<AsmMemoryOperand, AsmRegisterZmm, i32> for CodeAssembler

fn vextractf64x2( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVextractf64x2<AsmMemoryOperand, AsmRegisterZmm, u32> for CodeAssembler

fn vextractf64x2( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVextractf64x4<AsmMemoryOperand, AsmRegisterZmm, i32> for CodeAssembler

fn vextractf64x4( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVextractf64x4<AsmMemoryOperand, AsmRegisterZmm, u32> for CodeAssembler

fn vextractf64x4( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVextracti128<AsmMemoryOperand, AsmRegisterYmm, i32> for CodeAssembler

fn vextracti128( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVextracti128<AsmMemoryOperand, AsmRegisterYmm, u32> for CodeAssembler

fn vextracti128( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVextracti32x4<AsmMemoryOperand, AsmRegisterYmm, i32> for CodeAssembler

fn vextracti32x4( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVextracti32x4<AsmMemoryOperand, AsmRegisterYmm, u32> for CodeAssembler

fn vextracti32x4( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVextracti32x4<AsmMemoryOperand, AsmRegisterZmm, i32> for CodeAssembler

fn vextracti32x4( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVextracti32x4<AsmMemoryOperand, AsmRegisterZmm, u32> for CodeAssembler

fn vextracti32x4( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVextracti32x8<AsmMemoryOperand, AsmRegisterZmm, i32> for CodeAssembler

fn vextracti32x8( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVextracti32x8<AsmMemoryOperand, AsmRegisterZmm, u32> for CodeAssembler

fn vextracti32x8( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVextracti64x2<AsmMemoryOperand, AsmRegisterYmm, i32> for CodeAssembler

fn vextracti64x2( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVextracti64x2<AsmMemoryOperand, AsmRegisterYmm, u32> for CodeAssembler

fn vextracti64x2( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVextracti64x2<AsmMemoryOperand, AsmRegisterZmm, i32> for CodeAssembler

fn vextracti64x2( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVextracti64x2<AsmMemoryOperand, AsmRegisterZmm, u32> for CodeAssembler

fn vextracti64x2( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVextracti64x4<AsmMemoryOperand, AsmRegisterZmm, i32> for CodeAssembler

fn vextracti64x4( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVextracti64x4<AsmMemoryOperand, AsmRegisterZmm, u32> for CodeAssembler

fn vextracti64x4( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

impl 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 CodeAsmVfcmaddcph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfcmaddcph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfcmaddcph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfcmaddcph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfcmaddcph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfcmaddcph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfcmaddcsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfcmaddcsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfcmulcph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfcmulcph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfcmulcph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfcmulcph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfcmulcph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfcmulcph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfcmulcsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfcmulcsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> 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<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vfixupimmpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVfixupimmpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vfixupimmpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVfixupimmpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vfixupimmpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVfixupimmpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vfixupimmpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl 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<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vfixupimmps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVfixupimmps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vfixupimmps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVfixupimmps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vfixupimmps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVfixupimmps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vfixupimmps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl 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 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 CodeAsmVfmadd132pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd132pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmadd132pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd132pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmadd132pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd132pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmadd132ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd132ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmadd132ph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd132ph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmadd132ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd132ph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmadd132ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd132ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmadd132ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd132ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmadd132ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd132ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmadd132sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd132sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmadd132sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd132sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmadd132ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd132ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmadd213pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd213pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmadd213pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd213pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmadd213pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd213pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmadd213ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd213ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmadd213ph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd213ph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmadd213ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd213ph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmadd213ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd213ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmadd213ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd213ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmadd213ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd213ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmadd213sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd213sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmadd213sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd213sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmadd213ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd213ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmadd231pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd231pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmadd231pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd231pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmadd231pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd231pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmadd231ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd231ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmadd231ph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd231ph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmadd231ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd231ph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmadd231ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd231ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmadd231ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd231ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmadd231ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd231ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmadd231sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd231sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmadd231sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd231sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmadd231ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd231ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmaddcph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddcph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmaddcph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddcph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmaddcph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddcph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmaddcsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddcsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> 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<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vfmaddpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfmaddpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: AsmMemoryOperand, ) -> Result<(), IcedError>

impl 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<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vfmaddps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfmaddps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: AsmMemoryOperand, ) -> Result<(), IcedError>

impl 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 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 CodeAsmVfmaddsub132pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub132pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub132pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub132pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub132pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub132pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub132ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub132ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub132ph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub132ph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub132ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub132ph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub132ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub132ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub132ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub132ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub132ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub132ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub213pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub213pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub213pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub213pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub213pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub213pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub213ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub213ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub213ph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub213ph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub213ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub213ph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub213ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub213ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub213ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub213ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub213ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub213ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub231pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub231pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub231pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub231pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub231pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub231pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub231ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub231ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub231ph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub231ph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub231ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub231ph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub231ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub231ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub231ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub231ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub231ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub231ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> 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<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vfmaddsubpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsubpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsubpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: AsmMemoryOperand, ) -> Result<(), IcedError>

impl 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<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vfmaddsubps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsubps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsubps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsub132pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub132pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsub132pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub132pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsub132pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub132pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsub132ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub132ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsub132ph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub132ph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsub132ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub132ph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsub132ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub132ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsub132ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub132ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsub132ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub132ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsub132sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub132sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsub132sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub132sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsub132ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub132ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsub213pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub213pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsub213pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub213pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsub213pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub213pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsub213ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub213ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsub213ph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub213ph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsub213ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub213ph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsub213ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub213ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsub213ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub213ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsub213ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub213ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsub213sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub213sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsub213sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub213sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsub213ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub213ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsub231pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub231pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsub231pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub231pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsub231pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub231pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsub231ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub231ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsub231ph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub231ph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsub231ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub231ph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsub231ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub231ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsub231ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub231ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsub231ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub231ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsub231sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub231sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsub231sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub231sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsub231ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub231ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd132pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd132pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd132pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd132pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd132pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd132pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd132ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd132ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd132ph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd132ph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd132ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd132ph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd132ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd132ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd132ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd132ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd132ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd132ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd213pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd213pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd213pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd213pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd213pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd213pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd213ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd213ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd213ph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd213ph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd213ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd213ph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd213ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd213ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd213ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd213ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd213ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd213ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd231pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd231pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd231pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd231pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd231pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd231pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd231ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd231ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd231ph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd231ph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd231ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd231ph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd231ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd231ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd231ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd231ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd231ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd231ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> 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<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vfmsubaddpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsubaddpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubaddpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: AsmMemoryOperand, ) -> Result<(), IcedError>

impl 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<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vfmsubaddps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsubaddps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubaddps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: AsmMemoryOperand, ) -> Result<(), IcedError>

impl 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<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vfmsubpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsubpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: AsmMemoryOperand, ) -> Result<(), IcedError>

impl 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<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vfmsubps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsubps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: AsmMemoryOperand, ) -> Result<(), IcedError>

impl 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 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 CodeAsmVfmulcph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmulcph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmulcph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmulcph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmulcph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmulcph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmulcsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmulcsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd132pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd132pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd132pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd132pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd132pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd132pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd132ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd132ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd132ph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd132ph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd132ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd132ph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd132ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd132ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd132ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd132ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd132ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd132ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd132sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd132sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd132sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd132sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd132ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd132ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd213pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd213pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd213pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd213pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd213pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd213pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd213ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd213ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd213ph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd213ph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd213ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd213ph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd213ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd213ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd213ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd213ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd213ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd213ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd213sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd213sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd213sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd213sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd213ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd213ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd231pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd231pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd231pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd231pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd231pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd231pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd231ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd231ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd231ph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd231ph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd231ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd231ph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd231ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd231ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd231ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd231ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd231ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd231ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd231sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd231sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd231sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd231sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd231ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd231ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> 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<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vfnmaddpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmaddpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfnmaddpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: AsmMemoryOperand, ) -> Result<(), IcedError>

impl 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<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vfnmaddps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmaddps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfnmaddps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: AsmMemoryOperand, ) -> Result<(), IcedError>

impl 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 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 CodeAsmVfnmsub132pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub132pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub132pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub132pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub132pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub132pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub132ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub132ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub132ph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub132ph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub132ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub132ph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub132ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub132ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub132ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub132ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub132ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub132ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub132sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub132sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub132sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub132sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub132ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub132ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub213pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub213pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub213pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub213pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub213pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub213pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub213ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub213ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub213ph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub213ph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub213ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub213ph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub213ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub213ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub213ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub213ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub213ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub213ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub213sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub213sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub213sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub213sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub213ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub213ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub231pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub231pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub231pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub231pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub231pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub231pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub231ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub231ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub231ph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub231ph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub231ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub231ph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub231ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub231ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub231ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub231ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub231ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub231ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub231sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub231sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub231sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub231sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub231ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub231ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> 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<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vfnmsubpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmsubpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsubpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: AsmMemoryOperand, ) -> Result<(), IcedError>

impl 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<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vfnmsubps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmsubps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsubps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: AsmMemoryOperand, ) -> Result<(), IcedError>

impl 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 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 CodeAsmVfpclasspd<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

fn vfpclasspd( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVfpclasspd<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

fn vfpclasspd( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVfpclasspdx<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

fn vfpclasspdx( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVfpclasspdx<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

fn vfpclasspdx( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVfpclasspdy<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

fn vfpclasspdy( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVfpclasspdy<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

fn vfpclasspdy( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVfpclasspdz<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

fn vfpclasspdz( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVfpclasspdz<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

fn vfpclasspdz( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVfpclassph<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

fn vfpclassph( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVfpclassph<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

fn vfpclassph( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVfpclassphx<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

fn vfpclassphx( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVfpclassphx<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

fn vfpclassphx( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVfpclassphy<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

fn vfpclassphy( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVfpclassphy<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

fn vfpclassphy( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVfpclassphz<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

fn vfpclassphz( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVfpclassphz<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

fn vfpclassphz( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVfpclassps<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

fn vfpclassps( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVfpclassps<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

fn vfpclassps( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVfpclasspsx<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

fn vfpclasspsx( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVfpclasspsx<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

fn vfpclasspsx( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVfpclasspsy<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

fn vfpclasspsy( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVfpclasspsy<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

fn vfpclasspsy( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVfpclasspsz<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

fn vfpclasspsz( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVfpclasspsz<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

fn vfpclasspsz( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVfpclasssd<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

fn vfpclasssd( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVfpclasssd<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

fn vfpclasssd( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVfpclasssh<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

fn vfpclasssh( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVfpclasssh<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

fn vfpclasssh( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVfpclassss<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

fn vfpclassss( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVfpclassss<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

fn vfpclassss( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVfrczpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfrczpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfrczpd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfrczpd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfrczps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfrczps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfrczps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfrczps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfrczsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfrczsd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfrczss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfrczss( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVgatherdpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vgatherdpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVgatherdpd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vgatherdpd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVgatherdpd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vgatherdpd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVgatherdpd3<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vgatherdpd_3( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVgatherdpd3<AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vgatherdpd_3( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVgatherdps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vgatherdps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVgatherdps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vgatherdps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVgatherdps<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vgatherdps( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVgatherdps3<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vgatherdps_3( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVgatherdps3<AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vgatherdps_3( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVgatherpf0dpd<AsmMemoryOperand> for CodeAssembler

fn vgatherpf0dpd(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmVgatherpf0dps<AsmMemoryOperand> for CodeAssembler

fn vgatherpf0dps(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmVgatherpf0qpd<AsmMemoryOperand> for CodeAssembler

fn vgatherpf0qpd(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmVgatherpf0qps<AsmMemoryOperand> for CodeAssembler

fn vgatherpf0qps(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmVgatherpf1dpd<AsmMemoryOperand> for CodeAssembler

fn vgatherpf1dpd(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmVgatherpf1dps<AsmMemoryOperand> for CodeAssembler

fn vgatherpf1dps(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmVgatherpf1qpd<AsmMemoryOperand> for CodeAssembler

fn vgatherpf1qpd(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmVgatherpf1qps<AsmMemoryOperand> for CodeAssembler

fn vgatherpf1qps(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmVgatherqpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vgatherqpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVgatherqpd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vgatherqpd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVgatherqpd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vgatherqpd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVgatherqpd3<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vgatherqpd_3( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVgatherqpd3<AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vgatherqpd_3( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVgatherqps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vgatherqps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVgatherqps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vgatherqps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVgatherqps3<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vgatherqps_3( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVgetexppd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vgetexppd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVgetexppd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vgetexppd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVgetexppd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vgetexppd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVgetexpph<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vgetexpph( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVgetexpph<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vgetexpph( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVgetexpph<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vgetexpph( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVgetexpps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vgetexpps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVgetexpps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vgetexpps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVgetexpps<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vgetexpps( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVgetexpsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vgetexpsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVgetexpsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vgetexpsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVgetexpss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vgetexpss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> 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<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vgetmantpd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVgetmantpd<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vgetmantpd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVgetmantpd<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vgetmantpd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVgetmantpd<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vgetmantpd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl 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<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vgetmantph( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVgetmantph<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vgetmantph( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVgetmantph<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vgetmantph( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVgetmantph<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vgetmantph( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl 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<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vgetmantps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVgetmantps<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vgetmantps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVgetmantps<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vgetmantps( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVgetmantps<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vgetmantps( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl 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 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 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 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<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vgf2p8affineinvqb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVgf2p8affineinvqb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vgf2p8affineinvqb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVgf2p8affineinvqb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vgf2p8affineinvqb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVgf2p8affineinvqb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vgf2p8affineinvqb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl 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<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vgf2p8affineqb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVgf2p8affineqb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vgf2p8affineqb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVgf2p8affineqb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vgf2p8affineqb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVgf2p8affineqb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vgf2p8affineqb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVgf2p8mulb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vgf2p8mulb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVgf2p8mulb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vgf2p8mulb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVgf2p8mulb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vgf2p8mulb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVhaddpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vhaddpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVhaddpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vhaddpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVhaddps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vhaddps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVhaddps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vhaddps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVhsubpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vhsubpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVhsubpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vhsubpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVhsubps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vhsubps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVhsubps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vhsubps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVinsertf128<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vinsertf128( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVinsertf128<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vinsertf128( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVinsertf32x4<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vinsertf32x4( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVinsertf32x4<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vinsertf32x4( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVinsertf32x4<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vinsertf32x4( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVinsertf32x4<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vinsertf32x4( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVinsertf32x8<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vinsertf32x8( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVinsertf32x8<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vinsertf32x8( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVinsertf64x2<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vinsertf64x2( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVinsertf64x2<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vinsertf64x2( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVinsertf64x2<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vinsertf64x2( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVinsertf64x2<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vinsertf64x2( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVinsertf64x4<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vinsertf64x4( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVinsertf64x4<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vinsertf64x4( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVinserti128<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vinserti128( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVinserti128<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vinserti128( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVinserti32x4<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vinserti32x4( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVinserti32x4<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vinserti32x4( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVinserti32x4<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vinserti32x4( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVinserti32x4<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vinserti32x4( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVinserti32x8<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vinserti32x8( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVinserti32x8<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vinserti32x8( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVinserti64x2<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vinserti64x2( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVinserti64x2<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vinserti64x2( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVinserti64x2<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vinserti64x2( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVinserti64x2<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vinserti64x2( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVinserti64x4<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vinserti64x4( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVinserti64x4<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vinserti64x4( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl 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 CodeAsmVlddqu<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vlddqu( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVlddqu<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vlddqu( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVldmxcsr<AsmMemoryOperand> for CodeAssembler

fn vldmxcsr(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmVmaskmovpd<AsmMemoryOperand, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmaskmovpd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmaskmovpd<AsmMemoryOperand, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vmaskmovpd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVmaskmovpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmaskmovpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmaskmovpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vmaskmovpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmaskmovps<AsmMemoryOperand, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmaskmovps( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmaskmovps<AsmMemoryOperand, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vmaskmovps( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVmaskmovps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmaskmovps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmaskmovps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vmaskmovps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmaxpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmaxpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmaxpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vmaxpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmaxpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vmaxpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmaxph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmaxph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmaxph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vmaxph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmaxph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vmaxph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmaxps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmaxps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmaxps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vmaxps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmaxps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vmaxps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmaxsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmaxsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmaxsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmaxsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmaxss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmaxss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmclear<AsmMemoryOperand> for CodeAssembler

fn vmclear(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmVminpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vminpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVminpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vminpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVminpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vminpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVminph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vminph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVminph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vminph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVminph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vminph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVminps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vminps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVminps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vminps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVminps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vminps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVminsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vminsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVminsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vminsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVminss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vminss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovapd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovapd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmovapd<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vmovapd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVmovapd<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vmovapd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVmovapd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovapd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovapd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vmovapd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovapd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vmovapd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovaps<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovaps( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmovaps<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vmovaps( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVmovaps<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vmovaps( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVmovaps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovaps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovaps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vmovaps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovaps<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vmovaps( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmovd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovddup<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovddup( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovddup<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vmovddup( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovddup<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vmovddup( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovdqa<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovdqa( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmovdqa<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vmovdqa( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVmovdqa<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqa( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovdqa<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqa( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovdqa32<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovdqa32( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmovdqa32<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vmovdqa32( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVmovdqa32<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vmovdqa32( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVmovdqa32<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqa32( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovdqa32<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqa32( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovdqa32<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqa32( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovdqa64<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovdqa64( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmovdqa64<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vmovdqa64( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVmovdqa64<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vmovdqa64( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVmovdqa64<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqa64( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovdqa64<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqa64( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovdqa64<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqa64( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovdqu<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovdqu( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmovdqu<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vmovdqu( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVmovdqu<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqu( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovdqu<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqu( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovdqu16<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovdqu16( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmovdqu16<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vmovdqu16( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVmovdqu16<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vmovdqu16( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVmovdqu16<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqu16( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovdqu16<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqu16( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovdqu16<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqu16( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovdqu32<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovdqu32( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmovdqu32<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vmovdqu32( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVmovdqu32<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vmovdqu32( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVmovdqu32<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqu32( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovdqu32<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqu32( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovdqu32<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqu32( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovdqu64<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovdqu64( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmovdqu64<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vmovdqu64( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVmovdqu64<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vmovdqu64( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVmovdqu64<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqu64( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovdqu64<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqu64( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovdqu64<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqu64( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovdqu8<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovdqu8( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmovdqu8<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vmovdqu8( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVmovdqu8<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vmovdqu8( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVmovdqu8<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqu8( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovdqu8<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqu8( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovdqu8<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqu8( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> 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 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 CodeAsmVmovntdq<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovntdq( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmovntdq<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vmovntdq( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVmovntdq<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vmovntdq( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVmovntdqa<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovntdqa( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovntdqa<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vmovntdqa( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovntdqa<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vmovntdqa( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovntpd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovntpd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmovntpd<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vmovntpd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVmovntpd<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vmovntpd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVmovntps<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovntps( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmovntps<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vmovntps( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVmovntps<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vmovntps( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVmovq<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovq( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmovq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> 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 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 CodeAsmVmovshdup<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovshdup( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovshdup<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vmovshdup( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovshdup<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vmovshdup( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovsldup<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovsldup( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovsldup<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vmovsldup( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovsldup<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vmovsldup( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> 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 CodeAsmVmovupd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovupd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmovupd<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vmovupd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVmovupd<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vmovupd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVmovupd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovupd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovupd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vmovupd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovupd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vmovupd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovups<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovups( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmovups<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vmovups( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVmovups<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vmovups( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVmovups<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovups( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovups<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vmovups( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovups<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vmovups( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovw<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovw( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmovw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> 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<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vmpsadbw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVmpsadbw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vmpsadbw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVmptrld<AsmMemoryOperand> for CodeAssembler

fn vmptrld(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmVmptrst<AsmMemoryOperand> for CodeAssembler

fn vmptrst(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmVmread<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn vmread( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmVmread<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn vmread( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmVmulpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmulpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmulpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vmulpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmulpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vmulpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmulph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmulph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmulph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vmulph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmulph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vmulph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmulps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmulps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmulps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vmulps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmulps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vmulps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmulsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmulsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmulsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmulsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmulss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmulss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmwrite<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn vmwrite( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmwrite<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn vmwrite( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmxon<AsmMemoryOperand> for CodeAssembler

fn vmxon(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmVorpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vorpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVorpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vorpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVorpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vorpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVorps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vorps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVorps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vorps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVorps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vorps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVp2intersectd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vp2intersectd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVp2intersectd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vp2intersectd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVp2intersectd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vp2intersectd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVp2intersectq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vp2intersectq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVp2intersectq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vp2intersectq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVp2intersectq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vp2intersectq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVp4dpwssd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vp4dpwssd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVp4dpwssds<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vp4dpwssds( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpabsb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpabsb( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpabsb<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpabsb( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpabsb<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpabsb( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpabsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpabsd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpabsd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpabsd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpabsd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpabsd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpabsq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpabsq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpabsq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpabsq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpabsq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpabsq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpabsw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpabsw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpabsw<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpabsw( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpabsw<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpabsw( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpackssdw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpackssdw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpackssdw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpackssdw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpackssdw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpackssdw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpacksswb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpacksswb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpacksswb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpacksswb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpacksswb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpacksswb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpackusdw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpackusdw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpackusdw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpackusdw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpackusdw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpackusdw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpackuswb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpackuswb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpackuswb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpackuswb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpackuswb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpackuswb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpaddb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpaddb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpaddb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpaddb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpaddb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpaddb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpaddd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpaddd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpaddd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpaddd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpaddd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpaddd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpaddq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpaddq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpaddq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpaddq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpaddq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpaddq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpaddsb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpaddsb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpaddsb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpaddsb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpaddsb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpaddsb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpaddsw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpaddsw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpaddsw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpaddsw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpaddsw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpaddsw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpaddusb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpaddusb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpaddusb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpaddusb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpaddusb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpaddusb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpaddusw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpaddusw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpaddusw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpaddusw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpaddusw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpaddusw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpaddw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpaddw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpaddw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpaddw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpaddw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpaddw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> 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<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpalignr( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpalignr<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpalignr( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpalignr<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpalignr( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpalignr<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpalignr( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpand<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpand( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpand<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpand( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpandd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpandd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpandd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpandd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpandd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpandd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpandn<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpandn( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpandn<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpandn( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpandnd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpandnd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpandnd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpandnd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpandnd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpandnd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpandnq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpandnq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpandnq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpandnq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpandnq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpandnq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpandq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpandq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpandq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpandq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpandq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpandq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpavgb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpavgb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpavgb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpavgb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpavgb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpavgb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpavgw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpavgw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpavgw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpavgw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpavgw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpavgw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> 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<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpblendd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpblendd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpblendd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpblendmb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpblendmb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpblendmb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpblendmb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpblendmb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpblendmb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpblendmd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpblendmd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpblendmd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpblendmd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpblendmd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpblendmd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpblendmq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpblendmq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpblendmq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpblendmq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpblendmq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpblendmq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpblendmw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpblendmw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpblendmw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpblendmw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpblendmw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpblendmw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> 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<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpblendvb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpblendw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpblendw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpblendw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpblendw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpblendw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpblendw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpblendw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpblendw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpbroadcastb( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastb<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpbroadcastb( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastb<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpbroadcastb( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpbroadcastd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpbroadcastd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpbroadcastd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpbroadcastq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpbroadcastq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpbroadcastq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpbroadcastw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastw<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpbroadcastw( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastw<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpbroadcastw( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpclmulhqhqdq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpclmulhqhqdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpclmulhqhqdq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpclmulhqhqdq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpclmulhqhqdq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpclmulhqhqdq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpclmulhqlqdq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpclmulhqlqdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpclmulhqlqdq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpclmulhqlqdq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpclmulhqlqdq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpclmulhqlqdq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpclmullqhqdq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpclmullqhqdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpclmullqhqdq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpclmullqhqdq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpclmullqhqdq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpclmullqhqdq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpclmullqlqdq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpclmullqlqdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpclmullqlqdq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpclmullqlqdq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpclmullqlqdq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpclmullqlqdq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> 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<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpclmulqdq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpclmulqdq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpclmulqdq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpclmulqdq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpclmulqdq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpclmulqdq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpclmulqdq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl 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<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpcmov( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmov<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmov( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: AsmMemoryOperand, ) -> Result<(), IcedError>

impl 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, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl 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, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpequb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpequb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpequb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpequb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpequb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpequb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpequd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpequd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpequd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpequd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpequd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpequd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpequq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpequq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpequq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpequq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpequq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpequq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpequw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpequw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpequw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpequw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpequw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpequw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> 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 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 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 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 CodeAsmVpcmpfalseb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalsed<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalsed( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalsed<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalsed( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalsed<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalsed( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseub<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseub( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseub<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseub( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseub<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseub( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseud<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseud( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseud<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseud( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseud<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseud( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseuq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseuq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseuq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseuw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseuw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseuw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalsew<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalsew( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalsew<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalsew( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalsew<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalsew( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> 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 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 CodeAsmVpcmpleb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpleb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpleb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpled<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpled( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpled<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpled( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpled<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpled( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpleq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpleq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpleq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpleub<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleub( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpleub<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleub( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpleub<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleub( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpleud<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleud( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpleud<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleud( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpleud<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleud( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpleuq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpleuq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpleuq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpleuw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpleuw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpleuw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmplew<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmplew( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmplew<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmplew( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmplew<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmplew( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpltb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpltb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpltb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpltd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpltd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpltd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpltq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpltq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpltq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpltub<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltub( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpltub<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltub( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpltub<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltub( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpltud<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltud( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpltud<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltud( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpltud<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltud( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpltuq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpltuq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpltuq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpltuw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpltuw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpltuw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpltw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpltw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpltw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpneqb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpneqb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpneqb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpneqb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpneqb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpneqb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpneqd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpneqd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpneqd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpneqd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpneqd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpneqd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpneqq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpneqq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpneqq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpneqq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpneqq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpneqq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnequb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnequb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnequb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnequb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnequb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnequb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnequd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnequd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnequd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnequd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnequd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnequd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnequq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnequq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnequq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnequq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnequq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnequq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnequw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnequw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnequw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnequw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnequw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnequw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpneqw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpneqw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpneqw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpneqw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpneqw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpneqw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnled<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnled( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnled<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnled( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnled<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnled( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleub<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleub( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleub<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleub( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleub<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleub( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleud<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleud( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleud<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleud( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleud<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleud( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleuq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleuq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleuq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleuw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleuw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleuw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnlew<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnlew( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnlew<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnlew( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnlew<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnlew( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltub<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltub( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltub<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltub( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltub<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltub( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltud<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltud( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltud<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltud( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltud<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltud( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltuq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltuq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltuq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltuw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltuw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltuw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> 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, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmptrued<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrued( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmptrued<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrued( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmptrued<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrued( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueub<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueub( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueub<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueub( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueub<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueub( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueud<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueud( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueud<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueud( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueud<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueud( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueuq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueuq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueuq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueuw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueuw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueuw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmptruew<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptruew( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmptruew<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptruew( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmptruew<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptruew( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> 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, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpub( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpub<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpub( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpub<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpub( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpub<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpub( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl 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, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpud( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpud<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpud( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpud<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpud( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpud<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpud( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl 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, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpuq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpuq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpuq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl 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, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpuw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpuw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpuw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl 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, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl 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 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 CodeAsmVpcomeqb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomeqb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomeqd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomeqd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomeqq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomeqq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomequb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomequb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomequd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomequd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomequq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomequq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomequw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomequw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomeqw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomeqw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomfalseb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomfalseb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomfalsed<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomfalsed( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomfalseq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomfalseq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomfalseub<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomfalseub( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomfalseud<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomfalseud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomfalseuq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomfalseuq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomfalseuw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomfalseuw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomfalsew<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomfalsew( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomgeb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomgeb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomged<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomged( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomgeq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomgeq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomgeub<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomgeub( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomgeud<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomgeud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomgeuq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomgeuq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomgeuw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomgeuw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomgew<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomgew( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomgtb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomgtb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomgtd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomgtd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomgtq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomgtq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomgtub<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomgtub( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomgtud<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomgtud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomgtuq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomgtuq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomgtuw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomgtuw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomgtw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomgtw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomleb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomleb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomled<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomled( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomleq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomleq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomleub<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomleub( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomleud<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomleud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomleuq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomleuq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomleuw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomleuw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomlew<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomlew( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomltb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomltb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomltd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomltd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomltq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomltq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomltub<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomltub( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomltud<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomltud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomltuq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomltuq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomltuw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomltuw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomltw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomltw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomneqb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomneqb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomneqd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomneqd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomneqq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomneqq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomnequb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomnequb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomnequd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomnequd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomnequq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomnequq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomnequw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomnequw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomneqw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomneqw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcompressb<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpcompressb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcompressb<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpcompressb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcompressb<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpcompressb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcompressd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpcompressd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcompressd<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpcompressd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcompressd<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpcompressd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcompressq<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpcompressq( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcompressq<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpcompressq( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcompressq<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpcompressq( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcompressw<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpcompressw( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcompressw<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpcompressw( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcompressw<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpcompressw( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl 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 CodeAsmVpcomtrueb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomtrueb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomtrued<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomtrued( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomtrueq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomtrueq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomtrueub<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomtrueub( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomtrueud<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomtrueud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomtrueuq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomtrueuq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomtrueuw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomtrueuw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomtruew<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomtruew( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> 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 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 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 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 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 CodeAsmVpconflictd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpconflictd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpconflictd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpconflictd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpconflictd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpconflictd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpconflictq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpconflictq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpconflictq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpconflictq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpconflictq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpconflictq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpdpbssd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpdpbssd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpdpbssd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpdpbssd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpdpbssds<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpdpbssds( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpdpbssds<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpdpbssds( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpdpbsud<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpdpbsud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpdpbsud<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpdpbsud( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpdpbsuds<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpdpbsuds( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpdpbsuds<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpdpbsuds( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpdpbusd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpdpbusd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpdpbusd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpdpbusd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpdpbusd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpdpbusd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpdpbusds<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpdpbusds( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpdpbusds<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpdpbusds( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpdpbusds<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpdpbusds( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpdpbuud<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpdpbuud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpdpbuud<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpdpbuud( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpdpbuuds<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpdpbuuds( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpdpbuuds<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpdpbuuds( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpdpwssd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpdpwssd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpdpwssd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpdpwssd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpdpwssd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpdpwssd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpdpwssds<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpdpwssds( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpdpwssds<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpdpwssds( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpdpwssds<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpdpwssds( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpdpwsud<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpdpwsud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpdpwsud<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpdpwsud( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpdpwsuds<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpdpwsuds( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpdpwsuds<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpdpwsuds( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpdpwusd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpdpwusd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpdpwusd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpdpwusd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpdpwusds<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpdpwusds( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpdpwusds<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpdpwusds( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpdpwuud<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpdpwuud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpdpwuud<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpdpwuud( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpdpwuuds<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpdpwuuds( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpdpwuuds<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpdpwuuds( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVperm2f128<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vperm2f128( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVperm2f128<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vperm2f128( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVperm2i128<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vperm2i128( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVperm2i128<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vperm2i128( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpermb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpermb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpermb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpermb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpermd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpermd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermi2b<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpermi2b( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermi2b<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpermi2b( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermi2b<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpermi2b( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermi2d<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpermi2d( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermi2d<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpermi2d( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermi2d<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpermi2d( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermi2pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpermi2pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermi2pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpermi2pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermi2pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpermi2pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermi2ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpermi2ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermi2ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpermi2ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermi2ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpermi2ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermi2q<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpermi2q( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermi2q<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpermi2q( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermi2q<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpermi2q( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermi2w<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpermi2w( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermi2w<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpermi2w( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermi2w<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpermi2w( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> 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<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm, i32> for CodeAssembler

fn vpermil2pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: AsmRegisterYmm, op4: i32, ) -> Result<(), IcedError>

impl CodeAsmVpermil2pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm, u32> for CodeAssembler

fn vpermil2pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: AsmRegisterYmm, op4: u32, ) -> Result<(), IcedError>

impl CodeAsmVpermil2pd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpermil2pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: AsmMemoryOperand, op4: i32, ) -> Result<(), IcedError>

impl CodeAsmVpermil2pd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpermil2pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: AsmMemoryOperand, op4: u32, ) -> Result<(), IcedError>

impl 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<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm, i32> for CodeAssembler

fn vpermil2ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: AsmRegisterYmm, op4: i32, ) -> Result<(), IcedError>

impl CodeAsmVpermil2ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm, u32> for CodeAssembler

fn vpermil2ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: AsmRegisterYmm, op4: u32, ) -> Result<(), IcedError>

impl CodeAsmVpermil2ps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpermil2ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: AsmMemoryOperand, op4: i32, ) -> Result<(), IcedError>

impl CodeAsmVpermil2ps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpermil2ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: AsmMemoryOperand, op4: u32, ) -> Result<(), IcedError>

impl 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<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpermilpd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpermilpd<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpermilpd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpermilpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpermilpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermilpd<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpermilpd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpermilpd<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpermilpd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpermilpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpermilpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl 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<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpermilps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpermilps<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpermilps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpermilps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpermilps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermilps<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpermilps( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpermilps<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpermilps( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpermilps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpermilps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermpd<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpermpd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpermpd<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpermpd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpermpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpermpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermpd<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpermpd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpermpd<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpermpd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpermpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpermpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpermps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpermps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermq<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpermq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpermq<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpermq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpermq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpermq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermq<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpermq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpermq<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpermq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpermq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpermq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermt2b<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpermt2b( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermt2b<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpermt2b( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermt2b<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpermt2b( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermt2d<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpermt2d( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermt2d<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpermt2d( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermt2d<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpermt2d( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermt2pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpermt2pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermt2pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpermt2pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermt2pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpermt2pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermt2ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpermt2ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermt2ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpermt2ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermt2ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpermt2ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermt2q<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpermt2q( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermt2q<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpermt2q( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermt2q<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpermt2q( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermt2w<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpermt2w( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermt2w<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpermt2w( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermt2w<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpermt2w( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpermw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpermw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpermw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpexpandb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpexpandb( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpexpandb<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpexpandb( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpexpandb<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpexpandb( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpexpandd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpexpandd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpexpandd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpexpandd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpexpandd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpexpandd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpexpandq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpexpandq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpexpandq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpexpandq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpexpandq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpexpandq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpexpandw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpexpandw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpexpandw<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpexpandw( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpexpandw<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpexpandw( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> 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 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 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 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 CodeAsmVpgatherdd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpgatherdd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpgatherdd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpgatherdd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpgatherdd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpgatherdd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpgatherdd3<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpgatherdd_3( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpgatherdd3<AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpgatherdd_3( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpgatherdq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpgatherdq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpgatherdq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpgatherdq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpgatherdq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpgatherdq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpgatherdq3<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpgatherdq_3( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpgatherdq3<AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpgatherdq_3( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpgatherqd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpgatherqd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpgatherqd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpgatherqd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpgatherqd3<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpgatherqd_3( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpgatherqq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpgatherqq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpgatherqq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpgatherqq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpgatherqq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpgatherqq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpgatherqq3<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpgatherqq_3( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpgatherqq3<AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpgatherqq_3( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVphaddbd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphaddbd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVphaddbq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphaddbq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVphaddbw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphaddbw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVphaddd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphaddd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVphaddd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vphaddd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVphadddq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphadddq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVphaddsw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphaddsw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVphaddsw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vphaddsw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVphaddubd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphaddubd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVphaddubq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphaddubq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVphaddubw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphaddubw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVphaddudq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphaddudq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVphadduwd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphadduwd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVphadduwq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphadduwq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVphaddw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphaddw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVphaddw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vphaddw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVphaddwd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphaddwd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVphaddwq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphaddwq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVphminposuw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphminposuw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVphsubbw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphsubbw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVphsubd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphsubd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVphsubd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vphsubd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVphsubdq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphsubdq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVphsubsw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphsubsw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVphsubsw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vphsubsw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVphsubw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphsubw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVphsubw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vphsubw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVphsubwd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphsubwd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> 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 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 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 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 CodeAsmVplzcntd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vplzcntd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVplzcntd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vplzcntd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVplzcntd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vplzcntd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVplzcntq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vplzcntq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVplzcntq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vplzcntq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVplzcntq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vplzcntq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> 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 CodeAsmVpmacsdqh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmacsdqh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, 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 CodeAsmVpmacssdd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmacssdd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, 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 CodeAsmVpmacssdql<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmacssdql( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, 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 CodeAsmVpmacssww<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmacssww( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, 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 CodeAsmVpmacsww<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmacsww( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, 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 CodeAsmVpmadcswd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmadcswd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, 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<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmadd52huq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmadd52huq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmadd52huq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmadd52luq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmadd52luq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmadd52luq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmadd52luq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmadd52luq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmadd52luq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmaddubsw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmaddubsw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmaddubsw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmaddubsw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmaddubsw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmaddubsw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmaddwd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmaddwd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmaddwd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmaddwd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmaddwd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmaddwd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmaskmovd<AsmMemoryOperand, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmaskmovd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmaskmovd<AsmMemoryOperand, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpmaskmovd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmaskmovd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmaskmovd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmaskmovd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmaskmovd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmaskmovq<AsmMemoryOperand, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmaskmovq( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmaskmovq<AsmMemoryOperand, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpmaskmovq( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmaskmovq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmaskmovq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmaskmovq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmaskmovq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmaxsb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxsb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmaxsb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxsb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmaxsb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxsb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmaxsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmaxsd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxsd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmaxsd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxsd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmaxsq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxsq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmaxsq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxsq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmaxsq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxsq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmaxsw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxsw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmaxsw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxsw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmaxsw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxsw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmaxub<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxub( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmaxub<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxub( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmaxub<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxub( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmaxud<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmaxud<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxud( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmaxud<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxud( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmaxuq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxuq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmaxuq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxuq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmaxuq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxuq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmaxuw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxuw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmaxuw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxuw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmaxuw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxuw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpminsb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpminsb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpminsb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpminsb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpminsb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpminsb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpminsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpminsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpminsd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpminsd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpminsd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpminsd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpminsq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpminsq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpminsq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpminsq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpminsq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpminsq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpminsw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpminsw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpminsw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpminsw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpminsw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpminsw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpminub<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpminub( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpminub<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpminub( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpminub<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpminub( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpminud<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpminud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpminud<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpminud( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpminud<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpminud( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpminuq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpminuq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpminuq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpminuq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpminuq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpminuq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpminuw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpminuw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpminuw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpminuw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpminuw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpminuw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmovdb<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmovdb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovdb<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpmovdb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovdb<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpmovdb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovdw<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmovdw( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovdw<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpmovdw( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovdw<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpmovdw( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovqb<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmovqb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovqb<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpmovqb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovqb<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpmovqb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovqd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmovqd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovqd<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpmovqd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovqd<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpmovqd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovqw<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmovqw( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovqw<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpmovqw( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovqw<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpmovqw( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovsdb<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmovsdb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovsdb<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpmovsdb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovsdb<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpmovsdb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovsdw<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmovsdw( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovsdw<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpmovsdw( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovsdw<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpmovsdw( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovsqb<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmovsqb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovsqb<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpmovsqb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovsqb<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpmovsqb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovsqd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmovsqd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovsqd<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpmovsqd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovsqd<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpmovsqd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovsqw<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmovsqw( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovsqw<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpmovsqw( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovsqw<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpmovsqw( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovswb<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmovswb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovswb<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpmovswb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovswb<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpmovswb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovsxbd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmovsxbd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmovsxbd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmovsxbd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmovsxbd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmovsxbd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmovsxbq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmovsxbq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmovsxbq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmovsxbq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmovsxbq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmovsxbq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmovsxbw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmovsxbw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmovsxbw<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmovsxbw( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmovsxbw<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmovsxbw( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmovsxdq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmovsxdq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmovsxdq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmovsxdq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmovsxdq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmovsxdq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmovsxwd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmovsxwd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmovsxwd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmovsxwd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmovsxwd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmovsxwd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmovsxwq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmovsxwq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmovsxwq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmovsxwq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmovsxwq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmovsxwq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmovusdb<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmovusdb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovusdb<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpmovusdb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovusdb<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpmovusdb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovusdw<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmovusdw( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovusdw<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpmovusdw( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovusdw<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpmovusdw( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovusqb<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmovusqb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovusqb<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpmovusqb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovusqb<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpmovusqb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovusqd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmovusqd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovusqd<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpmovusqd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovusqd<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpmovusqd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovusqw<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmovusqw( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovusqw<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpmovusqw( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovusqw<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpmovusqw( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovuswb<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmovuswb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovuswb<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpmovuswb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovuswb<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpmovuswb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovwb<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmovwb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovwb<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpmovwb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovwb<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpmovwb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovzxbd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmovzxbd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmovzxbd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmovzxbd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmovzxbd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmovzxbd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmovzxbq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmovzxbq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmovzxbq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmovzxbq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmovzxbq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmovzxbq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmovzxbw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmovzxbw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmovzxbw<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmovzxbw( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmovzxbw<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmovzxbw( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmovzxdq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmovzxdq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmovzxdq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmovzxdq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmovzxdq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmovzxdq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmovzxwd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmovzxwd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmovzxwd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmovzxwd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmovzxwd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmovzxwd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmovzxwq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmovzxwq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmovzxwq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmovzxwq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmovzxwq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmovzxwq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmuldq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmuldq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmuldq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmuldq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmuldq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmuldq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmulhrsw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmulhrsw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmulhrsw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmulhrsw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmulhrsw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmulhrsw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmulhuw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmulhuw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmulhuw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmulhuw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmulhuw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmulhuw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmulhw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmulhw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmulhw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmulhw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmulhw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmulhw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmulld<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmulld( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmulld<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmulld( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmulld<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmulld( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmullq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmullq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmullq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmullq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmullq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmullq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmullw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmullw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmullw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmullw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmullw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmullw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmultishiftqb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmultishiftqb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmultishiftqb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmultishiftqb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmultishiftqb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmultishiftqb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmuludq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmuludq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmuludq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmuludq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmuludq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmuludq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpopcntb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpopcntb( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpopcntb<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpopcntb( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpopcntb<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpopcntb( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpopcntd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpopcntd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpopcntd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpopcntd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpopcntd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpopcntd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpopcntq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpopcntq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpopcntq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpopcntq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpopcntq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpopcntq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpopcntw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpopcntw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpopcntw<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpopcntw( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpopcntw<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpopcntw( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpor<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpor( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpor<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpor( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpord<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpord( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpord<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpord( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpord<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpord( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVporq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vporq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVporq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vporq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVporq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vporq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> 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 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<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vprold( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVprold<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vprold( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVprold<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vprold( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVprold<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vprold( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl 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<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vprolq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVprolq<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vprolq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVprolq<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vprolq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVprolq<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vprolq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVprolvd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vprolvd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVprolvd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vprolvd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVprolvd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vprolvd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVprolvq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vprolvq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVprolvq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vprolvq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVprolvq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vprolvq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> 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<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vprord( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVprord<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vprord( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVprord<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vprord( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVprord<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vprord( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl 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<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vprorq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVprorq<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vprorq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVprorq<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vprorq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVprorq<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vprorq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVprorvd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vprorvd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVprorvd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vprorvd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVprorvd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vprorvd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVprorvq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vprorvq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVprorvq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vprorvq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVprorvq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vprorvq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> 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 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 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 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 CodeAsmVpsadbw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsadbw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsadbw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsadbw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsadbw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsadbw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpscatterdd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpscatterdd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpscatterdd<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpscatterdd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpscatterdd<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpscatterdd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpscatterdq<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpscatterdq( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpscatterdq<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpscatterdq( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpscatterdq<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpscatterdq( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpscatterqd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpscatterqd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpscatterqd<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpscatterqd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpscatterqq<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpscatterqq( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpscatterqq<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpscatterqq( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpscatterqq<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpscatterqq( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpshab<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpshab( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpshab<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpshab( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl 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 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 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 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 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 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<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshldd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpshldd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshldd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpshldd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshldd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpshldd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshldd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl 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<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshldq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpshldq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshldq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpshldq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshldq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpshldq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshldq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpshldvd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpshldvd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpshldvd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpshldvd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpshldvd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpshldvd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpshldvq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpshldvq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpshldvq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpshldvq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpshldvq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpshldvq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpshldvw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpshldvw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpshldvw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpshldvw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpshldvw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpshldvw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> 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<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshldw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpshldw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshldw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpshldw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshldw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpshldw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshldw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl 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 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 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<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshrdd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpshrdd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshrdd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpshrdd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshrdd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpshrdd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshrdd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl 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<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshrdq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpshrdq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshrdq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpshrdq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshrdq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpshrdq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshrdq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpshrdvd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpshrdvd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpshrdvd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpshrdvd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpshrdvd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpshrdvd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpshrdvq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpshrdvq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpshrdvq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpshrdvq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpshrdvq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpshrdvq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpshrdvw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpshrdvw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpshrdvw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpshrdvw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpshrdvw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpshrdvw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> 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<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshrdw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpshrdw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshrdw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpshrdw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshrdw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpshrdw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshrdw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpshufb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpshufb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpshufb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpshufb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpshufb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpshufb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpshufbitqmb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpshufbitqmb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpshufbitqmb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpshufbitqmb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpshufbitqmb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpshufbitqmb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> 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<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshufd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpshufd<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshufd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpshufd<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshufd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpshufd<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshufd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl 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<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshufhw( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpshufhw<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshufhw( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpshufhw<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshufhw( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpshufhw<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshufhw( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl 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<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshuflw( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpshuflw<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshuflw( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpshuflw<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshuflw( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpshuflw<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshuflw( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsignb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsignb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsignb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsignb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsignd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsignd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsignd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsignd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsignw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsignw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsignw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsignw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> 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<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpslld( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpslld<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpslld( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpslld<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpslld( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpslld<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpslld( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpslld<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpslld( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpslld<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpslld( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl 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<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpslldq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpslldq<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpslldq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpslldq<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpslldq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpslldq<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpslldq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl 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<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsllq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpsllq<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsllq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsllq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsllq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsllq<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsllq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpsllq<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsllq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsllq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsllq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsllvd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsllvd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsllvd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsllvd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsllvd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsllvd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsllvq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsllvq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsllvq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsllvq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsllvq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsllvq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsllvw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsllvw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsllvw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsllvw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsllvw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsllvw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> 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<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsllw( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpsllw<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsllw( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsllw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsllw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsllw<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsllw( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpsllw<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsllw( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsllw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsllw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl 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<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsrad( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpsrad<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsrad( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsrad<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsrad( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsrad<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsrad( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpsrad<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsrad( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsrad<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsrad( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl 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<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsraq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpsraq<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsraq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsraq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsraq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsraq<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsraq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpsraq<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsraq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsraq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsraq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsravd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsravd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsravd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsravd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsravd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsravd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsravq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsravq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsravq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsravq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsravq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsravq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsravw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsravw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsravw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsravw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsravw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsravw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> 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<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsraw( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpsraw<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsraw( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsraw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsraw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsraw<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsraw( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpsraw<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsraw( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsraw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsraw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl 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<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsrld( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpsrld<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsrld( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsrld<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsrld( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsrld<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsrld( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpsrld<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsrld( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsrld<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsrld( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl 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<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsrldq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpsrldq<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsrldq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsrldq<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsrldq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpsrldq<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsrldq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl 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<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsrlq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpsrlq<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsrlq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsrlq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsrlq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsrlq<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsrlq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpsrlq<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsrlq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsrlq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsrlq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsrlvd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsrlvd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsrlvd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsrlvd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsrlvd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsrlvd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsrlvq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsrlvq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsrlvq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsrlvq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsrlvq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsrlvq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsrlvw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsrlvw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsrlvw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsrlvw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsrlvw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsrlvw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> 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<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsrlw( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpsrlw<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsrlw( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsrlw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsrlw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsrlw<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsrlw( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpsrlw<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsrlw( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsrlw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsrlw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsubb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsubb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsubb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsubb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsubb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsubb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsubd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsubd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsubd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsubd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsubd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsubd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsubq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsubq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsubq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsubq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsubq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsubq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsubsb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsubsb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsubsb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsubsb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsubsb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsubsb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsubsw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsubsw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsubsw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsubsw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsubsw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsubsw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsubusb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsubusb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsubusb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsubusb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsubusb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsubusb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsubusw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsubusw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsubusw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsubusw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsubusw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsubusw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsubw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsubw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsubw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsubw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsubw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsubw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> 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<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpternlogd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpternlogd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpternlogd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpternlogd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpternlogd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpternlogd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpternlogd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl 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<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpternlogq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpternlogq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpternlogq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpternlogq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpternlogq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpternlogq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpternlogq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVptest<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vptest( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVptest<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vptest( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVptestmb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vptestmb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVptestmb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vptestmb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVptestmb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vptestmb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVptestmd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vptestmd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVptestmd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vptestmd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVptestmd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vptestmd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVptestmq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vptestmq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVptestmq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vptestmq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVptestmq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vptestmq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVptestmw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vptestmw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVptestmw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vptestmw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVptestmw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vptestmw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVptestnmb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vptestnmb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVptestnmb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vptestnmb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVptestnmb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vptestnmb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVptestnmd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vptestnmd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVptestnmd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vptestnmd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVptestnmd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vptestnmd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVptestnmq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vptestnmq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVptestnmq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vptestnmq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVptestnmq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vptestnmq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVptestnmw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vptestnmw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVptestnmw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vptestnmw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVptestnmw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vptestnmw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpunpckhbw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpunpckhbw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpunpckhbw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpunpckhbw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpunpckhbw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpunpckhbw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpunpckhdq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpunpckhdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpunpckhdq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpunpckhdq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpunpckhdq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpunpckhdq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpunpckhqdq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpunpckhqdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpunpckhqdq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpunpckhqdq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpunpckhqdq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpunpckhqdq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpunpckhwd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpunpckhwd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpunpckhwd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpunpckhwd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpunpckhwd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpunpckhwd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpunpcklbw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpunpcklbw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpunpcklbw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpunpcklbw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpunpcklbw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpunpcklbw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpunpckldq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpunpckldq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpunpckldq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpunpckldq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpunpckldq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpunpckldq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpunpcklqdq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpunpcklqdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpunpcklqdq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpunpcklqdq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpunpcklqdq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpunpcklqdq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpunpcklwd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpunpcklwd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpunpcklwd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpunpcklwd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpunpcklwd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpunpcklwd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpxor<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpxor( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpxor<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpxor( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpxord<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpxord( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpxord<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpxord( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpxord<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpxord( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpxorq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpxorq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpxorq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpxorq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpxorq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpxorq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> 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<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vrangepd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVrangepd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vrangepd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVrangepd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vrangepd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVrangepd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vrangepd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl 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<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vrangeps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVrangeps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vrangeps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVrangeps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vrangeps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVrangeps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vrangeps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl 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 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 CodeAsmVrcp14pd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrcp14pd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrcp14pd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vrcp14pd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrcp14pd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vrcp14pd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrcp14ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrcp14ps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrcp14ps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vrcp14ps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrcp14ps<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vrcp14ps( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrcp14sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrcp14sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrcp14ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrcp14ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrcp28pd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vrcp28pd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrcp28ps<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vrcp28ps( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrcp28sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrcp28sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrcp28ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrcp28ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrcpph<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrcpph( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrcpph<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vrcpph( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrcpph<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vrcpph( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrcpps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrcpps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrcpps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vrcpps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrcpsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrcpsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrcpss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrcpss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> 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<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vreducepd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVreducepd<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vreducepd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVreducepd<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vreducepd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVreducepd<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vreducepd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl 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<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vreduceph( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVreduceph<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vreduceph( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVreduceph<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vreduceph( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVreduceph<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vreduceph( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl 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<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vreduceps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVreduceps<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vreduceps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVreduceps<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vreduceps( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVreduceps<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vreduceps( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl 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 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 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 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<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vrndscalepd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVrndscalepd<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vrndscalepd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVrndscalepd<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vrndscalepd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVrndscalepd<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vrndscalepd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl 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<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vrndscaleph( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVrndscaleph<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vrndscaleph( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVrndscaleph<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vrndscaleph( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVrndscaleph<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vrndscaleph( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl 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<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vrndscaleps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVrndscaleps<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vrndscaleps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVrndscaleps<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vrndscaleps( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVrndscaleps<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vrndscaleps( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl 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 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 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 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<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vroundpd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVroundpd<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vroundpd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl 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<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vroundps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVroundps<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vroundps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl 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 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 CodeAsmVrsqrt14pd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrsqrt14pd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrsqrt14pd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vrsqrt14pd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrsqrt14pd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vrsqrt14pd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrsqrt14ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrsqrt14ps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrsqrt14ps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vrsqrt14ps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrsqrt14ps<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vrsqrt14ps( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrsqrt14sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrsqrt14sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrsqrt14ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrsqrt14ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrsqrt28pd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vrsqrt28pd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrsqrt28ps<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vrsqrt28ps( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrsqrt28sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrsqrt28sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrsqrt28ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrsqrt28ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrsqrtph<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrsqrtph( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrsqrtph<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vrsqrtph( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrsqrtph<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vrsqrtph( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrsqrtps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrsqrtps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrsqrtps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vrsqrtps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrsqrtsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrsqrtsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrsqrtss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrsqrtss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVscalefpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vscalefpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVscalefpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vscalefpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVscalefpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vscalefpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVscalefph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vscalefph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVscalefph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vscalefph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVscalefph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vscalefph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVscalefps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vscalefps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVscalefps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vscalefps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVscalefps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vscalefps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVscalefsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vscalefsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVscalefsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vscalefsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVscalefss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vscalefss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVscatterdpd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vscatterdpd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVscatterdpd<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vscatterdpd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVscatterdpd<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vscatterdpd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVscatterdps<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vscatterdps( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVscatterdps<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vscatterdps( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVscatterdps<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vscatterdps( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVscatterpf0dpd<AsmMemoryOperand> for CodeAssembler

fn vscatterpf0dpd(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmVscatterpf0dps<AsmMemoryOperand> for CodeAssembler

fn vscatterpf0dps(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmVscatterpf0qpd<AsmMemoryOperand> for CodeAssembler

fn vscatterpf0qpd(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmVscatterpf0qps<AsmMemoryOperand> for CodeAssembler

fn vscatterpf0qps(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmVscatterpf1dpd<AsmMemoryOperand> for CodeAssembler

fn vscatterpf1dpd(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmVscatterpf1dps<AsmMemoryOperand> for CodeAssembler

fn vscatterpf1dps(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmVscatterpf1qpd<AsmMemoryOperand> for CodeAssembler

fn vscatterpf1qpd(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmVscatterpf1qps<AsmMemoryOperand> for CodeAssembler

fn vscatterpf1qps(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmVscatterqpd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vscatterqpd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVscatterqpd<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vscatterqpd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVscatterqpd<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vscatterqpd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVscatterqps<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vscatterqps( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVscatterqps<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vscatterqps( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVshuff32x4<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vshuff32x4( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVshuff32x4<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vshuff32x4( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVshuff32x4<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vshuff32x4( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVshuff32x4<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vshuff32x4( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVshuff64x2<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vshuff64x2( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVshuff64x2<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vshuff64x2( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVshuff64x2<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vshuff64x2( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVshuff64x2<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vshuff64x2( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVshufi32x4<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vshufi32x4( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVshufi32x4<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vshufi32x4( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVshufi32x4<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vshufi32x4( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVshufi32x4<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vshufi32x4( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVshufi64x2<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vshufi64x2( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVshufi64x2<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vshufi64x2( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVshufi64x2<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vshufi64x2( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVshufi64x2<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vshufi64x2( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl 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<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vshufpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVshufpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vshufpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVshufpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vshufpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVshufpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vshufpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl 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<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vshufps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVshufps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vshufps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVshufps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vshufps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVshufps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vshufps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVsm3msg1<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vsm3msg1( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVsm3msg2<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vsm3msg2( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> 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 CodeAsmVsm4key4<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vsm4key4( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVsm4key4<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vsm4key4( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVsm4rnds4<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vsm4rnds4( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVsm4rnds4<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vsm4rnds4( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVsqrtpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vsqrtpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVsqrtpd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vsqrtpd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVsqrtpd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vsqrtpd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVsqrtph<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vsqrtph( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVsqrtph<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vsqrtph( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVsqrtph<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vsqrtph( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVsqrtps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vsqrtps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVsqrtps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vsqrtps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVsqrtps<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vsqrtps( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVsqrtsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vsqrtsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVsqrtsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vsqrtsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVsqrtss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vsqrtss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVstmxcsr<AsmMemoryOperand> for CodeAssembler

fn vstmxcsr(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmVsubpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vsubpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVsubpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vsubpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVsubpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vsubpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVsubph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vsubph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVsubph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vsubph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVsubph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vsubph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVsubps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vsubps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVsubps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vsubps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVsubps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vsubps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVsubsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vsubsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVsubsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vsubsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVsubss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vsubss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVtestpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vtestpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVtestpd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vtestpd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVtestps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vtestps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVtestps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vtestps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVucomisd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vucomisd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVucomish<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vucomish( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVucomiss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vucomiss( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVunpckhpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vunpckhpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVunpckhpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vunpckhpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVunpckhpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vunpckhpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVunpckhps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vunpckhps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVunpckhps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vunpckhps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVunpckhps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vunpckhps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVunpcklpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vunpcklpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVunpcklpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vunpcklpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVunpcklpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vunpcklpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVunpcklps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vunpcklps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVunpcklps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vunpcklps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVunpcklps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vunpcklps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVxorpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vxorpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVxorpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vxorpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVxorpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vxorpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVxorps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vxorps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVxorps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vxorps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVxorps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vxorps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmWrshr<AsmMemoryOperand> for CodeAssembler

fn wrshr(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmWrssd<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn wrssd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmWrssq<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn wrssq( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmWrussd<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn wrussd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmWrussq<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn wrussq( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmXadd<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn xadd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmXadd<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn xadd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmXadd<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn xadd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmXadd<AsmMemoryOperand, AsmRegister8> for CodeAssembler

fn xadd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmXbts<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn xbts( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmXbts<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn xbts( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmXchg<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn xchg( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmXchg<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn xchg( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmXchg<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn xchg( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmXchg<AsmMemoryOperand, AsmRegister8> for CodeAssembler

fn xchg( &mut self, op0: AsmMemoryOperand, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmXor<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn xor( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmXor<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn xor( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmXor<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn xor( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmXor<AsmMemoryOperand, AsmRegister8> for CodeAssembler

fn xor( &mut self, op0: AsmMemoryOperand, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmXor<AsmMemoryOperand, i32> for CodeAssembler

fn xor(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

impl CodeAsmXor<AsmMemoryOperand, u32> for CodeAssembler

fn xor(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

impl CodeAsmXor<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn xor( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmXor<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn xor( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmXor<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn xor( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmXor<AsmRegister8, AsmMemoryOperand> for CodeAssembler

fn xor( &mut self, op0: AsmRegister8, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmXorpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn xorpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmXorps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn xorps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmXrstor<AsmMemoryOperand> for CodeAssembler

fn xrstor(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmXrstor64<AsmMemoryOperand> for CodeAssembler

fn xrstor64(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmXrstors<AsmMemoryOperand> for CodeAssembler

fn xrstors(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmXrstors64<AsmMemoryOperand> for CodeAssembler

fn xrstors64(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmXsave<AsmMemoryOperand> for CodeAssembler

fn xsave(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmXsave64<AsmMemoryOperand> for CodeAssembler

fn xsave64(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmXsavec<AsmMemoryOperand> for CodeAssembler

fn xsavec(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmXsavec64<AsmMemoryOperand> for CodeAssembler

fn xsavec64(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmXsaveopt<AsmMemoryOperand> for CodeAssembler

fn xsaveopt(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmXsaveopt64<AsmMemoryOperand> for CodeAssembler

fn xsaveopt64(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmXsaves<AsmMemoryOperand> for CodeAssembler

fn xsaves(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmXsaves64<AsmMemoryOperand> for CodeAssembler

fn xsaves64(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl Debug for AsmMemoryOperand

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<CodeLabel> for AsmMemoryOperand

fn from(other: CodeLabel) -> Self

Converts to this type from the input type.

impl<R: Into<Register>> From<R> for AsmMemoryOperand

fn from(other: R) -> Self

Converts to this type from the input type.

impl From<i16> for AsmMemoryOperand

fn from(other: i16) -> Self

Converts to this type from the input type.

impl From<i32> for AsmMemoryOperand

fn from(other: i32) -> Self

Converts to this type from the input type.

impl From<i64> for AsmMemoryOperand

fn from(other: i64) -> Self

Converts to this type from the input type.

impl From<i8> for AsmMemoryOperand

fn from(other: i8) -> Self

Converts to this type from the input type.

impl From<isize> for AsmMemoryOperand

fn from(other: isize) -> Self

Converts to this type from the input type.

impl From<u16> for AsmMemoryOperand

fn from(other: u16) -> Self

Converts to this type from the input type.

impl From<u32> for AsmMemoryOperand

fn from(other: u32) -> Self

Converts to this type from the input type.

impl From<u64> for AsmMemoryOperand

fn from(other: u64) -> Self

Converts to this type from the input type.

impl From<u8> for AsmMemoryOperand

fn from(other: u8) -> Self

Converts to this type from the input type.

impl From<usize> for AsmMemoryOperand

fn from(other: usize) -> Self

Converts to this type from the input type.

impl PartialEq for AsmMemoryOperand

fn eq(&self, other: &AsmMemoryOperand) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Sub<i16> for AsmMemoryOperand

type Output = AsmMemoryOperand

The resulting type after applying the - operator.

fn sub(self, rhs: i16) -> Self::Output

Performs the - operation.

impl Sub<i32> for AsmMemoryOperand

type Output = AsmMemoryOperand

The resulting type after applying the - operator.

fn sub(self, rhs: i32) -> Self::Output

Performs the - operation.

impl Sub<i64> for AsmMemoryOperand

type Output = AsmMemoryOperand

The resulting type after applying the - operator.

fn sub(self, rhs: i64) -> Self::Output

Performs the - operation.

impl Sub<i8> for AsmMemoryOperand

type Output = AsmMemoryOperand

The resulting type after applying the - operator.

fn sub(self, rhs: i8) -> Self::Output

Performs the - operation.

impl Sub<isize> for AsmMemoryOperand

type Output = AsmMemoryOperand

The resulting type after applying the - operator.

fn sub(self, rhs: isize) -> Self::Output

Performs the - operation.

impl Sub<u16> for AsmMemoryOperand

type Output = AsmMemoryOperand

The resulting type after applying the - operator.

fn sub(self, rhs: u16) -> Self::Output

Performs the - operation.

impl Sub<u32> for AsmMemoryOperand

type Output = AsmMemoryOperand

The resulting type after applying the - operator.

fn sub(self, rhs: u32) -> Self::Output

Performs the - operation.

impl Sub<u64> for AsmMemoryOperand

type Output = AsmMemoryOperand

The resulting type after applying the - operator.

fn sub(self, rhs: u64) -> Self::Output

Performs the - operation.

impl Sub<u8> for AsmMemoryOperand

type Output = AsmMemoryOperand

The resulting type after applying the - operator.

fn sub(self, rhs: u8) -> Self::Output

Performs the - operation.

impl Sub<usize> for AsmMemoryOperand

type Output = AsmMemoryOperand

The resulting type after applying the - operator.

fn sub(self, rhs: usize) -> Self::Output

Performs the - operation.

impl Copy for AsmMemoryOperand

impl Eq for AsmMemoryOperand

impl StructuralPartialEq for AsmMemoryOperand