Struct iced_x86::code_asm::AsmRegisterMm

pub struct AsmRegisterMm { /* private fields */ }

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 copy of the value.

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

Performs copy-assignment from source.

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 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 CodeAsmMovq2dq<AsmRegisterXmm, AsmRegisterMm> for CodeAssembler

fn movq2dq( &mut self, op0: AsmRegisterXmm, 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

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

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 Debug for AsmRegisterMm

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

Formats the value using the given formatter.

impl From<AsmRegisterMm> for Register

fn from(reg: AsmRegisterMm) -> Self

Converts to this type from the input type.

impl PartialEq for AsmRegisterMm

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

impl Eq for AsmRegisterMm

impl StructuralEq for AsmRegisterMm

impl StructuralPartialEq for AsmRegisterMm