Struct iced_x86::code_asm::AsmRegister16

#[repr(transparent)]
pub struct AsmRegister16 { /* private fields */ }

All 16-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::gpr16::*;

Trait Implementations

impl Add<AsmMemoryOperand> for AsmRegister16

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<AsmRegister16> for AsmMemoryOperand

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<AsmRegister16> for AsmRegister16

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<AsmRegister16> for i16

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<AsmRegister16> for i32

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<AsmRegister16> for i64

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<AsmRegister16> for i8

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<AsmRegister16> for isize

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<AsmRegister16> for u16

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<AsmRegister16> for u32

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<AsmRegister16> for u64

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<AsmRegister16> for u8

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<AsmRegister16> for usize

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<i16> for AsmRegister16

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<i32> for AsmRegister16

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<i64> for AsmRegister16

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<i8> for AsmRegister16

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<isize> for AsmRegister16

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<u16> for AsmRegister16

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<u32> for AsmRegister16

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<u64> for AsmRegister16

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<u8> for AsmRegister16

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<usize> for AsmRegister16

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

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

Performs the + operation.

impl Clone for AsmRegister16

fn clone(&self) -> AsmRegister16

Returns a copy of the value.

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

Performs copy-assignment from source.

impl CodeAsmAdc<AsmMemoryOperand, AsmRegister16> for CodeAssembler

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

impl CodeAsmAdc<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmAdc<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmAdc<AsmRegister16, i32> for CodeAssembler

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

impl CodeAsmAdc<AsmRegister16, u32> for CodeAssembler

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

impl CodeAsmAdd<AsmMemoryOperand, AsmRegister16> for CodeAssembler

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

impl CodeAsmAdd<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmAdd<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmAdd<AsmRegister16, i32> for CodeAssembler

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

impl CodeAsmAdd<AsmRegister16, u32> for CodeAssembler

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

impl CodeAsmAnd<AsmMemoryOperand, AsmRegister16> for CodeAssembler

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

impl CodeAsmAnd<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmAnd<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmAnd<AsmRegister16, i32> for CodeAssembler

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

impl CodeAsmAnd<AsmRegister16, u32> for CodeAssembler

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

impl CodeAsmArpl<AsmMemoryOperand, AsmRegister16> for CodeAssembler

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

impl CodeAsmArpl<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmBound<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmBsf<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmBsf<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmBsr<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmBsr<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmBswap<AsmRegister16> for CodeAssembler

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

impl CodeAsmBt<AsmMemoryOperand, AsmRegister16> for CodeAssembler

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

impl CodeAsmBt<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmBt<AsmRegister16, i32> for CodeAssembler

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

impl CodeAsmBt<AsmRegister16, u32> for CodeAssembler

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

impl CodeAsmBtc<AsmMemoryOperand, AsmRegister16> for CodeAssembler

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

impl CodeAsmBtc<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmBtc<AsmRegister16, i32> for CodeAssembler

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

impl CodeAsmBtc<AsmRegister16, u32> for CodeAssembler

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

impl CodeAsmBtr<AsmMemoryOperand, AsmRegister16> for CodeAssembler

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

impl CodeAsmBtr<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmBtr<AsmRegister16, i32> for CodeAssembler

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

impl CodeAsmBtr<AsmRegister16, u32> for CodeAssembler

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

impl CodeAsmBts<AsmMemoryOperand, AsmRegister16> for CodeAssembler

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

impl CodeAsmBts<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmBts<AsmRegister16, i32> for CodeAssembler

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

impl CodeAsmBts<AsmRegister16, u32> for CodeAssembler

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

impl CodeAsmCall<AsmRegister16> for CodeAssembler

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

impl CodeAsmCmova<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmova<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmCmovae<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovae<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmCmovb<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovb<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmCmovbe<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovbe<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmCmovc<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovc<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmCmove<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmove<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmCmovg<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovg<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmCmovge<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovge<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmCmovl<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovl<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmCmovle<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovle<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmCmovna<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovna<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmCmovnae<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovnae<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmCmovnb<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovnb<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmCmovnbe<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovnbe<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmCmovnc<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovnc<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmCmovne<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovne<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmCmovng<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovng<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmCmovnge<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovnge<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmCmovnl<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovnl<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmCmovnle<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovnle<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmCmovno<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovno<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmCmovnp<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovnp<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmCmovns<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovns<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmCmovnz<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovnz<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmCmovo<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovo<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmCmovp<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovp<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmCmovpe<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovpe<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmCmovpo<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovpo<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmCmovs<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovs<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmCmovz<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmovz<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmCmp<AsmMemoryOperand, AsmRegister16> for CodeAssembler

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

