[RISCV] add the MC layer support of riscv vector Zvamo extension

Implements the assemble and disassemble support of RISCV Vector
extension zvamo instructions, base on the 0.9 spec version.

Reviewed  by HsiangKai

Differential Revision: https://reviews.llvm.org/D85069

lib/Target/RISCV/RISCV.td

@@ -162,6 +162,13 @@ def FeatureStdExtZvlsseg
 def HasStdExtZvlsseg : Predicate<"Subtarget->hasStdExtZvlsseg()">,
                         AssemblerPredicate<(all_of FeatureStdExtZvlsseg),
                         "'Zvlsseg' (Vector segment load/store instructions)">;
+def FeatureExtZvamo
+    : SubtargetFeature<"experimental-zvamo", "HasStdExtZvamo", "true",
+                       "'Zvamo'(Vector AMO Operations)",
+                       [FeatureStdExtV]>;
+def HasStdExtZvamo : Predicate<"Subtarget->hasStdExtZvamo()">,
+                              AssemblerPredicate<(all_of FeatureExtZvamo),
+                              "'Zvamo'(Vector AMO Operations)">;
 
 def Feature64Bit
     : SubtargetFeature<"64bit", "HasRV64", "true", "Implements RV64">;

lib/Target/RISCV/RISCVInstrFormatsV.td

@@ -42,6 +42,19 @@ def LUMOPUnitStrideFF: RISCVLSUMOP<0b10000>;
 def SUMOPUnitStride  : RISCVLSUMOP<0b00000>;
 def SUMOPUnitStrideWholeReg : RISCVLSUMOP<0b01000>;
 
+class RISCVAMOOP<bits<5> val> {
+  bits<5> Value = val;
+}
+def AMOOPVamoSwap : RISCVAMOOP<0b00001>;
+def AMOOPVamoAdd : RISCVAMOOP<0b00000>;
+def AMOOPVamoXor : RISCVAMOOP<0b00100>;
+def AMOOPVamoAnd : RISCVAMOOP<0b01100>;
+def AMOOPVamoOr : RISCVAMOOP<0b01000>;
+def AMOOPVamoMin : RISCVAMOOP<0b10000>;
+def AMOOPVamoMax : RISCVAMOOP<0b10100>;
+def AMOOPVamoMinu : RISCVAMOOP<0b11000>;
+def AMOOPVamoMaxu : RISCVAMOOP<0b11100>;
+
 class RISCVWidth<bits<4> val> {
   bits<4> Value = val;
 }
@@ -313,3 +326,22 @@ class RVInstVSX<bits<3> nf, bit mew, RISCVMOP mop, bits<3> width,
 
   let Uses = [VTYPE, VL];
 }
+
+class RVInstVAMO<RISCVAMOOP amoop, bits<3> width, dag outs, 
+                 dag ins, string opcodestr, string argstr>
+    : RVInst<outs, ins, opcodestr, argstr, [], InstFormatR> {
+  bits<5> vs2;
+  bits<5> rs1;
+  bit wd;
+  bit vm;
+
+  let Inst{31-27} = amoop.Value;
+  let Inst{26} = wd;
+  let Inst{25} = vm;
+  let Inst{24-20} = vs2;
+  let Inst{19-15} = rs1;
+  let Inst{14-12} = width;
+  let Opcode = OPC_AMO.Value;
+
+  let Uses = [VTYPE, VL];
+}

lib/Target/RISCV/RISCVInstrInfoV.td

@@ -293,6 +293,29 @@ class VALUVs2<bits<6> funct6, bits<5> vs1, RISCVVFormat opv, string opcodestr>
                opcodestr, "$vd, $vs2$vm">;
 } // hasSideEffects = 0, mayLoad = 0, mayStore = 0
 
+let hasSideEffects = 0, mayLoad = 1, mayStore = 1 in {
+// vamo vd, (rs1), vs2, vd, vm
+class VAMOWd<RISCVAMOOP amoop, RISCVWidth width, string opcodestr>
+    : RVInstVAMO<amoop, width.Value{2-0}, (outs VRegOp:$vd_wd),
+            (ins GPR:$rs1, VRegOp:$vs2, VRegOp:$vd, VMaskOp:$vm),
+            opcodestr, "$vd_wd, (${rs1}), $vs2, $vd$vm"> {
+    let Constraints = "$vd_wd = $vd";
+    let wd = 1;
+    bits<5> vd;
+    let Inst{11-7} = vd;
+}
+
+// vamo x0, (rs1), vs2, vs3, vm
+class VAMONoWd<RISCVAMOOP amoop, RISCVWidth width, string opcodestr>
+    : RVInstVAMO<amoop, width.Value{2-0}, (outs),
+            (ins GPR:$rs1, VRegOp:$vs2, VRegOp:$vs3, VMaskOp:$vm),
+            opcodestr, "x0, (${rs1}), $vs2, $vs3$vm"> {
+    bits<5> vs3;
+    let Inst{11-7} = vs3;
+}
+
+} // hasSideEffects = 0, mayLoad = 1, mayStore = 1
+
 //===----------------------------------------------------------------------===//
 // Combination of instruction classes.
 // Use these multiclasses to define instructions more easily.
@@ -400,6 +423,11 @@ multiclass VALU_FV_VS2<string opcodestr, bits<6> funct6, bits<5> vs1> {
   def "" : VALUVs2<funct6, vs1, OPFVV, opcodestr>;
 }
 
+multiclass VAMO<RISCVAMOOP amoop, RISCVWidth width, string opcodestr> {
+  def _WD : VAMOWd<amoop, width, opcodestr>;
+  def _UNWD : VAMONoWd<amoop, width, opcodestr>;
+}
+
 //===----------------------------------------------------------------------===//
 // Instructions
 //===----------------------------------------------------------------------===//
@@ -1021,3 +1049,53 @@ let Predicates = [HasStdExtZvlsseg] in {
     def VSXSEG#nf#EI1024_V : VIndexedSegmentStore<!add(nf, -1), LSWidth1024, "vsxseg"#nf#"ei1024.v">;
   }
 } // Predicates = [HasStdExtZvlsseg]
