Index: llvm/lib/Target/RISCV/AsmParser/RISCVAsmParser.cpp
===================================================================
--- llvm/lib/Target/RISCV/AsmParser/RISCVAsmParser.cpp
+++ llvm/lib/Target/RISCV/AsmParser/RISCVAsmParser.cpp
@@ -14,6 +14,7 @@
 #include "Utils/RISCVBaseInfo.h"
 #include "Utils/RISCVMatInt.h"
 #include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/SmallBitVector.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/CodeGen/Register.h"
@@ -173,6 +174,9 @@
 
     return false;
   }
+
+  std::unique_ptr<RISCVOperand> defaultRVVMask() const;
+
 public:
   enum RISCVMatchResultTy {
     Match_Dummy = FIRST_TARGET_MATCH_RESULT_TY,
@@ -841,9 +845,15 @@
     assert(N == 1 && "Invalid number of operands!");
     Inst.addOperand(MCOperand::createImm(getRoundingMode()));
   }
+
 };
 } // end anonymous namespace.
 
+std::unique_ptr<RISCVOperand> RISCVAsmParser::defaultRVVMask() const {
+  return RISCVOperand::createReg(RISCV::NoRegister, llvm::SMLoc(),
+                                 llvm::SMLoc(), isRV64());
+}
+
 #define GET_REGISTER_MATCHER
 #define GET_MATCHER_IMPLEMENTATION
 #include "RISCVGenAsmMatcher.inc"
@@ -1932,6 +1942,12 @@
 
 bool RISCVAsmParser::validateInstruction(MCInst &Inst,
                                          OperandVector &Operands) {
+  // FIXME!
+  // We should look at the mask operand if any and update this code for the
+  // proper diagnostics.
+  return false;
+
+#if 0
   SMLoc Loc = Operands[0]->getStartLoc();
   const unsigned Opcode = Inst.getOpcode();
   switch (Opcode) {
@@ -2157,6 +2173,7 @@
     return false;
   }
   return false;
+#endif
 }
 
 bool RISCVAsmParser::processInstruction(MCInst &Inst, SMLoc IDLoc,
Index: llvm/lib/Target/RISCV/Disassembler/RISCVDisassembler.cpp
===================================================================
--- llvm/lib/Target/RISCV/Disassembler/RISCVDisassembler.cpp
+++ llvm/lib/Target/RISCV/Disassembler/RISCVDisassembler.cpp
@@ -163,6 +163,23 @@
   return MCDisassembler::Success;
 }
 
+static DecodeStatus DecodeVPRV0RegisterClass(MCInst &Inst, uint64_t RegNo,
+                                             uint64_t Address,
+                                             const void *Decoder) {
+  Register Reg = RISCV::NoRegister;
+  switch (RegNo) {
+  default:
+    return MCDisassembler::Fail;
+  case 0:
+    Reg = RISCV::V0;
+    break;
+  case 1:
+    break;
+  }
+  Inst.addOperand(MCOperand::createReg(Reg));
+  return MCDisassembler::Success;
+}
+
 // Add implied SP operand for instructions *SP compressed instructions. The SP
 // operand isn't explicitly encoded in the instruction.
 static void addImplySP(MCInst &Inst, int64_t Address, const void *Decoder) {
@@ -332,6 +349,8 @@
   if (Desc.TSFlags & RISCVII::InstVectorWithMask) {
     if ((Insn & (0x1 << 25)) == 0)
       Inst.addOperand(MCOperand::createReg(RISCV::V0));
+    else
+      Inst.addOperand(MCOperand::createReg(RISCV::NoRegister));
   }
 }
 
Index: llvm/lib/Target/RISCV/MCTargetDesc/RISCVInstPrinter.cpp
===================================================================
--- llvm/lib/Target/RISCV/MCTargetDesc/RISCVInstPrinter.cpp
+++ llvm/lib/Target/RISCV/MCTargetDesc/RISCVInstPrinter.cpp
@@ -166,9 +166,11 @@
   const MCOperand &MO = MI->getOperand(OpNo);
 
   assert(MO.isReg() && "printVPRMaskOp can only print register operands");
+  if (MO.getReg() == RISCV::NoRegister)
+    return;
+  O << ", ";
   printRegName(O, MO.getReg());
   O << ".t";
-  return;
 }
 
 const char *RISCVInstPrinter::getRegisterName(unsigned RegNo) {
Index: llvm/lib/Target/RISCV/MCTargetDesc/RISCVMCCodeEmitter.cpp
===================================================================
--- llvm/lib/Target/RISCV/MCTargetDesc/RISCVMCCodeEmitter.cpp
+++ llvm/lib/Target/RISCV/MCTargetDesc/RISCVMCCodeEmitter.cpp
@@ -80,6 +80,10 @@
   unsigned getImmOpValue(const MCInst &MI, unsigned OpNo,
                          SmallVectorImpl<MCFixup> &Fixups,
                          const MCSubtargetInfo &STI) const;
+
+  unsigned getVPRMaskOp(const MCInst &MI, unsigned OpNo,
+                        SmallVectorImpl<MCFixup> &Fixups,
+                        const MCSubtargetInfo &STI) const;
 };
 } // end anonymous namespace
 
@@ -368,4 +372,20 @@
   return 0;
 }
 