impl CodeAsmCmp<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmCmp<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmCmp<AsmRegister16, i32> for CodeAssembler

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

impl CodeAsmCmp<AsmRegister16, u32> for CodeAssembler

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

impl CodeAsmCmpxchg<AsmMemoryOperand, AsmRegister16> for CodeAssembler

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

impl CodeAsmCmpxchg<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmCrc32<AsmRegister32, AsmRegister16> for CodeAssembler

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

impl CodeAsmDec<AsmRegister16> for CodeAssembler

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

impl CodeAsmDiv<AsmRegister16> for CodeAssembler

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

impl CodeAsmEnqcmd<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmEnqcmds<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmFnstdw<AsmRegister16> for CodeAssembler

fn fnstdw(&mut self, op0: AsmRegister16) -> Result<(), IcedError>

impl CodeAsmFnstsg<AsmRegister16> for CodeAssembler

fn fnstsg(&mut self, op0: AsmRegister16) -> Result<(), IcedError>

impl CodeAsmFnstsw<AsmRegister16> for CodeAssembler

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

impl CodeAsmFstdw<AsmRegister16> for CodeAssembler

fn fstdw(&mut self, op0: AsmRegister16) -> Result<(), IcedError>

impl CodeAsmFstsg<AsmRegister16> for CodeAssembler

fn fstsg(&mut self, op0: AsmRegister16) -> Result<(), IcedError>

impl CodeAsmFstsw<AsmRegister16> for CodeAssembler

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

impl CodeAsmIbts<AsmMemoryOperand, AsmRegister16> for CodeAssembler

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

impl CodeAsmIbts<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmIdiv<AsmRegister16> for CodeAssembler

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

impl CodeAsmImul<AsmRegister16> for CodeAssembler

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

impl CodeAsmImul2<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmImul2<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmImul3<AsmRegister16, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmImul3<AsmRegister16, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmImul3<AsmRegister16, AsmRegister16, i32> for CodeAssembler

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

impl CodeAsmImul3<AsmRegister16, AsmRegister16, u32> for CodeAssembler

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

impl CodeAsmIn<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmIn<AsmRegister16, i32> for CodeAssembler

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

impl CodeAsmIn<AsmRegister16, u32> for CodeAssembler

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

impl CodeAsmIn<AsmRegister32, AsmRegister16> for CodeAssembler

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

impl CodeAsmIn<AsmRegister8, AsmRegister16> for CodeAssembler

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

impl CodeAsmInc<AsmRegister16> for CodeAssembler

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

impl CodeAsmJmp<AsmRegister16> for CodeAssembler

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

impl CodeAsmJmpe<AsmRegister16> for CodeAssembler

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

impl CodeAsmLar<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmLar<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmLds<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmLea<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmLes<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmLfs<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmLgs<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmLkgs<AsmRegister16> for CodeAssembler

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

impl CodeAsmLldt<AsmRegister16> for CodeAssembler

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

impl CodeAsmLmsw<AsmRegister16> for CodeAssembler

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

impl CodeAsmLsl<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmLsl<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmLss<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmLtr<AsmRegister16> for CodeAssembler

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

impl CodeAsmLzcnt<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmLzcnt<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmMov<AsmMemoryOperand, AsmRegister16> for CodeAssembler

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

impl CodeAsmMov<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMov<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmMov<AsmRegister16, AsmRegisterSegment> for CodeAssembler

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

impl CodeAsmMov<AsmRegister16, i32> for CodeAssembler

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

impl CodeAsmMov<AsmRegister16, u32> for CodeAssembler

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

impl CodeAsmMov<AsmRegisterSegment, AsmRegister16> for CodeAssembler

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

impl CodeAsmMovbe<AsmMemoryOperand, AsmRegister16> for CodeAssembler

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

impl CodeAsmMovbe<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMovdir64b<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMovsx<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMovsx<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmMovsx<AsmRegister16, AsmRegister8> for CodeAssembler

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

impl CodeAsmMovsx<AsmRegister32, AsmRegister16> for CodeAssembler

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

impl CodeAsmMovsx<AsmRegister64, AsmRegister16> for CodeAssembler

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

impl CodeAsmMovsxd<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMovsxd<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmMovzx<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmMovzx<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmMovzx<AsmRegister16, AsmRegister8> for CodeAssembler

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

impl CodeAsmMovzx<AsmRegister32, AsmRegister16> for CodeAssembler

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

impl CodeAsmMovzx<AsmRegister64, AsmRegister16> for CodeAssembler

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

impl CodeAsmMul<AsmRegister16> for CodeAssembler

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

impl CodeAsmNeg<AsmRegister16> for CodeAssembler

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

impl CodeAsmNop1<AsmRegister16> for CodeAssembler

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

