Struct iced_x86::code_asm::AsmRegister64

pub struct AsmRegister64 { /* private fields */ }

Expand description

All 64-bit general purpose registers.

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

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

use iced_x86::code_asm::*;

or import them from this module:

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

or import only these registers:

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

Implementations§

impl AsmRegister64

pub fn k1(self) -> Self

Adds a {k1} opmask register

pub fn k2(self) -> Self

Adds a {k2} opmask register

pub fn k3(self) -> Self

Adds a {k3} opmask register

pub fn k4(self) -> Self

Adds a {k4} opmask register

pub fn k5(self) -> Self

Adds a {k5} opmask register

pub fn k6(self) -> Self

Adds a {k6} opmask register

pub fn k7(self) -> Self

Adds a {k7} opmask register

pub fn z(self) -> Self

Enables zeroing masking {z}

pub fn sae(self) -> Self

Enables suppress all exceptions {sae}

pub fn rn_sae(self) -> Self

Round to nearest (even)

pub fn rd_sae(self) -> Self

Round down (toward -inf)

pub fn ru_sae(self) -> Self

Round up (toward +inf)

pub fn rz_sae(self) -> Self

Round toward zero (truncate)

Trait Implementations§

impl Add<AsmMemoryOperand> for AsmRegister64

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation. Read more

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. Read more

impl Add<AsmRegister64> for AsmRegisterXmm

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation. Read more

impl Add<AsmRegister64> for AsmRegisterYmm

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation. Read more

impl Add<AsmRegister64> for AsmRegisterZmm

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation. Read more

impl Add<AsmRegister64> for i16

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation. Read more

impl Add<AsmRegister64> for i32

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation. Read more

impl Add<AsmRegister64> for i64

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation. Read more

impl Add<AsmRegister64> for i8

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation. Read more

impl Add<AsmRegister64> for isize

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation. Read more

impl Add<AsmRegister64> for u16

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation. Read more

impl Add<AsmRegister64> for u32

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation. Read more

impl Add<AsmRegister64> for u64

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation. Read more

impl Add<AsmRegister64> for u8

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation. Read more

impl Add<AsmRegister64> for usize

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation. Read more

impl Add<AsmRegisterXmm> for AsmRegister64

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation. Read more

impl Add<AsmRegisterYmm> for AsmRegister64

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation. Read more

impl Add<AsmRegisterZmm> for AsmRegister64

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation. Read more

impl Add<i16> for AsmRegister64

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation. Read more

impl Add<i32> for AsmRegister64

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation. Read more

impl Add<i64> for AsmRegister64

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation. Read more

impl Add<i8> for AsmRegister64

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation. Read more

impl Add<isize> for AsmRegister64

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation. Read more

impl Add<u16> for AsmRegister64

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation. Read more

impl Add<u32> for AsmRegister64

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation. Read more

impl Add<u64> for AsmRegister64

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation. Read more

impl Add<u8> for AsmRegister64

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation. Read more

impl Add<usize> for AsmRegister64

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation. Read more

impl Add for AsmRegister64

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation. Read more

impl Clone for AsmRegister64

fn clone(&self) -> AsmRegister64

Returns a copy of the value. Read more

1.0.0 · source§

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

Performs copy-assignment from source. Read more

impl CodeAsmAadd<AsmMemoryOperand, AsmRegister64> for CodeAssembler

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

impl CodeAsmAand<AsmMemoryOperand, AsmRegister64> for CodeAssembler

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

impl CodeAsmAdc<AsmMemoryOperand, AsmRegister64> for CodeAssembler

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

impl CodeAsmAdc<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmAdc<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmAdc<AsmRegister64, i32> for CodeAssembler

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

impl CodeAsmAdcx<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmAdcx<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmAdd<AsmMemoryOperand, AsmRegister64> for CodeAssembler

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

impl CodeAsmAdd<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmAdd<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmAdd<AsmRegister64, i32> for CodeAssembler

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

