Struct iced_x86::code_asm::AsmRegister32

pub struct AsmRegister32 { /* private fields */ }

All 32-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::gpr32::*;

Implementations

impl AsmRegister32

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 AsmRegister32

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

fn add(self, rhs: AsmMemoryOperand) -> 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<AsmRegister32> for AsmRegister32

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<AsmRegister32> for AsmRegisterXmm

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<AsmRegister32> for AsmRegisterYmm

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<AsmRegister32> for AsmRegisterZmm

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<AsmRegister32> for i16

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<AsmRegister32> for i32

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<AsmRegister32> for i64

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<AsmRegister32> for i8

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<AsmRegister32> for isize

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<AsmRegister32> for u16

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<AsmRegister32> for u32

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<AsmRegister32> for u64

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<AsmRegister32> for u8

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<AsmRegister32> for usize

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<AsmRegisterXmm> for AsmRegister32

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<AsmRegisterYmm> for AsmRegister32

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<AsmRegisterZmm> for AsmRegister32

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<i16> for AsmRegister32

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<i32> for AsmRegister32

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<i64> for AsmRegister32

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<i8> for AsmRegister32

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<isize> for AsmRegister32

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<u16> for AsmRegister32

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<u32> for AsmRegister32

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<u64> for AsmRegister32

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<u8> for AsmRegister32

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<usize> for AsmRegister32

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Clone for AsmRegister32

fn clone(&self) -> AsmRegister32

Returns a copy of the value.

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

Performs copy-assignment from source.

impl CodeAsmAdc<AsmMemoryOperand, AsmRegister32> for CodeAssembler

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

impl CodeAsmAdc<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmAdc<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmAdc<AsmRegister32, i32> for CodeAssembler

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

impl CodeAsmAdc<AsmRegister32, u32> for CodeAssembler

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

impl CodeAsmAdcx<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmAdcx<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmAdd<AsmMemoryOperand, AsmRegister32> for CodeAssembler

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

impl CodeAsmAdd<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmAdd<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmAdd<AsmRegister32, i32> for CodeAssembler

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

impl CodeAsmAdd<AsmRegister32, u32> for CodeAssembler

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

impl CodeAsmAdox<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmAdox<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmAnd<AsmMemoryOperand, AsmRegister32> for CodeAssembler

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

impl CodeAsmAnd<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmAnd<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmAnd<AsmRegister32, i32> for CodeAssembler

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

impl CodeAsmAnd<AsmRegister32, u32> for CodeAssembler

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

impl CodeAsmAndn<AsmRegister32, AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmAndn<AsmRegister32, AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmArpl<AsmMemoryOperand, AsmRegister32> for CodeAssembler

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

impl CodeAsmArpl<AsmRegister32, AsmRegister32> for CodeAssembler

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

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

impl CodeAsmBextr<AsmRegister32, AsmRegister32, i32> for CodeAssembler

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

impl CodeAsmBextr<AsmRegister32, AsmRegister32, u32> for CodeAssembler

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

impl CodeAsmBlcfill<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmBlcfill<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmBlci<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmBlci<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmBlcic<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmBlcic<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmBlcmsk<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmBlcmsk<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmBlcs<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmBlcs<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmBlsfill<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmBlsfill<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmBlsi<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmBlsi<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmBlsic<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmBlsic<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmBlsmsk<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmBlsmsk<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmBlsr<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmBlsr<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmBndcl<AsmRegisterBnd, AsmRegister32> for CodeAssembler

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

impl CodeAsmBndcn<AsmRegisterBnd, AsmRegister32> for CodeAssembler

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

impl CodeAsmBndcu<AsmRegisterBnd, AsmRegister32> for CodeAssembler

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

impl CodeAsmBound<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmBsf<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmBsf<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmBsr<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmBsr<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmBswap<AsmRegister32> for CodeAssembler

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

impl CodeAsmBt<AsmMemoryOperand, AsmRegister32> for CodeAssembler

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

impl CodeAsmBt<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmBt<AsmRegister32, i32> for CodeAssembler

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

impl CodeAsmBt<AsmRegister32, u32> for CodeAssembler

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

impl CodeAsmBtc<AsmMemoryOperand, AsmRegister32> for CodeAssembler

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