+unsigned RISCVMCCodeEmitter::getVPRMaskOp(const MCInst &MI, unsigned OpNo,
+                                          SmallVectorImpl<MCFixup> &Fixups,
+                                          const MCSubtargetInfo &STI) const {
+  MCOperand MO = MI.getOperand(OpNo);
+  assert(MO.isReg() && "Expected a register");
+
+  switch (MO.getReg()) {
+  default:
+    llvm_unreachable("Invalid mask register");
+  case RISCV::V0:
+    return 0;
+  case RISCV::NoRegister:
+    return 1;
+  }
+}
+
 #include "RISCVGenMCCodeEmitter.inc"
Index: llvm/lib/Target/RISCV/RISCVInstrFormatsV.td
===================================================================
--- llvm/lib/Target/RISCV/RISCVInstrFormatsV.td
+++ llvm/lib/Target/RISCV/RISCVInstrFormatsV.td
@@ -90,12 +90,13 @@
   let TSFlags{5} = InstVectorNoMask.Value;
 }
 
-class RVInstVV<bits<6> funct6, RISCVVFormat opv, bit vm, dag outs, dag ins,
+class RVInstVV<bits<6> funct6, RISCVVFormat opv, dag outs, dag ins,
                string opcodestr, string argstr>
     : RVInst<outs, ins, opcodestr, argstr, [], InstFormatR> {
   bits<5> vs2;
   bits<5> vs1;
   bits<5> vd;
+  bits<1> vm;
 
   let Inst{31-26} = funct6;
   let Inst{25} = vm;
@@ -108,12 +109,13 @@
   let TSFlags{5} = InstVectorWithMask.Value;
 }
 
-class RVInstVX<bits<6> funct6, RISCVVFormat opv, bit vm, dag outs, dag ins,
+class RVInstVX<bits<6> funct6, RISCVVFormat opv, dag outs, dag ins,
                 string opcodestr, string argstr>
     : RVInst<outs, ins, opcodestr, argstr, [], InstFormatR> {
   bits<5> vs2;
   bits<5> rs1;
   bits<5> vd;
+  bits<1> vm;
 
   let Inst{31-26} = funct6;
   let Inst{25} = vm;
@@ -126,11 +128,12 @@
   let TSFlags{5} = InstVectorWithMask.Value;
 }
 
-class RVInstV2<bits<6> funct6, bits<5> vs2, RISCVVFormat opv, bit vm, dag outs, dag ins,
+class RVInstV2<bits<6> funct6, bits<5> vs2, RISCVVFormat opv, dag outs, dag ins,
                 string opcodestr, string argstr>
     : RVInst<outs, ins, opcodestr, argstr, [], InstFormatR> {
   bits<5> rs1;
   bits<5> vd;
+  bits<1> vm;
 
   let Inst{31-26} = funct6;
   let Inst{25} = vm;
@@ -143,12 +146,13 @@
   let TSFlags{5} = InstVectorWithMask.Value;
 }
 
-class RVInstIVI<bits<6> funct6, bit vm, dag outs, dag ins, string opcodestr,
+class RVInstIVI<bits<6> funct6, dag outs, dag ins, string opcodestr,
                 string argstr>
     : RVInst<outs, ins, opcodestr, argstr, [], InstFormatR> {
   bits<5> vs2;
   bits<5> imm;
   bits<5> vd;
+  bits<1> vm;
 
   let Inst{31-26} = funct6;
   let Inst{25} = vm;
@@ -161,11 +165,12 @@
   let TSFlags{5} = InstVectorWithMask.Value;
 }
 
-class RVInstV<bits<6> funct6, bits<5> vs1, RISCVVFormat opv, bit vm, dag outs,
+class RVInstV<bits<6> funct6, bits<5> vs1, RISCVVFormat opv, dag outs,
               dag ins, string opcodestr, string argstr>
     : RVInst<outs, ins, opcodestr, argstr, [], InstFormatR> {
   bits<5> vs2;
   bits<5> vd;
+  bits<1> vm;
 
   let Inst{31-26} = funct6;
   let Inst{25} = vm;
@@ -178,12 +183,13 @@
   let TSFlags{5} = InstVectorWithMask.Value;
 }
 
-class RVInstVLU<bits<3> nf, RISCVMOP mop, bit vm, RISCVLSUMOP lumop,
+class RVInstVLU<bits<3> nf, RISCVMOP mop, RISCVLSUMOP lumop,
                 RISCVWidth width, dag outs, dag ins, string opcodestr,
                 string argstr>
     : RVInst<outs, ins, opcodestr, argstr, [], InstFormatR> {
   bits<5> rs1;
   bits<5> vd;
+  bits<1> vm;
 
   let Inst{31-29} = nf;
   let Inst{28-26} = mop.Value;
@@ -197,12 +203,13 @@
   let TSFlags{5} = InstVectorWithMask.Value;
 }
 
-class RVInstVLS<bits<3> nf, RISCVMOP mop, bit vm, RISCVWidth width,
+class RVInstVLS<bits<3> nf, RISCVMOP mop, RISCVWidth width,
                 dag outs, dag ins, string opcodestr, string argstr>
     : RVInst<outs, ins, opcodestr, argstr, [], InstFormatR> {
   bits<5> rs2;
   bits<5> rs1;
   bits<5> vd;
+  bits<1> vm;
 
   let Inst{31-29} = nf;
   let Inst{28-26} = mop.Value;
@@ -216,12 +223,13 @@
   let TSFlags{5} = InstVectorWithMask.Value;
 }
 
