Skip to main content

AsmRegisterMm

Struct AsmRegisterMm 

pub struct AsmRegisterMm { /* private fields */ }
Expand description

All MMX 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::mm::*;

Trait Implementations§

§

impl Clone for AsmRegisterMm

§

fn clone(&self) -> AsmRegisterMm

Returns a duplicate of the value. Read more
1.0.0 (const: unstable) · Source§

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

Performs copy-assignment from source. Read more
§

impl CodeAsmCvtpd2pi<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmCvtpd2pi<AsmRegisterMm, AsmRegisterXmm> for CodeAssembler

§

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

§

impl CodeAsmCvtpi2pd<AsmRegisterXmm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmCvtpi2ps<AsmRegisterXmm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmCvtps2pi<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmCvtps2pi<AsmRegisterMm, AsmRegisterXmm> for CodeAssembler

§

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

§

impl CodeAsmCvttpd2pi<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmCvttpd2pi<AsmRegisterMm, AsmRegisterXmm> for CodeAssembler

§

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

§

impl CodeAsmCvttps2pi<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmCvttps2pi<AsmRegisterMm, AsmRegisterXmm> for CodeAssembler

§

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

§

impl CodeAsmMaskmovq<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmMovd<AsmMemoryOperand, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmMovd<AsmRegister32, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmMovd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmMovd<AsmRegisterMm, AsmRegister32> for CodeAssembler

§

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

§

impl CodeAsmMovdq2q<AsmRegisterMm, AsmRegisterXmm> for CodeAssembler

§

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

§

impl CodeAsmMovntq<AsmMemoryOperand, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmMovq2dq<AsmRegisterXmm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmMovq<AsmMemoryOperand, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmMovq<AsmRegister64, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmMovq<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmMovq<AsmRegisterMm, AsmRegister64> for CodeAssembler

§

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

§

impl CodeAsmMovq<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPabsb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPabsb<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPabsd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPabsd<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPabsw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPabsw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPackssdw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPackssdw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPacksswb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPacksswb<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPackuswb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPackuswb<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPaddb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPaddb<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPaddd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPaddd<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPaddq<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPaddq<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPaddsb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPaddsb<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPaddsiw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPaddsiw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPaddsw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPaddsw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPaddusb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPaddusb<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPaddusw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPaddusw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPaddw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPaddw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPalignr<AsmRegisterMm, AsmMemoryOperand, i32> for CodeAssembler

§

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

§

impl CodeAsmPalignr<AsmRegisterMm, AsmMemoryOperand, u32> for CodeAssembler

§

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

§

impl CodeAsmPalignr<AsmRegisterMm, AsmRegisterMm, i32> for CodeAssembler

§

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

§

impl CodeAsmPalignr<AsmRegisterMm, AsmRegisterMm, u32> for CodeAssembler

§

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

§

impl CodeAsmPand<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPand<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPandn<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPandn<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPaveb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPaveb<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPavgb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPavgb<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPavgusb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPavgusb<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPavgw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPavgw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPcmpeqb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPcmpeqb<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPcmpeqd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPcmpeqd<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPcmpeqw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPcmpeqw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPcmpgtb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPcmpgtb<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPcmpgtd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPcmpgtd<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPcmpgtw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPcmpgtw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPdistib<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

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

§

impl CodeAsmPextrw<AsmRegister64, AsmRegisterMm, u32> for CodeAssembler

§

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

§

impl CodeAsmPf2id<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPf2id<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPf2iw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPf2iw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPfacc<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPfacc<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPfadd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPfadd<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPfcmpeq<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPfcmpeq<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPfcmpge<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPfcmpge<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPfcmpgt<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPfcmpgt<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPfmax<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPfmax<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPfmin<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPfmin<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPfmul<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPfmul<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPfnacc<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPfnacc<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPfpnacc<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPfpnacc<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPfrcp<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPfrcp<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPfrcpit1<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPfrcpit1<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPfrcpit2<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPfrcpit2<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPfrcpv<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPfrcpv<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPfrsqit1<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPfrsqit1<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPfrsqrt<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPfrsqrt<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPfrsqrtv<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPfrsqrtv<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPfsub<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPfsub<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPfsubr<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPfsubr<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPhaddd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPhaddd<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPhaddsw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPhaddsw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPhaddw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPhaddw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPhsubd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPhsubd<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPhsubsw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPhsubsw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPhsubw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPhsubw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPi2fd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPi2fd<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPi2fw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPi2fw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPinsrw<AsmRegisterMm, AsmMemoryOperand, i32> for CodeAssembler

§

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

§

impl CodeAsmPinsrw<AsmRegisterMm, AsmMemoryOperand, u32> for CodeAssembler

§

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

§

impl CodeAsmPinsrw<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<AsmRegisterMm, AsmRegister64, i32> for CodeAssembler

§

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

§

impl CodeAsmPinsrw<AsmRegisterMm, AsmRegister64, u32> for CodeAssembler

