[clang] [llvm] [RISCV] Add Tenstorrent Ascalon XG (PR #229030)

Ramkumar Ramachandra via llvm-commits llvm-commits at lists.llvm.org
Tue Oct 6 11:48:24 PDT 2026


https://github.com/artagnon updated https://github.com/llvm/llvm-project/pull/229030

>From ac544558dfc23df76c73304c038d9b8eec089e78 Mon Sep 17 00:00:00 2001
From: Ramkumar Ramachandra <artagnon at tenstorrent.com>
Date: Tue, 1 Sep 2026 07:11:38 +0100
Subject: [PATCH 1/3] [RISCV] Add Tenstorrent Ascalon XG

Ascalon XG is the global variant of Ascalon X, to meet export
restrictions: it lacks the Zvkng extension and has reduced vector FP64
throughput. Add it as tt-ascalon-xg to RISCVProcessors. Restructure the
Ascalon scheduling model into a multiclass similar to the SiFive7 model,
so that both cores share the same definitions. On Ascalon XG, vector
instructions producing FP64 results (SEW=64 add/mul/fma, and the SEW=32
widening add/mul/fma and conversions) additionally occupy an FP64 unit
for 4x the cycles and have increased latency.

tt-ascalon-x is unchanged.

Ref: https://gcc.gnu.org/git/?p=gcc.git;a=commit;h=2bfe853b3b1703216a32a48d2bc61363140c6aea
Assisted-by: llm

-- 8< --
Kindly review this patch with whitespace changes turned off on GitHub.
---
 clang/test/Driver/riscv-cpus.c                |   65 +
 .../test/Misc/target-invalid-cpu-note/riscv.c |    2 +
 llvm/docs/ReleaseNotes.md                     |    3 +
 llvm/lib/Target/RISCV/RISCVProcessors.td      |   69 +-
 llvm/lib/Target/RISCV/RISCVSchedTTAscalonX.td | 1757 +++++++++--------
 .../tools/llvm-mca/RISCV/tt-ascalon-x/vfp64.s |  116 ++
 6 files changed, 1139 insertions(+), 873 deletions(-)
 create mode 100644 llvm/test/tools/llvm-mca/RISCV/tt-ascalon-x/vfp64.s

diff --git a/clang/test/Driver/riscv-cpus.c b/clang/test/Driver/riscv-cpus.c
index 9cfe399ca71a7a0..9376492309cc0be 100644
--- a/clang/test/Driver/riscv-cpus.c
+++ b/clang/test/Driver/riscv-cpus.c
@@ -250,6 +250,71 @@
 // MCPU-TT-ASCALON-X-SAME: "-target-feature" "+svpbmt"
 // MCPU-TT-ASCALON-X-SAME: "-target-abi" "lp64d"
 
+// RUN: %clang --target=riscv64 -### -c %s 2>&1 -mtune=tt-ascalon-xg | FileCheck -check-prefix=MTUNE-TT-ASCALON-XG %s
+// MTUNE-TT-ASCALON-XG: "-tune-cpu" "tt-ascalon-xg"
+
+// RUN: %clang --target=riscv64 -### -c %s 2>&1 -mcpu=tt-ascalon-xg | FileCheck -check-prefix=MCPU-TT-ASCALON-XG %s
+// MCPU-TT-ASCALON-XG: "-target-cpu" "tt-ascalon-xg"
+// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+m"
+// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+a"
+// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+f"
+// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+d"
+// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+c"
+// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+v"
+// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+h"
+// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zicbom"
+// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zicbop"
+// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zicboz"
+// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zicntr"
+// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zicond"
+// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zicsr"
+// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zifencei"
+// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zihintntl"
+// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zihintpause"
+// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zihpm"
+// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zimop"
+// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zmmul"
+// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zawrs"
+// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zfa"
+// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zfbfmin"
+// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zfh"
+// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zfhmin"
+// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zca"
+// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zcb"
+// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zba"
+// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zbb"
+// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zbs"
+// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zkr"
+// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zkt"
+// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zvbb"
+// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zvbc"
+// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zve32f"
+// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zve32x"
+// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zve64d"
+// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zve64f"
+// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zve64x"
+// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zvfbfmin"
+// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zvfbfwma"
+// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zvfh"
+// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zvfhmin"
+// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zvkb"
+// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zvkt"
+// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zvl128b"
+// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zvl256b"
+// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zvl32b"
+// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zvl64b"
+// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+smaia"
+// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+smmpm"
+// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+smnpm"
+// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+smrnmi"
+// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+smstateen"
+// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+sscofpmf"
+// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+svinval"
+// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+svnapot"
+// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+svpbmt"
+// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "-zvkng"
+// MCPU-TT-ASCALON-XG-SAME: "-target-abi" "lp64d"
+
 // RUN: %clang --target=riscv64 -### -c %s 2>&1 -mtune=xiangshan-nanhu | FileCheck -check-prefix=MTUNE-XIANGSHAN-NANHU %s
 // MTUNE-XIANGSHAN-NANHU: "-tune-cpu" "xiangshan-nanhu"
 
diff --git a/clang/test/Misc/target-invalid-cpu-note/riscv.c b/clang/test/Misc/target-invalid-cpu-note/riscv.c
index 86fdf400ac46113..df13001fedf0dae 100644
--- a/clang/test/Misc/target-invalid-cpu-note/riscv.c
+++ b/clang/test/Misc/target-invalid-cpu-note/riscv.c
@@ -60,6 +60,7 @@
 // RISCV64-SAME: {{^}}, syntacore-scr5-rv64
 // RISCV64-SAME: {{^}}, syntacore-scr7
 // RISCV64-SAME: {{^}}, tt-ascalon-x
+// RISCV64-SAME: {{^}}, tt-ascalon-xg
 // RISCV64-SAME: {{^}}, xiangshan-kunminghu
 // RISCV64-SAME: {{^}}, xiangshan-nanhu
 // RISCV64-SAME: {{^}}, xt-c910v2
@@ -129,6 +130,7 @@
 // TUNE-RISCV64-SAME: {{^}}, syntacore-scr5-rv64
 // TUNE-RISCV64-SAME: {{^}}, syntacore-scr7
 // TUNE-RISCV64-SAME: {{^}}, tt-ascalon-x
+// TUNE-RISCV64-SAME: {{^}}, tt-ascalon-xg
 // TUNE-RISCV64-SAME: {{^}}, xiangshan-kunminghu
 // TUNE-RISCV64-SAME: {{^}}, xiangshan-nanhu
 // TUNE-RISCV64-SAME: {{^}}, xt-c910v2
diff --git a/llvm/docs/ReleaseNotes.md b/llvm/docs/ReleaseNotes.md
index 4e2882de82a02cd..b369e95263debc1 100644
--- a/llvm/docs/ReleaseNotes.md
+++ b/llvm/docs/ReleaseNotes.md
@@ -298,6 +298,9 @@ Makes programs 10x faster by doing Special New Thing.
   latest specification, placing ``p`` after ``v`` and removing unused ``n``.
 * Adds experimental assembler support for the `Xqccmi` (Qualcomm 16-bit Instruction Lookup Table) vendor extension.
 * Added `-mcpu=gaisler-gr765` for the 64-bit GR765 processor.
+* Added `-mcpu=tt-ascalon-xg` for the Tenstorrent Ascalon XG processor, the
+  global variant of Ascalon X without `Zvkng` and with reduced vector FP64
+  throughput.
 
 ### Changes to the WebAssembly Backend
 
diff --git a/llvm/lib/Target/RISCV/RISCVProcessors.td b/llvm/lib/Target/RISCV/RISCVProcessors.td
index eb4e2214dc38948..04a2fabc2c4fe7e 100644
--- a/llvm/lib/Target/RISCV/RISCVProcessors.td
+++ b/llvm/lib/Target/RISCV/RISCVProcessors.td
@@ -732,38 +732,47 @@ def SYNTACORE_SCR7 : RISCVProcessorModel<"syntacore-scr7",
                                                FeatureStdExtZkn],
                                               [TuneNoDefaultUnroll, TunePostRAScheduler]>;
 
+defvar TTAscalonXGFeatures = !listconcat(RVA23S64Features,
+                                         [FeatureStdExtSmaia,
+                                          FeatureStdExtSmmpm,
+                                          FeatureStdExtSmnpm,
+                                          FeatureStdExtSmrnmi,
+                                          FeatureStdExtSmstateen,
+                                          FeatureStdExtSsaia,
+                                          FeatureStdExtSsstrict,
+                                          FeatureStdExtZfbfmin,
+                                          FeatureStdExtZfh,
+                                          FeatureStdExtZkr,
+                                          FeatureStdExtZvbc,
+                                          FeatureStdExtZvfbfmin,
+                                          FeatureStdExtZvfbfwma,
+                                          FeatureStdExtZvfh,
+                                          FeatureStdExtZvl256b,
+                                          FeatureUnalignedScalarMem,
+                                          FeatureUnalignedVectorMem]);
+
+defvar TTAscalonTuneFeatures = [TuneNoDefaultUnroll,
+                                TuneNLogNVRGather,
+                                TuneOptimizedNF2SegmentLoadStore,
+                                TuneOptimizedNF3SegmentLoadStore,
+                                TuneOptimizedNF4SegmentLoadStore,
+                                TuneOptimizedNF5SegmentLoadStore,
+                                TuneOptimizedNF6SegmentLoadStore,
+                                TuneOptimizedNF7SegmentLoadStore,
+                                TuneOptimizedNF8SegmentLoadStore,
+                                TuneOptimizedZeroStrideLoad,
+                                TunePostRAScheduler];
+
 def TENSTORRENT_ASCALON_X : RISCVProcessorModel<"tt-ascalon-x",
                                                 TTAscalonXModel,
-                                                !listconcat(RVA23S64Features,
-                                                [FeatureStdExtSmaia,
-                                                 FeatureStdExtSmmpm,
-                                                 FeatureStdExtSmnpm,
-                                                 FeatureStdExtSmrnmi,
-                                                 FeatureStdExtSmstateen,
-                                                 FeatureStdExtSsaia,
-                                                 FeatureStdExtSsstrict,
-                                                 FeatureStdExtZfbfmin,
-                                                 FeatureStdExtZfh,
-                                                 FeatureStdExtZkr,
-                                                 FeatureStdExtZvbc,
-                                                 FeatureStdExtZvfbfmin,
-                                                 FeatureStdExtZvfbfwma,
-                                                 FeatureStdExtZvfh,
-                                                 FeatureStdExtZvkng,
-                                                 FeatureStdExtZvl256b,
-                                                 FeatureUnalignedScalarMem,
-                                                 FeatureUnalignedVectorMem]),
-                                                [TuneNoDefaultUnroll,
-                                                 TuneNLogNVRGather,
-                                                 TuneOptimizedNF2SegmentLoadStore,
-                                                 TuneOptimizedNF3SegmentLoadStore,
-                                                 TuneOptimizedNF4SegmentLoadStore,
-                                                 TuneOptimizedNF5SegmentLoadStore,
-                                                 TuneOptimizedNF6SegmentLoadStore,
-                                                 TuneOptimizedNF7SegmentLoadStore,
-                                                 TuneOptimizedNF8SegmentLoadStore,
-                                                 TuneOptimizedZeroStrideLoad,
-                                                 TunePostRAScheduler]>;
+                                                !listconcat(TTAscalonXGFeatures,
+                                                            [FeatureStdExtZvkng]),
+                                                TTAscalonTuneFeatures>;
+
+def TENSTORRENT_ASCALON_XG : RISCVProcessorModel<"tt-ascalon-xg",
+                                                 TTAscalonXGModel,
+                                                 TTAscalonXGFeatures,
+                                                 TTAscalonTuneFeatures>;
 
 def XIANGSHAN_NANHU : RISCVProcessorModel<"xiangshan-nanhu",
                                           XiangShanNanHuModel,
diff --git a/llvm/lib/Target/RISCV/RISCVSchedTTAscalonX.td b/llvm/lib/Target/RISCV/RISCVSchedTTAscalonX.td
index d6a1f341e3e3366..0dc6f06079b025e 100644
--- a/llvm/lib/Target/RISCV/RISCVSchedTTAscalonX.td
+++ b/llvm/lib/Target/RISCV/RISCVSchedTTAscalonX.td
@@ -1,4 +1,4 @@
-//=- RISCVSchedTTAscalonX.td - TT Ascalon X Sched Defs -------*- tablegen -*-=//
+//=- RISCVSchedTTAscalonX.td - TT Ascalon X/XG Sched Defs ----*- tablegen -*-=//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -95,7 +95,7 @@ class AscalonGetCyclesStridedSegmented<string mx, int sew> {
 
 //===----------------------------------------------------------------------===//
 