impl CodeAsmAdox<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmAdox<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmAnd<AsmMemoryOperand, AsmRegister64> for CodeAssembler

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

impl CodeAsmAnd<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmAnd<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmAnd<AsmRegister64, i32> for CodeAssembler

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

impl CodeAsmAndn<AsmRegister64, AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmAndn<AsmRegister64, AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmAor<AsmMemoryOperand, AsmRegister64> for CodeAssembler

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

impl CodeAsmAxor<AsmMemoryOperand, AsmRegister64> for CodeAssembler

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

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

impl CodeAsmBextr<AsmRegister64, AsmRegister64, i32> for CodeAssembler

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

impl CodeAsmBextr<AsmRegister64, AsmRegister64, u32> for CodeAssembler

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

impl CodeAsmBlcfill<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmBlcfill<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmBlci<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmBlci<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmBlcic<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmBlcic<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmBlcmsk<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmBlcmsk<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmBlcs<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmBlcs<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmBlsfill<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmBlsfill<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmBlsi<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmBlsi<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmBlsic<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmBlsic<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmBlsmsk<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmBlsmsk<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmBlsr<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmBlsr<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmBndcl<AsmRegisterBnd, AsmRegister64> for CodeAssembler

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

impl CodeAsmBndcn<AsmRegisterBnd, AsmRegister64> for CodeAssembler

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

impl CodeAsmBndcu<AsmRegisterBnd, AsmRegister64> for CodeAssembler

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

impl CodeAsmBsf<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmBsf<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmBsr<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmBsr<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmBswap<AsmRegister64> for CodeAssembler