impl CodeAsmNot<AsmRegister16> for CodeAssembler

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

impl CodeAsmOr<AsmMemoryOperand, AsmRegister16> for CodeAssembler

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

impl CodeAsmOr<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmOr<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmOr<AsmRegister16, i32> for CodeAssembler

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

impl CodeAsmOr<AsmRegister16, u32> for CodeAssembler

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

impl CodeAsmOut<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmOut<AsmRegister16, AsmRegister32> for CodeAssembler

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

impl CodeAsmOut<AsmRegister16, AsmRegister8> for CodeAssembler

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

impl CodeAsmOut<i32, AsmRegister16> for CodeAssembler

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

impl CodeAsmOut<u32, AsmRegister16> for CodeAssembler

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

impl CodeAsmPop<AsmRegister16> for CodeAssembler

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

impl CodeAsmPopcnt<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmPopcnt<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmPush<AsmRegister16> for CodeAssembler

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

impl CodeAsmRcl<AsmRegister16, AsmRegister8> for CodeAssembler

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

impl CodeAsmRcl<AsmRegister16, i32> for CodeAssembler

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

impl CodeAsmRcl<AsmRegister16, u32> for CodeAssembler

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

impl CodeAsmRcr<AsmRegister16, AsmRegister8> for CodeAssembler

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

impl CodeAsmRcr<AsmRegister16, i32> for CodeAssembler

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

impl CodeAsmRcr<AsmRegister16, u32> for CodeAssembler

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

impl CodeAsmRdrand<AsmRegister16> for CodeAssembler

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

impl CodeAsmRdseed<AsmRegister16> for CodeAssembler

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

impl CodeAsmReservednop_0f0d<AsmMemoryOperand, AsmRegister16> for CodeAssembler

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

impl CodeAsmReservednop_0f0d<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmReservednop_0f18<AsmMemoryOperand, AsmRegister16> for CodeAssembler

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

impl CodeAsmReservednop_0f18<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmReservednop_0f19<AsmMemoryOperand, AsmRegister16> for CodeAssembler

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

impl CodeAsmReservednop_0f19<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmReservednop_0f1a<AsmMemoryOperand, AsmRegister16> for CodeAssembler

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

impl CodeAsmReservednop_0f1a<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmReservednop_0f1b<AsmMemoryOperand, AsmRegister16> for CodeAssembler

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

impl CodeAsmReservednop_0f1b<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmReservednop_0f1c<AsmMemoryOperand, AsmRegister16> for CodeAssembler

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

impl CodeAsmReservednop_0f1c<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmReservednop_0f1d<AsmMemoryOperand, AsmRegister16> for CodeAssembler

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

impl CodeAsmReservednop_0f1d<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmReservednop_0f1e<AsmMemoryOperand, AsmRegister16> for CodeAssembler

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

impl CodeAsmReservednop_0f1e<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmReservednop_0f1f<AsmMemoryOperand, AsmRegister16> for CodeAssembler

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

impl CodeAsmReservednop_0f1f<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmRol<AsmRegister16, AsmRegister8> for CodeAssembler

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

impl CodeAsmRol<AsmRegister16, i32> for CodeAssembler

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

impl CodeAsmRol<AsmRegister16, u32> for CodeAssembler

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

impl CodeAsmRor<AsmRegister16, AsmRegister8> for CodeAssembler

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

impl CodeAsmRor<AsmRegister16, i32> for CodeAssembler

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

impl CodeAsmRor<AsmRegister16, u32> for CodeAssembler

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

impl CodeAsmSal<AsmRegister16, AsmRegister8> for CodeAssembler

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

impl CodeAsmSal<AsmRegister16, i32> for CodeAssembler

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

impl CodeAsmSal<AsmRegister16, u32> for CodeAssembler

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

impl CodeAsmSar<AsmRegister16, AsmRegister8> for CodeAssembler

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

impl CodeAsmSar<AsmRegister16, i32> for CodeAssembler

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

impl CodeAsmSar<AsmRegister16, u32> for CodeAssembler

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

impl CodeAsmSbb<AsmMemoryOperand, AsmRegister16> for CodeAssembler

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

impl CodeAsmSbb<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmSbb<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmSbb<AsmRegister16, i32> for CodeAssembler

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

impl CodeAsmSbb<AsmRegister16, u32> for CodeAssembler

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

impl CodeAsmShl<AsmRegister16, AsmRegister8> for CodeAssembler

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

impl CodeAsmShl<AsmRegister16, i32> for CodeAssembler

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

impl CodeAsmShl<AsmRegister16, u32> for CodeAssembler

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

impl CodeAsmShld<AsmMemoryOperand, AsmRegister16, AsmRegister8> for CodeAssembler

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

