From 8dd24026c04d7d0d36c3de8a4c9cc3c86e67ba15 Mon Sep 17 00:00:00 2001
From: luxufan <932494295@qq.com>
Date: Fri, 31 Jul 2020 13:03:57 +0800
Subject: [PATCH] [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              |   7 +
 lib/Target/RISCV/RISCVInstrFormatsV.td |  32 +
 lib/Target/RISCV/RISCVInstrInfoV.td    |  78 +++
 lib/Target/RISCV/RISCVSchedRocket32.td |   2 +-
 lib/Target/RISCV/RISCVSchedRocket64.td |   2 +-
 lib/Target/RISCV/RISCVSubtarget.h      |   2 +
 test/MC/RISCV/rvv/zvamo.s              | 874 +++++++++++++++++++++++++
 7 files changed, 995 insertions(+), 2 deletions(-)
 create mode 100644 test/MC/RISCV/rvv/zvamo.s

diff --git a/lib/Target/RISCV/RISCV.td b/lib/Target/RISCV/RISCV.td
index 493f5fa0b67..73fcbb43adb 100644
--- a/lib/Target/RISCV/RISCV.td
+++ b/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">;
diff --git a/lib/Target/RISCV/RISCVInstrFormatsV.td b/lib/Target/RISCV/RISCVInstrFormatsV.td
index 8ca010d033c..030571a370f 100644
--- a/lib/Target/RISCV/RISCVInstrFormatsV.td
+++ b/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];
+}
diff --git a/lib/Target/RISCV/RISCVInstrInfoV.td b/lib/Target/RISCV/RISCVInstrInfoV.td
index 70afcc6776d..3ac474cb654 100644
--- a/lib/Target/RISCV/RISCVInstrInfoV.td
+++ b/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]
diff --git a/lib/Target/RISCV/RISCVSchedRocket32.td b/lib/Target/RISCV/RISCVSchedRocket32.td
index f9f80848e12..1cb474b54d8 100644
--- a/lib/Target/RISCV/RISCVSchedRocket32.td
+++ b/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];
 }
 
 //===----------------------------------------------------------------------===//
diff --git a/lib/Target/RISCV/RISCVSchedRocket64.td b/lib/Target/RISCV/RISCVSchedRocket64.td
index 9b5aa776a0d..8a29762e5ad 100644
--- a/lib/Target/RISCV/RISCVSchedRocket64.td
+++ b/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];
 }
 
 //===----------------------------------------------------------------------===//
diff --git a/lib/Target/RISCV/RISCVSubtarget.h b/lib/Target/RISCV/RISCVSubtarget.h
index 72d35515d51..245c8eb01e3 100644
--- a/lib/Target/RISCV/RISCVSubtarget.h
+++ b/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; }
diff --git a/test/MC/RISCV/rvv/zvamo.s b/test/MC/RISCV/rvv/zvamo.s
new file mode 100644
index 00000000000..8c38ff8e1a1
--- /dev/null
+++ b/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>
\ No newline at end of file