fn bswap(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

impl CodeAsmBt<AsmMemoryOperand, AsmRegister64> for CodeAssembler

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

impl CodeAsmBt<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmBt<AsmRegister64, i32> for CodeAssembler

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

impl CodeAsmBt<AsmRegister64, u32> for CodeAssembler

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

impl CodeAsmBtc<AsmMemoryOperand, AsmRegister64> for CodeAssembler

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

impl CodeAsmBtc<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmBtc<AsmRegister64, i32> for CodeAssembler

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

impl CodeAsmBtc<AsmRegister64, u32> for CodeAssembler

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

impl CodeAsmBtr<AsmMemoryOperand, AsmRegister64> for CodeAssembler

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

impl CodeAsmBtr<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmBtr<AsmRegister64, i32> for CodeAssembler

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

impl CodeAsmBtr<AsmRegister64, u32> for CodeAssembler

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

impl CodeAsmBts<AsmMemoryOperand, AsmRegister64> for CodeAssembler

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

impl CodeAsmBts<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmBts<AsmRegister64, i32> for CodeAssembler

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

impl CodeAsmBts<AsmRegister64, u32> for CodeAssembler

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

impl CodeAsmBzhi<AsmRegister64, AsmMemoryOperand, AsmRegister64> for CodeAssembler

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

impl CodeAsmBzhi<AsmRegister64, AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCall<AsmRegister64> for CodeAssembler

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

impl CodeAsmCmova<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmova<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmovae<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovae<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmovb<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovb<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmovbe<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovbe<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmovc<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovc<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmove<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmove<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmovg<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovg<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmovge<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovge<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmovl<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovl<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmovle<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovle<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmovna<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovna<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmovnae<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovnae<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmovnb<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovnb<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmovnbe<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovnbe<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmovnc<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovnc<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmovne<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovne<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmovng<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovng<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmovnge<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovnge<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmovnl<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovnl<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmovnle<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovnle<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmovno<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovno<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmovnp<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovnp<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmovns<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovns<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmovnz<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovnz<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmovo<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovo<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmovp<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovp<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmovpe<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovpe<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmovpo<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovpo<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmovs<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovs<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmovz<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovz<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmp<AsmMemoryOperand, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmp<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmp<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmp<AsmRegister64, i32> for CodeAssembler

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

impl CodeAsmCmpbexadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmpbxadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmpcxadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmplexadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmplxadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmpnaexadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmpnaxadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmpnbexadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmpnbxadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmpncxadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmpngexadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmpngxadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmpnlexadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmpnlxadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmpnoxadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmpnpxadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmpnsxadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmpnzxadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmpoxadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmppexadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmppoxadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmppxadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmpsxadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmpxchg<AsmMemoryOperand, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmpxchg<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCmpzxadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCrc32<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCrc32<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmCrc32<AsmRegister64, AsmRegister8> for CodeAssembler

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

impl CodeAsmCvtsd2si<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCvtsd2si<AsmRegister64, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmCvtsi2sd<AsmRegisterXmm, AsmRegister64> for CodeAssembler

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

impl CodeAsmCvtsi2ss<AsmRegisterXmm, AsmRegister64> for CodeAssembler

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

impl CodeAsmCvtss2si<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCvtss2si<AsmRegister64, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmCvttsd2si<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCvttsd2si<AsmRegister64, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmCvttss2si<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCvttss2si<AsmRegister64, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmDec<AsmRegister64> for CodeAssembler

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

impl CodeAsmDiv<AsmRegister64> for CodeAssembler

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

impl CodeAsmEnqcmd<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmEnqcmds<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmExtractps<AsmRegister64, AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmExtractps<AsmRegister64, AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmIdiv<AsmRegister64> for CodeAssembler

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

impl CodeAsmImul<AsmRegister64> for CodeAssembler

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

impl CodeAsmImul2<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmImul2<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmImul3<AsmRegister64, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmImul3<AsmRegister64, AsmRegister64, i32> for CodeAssembler

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

impl CodeAsmInc<AsmRegister64> for CodeAssembler

fn inc(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

impl CodeAsmIncsspq<AsmRegister64> for CodeAssembler

fn incsspq(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

impl CodeAsmInvept<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmInvpcid<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmInvvpid<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmJmp<AsmRegister64> for CodeAssembler

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

impl CodeAsmKmovq<AsmRegister64, AsmRegisterK> for CodeAssembler

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

impl CodeAsmKmovq<AsmRegisterK, AsmRegister64> for CodeAssembler

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

impl CodeAsmLar<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmLea<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmLfs<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmLgs<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmLkgs<AsmRegister64> for CodeAssembler

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

impl CodeAsmLldt<AsmRegister64> for CodeAssembler

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

impl CodeAsmLlwpcb<AsmRegister64> for CodeAssembler

fn llwpcb(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

impl CodeAsmLmsw<AsmRegister64> for CodeAssembler

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

impl CodeAsmLsl<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmLss<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmLtr<AsmRegister64> for CodeAssembler

fn ltr(&mut self, op0: AsmRegister64) -> 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 CodeAsmLwpins<AsmRegister64, AsmRegister32, i32> for CodeAssembler

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

impl CodeAsmLwpins<AsmRegister64, AsmRegister32, u32> for CodeAssembler

fn lwpins( &mut self, op0: AsmRegister64, op1: AsmRegister32, 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 CodeAsmLwpval<AsmRegister64, AsmRegister32, i32> for CodeAssembler

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

impl CodeAsmLwpval<AsmRegister64, AsmRegister32, u32> for CodeAssembler

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

impl CodeAsmLzcnt<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmLzcnt<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmMov<AsmMemoryOperand, AsmRegister64> for CodeAssembler

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

impl CodeAsmMov<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMov<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmMov<AsmRegister64, AsmRegisterCr> for CodeAssembler

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

impl CodeAsmMov<AsmRegister64, AsmRegisterDr> for CodeAssembler

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

impl CodeAsmMov<AsmRegister64, AsmRegisterSegment> for CodeAssembler

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

impl CodeAsmMov<AsmRegister64, i64> for CodeAssembler

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

impl CodeAsmMov<AsmRegister64, u64> for CodeAssembler

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

impl CodeAsmMov<AsmRegisterCr, AsmRegister64> for CodeAssembler

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

impl CodeAsmMov<AsmRegisterDr, AsmRegister64> for CodeAssembler

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

impl CodeAsmMov<AsmRegisterSegment, AsmRegister64> for CodeAssembler

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

impl CodeAsmMovbe<AsmMemoryOperand, AsmRegister64> for CodeAssembler

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

impl CodeAsmMovbe<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMovdir64b<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMovdiri<AsmMemoryOperand, AsmRegister64> for CodeAssembler

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

impl CodeAsmMovmskpd<AsmRegister64, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmMovmskps<AsmRegister64, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmMovnti<AsmMemoryOperand, AsmRegister64> for CodeAssembler

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

impl CodeAsmMovq<AsmRegister64, AsmRegisterMm> for CodeAssembler

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

impl CodeAsmMovq<AsmRegister64, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmMovq<AsmRegisterMm, AsmRegister64> for CodeAssembler

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

impl CodeAsmMovq<AsmRegisterXmm, AsmRegister64> for CodeAssembler

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

impl CodeAsmMovsx<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMovsx<AsmRegister64, AsmRegister16> for CodeAssembler

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

impl CodeAsmMovsx<AsmRegister64, AsmRegister8> for CodeAssembler

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

impl CodeAsmMovsxd<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMovsxd<AsmRegister64, AsmRegister32> for CodeAssembler

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

impl CodeAsmMovzx<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMovzx<AsmRegister64, AsmRegister16> for CodeAssembler

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

impl CodeAsmMovzx<AsmRegister64, AsmRegister8> for CodeAssembler

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

impl CodeAsmMul<AsmRegister64> for CodeAssembler

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

impl CodeAsmMulx<AsmRegister64, AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMulx<AsmRegister64, AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmNeg<AsmRegister64> for CodeAssembler

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

impl CodeAsmNop1<AsmRegister64> for CodeAssembler

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

impl CodeAsmNot<AsmRegister64> for CodeAssembler

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

impl CodeAsmOr<AsmMemoryOperand, AsmRegister64> for CodeAssembler

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

impl CodeAsmOr<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmOr<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmOr<AsmRegister64, i32> for CodeAssembler

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

impl CodeAsmPdep<AsmRegister64, AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPdep<AsmRegister64, AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmPext<AsmRegister64, AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPext<AsmRegister64, AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmPextrb<AsmRegister64, AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmPextrb<AsmRegister64, AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmPextrq<AsmRegister64, AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmPextrq<AsmRegister64, AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmPextrw<AsmRegister64, AsmRegisterMm, i32> for CodeAssembler

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

impl CodeAsmPextrw<AsmRegister64, AsmRegisterMm, u32> for CodeAssembler

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

impl CodeAsmPextrw<AsmRegister64, AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmPextrw<AsmRegister64, AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmPinsrb<AsmRegisterXmm, AsmRegister64, i32> for CodeAssembler

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

impl CodeAsmPinsrb<AsmRegisterXmm, AsmRegister64, u32> for CodeAssembler

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

impl CodeAsmPinsrq<AsmRegisterXmm, AsmRegister64, i32> for CodeAssembler

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

impl CodeAsmPinsrq<AsmRegisterXmm, AsmRegister64, u32> for CodeAssembler

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

impl CodeAsmPinsrw<AsmRegisterMm, AsmRegister64, i32> for CodeAssembler

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

impl CodeAsmPinsrw<AsmRegisterMm, AsmRegister64, u32> for CodeAssembler

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

impl CodeAsmPinsrw<AsmRegisterXmm, AsmRegister64, i32> for CodeAssembler

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

impl CodeAsmPinsrw<AsmRegisterXmm, AsmRegister64, u32> for CodeAssembler

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

impl CodeAsmPmovmskb<AsmRegister64, AsmRegisterMm> for CodeAssembler

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

impl CodeAsmPmovmskb<AsmRegister64, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPop<AsmRegister64> for CodeAssembler

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

impl CodeAsmPopcnt<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPopcnt<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmPtwrite<AsmRegister64> for CodeAssembler

fn ptwrite(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

impl CodeAsmPush<AsmRegister64> for CodeAssembler

fn push(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

impl CodeAsmRcl<AsmRegister64, AsmRegister8> for CodeAssembler

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

impl CodeAsmRcl<AsmRegister64, i32> for CodeAssembler

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

impl CodeAsmRcl<AsmRegister64, u32> for CodeAssembler

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

impl CodeAsmRcr<AsmRegister64, AsmRegister8> for CodeAssembler

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

impl CodeAsmRcr<AsmRegister64, i32> for CodeAssembler

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

impl CodeAsmRcr<AsmRegister64, u32> for CodeAssembler

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

impl CodeAsmRdfsbase<AsmRegister64> for CodeAssembler

fn rdfsbase(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

impl CodeAsmRdgsbase<AsmRegister64> for CodeAssembler

fn rdgsbase(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

impl CodeAsmRdpid<AsmRegister64> for CodeAssembler

fn rdpid(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

impl CodeAsmRdrand<AsmRegister64> for CodeAssembler

fn rdrand(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

impl CodeAsmRdseed<AsmRegister64> for CodeAssembler

fn rdseed(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

impl CodeAsmRdsspq<AsmRegister64> for CodeAssembler

fn rdsspq(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

impl CodeAsmReservednop_0f0d<AsmMemoryOperand, AsmRegister64> for CodeAssembler

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

impl CodeAsmReservednop_0f0d<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmReservednop_0f18<AsmMemoryOperand, AsmRegister64> for CodeAssembler

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

impl CodeAsmReservednop_0f18<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmReservednop_0f19<AsmMemoryOperand, AsmRegister64> for CodeAssembler

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

impl CodeAsmReservednop_0f19<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmReservednop_0f1a<AsmMemoryOperand, AsmRegister64> for CodeAssembler

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

impl CodeAsmReservednop_0f1a<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmReservednop_0f1b<AsmMemoryOperand, AsmRegister64> for CodeAssembler

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

impl CodeAsmReservednop_0f1b<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmReservednop_0f1c<AsmMemoryOperand, AsmRegister64> for CodeAssembler

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

impl CodeAsmReservednop_0f1c<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmReservednop_0f1d<AsmMemoryOperand, AsmRegister64> for CodeAssembler

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

impl CodeAsmReservednop_0f1d<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmReservednop_0f1e<AsmMemoryOperand, AsmRegister64> for CodeAssembler

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

impl CodeAsmReservednop_0f1e<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmReservednop_0f1f<AsmMemoryOperand, AsmRegister64> for CodeAssembler

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

impl CodeAsmReservednop_0f1f<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmRol<AsmRegister64, AsmRegister8> for CodeAssembler

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

impl CodeAsmRol<AsmRegister64, i32> for CodeAssembler

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

impl CodeAsmRol<AsmRegister64, u32> for CodeAssembler

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

impl CodeAsmRor<AsmRegister64, AsmRegister8> for CodeAssembler

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

impl CodeAsmRor<AsmRegister64, i32> for CodeAssembler

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

impl CodeAsmRor<AsmRegister64, u32> for CodeAssembler

fn ror(&mut self, op0: AsmRegister64, op1: 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 CodeAsmRorx<AsmRegister64, AsmRegister64, i32> for CodeAssembler

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

impl CodeAsmRorx<AsmRegister64, AsmRegister64, u32> for CodeAssembler

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

impl CodeAsmSal<AsmRegister64, AsmRegister8> for CodeAssembler

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

impl CodeAsmSal<AsmRegister64, i32> for CodeAssembler

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

impl CodeAsmSal<AsmRegister64, u32> for CodeAssembler

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

impl CodeAsmSar<AsmRegister64, AsmRegister8> for CodeAssembler

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

impl CodeAsmSar<AsmRegister64, i32> for CodeAssembler

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

impl CodeAsmSar<AsmRegister64, u32> for CodeAssembler

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

impl CodeAsmSarx<AsmRegister64, AsmMemoryOperand, AsmRegister64> for CodeAssembler

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

impl CodeAsmSarx<AsmRegister64, AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmSbb<AsmMemoryOperand, AsmRegister64> for CodeAssembler

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

impl CodeAsmSbb<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmSbb<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmSbb<AsmRegister64, i32> for CodeAssembler

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

impl CodeAsmSenduipi<AsmRegister64> for CodeAssembler

fn senduipi(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

impl CodeAsmShl<AsmRegister64, AsmRegister8> for CodeAssembler

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

impl CodeAsmShl<AsmRegister64, i32> for CodeAssembler

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

impl CodeAsmShl<AsmRegister64, u32> for CodeAssembler

fn shl(&mut self, op0: AsmRegister64, op1: 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 CodeAsmShld<AsmRegister64, AsmRegister64, AsmRegister8> for CodeAssembler

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

impl CodeAsmShld<AsmRegister64, AsmRegister64, i32> for CodeAssembler

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

impl CodeAsmShld<AsmRegister64, AsmRegister64, u32> for CodeAssembler

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

impl CodeAsmShlx<AsmRegister64, AsmMemoryOperand, AsmRegister64> for CodeAssembler

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

impl CodeAsmShlx<AsmRegister64, AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmShr<AsmRegister64, AsmRegister8> for CodeAssembler

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

impl CodeAsmShr<AsmRegister64, i32> for CodeAssembler

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

impl CodeAsmShr<AsmRegister64, u32> for CodeAssembler

fn shr(&mut self, op0: AsmRegister64, op1: 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 CodeAsmShrd<AsmRegister64, AsmRegister64, AsmRegister8> for CodeAssembler

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

impl CodeAsmShrd<AsmRegister64, AsmRegister64, i32> for CodeAssembler

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

impl CodeAsmShrd<AsmRegister64, AsmRegister64, u32> for CodeAssembler

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

impl CodeAsmShrx<AsmRegister64, AsmMemoryOperand, AsmRegister64> for CodeAssembler

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

impl CodeAsmShrx<AsmRegister64, AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmSldt<AsmRegister64> for CodeAssembler

fn sldt(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

impl CodeAsmSlwpcb<AsmRegister64> for CodeAssembler

fn slwpcb(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

impl CodeAsmSmsw<AsmRegister64> for CodeAssembler

fn smsw(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

impl CodeAsmStr<AsmRegister64> for CodeAssembler

fn str(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

impl CodeAsmSub<AsmMemoryOperand, AsmRegister64> for CodeAssembler

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

impl CodeAsmSub<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmSub<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmSub<AsmRegister64, i32> for CodeAssembler

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

impl CodeAsmT1mskc<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmT1mskc<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmTest<AsmMemoryOperand, AsmRegister64> for CodeAssembler

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

impl CodeAsmTest<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmTest<AsmRegister64, i32> for CodeAssembler

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

impl CodeAsmTpause<AsmRegister64> for CodeAssembler

fn tpause(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

impl CodeAsmTzcnt<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmTzcnt<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmTzmsk<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmTzmsk<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmUd02<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmUd02<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmUd1<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmUd1<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmUmonitor<AsmRegister64> for CodeAssembler

fn umonitor(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

impl CodeAsmUmwait<AsmRegister64> for CodeAssembler

fn umwait(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

impl CodeAsmVcvtsd2si<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcvtsd2si<AsmRegister64, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcvtsd2usi<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcvtsd2usi<AsmRegister64, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcvtsh2si<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcvtsh2si<AsmRegister64, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcvtsh2usi<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcvtsh2usi<AsmRegister64, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcvtsi2sd<AsmRegisterXmm, AsmRegisterXmm, AsmRegister64> for CodeAssembler

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

impl CodeAsmVcvtsi2sh<AsmRegisterXmm, AsmRegisterXmm, AsmRegister64> for CodeAssembler

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

impl CodeAsmVcvtsi2ss<AsmRegisterXmm, AsmRegisterXmm, AsmRegister64> for CodeAssembler

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

impl CodeAsmVcvtss2si<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcvtss2si<AsmRegister64, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcvtss2usi<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcvtss2usi<AsmRegister64, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcvttsd2si<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcvttsd2si<AsmRegister64, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcvttsd2usi<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcvttsd2usi<AsmRegister64, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcvttsh2si<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcvttsh2si<AsmRegister64, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcvttsh2usi<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcvttsh2usi<AsmRegister64, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcvttss2si<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcvttss2si<AsmRegister64, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcvttss2usi<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcvttss2usi<AsmRegister64, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcvtusi2sd<AsmRegisterXmm, AsmRegisterXmm, AsmRegister64> for CodeAssembler

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

impl CodeAsmVcvtusi2sh<AsmRegisterXmm, AsmRegisterXmm, AsmRegister64> for CodeAssembler

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

impl CodeAsmVcvtusi2ss<AsmRegisterXmm, AsmRegisterXmm, AsmRegister64> for CodeAssembler

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

impl CodeAsmVerr<AsmRegister64> for CodeAssembler

fn verr(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

impl CodeAsmVerw<AsmRegister64> for CodeAssembler

fn verw(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

impl CodeAsmVextractps<AsmRegister64, AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmVextractps<AsmRegister64, AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmVmovmskpd<AsmRegister64, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVmovmskpd<AsmRegister64, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVmovmskps<AsmRegister64, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVmovmskps<AsmRegister64, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVmovq<AsmRegister64, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVmovq<AsmRegisterXmm, AsmRegister64> for CodeAssembler

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

impl CodeAsmVmovw<AsmRegister64, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVmovw<AsmRegisterXmm, AsmRegister64> for CodeAssembler

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

impl CodeAsmVmread<AsmMemoryOperand, AsmRegister64> for CodeAssembler

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

impl CodeAsmVmread<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmVmwrite<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVmwrite<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmVpbroadcastq<AsmRegisterXmm, AsmRegister64> for CodeAssembler

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

impl CodeAsmVpbroadcastq<AsmRegisterYmm, AsmRegister64> for CodeAssembler

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

impl CodeAsmVpbroadcastq<AsmRegisterZmm, AsmRegister64> for CodeAssembler

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

impl CodeAsmVpextrb<AsmRegister64, AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmVpextrb<AsmRegister64, AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmVpextrq<AsmRegister64, AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmVpextrq<AsmRegister64, AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmVpextrw<AsmRegister64, AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmVpextrw<AsmRegister64, AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmVpinsrb<AsmRegisterXmm, AsmRegisterXmm, AsmRegister64, i32> for CodeAssembler

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

impl CodeAsmVpinsrb<AsmRegisterXmm, AsmRegisterXmm, AsmRegister64, u32> for CodeAssembler

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

impl CodeAsmVpinsrq<AsmRegisterXmm, AsmRegisterXmm, AsmRegister64, i32> for CodeAssembler

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

impl CodeAsmVpinsrq<AsmRegisterXmm, AsmRegisterXmm, AsmRegister64, u32> for CodeAssembler

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

impl CodeAsmVpinsrw<AsmRegisterXmm, AsmRegisterXmm, AsmRegister64, i32> for CodeAssembler

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

impl CodeAsmVpinsrw<AsmRegisterXmm, AsmRegisterXmm, AsmRegister64, u32> for CodeAssembler

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

impl CodeAsmVpmovmskb<AsmRegister64, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVpmovmskb<AsmRegister64, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmWrfsbase<AsmRegister64> for CodeAssembler

fn wrfsbase(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

impl CodeAsmWrgsbase<AsmRegister64> for CodeAssembler

fn wrgsbase(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

impl CodeAsmWrssq<AsmMemoryOperand, AsmRegister64> for CodeAssembler

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

impl CodeAsmWrussq<AsmMemoryOperand, AsmRegister64> for CodeAssembler

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

impl CodeAsmXadd<AsmMemoryOperand, AsmRegister64> for CodeAssembler

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

impl CodeAsmXadd<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmXchg<AsmMemoryOperand, AsmRegister64> for CodeAssembler

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

impl CodeAsmXchg<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmXor<AsmMemoryOperand, AsmRegister64> for CodeAssembler

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

impl CodeAsmXor<AsmRegister64, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmXor<AsmRegister64, AsmRegister64> for CodeAssembler

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

impl CodeAsmXor<AsmRegister64, i32> for CodeAssembler

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

impl Debug for AsmRegister64

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more

impl From<AsmRegister64> for Register

fn from(reg: AsmRegister64) -> Self

Converts to this type from the input type.

impl Mul<AsmRegister64> for i16

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl Mul<AsmRegister64> for i32

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl Mul<AsmRegister64> for i64

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl Mul<AsmRegister64> for i8

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl Mul<AsmRegister64> for isize

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl Mul<AsmRegister64> for u16

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl Mul<AsmRegister64> for u32

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl Mul<AsmRegister64> for u64

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl Mul<AsmRegister64> for u8

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl Mul<AsmRegister64> for usize

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl Mul<i16> for AsmRegister64

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl Mul<i32> for AsmRegister64

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl Mul<i64> for AsmRegister64

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl Mul<i8> for AsmRegister64

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl Mul<isize> for AsmRegister64

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl Mul<u16> for AsmRegister64

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl Mul<u32> for AsmRegister64

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl Mul<u64> for AsmRegister64

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl Mul<u8> for AsmRegister64

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl Mul<usize> for AsmRegister64

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl PartialEq for AsmRegister64

fn eq(&self, other: &AsmRegister64) -> bool

This method tests for self and other values to be equal, and is used by ==.

1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Sub<i16> for AsmRegister64

type Output = AsmMemoryOperand

The resulting type after applying the - operator.

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

Performs the - operation. Read more

impl Sub<i32> for AsmRegister64

type Output = AsmMemoryOperand

The resulting type after applying the - operator.

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

Performs the - operation. Read more

impl Sub<i64> for AsmRegister64

type Output = AsmMemoryOperand

The resulting type after applying the - operator.

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

Performs the - operation. Read more

impl Sub<i8> for AsmRegister64

type Output = AsmMemoryOperand

The resulting type after applying the - operator.

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

Performs the - operation. Read more

impl Sub<isize> for AsmRegister64

type Output = AsmMemoryOperand

The resulting type after applying the - operator.

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

Performs the - operation. Read more

impl Sub<u16> for AsmRegister64

type Output = AsmMemoryOperand

The resulting type after applying the - operator.

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

Performs the - operation. Read more

impl Sub<u32> for AsmRegister64

type Output = AsmMemoryOperand

The resulting type after applying the - operator.

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

Performs the - operation. Read more

impl Sub<u64> for AsmRegister64

type Output = AsmMemoryOperand

The resulting type after applying the - operator.

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

Performs the - operation. Read more

impl Sub<u8> for AsmRegister64

type Output = AsmMemoryOperand

The resulting type after applying the - operator.

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

Performs the - operation. Read more

impl Sub<usize> for AsmRegister64

type Output = AsmMemoryOperand

The resulting type after applying the - operator.

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

Performs the - operation. Read more

impl Copy for AsmRegister64

impl Eq for AsmRegister64

impl StructuralEq for AsmRegister64

impl StructuralPartialEq for AsmRegister64

Auto Trait Implementations§

impl RefUnwindSafe for AsmRegister64

impl Send for AsmRegister64

impl Sync for AsmRegister64

impl Unpin for AsmRegister64

impl UnwindSafe for AsmRegister64

Blanket Implementations§

impl<T> Any for T
where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

impl<T> Borrow<T> for T
where T: ?Sized,

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

impl<T> BorrowMut<T> for T
where T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

impl<T> From<T> for T

fn from(t: T) -> T

Returns the argument unchanged.

impl<T, U> Into<U> for T
where U: From<T>,

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

impl<T> ToOwned for T
where T: Clone,

type Owned = T

The resulting type after obtaining ownership.

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more

impl<T, U> TryFrom<U> for T
where U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.