+
+let Predicates = [HasStdExtZvamo, HasStdExtA] in {
+  defm VAMOSWAPEI8 : VAMO<AMOOPVamoSwap, LSWidth8, "vamoswapei8.v">;
+  defm VAMOSWAPEI16 : VAMO<AMOOPVamoSwap, LSWidth16, "vamoswapei16.v">;
+  defm VAMOSWAPEI32 : VAMO<AMOOPVamoSwap, LSWidth32, "vamoswapei32.v">;
+
+  defm VAMOADDEI8 : VAMO<AMOOPVamoAdd, LSWidth8, "vamoaddei8.v">;
+  defm VAMOADDEI16 : VAMO<AMOOPVamoAdd, LSWidth16, "vamoaddei16.v">;
+  defm VAMOADDEI32 : VAMO<AMOOPVamoAdd, LSWidth32, "vamoaddei32.v">;
+
+  defm VAMOXOREI8 : VAMO<AMOOPVamoXor, LSWidth8, "vamoxorei8.v">;
+  defm VAMOXOREI16 : VAMO<AMOOPVamoXor, LSWidth16, "vamoxorei16.v">;
+  defm VAMOXOREI32 : VAMO<AMOOPVamoXor, LSWidth32, "vamoxorei32.v">;
+
+  defm VAMOANDEI8 : VAMO<AMOOPVamoAnd, LSWidth8, "vamoandei8.v">;
+  defm VAMOANDEI16 : VAMO<AMOOPVamoAnd, LSWidth16, "vamoandei16.v">;
+  defm VAMOANDEI32 : VAMO<AMOOPVamoAnd, LSWidth32, "vamoandei32.v">;
+
+  defm VAMOOREI8 : VAMO<AMOOPVamoOr, LSWidth8, "vamoorei8.v">;
+  defm VAMOOREI16 : VAMO<AMOOPVamoOr, LSWidth16, "vamoorei16.v">;
+  defm VAMOOREI32 : VAMO<AMOOPVamoOr, LSWidth32, "vamoorei32.v">;
+
+  defm VAMOMINEI8 : VAMO<AMOOPVamoMin, LSWidth8, "vamominei8.v">;
+  defm VAMOMINEI16 : VAMO<AMOOPVamoMin, LSWidth16, "vamominei16.v">;
+  defm VAMOMINEI32 : VAMO<AMOOPVamoMin, LSWidth32, "vamominei32.v">;
+
+  defm VAMOMAXEI8 : VAMO<AMOOPVamoMax, LSWidth8, "vamomaxei8.v">;
+  defm VAMOMAXEI16 : VAMO<AMOOPVamoMax, LSWidth16, "vamomaxei16.v">;
+  defm VAMOMAXEI32 : VAMO<AMOOPVamoMax, LSWidth32, "vamomaxei32.v">;
+
+  defm VAMOMINUEI8 : VAMO<AMOOPVamoMinu, LSWidth8, "vamominuei8.v">;
+  defm VAMOMINUEI16 : VAMO<AMOOPVamoMinu, LSWidth16, "vamominuei16.v">;
+  defm VAMOMINUEI32 : VAMO<AMOOPVamoMinu, LSWidth32, "vamominuei32.v">;
+
+  defm VAMOMAXUEI8 : VAMO<AMOOPVamoMaxu, LSWidth8, "vamomaxuei8.v">;
+  defm VAMOMAXUEI16 : VAMO<AMOOPVamoMaxu, LSWidth16, "vamomaxuei16.v">;
+  defm VAMOMAXUEI32 : VAMO<AMOOPVamoMaxu, LSWidth32, "vamomaxuei32.v">;
+} // Predicates = [HasStdExtZvamo, HasStdExtA]
+
+let Predicates = [HasStdExtZvamo, HasStdExtA, IsRV64] in {
+  defm VAMOSWAPEI64 : VAMO<AMOOPVamoSwap, LSWidth64, "vamoswapei64.v">;
+  defm VAMOADDEI64 : VAMO<AMOOPVamoAdd, LSWidth64, "vamoaddei64.v">;
+  defm VAMOXOREI64 : VAMO<AMOOPVamoXor, LSWidth64, "vamoxorei64.v">;
+  defm VAMOANDEI64 : VAMO<AMOOPVamoAnd, LSWidth64, "vamoandei64.v">;
+  defm VAMOOREI64 : VAMO<AMOOPVamoOr, LSWidth64, "vamoorei64.v">;
+  defm VAMOMINEI64 : VAMO<AMOOPVamoMin, LSWidth64, "vamominei64.v">;
+  defm VAMOMAXEI64 : VAMO<AMOOPVamoMax, LSWidth64, "vamomaxei64.v">;
+  defm VAMOMINUEI64 : VAMO<AMOOPVamoMinu, LSWidth64, "vamominuei64.v">;
+  defm VAMOMAXUEI64 : VAMO<AMOOPVamoMaxu, LSWidth64, "vamomaxuei64.v">;
+} // Predicates = [HasStdExtZvamo, HasStdExtA, IsRV64]

lib/Target/RISCV/RISCVSchedRocket32.td

@@ -17,7 +17,7 @@ def Rocket32Model : SchedMachineModel {
   let LoadLatency = 3;
   let MispredictPenalty = 3;
   let CompleteModel = 1;
-  let UnsupportedFeatures = [HasStdExtV, HasStdExtZvlsseg];
+  let UnsupportedFeatures = [HasStdExtV, HasStdExtZvlsseg, HasStdExtZvamo];
 }
 
 //===----------------------------------------------------------------------===//

lib/Target/RISCV/RISCVSchedRocket64.td

@@ -16,7 +16,7 @@ def Rocket64Model : SchedMachineModel {
   let IssueWidth = 1;        // 1 micro-ops are dispatched per cycle.
   let LoadLatency = 3;
   let MispredictPenalty = 3;
-  let UnsupportedFeatures = [HasStdExtV, HasStdExtZvlsseg];
+  let UnsupportedFeatures = [HasStdExtV, HasStdExtZvlsseg, HasStdExtZvamo];
 }
 
 //===----------------------------------------------------------------------===//

lib/Target/RISCV/RISCVSubtarget.h