impl CodeAsmBtc<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmBtc<AsmRegister32, i32> for CodeAssembler

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

impl CodeAsmBtc<AsmRegister32, u32> for CodeAssembler

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

impl CodeAsmBtr<AsmMemoryOperand, AsmRegister32> for CodeAssembler

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

impl CodeAsmBtr<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmBtr<AsmRegister32, i32> for CodeAssembler

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

impl CodeAsmBtr<AsmRegister32, u32> for CodeAssembler

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

impl CodeAsmBts<AsmMemoryOperand, AsmRegister32> for CodeAssembler

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

impl CodeAsmBts<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmBts<AsmRegister32, i32> for CodeAssembler

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

impl CodeAsmBts<AsmRegister32, u32> for CodeAssembler

fn bts(&mut self, op0: AsmRegister32, 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<AsmRegister32, AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmCall<AsmRegister32> for CodeAssembler

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

impl CodeAsmCmova<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmova<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmCmovae<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovae<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmCmovb<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovb<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmCmovbe<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovbe<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmCmovc<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovc<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmCmove<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmove<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmCmovg<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovg<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmCmovge<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovge<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmCmovl<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovl<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmCmovle<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovle<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmCmovna<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovna<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmCmovnae<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovnae<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmCmovnb<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovnb<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmCmovnbe<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovnbe<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmCmovnc<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovnc<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmCmovne<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovne<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmCmovng<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovng<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmCmovnge<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovnge<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmCmovnl<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovnl<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmCmovnle<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovnle<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmCmovno<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovno<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmCmovnp<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovnp<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmCmovns<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovns<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmCmovnz<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovnz<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmCmovo<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovo<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmCmovp<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovp<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmCmovpe<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovpe<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmCmovpo<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovpo<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmCmovs<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovs<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmCmovz<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovz<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmCmp<AsmMemoryOperand, AsmRegister32> for CodeAssembler

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

impl CodeAsmCmp<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmp<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmCmp<AsmRegister32, i32> for CodeAssembler

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

impl CodeAsmCmp<AsmRegister32, u32> for CodeAssembler

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

impl CodeAsmCmpxchg<AsmMemoryOperand, AsmRegister32> for CodeAssembler

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

impl CodeAsmCmpxchg<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmCrc32<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCrc32<AsmRegister32, AsmRegister16> for CodeAssembler

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

impl CodeAsmCrc32<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmCrc32<AsmRegister32, AsmRegister8> for CodeAssembler

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

impl CodeAsmCvtsd2si<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCvtsd2si<AsmRegister32, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmCvtsi2sd<AsmRegisterXmm, AsmRegister32> for CodeAssembler

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

impl CodeAsmCvtsi2ss<AsmRegisterXmm, AsmRegister32> for CodeAssembler

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

impl CodeAsmCvtss2si<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCvtss2si<AsmRegister32, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmCvttsd2si<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCvttsd2si<AsmRegister32, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmCvttss2si<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCvttss2si<AsmRegister32, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmDec<AsmRegister32> for CodeAssembler

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

impl CodeAsmDiv<AsmRegister32> for CodeAssembler

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

impl CodeAsmEncodekey128<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmEncodekey256<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmEnqcmd<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmEnqcmds<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmExtractps<AsmRegister32, AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmExtractps<AsmRegister32, AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmIbts<AsmMemoryOperand, AsmRegister32> for CodeAssembler

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

impl CodeAsmIbts<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmIdiv<AsmRegister32> for CodeAssembler

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

impl CodeAsmImul<AsmRegister32> for CodeAssembler

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

impl CodeAsmImul2<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmImul2<AsmRegister32, AsmRegister32> for CodeAssembler

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

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

impl CodeAsmImul3<AsmRegister32, AsmRegister32, u32> for CodeAssembler

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

impl CodeAsmIn<AsmRegister32, AsmRegister16> for CodeAssembler

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

impl CodeAsmIn<AsmRegister32, i32> for CodeAssembler

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

impl CodeAsmIn<AsmRegister32, u32> for CodeAssembler

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

impl CodeAsmInc<AsmRegister32> for CodeAssembler

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

impl CodeAsmIncsspd<AsmRegister32> for CodeAssembler

fn incsspd(&mut self, op0: AsmRegister32) -> Result<(), IcedError>

impl CodeAsmInvept<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmInvpcid<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmInvvpid<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmJmp<AsmRegister32> for CodeAssembler

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

impl CodeAsmJmpe<AsmRegister32> for CodeAssembler

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

impl CodeAsmKmovb<AsmRegister32, AsmRegisterK> for CodeAssembler

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

impl CodeAsmKmovb<AsmRegisterK, AsmRegister32> for CodeAssembler

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

impl CodeAsmKmovd<AsmRegister32, AsmRegisterK> for CodeAssembler

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

impl CodeAsmKmovd<AsmRegisterK, AsmRegister32> for CodeAssembler

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

impl CodeAsmKmovw<AsmRegister32, AsmRegisterK> for CodeAssembler

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

impl CodeAsmKmovw<AsmRegisterK, AsmRegister32> for CodeAssembler

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

impl CodeAsmLar<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmLar<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmLds<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmLea<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmLes<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmLfs<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmLgs<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmLkgs<AsmRegister32> for CodeAssembler

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

impl CodeAsmLldt<AsmRegister32> for CodeAssembler

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

impl CodeAsmLlwpcb<AsmRegister32> for CodeAssembler

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

impl CodeAsmLmsw<AsmRegister32> for CodeAssembler

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

impl CodeAsmLsl<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmLsl<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmLss<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmLtr<AsmRegister32> for CodeAssembler

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

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

impl CodeAsmLwpins<AsmRegister32, AsmRegister32, u32> for CodeAssembler

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

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

impl CodeAsmLwpval<AsmRegister32, AsmRegister32, u32> for CodeAssembler

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

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

impl CodeAsmLzcnt<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmMov<AsmMemoryOperand, AsmRegister32> for CodeAssembler

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

impl CodeAsmMov<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMov<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmMov<AsmRegister32, AsmRegisterCr> for CodeAssembler

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

impl CodeAsmMov<AsmRegister32, AsmRegisterDr> for CodeAssembler

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

impl CodeAsmMov<AsmRegister32, AsmRegisterSegment> for CodeAssembler

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

impl CodeAsmMov<AsmRegister32, AsmRegisterTr> for CodeAssembler

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

impl CodeAsmMov<AsmRegister32, i32> for CodeAssembler

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

impl CodeAsmMov<AsmRegister32, u32> for CodeAssembler

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

impl CodeAsmMov<AsmRegisterCr, AsmRegister32> for CodeAssembler

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

impl CodeAsmMov<AsmRegisterDr, AsmRegister32> for CodeAssembler

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

impl CodeAsmMov<AsmRegisterSegment, AsmRegister32> for CodeAssembler

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

impl CodeAsmMov<AsmRegisterTr, AsmRegister32> for CodeAssembler

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

impl CodeAsmMovbe<AsmMemoryOperand, AsmRegister32> for CodeAssembler

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

impl CodeAsmMovbe<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMovd<AsmRegister32, AsmRegisterMm> for CodeAssembler

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

impl CodeAsmMovd<AsmRegister32, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmMovd<AsmRegisterMm, AsmRegister32> for CodeAssembler

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

impl CodeAsmMovd<AsmRegisterXmm, AsmRegister32> for CodeAssembler

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

impl CodeAsmMovdir64b<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMovdiri<AsmMemoryOperand, AsmRegister32> for CodeAssembler

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

impl CodeAsmMovmskpd<AsmRegister32, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmMovmskps<AsmRegister32, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmMovnti<AsmMemoryOperand, AsmRegister32> for CodeAssembler

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

impl CodeAsmMovsx<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMovsx<AsmRegister32, AsmRegister16> for CodeAssembler

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

impl CodeAsmMovsx<AsmRegister32, AsmRegister8> for CodeAssembler

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

impl CodeAsmMovsxd<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMovsxd<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmMovsxd<AsmRegister64, AsmRegister32> for CodeAssembler

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

impl CodeAsmMovzx<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMovzx<AsmRegister32, AsmRegister16> for CodeAssembler

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

impl CodeAsmMovzx<AsmRegister32, AsmRegister8> for CodeAssembler

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

impl CodeAsmMul<AsmRegister32> for CodeAssembler

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

impl CodeAsmMulx<AsmRegister32, AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMulx<AsmRegister32, AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmNeg<AsmRegister32> for CodeAssembler

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

impl CodeAsmNop1<AsmRegister32> for CodeAssembler

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

impl CodeAsmNot<AsmRegister32> for CodeAssembler

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

impl CodeAsmOr<AsmMemoryOperand, AsmRegister32> for CodeAssembler

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

impl CodeAsmOr<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmOr<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmOr<AsmRegister32, i32> for CodeAssembler

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

impl CodeAsmOr<AsmRegister32, u32> for CodeAssembler

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

impl CodeAsmOut<AsmRegister16, AsmRegister32> for CodeAssembler

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

impl CodeAsmOut<i32, AsmRegister32> for CodeAssembler

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

impl CodeAsmOut<u32, AsmRegister32> for CodeAssembler

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

impl CodeAsmPdep<AsmRegister32, AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPdep<AsmRegister32, AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmPext<AsmRegister32, AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPext<AsmRegister32, AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmPextrb<AsmRegister32, AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmPextrb<AsmRegister32, AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmPextrd<AsmRegister32, AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmPextrd<AsmRegister32, AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmPextrw<AsmRegister32, AsmRegisterMm, i32> for CodeAssembler

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

impl CodeAsmPextrw<AsmRegister32, AsmRegisterMm, u32> for CodeAssembler

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

impl CodeAsmPextrw<AsmRegister32, AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmPextrw<AsmRegister32, AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmPinsrb<AsmRegisterXmm, AsmRegister32, i32> for CodeAssembler

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

impl CodeAsmPinsrb<AsmRegisterXmm, AsmRegister32, u32> for CodeAssembler

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

impl CodeAsmPinsrd<AsmRegisterXmm, AsmRegister32, i32> for CodeAssembler

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

impl CodeAsmPinsrd<AsmRegisterXmm, AsmRegister32, u32> for CodeAssembler

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

impl CodeAsmPinsrw<AsmRegisterMm, AsmRegister32, i32> for CodeAssembler

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

impl CodeAsmPinsrw<AsmRegisterMm, AsmRegister32, u32> for CodeAssembler

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

impl CodeAsmPinsrw<AsmRegisterXmm, AsmRegister32, i32> for CodeAssembler

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

impl CodeAsmPinsrw<AsmRegisterXmm, AsmRegister32, u32> for CodeAssembler

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

impl CodeAsmPmovmskb<AsmRegister32, AsmRegisterMm> for CodeAssembler

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

impl CodeAsmPmovmskb<AsmRegister32, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmPop<AsmRegister32> for CodeAssembler

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

impl CodeAsmPopcnt<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPopcnt<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmPtwrite<AsmRegister32> for CodeAssembler

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

impl CodeAsmPush<AsmRegister32> for CodeAssembler

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

impl CodeAsmRcl<AsmRegister32, AsmRegister8> for CodeAssembler

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

impl CodeAsmRcl<AsmRegister32, i32> for CodeAssembler

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

impl CodeAsmRcl<AsmRegister32, u32> for CodeAssembler

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

impl CodeAsmRcr<AsmRegister32, AsmRegister8> for CodeAssembler

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

impl CodeAsmRcr<AsmRegister32, i32> for CodeAssembler

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

impl CodeAsmRcr<AsmRegister32, u32> for CodeAssembler

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

impl CodeAsmRdfsbase<AsmRegister32> for CodeAssembler

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

impl CodeAsmRdgsbase<AsmRegister32> for CodeAssembler

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

impl CodeAsmRdpid<AsmRegister32> for CodeAssembler

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

impl CodeAsmRdrand<AsmRegister32> for CodeAssembler

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

impl CodeAsmRdseed<AsmRegister32> for CodeAssembler

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

impl CodeAsmRdshr<AsmRegister32> for CodeAssembler

fn rdshr(&mut self, op0: AsmRegister32) -> Result<(), IcedError>

impl CodeAsmRdsspd<AsmRegister32> for CodeAssembler

fn rdsspd(&mut self, op0: AsmRegister32) -> Result<(), IcedError>

impl CodeAsmReservednop_0f0d<AsmMemoryOperand, AsmRegister32> for CodeAssembler

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

impl CodeAsmReservednop_0f0d<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmReservednop_0f18<AsmMemoryOperand, AsmRegister32> for CodeAssembler

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

impl CodeAsmReservednop_0f18<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmReservednop_0f19<AsmMemoryOperand, AsmRegister32> for CodeAssembler

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

impl CodeAsmReservednop_0f19<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmReservednop_0f1a<AsmMemoryOperand, AsmRegister32> for CodeAssembler

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

impl CodeAsmReservednop_0f1a<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmReservednop_0f1b<AsmMemoryOperand, AsmRegister32> for CodeAssembler

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

impl CodeAsmReservednop_0f1b<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmReservednop_0f1c<AsmMemoryOperand, AsmRegister32> for CodeAssembler

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

impl CodeAsmReservednop_0f1c<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmReservednop_0f1d<AsmMemoryOperand, AsmRegister32> for CodeAssembler

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

impl CodeAsmReservednop_0f1d<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmReservednop_0f1e<AsmMemoryOperand, AsmRegister32> for CodeAssembler

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

impl CodeAsmReservednop_0f1e<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmReservednop_0f1f<AsmMemoryOperand, AsmRegister32> for CodeAssembler

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

impl CodeAsmReservednop_0f1f<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmRol<AsmRegister32, AsmRegister8> for CodeAssembler

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

impl CodeAsmRol<AsmRegister32, i32> for CodeAssembler

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

impl CodeAsmRol<AsmRegister32, u32> for CodeAssembler

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

impl CodeAsmRor<AsmRegister32, AsmRegister8> for CodeAssembler

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

impl CodeAsmRor<AsmRegister32, i32> for CodeAssembler

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

impl CodeAsmRor<AsmRegister32, u32> for CodeAssembler

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

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

impl CodeAsmRorx<AsmRegister32, AsmRegister32, u32> for CodeAssembler

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

impl CodeAsmSal<AsmRegister32, AsmRegister8> for CodeAssembler

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

impl CodeAsmSal<AsmRegister32, i32> for CodeAssembler

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

impl CodeAsmSal<AsmRegister32, u32> for CodeAssembler

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

impl CodeAsmSar<AsmRegister32, AsmRegister8> for CodeAssembler

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

impl CodeAsmSar<AsmRegister32, i32> for CodeAssembler

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

impl CodeAsmSar<AsmRegister32, u32> for CodeAssembler

fn sar(&mut self, op0: AsmRegister32, 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<AsmRegister32, AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmSbb<AsmMemoryOperand, AsmRegister32> for CodeAssembler

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

impl CodeAsmSbb<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmSbb<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmSbb<AsmRegister32, i32> for CodeAssembler

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

impl CodeAsmSbb<AsmRegister32, u32> for CodeAssembler

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

impl CodeAsmShl<AsmRegister32, AsmRegister8> for CodeAssembler

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

impl CodeAsmShl<AsmRegister32, i32> for CodeAssembler

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

impl CodeAsmShl<AsmRegister32, u32> for CodeAssembler

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

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

impl CodeAsmShld<AsmRegister32, AsmRegister32, i32> for CodeAssembler

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

impl CodeAsmShld<AsmRegister32, AsmRegister32, u32> for CodeAssembler

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

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

impl CodeAsmShr<AsmRegister32, AsmRegister8> for CodeAssembler

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

impl CodeAsmShr<AsmRegister32, i32> for CodeAssembler

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

impl CodeAsmShr<AsmRegister32, u32> for CodeAssembler

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

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

impl CodeAsmShrd<AsmRegister32, AsmRegister32, i32> for CodeAssembler

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

impl CodeAsmShrd<AsmRegister32, AsmRegister32, u32> for CodeAssembler

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

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

impl CodeAsmSldt<AsmRegister32> for CodeAssembler

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

impl CodeAsmSlwpcb<AsmRegister32> for CodeAssembler

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

impl CodeAsmSmsw<AsmRegister32> for CodeAssembler

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

impl CodeAsmStr<AsmRegister32> for CodeAssembler

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

impl CodeAsmSub<AsmMemoryOperand, AsmRegister32> for CodeAssembler

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

impl CodeAsmSub<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmSub<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmSub<AsmRegister32, i32> for CodeAssembler

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

impl CodeAsmSub<AsmRegister32, u32> for CodeAssembler

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

impl CodeAsmT1mskc<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmT1mskc<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmTest<AsmMemoryOperand, AsmRegister32> for CodeAssembler

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

impl CodeAsmTest<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmTest<AsmRegister32, i32> for CodeAssembler

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

impl CodeAsmTest<AsmRegister32, u32> for CodeAssembler

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

impl CodeAsmTpause<AsmRegister32> for CodeAssembler

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

impl CodeAsmTzcnt<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmTzcnt<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmTzmsk<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmTzmsk<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmUd02<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmUd02<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmUd1<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmUd1<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmUmonitor<AsmRegister32> for CodeAssembler

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

impl CodeAsmUmov<AsmMemoryOperand, AsmRegister32> for CodeAssembler

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

impl CodeAsmUmov<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmUmov<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmUmwait<AsmRegister32> for CodeAssembler

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

impl CodeAsmVcvtsd2si<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcvtsd2si<AsmRegister32, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcvtsd2usi<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcvtsd2usi<AsmRegister32, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcvtsh2si<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcvtsh2si<AsmRegister32, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcvtsh2usi<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcvtsh2usi<AsmRegister32, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcvtsi2sd<AsmRegisterXmm, AsmRegisterXmm, AsmRegister32> for CodeAssembler

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

impl CodeAsmVcvtsi2sh<AsmRegisterXmm, AsmRegisterXmm, AsmRegister32> for CodeAssembler

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

impl CodeAsmVcvtsi2ss<AsmRegisterXmm, AsmRegisterXmm, AsmRegister32> for CodeAssembler

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

impl CodeAsmVcvtss2si<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcvtss2si<AsmRegister32, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcvtss2usi<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcvtss2usi<AsmRegister32, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcvttsd2si<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcvttsd2si<AsmRegister32, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcvttsd2usi<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcvttsd2usi<AsmRegister32, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcvttsh2si<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcvttsh2si<AsmRegister32, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcvttsh2usi<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcvttsh2usi<AsmRegister32, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcvttss2si<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcvttss2si<AsmRegister32, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcvttss2usi<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcvttss2usi<AsmRegister32, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcvtusi2sd<AsmRegisterXmm, AsmRegisterXmm, AsmRegister32> for CodeAssembler

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

impl CodeAsmVcvtusi2sh<AsmRegisterXmm, AsmRegisterXmm, AsmRegister32> for CodeAssembler

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

impl CodeAsmVcvtusi2ss<AsmRegisterXmm, AsmRegisterXmm, AsmRegister32> for CodeAssembler

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

impl CodeAsmVerr<AsmRegister32> for CodeAssembler

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

impl CodeAsmVerw<AsmRegister32> for CodeAssembler

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

impl CodeAsmVextractps<AsmRegister32, AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmVextractps<AsmRegister32, AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmVmovd<AsmRegister32, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVmovd<AsmRegisterXmm, AsmRegister32> for CodeAssembler

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

impl CodeAsmVmovmskpd<AsmRegister32, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVmovmskpd<AsmRegister32, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVmovmskps<AsmRegister32, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVmovmskps<AsmRegister32, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVmovw<AsmRegister32, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVmovw<AsmRegisterXmm, AsmRegister32> for CodeAssembler

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

impl CodeAsmVmread<AsmMemoryOperand, AsmRegister32> for CodeAssembler

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

impl CodeAsmVmread<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmVmwrite<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVmwrite<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmVpbroadcastb<AsmRegisterXmm, AsmRegister32> for CodeAssembler

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

impl CodeAsmVpbroadcastb<AsmRegisterYmm, AsmRegister32> for CodeAssembler

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

impl CodeAsmVpbroadcastb<AsmRegisterZmm, AsmRegister32> for CodeAssembler

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

impl CodeAsmVpbroadcastd<AsmRegisterXmm, AsmRegister32> for CodeAssembler

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

impl CodeAsmVpbroadcastd<AsmRegisterYmm, AsmRegister32> for CodeAssembler

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

impl CodeAsmVpbroadcastd<AsmRegisterZmm, AsmRegister32> for CodeAssembler

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

impl CodeAsmVpbroadcastw<AsmRegisterXmm, AsmRegister32> for CodeAssembler

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

impl CodeAsmVpbroadcastw<AsmRegisterYmm, AsmRegister32> for CodeAssembler

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

impl CodeAsmVpbroadcastw<AsmRegisterZmm, AsmRegister32> for CodeAssembler

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

impl CodeAsmVpextrb<AsmRegister32, AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmVpextrb<AsmRegister32, AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmVpextrd<AsmRegister32, AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmVpextrd<AsmRegister32, AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmVpextrw<AsmRegister32, AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmVpextrw<AsmRegister32, AsmRegisterXmm, u32> for CodeAssembler

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

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

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

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

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

impl CodeAsmVpinsrd<AsmRegisterXmm, AsmRegisterXmm, AsmRegister32, i32> for CodeAssembler

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

impl CodeAsmVpinsrd<AsmRegisterXmm, AsmRegisterXmm, AsmRegister32, u32> for CodeAssembler

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

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

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

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

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

impl CodeAsmVpmovmskb<AsmRegister32, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVpmovmskb<AsmRegister32, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmWrfsbase<AsmRegister32> for CodeAssembler

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

impl CodeAsmWrgsbase<AsmRegister32> for CodeAssembler

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

impl CodeAsmWrshr<AsmRegister32> for CodeAssembler

fn wrshr(&mut self, op0: AsmRegister32) -> Result<(), IcedError>

impl CodeAsmWrssd<AsmMemoryOperand, AsmRegister32> for CodeAssembler

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

impl CodeAsmWrussd<AsmMemoryOperand, AsmRegister32> for CodeAssembler

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

impl CodeAsmXadd<AsmMemoryOperand, AsmRegister32> for CodeAssembler

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

impl CodeAsmXadd<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmXbts<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmXbts<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmXchg<AsmMemoryOperand, AsmRegister32> for CodeAssembler

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

impl CodeAsmXchg<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmXor<AsmMemoryOperand, AsmRegister32> for CodeAssembler

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

impl CodeAsmXor<AsmRegister32, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmXor<AsmRegister32, AsmRegister32> for CodeAssembler

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

impl CodeAsmXor<AsmRegister32, i32> for CodeAssembler

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

impl CodeAsmXor<AsmRegister32, u32> for CodeAssembler

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

impl Debug for AsmRegister32

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

Formats the value using the given formatter.

impl From<AsmRegister32> for Register

fn from(reg: AsmRegister32) -> Self

Converts to this type from the input type.

impl Mul<AsmRegister32> for i16

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<AsmRegister32> for i32

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<AsmRegister32> for i64

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<AsmRegister32> for i8

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<AsmRegister32> for isize

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<AsmRegister32> for u16

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<AsmRegister32> for u32

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<AsmRegister32> for u64

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<AsmRegister32> for u8

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<AsmRegister32> for usize

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<i16> for AsmRegister32

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<i32> for AsmRegister32

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<i64> for AsmRegister32

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<i8> for AsmRegister32

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<isize> for AsmRegister32

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<u16> for AsmRegister32

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<u32> for AsmRegister32

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<u64> for AsmRegister32

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<u8> for AsmRegister32

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<usize> for AsmRegister32

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

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

Performs the * operation.

impl PartialEq<AsmRegister32> for AsmRegister32

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

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

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

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

impl Sub<i16> for AsmRegister32

type Output = AsmMemoryOperand

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<i32> for AsmRegister32

type Output = AsmMemoryOperand

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<i64> for AsmRegister32

type Output = AsmMemoryOperand

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<i8> for AsmRegister32

type Output = AsmMemoryOperand

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<isize> for AsmRegister32

type Output = AsmMemoryOperand

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<u16> for AsmRegister32

type Output = AsmMemoryOperand

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<u32> for AsmRegister32

type Output = AsmMemoryOperand

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<u64> for AsmRegister32

type Output = AsmMemoryOperand

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<u8> for AsmRegister32

type Output = AsmMemoryOperand

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<usize> for AsmRegister32

type Output = AsmMemoryOperand

The resulting type after applying the - operator.

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

Performs the - operation.

impl Copy for AsmRegister32

impl Eq for AsmRegister32

impl StructuralEq for AsmRegister32

impl StructuralPartialEq for AsmRegister32