-class RVInstVLX<bits<3> nf, RISCVMOP mop, bit vm, RISCVWidth width,
+class RVInstVLX<bits<3> nf, RISCVMOP mop, RISCVWidth width,
                 dag outs, dag ins, string opcodestr, string argstr>
     : RVInst<outs, ins, opcodestr, argstr, [], InstFormatR> {
   bits<5> vs2;
   bits<5> rs1;
   bits<5> vd;
+  bits<1> vm;
 
   let Inst{31-29} = nf;
   let Inst{28-26} = mop.Value;
@@ -235,12 +243,13 @@
   let TSFlags{5} = InstVectorWithMask.Value;
 }
 
-class RVInstVSU<bits<3> nf, RISCVMOP mop, bit vm, RISCVLSUMOP sumop,
+class RVInstVSU<bits<3> nf, RISCVMOP mop, RISCVLSUMOP sumop,
                 RISCVWidth width, dag outs, dag ins, string opcodestr,
                 string argstr>
     : RVInst<outs, ins, opcodestr, argstr, [], InstFormatR> {
   bits<5> rs1;
   bits<5> vs3;
+  bits<1> vm;
 
   let Inst{31-29} = nf;
   let Inst{28-26} = mop.Value;
@@ -254,12 +263,13 @@
   let TSFlags{5} = InstVectorWithMask.Value;
 }
 
-class RVInstVSS<bits<3> nf, RISCVMOP mop, bit vm, RISCVWidth width,
+class RVInstVSS<bits<3> nf, RISCVMOP mop, RISCVWidth width,
                 dag outs, dag ins, string opcodestr, string argstr>
     : RVInst<outs, ins, opcodestr, argstr, [], InstFormatR> {
   bits<5> rs2;
   bits<5> rs1;
   bits<5> vs3;
+  bits<1> vm;
 
   let Inst{31-29} = nf;
   let Inst{28-26} = mop.Value;
@@ -273,12 +283,13 @@
   let TSFlags{5} = InstVectorWithMask.Value;
 }
 