@@ -52,6 +52,7 @@ class RISCVSubtarget : public RISCVGenSubtargetInfo {
   bool HasStdExtZbproposedc = false;
   bool HasStdExtV = false;
   bool HasStdExtZvlsseg = false;
+  bool HasStdExtZvamo = false;
   bool HasRV64 = false;
   bool IsRV32E = false;
   bool EnableLinkerRelax = false;
@@ -114,6 +115,7 @@ public:
   bool hasStdExtZbproposedc() const { return HasStdExtZbproposedc; }
   bool hasStdExtV() const { return HasStdExtV; }
   bool hasStdExtZvlsseg() const { return HasStdExtZvlsseg; }
+  bool hasStdExtZvamo() const { return HasStdExtZvamo; }
   bool is64Bit() const { return HasRV64; }
   bool isRV32E() const { return IsRV32E; }
   bool enableLinkerRelax() const { return EnableLinkerRelax; }

test/MC/RISCV/rvv/zvamo.s

@@ -0,0 +1,874 @@
+# RUN: llvm-mc -triple=riscv64 -show-encoding --mattr=+a,+experimental-zvamo %s \
+# RUN:        | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
+# RUN: not llvm-mc -triple=riscv64 -show-encoding %s 2>&1 \
+# RUN:        | FileCheck %s --check-prefix=CHECK-ERROR
+# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+a,+experimental-zvamo %s \
+# RUN:        | llvm-objdump -d --mattr=+a,+experimental-zvamo - \
+# RUN:        | FileCheck %s --check-prefix=CHECK-INST
+# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+a,+experimental-zvamo %s \
+# RUN:        | llvm-objdump -d - | FileCheck %s --check-prefix=CHECK-UNKNOWN
+
+
+vamoswapei8.v v8, (a0), v4, v8
+# CHECK-INST: vamoswapei8.v v8, (a0), v4, v8
+# CHECK-ENCODING: [0x2f,0x04,0x45,0x0e]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 04 45 0e <unknown>
+
+vamoswapei16.v v8, (a0), v4, v8
+# CHECK-INST: vamoswapei16.v v8, (a0), v4, v8
+# CHECK-ENCODING: [0x2f,0x54,0x45,0x0e]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 54 45 0e <unknown>
+
+vamoswapei32.v v8, (a0), v4, v8
+# CHECK-INST: vamoswapei32.v v8, (a0), v4, v8
+# CHECK-ENCODING: [0x2f,0x64,0x45,0x0e]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 64 45 0e <unknown>
+
+vamoswapei64.v v8, (a0), v4, v8
+# CHECK-INST: vamoswapei64.v v8, (a0), v4, v8
+# CHECK-ENCODING: [0x2f,0x74,0x45,0x0e]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 74 45 0e <unknown>
+
+vamoswapei8.v v8, (a0), v4, v8, v0.t
+# CHECK-INST: vamoswapei8.v v8, (a0), v4, v8, v0.t
+# CHECK-ENCODING: [0x2f,0x04,0x45,0x0c]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 04 45 0c <unknown>
+
+vamoswapei16.v v8, (a0), v4, v8, v0.t
+# CHECK-INST: vamoswapei16.v v8, (a0), v4, v8, v0.t
+# CHECK-ENCODING: [0x2f,0x54,0x45,0x0c]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 54 45 0c <unknown>
+
+vamoswapei32.v v8, (a0), v4, v8, v0.t
+# CHECK-INST: vamoswapei32.v v8, (a0), v4, v8, v0.t
+# CHECK-ENCODING: [0x2f,0x64,0x45,0x0c]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 64 45 0c <unknown>
+
+vamoswapei64.v v8, (a0), v4, v8, v0.t
+# CHECK-INST: vamoswapei64.v v8, (a0), v4, v8, v0.t
+# CHECK-ENCODING: [0x2f,0x74,0x45,0x0c]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 74 45 0c <unknown>
+
+vamoaddei8.v v8, (a0), v4, v8
+# CHECK-INST: vamoaddei8.v v8, (a0), v4, v8
+# CHECK-ENCODING: [0x2f,0x04,0x45,0x06]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 04 45 06 <unknown>
+
+vamoaddei16.v v8, (a0), v4, v8
+# CHECK-INST: vamoaddei16.v v8, (a0), v4, v8
+# CHECK-ENCODING: [0x2f,0x54,0x45,0x06]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 54 45 06 <unknown>
+
+vamoaddei32.v v8, (a0), v4, v8
+# CHECK-INST: vamoaddei32.v v8, (a0), v4, v8
+# CHECK-ENCODING: [0x2f,0x64,0x45,0x06]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 64 45 06 <unknown>
+
+vamoaddei64.v v8, (a0), v4, v8
+# CHECK-INST: vamoaddei64.v v8, (a0), v4, v8
+# CHECK-ENCODING: [0x2f,0x74,0x45,0x06]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 74 45 06 <unknown>
+
+vamoaddei8.v v8, (a0), v4, v8, v0.t
+# CHECK-INST: vamoaddei8.v v8, (a0), v4, v8, v0.t
+# CHECK-ENCODING: [0x2f,0x04,0x45,0x04]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 04 45 04 <unknown>
+
+vamoaddei16.v v8, (a0), v4, v8, v0.t
+# CHECK-INST: vamoaddei16.v v8, (a0), v4, v8, v0.t
+# CHECK-ENCODING: [0x2f,0x54,0x45,0x04]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 54 45 04 <unknown>
+
+vamoaddei32.v v8, (a0), v4, v8, v0.t
+# CHECK-INST: vamoaddei32.v v8, (a0), v4, v8, v0.t
+# CHECK-ENCODING: [0x2f,0x64,0x45,0x04]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 64 45 04 <unknown>
+
+vamoaddei64.v v8, (a0), v4, v8, v0.t
+# CHECK-INST: vamoaddei64.v v8, (a0), v4, v8, v0.t
+# CHECK-ENCODING: [0x2f,0x74,0x45,0x04]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 74 45 04 <unknown>
+
+vamoxorei8.v v8, (a0), v4, v8
+# CHECK-INST: vamoxorei8.v v8, (a0), v4, v8
+# CHECK-ENCODING: [0x2f,0x04,0x45,0x26]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 04 45 26 <unknown>
+
+vamoxorei16.v v8, (a0), v4, v8
+# CHECK-INST: vamoxorei16.v v8, (a0), v4, v8
+# CHECK-ENCODING: [0x2f,0x54,0x45,0x26]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 54 45 26 <unknown>
+
+vamoxorei32.v v8, (a0), v4, v8
+# CHECK-INST: vamoxorei32.v v8, (a0), v4, v8
+# CHECK-ENCODING: [0x2f,0x64,0x45,0x26]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 64 45 26 <unknown>
+
+vamoxorei64.v v8, (a0), v4, v8
+# CHECK-INST: vamoxorei64.v v8, (a0), v4, v8
+# CHECK-ENCODING: [0x2f,0x74,0x45,0x26]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 74 45 26 <unknown>
+
+vamoxorei8.v v8, (a0), v4, v8, v0.t
+# CHECK-INST: vamoxorei8.v v8, (a0), v4, v8, v0.t
+# CHECK-ENCODING: [0x2f,0x04,0x45,0x24]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 04 45 24 <unknown>
+
+vamoxorei16.v v8, (a0), v4, v8, v0.t
+# CHECK-INST: vamoxorei16.v v8, (a0), v4, v8, v0.t
+# CHECK-ENCODING: [0x2f,0x54,0x45,0x24]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 54 45 24 <unknown>
+
+vamoxorei32.v v8, (a0), v4, v8, v0.t
+# CHECK-INST: vamoxorei32.v v8, (a0), v4, v8, v0.t
+# CHECK-ENCODING: [0x2f,0x64,0x45,0x24]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 64 45 24 <unknown>
+
+vamoxorei64.v v8, (a0), v4, v8, v0.t
+# CHECK-INST: vamoxorei64.v v8, (a0), v4, v8, v0.t
+# CHECK-ENCODING: [0x2f,0x74,0x45,0x24]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 74 45 24 <unknown>
+
+vamoandei8.v v8, (a0), v4, v8
+# CHECK-INST: vamoandei8.v v8, (a0), v4, v8
+# CHECK-ENCODING: [0x2f,0x04,0x45,0x66]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 04 45 66 <unknown>
+
+vamoandei16.v v8, (a0), v4, v8
+# CHECK-INST: vamoandei16.v v8, (a0), v4, v8
+# CHECK-ENCODING: [0x2f,0x54,0x45,0x66]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 54 45 66 <unknown>
+
+vamoandei32.v v8, (a0), v4, v8
+# CHECK-INST: vamoandei32.v v8, (a0), v4, v8
+# CHECK-ENCODING: [0x2f,0x64,0x45,0x66]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 64 45 66 <unknown>
+
+vamoandei64.v v8, (a0), v4, v8
+# CHECK-INST: vamoandei64.v v8, (a0), v4, v8
+# CHECK-ENCODING: [0x2f,0x74,0x45,0x66]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 74 45 66 <unknown>
+
+vamoandei8.v v8, (a0), v4, v8, v0.t
+# CHECK-INST: vamoandei8.v v8, (a0), v4, v8, v0.t
+# CHECK-ENCODING: [0x2f,0x04,0x45,0x64]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 04 45 64 <unknown>
+
+vamoandei16.v v8, (a0), v4, v8, v0.t
+# CHECK-INST: vamoandei16.v v8, (a0), v4, v8, v0.t
+# CHECK-ENCODING: [0x2f,0x54,0x45,0x64]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 54 45 64 <unknown>
+
+vamoandei32.v v8, (a0), v4, v8, v0.t
+# CHECK-INST: vamoandei32.v v8, (a0), v4, v8, v0.t
+# CHECK-ENCODING: [0x2f,0x64,0x45,0x64]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 64 45 64 <unknown>
+
+vamoandei64.v v8, (a0), v4, v8, v0.t
+# CHECK-INST: vamoandei64.v v8, (a0), v4, v8, v0.t
+# CHECK-ENCODING: [0x2f,0x74,0x45,0x64]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 74 45 64 <unknown>
+
+vamoorei8.v v8, (a0), v4, v8
+# CHECK-INST: vamoorei8.v v8, (a0), v4, v8
+# CHECK-ENCODING: [0x2f,0x04,0x45,0x46]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 04 45 46 <unknown>
+
+vamoorei16.v v8, (a0), v4, v8
+# CHECK-INST: vamoorei16.v v8, (a0), v4, v8
+# CHECK-ENCODING: [0x2f,0x54,0x45,0x46]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 54 45 46 <unknown>
+
+vamoorei32.v v8, (a0), v4, v8
+# CHECK-INST: vamoorei32.v v8, (a0), v4, v8
+# CHECK-ENCODING: [0x2f,0x64,0x45,0x46]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 64 45 46 <unknown>
+
+vamoorei64.v v8, (a0), v4, v8
+# CHECK-INST: vamoorei64.v v8, (a0), v4, v8
+# CHECK-ENCODING: [0x2f,0x74,0x45,0x46]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 74 45 46 <unknown>
+
+vamoorei8.v v8, (a0), v4, v8, v0.t
+# CHECK-INST: vamoorei8.v v8, (a0), v4, v8, v0.t
+# CHECK-ENCODING: [0x2f,0x04,0x45,0x44]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 04 45 44 <unknown>
+
+vamoorei16.v v8, (a0), v4, v8, v0.t
+# CHECK-INST: vamoorei16.v v8, (a0), v4, v8, v0.t
+# CHECK-ENCODING: [0x2f,0x54,0x45,0x44]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 54 45 44 <unknown>
+
+vamoorei32.v v8, (a0), v4, v8, v0.t
+# CHECK-INST: vamoorei32.v v8, (a0), v4, v8, v0.t
+# CHECK-ENCODING: [0x2f,0x64,0x45,0x44]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 64 45 44 <unknown>
+
+vamoorei64.v v8, (a0), v4, v8, v0.t
+# CHECK-INST: vamoorei64.v v8, (a0), v4, v8, v0.t
+# CHECK-ENCODING: [0x2f,0x74,0x45,0x44]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 74 45 44 <unknown>
+
+vamominei8.v v8, (a0), v4, v8
+# CHECK-INST: vamominei8.v v8, (a0), v4, v8
+# CHECK-ENCODING: [0x2f,0x04,0x45,0x86]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 04 45 86 <unknown>
+
+vamominei16.v v8, (a0), v4, v8
+# CHECK-INST: vamominei16.v v8, (a0), v4, v8
+# CHECK-ENCODING: [0x2f,0x54,0x45,0x86]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 54 45 86 <unknown>
+
+vamominei32.v v8, (a0), v4, v8
+# CHECK-INST: vamominei32.v v8, (a0), v4, v8
+# CHECK-ENCODING: [0x2f,0x64,0x45,0x86]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 64 45 86 <unknown>
+
+vamominei64.v v8, (a0), v4, v8
+# CHECK-INST: vamominei64.v v8, (a0), v4, v8
+# CHECK-ENCODING: [0x2f,0x74,0x45,0x86]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 74 45 86 <unknown>
+
+vamominei8.v v8, (a0), v4, v8, v0.t
+# CHECK-INST: vamominei8.v v8, (a0), v4, v8, v0.t
+# CHECK-ENCODING: [0x2f,0x04,0x45,0x84]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 04 45 84 <unknown>
+
+vamominei16.v v8, (a0), v4, v8, v0.t
+# CHECK-INST: vamominei16.v v8, (a0), v4, v8, v0.t
+# CHECK-ENCODING: [0x2f,0x54,0x45,0x84]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 54 45 84 <unknown>
+
+vamominei32.v v8, (a0), v4, v8, v0.t
+# CHECK-INST: vamominei32.v v8, (a0), v4, v8, v0.t
+# CHECK-ENCODING: [0x2f,0x64,0x45,0x84]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 64 45 84 <unknown>
+
+vamominei64.v v8, (a0), v4, v8, v0.t
+# CHECK-INST: vamominei64.v v8, (a0), v4, v8, v0.t
+# CHECK-ENCODING: [0x2f,0x74,0x45,0x84]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 74 45 84 <unknown>
+
+vamomaxei8.v v8, (a0), v4, v8
+# CHECK-INST: vamomaxei8.v v8, (a0), v4, v8
+# CHECK-ENCODING: [0x2f,0x04,0x45,0xa6]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 04 45 a6 <unknown>
+
+vamomaxei16.v v8, (a0), v4, v8
+# CHECK-INST: vamomaxei16.v v8, (a0), v4, v8
+# CHECK-ENCODING: [0x2f,0x54,0x45,0xa6]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 54 45 a6 <unknown>
+
+vamomaxei32.v v8, (a0), v4, v8
+# CHECK-INST: vamomaxei32.v v8, (a0), v4, v8
+# CHECK-ENCODING: [0x2f,0x64,0x45,0xa6]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 64 45 a6 <unknown>
+
+vamomaxei64.v v8, (a0), v4, v8
+# CHECK-INST: vamomaxei64.v v8, (a0), v4, v8
+# CHECK-ENCODING: [0x2f,0x74,0x45,0xa6]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 74 45 a6 <unknown>
+
+vamomaxei8.v v8, (a0), v4, v8, v0.t
+# CHECK-INST: vamomaxei8.v v8, (a0), v4, v8, v0.t
+# CHECK-ENCODING: [0x2f,0x04,0x45,0xa4]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 04 45 a4 <unknown>
+
+vamomaxei16.v v8, (a0), v4, v8, v0.t
+# CHECK-INST: vamomaxei16.v v8, (a0), v4, v8, v0.t
+# CHECK-ENCODING: [0x2f,0x54,0x45,0xa4]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 54 45 a4 <unknown>
+
+vamomaxei32.v v8, (a0), v4, v8, v0.t
+# CHECK-INST: vamomaxei32.v v8, (a0), v4, v8, v0.t
+# CHECK-ENCODING: [0x2f,0x64,0x45,0xa4]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 64 45 a4 <unknown>
+
+vamomaxei64.v v8, (a0), v4, v8, v0.t
+# CHECK-INST: vamomaxei64.v v8, (a0), v4, v8, v0.t
+# CHECK-ENCODING: [0x2f,0x74,0x45,0xa4]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 74 45 a4 <unknown>
+
+vamominuei8.v v8, (a0), v4, v8
+# CHECK-INST: vamominuei8.v v8, (a0), v4, v8
+# CHECK-ENCODING: [0x2f,0x04,0x45,0xc6]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 04 45 c6 <unknown>
+
+vamominuei16.v v8, (a0), v4, v8
+# CHECK-INST: vamominuei16.v v8, (a0), v4, v8
+# CHECK-ENCODING: [0x2f,0x54,0x45,0xc6]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 54 45 c6 <unknown>
+
+vamominuei32.v v8, (a0), v4, v8
+# CHECK-INST: vamominuei32.v v8, (a0), v4, v8
+# CHECK-ENCODING: [0x2f,0x64,0x45,0xc6]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 64 45 c6 <unknown>
+
+vamominuei64.v v8, (a0), v4, v8
+# CHECK-INST: vamominuei64.v v8, (a0), v4, v8
+# CHECK-ENCODING: [0x2f,0x74,0x45,0xc6]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 74 45 c6 <unknown>
+
+vamominuei8.v v8, (a0), v4, v8, v0.t
+# CHECK-INST: vamominuei8.v v8, (a0), v4, v8, v0.t
+# CHECK-ENCODING: [0x2f,0x04,0x45,0xc4]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 04 45 c4 <unknown>
+
+vamominuei16.v v8, (a0), v4, v8, v0.t
+# CHECK-INST: vamominuei16.v v8, (a0), v4, v8, v0.t
+# CHECK-ENCODING: [0x2f,0x54,0x45,0xc4]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 54 45 c4 <unknown>
+
+vamominuei32.v v8, (a0), v4, v8, v0.t
+# CHECK-INST: vamominuei32.v v8, (a0), v4, v8, v0.t
+# CHECK-ENCODING: [0x2f,0x64,0x45,0xc4]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 64 45 c4 <unknown>
+
+vamominuei64.v v8, (a0), v4, v8, v0.t
+# CHECK-INST: vamominuei64.v v8, (a0), v4, v8, v0.t
+# CHECK-ENCODING: [0x2f,0x74,0x45,0xc4]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 74 45 c4 <unknown>
+
+vamomaxuei8.v v8, (a0), v4, v8
+# CHECK-INST: vamomaxuei8.v v8, (a0), v4, v8
+# CHECK-ENCODING: [0x2f,0x04,0x45,0xe6]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 04 45 e6 <unknown>
+
+vamomaxuei16.v v8, (a0), v4, v8
+# CHECK-INST: vamomaxuei16.v v8, (a0), v4, v8
+# CHECK-ENCODING: [0x2f,0x54,0x45,0xe6]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 54 45 e6 <unknown>
+
+vamomaxuei32.v v8, (a0), v4, v8
+# CHECK-INST: vamomaxuei32.v v8, (a0), v4, v8
+# CHECK-ENCODING: [0x2f,0x64,0x45,0xe6]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 64 45 e6 <unknown>
+
+vamomaxuei64.v v8, (a0), v4, v8
+# CHECK-INST: vamomaxuei64.v v8, (a0), v4, v8
+# CHECK-ENCODING: [0x2f,0x74,0x45,0xe6]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 74 45 e6 <unknown>
+
+vamomaxuei8.v v8, (a0), v4, v8, v0.t
+# CHECK-INST: vamomaxuei8.v v8, (a0), v4, v8, v0.t
+# CHECK-ENCODING: [0x2f,0x04,0x45,0xe4]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 04 45 e4 <unknown>
+
+vamomaxuei16.v v8, (a0), v4, v8, v0.t
+# CHECK-INST: vamomaxuei16.v v8, (a0), v4, v8, v0.t
+# CHECK-ENCODING: [0x2f,0x54,0x45,0xe4]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 54 45 e4 <unknown>
+
+vamomaxuei32.v v8, (a0), v4, v8, v0.t
+# CHECK-INST: vamomaxuei32.v v8, (a0), v4, v8, v0.t
+# CHECK-ENCODING: [0x2f,0x64,0x45,0xe4]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 64 45 e4 <unknown>
+
+vamomaxuei64.v v8, (a0), v4, v8, v0.t
+# CHECK-INST: vamomaxuei64.v v8, (a0), v4, v8, v0.t
+# CHECK-ENCODING: [0x2f,0x74,0x45,0xe4]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 74 45 e4 <unknown>
+
+vamoswapei8.v x0, (a0), v4, v24
+# CHECK-INST: vamoswapei8.v x0, (a0), v4, v24
+# CHECK-ENCODING: [0x2f,0x0c,0x45,0x0a]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 0c 45 0a <unknown>
+
+vamoswapei16.v x0, (a0), v4, v24
+# CHECK-INST: vamoswapei16.v x0, (a0), v4, v24
+# CHECK-ENCODING: [0x2f,0x5c,0x45,0x0a]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 5c 45 0a <unknown>
+
+vamoswapei32.v x0, (a0), v4, v24
+# CHECK-INST: vamoswapei32.v x0, (a0), v4, v24
+# CHECK-ENCODING: [0x2f,0x6c,0x45,0x0a]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 6c 45 0a <unknown>
+
+vamoswapei64.v x0, (a0), v4, v24
+# CHECK-INST: vamoswapei64.v x0, (a0), v4, v24
+# CHECK-ENCODING: [0x2f,0x7c,0x45,0x0a]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 7c 45 0a <unknown>
+
+vamoswapei8.v x0, (a0), v4, v24, v0.t
+# CHECK-INST: vamoswapei8.v x0, (a0), v4, v24, v0.t
+# CHECK-ENCODING: [0x2f,0x0c,0x45,0x08]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 0c 45 08 <unknown>
+
+vamoswapei16.v x0, (a0), v4, v24, v0.t
+# CHECK-INST: vamoswapei16.v x0, (a0), v4, v24, v0.t
+# CHECK-ENCODING: [0x2f,0x5c,0x45,0x08]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 5c 45 08 <unknown>
+
+vamoswapei32.v x0, (a0), v4, v24, v0.t
+# CHECK-INST: vamoswapei32.v x0, (a0), v4, v24, v0.t
+# CHECK-ENCODING: [0x2f,0x6c,0x45,0x08]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 6c 45 08 <unknown>
+
+vamoswapei64.v x0, (a0), v4, v24, v0.t
+# CHECK-INST: vamoswapei64.v x0, (a0), v4, v24, v0.t
+# CHECK-ENCODING: [0x2f,0x7c,0x45,0x08]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 7c 45 08 <unknown>
+
+vamoaddei8.v x0, (a0), v4, v24
+# CHECK-INST: vamoaddei8.v x0, (a0), v4, v24
+# CHECK-ENCODING: [0x2f,0x0c,0x45,0x02]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 0c 45 02 <unknown>
+
+vamoaddei16.v x0, (a0), v4, v24
+# CHECK-INST: vamoaddei16.v x0, (a0), v4, v24
+# CHECK-ENCODING: [0x2f,0x5c,0x45,0x02]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 5c 45 02 <unknown>
+
+vamoaddei32.v x0, (a0), v4, v24
+# CHECK-INST: vamoaddei32.v x0, (a0), v4, v24
+# CHECK-ENCODING: [0x2f,0x6c,0x45,0x02]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 6c 45 02 <unknown>
+
+vamoaddei64.v x0, (a0), v4, v24
+# CHECK-INST: vamoaddei64.v x0, (a0), v4, v24
+# CHECK-ENCODING: [0x2f,0x7c,0x45,0x02]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 7c 45 02 <unknown>
+
+vamoaddei8.v x0, (a0), v4, v24, v0.t
+# CHECK-INST: vamoaddei8.v x0, (a0), v4, v24, v0.t
+# CHECK-ENCODING: [0x2f,0x0c,0x45,0x00]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 0c 45 00 <unknown>
+
+vamoaddei16.v x0, (a0), v4, v24, v0.t
+# CHECK-INST: vamoaddei16.v x0, (a0), v4, v24, v0.t
+# CHECK-ENCODING: [0x2f,0x5c,0x45,0x00]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 5c 45 00 <unknown>
+
+vamoaddei32.v x0, (a0), v4, v24, v0.t
+# CHECK-INST: vamoaddei32.v x0, (a0), v4, v24, v0.t
+# CHECK-ENCODING: [0x2f,0x6c,0x45,0x00]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 6c 45 00 <unknown>
+
+vamoaddei64.v x0, (a0), v4, v24, v0.t
+# CHECK-INST: vamoaddei64.v x0, (a0), v4, v24, v0.t
+# CHECK-ENCODING: [0x2f,0x7c,0x45,0x00]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 7c 45 00 <unknown>
+
+vamoxorei8.v x0, (a0), v4, v24
+# CHECK-INST: vamoxorei8.v x0, (a0), v4, v24
+# CHECK-ENCODING: [0x2f,0x0c,0x45,0x22]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 0c 45 22 <unknown>
+
+vamoxorei16.v x0, (a0), v4, v24
+# CHECK-INST: vamoxorei16.v x0, (a0), v4, v24
+# CHECK-ENCODING: [0x2f,0x5c,0x45,0x22]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 5c 45 22 <unknown>
+
+vamoxorei32.v x0, (a0), v4, v24
+# CHECK-INST: vamoxorei32.v x0, (a0), v4, v24
+# CHECK-ENCODING: [0x2f,0x6c,0x45,0x22]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 6c 45 22 <unknown>
+
+vamoxorei64.v x0, (a0), v4, v24
+# CHECK-INST: vamoxorei64.v x0, (a0), v4, v24
+# CHECK-ENCODING: [0x2f,0x7c,0x45,0x22]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 7c 45 22 <unknown>
+
+vamoxorei8.v x0, (a0), v4, v24, v0.t
+# CHECK-INST: vamoxorei8.v x0, (a0), v4, v24, v0.t
+# CHECK-ENCODING: [0x2f,0x0c,0x45,0x20]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 0c 45 20 <unknown>
+
+vamoxorei16.v x0, (a0), v4, v24, v0.t
+# CHECK-INST: vamoxorei16.v x0, (a0), v4, v24, v0.t
+# CHECK-ENCODING: [0x2f,0x5c,0x45,0x20]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 5c 45 20 <unknown>
+
+vamoxorei32.v x0, (a0), v4, v24, v0.t
+# CHECK-INST: vamoxorei32.v x0, (a0), v4, v24, v0.t
+# CHECK-ENCODING: [0x2f,0x6c,0x45,0x20]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 6c 45 20 <unknown>
+
+vamoxorei64.v x0, (a0), v4, v24, v0.t
+# CHECK-INST: vamoxorei64.v x0, (a0), v4, v24, v0.t
+# CHECK-ENCODING: [0x2f,0x7c,0x45,0x20]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 7c 45 20 <unknown>
+
+vamoandei8.v x0, (a0), v4, v24
+# CHECK-INST: vamoandei8.v x0, (a0), v4, v24
+# CHECK-ENCODING: [0x2f,0x0c,0x45,0x62]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 0c 45 62 <unknown>
+
+vamoandei16.v x0, (a0), v4, v24
+# CHECK-INST: vamoandei16.v x0, (a0), v4, v24
+# CHECK-ENCODING: [0x2f,0x5c,0x45,0x62]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 5c 45 62 <unknown>
+
+vamoandei32.v x0, (a0), v4, v24
+# CHECK-INST: vamoandei32.v x0, (a0), v4, v24
+# CHECK-ENCODING: [0x2f,0x6c,0x45,0x62]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 6c 45 62 <unknown>
+
+vamoandei64.v x0, (a0), v4, v24
+# CHECK-INST: vamoandei64.v x0, (a0), v4, v24
+# CHECK-ENCODING: [0x2f,0x7c,0x45,0x62]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 7c 45 62 <unknown>
+
+vamoandei8.v x0, (a0), v4, v24, v0.t
+# CHECK-INST: vamoandei8.v x0, (a0), v4, v24, v0.t
+# CHECK-ENCODING: [0x2f,0x0c,0x45,0x60]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 0c 45 60 <unknown>
+
+vamoandei16.v x0, (a0), v4, v24, v0.t
+# CHECK-INST: vamoandei16.v x0, (a0), v4, v24, v0.t
+# CHECK-ENCODING: [0x2f,0x5c,0x45,0x60]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 5c 45 60 <unknown>
+
+vamoandei32.v x0, (a0), v4, v24, v0.t
+# CHECK-INST: vamoandei32.v x0, (a0), v4, v24, v0.t
+# CHECK-ENCODING: [0x2f,0x6c,0x45,0x60]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 6c 45 60 <unknown>
+
+vamoandei64.v x0, (a0), v4, v24, v0.t
+# CHECK-INST: vamoandei64.v x0, (a0), v4, v24, v0.t
+# CHECK-ENCODING: [0x2f,0x7c,0x45,0x60]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 7c 45 60 <unknown>
+
+vamoorei8.v x0, (a0), v4, v24
+# CHECK-INST: vamoorei8.v x0, (a0), v4, v24
+# CHECK-ENCODING: [0x2f,0x0c,0x45,0x42]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 0c 45 42 <unknown>
+
+vamoorei16.v x0, (a0), v4, v24
+# CHECK-INST: vamoorei16.v x0, (a0), v4, v24
+# CHECK-ENCODING: [0x2f,0x5c,0x45,0x42]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 5c 45 42 <unknown>
+
+vamoorei32.v x0, (a0), v4, v24
+# CHECK-INST: vamoorei32.v x0, (a0), v4, v24
+# CHECK-ENCODING: [0x2f,0x6c,0x45,0x42]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 6c 45 42 <unknown>
+
+vamoorei64.v x0, (a0), v4, v24
+# CHECK-INST: vamoorei64.v x0, (a0), v4, v24
+# CHECK-ENCODING: [0x2f,0x7c,0x45,0x42]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 7c 45 42 <unknown>
+
+vamoorei8.v x0, (a0), v4, v24, v0.t
+# CHECK-INST: vamoorei8.v x0, (a0), v4, v24, v0.t
+# CHECK-ENCODING: [0x2f,0x0c,0x45,0x40]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 0c 45 40 <unknown>
+
+vamoorei16.v x0, (a0), v4, v24, v0.t
+# CHECK-INST: vamoorei16.v x0, (a0), v4, v24, v0.t
+# CHECK-ENCODING: [0x2f,0x5c,0x45,0x40]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 5c 45 40 <unknown>
+
+vamoorei32.v x0, (a0), v4, v24, v0.t
+# CHECK-INST: vamoorei32.v x0, (a0), v4, v24, v0.t
+# CHECK-ENCODING: [0x2f,0x6c,0x45,0x40]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 6c 45 40 <unknown>
+
+vamoorei64.v x0, (a0), v4, v24, v0.t
+# CHECK-INST: vamoorei64.v x0, (a0), v4, v24, v0.t
+# CHECK-ENCODING: [0x2f,0x7c,0x45,0x40]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 7c 45 40 <unknown>
+
+vamominei8.v x0, (a0), v4, v24
+# CHECK-INST: vamominei8.v x0, (a0), v4, v24
+# CHECK-ENCODING: [0x2f,0x0c,0x45,0x82]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 0c 45 82 <unknown>
+
+vamominei16.v x0, (a0), v4, v24
+# CHECK-INST: vamominei16.v x0, (a0), v4, v24
+# CHECK-ENCODING: [0x2f,0x5c,0x45,0x82]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 5c 45 82 <unknown>
+
+vamominei32.v x0, (a0), v4, v24
+# CHECK-INST: vamominei32.v x0, (a0), v4, v24
+# CHECK-ENCODING: [0x2f,0x6c,0x45,0x82]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 6c 45 82 <unknown>
+
+vamominei64.v x0, (a0), v4, v24
+# CHECK-INST: vamominei64.v x0, (a0), v4, v24
+# CHECK-ENCODING: [0x2f,0x7c,0x45,0x82]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 7c 45 82 <unknown>
+
+vamominei8.v x0, (a0), v4, v24, v0.t
+# CHECK-INST: vamominei8.v x0, (a0), v4, v24, v0.t
+# CHECK-ENCODING: [0x2f,0x0c,0x45,0x80]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 0c 45 80 <unknown>
+
+vamominei16.v x0, (a0), v4, v24, v0.t
+# CHECK-INST: vamominei16.v x0, (a0), v4, v24, v0.t
+# CHECK-ENCODING: [0x2f,0x5c,0x45,0x80]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 5c 45 80 <unknown>
+
+vamominei32.v x0, (a0), v4, v24, v0.t
+# CHECK-INST: vamominei32.v x0, (a0), v4, v24, v0.t
+# CHECK-ENCODING: [0x2f,0x6c,0x45,0x80]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 6c 45 80 <unknown>
+
+vamominei64.v x0, (a0), v4, v24, v0.t
+# CHECK-INST: vamominei64.v x0, (a0), v4, v24, v0.t
+# CHECK-ENCODING: [0x2f,0x7c,0x45,0x80]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 7c 45 80 <unknown>
+
+vamomaxei8.v x0, (a0), v4, v24
+# CHECK-INST: vamomaxei8.v x0, (a0), v4, v24
+# CHECK-ENCODING: [0x2f,0x0c,0x45,0xa2]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 0c 45 a2 <unknown>
+
+vamomaxei16.v x0, (a0), v4, v24
+# CHECK-INST: vamomaxei16.v x0, (a0), v4, v24
+# CHECK-ENCODING: [0x2f,0x5c,0x45,0xa2]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 5c 45 a2 <unknown>
+
+vamomaxei32.v x0, (a0), v4, v24
+# CHECK-INST: vamomaxei32.v x0, (a0), v4, v24
+# CHECK-ENCODING: [0x2f,0x6c,0x45,0xa2]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 6c 45 a2 <unknown>
+
+vamomaxei64.v x0, (a0), v4, v24
+# CHECK-INST: vamomaxei64.v x0, (a0), v4, v24
+# CHECK-ENCODING: [0x2f,0x7c,0x45,0xa2]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 7c 45 a2 <unknown>
+
+vamomaxei8.v x0, (a0), v4, v24, v0.t
+# CHECK-INST: vamomaxei8.v x0, (a0), v4, v24, v0.t
+# CHECK-ENCODING: [0x2f,0x0c,0x45,0xa0]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 0c 45 a0 <unknown>
+
+vamomaxei16.v x0, (a0), v4, v24, v0.t
+# CHECK-INST: vamomaxei16.v x0, (a0), v4, v24, v0.t
+# CHECK-ENCODING: [0x2f,0x5c,0x45,0xa0]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 5c 45 a0 <unknown>
+
+vamomaxei32.v x0, (a0), v4, v24, v0.t
+# CHECK-INST: vamomaxei32.v x0, (a0), v4, v24, v0.t
+# CHECK-ENCODING: [0x2f,0x6c,0x45,0xa0]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 6c 45 a0 <unknown>
+
+vamomaxei64.v x0, (a0), v4, v24, v0.t
+# CHECK-INST: vamomaxei64.v x0, (a0), v4, v24, v0.t
+# CHECK-ENCODING: [0x2f,0x7c,0x45,0xa0]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 7c 45 a0 <unknown>
+
+vamominuei8.v x0, (a0), v4, v24
+# CHECK-INST: vamominuei8.v x0, (a0), v4, v24
+# CHECK-ENCODING: [0x2f,0x0c,0x45,0xc2]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 0c 45 c2 <unknown>
+
+vamominuei16.v x0, (a0), v4, v24
+# CHECK-INST: vamominuei16.v x0, (a0), v4, v24
+# CHECK-ENCODING: [0x2f,0x5c,0x45,0xc2]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 5c 45 c2 <unknown>
+
+vamominuei32.v x0, (a0), v4, v24
+# CHECK-INST: vamominuei32.v x0, (a0), v4, v24
+# CHECK-ENCODING: [0x2f,0x6c,0x45,0xc2]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 6c 45 c2 <unknown>
+
+vamominuei64.v x0, (a0), v4, v24
+# CHECK-INST: vamominuei64.v x0, (a0), v4, v24
+# CHECK-ENCODING: [0x2f,0x7c,0x45,0xc2]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 7c 45 c2 <unknown>
+
+vamominuei8.v x0, (a0), v4, v24, v0.t
+# CHECK-INST: vamominuei8.v x0, (a0), v4, v24, v0.t
+# CHECK-ENCODING: [0x2f,0x0c,0x45,0xc0]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 0c 45 c0 <unknown>
+
+vamominuei16.v x0, (a0), v4, v24, v0.t
+# CHECK-INST: vamominuei16.v x0, (a0), v4, v24, v0.t
+# CHECK-ENCODING: [0x2f,0x5c,0x45,0xc0]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 5c 45 c0 <unknown>
+
+vamominuei32.v x0, (a0), v4, v24, v0.t
+# CHECK-INST: vamominuei32.v x0, (a0), v4, v24, v0.t
+# CHECK-ENCODING: [0x2f,0x6c,0x45,0xc0]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 6c 45 c0 <unknown>
+
+vamominuei64.v x0, (a0), v4, v24, v0.t
+# CHECK-INST: vamominuei64.v x0, (a0), v4, v24, v0.t
+# CHECK-ENCODING: [0x2f,0x7c,0x45,0xc0]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 7c 45 c0 <unknown>
+
+vamomaxuei8.v x0, (a0), v4, v24
+# CHECK-INST: vamomaxuei8.v x0, (a0), v4, v24
+# CHECK-ENCODING: [0x2f,0x0c,0x45,0xe2]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 0c 45 e2 <unknown>
+
+vamomaxuei16.v x0, (a0), v4, v24
+# CHECK-INST: vamomaxuei16.v x0, (a0), v4, v24
+# CHECK-ENCODING: [0x2f,0x5c,0x45,0xe2]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 5c 45 e2 <unknown>
+
+vamomaxuei32.v x0, (a0), v4, v24
+# CHECK-INST: vamomaxuei32.v x0, (a0), v4, v24
+# CHECK-ENCODING: [0x2f,0x6c,0x45,0xe2]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 6c 45 e2 <unknown>
+
+vamomaxuei64.v x0, (a0), v4, v24
+# CHECK-INST: vamomaxuei64.v x0, (a0), v4, v24
+# CHECK-ENCODING: [0x2f,0x7c,0x45,0xe2]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 7c 45 e2 <unknown>
+
+vamomaxuei8.v x0, (a0), v4, v24, v0.t
+# CHECK-INST: vamomaxuei8.v x0, (a0), v4, v24, v0.t
+# CHECK-ENCODING: [0x2f,0x0c,0x45,0xe0]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 0c 45 e0 <unknown>
+
+vamomaxuei16.v x0, (a0), v4, v24, v0.t
+# CHECK-INST: vamomaxuei16.v x0, (a0), v4, v24, v0.t
+# CHECK-ENCODING: [0x2f,0x5c,0x45,0xe0]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 5c 45 e0 <unknown>
+
+vamomaxuei32.v x0, (a0), v4, v24, v0.t
+# CHECK-INST: vamomaxuei32.v x0, (a0), v4, v24, v0.t
+# CHECK-ENCODING: [0x2f,0x6c,0x45,0xe0]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 6c 45 e0 <unknown>
+
+vamomaxuei64.v x0, (a0), v4, v24, v0.t
+# CHECK-INST: vamomaxuei64.v x0, (a0), v4, v24, v0.t
+# CHECK-ENCODING: [0x2f,0x7c,0x45,0xe0]
+# CHECK-ERROR: instruction requires the following: 'A' (Atomic Instructions), 'Zvamo'(Vector AMO Operations)
+# CHECK-UNKNOWN: 2f 7c 45 e0 <unknown>