[RISCV] Remove lmuls argument in Sched class

[• pcwang-thead]

Summary

The original intention is adding a list of SchedWrites (which is a
default argument of ReadAdvance) to LMULReadAdvance, but it may not
be practical that there are two default arguments in one class. So
we add variants that are intended for widening and narrowing
instructions with postfix "W" and remove lmuls argument.

[michaelmaitland]

LGTM.

[michaelmaitland]

There may be some more changes (of the same kind) required depending when this lands because of the following patches:

https://reviews.llvm.org/D137342 (already landed)
https://reviews.llvm.org/D137426

[• pcwang-thead]

Rebase

[• pcwang-thead]

In D138640#3958805, @michaelmaitland wrote:

There may be some more changes (of the same kind) required depending when this lands because of the following patches:

https://reviews.llvm.org/D137342 (already landed)
https://reviews.llvm.org/D137426

I will land this first and we can make some changes in D137426 before it is accepted.

llvm/lib/Target/RISCV/RISCVScheduleV.td

 //===-- RISCVScheduleV.td - RISCV Scheduling Definitions V -*- tablegen -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 //===----------------------------------------------------------------------===//
 /// Define scheduler resources associated with def operands.
 
 defvar SchedMxList = ["UpperBound", "M1", "M2", "M4", "M8", "MF2", "MF4", "MF8"];
 // Used for widening and narrowing instructions as it doesn't contain M8.
 defvar SchedMxListW = ["UpperBound", "MF8", "MF4", "MF2", "M1", "M2", "M4"];
 