-class RVInstVSX<bits<3> nf, RISCVMOP mop, bit vm, RISCVWidth width,
+class RVInstVSX<bits<3> nf, RISCVMOP mop, RISCVWidth width,
                 dag outs, dag ins, string opcodestr, string argstr>
     : RVInst<outs, ins, opcodestr, argstr, [], InstFormatR> {
   bits<5> vs2;
   bits<5> rs1;
   bits<5> vs3;
+  bits<1> vm;
 
   let Inst{31-29} = nf;
   let Inst{28-26} = mop.Value;
Index: llvm/lib/Target/RISCV/RISCVInstrInfoV.td
===================================================================
--- llvm/lib/Target/RISCV/RISCVInstrInfoV.td
+++ llvm/lib/Target/RISCV/RISCVInstrInfoV.td
@@ -46,11 +46,14 @@
   let RenderMethod = "addRegOperands";
   let PredicateMethod = "isReg";
   let ParserMethod = "parseMaskRegister";
+  let IsOptional = 1;
+  let DefaultMethod = "defaultRVVMask";
 }
 
 def VPRMaskRegOp: RegisterOperand<VPRV0> {
   let ParserMatchClass = VPRMaskAsmOperand;
   let PrintMethod = "printVPRMaskOp";
+  let EncoderMethod = "getVPRMaskOp";
 }
 
 def simm5 : Operand<XLenVT>, ImmLeaf<XLenVT, [{return isInt<5>(Imm);}]> {
@@ -70,195 +73,121 @@
 //===----------------------------------------------------------------------===//
 
 let hasSideEffects = 0, mayLoad = 1, mayStore = 0 in {
-// load vd, (rs1) (without mask)
-class VUnitStrideLoad<RISCVMOP mop, RISCVLSUMOP lumop, RISCVWidth width,
-                      string opcodestr>
-    : RVInstVLU<0b000, mop, 1, lumop, width, (outs VPRRegOp:$vd),
-                (ins GPR:$rs1), opcodestr, "$vd, (${rs1})">;
-
 // load vd, (rs1), vm (with mask)
 class VUnitStrideLoad_t<RISCVMOP mop, RISCVLSUMOP lumop, RISCVWidth width,
                         string opcodestr>
-    : RVInstVLU<0b000, mop, 0, lumop, width, (outs VPRRegOp:$vd),
-                (ins GPR:$rs1, VPRMaskRegOp:$vm), opcodestr, "$vd, (${rs1}), $vm">;
-
-// load vd, (rs1), rs2 (without mask)
-class VStridedLoad<RISCVMOP mop, RISCVWidth width, string opcodestr>
-    : RVInstVLS<0b000, mop, 1, width, (outs VPRRegOp:$vd),
-                (ins GPR:$rs1, GPR:$rs2), opcodestr, "$vd, (${rs1}), $rs2">;
+    : RVInstVLU<0b000, mop, lumop, width, (outs VPRRegOp:$vd),
+                (ins GPR:$rs1, VPRMaskRegOp:$vm), opcodestr, "$vd, (${rs1})${vm}">;
 
 // load vd, (rs1), rs2, vm (with mask)
 class VStridedLoad_t<RISCVMOP mop, RISCVWidth width, string opcodestr>
-    : RVInstVLS<0b000, mop, 0, width, (outs VPRRegOp:$vd),
+    : RVInstVLS<0b000, mop, width, (outs VPRRegOp:$vd),
                 (ins GPR:$rs1, GPR:$rs2, VPRMaskRegOp:$vm), opcodestr,
-                "$vd, (${rs1}), $rs2, $vm">;
-
-// load vd, (rs1), vs2 (without mask)
-class VIndexedLoad<RISCVMOP mop, RISCVWidth width, string opcodestr>
-    : RVInstVLX<0b000, mop, 1, width, (outs VPRRegOp:$vd),
-                (ins GPR:$rs1, VPRRegOp:$vs2), opcodestr,
-                "$vd, (${rs1}), $vs2">;
+                "$vd, (${rs1}), $rs2${vm}">;
 
 // load vd, (rs1), vs2, vm (with mask)
 class VIndexedLoad_t<RISCVMOP mop, RISCVWidth width, string opcodestr>
-    : RVInstVLX<0b000, mop, 0, width, (outs VPRRegOp:$vd),
+    : RVInstVLX<0b000, mop, width, (outs VPRRegOp:$vd),
                 (ins GPR:$rs1, VPRRegOp:$vs2, VPRMaskRegOp:$vm), opcodestr,
-                "$vd, (${rs1}), $vs2, $vm">;
+                "$vd, (${rs1}), $vs2${vm}">;
 }
 
 let hasSideEffects = 0, mayLoad = 0, mayStore = 1 in {
-// store vd, vs3, (rs1) (without mask)
-class VUnitStrideStore<RISCVMOP mop, RISCVLSUMOP sumop, RISCVWidth width,
-                       string opcodestr>
-    : RVInstVSU<0b000, mop, 1, sumop, width, (outs),
-                (ins VPRRegOp:$vs3, GPR:$rs1), opcodestr, "$vs3, (${rs1})">;
-
 // store vd, vs3, (rs1), vm (with mask)
 class VUnitStrideStore_t<RISCVMOP mop, RISCVLSUMOP sumop, RISCVWidth width,
                          string opcodestr>
-    : RVInstVSU<0b000, mop, 0, sumop, width, (outs),
+    : RVInstVSU<0b000, mop, sumop, width, (outs),
                 (ins VPRRegOp:$vs3, GPR:$rs1, VPRMaskRegOp:$vm), opcodestr,
-                "$vs3, (${rs1}), $vm">;
-
-// store vd, vs3, (rs1), rs2 (without mask)
-class VStridedStore<RISCVMOP mop, RISCVWidth width, string opcodestr>
-    : RVInstVSS<0b000, mop, 1, width, (outs),
-                (ins VPRRegOp:$vs3, GPR:$rs1, GPR:$rs2), opcodestr,
-                "$vs3, (${rs1}), $rs2">;
+                "$vs3, (${rs1})${vm}">;
 
 // store vd, vs3, (rs1), rs2, vm (with mask)
 class VStridedStore_t<RISCVMOP mop, RISCVWidth width, string opcodestr>
-    : RVInstVSS<0b000, mop, 0, width, (outs),
+    : RVInstVSS<0b000, mop, width, (outs),
                 (ins VPRRegOp:$vs3, GPR:$rs1, GPR:$rs2, VPRMaskRegOp:$vm),
-                opcodestr, "$vs3, (${rs1}), $rs2, $vm">;
-
-// store vd, vs3, (rs1), vs2 (without mask)
-class VIndexedStore<RISCVMOP mop, RISCVWidth width, string opcodestr>
-    : RVInstVSX<0b000, mop, 1, width, (outs),
-                (ins VPRRegOp:$vs3, GPR:$rs1, VPRRegOp:$vs2), opcodestr,
-                "$vs3, (${rs1}), $vs2">;
+                opcodestr, "$vs3, (${rs1}), $rs2${vm}">;
 
 // store vd, vs3, (rs1), vs2, vm (with mask)
 class VIndexedStore_t<RISCVMOP mop, RISCVWidth width, string opcodestr>
-    : RVInstVSX<0b000, mop, 0, width, (outs),
+    : RVInstVSX<0b000, mop, width, (outs),
                 (ins VPRRegOp:$vs3, GPR:$rs1, VPRRegOp:$vs2, VPRMaskRegOp:$vm),
-                opcodestr, "$vs3, (${rs1}), $vs2, $vm">;
+                opcodestr, "$vs3, (${rs1}), $vs2${vm}">;
 }
 
 let hasSideEffects = 0, mayLoad = 0, mayStore = 0 in {
 // op vd, vs2, vs1 (without mask)
+let vm = 1 in
 class VALUVV<bits<6> funct6, RISCVVFormat opv, string opcodestr>
-    : RVInstVV<funct6, opv, 1, (outs VPRRegOp:$vd),
+    : RVInstVV<funct6, opv, (outs VPRRegOp:$vd),
                (ins VPRRegOp:$vs2, VPRRegOp:$vs1),
                opcodestr, "$vd, $vs2, $vs1">;
 
 // op vd, vs2, vs1, vm (with mask)
 class VALUVV_t<bits<6> funct6, RISCVVFormat opv, string opcodestr>
-    : RVInstVV<funct6, opv, 0, (outs VPRRegOp:$vd),
+    : RVInstVV<funct6, opv, (outs VPRRegOp:$vd),
                 (ins VPRRegOp:$vs2, VPRRegOp:$vs1, VPRMaskRegOp:$vm),
-                opcodestr, "$vd, $vs2, $vs1, $vm">;
+                opcodestr, "$vd, $vs2, $vs1${vm}">;
 
 // op vd, vs2, vs1, v0 (without mask, use v0 as carry input)
+let vm = 1 in
 class VALUmVV<bits<6> funct6, RISCVVFormat opv, string opcodestr>
-    : RVInstVV<funct6, opv, 1, (outs VPRRegOp:$vd),
+    : RVInstVV<funct6, opv, (outs VPRRegOp:$vd),
                 (ins VPRRegOp:$vs2, VPRRegOp:$vs1, VPRV0:$v0),
                 opcodestr, "$vd, $vs2, $vs1, v0">;
 
-// op vd, vs1, vs2 (without mask, reverse the order of vs1 and vs2)
-class VALUrVV<bits<6> funct6, RISCVVFormat opv, string opcodestr>
-    : RVInstVV<funct6, opv, 1, (outs VPRRegOp:$vd),
-               (ins VPRRegOp:$vs1, VPRRegOp:$vs2),
-               opcodestr, "$vd, $vs1, $vs2">;
-
 // op vd, vs1, vs2, vm (with mask, reverse the order of vs1 and vs2)
 class VALUrVV_t<bits<6> funct6, RISCVVFormat opv, string opcodestr>
-    : RVInstVV<funct6, opv, 0, (outs VPRRegOp:$vd),
+    : RVInstVV<funct6, opv, (outs VPRRegOp:$vd),
                 (ins VPRRegOp:$vs1, VPRRegOp:$vs2, VPRMaskRegOp:$vm),
-                opcodestr, "$vd, $vs1, $vs2, $vm">;
-
-// op vd, vs2, rs1 (without mask)
-class VALUVX<bits<6> funct6, RISCVVFormat opv, string opcodestr>
-    : RVInstVX<funct6, opv, 1, (outs VPRRegOp:$vd),
-                (ins VPRRegOp:$vs2, GPR:$rs1),
-                opcodestr, "$vd, $vs2, $rs1">;
+                opcodestr, "$vd, $vs1, $vs2${vm}">;
 
 // op vd, vs2, rs1, vm (with mask)
 class VALUVX_t<bits<6> funct6, RISCVVFormat opv, string opcodestr>
-    : RVInstVX<funct6, opv, 0, (outs VPRRegOp:$vd),
+    : RVInstVX<funct6, opv, (outs VPRRegOp:$vd),
                 (ins VPRRegOp:$vs2, GPR:$rs1, VPRMaskRegOp:$vm),
-                opcodestr, "$vd, $vs2, $rs1, $vm">;
+                opcodestr, "$vd, $vs2, $rs1${vm}">;
 
 // op vd, vs2, rs1, v0 (without mask, use v0 as carry input)
+let vm = 1 in
 class VALUmVX<bits<6> funct6, RISCVVFormat opv, string opcodestr>
-    : RVInstVX<funct6, opv, 1, (outs VPRRegOp:$vd),
+    : RVInstVX<funct6, opv, (outs VPRRegOp:$vd),
                 (ins VPRRegOp:$vs2, GPR:$rs1, VPRV0:$v0),
                 opcodestr, "$vd, $vs2, $rs1, v0">;
 
-// op vd, rs1, vs2 (without mask, reverse the order of rs1 and vs2)
-class VALUrVX<bits<6> funct6, RISCVVFormat opv, string opcodestr>
-    : RVInstVX<funct6, opv, 1, (outs VPRRegOp:$vd),
-                (ins GPR:$rs1, VPRRegOp:$vs2),
-                opcodestr, "$vd, $rs1, $vs2">;
-
 // op vd, rs1, vs2, vm (with mask, reverse the order of rs1 and vs2)
 class VALUrVX_t<bits<6> funct6, RISCVVFormat opv, string opcodestr>
-    : RVInstVX<funct6, opv, 0, (outs VPRRegOp:$vd),
+    : RVInstVX<funct6, opv, (outs VPRRegOp:$vd),
                 (ins GPR:$rs1, VPRRegOp:$vs2, VPRMaskRegOp:$vm),
-                opcodestr, "$vd, $rs1, $vs2, $vm">;
-
-// op vd, vs2, imm (without mask)
-class VALUVI<bits<6> funct6, string opcodestr, Operand optype = simm5>
-    : RVInstIVI<funct6, 1, (outs VPRRegOp:$vd),
-                (ins VPRRegOp:$vs2, optype:$imm),
-                opcodestr, "$vd, $vs2, $imm">;
+                opcodestr, "$vd, $rs1, $vs2${vm}">;
 
 // op vd, vs2, imm, vm (with mask)
 class VALUVI_t<bits<6> funct6, string opcodestr, Operand optype = simm5>
-    : RVInstIVI<funct6, 0, (outs VPRRegOp:$vd),
+    : RVInstIVI<funct6, (outs VPRRegOp:$vd),
                 (ins VPRRegOp:$vs2, optype:$imm, VPRMaskRegOp:$vm),
-                opcodestr, "$vd, $vs2, $imm, $vm">;
+                opcodestr, "$vd, $vs2, $imm${vm}">;
 
 // op vd, vs2, imm, v0 (without mask, use v0 as carry input)
 class VALUmVI<bits<6> funct6, string opcodestr, Operand optype = simm5>
-    : RVInstIVI<funct6, 1, (outs VPRRegOp:$vd),
+    : RVInstIVI<funct6, (outs VPRRegOp:$vd),
                 (ins VPRRegOp:$vs2, optype:$imm, VPRV0:$v0),
                 opcodestr, "$vd, $vs2, $imm, v0">;
 
-// op vd, vs2, rs1 (Float) (without mask)
-class VALUVF<bits<6> funct6, RISCVVFormat opv, string opcodestr>
-    : RVInstVX<funct6, opv, 1, (outs VPRRegOp:$vd),
-                (ins VPRRegOp:$vs2, FPR32:$rs1),
-                opcodestr, "$vd, $vs2, $rs1">;
-
 // op vd, vs2, rs1, vm (Float) (with mask)
 class VALUVF_t<bits<6> funct6, RISCVVFormat opv, string opcodestr>
-    : RVInstVX<funct6, opv, 0, (outs VPRRegOp:$vd),
+    : RVInstVX<funct6, opv, (outs VPRRegOp:$vd),
                 (ins VPRRegOp:$vs2, FPR32:$rs1, VPRMaskRegOp:$vm),
-                opcodestr, "$vd, $vs2, $rs1, $vm">;
-
-// op vd, rs1, vs2 (Float) (without mask, reverse the order of rs1 and vs2)
-class VALUrVF<bits<6> funct6, RISCVVFormat opv, string opcodestr>
-    : RVInstVX<funct6, opv, 1, (outs VPRRegOp:$vd),
-                (ins FPR32:$rs1, VPRRegOp:$vs2),
-                opcodestr, "$vd, $rs1, $vs2">;
+                opcodestr, "$vd, $vs2, $rs1${vm}">;
 
 // op vd, rs1, vs2 (Float) (with mask, reverse the order of rs1 and vs2)
 class VALUrVF_t<bits<6> funct6, RISCVVFormat opv, string opcodestr>
-    : RVInstVX<funct6, opv, 0, (outs VPRRegOp:$vd),
+    : RVInstVX<funct6, opv, (outs VPRRegOp:$vd),
                 (ins FPR32:$rs1, VPRRegOp:$vs2, VPRMaskRegOp:$vm),
-                opcodestr, "$vd, $rs1, $vs2, $vm">;
-
-// op vd, vs2 (without mask, use vs1 as instruction encoding)
-class VALUVs2<bits<6> funct6, bits<5> vs1, RISCVVFormat opv, string opcodestr>
-    : RVInstV<funct6, vs1, opv, 1, (outs VPRRegOp:$vd),
-               (ins VPRRegOp:$vs2),
-               opcodestr, "$vd, $vs2">;
+                opcodestr, "$vd, $rs1, $vs2${vm}">;
 
 // op vd, vs2, vm (with mask, use vs1 as instruction encoding)
 class VALUVs2_t<bits<6> funct6, bits<5> vs1, RISCVVFormat opv, string opcodestr>
-    : RVInstV<funct6, vs1, opv, 0, (outs VPRRegOp:$vd),
+    : RVInstV<funct6, vs1, opv, (outs VPRRegOp:$vd),
                (ins VPRRegOp:$vs2, VPRMaskRegOp:$vm),
-               opcodestr, "$vd, $vs2, $vm">;
+               opcodestr, "$vd, $vs2${vm}">;
 }
 
 //===----------------------------------------------------------------------===//
@@ -267,75 +196,61 @@
 //===----------------------------------------------------------------------===//
 
 multiclass VALUVV_Mask<bits<6> funct6, RISCVVFormat opv, string opcodestr> {
-  def "": VALUVV<funct6, opv, opcodestr>;
-  def _T : VALUVV_t<funct6, opv, opcodestr>;
+  def "" : VALUVV_t<funct6, opv, opcodestr>;
 }
 
 multiclass VALUrVV_Mask<bits<6> funct6, RISCVVFormat opv, string opcodestr> {
-  def "": VALUrVV<funct6, opv, opcodestr>;
-  def _T : VALUrVV_t<funct6, opv, opcodestr>;
+  def "" : VALUrVV_t<funct6, opv, opcodestr>;
 }
 
 multiclass VALUVX_Mask<bits<6> funct6, RISCVVFormat opv, string opcodestr> {
-  def "": VALUVX<funct6, opv, opcodestr>;
-  def _T : VALUVX_t<funct6, opv, opcodestr>;
+  def "" : VALUVX_t<funct6, opv, opcodestr>;
 }
 
 multiclass VALUrVX_Mask<bits<6> funct6, RISCVVFormat opv, string opcodestr> {
-  def "": VALUrVX<funct6, opv, opcodestr>;
-  def _T : VALUrVX_t<funct6, opv, opcodestr>;
+  def "" : VALUrVX_t<funct6, opv, opcodestr>;
 }
 
 multiclass VALUVI_Mask<bits<6> funct6, string opcodestr, Operand optype = simm5> {
-  def "": VALUVI<funct6, opcodestr, optype>;
-  def _T : VALUVI_t<funct6, opcodestr, optype>;
+  def "" : VALUVI_t<funct6, opcodestr, optype>;
 }
 
 multiclass VALUVF_Mask<bits<6> funct6, RISCVVFormat opv, string opcodestr> {
-  def "": VALUVF<funct6, opv, opcodestr>;
-  def _T : VALUVF_t<funct6, opv, opcodestr>;
+  def "" : VALUVF_t<funct6, opv, opcodestr>;
 }
 
 multiclass VALUrVF_Mask<bits<6> funct6, RISCVVFormat opv, string opcodestr> {
-  def "": VALUrVF<funct6, opv, opcodestr>;
-  def _T : VALUrVF_t<funct6, opv, opcodestr>;
+  def "" : VALUrVF_t<funct6, opv, opcodestr>;
 }
 
 multiclass VALUVs2_Mask<bits<6> funct6, bits<5> vs1, RISCVVFormat opv, string opcodestr> {
-  def "": VALUVs2<funct6, vs1, opv, opcodestr>;
-  def _T : VALUVs2_t<funct6, vs1, opv, opcodestr>;
+  def "" : VALUVs2_t<funct6, vs1, opv, opcodestr>;
 }
 
 multiclass VUnitStrideLoadMask<RISCVMOP mop, RISCVLSUMOP lumop, RISCVWidth width,
                                string opcodestr> {
-  def "": VUnitStrideLoad<mop, lumop, width, opcodestr>;
-  def _T : VUnitStrideLoad_t<mop, lumop, width, opcodestr>;
+  def "" : VUnitStrideLoad_t<mop, lumop, width, opcodestr>;
 }
 
 multiclass VStridedLoadMask<RISCVMOP mop, RISCVWidth width, string opcodestr> {
-  def "": VStridedLoad<mop, width, opcodestr>;
-  def _T : VStridedLoad_t<mop, width, opcodestr>;
+  def "" : VStridedLoad_t<mop, width, opcodestr>;
 }
 
 multiclass VIndexedLoadMask<RISCVMOP mop, RISCVWidth width, string opcodestr> {
-  def "": VIndexedLoad<mop, width, opcodestr>;
-  def _T : VIndexedLoad_t<mop, width, opcodestr>;
+  def "" : VIndexedLoad_t<mop, width, opcodestr>;
 }
 
 multiclass VUnitStrideStoreMask<RISCVMOP mop, RISCVLSUMOP sumop, RISCVWidth width,
                                 string opcodestr> {
-  def "": VUnitStrideStore<mop, sumop, width, opcodestr>;
-  def _T : VUnitStrideStore_t<mop, sumop, width, opcodestr>;
+  def "" : VUnitStrideStore_t<mop, sumop, width, opcodestr>;
 }
 
 multiclass VStridedStoreMask<RISCVMOP mop, RISCVWidth width, string opcodestr> {
-  def "": VStridedStore<mop, width, opcodestr>;
-  def _T : VStridedStore_t<mop, width, opcodestr>;
+  def "" : VStridedStore_t<mop, width, opcodestr>;
 }
 
 multiclass VIndexedStoreMask<RISCVMOP mop, RISCVWidth width, string opcodestr> {
-  def "": VIndexedStore<mop, width, opcodestr>;
-  def _T : VIndexedStore_t<mop, width, opcodestr>;
+  def "" : VIndexedStore_t<mop, width, opcodestr>;
 }
 
 multiclass VALU_IV_V_X_I<string opcodestr, bits<6> funct6, Operand optype = simm5, string vw = "v"> {
@@ -610,18 +525,21 @@
 // Vector Integer Move Instructions
 let hasSideEffects = 0, mayLoad = 0, mayStore = 0 in {
 // op vd, vs1
-def VMV_V_V : RVInstVV<0b010111, OPIVV, 1, (outs VPRRegOp:$vd),
+def VMV_V_V : RVInstVV<0b010111, OPIVV, (outs VPRRegOp:$vd),
                        (ins VPRRegOp:$vs1), "vmv.v.v", "$vd, $vs1"> {
+  let vm = 1;
   let vs2 = 0;
 }
 // op vd, rs1
-def VMV_V_X : RVInstVX<0b010111, OPIVX, 1, (outs VPRRegOp:$vd),
+def VMV_V_X : RVInstVX<0b010111, OPIVX, (outs VPRRegOp:$vd),
                        (ins GPR:$rs1), "vmv.v.x", "$vd, $rs1"> {
+  let vm = 1;
   let vs2 = 0;
 }
 // op vd, imm
-def VMV_V_I : RVInstIVI<0b010111, 1, (outs VPRRegOp:$vd),
+def VMV_V_I : RVInstIVI<0b010111, (outs VPRRegOp:$vd),
                        (ins simm5:$imm), "vmv.v.i", "$vd, $imm"> {
+  let vm = 1;
   let vs2 = 0;
 }
 }
@@ -722,13 +640,17 @@
 
 let hasSideEffects = 0, mayLoad = 0, mayStore = 0 in {
 // Vector Floating-Point Merge Instruction
-def VFMERGE_VFM : RVInstVX<0b010111, OPFVF, 0, (outs VPRRegOp:$vd),
+def VFMERGE_VFM : RVInstVX<0b010111, OPFVF, (outs VPRRegOp:$vd),
                            (ins VPRRegOp:$vs2, FPR32:$rs1, VPRV0:$v0),
-                           "vfmerge.vfm", "$vd, $vs2, $rs1, v0">;
+                           "vfmerge.vfm", "$vd, $vs2, $rs1, v0">
+{
+  let vm = 0;
+}
 
 // Vector Floating-Point Move Instruction
-def VFMV_V_F : RVInstVX<0b010111, OPFVF, 1, (outs VPRRegOp:$vd),
+def VFMV_V_F : RVInstVX<0b010111, OPFVF, (outs VPRRegOp:$vd),
                        (ins FPR32:$rs1), "vfmv.v.f", "$vd, $rs1"> {
+  let vm = 1;
   let vs2 = 0;
 }
 }
@@ -792,18 +714,14 @@
 
 let hasSideEffects = 0, mayLoad = 0, mayStore = 0 in {
 // Vector mask population count vpopc
-def VPOPC_M : RVInstV<0b010000, 0b10000, OPMVV, 1, (outs GPR:$vd),
-                      (ins VPRRegOp:$vs2), "vpopc.m", "$vd, $vs2">;
-def VPOPC_M_T : RVInstV<0b010000, 0b10000, OPMVV, 0, (outs GPR:$vd),
+def VPOPC_M : RVInstV<0b010000, 0b10000, OPMVV, (outs GPR:$vd),
                         (ins VPRRegOp:$vs2, VPRMaskRegOp:$vm),
-                        "vpopc.m", "$vd, $vs2, $vm">;
+                        "vpopc.m", "$vd, $vs2${vm}">;
 
 // vfirst find-first-set mask bit
-def VFIRST_M : RVInstV<0b010000, 0b10001, OPMVV, 1, (outs GPR:$vd),
-                      (ins VPRRegOp:$vs2), "vfirst.m", "$vd, $vs2">;
-def VFIRST_M_T : RVInstV<0b010000, 0b10001, OPMVV, 0, (outs GPR:$vd),
+def VFIRST_M : RVInstV<0b010000, 0b10001, OPMVV, (outs GPR:$vd),
                         (ins VPRRegOp:$vs2, VPRMaskRegOp:$vm),
-                        "vfirst.m", "$vd, $vs2, $vm">;
+                        "vfirst.m", "$vd, $vs2${vm}">;
 }
 
 // vmsbf.m set-before-first mask bit
@@ -822,27 +740,35 @@
 
 // Vector Element Index Instruction
 let hasSideEffects = 0, mayLoad = 0, mayStore = 0 in {
-def VID_V : RVInstV<0b010100, 0b10001, OPMVV, 1, (outs VPRRegOp:$vd),
-                    (ins), "vid.v", "$vd"> {
-  let vs2 = 0;
-}
 
-def VID_V_T : RVInstV<0b010100, 0b10001, OPMVV, 0, (outs VPRRegOp:$vd),
-                      (ins VPRMaskRegOp:$vm), "vid.v", "$vd, $vm"> {
+def VID_V : RVInstV<0b010100, 0b10001, OPMVV, (outs VPRRegOp:$vd),
+                      (ins VPRMaskRegOp:$vm), "vid.v", "$vd${vm}"> {
   let vs2 = 0;
 }
 
 // Integer Scalar Move Instructions
-def VMV_X_S : RVInstV<0b010000, 0b00000, OPMVV, 1, (outs GPR:$vd),
-                      (ins VPRRegOp:$vs2), "vmv.x.s", "$vd, $vs2">;
-def VMV_S_X : RVInstV2<0b010000, 0b00000, OPMVX, 1, (outs VPRRegOp:$vd),
-                      (ins GPR:$rs1), "vmv.s.x", "$vd, $rs1">;
+def VMV_X_S : RVInstV<0b010000, 0b00000, OPMVV, (outs GPR:$vd),
+                      (ins VPRRegOp:$vs2), "vmv.x.s", "$vd, $vs2">
+{
+  let vm = 1;
+}
+def VMV_S_X : RVInstV2<0b010000, 0b00000, OPMVX, (outs VPRRegOp:$vd),
+                      (ins GPR:$rs1), "vmv.s.x", "$vd, $rs1">
+{
+  let vm = 1;
+}
 
 // Floating-Point Scalar Move Instructions
-def VFMV_F_S : RVInstV<0b010000, 0b00000, OPFVV, 1, (outs FPR32:$vd),
-                      (ins VPRRegOp:$vs2), "vfmv.f.s", "$vd, $vs2">;
-def VFMV_S_F : RVInstV2<0b010000, 0b00000, OPFVF, 1, (outs VPRRegOp:$vd),
-                      (ins FPR32:$rs1), "vfmv.s.f", "$vd, $rs1">;
+def VFMV_F_S : RVInstV<0b010000, 0b00000, OPFVV, (outs FPR32:$vd),
+                      (ins VPRRegOp:$vs2), "vfmv.f.s", "$vd, $vs2">
+{
+  let vm = 1;
+}
+def VFMV_S_F : RVInstV2<0b010000, 0b00000, OPFVF, (outs VPRRegOp:$vd),
+                      (ins FPR32:$rs1), "vfmv.s.f", "$vd, $rs1">
+{
+  let vm = 1;
+}
 }
 
 // Vector Slide Instructions