Skip to main content

Assembler

asmkit::aarch64::assembler

Struct Assembler

pub struct Assembler<'a> {
    pub buffer: &'a mut CodeBuffer,
    /* private fields */
}

Fields§

§buffer: &'a mut CodeBuffer

Implementations§

impl<'a> Assembler<'a>

pub fn new(buffer: &'a mut CodeBuffer) -> Self

pub fn get_label(&mut self) -> Label

pub fn bind_label(&mut self, label: Label)

pub fn load_constant<DST, SRC>(&mut self, dst: DST, src: SRC)
where Self: LoadConstantEmitter<DST, SRC>,

A helper to load a constant address into a register.

Supported variants are:

+------------------+
|  DST  |  SRC     |
+------------------+
|  Gp   | Label    |
|  Gp   | Sym      |
|  Gp   | Constant |
+------------------+

Note that Sym is loaded based on self.buffer.pic() and its distance. If PIC is enabled then GOT is always used. Otherwise, if symbol is near it uses adrp + add combination, and for far symbols Abs8 reloc is used and data is embedded right into code.

pub fn last_error(&self) -> Option<AsmError>

pub fn emit_n(&mut self, id: impl Into<u32>, ops: &[&Operand])

impl Assembler<'_>

pub fn adc<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: AdcEmitter<T0, T1, T2>,

pub fn adcs<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: AdcsEmitter<T0, T1, T2>,

pub fn add<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: AddEmitter<T0, T1, T2>,

pub fn add_4<T0, T1, T2, T3>(&mut self, op0: T0, op1: T1, op2: T2, op3: T3)
where Self: Add4Emitter<T0, T1, T2, T3>,

pub fn adds<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: AddsEmitter<T0, T1, T2>,

pub fn adds_4<T0, T1, T2, T3>(&mut self, op0: T0, op1: T1, op2: T2, op3: T3)
where Self: Adds4Emitter<T0, T1, T2, T3>,

pub fn adr<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: AdrEmitter<T0, T1>,

pub fn adrp<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: AdrpEmitter<T0, T1>,

pub fn and_<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: AndEmitter<T0, T1, T2>,

pub fn and__4<T0, T1, T2, T3>(&mut self, op0: T0, op1: T1, op2: T2, op3: T3)
where Self: And4Emitter<T0, T1, T2, T3>,

pub fn ands<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: AndsEmitter<T0, T1, T2>,

pub fn ands_4<T0, T1, T2, T3>(&mut self, op0: T0, op1: T1, op2: T2, op3: T3)
where Self: Ands4Emitter<T0, T1, T2, T3>,

pub fn asr<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: AsrEmitter<T0, T1, T2>,

pub fn asrv<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: AsrvEmitter<T0, T1, T2>,

pub fn at<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: AtEmitter<T0, T1>,

pub fn bfc<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: BfcEmitter<T0, T1, T2>,

pub fn bfi<T0, T1, T2, T3>(&mut self, op0: T0, op1: T1, op2: T2, op3: T3)
where Self: BfiEmitter<T0, T1, T2, T3>,

pub fn bfm<T0, T1, T2, T3>(&mut self, op0: T0, op1: T1, op2: T2, op3: T3)
where Self: BfmEmitter<T0, T1, T2, T3>,

pub fn bfxil<T0, T1, T2, T3>(&mut self, op0: T0, op1: T1, op2: T2, op3: T3)
where Self: BfxilEmitter<T0, T1, T2, T3>,

pub fn bic<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: BicEmitter<T0, T1, T2>,

pub fn bic_4<T0, T1, T2, T3>(&mut self, op0: T0, op1: T1, op2: T2, op3: T3)
where Self: Bic4Emitter<T0, T1, T2, T3>,

pub fn bics<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: BicsEmitter<T0, T1, T2>,

pub fn bics_4<T0, T1, T2, T3>(&mut self, op0: T0, op1: T1, op2: T2, op3: T3)
where Self: Bics4Emitter<T0, T1, T2, T3>,

pub fn brk<T0>(&mut self, op0: T0)
where Self: BrkEmitter<T0>,

pub fn ccmn<T0, T1, T2, T3>(&mut self, op0: T0, op1: T1, op2: T2, op3: T3)
where Self: CcmnEmitter<T0, T1, T2, T3>,

pub fn ccmp<T0, T1, T2, T3>(&mut self, op0: T0, op1: T1, op2: T2, op3: T3)
where Self: CcmpEmitter<T0, T1, T2, T3>,

pub fn cinc<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: CincEmitter<T0, T1, T2>,

pub fn cinv<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: CinvEmitter<T0, T1, T2>,

pub fn clrex<T0>(&mut self, op0: T0)
where Self: ClrexEmitter<T0>,

pub fn cls<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: ClsEmitter<T0, T1>,

pub fn clz<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: ClzEmitter<T0, T1>,

pub fn cmn<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: CmnEmitter<T0, T1>,

pub fn cmn_3<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Cmn3Emitter<T0, T1, T2>,

pub fn cmp<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: CmpEmitter<T0, T1>,

pub fn cmp_3<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Cmp3Emitter<T0, T1, T2>,

pub fn cneg<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: CnegEmitter<T0, T1, T2>,

pub fn csel<T0, T1, T2, T3>(&mut self, op0: T0, op1: T1, op2: T2, op3: T3)
where Self: CselEmitter<T0, T1, T2, T3>,

pub fn cset<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: CsetEmitter<T0, T1>,

pub fn csetm<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: CsetmEmitter<T0, T1>,

pub fn csinc<T0, T1, T2, T3>(&mut self, op0: T0, op1: T1, op2: T2, op3: T3)
where Self: CsincEmitter<T0, T1, T2, T3>,

pub fn csinv<T0, T1, T2, T3>(&mut self, op0: T0, op1: T1, op2: T2, op3: T3)
where Self: CsinvEmitter<T0, T1, T2, T3>,

pub fn csneg<T0, T1, T2, T3>(&mut self, op0: T0, op1: T1, op2: T2, op3: T3)
where Self: CsnegEmitter<T0, T1, T2, T3>,

pub fn dc<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: DcEmitter<T0, T1>,

pub fn dmb<T0>(&mut self, op0: T0)
where Self: DmbEmitter<T0>,

pub fn dsb<T0>(&mut self, op0: T0)
where Self: DsbEmitter<T0>,

pub fn drps(&mut self)
where Self: DrpsEmitter,

pub fn eon<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: EonEmitter<T0, T1, T2>,

pub fn eon_4<T0, T1, T2, T3>(&mut self, op0: T0, op1: T1, op2: T2, op3: T3)
where Self: Eon4Emitter<T0, T1, T2, T3>,

pub fn eor<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: EorEmitter<T0, T1, T2>,

pub fn eor_4<T0, T1, T2, T3>(&mut self, op0: T0, op1: T1, op2: T2, op3: T3)
where Self: Eor4Emitter<T0, T1, T2, T3>,

pub fn eret(&mut self)
where Self: EretEmitter,

pub fn esb(&mut self)
where Self: EsbEmitter,

pub fn extr<T0, T1, T2, T3>(&mut self, op0: T0, op1: T1, op2: T2, op3: T3)
where Self: ExtrEmitter<T0, T1, T2, T3>,

pub fn hlt<T0>(&mut self, op0: T0)
where Self: HltEmitter<T0>,

pub fn hvc<T0>(&mut self, op0: T0)
where Self: HvcEmitter<T0>,

pub fn ic<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: IcEmitter<T0, T1>,

pub fn isb<T0>(&mut self, op0: T0)
where Self: IsbEmitter<T0>,

pub fn lsl<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LslEmitter<T0, T1, T2>,

pub fn lslv<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LslvEmitter<T0, T1, T2>,

pub fn lsr<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LsrEmitter<T0, T1, T2>,

pub fn lsrv<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LsrvEmitter<T0, T1, T2>,

pub fn madd<T0, T1, T2, T3>(&mut self, op0: T0, op1: T1, op2: T2, op3: T3)
where Self: MaddEmitter<T0, T1, T2, T3>,

pub fn mneg<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: MnegEmitter<T0, T1, T2>,

pub fn mov<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: MovEmitter<T0, T1>,

pub fn movk<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: MovkEmitter<T0, T1>,

pub fn movk_3<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Movk3Emitter<T0, T1, T2>,

pub fn movn<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: MovnEmitter<T0, T1>,

pub fn movn_3<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Movn3Emitter<T0, T1, T2>,

pub fn movz<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: MovzEmitter<T0, T1>,

pub fn movz_3<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Movz3Emitter<T0, T1, T2>,

pub fn mrs<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: MrsEmitter<T0, T1>,

pub fn msr<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: MsrEmitter<T0, T1>,

pub fn msub<T0, T1, T2, T3>(&mut self, op0: T0, op1: T1, op2: T2, op3: T3)
where Self: MsubEmitter<T0, T1, T2, T3>,

pub fn mul<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: MulEmitter<T0, T1, T2>,

pub fn mvn<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: MvnEmitter<T0, T1>,

pub fn mvn_3<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Mvn3Emitter<T0, T1, T2>,

pub fn mvn_<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: Mvn_Emitter<T0, T1>,

pub fn mvn__3<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Mvn_3Emitter<T0, T1, T2>,

pub fn neg<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: NegEmitter<T0, T1>,

pub fn neg_3<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Neg3Emitter<T0, T1, T2>,

pub fn negs<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: NegsEmitter<T0, T1>,

pub fn negs_3<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Negs3Emitter<T0, T1, T2>,

pub fn ngc<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: NgcEmitter<T0, T1>,

pub fn ngcs<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: NgcsEmitter<T0, T1>,

pub fn orn<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: OrnEmitter<T0, T1, T2>,

pub fn orn_4<T0, T1, T2, T3>(&mut self, op0: T0, op1: T1, op2: T2, op3: T3)
where Self: Orn4Emitter<T0, T1, T2, T3>,

pub fn orr<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: OrrEmitter<T0, T1, T2>,

pub fn orr_4<T0, T1, T2, T3>(&mut self, op0: T0, op1: T1, op2: T2, op3: T3)
where Self: Orr4Emitter<T0, T1, T2, T3>,

pub fn rbit<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: RbitEmitter<T0, T1>,

pub fn ret<T0>(&mut self, op0: T0)
where Self: RetEmitter<T0>,

pub fn rev<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: RevEmitter<T0, T1>,

pub fn rev16<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: Rev16Emitter<T0, T1>,

pub fn rev32<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: Rev32Emitter<T0, T1>,

pub fn rev64<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: Rev64Emitter<T0, T1>,

pub fn ror<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: RorEmitter<T0, T1, T2>,

pub fn rorv<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: RorvEmitter<T0, T1, T2>,

pub fn sbc<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: SbcEmitter<T0, T1, T2>,

pub fn sbcs<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: SbcsEmitter<T0, T1, T2>,

pub fn sbfiz<T0, T1, T2, T3>(&mut self, op0: T0, op1: T1, op2: T2, op3: T3)
where Self: SbfizEmitter<T0, T1, T2, T3>,

pub fn sbfm<T0, T1, T2, T3>(&mut self, op0: T0, op1: T1, op2: T2, op3: T3)
where Self: SbfmEmitter<T0, T1, T2, T3>,

pub fn sbfx<T0, T1, T2, T3>(&mut self, op0: T0, op1: T1, op2: T2, op3: T3)
where Self: SbfxEmitter<T0, T1, T2, T3>,

pub fn sdiv<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: SdivEmitter<T0, T1, T2>,

pub fn smaddl<T0, T1, T2, T3>(&mut self, op0: T0, op1: T1, op2: T2, op3: T3)
where Self: SmaddlEmitter<T0, T1, T2, T3>,

pub fn smc<T0>(&mut self, op0: T0)
where Self: SmcEmitter<T0>,

pub fn smnegl<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: SmneglEmitter<T0, T1, T2>,

pub fn smsubl<T0, T1, T2, T3>(&mut self, op0: T0, op1: T1, op2: T2, op3: T3)
where Self: SmsublEmitter<T0, T1, T2, T3>,

pub fn smulh<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: SmulhEmitter<T0, T1, T2>,

pub fn smull<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: SmullEmitter<T0, T1, T2>,

pub fn sub<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: SubEmitter<T0, T1, T2>,

pub fn sub_4<T0, T1, T2, T3>(&mut self, op0: T0, op1: T1, op2: T2, op3: T3)
where Self: Sub4Emitter<T0, T1, T2, T3>,

pub fn subs<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: SubsEmitter<T0, T1, T2>,

pub fn subs_4<T0, T1, T2, T3>(&mut self, op0: T0, op1: T1, op2: T2, op3: T3)
where Self: Subs4Emitter<T0, T1, T2, T3>,

pub fn svc<T0>(&mut self, op0: T0)
where Self: SvcEmitter<T0>,

pub fn sxtb<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: SxtbEmitter<T0, T1>,

pub fn sxth<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: SxthEmitter<T0, T1>,

pub fn sxtw<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: SxtwEmitter<T0, T1>,

pub fn sys<T0, T1, T2, T3>(&mut self, op0: T0, op1: T1, op2: T2, op3: T3)
where Self: SysEmitter<T0, T1, T2, T3>,

pub fn sys_5<T0, T1, T2, T3, T4>( &mut self, op0: T0, op1: T1, op2: T2, op3: T3, op4: T4, )
where Self: Sys5Emitter<T0, T1, T2, T3, T4>,

pub fn tlbi<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: TlbiEmitter<T0, T1>,

pub fn tst<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: TstEmitter<T0, T1>,

pub fn tst_3<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Tst3Emitter<T0, T1, T2>,

pub fn udiv<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: UdivEmitter<T0, T1, T2>,

pub fn ubfiz<T0, T1, T2, T3>(&mut self, op0: T0, op1: T1, op2: T2, op3: T3)
where Self: UbfizEmitter<T0, T1, T2, T3>,

pub fn ubfm<T0, T1, T2, T3>(&mut self, op0: T0, op1: T1, op2: T2, op3: T3)
where Self: UbfmEmitter<T0, T1, T2, T3>,

pub fn ubfx<T0, T1, T2, T3>(&mut self, op0: T0, op1: T1, op2: T2, op3: T3)
where Self: UbfxEmitter<T0, T1, T2, T3>,

pub fn umaddl<T0, T1, T2, T3>(&mut self, op0: T0, op1: T1, op2: T2, op3: T3)
where Self: UmaddlEmitter<T0, T1, T2, T3>,

pub fn umnegl<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: UmneglEmitter<T0, T1, T2>,

pub fn umsubl<T0, T1, T2, T3>(&mut self, op0: T0, op1: T1, op2: T2, op3: T3)
where Self: UmsublEmitter<T0, T1, T2, T3>,

pub fn umull<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: UmullEmitter<T0, T1, T2>,

pub fn umulh<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: UmulhEmitter<T0, T1, T2>,

pub fn uxtb<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: UxtbEmitter<T0, T1>,

pub fn uxth<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: UxthEmitter<T0, T1>,

pub fn csdb(&mut self)
where Self: CsdbEmitter,

pub fn dcps1<T0>(&mut self, op0: T0)
where Self: Dcps1Emitter<T0>,

pub fn dcps2<T0>(&mut self, op0: T0)
where Self: Dcps2Emitter<T0>,

pub fn dcps3<T0>(&mut self, op0: T0)
where Self: Dcps3Emitter<T0>,

pub fn pssbb(&mut self)
where Self: PssbbEmitter,

pub fn ssbb(&mut self)
where Self: SsbbEmitter,

pub fn udf<T0>(&mut self, op0: T0)
where Self: UdfEmitter<T0>,

pub fn b<T>(&mut self, op0: T)
where Self: BEmitter<T>,

pub fn b_eq<T0>(&mut self, op0: T0)
where Self: BEmitter<T0>,

pub fn b_ne<T0>(&mut self, op0: T0)
where Self: BEmitter<T0>,

pub fn b_cs<T0>(&mut self, op0: T0)
where Self: BEmitter<T0>,

pub fn b_hs<T0>(&mut self, op0: T0)
where Self: BEmitter<T0>,

pub fn b_cc<T0>(&mut self, op0: T0)
where Self: BEmitter<T0>,

pub fn b_lo<T0>(&mut self, op0: T0)
where Self: BEmitter<T0>,

pub fn b_mi<T0>(&mut self, op0: T0)
where Self: BEmitter<T0>,

pub fn b_pl<T0>(&mut self, op0: T0)
where Self: BEmitter<T0>,

pub fn b_vs<T0>(&mut self, op0: T0)
where Self: BEmitter<T0>,

pub fn b_vc<T0>(&mut self, op0: T0)
where Self: BEmitter<T0>,

pub fn b_hi<T0>(&mut self, op0: T0)
where Self: BEmitter<T0>,

pub fn b_ls<T0>(&mut self, op0: T0)
where Self: BEmitter<T0>,

pub fn b_ge<T0>(&mut self, op0: T0)
where Self: BEmitter<T0>,

pub fn b_lt<T0>(&mut self, op0: T0)
where Self: BEmitter<T0>,

pub fn b_gt<T0>(&mut self, op0: T0)
where Self: BEmitter<T0>,

pub fn b_le<T0>(&mut self, op0: T0)
where Self: BEmitter<T0>,

pub fn b_al<T0>(&mut self, op0: T0)
where Self: BEmitter<T0>,

pub fn bl<T0>(&mut self, op0: T0)
where Self: BlEmitter<T0>,

pub fn blr<T0>(&mut self, op0: T0)
where Self: BlrEmitter<T0>,

pub fn br<T0>(&mut self, op0: T0)
where Self: BrEmitter<T0>,

pub fn cbz<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: CbzEmitter<T0, T1>,

pub fn cbnz<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: CbnzEmitter<T0, T1>,

pub fn tbnz<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: TbnzEmitter<T0, T1, T2>,

pub fn tbz<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: TbzEmitter<T0, T1, T2>,

pub fn cas<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: CasEmitter<T0, T1, T2>,

pub fn casa<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: CasaEmitter<T0, T1, T2>,

pub fn casab<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: CasabEmitter<T0, T1, T2>,

pub fn casah<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: CasahEmitter<T0, T1, T2>,

pub fn casal<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: CasalEmitter<T0, T1, T2>,

pub fn casalb<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: CasalbEmitter<T0, T1, T2>,

pub fn casalh<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: CasalhEmitter<T0, T1, T2>,

pub fn casb<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: CasbEmitter<T0, T1, T2>,

pub fn cash<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: CashEmitter<T0, T1, T2>,

pub fn casl<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: CaslEmitter<T0, T1, T2>,

pub fn caslb<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: CaslbEmitter<T0, T1, T2>,

pub fn caslh<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: CaslhEmitter<T0, T1, T2>,

pub fn casp<T0, T1, T2, T3, T4>( &mut self, op0: T0, op1: T1, op2: T2, op3: T3, op4: T4, )
where Self: CaspEmitter<T0, T1, T2, T3, T4>,

pub fn caspa<T0, T1, T2, T3, T4>( &mut self, op0: T0, op1: T1, op2: T2, op3: T3, op4: T4, )
where Self: CaspaEmitter<T0, T1, T2, T3, T4>,

pub fn caspal<T0, T1, T2, T3, T4>( &mut self, op0: T0, op1: T1, op2: T2, op3: T3, op4: T4, )
where Self: CaspalEmitter<T0, T1, T2, T3, T4>,

pub fn caspl<T0, T1, T2, T3, T4>( &mut self, op0: T0, op1: T1, op2: T2, op3: T3, op4: T4, )
where Self: CasplEmitter<T0, T1, T2, T3, T4>,

pub fn ldadd<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdaddEmitter<T0, T1, T2>,

pub fn ldadda<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdaddaEmitter<T0, T1, T2>,

pub fn ldaddab<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdaddabEmitter<T0, T1, T2>,

pub fn ldaddah<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdaddahEmitter<T0, T1, T2>,

pub fn ldaddal<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdaddalEmitter<T0, T1, T2>,

pub fn ldaddalb<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdaddalbEmitter<T0, T1, T2>,

pub fn ldaddalh<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdaddalhEmitter<T0, T1, T2>,

pub fn ldaddb<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdaddbEmitter<T0, T1, T2>,

pub fn ldaddh<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdaddhEmitter<T0, T1, T2>,

pub fn ldaddl<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdaddlEmitter<T0, T1, T2>,

pub fn ldaddlb<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdaddlbEmitter<T0, T1, T2>,

pub fn ldaddlh<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdaddlhEmitter<T0, T1, T2>,

pub fn ldar<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: LdarEmitter<T0, T1>,

pub fn ldarb<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: LdarbEmitter<T0, T1>,

pub fn ldarh<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: LdarhEmitter<T0, T1>,

pub fn ldaxr<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: LdaxrEmitter<T0, T1>,

pub fn ldaxrb<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: LdaxrbEmitter<T0, T1>,

pub fn ldaxrh<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: LdaxrhEmitter<T0, T1>,

pub fn ldclr<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdclrEmitter<T0, T1, T2>,

pub fn ldclra<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdclraEmitter<T0, T1, T2>,

pub fn ldclrab<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdclrabEmitter<T0, T1, T2>,

pub fn ldclrah<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdclrahEmitter<T0, T1, T2>,

pub fn ldclral<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdclralEmitter<T0, T1, T2>,

pub fn ldclralb<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdclralbEmitter<T0, T1, T2>,

pub fn ldclralh<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdclralhEmitter<T0, T1, T2>,

pub fn ldclrb<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdclrbEmitter<T0, T1, T2>,

pub fn ldclrh<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdclrhEmitter<T0, T1, T2>,

pub fn ldclrl<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdclrlEmitter<T0, T1, T2>,

pub fn ldclrlb<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdclrlbEmitter<T0, T1, T2>,

pub fn ldclrlh<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdclrlhEmitter<T0, T1, T2>,

pub fn ldeor<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdeorEmitter<T0, T1, T2>,

pub fn ldeora<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdeoraEmitter<T0, T1, T2>,

pub fn ldeorab<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdeorabEmitter<T0, T1, T2>,

pub fn ldeorah<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdeorahEmitter<T0, T1, T2>,

pub fn ldeoral<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdeoralEmitter<T0, T1, T2>,

pub fn ldeoralb<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdeoralbEmitter<T0, T1, T2>,

pub fn ldeoralh<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdeoralhEmitter<T0, T1, T2>,

pub fn ldeorb<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdeorbEmitter<T0, T1, T2>,

pub fn ldeorh<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdeorhEmitter<T0, T1, T2>,

pub fn ldeorl<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdeorlEmitter<T0, T1, T2>,

pub fn ldeorlb<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdeorlbEmitter<T0, T1, T2>,

pub fn ldeorlh<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdeorlhEmitter<T0, T1, T2>,

pub fn ldlar<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: LdlarEmitter<T0, T1>,

pub fn ldlarb<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: LdlarbEmitter<T0, T1>,

pub fn ldlarh<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: LdlarhEmitter<T0, T1>,

pub fn ldnp<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdnpEmitter<T0, T1, T2>,

pub fn ldp<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdpEmitter<T0, T1, T2>,

pub fn ldpsw<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdpswEmitter<T0, T1, T2>,

pub fn ldr<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: LdrEmitter<T0, T1>,

pub fn ldrb<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: LdrbEmitter<T0, T1>,

pub fn ldrh<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: LdrhEmitter<T0, T1>,

pub fn ldrsb<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: LdrsbEmitter<T0, T1>,

pub fn ldrsh<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: LdrshEmitter<T0, T1>,

pub fn ldrsw<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: LdrswEmitter<T0, T1>,

pub fn ldset<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdsetEmitter<T0, T1, T2>,

pub fn ldseta<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdsetaEmitter<T0, T1, T2>,

pub fn ldsetab<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdsetabEmitter<T0, T1, T2>,

pub fn ldsetah<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdsetahEmitter<T0, T1, T2>,

pub fn ldsetal<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdsetalEmitter<T0, T1, T2>,

pub fn ldsetalb<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdsetalbEmitter<T0, T1, T2>,

pub fn ldsetalh<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdsetalhEmitter<T0, T1, T2>,

pub fn ldsetb<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdsetbEmitter<T0, T1, T2>,

pub fn ldseth<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdsethEmitter<T0, T1, T2>,

pub fn ldsetl<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdsetlEmitter<T0, T1, T2>,

pub fn ldsetlb<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdsetlbEmitter<T0, T1, T2>,

pub fn ldsetlh<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdsetlhEmitter<T0, T1, T2>,

pub fn ldsmax<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdsmaxEmitter<T0, T1, T2>,

pub fn ldsmaxa<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdsmaxaEmitter<T0, T1, T2>,

pub fn ldsmaxab<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdsmaxabEmitter<T0, T1, T2>,

pub fn ldsmaxah<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdsmaxahEmitter<T0, T1, T2>,

pub fn ldsmaxal<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdsmaxalEmitter<T0, T1, T2>,

pub fn ldsmaxalb<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdsmaxalbEmitter<T0, T1, T2>,

pub fn ldsmaxalh<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdsmaxalhEmitter<T0, T1, T2>,

pub fn ldsmaxb<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdsmaxbEmitter<T0, T1, T2>,

pub fn ldsmaxh<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdsmaxhEmitter<T0, T1, T2>,

pub fn ldsmaxl<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdsmaxlEmitter<T0, T1, T2>,

pub fn ldsmaxlb<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdsmaxlbEmitter<T0, T1, T2>,

pub fn ldsmaxlh<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdsmaxlhEmitter<T0, T1, T2>,

pub fn ldsmin<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdsminEmitter<T0, T1, T2>,

pub fn ldsmina<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdsminaEmitter<T0, T1, T2>,

pub fn ldsminab<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdsminabEmitter<T0, T1, T2>,

pub fn ldsminah<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdsminahEmitter<T0, T1, T2>,

pub fn ldsminal<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdsminalEmitter<T0, T1, T2>,

pub fn ldsminalb<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdsminalbEmitter<T0, T1, T2>,

pub fn ldsminalh<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdsminalhEmitter<T0, T1, T2>,

pub fn ldsminb<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdsminbEmitter<T0, T1, T2>,

pub fn ldsminh<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdsminhEmitter<T0, T1, T2>,

pub fn ldsminl<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdsminlEmitter<T0, T1, T2>,

pub fn ldsminlb<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdsminlbEmitter<T0, T1, T2>,

pub fn ldsminlh<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdsminlhEmitter<T0, T1, T2>,

pub fn ldtr<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: LdtrEmitter<T0, T1>,

pub fn ldtrb<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: LdtrbEmitter<T0, T1>,

pub fn ldtrh<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: LdtrhEmitter<T0, T1>,

pub fn ldtrsb<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: LdtrsbEmitter<T0, T1>,

pub fn ldtrsh<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: LdtrshEmitter<T0, T1>,

pub fn ldtrsw<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: LdtrswEmitter<T0, T1>,

pub fn ldumax<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdumaxEmitter<T0, T1, T2>,

pub fn ldumaxa<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdumaxaEmitter<T0, T1, T2>,

pub fn ldumaxab<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdumaxabEmitter<T0, T1, T2>,

pub fn ldumaxah<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdumaxahEmitter<T0, T1, T2>,

pub fn ldumaxal<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdumaxalEmitter<T0, T1, T2>,

pub fn ldumaxalb<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdumaxalbEmitter<T0, T1, T2>,

pub fn ldumaxalh<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdumaxalhEmitter<T0, T1, T2>,

pub fn ldumaxb<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdumaxbEmitter<T0, T1, T2>,

pub fn ldumaxh<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdumaxhEmitter<T0, T1, T2>,

pub fn ldumaxl<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdumaxlEmitter<T0, T1, T2>,

pub fn ldumaxlb<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdumaxlbEmitter<T0, T1, T2>,

pub fn ldumaxlh<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdumaxlhEmitter<T0, T1, T2>,

pub fn ldumin<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LduminEmitter<T0, T1, T2>,

pub fn ldumina<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LduminaEmitter<T0, T1, T2>,

pub fn lduminab<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LduminabEmitter<T0, T1, T2>,

pub fn lduminah<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LduminahEmitter<T0, T1, T2>,

pub fn lduminal<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LduminalEmitter<T0, T1, T2>,

pub fn lduminalb<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LduminalbEmitter<T0, T1, T2>,

pub fn lduminalh<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LduminalhEmitter<T0, T1, T2>,

pub fn lduminb<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LduminbEmitter<T0, T1, T2>,

pub fn lduminh<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LduminhEmitter<T0, T1, T2>,

pub fn lduminl<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LduminlEmitter<T0, T1, T2>,

pub fn lduminlb<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LduminlbEmitter<T0, T1, T2>,

pub fn lduminlh<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LduminlhEmitter<T0, T1, T2>,

pub fn ldur<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: LdurEmitter<T0, T1>,

pub fn ldurb<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: LdurbEmitter<T0, T1>,

pub fn ldurh<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: LdurhEmitter<T0, T1>,

pub fn ldursb<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: LdursbEmitter<T0, T1>,

pub fn ldursh<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: LdurshEmitter<T0, T1>,

pub fn ldursw<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: LdurswEmitter<T0, T1>,

pub fn ldxp<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdxpEmitter<T0, T1, T2>,

pub fn ldaxp<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: LdaxpEmitter<T0, T1, T2>,

pub fn ldxr<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: LdxrEmitter<T0, T1>,

pub fn ldxrb<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: LdxrbEmitter<T0, T1>,

pub fn ldxrh<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: LdxrhEmitter<T0, T1>,

pub fn prfm<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: PrfmEmitter<T0, T1>,

pub fn stadd<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: StaddEmitter<T0, T1>,

pub fn staddb<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: StaddbEmitter<T0, T1>,

pub fn staddh<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: StaddhEmitter<T0, T1>,

pub fn staddl<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: StaddlEmitter<T0, T1>,

pub fn staddlb<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: StaddlbEmitter<T0, T1>,

pub fn staddlh<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: StaddlhEmitter<T0, T1>,

pub fn stclr<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: StclrEmitter<T0, T1>,

pub fn stclrb<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: StclrbEmitter<T0, T1>,

pub fn stclrh<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: StclrhEmitter<T0, T1>,

pub fn stclrl<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: StclrlEmitter<T0, T1>,

pub fn stclrlb<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: StclrlbEmitter<T0, T1>,

pub fn stclrlh<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: StclrlhEmitter<T0, T1>,

pub fn steor<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: SteorEmitter<T0, T1>,

pub fn steorb<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: SteorbEmitter<T0, T1>,

pub fn steorh<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: SteorhEmitter<T0, T1>,

pub fn steorl<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: SteorlEmitter<T0, T1>,

pub fn steorlb<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: SteorlbEmitter<T0, T1>,

pub fn steorlh<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: SteorlhEmitter<T0, T1>,

pub fn stllr<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: StllrEmitter<T0, T1>,

pub fn stllrb<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: StllrbEmitter<T0, T1>,

pub fn stllrh<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: StllrhEmitter<T0, T1>,

pub fn stlr<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: StlrEmitter<T0, T1>,

pub fn stlrb<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: StlrbEmitter<T0, T1>,

pub fn stlrh<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: StlrhEmitter<T0, T1>,

pub fn stlxr<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: StlxrEmitter<T0, T1, T2>,

pub fn stlxrb<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: StlxrbEmitter<T0, T1, T2>,

pub fn stlxrh<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: StlxrhEmitter<T0, T1, T2>,

pub fn stnp<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: StnpEmitter<T0, T1, T2>,

pub fn stp<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: StpEmitter<T0, T1, T2>,

pub fn str<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: StrEmitter<T0, T1>,

pub fn strb<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: StrbEmitter<T0, T1>,

pub fn strh<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: StrhEmitter<T0, T1>,

pub fn stset<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: StsetEmitter<T0, T1>,

pub fn stsetb<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: StsetbEmitter<T0, T1>,

pub fn stseth<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: StsethEmitter<T0, T1>,

pub fn stsetl<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: StsetlEmitter<T0, T1>,

pub fn stsetlb<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: StsetlbEmitter<T0, T1>,

pub fn stsetlh<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: StsetlhEmitter<T0, T1>,

pub fn stsmax<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: StsmaxEmitter<T0, T1>,

pub fn stsmaxb<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: StsmaxbEmitter<T0, T1>,

pub fn stsmaxh<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: StsmaxhEmitter<T0, T1>,

pub fn stsmaxl<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: StsmaxlEmitter<T0, T1>,

pub fn stsmaxlb<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: StsmaxlbEmitter<T0, T1>,

pub fn stsmaxlh<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: StsmaxlhEmitter<T0, T1>,

pub fn stsmin<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: StsminEmitter<T0, T1>,

pub fn stsminb<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: StsminbEmitter<T0, T1>,

pub fn stsminh<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: StsminhEmitter<T0, T1>,

pub fn stsminl<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: StsminlEmitter<T0, T1>,

pub fn stsminlb<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: StsminlbEmitter<T0, T1>,

pub fn stsminlh<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: StsminlhEmitter<T0, T1>,

pub fn sttr<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: SttrEmitter<T0, T1>,

pub fn sttrb<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: SttrbEmitter<T0, T1>,

pub fn sttrh<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: SttrhEmitter<T0, T1>,

pub fn stumax<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: StumaxEmitter<T0, T1>,

pub fn stumaxb<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: StumaxbEmitter<T0, T1>,

pub fn stumaxh<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: StumaxhEmitter<T0, T1>,

pub fn stumaxl<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: StumaxlEmitter<T0, T1>,

pub fn stumaxlb<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: StumaxlbEmitter<T0, T1>,

pub fn stumaxlh<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: StumaxlhEmitter<T0, T1>,

pub fn stumin<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: StuminEmitter<T0, T1>,

pub fn stuminb<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: StuminbEmitter<T0, T1>,

pub fn stuminh<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: StuminhEmitter<T0, T1>,

pub fn stuminl<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: StuminlEmitter<T0, T1>,

pub fn stuminlb<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: StuminlbEmitter<T0, T1>,

pub fn stuminlh<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: StuminlhEmitter<T0, T1>,

pub fn stur<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: SturEmitter<T0, T1>,

pub fn sturb<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: SturbEmitter<T0, T1>,

pub fn sturh<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: SturhEmitter<T0, T1>,

pub fn stxp<T0, T1, T2, T3>(&mut self, op0: T0, op1: T1, op2: T2, op3: T3)
where Self: StxpEmitter<T0, T1, T2, T3>,

pub fn stlxp<T0, T1, T2, T3>(&mut self, op0: T0, op1: T1, op2: T2, op3: T3)
where Self: StlxpEmitter<T0, T1, T2, T3>,

pub fn stxr<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: StxrEmitter<T0, T1, T2>,

pub fn stxrb<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: StxrbEmitter<T0, T1, T2>,

pub fn stxrh<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: StxrhEmitter<T0, T1, T2>,

pub fn swp<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: SwpEmitter<T0, T1, T2>,

pub fn swpa<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: SwpaEmitter<T0, T1, T2>,

pub fn swpab<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: SwpabEmitter<T0, T1, T2>,

pub fn swpah<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: SwpahEmitter<T0, T1, T2>,

pub fn swpal<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: SwpalEmitter<T0, T1, T2>,

pub fn swpalb<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: SwpalbEmitter<T0, T1, T2>,

pub fn swpalh<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: SwpalhEmitter<T0, T1, T2>,

pub fn swpb<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: SwpbEmitter<T0, T1, T2>,

pub fn swph<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: SwphEmitter<T0, T1, T2>,

pub fn swpl<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: SwplEmitter<T0, T1, T2>,

pub fn swplb<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: SwplbEmitter<T0, T1, T2>,

pub fn swplh<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: SwplhEmitter<T0, T1, T2>,

pub fn bti<T0>(&mut self, op0: T0)
where Self: BtiEmitter<T0>,

pub fn chkfeat<T0>(&mut self, op0: T0)
where Self: ChkfeatEmitter<T0>,

pub fn clrbhb(&mut self)
where Self: ClrbhbEmitter,

pub fn crc32b<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Crc32bEmitter<T0, T1, T2>,

pub fn crc32h<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Crc32hEmitter<T0, T1, T2>,

pub fn crc32w<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Crc32wEmitter<T0, T1, T2>,

pub fn crc32x<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Crc32xEmitter<T0, T1, T2>,

pub fn crc32cb<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Crc32cbEmitter<T0, T1, T2>,

pub fn crc32ch<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Crc32chEmitter<T0, T1, T2>,

pub fn crc32cw<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Crc32cwEmitter<T0, T1, T2>,

pub fn crc32cx<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Crc32cxEmitter<T0, T1, T2>,

pub fn abs<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: AbsEmitter<T0, T1>,

pub fn cnt<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: CntEmitter<T0, T1>,

pub fn ctz<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: CtzEmitter<T0, T1>,

pub fn smax<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: SmaxEmitter<T0, T1, T2>,

pub fn smin<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: SminEmitter<T0, T1, T2>,

pub fn umax<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: UmaxEmitter<T0, T1, T2>,

pub fn umin<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: UminEmitter<T0, T1, T2>,

pub fn dgh(&mut self)
where Self: DghEmitter,

pub fn cfinv(&mut self)
where Self: CfinvEmitter,

pub fn setf8<T0>(&mut self, op0: T0)
where Self: Setf8Emitter<T0>,

pub fn setf16<T0>(&mut self, op0: T0)
where Self: Setf16Emitter<T0>,

pub fn axflag(&mut self)
where Self: AxflagEmitter,

pub fn xaflag(&mut self)
where Self: XaflagEmitter,

pub fn bc_eq<T0>(&mut self, op0: T0)
where Self: BcEmitter<T0>,

pub fn bc_ne<T0>(&mut self, op0: T0)
where Self: BcEmitter<T0>,

pub fn bc_cs<T0>(&mut self, op0: T0)
where Self: BcEmitter<T0>,

pub fn bc_hs<T0>(&mut self, op0: T0)
where Self: BcEmitter<T0>,

pub fn bc_cc<T0>(&mut self, op0: T0)
where Self: BcEmitter<T0>,

pub fn bc_lo<T0>(&mut self, op0: T0)
where Self: BcEmitter<T0>,

pub fn bc_mi<T0>(&mut self, op0: T0)
where Self: BcEmitter<T0>,

pub fn bc_pl<T0>(&mut self, op0: T0)
where Self: BcEmitter<T0>,

pub fn bc_vs<T0>(&mut self, op0: T0)
where Self: BcEmitter<T0>,

pub fn bc_vc<T0>(&mut self, op0: T0)
where Self: BcEmitter<T0>,

pub fn bc_hi<T0>(&mut self, op0: T0)
where Self: BcEmitter<T0>,

pub fn bc_ls<T0>(&mut self, op0: T0)
where Self: BcEmitter<T0>,

pub fn bc_ge<T0>(&mut self, op0: T0)
where Self: BcEmitter<T0>,

pub fn bc_lt<T0>(&mut self, op0: T0)
where Self: BcEmitter<T0>,

pub fn bc_gt<T0>(&mut self, op0: T0)
where Self: BcEmitter<T0>,

pub fn bc_le<T0>(&mut self, op0: T0)
where Self: BcEmitter<T0>,

pub fn bc_al<T0>(&mut self, op0: T0)
where Self: BcEmitter<T0>,

pub fn autda<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: AutdaEmitter<T0, T1>,

pub fn autdb<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: AutdbEmitter<T0, T1>,

pub fn autdza<T0>(&mut self, op0: T0)
where Self: AutdzaEmitter<T0>,

pub fn autdzb<T0>(&mut self, op0: T0)
where Self: AutdzbEmitter<T0>,

pub fn autia<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: AutiaEmitter<T0, T1>,

pub fn autia1716(&mut self)
where Self: Autia1716Emitter,

pub fn autiasp(&mut self)
where Self: AutiaspEmitter,

pub fn autiaz(&mut self)
where Self: AutiazEmitter,

pub fn autib<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: AutibEmitter<T0, T1>,

pub fn autib1716(&mut self)
where Self: Autib1716Emitter,

pub fn autibsp(&mut self)
where Self: AutibspEmitter,

pub fn autibz(&mut self)
where Self: AutibzEmitter,

pub fn autiza<T0>(&mut self, op0: T0)
where Self: AutizaEmitter<T0>,

pub fn autizb<T0>(&mut self, op0: T0)
where Self: AutizbEmitter<T0>,

pub fn gmi<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: GmiEmitter<T0, T1, T2>,

pub fn cmpp<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: CmppEmitter<T0, T1>,

pub fn addg<T0, T1, T2, T3>(&mut self, op0: T0, op1: T1, op2: T2, op3: T3)
where Self: AddgEmitter<T0, T1, T2, T3>,

pub fn ldg<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: LdgEmitter<T0, T1>,

pub fn ldgm<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: LdgmEmitter<T0, T1>,

pub fn ldraa<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: LdraaEmitter<T0, T1>,

pub fn ldrab<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: LdrabEmitter<T0, T1>,

pub fn pacda<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: PacdaEmitter<T0, T1>,

pub fn pacdb<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: PacdbEmitter<T0, T1>,

pub fn pacdza<T0>(&mut self, op0: T0)
where Self: PacdzaEmitter<T0>,

pub fn pacdzb<T0>(&mut self, op0: T0)
where Self: PacdzbEmitter<T0>,

pub fn pacga<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: PacgaEmitter<T0, T1, T2>,

pub fn subp<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: SubpEmitter<T0, T1, T2>,

pub fn subps<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: SubpsEmitter<T0, T1, T2>,

pub fn subg<T0, T1, T2, T3>(&mut self, op0: T0, op1: T1, op2: T2, op3: T3)
where Self: SubgEmitter<T0, T1, T2, T3>,

pub fn st2g<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: St2gEmitter<T0, T1>,

pub fn stg<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: StgEmitter<T0, T1>,

pub fn stgp<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: StgpEmitter<T0, T1, T2>,

pub fn stgm<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: StgmEmitter<T0, T1>,

pub fn stzg<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: StzgEmitter<T0, T1>,

pub fn stz2g<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: Stz2gEmitter<T0, T1>,

pub fn stzgm<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: StzgmEmitter<T0, T1>,

pub fn xpacd<T0>(&mut self, op0: T0)
where Self: XpacdEmitter<T0>,

pub fn xpaci<T0>(&mut self, op0: T0)
where Self: XpaciEmitter<T0>,

pub fn xpaclri(&mut self)
where Self: XpaclriEmitter,

pub fn hint<T0>(&mut self, op0: T0)
where Self: HintEmitter<T0>,

pub fn nop(&mut self)
where Self: NopEmitter,

pub fn sev(&mut self)
where Self: SevEmitter,

pub fn sevl(&mut self)
where Self: SevlEmitter,

pub fn wfe(&mut self)
where Self: WfeEmitter,

pub fn wfi(&mut self)
where Self: WfiEmitter,

pub fn yield(&mut self)
where Self: YieldEmitter,

pub fn addhn<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: AddhnEmitter<T0, T1, T2>,

pub fn addhn2<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Addhn2Emitter<T0, T1, T2>,

pub fn addp<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: AddpEmitter<T0, T1>,

pub fn addp_3<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Addp3Emitter<T0, T1, T2>,

pub fn addv<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: AddvEmitter<T0, T1>,

pub fn bic_2<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: Bic2Emitter<T0, T1>,

pub fn bif<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: BifEmitter<T0, T1, T2>,

pub fn bit<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: BitEmitter<T0, T1, T2>,

pub fn bsl<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: BslEmitter<T0, T1, T2>,

pub fn cmeq<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: CmeqEmitter<T0, T1, T2>,

pub fn cmge<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: CmgeEmitter<T0, T1, T2>,

pub fn cmgt<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: CmgtEmitter<T0, T1, T2>,

pub fn cmhi<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: CmhiEmitter<T0, T1, T2>,

pub fn cmhs<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: CmhsEmitter<T0, T1, T2>,

pub fn cmle<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: CmleEmitter<T0, T1, T2>,

pub fn cmlt<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: CmltEmitter<T0, T1, T2>,

pub fn cmtst<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: CmtstEmitter<T0, T1, T2>,

pub fn dup<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: DupEmitter<T0, T1>,

pub fn ext<T0, T1, T2, T3>(&mut self, op0: T0, op1: T1, op2: T2, op3: T3)
where Self: ExtEmitter<T0, T1, T2, T3>,

pub fn fabd<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: FabdEmitter<T0, T1, T2>,

pub fn fabs<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: FabsEmitter<T0, T1>,

pub fn facge<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: FacgeEmitter<T0, T1, T2>,

pub fn facgt<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: FacgtEmitter<T0, T1, T2>,

pub fn fadd<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: FaddEmitter<T0, T1, T2>,

pub fn faddp<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: FaddpEmitter<T0, T1>,

pub fn faddp_3<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Faddp3Emitter<T0, T1, T2>,

pub fn fccmp<T0, T1, T2, T3>(&mut self, op0: T0, op1: T1, op2: T2, op3: T3)
where Self: FccmpEmitter<T0, T1, T2, T3>,

pub fn fccmpe<T0, T1, T2, T3>(&mut self, op0: T0, op1: T1, op2: T2, op3: T3)
where Self: FccmpeEmitter<T0, T1, T2, T3>,

pub fn fcmeq<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: FcmeqEmitter<T0, T1, T2>,

pub fn fcmge<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: FcmgeEmitter<T0, T1, T2>,

pub fn fcmgt<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: FcmgtEmitter<T0, T1, T2>,

pub fn fcmle<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: FcmleEmitter<T0, T1, T2>,

pub fn fcmlt<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: FcmltEmitter<T0, T1, T2>,

pub fn fcmp<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: FcmpEmitter<T0, T1>,

pub fn fcmpe<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: FcmpeEmitter<T0, T1>,

pub fn fcsel<T0, T1, T2, T3>(&mut self, op0: T0, op1: T1, op2: T2, op3: T3)
where Self: FcselEmitter<T0, T1, T2, T3>,

pub fn fcvt<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: FcvtEmitter<T0, T1>,

pub fn fcvtas<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: FcvtasEmitter<T0, T1>,

pub fn fcvtau<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: FcvtauEmitter<T0, T1>,

pub fn fcvtl<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: FcvtlEmitter<T0, T1>,

pub fn fcvtl2<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: Fcvtl2Emitter<T0, T1>,

pub fn fcvtms<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: FcvtmsEmitter<T0, T1>,

pub fn fcvtmu<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: FcvtmuEmitter<T0, T1>,

pub fn fcvtn<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: FcvtnEmitter<T0, T1>,

pub fn fcvtn2<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: Fcvtn2Emitter<T0, T1>,

pub fn fcvtns<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: FcvtnsEmitter<T0, T1>,

pub fn fcvtnu<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: FcvtnuEmitter<T0, T1>,

pub fn fcvtps<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: FcvtpsEmitter<T0, T1>,

pub fn fcvtpu<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: FcvtpuEmitter<T0, T1>,

pub fn fcvtxn<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: FcvtxnEmitter<T0, T1>,

pub fn fcvtxn2<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: Fcvtxn2Emitter<T0, T1>,

pub fn fcvtzs<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: FcvtzsEmitter<T0, T1>,

pub fn fcvtzs_3<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Fcvtzs3Emitter<T0, T1, T2>,

pub fn fcvtzu<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: FcvtzuEmitter<T0, T1>,

pub fn fcvtzu_3<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Fcvtzu3Emitter<T0, T1, T2>,

pub fn fdiv<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: FdivEmitter<T0, T1, T2>,

pub fn fmadd<T0, T1, T2, T3>(&mut self, op0: T0, op1: T1, op2: T2, op3: T3)
where Self: FmaddEmitter<T0, T1, T2, T3>,

pub fn fmax<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: FmaxEmitter<T0, T1, T2>,

pub fn fmaxnm<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: FmaxnmEmitter<T0, T1, T2>,

pub fn fmaxnmp<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: FmaxnmpEmitter<T0, T1, T2>,

pub fn fmaxnmp_2<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: Fmaxnmp2Emitter<T0, T1>,

pub fn fmaxnmv<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: FmaxnmvEmitter<T0, T1>,

pub fn fmaxp<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: FmaxpEmitter<T0, T1, T2>,

pub fn fmaxp_2<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: Fmaxp2Emitter<T0, T1>,

pub fn fmaxv<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: FmaxvEmitter<T0, T1>,

pub fn fmin<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: FminEmitter<T0, T1, T2>,

pub fn fminnm<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: FminnmEmitter<T0, T1, T2>,

pub fn fminnmv<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: FminnmvEmitter<T0, T1>,

pub fn fminnmp<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: FminnmpEmitter<T0, T1, T2>,

pub fn fminnmp_2<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: Fminnmp2Emitter<T0, T1>,

pub fn fminp<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: FminpEmitter<T0, T1>,

pub fn fminp_3<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Fminp3Emitter<T0, T1, T2>,

pub fn fminv<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: FminvEmitter<T0, T1>,

pub fn fmla<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: FmlaEmitter<T0, T1, T2>,

pub fn fmls<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: FmlsEmitter<T0, T1, T2>,

pub fn fmov<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: FmovEmitter<T0, T1>,

pub fn fmsub<T0, T1, T2, T3>(&mut self, op0: T0, op1: T1, op2: T2, op3: T3)
where Self: FmsubEmitter<T0, T1, T2, T3>,

pub fn fmul<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: FmulEmitter<T0, T1, T2>,

pub fn fmulx<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: FmulxEmitter<T0, T1, T2>,

pub fn fneg<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: FnegEmitter<T0, T1>,

pub fn fnmadd<T0, T1, T2, T3>(&mut self, op0: T0, op1: T1, op2: T2, op3: T3)
where Self: FnmaddEmitter<T0, T1, T2, T3>,

pub fn fnmsub<T0, T1, T2, T3>(&mut self, op0: T0, op1: T1, op2: T2, op3: T3)
where Self: FnmsubEmitter<T0, T1, T2, T3>,

pub fn fnmul<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: FnmulEmitter<T0, T1, T2>,

pub fn frecpe<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: FrecpeEmitter<T0, T1>,

pub fn frecps<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: FrecpsEmitter<T0, T1, T2>,

pub fn frecpx<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: FrecpxEmitter<T0, T1>,

pub fn frint32x<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: Frint32xEmitter<T0, T1>,

pub fn frint32z<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: Frint32zEmitter<T0, T1>,

pub fn frint64x<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: Frint64xEmitter<T0, T1>,

pub fn frint64z<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: Frint64zEmitter<T0, T1>,

pub fn frinta<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: FrintaEmitter<T0, T1>,

pub fn frinti<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: FrintiEmitter<T0, T1>,

pub fn frintm<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: FrintmEmitter<T0, T1>,

pub fn frintn<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: FrintnEmitter<T0, T1>,

pub fn frintp<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: FrintpEmitter<T0, T1>,

pub fn frintx<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: FrintxEmitter<T0, T1>,

pub fn frintz<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: FrintzEmitter<T0, T1>,

pub fn frsqrte<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: FrsqrteEmitter<T0, T1>,

pub fn frsqrts<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: FrsqrtsEmitter<T0, T1, T2>,

pub fn fsqrt<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: FsqrtEmitter<T0, T1>,

pub fn fsub<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: FsubEmitter<T0, T1, T2>,

pub fn ins<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: InsEmitter<T0, T1>,

pub fn ld1<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: Ld1Emitter<T0, T1>,

pub fn ld1_3<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Ld13Emitter<T0, T1, T2>,

pub fn ld1_4<T0, T1, T2, T3>(&mut self, op0: T0, op1: T1, op2: T2, op3: T3)
where Self: Ld14Emitter<T0, T1, T2, T3>,

pub fn ld1_5<T0, T1, T2, T3, T4>( &mut self, op0: T0, op1: T1, op2: T2, op3: T3, op4: T4, )
where Self: Ld15Emitter<T0, T1, T2, T3, T4>,

pub fn ld1r<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: Ld1rEmitter<T0, T1>,

pub fn ld2<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Ld2Emitter<T0, T1, T2>,

pub fn ld2r<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Ld2rEmitter<T0, T1, T2>,

pub fn ld3<T0, T1, T2, T3>(&mut self, op0: T0, op1: T1, op2: T2, op3: T3)
where Self: Ld3Emitter<T0, T1, T2, T3>,

pub fn ld3r<T0, T1, T2, T3>(&mut self, op0: T0, op1: T1, op2: T2, op3: T3)
where Self: Ld3rEmitter<T0, T1, T2, T3>,

pub fn ld4<T0, T1, T2, T3, T4>( &mut self, op0: T0, op1: T1, op2: T2, op3: T3, op4: T4, )
where Self: Ld4Emitter<T0, T1, T2, T3, T4>,

pub fn ld4r<T0, T1, T2, T3, T4>( &mut self, op0: T0, op1: T1, op2: T2, op3: T3, op4: T4, )
where Self: Ld4rEmitter<T0, T1, T2, T3, T4>,

pub fn mla<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: MlaEmitter<T0, T1, T2>,

pub fn mls<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: MlsEmitter<T0, T1, T2>,

pub fn movi<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: MoviEmitter<T0, T1>,

pub fn movi_3<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Movi3Emitter<T0, T1, T2>,

pub fn mvni<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: MvniEmitter<T0, T1>,

pub fn mvni_3<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Mvni3Emitter<T0, T1, T2>,

pub fn not_<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: NotEmitter<T0, T1>,

pub fn orr_2<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: Orr2Emitter<T0, T1>,

pub fn pmul<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: PmulEmitter<T0, T1, T2>,

pub fn pmull<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: PmullEmitter<T0, T1, T2>,

pub fn pmull2<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Pmull2Emitter<T0, T1, T2>,

pub fn raddhn<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: RaddhnEmitter<T0, T1, T2>,

pub fn raddhn2<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Raddhn2Emitter<T0, T1, T2>,

pub fn rshrn<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: RshrnEmitter<T0, T1, T2>,

pub fn rshrn2<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Rshrn2Emitter<T0, T1, T2>,

pub fn rsubhn<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: RsubhnEmitter<T0, T1, T2>,

pub fn rsubhn2<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Rsubhn2Emitter<T0, T1, T2>,

pub fn saba<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: SabaEmitter<T0, T1, T2>,

pub fn sabal<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: SabalEmitter<T0, T1, T2>,

pub fn sabal2<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Sabal2Emitter<T0, T1, T2>,

pub fn sabd<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: SabdEmitter<T0, T1, T2>,

pub fn sabdl<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: SabdlEmitter<T0, T1, T2>,

pub fn sabdl2<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Sabdl2Emitter<T0, T1, T2>,

pub fn sadalp<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: SadalpEmitter<T0, T1>,

pub fn saddl<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: SaddlEmitter<T0, T1, T2>,

pub fn saddl2<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Saddl2Emitter<T0, T1, T2>,

pub fn saddlp<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: SaddlpEmitter<T0, T1>,

pub fn saddlv<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: SaddlvEmitter<T0, T1>,

pub fn saddw<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: SaddwEmitter<T0, T1, T2>,

pub fn saddw2<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Saddw2Emitter<T0, T1, T2>,

pub fn scvtf<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: ScvtfEmitter<T0, T1>,

pub fn scvtf_3<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Scvtf3Emitter<T0, T1, T2>,

pub fn shadd<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: ShaddEmitter<T0, T1, T2>,

pub fn shl<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: ShlEmitter<T0, T1, T2>,

pub fn shll<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: ShllEmitter<T0, T1, T2>,

pub fn shll2<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Shll2Emitter<T0, T1, T2>,

pub fn shrn<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: ShrnEmitter<T0, T1, T2>,

pub fn shrn2<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Shrn2Emitter<T0, T1, T2>,

pub fn shsub<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: ShsubEmitter<T0, T1, T2>,

pub fn sli<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: SliEmitter<T0, T1, T2>,

pub fn smaxp<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: SmaxpEmitter<T0, T1, T2>,

pub fn smaxv<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: SmaxvEmitter<T0, T1>,

pub fn sminp<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: SminpEmitter<T0, T1, T2>,

pub fn sminv<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: SminvEmitter<T0, T1>,

pub fn smlal<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: SmlalEmitter<T0, T1, T2>,

pub fn smlal2<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Smlal2Emitter<T0, T1, T2>,

pub fn smlsl<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: SmlslEmitter<T0, T1, T2>,

pub fn smlsl2<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Smlsl2Emitter<T0, T1, T2>,

pub fn smov<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: SmovEmitter<T0, T1>,

pub fn smull2<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Smull2Emitter<T0, T1, T2>,

pub fn sqabs<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: SqabsEmitter<T0, T1>,

pub fn sqadd<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: SqaddEmitter<T0, T1, T2>,

pub fn sqdmlal<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: SqdmlalEmitter<T0, T1, T2>,

pub fn sqdmlal2<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Sqdmlal2Emitter<T0, T1, T2>,

pub fn sqdmlsl<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: SqdmlslEmitter<T0, T1, T2>,

pub fn sqdmlsl2<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Sqdmlsl2Emitter<T0, T1, T2>,

pub fn sqdmulh<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: SqdmulhEmitter<T0, T1, T2>,

pub fn sqdmull<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: SqdmullEmitter<T0, T1, T2>,

pub fn sqdmull2<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Sqdmull2Emitter<T0, T1, T2>,

pub fn sqneg<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: SqnegEmitter<T0, T1>,

pub fn sqrdmulh<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: SqrdmulhEmitter<T0, T1, T2>,

pub fn sqrshl<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: SqrshlEmitter<T0, T1, T2>,

pub fn sqrshrn<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: SqrshrnEmitter<T0, T1, T2>,

pub fn sqrshrn2<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Sqrshrn2Emitter<T0, T1, T2>,

pub fn sqrshrun<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: SqrshrunEmitter<T0, T1, T2>,

pub fn sqrshrun2<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Sqrshrun2Emitter<T0, T1, T2>,

pub fn sqshl<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: SqshlEmitter<T0, T1, T2>,

pub fn sqshlu<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: SqshluEmitter<T0, T1, T2>,

pub fn sqshrn<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: SqshrnEmitter<T0, T1, T2>,

pub fn sqshrn2<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Sqshrn2Emitter<T0, T1, T2>,

pub fn sqshrun<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: SqshrunEmitter<T0, T1, T2>,

pub fn sqshrun2<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Sqshrun2Emitter<T0, T1, T2>,

pub fn sqsub<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: SqsubEmitter<T0, T1, T2>,

pub fn sqxtn<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: SqxtnEmitter<T0, T1>,

pub fn sqxtn2<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: Sqxtn2Emitter<T0, T1>,

pub fn sqxtun<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: SqxtunEmitter<T0, T1>,

pub fn sqxtun2<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: Sqxtun2Emitter<T0, T1>,

pub fn srhadd<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: SrhaddEmitter<T0, T1, T2>,

pub fn sri<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: SriEmitter<T0, T1, T2>,

pub fn srshl<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: SrshlEmitter<T0, T1, T2>,

pub fn srshr<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: SrshrEmitter<T0, T1, T2>,

pub fn srsra<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: SrsraEmitter<T0, T1, T2>,

pub fn sshl<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: SshlEmitter<T0, T1, T2>,

pub fn sshll<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: SshllEmitter<T0, T1, T2>,

pub fn sshll2<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Sshll2Emitter<T0, T1, T2>,

pub fn sshr<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: SshrEmitter<T0, T1, T2>,

pub fn ssra<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: SsraEmitter<T0, T1, T2>,

pub fn ssubl<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: SsublEmitter<T0, T1, T2>,

pub fn ssubl2<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Ssubl2Emitter<T0, T1, T2>,

pub fn ssubw<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: SsubwEmitter<T0, T1, T2>,

pub fn ssubw2<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Ssubw2Emitter<T0, T1, T2>,

pub fn st1<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: St1Emitter<T0, T1>,

pub fn st1_3<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: St13Emitter<T0, T1, T2>,

pub fn st1_4<T0, T1, T2, T3>(&mut self, op0: T0, op1: T1, op2: T2, op3: T3)
where Self: St14Emitter<T0, T1, T2, T3>,

pub fn st1_5<T0, T1, T2, T3, T4>( &mut self, op0: T0, op1: T1, op2: T2, op3: T3, op4: T4, )
where Self: St15Emitter<T0, T1, T2, T3, T4>,

pub fn st2<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: St2Emitter<T0, T1, T2>,

pub fn st3<T0, T1, T2, T3>(&mut self, op0: T0, op1: T1, op2: T2, op3: T3)
where Self: St3Emitter<T0, T1, T2, T3>,

pub fn st4<T0, T1, T2, T3, T4>( &mut self, op0: T0, op1: T1, op2: T2, op3: T3, op4: T4, )
where Self: St4Emitter<T0, T1, T2, T3, T4>,

pub fn subhn<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: SubhnEmitter<T0, T1, T2>,

pub fn subhn2<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Subhn2Emitter<T0, T1, T2>,

pub fn suqadd<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: SuqaddEmitter<T0, T1>,

pub fn sxtl<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: SxtlEmitter<T0, T1>,

pub fn sxtl2<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: Sxtl2Emitter<T0, T1>,

pub fn tbl<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: TblEmitter<T0, T1, T2>,

pub fn tbl_4<T0, T1, T2, T3>(&mut self, op0: T0, op1: T1, op2: T2, op3: T3)
where Self: Tbl4Emitter<T0, T1, T2, T3>,

pub fn tbl_5<T0, T1, T2, T3, T4>( &mut self, op0: T0, op1: T1, op2: T2, op3: T3, op4: T4, )
where Self: Tbl5Emitter<T0, T1, T2, T3, T4>,

pub fn tbl_6<T0, T1, T2, T3, T4, T5>( &mut self, op0: T0, op1: T1, op2: T2, op3: T3, op4: T4, op5: T5, )
where Self: Tbl6Emitter<T0, T1, T2, T3, T4, T5>,

pub fn tbx<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: TbxEmitter<T0, T1, T2>,

pub fn tbx_4<T0, T1, T2, T3>(&mut self, op0: T0, op1: T1, op2: T2, op3: T3)
where Self: Tbx4Emitter<T0, T1, T2, T3>,

pub fn tbx_5<T0, T1, T2, T3, T4>( &mut self, op0: T0, op1: T1, op2: T2, op3: T3, op4: T4, )
where Self: Tbx5Emitter<T0, T1, T2, T3, T4>,

pub fn tbx_6<T0, T1, T2, T3, T4, T5>( &mut self, op0: T0, op1: T1, op2: T2, op3: T3, op4: T4, op5: T5, )
where Self: Tbx6Emitter<T0, T1, T2, T3, T4, T5>,

pub fn trn1<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Trn1Emitter<T0, T1, T2>,

pub fn trn2<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Trn2Emitter<T0, T1, T2>,

pub fn uaba<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: UabaEmitter<T0, T1, T2>,

pub fn uabal<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: UabalEmitter<T0, T1, T2>,

pub fn uabal2<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Uabal2Emitter<T0, T1, T2>,

pub fn uabd<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: UabdEmitter<T0, T1, T2>,

pub fn uabdl<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: UabdlEmitter<T0, T1, T2>,

pub fn uabdl2<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Uabdl2Emitter<T0, T1, T2>,

pub fn uadalp<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: UadalpEmitter<T0, T1>,

pub fn uaddl<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: UaddlEmitter<T0, T1, T2>,

pub fn uaddl2<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Uaddl2Emitter<T0, T1, T2>,

pub fn uaddlp<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: UaddlpEmitter<T0, T1>,

pub fn uaddlv<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: UaddlvEmitter<T0, T1>,

pub fn uaddw<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: UaddwEmitter<T0, T1, T2>,

pub fn uaddw2<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Uaddw2Emitter<T0, T1, T2>,

pub fn ucvtf<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: UcvtfEmitter<T0, T1>,

pub fn ucvtf_3<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Ucvtf3Emitter<T0, T1, T2>,

pub fn uhadd<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: UhaddEmitter<T0, T1, T2>,

pub fn uhsub<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: UhsubEmitter<T0, T1, T2>,

pub fn umaxp<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: UmaxpEmitter<T0, T1, T2>,

pub fn umaxv<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: UmaxvEmitter<T0, T1>,

pub fn uminp<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: UminpEmitter<T0, T1, T2>,

pub fn uminv<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: UminvEmitter<T0, T1>,

pub fn umlal<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: UmlalEmitter<T0, T1, T2>,

pub fn umlal2<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Umlal2Emitter<T0, T1, T2>,

pub fn umlsl<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: UmlslEmitter<T0, T1, T2>,

pub fn umlsl2<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Umlsl2Emitter<T0, T1, T2>,

pub fn umov<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: UmovEmitter<T0, T1>,

pub fn umull2<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Umull2Emitter<T0, T1, T2>,

pub fn uqadd<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: UqaddEmitter<T0, T1, T2>,

pub fn uqrshl<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: UqrshlEmitter<T0, T1, T2>,

pub fn uqrshrn<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: UqrshrnEmitter<T0, T1, T2>,

pub fn uqrshrn2<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Uqrshrn2Emitter<T0, T1, T2>,

pub fn uqshl<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: UqshlEmitter<T0, T1, T2>,

pub fn uqshrn<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: UqshrnEmitter<T0, T1, T2>,

pub fn uqshrn2<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Uqshrn2Emitter<T0, T1, T2>,

pub fn uqsub<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: UqsubEmitter<T0, T1, T2>,

pub fn uqxtn<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: UqxtnEmitter<T0, T1>,

pub fn uqxtn2<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: Uqxtn2Emitter<T0, T1>,

pub fn urecpe<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: UrecpeEmitter<T0, T1>,

pub fn urhadd<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: UrhaddEmitter<T0, T1, T2>,

pub fn urshl<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: UrshlEmitter<T0, T1, T2>,

pub fn urshr<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: UrshrEmitter<T0, T1, T2>,

pub fn ursqrte<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: UrsqrteEmitter<T0, T1>,

pub fn ursra<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: UrsraEmitter<T0, T1, T2>,

pub fn ushl<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: UshlEmitter<T0, T1, T2>,

pub fn ushll<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: UshllEmitter<T0, T1, T2>,

pub fn ushll2<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Ushll2Emitter<T0, T1, T2>,

pub fn ushr<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: UshrEmitter<T0, T1, T2>,

pub fn usqadd<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: UsqaddEmitter<T0, T1>,

pub fn usra<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: UsraEmitter<T0, T1, T2>,

pub fn usubl<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: UsublEmitter<T0, T1, T2>,

pub fn usubl2<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Usubl2Emitter<T0, T1, T2>,

pub fn usubw<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: UsubwEmitter<T0, T1, T2>,

pub fn usubw2<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Usubw2Emitter<T0, T1, T2>,

pub fn uxtl<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: UxtlEmitter<T0, T1>,

pub fn uxtl2<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: Uxtl2Emitter<T0, T1>,

pub fn uzp1<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Uzp1Emitter<T0, T1, T2>,

pub fn uzp2<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Uzp2Emitter<T0, T1, T2>,

pub fn xtn<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: XtnEmitter<T0, T1>,

pub fn xtn2<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: Xtn2Emitter<T0, T1>,

pub fn zip1<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Zip1Emitter<T0, T1, T2>,

pub fn zip2<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Zip2Emitter<T0, T1, T2>,

pub fn aesd<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: AesdEmitter<T0, T1>,

pub fn aese<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: AeseEmitter<T0, T1>,

pub fn aesimc<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: AesimcEmitter<T0, T1>,

pub fn aesmc<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: AesmcEmitter<T0, T1>,

pub fn sha1c<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Sha1cEmitter<T0, T1, T2>,

pub fn sha1h<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: Sha1hEmitter<T0, T1>,

pub fn sha1m<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Sha1mEmitter<T0, T1, T2>,

pub fn sha1p<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Sha1pEmitter<T0, T1, T2>,

pub fn sha1su0<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Sha1su0Emitter<T0, T1, T2>,

pub fn sha1su1<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: Sha1su1Emitter<T0, T1>,

pub fn sha256h<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Sha256hEmitter<T0, T1, T2>,

pub fn sha256h2<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Sha256h2Emitter<T0, T1, T2>,

pub fn sha256su0<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: Sha256su0Emitter<T0, T1>,

pub fn sha256su1<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Sha256su1Emitter<T0, T1, T2>,

pub fn sqrdmlah<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: SqrdmlahEmitter<T0, T1, T2>,

pub fn sqrdmlsh<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: SqrdmlshEmitter<T0, T1, T2>,

pub fn fcadd<T0, T1, T2, T3>(&mut self, op0: T0, op1: T1, op2: T2, op3: T3)
where Self: FcaddEmitter<T0, T1, T2, T3>,

pub fn fcmla<T0, T1, T2, T3>(&mut self, op0: T0, op1: T1, op2: T2, op3: T3)
where Self: FcmlaEmitter<T0, T1, T2, T3>,

pub fn fjcvtzs<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: FjcvtzsEmitter<T0, T1>,

pub fn fmlal<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: FmlalEmitter<T0, T1, T2>,

pub fn fmlal2<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Fmlal2Emitter<T0, T1, T2>,

pub fn fmlsl<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: FmlslEmitter<T0, T1, T2>,

pub fn fmlsl2<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Fmlsl2Emitter<T0, T1, T2>,

pub fn bcax<T0, T1, T2, T3>(&mut self, op0: T0, op1: T1, op2: T2, op3: T3)
where Self: BcaxEmitter<T0, T1, T2, T3>,

pub fn eor3<T0, T1, T2, T3>(&mut self, op0: T0, op1: T1, op2: T2, op3: T3)
where Self: Eor3Emitter<T0, T1, T2, T3>,

pub fn rax1<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Rax1Emitter<T0, T1, T2>,

pub fn xar<T0, T1, T2, T3>(&mut self, op0: T0, op1: T1, op2: T2, op3: T3)
where Self: XarEmitter<T0, T1, T2, T3>,

pub fn sha512h<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Sha512hEmitter<T0, T1, T2>,

pub fn sha512h2<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Sha512h2Emitter<T0, T1, T2>,

pub fn sha512su0<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: Sha512su0Emitter<T0, T1>,

pub fn sha512su1<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Sha512su1Emitter<T0, T1, T2>,

pub fn sm3partw1<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Sm3partw1Emitter<T0, T1, T2>,

pub fn sm3partw2<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Sm3partw2Emitter<T0, T1, T2>,

pub fn sm3ss1<T0, T1, T2, T3>(&mut self, op0: T0, op1: T1, op2: T2, op3: T3)
where Self: Sm3ss1Emitter<T0, T1, T2, T3>,

pub fn sm3tt1a<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Sm3tt1aEmitter<T0, T1, T2>,

pub fn sm3tt1b<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Sm3tt1bEmitter<T0, T1, T2>,

pub fn sm3tt2a<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Sm3tt2aEmitter<T0, T1, T2>,

pub fn sm3tt2b<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Sm3tt2bEmitter<T0, T1, T2>,

pub fn sm4e<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: Sm4eEmitter<T0, T1>,

pub fn sm4ekey<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: Sm4ekeyEmitter<T0, T1, T2>,

pub fn sdot<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: SdotEmitter<T0, T1, T2>,

pub fn udot<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: UdotEmitter<T0, T1, T2>,

pub fn bfcvt<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: BfcvtEmitter<T0, T1>,

pub fn bfcvtn<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: BfcvtnEmitter<T0, T1>,

pub fn bfcvtn2<T0, T1>(&mut self, op0: T0, op1: T1)
where Self: Bfcvtn2Emitter<T0, T1>,

pub fn bfmlalb<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: BfmlalbEmitter<T0, T1, T2>,

pub fn bfmlalt<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: BfmlaltEmitter<T0, T1, T2>,

pub fn bfmmla<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: BfmmlaEmitter<T0, T1, T2>,

pub fn bfdot<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: BfdotEmitter<T0, T1, T2>,

pub fn smmla<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: SmmlaEmitter<T0, T1, T2>,

pub fn sudot<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: SudotEmitter<T0, T1, T2>,

pub fn ummla<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: UmmlaEmitter<T0, T1, T2>,

pub fn usdot<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: UsdotEmitter<T0, T1, T2>,

pub fn usmmla<T0, T1, T2>(&mut self, op0: T0, op1: T1, op2: T2)
where Self: UsmmlaEmitter<T0, T1, T2>,

Trait Implementations§

impl AbsEmitter<Gp, Gp> for Assembler<'_>

fn abs(&mut self, op0: Gp, op1: Gp)

impl AbsEmitter<Vec, Vec> for Assembler<'_>

fn abs(&mut self, op0: Vec, op1: Vec)

impl AdcEmitter<Gp, Gp, Gp> for Assembler<'_>

fn adc(&mut self, op0: Gp, op1: Gp, op2: Gp)

impl AdcsEmitter<Gp, Gp, Gp> for Assembler<'_>

fn adcs(&mut self, op0: Gp, op1: Gp, op2: Gp)

impl Add4Emitter<Gp, Gp, Gp, Imm> for Assembler<'_>

fn add_4(&mut self, op0: Gp, op1: Gp, op2: Gp, op3: Imm)

impl Add4Emitter<Gp, Gp, Imm, Imm> for Assembler<'_>

fn add_4(&mut self, op0: Gp, op1: Gp, op2: Imm, op3: Imm)

impl AddEmitter<Gp, Gp, Gp> for Assembler<'_>

fn add(&mut self, op0: Gp, op1: Gp, op2: Gp)

impl AddEmitter<Gp, Gp, Imm> for Assembler<'_>

fn add(&mut self, op0: Gp, op1: Gp, op2: Imm)

impl AddEmitter<Vec, Vec, Vec> for Assembler<'_>

fn add(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl AddgEmitter<Gp, Gp, Imm, Imm> for Assembler<'_>

fn addg(&mut self, op0: Gp, op1: Gp, op2: Imm, op3: Imm)

impl Addhn2Emitter<Vec, Vec, Vec> for Assembler<'_>

fn addhn2(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl AddhnEmitter<Vec, Vec, Vec> for Assembler<'_>

fn addhn(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl Addp3Emitter<Vec, Vec, Vec> for Assembler<'_>

fn addp_3(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl AddpEmitter<Vec, Vec> for Assembler<'_>

fn addp(&mut self, op0: Vec, op1: Vec)

impl Adds4Emitter<Gp, Gp, Gp, Imm> for Assembler<'_>

fn adds_4(&mut self, op0: Gp, op1: Gp, op2: Gp, op3: Imm)

impl Adds4Emitter<Gp, Gp, Imm, Imm> for Assembler<'_>

fn adds_4(&mut self, op0: Gp, op1: Gp, op2: Imm, op3: Imm)

impl AddsEmitter<Gp, Gp, Gp> for Assembler<'_>

fn adds(&mut self, op0: Gp, op1: Gp, op2: Gp)

impl AddsEmitter<Gp, Gp, Imm> for Assembler<'_>

fn adds(&mut self, op0: Gp, op1: Gp, op2: Imm)

impl AddvEmitter<Vec, Vec> for Assembler<'_>

fn addv(&mut self, op0: Vec, op1: Vec)

impl AdrEmitter<Gp, Imm> for Assembler<'_>

fn adr(&mut self, op0: Gp, op1: Imm)

impl AdrEmitter<Gp, Label> for Assembler<'_>

fn adr(&mut self, op0: Gp, op1: Label)

impl AdrEmitter<Gp, Sym> for Assembler<'_>

fn adr(&mut self, op0: Gp, op1: Sym)

impl AdrpEmitter<Gp, Imm> for Assembler<'_>

fn adrp(&mut self, op0: Gp, op1: Imm)

impl AdrpEmitter<Gp, Label> for Assembler<'_>

fn adrp(&mut self, op0: Gp, op1: Label)

impl AdrpEmitter<Gp, Sym> for Assembler<'_>

fn adrp(&mut self, op0: Gp, op1: Sym)

impl AesdEmitter<Vec, Vec> for Assembler<'_>

fn aesd(&mut self, op0: Vec, op1: Vec)

impl AeseEmitter<Vec, Vec> for Assembler<'_>

fn aese(&mut self, op0: Vec, op1: Vec)

impl AesimcEmitter<Vec, Vec> for Assembler<'_>

fn aesimc(&mut self, op0: Vec, op1: Vec)

impl AesmcEmitter<Vec, Vec> for Assembler<'_>

fn aesmc(&mut self, op0: Vec, op1: Vec)

impl And4Emitter<Gp, Gp, Gp, Imm> for Assembler<'_>

fn and__4(&mut self, op0: Gp, op1: Gp, op2: Gp, op3: Imm)

impl AndEmitter<Gp, Gp, Gp> for Assembler<'_>

fn and_(&mut self, op0: Gp, op1: Gp, op2: Gp)

impl AndEmitter<Gp, Gp, Imm> for Assembler<'_>

fn and_(&mut self, op0: Gp, op1: Gp, op2: Imm)

impl AndEmitter<Vec, Vec, Vec> for Assembler<'_>

fn and_(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl Ands4Emitter<Gp, Gp, Gp, Imm> for Assembler<'_>

fn ands_4(&mut self, op0: Gp, op1: Gp, op2: Gp, op3: Imm)

impl AndsEmitter<Gp, Gp, Gp> for Assembler<'_>

fn ands(&mut self, op0: Gp, op1: Gp, op2: Gp)

impl AndsEmitter<Gp, Gp, Imm> for Assembler<'_>

fn ands(&mut self, op0: Gp, op1: Gp, op2: Imm)

impl AsrEmitter<Gp, Gp, Gp> for Assembler<'_>

fn asr(&mut self, op0: Gp, op1: Gp, op2: Gp)

impl AsrEmitter<Gp, Gp, Imm> for Assembler<'_>

fn asr(&mut self, op0: Gp, op1: Gp, op2: Imm)

impl AsrvEmitter<Gp, Gp, Gp> for Assembler<'_>

fn asrv(&mut self, op0: Gp, op1: Gp, op2: Gp)

impl AtEmitter<Imm, Gp> for Assembler<'_>

fn at(&mut self, op0: Imm, op1: Gp)

impl AutdaEmitter<Gp, Gp> for Assembler<'_>

fn autda(&mut self, op0: Gp, op1: Gp)

impl AutdbEmitter<Gp, Gp> for Assembler<'_>

fn autdb(&mut self, op0: Gp, op1: Gp)

impl AutdzaEmitter<Gp> for Assembler<'_>

fn autdza(&mut self, op0: Gp)

impl AutdzbEmitter<Gp> for Assembler<'_>

fn autdzb(&mut self, op0: Gp)

impl Autia1716Emitter for Assembler<'_>

fn autia1716(&mut self)

impl AutiaEmitter<Gp, Gp> for Assembler<'_>

fn autia(&mut self, op0: Gp, op1: Gp)

impl AutiaspEmitter for Assembler<'_>

fn autiasp(&mut self)

impl AutiazEmitter for Assembler<'_>

fn autiaz(&mut self)

impl Autib1716Emitter for Assembler<'_>

fn autib1716(&mut self)

impl AutibEmitter<Gp, Gp> for Assembler<'_>

fn autib(&mut self, op0: Gp, op1: Gp)

impl AutibspEmitter for Assembler<'_>

fn autibsp(&mut self)

impl AutibzEmitter for Assembler<'_>

fn autibz(&mut self)

impl AutizaEmitter<Gp> for Assembler<'_>

fn autiza(&mut self, op0: Gp)

impl AutizbEmitter<Gp> for Assembler<'_>

fn autizb(&mut self, op0: Gp)

impl AxflagEmitter for Assembler<'_>

fn axflag(&mut self)

impl BEmitter<Imm> for Assembler<'_>

fn b(&mut self, op0: Imm)

fn b_eq(&mut self, op0: Imm)

fn b_ne(&mut self, op0: Imm)

fn b_cs(&mut self, op0: Imm)

fn b_hs(&mut self, op0: Imm)

fn b_cc(&mut self, op0: Imm)

fn b_lo(&mut self, op0: Imm)

fn b_mi(&mut self, op0: Imm)

fn b_pl(&mut self, op0: Imm)

fn b_vs(&mut self, op0: Imm)

fn b_vc(&mut self, op0: Imm)

fn b_hi(&mut self, op0: Imm)

fn b_ls(&mut self, op0: Imm)

fn b_ge(&mut self, op0: Imm)

fn b_lt(&mut self, op0: Imm)

fn b_gt(&mut self, op0: Imm)

fn b_le(&mut self, op0: Imm)

fn b_al(&mut self, op0: Imm)

impl BEmitter<Label> for Assembler<'_>

fn b(&mut self, op0: Label)

fn b_eq(&mut self, op0: Label)

fn b_ne(&mut self, op0: Label)

fn b_cs(&mut self, op0: Label)

fn b_hs(&mut self, op0: Label)

fn b_cc(&mut self, op0: Label)

fn b_lo(&mut self, op0: Label)

fn b_mi(&mut self, op0: Label)

fn b_pl(&mut self, op0: Label)

fn b_vs(&mut self, op0: Label)

fn b_vc(&mut self, op0: Label)

fn b_hi(&mut self, op0: Label)

fn b_ls(&mut self, op0: Label)

fn b_ge(&mut self, op0: Label)

fn b_lt(&mut self, op0: Label)

fn b_gt(&mut self, op0: Label)

fn b_le(&mut self, op0: Label)

fn b_al(&mut self, op0: Label)

impl BcEmitter<Imm> for Assembler<'_>

fn bc_eq(&mut self, op0: Imm)

fn bc_ne(&mut self, op0: Imm)

fn bc_cs(&mut self, op0: Imm)

fn bc_hs(&mut self, op0: Imm)

fn bc_cc(&mut self, op0: Imm)

fn bc_lo(&mut self, op0: Imm)

fn bc_mi(&mut self, op0: Imm)

fn bc_pl(&mut self, op0: Imm)

fn bc_vs(&mut self, op0: Imm)

fn bc_vc(&mut self, op0: Imm)

fn bc_hi(&mut self, op0: Imm)

fn bc_ls(&mut self, op0: Imm)

fn bc_ge(&mut self, op0: Imm)

fn bc_lt(&mut self, op0: Imm)

fn bc_gt(&mut self, op0: Imm)

fn bc_le(&mut self, op0: Imm)

fn bc_al(&mut self, op0: Imm)

impl BcEmitter<Label> for Assembler<'_>

fn bc_eq(&mut self, op0: Label)

fn bc_ne(&mut self, op0: Label)

fn bc_cs(&mut self, op0: Label)

fn bc_hs(&mut self, op0: Label)

fn bc_cc(&mut self, op0: Label)

fn bc_lo(&mut self, op0: Label)

fn bc_mi(&mut self, op0: Label)

fn bc_pl(&mut self, op0: Label)

fn bc_vs(&mut self, op0: Label)

fn bc_vc(&mut self, op0: Label)

fn bc_hi(&mut self, op0: Label)

fn bc_ls(&mut self, op0: Label)

fn bc_ge(&mut self, op0: Label)

fn bc_lt(&mut self, op0: Label)

fn bc_gt(&mut self, op0: Label)

fn bc_le(&mut self, op0: Label)

fn bc_al(&mut self, op0: Label)

impl BcEmitter<Sym> for Assembler<'_>

fn bc_eq(&mut self, op0: Sym)

fn bc_ne(&mut self, op0: Sym)

fn bc_cs(&mut self, op0: Sym)

fn bc_hs(&mut self, op0: Sym)

fn bc_cc(&mut self, op0: Sym)

fn bc_lo(&mut self, op0: Sym)

fn bc_mi(&mut self, op0: Sym)

fn bc_pl(&mut self, op0: Sym)

fn bc_vs(&mut self, op0: Sym)

fn bc_vc(&mut self, op0: Sym)

fn bc_hi(&mut self, op0: Sym)

fn bc_ls(&mut self, op0: Sym)

fn bc_ge(&mut self, op0: Sym)

fn bc_lt(&mut self, op0: Sym)

fn bc_gt(&mut self, op0: Sym)

fn bc_le(&mut self, op0: Sym)

fn bc_al(&mut self, op0: Sym)

impl BcaxEmitter<Vec, Vec, Vec, Vec> for Assembler<'_>

fn bcax(&mut self, op0: Vec, op1: Vec, op2: Vec, op3: Vec)

impl BfcEmitter<Gp, Imm, Imm> for Assembler<'_>

fn bfc(&mut self, op0: Gp, op1: Imm, op2: Imm)

impl BfcvtEmitter<Vec, Vec> for Assembler<'_>

fn bfcvt(&mut self, op0: Vec, op1: Vec)

impl Bfcvtn2Emitter<Vec, Vec> for Assembler<'_>

fn bfcvtn2(&mut self, op0: Vec, op1: Vec)

impl BfcvtnEmitter<Vec, Vec> for Assembler<'_>

fn bfcvtn(&mut self, op0: Vec, op1: Vec)

impl BfdotEmitter<Vec, Vec, Vec> for Assembler<'_>

fn bfdot(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl BfiEmitter<Gp, Gp, Imm, Imm> for Assembler<'_>

fn bfi(&mut self, op0: Gp, op1: Gp, op2: Imm, op3: Imm)

impl BfmEmitter<Gp, Gp, Imm, Imm> for Assembler<'_>

fn bfm(&mut self, op0: Gp, op1: Gp, op2: Imm, op3: Imm)

impl BfmlalbEmitter<Vec, Vec, Vec> for Assembler<'_>

fn bfmlalb(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl BfmlaltEmitter<Vec, Vec, Vec> for Assembler<'_>

fn bfmlalt(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl BfmmlaEmitter<Vec, Vec, Vec> for Assembler<'_>

fn bfmmla(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl BfxilEmitter<Gp, Gp, Imm, Imm> for Assembler<'_>

fn bfxil(&mut self, op0: Gp, op1: Gp, op2: Imm, op3: Imm)

impl Bic2Emitter<Vec, Imm> for Assembler<'_>

fn bic_2(&mut self, op0: Vec, op1: Imm)

impl Bic4Emitter<Gp, Gp, Gp, Imm> for Assembler<'_>

fn bic_4(&mut self, op0: Gp, op1: Gp, op2: Gp, op3: Imm)

impl BicEmitter<Gp, Gp, Gp> for Assembler<'_>

fn bic(&mut self, op0: Gp, op1: Gp, op2: Gp)

impl BicEmitter<Gp, Gp, Imm> for Assembler<'_>

fn bic(&mut self, op0: Gp, op1: Gp, op2: Imm)

impl BicEmitter<Vec, Imm, Imm> for Assembler<'_>

fn bic(&mut self, op0: Vec, op1: Imm, op2: Imm)

impl BicEmitter<Vec, Vec, Vec> for Assembler<'_>

fn bic(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl Bics4Emitter<Gp, Gp, Gp, Imm> for Assembler<'_>

fn bics_4(&mut self, op0: Gp, op1: Gp, op2: Gp, op3: Imm)

impl BicsEmitter<Gp, Gp, Gp> for Assembler<'_>

fn bics(&mut self, op0: Gp, op1: Gp, op2: Gp)

impl BicsEmitter<Gp, Gp, Imm> for Assembler<'_>

fn bics(&mut self, op0: Gp, op1: Gp, op2: Imm)

impl BifEmitter<Vec, Vec, Vec> for Assembler<'_>

fn bif(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl BitEmitter<Vec, Vec, Vec> for Assembler<'_>

fn bit(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl BlEmitter<Imm> for Assembler<'_>

fn bl(&mut self, op0: Imm)

impl BlEmitter<Label> for Assembler<'_>

fn bl(&mut self, op0: Label)

impl BlEmitter<Sym> for Assembler<'_>

fn bl(&mut self, op0: Sym)

impl BlrEmitter<Gp> for Assembler<'_>

fn blr(&mut self, op0: Gp)

impl BrEmitter<Gp> for Assembler<'_>

fn br(&mut self, op0: Gp)

impl BrkEmitter<Imm> for Assembler<'_>

fn brk(&mut self, op0: Imm)

impl BslEmitter<Vec, Vec, Vec> for Assembler<'_>

fn bsl(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl BtiEmitter<Imm> for Assembler<'_>

fn bti(&mut self, op0: Imm)

impl CasEmitter<Gp, Gp, Mem> for Assembler<'_>

fn cas(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl CasaEmitter<Gp, Gp, Mem> for Assembler<'_>

fn casa(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl CasabEmitter<Gp, Gp, Mem> for Assembler<'_>

fn casab(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl CasahEmitter<Gp, Gp, Mem> for Assembler<'_>

fn casah(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl CasalEmitter<Gp, Gp, Mem> for Assembler<'_>

fn casal(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl CasalbEmitter<Gp, Gp, Mem> for Assembler<'_>

fn casalb(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl CasalhEmitter<Gp, Gp, Mem> for Assembler<'_>

fn casalh(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl CasbEmitter<Gp, Gp, Mem> for Assembler<'_>

fn casb(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl CashEmitter<Gp, Gp, Mem> for Assembler<'_>

fn cash(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl CaslEmitter<Gp, Gp, Mem> for Assembler<'_>

fn casl(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl CaslbEmitter<Gp, Gp, Mem> for Assembler<'_>

fn caslb(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl CaslhEmitter<Gp, Gp, Mem> for Assembler<'_>

fn caslh(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl CaspEmitter<Gp, Gp, Gp, Gp, Mem> for Assembler<'_>

fn casp(&mut self, op0: Gp, op1: Gp, op2: Gp, op3: Gp, op4: Mem)

impl CaspaEmitter<Gp, Gp, Gp, Gp, Mem> for Assembler<'_>

fn caspa(&mut self, op0: Gp, op1: Gp, op2: Gp, op3: Gp, op4: Mem)

impl CaspalEmitter<Gp, Gp, Gp, Gp, Mem> for Assembler<'_>

fn caspal(&mut self, op0: Gp, op1: Gp, op2: Gp, op3: Gp, op4: Mem)

impl CasplEmitter<Gp, Gp, Gp, Gp, Mem> for Assembler<'_>

fn caspl(&mut self, op0: Gp, op1: Gp, op2: Gp, op3: Gp, op4: Mem)

impl CbnzEmitter<Gp, Imm> for Assembler<'_>

fn cbnz(&mut self, op0: Gp, op1: Imm)

impl CbnzEmitter<Gp, Label> for Assembler<'_>

fn cbnz(&mut self, op0: Gp, op1: Label)

impl CbnzEmitter<Gp, Sym> for Assembler<'_>

fn cbnz(&mut self, op0: Gp, op1: Sym)

impl CbzEmitter<Gp, Imm> for Assembler<'_>

fn cbz(&mut self, op0: Gp, op1: Imm)

impl CbzEmitter<Gp, Label> for Assembler<'_>

fn cbz(&mut self, op0: Gp, op1: Label)

impl CbzEmitter<Gp, Sym> for Assembler<'_>

fn cbz(&mut self, op0: Gp, op1: Sym)

impl CcmnEmitter<Gp, Gp, Imm, Imm> for Assembler<'_>

fn ccmn(&mut self, op0: Gp, op1: Gp, op2: Imm, op3: Imm)

impl CcmnEmitter<Gp, Imm, Imm, Imm> for Assembler<'_>

fn ccmn(&mut self, op0: Gp, op1: Imm, op2: Imm, op3: Imm)

impl CcmpEmitter<Gp, Gp, Imm, Imm> for Assembler<'_>

fn ccmp(&mut self, op0: Gp, op1: Gp, op2: Imm, op3: Imm)

impl CcmpEmitter<Gp, Imm, Imm, Imm> for Assembler<'_>

fn ccmp(&mut self, op0: Gp, op1: Imm, op2: Imm, op3: Imm)

impl CfinvEmitter for Assembler<'_>

fn cfinv(&mut self)

impl ChkfeatEmitter<Gp> for Assembler<'_>

fn chkfeat(&mut self, op0: Gp)

impl CincEmitter<Gp, Gp, Imm> for Assembler<'_>

fn cinc(&mut self, op0: Gp, op1: Gp, op2: Imm)

impl CinvEmitter<Gp, Gp, Imm> for Assembler<'_>

fn cinv(&mut self, op0: Gp, op1: Gp, op2: Imm)

impl ClrbhbEmitter for Assembler<'_>

fn clrbhb(&mut self)

impl ClrexEmitter<Imm> for Assembler<'_>

fn clrex(&mut self, op0: Imm)

impl ClsEmitter<Gp, Gp> for Assembler<'_>

fn cls(&mut self, op0: Gp, op1: Gp)

impl ClsEmitter<Vec, Vec> for Assembler<'_>

fn cls(&mut self, op0: Vec, op1: Vec)

impl ClzEmitter<Gp, Gp> for Assembler<'_>

fn clz(&mut self, op0: Gp, op1: Gp)

impl ClzEmitter<Vec, Vec> for Assembler<'_>

fn clz(&mut self, op0: Vec, op1: Vec)

impl CmeqEmitter<Vec, Vec, Imm> for Assembler<'_>

fn cmeq(&mut self, op0: Vec, op1: Vec, op2: Imm)

impl CmeqEmitter<Vec, Vec, Vec> for Assembler<'_>

fn cmeq(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl CmgeEmitter<Vec, Vec, Imm> for Assembler<'_>

fn cmge(&mut self, op0: Vec, op1: Vec, op2: Imm)

impl CmgeEmitter<Vec, Vec, Vec> for Assembler<'_>

fn cmge(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl CmgtEmitter<Vec, Vec, Imm> for Assembler<'_>

fn cmgt(&mut self, op0: Vec, op1: Vec, op2: Imm)

impl CmgtEmitter<Vec, Vec, Vec> for Assembler<'_>

fn cmgt(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl CmhiEmitter<Vec, Vec, Vec> for Assembler<'_>

fn cmhi(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl CmhsEmitter<Vec, Vec, Vec> for Assembler<'_>

fn cmhs(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl CmleEmitter<Vec, Vec, Imm> for Assembler<'_>

fn cmle(&mut self, op0: Vec, op1: Vec, op2: Imm)

impl CmltEmitter<Vec, Vec, Imm> for Assembler<'_>

fn cmlt(&mut self, op0: Vec, op1: Vec, op2: Imm)

impl Cmn3Emitter<Gp, Gp, Imm> for Assembler<'_>

fn cmn_3(&mut self, op0: Gp, op1: Gp, op2: Imm)

impl Cmn3Emitter<Gp, Imm, Imm> for Assembler<'_>

fn cmn_3(&mut self, op0: Gp, op1: Imm, op2: Imm)

impl CmnEmitter<Gp, Gp> for Assembler<'_>

fn cmn(&mut self, op0: Gp, op1: Gp)

impl CmnEmitter<Gp, Imm> for Assembler<'_>

fn cmn(&mut self, op0: Gp, op1: Imm)

impl Cmp3Emitter<Gp, Gp, Imm> for Assembler<'_>

fn cmp_3(&mut self, op0: Gp, op1: Gp, op2: Imm)

impl Cmp3Emitter<Gp, Imm, Imm> for Assembler<'_>

fn cmp_3(&mut self, op0: Gp, op1: Imm, op2: Imm)

impl CmpEmitter<Gp, Gp> for Assembler<'_>

fn cmp(&mut self, op0: Gp, op1: Gp)

impl CmpEmitter<Gp, Imm> for Assembler<'_>

fn cmp(&mut self, op0: Gp, op1: Imm)

impl CmppEmitter<Gp, Gp> for Assembler<'_>

fn cmpp(&mut self, op0: Gp, op1: Gp)

impl CmtstEmitter<Vec, Vec, Vec> for Assembler<'_>

fn cmtst(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl CnegEmitter<Gp, Gp, Imm> for Assembler<'_>

fn cneg(&mut self, op0: Gp, op1: Gp, op2: Imm)

impl CntEmitter<Gp, Gp> for Assembler<'_>

fn cnt(&mut self, op0: Gp, op1: Gp)

impl CntEmitter<Vec, Vec> for Assembler<'_>

fn cnt(&mut self, op0: Vec, op1: Vec)

impl Crc32bEmitter<Gp, Gp, Gp> for Assembler<'_>

fn crc32b(&mut self, op0: Gp, op1: Gp, op2: Gp)

impl Crc32cbEmitter<Gp, Gp, Gp> for Assembler<'_>

fn crc32cb(&mut self, op0: Gp, op1: Gp, op2: Gp)

impl Crc32chEmitter<Gp, Gp, Gp> for Assembler<'_>

fn crc32ch(&mut self, op0: Gp, op1: Gp, op2: Gp)

impl Crc32cwEmitter<Gp, Gp, Gp> for Assembler<'_>

fn crc32cw(&mut self, op0: Gp, op1: Gp, op2: Gp)

impl Crc32cxEmitter<Gp, Gp, Gp> for Assembler<'_>

fn crc32cx(&mut self, op0: Gp, op1: Gp, op2: Gp)

impl Crc32hEmitter<Gp, Gp, Gp> for Assembler<'_>

fn crc32h(&mut self, op0: Gp, op1: Gp, op2: Gp)

impl Crc32wEmitter<Gp, Gp, Gp> for Assembler<'_>

fn crc32w(&mut self, op0: Gp, op1: Gp, op2: Gp)

impl Crc32xEmitter<Gp, Gp, Gp> for Assembler<'_>

fn crc32x(&mut self, op0: Gp, op1: Gp, op2: Gp)

impl CsdbEmitter for Assembler<'_>

fn csdb(&mut self)

impl CselEmitter<Gp, Gp, Gp, Imm> for Assembler<'_>

fn csel(&mut self, op0: Gp, op1: Gp, op2: Gp, op3: Imm)

impl CsetEmitter<Gp, Imm> for Assembler<'_>

fn cset(&mut self, op0: Gp, op1: Imm)

impl CsetmEmitter<Gp, Imm> for Assembler<'_>

fn csetm(&mut self, op0: Gp, op1: Imm)

impl CsincEmitter<Gp, Gp, Gp, Imm> for Assembler<'_>

fn csinc(&mut self, op0: Gp, op1: Gp, op2: Gp, op3: Imm)

impl CsinvEmitter<Gp, Gp, Gp, Imm> for Assembler<'_>

fn csinv(&mut self, op0: Gp, op1: Gp, op2: Gp, op3: Imm)

impl CsnegEmitter<Gp, Gp, Gp, Imm> for Assembler<'_>

fn csneg(&mut self, op0: Gp, op1: Gp, op2: Gp, op3: Imm)

impl CtzEmitter<Gp, Gp> for Assembler<'_>

fn ctz(&mut self, op0: Gp, op1: Gp)

impl DcEmitter<Imm, Gp> for Assembler<'_>

fn dc(&mut self, op0: Imm, op1: Gp)

impl Dcps1Emitter<Imm> for Assembler<'_>

fn dcps1(&mut self, op0: Imm)

impl Dcps2Emitter<Imm> for Assembler<'_>

fn dcps2(&mut self, op0: Imm)

impl Dcps3Emitter<Imm> for Assembler<'_>

fn dcps3(&mut self, op0: Imm)

impl DghEmitter for Assembler<'_>

fn dgh(&mut self)

impl DmbEmitter<Imm> for Assembler<'_>

fn dmb(&mut self, op0: Imm)

impl DrpsEmitter for Assembler<'_>

fn drps(&mut self)

impl DsbEmitter<Imm> for Assembler<'_>

fn dsb(&mut self, op0: Imm)

impl DupEmitter<Vec, Gp> for Assembler<'_>

fn dup(&mut self, op0: Vec, op1: Gp)

impl DupEmitter<Vec, Vec> for Assembler<'_>

fn dup(&mut self, op0: Vec, op1: Vec)

impl Eon4Emitter<Gp, Gp, Gp, Imm> for Assembler<'_>

fn eon_4(&mut self, op0: Gp, op1: Gp, op2: Gp, op3: Imm)

impl EonEmitter<Gp, Gp, Gp> for Assembler<'_>

fn eon(&mut self, op0: Gp, op1: Gp, op2: Gp)

impl Eor3Emitter<Vec, Vec, Vec, Vec> for Assembler<'_>

fn eor3(&mut self, op0: Vec, op1: Vec, op2: Vec, op3: Vec)

impl Eor4Emitter<Gp, Gp, Gp, Imm> for Assembler<'_>

fn eor_4(&mut self, op0: Gp, op1: Gp, op2: Gp, op3: Imm)

impl EorEmitter<Gp, Gp, Gp> for Assembler<'_>

fn eor(&mut self, op0: Gp, op1: Gp, op2: Gp)

impl EorEmitter<Gp, Gp, Imm> for Assembler<'_>

fn eor(&mut self, op0: Gp, op1: Gp, op2: Imm)

impl EorEmitter<Vec, Vec, Vec> for Assembler<'_>

fn eor(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl EretEmitter for Assembler<'_>

fn eret(&mut self)

impl EsbEmitter for Assembler<'_>

fn esb(&mut self)

impl ExtEmitter<Vec, Vec, Vec, Imm> for Assembler<'_>

fn ext(&mut self, op0: Vec, op1: Vec, op2: Vec, op3: Imm)

impl ExtrEmitter<Gp, Gp, Gp, Imm> for Assembler<'_>

fn extr(&mut self, op0: Gp, op1: Gp, op2: Gp, op3: Imm)

impl FabdEmitter<Vec, Vec, Vec> for Assembler<'_>

fn fabd(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl FabsEmitter<Vec, Vec> for Assembler<'_>

fn fabs(&mut self, op0: Vec, op1: Vec)

impl FacgeEmitter<Vec, Vec, Vec> for Assembler<'_>

fn facge(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl FacgtEmitter<Vec, Vec, Vec> for Assembler<'_>

fn facgt(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl FaddEmitter<Vec, Vec, Vec> for Assembler<'_>

fn fadd(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl Faddp3Emitter<Vec, Vec, Vec> for Assembler<'_>

fn faddp_3(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl FaddpEmitter<Vec, Vec> for Assembler<'_>

fn faddp(&mut self, op0: Vec, op1: Vec)

impl FcaddEmitter<Vec, Vec, Vec, Imm> for Assembler<'_>

fn fcadd(&mut self, op0: Vec, op1: Vec, op2: Vec, op3: Imm)

impl FccmpEmitter<Vec, Vec, Imm, Imm> for Assembler<'_>

fn fccmp(&mut self, op0: Vec, op1: Vec, op2: Imm, op3: Imm)

impl FccmpeEmitter<Vec, Vec, Imm, Imm> for Assembler<'_>

fn fccmpe(&mut self, op0: Vec, op1: Vec, op2: Imm, op3: Imm)

impl FcmeqEmitter<Vec, Vec, Imm> for Assembler<'_>

fn fcmeq(&mut self, op0: Vec, op1: Vec, op2: Imm)

impl FcmeqEmitter<Vec, Vec, Vec> for Assembler<'_>

fn fcmeq(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl FcmgeEmitter<Vec, Vec, Imm> for Assembler<'_>

fn fcmge(&mut self, op0: Vec, op1: Vec, op2: Imm)

impl FcmgeEmitter<Vec, Vec, Vec> for Assembler<'_>

fn fcmge(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl FcmgtEmitter<Vec, Vec, Imm> for Assembler<'_>

fn fcmgt(&mut self, op0: Vec, op1: Vec, op2: Imm)

impl FcmgtEmitter<Vec, Vec, Vec> for Assembler<'_>

fn fcmgt(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl FcmlaEmitter<Vec, Vec, Vec, Imm> for Assembler<'_>

fn fcmla(&mut self, op0: Vec, op1: Vec, op2: Vec, op3: Imm)

impl FcmleEmitter<Vec, Vec, Imm> for Assembler<'_>

fn fcmle(&mut self, op0: Vec, op1: Vec, op2: Imm)

impl FcmltEmitter<Vec, Vec, Imm> for Assembler<'_>

fn fcmlt(&mut self, op0: Vec, op1: Vec, op2: Imm)

impl FcmpEmitter<Vec, Imm> for Assembler<'_>

fn fcmp(&mut self, op0: Vec, op1: Imm)

impl FcmpEmitter<Vec, Vec> for Assembler<'_>

fn fcmp(&mut self, op0: Vec, op1: Vec)

impl FcmpeEmitter<Vec, Imm> for Assembler<'_>

fn fcmpe(&mut self, op0: Vec, op1: Imm)

impl FcmpeEmitter<Vec, Vec> for Assembler<'_>

fn fcmpe(&mut self, op0: Vec, op1: Vec)

impl FcselEmitter<Vec, Vec, Vec, Imm> for Assembler<'_>

fn fcsel(&mut self, op0: Vec, op1: Vec, op2: Vec, op3: Imm)

impl FcvtEmitter<Vec, Vec> for Assembler<'_>

fn fcvt(&mut self, op0: Vec, op1: Vec)

impl FcvtasEmitter<Gp, Vec> for Assembler<'_>

fn fcvtas(&mut self, op0: Gp, op1: Vec)

impl FcvtasEmitter<Vec, Vec> for Assembler<'_>

fn fcvtas(&mut self, op0: Vec, op1: Vec)

impl FcvtauEmitter<Gp, Vec> for Assembler<'_>

fn fcvtau(&mut self, op0: Gp, op1: Vec)

impl FcvtauEmitter<Vec, Vec> for Assembler<'_>

fn fcvtau(&mut self, op0: Vec, op1: Vec)

impl Fcvtl2Emitter<Vec, Vec> for Assembler<'_>

fn fcvtl2(&mut self, op0: Vec, op1: Vec)

impl FcvtlEmitter<Vec, Vec> for Assembler<'_>

fn fcvtl(&mut self, op0: Vec, op1: Vec)

impl FcvtmsEmitter<Gp, Vec> for Assembler<'_>

fn fcvtms(&mut self, op0: Gp, op1: Vec)

impl FcvtmsEmitter<Vec, Vec> for Assembler<'_>

fn fcvtms(&mut self, op0: Vec, op1: Vec)

impl FcvtmuEmitter<Gp, Vec> for Assembler<'_>

fn fcvtmu(&mut self, op0: Gp, op1: Vec)

impl FcvtmuEmitter<Vec, Vec> for Assembler<'_>

fn fcvtmu(&mut self, op0: Vec, op1: Vec)

impl Fcvtn2Emitter<Vec, Vec> for Assembler<'_>

fn fcvtn2(&mut self, op0: Vec, op1: Vec)

impl FcvtnEmitter<Vec, Vec> for Assembler<'_>

fn fcvtn(&mut self, op0: Vec, op1: Vec)

impl FcvtnsEmitter<Gp, Vec> for Assembler<'_>

fn fcvtns(&mut self, op0: Gp, op1: Vec)

impl FcvtnsEmitter<Vec, Vec> for Assembler<'_>

fn fcvtns(&mut self, op0: Vec, op1: Vec)

impl FcvtnuEmitter<Gp, Vec> for Assembler<'_>

fn fcvtnu(&mut self, op0: Gp, op1: Vec)

impl FcvtnuEmitter<Vec, Vec> for Assembler<'_>

fn fcvtnu(&mut self, op0: Vec, op1: Vec)

impl FcvtpsEmitter<Gp, Vec> for Assembler<'_>

fn fcvtps(&mut self, op0: Gp, op1: Vec)

impl FcvtpsEmitter<Vec, Vec> for Assembler<'_>

fn fcvtps(&mut self, op0: Vec, op1: Vec)

impl FcvtpuEmitter<Gp, Vec> for Assembler<'_>

fn fcvtpu(&mut self, op0: Gp, op1: Vec)

impl FcvtpuEmitter<Vec, Vec> for Assembler<'_>

fn fcvtpu(&mut self, op0: Vec, op1: Vec)

impl Fcvtxn2Emitter<Vec, Vec> for Assembler<'_>

fn fcvtxn2(&mut self, op0: Vec, op1: Vec)

impl FcvtxnEmitter<Vec, Vec> for Assembler<'_>

fn fcvtxn(&mut self, op0: Vec, op1: Vec)

impl Fcvtzs3Emitter<Gp, Vec, Imm> for Assembler<'_>

fn fcvtzs_3(&mut self, op0: Gp, op1: Vec, op2: Imm)

impl Fcvtzs3Emitter<Vec, Vec, Imm> for Assembler<'_>

fn fcvtzs_3(&mut self, op0: Vec, op1: Vec, op2: Imm)

impl FcvtzsEmitter<Gp, Vec> for Assembler<'_>

fn fcvtzs(&mut self, op0: Gp, op1: Vec)

impl FcvtzsEmitter<Vec, Vec> for Assembler<'_>

fn fcvtzs(&mut self, op0: Vec, op1: Vec)

impl Fcvtzu3Emitter<Gp, Vec, Imm> for Assembler<'_>

fn fcvtzu_3(&mut self, op0: Gp, op1: Vec, op2: Imm)

impl Fcvtzu3Emitter<Vec, Vec, Imm> for Assembler<'_>

fn fcvtzu_3(&mut self, op0: Vec, op1: Vec, op2: Imm)

impl FcvtzuEmitter<Gp, Vec> for Assembler<'_>

fn fcvtzu(&mut self, op0: Gp, op1: Vec)

impl FcvtzuEmitter<Vec, Vec> for Assembler<'_>

fn fcvtzu(&mut self, op0: Vec, op1: Vec)

impl FdivEmitter<Vec, Vec, Vec> for Assembler<'_>

fn fdiv(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl FjcvtzsEmitter<Gp, Vec> for Assembler<'_>

fn fjcvtzs(&mut self, op0: Gp, op1: Vec)

impl FmaddEmitter<Vec, Vec, Vec, Vec> for Assembler<'_>

fn fmadd(&mut self, op0: Vec, op1: Vec, op2: Vec, op3: Vec)

impl FmaxEmitter<Vec, Vec, Vec> for Assembler<'_>

fn fmax(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl FmaxnmEmitter<Vec, Vec, Vec> for Assembler<'_>

fn fmaxnm(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl Fmaxnmp2Emitter<Vec, Vec> for Assembler<'_>

fn fmaxnmp_2(&mut self, op0: Vec, op1: Vec)

impl FmaxnmpEmitter<Vec, Vec, Vec> for Assembler<'_>

fn fmaxnmp(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl FmaxnmvEmitter<Vec, Vec> for Assembler<'_>

fn fmaxnmv(&mut self, op0: Vec, op1: Vec)

impl Fmaxp2Emitter<Vec, Vec> for Assembler<'_>

fn fmaxp_2(&mut self, op0: Vec, op1: Vec)

impl FmaxpEmitter<Vec, Vec, Vec> for Assembler<'_>

fn fmaxp(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl FmaxvEmitter<Vec, Vec> for Assembler<'_>

fn fmaxv(&mut self, op0: Vec, op1: Vec)

impl FminEmitter<Vec, Vec, Vec> for Assembler<'_>

fn fmin(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl FminnmEmitter<Vec, Vec, Vec> for Assembler<'_>

fn fminnm(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl Fminnmp2Emitter<Vec, Vec> for Assembler<'_>

fn fminnmp_2(&mut self, op0: Vec, op1: Vec)

impl FminnmpEmitter<Vec, Vec, Vec> for Assembler<'_>

fn fminnmp(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl FminnmvEmitter<Vec, Vec> for Assembler<'_>

fn fminnmv(&mut self, op0: Vec, op1: Vec)

impl Fminp3Emitter<Vec, Vec, Vec> for Assembler<'_>

fn fminp_3(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl FminpEmitter<Vec, Vec> for Assembler<'_>

fn fminp(&mut self, op0: Vec, op1: Vec)

impl FminvEmitter<Vec, Vec> for Assembler<'_>

fn fminv(&mut self, op0: Vec, op1: Vec)

impl FmlaEmitter<Vec, Vec, Vec> for Assembler<'_>

fn fmla(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl Fmlal2Emitter<Vec, Vec, Vec> for Assembler<'_>

fn fmlal2(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl FmlalEmitter<Vec, Vec, Vec> for Assembler<'_>

fn fmlal(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl FmlsEmitter<Vec, Vec, Vec> for Assembler<'_>

fn fmls(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl Fmlsl2Emitter<Vec, Vec, Vec> for Assembler<'_>

fn fmlsl2(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl FmlslEmitter<Vec, Vec, Vec> for Assembler<'_>

fn fmlsl(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl FmovEmitter<Gp, Vec> for Assembler<'_>

fn fmov(&mut self, op0: Gp, op1: Vec)

impl FmovEmitter<Vec, Gp> for Assembler<'_>

fn fmov(&mut self, op0: Vec, op1: Gp)

impl FmovEmitter<Vec, Imm> for Assembler<'_>

fn fmov(&mut self, op0: Vec, op1: Imm)

impl FmovEmitter<Vec, Vec> for Assembler<'_>

fn fmov(&mut self, op0: Vec, op1: Vec)

impl FmsubEmitter<Vec, Vec, Vec, Vec> for Assembler<'_>

fn fmsub(&mut self, op0: Vec, op1: Vec, op2: Vec, op3: Vec)

impl FmulEmitter<Vec, Vec, Vec> for Assembler<'_>

fn fmul(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl FmulxEmitter<Vec, Vec, Vec> for Assembler<'_>

fn fmulx(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl FnegEmitter<Vec, Vec> for Assembler<'_>

fn fneg(&mut self, op0: Vec, op1: Vec)

impl FnmaddEmitter<Vec, Vec, Vec, Vec> for Assembler<'_>

fn fnmadd(&mut self, op0: Vec, op1: Vec, op2: Vec, op3: Vec)

impl FnmsubEmitter<Vec, Vec, Vec, Vec> for Assembler<'_>

fn fnmsub(&mut self, op0: Vec, op1: Vec, op2: Vec, op3: Vec)

impl FnmulEmitter<Vec, Vec, Vec> for Assembler<'_>

fn fnmul(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl FrecpeEmitter<Vec, Vec> for Assembler<'_>

fn frecpe(&mut self, op0: Vec, op1: Vec)

impl FrecpsEmitter<Vec, Vec, Vec> for Assembler<'_>

fn frecps(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl FrecpxEmitter<Vec, Vec> for Assembler<'_>

fn frecpx(&mut self, op0: Vec, op1: Vec)

impl Frint32xEmitter<Vec, Vec> for Assembler<'_>

fn frint32x(&mut self, op0: Vec, op1: Vec)

impl Frint32zEmitter<Vec, Vec> for Assembler<'_>

fn frint32z(&mut self, op0: Vec, op1: Vec)

impl Frint64xEmitter<Vec, Vec> for Assembler<'_>

fn frint64x(&mut self, op0: Vec, op1: Vec)

impl Frint64zEmitter<Vec, Vec> for Assembler<'_>

fn frint64z(&mut self, op0: Vec, op1: Vec)

impl FrintaEmitter<Vec, Vec> for Assembler<'_>

fn frinta(&mut self, op0: Vec, op1: Vec)

impl FrintiEmitter<Vec, Vec> for Assembler<'_>

fn frinti(&mut self, op0: Vec, op1: Vec)

impl FrintmEmitter<Vec, Vec> for Assembler<'_>

fn frintm(&mut self, op0: Vec, op1: Vec)

impl FrintnEmitter<Vec, Vec> for Assembler<'_>

fn frintn(&mut self, op0: Vec, op1: Vec)

impl FrintpEmitter<Vec, Vec> for Assembler<'_>

fn frintp(&mut self, op0: Vec, op1: Vec)

impl FrintxEmitter<Vec, Vec> for Assembler<'_>

fn frintx(&mut self, op0: Vec, op1: Vec)

impl FrintzEmitter<Vec, Vec> for Assembler<'_>

fn frintz(&mut self, op0: Vec, op1: Vec)

impl FrsqrteEmitter<Vec, Vec> for Assembler<'_>

fn frsqrte(&mut self, op0: Vec, op1: Vec)

impl FrsqrtsEmitter<Vec, Vec, Vec> for Assembler<'_>

fn frsqrts(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl FsqrtEmitter<Vec, Vec> for Assembler<'_>

fn fsqrt(&mut self, op0: Vec, op1: Vec)

impl FsubEmitter<Vec, Vec, Vec> for Assembler<'_>

fn fsub(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl GmiEmitter<Gp, Gp, Gp> for Assembler<'_>

fn gmi(&mut self, op0: Gp, op1: Gp, op2: Gp)

impl HintEmitter<Imm> for Assembler<'_>

fn hint(&mut self, op0: Imm)

impl HltEmitter<Imm> for Assembler<'_>

fn hlt(&mut self, op0: Imm)

impl HvcEmitter<Imm> for Assembler<'_>

fn hvc(&mut self, op0: Imm)

impl IcEmitter<Imm, Gp> for Assembler<'_>

fn ic(&mut self, op0: Imm, op1: Gp)

impl InsEmitter<Vec, Gp> for Assembler<'_>

fn ins(&mut self, op0: Vec, op1: Gp)

impl InsEmitter<Vec, Vec> for Assembler<'_>

fn ins(&mut self, op0: Vec, op1: Vec)

impl IsbEmitter<Imm> for Assembler<'_>

fn isb(&mut self, op0: Imm)

impl Ld13Emitter<Vec, Vec, Mem> for Assembler<'_>

fn ld1_3(&mut self, op0: Vec, op1: Vec, op2: Mem)

impl Ld14Emitter<Vec, Vec, Vec, Mem> for Assembler<'_>

fn ld1_4(&mut self, op0: Vec, op1: Vec, op2: Vec, op3: Mem)

impl Ld15Emitter<Vec, Vec, Vec, Vec, Mem> for Assembler<'_>

fn ld1_5(&mut self, op0: Vec, op1: Vec, op2: Vec, op3: Vec, op4: Mem)

impl Ld1Emitter<Vec, Mem> for Assembler<'_>

fn ld1(&mut self, op0: Vec, op1: Mem)

impl Ld1rEmitter<Vec, Mem> for Assembler<'_>

fn ld1r(&mut self, op0: Vec, op1: Mem)

impl Ld2Emitter<Vec, Vec, Mem> for Assembler<'_>

fn ld2(&mut self, op0: Vec, op1: Vec, op2: Mem)

impl Ld2rEmitter<Vec, Vec, Mem> for Assembler<'_>

fn ld2r(&mut self, op0: Vec, op1: Vec, op2: Mem)

impl Ld3Emitter<Vec, Vec, Vec, Mem> for Assembler<'_>

fn ld3(&mut self, op0: Vec, op1: Vec, op2: Vec, op3: Mem)

impl Ld3rEmitter<Vec, Vec, Vec, Mem> for Assembler<'_>

fn ld3r(&mut self, op0: Vec, op1: Vec, op2: Vec, op3: Mem)

impl Ld4Emitter<Vec, Vec, Vec, Vec, Mem> for Assembler<'_>

fn ld4(&mut self, op0: Vec, op1: Vec, op2: Vec, op3: Vec, op4: Mem)

impl Ld4rEmitter<Vec, Vec, Vec, Vec, Mem> for Assembler<'_>

fn ld4r(&mut self, op0: Vec, op1: Vec, op2: Vec, op3: Vec, op4: Mem)

impl LdaddEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldadd(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdaddaEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldadda(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdaddabEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldaddab(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdaddahEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldaddah(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdaddalEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldaddal(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdaddalbEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldaddalb(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdaddalhEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldaddalh(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdaddbEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldaddb(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdaddhEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldaddh(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdaddlEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldaddl(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdaddlbEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldaddlb(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdaddlhEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldaddlh(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdarEmitter<Gp, Mem> for Assembler<'_>

fn ldar(&mut self, op0: Gp, op1: Mem)

impl LdarbEmitter<Gp, Mem> for Assembler<'_>

fn ldarb(&mut self, op0: Gp, op1: Mem)

impl LdarhEmitter<Gp, Mem> for Assembler<'_>

fn ldarh(&mut self, op0: Gp, op1: Mem)

impl LdaxpEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldaxp(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdaxrEmitter<Gp, Mem> for Assembler<'_>

fn ldaxr(&mut self, op0: Gp, op1: Mem)

impl LdaxrbEmitter<Gp, Mem> for Assembler<'_>

fn ldaxrb(&mut self, op0: Gp, op1: Mem)

impl LdaxrhEmitter<Gp, Mem> for Assembler<'_>

fn ldaxrh(&mut self, op0: Gp, op1: Mem)

impl LdclrEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldclr(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdclraEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldclra(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdclrabEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldclrab(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdclrahEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldclrah(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdclralEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldclral(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdclralbEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldclralb(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdclralhEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldclralh(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdclrbEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldclrb(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdclrhEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldclrh(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdclrlEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldclrl(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdclrlbEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldclrlb(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdclrlhEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldclrlh(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdeorEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldeor(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdeoraEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldeora(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdeorabEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldeorab(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdeorahEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldeorah(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdeoralEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldeoral(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdeoralbEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldeoralb(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdeoralhEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldeoralh(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdeorbEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldeorb(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdeorhEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldeorh(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdeorlEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldeorl(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdeorlbEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldeorlb(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdeorlhEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldeorlh(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdgEmitter<Gp, Mem> for Assembler<'_>

fn ldg(&mut self, op0: Gp, op1: Mem)

impl LdgmEmitter<Gp, Mem> for Assembler<'_>

fn ldgm(&mut self, op0: Gp, op1: Mem)

impl LdlarEmitter<Gp, Mem> for Assembler<'_>

fn ldlar(&mut self, op0: Gp, op1: Mem)

impl LdlarbEmitter<Gp, Mem> for Assembler<'_>

fn ldlarb(&mut self, op0: Gp, op1: Mem)

impl LdlarhEmitter<Gp, Mem> for Assembler<'_>

fn ldlarh(&mut self, op0: Gp, op1: Mem)

impl LdnpEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldnp(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdnpEmitter<Vec, Vec, Mem> for Assembler<'_>

fn ldnp(&mut self, op0: Vec, op1: Vec, op2: Mem)

impl LdpEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldp(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdpEmitter<Vec, Vec, Mem> for Assembler<'_>

fn ldp(&mut self, op0: Vec, op1: Vec, op2: Mem)

impl LdpswEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldpsw(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdrEmitter<Gp, Mem> for Assembler<'_>

fn ldr(&mut self, op0: Gp, op1: Mem)

impl LdrEmitter<Vec, Mem> for Assembler<'_>

fn ldr(&mut self, op0: Vec, op1: Mem)

impl LdraaEmitter<Gp, Mem> for Assembler<'_>

fn ldraa(&mut self, op0: Gp, op1: Mem)

impl LdrabEmitter<Gp, Mem> for Assembler<'_>

fn ldrab(&mut self, op0: Gp, op1: Mem)

impl LdrbEmitter<Gp, Mem> for Assembler<'_>

fn ldrb(&mut self, op0: Gp, op1: Mem)

impl LdrhEmitter<Gp, Mem> for Assembler<'_>

fn ldrh(&mut self, op0: Gp, op1: Mem)

impl LdrsbEmitter<Gp, Mem> for Assembler<'_>

fn ldrsb(&mut self, op0: Gp, op1: Mem)

impl LdrshEmitter<Gp, Mem> for Assembler<'_>

fn ldrsh(&mut self, op0: Gp, op1: Mem)

impl LdrswEmitter<Gp, Mem> for Assembler<'_>

fn ldrsw(&mut self, op0: Gp, op1: Mem)

impl LdsetEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldset(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdsetaEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldseta(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdsetabEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldsetab(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdsetahEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldsetah(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdsetalEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldsetal(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdsetalbEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldsetalb(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdsetalhEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldsetalh(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdsetbEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldsetb(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdsethEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldseth(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdsetlEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldsetl(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdsetlbEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldsetlb(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdsetlhEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldsetlh(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdsmaxEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldsmax(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdsmaxaEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldsmaxa(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdsmaxabEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldsmaxab(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdsmaxahEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldsmaxah(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdsmaxalEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldsmaxal(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdsmaxalbEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldsmaxalb(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdsmaxalhEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldsmaxalh(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdsmaxbEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldsmaxb(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdsmaxhEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldsmaxh(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdsmaxlEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldsmaxl(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdsmaxlbEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldsmaxlb(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdsmaxlhEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldsmaxlh(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdsminEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldsmin(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdsminaEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldsmina(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdsminabEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldsminab(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdsminahEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldsminah(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdsminalEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldsminal(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdsminalbEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldsminalb(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdsminalhEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldsminalh(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdsminbEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldsminb(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdsminhEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldsminh(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdsminlEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldsminl(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdsminlbEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldsminlb(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdsminlhEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldsminlh(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdtrEmitter<Gp, Mem> for Assembler<'_>

fn ldtr(&mut self, op0: Gp, op1: Mem)

impl LdtrbEmitter<Gp, Mem> for Assembler<'_>

fn ldtrb(&mut self, op0: Gp, op1: Mem)

impl LdtrhEmitter<Gp, Mem> for Assembler<'_>

fn ldtrh(&mut self, op0: Gp, op1: Mem)

impl LdtrsbEmitter<Gp, Mem> for Assembler<'_>

fn ldtrsb(&mut self, op0: Gp, op1: Mem)

impl LdtrshEmitter<Gp, Mem> for Assembler<'_>

fn ldtrsh(&mut self, op0: Gp, op1: Mem)

impl LdtrswEmitter<Gp, Mem> for Assembler<'_>

fn ldtrsw(&mut self, op0: Gp, op1: Mem)

impl LdumaxEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldumax(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdumaxaEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldumaxa(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdumaxabEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldumaxab(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdumaxahEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldumaxah(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdumaxalEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldumaxal(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdumaxalbEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldumaxalb(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdumaxalhEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldumaxalh(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdumaxbEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldumaxb(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdumaxhEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldumaxh(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdumaxlEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldumaxl(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdumaxlbEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldumaxlb(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdumaxlhEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldumaxlh(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LduminEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldumin(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LduminaEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldumina(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LduminabEmitter<Gp, Gp, Mem> for Assembler<'_>

fn lduminab(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LduminahEmitter<Gp, Gp, Mem> for Assembler<'_>

fn lduminah(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LduminalEmitter<Gp, Gp, Mem> for Assembler<'_>

fn lduminal(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LduminalbEmitter<Gp, Gp, Mem> for Assembler<'_>

fn lduminalb(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LduminalhEmitter<Gp, Gp, Mem> for Assembler<'_>

fn lduminalh(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LduminbEmitter<Gp, Gp, Mem> for Assembler<'_>

fn lduminb(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LduminhEmitter<Gp, Gp, Mem> for Assembler<'_>

fn lduminh(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LduminlEmitter<Gp, Gp, Mem> for Assembler<'_>

fn lduminl(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LduminlbEmitter<Gp, Gp, Mem> for Assembler<'_>

fn lduminlb(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LduminlhEmitter<Gp, Gp, Mem> for Assembler<'_>

fn lduminlh(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdurEmitter<Gp, Mem> for Assembler<'_>

fn ldur(&mut self, op0: Gp, op1: Mem)

impl LdurEmitter<Vec, Mem> for Assembler<'_>

fn ldur(&mut self, op0: Vec, op1: Mem)

impl LdurbEmitter<Gp, Mem> for Assembler<'_>

fn ldurb(&mut self, op0: Gp, op1: Mem)

impl LdurhEmitter<Gp, Mem> for Assembler<'_>

fn ldurh(&mut self, op0: Gp, op1: Mem)

impl LdursbEmitter<Gp, Mem> for Assembler<'_>

fn ldursb(&mut self, op0: Gp, op1: Mem)

impl LdurshEmitter<Gp, Mem> for Assembler<'_>

fn ldursh(&mut self, op0: Gp, op1: Mem)

impl LdurswEmitter<Gp, Mem> for Assembler<'_>

fn ldursw(&mut self, op0: Gp, op1: Mem)

impl LdxpEmitter<Gp, Gp, Mem> for Assembler<'_>

fn ldxp(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl LdxrEmitter<Gp, Mem> for Assembler<'_>

fn ldxr(&mut self, op0: Gp, op1: Mem)

impl LdxrbEmitter<Gp, Mem> for Assembler<'_>

fn ldxrb(&mut self, op0: Gp, op1: Mem)

impl LdxrhEmitter<Gp, Mem> for Assembler<'_>

fn ldxrh(&mut self, op0: Gp, op1: Mem)

impl LoadConstantEmitter<Gp, Constant> for Assembler<'_>

fn load_constant(&mut self, dst: Gp, src: Constant)

impl LoadConstantEmitter<Gp, Label> for Assembler<'_>

fn load_constant(&mut self, dst: Gp, src: Label)

impl LoadConstantEmitter<Gp, Sym> for Assembler<'_>

fn load_constant(&mut self, dst: Gp, src: Sym)

impl LslEmitter<Gp, Gp, Gp> for Assembler<'_>

fn lsl(&mut self, op0: Gp, op1: Gp, op2: Gp)

impl LslEmitter<Gp, Gp, Imm> for Assembler<'_>

fn lsl(&mut self, op0: Gp, op1: Gp, op2: Imm)

impl LslvEmitter<Gp, Gp, Gp> for Assembler<'_>

fn lslv(&mut self, op0: Gp, op1: Gp, op2: Gp)

impl LsrEmitter<Gp, Gp, Gp> for Assembler<'_>

fn lsr(&mut self, op0: Gp, op1: Gp, op2: Gp)

impl LsrEmitter<Gp, Gp, Imm> for Assembler<'_>

fn lsr(&mut self, op0: Gp, op1: Gp, op2: Imm)

impl LsrvEmitter<Gp, Gp, Gp> for Assembler<'_>

fn lsrv(&mut self, op0: Gp, op1: Gp, op2: Gp)

impl MaddEmitter<Gp, Gp, Gp, Gp> for Assembler<'_>

fn madd(&mut self, op0: Gp, op1: Gp, op2: Gp, op3: Gp)

impl MlaEmitter<Vec, Vec, Vec> for Assembler<'_>

fn mla(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl MlsEmitter<Vec, Vec, Vec> for Assembler<'_>

fn mls(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl MnegEmitter<Gp, Gp, Gp> for Assembler<'_>

fn mneg(&mut self, op0: Gp, op1: Gp, op2: Gp)

impl MovEmitter<Gp, Gp> for Assembler<'_>

fn mov(&mut self, op0: Gp, op1: Gp)

impl MovEmitter<Gp, Imm> for Assembler<'_>

fn mov(&mut self, op0: Gp, op1: Imm)

impl MovEmitter<Gp, Vec> for Assembler<'_>

fn mov(&mut self, op0: Gp, op1: Vec)

impl MovEmitter<Vec, Gp> for Assembler<'_>

fn mov(&mut self, op0: Vec, op1: Gp)

impl MovEmitter<Vec, Vec> for Assembler<'_>

fn mov(&mut self, op0: Vec, op1: Vec)

impl Movi3Emitter<Vec, Imm, Imm> for Assembler<'_>

fn movi_3(&mut self, op0: Vec, op1: Imm, op2: Imm)

impl MoviEmitter<Vec, Imm> for Assembler<'_>

fn movi(&mut self, op0: Vec, op1: Imm)

impl Movk3Emitter<Gp, Imm, Imm> for Assembler<'_>

fn movk_3(&mut self, op0: Gp, op1: Imm, op2: Imm)

impl MovkEmitter<Gp, Imm> for Assembler<'_>

fn movk(&mut self, op0: Gp, op1: Imm)

impl Movn3Emitter<Gp, Imm, Imm> for Assembler<'_>

fn movn_3(&mut self, op0: Gp, op1: Imm, op2: Imm)

impl MovnEmitter<Gp, Imm> for Assembler<'_>

fn movn(&mut self, op0: Gp, op1: Imm)

impl Movz3Emitter<Gp, Imm, Imm> for Assembler<'_>

fn movz_3(&mut self, op0: Gp, op1: Imm, op2: Imm)

impl MovzEmitter<Gp, Imm> for Assembler<'_>

fn movz(&mut self, op0: Gp, op1: Imm)

impl MrsEmitter<Gp, Imm> for Assembler<'_>

fn mrs(&mut self, op0: Gp, op1: Imm)

impl MsrEmitter<Imm, Gp> for Assembler<'_>

fn msr(&mut self, op0: Imm, op1: Gp)

impl MsrEmitter<Imm, Imm> for Assembler<'_>

fn msr(&mut self, op0: Imm, op1: Imm)

impl MsubEmitter<Gp, Gp, Gp, Gp> for Assembler<'_>

fn msub(&mut self, op0: Gp, op1: Gp, op2: Gp, op3: Gp)

impl MulEmitter<Gp, Gp, Gp> for Assembler<'_>

fn mul(&mut self, op0: Gp, op1: Gp, op2: Gp)

impl MulEmitter<Vec, Vec, Vec> for Assembler<'_>

fn mul(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl Mvn3Emitter<Gp, Gp, Imm> for Assembler<'_>

fn mvn_3(&mut self, op0: Gp, op1: Gp, op2: Imm)

impl MvnEmitter<Gp, Gp> for Assembler<'_>

fn mvn(&mut self, op0: Gp, op1: Gp)

impl MvnEmitter<Vec, Vec> for Assembler<'_>

fn mvn(&mut self, op0: Vec, op1: Vec)

impl Mvn_3Emitter<Gp, Gp, Imm> for Assembler<'_>

fn mvn__3(&mut self, op0: Gp, op1: Gp, op2: Imm)

impl Mvn_Emitter<Gp, Gp> for Assembler<'_>

fn mvn_(&mut self, op0: Gp, op1: Gp)

impl Mvn_Emitter<Vec, Vec> for Assembler<'_>

fn mvn_(&mut self, op0: Vec, op1: Vec)

impl Mvni3Emitter<Vec, Imm, Imm> for Assembler<'_>

fn mvni_3(&mut self, op0: Vec, op1: Imm, op2: Imm)

impl MvniEmitter<Vec, Imm> for Assembler<'_>

fn mvni(&mut self, op0: Vec, op1: Imm)

impl Neg3Emitter<Gp, Gp, Imm> for Assembler<'_>

fn neg_3(&mut self, op0: Gp, op1: Gp, op2: Imm)

impl NegEmitter<Gp, Gp> for Assembler<'_>

fn neg(&mut self, op0: Gp, op1: Gp)

impl NegEmitter<Vec, Vec> for Assembler<'_>

fn neg(&mut self, op0: Vec, op1: Vec)

impl Negs3Emitter<Gp, Gp, Imm> for Assembler<'_>

fn negs_3(&mut self, op0: Gp, op1: Gp, op2: Imm)

impl NegsEmitter<Gp, Gp> for Assembler<'_>

fn negs(&mut self, op0: Gp, op1: Gp)

impl NgcEmitter<Gp, Gp> for Assembler<'_>

fn ngc(&mut self, op0: Gp, op1: Gp)

impl NgcsEmitter<Gp, Gp> for Assembler<'_>

fn ngcs(&mut self, op0: Gp, op1: Gp)

impl NopEmitter for Assembler<'_>

fn nop(&mut self)

impl NotEmitter<Vec, Vec> for Assembler<'_>

fn not_(&mut self, op0: Vec, op1: Vec)

impl Orn4Emitter<Gp, Gp, Gp, Imm> for Assembler<'_>

fn orn_4(&mut self, op0: Gp, op1: Gp, op2: Gp, op3: Imm)

impl OrnEmitter<Gp, Gp, Gp> for Assembler<'_>

fn orn(&mut self, op0: Gp, op1: Gp, op2: Gp)

impl OrnEmitter<Vec, Vec, Vec> for Assembler<'_>

fn orn(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl Orr2Emitter<Vec, Imm> for Assembler<'_>

fn orr_2(&mut self, op0: Vec, op1: Imm)

impl Orr4Emitter<Gp, Gp, Gp, Imm> for Assembler<'_>

fn orr_4(&mut self, op0: Gp, op1: Gp, op2: Gp, op3: Imm)

impl OrrEmitter<Gp, Gp, Gp> for Assembler<'_>

fn orr(&mut self, op0: Gp, op1: Gp, op2: Gp)

impl OrrEmitter<Gp, Gp, Imm> for Assembler<'_>

fn orr(&mut self, op0: Gp, op1: Gp, op2: Imm)

impl OrrEmitter<Vec, Imm, Imm> for Assembler<'_>

fn orr(&mut self, op0: Vec, op1: Imm, op2: Imm)

impl OrrEmitter<Vec, Vec, Vec> for Assembler<'_>

fn orr(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl PacdaEmitter<Gp, Gp> for Assembler<'_>

fn pacda(&mut self, op0: Gp, op1: Gp)

impl PacdbEmitter<Gp, Gp> for Assembler<'_>

fn pacdb(&mut self, op0: Gp, op1: Gp)

impl PacdzaEmitter<Gp> for Assembler<'_>

fn pacdza(&mut self, op0: Gp)

impl PacdzbEmitter<Gp> for Assembler<'_>

fn pacdzb(&mut self, op0: Gp)

impl PacgaEmitter<Gp, Gp, Gp> for Assembler<'_>

fn pacga(&mut self, op0: Gp, op1: Gp, op2: Gp)

impl PmulEmitter<Vec, Vec, Vec> for Assembler<'_>

fn pmul(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl Pmull2Emitter<Vec, Vec, Vec> for Assembler<'_>

fn pmull2(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl PmullEmitter<Vec, Vec, Vec> for Assembler<'_>

fn pmull(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl PrfmEmitter<Imm, Mem> for Assembler<'_>

fn prfm(&mut self, op0: Imm, op1: Mem)

impl PssbbEmitter for Assembler<'_>

fn pssbb(&mut self)

impl Raddhn2Emitter<Vec, Vec, Vec> for Assembler<'_>

fn raddhn2(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl RaddhnEmitter<Vec, Vec, Vec> for Assembler<'_>

fn raddhn(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl Rax1Emitter<Vec, Vec, Vec> for Assembler<'_>

fn rax1(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl RbitEmitter<Gp, Gp> for Assembler<'_>

fn rbit(&mut self, op0: Gp, op1: Gp)

impl RbitEmitter<Vec, Vec> for Assembler<'_>

fn rbit(&mut self, op0: Vec, op1: Vec)

impl RetEmitter<Gp> for Assembler<'_>

fn ret(&mut self, op0: Gp)

impl Rev16Emitter<Gp, Gp> for Assembler<'_>

fn rev16(&mut self, op0: Gp, op1: Gp)

impl Rev16Emitter<Vec, Vec> for Assembler<'_>

fn rev16(&mut self, op0: Vec, op1: Vec)

impl Rev32Emitter<Gp, Gp> for Assembler<'_>

fn rev32(&mut self, op0: Gp, op1: Gp)

impl Rev32Emitter<Vec, Vec> for Assembler<'_>

fn rev32(&mut self, op0: Vec, op1: Vec)

impl Rev64Emitter<Gp, Gp> for Assembler<'_>

fn rev64(&mut self, op0: Gp, op1: Gp)

impl Rev64Emitter<Vec, Vec> for Assembler<'_>

fn rev64(&mut self, op0: Vec, op1: Vec)

impl RevEmitter<Gp, Gp> for Assembler<'_>

fn rev(&mut self, op0: Gp, op1: Gp)

impl RorEmitter<Gp, Gp, Gp> for Assembler<'_>

fn ror(&mut self, op0: Gp, op1: Gp, op2: Gp)

impl RorEmitter<Gp, Gp, Imm> for Assembler<'_>

fn ror(&mut self, op0: Gp, op1: Gp, op2: Imm)

impl RorvEmitter<Gp, Gp, Gp> for Assembler<'_>

fn rorv(&mut self, op0: Gp, op1: Gp, op2: Gp)

impl Rshrn2Emitter<Vec, Vec, Imm> for Assembler<'_>

fn rshrn2(&mut self, op0: Vec, op1: Vec, op2: Imm)

impl RshrnEmitter<Vec, Vec, Imm> for Assembler<'_>

fn rshrn(&mut self, op0: Vec, op1: Vec, op2: Imm)

impl Rsubhn2Emitter<Vec, Vec, Vec> for Assembler<'_>

fn rsubhn2(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl RsubhnEmitter<Vec, Vec, Vec> for Assembler<'_>

fn rsubhn(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl SabaEmitter<Vec, Vec, Vec> for Assembler<'_>

fn saba(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl Sabal2Emitter<Vec, Vec, Vec> for Assembler<'_>

fn sabal2(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl SabalEmitter<Vec, Vec, Vec> for Assembler<'_>

fn sabal(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl SabdEmitter<Vec, Vec, Vec> for Assembler<'_>

fn sabd(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl Sabdl2Emitter<Vec, Vec, Vec> for Assembler<'_>

fn sabdl2(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl SabdlEmitter<Vec, Vec, Vec> for Assembler<'_>

fn sabdl(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl SadalpEmitter<Vec, Vec> for Assembler<'_>

fn sadalp(&mut self, op0: Vec, op1: Vec)

impl Saddl2Emitter<Vec, Vec, Vec> for Assembler<'_>

fn saddl2(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl SaddlEmitter<Vec, Vec, Vec> for Assembler<'_>

fn saddl(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl SaddlpEmitter<Vec, Vec> for Assembler<'_>

fn saddlp(&mut self, op0: Vec, op1: Vec)

impl SaddlvEmitter<Vec, Vec> for Assembler<'_>

fn saddlv(&mut self, op0: Vec, op1: Vec)

impl Saddw2Emitter<Vec, Vec, Vec> for Assembler<'_>

fn saddw2(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl SaddwEmitter<Vec, Vec, Vec> for Assembler<'_>

fn saddw(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl SbcEmitter<Gp, Gp, Gp> for Assembler<'_>

fn sbc(&mut self, op0: Gp, op1: Gp, op2: Gp)

impl SbcsEmitter<Gp, Gp, Gp> for Assembler<'_>

fn sbcs(&mut self, op0: Gp, op1: Gp, op2: Gp)

impl SbfizEmitter<Gp, Gp, Imm, Imm> for Assembler<'_>

fn sbfiz(&mut self, op0: Gp, op1: Gp, op2: Imm, op3: Imm)

impl SbfmEmitter<Gp, Gp, Imm, Imm> for Assembler<'_>

fn sbfm(&mut self, op0: Gp, op1: Gp, op2: Imm, op3: Imm)

impl SbfxEmitter<Gp, Gp, Imm, Imm> for Assembler<'_>

fn sbfx(&mut self, op0: Gp, op1: Gp, op2: Imm, op3: Imm)

impl Scvtf3Emitter<Vec, Gp, Imm> for Assembler<'_>

fn scvtf_3(&mut self, op0: Vec, op1: Gp, op2: Imm)

impl Scvtf3Emitter<Vec, Vec, Imm> for Assembler<'_>

fn scvtf_3(&mut self, op0: Vec, op1: Vec, op2: Imm)

impl ScvtfEmitter<Vec, Gp> for Assembler<'_>

fn scvtf(&mut self, op0: Vec, op1: Gp)

impl ScvtfEmitter<Vec, Vec> for Assembler<'_>

fn scvtf(&mut self, op0: Vec, op1: Vec)

impl SdivEmitter<Gp, Gp, Gp> for Assembler<'_>

fn sdiv(&mut self, op0: Gp, op1: Gp, op2: Gp)

impl SdotEmitter<Vec, Vec, Vec> for Assembler<'_>

fn sdot(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl Setf16Emitter<Gp> for Assembler<'_>

fn setf16(&mut self, op0: Gp)

impl Setf8Emitter<Gp> for Assembler<'_>

fn setf8(&mut self, op0: Gp)

impl SevEmitter for Assembler<'_>

fn sev(&mut self)

impl SevlEmitter for Assembler<'_>

fn sevl(&mut self)

impl Sha1cEmitter<Vec, Vec, Vec> for Assembler<'_>

fn sha1c(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl Sha1hEmitter<Vec, Vec> for Assembler<'_>

fn sha1h(&mut self, op0: Vec, op1: Vec)

impl Sha1mEmitter<Vec, Vec, Vec> for Assembler<'_>

fn sha1m(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl Sha1pEmitter<Vec, Vec, Vec> for Assembler<'_>

fn sha1p(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl Sha1su0Emitter<Vec, Vec, Vec> for Assembler<'_>

fn sha1su0(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl Sha1su1Emitter<Vec, Vec> for Assembler<'_>

fn sha1su1(&mut self, op0: Vec, op1: Vec)

impl Sha256h2Emitter<Vec, Vec, Vec> for Assembler<'_>

fn sha256h2(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl Sha256hEmitter<Vec, Vec, Vec> for Assembler<'_>

fn sha256h(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl Sha256su0Emitter<Vec, Vec> for Assembler<'_>

fn sha256su0(&mut self, op0: Vec, op1: Vec)

impl Sha256su1Emitter<Vec, Vec, Vec> for Assembler<'_>

fn sha256su1(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl Sha512h2Emitter<Vec, Vec, Vec> for Assembler<'_>

fn sha512h2(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl Sha512hEmitter<Vec, Vec, Vec> for Assembler<'_>

fn sha512h(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl Sha512su0Emitter<Vec, Vec> for Assembler<'_>

fn sha512su0(&mut self, op0: Vec, op1: Vec)

impl Sha512su1Emitter<Vec, Vec, Vec> for Assembler<'_>

fn sha512su1(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl ShaddEmitter<Vec, Vec, Vec> for Assembler<'_>

fn shadd(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl ShlEmitter<Vec, Vec, Imm> for Assembler<'_>

fn shl(&mut self, op0: Vec, op1: Vec, op2: Imm)

impl Shll2Emitter<Vec, Vec, Imm> for Assembler<'_>

fn shll2(&mut self, op0: Vec, op1: Vec, op2: Imm)

impl ShllEmitter<Vec, Vec, Imm> for Assembler<'_>

fn shll(&mut self, op0: Vec, op1: Vec, op2: Imm)

impl Shrn2Emitter<Vec, Vec, Imm> for Assembler<'_>

fn shrn2(&mut self, op0: Vec, op1: Vec, op2: Imm)

impl ShrnEmitter<Vec, Vec, Imm> for Assembler<'_>

fn shrn(&mut self, op0: Vec, op1: Vec, op2: Imm)

impl ShsubEmitter<Vec, Vec, Vec> for Assembler<'_>

fn shsub(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl SliEmitter<Vec, Vec, Imm> for Assembler<'_>

fn sli(&mut self, op0: Vec, op1: Vec, op2: Imm)

impl Sm3partw1Emitter<Vec, Vec, Vec> for Assembler<'_>

fn sm3partw1(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl Sm3partw2Emitter<Vec, Vec, Vec> for Assembler<'_>

fn sm3partw2(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl Sm3ss1Emitter<Vec, Vec, Vec, Vec> for Assembler<'_>

fn sm3ss1(&mut self, op0: Vec, op1: Vec, op2: Vec, op3: Vec)

impl Sm3tt1aEmitter<Vec, Vec, Vec> for Assembler<'_>

fn sm3tt1a(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl Sm3tt1bEmitter<Vec, Vec, Vec> for Assembler<'_>

fn sm3tt1b(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl Sm3tt2aEmitter<Vec, Vec, Vec> for Assembler<'_>

fn sm3tt2a(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl Sm3tt2bEmitter<Vec, Vec, Vec> for Assembler<'_>

fn sm3tt2b(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl Sm4eEmitter<Vec, Vec> for Assembler<'_>

fn sm4e(&mut self, op0: Vec, op1: Vec)

impl Sm4ekeyEmitter<Vec, Vec, Vec> for Assembler<'_>

fn sm4ekey(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl SmaddlEmitter<Gp, Gp, Gp, Gp> for Assembler<'_>

fn smaddl(&mut self, op0: Gp, op1: Gp, op2: Gp, op3: Gp)

impl SmaxEmitter<Gp, Gp, Gp> for Assembler<'_>

fn smax(&mut self, op0: Gp, op1: Gp, op2: Gp)

impl SmaxEmitter<Gp, Gp, Imm> for Assembler<'_>

fn smax(&mut self, op0: Gp, op1: Gp, op2: Imm)

impl SmaxEmitter<Vec, Vec, Vec> for Assembler<'_>

fn smax(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl SmaxpEmitter<Vec, Vec, Vec> for Assembler<'_>

fn smaxp(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl SmaxvEmitter<Vec, Vec> for Assembler<'_>

fn smaxv(&mut self, op0: Vec, op1: Vec)

impl SmcEmitter<Imm> for Assembler<'_>

fn smc(&mut self, op0: Imm)

impl SminEmitter<Gp, Gp, Gp> for Assembler<'_>

fn smin(&mut self, op0: Gp, op1: Gp, op2: Gp)

impl SminEmitter<Gp, Gp, Imm> for Assembler<'_>

fn smin(&mut self, op0: Gp, op1: Gp, op2: Imm)

impl SminEmitter<Vec, Vec, Vec> for Assembler<'_>

fn smin(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl SminpEmitter<Vec, Vec, Vec> for Assembler<'_>

fn sminp(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl SminvEmitter<Vec, Vec> for Assembler<'_>

fn sminv(&mut self, op0: Vec, op1: Vec)

impl Smlal2Emitter<Vec, Vec, Vec> for Assembler<'_>

fn smlal2(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl SmlalEmitter<Vec, Vec, Vec> for Assembler<'_>

fn smlal(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl Smlsl2Emitter<Vec, Vec, Vec> for Assembler<'_>

fn smlsl2(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl SmlslEmitter<Vec, Vec, Vec> for Assembler<'_>

fn smlsl(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl SmmlaEmitter<Vec, Vec, Vec> for Assembler<'_>

fn smmla(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl SmneglEmitter<Gp, Gp, Gp> for Assembler<'_>

fn smnegl(&mut self, op0: Gp, op1: Gp, op2: Gp)

impl SmovEmitter<Gp, Vec> for Assembler<'_>

fn smov(&mut self, op0: Gp, op1: Vec)

impl SmsublEmitter<Gp, Gp, Gp, Gp> for Assembler<'_>

fn smsubl(&mut self, op0: Gp, op1: Gp, op2: Gp, op3: Gp)

impl SmulhEmitter<Gp, Gp, Gp> for Assembler<'_>

fn smulh(&mut self, op0: Gp, op1: Gp, op2: Gp)

impl Smull2Emitter<Vec, Vec, Vec> for Assembler<'_>

fn smull2(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl SmullEmitter<Gp, Gp, Gp> for Assembler<'_>

fn smull(&mut self, op0: Gp, op1: Gp, op2: Gp)

impl SmullEmitter<Vec, Vec, Vec> for Assembler<'_>

fn smull(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl SqabsEmitter<Vec, Vec> for Assembler<'_>

fn sqabs(&mut self, op0: Vec, op1: Vec)

impl SqaddEmitter<Vec, Vec, Vec> for Assembler<'_>

fn sqadd(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl Sqdmlal2Emitter<Vec, Vec, Vec> for Assembler<'_>

fn sqdmlal2(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl SqdmlalEmitter<Vec, Vec, Vec> for Assembler<'_>

fn sqdmlal(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl Sqdmlsl2Emitter<Vec, Vec, Vec> for Assembler<'_>

fn sqdmlsl2(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl SqdmlslEmitter<Vec, Vec, Vec> for Assembler<'_>

fn sqdmlsl(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl SqdmulhEmitter<Vec, Vec, Vec> for Assembler<'_>

fn sqdmulh(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl Sqdmull2Emitter<Vec, Vec, Vec> for Assembler<'_>

fn sqdmull2(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl SqdmullEmitter<Vec, Vec, Vec> for Assembler<'_>

fn sqdmull(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl SqnegEmitter<Vec, Vec> for Assembler<'_>

fn sqneg(&mut self, op0: Vec, op1: Vec)

impl SqrdmlahEmitter<Vec, Vec, Vec> for Assembler<'_>

fn sqrdmlah(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl SqrdmlshEmitter<Vec, Vec, Vec> for Assembler<'_>

fn sqrdmlsh(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl SqrdmulhEmitter<Vec, Vec, Vec> for Assembler<'_>

fn sqrdmulh(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl SqrshlEmitter<Vec, Vec, Vec> for Assembler<'_>

fn sqrshl(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl Sqrshrn2Emitter<Vec, Vec, Imm> for Assembler<'_>

fn sqrshrn2(&mut self, op0: Vec, op1: Vec, op2: Imm)

impl SqrshrnEmitter<Vec, Vec, Imm> for Assembler<'_>

fn sqrshrn(&mut self, op0: Vec, op1: Vec, op2: Imm)

impl Sqrshrun2Emitter<Vec, Vec, Imm> for Assembler<'_>

fn sqrshrun2(&mut self, op0: Vec, op1: Vec, op2: Imm)

impl SqrshrunEmitter<Vec, Vec, Imm> for Assembler<'_>

fn sqrshrun(&mut self, op0: Vec, op1: Vec, op2: Imm)

impl SqshlEmitter<Vec, Vec, Imm> for Assembler<'_>

fn sqshl(&mut self, op0: Vec, op1: Vec, op2: Imm)

impl SqshlEmitter<Vec, Vec, Vec> for Assembler<'_>

fn sqshl(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl SqshluEmitter<Vec, Vec, Imm> for Assembler<'_>

fn sqshlu(&mut self, op0: Vec, op1: Vec, op2: Imm)

impl Sqshrn2Emitter<Vec, Vec, Imm> for Assembler<'_>

fn sqshrn2(&mut self, op0: Vec, op1: Vec, op2: Imm)

impl SqshrnEmitter<Vec, Vec, Imm> for Assembler<'_>

fn sqshrn(&mut self, op0: Vec, op1: Vec, op2: Imm)

impl Sqshrun2Emitter<Vec, Vec, Imm> for Assembler<'_>

fn sqshrun2(&mut self, op0: Vec, op1: Vec, op2: Imm)

impl SqshrunEmitter<Vec, Vec, Imm> for Assembler<'_>

fn sqshrun(&mut self, op0: Vec, op1: Vec, op2: Imm)

impl SqsubEmitter<Vec, Vec, Vec> for Assembler<'_>

fn sqsub(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl Sqxtn2Emitter<Vec, Vec> for Assembler<'_>

fn sqxtn2(&mut self, op0: Vec, op1: Vec)

impl SqxtnEmitter<Vec, Vec> for Assembler<'_>

fn sqxtn(&mut self, op0: Vec, op1: Vec)

impl Sqxtun2Emitter<Vec, Vec> for Assembler<'_>

fn sqxtun2(&mut self, op0: Vec, op1: Vec)

impl SqxtunEmitter<Vec, Vec> for Assembler<'_>

fn sqxtun(&mut self, op0: Vec, op1: Vec)

impl SrhaddEmitter<Vec, Vec, Vec> for Assembler<'_>

fn srhadd(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl SriEmitter<Vec, Vec, Imm> for Assembler<'_>

fn sri(&mut self, op0: Vec, op1: Vec, op2: Imm)

impl SrshlEmitter<Vec, Vec, Vec> for Assembler<'_>

fn srshl(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl SrshrEmitter<Vec, Vec, Imm> for Assembler<'_>

fn srshr(&mut self, op0: Vec, op1: Vec, op2: Imm)

impl SrsraEmitter<Vec, Vec, Imm> for Assembler<'_>

fn srsra(&mut self, op0: Vec, op1: Vec, op2: Imm)

impl SsbbEmitter for Assembler<'_>

fn ssbb(&mut self)

impl SshlEmitter<Vec, Vec, Vec> for Assembler<'_>

fn sshl(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl Sshll2Emitter<Vec, Vec, Imm> for Assembler<'_>

fn sshll2(&mut self, op0: Vec, op1: Vec, op2: Imm)

impl SshllEmitter<Vec, Vec, Imm> for Assembler<'_>

fn sshll(&mut self, op0: Vec, op1: Vec, op2: Imm)

impl SshrEmitter<Vec, Vec, Imm> for Assembler<'_>

fn sshr(&mut self, op0: Vec, op1: Vec, op2: Imm)

impl SsraEmitter<Vec, Vec, Imm> for Assembler<'_>

fn ssra(&mut self, op0: Vec, op1: Vec, op2: Imm)

impl Ssubl2Emitter<Vec, Vec, Vec> for Assembler<'_>

fn ssubl2(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl SsublEmitter<Vec, Vec, Vec> for Assembler<'_>

fn ssubl(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl Ssubw2Emitter<Vec, Vec, Vec> for Assembler<'_>

fn ssubw2(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl SsubwEmitter<Vec, Vec, Vec> for Assembler<'_>

fn ssubw(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl St13Emitter<Vec, Vec, Mem> for Assembler<'_>

fn st1_3(&mut self, op0: Vec, op1: Vec, op2: Mem)

impl St14Emitter<Vec, Vec, Vec, Mem> for Assembler<'_>

fn st1_4(&mut self, op0: Vec, op1: Vec, op2: Vec, op3: Mem)

impl St15Emitter<Vec, Vec, Vec, Vec, Mem> for Assembler<'_>

fn st1_5(&mut self, op0: Vec, op1: Vec, op2: Vec, op3: Vec, op4: Mem)

impl St1Emitter<Vec, Mem> for Assembler<'_>

fn st1(&mut self, op0: Vec, op1: Mem)

impl St2Emitter<Vec, Vec, Mem> for Assembler<'_>

fn st2(&mut self, op0: Vec, op1: Vec, op2: Mem)

impl St2gEmitter<Gp, Mem> for Assembler<'_>

fn st2g(&mut self, op0: Gp, op1: Mem)

impl St3Emitter<Vec, Vec, Vec, Mem> for Assembler<'_>

fn st3(&mut self, op0: Vec, op1: Vec, op2: Vec, op3: Mem)

impl St4Emitter<Vec, Vec, Vec, Vec, Mem> for Assembler<'_>

fn st4(&mut self, op0: Vec, op1: Vec, op2: Vec, op3: Vec, op4: Mem)

impl StaddEmitter<Gp, Mem> for Assembler<'_>

fn stadd(&mut self, op0: Gp, op1: Mem)

impl StaddbEmitter<Gp, Mem> for Assembler<'_>

fn staddb(&mut self, op0: Gp, op1: Mem)

impl StaddhEmitter<Gp, Mem> for Assembler<'_>

fn staddh(&mut self, op0: Gp, op1: Mem)

impl StaddlEmitter<Gp, Mem> for Assembler<'_>

fn staddl(&mut self, op0: Gp, op1: Mem)

impl StaddlbEmitter<Gp, Mem> for Assembler<'_>

fn staddlb(&mut self, op0: Gp, op1: Mem)

impl StaddlhEmitter<Gp, Mem> for Assembler<'_>

fn staddlh(&mut self, op0: Gp, op1: Mem)

impl StclrEmitter<Gp, Mem> for Assembler<'_>

fn stclr(&mut self, op0: Gp, op1: Mem)

impl StclrbEmitter<Gp, Mem> for Assembler<'_>

fn stclrb(&mut self, op0: Gp, op1: Mem)

impl StclrhEmitter<Gp, Mem> for Assembler<'_>

fn stclrh(&mut self, op0: Gp, op1: Mem)

impl StclrlEmitter<Gp, Mem> for Assembler<'_>

fn stclrl(&mut self, op0: Gp, op1: Mem)

impl StclrlbEmitter<Gp, Mem> for Assembler<'_>

fn stclrlb(&mut self, op0: Gp, op1: Mem)

impl StclrlhEmitter<Gp, Mem> for Assembler<'_>

fn stclrlh(&mut self, op0: Gp, op1: Mem)

impl SteorEmitter<Gp, Mem> for Assembler<'_>

fn steor(&mut self, op0: Gp, op1: Mem)

impl SteorbEmitter<Gp, Mem> for Assembler<'_>

fn steorb(&mut self, op0: Gp, op1: Mem)

impl SteorhEmitter<Gp, Mem> for Assembler<'_>

fn steorh(&mut self, op0: Gp, op1: Mem)

impl SteorlEmitter<Gp, Mem> for Assembler<'_>

fn steorl(&mut self, op0: Gp, op1: Mem)

impl SteorlbEmitter<Gp, Mem> for Assembler<'_>

fn steorlb(&mut self, op0: Gp, op1: Mem)

impl SteorlhEmitter<Gp, Mem> for Assembler<'_>

fn steorlh(&mut self, op0: Gp, op1: Mem)

impl StgEmitter<Gp, Mem> for Assembler<'_>

fn stg(&mut self, op0: Gp, op1: Mem)

impl StgmEmitter<Gp, Mem> for Assembler<'_>

fn stgm(&mut self, op0: Gp, op1: Mem)

impl StgpEmitter<Gp, Gp, Mem> for Assembler<'_>

fn stgp(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl StllrEmitter<Gp, Mem> for Assembler<'_>

fn stllr(&mut self, op0: Gp, op1: Mem)

impl StllrbEmitter<Gp, Mem> for Assembler<'_>

fn stllrb(&mut self, op0: Gp, op1: Mem)

impl StllrhEmitter<Gp, Mem> for Assembler<'_>

fn stllrh(&mut self, op0: Gp, op1: Mem)

impl StlrEmitter<Gp, Mem> for Assembler<'_>

fn stlr(&mut self, op0: Gp, op1: Mem)

impl StlrbEmitter<Gp, Mem> for Assembler<'_>

fn stlrb(&mut self, op0: Gp, op1: Mem)

impl StlrhEmitter<Gp, Mem> for Assembler<'_>

fn stlrh(&mut self, op0: Gp, op1: Mem)

impl StlxpEmitter<Gp, Gp, Gp, Mem> for Assembler<'_>

fn stlxp(&mut self, op0: Gp, op1: Gp, op2: Gp, op3: Mem)

impl StlxrEmitter<Gp, Gp, Mem> for Assembler<'_>

fn stlxr(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl StlxrbEmitter<Gp, Gp, Mem> for Assembler<'_>

fn stlxrb(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl StlxrhEmitter<Gp, Gp, Mem> for Assembler<'_>

fn stlxrh(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl StnpEmitter<Gp, Gp, Mem> for Assembler<'_>

fn stnp(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl StnpEmitter<Vec, Vec, Mem> for Assembler<'_>

fn stnp(&mut self, op0: Vec, op1: Vec, op2: Mem)

impl StpEmitter<Gp, Gp, Mem> for Assembler<'_>

fn stp(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl StpEmitter<Vec, Vec, Mem> for Assembler<'_>

fn stp(&mut self, op0: Vec, op1: Vec, op2: Mem)

impl StrEmitter<Gp, Mem> for Assembler<'_>

fn str(&mut self, op0: Gp, op1: Mem)

impl StrEmitter<Vec, Mem> for Assembler<'_>

fn str(&mut self, op0: Vec, op1: Mem)

impl StrbEmitter<Gp, Mem> for Assembler<'_>

fn strb(&mut self, op0: Gp, op1: Mem)

impl StrhEmitter<Gp, Mem> for Assembler<'_>

fn strh(&mut self, op0: Gp, op1: Mem)

impl StsetEmitter<Gp, Mem> for Assembler<'_>

fn stset(&mut self, op0: Gp, op1: Mem)

impl StsetbEmitter<Gp, Mem> for Assembler<'_>

fn stsetb(&mut self, op0: Gp, op1: Mem)

impl StsethEmitter<Gp, Mem> for Assembler<'_>

fn stseth(&mut self, op0: Gp, op1: Mem)

impl StsetlEmitter<Gp, Mem> for Assembler<'_>

fn stsetl(&mut self, op0: Gp, op1: Mem)

impl StsetlbEmitter<Gp, Mem> for Assembler<'_>

fn stsetlb(&mut self, op0: Gp, op1: Mem)

impl StsetlhEmitter<Gp, Mem> for Assembler<'_>

fn stsetlh(&mut self, op0: Gp, op1: Mem)

impl StsmaxEmitter<Gp, Mem> for Assembler<'_>

fn stsmax(&mut self, op0: Gp, op1: Mem)

impl StsmaxbEmitter<Gp, Mem> for Assembler<'_>

fn stsmaxb(&mut self, op0: Gp, op1: Mem)

impl StsmaxhEmitter<Gp, Mem> for Assembler<'_>

fn stsmaxh(&mut self, op0: Gp, op1: Mem)

impl StsmaxlEmitter<Gp, Mem> for Assembler<'_>

fn stsmaxl(&mut self, op0: Gp, op1: Mem)

impl StsmaxlbEmitter<Gp, Mem> for Assembler<'_>

fn stsmaxlb(&mut self, op0: Gp, op1: Mem)

impl StsmaxlhEmitter<Gp, Mem> for Assembler<'_>

fn stsmaxlh(&mut self, op0: Gp, op1: Mem)

impl StsminEmitter<Gp, Mem> for Assembler<'_>

fn stsmin(&mut self, op0: Gp, op1: Mem)

impl StsminbEmitter<Gp, Mem> for Assembler<'_>

fn stsminb(&mut self, op0: Gp, op1: Mem)

impl StsminhEmitter<Gp, Mem> for Assembler<'_>

fn stsminh(&mut self, op0: Gp, op1: Mem)

impl StsminlEmitter<Gp, Mem> for Assembler<'_>

fn stsminl(&mut self, op0: Gp, op1: Mem)

impl StsminlbEmitter<Gp, Mem> for Assembler<'_>

fn stsminlb(&mut self, op0: Gp, op1: Mem)

impl StsminlhEmitter<Gp, Mem> for Assembler<'_>

fn stsminlh(&mut self, op0: Gp, op1: Mem)

impl SttrEmitter<Gp, Mem> for Assembler<'_>

fn sttr(&mut self, op0: Gp, op1: Mem)

impl SttrbEmitter<Gp, Mem> for Assembler<'_>

fn sttrb(&mut self, op0: Gp, op1: Mem)

impl SttrhEmitter<Gp, Mem> for Assembler<'_>

fn sttrh(&mut self, op0: Gp, op1: Mem)

impl StumaxEmitter<Gp, Mem> for Assembler<'_>

fn stumax(&mut self, op0: Gp, op1: Mem)

impl StumaxbEmitter<Gp, Mem> for Assembler<'_>

fn stumaxb(&mut self, op0: Gp, op1: Mem)

impl StumaxhEmitter<Gp, Mem> for Assembler<'_>

fn stumaxh(&mut self, op0: Gp, op1: Mem)

impl StumaxlEmitter<Gp, Mem> for Assembler<'_>

fn stumaxl(&mut self, op0: Gp, op1: Mem)

impl StumaxlbEmitter<Gp, Mem> for Assembler<'_>

fn stumaxlb(&mut self, op0: Gp, op1: Mem)

impl StumaxlhEmitter<Gp, Mem> for Assembler<'_>

fn stumaxlh(&mut self, op0: Gp, op1: Mem)

impl StuminEmitter<Gp, Mem> for Assembler<'_>

fn stumin(&mut self, op0: Gp, op1: Mem)

impl StuminbEmitter<Gp, Mem> for Assembler<'_>

fn stuminb(&mut self, op0: Gp, op1: Mem)

impl StuminhEmitter<Gp, Mem> for Assembler<'_>

fn stuminh(&mut self, op0: Gp, op1: Mem)

impl StuminlEmitter<Gp, Mem> for Assembler<'_>

fn stuminl(&mut self, op0: Gp, op1: Mem)

impl StuminlbEmitter<Gp, Mem> for Assembler<'_>

fn stuminlb(&mut self, op0: Gp, op1: Mem)

impl StuminlhEmitter<Gp, Mem> for Assembler<'_>

fn stuminlh(&mut self, op0: Gp, op1: Mem)

impl SturEmitter<Gp, Mem> for Assembler<'_>

fn stur(&mut self, op0: Gp, op1: Mem)

impl SturEmitter<Vec, Mem> for Assembler<'_>

fn stur(&mut self, op0: Vec, op1: Mem)

impl SturbEmitter<Gp, Mem> for Assembler<'_>

fn sturb(&mut self, op0: Gp, op1: Mem)

impl SturhEmitter<Gp, Mem> for Assembler<'_>

fn sturh(&mut self, op0: Gp, op1: Mem)

impl StxpEmitter<Gp, Gp, Gp, Mem> for Assembler<'_>

fn stxp(&mut self, op0: Gp, op1: Gp, op2: Gp, op3: Mem)

impl StxrEmitter<Gp, Gp, Mem> for Assembler<'_>

fn stxr(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl StxrbEmitter<Gp, Gp, Mem> for Assembler<'_>

fn stxrb(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl StxrhEmitter<Gp, Gp, Mem> for Assembler<'_>

fn stxrh(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl Stz2gEmitter<Gp, Mem> for Assembler<'_>

fn stz2g(&mut self, op0: Gp, op1: Mem)

impl StzgEmitter<Gp, Mem> for Assembler<'_>

fn stzg(&mut self, op0: Gp, op1: Mem)

impl StzgmEmitter<Gp, Mem> for Assembler<'_>

fn stzgm(&mut self, op0: Gp, op1: Mem)

impl Sub4Emitter<Gp, Gp, Gp, Imm> for Assembler<'_>

fn sub_4(&mut self, op0: Gp, op1: Gp, op2: Gp, op3: Imm)

impl Sub4Emitter<Gp, Gp, Imm, Imm> for Assembler<'_>

fn sub_4(&mut self, op0: Gp, op1: Gp, op2: Imm, op3: Imm)

impl SubEmitter<Gp, Gp, Gp> for Assembler<'_>

fn sub(&mut self, op0: Gp, op1: Gp, op2: Gp)

impl SubEmitter<Gp, Gp, Imm> for Assembler<'_>

fn sub(&mut self, op0: Gp, op1: Gp, op2: Imm)

impl SubEmitter<Vec, Vec, Vec> for Assembler<'_>

fn sub(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl SubgEmitter<Gp, Gp, Imm, Imm> for Assembler<'_>

fn subg(&mut self, op0: Gp, op1: Gp, op2: Imm, op3: Imm)

impl Subhn2Emitter<Vec, Vec, Vec> for Assembler<'_>

fn subhn2(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl SubhnEmitter<Vec, Vec, Vec> for Assembler<'_>

fn subhn(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl SubpEmitter<Gp, Gp, Gp> for Assembler<'_>

fn subp(&mut self, op0: Gp, op1: Gp, op2: Gp)

impl SubpsEmitter<Gp, Gp, Gp> for Assembler<'_>

fn subps(&mut self, op0: Gp, op1: Gp, op2: Gp)

impl Subs4Emitter<Gp, Gp, Gp, Imm> for Assembler<'_>

fn subs_4(&mut self, op0: Gp, op1: Gp, op2: Gp, op3: Imm)

impl Subs4Emitter<Gp, Gp, Imm, Imm> for Assembler<'_>

fn subs_4(&mut self, op0: Gp, op1: Gp, op2: Imm, op3: Imm)

impl SubsEmitter<Gp, Gp, Gp> for Assembler<'_>

fn subs(&mut self, op0: Gp, op1: Gp, op2: Gp)

impl SubsEmitter<Gp, Gp, Imm> for Assembler<'_>

fn subs(&mut self, op0: Gp, op1: Gp, op2: Imm)

impl SudotEmitter<Vec, Vec, Vec> for Assembler<'_>

fn sudot(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl SuqaddEmitter<Vec, Vec> for Assembler<'_>

fn suqadd(&mut self, op0: Vec, op1: Vec)

impl SvcEmitter<Imm> for Assembler<'_>

fn svc(&mut self, op0: Imm)

impl SwpEmitter<Gp, Gp, Mem> for Assembler<'_>

fn swp(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl SwpaEmitter<Gp, Gp, Mem> for Assembler<'_>

fn swpa(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl SwpabEmitter<Gp, Gp, Mem> for Assembler<'_>

fn swpab(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl SwpahEmitter<Gp, Gp, Mem> for Assembler<'_>

fn swpah(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl SwpalEmitter<Gp, Gp, Mem> for Assembler<'_>

fn swpal(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl SwpalbEmitter<Gp, Gp, Mem> for Assembler<'_>

fn swpalb(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl SwpalhEmitter<Gp, Gp, Mem> for Assembler<'_>

fn swpalh(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl SwpbEmitter<Gp, Gp, Mem> for Assembler<'_>

fn swpb(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl SwphEmitter<Gp, Gp, Mem> for Assembler<'_>

fn swph(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl SwplEmitter<Gp, Gp, Mem> for Assembler<'_>

fn swpl(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl SwplbEmitter<Gp, Gp, Mem> for Assembler<'_>

fn swplb(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl SwplhEmitter<Gp, Gp, Mem> for Assembler<'_>

fn swplh(&mut self, op0: Gp, op1: Gp, op2: Mem)

impl SxtbEmitter<Gp, Gp> for Assembler<'_>

fn sxtb(&mut self, op0: Gp, op1: Gp)

impl SxthEmitter<Gp, Gp> for Assembler<'_>

fn sxth(&mut self, op0: Gp, op1: Gp)

impl Sxtl2Emitter<Vec, Vec> for Assembler<'_>

fn sxtl2(&mut self, op0: Vec, op1: Vec)

impl SxtlEmitter<Vec, Vec> for Assembler<'_>

fn sxtl(&mut self, op0: Vec, op1: Vec)

impl SxtwEmitter<Gp, Gp> for Assembler<'_>

fn sxtw(&mut self, op0: Gp, op1: Gp)

impl Sys5Emitter<Imm, Imm, Imm, Imm, Gp> for Assembler<'_>

fn sys_5(&mut self, op0: Imm, op1: Imm, op2: Imm, op3: Imm, op4: Gp)

impl SysEmitter<Imm, Imm, Imm, Imm> for Assembler<'_>

fn sys(&mut self, op0: Imm, op1: Imm, op2: Imm, op3: Imm)

impl Tbl4Emitter<Vec, Vec, Vec, Vec> for Assembler<'_>

fn tbl_4(&mut self, op0: Vec, op1: Vec, op2: Vec, op3: Vec)

impl Tbl5Emitter<Vec, Vec, Vec, Vec, Vec> for Assembler<'_>

fn tbl_5(&mut self, op0: Vec, op1: Vec, op2: Vec, op3: Vec, op4: Vec)

impl Tbl6Emitter<Vec, Vec, Vec, Vec, Vec, Vec> for Assembler<'_>

fn tbl_6(&mut self, op0: Vec, op1: Vec, op2: Vec, op3: Vec, op4: Vec, op5: Vec)

impl TblEmitter<Vec, Vec, Vec> for Assembler<'_>

fn tbl(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl TbnzEmitter<Gp, Imm, Imm> for Assembler<'_>

fn tbnz(&mut self, op0: Gp, op1: Imm, op2: Imm)

impl TbnzEmitter<Gp, Imm, Label> for Assembler<'_>

fn tbnz(&mut self, op0: Gp, op1: Imm, op2: Label)

impl TbnzEmitter<Gp, Imm, Sym> for Assembler<'_>

fn tbnz(&mut self, op0: Gp, op1: Imm, op2: Sym)

impl Tbx4Emitter<Vec, Vec, Vec, Vec> for Assembler<'_>

fn tbx_4(&mut self, op0: Vec, op1: Vec, op2: Vec, op3: Vec)

impl Tbx5Emitter<Vec, Vec, Vec, Vec, Vec> for Assembler<'_>

fn tbx_5(&mut self, op0: Vec, op1: Vec, op2: Vec, op3: Vec, op4: Vec)

impl Tbx6Emitter<Vec, Vec, Vec, Vec, Vec, Vec> for Assembler<'_>

fn tbx_6(&mut self, op0: Vec, op1: Vec, op2: Vec, op3: Vec, op4: Vec, op5: Vec)

impl TbxEmitter<Vec, Vec, Vec> for Assembler<'_>

fn tbx(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl TbzEmitter<Gp, Imm, Imm> for Assembler<'_>

fn tbz(&mut self, op0: Gp, op1: Imm, op2: Imm)

impl TbzEmitter<Gp, Imm, Label> for Assembler<'_>

fn tbz(&mut self, op0: Gp, op1: Imm, op2: Label)

impl TbzEmitter<Gp, Imm, Sym> for Assembler<'_>

fn tbz(&mut self, op0: Gp, op1: Imm, op2: Sym)

impl TlbiEmitter<Imm, Gp> for Assembler<'_>

fn tlbi(&mut self, op0: Imm, op1: Gp)

impl Trn1Emitter<Vec, Vec, Vec> for Assembler<'_>

fn trn1(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl Trn2Emitter<Vec, Vec, Vec> for Assembler<'_>

fn trn2(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl Tst3Emitter<Gp, Gp, Imm> for Assembler<'_>

fn tst_3(&mut self, op0: Gp, op1: Gp, op2: Imm)

impl TstEmitter<Gp, Gp> for Assembler<'_>

fn tst(&mut self, op0: Gp, op1: Gp)

impl TstEmitter<Gp, Imm> for Assembler<'_>

fn tst(&mut self, op0: Gp, op1: Imm)

impl UabaEmitter<Vec, Vec, Vec> for Assembler<'_>

fn uaba(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl Uabal2Emitter<Vec, Vec, Vec> for Assembler<'_>

fn uabal2(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl UabalEmitter<Vec, Vec, Vec> for Assembler<'_>

fn uabal(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl UabdEmitter<Vec, Vec, Vec> for Assembler<'_>

fn uabd(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl Uabdl2Emitter<Vec, Vec, Vec> for Assembler<'_>

fn uabdl2(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl UabdlEmitter<Vec, Vec, Vec> for Assembler<'_>

fn uabdl(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl UadalpEmitter<Vec, Vec> for Assembler<'_>

fn uadalp(&mut self, op0: Vec, op1: Vec)

impl Uaddl2Emitter<Vec, Vec, Vec> for Assembler<'_>

fn uaddl2(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl UaddlEmitter<Vec, Vec, Vec> for Assembler<'_>

fn uaddl(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl UaddlpEmitter<Vec, Vec> for Assembler<'_>

fn uaddlp(&mut self, op0: Vec, op1: Vec)

impl UaddlvEmitter<Vec, Vec> for Assembler<'_>

fn uaddlv(&mut self, op0: Vec, op1: Vec)

impl Uaddw2Emitter<Vec, Vec, Vec> for Assembler<'_>

fn uaddw2(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl UaddwEmitter<Vec, Vec, Vec> for Assembler<'_>

fn uaddw(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl UbfizEmitter<Gp, Gp, Imm, Imm> for Assembler<'_>

fn ubfiz(&mut self, op0: Gp, op1: Gp, op2: Imm, op3: Imm)

impl UbfmEmitter<Gp, Gp, Imm, Imm> for Assembler<'_>

fn ubfm(&mut self, op0: Gp, op1: Gp, op2: Imm, op3: Imm)

impl UbfxEmitter<Gp, Gp, Imm, Imm> for Assembler<'_>

fn ubfx(&mut self, op0: Gp, op1: Gp, op2: Imm, op3: Imm)

impl Ucvtf3Emitter<Vec, Gp, Imm> for Assembler<'_>

fn ucvtf_3(&mut self, op0: Vec, op1: Gp, op2: Imm)

impl Ucvtf3Emitter<Vec, Vec, Imm> for Assembler<'_>

fn ucvtf_3(&mut self, op0: Vec, op1: Vec, op2: Imm)

impl UcvtfEmitter<Vec, Gp> for Assembler<'_>

fn ucvtf(&mut self, op0: Vec, op1: Gp)

impl UcvtfEmitter<Vec, Vec> for Assembler<'_>

fn ucvtf(&mut self, op0: Vec, op1: Vec)

impl UdfEmitter<Imm> for Assembler<'_>

fn udf(&mut self, op0: Imm)

impl UdivEmitter<Gp, Gp, Gp> for Assembler<'_>

fn udiv(&mut self, op0: Gp, op1: Gp, op2: Gp)

impl UdotEmitter<Vec, Vec, Vec> for Assembler<'_>

fn udot(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl UhaddEmitter<Vec, Vec, Vec> for Assembler<'_>

fn uhadd(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl UhsubEmitter<Vec, Vec, Vec> for Assembler<'_>

fn uhsub(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl UmaddlEmitter<Gp, Gp, Gp, Gp> for Assembler<'_>

fn umaddl(&mut self, op0: Gp, op1: Gp, op2: Gp, op3: Gp)

impl UmaxEmitter<Gp, Gp, Gp> for Assembler<'_>

fn umax(&mut self, op0: Gp, op1: Gp, op2: Gp)

impl UmaxEmitter<Gp, Gp, Imm> for Assembler<'_>

fn umax(&mut self, op0: Gp, op1: Gp, op2: Imm)

impl UmaxEmitter<Vec, Vec, Vec> for Assembler<'_>

fn umax(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl UmaxpEmitter<Vec, Vec, Vec> for Assembler<'_>

fn umaxp(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl UmaxvEmitter<Vec, Vec> for Assembler<'_>

fn umaxv(&mut self, op0: Vec, op1: Vec)

impl UminEmitter<Gp, Gp, Gp> for Assembler<'_>

fn umin(&mut self, op0: Gp, op1: Gp, op2: Gp)

impl UminEmitter<Gp, Gp, Imm> for Assembler<'_>

fn umin(&mut self, op0: Gp, op1: Gp, op2: Imm)

impl UminEmitter<Vec, Vec, Vec> for Assembler<'_>

fn umin(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl UminpEmitter<Vec, Vec, Vec> for Assembler<'_>

fn uminp(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl UminvEmitter<Vec, Vec> for Assembler<'_>

fn uminv(&mut self, op0: Vec, op1: Vec)

impl Umlal2Emitter<Vec, Vec, Vec> for Assembler<'_>

fn umlal2(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl UmlalEmitter<Vec, Vec, Vec> for Assembler<'_>

fn umlal(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl Umlsl2Emitter<Vec, Vec, Vec> for Assembler<'_>

fn umlsl2(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl UmlslEmitter<Vec, Vec, Vec> for Assembler<'_>

fn umlsl(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl UmmlaEmitter<Vec, Vec, Vec> for Assembler<'_>

fn ummla(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl UmneglEmitter<Gp, Gp, Gp> for Assembler<'_>

fn umnegl(&mut self, op0: Gp, op1: Gp, op2: Gp)

impl UmovEmitter<Gp, Vec> for Assembler<'_>

fn umov(&mut self, op0: Gp, op1: Vec)

impl UmsublEmitter<Gp, Gp, Gp, Gp> for Assembler<'_>

fn umsubl(&mut self, op0: Gp, op1: Gp, op2: Gp, op3: Gp)

impl UmulhEmitter<Gp, Gp, Gp> for Assembler<'_>

fn umulh(&mut self, op0: Gp, op1: Gp, op2: Gp)

impl Umull2Emitter<Vec, Vec, Vec> for Assembler<'_>

fn umull2(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl UmullEmitter<Gp, Gp, Gp> for Assembler<'_>

fn umull(&mut self, op0: Gp, op1: Gp, op2: Gp)

impl UmullEmitter<Vec, Vec, Vec> for Assembler<'_>

fn umull(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl UqaddEmitter<Vec, Vec, Vec> for Assembler<'_>

fn uqadd(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl UqrshlEmitter<Vec, Vec, Imm> for Assembler<'_>

fn uqrshl(&mut self, op0: Vec, op1: Vec, op2: Imm)

impl UqrshlEmitter<Vec, Vec, Vec> for Assembler<'_>

fn uqrshl(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl Uqrshrn2Emitter<Vec, Vec, Imm> for Assembler<'_>

fn uqrshrn2(&mut self, op0: Vec, op1: Vec, op2: Imm)

impl UqrshrnEmitter<Vec, Vec, Imm> for Assembler<'_>

fn uqrshrn(&mut self, op0: Vec, op1: Vec, op2: Imm)

impl UqshlEmitter<Vec, Vec, Imm> for Assembler<'_>

fn uqshl(&mut self, op0: Vec, op1: Vec, op2: Imm)

impl UqshlEmitter<Vec, Vec, Vec> for Assembler<'_>

fn uqshl(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl Uqshrn2Emitter<Vec, Vec, Imm> for Assembler<'_>

fn uqshrn2(&mut self, op0: Vec, op1: Vec, op2: Imm)

impl UqshrnEmitter<Vec, Vec, Imm> for Assembler<'_>

fn uqshrn(&mut self, op0: Vec, op1: Vec, op2: Imm)

impl UqsubEmitter<Vec, Vec, Vec> for Assembler<'_>

fn uqsub(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl Uqxtn2Emitter<Vec, Vec> for Assembler<'_>

fn uqxtn2(&mut self, op0: Vec, op1: Vec)

impl UqxtnEmitter<Vec, Vec> for Assembler<'_>

fn uqxtn(&mut self, op0: Vec, op1: Vec)

impl UrecpeEmitter<Vec, Vec> for Assembler<'_>

fn urecpe(&mut self, op0: Vec, op1: Vec)

impl UrhaddEmitter<Vec, Vec, Vec> for Assembler<'_>

fn urhadd(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl UrshlEmitter<Vec, Vec, Vec> for Assembler<'_>

fn urshl(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl UrshrEmitter<Vec, Vec, Imm> for Assembler<'_>

fn urshr(&mut self, op0: Vec, op1: Vec, op2: Imm)

impl UrsqrteEmitter<Vec, Vec> for Assembler<'_>

fn ursqrte(&mut self, op0: Vec, op1: Vec)

impl UrsraEmitter<Vec, Vec, Imm> for Assembler<'_>

fn ursra(&mut self, op0: Vec, op1: Vec, op2: Imm)

impl UsdotEmitter<Vec, Vec, Vec> for Assembler<'_>

fn usdot(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl UshlEmitter<Vec, Vec, Vec> for Assembler<'_>

fn ushl(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl Ushll2Emitter<Vec, Vec, Imm> for Assembler<'_>

fn ushll2(&mut self, op0: Vec, op1: Vec, op2: Imm)

impl UshllEmitter<Vec, Vec, Imm> for Assembler<'_>

fn ushll(&mut self, op0: Vec, op1: Vec, op2: Imm)

impl UshrEmitter<Vec, Vec, Imm> for Assembler<'_>

fn ushr(&mut self, op0: Vec, op1: Vec, op2: Imm)

impl UsmmlaEmitter<Vec, Vec, Vec> for Assembler<'_>

fn usmmla(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl UsqaddEmitter<Vec, Vec> for Assembler<'_>

fn usqadd(&mut self, op0: Vec, op1: Vec)

impl UsraEmitter<Vec, Vec, Imm> for Assembler<'_>

fn usra(&mut self, op0: Vec, op1: Vec, op2: Imm)

impl Usubl2Emitter<Vec, Vec, Vec> for Assembler<'_>

fn usubl2(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl UsublEmitter<Vec, Vec, Vec> for Assembler<'_>

fn usubl(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl Usubw2Emitter<Vec, Vec, Vec> for Assembler<'_>

fn usubw2(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl UsubwEmitter<Vec, Vec, Vec> for Assembler<'_>

fn usubw(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl UxtbEmitter<Gp, Gp> for Assembler<'_>

fn uxtb(&mut self, op0: Gp, op1: Gp)

impl UxthEmitter<Gp, Gp> for Assembler<'_>

fn uxth(&mut self, op0: Gp, op1: Gp)

impl Uxtl2Emitter<Vec, Vec> for Assembler<'_>

fn uxtl2(&mut self, op0: Vec, op1: Vec)

impl UxtlEmitter<Vec, Vec> for Assembler<'_>

fn uxtl(&mut self, op0: Vec, op1: Vec)

impl Uzp1Emitter<Vec, Vec, Vec> for Assembler<'_>

fn uzp1(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl Uzp2Emitter<Vec, Vec, Vec> for Assembler<'_>

fn uzp2(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl WfeEmitter for Assembler<'_>

fn wfe(&mut self)

impl WfiEmitter for Assembler<'_>

fn wfi(&mut self)

impl XaflagEmitter for Assembler<'_>

fn xaflag(&mut self)

impl XarEmitter<Vec, Vec, Vec, Imm> for Assembler<'_>

fn xar(&mut self, op0: Vec, op1: Vec, op2: Vec, op3: Imm)

impl XpacdEmitter<Gp> for Assembler<'_>

fn xpacd(&mut self, op0: Gp)

impl XpaciEmitter<Gp> for Assembler<'_>

fn xpaci(&mut self, op0: Gp)

impl XpaclriEmitter for Assembler<'_>

fn xpaclri(&mut self)

impl Xtn2Emitter<Vec, Vec> for Assembler<'_>

fn xtn2(&mut self, op0: Vec, op1: Vec)

impl XtnEmitter<Vec, Vec> for Assembler<'_>

fn xtn(&mut self, op0: Vec, op1: Vec)

impl YieldEmitter for Assembler<'_>

fn yield(&mut self)

impl Zip1Emitter<Vec, Vec, Vec> for Assembler<'_>

fn zip1(&mut self, op0: Vec, op1: Vec, op2: Vec)

impl Zip2Emitter<Vec, Vec, Vec> for Assembler<'_>

fn zip2(&mut self, op0: Vec, op1: Vec, op2: Vec)

Auto Trait Implementations§

impl<'a> Freeze for Assembler<'a>

impl<'a> RefUnwindSafe for Assembler<'a>

impl<'a> Send for Assembler<'a>

impl<'a> Sync for Assembler<'a>

impl<'a> Unpin for Assembler<'a>

impl<'a> UnsafeUnpin for Assembler<'a>

impl<'a> !UnwindSafe for Assembler<'a>

Blanket Implementations§

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

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

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

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

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

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

Mutably borrows from an owned value. Read more

impl<T> From<T> for T

fn from(t: T) -> T

Returns the argument unchanged.

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

fn into(self) -> U

Calls U::from(self).

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

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

type Error = Infallible

The type returned in the event of a conversion error.

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

Performs the conversion.

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

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

The type returned in the event of a conversion error.

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

Performs the conversion.