impl CodeAsmShld<AsmMemoryOperand, AsmRegister16, i32> for CodeAssembler

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

impl CodeAsmShld<AsmMemoryOperand, AsmRegister16, u32> for CodeAssembler

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

impl CodeAsmShld<AsmRegister16, AsmRegister16, AsmRegister8> for CodeAssembler

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

impl CodeAsmShld<AsmRegister16, AsmRegister16, i32> for CodeAssembler

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

impl CodeAsmShld<AsmRegister16, AsmRegister16, u32> for CodeAssembler

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

impl CodeAsmShr<AsmRegister16, AsmRegister8> for CodeAssembler

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

impl CodeAsmShr<AsmRegister16, i32> for CodeAssembler

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

impl CodeAsmShr<AsmRegister16, u32> for CodeAssembler

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

impl CodeAsmShrd<AsmMemoryOperand, AsmRegister16, AsmRegister8> for CodeAssembler

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

impl CodeAsmShrd<AsmMemoryOperand, AsmRegister16, i32> for CodeAssembler

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

impl CodeAsmShrd<AsmMemoryOperand, AsmRegister16, u32> for CodeAssembler

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

impl CodeAsmShrd<AsmRegister16, AsmRegister16, AsmRegister8> for CodeAssembler

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

impl CodeAsmShrd<AsmRegister16, AsmRegister16, i32> for CodeAssembler

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

impl CodeAsmShrd<AsmRegister16, AsmRegister16, u32> for CodeAssembler

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

impl CodeAsmSldt<AsmRegister16> for CodeAssembler

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

impl CodeAsmSmsw<AsmRegister16> for CodeAssembler

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

impl CodeAsmStr<AsmRegister16> for CodeAssembler

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

impl CodeAsmSub<AsmMemoryOperand, AsmRegister16> for CodeAssembler

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

impl CodeAsmSub<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmSub<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmSub<AsmRegister16, i32> for CodeAssembler

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

impl CodeAsmSub<AsmRegister16, u32> for CodeAssembler

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

impl CodeAsmTest<AsmMemoryOperand, AsmRegister16> for CodeAssembler

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

impl CodeAsmTest<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmTest<AsmRegister16, i32> for CodeAssembler

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

impl CodeAsmTest<AsmRegister16, u32> for CodeAssembler

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

impl CodeAsmTzcnt<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmTzcnt<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmUd02<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmUd02<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmUd1<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmUd1<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmUmonitor<AsmRegister16> for CodeAssembler

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

impl CodeAsmUmov<AsmMemoryOperand, AsmRegister16> for CodeAssembler

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

impl CodeAsmUmov<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmUmov<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmVerr<AsmRegister16> for CodeAssembler

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

impl CodeAsmVerw<AsmRegister16> for CodeAssembler

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

impl CodeAsmXadd<AsmMemoryOperand, AsmRegister16> for CodeAssembler

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

impl CodeAsmXadd<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmXbts<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmXbts<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmXchg<AsmMemoryOperand, AsmRegister16> for CodeAssembler

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

impl CodeAsmXchg<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmXor<AsmMemoryOperand, AsmRegister16> for CodeAssembler

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

impl CodeAsmXor<AsmRegister16, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmXor<AsmRegister16, AsmRegister16> for CodeAssembler

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

impl CodeAsmXor<AsmRegister16, i32> for CodeAssembler

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

impl CodeAsmXor<AsmRegister16, u32> for CodeAssembler

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

impl Debug for AsmRegister16

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

Formats the value using the given formatter.

impl From<AsmRegister16> for Register

fn from(reg: AsmRegister16) -> Self

Converts to this type from the input type.

impl PartialEq<AsmRegister16> for AsmRegister16

fn eq(&self, other: &AsmRegister16) -> 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 AsmRegister16

type Output = AsmMemoryOperand

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<i32> for AsmRegister16

type Output = AsmMemoryOperand

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<i64> for AsmRegister16

type Output = AsmMemoryOperand

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<i8> for AsmRegister16

type Output = AsmMemoryOperand

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<isize> for AsmRegister16

type Output = AsmMemoryOperand

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<u16> for AsmRegister16

type Output = AsmMemoryOperand

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<u32> for AsmRegister16

type Output = AsmMemoryOperand

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<u64> for AsmRegister16

type Output = AsmMemoryOperand

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<u8> for AsmRegister16

type Output = AsmMemoryOperand

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<usize> for AsmRegister16

type Output = AsmMemoryOperand

The resulting type after applying the - operator.

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

Performs the - operation.

impl Copy for AsmRegister16

impl Eq for AsmRegister16

impl StructuralEq for AsmRegister16

impl StructuralPartialEq for AsmRegister16