§

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

§

impl CodeAsmPmachriw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPmaddubsw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPmaddubsw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPmaddwd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPmaddwd<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPmagw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPmagw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPmaxsw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPmaxsw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPmaxub<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPmaxub<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPminsw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPminsw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPminub<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPminub<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPmovmskb<AsmRegister32, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPmovmskb<AsmRegister64, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPmulhriw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPmulhriw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPmulhrsw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPmulhrsw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPmulhrw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPmulhrw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPmulhrw_cyrix<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

impl CodeAsmPmulhrw_cyrix<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPmulhuw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPmulhuw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPmulhw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPmulhw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPmullw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPmullw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPmuludq<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPmuludq<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPmvgezb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPmvlzb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPmvnzb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPmvzb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPor<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPor<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPsadbw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPsadbw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPshufb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPshufb<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPshufw<AsmRegisterMm, AsmMemoryOperand, i32> for CodeAssembler

§

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

§

impl CodeAsmPshufw<AsmRegisterMm, AsmMemoryOperand, u32> for CodeAssembler

§

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

§

impl CodeAsmPshufw<AsmRegisterMm, AsmRegisterMm, i32> for CodeAssembler

§

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

§

impl CodeAsmPshufw<AsmRegisterMm, AsmRegisterMm, u32> for CodeAssembler

§

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

§

impl CodeAsmPsignb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPsignb<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPsignd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPsignd<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPsignw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPsignw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPslld<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPslld<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPslld<AsmRegisterMm, i32> for CodeAssembler

§

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

§

impl CodeAsmPslld<AsmRegisterMm, u32> for CodeAssembler

§

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

§

impl CodeAsmPsllq<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPsllq<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPsllq<AsmRegisterMm, i32> for CodeAssembler

§

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

§

impl CodeAsmPsllq<AsmRegisterMm, u32> for CodeAssembler

§

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

§

impl CodeAsmPsllw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPsllw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPsllw<AsmRegisterMm, i32> for CodeAssembler

§

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

§

impl CodeAsmPsllw<AsmRegisterMm, u32> for CodeAssembler

§

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

§

impl CodeAsmPsrad<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPsrad<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPsrad<AsmRegisterMm, i32> for CodeAssembler

§

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

§

impl CodeAsmPsrad<AsmRegisterMm, u32> for CodeAssembler

§

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

§

impl CodeAsmPsraw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPsraw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPsraw<AsmRegisterMm, i32> for CodeAssembler

§

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

§

impl CodeAsmPsraw<AsmRegisterMm, u32> for CodeAssembler

§

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

§

impl CodeAsmPsrld<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPsrld<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPsrld<AsmRegisterMm, i32> for CodeAssembler

§

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

§

impl CodeAsmPsrld<AsmRegisterMm, u32> for CodeAssembler

§

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

§

impl CodeAsmPsrlq<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPsrlq<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPsrlq<AsmRegisterMm, i32> for CodeAssembler

§

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

§

impl CodeAsmPsrlq<AsmRegisterMm, u32> for CodeAssembler

§

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

§

impl CodeAsmPsrlw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPsrlw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPsrlw<AsmRegisterMm, i32> for CodeAssembler

§

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

§

impl CodeAsmPsrlw<AsmRegisterMm, u32> for CodeAssembler

§

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

§

impl CodeAsmPsubb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPsubb<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPsubd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPsubd<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPsubq<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPsubq<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPsubsb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPsubsb<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPsubsiw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPsubsiw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPsubsw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPsubsw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPsubusb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPsubusb<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPsubusw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPsubusw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPsubw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPsubw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPswapd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPswapd<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPunpckhbw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPunpckhbw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPunpckhdq<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPunpckhdq<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPunpckhwd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPunpckhwd<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPunpcklbw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPunpcklbw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPunpckldq<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPunpckldq<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPunpcklwd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPunpcklwd<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl CodeAsmPxor<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

§

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

§

impl CodeAsmPxor<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

§

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

§

impl Copy for AsmRegisterMm

§

impl Debug for AsmRegisterMm

§

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

Formats the value using the given formatter. Read more
§

impl Eq for AsmRegisterMm

§

impl PartialEq for AsmRegisterMm

§

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

Equality operator ==. Read more
1.0.0 (const: unstable) · Source§

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

Inequality operator !=. Read more
§

impl StructuralPartialEq for AsmRegisterMm

Auto Trait Implementations§

Blanket Implementations§

Source§

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

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

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

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

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

Source§

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

Mutably borrows from an owned value. Read more
Source§

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

Source§

unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dest. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

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

Source§

fn into(self) -> U

Calls U::from(self).

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

Source§

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

Source§

type Owned = T

The resulting type after obtaining ownership.
Source§

fn to_owned(&self) -> T

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

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

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

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

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

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

Performs the conversion.
Source§

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

Source§

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

The type returned in the event of a conversion error.
Source§

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

Performs the conversion.