-def TTAscalonXModel : SchedMachineModel {
+class TTAscalonSchedMachineModel : SchedMachineModel {
   let IssueWidth        =   8; // 8-way decode and dispatch
   let MicroOpBufferSize = 256; // 256 micro-op re-order buffer
   let LoadLatency       =   4; // Optimistic load latency
@@ -108,935 +108,1006 @@ def TTAscalonXModel : SchedMachineModel {
                              HasStdExtZcmt, HasStdExtZknd, HasStdExtZkne,
                              HasStdExtZknh, HasStdExtZksed, HasStdExtZksh,
                              HasStdExtZkr];
-}
-
-let SchedModel = TTAscalonXModel in {
 
-//===----------------------------------------------------------------------===//
-// Define each kind of processor resource and number available.
-
-let BufferSize = 16 in {
-  def AscalonLS : ProcResource<3>;
-  def AscalonFXA : ProcResource<1>; // ALU, FP/VEC -> INT, MUL, DIV, CSR
-  def AscalonFXB : ProcResource<1>; // ALU, INT -> FP/VEC
-  def AscalonFXC : ProcResource<2>; // ALU, BR
-  def AscalonFXD : ProcResource<2>; // ALU
-  def AscalonFX : ProcResGroup<[AscalonFXA, AscalonFXB, AscalonFXC, AscalonFXD]>;
-  // FP
-  def AscalonFPA : ProcResource<1>; // Pipe A also handles FP/VEC -> INT
-  def AscalonFPB : ProcResource<1>;
-  def AscalonFP : ProcResGroup<[AscalonFPA, AscalonFPB]>;
-  // Vector
-  def AscalonVA : ProcResource<1>;
-  def AscalonVB : ProcResource<1>;
-  def AscalonV : ProcResGroup<[AscalonVA, AscalonVB]>;
+  string Name;
+  bit HasReducedFP64VectorThroughput;
 }
 
+def TTAscalonXModel : TTAscalonSchedMachineModel {
+  // TODO: This should technically be AscalonX.
+  let Name = "Ascalon";
+  let HasReducedFP64VectorThroughput = false;
+}
 
-//===----------------------------------------------------------------------===//
+def TTAscalonXGModel : TTAscalonSchedMachineModel {
+  let Name = "AscalonXG";
+  let HasReducedFP64VectorThroughput = true;
+}
 
-// Branching
-def : WriteRes<WriteJmp, [AscalonFXC]>;
-def : WriteRes<WriteJal, [AscalonFXC]>;
-def : WriteRes<WriteJalr, [AscalonFXC]>;
-
-// Integer arithmetic and logic
-def : WriteRes<WriteIALU32, [AscalonFX]>;
-def : WriteRes<WriteIALU, [AscalonFX]>;
-def : WriteRes<WriteShiftImm32, [AscalonFX]>;
-def : WriteRes<WriteShiftImm, [AscalonFX]>;
-def : WriteRes<WriteShiftReg32, [AscalonFX]>;
-def : WriteRes<WriteShiftReg, [AscalonFX]>;
-
-// Integer multiplication
-let Latency = 3 in {
-def : WriteRes<WriteIMul, [AscalonFXA]>;
-def : WriteRes<WriteIMul32, [AscalonFXA]>;
+/// Latency and occupancy of the extra FP64 vector unit on Ascalon XG for
+/// vector instructions producing FP64 results.
+class AscalonXGFP64Vec<int Cycles> {
+  int Latency = !add(Cycles, 8);
+  int ReleaseAtCycles = !mul(Cycles, 4);
 }
 
-// Integer division
-// Worst case latency is used.
+multiclass TTAscalonSchedResources<bit ReducedFP64Vec> {
+  //===--------------------------------------------------------------------===//
+  // Define each kind of processor resource and number available.
+  let BufferSize = 16 in {
+    def LS : ProcResource<3>;
+    def FXA : ProcResource<1>; // ALU, FP/VEC -> INT, MUL, DIV, CSR
+    def FXB : ProcResource<1>; // ALU, INT -> FP/VEC
+    def FXC : ProcResource<2>; // ALU, BR
+    def FXD : ProcResource<2>; // ALU
+    def FX : ProcResGroup<[!cast<ProcResource>(NAME # "FXA"),
+                           !cast<ProcResource>(NAME # "FXB"),
+                           !cast<ProcResource>(NAME # "FXC"),
+                           !cast<ProcResource>(NAME # "FXD")]>;
+    // FP
+    def FPA : ProcResource<1>; // Pipe A also handles FP/VEC -> INT
+    def FPB : ProcResource<1>;
+    def FP : ProcResGroup<[!cast<ProcResource>(NAME # "FPA"),
+                           !cast<ProcResource>(NAME # "FPB")]>;
+    // Vector
+    def VA : ProcResource<1>;
+    def VB : ProcResource<1>;
+    def V : ProcResGroup<[!cast<ProcResource>(NAME # "VA"),
+                          !cast<ProcResource>(NAME # "VB")]>;
+    // Extra unit that models the reduced throughput of vector instructions
+    // producing FP64 results.
+    if ReducedFP64Vec then
+      def FP64V : ProcResource<2>;
+  }
 
-let Latency = 7, ReleaseAtCycles = [7] in {
-  def : WriteRes<WriteIDiv32, [AscalonFXA]>;
-  def : WriteRes<WriteIDiv, [AscalonFXA]>;
-  def : WriteRes<WriteIRem32, [AscalonFXA]>;
-  def : WriteRes<WriteIRem, [AscalonFXA]>;
-}
+  defvar AscalonLS = !cast<ProcResource>(NAME # "LS");
+  defvar AscalonFXA = !cast<ProcResource>(NAME # "FXA");
+  defvar AscalonFXB = !cast<ProcResource>(NAME # "FXB");
+  defvar AscalonFXC = !cast<ProcResource>(NAME # "FXC");
+  defvar AscalonFXD = !cast<ProcResource>(NAME # "FXD");
+  defvar AscalonFX = !cast<ProcResGroup>(NAME # "FX");
+  defvar AscalonFPA = !cast<ProcResource>(NAME # "FPA");
+  defvar AscalonFPB = !cast<ProcResource>(NAME # "FPB");
+  defvar AscalonFP = !cast<ProcResGroup>(NAME # "FP");
+  defvar AscalonVA = !cast<ProcResource>(NAME # "VA");
+  defvar AscalonVB = !cast<ProcResource>(NAME # "VB");
+  defvar AscalonV = !cast<ProcResGroup>(NAME # "V");
+
+  // Only used when ReducedFP64Vec is set; fall back to the vector pipes
+  // otherwise so that the defvar is always well-formed.
+  defvar AscalonFP64V = !if(ReducedFP64Vec,
+                            !cast<ProcResource>(NAME # "FP64V"), AscalonV);
+
+  //===--------------------------------------------------------------------===//
+  // Branching
+  def : WriteRes<WriteJmp, [AscalonFXC]>;
+  def : WriteRes<WriteJal, [AscalonFXC]>;
+  def : WriteRes<WriteJalr, [AscalonFXC]>;
+
+  // Integer arithmetic and logic
+  def : WriteRes<WriteIALU32, [AscalonFX]>;
+  def : WriteRes<WriteIALU, [AscalonFX]>;
+  def : WriteRes<WriteShiftImm32, [AscalonFX]>;
+  def : WriteRes<WriteShiftImm, [AscalonFX]>;
+  def : WriteRes<WriteShiftReg32, [AscalonFX]>;
+  def : WriteRes<WriteShiftReg, [AscalonFX]>;
+
+  // Integer multiplication
+  let Latency = 3 in {
+  def : WriteRes<WriteIMul, [AscalonFXA]>;
+  def : WriteRes<WriteIMul32, [AscalonFXA]>;
+  }
 
-// Bitmanip
-def : WriteRes<WriteRotateImm, [AscalonFX]>;
-def : WriteRes<WriteRotateImm32, [AscalonFX]>;
-def : WriteRes<WriteRotateReg, [AscalonFX]>;
-def : WriteRes<WriteRotateReg32, [AscalonFX]>;
-
-def : WriteRes<WriteCLZ, [AscalonFX]>;
-def : WriteRes<WriteCLZ32, [AscalonFX]>;
-def : WriteRes<WriteCTZ, [AscalonFX]>;
-def : WriteRes<WriteCTZ32, [AscalonFX]>;
-
-def : WriteRes<WriteCPOP, [AscalonFX]>;
-def : WriteRes<WriteCPOP32, [AscalonFX]>;
-
-def : WriteRes<WriteORCB, [AscalonFX]>;
-
-def : WriteRes<WriteIMinMax, [AscalonFX]>;
-
-def : WriteRes<WriteREV8, [AscalonFX]>;
-
-def : WriteRes<WriteSHXADD, [AscalonFX]>;
-def : WriteRes<WriteSHXADD32, [AscalonFX]>;
-
-// Single-bit instructions
-def : WriteRes<WriteSingleBit, [AscalonFX]>;
-def : WriteRes<WriteSingleBitImm, [AscalonFX]>;
-def : WriteRes<WriteBEXT, [AscalonFX]>;
-def : WriteRes<WriteBEXTI, [AscalonFX]>;
-
-// Memory
-def : WriteRes<WriteSTB, [AscalonLS]>;
-def : WriteRes<WriteSTH, [AscalonLS]>;
-def : WriteRes<WriteSTW, [AscalonLS]>;
-def : WriteRes<WriteSTD, [AscalonLS]>;
-def : WriteRes<WriteFST16, [AscalonLS]>;
-def : WriteRes<WriteFST32, [AscalonLS]>;
-def : WriteRes<WriteFST64, [AscalonLS]>;
-
-let Latency = 4 in {
-def : WriteRes<WriteLDB, [AscalonLS]>;
-def : WriteRes<WriteLDH, [AscalonLS]>;
-def : WriteRes<WriteLDW, [AscalonLS]>;
-def : WriteRes<WriteLDD, [AscalonLS]>;
-def : WriteRes<WriteFLD16, [AscalonLS]>;
-def : WriteRes<WriteFLD32, [AscalonLS]>;
-def : WriteRes<WriteFLD64, [AscalonLS]>;
-}
+  // Integer division
+  // Worst case latency is used.
 
-// Atomic memory
-def : WriteRes<WriteAtomicSTW, [AscalonLS]>;
-def : WriteRes<WriteAtomicSTD, [AscalonLS]>;
+  let Latency = 7, ReleaseAtCycles = [7] in {
+    def : WriteRes<WriteIDiv32, [AscalonFXA]>;
+    def : WriteRes<WriteIDiv, [AscalonFXA]>;
+    def : WriteRes<WriteIRem32, [AscalonFXA]>;
+    def : WriteRes<WriteIRem, [AscalonFXA]>;
+  }
 
-let Latency = 4 in {
-def : WriteRes<WriteAtomicW, [AscalonLS]>;
-def : WriteRes<WriteAtomicD, [AscalonLS]>;
-def : WriteRes<WriteAtomicLDW, [AscalonLS]>;
-def : WriteRes<WriteAtomicLDD, [AscalonLS]>;
-}
+  // Bitmanip
+  def : WriteRes<WriteRotateImm, [AscalonFX]>;
+  def : WriteRes<WriteRotateImm32, [AscalonFX]>;
+  def : WriteRes<WriteRotateReg, [AscalonFX]>;
+  def : WriteRes<WriteRotateReg32, [AscalonFX]>;
+
+  def : WriteRes<WriteCLZ, [AscalonFX]>;
+  def : WriteRes<WriteCLZ32, [AscalonFX]>;
+  def : WriteRes<WriteCTZ, [AscalonFX]>;
+  def : WriteRes<WriteCTZ32, [AscalonFX]>;
+
+  def : WriteRes<WriteCPOP, [AscalonFX]>;
+  def : WriteRes<WriteCPOP32, [AscalonFX]>;
+
+  def : WriteRes<WriteORCB, [AscalonFX]>;
+
+  def : WriteRes<WriteIMinMax, [AscalonFX]>;
+
+  def : WriteRes<WriteREV8, [AscalonFX]>;
+
+  def : WriteRes<WriteSHXADD, [AscalonFX]>;
+  def : WriteRes<WriteSHXADD32, [AscalonFX]>;
+
+  // Single-bit instructions
+  def : WriteRes<WriteSingleBit, [AscalonFX]>;
+  def : WriteRes<WriteSingleBitImm, [AscalonFX]>;
+  def : WriteRes<WriteBEXT, [AscalonFX]>;
+  def : WriteRes<WriteBEXTI, [AscalonFX]>;
+
+  // Memory
+  def : WriteRes<WriteSTB, [AscalonLS]>;
+  def : WriteRes<WriteSTH, [AscalonLS]>;
+  def : WriteRes<WriteSTW, [AscalonLS]>;
+  def : WriteRes<WriteSTD, [AscalonLS]>;
+  def : WriteRes<WriteFST16, [AscalonLS]>;
+  def : WriteRes<WriteFST32, [AscalonLS]>;
+  def : WriteRes<WriteFST64, [AscalonLS]>;
+
+  let Latency = 4 in {
+  def : WriteRes<WriteLDB, [AscalonLS]>;
+  def : WriteRes<WriteLDH, [AscalonLS]>;
+  def : WriteRes<WriteLDW, [AscalonLS]>;
+  def : WriteRes<WriteLDD, [AscalonLS]>;
+  def : WriteRes<WriteFLD16, [AscalonLS]>;
+  def : WriteRes<WriteFLD32, [AscalonLS]>;
+  def : WriteRes<WriteFLD64, [AscalonLS]>;
+  }
 
-// Half precision.
-let Latency = 3 in {
-def : WriteRes<WriteFAdd16, [AscalonFP]>;
-def : WriteRes<WriteFMul16, [AscalonFP]>;
-def : WriteRes<WriteFMA16, [AscalonFP]>;
-def : WriteRes<WriteFSGNJ16, [AscalonFP]>;
-def : WriteRes<WriteFMinMax16, [AscalonFP]>;
-}
+  // Atomic memory
+  def : WriteRes<WriteAtomicSTW, [AscalonLS]>;
+  def : WriteRes<WriteAtomicSTD, [AscalonLS]>;
 
-let Latency = 7, ReleaseAtCycles = [7] in {
-def :  WriteRes<WriteFDiv16, [AscalonFP]>;
-def :  WriteRes<WriteFSqrt16, [AscalonFP]>;
-}
+  let Latency = 4 in {
+  def : WriteRes<WriteAtomicW, [AscalonLS]>;
+  def : WriteRes<WriteAtomicD, [AscalonLS]>;
+  def : WriteRes<WriteAtomicLDW, [AscalonLS]>;
+  def : WriteRes<WriteAtomicLDD, [AscalonLS]>;
+  }
 
-// Single precision.
-let Latency = 3 in {
-def : WriteRes<WriteFAdd32, [AscalonFP]>;
-def : WriteRes<WriteFMul32, [AscalonFP]>;
-def : WriteRes<WriteFMA32, [AscalonFP]>;
-def : WriteRes<WriteFSGNJ32, [AscalonFP]>;
-def : WriteRes<WriteFMinMax32, [AscalonFP]>;
-}
+  // Half precision.
+  let Latency = 3 in {
+  def : WriteRes<WriteFAdd16, [AscalonFP]>;
+  def : WriteRes<WriteFMul16, [AscalonFP]>;
+  def : WriteRes<WriteFMA16, [AscalonFP]>;
+  def : WriteRes<WriteFSGNJ16, [AscalonFP]>;
+  def : WriteRes<WriteFMinMax16, [AscalonFP]>;
+  }
 
-let Latency = 7, ReleaseAtCycles = [7] in {
-def :  WriteRes<WriteFDiv32, [AscalonFP]>;
-def :  WriteRes<WriteFSqrt32, [AscalonFP]>;
-}
+  let Latency = 7, ReleaseAtCycles = [7] in {
+  def :  WriteRes<WriteFDiv16, [AscalonFP]>;
+  def :  WriteRes<WriteFSqrt16, [AscalonFP]>;
+  }
 
-// Double precision
-let Latency = 3 in {
-def : WriteRes<WriteFAdd64, [AscalonFP]>;
-def : WriteRes<WriteFMul64, [AscalonFP]>;
-def : WriteRes<WriteFMA64, [AscalonFP]>;
-def : WriteRes<WriteFSGNJ64, [AscalonFP]>;
-def : WriteRes<WriteFMinMax64, [AscalonFP]>;
-}
+  // Single precision.
+  let Latency = 3 in {
+  def : WriteRes<WriteFAdd32, [AscalonFP]>;
+  def : WriteRes<WriteFMul32, [AscalonFP]>;
+  def : WriteRes<WriteFMA32, [AscalonFP]>;
+  def : WriteRes<WriteFSGNJ32, [AscalonFP]>;
+  def : WriteRes<WriteFMinMax32, [AscalonFP]>;
+  }
 
-let Latency = 12, ReleaseAtCycles = [12] in {
-def :  WriteRes<WriteFDiv64, [AscalonFP]>;
-def :  WriteRes<WriteFSqrt64, [AscalonFP]>;
-}
+  let Latency = 7, ReleaseAtCycles = [7] in {
+  def :  WriteRes<WriteFDiv32, [AscalonFP]>;
+  def :  WriteRes<WriteFSqrt32, [AscalonFP]>;
+  }
 
-// Conversions
-def : WriteRes<WriteFCvtI32ToF16, [AscalonFXB]>;
-def : WriteRes<WriteFCvtI32ToF32, [AscalonFXB]>;
-def : WriteRes<WriteFCvtI32ToF64, [AscalonFXB]>;
-def : WriteRes<WriteFCvtI64ToF16, [AscalonFXB]>;
-def : WriteRes<WriteFCvtI64ToF32, [AscalonFXB]>;
-def : WriteRes<WriteFCvtI64ToF64, [AscalonFXB]>;
-def : WriteRes<WriteFCvtF16ToI32, [AscalonFXA]>;
-def : WriteRes<WriteFCvtF16ToI64, [AscalonFXA]>;
-def : WriteRes<WriteFCvtF16ToF32, [AscalonFP]>;
-def : WriteRes<WriteFCvtF16ToF64, [AscalonFP]>;
-def : WriteRes<WriteFCvtF32ToI32, [AscalonFXA]>;
-def : WriteRes<WriteFCvtF32ToI64, [AscalonFXA]>;
-def : WriteRes<WriteFCvtF32ToF16, [AscalonFP]>;
-def : WriteRes<WriteFCvtF32ToF64, [AscalonFP]>;
-def : WriteRes<WriteFCvtF64ToI32, [AscalonFXA]>;
-def : WriteRes<WriteFCvtF64ToI64, [AscalonFXA]>;
-def : WriteRes<WriteFCvtF64ToF16, [AscalonFP]>;
-def : WriteRes<WriteFCvtF64ToF32, [AscalonFP]>;
-
-def : WriteRes<WriteFClass16, [AscalonFP]>;
-def : WriteRes<WriteFClass32, [AscalonFP]>;
-def : WriteRes<WriteFClass64, [AscalonFP]>;
-def : WriteRes<WriteFCmp16, [AscalonFP]>;
-def : WriteRes<WriteFCmp32, [AscalonFP]>;
-def : WriteRes<WriteFCmp64, [AscalonFP]>;
-
-def : WriteRes<WriteFMovI16ToF16, [AscalonFXB]>;
-def : WriteRes<WriteFMovF16ToI16, [AscalonFXA]>;
-def : WriteRes<WriteFMovI32ToF32, [AscalonFXB]>;
-def : WriteRes<WriteFMovF32ToI32, [AscalonFXA]>;
-def : WriteRes<WriteFMovI64ToF64, [AscalonFXB]>;
-def : WriteRes<WriteFMovF64ToI64, [AscalonFXA]>;
-
-// Others
-def : WriteRes<WriteCSR, [AscalonFXA]>;
-def : WriteRes<WriteNop, [AscalonFX]>;
-
-def : InstRW<[WriteIALU], (instrs COPY)>;
+  // Double precision
+  let Latency = 3 in {
+  def : WriteRes<WriteFAdd64, [AscalonFP]>;
+  def : WriteRes<WriteFMul64, [AscalonFP]>;
+  def : WriteRes<WriteFMA64, [AscalonFP]>;
+  def : WriteRes<WriteFSGNJ64, [AscalonFP]>;
+  def : WriteRes<WriteFMinMax64, [AscalonFP]>;
+  }
 
-//===----------------------------------------------------------------------===//
-// Bypass and advance
-def : ReadAdvance<ReadJmp, 0>;
-def : ReadAdvance<ReadJalr, 0>;
-def : ReadAdvance<ReadCSR, 0>;
-def : ReadAdvance<ReadStoreData, 0>;
-def : ReadAdvance<ReadMemBase, 0>;
-def : ReadAdvance<ReadIALU, 0>;
-def : ReadAdvance<ReadIALU32, 0>;
-def : ReadAdvance<ReadShiftImm, 0>;
-def : ReadAdvance<ReadShiftImm32, 0>;
-def : ReadAdvance<ReadShiftReg, 0>;
-def : ReadAdvance<ReadShiftReg32, 0>;
-def : ReadAdvance<ReadIDiv, 0>;
-def : ReadAdvance<ReadIDiv32, 0>;
-def : ReadAdvance<ReadIRem, 0>;
-def : ReadAdvance<ReadIRem32, 0>;
-def : ReadAdvance<ReadIMul, 0>;
-def : ReadAdvance<ReadIMul32, 0>;
-def : ReadAdvance<ReadAtomicWA, 0>;
-def : ReadAdvance<ReadAtomicWD, 0>;
-def : ReadAdvance<ReadAtomicDA, 0>;
-def : ReadAdvance<ReadAtomicDD, 0>;
-def : ReadAdvance<ReadAtomicLDW, 0>;
-def : ReadAdvance<ReadAtomicLDD, 0>;
-def : ReadAdvance<ReadAtomicSTW, 0>;
-def : ReadAdvance<ReadAtomicSTD, 0>;
-def : ReadAdvance<ReadFStoreData, 0>;
-def : ReadAdvance<ReadFMemBase, 0>;
-def : ReadAdvance<ReadFAdd16, 0>;
-def : ReadAdvance<ReadFAdd32, 0>;
-def : ReadAdvance<ReadFAdd64, 0>;
-def : ReadAdvance<ReadFMul16, 0>;
-def : ReadAdvance<ReadFMA16, 0>;
-def : ReadAdvance<ReadFMA16Addend, 0>;
-def : ReadAdvance<ReadFMul32, 0>;
-def : ReadAdvance<ReadFMul64, 0>;
-def : ReadAdvance<ReadFMA32, 0>;
-def : ReadAdvance<ReadFMA32Addend, 0>;
-def : ReadAdvance<ReadFMA64, 0>;
-def : ReadAdvance<ReadFMA64Addend, 0>;
-def : ReadAdvance<ReadFDiv16, 0>;
-def : ReadAdvance<ReadFDiv32, 0>;
-def : ReadAdvance<ReadFDiv64, 0>;
-def : ReadAdvance<ReadFSqrt16, 0>;
-def : ReadAdvance<ReadFSqrt32, 0>;
-def : ReadAdvance<ReadFSqrt64, 0>;
-def : ReadAdvance<ReadFCmp16, 0>;
-def : ReadAdvance<ReadFCmp32, 0>;
-def : ReadAdvance<ReadFCmp64, 0>;
-def : ReadAdvance<ReadFSGNJ16, 0>;
-def : ReadAdvance<ReadFSGNJ32, 0>;
-def : ReadAdvance<ReadFSGNJ64, 0>;
-def : ReadAdvance<ReadFMinMax16, 0>;
-def : ReadAdvance<ReadFMinMax32, 0>;
-def : ReadAdvance<ReadFMinMax64, 0>;
-def : ReadAdvance<ReadFCvtF16ToI32, 0>;
-def : ReadAdvance<ReadFCvtF16ToI64, 0>;
-def : ReadAdvance<ReadFCvtF32ToI32, 0>;
-def : ReadAdvance<ReadFCvtF32ToI64, 0>;
-def : ReadAdvance<ReadFCvtF64ToI32, 0>;
-def : ReadAdvance<ReadFCvtF64ToI64, 0>;
-def : ReadAdvance<ReadFCvtI32ToF16, 0>;
-def : ReadAdvance<ReadFCvtI32ToF32, 0>;
-def : ReadAdvance<ReadFCvtI32ToF64, 0>;
-def : ReadAdvance<ReadFCvtI64ToF16, 0>;
-def : ReadAdvance<ReadFCvtI64ToF32, 0>;
-def : ReadAdvance<ReadFCvtI64ToF64, 0>;
-def : ReadAdvance<ReadFCvtF32ToF64, 0>;
-def : ReadAdvance<ReadFCvtF64ToF32, 0>;
-def : ReadAdvance<ReadFCvtF16ToF32, 0>;
-def : ReadAdvance<ReadFCvtF32ToF16, 0>;
-def : ReadAdvance<ReadFCvtF16ToF64, 0>;
-def : ReadAdvance<ReadFCvtF64ToF16, 0>;
-def : ReadAdvance<ReadFMovF16ToI16, 0>;
-def : ReadAdvance<ReadFMovI16ToF16, 0>;
-def : ReadAdvance<ReadFMovF32ToI32, 0>;
-def : ReadAdvance<ReadFMovI32ToF32, 0>;
-def : ReadAdvance<ReadFMovF64ToI64, 0>;
-def : ReadAdvance<ReadFMovI64ToF64, 0>;
-def : ReadAdvance<ReadFClass16, 0>;
-def : ReadAdvance<ReadFClass32, 0>;
-def : ReadAdvance<ReadFClass64, 0>;
-
-// Bitmanip
-def : ReadAdvance<ReadRotateImm, 0>;
-def : ReadAdvance<ReadRotateImm32, 0>;
-def : ReadAdvance<ReadRotateReg, 0>;
-def : ReadAdvance<ReadRotateReg32, 0>;
-def : ReadAdvance<ReadCLZ, 0>;
-def : ReadAdvance<ReadCLZ32, 0>;
-def : ReadAdvance<ReadCTZ, 0>;
-def : ReadAdvance<ReadCTZ32, 0>;
-def : ReadAdvance<ReadCPOP, 0>;
-def : ReadAdvance<ReadCPOP32, 0>;
-def : ReadAdvance<ReadORCB, 0>;
-def : ReadAdvance<ReadIMinMax, 0>;
-def : ReadAdvance<ReadREV8, 0>;
-def : ReadAdvance<ReadSHXADD, 0>;
-def : ReadAdvance<ReadSHXADD32, 0>;
-// Single-bit instructions
-def : ReadAdvance<ReadSingleBit, 0>;
-def : ReadAdvance<ReadSingleBitImm, 0>;
+  let Latency = 12, ReleaseAtCycles = [12] in {
+  def :  WriteRes<WriteFDiv64, [AscalonFP]>;
+  def :  WriteRes<WriteFSqrt64, [AscalonFP]>;
+  }
 
-//===----------------------------------------------------------------------===//
-// Vector
-def : WriteRes<WriteRdVLENB, [AscalonFXA]>;
-
-// Configuration-Setting Instructions
-def : WriteRes<WriteVSETVLI, [AscalonV]>;
-def : WriteRes<WriteVSETIVLI, [AscalonV]>;
-let Latency = 2 in {
-  def : WriteRes<WriteVSETVL, [AscalonV]>;
-}
+  // Conversions
+  def : WriteRes<WriteFCvtI32ToF16, [AscalonFXB]>;
+  def : WriteRes<WriteFCvtI32ToF32, [AscalonFXB]>;
+  def : WriteRes<WriteFCvtI32ToF64, [AscalonFXB]>;
+  def : WriteRes<WriteFCvtI64ToF16, [AscalonFXB]>;
+  def : WriteRes<WriteFCvtI64ToF32, [AscalonFXB]>;
+  def : WriteRes<WriteFCvtI64ToF64, [AscalonFXB]>;
+  def : WriteRes<WriteFCvtF16ToI32, [AscalonFXA]>;
+  def : WriteRes<WriteFCvtF16ToI64, [AscalonFXA]>;
+  def : WriteRes<WriteFCvtF16ToF32, [AscalonFP]>;
+  def : WriteRes<WriteFCvtF16ToF64, [AscalonFP]>;
+  def : WriteRes<WriteFCvtF32ToI32, [AscalonFXA]>;
+  def : WriteRes<WriteFCvtF32ToI64, [AscalonFXA]>;
+  def : WriteRes<WriteFCvtF32ToF16, [AscalonFP]>;
+  def : WriteRes<WriteFCvtF32ToF64, [AscalonFP]>;
+  def : WriteRes<WriteFCvtF64ToI32, [AscalonFXA]>;
+  def : WriteRes<WriteFCvtF64ToI64, [AscalonFXA]>;
+  def : WriteRes<WriteFCvtF64ToF16, [AscalonFP]>;
+  def : WriteRes<WriteFCvtF64ToF32, [AscalonFP]>;
+
+  def : WriteRes<WriteFClass16, [AscalonFP]>;
+  def : WriteRes<WriteFClass32, [AscalonFP]>;
+  def : WriteRes<WriteFClass64, [AscalonFP]>;
+  def : WriteRes<WriteFCmp16, [AscalonFP]>;
+  def : WriteRes<WriteFCmp32, [AscalonFP]>;
+  def : WriteRes<WriteFCmp64, [AscalonFP]>;
+
+  def : WriteRes<WriteFMovI16ToF16, [AscalonFXB]>;
+  def : WriteRes<WriteFMovF16ToI16, [AscalonFXA]>;
+  def : WriteRes<WriteFMovI32ToF32, [AscalonFXB]>;
+  def : WriteRes<WriteFMovF32ToI32, [AscalonFXA]>;
+  def : WriteRes<WriteFMovI64ToF64, [AscalonFXB]>;
+  def : WriteRes<WriteFMovF64ToI64, [AscalonFXA]>;
+
+  // Others
+  def : WriteRes<WriteCSR, [AscalonFXA]>;
+  def : WriteRes<WriteNop, [AscalonFX]>;
+
+  def : InstRW<[WriteIALU], (instrs COPY)>;
+
+  //===--------------------------------------------------------------------===//
+  // Bypass and advance
+  def : ReadAdvance<ReadJmp, 0>;
+  def : ReadAdvance<ReadJalr, 0>;
+  def : ReadAdvance<ReadCSR, 0>;
+  def : ReadAdvance<ReadStoreData, 0>;
+  def : ReadAdvance<ReadMemBase, 0>;
+  def : ReadAdvance<ReadIALU, 0>;
+  def : ReadAdvance<ReadIALU32, 0>;
+  def : ReadAdvance<ReadShiftImm, 0>;
+  def : ReadAdvance<ReadShiftImm32, 0>;
+  def : ReadAdvance<ReadShiftReg, 0>;
+  def : ReadAdvance<ReadShiftReg32, 0>;
+  def : ReadAdvance<ReadIDiv, 0>;
+  def : ReadAdvance<ReadIDiv32, 0>;
+  def : ReadAdvance<ReadIRem, 0>;
+  def : ReadAdvance<ReadIRem32, 0>;
+  def : ReadAdvance<ReadIMul, 0>;
+  def : ReadAdvance<ReadIMul32, 0>;
+  def : ReadAdvance<ReadAtomicWA, 0>;
+  def : ReadAdvance<ReadAtomicWD, 0>;
+  def : ReadAdvance<ReadAtomicDA, 0>;
+  def : ReadAdvance<ReadAtomicDD, 0>;
+  def : ReadAdvance<ReadAtomicLDW, 0>;
+  def : ReadAdvance<ReadAtomicLDD, 0>;
+  def : ReadAdvance<ReadAtomicSTW, 0>;
+  def : ReadAdvance<ReadAtomicSTD, 0>;
+  def : ReadAdvance<ReadFStoreData, 0>;
+  def : ReadAdvance<ReadFMemBase, 0>;
+  def : ReadAdvance<ReadFAdd16, 0>;
+  def : ReadAdvance<ReadFAdd32, 0>;
+  def : ReadAdvance<ReadFAdd64, 0>;
+  def : ReadAdvance<ReadFMul16, 0>;
+  def : ReadAdvance<ReadFMA16, 0>;
+  def : ReadAdvance<ReadFMA16Addend, 0>;
+  def : ReadAdvance<ReadFMul32, 0>;
+  def : ReadAdvance<ReadFMul64, 0>;
+  def : ReadAdvance<ReadFMA32, 0>;
+  def : ReadAdvance<ReadFMA32Addend, 0>;
+  def : ReadAdvance<ReadFMA64, 0>;
+  def : ReadAdvance<ReadFMA64Addend, 0>;
+  def : ReadAdvance<ReadFDiv16, 0>;
+  def : ReadAdvance<ReadFDiv32, 0>;
+  def : ReadAdvance<ReadFDiv64, 0>;
+  def : ReadAdvance<ReadFSqrt16, 0>;
+  def : ReadAdvance<ReadFSqrt32, 0>;
+  def : ReadAdvance<ReadFSqrt64, 0>;
+  def : ReadAdvance<ReadFCmp16, 0>;
+  def : ReadAdvance<ReadFCmp32, 0>;
+  def : ReadAdvance<ReadFCmp64, 0>;
+  def : ReadAdvance<ReadFSGNJ16, 0>;
+  def : ReadAdvance<ReadFSGNJ32, 0>;
+  def : ReadAdvance<ReadFSGNJ64, 0>;
+  def : ReadAdvance<ReadFMinMax16, 0>;
+  def : ReadAdvance<ReadFMinMax32, 0>;
+  def : ReadAdvance<ReadFMinMax64, 0>;
+  def : ReadAdvance<ReadFCvtF16ToI32, 0>;
+  def : ReadAdvance<ReadFCvtF16ToI64, 0>;
+  def : ReadAdvance<ReadFCvtF32ToI32, 0>;
+  def : ReadAdvance<ReadFCvtF32ToI64, 0>;
+  def : ReadAdvance<ReadFCvtF64ToI32, 0>;
+  def : ReadAdvance<ReadFCvtF64ToI64, 0>;
+  def : ReadAdvance<ReadFCvtI32ToF16, 0>;
+  def : ReadAdvance<ReadFCvtI32ToF32, 0>;
+  def : ReadAdvance<ReadFCvtI32ToF64, 0>;
+  def : ReadAdvance<ReadFCvtI64ToF16, 0>;
+  def : ReadAdvance<ReadFCvtI64ToF32, 0>;
+  def : ReadAdvance<ReadFCvtI64ToF64, 0>;
+  def : ReadAdvance<ReadFCvtF32ToF64, 0>;
+  def : ReadAdvance<ReadFCvtF64ToF32, 0>;
+  def : ReadAdvance<ReadFCvtF16ToF32, 0>;
+  def : ReadAdvance<ReadFCvtF32ToF16, 0>;
+  def : ReadAdvance<ReadFCvtF16ToF64, 0>;
+  def : ReadAdvance<ReadFCvtF64ToF16, 0>;
+  def : ReadAdvance<ReadFMovF16ToI16, 0>;
+  def : ReadAdvance<ReadFMovI16ToF16, 0>;
+  def : ReadAdvance<ReadFMovF32ToI32, 0>;
+  def : ReadAdvance<ReadFMovI32ToF32, 0>;
+  def : ReadAdvance<ReadFMovF64ToI64, 0>;
+  def : ReadAdvance<ReadFMovI64ToF64, 0>;
+  def : ReadAdvance<ReadFClass16, 0>;
+  def : ReadAdvance<ReadFClass32, 0>;
+  def : ReadAdvance<ReadFClass64, 0>;
+
+  // Bitmanip
+  def : ReadAdvance<ReadRotateImm, 0>;
+  def : ReadAdvance<ReadRotateImm32, 0>;
+  def : ReadAdvance<ReadRotateReg, 0>;
+  def : ReadAdvance<ReadRotateReg32, 0>;
+  def : ReadAdvance<ReadCLZ, 0>;
+  def : ReadAdvance<ReadCLZ32, 0>;
+  def : ReadAdvance<ReadCTZ, 0>;
+  def : ReadAdvance<ReadCTZ32, 0>;
+  def : ReadAdvance<ReadCPOP, 0>;
+  def : ReadAdvance<ReadCPOP32, 0>;
+  def : ReadAdvance<ReadORCB, 0>;
+  def : ReadAdvance<ReadIMinMax, 0>;
+  def : ReadAdvance<ReadREV8, 0>;
+  def : ReadAdvance<ReadSHXADD, 0>;
+  def : ReadAdvance<ReadSHXADD32, 0>;
+  // Single-bit instructions
+  def : ReadAdvance<ReadSingleBit, 0>;
+  def : ReadAdvance<ReadSingleBitImm, 0>;
+
+  //===--------------------------------------------------------------------===//
+  // Vector
+  def : WriteRes<WriteRdVLENB, [AscalonFXA]>;
 
-// Vector Loads and Stores
-foreach mx = SchedMxList in {
-  defvar Cycles = AscalonGetCyclesDefault<mx>.c;
-  defvar IsWorstCase = AscalonIsWorstCaseMX<mx, SchedMxList>.c;
-  let Latency = Cycles in {
-    defm "" : LMULWriteResMX<"WriteVLDE",    [AscalonLS], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVLDFF",   [AscalonLS], mx, IsWorstCase>;
+  // Configuration-Setting Instructions
+  def : WriteRes<WriteVSETVLI, [AscalonV]>;
+  def : WriteRes<WriteVSETIVLI, [AscalonV]>;
+  let Latency = 2 in {
+    def : WriteRes<WriteVSETVL, [AscalonV]>;
   }
-  defm "" : LMULWriteResMX<"WriteVSTE",    [AscalonLS], mx, IsWorstCase>;
-}
 
-foreach mx = SchedMxList in {
-  defvar IsWorstCase = AscalonIsWorstCaseMX<mx, SchedMxList>.c;
-  defm "" : LMULWriteResMX<"WriteVLDM",    [AscalonLS], mx, IsWorstCase>;
-  defm "" : LMULWriteResMX<"WriteVSTM",    [AscalonLS], mx, IsWorstCase>;
-}
+  // Vector Loads and Stores
+  foreach mx = SchedMxList in {
+    defvar Cycles = AscalonGetCyclesDefault<mx>.c;
+    defvar IsWorstCase = AscalonIsWorstCaseMX<mx, SchedMxList>.c;
+    let Latency = Cycles in {
+      defm "" : LMULWriteResMX<"WriteVLDE",    [AscalonLS], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVLDFF",   [AscalonLS], mx, IsWorstCase>;
+    }
+    defm "" : LMULWriteResMX<"WriteVSTE",    [AscalonLS], mx, IsWorstCase>;
+  }
 
-foreach mx = SchedMxListEEW8 in {
-  defvar Cycles = AscalonGetCyclesLMUL<mx, 2>.c;
-  defvar IsWorstCase = AscalonIsWorstCaseMX<mx, SchedMxList>.c;
-  let Latency = Cycles in {
-    defm "" : LMULWriteResMX<"WriteVLDS8", [AscalonLS], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVLDUX8", [AscalonLS], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVLDOX8", [AscalonLS], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVSTS8",  [AscalonLS], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVSTUX8", [AscalonLS], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVSTOX8", [AscalonLS], mx, IsWorstCase>;
+  foreach mx = SchedMxList in {
+    defvar IsWorstCase = AscalonIsWorstCaseMX<mx, SchedMxList>.c;
+    defm "" : LMULWriteResMX<"WriteVLDM",    [AscalonLS], mx, IsWorstCase>;
+    defm "" : LMULWriteResMX<"WriteVSTM",    [AscalonLS], mx, IsWorstCase>;
   }
-}
-foreach mx = SchedMxListEEW16 in {
-  defvar Cycles = AscalonGetCyclesLMUL<mx, 2>.c;
-  defvar IsWorstCase = AscalonIsWorstCaseMX<mx, SchedMxList>.c;
-  let Latency = Cycles in {
-    defm "" : LMULWriteResMX<"WriteVLDS16", [AscalonLS], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVLDUX16", [AscalonLS], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVLDOX16", [AscalonLS], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVSTS16",  [AscalonLS], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVSTUX16", [AscalonLS], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVSTOX16", [AscalonLS], mx, IsWorstCase>;
+
+  foreach mx = SchedMxListEEW8 in {
+    defvar Cycles = AscalonGetCyclesLMUL<mx, 2>.c;
+    defvar IsWorstCase = AscalonIsWorstCaseMX<mx, SchedMxList>.c;
+    let Latency = Cycles in {
+      defm "" : LMULWriteResMX<"WriteVLDS8", [AscalonLS], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVLDUX8", [AscalonLS], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVLDOX8", [AscalonLS], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVSTS8",  [AscalonLS], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVSTUX8", [AscalonLS], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVSTOX8", [AscalonLS], mx, IsWorstCase>;
+    }
   }
-}
-foreach mx = SchedMxListEEW32 in {
-  defvar Cycles = AscalonGetCyclesLMUL<mx, 2>.c;
-  defvar IsWorstCase = AscalonIsWorstCaseMX<mx, SchedMxList>.c;
-  let Latency = Cycles in {
-    defm "" : LMULWriteResMX<"WriteVLDS32", [AscalonLS], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVLDUX32", [AscalonLS], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVLDOX32", [AscalonLS], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVSTS32",  [AscalonLS], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVSTUX32", [AscalonLS], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVSTOX32", [AscalonLS], mx, IsWorstCase>;
+  foreach mx = SchedMxListEEW16 in {
+    defvar Cycles = AscalonGetCyclesLMUL<mx, 2>.c;
+    defvar IsWorstCase = AscalonIsWorstCaseMX<mx, SchedMxList>.c;
+    let Latency = Cycles in {
+      defm "" : LMULWriteResMX<"WriteVLDS16", [AscalonLS], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVLDUX16", [AscalonLS], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVLDOX16", [AscalonLS], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVSTS16",  [AscalonLS], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVSTUX16", [AscalonLS], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVSTOX16", [AscalonLS], mx, IsWorstCase>;
+    }
   }
-}
-foreach mx = SchedMxListEEW64 in {
-  defvar Cycles = AscalonGetCyclesLMUL<mx, 2>.c;
-  defvar IsWorstCase = AscalonIsWorstCaseMX<mx, SchedMxList>.c;
-  let Latency = Cycles in {
-    defm "" : LMULWriteResMX<"WriteVLDS64", [AscalonLS], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVLDUX64", [AscalonLS], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVLDOX64", [AscalonLS], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVSTS64",  [AscalonLS], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVSTUX64", [AscalonLS], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVSTOX64", [AscalonLS], mx, IsWorstCase>;
+  foreach mx = SchedMxListEEW32 in {
+    defvar Cycles = AscalonGetCyclesLMUL<mx, 2>.c;
+    defvar IsWorstCase = AscalonIsWorstCaseMX<mx, SchedMxList>.c;
+    let Latency = Cycles in {
+      defm "" : LMULWriteResMX<"WriteVLDS32", [AscalonLS], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVLDUX32", [AscalonLS], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVLDOX32", [AscalonLS], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVSTS32",  [AscalonLS], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVSTUX32", [AscalonLS], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVSTOX32", [AscalonLS], mx, IsWorstCase>;
+    }
+  }
+  foreach mx = SchedMxListEEW64 in {
+    defvar Cycles = AscalonGetCyclesLMUL<mx, 2>.c;
+    defvar IsWorstCase = AscalonIsWorstCaseMX<mx, SchedMxList>.c;
+    let Latency = Cycles in {
+      defm "" : LMULWriteResMX<"WriteVLDS64", [AscalonLS], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVLDUX64", [AscalonLS], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVLDOX64", [AscalonLS], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVSTS64",  [AscalonLS], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVSTUX64", [AscalonLS], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVSTOX64", [AscalonLS], mx, IsWorstCase>;
+    }
   }
-}
 
-// VLD*R is not LMUL aware
-def : WriteRes<WriteVLD1R,  [AscalonLS]>;
-def : WriteRes<WriteVLD2R,  [AscalonLS]>;
-def : WriteRes<WriteVLD4R,  [AscalonLS]>;
-def : WriteRes<WriteVLD8R,  [AscalonLS]>;
-// VST*R is not LMUL aware
-def : WriteRes<WriteVST1R,   [AscalonLS]>;
-def : WriteRes<WriteVST2R,   [AscalonLS]>;
-def : WriteRes<WriteVST4R,   [AscalonLS]>;
-def : WriteRes<WriteVST8R,   [AscalonLS]>;
-
-// Segmented Loads and Stores
-foreach mx = SchedMxList in {
-  foreach eew = [8, 16, 32, 64] in {
-    foreach nf=2-8 in {
-      defvar Cycles = AscalonGetCyclesDefault<mx>.c;
-      defvar IsWorstCase = AscalonIsWorstCaseMX<mx, SchedMxList>.c;
-      let Latency = Cycles in {
-        defm "" : LMULWriteResMX<"WriteVLSEG" # nf # "e" # eew,   [AscalonLS], mx, IsWorstCase>;
-        defm "" : LMULWriteResMX<"WriteVLSEGFF" # nf # "e" # eew, [AscalonLS], mx, IsWorstCase>;
+  // VLD*R is not LMUL aware
+  def : WriteRes<WriteVLD1R,  [AscalonLS]>;
+  def : WriteRes<WriteVLD2R,  [AscalonLS]>;
+  def : WriteRes<WriteVLD4R,  [AscalonLS]>;
+  def : WriteRes<WriteVLD8R,  [AscalonLS]>;
+  // VST*R is not LMUL aware
+  def : WriteRes<WriteVST1R,   [AscalonLS]>;
+  def : WriteRes<WriteVST2R,   [AscalonLS]>;
+  def : WriteRes<WriteVST4R,   [AscalonLS]>;
+  def : WriteRes<WriteVST8R,   [AscalonLS]>;
+
+  // Segmented Loads and Stores
+  foreach mx = SchedMxList in {
+    foreach eew = [8, 16, 32, 64] in {
+      foreach nf=2-8 in {
+        defvar Cycles = AscalonGetCyclesDefault<mx>.c;
+        defvar IsWorstCase = AscalonIsWorstCaseMX<mx, SchedMxList>.c;
+        let Latency = Cycles in {
+          defm "" : LMULWriteResMX<"WriteVLSEG" # nf # "e" # eew,   [AscalonLS], mx, IsWorstCase>;
+          defm "" : LMULWriteResMX<"WriteVLSEGFF" # nf # "e" # eew, [AscalonLS], mx, IsWorstCase>;
+        }
+        let Latency = 1, AcquireAtCycles = [1], ReleaseAtCycles = [!add(1, Cycles)] in
+        defm "" : LMULWriteResMX<"WriteVSSEG" # nf # "e" # eew,   [AscalonLS], mx, IsWorstCase>;
       }
-      let Latency = 1, AcquireAtCycles = [1], ReleaseAtCycles = [!add(1, Cycles)] in
-      defm "" : LMULWriteResMX<"WriteVSSEG" # nf # "e" # eew,   [AscalonLS], mx, IsWorstCase>;
     }
   }
-}
-foreach mx = SchedMxList in {
-  foreach nf=2-8 in {
-    foreach eew = [8, 16, 32, 64] in {
-      defvar Cycles = AscalonGetCyclesStridedSegmented<mx, eew>.c;
-      defvar IsWorstCase = AscalonIsWorstCaseMX<mx, SchedMxList>.c;
-      let Latency = Cycles in {
-        defm "" : LMULWriteResMX<"WriteVLSSEG" # nf # "e" # eew,  [AscalonLS], mx, IsWorstCase>;
-        defm "" : LMULWriteResMX<"WriteVLUXSEG" # nf # "e" # eew, [AscalonLS], mx, IsWorstCase>;
-        defm "" : LMULWriteResMX<"WriteVLOXSEG" # nf # "e" # eew, [AscalonLS], mx, IsWorstCase>;
-        defm "" : LMULWriteResMX<"WriteVSSSEG" # nf # "e" # eew,  [AscalonLS], mx, IsWorstCase>;
-        defm "" : LMULWriteResMX<"WriteVSUXSEG" # nf # "e" # eew, [AscalonLS], mx, IsWorstCase>;
-        defm "" : LMULWriteResMX<"WriteVSOXSEG" # nf # "e" # eew, [AscalonLS], mx, IsWorstCase>;
+  foreach mx = SchedMxList in {
+    foreach nf=2-8 in {
+      foreach eew = [8, 16, 32, 64] in {
+        defvar Cycles = AscalonGetCyclesStridedSegmented<mx, eew>.c;
+        defvar IsWorstCase = AscalonIsWorstCaseMX<mx, SchedMxList>.c;
+        let Latency = Cycles in {
+          defm "" : LMULWriteResMX<"WriteVLSSEG" # nf # "e" # eew,  [AscalonLS], mx, IsWorstCase>;
+          defm "" : LMULWriteResMX<"WriteVLUXSEG" # nf # "e" # eew, [AscalonLS], mx, IsWorstCase>;
+          defm "" : LMULWriteResMX<"WriteVLOXSEG" # nf # "e" # eew, [AscalonLS], mx, IsWorstCase>;
+          defm "" : LMULWriteResMX<"WriteVSSSEG" # nf # "e" # eew,  [AscalonLS], mx, IsWorstCase>;
+          defm "" : LMULWriteResMX<"WriteVSUXSEG" # nf # "e" # eew, [AscalonLS], mx, IsWorstCase>;
+          defm "" : LMULWriteResMX<"WriteVSOXSEG" # nf # "e" # eew, [AscalonLS], mx, IsWorstCase>;
+        }
       }
     }
   }
-}
 
-// Vector Fixed-Point Arithmetic Instructions
-foreach mx = SchedMxList in {
-  defvar Cycles = AscalonGetCyclesDefault<mx>.c;
-  defvar IsWorstCase = AscalonIsWorstCaseMX<mx, SchedMxList>.c;
-  let Latency = Cycles, ReleaseAtCycles = [1, Cycles] in {
-    defm "" : LMULWriteResMX<"WriteVSALUV",   [AscalonFX, AscalonV], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVSALUX",   [AscalonFX, AscalonV], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVSALUI",   [AscalonFX, AscalonV], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVAALUV",   [AscalonFX, AscalonV], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVAALUX",   [AscalonFX, AscalonV], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVSMulV",   [AscalonFXA, AscalonV], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVSMulX",   [AscalonFXA, AscalonV], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVSShiftV", [AscalonFX, AscalonV], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVSShiftX", [AscalonFX, AscalonV], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVSShiftI", [AscalonFX, AscalonV], mx, IsWorstCase>;
+  // Vector Fixed-Point Arithmetic Instructions
+  foreach mx = SchedMxList in {
+    defvar Cycles = AscalonGetCyclesDefault<mx>.c;
+    defvar IsWorstCase = AscalonIsWorstCaseMX<mx, SchedMxList>.c;
+    let Latency = Cycles, ReleaseAtCycles = [1, Cycles] in {
+      defm "" : LMULWriteResMX<"WriteVSALUV",   [AscalonFX, AscalonV], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVSALUX",   [AscalonFX, AscalonV], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVSALUI",   [AscalonFX, AscalonV], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVAALUV",   [AscalonFX, AscalonV], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVAALUX",   [AscalonFX, AscalonV], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVSMulV",   [AscalonFXA, AscalonV], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVSMulX",   [AscalonFXA, AscalonV], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVSShiftV", [AscalonFX, AscalonV], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVSShiftX", [AscalonFX, AscalonV], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVSShiftI", [AscalonFX, AscalonV], mx, IsWorstCase>;
+    }
   }
-}
-// Narrowing
-foreach mx = SchedMxListW in {
-  defvar Cycles = AscalonGetCyclesNarrowing<mx>.c;
-  defvar IsWorstCase = AscalonIsWorstCaseMX<mx, SchedMxListW>.c;
-  let Latency = Cycles, ReleaseAtCycles = [1, Cycles] in {
-    defm "" : LMULWriteResMX<"WriteVNClipV",  [AscalonFX, AscalonV], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVNClipX",  [AscalonFX, AscalonV], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVNClipI",  [AscalonFX, AscalonV], mx, IsWorstCase>;
+  // Narrowing
+  foreach mx = SchedMxListW in {
+    defvar Cycles = AscalonGetCyclesNarrowing<mx>.c;
+    defvar IsWorstCase = AscalonIsWorstCaseMX<mx, SchedMxListW>.c;
+    let Latency = Cycles, ReleaseAtCycles = [1, Cycles] in {
+      defm "" : LMULWriteResMX<"WriteVNClipV",  [AscalonFX, AscalonV], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVNClipX",  [AscalonFX, AscalonV], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVNClipI",  [AscalonFX, AscalonV], mx, IsWorstCase>;
+    }
   }
-}
 
-// Configuration-Setting Instructions
-def : ReadAdvance<ReadVSETVLI, 1>;
-def : ReadAdvance<ReadVSETVL, 1>;
-
-// Vector Loads and Stores
-def : ReadAdvance<ReadVLDX, 0>;
-def : ReadAdvance<ReadVSTX, 0>;
-defm "" : LMULReadAdvance<"ReadVSTEV", 0>;
-defm "" : LMULReadAdvance<"ReadVSTM", 0>;
-def : ReadAdvance<ReadVLDSX, 0>;
-def : ReadAdvance<ReadVSTSX, 0>;
-defm "" : LMULReadAdvance<"ReadVSTS8V", 0>;
-defm "" : LMULReadAdvance<"ReadVSTS16V", 0>;
-defm "" : LMULReadAdvance<"ReadVSTS32V", 0>;
-defm "" : LMULReadAdvance<"ReadVSTS64V", 0>;
-defm "" : LMULReadAdvance<"ReadVLDUXV", 0>;
-defm "" : LMULReadAdvance<"ReadVLDOXV", 0>;
-defm "" : LMULReadAdvance<"ReadVSTUX8", 0>;
-defm "" : LMULReadAdvance<"ReadVSTUX16", 0>;
-defm "" : LMULReadAdvance<"ReadVSTUX32", 0>;
-defm "" : LMULReadAdvance<"ReadVSTUX64", 0>;
-defm "" : LMULReadAdvance<"ReadVSTUXV", 0>;
-defm "" : LMULReadAdvance<"ReadVSTUX8V", 0>;
-defm "" : LMULReadAdvance<"ReadVSTUX16V", 0>;
-defm "" : LMULReadAdvance<"ReadVSTUX32V", 0>;
-defm "" : LMULReadAdvance<"ReadVSTUX64V", 0>;
-defm "" : LMULReadAdvance<"ReadVSTOX8", 0>;
-defm "" : LMULReadAdvance<"ReadVSTOX16", 0>;
-defm "" : LMULReadAdvance<"ReadVSTOX32", 0>;
-defm "" : LMULReadAdvance<"ReadVSTOX64", 0>;
-defm "" : LMULReadAdvance<"ReadVSTOXV", 0>;
-defm "" : LMULReadAdvance<"ReadVSTOX8V", 0>;
-defm "" : LMULReadAdvance<"ReadVSTOX16V", 0>;
-defm "" : LMULReadAdvance<"ReadVSTOX32V", 0>;
-defm "" : LMULReadAdvance<"ReadVSTOX64V", 0>;
-// LMUL Aware
-def : ReadAdvance<ReadVST1R, 0>;
-def : ReadAdvance<ReadVST2R, 0>;
-def : ReadAdvance<ReadVST4R, 0>;
-def : ReadAdvance<ReadVST8R, 0>;
-
-// Vector Integer Arithmetic Instructions
-foreach mx = SchedMxList in {
-  defvar Cycles = AscalonGetCyclesDefault<mx>.c;
-  defvar IsWorstCase = AscalonIsWorstCaseMX<mx, SchedMxList>.c;
-  let Latency = Cycles, ReleaseAtCycles = [1, Cycles] in {
-    defm "" : LMULWriteResMX<"WriteVIALUV",     [AscalonFX, AscalonV], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVIALUX",     [AscalonFX, AscalonV], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVIALUI",     [AscalonFX, AscalonV], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVICALUV",    [AscalonFX, AscalonV], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVICALUX",    [AscalonFX, AscalonV], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVICALUI",    [AscalonFX, AscalonV], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVICALUMV",   [AscalonFX, AscalonV], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVICALUMX",   [AscalonFX, AscalonV], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVICALUMI",   [AscalonFX, AscalonV], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVShiftV",    [AscalonFX, AscalonV], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVShiftX",    [AscalonFX, AscalonV], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVShiftI",    [AscalonFX, AscalonV], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVIMinMaxV",  [AscalonFX, AscalonV], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVIMinMaxX",  [AscalonFX, AscalonV], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVIMulV",     [AscalonFX, AscalonV], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVIMulX",     [AscalonFX, AscalonV], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVIMulAddV",  [AscalonFX, AscalonV], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVIMulAddX",  [AscalonFX, AscalonV], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVIMergeV",   [AscalonFX, AscalonV], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVIMergeX",   [AscalonFX, AscalonV], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVIMergeI",   [AscalonFX, AscalonV], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVIMovV",     [AscalonFX, AscalonV], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVIMovX",     [AscalonFX, AscalonV], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVIMovI",     [AscalonFX, AscalonV], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVICmpV",     [AscalonFX, AscalonV], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVICmpX",     [AscalonFX, AscalonV], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVICmpI",     [AscalonFX, AscalonV], mx, IsWorstCase>;
-  }
-}
-foreach mx = SchedMxList in {
-  defvar Cycles = AscalonGetCyclesDefault<mx>.c;
-  defvar IsWorstCase = AscalonIsWorstCaseMX<mx, SchedMxList>.c;
-  let Latency = Cycles, ReleaseAtCycles = [1, Cycles] in {
-    defm "" : LMULWriteResMX<"WriteVExtV",      [AscalonFX, AscalonV], mx, IsWorstCase>;
-  }
-}
-foreach mx = SchedMxList in {
-  foreach sew = SchedSEWSet<mx>.val in {
-    defvar Cycles = AscalonGetCyclesDivOrSqrt<mx, sew>.c;
-    defvar IsWorstCase = AscalonIsWorstCaseMXSEW<mx, sew, SchedMxList>.c;
+  // Configuration-Setting Instructions
+  def : ReadAdvance<ReadVSETVLI, 1>;
+  def : ReadAdvance<ReadVSETVL, 1>;
+
+  // Vector Loads and Stores
+  def : ReadAdvance<ReadVLDX, 0>;
+  def : ReadAdvance<ReadVSTX, 0>;
+  defm "" : LMULReadAdvance<"ReadVSTEV", 0>;
+  defm "" : LMULReadAdvance<"ReadVSTM", 0>;
+  def : ReadAdvance<ReadVLDSX, 0>;
+  def : ReadAdvance<ReadVSTSX, 0>;
+  defm "" : LMULReadAdvance<"ReadVSTS8V", 0>;
+  defm "" : LMULReadAdvance<"ReadVSTS16V", 0>;
+  defm "" : LMULReadAdvance<"ReadVSTS32V", 0>;
+  defm "" : LMULReadAdvance<"ReadVSTS64V", 0>;
+  defm "" : LMULReadAdvance<"ReadVLDUXV", 0>;
+  defm "" : LMULReadAdvance<"ReadVLDOXV", 0>;
+  defm "" : LMULReadAdvance<"ReadVSTUX8", 0>;
+  defm "" : LMULReadAdvance<"ReadVSTUX16", 0>;
+  defm "" : LMULReadAdvance<"ReadVSTUX32", 0>;
+  defm "" : LMULReadAdvance<"ReadVSTUX64", 0>;
+  defm "" : LMULReadAdvance<"ReadVSTUXV", 0>;
+  defm "" : LMULReadAdvance<"ReadVSTUX8V", 0>;
+  defm "" : LMULReadAdvance<"ReadVSTUX16V", 0>;
+  defm "" : LMULReadAdvance<"ReadVSTUX32V", 0>;
+  defm "" : LMULReadAdvance<"ReadVSTUX64V", 0>;
+  defm "" : LMULReadAdvance<"ReadVSTOX8", 0>;
+  defm "" : LMULReadAdvance<"ReadVSTOX16", 0>;
+  defm "" : LMULReadAdvance<"ReadVSTOX32", 0>;
+  defm "" : LMULReadAdvance<"ReadVSTOX64", 0>;
+  defm "" : LMULReadAdvance<"ReadVSTOXV", 0>;
+  defm "" : LMULReadAdvance<"ReadVSTOX8V", 0>;
+  defm "" : LMULReadAdvance<"ReadVSTOX16V", 0>;
+  defm "" : LMULReadAdvance<"ReadVSTOX32V", 0>;
+  defm "" : LMULReadAdvance<"ReadVSTOX64V", 0>;
+  // LMUL Aware
+  def : ReadAdvance<ReadVST1R, 0>;
+  def : ReadAdvance<ReadVST2R, 0>;
+  def : ReadAdvance<ReadVST4R, 0>;
+  def : ReadAdvance<ReadVST8R, 0>;
+
+  // Vector Integer Arithmetic Instructions
+  foreach mx = SchedMxList in {
+    defvar Cycles = AscalonGetCyclesDefault<mx>.c;
+    defvar IsWorstCase = AscalonIsWorstCaseMX<mx, SchedMxList>.c;
     let Latency = Cycles, ReleaseAtCycles = [1, Cycles] in {
-      defm "" : LMULSEWWriteResMXSEW<"WriteVIDivV", [AscalonFX, AscalonV], mx, sew, IsWorstCase>;
-      defm "" : LMULSEWWriteResMXSEW<"WriteVIDivX", [AscalonFX, AscalonV], mx, sew, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVIALUV",     [AscalonFX, AscalonV], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVIALUX",     [AscalonFX, AscalonV], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVIALUI",     [AscalonFX, AscalonV], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVICALUV",    [AscalonFX, AscalonV], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVICALUX",    [AscalonFX, AscalonV], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVICALUI",    [AscalonFX, AscalonV], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVICALUMV",   [AscalonFX, AscalonV], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVICALUMX",   [AscalonFX, AscalonV], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVICALUMI",   [AscalonFX, AscalonV], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVShiftV",    [AscalonFX, AscalonV], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVShiftX",    [AscalonFX, AscalonV], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVShiftI",    [AscalonFX, AscalonV], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVIMinMaxV",  [AscalonFX, AscalonV], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVIMinMaxX",  [AscalonFX, AscalonV], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVIMulV",     [AscalonFX, AscalonV], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVIMulX",     [AscalonFX, AscalonV], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVIMulAddV",  [AscalonFX, AscalonV], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVIMulAddX",  [AscalonFX, AscalonV], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVIMergeV",   [AscalonFX, AscalonV], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVIMergeX",   [AscalonFX, AscalonV], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVIMergeI",   [AscalonFX, AscalonV], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVIMovV",     [AscalonFX, AscalonV], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVIMovX",     [AscalonFX, AscalonV], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVIMovI",     [AscalonFX, AscalonV], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVICmpV",     [AscalonFX, AscalonV], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVICmpX",     [AscalonFX, AscalonV], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVICmpI",     [AscalonFX, AscalonV], mx, IsWorstCase>;
     }
   }
-}
-
-// Widening
-foreach mx = SchedMxListW in {
-  defvar Cycles = AscalonGetCyclesDefault<mx>.c;
-  defvar IsWorstCase = AscalonIsWorstCaseMX<mx, SchedMxListW>.c;
-  let Latency = Cycles, ReleaseAtCycles = [1, Cycles] in {
-    defm "" : LMULWriteResMX<"WriteVIWALUV",    [AscalonFX, AscalonV], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVIWALUX",    [AscalonFX, AscalonV], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVIWALUI",    [AscalonFX, AscalonV], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVIWMulV",    [AscalonFX, AscalonV], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVIWMulX",    [AscalonFX, AscalonV], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVIWMulAddV", [AscalonFX, AscalonV], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVIWMulAddX", [AscalonFX, AscalonV], mx, IsWorstCase>;
+  foreach mx = SchedMxList in {
+    defvar Cycles = AscalonGetCyclesDefault<mx>.c;
+    defvar IsWorstCase = AscalonIsWorstCaseMX<mx, SchedMxList>.c;
+    let Latency = Cycles, ReleaseAtCycles = [1, Cycles] in {
+      defm "" : LMULWriteResMX<"WriteVExtV",      [AscalonFX, AscalonV], mx, IsWorstCase>;
+    }
   }
-}
-// Narrowing
-foreach mx = SchedMxListW in {
-  defvar Cycles = AscalonGetCyclesNarrowing<mx>.c;
-  defvar IsWorstCase = AscalonIsWorstCaseMX<mx, SchedMxListW>.c;
-  let Latency = Cycles, ReleaseAtCycles = [1, Cycles] in {
-    defm "" : LMULWriteResMX<"WriteVNShiftV",   [AscalonFX, AscalonV], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVNShiftX",   [AscalonFX, AscalonV], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVNShiftI",   [AscalonFX, AscalonV], mx, IsWorstCase>;
+  foreach mx = SchedMxList in {
+    foreach sew = SchedSEWSet<mx>.val in {
+      defvar Cycles = AscalonGetCyclesDivOrSqrt<mx, sew>.c;
+      defvar IsWorstCase = AscalonIsWorstCaseMXSEW<mx, sew, SchedMxList>.c;
+      let Latency = Cycles, ReleaseAtCycles = [1, Cycles] in {
+        defm "" : LMULSEWWriteResMXSEW<"WriteVIDivV", [AscalonFX, AscalonV], mx, sew, IsWorstCase>;
+        defm "" : LMULSEWWriteResMXSEW<"WriteVIDivX", [AscalonFX, AscalonV], mx, sew, IsWorstCase>;
+      }
+    }
   }
-}
 
-// Vector Floating-Point Instructions
-foreach mx = SchedMxListF in {
-  foreach sew = SchedSEWSet<mx, isF=1>.val in {
+  // Widening
+  foreach mx = SchedMxListW in {
     defvar Cycles = AscalonGetCyclesDefault<mx>.c;
-    defvar IsWorstCase = AscalonIsWorstCaseMXSEW<mx, sew, SchedMxListF, isF=1>.c;
+    defvar IsWorstCase = AscalonIsWorstCaseMX<mx, SchedMxListW>.c;
     let Latency = Cycles, ReleaseAtCycles = [1, Cycles] in {
-      defm "" : LMULSEWWriteResMXSEW<"WriteVFALUV",  [AscalonFP, AscalonV], mx, sew, IsWorstCase>;
-      defm "" : LMULSEWWriteResMXSEW<"WriteVFALUF",  [AscalonFP, AscalonV], mx, sew, IsWorstCase>;
-      defm "" : LMULSEWWriteResMXSEW<"WriteVFMulV",  [AscalonFP, AscalonV], mx, sew, IsWorstCase>;
-      defm "" : LMULSEWWriteResMXSEW<"WriteVFMulF",  [AscalonFP, AscalonV], mx, sew, IsWorstCase>;
-      defm "" : LMULSEWWriteResMXSEW<"WriteVFMulAddV", [AscalonFP, AscalonV], mx, sew, IsWorstCase>;
-      defm "" : LMULSEWWriteResMXSEW<"WriteVFMulAddF", [AscalonFP, AscalonV], mx, sew, IsWorstCase>;
-      defm "" : LMULSEWWriteResMXSEW<"WriteVFRecpV",   [AscalonFP, AscalonV], mx, sew, IsWorstCase>;
-      defm "" : LMULSEWWriteResMXSEW<"WriteVFCvtIToFV", [AscalonFP, AscalonV], mx, sew, IsWorstCase>;
-      defm "" : LMULSEWWriteResMXSEW<"WriteVFMinMaxV", [AscalonFP, AscalonV], mx, sew, IsWorstCase>;
-      defm "" : LMULSEWWriteResMXSEW<"WriteVFMinMaxF", [AscalonFP, AscalonV], mx, sew, IsWorstCase>;
-      defm "" : LMULSEWWriteResMXSEW<"WriteVFSgnjV",   [AscalonFP, AscalonV], mx, sew, IsWorstCase>;
-      defm "" : LMULSEWWriteResMXSEW<"WriteVFSgnjF",   [AscalonFP, AscalonV], mx, sew, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVIWALUV",    [AscalonFX, AscalonV], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVIWALUX",    [AscalonFX, AscalonV], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVIWALUI",    [AscalonFX, AscalonV], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVIWMulV",    [AscalonFX, AscalonV], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVIWMulX",    [AscalonFX, AscalonV], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVIWMulAddV", [AscalonFX, AscalonV], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVIWMulAddX", [AscalonFX, AscalonV], mx, IsWorstCase>;
     }
   }
-}
-foreach mx = SchedMxList in {
-  defvar Cycles = AscalonGetCyclesDefault<mx>.c;
-  defvar IsWorstCase = AscalonIsWorstCaseMX<mx, SchedMxList>.c;
-  let Latency = Cycles, ReleaseAtCycles = [1, Cycles] in {
-    defm "" : LMULWriteResMX<"WriteVFCvtFToIV",  [AscalonFPA, AscalonV], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVFClassV",    [AscalonFP, AscalonV], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVFMergeV",    [AscalonFP, AscalonV], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVFMovV",      [AscalonFP, AscalonV], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVFCmpV",      [AscalonFP, AscalonV], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVFCmpF",      [AscalonFP, AscalonV], mx, IsWorstCase>;
-  }
-}
-foreach mx = SchedMxListF in {
-  foreach sew = SchedSEWSet<mx, isF=1>.val in {
-    defvar Cycles = AscalonGetCyclesDivOrSqrt<mx, sew>.c;
-    defvar IsWorstCase = AscalonIsWorstCaseMXSEW<mx, sew, SchedMxListF, 1>.c;
+  // Narrowing
+  foreach mx = SchedMxListW in {
+    defvar Cycles = AscalonGetCyclesNarrowing<mx>.c;
+    defvar IsWorstCase = AscalonIsWorstCaseMX<mx, SchedMxListW>.c;
     let Latency = Cycles, ReleaseAtCycles = [1, Cycles] in {
-      defm "" : LMULSEWWriteResMXSEW<"WriteVFSqrtV", [AscalonFP, AscalonV], mx, sew, IsWorstCase>;
-      defm "" : LMULSEWWriteResMXSEW<"WriteVFDivV",  [AscalonFP, AscalonV], mx, sew, IsWorstCase>;
-      defm "" : LMULSEWWriteResMXSEW<"WriteVFDivF",  [AscalonFP, AscalonV], mx, sew, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVNShiftV",   [AscalonFX, AscalonV], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVNShiftX",   [AscalonFX, AscalonV], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVNShiftI",   [AscalonFX, AscalonV], mx, IsWorstCase>;
     }
   }
-}
 
-// Widening
-foreach mx = SchedMxListW in {
-  foreach sew = SchedSEWSet<mx, isF=0, isWidening=1>.val in {
-    defvar Cycles = AscalonGetCyclesDefault<mx>.c;
-    defvar IsWorstCase = AscalonIsWorstCaseMXSEW<mx, sew, SchedMxListW>.c;
-    let Latency = Cycles, ReleaseAtCycles = [1, Cycles] in
-    defm "" : LMULSEWWriteResMXSEW<"WriteVFWCvtIToFV", [AscalonFXB, AscalonV], mx, sew, IsWorstCase>;
+  // Vector Floating-Point Instructions
+  foreach mx = SchedMxListF in {
+    foreach sew = SchedSEWSet<mx, isF=1>.val in {
+      defvar Cycles = AscalonGetCyclesDefault<mx>.c;
+      defvar IsWorstCase = AscalonIsWorstCaseMXSEW<mx, sew, SchedMxListF, isF=1>.c;
+      // FP64 add/mul/fma have reduced throughput on Ascalon XG.
+      defvar IsFP64 = !and(ReducedFP64Vec, !eq(sew, 64));
+      defvar FP64 = AscalonXGFP64Vec<Cycles>;
+      defvar FPVRes = !if(IsFP64, [AscalonFP, AscalonV, AscalonFP64V],
+                                  [AscalonFP, AscalonV]);
+      let Latency = !if(IsFP64, FP64.Latency, Cycles),
+          ReleaseAtCycles = !if(IsFP64, [1, Cycles, FP64.ReleaseAtCycles],
+                                        [1, Cycles]) in {
+        defm "" : LMULSEWWriteResMXSEW<"WriteVFALUV",  FPVRes, mx, sew, IsWorstCase>;
+        defm "" : LMULSEWWriteResMXSEW<"WriteVFALUF",  FPVRes, mx, sew, IsWorstCase>;
+        defm "" : LMULSEWWriteResMXSEW<"WriteVFMulV",  FPVRes, mx, sew, IsWorstCase>;
+        defm "" : LMULSEWWriteResMXSEW<"WriteVFMulF",  FPVRes, mx, sew, IsWorstCase>;
+        defm "" : LMULSEWWriteResMXSEW<"WriteVFMulAddV", FPVRes, mx, sew, IsWorstCase>;
+        defm "" : LMULSEWWriteResMXSEW<"WriteVFMulAddF", FPVRes, mx, sew, IsWorstCase>;
+      }
+      let Latency = Cycles, ReleaseAtCycles = [1, Cycles] in {
+        defm "" : LMULSEWWriteResMXSEW<"WriteVFRecpV",   [AscalonFP, AscalonV], mx, sew, IsWorstCase>;
+        defm "" : LMULSEWWriteResMXSEW<"WriteVFCvtIToFV", [AscalonFP, AscalonV], mx, sew, IsWorstCase>;
+        defm "" : LMULSEWWriteResMXSEW<"WriteVFMinMaxV", [AscalonFP, AscalonV], mx, sew, IsWorstCase>;
+        defm "" : LMULSEWWriteResMXSEW<"WriteVFMinMaxF", [AscalonFP, AscalonV], mx, sew, IsWorstCase>;
+        defm "" : LMULSEWWriteResMXSEW<"WriteVFSgnjV",   [AscalonFP, AscalonV], mx, sew, IsWorstCase>;
+        defm "" : LMULSEWWriteResMXSEW<"WriteVFSgnjF",   [AscalonFP, AscalonV], mx, sew, IsWorstCase>;
+      }
+    }
   }
-}
-foreach mx = SchedMxListFW in {
-  foreach sew = SchedSEWSet<mx, isF=1, isWidening=1>.val in {
+  foreach mx = SchedMxList in {
     defvar Cycles = AscalonGetCyclesDefault<mx>.c;
-    defvar IsWorstCase = AscalonIsWorstCaseMXSEW<mx, sew, SchedMxListFW, isF=1>.c;
+    defvar IsWorstCase = AscalonIsWorstCaseMX<mx, SchedMxList>.c;
     let Latency = Cycles, ReleaseAtCycles = [1, Cycles] in {
-      defm "" : LMULSEWWriteResMXSEW<"WriteVFWALUV", [AscalonFP, AscalonV], mx, sew, IsWorstCase>;
-      defm "" : LMULSEWWriteResMXSEW<"WriteVFWALUF", [AscalonFP, AscalonV], mx, sew, IsWorstCase>;
-      defm "" : LMULSEWWriteResMXSEW<"WriteVFWMulV", [AscalonFP, AscalonV], mx, sew, IsWorstCase>;
-      defm "" : LMULSEWWriteResMXSEW<"WriteVFWMulF", [AscalonFP, AscalonV], mx, sew, IsWorstCase>;
-      defm "" : LMULSEWWriteResMXSEW<"WriteVFWMulAddV", [AscalonFP, AscalonV], mx, sew, IsWorstCase>;
-      defm "" : LMULSEWWriteResMXSEW<"WriteVFWMulAddF", [AscalonFP, AscalonV], mx, sew, IsWorstCase>;
-      defm "" : LMULSEWWriteResMXSEW<"WriteVFWCvtFToFV", [AscalonFP, AscalonV], mx, sew, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVFCvtFToIV",  [AscalonFPA, AscalonV], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVFClassV",    [AscalonFP, AscalonV], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVFMergeV",    [AscalonFP, AscalonV], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVFMovV",      [AscalonFP, AscalonV], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVFCmpV",      [AscalonFP, AscalonV], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVFCmpF",      [AscalonFP, AscalonV], mx, IsWorstCase>;
     }
   }
-  defvar Cycles = AscalonGetCyclesDefault<mx>.c;
-  defvar IsWorstCase = AscalonIsWorstCaseMX<mx, SchedMxListFW>.c;
-  let Latency = Cycles, ReleaseAtCycles = [1, Cycles] in
-  defm "" : LMULWriteResMX<"WriteVFWCvtFToIV", [AscalonFPA, AscalonV], mx, IsWorstCase>;
-}
-// Narrowing
-foreach mx = SchedMxListW in {
-  defvar Cycles = AscalonGetCyclesNarrowing<mx>.c;
-  defvar IsWorstCase = AscalonIsWorstCaseMX<mx, SchedMxListW>.c;
-  let Latency = Cycles, ReleaseAtCycles = [1, Cycles] in {
-    defm "" : LMULWriteResMX<"WriteVFNCvtFToIV", [AscalonFPA, AscalonV], mx, IsWorstCase>;
+  foreach mx = SchedMxListF in {
+    foreach sew = SchedSEWSet<mx, isF=1>.val in {
+      defvar Cycles = AscalonGetCyclesDivOrSqrt<mx, sew>.c;
+      defvar IsWorstCase = AscalonIsWorstCaseMXSEW<mx, sew, SchedMxListF, 1>.c;
+      let Latency = Cycles, ReleaseAtCycles = [1, Cycles] in {
+        defm "" : LMULSEWWriteResMXSEW<"WriteVFSqrtV", [AscalonFP, AscalonV], mx, sew, IsWorstCase>;
+        defm "" : LMULSEWWriteResMXSEW<"WriteVFDivV",  [AscalonFP, AscalonV], mx, sew, IsWorstCase>;
+        defm "" : LMULSEWWriteResMXSEW<"WriteVFDivF",  [AscalonFP, AscalonV], mx, sew, IsWorstCase>;
+      }
+    }
   }
-}
-foreach mx = SchedMxListFW in {
-  foreach sew = SchedSEWSet<mx, isF=1, isWidening=1>.val in {
+
+  // Widening
+  foreach mx = SchedMxListW in {
+    foreach sew = SchedSEWSet<mx, isF=0, isWidening=1>.val in {
+      defvar Cycles = AscalonGetCyclesDefault<mx>.c;
+      defvar IsWorstCase = AscalonIsWorstCaseMXSEW<mx, sew, SchedMxListW>.c;
+      defvar IsFP64 = !and(ReducedFP64Vec, !eq(sew, 32));
+      defvar FP64 = AscalonXGFP64Vec<Cycles>;
+      defvar FXBVRes = !if(IsFP64, [AscalonFXB, AscalonV, AscalonFP64V],
+                                   [AscalonFXB, AscalonV]);
+      let Latency = !if(IsFP64, FP64.Latency, Cycles),
+          ReleaseAtCycles = !if(IsFP64, [1, Cycles, FP64.ReleaseAtCycles],
+                                        [1, Cycles]) in
+      defm "" : LMULSEWWriteResMXSEW<"WriteVFWCvtIToFV", FXBVRes, mx, sew, IsWorstCase>;
+    }
+  }
+  foreach mx = SchedMxListFW in {
+    foreach sew = SchedSEWSet<mx, isF=1, isWidening=1>.val in {
+      defvar Cycles = AscalonGetCyclesDefault<mx>.c;
+      defvar IsWorstCase = AscalonIsWorstCaseMXSEW<mx, sew, SchedMxListFW, isF=1>.c;
+      defvar IsFP64 = !and(ReducedFP64Vec, !eq(sew, 32));
+      defvar FP64 = AscalonXGFP64Vec<Cycles>;
+      defvar FPVRes = !if(IsFP64, [AscalonFP, AscalonV, AscalonFP64V],
+                                  [AscalonFP, AscalonV]);
+      let Latency = !if(IsFP64, FP64.Latency, Cycles),
+          ReleaseAtCycles = !if(IsFP64, [1, Cycles, FP64.ReleaseAtCycles],
+                                        [1, Cycles]) in {
+        defm "" : LMULSEWWriteResMXSEW<"WriteVFWALUV", FPVRes, mx, sew, IsWorstCase>;
+        defm "" : LMULSEWWriteResMXSEW<"WriteVFWALUF", FPVRes, mx, sew, IsWorstCase>;
+        defm "" : LMULSEWWriteResMXSEW<"WriteVFWMulV", FPVRes, mx, sew, IsWorstCase>;
+        defm "" : LMULSEWWriteResMXSEW<"WriteVFWMulF", FPVRes, mx, sew, IsWorstCase>;
+        defm "" : LMULSEWWriteResMXSEW<"WriteVFWMulAddV", FPVRes, mx, sew, IsWorstCase>;
+        defm "" : LMULSEWWriteResMXSEW<"WriteVFWMulAddF", FPVRes, mx, sew, IsWorstCase>;
+        defm "" : LMULSEWWriteResMXSEW<"WriteVFWCvtFToFV", FPVRes, mx, sew, IsWorstCase>;
+      }
+    }
+    defvar Cycles = AscalonGetCyclesDefault<mx>.c;
+    defvar IsWorstCase = AscalonIsWorstCaseMX<mx, SchedMxListFW>.c;
+    let Latency = Cycles, ReleaseAtCycles = [1, Cycles] in
+    defm "" : LMULWriteResMX<"WriteVFWCvtFToIV", [AscalonFPA, AscalonV], mx, IsWorstCase>;
+  }
+  // Narrowing
+  foreach mx = SchedMxListW in {
     defvar Cycles = AscalonGetCyclesNarrowing<mx>.c;
-    defvar IsWorstCase = AscalonIsWorstCaseMXSEW<mx, sew, SchedMxListFW, isF=1>.c;
+    defvar IsWorstCase = AscalonIsWorstCaseMX<mx, SchedMxListW>.c;
     let Latency = Cycles, ReleaseAtCycles = [1, Cycles] in {
-      defm "" : LMULSEWWriteResMXSEW<"WriteVFNCvtIToFV", [AscalonFXB, AscalonV], mx, sew, IsWorstCase>;
-      defm "" : LMULSEWWriteResMXSEW<"WriteVFNCvtFToFV", [AscalonFXB, AscalonV], mx, sew, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVFNCvtFToIV", [AscalonFPA, AscalonV], mx, IsWorstCase>;
+    }
+  }
+  foreach mx = SchedMxListFW in {
+    foreach sew = SchedSEWSet<mx, isF=1, isWidening=1>.val in {
+      defvar Cycles = AscalonGetCyclesNarrowing<mx>.c;
+      defvar IsWorstCase = AscalonIsWorstCaseMXSEW<mx, sew, SchedMxListFW, isF=1>.c;
+      let Latency = Cycles, ReleaseAtCycles = [1, Cycles] in {
+        defm "" : LMULSEWWriteResMXSEW<"WriteVFNCvtIToFV", [AscalonFXB, AscalonV], mx, sew, IsWorstCase>;
+        defm "" : LMULSEWWriteResMXSEW<"WriteVFNCvtFToFV", [AscalonFXB, AscalonV], mx, sew, IsWorstCase>;
+      }
     }
   }
-}
 
-// Vector Reduction Instructions
-foreach mx = SchedMxList in {
-  foreach sew = SchedSEWSet<mx>.val in {
-    defvar Cycles = AscalonGetCyclesDefault<mx>.c;
-    defvar IsWorstCase = AscalonIsWorstCaseMXSEW<mx, sew, SchedMxList>.c;
-    let Latency = Cycles, ReleaseAtCycles = [1, Cycles] in {
-      defm "" : LMULSEWWriteResMXSEW<"WriteVIRedV_From", [AscalonFX, AscalonV],
-                                     mx, sew, IsWorstCase>;
-      defm "" : LMULSEWWriteResMXSEW<"WriteVIRedMinMaxV_From", [AscalonFX, AscalonV],
+  // Vector Reduction Instructions
+  foreach mx = SchedMxList in {
+    foreach sew = SchedSEWSet<mx>.val in {
+      defvar Cycles = AscalonGetCyclesDefault<mx>.c;
+      defvar IsWorstCase = AscalonIsWorstCaseMXSEW<mx, sew, SchedMxList>.c;
+      let Latency = Cycles, ReleaseAtCycles = [1, Cycles] in {
+        defm "" : LMULSEWWriteResMXSEW<"WriteVIRedV_From", [AscalonFX, AscalonV],
+                                       mx, sew, IsWorstCase>;
+        defm "" : LMULSEWWriteResMXSEW<"WriteVIRedMinMaxV_From", [AscalonFX, AscalonV],
+                                       mx, sew, IsWorstCase>;
+      }
+    }
+  }
+
+  foreach mx = SchedMxListWRed in {
+    foreach sew = SchedSEWSet<mx, 0, 1>.val in {
+      defvar Cycles = AscalonGetCyclesDefault<mx>.c;
+      defvar IsWorstCase = AscalonIsWorstCaseMXSEW<mx, sew, SchedMxListWRed>.c;
+      let Latency = Cycles, ReleaseAtCycles = [1, Cycles] in
+      defm "" : LMULSEWWriteResMXSEW<"WriteVIWRedV_From", [AscalonFX, AscalonV],
                                      mx, sew, IsWorstCase>;
     }
   }
-}
 
-foreach mx = SchedMxListWRed in {
-  foreach sew = SchedSEWSet<mx, 0, 1>.val in {
-    defvar Cycles = AscalonGetCyclesDefault<mx>.c;
-    defvar IsWorstCase = AscalonIsWorstCaseMXSEW<mx, sew, SchedMxListWRed>.c;
-    let Latency = Cycles, ReleaseAtCycles = [1, Cycles] in
-    defm "" : LMULSEWWriteResMXSEW<"WriteVIWRedV_From", [AscalonFX, AscalonV],
-                                   mx, sew, IsWorstCase>;
+  foreach mx = SchedMxListF in {
+    foreach sew = SchedSEWSet<mx, 1>.val in {
+      defvar RedCycles = AscalonGetCyclesDefault<mx>.c;
+      defvar IsWorstCase = AscalonIsWorstCaseMXSEW<mx, sew, SchedMxListF, 1>.c;
+      let Latency = RedCycles, ReleaseAtCycles = [1, RedCycles] in {
+        defm "" : LMULSEWWriteResMXSEW<"WriteVFRedV_From", [AscalonFX, AscalonV],
+                                       mx, sew, IsWorstCase>;
+        defm "" : LMULSEWWriteResMXSEW<"WriteVFRedMinMaxV_From", [AscalonFX, AscalonV],
+                                       mx, sew, IsWorstCase>;
+      }
+      defvar OrdRedCycles = AscalonGetCyclesLMUL<mx, 18>.c;
+      let Latency = OrdRedCycles, ReleaseAtCycles = [1, OrdRedCycles] in
+      defm "" : LMULSEWWriteResMXSEW<"WriteVFRedOV_From", [AscalonFX, AscalonV],
+                                     mx, sew, IsWorstCase>;
+    }
   }
-}
 
-foreach mx = SchedMxListF in {
-  foreach sew = SchedSEWSet<mx, 1>.val in {
-    defvar RedCycles = AscalonGetCyclesDefault<mx>.c;
-    defvar IsWorstCase = AscalonIsWorstCaseMXSEW<mx, sew, SchedMxListF, 1>.c;
-    let Latency = RedCycles, ReleaseAtCycles = [1, RedCycles] in {
-      defm "" : LMULSEWWriteResMXSEW<"WriteVFRedV_From", [AscalonFX, AscalonV],
+  foreach mx = SchedMxListFWRed in {
+    foreach sew = SchedSEWSet<mx, 1, 1>.val in {
+      defvar RedCycles = AscalonGetCyclesDefault<mx>.c;
+      defvar IsWorstCase = AscalonIsWorstCaseMXSEW<mx, sew, SchedMxListFWRed, 1>.c;
+      let Latency = RedCycles, ReleaseAtCycles = [1, RedCycles] in
+      defm "" : LMULSEWWriteResMXSEW<"WriteVFWRedV_From", [AscalonFX, AscalonV],
                                      mx, sew, IsWorstCase>;
-      defm "" : LMULSEWWriteResMXSEW<"WriteVFRedMinMaxV_From", [AscalonFX, AscalonV],
+      defvar OrdRedCycles = AscalonGetCyclesLMUL<mx, 18>.c;
+      let Latency = OrdRedCycles, ReleaseAtCycles = [1, OrdRedCycles] in
+      defm "" : LMULSEWWriteResMXSEW<"WriteVFWRedOV_From", [AscalonFX, AscalonV],
                                      mx, sew, IsWorstCase>;
     }
-    defvar OrdRedCycles = AscalonGetCyclesLMUL<mx, 18>.c;
-    let Latency = OrdRedCycles, ReleaseAtCycles = [1, OrdRedCycles] in
-    defm "" : LMULSEWWriteResMXSEW<"WriteVFRedOV_From", [AscalonFX, AscalonV],
-                                   mx, sew, IsWorstCase>;
   }
-}
 
-foreach mx = SchedMxListFWRed in {
-  foreach sew = SchedSEWSet<mx, 1, 1>.val in {
-    defvar RedCycles = AscalonGetCyclesDefault<mx>.c;
-    defvar IsWorstCase = AscalonIsWorstCaseMXSEW<mx, sew, SchedMxListFWRed, 1>.c;
-    let Latency = RedCycles, ReleaseAtCycles = [1, RedCycles] in
-    defm "" : LMULSEWWriteResMXSEW<"WriteVFWRedV_From", [AscalonFX, AscalonV],
-                                   mx, sew, IsWorstCase>;
-    defvar OrdRedCycles = AscalonGetCyclesLMUL<mx, 18>.c;
-    let Latency = OrdRedCycles, ReleaseAtCycles = [1, OrdRedCycles] in
-    defm "" : LMULSEWWriteResMXSEW<"WriteVFWRedOV_From", [AscalonFX, AscalonV],
-                                   mx, sew, IsWorstCase>;
+  // Vector Mask Instructions
+  foreach mx = SchedMxList in {
+    defvar IsWorstCase = AscalonIsWorstCaseMX<mx, SchedMxList>.c;
+    defm "" : LMULWriteResMX<"WriteVMALUV", [AscalonV], mx, IsWorstCase>;
+    defm "" : LMULWriteResMX<"WriteVMSFSV", [AscalonV], mx, IsWorstCase>;
+    let Latency = 2, ReleaseAtCycles = [1, 2] in {
+      defm "" : LMULWriteResMX<"WriteVMPopV", [AscalonFX, AscalonV], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVMFFSV", [AscalonFX, AscalonV], mx, IsWorstCase>;
+    }
+  }
+  foreach mx = SchedMxList in {
+    defvar Cycles = AscalonGetCyclesDefault<mx>.c;
+    defvar IsWorstCase = AscalonIsWorstCaseMX<mx, SchedMxList>.c;
+    let Latency = Cycles, ReleaseAtCycles = [1, Cycles] in {
+      defm "" : LMULWriteResMX<"WriteVIotaV", [AscalonFX, AscalonV], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVIdxV", [AscalonFX, AscalonV], mx, IsWorstCase>;
+    }
   }
-}
 
-// Vector Mask Instructions
-foreach mx = SchedMxList in {
-  defvar IsWorstCase = AscalonIsWorstCaseMX<mx, SchedMxList>.c;
-  defm "" : LMULWriteResMX<"WriteVMALUV", [AscalonV], mx, IsWorstCase>;
-  defm "" : LMULWriteResMX<"WriteVMSFSV", [AscalonV], mx, IsWorstCase>;
+  // Vector Permutation Instructions
   let Latency = 2, ReleaseAtCycles = [1, 2] in {
-    defm "" : LMULWriteResMX<"WriteVMPopV", [AscalonFX, AscalonV], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVMFFSV", [AscalonFX, AscalonV], mx, IsWorstCase>;
+    def : WriteRes<WriteVMovSX, [AscalonFX, AscalonV]>;
+    def : WriteRes<WriteVMovXS, [AscalonFX, AscalonV]>;
+    def : WriteRes<WriteVMovSF, [AscalonFX, AscalonV]>;
+    def : WriteRes<WriteVMovFS, [AscalonFX, AscalonV]>;
   }
-}
-foreach mx = SchedMxList in {
-  defvar Cycles = AscalonGetCyclesDefault<mx>.c;
-  defvar IsWorstCase = AscalonIsWorstCaseMX<mx, SchedMxList>.c;
-  let Latency = Cycles, ReleaseAtCycles = [1, Cycles] in {
-    defm "" : LMULWriteResMX<"WriteVIotaV", [AscalonFX, AscalonV], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVIdxV", [AscalonFX, AscalonV], mx, IsWorstCase>;
+  foreach mx = SchedMxList in {
+    defvar Cycles = AscalonGetCyclesDefault<mx>.c;
+    defvar IsWorstCase = AscalonIsWorstCaseMX<mx, SchedMxList>.c;
+    let Latency = !mul(Cycles, 2), ReleaseAtCycles = [Cycles, !mul(Cycles, 2)] in {
+      defm "" : LMULWriteResMX<"WriteVRGatherVX",    [AscalonFX, AscalonV], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVRGatherVI",    [AscalonFX, AscalonV], mx, IsWorstCase>;
+    }
   }
-}
 
-// Vector Permutation Instructions
-let Latency = 2, ReleaseAtCycles = [1, 2] in {
-  def : WriteRes<WriteVMovSX, [AscalonFX, AscalonV]>;
-  def : WriteRes<WriteVMovXS, [AscalonFX, AscalonV]>;
-  def : WriteRes<WriteVMovSF, [AscalonFX, AscalonV]>;
-  def : WriteRes<WriteVMovFS, [AscalonFX, AscalonV]>;
-}
-foreach mx = SchedMxList in {
-  defvar Cycles = AscalonGetCyclesDefault<mx>.c;
-  defvar IsWorstCase = AscalonIsWorstCaseMX<mx, SchedMxList>.c;
-  let Latency = !mul(Cycles, 2), ReleaseAtCycles = [Cycles, !mul(Cycles, 2)] in {
-    defm "" : LMULWriteResMX<"WriteVRGatherVX",    [AscalonFX, AscalonV], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVRGatherVI",    [AscalonFX, AscalonV], mx, IsWorstCase>;
+  foreach mx = SchedMxList in {
+    foreach sew = SchedSEWSet<mx>.val in {
+      defvar Cycles = AscalonGetCyclesVRGatherVV<mx>.c;
+      defvar IsWorstCase = AscalonIsWorstCaseMXSEW<mx, sew, SchedMxList>.c;
+      let Latency = !add(Cycles, 3), ReleaseAtCycles = [1, !add(1, Cycles)] in {
+        defm "" : LMULSEWWriteResMXSEW<"WriteVRGatherVV", [AscalonFX, AscalonV], mx, sew, IsWorstCase>;
+        defm "" : LMULSEWWriteResMXSEW<"WriteVRGatherEI16VV", [AscalonFX, AscalonV], mx, sew, IsWorstCase>;
+        defm "" : LMULSEWWriteResMXSEW<"WriteVCompressV", [AscalonFX, AscalonV], mx, sew, IsWorstCase>;
+      }
+    }
   }
-}
 
-foreach mx = SchedMxList in {
-  foreach sew = SchedSEWSet<mx>.val in {
-    defvar Cycles = AscalonGetCyclesVRGatherVV<mx>.c;
-    defvar IsWorstCase = AscalonIsWorstCaseMXSEW<mx, sew, SchedMxList>.c;
-    let Latency = !add(Cycles, 3), ReleaseAtCycles = [1, !add(1, Cycles)] in {
-      defm "" : LMULSEWWriteResMXSEW<"WriteVRGatherVV", [AscalonFX, AscalonV], mx, sew, IsWorstCase>;
-      defm "" : LMULSEWWriteResMXSEW<"WriteVRGatherEI16VV", [AscalonFX, AscalonV], mx, sew, IsWorstCase>;
-      defm "" : LMULSEWWriteResMXSEW<"WriteVCompressV", [AscalonFX, AscalonV], mx, sew, IsWorstCase>;
+  foreach mx = SchedMxList in {
+    defvar Cycles = AscalonGetCyclesDefault<mx>.c;
+    defvar IsWorstCase = AscalonIsWorstCaseMX<mx, SchedMxList>.c;
+    let Latency = 4, AcquireAtCycles = [0, 1], ReleaseAtCycles = [1, !add(1, Cycles)] in {
+      defm "" : LMULWriteResMX<"WriteVSlideUpX",   [AscalonFX, AscalonV], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVSlideDownX", [AscalonFX, AscalonV], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVSlideUpI",   [AscalonFX, AscalonV], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVSlideDownI", [AscalonFX, AscalonV], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVISlide1Up",   [AscalonFX, AscalonV], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVISlide1Down", [AscalonFX, AscalonV], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVFSlide1Up",   [AscalonFX, AscalonV], mx, IsWorstCase>;
+      defm "" : LMULWriteResMX<"WriteVFSlide1Down", [AscalonFX, AscalonV], mx, IsWorstCase>;
     }
   }
-}
 
-foreach mx = SchedMxList in {
-  defvar Cycles = AscalonGetCyclesDefault<mx>.c;
-  defvar IsWorstCase = AscalonIsWorstCaseMX<mx, SchedMxList>.c;
-  let Latency = 4, AcquireAtCycles = [0, 1], ReleaseAtCycles = [1, !add(1, Cycles)] in {
-    defm "" : LMULWriteResMX<"WriteVSlideUpX",   [AscalonFX, AscalonV], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVSlideDownX", [AscalonFX, AscalonV], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVSlideUpI",   [AscalonFX, AscalonV], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVSlideDownI", [AscalonFX, AscalonV], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVISlide1Up",   [AscalonFX, AscalonV], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVISlide1Down", [AscalonFX, AscalonV], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVFSlide1Up",   [AscalonFX, AscalonV], mx, IsWorstCase>;
-    defm "" : LMULWriteResMX<"WriteVFSlide1Down", [AscalonFX, AscalonV], mx, IsWorstCase>;
+  // Whole vector register move, vmv<N>.v, not LMUL aware
+  let Latency = 1, ReleaseAtCycles = [1] in
+    def : WriteRes<WriteVMov1V,     [AscalonV]>;
+  let Latency = 2, ReleaseAtCycles = [2] in
+    def : WriteRes<WriteVMov2V,     [AscalonV]>;
+  let Latency = 4, ReleaseAtCycles = [4] in
+    def : WriteRes<WriteVMov4V,     [AscalonV]>;
+  let Latency = 8, ReleaseAtCycles = [8] in
+    def : WriteRes<WriteVMov8V,     [AscalonV]>;
+
+  // Vector Integer Arithmetic Instructions
+  defm : LMULReadAdvance<"ReadVIALUV", 0>;
+  defm : LMULReadAdvance<"ReadVIALUX", 0>;
+  defm : LMULReadAdvanceW<"ReadVIWALUV", 0>;
+  defm : LMULReadAdvanceW<"ReadVIWALUX", 0>;
+  defm : LMULReadAdvance<"ReadVExtV", 0>;
+  defm : LMULReadAdvance<"ReadVICALUV", 0>;
+  defm : LMULReadAdvance<"ReadVICALUX", 0>;
+  defm : LMULReadAdvance<"ReadVShiftV", 0>;
+  defm : LMULReadAdvance<"ReadVShiftX", 0>;
+  defm : LMULReadAdvanceW<"ReadVNShiftV", 0>;
+  defm : LMULReadAdvanceW<"ReadVNShiftX", 0>;
+  defm : LMULReadAdvance<"ReadVICmpV", 0>;
+  defm : LMULReadAdvance<"ReadVICmpX", 0>;
+  defm : LMULReadAdvance<"ReadVIMinMaxV", 0>;
+  defm : LMULReadAdvance<"ReadVIMinMaxX", 0>;
+  defm : LMULReadAdvance<"ReadVIMulV", 0>;
+  defm : LMULReadAdvance<"ReadVIMulX", 0>;
+  defm : LMULSEWReadAdvance<"ReadVIDivV", 0>;
+  defm : LMULSEWReadAdvance<"ReadVIDivX", 0>;
+  defm : LMULReadAdvanceW<"ReadVIWMulV", 0>;
+  defm : LMULReadAdvanceW<"ReadVIWMulX", 0>;
+  defm : LMULReadAdvance<"ReadVIMulAddV", 0>;
+  defm : LMULReadAdvance<"ReadVIMulAddX", 0>;
+  defm : LMULReadAdvanceW<"ReadVIWMulAddV", 0>;
+  defm : LMULReadAdvanceW<"ReadVIWMulAddX", 0>;
+  defm : LMULReadAdvance<"ReadVIMergeV", 0>;
+  defm : LMULReadAdvance<"ReadVIMergeX", 0>;
+  defm : LMULReadAdvance<"ReadVIMovV", 0>;
+  defm : LMULReadAdvance<"ReadVIMovX", 0>;
+
+  // Vector Fixed-Point Arithmetic Instructions
+  defm "" : LMULReadAdvance<"ReadVSALUV", 0>;
+  defm "" : LMULReadAdvance<"ReadVSALUX", 0>;
+  defm "" : LMULReadAdvance<"ReadVAALUV", 0>;
+  defm "" : LMULReadAdvance<"ReadVAALUX", 0>;
+  defm "" : LMULReadAdvance<"ReadVSMulV", 0>;
+  defm "" : LMULReadAdvance<"ReadVSMulX", 0>;
+  defm "" : LMULReadAdvance<"ReadVSShiftV", 0>;
+  defm "" : LMULReadAdvance<"ReadVSShiftX", 0>;
+  defm "" : LMULReadAdvanceW<"ReadVNClipV", 0>;
+  defm "" : LMULReadAdvanceW<"ReadVNClipX", 0>;
+
+  // Vector Floating-Point Instructions
+  defm "" : LMULSEWReadAdvanceF<"ReadVFALUV", 0>;
+  defm "" : LMULSEWReadAdvanceF<"ReadVFALUF", 0>;
+  defm "" : LMULSEWReadAdvanceFW<"ReadVFWALUV", 0>;
+  defm "" : LMULSEWReadAdvanceFW<"ReadVFWALUF", 0>;
+  defm "" : LMULSEWReadAdvanceF<"ReadVFMulV", 0>;
+  defm "" : LMULSEWReadAdvanceF<"ReadVFMulF", 0>;
+  defm "" : LMULSEWReadAdvanceF<"ReadVFDivV", 0>;
+  defm "" : LMULSEWReadAdvanceF<"ReadVFDivF", 0>;
+  defm "" : LMULSEWReadAdvanceFW<"ReadVFWMulV", 0>;
+  defm "" : LMULSEWReadAdvanceFW<"ReadVFWMulF", 0>;
+  defm "" : LMULSEWReadAdvanceF<"ReadVFMulAddV", 0>;
+  defm "" : LMULSEWReadAdvanceF<"ReadVFMulAddF", 0>;
+  defm "" : LMULSEWReadAdvanceFW<"ReadVFWMulAddV", 0>;
+  defm "" : LMULSEWReadAdvanceFW<"ReadVFWMulAddF", 0>;
+  defm "" : LMULSEWReadAdvanceF<"ReadVFSqrtV", 0>;
+  defm "" : LMULSEWReadAdvanceF<"ReadVFRecpV", 0>;
+  defm "" : LMULSEWReadAdvanceF<"ReadVFMinMaxV", 0>;
+  defm "" : LMULSEWReadAdvanceF<"ReadVFMinMaxF", 0>;
+  defm "" : LMULSEWReadAdvanceF<"ReadVFSgnjV", 0>;
+  defm "" : LMULSEWReadAdvanceF<"ReadVFSgnjF", 0>;
+  defm "" : LMULReadAdvance<"ReadVFCmpV", 0>;
+  defm "" : LMULReadAdvance<"ReadVFCmpF", 0>;
+  defm "" : LMULReadAdvance<"ReadVFClassV", 0>;
+  defm "" : LMULReadAdvance<"ReadVFMergeV", 0>;
+  defm "" : LMULReadAdvance<"ReadVFMergeF", 0>;
+  defm "" : LMULReadAdvance<"ReadVFMovF", 0>;
+  defm "" : LMULSEWReadAdvanceF<"ReadVFCvtIToFV", 0>;
+  defm "" : LMULReadAdvance<"ReadVFCvtFToIV", 0>;
+  defm "" : LMULSEWReadAdvanceW<"ReadVFWCvtIToFV", 0>;
+  defm "" : LMULReadAdvanceFW<"ReadVFWCvtFToIV", 0>;
+  defm "" : LMULSEWReadAdvanceFW<"ReadVFWCvtFToFV", 0>;
+  defm "" : LMULSEWReadAdvanceFW<"ReadVFNCvtIToFV", 0>;
+  defm "" : LMULReadAdvanceW<"ReadVFNCvtFToIV", 0>;
+  defm "" : LMULSEWReadAdvanceFW<"ReadVFNCvtFToFV", 0>;
+
+  // Vector Reduction Instructions
+  def : ReadAdvance<ReadVIRedV, 0>;
+  def : ReadAdvance<ReadVIRedV0, 0>;
+  def : ReadAdvance<ReadVIWRedV, 0>;
+  def : ReadAdvance<ReadVIWRedV0, 0>;
+  def : ReadAdvance<ReadVFRedV, 0>;
+  def : ReadAdvance<ReadVFRedV0, 0>;
+  def : ReadAdvance<ReadVFRedOV, 0>;
+  def : ReadAdvance<ReadVFRedOV0, 0>;
+  def : ReadAdvance<ReadVFWRedV, 0>;
+  def : ReadAdvance<ReadVFWRedV0, 0>;
+  def : ReadAdvance<ReadVFWRedOV, 0>;
+  def : ReadAdvance<ReadVFWRedOV0, 0>;
+
+  // Vector Mask Instructions
+  defm "" : LMULReadAdvance<"ReadVMALUV", 0>;
+  defm "" : LMULReadAdvance<"ReadVMPopV", 0>;
+  defm "" : LMULReadAdvance<"ReadVMFFSV", 0>;
+  defm "" : LMULReadAdvance<"ReadVMSFSV", 0>;
+  defm "" : LMULReadAdvance<"ReadVIotaV", 0>;
+
+  // Vector Permutation Instructions
+  def : ReadAdvance<ReadVMovXS, 0>;
+  def : ReadAdvance<ReadVMovSX_V, 0>;
+  def : ReadAdvance<ReadVMovSX_X, 0>;
+  def : ReadAdvance<ReadVMovFS, 0>;
+  def : ReadAdvance<ReadVMovSF_V, 0>;
+  def : ReadAdvance<ReadVMovSF_F, 0>;
+  defm "" : LMULReadAdvance<"ReadVISlideV", 0>;
+  defm "" : LMULReadAdvance<"ReadVISlideX", 0>;
+  defm "" : LMULReadAdvance<"ReadVFSlideV", 0>;
+  defm "" : LMULReadAdvance<"ReadVFSlideF", 0>;
+  defm "" : LMULSEWReadAdvance<"ReadVRGatherVV_data", 0>;
+  defm "" : LMULSEWReadAdvance<"ReadVRGatherVV_index", 0>;
+  defm "" : LMULSEWReadAdvance<"ReadVRGatherEI16VV_data", 0>;
+  defm "" : LMULSEWReadAdvance<"ReadVRGatherEI16VV_index", 0>;
+  defm "" : LMULReadAdvance<"ReadVRGatherVX_data", 0>;
+  defm "" : LMULReadAdvance<"ReadVRGatherVX_index", 0>;
+  defm "" : LMULReadAdvance<"ReadVRGatherVI_data", 0>;
+  defm "" : LMULSEWReadAdvance<"ReadVCompressV", 0>;
+  // LMUL Aware
+  def : ReadAdvance<ReadVMov1V, 0>;
+  def : ReadAdvance<ReadVMov2V, 0>;
+  def : ReadAdvance<ReadVMov4V, 0>;
+  def : ReadAdvance<ReadVMov8V, 0>;
+
+  // Others
+  def : ReadAdvance<ReadVMask, 0>;
+  def : ReadAdvance<ReadVPassthru_WorstCase, 0>;
+  foreach mx = SchedMxList in {
+    def : ReadAdvance<!cast<SchedRead>("ReadVPassthru_" # mx), 0>;
+    foreach sew = SchedSEWSet<mx>.val in
+      def : ReadAdvance<!cast<SchedRead>("ReadVPassthru_" # mx  # "_E" # sew), 0>;
   }
-}
 
-// Whole vector register move, vmv<N>.v, not LMUL aware
-let Latency = 1, ReleaseAtCycles = [1] in
-  def : WriteRes<WriteVMov1V,     [AscalonV]>;
-let Latency = 2, ReleaseAtCycles = [2] in
-  def : WriteRes<WriteVMov2V,     [AscalonV]>;
-let Latency = 4, ReleaseAtCycles = [4] in
-  def : WriteRes<WriteVMov4V,     [AscalonV]>;
-let Latency = 8, ReleaseAtCycles = [8] in
-  def : WriteRes<WriteVMov8V,     [AscalonV]>;
-
-// Vector Integer Arithmetic Instructions
-defm : LMULReadAdvance<"ReadVIALUV", 0>;
-defm : LMULReadAdvance<"ReadVIALUX", 0>;
-defm : LMULReadAdvanceW<"ReadVIWALUV", 0>;
-defm : LMULReadAdvanceW<"ReadVIWALUX", 0>;
-defm : LMULReadAdvance<"ReadVExtV", 0>;
-defm : LMULReadAdvance<"ReadVICALUV", 0>;
-defm : LMULReadAdvance<"ReadVICALUX", 0>;
-defm : LMULReadAdvance<"ReadVShiftV", 0>;
-defm : LMULReadAdvance<"ReadVShiftX", 0>;
-defm : LMULReadAdvanceW<"ReadVNShiftV", 0>;
-defm : LMULReadAdvanceW<"ReadVNShiftX", 0>;
-defm : LMULReadAdvance<"ReadVICmpV", 0>;
-defm : LMULReadAdvance<"ReadVICmpX", 0>;
-defm : LMULReadAdvance<"ReadVIMinMaxV", 0>;
-defm : LMULReadAdvance<"ReadVIMinMaxX", 0>;
-defm : LMULReadAdvance<"ReadVIMulV", 0>;
-defm : LMULReadAdvance<"ReadVIMulX", 0>;
-defm : LMULSEWReadAdvance<"ReadVIDivV", 0>;
-defm : LMULSEWReadAdvance<"ReadVIDivX", 0>;
-defm : LMULReadAdvanceW<"ReadVIWMulV", 0>;
-defm : LMULReadAdvanceW<"ReadVIWMulX", 0>;
-defm : LMULReadAdvance<"ReadVIMulAddV", 0>;
-defm : LMULReadAdvance<"ReadVIMulAddX", 0>;
-defm : LMULReadAdvanceW<"ReadVIWMulAddV", 0>;
-defm : LMULReadAdvanceW<"ReadVIWMulAddX", 0>;
-defm : LMULReadAdvance<"ReadVIMergeV", 0>;
-defm : LMULReadAdvance<"ReadVIMergeX", 0>;
-defm : LMULReadAdvance<"ReadVIMovV", 0>;
-defm : LMULReadAdvance<"ReadVIMovX", 0>;
-
-// Vector Fixed-Point Arithmetic Instructions
-defm "" : LMULReadAdvance<"ReadVSALUV", 0>;
-defm "" : LMULReadAdvance<"ReadVSALUX", 0>;
-defm "" : LMULReadAdvance<"ReadVAALUV", 0>;
-defm "" : LMULReadAdvance<"ReadVAALUX", 0>;
-defm "" : LMULReadAdvance<"ReadVSMulV", 0>;
-defm "" : LMULReadAdvance<"ReadVSMulX", 0>;
-defm "" : LMULReadAdvance<"ReadVSShiftV", 0>;
-defm "" : LMULReadAdvance<"ReadVSShiftX", 0>;
-defm "" : LMULReadAdvanceW<"ReadVNClipV", 0>;
-defm "" : LMULReadAdvanceW<"ReadVNClipX", 0>;
-
-// Vector Floating-Point Instructions
-defm "" : LMULSEWReadAdvanceF<"ReadVFALUV", 0>;
-defm "" : LMULSEWReadAdvanceF<"ReadVFALUF", 0>;
-defm "" : LMULSEWReadAdvanceFW<"ReadVFWALUV", 0>;
-defm "" : LMULSEWReadAdvanceFW<"ReadVFWALUF", 0>;
-defm "" : LMULSEWReadAdvanceF<"ReadVFMulV", 0>;
-defm "" : LMULSEWReadAdvanceF<"ReadVFMulF", 0>;
-defm "" : LMULSEWReadAdvanceF<"ReadVFDivV", 0>;
-defm "" : LMULSEWReadAdvanceF<"ReadVFDivF", 0>;
-defm "" : LMULSEWReadAdvanceFW<"ReadVFWMulV", 0>;
-defm "" : LMULSEWReadAdvanceFW<"ReadVFWMulF", 0>;
-defm "" : LMULSEWReadAdvanceF<"ReadVFMulAddV", 0>;
-defm "" : LMULSEWReadAdvanceF<"ReadVFMulAddF", 0>;
-defm "" : LMULSEWReadAdvanceFW<"ReadVFWMulAddV", 0>;
-defm "" : LMULSEWReadAdvanceFW<"ReadVFWMulAddF", 0>;
-defm "" : LMULSEWReadAdvanceF<"ReadVFSqrtV", 0>;
-defm "" : LMULSEWReadAdvanceF<"ReadVFRecpV", 0>;
-defm "" : LMULSEWReadAdvanceF<"ReadVFMinMaxV", 0>;
-defm "" : LMULSEWReadAdvanceF<"ReadVFMinMaxF", 0>;
-defm "" : LMULSEWReadAdvanceF<"ReadVFSgnjV", 0>;
-defm "" : LMULSEWReadAdvanceF<"ReadVFSgnjF", 0>;
-defm "" : LMULReadAdvance<"ReadVFCmpV", 0>;
-defm "" : LMULReadAdvance<"ReadVFCmpF", 0>;
-defm "" : LMULReadAdvance<"ReadVFClassV", 0>;
-defm "" : LMULReadAdvance<"ReadVFMergeV", 0>;
-defm "" : LMULReadAdvance<"ReadVFMergeF", 0>;
-defm "" : LMULReadAdvance<"ReadVFMovF", 0>;
-defm "" : LMULSEWReadAdvanceF<"ReadVFCvtIToFV", 0>;
-defm "" : LMULReadAdvance<"ReadVFCvtFToIV", 0>;
-defm "" : LMULSEWReadAdvanceW<"ReadVFWCvtIToFV", 0>;
-defm "" : LMULReadAdvanceFW<"ReadVFWCvtFToIV", 0>;
-defm "" : LMULSEWReadAdvanceFW<"ReadVFWCvtFToFV", 0>;
-defm "" : LMULSEWReadAdvanceFW<"ReadVFNCvtIToFV", 0>;
-defm "" : LMULReadAdvanceW<"ReadVFNCvtFToIV", 0>;
-defm "" : LMULSEWReadAdvanceFW<"ReadVFNCvtFToFV", 0>;
-
-// Vector Reduction Instructions
-def : ReadAdvance<ReadVIRedV, 0>;
-def : ReadAdvance<ReadVIRedV0, 0>;
-def : ReadAdvance<ReadVIWRedV, 0>;
-def : ReadAdvance<ReadVIWRedV0, 0>;
-def : ReadAdvance<ReadVFRedV, 0>;
-def : ReadAdvance<ReadVFRedV0, 0>;
-def : ReadAdvance<ReadVFRedOV, 0>;
-def : ReadAdvance<ReadVFRedOV0, 0>;
-def : ReadAdvance<ReadVFWRedV, 0>;
-def : ReadAdvance<ReadVFWRedV0, 0>;
-def : ReadAdvance<ReadVFWRedOV, 0>;
-def : ReadAdvance<ReadVFWRedOV0, 0>;
-
-// Vector Mask Instructions
-defm "" : LMULReadAdvance<"ReadVMALUV", 0>;
-defm "" : LMULReadAdvance<"ReadVMPopV", 0>;
-defm "" : LMULReadAdvance<"ReadVMFFSV", 0>;
-defm "" : LMULReadAdvance<"ReadVMSFSV", 0>;
-defm "" : LMULReadAdvance<"ReadVIotaV", 0>;
-
-// Vector Permutation Instructions
-def : ReadAdvance<ReadVMovXS, 0>;
-def : ReadAdvance<ReadVMovSX_V, 0>;
-def : ReadAdvance<ReadVMovSX_X, 0>;
-def : ReadAdvance<ReadVMovFS, 0>;
-def : ReadAdvance<ReadVMovSF_V, 0>;
-def : ReadAdvance<ReadVMovSF_F, 0>;
-defm "" : LMULReadAdvance<"ReadVISlideV", 0>;
-defm "" : LMULReadAdvance<"ReadVISlideX", 0>;
-defm "" : LMULReadAdvance<"ReadVFSlideV", 0>;
-defm "" : LMULReadAdvance<"ReadVFSlideF", 0>;
-defm "" : LMULSEWReadAdvance<"ReadVRGatherVV_data", 0>;
-defm "" : LMULSEWReadAdvance<"ReadVRGatherVV_index", 0>;
-defm "" : LMULSEWReadAdvance<"ReadVRGatherEI16VV_data", 0>;
-defm "" : LMULSEWReadAdvance<"ReadVRGatherEI16VV_index", 0>;
-defm "" : LMULReadAdvance<"ReadVRGatherVX_data", 0>;
-defm "" : LMULReadAdvance<"ReadVRGatherVX_index", 0>;
-defm "" : LMULReadAdvance<"ReadVRGatherVI_data", 0>;
-defm "" : LMULSEWReadAdvance<"ReadVCompressV", 0>;
-// LMUL Aware
-def : ReadAdvance<ReadVMov1V, 0>;
-def : ReadAdvance<ReadVMov2V, 0>;
-def : ReadAdvance<ReadVMov4V, 0>;
-def : ReadAdvance<ReadVMov8V, 0>;
-
-// Others
-def : ReadAdvance<ReadVMask, 0>;
-def : ReadAdvance<ReadVPassthru_WorstCase, 0>;
-foreach mx = SchedMxList in {
-  def : ReadAdvance<!cast<SchedRead>("ReadVPassthru_" # mx), 0>;
-  foreach sew = SchedSEWSet<mx>.val in
-    def : ReadAdvance<!cast<SchedRead>("ReadVPassthru_" # mx  # "_E" # sew), 0>;
+  //===--------------------------------------------------------------------===//
+  // Unsupported extensions
+  defm : UnsupportedSchedQ;
+  defm : UnsupportedSchedZabha;
+  defm : UnsupportedSchedZbc;
+  defm : UnsupportedSchedZbkb;
+  defm : UnsupportedSchedZbkx;
+  defm : UnsupportedSchedZfa;
+  defm : UnsupportedSchedZvk;
+  defm : UnsupportedSchedSFB;
+  defm : UnsupportedSchedXsf;
 }
 
-//===----------------------------------------------------------------------===//
-// Unsupported extensions
-defm : UnsupportedSchedQ;
-defm : UnsupportedSchedZabha;
-defm : UnsupportedSchedZbc;
-defm : UnsupportedSchedZbkb;
-defm : UnsupportedSchedZbkx;
-defm : UnsupportedSchedZfa;
-defm : UnsupportedSchedZvk;
-defm : UnsupportedSchedSFB;
-defm : UnsupportedSchedXsf;
+foreach model = [TTAscalonXModel, TTAscalonXGModel] in {
+  let SchedModel = model in
+  defm model.Name
+      : TTAscalonSchedResources<model.HasReducedFP64VectorThroughput>;
 }
diff --git a/llvm/test/tools/llvm-mca/RISCV/tt-ascalon-x/vfp64.s b/llvm/test/tools/llvm-mca/RISCV/tt-ascalon-x/vfp64.s
new file mode 100644
index 000000000000000..5fcf88aed59d98e
--- /dev/null
+++ b/llvm/test/tools/llvm-mca/RISCV/tt-ascalon-x/vfp64.s
@@ -0,0 +1,116 @@
+# NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py
+# RUN: llvm-mca -mtriple=riscv64-unknown-unknown -mcpu=tt-ascalon-xg --iterations=1 < %s | FileCheck %s
+
+# Vector instructions producing FP64 results have reduced throughput on
+# Ascalon XG: all other vector instructions are unaffected.
+
+vsetvli zero, zero, e32, m1, ta, ma
+vfadd.vv v8, v9, v10
+vfmul.vv v8, v9, v10
+vfmacc.vv v8, v9, v10
+vfwadd.vv v8, v10, v11
+vfwmul.vv v8, v10, v11
+vfwmacc.vv v8, v10, v11
+vfwcvt.f.f.v v8, v10
+vfwcvt.f.x.v v8, v10
+vfsqrt.v v8, v9
+vfmin.vv v8, v9, v10
+vsetvli zero, zero, e64, m1, ta, ma
+vfadd.vv v8, v9, v10
+vfmul.vv v8, v9, v10
+vfmacc.vv v8, v9, v10
+vfsqrt.v v8, v9
+vfmin.vv v8, v9, v10
+vfredusum.vs v8, v9, v10
+vsetvli zero, zero, e64, m4, ta, ma
+vfadd.vv v8, v12, v16
+vfmul.vv v8, v12, v16
+vfmacc.vv v8, v12, v16
+
+# CHECK:      Iterations:        1
+# CHECK-NEXT: Instructions:      22
+# CHECK-NEXT: Total Cycles:      52
+# CHECK-NEXT: Total uOps:        22
+
+# CHECK:      Dispatch Width:    8
+# CHECK-NEXT: uOps Per Cycle:    0.42
+# CHECK-NEXT: IPC:               0.42
+# CHECK-NEXT: Block RThroughput: 40.0
+
+# CHECK:      Instruction Info:
+# CHECK-NEXT: [1]: #uOps
+# CHECK-NEXT: [2]: Latency
+# CHECK-NEXT: [3]: RThroughput
+# CHECK-NEXT: [4]: MayLoad
+# CHECK-NEXT: [5]: MayStore
+# CHECK-NEXT: [6]: HasSideEffects (U)
+
+# CHECK:      [1]    [2]    [3]    [4]    [5]    [6]    Instructions:
+# CHECK-NEXT:  1      1     0.50                  U     vsetvli	zero, zero, e32, m1, ta, ma
+# CHECK-NEXT:  1      1     0.50                        vfadd.vv	v8, v9, v10
+# CHECK-NEXT:  1      1     0.50                        vfmul.vv	v8, v9, v10
+# CHECK-NEXT:  1      1     0.50                        vfmacc.vv	v8, v9, v10
+# CHECK-NEXT:  1      9     2.00                        vfwadd.vv	v8, v10, v11
+# CHECK-NEXT:  1      9     2.00                        vfwmul.vv	v8, v10, v11
+# CHECK-NEXT:  1      9     2.00                        vfwmacc.vv	v8, v10, v11
+# CHECK-NEXT:  1      9     2.00                        vfwcvt.f.f.v	v8, v10
+# CHECK-NEXT:  1      9     2.00                        vfwcvt.f.x.v	v8, v10
+# CHECK-NEXT:  1      5     2.50                        vfsqrt.v	v8, v9
+# CHECK-NEXT:  1      1     0.50                        vfmin.vv	v8, v9, v10
+# CHECK-NEXT:  1      1     0.50                  U     vsetvli	zero, zero, e64, m1, ta, ma
+# CHECK-NEXT:  1      9     2.00                        vfadd.vv	v8, v9, v10
+# CHECK-NEXT:  1      9     2.00                        vfmul.vv	v8, v9, v10
+# CHECK-NEXT:  1      9     2.00                        vfmacc.vv	v8, v9, v10
+# CHECK-NEXT:  1      8     4.00                        vfsqrt.v	v8, v9
+# CHECK-NEXT:  1      1     0.50                        vfmin.vv	v8, v9, v10
+# CHECK-NEXT:  1      1     0.50                        vfredusum.vs	v8, v9, v10
+# CHECK-NEXT:  1      1     0.50                  U     vsetvli	zero, zero, e64, m4, ta, ma
+# CHECK-NEXT:  1      12    8.00                        vfadd.vv	v8, v12, v16
+# CHECK-NEXT:  1      12    8.00                        vfmul.vv	v8, v12, v16
+# CHECK-NEXT:  1      12    8.00                        vfmacc.vv	v8, v12, v16
+
+# CHECK:      Resources:
+# CHECK-NEXT: [0.0] - AscalonXGFP64V
+# CHECK-NEXT: [0.1] - AscalonXGFP64V
+# CHECK-NEXT: [1]   - AscalonXGFPA
+# CHECK-NEXT: [2]   - AscalonXGFPB
+# CHECK-NEXT: [3]   - AscalonXGFXA
+# CHECK-NEXT: [4]   - AscalonXGFXB
+# CHECK-NEXT: [5.0] - AscalonXGFXC
+# CHECK-NEXT: [5.1] - AscalonXGFXC
+# CHECK-NEXT: [6.0] - AscalonXGFXD
+# CHECK-NEXT: [6.1] - AscalonXGFXD
+# CHECK-NEXT: [7.0] - AscalonXGLS
+# CHECK-NEXT: [7.1] - AscalonXGLS
+# CHECK-NEXT: [7.2] - AscalonXGLS
+# CHECK-NEXT: [8]   - AscalonXGVA
+# CHECK-NEXT: [9]   - AscalonXGVB
+
+# CHECK:      Resource pressure per iteration:
+# CHECK-NEXT: [0.0]  [0.1]  [1]    [2]    [3]    [4]    [5.0]  [5.1]  [6.0]  [6.1]  [7.0]  [7.1]  [7.2]  [8]    [9]
+# CHECK-NEXT: 32.00  48.00  8.00   9.00    -     1.00    -      -      -     1.00    -      -      -     22.00  20.00
+
+# CHECK:      Resource pressure by instruction:
+# CHECK-NEXT: [0.0]  [0.1]  [1]    [2]    [3]    [4]    [5.0]  [5.1]  [6.0]  [6.1]  [7.0]  [7.1]  [7.2]  [8]    [9]    Instructions:
+# CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -      -      -      -      -     1.00   vsetvli	zero, zero, e32, m1, ta, ma
+# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -      -      -      -     1.00    -     vfadd.vv	v8, v9, v10
+# CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -      -      -      -      -     1.00   vfmul.vv	v8, v9, v10
+# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -      -      -      -      -     1.00   vfmacc.vv	v8, v9, v10
+# CHECK-NEXT:  -     4.00   1.00    -      -      -      -      -      -      -      -      -      -     1.00    -     vfwadd.vv	v8, v10, v11
+# CHECK-NEXT: 4.00    -      -     1.00    -      -      -      -      -      -      -      -      -      -     1.00   vfwmul.vv	v8, v10, v11
+# CHECK-NEXT:  -     4.00    -     1.00    -      -      -      -      -      -      -      -      -     1.00    -     vfwmacc.vv	v8, v10, v11
+# CHECK-NEXT:  -     4.00    -     1.00    -      -      -      -      -      -      -      -      -     1.00    -     vfwcvt.f.f.v	v8, v10
+# CHECK-NEXT: 4.00    -      -      -      -     1.00    -      -      -      -      -      -      -     1.00    -     vfwcvt.f.x.v	v8, v10
+# CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -      -      -      -     5.00    -     vfsqrt.v	v8, v9
+# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -      -      -      -      -     1.00   vfmin.vv	v8, v9, v10
+# CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -      -      -      -     1.00    -     vsetvli	zero, zero, e64, m1, ta, ma
+# CHECK-NEXT: 4.00    -     1.00    -      -      -      -      -      -      -      -      -      -      -     1.00   vfadd.vv	v8, v9, v10
+# CHECK-NEXT:  -     4.00    -     1.00    -      -      -      -      -      -      -      -      -     1.00    -     vfmul.vv	v8, v9, v10
+# CHECK-NEXT: 4.00    -     1.00    -      -      -      -      -      -      -      -      -      -      -     1.00   vfmacc.vv	v8, v9, v10
+# CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -      -      -      -      -     8.00   vfsqrt.v	v8, v9
+# CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -      -      -      -     1.00    -     vfmin.vv	v8, v9, v10
+# CHECK-NEXT:  -      -      -      -      -      -      -      -      -     1.00    -      -      -     1.00    -     vfredusum.vs	v8, v9, v10
+# CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -      -      -      -      -     1.00   vsetvli	zero, zero, e64, m4, ta, ma
+# CHECK-NEXT: 16.00   -     1.00    -      -      -      -      -      -      -      -      -      -      -     4.00   vfadd.vv	v8, v12, v16
+# CHECK-NEXT:  -     16.00   -     1.00    -      -      -      -      -      -      -      -      -     4.00    -     vfmul.vv	v8, v12, v16
+# CHECK-NEXT:  -     16.00   -     1.00    -      -      -      -      -      -      -      -      -     4.00    -     vfmacc.vv	v8, v12, v16

>From 6c7c1d0dcbd35685bc1392c75299e37c121208a6 Mon Sep 17 00:00:00 2001
From: Ramkumar Ramachandra <artagnon at tenstorrent.com>
Date: Tue, 6 Oct 2026 12:15:50 +0100
Subject: [PATCH 2/3] [RISCV] Fix missed sched, modernize tests

---
 clang/test/Driver/riscv-cpus.c                | 129 ++++++-------
 llvm/lib/Target/RISCV/RISCVSchedTTAscalonX.td |  14 +-
 .../tools/llvm-mca/RISCV/tt-ascalon-x/vfp64.s | 171 ++++++++++++------
 3 files changed, 186 insertions(+), 128 deletions(-)

diff --git a/clang/test/Driver/riscv-cpus.c b/clang/test/Driver/riscv-cpus.c
index 9376492309cc0be..ea7966089b2d752 100644
--- a/clang/test/Driver/riscv-cpus.c
+++ b/clang/test/Driver/riscv-cpus.c
@@ -250,70 +250,71 @@
 // MCPU-TT-ASCALON-X-SAME: "-target-feature" "+svpbmt"
 // MCPU-TT-ASCALON-X-SAME: "-target-abi" "lp64d"
 
-// RUN: %clang --target=riscv64 -### -c %s 2>&1 -mtune=tt-ascalon-xg | FileCheck -check-prefix=MTUNE-TT-ASCALON-XG %s
-// MTUNE-TT-ASCALON-XG: "-tune-cpu" "tt-ascalon-xg"
-
-// RUN: %clang --target=riscv64 -### -c %s 2>&1 -mcpu=tt-ascalon-xg | FileCheck -check-prefix=MCPU-TT-ASCALON-XG %s
-// MCPU-TT-ASCALON-XG: "-target-cpu" "tt-ascalon-xg"
-// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+m"
-// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+a"
-// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+f"
-// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+d"
-// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+c"
-// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+v"
-// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+h"
-// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zicbom"
-// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zicbop"
-// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zicboz"
-// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zicntr"
-// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zicond"
-// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zicsr"
-// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zifencei"
-// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zihintntl"
-// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zihintpause"
-// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zihpm"
-// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zimop"
-// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zmmul"
-// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zawrs"
-// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zfa"
-// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zfbfmin"
-// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zfh"
-// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zfhmin"
-// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zca"
-// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zcb"
-// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zba"
-// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zbb"
-// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zbs"
-// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zkr"
-// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zkt"
-// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zvbb"
-// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zvbc"
-// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zve32f"
-// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zve32x"
-// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zve64d"
-// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zve64f"
-// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zve64x"
-// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zvfbfmin"
-// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zvfbfwma"
-// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zvfh"
-// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zvfhmin"
-// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zvkb"
-// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zvkt"
-// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zvl128b"
-// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zvl256b"
-// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zvl32b"
-// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+zvl64b"
-// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+smaia"
-// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+smmpm"
-// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+smnpm"
-// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+smrnmi"
-// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+smstateen"
-// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+sscofpmf"
-// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+svinval"
-// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+svnapot"
-// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "+svpbmt"
-// MCPU-TT-ASCALON-XG-SAME: "-target-feature" "-zvkng"
-// MCPU-TT-ASCALON-XG-SAME: "-target-abi" "lp64d"
+// RUN: %clang --target=riscv64 -mcpu=tt-ascalon-xg --print-enabled-extensions | FileCheck -check-prefix=MCPU-TT-ASCALON-XG %s
+// MCPU-TT-ASCALON-XG: i
+// MCPU-TT-ASCALON-XG: m
+// MCPU-TT-ASCALON-XG: a
+// MCPU-TT-ASCALON-XG: f
+// MCPU-TT-ASCALON-XG: d
+// MCPU-TT-ASCALON-XG: c
+// MCPU-TT-ASCALON-XG: v
+// MCPU-TT-ASCALON-XG: h
+// MCPU-TT-ASCALON-XG: zicbom
+// MCPU-TT-ASCALON-XG: zicbop
+// MCPU-TT-ASCALON-XG: zicboz
+// MCPU-TT-ASCALON-XG: zicntr
+// MCPU-TT-ASCALON-XG: zicond
+// MCPU-TT-ASCALON-XG: zicsr
+// MCPU-TT-ASCALON-XG: zifencei
+// MCPU-TT-ASCALON-XG: zihintntl
+// MCPU-TT-ASCALON-XG: zihintpause
+// MCPU-TT-ASCALON-XG: zihpm
+// MCPU-TT-ASCALON-XG: zimop
+// MCPU-TT-ASCALON-XG: zmmul
+// MCPU-TT-ASCALON-XG: zawrs
+// MCPU-TT-ASCALON-XG: zfa
+// MCPU-TT-ASCALON-XG: zfbfmin
+// MCPU-TT-ASCALON-XG: zfh
+// MCPU-TT-ASCALON-XG: zfhmin
+// MCPU-TT-ASCALON-XG: zca
+// MCPU-TT-ASCALON-XG: zcb
+// MCPU-TT-ASCALON-XG: zba
+// MCPU-TT-ASCALON-XG: zbb
+// MCPU-TT-ASCALON-XG: zbs
+// MCPU-TT-ASCALON-XG: zkr
+// MCPU-TT-ASCALON-XG: zkt
+// MCPU-TT-ASCALON-XG: zvbb
+// MCPU-TT-ASCALON-XG: zvbc
+// MCPU-TT-ASCALON-XG: zve32f
+// MCPU-TT-ASCALON-XG: zve32x
+// MCPU-TT-ASCALON-XG: zve64d
+// MCPU-TT-ASCALON-XG: zve64f
+// MCPU-TT-ASCALON-XG: zve64x
+// MCPU-TT-ASCALON-XG: zvfbfmin
+// MCPU-TT-ASCALON-XG: zvfbfwma
+// MCPU-TT-ASCALON-XG: zvfh
+// MCPU-TT-ASCALON-XG: zvfhmin
+// MCPU-TT-ASCALON-XG: zvkb
+// MCPU-TT-ASCALON-XG-NOT: zvkg
+// MCPU-TT-ASCALON-XG-NOT: zvkn
+// MCPU-TT-ASCALON-XG-NOT: zvknc
+// MCPU-TT-ASCALON-XG-NOT: zvkned
+// MCPU-TT-ASCALON-XG-NOT: zvknha
+// MCPU-TT-ASCALON-XG-NOT: zvknhb
+// MCPU-TT-ASCALON-XG: zvkt
+// MCPU-TT-ASCALON-XG: zvl128b
+// MCPU-TT-ASCALON-XG: zvl256b
+// MCPU-TT-ASCALON-XG: zvl32b
+// MCPU-TT-ASCALON-XG: zvl64b
+// MCPU-TT-ASCALON-XG: smaia
+// MCPU-TT-ASCALON-XG: smmpm
+// MCPU-TT-ASCALON-XG: smnpm
+// MCPU-TT-ASCALON-XG: smrnmi
+// MCPU-TT-ASCALON-XG: smstateen
+// MCPU-TT-ASCALON-XG: sscofpmf
+// MCPU-TT-ASCALON-XG: svinval
+// MCPU-TT-ASCALON-XG: svnapot
+// MCPU-TT-ASCALON-XG: svpbmt
 
 // RUN: %clang --target=riscv64 -### -c %s 2>&1 -mtune=xiangshan-nanhu | FileCheck -check-prefix=MTUNE-XIANGSHAN-NANHU %s
 // MTUNE-XIANGSHAN-NANHU: "-tune-cpu" "xiangshan-nanhu"
diff --git a/llvm/lib/Target/RISCV/RISCVSchedTTAscalonX.td b/llvm/lib/Target/RISCV/RISCVSchedTTAscalonX.td
index 0dc6f06079b025e..6a1c5aceae75f76 100644
--- a/llvm/lib/Target/RISCV/RISCVSchedTTAscalonX.td
+++ b/llvm/lib/Target/RISCV/RISCVSchedTTAscalonX.td
@@ -738,14 +738,12 @@ multiclass TTAscalonSchedResources<bit ReducedFP64Vec> {
         defm "" : LMULSEWWriteResMXSEW<"WriteVFMulF",  FPVRes, mx, sew, IsWorstCase>;
         defm "" : LMULSEWWriteResMXSEW<"WriteVFMulAddV", FPVRes, mx, sew, IsWorstCase>;
         defm "" : LMULSEWWriteResMXSEW<"WriteVFMulAddF", FPVRes, mx, sew, IsWorstCase>;
-      }
-      let Latency = Cycles, ReleaseAtCycles = [1, Cycles] in {
-        defm "" : LMULSEWWriteResMXSEW<"WriteVFRecpV",   [AscalonFP, AscalonV], mx, sew, IsWorstCase>;
-        defm "" : LMULSEWWriteResMXSEW<"WriteVFCvtIToFV", [AscalonFP, AscalonV], mx, sew, IsWorstCase>;
-        defm "" : LMULSEWWriteResMXSEW<"WriteVFMinMaxV", [AscalonFP, AscalonV], mx, sew, IsWorstCase>;
-        defm "" : LMULSEWWriteResMXSEW<"WriteVFMinMaxF", [AscalonFP, AscalonV], mx, sew, IsWorstCase>;
-        defm "" : LMULSEWWriteResMXSEW<"WriteVFSgnjV",   [AscalonFP, AscalonV], mx, sew, IsWorstCase>;
-        defm "" : LMULSEWWriteResMXSEW<"WriteVFSgnjF",   [AscalonFP, AscalonV], mx, sew, IsWorstCase>;
+        defm "" : LMULSEWWriteResMXSEW<"WriteVFRecpV",   FPVRes, mx, sew, IsWorstCase>;
+        defm "" : LMULSEWWriteResMXSEW<"WriteVFCvtIToFV", FPVRes, mx, sew, IsWorstCase>;
+        defm "" : LMULSEWWriteResMXSEW<"WriteVFMinMaxV", FPVRes, mx, sew, IsWorstCase>;
+        defm "" : LMULSEWWriteResMXSEW<"WriteVFMinMaxF", FPVRes, mx, sew, IsWorstCase>;
+        defm "" : LMULSEWWriteResMXSEW<"WriteVFSgnjV",   FPVRes, mx, sew, IsWorstCase>;
+        defm "" : LMULSEWWriteResMXSEW<"WriteVFSgnjF",   FPVRes, mx, sew, IsWorstCase>;
       }
     }
   }
diff --git a/llvm/test/tools/llvm-mca/RISCV/tt-ascalon-x/vfp64.s b/llvm/test/tools/llvm-mca/RISCV/tt-ascalon-x/vfp64.s
index 5fcf88aed59d98e..218a55ccdcbd6c0 100644
--- a/llvm/test/tools/llvm-mca/RISCV/tt-ascalon-x/vfp64.s
+++ b/llvm/test/tools/llvm-mca/RISCV/tt-ascalon-x/vfp64.s
@@ -1,5 +1,5 @@
 # NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py
-# RUN: llvm-mca -mtriple=riscv64-unknown-unknown -mcpu=tt-ascalon-xg --iterations=1 < %s | FileCheck %s
+# RUN: llvm-mca -mtriple=riscv64 -mcpu=tt-ascalon-xg --instruction-tables=full < %s | FileCheck %s
 
 # Vector instructions producing FP64 results have reduced throughput on
 # Ascalon XG: all other vector instructions are unaffected.
@@ -15,27 +15,49 @@ vfwcvt.f.f.v v8, v10
 vfwcvt.f.x.v v8, v10
 vfsqrt.v v8, v9
 vfmin.vv v8, v9, v10
+vfcvt.f.x.v v8, v9
+vfcvt.f.xu.v v8, v9
+vfmin.vf v8, v9, fa0
+vfmax.vf v8, v9, fa0
+vfsgnj.vv v8, v9, v10
+vfsgnj.vf v8, v9, fa0
 vsetvli zero, zero, e64, m1, ta, ma
 vfadd.vv v8, v9, v10
 vfmul.vv v8, v9, v10
 vfmacc.vv v8, v9, v10
 vfsqrt.v v8, v9
 vfmin.vv v8, v9, v10
+vfcvt.f.x.v v8, v9
+vfcvt.f.xu.v v8, v9
+vfmin.vf v8, v9, fa0
+vfmax.vf v8, v9, fa0
+vfsgnj.vv v8, v9, v10
+vfsgnj.vf v8, v9, fa0
 vfredusum.vs v8, v9, v10
 vsetvli zero, zero, e64, m4, ta, ma
 vfadd.vv v8, v12, v16
 vfmul.vv v8, v12, v16
 vfmacc.vv v8, v12, v16
+vfcvt.f.x.v v8, v12
+vfmin.vv v8, v12, v16
+vfmin.vf v8, v12, fa0
+vfsgnj.vv v8, v12, v16
+vfsgnj.vf v8, v12, fa0
 
-# CHECK:      Iterations:        1
-# CHECK-NEXT: Instructions:      22
-# CHECK-NEXT: Total Cycles:      52
-# CHECK-NEXT: Total uOps:        22
-
-# CHECK:      Dispatch Width:    8
-# CHECK-NEXT: uOps Per Cycle:    0.42
-# CHECK-NEXT: IPC:               0.42
-# CHECK-NEXT: Block RThroughput: 40.0
+# CHECK:      Resources:
+# CHECK-NEXT: [0]   - AscalonXGFP:2 AscalonXGFPA, AscalonXGFPB
+# CHECK-NEXT: [1]   - AscalonXGFP64V:2
+# CHECK-NEXT: [2]   - AscalonXGFPA:1
+# CHECK-NEXT: [3]   - AscalonXGFPB:1
+# CHECK-NEXT: [4]   - AscalonXGFX:6 AscalonXGFXA, AscalonXGFXB, AscalonXGFXC, AscalonXGFXC, AscalonXGFXD, AscalonXGFXD
+# CHECK-NEXT: [5]   - AscalonXGFXA:1
+# CHECK-NEXT: [6]   - AscalonXGFXB:1
+# CHECK-NEXT: [7]   - AscalonXGFXC:2
+# CHECK-NEXT: [8]   - AscalonXGFXD:2
+# CHECK-NEXT: [9]   - AscalonXGLS:3
+# CHECK-NEXT: [10]  - AscalonXGV:2 AscalonXGVA, AscalonXGVB
+# CHECK-NEXT: [11]  - AscalonXGVA:1
+# CHECK-NEXT: [12]  - AscalonXGVB:1
 
 # CHECK:      Instruction Info:
 # CHECK-NEXT: [1]: #uOps
@@ -44,30 +66,50 @@ vfmacc.vv v8, v12, v16
 # CHECK-NEXT: [4]: MayLoad
 # CHECK-NEXT: [5]: MayStore
 # CHECK-NEXT: [6]: HasSideEffects (U)
+# CHECK-NEXT: [7]: Bypass Latency
+# CHECK-NEXT: [8]: Resources (<Name> | <Name>[<ReleaseAtCycle>] | <Name>[<AcquireAtCycle>,<ReleaseAtCycle])
+# CHECK-NEXT: [9]: LLVM Opcode Name
 
-# CHECK:      [1]    [2]    [3]    [4]    [5]    [6]    Instructions:
-# CHECK-NEXT:  1      1     0.50                  U     vsetvli	zero, zero, e32, m1, ta, ma
-# CHECK-NEXT:  1      1     0.50                        vfadd.vv	v8, v9, v10
-# CHECK-NEXT:  1      1     0.50                        vfmul.vv	v8, v9, v10
-# CHECK-NEXT:  1      1     0.50                        vfmacc.vv	v8, v9, v10
-# CHECK-NEXT:  1      9     2.00                        vfwadd.vv	v8, v10, v11
-# CHECK-NEXT:  1      9     2.00                        vfwmul.vv	v8, v10, v11
-# CHECK-NEXT:  1      9     2.00                        vfwmacc.vv	v8, v10, v11
-# CHECK-NEXT:  1      9     2.00                        vfwcvt.f.f.v	v8, v10
-# CHECK-NEXT:  1      9     2.00                        vfwcvt.f.x.v	v8, v10
-# CHECK-NEXT:  1      5     2.50                        vfsqrt.v	v8, v9
-# CHECK-NEXT:  1      1     0.50                        vfmin.vv	v8, v9, v10
-# CHECK-NEXT:  1      1     0.50                  U     vsetvli	zero, zero, e64, m1, ta, ma
-# CHECK-NEXT:  1      9     2.00                        vfadd.vv	v8, v9, v10
-# CHECK-NEXT:  1      9     2.00                        vfmul.vv	v8, v9, v10
-# CHECK-NEXT:  1      9     2.00                        vfmacc.vv	v8, v9, v10
-# CHECK-NEXT:  1      8     4.00                        vfsqrt.v	v8, v9
-# CHECK-NEXT:  1      1     0.50                        vfmin.vv	v8, v9, v10
-# CHECK-NEXT:  1      1     0.50                        vfredusum.vs	v8, v9, v10
-# CHECK-NEXT:  1      1     0.50                  U     vsetvli	zero, zero, e64, m4, ta, ma
-# CHECK-NEXT:  1      12    8.00                        vfadd.vv	v8, v12, v16
-# CHECK-NEXT:  1      12    8.00                        vfmul.vv	v8, v12, v16
-# CHECK-NEXT:  1      12    8.00                        vfmacc.vv	v8, v12, v16
+# CHECK:      [1]    [2]    [3]    [4]    [5]    [6]    [7]    [8]                                        [9]                        Instructions:
+# CHECK-NEXT:  1      1     0.50                  U      0     AscalonXGV                                 VSETVLI                    vsetvli	zero, zero, e32, m1, ta, ma
+# CHECK-NEXT:  1      1     0.50                         1     AscalonXGFP,AscalonXGV                     VFADD_VV                   vfadd.vv	v8, v9, v10
+# CHECK-NEXT:  1      1     0.50                         1     AscalonXGFP,AscalonXGV                     VFMUL_VV                   vfmul.vv	v8, v9, v10
+# CHECK-NEXT:  1      1     0.50                         1     AscalonXGFP,AscalonXGV                     VFMACC_VV                  vfmacc.vv	v8, v9, v10
+# CHECK-NEXT:  1      9     2.00                         9     AscalonXGFP,AscalonXGFP64V[4],AscalonXGV   VFWADD_VV                  vfwadd.vv	v8, v10, v11
+# CHECK-NEXT:  1      9     2.00                         9     AscalonXGFP,AscalonXGFP64V[4],AscalonXGV   VFWMUL_VV                  vfwmul.vv	v8, v10, v11
+# CHECK-NEXT:  1      9     2.00                         9     AscalonXGFP,AscalonXGFP64V[4],AscalonXGV   VFWMACC_VV                 vfwmacc.vv	v8, v10, v11
+# CHECK-NEXT:  1      9     2.00                         9     AscalonXGFP,AscalonXGFP64V[4],AscalonXGV   VFWCVT_F_F_V               vfwcvt.f.f.v	v8, v10
+# CHECK-NEXT:  1      9     2.00                         9     AscalonXGFP64V[4],AscalonXGFX,AscalonXGFXB,AscalonXGV VFWCVT_F_X_V    vfwcvt.f.x.v	v8, v10
+# CHECK-NEXT:  1      5     2.50                         5     AscalonXGFP,AscalonXGV[5]                  VFSQRT_V                   vfsqrt.v	v8, v9
+# CHECK-NEXT:  1      1     0.50                         1     AscalonXGFP,AscalonXGV                     VFMIN_VV                   vfmin.vv	v8, v9, v10
+# CHECK-NEXT:  1      1     0.50                         1     AscalonXGFP,AscalonXGV                     VFCVT_F_X_V                vfcvt.f.x.v	v8, v9
+# CHECK-NEXT:  1      1     0.50                         1     AscalonXGFP,AscalonXGV                     VFCVT_F_XU_V               vfcvt.f.xu.v	v8, v9
+# CHECK-NEXT:  1      1     0.50                         1     AscalonXGFP,AscalonXGV                     VFMIN_VF                   vfmin.vf	v8, v9, fa0
+# CHECK-NEXT:  1      1     0.50                         1     AscalonXGFP,AscalonXGV                     VFMAX_VF                   vfmax.vf	v8, v9, fa0
+# CHECK-NEXT:  1      1     0.50                         1     AscalonXGFP,AscalonXGV                     VFSGNJ_VV                  vfsgnj.vv	v8, v9, v10
+# CHECK-NEXT:  1      1     0.50                         1     AscalonXGFP,AscalonXGV                     VFSGNJ_VF                  vfsgnj.vf	v8, v9, fa0
+# CHECK-NEXT:  1      1     0.50                  U      0     AscalonXGV                                 VSETVLI                    vsetvli	zero, zero, e64, m1, ta, ma
+# CHECK-NEXT:  1      9     2.00                         9     AscalonXGFP,AscalonXGFP64V[4],AscalonXGV   VFADD_VV                   vfadd.vv	v8, v9, v10
+# CHECK-NEXT:  1      9     2.00                         9     AscalonXGFP,AscalonXGFP64V[4],AscalonXGV   VFMUL_VV                   vfmul.vv	v8, v9, v10
+# CHECK-NEXT:  1      9     2.00                         9     AscalonXGFP,AscalonXGFP64V[4],AscalonXGV   VFMACC_VV                  vfmacc.vv	v8, v9, v10
+# CHECK-NEXT:  1      8     4.00                         8     AscalonXGFP,AscalonXGV[8]                  VFSQRT_V                   vfsqrt.v	v8, v9
+# CHECK-NEXT:  1      9     2.00                         9     AscalonXGFP,AscalonXGFP64V[4],AscalonXGV   VFMIN_VV                   vfmin.vv	v8, v9, v10
+# CHECK-NEXT:  1      9     2.00                         9     AscalonXGFP,AscalonXGFP64V[4],AscalonXGV   VFCVT_F_X_V                vfcvt.f.x.v	v8, v9
+# CHECK-NEXT:  1      9     2.00                         9     AscalonXGFP,AscalonXGFP64V[4],AscalonXGV   VFCVT_F_XU_V               vfcvt.f.xu.v	v8, v9
+# CHECK-NEXT:  1      9     2.00                         9     AscalonXGFP,AscalonXGFP64V[4],AscalonXGV   VFMIN_VF                   vfmin.vf	v8, v9, fa0
+# CHECK-NEXT:  1      9     2.00                         9     AscalonXGFP,AscalonXGFP64V[4],AscalonXGV   VFMAX_VF                   vfmax.vf	v8, v9, fa0
+# CHECK-NEXT:  1      9     2.00                         9     AscalonXGFP,AscalonXGFP64V[4],AscalonXGV   VFSGNJ_VV                  vfsgnj.vv	v8, v9, v10
+# CHECK-NEXT:  1      9     2.00                         9     AscalonXGFP,AscalonXGFP64V[4],AscalonXGV   VFSGNJ_VF                  vfsgnj.vf	v8, v9, fa0
+# CHECK-NEXT:  1      1     0.50                         1     AscalonXGFX,AscalonXGV                     VFREDUSUM_VS               vfredusum.vs	v8, v9, v10
+# CHECK-NEXT:  1      1     0.50                  U      0     AscalonXGV                                 VSETVLI                    vsetvli	zero, zero, e64, m4, ta, ma
+# CHECK-NEXT:  1      12    8.00                         12    AscalonXGFP,AscalonXGFP64V[16],AscalonXGV[4] VFADD_VV                 vfadd.vv	v8, v12, v16
+# CHECK-NEXT:  1      12    8.00                         12    AscalonXGFP,AscalonXGFP64V[16],AscalonXGV[4] VFMUL_VV                 vfmul.vv	v8, v12, v16
+# CHECK-NEXT:  1      12    8.00                         12    AscalonXGFP,AscalonXGFP64V[16],AscalonXGV[4] VFMACC_VV                vfmacc.vv	v8, v12, v16
+# CHECK-NEXT:  1      12    8.00                         12    AscalonXGFP,AscalonXGFP64V[16],AscalonXGV[4] VFCVT_F_X_V              vfcvt.f.x.v	v8, v12
+# CHECK-NEXT:  1      12    8.00                         12    AscalonXGFP,AscalonXGFP64V[16],AscalonXGV[4] VFMIN_VV                 vfmin.vv	v8, v12, v16
+# CHECK-NEXT:  1      12    8.00                         12    AscalonXGFP,AscalonXGFP64V[16],AscalonXGV[4] VFMIN_VF                 vfmin.vf	v8, v12, fa0
+# CHECK-NEXT:  1      12    8.00                         12    AscalonXGFP,AscalonXGFP64V[16],AscalonXGV[4] VFSGNJ_VV                vfsgnj.vv	v8, v12, v16
+# CHECK-NEXT:  1      12    8.00                         12    AscalonXGFP,AscalonXGFP64V[16],AscalonXGV[4] VFSGNJ_VF                vfsgnj.vf	v8, v12, fa0
 
 # CHECK:      Resources:
 # CHECK-NEXT: [0.0] - AscalonXGFP64V
@@ -88,29 +130,46 @@ vfmacc.vv v8, v12, v16
 
 # CHECK:      Resource pressure per iteration:
 # CHECK-NEXT: [0.0]  [0.1]  [1]    [2]    [3]    [4]    [5.0]  [5.1]  [6.0]  [6.1]  [7.0]  [7.1]  [7.2]  [8]    [9]
-# CHECK-NEXT: 32.00  48.00  8.00   9.00    -     1.00    -      -      -     1.00    -      -      -     22.00  20.00
+# CHECK-NEXT: 94.00  94.00  17.00  17.00  0.17   1.17   0.17   0.17   0.17   0.17    -      -      -     37.00  37.00
 
 # CHECK:      Resource pressure by instruction:
 # CHECK-NEXT: [0.0]  [0.1]  [1]    [2]    [3]    [4]    [5.0]  [5.1]  [6.0]  [6.1]  [7.0]  [7.1]  [7.2]  [8]    [9]    Instructions:
-# CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -      -      -      -      -     1.00   vsetvli	zero, zero, e32, m1, ta, ma
-# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -      -      -      -     1.00    -     vfadd.vv	v8, v9, v10
-# CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -      -      -      -      -     1.00   vfmul.vv	v8, v9, v10
-# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -      -      -      -      -     1.00   vfmacc.vv	v8, v9, v10
-# CHECK-NEXT:  -     4.00   1.00    -      -      -      -      -      -      -      -      -      -     1.00    -     vfwadd.vv	v8, v10, v11
-# CHECK-NEXT: 4.00    -      -     1.00    -      -      -      -      -      -      -      -      -      -     1.00   vfwmul.vv	v8, v10, v11
-# CHECK-NEXT:  -     4.00    -     1.00    -      -      -      -      -      -      -      -      -     1.00    -     vfwmacc.vv	v8, v10, v11
-# CHECK-NEXT:  -     4.00    -     1.00    -      -      -      -      -      -      -      -      -     1.00    -     vfwcvt.f.f.v	v8, v10
-# CHECK-NEXT: 4.00    -      -      -      -     1.00    -      -      -      -      -      -      -     1.00    -     vfwcvt.f.x.v	v8, v10
-# CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -      -      -      -     5.00    -     vfsqrt.v	v8, v9
-# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -      -      -      -      -     1.00   vfmin.vv	v8, v9, v10
-# CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -      -      -      -     1.00    -     vsetvli	zero, zero, e64, m1, ta, ma
-# CHECK-NEXT: 4.00    -     1.00    -      -      -      -      -      -      -      -      -      -      -     1.00   vfadd.vv	v8, v9, v10
-# CHECK-NEXT:  -     4.00    -     1.00    -      -      -      -      -      -      -      -      -     1.00    -     vfmul.vv	v8, v9, v10
-# CHECK-NEXT: 4.00    -     1.00    -      -      -      -      -      -      -      -      -      -      -     1.00   vfmacc.vv	v8, v9, v10
-# CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -      -      -      -      -     8.00   vfsqrt.v	v8, v9
-# CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -      -      -      -     1.00    -     vfmin.vv	v8, v9, v10
-# CHECK-NEXT:  -      -      -      -      -      -      -      -      -     1.00    -      -      -     1.00    -     vfredusum.vs	v8, v9, v10
-# CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -      -      -      -      -     1.00   vsetvli	zero, zero, e64, m4, ta, ma
-# CHECK-NEXT: 16.00   -     1.00    -      -      -      -      -      -      -      -      -      -      -     4.00   vfadd.vv	v8, v12, v16
-# CHECK-NEXT:  -     16.00   -     1.00    -      -      -      -      -      -      -      -      -     4.00    -     vfmul.vv	v8, v12, v16
-# CHECK-NEXT:  -     16.00   -     1.00    -      -      -      -      -      -      -      -      -     4.00    -     vfmacc.vv	v8, v12, v16
+# CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -      -      -      -     0.50   0.50   vsetvli	zero, zero, e32, m1, ta, ma
+# CHECK-NEXT:  -      -     0.50   0.50    -      -      -      -      -      -      -      -      -     0.50   0.50   vfadd.vv	v8, v9, v10
+# CHECK-NEXT:  -      -     0.50   0.50    -      -      -      -      -      -      -      -      -     0.50   0.50   vfmul.vv	v8, v9, v10
+# CHECK-NEXT:  -      -     0.50   0.50    -      -      -      -      -      -      -      -      -     0.50   0.50   vfmacc.vv	v8, v9, v10
+# CHECK-NEXT: 2.00   2.00   0.50   0.50    -      -      -      -      -      -      -      -      -     0.50   0.50   vfwadd.vv	v8, v10, v11
+# CHECK-NEXT: 2.00   2.00   0.50   0.50    -      -      -      -      -      -      -      -      -     0.50   0.50   vfwmul.vv	v8, v10, v11
+# CHECK-NEXT: 2.00   2.00   0.50   0.50    -      -      -      -      -      -      -      -      -     0.50   0.50   vfwmacc.vv	v8, v10, v11
+# CHECK-NEXT: 2.00   2.00   0.50   0.50    -      -      -      -      -      -      -      -      -     0.50   0.50   vfwcvt.f.f.v	v8, v10
+# CHECK-NEXT: 2.00   2.00    -      -      -     1.00    -      -      -      -      -      -      -     0.50   0.50   vfwcvt.f.x.v	v8, v10
+# CHECK-NEXT:  -      -     0.50   0.50    -      -      -      -      -      -      -      -      -     2.50   2.50   vfsqrt.v	v8, v9
+# CHECK-NEXT:  -      -     0.50   0.50    -      -      -      -      -      -      -      -      -     0.50   0.50   vfmin.vv	v8, v9, v10
+# CHECK-NEXT:  -      -     0.50   0.50    -      -      -      -      -      -      -      -      -     0.50   0.50   vfcvt.f.x.v	v8, v9
+# CHECK-NEXT:  -      -     0.50   0.50    -      -      -      -      -      -      -      -      -     0.50   0.50   vfcvt.f.xu.v	v8, v9
+# CHECK-NEXT:  -      -     0.50   0.50    -      -      -      -      -      -      -      -      -     0.50   0.50   vfmin.vf	v8, v9, fa0
+# CHECK-NEXT:  -      -     0.50   0.50    -      -      -      -      -      -      -      -      -     0.50   0.50   vfmax.vf	v8, v9, fa0
+# CHECK-NEXT:  -      -     0.50   0.50    -      -      -      -      -      -      -      -      -     0.50   0.50   vfsgnj.vv	v8, v9, v10
+# CHECK-NEXT:  -      -     0.50   0.50    -      -      -      -      -      -      -      -      -     0.50   0.50   vfsgnj.vf	v8, v9, fa0
+# CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -      -      -      -     0.50   0.50   vsetvli	zero, zero, e64, m1, ta, ma
+# CHECK-NEXT: 2.00   2.00   0.50   0.50    -      -      -      -      -      -      -      -      -     0.50   0.50   vfadd.vv	v8, v9, v10
+# CHECK-NEXT: 2.00   2.00   0.50   0.50    -      -      -      -      -      -      -      -      -     0.50   0.50   vfmul.vv	v8, v9, v10
+# CHECK-NEXT: 2.00   2.00   0.50   0.50    -      -      -      -      -      -      -      -      -     0.50   0.50   vfmacc.vv	v8, v9, v10
+# CHECK-NEXT:  -      -     0.50   0.50    -      -      -      -      -      -      -      -      -     4.00   4.00   vfsqrt.v	v8, v9
+# CHECK-NEXT: 2.00   2.00   0.50   0.50    -      -      -      -      -      -      -      -      -     0.50   0.50   vfmin.vv	v8, v9, v10
+# CHECK-NEXT: 2.00   2.00   0.50   0.50    -      -      -      -      -      -      -      -      -     0.50   0.50   vfcvt.f.x.v	v8, v9
+# CHECK-NEXT: 2.00   2.00   0.50   0.50    -      -      -      -      -      -      -      -      -     0.50   0.50   vfcvt.f.xu.v	v8, v9
+# CHECK-NEXT: 2.00   2.00   0.50   0.50    -      -      -      -      -      -      -      -      -     0.50   0.50   vfmin.vf	v8, v9, fa0
+# CHECK-NEXT: 2.00   2.00   0.50   0.50    -      -      -      -      -      -      -      -      -     0.50   0.50   vfmax.vf	v8, v9, fa0
+# CHECK-NEXT: 2.00   2.00   0.50   0.50    -      -      -      -      -      -      -      -      -     0.50   0.50   vfsgnj.vv	v8, v9, v10
+# CHECK-NEXT: 2.00   2.00   0.50   0.50    -      -      -      -      -      -      -      -      -     0.50   0.50   vfsgnj.vf	v8, v9, fa0
+# CHECK-NEXT:  -      -      -      -     0.17   0.17   0.17   0.17   0.17   0.17    -      -      -     0.50   0.50   vfredusum.vs	v8, v9, v10
+# CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -      -      -      -     0.50   0.50   vsetvli	zero, zero, e64, m4, ta, ma
+# CHECK-NEXT: 8.00   8.00   0.50   0.50    -      -      -      -      -      -      -      -      -     2.00   2.00   vfadd.vv	v8, v12, v16
+# CHECK-NEXT: 8.00   8.00   0.50   0.50    -      -      -      -      -      -      -      -      -     2.00   2.00   vfmul.vv	v8, v12, v16
+# CHECK-NEXT: 8.00   8.00   0.50   0.50    -      -      -      -      -      -      -      -      -     2.00   2.00   vfmacc.vv	v8, v12, v16
+# CHECK-NEXT: 8.00   8.00   0.50   0.50    -      -      -      -      -      -      -      -      -     2.00   2.00   vfcvt.f.x.v	v8, v12
+# CHECK-NEXT: 8.00   8.00   0.50   0.50    -      -      -      -      -      -      -      -      -     2.00   2.00   vfmin.vv	v8, v12, v16
+# CHECK-NEXT: 8.00   8.00   0.50   0.50    -      -      -      -      -      -      -      -      -     2.00   2.00   vfmin.vf	v8, v12, fa0
+# CHECK-NEXT: 8.00   8.00   0.50   0.50    -      -      -      -      -      -      -      -      -     2.00   2.00   vfsgnj.vv	v8, v12, v16
+# CHECK-NEXT: 8.00   8.00   0.50   0.50    -      -      -      -      -      -      -      -      -     2.00   2.00   vfsgnj.vf	v8, v12, fa0

>From a2d78ab4ef42e170f9d0f2ecfed3cd750f4bca9e Mon Sep 17 00:00:00 2001
From: Ramkumar Ramachandra <artagnon at tenstorrent.com>
Date: Tue, 6 Oct 2026 19:43:12 +0100
Subject: [PATCH 3/3] [RISCV] Add print-enabled-extensions test

---
 .../riscv-tt-ascalon-xg.c                     | 99 +++++++++++++++++++
 clang/test/Driver/riscv-cpus.c                | 66 -------------
 2 files changed, 99 insertions(+), 66 deletions(-)
 create mode 100644 clang/test/Driver/print-enabled-extensions/riscv-tt-ascalon-xg.c

diff --git a/clang/test/Driver/print-enabled-extensions/riscv-tt-ascalon-xg.c b/clang/test/Driver/print-enabled-extensions/riscv-tt-ascalon-xg.c
new file mode 100644
index 000000000000000..b046d71faabc4d4
--- /dev/null
+++ b/clang/test/Driver/print-enabled-extensions/riscv-tt-ascalon-xg.c
@@ -0,0 +1,99 @@
+// REQUIRES: riscv-registered-target
+// RUN: %clang --target=riscv64 -mcpu=tt-ascalon-xg --print-enabled-extensions | FileCheck %s
+
+// CHECK: Extensions enabled for the given RISC-V target
+// CHECK-EMPTY:
+// CHECK-NEXT:     Name                 Version   Description
+// CHECK-NEXT:     i                    2.1       'I' (Base Integer Instruction Set)
+// CHECK-NEXT:     m                    2.0       'M' (Integer Multiplication and Division)
+// CHECK-NEXT:     a                    2.1       'A' (Atomic Instructions)
+// CHECK-NEXT:     f                    2.2       'F' (Single-Precision Floating-Point)
+// CHECK-NEXT:     d                    2.2       'D' (Double-Precision Floating-Point)
+// CHECK-NEXT:     c                    2.0       'C' (Compressed Instructions)
+// CHECK-NEXT:     b                    1.0       'B' (the collection of the Zba, Zbb, Zbs extensions)
+// CHECK-NEXT:     v                    1.0       'V' (Vector Extension for Application Processors)
+// CHECK-NEXT:     h                    1.0       'H' (Hypervisor)
+// CHECK-NEXT:     zic64b               1.0       'Zic64b' (Cache Block Size Is 64 Bytes)
+// CHECK-NEXT:     zicbom               1.0       'Zicbom' (Cache-Block Management Instructions)
+// CHECK-NEXT:     zicbop               1.0       'Zicbop' (Cache-Block Prefetch Instructions)
+// CHECK-NEXT:     zicboz               1.0       'Zicboz' (Cache-Block Zero Instructions)
+// CHECK-NEXT:     ziccamoa             1.0       'Ziccamoa' (Main Memory Supports All Atomics in A)
+// CHECK-NEXT:     ziccif               1.0       'Ziccif' (Main Memory Supports Instruction Fetch with Atomicity Requirement)
+// CHECK-NEXT:     zicclsm              1.0       'Zicclsm' (Main Memory Supports Misaligned Loads/Stores)
+// CHECK-NEXT:     ziccrse              1.0       'Ziccrse' (Main Memory Supports Forward Progress on LR/SC Sequences)
+// CHECK-NEXT:     zicntr               2.0       'Zicntr' (Base Counters and Timers)
+// CHECK-NEXT:     zicond               1.0       'Zicond' (Integer Conditional Operations)
+// CHECK-NEXT:     zicsr                2.0       'Zicsr' (CSRs)
+// CHECK-NEXT:     zifencei             2.0       'Zifencei' (fence.i)
+// CHECK-NEXT:     zihintntl            1.0       'Zihintntl' (Non-Temporal Locality Hints)
+// CHECK-NEXT:     zihintpause          2.0       'Zihintpause' (Pause Hint)
+// CHECK-NEXT:     zihpm                2.0       'Zihpm' (Hardware Performance Counters)
+// CHECK-NEXT:     zimop                1.0       'Zimop' (May-Be-Operations)
+// CHECK-NEXT:     zmmul                1.0       'Zmmul' (Integer Multiplication)
+// CHECK-NEXT:     za64rs               1.0       'Za64rs' (Reservation Set Size of at Most 64 Bytes)
+// CHECK-NEXT:     zaamo                1.0       'Zaamo' (Atomic Memory Operations)
+// CHECK-NEXT:     zalrsc               1.0       'Zalrsc' (Load-Reserved/Store-Conditional)
+// CHECK-NEXT:     zawrs                1.0       'Zawrs' (Wait on Reservation Set)
+// CHECK-NEXT:     zfa                  1.0       'Zfa' (Additional Floating-Point)
+// CHECK-NEXT:     zfbfmin              1.0       'Zfbfmin' (Scalar BF16 Converts)
+// CHECK-NEXT:     zfh                  1.0       'Zfh' (Half-Precision Floating-Point)
+// CHECK-NEXT:     zfhmin               1.0       'Zfhmin' (Half-Precision Floating-Point Minimal)
+// CHECK-NEXT:     zca                  1.0       'Zca' (part of the C extension, excluding compressed floating point loads/stores)
+// CHECK-NEXT:     zcb                  1.0       'Zcb' (Compressed basic bit manipulation instructions)
+// CHECK-NEXT:     zcd                  1.0       'Zcd' (Compressed Double-Precision Floating-Point Instructions)
+// CHECK-NEXT:     zcmop                1.0       'Zcmop' (Compressed May-Be-Operations)
+// CHECK-NEXT:     zba                  1.0       'Zba' (Address Generation Instructions)
+// CHECK-NEXT:     zbb                  1.0       'Zbb' (Basic Bit-Manipulation)
+// CHECK-NEXT:     zbs                  1.0       'Zbs' (Single-Bit Instructions)
+// CHECK-NEXT:     zkr                  1.0       'Zkr' (Entropy Source Extension)
+// CHECK-NEXT:     zkt                  1.0       'Zkt' (Data Independent Execution Latency)
+// CHECK-NEXT:     zvbb                 1.0       'Zvbb' (Vector basic bit-manipulation instructions)
+// CHECK-NEXT:     zvbc                 1.0       'Zvbc' (Vector Carryless Multiplication)
+// CHECK-NEXT:     zve32f               1.0       'Zve32f' (Vector Extensions for Embedded Processors with maximal 32 EEW and F extension)
+// CHECK-NEXT:     zve32x               1.0       'Zve32x' (Vector Extensions for Embedded Processors with maximal 32 EEW)
+// CHECK-NEXT:     zve64d               1.0       'Zve64d' (Vector Extensions for Embedded Processors with maximal 64 EEW, F and D extension)
+// CHECK-NEXT:     zve64f               1.0       'Zve64f' (Vector Extensions for Embedded Processors with maximal 64 EEW and F extension)
+// CHECK-NEXT:     zve64x               1.0       'Zve64x' (Vector Extensions for Embedded Processors with maximal 64 EEW)
+// CHECK-NEXT:     zvfbfmin             1.0       'Zvfbfmin' (Vector BF16 Converts)
+// CHECK-NEXT:     zvfbfwma             1.0       'Zvfbfwma' (Vector BF16 widening mul-add)
+// CHECK-NEXT:     zvfh                 1.0       'Zvfh' (Vector Half-Precision Floating-Point)
+// CHECK-NEXT:     zvfhmin              1.0       'Zvfhmin' (Vector Half-Precision Floating-Point Minimal)
+// CHECK-NEXT:     zvkb                 1.0       'Zvkb' (Vector Bit-manipulation used in Cryptography)
+// CHECK-NEXT:     zvkt                 1.0       'Zvkt' (Vector Data-Independent Execution Latency)
+// CHECK-NEXT:     zvl128b              1.0       'Zvl128b' (Minimum Vector Length 128)
+// CHECK-NEXT:     zvl256b              1.0       'Zvl256b' (Minimum Vector Length 256)
+// CHECK-NEXT:     zvl32b               1.0       'Zvl32b' (Minimum Vector Length 32)
+// CHECK-NEXT:     zvl64b               1.0       'Zvl64b' (Minimum Vector Length 64)
+// CHECK-NEXT:     sha                  1.0       'Sha' (Augmented Hypervisor)
+// CHECK-NEXT:     shcounterenw         1.0       'Shcounterenw' (Support writeable hcounteren enable bit for any hpmcounter that is not read-only zero)
+// CHECK-NEXT:     shgatpa              1.0       'Shgatpa' (SvNNx4 mode supported for all modes supported by satp, as well as Bare)
+// CHECK-NEXT:     shtvala              1.0       'Shtvala' (htval provides all needed values)
+// CHECK-NEXT:     shvsatpa             1.0       'Shvsatpa' (vsatp supports all modes supported by satp)
+// CHECK-NEXT:     shvstvala            1.0       'Shvstvala' (vstval provides all needed values)
+// CHECK-NEXT:     shvstvecd            1.0       'Shvstvecd' (vstvec supports Direct mode)
+// CHECK-NEXT:     smaia                1.0       'Smaia' (Advanced Interrupt Architecture Machine Level)
+// CHECK-NEXT:     smmpm                1.0       'Smmpm' (Machine-level Pointer Masking for M-mode)
+// CHECK-NEXT:     smnpm                1.0       'Smnpm' (Machine-level Pointer Masking for next lower privilege mode)
+// CHECK-NEXT:     smrnmi               1.0       'Smrnmi' (Resumable Non-Maskable Interrupts)
+// CHECK-NEXT:     smstateen            1.0       'Smstateen' (Machine-mode view of the state-enable extension)
+// CHECK-NEXT:     ssaia                1.0       'Ssaia' (Advanced Interrupt Architecture Supervisor Level)
+// CHECK-NEXT:     ssccptr              1.0       'Ssccptr' (Main memory supports page table reads)
+// CHECK-NEXT:     sscofpmf             1.0       'Sscofpmf' (Count Overflow and Mode-Based Filtering)
+// CHECK-NEXT:     sscounterenw         1.0       'Sscounterenw' (Support writeable scounteren enable bit for any hpmcounter that is not read-only zero)
+// CHECK-NEXT:     ssnpm                1.0       'Ssnpm' (Supervisor-level Pointer Masking for next lower privilege mode)
+// CHECK-NEXT:     ssstateen            1.0       'Ssstateen' (Supervisor-mode view of the state-enable extension)
+// CHECK-NEXT:     ssstrict             1.0       'Ssstrict' (No non-conforming extensions are present)
+// CHECK-NEXT:     sstc                 1.0       'Sstc' (Supervisor-mode timer interrupts)
+// CHECK-NEXT:     sstvala              1.0       'Sstvala' (stval provides all needed values)
+// CHECK-NEXT:     sstvecd              1.0       'Sstvecd' (stvec supports Direct mode)
+// CHECK-NEXT:     ssu64xl              1.0       'Ssu64xl' (UXLEN=64 supported)
+// CHECK-NEXT:     supm                 1.0       'Supm' (Indicates User-mode Pointer Masking)
+// CHECK-NEXT:     svade                1.0       'Svade' (Raise exceptions on improper A/D bits)
+// CHECK-NEXT:     svbare               1.0       'Svbare' (satp mode Bare supported)
+// CHECK-NEXT:     svinval              1.0       'Svinval' (Fine-Grained Address-Translation Cache Invalidation)
+// CHECK-NEXT:     svnapot              1.0       'Svnapot' (NAPOT Translation Contiguity)
+// CHECK-NEXT:     svpbmt               1.0       'Svpbmt' (Page-Based Memory Types)
+// CHECK-EMPTY:
+// CHECK-NEXT: Experimental extensions
+// CHECK-EMPTY:
+// CHECK-NEXT: ISA String: rv64i2p1_m2p0_a2p1_f2p2_d2p2_c2p0_b1p0_v1p0_h1p0_zic64b1p0_zicbom1p0_zicbop1p0_zicboz1p0_ziccamoa1p0_ziccif1p0_zicclsm1p0_ziccrse1p0_zicntr2p0_zicond1p0_zicsr2p0_zifencei2p0_zihintntl1p0_zihintpause2p0_zihpm2p0_zimop1p0_zmmul1p0_za64rs1p0_zaamo1p0_zalrsc1p0_zawrs1p0_zfa1p0_zfbfmin1p0_zfh1p0_zfhmin1p0_zca1p0_zcb1p0_zcd1p0_zcmop1p0_zba1p0_zbb1p0_zbs1p0_zkr1p0_zkt1p0_zvbb1p0_zvbc1p0_zve32f1p0_zve32x1p0_zve64d1p0_zve64f1p0_zve64x1p0_zvfbfmin1p0_zvfbfwma1p0_zvfh1p0_zvfhmin1p0_zvkb1p0_zvkt1p0_zvl128b1p0_zvl256b1p0_zvl32b1p0_zvl64b1p0_sha1p0_shcounterenw1p0_shgatpa1p0_shtvala1p0_shvsatpa1p0_shvstvala1p0_shvstvecd1p0_smaia1p0_smmpm1p0_smnpm1p0_smrnmi1p0_smstateen1p0_ssaia1p0_ssccptr1p0_sscofpmf1p0_sscounterenw1p0_ssnpm1p0_ssstateen1p0_ssstrict1p0_sstc1p0_sstvala1p0_sstvecd1p0_ssu64xl1p0_supm1p0_svade1p0_svbare1p0_svinval1p0_svnapot1p0_svpbmt1p0
diff --git a/clang/test/Driver/riscv-cpus.c b/clang/test/Driver/riscv-cpus.c
index ea7966089b2d752..9cfe399ca71a7a0 100644
--- a/clang/test/Driver/riscv-cpus.c
+++ b/clang/test/Driver/riscv-cpus.c
@@ -250,72 +250,6 @@
 // MCPU-TT-ASCALON-X-SAME: "-target-feature" "+svpbmt"
 // MCPU-TT-ASCALON-X-SAME: "-target-abi" "lp64d"
 
-// RUN: %clang --target=riscv64 -mcpu=tt-ascalon-xg --print-enabled-extensions | FileCheck -check-prefix=MCPU-TT-ASCALON-XG %s
-// MCPU-TT-ASCALON-XG: i
-// MCPU-TT-ASCALON-XG: m
-// MCPU-TT-ASCALON-XG: a
-// MCPU-TT-ASCALON-XG: f
-// MCPU-TT-ASCALON-XG: d
-// MCPU-TT-ASCALON-XG: c
-// MCPU-TT-ASCALON-XG: v
-// MCPU-TT-ASCALON-XG: h
-// MCPU-TT-ASCALON-XG: zicbom
-// MCPU-TT-ASCALON-XG: zicbop
-// MCPU-TT-ASCALON-XG: zicboz
-// MCPU-TT-ASCALON-XG: zicntr
-// MCPU-TT-ASCALON-XG: zicond
-// MCPU-TT-ASCALON-XG: zicsr
-// MCPU-TT-ASCALON-XG: zifencei
-// MCPU-TT-ASCALON-XG: zihintntl
-// MCPU-TT-ASCALON-XG: zihintpause
-// MCPU-TT-ASCALON-XG: zihpm
-// MCPU-TT-ASCALON-XG: zimop
-// MCPU-TT-ASCALON-XG: zmmul
-// MCPU-TT-ASCALON-XG: zawrs
-// MCPU-TT-ASCALON-XG: zfa
-// MCPU-TT-ASCALON-XG: zfbfmin
-// MCPU-TT-ASCALON-XG: zfh
-// MCPU-TT-ASCALON-XG: zfhmin
-// MCPU-TT-ASCALON-XG: zca
-// MCPU-TT-ASCALON-XG: zcb
-// MCPU-TT-ASCALON-XG: zba
-// MCPU-TT-ASCALON-XG: zbb
-// MCPU-TT-ASCALON-XG: zbs
-// MCPU-TT-ASCALON-XG: zkr
-// MCPU-TT-ASCALON-XG: zkt
-// MCPU-TT-ASCALON-XG: zvbb
-// MCPU-TT-ASCALON-XG: zvbc
-// MCPU-TT-ASCALON-XG: zve32f
-// MCPU-TT-ASCALON-XG: zve32x
-// MCPU-TT-ASCALON-XG: zve64d
-// MCPU-TT-ASCALON-XG: zve64f
-// MCPU-TT-ASCALON-XG: zve64x
-// MCPU-TT-ASCALON-XG: zvfbfmin
-// MCPU-TT-ASCALON-XG: zvfbfwma
-// MCPU-TT-ASCALON-XG: zvfh
-// MCPU-TT-ASCALON-XG: zvfhmin
-// MCPU-TT-ASCALON-XG: zvkb
-// MCPU-TT-ASCALON-XG-NOT: zvkg
-// MCPU-TT-ASCALON-XG-NOT: zvkn
-// MCPU-TT-ASCALON-XG-NOT: zvknc
-// MCPU-TT-ASCALON-XG-NOT: zvkned
-// MCPU-TT-ASCALON-XG-NOT: zvknha
-// MCPU-TT-ASCALON-XG-NOT: zvknhb
-// MCPU-TT-ASCALON-XG: zvkt
-// MCPU-TT-ASCALON-XG: zvl128b
-// MCPU-TT-ASCALON-XG: zvl256b
-// MCPU-TT-ASCALON-XG: zvl32b
-// MCPU-TT-ASCALON-XG: zvl64b
-// MCPU-TT-ASCALON-XG: smaia
-// MCPU-TT-ASCALON-XG: smmpm
-// MCPU-TT-ASCALON-XG: smnpm
-// MCPU-TT-ASCALON-XG: smrnmi
-// MCPU-TT-ASCALON-XG: smstateen
-// MCPU-TT-ASCALON-XG: sscofpmf
-// MCPU-TT-ASCALON-XG: svinval
-// MCPU-TT-ASCALON-XG: svnapot
-// MCPU-TT-ASCALON-XG: svpbmt
-
 // RUN: %clang --target=riscv64 -### -c %s 2>&1 -mtune=xiangshan-nanhu | FileCheck -check-prefix=MTUNE-XIANGSHAN-NANHU %s
 // MTUNE-XIANGSHAN-NANHU: "-tune-cpu" "xiangshan-nanhu"
 



More information about the llvm-commits mailing list