Skip to main content

Zve64xInstruction

ab_riscv_primitives::instructions::v::zve64x

Enum Zve64xInstruction 

Source 
pub enum Zve64xInstruction<Reg> {

Show 226 variants    Vsetvli {
        rs1: Reg,
        rd: Reg,
        vtypei: u16,
        /* private fields */
    },
    Vsetivli {
        rd: Reg,
        uimm: u8,
        vtypei: u16,
        /* private fields */
    },
    Vsetvl {
        rs1: Reg,
        rs2: Reg,
        rd: Reg,
    },
    Vle {
        rs1: Reg,
        vd: VReg,
        vm: bool,
        eew: Eew,
        /* private fields */
    },
    Vleff {
        rs1: Reg,
        vd: VReg,
        vm: bool,
        eew: Eew,
        /* private fields */
    },
    Vlm {
        rs1: Reg,
        vd: VReg,
        /* private fields */
    },
    Vlse {
        rs1: Reg,
        rs2: Reg,
        vd: VReg,
        vm: bool,
        eew: Eew,
    },
    Vluxei {
        rs1: Reg,
        vd: VReg,
        vs2: VReg,
        vm: bool,
        eew: Eew,
        /* private fields */
    },
    Vloxei {
        rs1: Reg,
        vd: VReg,
        vs2: VReg,
        vm: bool,
        eew: Eew,
        /* private fields */
    },
    Vlr {
        rs1: Reg,
        vd: VReg,
        nreg: u8,
        eew: Eew,
        /* private fields */
    },
    Vlseg {
        rs1: Reg,
        vd: VReg,
        vm: bool,
        eew: Eew,
        nf: u8,
        /* private fields */
    },
    Vlsegff {
        rs1: Reg,
        vd: VReg,
        vm: bool,
        eew: Eew,
        nf: u8,
        /* private fields */
    },
    Vlsseg {
        rs1: Reg,
        rs2: Reg,
        vd: VReg,
        vm: bool,
        eew: Eew,
        nf: u8,
    },
    Vluxseg {
        rs1: Reg,
        vd: VReg,
        vs2: VReg,
        vm: bool,
        eew: Eew,
        nf: u8,
        /* private fields */
    },
    Vloxseg {
        rs1: Reg,
        vd: VReg,
        vs2: VReg,
        vm: bool,
        eew: Eew,
        nf: u8,
        /* private fields */
    },
    Vse {
        rs1: Reg,
        vs3: VReg,
        vm: bool,
        eew: Eew,
        /* private fields */
    },
    Vsm {
        rs1: Reg,
        vs3: VReg,
        /* private fields */
    },
    Vsse {
        rs1: Reg,
        rs2: Reg,
        vs3: VReg,
        vm: bool,
        eew: Eew,
    },
    Vsuxei {
        rs1: Reg,
        vs3: VReg,
        vs2: VReg,
        vm: bool,
        eew: Eew,
        /* private fields */
    },
    Vsoxei {
        rs1: Reg,
        vs3: VReg,
        vs2: VReg,
        vm: bool,
        eew: Eew,
        /* private fields */
    },
    Vsr {
        rs1: Reg,
        vs3: VReg,
        nreg: u8,
        /* private fields */
    },
    Vsseg {
        rs1: Reg,
        vs3: VReg,
        vm: bool,
        eew: Eew,
        nf: u8,
        /* private fields */
    },
    Vssseg {
        rs1: Reg,
        rs2: Reg,
        vs3: VReg,
        vm: bool,
        eew: Eew,
        nf: u8,
    },
    Vsuxseg {
        rs1: Reg,
        vs3: VReg,
        vs2: VReg,
        vm: bool,
        eew: Eew,
        nf: u8,
        /* private fields */
    },
    Vsoxseg {
        rs1: Reg,
        vs3: VReg,
        vs2: VReg,
        vm: bool,
        eew: Eew,
        nf: u8,
        /* private fields */
    },
    VaddVv {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        vm: bool,
        /* private fields */
    },
    VaddVx {
        rs1: Reg,
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VaddVi {
        vd: VReg,
        vs2: VReg,
        imm: i8,
        vm: bool,
        /* private fields */
    },
    VsubVv {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        vm: bool,
        /* private fields */
    },
    VsubVx {
        rs1: Reg,
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VrsubVx {
        rs1: Reg,
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VrsubVi {
        vd: VReg,
        vs2: VReg,
        imm: i8,
        vm: bool,
        /* private fields */
    },
    VandVv {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        vm: bool,
        /* private fields */
    },
    VandVx {
        rs1: Reg,
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VandVi {
        vd: VReg,
        vs2: VReg,
        imm: i8,
        vm: bool,
        /* private fields */
    },
    VorVv {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        vm: bool,
        /* private fields */
    },
    VorVx {
        rs1: Reg,
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VorVi {
        vd: VReg,
        vs2: VReg,
        imm: i8,
        vm: bool,
        /* private fields */
    },
    VxorVv {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        vm: bool,
        /* private fields */
    },
    VxorVx {
        rs1: Reg,
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VxorVi {
        vd: VReg,
        vs2: VReg,
        imm: i8,
        vm: bool,
        /* private fields */
    },
    VsllVv {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        vm: bool,
        /* private fields */
    },
    VsllVx {
        rs1: Reg,
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VsllVi {
        vd: VReg,
        vs2: VReg,
        uimm: u8,
        vm: bool,
        /* private fields */
    },
    VsrlVv {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        vm: bool,
        /* private fields */
    },
    VsrlVx {
        rs1: Reg,
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VsrlVi {
        vd: VReg,
        vs2: VReg,
        uimm: u8,
        vm: bool,
        /* private fields */
    },
    VsraVv {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        vm: bool,
        /* private fields */
    },
    VsraVx {
        rs1: Reg,
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VsraVi {
        vd: VReg,
        vs2: VReg,
        uimm: u8,
        vm: bool,
        /* private fields */
    },
    VminuVv {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        vm: bool,
        /* private fields */
    },
    VminuVx {
        rs1: Reg,
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VminVv {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        vm: bool,
        /* private fields */
    },
    VminVx {
        rs1: Reg,
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VmaxuVv {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        vm: bool,
        /* private fields */
    },
    VmaxuVx {
        rs1: Reg,
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VmaxVv {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        vm: bool,
        /* private fields */
    },
    VmaxVx {
        rs1: Reg,
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VmseqVv {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        vm: bool,
        /* private fields */
    },
    VmseqVx {
        rs1: Reg,
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VmseqVi {
        vd: VReg,
        vs2: VReg,
        imm: i8,
        vm: bool,
        /* private fields */
    },
    VmsneVv {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        vm: bool,
        /* private fields */
    },
    VmsneVx {
        rs1: Reg,
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VmsneVi {
        vd: VReg,
        vs2: VReg,
        imm: i8,
        vm: bool,
        /* private fields */
    },
    VmsltuVv {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        vm: bool,
        /* private fields */
    },
    VmsltuVx {
        rs1: Reg,
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VmsltVv {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        vm: bool,
        /* private fields */
    },
    VmsltVx {
        rs1: Reg,
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VmsleuVv {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        vm: bool,
        /* private fields */
    },
    VmsleuVx {
        rs1: Reg,
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VmsleuVi {
        vd: VReg,
        vs2: VReg,
        imm: i8,
        vm: bool,
        /* private fields */
    },
    VmsleVv {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        vm: bool,
        /* private fields */
    },
    VmsleVx {
        rs1: Reg,
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VmsleVi {
        vd: VReg,
        vs2: VReg,
        imm: i8,
        vm: bool,
        /* private fields */
    },
    VmsgtuVx {
        rs1: Reg,
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VmsgtuVi {
        vd: VReg,
        vs2: VReg,
        imm: i8,
        vm: bool,
        /* private fields */
    },
    VmsgtVx {
        rs1: Reg,
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VmsgtVi {
        vd: VReg,
        vs2: VReg,
        imm: i8,
        vm: bool,
        /* private fields */
    },
    VmulVv {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        vm: bool,
        /* private fields */
    },
    VmulVx {
        rs1: Reg,
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VmulhVv {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        vm: bool,
        /* private fields */
    },
    VmulhVx {
        rs1: Reg,
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VmulhuVv {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        vm: bool,
        /* private fields */
    },
    VmulhuVx {
        rs1: Reg,
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VmulhsuVv {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        vm: bool,
        /* private fields */
    },
    VmulhsuVx {
        rs1: Reg,
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VdivuVv {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        vm: bool,
        /* private fields */
    },
    VdivuVx {
        rs1: Reg,
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VdivVv {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        vm: bool,
        /* private fields */
    },
    VdivVx {
        rs1: Reg,
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VremuVv {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        vm: bool,
        /* private fields */
    },
    VremuVx {
        rs1: Reg,
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VremVv {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        vm: bool,
        /* private fields */
    },
    VremVx {
        rs1: Reg,
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VwmulVv {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        vm: bool,
        /* private fields */
    },
    VwmulVx {
        rs1: Reg,
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VwmuluVv {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        vm: bool,
        /* private fields */
    },
    VwmuluVx {
        rs1: Reg,
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VwmulsuVv {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        vm: bool,
        /* private fields */
    },
    VwmulsuVx {
        rs1: Reg,
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VmaccVv {
        vd: VReg,
        vs1: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VmaccVx {
        rs1: Reg,
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VnmsacVv {
        vd: VReg,
        vs1: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VnmsacVx {
        rs1: Reg,
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VmaddVv {
        vd: VReg,
        vs1: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VmaddVx {
        rs1: Reg,
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VnmsubVv {
        vd: VReg,
        vs1: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VnmsubVx {
        rs1: Reg,
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VwmaccuVv {
        vd: VReg,
        vs1: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VwmaccuVx {
        rs1: Reg,
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VwmaccVv {
        vd: VReg,
        vs1: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VwmaccVx {
        rs1: Reg,
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VwmaccsuVv {
        vd: VReg,
        vs1: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VwmaccsuVx {
        rs1: Reg,
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VwmaccusVx {
        rs1: Reg,
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VwadduVv {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        vm: bool,
        /* private fields */
    },
    VwadduVx {
        rs1: Reg,
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VwaddVv {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        vm: bool,
        /* private fields */
    },
    VwaddVx {
        rs1: Reg,
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VwsubuVv {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        vm: bool,
        /* private fields */
    },
    VwsubuVx {
        rs1: Reg,
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VwsubVv {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        vm: bool,
        /* private fields */
    },
    VwsubVx {
        rs1: Reg,
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VwadduWv {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        vm: bool,
        /* private fields */
    },
    VwadduWx {
        rs1: Reg,
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VwaddWv {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        vm: bool,
        /* private fields */
    },
    VwaddWx {
        rs1: Reg,
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VwsubuWv {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        vm: bool,
        /* private fields */
    },
    VwsubuWx {
        rs1: Reg,
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VwsubWv {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        vm: bool,
        /* private fields */
    },
    VwsubWx {
        rs1: Reg,
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VnsrlWv {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        vm: bool,
        /* private fields */
    },
    VnsrlWx {
        rs1: Reg,
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VnsrlWi {
        vd: VReg,
        vs2: VReg,
        uimm: u8,
        vm: bool,
        /* private fields */
    },
    VnsraWv {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        vm: bool,
        /* private fields */
    },
    VnsraWx {
        rs1: Reg,
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VnsraWi {
        vd: VReg,
        vs2: VReg,
        uimm: u8,
        vm: bool,
        /* private fields */
    },
    VzextVf2 {
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VzextVf4 {
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VzextVf8 {
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VsextVf2 {
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VsextVf4 {
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VsextVf8 {
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VsadduVv {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        vm: bool,
        /* private fields */
    },
    VsadduVx {
        rs1: Reg,
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VsadduVi {
        vd: VReg,
        vs2: VReg,
        imm: i8,
        vm: bool,
        /* private fields */
    },
    VsaddVv {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        vm: bool,
        /* private fields */
    },
    VsaddVx {
        rs1: Reg,
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VsaddVi {
        vd: VReg,
        vs2: VReg,
        imm: i8,
        vm: bool,
        /* private fields */
    },
    VssubuVv {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        vm: bool,
        /* private fields */
    },
    VssubuVx {
        rs1: Reg,
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VssubVv {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        vm: bool,
        /* private fields */
    },
    VssubVx {
        rs1: Reg,
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VaadduVv {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        vm: bool,
        /* private fields */
    },
    VaadduVx {
        rs1: Reg,
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VaaddVv {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        vm: bool,
        /* private fields */
    },
    VaaddVx {
        rs1: Reg,
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VasubuVv {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        vm: bool,
        /* private fields */
    },
    VasubuVx {
        rs1: Reg,
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VasubVv {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        vm: bool,
        /* private fields */
    },
    VasubVx {
        rs1: Reg,
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VsmulVv {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        vm: bool,
        /* private fields */
    },
    VsmulVx {
        rs1: Reg,
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VssrlVv {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        vm: bool,
        /* private fields */
    },
    VssrlVx {
        rs1: Reg,
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VssrlVi {
        vd: VReg,
        vs2: VReg,
        imm: u8,
        vm: bool,
        /* private fields */
    },
    VssraVv {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        vm: bool,
        /* private fields */
    },
    VssraVx {
        rs1: Reg,
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VssraVi {
        vd: VReg,
        vs2: VReg,
        imm: u8,
        vm: bool,
        /* private fields */
    },
    VnclipuWv {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        vm: bool,
        /* private fields */
    },
    VnclipuWx {
        rs1: Reg,
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VnclipuWi {
        vd: VReg,
        vs2: VReg,
        imm: u8,
        vm: bool,
        /* private fields */
    },
    VnclipWv {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        vm: bool,
        /* private fields */
    },
    VnclipWx {
        rs1: Reg,
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VnclipWi {
        vd: VReg,
        vs2: VReg,
        imm: u8,
        vm: bool,
        /* private fields */
    },
    Vmandn {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        /* private fields */
    },
    Vmand {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        /* private fields */
    },
    Vmor {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        /* private fields */
    },
    Vmxor {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        /* private fields */
    },
    Vmorn {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        /* private fields */
    },
    Vmnand {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        /* private fields */
    },
    Vmnor {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        /* private fields */
    },
    Vmxnor {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        /* private fields */
    },
    Vcpop {
        rd: Reg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    Vfirst {
        rd: Reg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    Vmsbf {
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    Vmsof {
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    Vmsif {
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    Viota {
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    Vid {
        vd: VReg,
        vm: bool,
        /* private fields */
    },
    Vredsum {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        vm: bool,
        /* private fields */
    },
    Vredand {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        vm: bool,
        /* private fields */
    },
    Vredor {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        vm: bool,
        /* private fields */
    },
    Vredxor {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        vm: bool,
        /* private fields */
    },
    Vredminu {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        vm: bool,
        /* private fields */
    },
    Vredmin {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        vm: bool,
        /* private fields */
    },
    Vredmaxu {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        vm: bool,
        /* private fields */
    },
    Vredmax {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        vm: bool,
        /* private fields */
    },
    Vwredsumu {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        vm: bool,
        /* private fields */
    },
    Vwredsum {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        vm: bool,
        /* private fields */
    },
    VmvXS {
        rd: Reg,
        vs2: VReg,
        /* private fields */
    },
    VmvSX {
        rs1: Reg,
        vd: VReg,
        /* private fields */
    },
    VslideupVx {
        rs1: Reg,
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VslideupVi {
        vd: VReg,
        vs2: VReg,
        uimm: u8,
        vm: bool,
        /* private fields */
    },
    VslidedownVx {
        rs1: Reg,
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VslidedownVi {
        vd: VReg,
        vs2: VReg,
        uimm: u8,
        vm: bool,
        /* private fields */
    },
    Vslide1upVx {
        rs1: Reg,
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    Vslide1downVx {
        rs1: Reg,
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VrgatherVv {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        vm: bool,
        /* private fields */
    },
    VrgatherVx {
        rs1: Reg,
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VrgatherVi {
        vd: VReg,
        vs2: VReg,
        uimm: u8,
        vm: bool,
        /* private fields */
    },
    Vrgatherei16Vv {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        vm: bool,
        /* private fields */
    },
    VmergeVvm {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        vm: bool,
        /* private fields */
    },
    VmergeVxm {
        rs1: Reg,
        vd: VReg,
        vs2: VReg,
        vm: bool,
        /* private fields */
    },
    VmergeVim {
        vd: VReg,
        vs2: VReg,
        simm5: i8,
        vm: bool,
        /* private fields */
    },
    VcompressVm {
        vd: VReg,
        vs2: VReg,
        vs1: VReg,
        /* private fields */
    },
    Vmv1rV {
        vd: VReg,
        vs2: VReg,
        /* private fields */
    },
    Vmv2rV {
        vd: VReg,
        vs2: VReg,
        /* private fields */
    },
    Vmv4rV {
        vd: VReg,
        vs2: VReg,
        /* private fields */
    },
    Vmv8rV {
        vd: VReg,
        vs2: VReg,
        /* private fields */
    },
    Csrrw {
        rs1: Reg,
        rd: Reg,
        csr_index: u16,
        /* private fields */
    },
    Csrrs {
        rs1: Reg,
        rd: Reg,
        csr_index: u16,
        /* private fields */
    },
    Csrrc {
        rs1: Reg,
        rd: Reg,
        csr_index: u16,
        /* private fields */
    },
    Csrrwi {
        rd: Reg,
        zimm: u8,
        csr_index: u16,
        /* private fields */
    },
    Csrrsi {
        rd: Reg,
        zimm: u8,
        csr_index: u16,
        /* private fields */
    },
    Csrrci {
        rd: Reg,
        zimm: u8,
        csr_index: u16,
        /* private fields */
    },

}
Expand description

RISC-V Zve64x instruction

Variants§

§

Vsetvli

Set vector length and type from GPR

vsetvli rd, rs1, vtypei rd = new vl, rs1 = AVL, vtypei = new vtype setting (11-bit immediate)

Fields

§rs1: Reg
§rd: Reg
§vtypei: u16
§

Vsetivli

Set vector length and type from immediate AVL

vsetivli rd, uimm, vtypei rd = new vl, uimm[4:0] = AVL, vtypei = new vtype setting (10-bit immediate)

Fields

§rd: Reg
§uimm: u8
§vtypei: u16
§

Vsetvl

Set vector length and type from GPRs

vsetvl rd, rs1, rs2 rd = new vl, rs1 = AVL, rs2 = new vtype value

Fields

§rs1: Reg
§rs2: Reg
§rd: Reg
§

Vle

Unit-stride load: vle{eew}.v vd, (rs1), vm

mop=00, lumop=00000, nf=000

Fields

§rs1: Reg
§vd: VReg
§vm: bool
§eew: Eew
§

Vleff

Unit-stride fault-only-first load: vle{eew}ff.v vd, (rs1), vm

mop=00, lumop=10000, nf=000

Fields

§rs1: Reg
§vd: VReg
§vm: bool
§eew: Eew
§

Vlm

Unit-stride mask load: vlm.v vd, (rs1)

mop=00, lumop=01011, nf=000, eew=e8, vm=1

Fields

§rs1: Reg
§vd: VReg
§

Vlse

Strided load: vlse{eew}.v vd, (rs1), rs2, vm

mop=10, nf=000

Fields

§rs1: Reg
§rs2: Reg
§vd: VReg
§vm: bool
§eew: Eew
§

Vluxei

Indexed-unordered load: vluxei{eew}.v vd, (rs1), vs2, vm

mop=01, nf=000. eew is the index element width.

Fields

§rs1: Reg
§vd: VReg
§vs2: VReg
§vm: bool
§eew: Eew
§

Vloxei

Indexed-ordered load: vloxei{eew}.v vd, (rs1), vs2, vm

mop=11, nf=000. eew is the index element width.

Fields

§rs1: Reg
§vd: VReg
§vs2: VReg
§vm: bool
§eew: Eew
§

Vlr

Whole-register load: vl{nreg}re{eew}.v vd, (rs1)

mop=00, lumop=01000, vm=1. nreg must be 1, 2, 4, or 8.

Fields

§rs1: Reg
§vd: VReg
§nreg: u8
§eew: Eew
§

Vlseg

Unit-stride segment load: vlseg{nf}e{eew}.v vd, (rs1), vm

mop=00, lumop=00000, nf>0

Fields

§rs1: Reg
§vd: VReg
§vm: bool
§eew: Eew
§nf: u8
§

Vlsegff

Unit-stride fault-only-first segment load: vlseg{nf}e{eew}ff.v vd, (rs1), vm

mop=00, lumop=10000, nf>0

Fields

§rs1: Reg
§vd: VReg
§vm: bool
§eew: Eew
§nf: u8
§

Vlsseg

Strided segment load: vlsseg{nf}e{eew}.v vd, (rs1), rs2, vm

mop=10, nf>0

Fields

§rs1: Reg
§rs2: Reg
§vd: VReg
§vm: bool
§eew: Eew
§nf: u8
§

Vluxseg

Indexed-unordered segment load: vluxseg{nf}ei{eew}.v vd, (rs1), vs2, vm

mop=01, nf>0

Fields

§rs1: Reg
§vd: VReg
§vs2: VReg
§vm: bool
§eew: Eew
§nf: u8
§

Vloxseg

Indexed-ordered segment load: vloxseg{nf}ei{eew}.v vd, (rs1), vs2, vm

mop=11, nf>0

Fields

§rs1: Reg
§vd: VReg
§vs2: VReg
§vm: bool
§eew: Eew
§nf: u8
§

Vse

Unit-stride store: vse{eew}.v vs3, (rs1), vm

mop=00, sumop=00000, nf=000

Fields

§rs1: Reg
§vs3: VReg
§vm: bool
§eew: Eew
§

Vsm

Unit-stride mask store: vsm.v vs3, (rs1)

mop=00, sumop=01011, nf=000, eew=e8, vm=1

Fields

§rs1: Reg
§vs3: VReg
§

Vsse

Strided store: vsse{eew}.v vs3, (rs1), rs2, vm

mop=10, nf=000

Fields

§rs1: Reg
§rs2: Reg
§vs3: VReg
§vm: bool
§eew: Eew
§

Vsuxei

Indexed-unordered store: vsuxei{eew}.v vs3, (rs1), vs2, vm

mop=01, nf=000. eew is the index element width.

Fields

§rs1: Reg
§vs3: VReg
§vs2: VReg
§vm: bool
§eew: Eew
§

Vsoxei

Indexed-ordered store: vsoxei{eew}.v vs3, (rs1), vs2, vm

mop=11, nf=000. eew is the index element width.

Fields

§rs1: Reg
§vs3: VReg
§vs2: VReg
§vm: bool
§eew: Eew
§

Vsr

Whole-register store: vs{nreg}r.v vs3, (rs1)

mop=00, sumop=01000, vm=1. nreg must be 1, 2, 4, or 8.

Fields

§rs1: Reg
§vs3: VReg
§nreg: u8
§

Vsseg

Unit-stride segment store: vsseg{nf}e{eew}.v vs3, (rs1), vm

mop=00, sumop=00000, nf>0

Fields

§rs1: Reg
§vs3: VReg
§vm: bool
§eew: Eew
§nf: u8
§

Vssseg

Strided segment store: vssseg{nf}e{eew}.v vs3, (rs1), rs2, vm

mop=10, nf>0

Fields

§rs1: Reg
§rs2: Reg
§vs3: VReg
§vm: bool
§eew: Eew
§nf: u8
§

Vsuxseg

Indexed-unordered segment store: vsuxseg{nf}ei{eew}.v vs3, (rs1), vs2, vm

mop=01, nf>0

Fields

§rs1: Reg
§vs3: VReg
§vs2: VReg
§vm: bool
§eew: Eew
§nf: u8
§

Vsoxseg

Indexed-ordered segment store: vsoxseg{nf}ei{eew}.v vs3, (rs1), vs2, vm

mop=11, nf>0

Fields

§rs1: Reg
§vs3: VReg
§vs2: VReg
§vm: bool
§eew: Eew
§nf: u8
§

VaddVv

vadd.vv vd, vs2, vs1, vm

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§vm: bool
§

VaddVx

vadd.vx vd, vs2, rs1, vm

Fields

§rs1: Reg
§vd: VReg
§vs2: VReg
§vm: bool
§

VaddVi

vadd.vi vd, vs2, imm, vm

Fields

§vd: VReg
§vs2: VReg
§imm: i8
§vm: bool
§

VsubVv

vsub.vv vd, vs2, vs1, vm

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§vm: bool
§

VsubVx

vsub.vx vd, vs2, rs1, vm

Fields

§rs1: Reg
§vd: VReg
§vs2: VReg
§vm: bool
§

VrsubVx

vrsub.vx vd, vs2, rs1, vm

Fields

§rs1: Reg
§vd: VReg
§vs2: VReg
§vm: bool
§

VrsubVi

vrsub.vi vd, vs2, imm, vm

Fields

§vd: VReg
§vs2: VReg
§imm: i8
§vm: bool
§

VandVv

vand.vv vd, vs2, vs1, vm

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§vm: bool
§

VandVx

vand.vx vd, vs2, rs1, vm

Fields

§rs1: Reg
§vd: VReg
§vs2: VReg
§vm: bool
§

VandVi

vand.vi vd, vs2, imm, vm

Fields

§vd: VReg
§vs2: VReg
§imm: i8
§vm: bool
§

VorVv

vor.vv vd, vs2, vs1, vm

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§vm: bool
§

VorVx

vor.vx vd, vs2, rs1, vm

Fields

§rs1: Reg
§vd: VReg
§vs2: VReg
§vm: bool
§

VorVi

vor.vi vd, vs2, imm, vm

Fields

§vd: VReg
§vs2: VReg
§imm: i8
§vm: bool
§

VxorVv

vxor.vv vd, vs2, vs1, vm

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§vm: bool
§

VxorVx

vxor.vx vd, vs2, rs1, vm

Fields

§rs1: Reg
§vd: VReg
§vs2: VReg
§vm: bool
§

VxorVi

vxor.vi vd, vs2, imm, vm

Fields

§vd: VReg
§vs2: VReg
§imm: i8
§vm: bool
§

VsllVv

vsll.vv vd, vs2, vs1, vm

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§vm: bool
§

VsllVx

vsll.vx vd, vs2, rs1, vm

Fields

§rs1: Reg
§vd: VReg
§vs2: VReg
§vm: bool
§

VsllVi

vsll.vi vd, vs2, uimm, vm

Fields

§vd: VReg
§vs2: VReg
§uimm: u8
§vm: bool
§

VsrlVv

vsrl.vv vd, vs2, vs1, vm

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§vm: bool
§

VsrlVx

vsrl.vx vd, vs2, rs1, vm

Fields

§rs1: Reg
§vd: VReg
§vs2: VReg
§vm: bool
§

VsrlVi

vsrl.vi vd, vs2, uimm, vm

Fields

§vd: VReg
§vs2: VReg
§uimm: u8
§vm: bool
§

VsraVv

vsra.vv vd, vs2, vs1, vm

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§vm: bool
§

VsraVx

vsra.vx vd, vs2, rs1, vm

Fields

§rs1: Reg
§vd: VReg
§vs2: VReg
§vm: bool
§

VsraVi

vsra.vi vd, vs2, uimm, vm

Fields

§vd: VReg
§vs2: VReg
§uimm: u8
§vm: bool
§

VminuVv

vminu.vv vd, vs2, vs1, vm

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§vm: bool
§

VminuVx

vminu.vx vd, vs2, rs1, vm

Fields

§rs1: Reg
§vd: VReg
§vs2: VReg
§vm: bool
§

VminVv

vmin.vv vd, vs2, vs1, vm

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§vm: bool
§

VminVx

vmin.vx vd, vs2, rs1, vm

Fields

§rs1: Reg
§vd: VReg
§vs2: VReg
§vm: bool
§

VmaxuVv

vmaxu.vv vd, vs2, vs1, vm

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§vm: bool
§

VmaxuVx

vmaxu.vx vd, vs2, rs1, vm

Fields

§rs1: Reg
§vd: VReg
§vs2: VReg
§vm: bool
§

VmaxVv

vmax.vv vd, vs2, vs1, vm

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§vm: bool
§

VmaxVx

vmax.vx vd, vs2, rs1, vm

Fields

§rs1: Reg
§vd: VReg
§vs2: VReg
§vm: bool
§

VmseqVv

vmseq.vv vd, vs2, vs1, vm

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§vm: bool
§

VmseqVx

vmseq.vx vd, vs2, rs1, vm

Fields

§rs1: Reg
§vd: VReg
§vs2: VReg
§vm: bool
§

VmseqVi

vmseq.vi vd, vs2, imm, vm

Fields

§vd: VReg
§vs2: VReg
§imm: i8
§vm: bool
§

VmsneVv

vmsne.vv vd, vs2, vs1, vm

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§vm: bool
§

VmsneVx

vmsne.vx vd, vs2, rs1, vm

Fields

§rs1: Reg
§vd: VReg
§vs2: VReg
§vm: bool
§

VmsneVi

vmsne.vi vd, vs2, imm, vm

Fields

§vd: VReg
§vs2: VReg
§imm: i8
§vm: bool
§

VmsltuVv

vmsltu.vv vd, vs2, vs1, vm

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§vm: bool
§

VmsltuVx

vmsltu.vx vd, vs2, rs1, vm

Fields

§rs1: Reg
§vd: VReg
§vs2: VReg
§vm: bool
§

VmsltVv

vmslt.vv vd, vs2, vs1, vm

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§vm: bool
§

VmsltVx

vmslt.vx vd, vs2, rs1, vm

Fields

§rs1: Reg
§vd: VReg
§vs2: VReg
§vm: bool
§

VmsleuVv

vmsleu.vv vd, vs2, vs1, vm

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§vm: bool
§

VmsleuVx

vmsleu.vx vd, vs2, rs1, vm

Fields

§rs1: Reg
§vd: VReg
§vs2: VReg
§vm: bool
§

VmsleuVi

vmsleu.vi vd, vs2, imm, vm

Fields

§vd: VReg
§vs2: VReg
§imm: i8
§vm: bool
§

VmsleVv

vmsle.vv vd, vs2, vs1, vm

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§vm: bool
§

VmsleVx

vmsle.vx vd, vs2, rs1, vm

Fields

§rs1: Reg
§vd: VReg
§vs2: VReg
§vm: bool
§

VmsleVi

vmsle.vi vd, vs2, imm, vm

Fields

§vd: VReg
§vs2: VReg
§imm: i8
§vm: bool
§

VmsgtuVx

vmsgtu.vx vd, vs2, rs1, vm

Fields

§rs1: Reg
§vd: VReg
§vs2: VReg
§vm: bool
§

VmsgtuVi

vmsgtu.vi vd, vs2, imm, vm

Fields

§vd: VReg
§vs2: VReg
§imm: i8
§vm: bool
§

VmsgtVx

vmsgt.vx vd, vs2, rs1, vm

Fields

§rs1: Reg
§vd: VReg
§vs2: VReg
§vm: bool
§

VmsgtVi

vmsgt.vi vd, vs2, imm, vm

Fields

§vd: VReg
§vs2: VReg
§imm: i8
§vm: bool
§

VmulVv

vmul.vv vd, vs2, vs1, vm - signed multiply, low bits

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§vm: bool
§

VmulVx

vmul.vx vd, vs2, rs1, vm - signed multiply, low bits

Fields

§rs1: Reg
§vd: VReg
§vs2: VReg
§vm: bool
§

VmulhVv

vmulh.vv vd, vs2, vs1, vm - signed×signed multiply, high bits

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§vm: bool
§

VmulhVx

vmulh.vx vd, vs2, rs1, vm - signed×signed multiply, high bits

Fields

§rs1: Reg
§vd: VReg
§vs2: VReg
§vm: bool
§

VmulhuVv

vmulhu.vv vd, vs2, vs1, vm - unsigned×unsigned multiply, high bits

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§vm: bool
§

VmulhuVx

vmulhu.vx vd, vs2, rs1, vm - unsigned×unsigned multiply, high bits

Fields

§rs1: Reg
§vd: VReg
§vs2: VReg
§vm: bool
§

VmulhsuVv

vmulhsu.vv vd, vs2, vs1, vm - signed×unsigned multiply, high bits

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§vm: bool
§

VmulhsuVx

vmulhsu.vx vd, vs2, rs1, vm - signed×unsigned multiply, high bits

Fields

§rs1: Reg
§vd: VReg
§vs2: VReg
§vm: bool
§

VdivuVv

vdivu.vv vd, vs2, vs1, vm - unsigned divide

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§vm: bool
§

VdivuVx

vdivu.vx vd, vs2, rs1, vm - unsigned divide

Fields

§rs1: Reg
§vd: VReg
§vs2: VReg
§vm: bool
§

VdivVv

vdiv.vv vd, vs2, vs1, vm - signed divide

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§vm: bool
§

VdivVx

vdiv.vx vd, vs2, rs1, vm - signed divide

Fields

§rs1: Reg
§vd: VReg
§vs2: VReg
§vm: bool
§

VremuVv

vremu.vv vd, vs2, vs1, vm - unsigned remainder

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§vm: bool
§

VremuVx

vremu.vx vd, vs2, rs1, vm - unsigned remainder

Fields

§rs1: Reg
§vd: VReg
§vs2: VReg
§vm: bool
§

VremVv

vrem.vv vd, vs2, vs1, vm - signed remainder

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§vm: bool
§

VremVx

vrem.vx vd, vs2, rs1, vm - signed remainder

Fields

§rs1: Reg
§vd: VReg
§vs2: VReg
§vm: bool
§

VwmulVv

vwmul.vv vd, vs2, vs1, vm - signed widening multiply

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§vm: bool
§

VwmulVx

vwmul.vx vd, vs2, rs1, vm - signed widening multiply

Fields

§rs1: Reg
§vd: VReg
§vs2: VReg
§vm: bool
§

VwmuluVv

vwmulu.vv vd, vs2, vs1, vm - unsigned widening multiply

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§vm: bool
§

VwmuluVx

vwmulu.vx vd, vs2, rs1, vm - unsigned widening multiply

Fields

§rs1: Reg
§vd: VReg
§vs2: VReg
§vm: bool
§

VwmulsuVv

vwmulsu.vv vd, vs2, vs1, vm - signed×unsigned widening multiply

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§vm: bool
§

VwmulsuVx

vwmulsu.vx vd, vs2, rs1, vm - signed×unsigned widening multiply

Fields

§rs1: Reg
§vd: VReg
§vs2: VReg
§vm: bool
§

VmaccVv

vmacc.vv vd, vs1, vs2, vm - vd = vd + vs1 * vs2

Fields

§vd: VReg
§vs1: VReg
§vs2: VReg
§vm: bool
§

VmaccVx

vmacc.vx vd, rs1, vs2, vm - vd = vd + rs1 * vs2

Fields

§rs1: Reg
§vd: VReg
§vs2: VReg
§vm: bool
§

VnmsacVv

vnmsac.vv vd, vs1, vs2, vm - vd = vd - vs1 * vs2

Fields

§vd: VReg
§vs1: VReg
§vs2: VReg
§vm: bool
§

VnmsacVx

vnmsac.vx vd, rs1, vs2, vm - vd = vd - rs1 * vs2

Fields

§rs1: Reg
§vd: VReg
§vs2: VReg
§vm: bool
§

VmaddVv

vmadd.vv vd, vs1, vs2, vm - vd = vs1 * vd + vs2

Fields

§vd: VReg
§vs1: VReg
§vs2: VReg
§vm: bool
§

VmaddVx

vmadd.vx vd, rs1, vs2, vm - vd = rs1 * vd + vs2

Fields

§rs1: Reg
§vd: VReg
§vs2: VReg
§vm: bool
§

VnmsubVv

vnmsub.vv vd, vs1, vs2, vm - vd = -(vs1 * vd - vs2)

Fields

§vd: VReg
§vs1: VReg
§vs2: VReg
§vm: bool
§

VnmsubVx

vnmsub.vx vd, rs1, vs2, vm - vd = -(rs1 * vd - vs2)

Fields

§rs1: Reg
§vd: VReg
§vs2: VReg
§vm: bool
§

VwmaccuVv

vwmaccu.vv vd, vs1, vs2, vm - unsigned widening multiply-add

Fields

§vd: VReg
§vs1: VReg
§vs2: VReg
§vm: bool
§

VwmaccuVx

vwmaccu.vx vd, rs1, vs2, vm - unsigned widening multiply-add

Fields

§rs1: Reg
§vd: VReg
§vs2: VReg
§vm: bool
§

VwmaccVv

vwmacc.vv vd, vs1, vs2, vm - signed widening multiply-add

Fields

§vd: VReg
§vs1: VReg
§vs2: VReg
§vm: bool
§

VwmaccVx

vwmacc.vx vd, rs1, vs2, vm - signed widening multiply-add

Fields

§rs1: Reg
§vd: VReg
§vs2: VReg
§vm: bool
§

VwmaccsuVv

vwmaccsu.vv vd, vs1, vs2, vm - signed×unsigned widening multiply-add

Fields

§vd: VReg
§vs1: VReg
§vs2: VReg
§vm: bool
§

VwmaccsuVx

vwmaccsu.vx vd, rs1, vs2, vm - signed×unsigned widening multiply-add

Fields

§rs1: Reg
§vd: VReg
§vs2: VReg
§vm: bool
§

VwmaccusVx

vwmaccus.vx vd, rs1, vs2, vm - unsigned×signed widening multiply-add (vx only)

Fields

§rs1: Reg
§vd: VReg
§vs2: VReg
§vm: bool
§

VwadduVv

vwaddu.vv vd, vs2, vs1, vm

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§vm: bool
§

VwadduVx

vwaddu.vx vd, vs2, rs1, vm

Fields

§rs1: Reg
§vd: VReg
§vs2: VReg
§vm: bool
§

VwaddVv

vwadd.vv vd, vs2, vs1, vm

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§vm: bool
§

VwaddVx

vwadd.vx vd, vs2, rs1, vm

Fields

§rs1: Reg
§vd: VReg
§vs2: VReg
§vm: bool
§

VwsubuVv

vwsubu.vv vd, vs2, vs1, vm

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§vm: bool
§

VwsubuVx

vwsubu.vx vd, vs2, rs1, vm

Fields

§rs1: Reg
§vd: VReg
§vs2: VReg
§vm: bool
§

VwsubVv

vwsub.vv vd, vs2, vs1, vm

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§vm: bool
§

VwsubVx

vwsub.vx vd, vs2, rs1, vm

Fields

§rs1: Reg
§vd: VReg
§vs2: VReg
§vm: bool
§

VwadduWv

vwaddu.wv vd, vs2, vs1, vm

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§vm: bool
§

VwadduWx

vwaddu.wx vd, vs2, rs1, vm

Fields

§rs1: Reg
§vd: VReg
§vs2: VReg
§vm: bool
§

VwaddWv

vwadd.wv vd, vs2, vs1, vm

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§vm: bool
§

VwaddWx

vwadd.wx vd, vs2, rs1, vm

Fields

§rs1: Reg
§vd: VReg
§vs2: VReg
§vm: bool
§

VwsubuWv

vwsubu.wv vd, vs2, vs1, vm

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§vm: bool
§

VwsubuWx

vwsubu.wx vd, vs2, rs1, vm

Fields

§rs1: Reg
§vd: VReg
§vs2: VReg
§vm: bool
§

VwsubWv

vwsub.wv vd, vs2, vs1, vm

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§vm: bool
§

VwsubWx

vwsub.wx vd, vs2, rs1, vm

Fields

§rs1: Reg
§vd: VReg
§vs2: VReg
§vm: bool
§

VnsrlWv

vnsrl.wv vd, vs2, vs1, vm

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§vm: bool
§

VnsrlWx

vnsrl.wx vd, vs2, rs1, vm

Fields

§rs1: Reg
§vd: VReg
§vs2: VReg
§vm: bool
§

VnsrlWi

vnsrl.wi vd, vs2, uimm, vm

Fields

§vd: VReg
§vs2: VReg
§uimm: u8
§vm: bool
§

VnsraWv

vnsra.wv vd, vs2, vs1, vm

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§vm: bool
§

VnsraWx

vnsra.wx vd, vs2, rs1, vm

Fields

§rs1: Reg
§vd: VReg
§vs2: VReg
§vm: bool
§

VnsraWi

vnsra.wi vd, vs2, uimm, vm

Fields

§vd: VReg
§vs2: VReg
§uimm: u8
§vm: bool
§

VzextVf2

vzext.vf2 vd, vs2, vm - zero-extend SEW/2 source to SEW destination

Fields

§vd: VReg
§vs2: VReg
§vm: bool
§

VzextVf4

vzext.vf4 vd, vs2, vm - zero-extend SEW/4 source to SEW destination

Fields

§vd: VReg
§vs2: VReg
§vm: bool
§

VzextVf8

vzext.vf8 vd, vs2, vm - zero-extend SEW/8 source to SEW destination

Fields

§vd: VReg
§vs2: VReg
§vm: bool
§

VsextVf2

vsext.vf2 vd, vs2, vm - sign-extend SEW/2 source to SEW destination

Fields

§vd: VReg
§vs2: VReg
§vm: bool
§

VsextVf4

vsext.vf4 vd, vs2, vm - sign-extend SEW/4 source to SEW destination

Fields

§vd: VReg
§vs2: VReg
§vm: bool
§

VsextVf8

vsext.vf8 vd, vs2, vm - sign-extend SEW/8 source to SEW destination

Fields

§vd: VReg
§vs2: VReg
§vm: bool
§

VsadduVv

vsaddu.vv vd, vs2, vs1, vm - Saturating unsigned add, vector-vector

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§vm: bool
§

VsadduVx

vsaddu.vx vd, vs2, rs1, vm - Saturating unsigned add, vector-scalar

Fields

§rs1: Reg
§vd: VReg
§vs2: VReg
§vm: bool
§

VsadduVi

vsaddu.vi vd, vs2, imm, vm - Saturating unsigned add, vector-immediate

Fields

§vd: VReg
§vs2: VReg
§imm: i8
§vm: bool
§

VsaddVv

vsadd.vv vd, vs2, vs1, vm - Saturating signed add, vector-vector

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§vm: bool
§

VsaddVx

vsadd.vx vd, vs2, rs1, vm - Saturating signed add, vector-scalar

Fields

§rs1: Reg
§vd: VReg
§vs2: VReg
§vm: bool
§

VsaddVi

vsadd.vi vd, vs2, imm, vm - Saturating signed add, vector-immediate

Fields

§vd: VReg
§vs2: VReg
§imm: i8
§vm: bool
§

VssubuVv

vssubu.vv vd, vs2, vs1, vm - Saturating unsigned subtract, vector-vector

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§vm: bool
§

VssubuVx

vssubu.vx vd, vs2, rs1, vm - Saturating unsigned subtract, vector-scalar

Fields

§rs1: Reg
§vd: VReg
§vs2: VReg
§vm: bool
§

VssubVv

vssub.vv vd, vs2, vs1, vm - Saturating signed subtract, vector-vector

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§vm: bool
§

VssubVx

vssub.vx vd, vs2, rs1, vm - Saturating signed subtract, vector-scalar

Fields

§rs1: Reg
§vd: VReg
§vs2: VReg
§vm: bool
§

VaadduVv

vaaddu.vv vd, vs2, vs1, vm - Averaging unsigned add, vector-vector

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§vm: bool
§

VaadduVx

vaaddu.vx vd, vs2, rs1, vm - Averaging unsigned add, vector-scalar

Fields

§rs1: Reg
§vd: VReg
§vs2: VReg
§vm: bool
§

VaaddVv

vaadd.vv vd, vs2, vs1, vm - Averaging signed add, vector-vector

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§vm: bool
§

VaaddVx

vaadd.vx vd, vs2, rs1, vm - Averaging signed add, vector-scalar

Fields

§rs1: Reg
§vd: VReg
§vs2: VReg
§vm: bool
§

VasubuVv

vasubu.vv vd, vs2, vs1, vm - Averaging unsigned subtract, vector-vector

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§vm: bool
§

VasubuVx

vasubu.vx vd, vs2, rs1, vm - Averaging unsigned subtract, vector-scalar

Fields

§rs1: Reg
§vd: VReg
§vs2: VReg
§vm: bool
§

VasubVv

vasub.vv vd, vs2, vs1, vm - Averaging signed subtract, vector-vector

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§vm: bool
§

VasubVx

vasub.vx vd, vs2, rs1, vm - Averaging signed subtract, vector-scalar

Fields

§rs1: Reg
§vd: VReg
§vs2: VReg
§vm: bool
§

VsmulVv

vsmul.vv vd, vs2, vs1, vm - Fractional multiply with rounding and saturation

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§vm: bool
§

VsmulVx

vsmul.vx vd, vs2, rs1, vm - Fractional multiply with rounding and saturation

Fields

§rs1: Reg
§vd: VReg
§vs2: VReg
§vm: bool
§

VssrlVv

vssrl.vv vd, vs2, vs1, vm - Scaling shift right logical, vector-vector

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§vm: bool
§

VssrlVx

vssrl.vx vd, vs2, rs1, vm - Scaling shift right logical, vector-scalar

Fields

§rs1: Reg
§vd: VReg
§vs2: VReg
§vm: bool
§

VssrlVi

vssrl.vi vd, vs2, imm, vm - Scaling shift right logical, vector-immediate

Fields

§vd: VReg
§vs2: VReg
§imm: u8
§vm: bool
§

VssraVv

vssra.vv vd, vs2, vs1, vm - Scaling shift right arithmetic, vector-vector

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§vm: bool
§

VssraVx

vssra.vx vd, vs2, rs1, vm - Scaling shift right arithmetic, vector-scalar

Fields

§rs1: Reg
§vd: VReg
§vs2: VReg
§vm: bool
§

VssraVi

vssra.vi vd, vs2, imm, vm - Scaling shift right arithmetic, vector-immediate

Fields

§vd: VReg
§vs2: VReg
§imm: u8
§vm: bool
§

VnclipuWv

vnclipu.wv vd, vs2, vs1, vm - Narrowing unsigned clip, vector-vector

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§vm: bool
§

VnclipuWx

vnclipu.wx vd, vs2, rs1, vm - Narrowing unsigned clip, vector-scalar

Fields

§rs1: Reg
§vd: VReg
§vs2: VReg
§vm: bool
§

VnclipuWi

vnclipu.wi vd, vs2, imm, vm - Narrowing unsigned clip, vector-immediate

Fields

§vd: VReg
§vs2: VReg
§imm: u8
§vm: bool
§

VnclipWv

vnclip.wv vd, vs2, vs1, vm - Narrowing signed clip, vector-vector

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§vm: bool
§

VnclipWx

vnclip.wx vd, vs2, rs1, vm - Narrowing signed clip, vector-scalar

Fields

§rs1: Reg
§vd: VReg
§vs2: VReg
§vm: bool
§

VnclipWi

vnclip.wi vd, vs2, imm, vm - Narrowing signed clip, vector-immediate

Fields

§vd: VReg
§vs2: VReg
§imm: u8
§vm: bool
§

Vmandn

vmandn.mm vd, vs2, vs1 - vd = vs2 AND NOT vs1

funct6=011000, OPMVV, vm=1

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§

Vmand

vmand.mm vd, vs2, vs1 - vd = vs2 AND vs1

funct6=011001, OPMVV, vm=1

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§

Vmor

vmor.mm vd, vs2, vs1 - vd = vs2 OR vs1

funct6=011010, OPMVV, vm=1

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§

Vmxor

vmxor.mm vd, vs2, vs1 - vd = vs2 XOR vs1

funct6=011011, OPMVV, vm=1

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§

Vmorn

vmorn.mm vd, vs2, vs1 - vd = vs2 OR NOT vs1

funct6=011100, OPMVV, vm=1

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§

Vmnand

vmnand.mm vd, vs2, vs1 - vd = NOT(vs2 AND vs1)

funct6=011101, OPMVV, vm=1

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§

Vmnor

vmnor.mm vd, vs2, vs1 - vd = NOT(vs2 OR vs1)

funct6=011110, OPMVV, vm=1

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§

Vmxnor

vmxnor.mm vd, vs2, vs1 - vd = NOT(vs2 XOR vs1)

funct6=011111, OPMVV, vm=1

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§

Vcpop

vcpop.m rd, vs2, vm - rd = population count of mask vs2

funct6=010000, OPMVV, vs1=10000

Fields

§rd: Reg
§vs2: VReg
§vm: bool
§

Vfirst

vfirst.m rd, vs2, vm - rd = index of first set bit in mask vs2, or -1

funct6=010000, OPMVV, vs1=10001

Fields

§rd: Reg
§vs2: VReg
§vm: bool
§

Vmsbf

vmsbf.m vd, vs2, vm - set-before-first mask bit

funct6=010100, OPMVV, vs1=00001

Fields

§vd: VReg
§vs2: VReg
§vm: bool
§

Vmsof

vmsof.m vd, vs2, vm - set-only-first mask bit

funct6=010100, OPMVV, vs1=00010

Fields

§vd: VReg
§vs2: VReg
§vm: bool
§

Vmsif

vmsif.m vd, vs2, vm - set-including-first mask bit

funct6=010100, OPMVV, vs1=00011

Fields

§vd: VReg
§vs2: VReg
§vm: bool
§

Viota

viota.m vd, vs2, vm - iota: vd[i] = popcount of vs2[0..i-1]

funct6=010100, OPMVV, vs1=10000

Fields

§vd: VReg
§vs2: VReg
§vm: bool
§

Vid

vid.v vd, vm - vector element index: vd[i] = i

funct6=010100, OPMVV, vs1=10001, vs2=00000

Fields

§vd: VReg
§vm: bool
§

Vredsum

Sum reduction: vredsum.vs vd, vs2, vs1, vm

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§vm: bool
§

Vredand

AND reduction: vredand.vs vd, vs2, vs1, vm

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§vm: bool
§

Vredor

OR reduction: vredor.vs vd, vs2, vs1, vm

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§vm: bool
§

Vredxor

XOR reduction: vredxor.vs vd, vs2, vs1, vm

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§vm: bool
§

Vredminu

Unsigned minimum reduction: vredminu.vs vd, vs2, vs1, vm

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§vm: bool
§

Vredmin

Signed minimum reduction: vredmin.vs vd, vs2, vs1, vm

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§vm: bool
§

Vredmaxu

Unsigned maximum reduction: vredmaxu.vs vd, vs2, vs1, vm

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§vm: bool
§

Vredmax

Signed maximum reduction: vredmax.vs vd, vs2, vs1, vm

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§vm: bool
§

Vwredsumu

Widening unsigned sum reduction: vwredsumu.vs vd, vs2, vs1, vm

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§vm: bool
§

Vwredsum

Widening signed sum reduction: vwredsum.vs vd, vs2, vs1, vm

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§vm: bool
§

VmvXS

vmv.x.s rd, vs2 - Copy scalar element 0 of vs2 to GPR rd

funct6=010000, OPMVV, vs1=00000, vm=1

Fields

§rd: Reg
§vs2: VReg
§

VmvSX

vmv.s.x vd, rs1 - Copy scalar GPR rs1 to element 0 of vd

funct6=010000, OPMVX, vs2=00000, vm=1

Fields

§rs1: Reg
§vd: VReg
§

VslideupVx

vslideup.vx vd, vs2, rs1, vm - Slide elements up by scalar amount

funct6=001110, OPIVX

Fields

§rs1: Reg
§vd: VReg
§vs2: VReg
§vm: bool
§

VslideupVi

vslideup.vi vd, vs2, uimm, vm - Slide elements up by immediate amount

funct6=001110, OPIVI

Fields

§vd: VReg
§vs2: VReg
§uimm: u8
§vm: bool
§

VslidedownVx

vslidedown.vx vd, vs2, rs1, vm - Slide elements down by scalar amount

funct6=001111, OPIVX

Fields

§rs1: Reg
§vd: VReg
§vs2: VReg
§vm: bool
§

VslidedownVi

vslidedown.vi vd, vs2, uimm, vm - Slide elements down by immediate amount

funct6=001111, OPIVI

Fields

§vd: VReg
§vs2: VReg
§uimm: u8
§vm: bool
§

Vslide1upVx

vslide1up.vx vd, vs2, rs1, vm - Slide up by 1 and insert scalar at element 0

funct6=001110, OPMVX

Fields

§rs1: Reg
§vd: VReg
§vs2: VReg
§vm: bool
§

Vslide1downVx

vslide1down.vx vd, vs2, rs1, vm - Slide down by 1 and insert scalar at top

funct6=001111, OPMVX

Fields

§rs1: Reg
§vd: VReg
§vs2: VReg
§vm: bool
§

VrgatherVv

vrgather.vv vd, vs2, vs1, vm - Gather elements from vs2 using indices in vs1

funct6=001100, OPIVV

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§vm: bool
§

VrgatherVx

vrgather.vx vd, vs2, rs1, vm - Gather elements from vs2 using scalar index

funct6=001100, OPIVX

Fields

§rs1: Reg
§vd: VReg
§vs2: VReg
§vm: bool
§

VrgatherVi

vrgather.vi vd, vs2, uimm, vm - Gather elements from vs2 using immediate index

funct6=001100, OPIVI

Fields

§vd: VReg
§vs2: VReg
§uimm: u8
§vm: bool
§

Vrgatherei16Vv

vrgatherei16.vv vd, vs2, vs1, vm - Gather with 16-bit indices

funct6=001110, OPIVV

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§vm: bool
§

VmergeVvm

vmerge.vvm vd, vs2, vs1, v0 / vmv.v.v vd, vs1 (when vm=1)

funct6=010111, OPIVV

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§vm: bool
§

VmergeVxm

vmerge.vxm vd, vs2, rs1, v0 / vmv.v.x vd, rs1 (when vm=1)

funct6=010111, OPIVX

Fields

§rs1: Reg
§vd: VReg
§vs2: VReg
§vm: bool
§

VmergeVim

vmerge.vim vd, vs2, simm5, v0 / vmv.v.i vd, simm5 (when vm=1)

funct6=010111, OPIVI

Fields

§vd: VReg
§vs2: VReg
§simm5: i8
§vm: bool
§

VcompressVm

vcompress.vm vd, vs2, vs1 - Compress active elements from vs2 under mask vs1

funct6=010111, OPMVV, vm=1 (always unmasked)

Fields

§vd: VReg
§vs2: VReg
§vs1: VReg
§

Vmv1rV

vmv1r.v vd, vs2 - Whole register move (1 register)

funct6=100111, OPIVI, simm5=00000, vm=1

Fields

§vd: VReg
§vs2: VReg
§

Vmv2rV

vmv2r.v vd, vs2 - Whole register move (2 registers)

funct6=100111, OPIVI, simm5=00001, vm=1

Fields

§vd: VReg
§vs2: VReg
§

Vmv4rV

vmv4r.v vd, vs2 - Whole register move (4 registers)

funct6=100111, OPIVI, simm5=00011, vm=1

Fields

§vd: VReg
§vs2: VReg
§

Vmv8rV

vmv8r.v vd, vs2 - Whole register move (8 registers)

funct6=100111, OPIVI, simm5=00111, vm=1

Fields

§vd: VReg
§vs2: VReg
§

Csrrw

Fields

§rs1: Reg
§rd: Reg
§csr_index: u16
§

Csrrs

Fields

§rs1: Reg
§rd: Reg
§csr_index: u16
§

Csrrc

Fields

§rs1: Reg
§rd: Reg
§csr_index: u16
§

Csrrwi

Fields

§rd: Reg
§zimm: u8
§csr_index: u16
§

Csrrsi

Fields

§rd: Reg
§zimm: u8
§csr_index: u16
§

Csrrci

Fields

§rd: Reg
§zimm: u8
§csr_index: u16

Trait Implementations§

Source§

impl<Reg: Clone> Clone for Zve64xInstruction<Reg>

Source§

fn clone(&self) -> Zve64xInstruction<Reg>

Returns a duplicate of the value. Read more
1.0.0 · Source§

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

Performs copy-assignment from source. Read more
Source§

impl<Reg: Debug> Debug for Zve64xInstruction<Reg>

Source§

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

Formats the value using the given formatter. Read more
§

impl<Reg> Display for Zve64xInstruction<Reg>
where Reg: Display + Copy,

§

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

Formats the value using the given formatter. Read more
§

impl<Reg> Instruction for Zve64xInstruction<Reg>
where Reg: Register,

§

type Reg = Reg

A register type used by the instruction
§

fn try_decode(instruction: u32) -> Option<Self>

Try to decode a single valid instruction
§

fn alignment() -> u8

Instruction alignment in bytes
§

fn size(&self) -> u8

Instruction size in bytes
Source§

impl<Reg: PartialEq> PartialEq for Zve64xInstruction<Reg>

Source§

fn eq(&self, other: &Zve64xInstruction<Reg>) -> bool

Tests for self and other values to be equal, and is used by ==.
1.0.0 · Source§

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
Source§

impl<Reg: Copy> Copy for Zve64xInstruction<Reg>

Source§

impl<Reg: Eq> Eq for Zve64xInstruction<Reg>

Source§

impl<Reg> StructuralPartialEq for Zve64xInstruction<Reg>

Auto Trait Implementations§

§

impl<Reg> Freeze for Zve64xInstruction<Reg>
where Reg: Freeze,

§

impl<Reg> RefUnwindSafe for Zve64xInstruction<Reg>
where Reg: RefUnwindSafe,

§

impl<Reg> Send for Zve64xInstruction<Reg>
where Reg: Send,

§

impl<Reg> Sync for Zve64xInstruction<Reg>
where Reg: Sync,

§

impl<Reg> Unpin for Zve64xInstruction<Reg>
where Reg: Unpin,

§

impl<Reg> UnsafeUnpin for Zve64xInstruction<Reg>
where Reg: UnsafeUnpin,

§

impl<Reg> UnwindSafe for Zve64xInstruction<Reg>
where Reg: UnwindSafe,

Blanket Implementations§

Source§

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

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

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

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

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

Source§

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

Mutably borrows from an owned value. Read more
Source§

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

Source§

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

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

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

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

Source§

fn into(self) -> U

Calls U::from(self).

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

Source§

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

Source§

type Owned = T

The resulting type after obtaining ownership.
Source§

fn to_owned(&self) -> T

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

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

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

impl<T> ToString for T
where T: Display + ?Sized,

Source§

fn to_string(&self) -> String

Converts the given value to a String. Read more
Source§

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

Source§

type Error = Infallible

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

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

Performs the conversion.
Source§

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

Source§

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

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

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

Performs the conversion.