-// Creates SchedWrite for each (name, LMUL) pair for LMUL in lmuls argument
-multiclass LMULSchedWrites<string name, list<string> lmuls = SchedMxList> {
-  foreach mx = lmuls in {
+// Creates SchedWrite for each (name, LMUL) pair for LMUL in SchedMxList
+multiclass LMULSchedWrites<string name> {
+  foreach mx = SchedMxList in {
     def name # "_" # mx : SchedWrite;
   }
 }
 
-// Creates SchedRead for each (name, LMUL) pair for LMUL in lmuls argument
-multiclass LMULSchedReads<string name, list<string> lmuls = SchedMxList> {
-  foreach mx = lmuls in {
+// Creates SchedWrite for each (name, LMUL) pair for LMUL in SchedMxListW
+multiclass LMULSchedWritesW<string name> {
+  foreach mx = SchedMxListW in {
+    def name # "_" # mx : SchedWrite;
+  }
+}
+
+// Creates SchedRead for each (name, LMUL) pair for LMUL in SchedMxList
+multiclass LMULSchedReads<string name> {
+  foreach mx = SchedMxList in {
+    def name # "_" # mx : SchedRead;
+  }
+}
+
+// Creates SchedRead for each (name, LMUL) pair for LMUL in SchedMxListW
+multiclass LMULSchedReadsW<string name> {
+  foreach mx = SchedMxListW in {
     def name # "_" # mx : SchedRead;
   }
 }
 
 // Creates WriteRes for each (name, LMUL, resources) tuple for LMUL
-// in lmuls argument
-multiclass LMULWriteRes<string name, list<ProcResourceKind> resources,
-                        list<string> lmuls = SchedMxList> {
-  foreach mx = lmuls in {
+// in SchedMxList
+multiclass LMULWriteRes<string name, list<ProcResourceKind> resources> {
+  foreach mx = SchedMxList in {
     def : WriteRes<!cast<SchedWrite>(name # "_" # mx), resources>;
   }
 }
 
+// Creates WriteRes for each (name, LMUL, resources) tuple for LMUL
+// in SchedMxListW
+multiclass LMULWriteResW<string name, list<ProcResourceKind> resources> {
+  foreach mx = SchedMxListW in {
+    def : WriteRes<!cast<SchedWrite>(name # "_" # mx), resources>;
+  }
+}
+
+// Creates ReadAdvance for each (name, LMUL, val) tuple for LMUL
+// in SchedMxList
+multiclass LMULReadAdvance<string name, int val, list<SchedWrite> writes = []> {
+  foreach mx = SchedMxList in {
+    def : ReadAdvance<!cast<SchedRead>(name # "_" # mx), val, writes>;
+  }
+}
+
 // Creates ReadAdvance for each (name, LMUL, val) tuple for LMUL
-// in lmuls argument
-multiclass LMULReadAdvance<string name, int val, list<string> lmuls = SchedMxList> {
-  foreach mx = lmuls in {
-    def : ReadAdvance<!cast<SchedRead>(name # "_" # mx), val>;
+// in SchedMxListW
+multiclass LMULReadAdvanceW<string name, int val, list<SchedWrite> writes = []> {
+  foreach mx = SchedMxListW in {
+    def : ReadAdvance<!cast<SchedRead>(name # "_" # mx), val, writes>;
   }
 }
 
 // 3.6 Vector Byte Length vlenb
 def WriteRdVLENB      : SchedWrite;
 
 // 6. Configuration-Setting Instructions
 def WriteVSETVLI      : SchedWrite;

 
 // 11. Vector Integer Arithmetic Instructions
 // 11.1. Vector Single-Width Integer Add and Subtract
 // 11.5. Vector Bitwise Logical Instructions
 defm "" : LMULSchedWrites<"WriteVIALUV">;
 defm "" : LMULSchedWrites<"WriteVIALUX">;
 defm "" : LMULSchedWrites<"WriteVIALUI">;
 // 11.2. Vector Widening Integer Add/Subtract
-defm "" : LMULSchedWrites<"WriteVIWALUV", SchedMxListW>;
-defm "" : LMULSchedWrites<"WriteVIWALUX", SchedMxListW>;
-defm "" : LMULSchedWrites<"WriteVIWALUI", SchedMxListW>;
+defm "" : LMULSchedWritesW<"WriteVIWALUV">;
+defm "" : LMULSchedWritesW<"WriteVIWALUX">;
+defm "" : LMULSchedWritesW<"WriteVIWALUI">;
 // 11.3. Vector Integer Extension
 defm "" : LMULSchedWrites<"WriteVExtV">;
 // 11.4. Vector Integer Arithmetic with Carry or Borrow Instructions
 defm "" : LMULSchedWrites<"WriteVICALUV">;
 defm "" : LMULSchedWrites<"WriteVICALUX">;
 defm "" : LMULSchedWrites<"WriteVICALUI">;
 // 11.6. Vector Single-Width Bit Shift Instructions
 defm "" : LMULSchedWrites<"WriteVShiftV">;
 defm "" : LMULSchedWrites<"WriteVShiftX">;
 defm "" : LMULSchedWrites<"WriteVShiftI">;
 // 11.7. Vector Narrowing Integer Right Shift Instructions
-defm "" : LMULSchedWrites<"WriteVNShiftV", SchedMxListW>;
-defm "" : LMULSchedWrites<"WriteVNShiftX", SchedMxListW>;
-defm "" : LMULSchedWrites<"WriteVNShiftI", SchedMxListW>;
+defm "" : LMULSchedWritesW<"WriteVNShiftV">;
+defm "" : LMULSchedWritesW<"WriteVNShiftX">;
+defm "" : LMULSchedWritesW<"WriteVNShiftI">;
 // 11.8. Vector Integer Comparison Instructions
 // 11.9. Vector Integer Min/Max Instructions
 defm "" : LMULSchedWrites<"WriteVICmpV">;
 defm "" : LMULSchedWrites<"WriteVICmpX">;
 defm "" : LMULSchedWrites<"WriteVICmpI">;
 // 11.10. Vector Single-Width Integer Multiply Instructions
 defm "" : LMULSchedWrites<"WriteVIMulV">;
 defm "" : LMULSchedWrites<"WriteVIMulX">;
 // 11.11. Vector Integer Divide Instructions
 defm "" : LMULSchedWrites<"WriteVIDivV">;
 defm "" : LMULSchedWrites<"WriteVIDivX">;
 // 11.12. Vector Widening Integer Multiply Instructions
-defm "" : LMULSchedWrites<"WriteVIWMulV", SchedMxListW>;
-defm "" : LMULSchedWrites<"WriteVIWMulX", SchedMxListW>;
+defm "" : LMULSchedWritesW<"WriteVIWMulV">;
+defm "" : LMULSchedWritesW<"WriteVIWMulX">;
 // 11.13. Vector Single-Width Integer Multiply-Add Instructions
 defm "" : LMULSchedWrites<"WriteVIMulAddV">;
 defm "" : LMULSchedWrites<"WriteVIMulAddX">;
 // 11.14. Vector Widening Integer Multiply-Add Instructions
-defm "" : LMULSchedWrites<"WriteVIWMulAddV", SchedMxListW>;
-defm "" : LMULSchedWrites<"WriteVIWMulAddX", SchedMxListW>;
+defm "" : LMULSchedWritesW<"WriteVIWMulAddV">;
+defm "" : LMULSchedWritesW<"WriteVIWMulAddX">;
 // 11.15. Vector Integer Merge Instructions
 defm "" : LMULSchedWrites<"WriteVIMergeV">;
 defm "" : LMULSchedWrites<"WriteVIMergeX">;
 defm "" : LMULSchedWrites<"WriteVIMergeI">;
 // 11.16. Vector Integer Move Instructions
 defm "" : LMULSchedWrites<"WriteVIMovV">;
 defm "" : LMULSchedWrites<"WriteVIMovX">;
 defm "" : LMULSchedWrites<"WriteVIMovI">;

 // 12.3. Vector Single-Width Fractional Multiply with Rounding and Saturation
 defm "" : LMULSchedWrites<"WriteVSMulV">;
 defm "" : LMULSchedWrites<"WriteVSMulX">;
 // 12.4. Vector Single-Width Scaling Shift Instructions
 defm "" : LMULSchedWrites<"WriteVSShiftV">;
 defm "" : LMULSchedWrites<"WriteVSShiftX">;
 defm "" : LMULSchedWrites<"WriteVSShiftI">;
 // 12.5. Vector Narrowing Fixed-Point Clip Instructions
-defm "" : LMULSchedWrites<"WriteVNClipV", SchedMxListW>;
-defm "" : LMULSchedWrites<"WriteVNClipX", SchedMxListW>;
-defm "" : LMULSchedWrites<"WriteVNClipI", SchedMxListW>;
+defm "" : LMULSchedWritesW<"WriteVNClipV">;
+defm "" : LMULSchedWritesW<"WriteVNClipX">;
+defm "" : LMULSchedWritesW<"WriteVNClipI">;
 
 // 13. Vector Floating-Point Instructions
 // 13.2. Vector Single-Width Floating-Point Add/Subtract Instructions
 def WriteVFALUV       : SchedWrite;
 def WriteVFALUF       : SchedWrite;
 // 13.3. Vector Widening Floating-Point Add/Subtract Instructions
 def WriteVFWALUV      : SchedWrite;
 def WriteVFWALUF      : SchedWrite;

 def ReadVST8R         : SchedRead;
 
 // 11. Vector Integer Arithmetic Instructions
 // 11.1. Vector Single-Width Integer Add and Subtract
 // 11.5. Vector Bitwise Logical Instructions
 defm "" : LMULSchedReads<"ReadVIALUV">;
 defm "" : LMULSchedReads<"ReadVIALUX">;
 // 11.2. Vector Widening Integer Add/Subtract
-defm "" : LMULSchedReads<"ReadVIWALUV", SchedMxListW>;
-defm "" : LMULSchedReads<"ReadVIWALUX", SchedMxListW>;
+defm "" : LMULSchedReadsW<"ReadVIWALUV">;
+defm "" : LMULSchedReadsW<"ReadVIWALUX">;
 // 11.3. Vector Integer Extension
 defm "" : LMULSchedReads<"ReadVExtV">;
 // 11.4. Vector Integer Arithmetic with Carry or Borrow Instructions
 defm "" : LMULSchedReads<"ReadVICALUV">;
 defm "" : LMULSchedReads<"ReadVICALUX">;
 // 11.6. Vector Single-Width Bit Shift Instructions
 defm "" : LMULSchedReads<"ReadVShiftV">;
 defm "" : LMULSchedReads<"ReadVShiftX">;
 // 11.7. Vector Narrowing Integer Right Shift Instructions
-defm "" : LMULSchedReads<"ReadVNShiftV", SchedMxListW>;
-defm "" : LMULSchedReads<"ReadVNShiftX", SchedMxListW>;
+defm "" : LMULSchedReadsW<"ReadVNShiftV">;
+defm "" : LMULSchedReadsW<"ReadVNShiftX">;
 // 11.8. Vector Integer Comparison Instructions
 // 11.9. Vector Integer Min/Max Instructions
 defm "" : LMULSchedReads<"ReadVICmpV">;
 defm "" : LMULSchedReads<"ReadVICmpX">;
 // 11.10. Vector Single-Width Integer Multiply Instructions
 defm "" : LMULSchedReads<"ReadVIMulV">;
 defm "" : LMULSchedReads<"ReadVIMulX">;
 // 11.11. Vector Integer Divide Instructions
 defm "" : LMULSchedReads<"ReadVIDivV">;
 defm "" : LMULSchedReads<"ReadVIDivX">;
 // 11.12. Vector Widening Integer Multiply Instructions
-defm "" : LMULSchedReads<"ReadVIWMulV", SchedMxListW>;
-defm "" : LMULSchedReads<"ReadVIWMulX", SchedMxListW>;
+defm "" : LMULSchedReadsW<"ReadVIWMulV">;
+defm "" : LMULSchedReadsW<"ReadVIWMulX">;
 // 11.13. Vector Single-Width Integer Multiply-Add Instructions
 defm "" : LMULSchedReads<"ReadVIMulAddV">;
 defm "" : LMULSchedReads<"ReadVIMulAddX">;
 // 11.14. Vector Widening Integer Multiply-Add Instructions
-defm "" : LMULSchedReads<"ReadVIWMulAddV", SchedMxListW>;
-defm "" : LMULSchedReads<"ReadVIWMulAddX", SchedMxListW>;
+defm "" : LMULSchedReadsW<"ReadVIWMulAddV">;
+defm "" : LMULSchedReadsW<"ReadVIWMulAddX">;
 // 11.15. Vector Integer Merge Instructions
 defm "" : LMULSchedReads<"ReadVIMergeV">;
 defm "" : LMULSchedReads<"ReadVIMergeX">;
 // 11.16. Vector Integer Move Instructions
 defm "" : LMULSchedReads<"ReadVIMovV">;
 defm "" : LMULSchedReads<"ReadVIMovX">;
 
 // 12. Vector Fixed-Point Arithmetic Instructions
 // 12.1. Vector Single-Width Saturating Add and Subtract
 defm "" : LMULSchedReads<"ReadVSALUV">;
 defm "" : LMULSchedReads<"ReadVSALUX">;
 // 12.2. Vector Single-Width Averaging Add and Subtract
 defm "" : LMULSchedReads<"ReadVAALUV">;
 defm "" : LMULSchedReads<"ReadVAALUX">;
 // 12.3. Vector Single-Width Fractional Multiply with Rounding and Saturation
 defm "" : LMULSchedReads<"ReadVSMulV">;
 defm "" : LMULSchedReads<"ReadVSMulX">;
 // 12.4. Vector Single-Width Scaling Shift Instructions
 defm "" : LMULSchedReads<"ReadVSShiftV">;
 defm "" : LMULSchedReads<"ReadVSShiftX">;
 // 12.5. Vector Narrowing Fixed-Point Clip Instructions
-defm "" : LMULSchedReads<"ReadVNClipV", SchedMxListW>;
-defm "" : LMULSchedReads<"ReadVNClipX", SchedMxListW>;
+defm "" : LMULSchedReadsW<"ReadVNClipV">;
+defm "" : LMULSchedReadsW<"ReadVNClipX">;
 
 // 13. Vector Floating-Point Instructions
 // 13.2. Vector Single-Width Floating-Point Add/Subtract Instructions
 def ReadVFALUV        : SchedRead;
 def ReadVFALUF        : SchedRead;
 // 13.3. Vector Widening Floating-Point Add/Subtract Instructions
 def ReadVFWALUV       : SchedRead;
 def ReadVFWALUF       : SchedRead;
foreach eew = [8, 16, 32, 64] in {
     def : WriteRes <!cast<SchedWrite>("WriteVSOXSEG" # nf # "e" # eew), []>;
   }
 }
 
 // 11. Vector Integer Arithmetic Instructions
 defm "" : LMULWriteRes<"WriteVIALUV", []>;
 defm "" : LMULWriteRes<"WriteVIALUX", []>;
 defm "" : LMULWriteRes<"WriteVIALUI", []>;
-defm "" : LMULWriteRes<"WriteVIWALUV", [], SchedMxListW>;
-defm "" : LMULWriteRes<"WriteVIWALUX", [], SchedMxListW>;
-defm "" : LMULWriteRes<"WriteVIWALUI", [], SchedMxListW>;
+defm "" : LMULWriteResW<"WriteVIWALUV", []>;
+defm "" : LMULWriteResW<"WriteVIWALUX", []>;
+defm "" : LMULWriteResW<"WriteVIWALUI", []>;
 defm "" : LMULWriteRes<"WriteVExtV", []>;
 defm "" : LMULWriteRes<"WriteVICALUV", []>;
 defm "" : LMULWriteRes<"WriteVICALUX", []>;
 defm "" : LMULWriteRes<"WriteVICALUI", []>;
 defm "" : LMULWriteRes<"WriteVShiftV", []>;
 defm "" : LMULWriteRes<"WriteVShiftX", []>;
 defm "" : LMULWriteRes<"WriteVShiftI", []>;
-defm "" : LMULWriteRes<"WriteVNShiftV", [], SchedMxListW>;
-defm "" : LMULWriteRes<"WriteVNShiftX", [], SchedMxListW>;
-defm "" : LMULWriteRes<"WriteVNShiftI", [], SchedMxListW>;
+defm "" : LMULWriteResW<"WriteVNShiftV", []>;
+defm "" : LMULWriteResW<"WriteVNShiftX", []>;
+defm "" : LMULWriteResW<"WriteVNShiftI", []>;
 defm "" : LMULWriteRes<"WriteVICmpV", []>;
 defm "" : LMULWriteRes<"WriteVICmpX", []>;
 defm "" : LMULWriteRes<"WriteVICmpI", []>;
 defm "" : LMULWriteRes<"WriteVIMulV", []>;
 defm "" : LMULWriteRes<"WriteVIMulX", []>;
 defm "" : LMULWriteRes<"WriteVIDivV", []>;
 defm "" : LMULWriteRes<"WriteVIDivX", []>;
-defm "" : LMULWriteRes<"WriteVIWMulV", [], SchedMxListW>;
-defm "" : LMULWriteRes<"WriteVIWMulX", [], SchedMxListW>;
+defm "" : LMULWriteResW<"WriteVIWMulV", []>;
+defm "" : LMULWriteResW<"WriteVIWMulX", []>;
 defm "" : LMULWriteRes<"WriteVIMulAddV", []>;
 defm "" : LMULWriteRes<"WriteVIMulAddX", []>;
-defm "" : LMULWriteRes<"WriteVIWMulAddV", [], SchedMxListW>;
-defm "" : LMULWriteRes<"WriteVIWMulAddX", [], SchedMxListW>;
+defm "" : LMULWriteResW<"WriteVIWMulAddV", []>;
+defm "" : LMULWriteResW<"WriteVIWMulAddX", []>;
 defm "" : LMULWriteRes<"WriteVIMergeV", []>;
 defm "" : LMULWriteRes<"WriteVIMergeX", []>;
 defm "" : LMULWriteRes<"WriteVIMergeI", []>;
 defm "" : LMULWriteRes<"WriteVIMovV", []>;
 defm "" : LMULWriteRes<"WriteVIMovX", []>;
 defm "" : LMULWriteRes<"WriteVIMovI", []>;
 
 // 12. Vector Fixed-Point Arithmetic Instructions
 defm "" : LMULWriteRes<"WriteVSALUV", []>;
 defm "" : LMULWriteRes<"WriteVSALUX", []>;
 defm "" : LMULWriteRes<"WriteVSALUI", []>;
 defm "" : LMULWriteRes<"WriteVAALUV", []>;
 defm "" : LMULWriteRes<"WriteVAALUX", []>;
 defm "" : LMULWriteRes<"WriteVSMulV", []>;
 defm "" : LMULWriteRes<"WriteVSMulX", []>;
 defm "" : LMULWriteRes<"WriteVSShiftV", []>;
 defm "" : LMULWriteRes<"WriteVSShiftX", []>;
 defm "" : LMULWriteRes<"WriteVSShiftI", []>;
-defm "" : LMULWriteRes<"WriteVNClipV", [], SchedMxListW>;
-defm "" : LMULWriteRes<"WriteVNClipX", [], SchedMxListW>;
-defm "" : LMULWriteRes<"WriteVNClipI", [], SchedMxListW>;
+defm "" : LMULWriteResW<"WriteVNClipV", []>;
+defm "" : LMULWriteResW<"WriteVNClipX", []>;
+defm "" : LMULWriteResW<"WriteVNClipI", []>;
 
 // 13. Vector Floating-Point Instructions
 def : WriteRes<WriteVFALUV, []>;
 def : WriteRes<WriteVFALUF, []>;
 def : WriteRes<WriteVFWALUV, []>;
 def : WriteRes<WriteVFWALUF, []>;
 def : WriteRes<WriteVFMulV, []>;
 def : WriteRes<WriteVFMulF, []>;

 def : ReadAdvance<ReadVST1R, 0>;
 def : ReadAdvance<ReadVST2R, 0>;
 def : ReadAdvance<ReadVST4R, 0>;
 def : ReadAdvance<ReadVST8R, 0>;
 
 // 11. Vector Integer Arithmetic Instructions
 defm "" : LMULReadAdvance<"ReadVIALUV", 0>;
 defm "" : LMULReadAdvance<"ReadVIALUX", 0>;
-defm "" : LMULReadAdvance<"ReadVIWALUV", 0, SchedMxListW>;
-defm "" : LMULReadAdvance<"ReadVIWALUX", 0, SchedMxListW>;
+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 "" : LMULReadAdvance<"ReadVNShiftV", 0, SchedMxListW>;
-defm "" : LMULReadAdvance<"ReadVNShiftX", 0, SchedMxListW>;
+defm "" : LMULReadAdvanceW<"ReadVNShiftV", 0>;
+defm "" : LMULReadAdvanceW<"ReadVNShiftX", 0>;
 defm "" : LMULReadAdvance<"ReadVICmpV", 0>;
 defm "" : LMULReadAdvance<"ReadVICmpX", 0>;
 defm "" : LMULReadAdvance<"ReadVIMulV", 0>;
 defm "" : LMULReadAdvance<"ReadVIMulX", 0>;
 defm "" : LMULReadAdvance<"ReadVIDivV", 0>;
 defm "" : LMULReadAdvance<"ReadVIDivX", 0>;
-defm "" : LMULReadAdvance<"ReadVIWMulV", 0, SchedMxListW>;
-defm "" : LMULReadAdvance<"ReadVIWMulX", 0, SchedMxListW>;
+defm "" : LMULReadAdvanceW<"ReadVIWMulV", 0>;
+defm "" : LMULReadAdvanceW<"ReadVIWMulX", 0>;
 defm "" : LMULReadAdvance<"ReadVIMulAddV", 0>;
 defm "" : LMULReadAdvance<"ReadVIMulAddX", 0>;
-defm "" : LMULReadAdvance<"ReadVIWMulAddV", 0, SchedMxListW>;
-defm "" : LMULReadAdvance<"ReadVIWMulAddX", 0, SchedMxListW>;
+defm "" : LMULReadAdvanceW<"ReadVIWMulAddV", 0>;
+defm "" : LMULReadAdvanceW<"ReadVIWMulAddX", 0>;
 defm "" : LMULReadAdvance<"ReadVIMergeV", 0>;
 defm "" : LMULReadAdvance<"ReadVIMergeX", 0>;
 defm "" : LMULReadAdvance<"ReadVIMovV", 0>;
 defm "" : LMULReadAdvance<"ReadVIMovX", 0>;
 
 // 12. 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 "" : LMULReadAdvance<"ReadVNClipV", 0, SchedMxListW>;
-defm "" : LMULReadAdvance<"ReadVNClipX", 0, SchedMxListW>;
+defm "" : LMULReadAdvanceW<"ReadVNClipV", 0>;
+defm "" : LMULReadAdvanceW<"ReadVNClipX", 0>;
 
 // 13. Vector Floating-Point Instructions
 def : ReadAdvance<ReadVFALUV, 0>;
 def : ReadAdvance<ReadVFALUF, 0>;
 def : ReadAdvance<ReadVFWALUV, 0>;
 def : ReadAdvance<ReadVFWALUF, 0>;
 def : ReadAdvance<ReadVFMulV, 0>;
 def : ReadAdvance<ReadVFMulF, 0>;