[clang] 1ebfb7a - [RISCV] Add Tenstorrent Ascalon XG (#229030)
via cfe-commits
cfe-commits at lists.llvm.org
Wed Oct 7 03:12:09 PDT 2026
Author: Ramkumar Ramachandra
Date: 2026-10-07T10:11:57Z
New Revision: 1ebfb7a71d0f11cbe3c240d875ef2c1690be3491
URL: https://github.com/llvm/llvm-project/commit/1ebfb7a71d0f11cbe3c240d875ef2c1690be3491
DIFF: https://github.com/llvm/llvm-project/commit/1ebfb7a71d0f11cbe3c240d875ef2c1690be3491.diff
LOG: [RISCV] Add Tenstorrent Ascalon XG (#229030)
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
Added:
clang/test/Driver/print-enabled-extensions/riscv-tt-ascalon-xg.c
llvm/test/tools/llvm-mca/RISCV/tt-ascalon-x/vfp64.s
Modified:
clang/test/Misc/target-invalid-cpu-note/riscv.c
llvm/docs/ReleaseNotes.md
llvm/lib/Target/RISCV/RISCVProcessors.td
llvm/lib/Target/RISCV/RISCVSchedTTAscalonX.td
Removed:
################################################################################
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 00000000000000..b046d71faabc4d
--- /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/Misc/target-invalid-cpu-note/riscv.c b/clang/test/Misc/target-invalid-cpu-note/riscv.c
index 86fdf400ac4611..df13001fedf0da 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 4e2882de82a02c..b369e95263debc 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 eb4e2214dc3894..04a2fabc2c4fe7 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 d6a1f341e3e336..6a1c5aceae75f7 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,1004 @@ 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>;
+ 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>;
+ }
+ }
}
-}
-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 00000000000000..218a55ccdcbd6c
--- /dev/null
+++ b/llvm/test/tools/llvm-mca/RISCV/tt-ascalon-x/vfp64.s
@@ -0,0 +1,175 @@
+# NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py
+# 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.
+
+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
+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: 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
+# CHECK-NEXT: [2]: Latency
+# CHECK-NEXT: [3]: RThroughput
+# 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] [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
+# 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: 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: - - - - - - - - - - - - - 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
More information about the cfe-commits
mailing list