1//===- RISCVScheduleV.td - RISC-V Scheduling Definitions V -*- tablegen -*-===// 2// 3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4// See https://llvm.org/LICENSE.txt for license information. 5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6// 7//===----------------------------------------------------------------------===// 8 9//===----------------------------------------------------------------------===// 10/// Define scheduler resources associated with def operands. 11 12defvar SchedMxList = ["MF8", "MF4", "MF2", "M1", "M2", "M4", "M8"]; 13// Used for widening and narrowing instructions as it doesn't contain M8. 14defvar SchedMxListW = !listremove(SchedMxList, ["M8"]); 15// Used for widening reductions, which does contain M8. 16defvar SchedMxListWRed = SchedMxList; 17defvar SchedMxListFW = !listremove(SchedMxList, ["M8", "MF8"]); 18// Used for floating-point as it doesn't contain MF8. 19defvar SchedMxListF = !listremove(SchedMxList, ["MF8"]); 20// Used for widening floating-point Reduction as it doesn't contain MF8. 21defvar SchedMxListFWRed = SchedMxListF; 22 23class SchedSEWSet<string mx, bit isF = 0, bit isWidening = 0> { 24 assert !or(!not(isF), !ne(mx, "MF8")), "LMUL shouldn't be MF8 for floating-point"; 25 defvar t = !cond(!eq(mx, "M1"): [8, 16, 32, 64], 26 !eq(mx, "M2"): [8, 16, 32, 64], 27 !eq(mx, "M4"): [8, 16, 32, 64], 28 !eq(mx, "M8"): [8, 16, 32, 64], 29 !eq(mx, "MF2"): [8, 16, 32], 30 !eq(mx, "MF4"): [8, 16], 31 !eq(mx, "MF8"): [8]); 32 // For floating-point instructions, SEW won't be 8. 33 defvar remove8 = !if(isF, !listremove(t, [8]), t); 34 // For widening instructions, SEW will not be 64. 35 defvar remove64 = !if(isWidening, !listremove(remove8, [64]), remove8); 36 list<int> val = remove64; 37} 38 39// Helper function to get the largest LMUL from MxList 40// Precondition: MxList is sorted in ascending LMUL order. 41class LargestLMUL<list<string> MxList> { 42 // MX list is sorted from smallest to largest 43 string r = !foldl(!head(MxList), MxList, last, curr, curr); 44} 45// Helper function to get the smallest SEW that can be used with LMUL mx 46// Precondition: MxList is sorted in ascending LMUL order and SchedSEWSet<mx> 47class SmallestSEW<string mx, bit isF = 0> { 48 int r = !head(SchedSEWSet<mx, isF>.val); 49} 50 51// Creates WriteRes for (name, mx, resources) tuple 52multiclass LMULWriteResMX<string name, list<ProcResourceKind> resources, 53 string mx, bit IsWorstCase> { 54 def : WriteRes<!cast<SchedWrite>(name # "_" # mx), resources>; 55 if IsWorstCase then 56 def : WriteRes<!cast<SchedWrite>(name # "_WorstCase"), resources>; 57} 58multiclass LMULSEWWriteResMXSEW<string name, list<ProcResourceKind> resources, 59 string mx, int sew, bit IsWorstCase> { 60 def : WriteRes<!cast<SchedWrite>(name # "_" # mx # "_E" # sew), resources>; 61 if IsWorstCase then 62 def : WriteRes<!cast<SchedWrite>(name # "_WorstCase"), resources>; 63} 64 65// Define a SchedAlias for the SchedWrite associated with (name, mx) whose 66// behavior is aliased to a Variant. The Variant has Latency predLad and 67// ReleaseAtCycles predCycles if the SchedPredicate Pred is true, otherwise has 68// Latency noPredLat and ReleaseAtCycles noPredCycles. The WorstCase SchedWrite 69// is created similarly if IsWorstCase is true. 70multiclass LMULWriteResMXVariant<string name, SchedPredicateBase Pred, 71 list<ProcResourceKind> resources, 72 int predLat, list<int> predAcquireCycles, 73 list<int> predReleaseCycles, int noPredLat, 74 list<int> noPredAcquireCycles, 75 list<int> noPredReleaseCycles, 76 string mx, bit IsWorstCase> { 77 defvar nameMX = name # "_" # mx; 78 79 // Define the different behaviors 80 def nameMX # "_Pred" : SchedWriteRes<resources>{ 81 let Latency = predLat; 82 let AcquireAtCycles = predAcquireCycles; 83 let ReleaseAtCycles = predReleaseCycles; 84 } 85 def nameMX # "_NoPred" : SchedWriteRes<resources> { 86 let Latency = noPredLat; 87 let AcquireAtCycles = noPredAcquireCycles; 88 let ReleaseAtCycles = noPredReleaseCycles; 89 } 90 91 // Define SchedVars 92 def nameMX # PredSchedVar 93 : SchedVar<Pred, [!cast<SchedWriteRes>(NAME # nameMX # "_Pred")]>; 94 def nameMX # NoPredSchedVar 95 : SchedVar<NoSchedPred, [!cast<SchedWriteRes>(NAME # nameMX #"_NoPred")]>; 96 // Allow multiclass to refer to SchedVars -- need to have NAME prefix. 97 defvar PredSchedVar = !cast<SchedVar>(NAME # nameMX # PredSchedVar); 98 defvar NoPredSchedVar = !cast<SchedVar>(NAME # nameMX # NoPredSchedVar); 99 100 // Tie behavior to predicate 101 def NAME # nameMX # "_Variant" 102 : SchedWriteVariant<[PredSchedVar, NoPredSchedVar]>; 103 def : SchedAlias< 104 !cast<SchedReadWrite>(nameMX), 105 !cast<SchedReadWrite>(NAME # nameMX # "_Variant")>; 106 107 if IsWorstCase then { 108 def NAME # name # "_WorstCase_Variant" 109 : SchedWriteVariant<[PredSchedVar, NoPredSchedVar]>; 110 def : SchedAlias< 111 !cast<SchedReadWrite>(name # "_WorstCase"), 112 !cast<SchedReadWrite>(NAME # name # "_WorstCase_Variant")>; 113 } 114} 115 116// Define multiclasses to define SchedWrite, SchedRead, WriteRes, and 117// ReadAdvance for each (name, LMUL) pair and for each LMUL in each of the 118// SchedMxList variants above. Each multiclass is responsible for defining 119// a record that represents the WorseCase behavior for name. 120multiclass LMULSchedWritesImpl<string name, list<string> MxList> { 121 def name # "_WorstCase" : SchedWrite; 122 foreach mx = MxList in { 123 def name # "_" # mx : SchedWrite; 124 } 125} 126multiclass LMULSchedReadsImpl<string name, list<string> MxList> { 127 def name # "_WorstCase" : SchedRead; 128 foreach mx = MxList in { 129 def name # "_" # mx : SchedRead; 130 } 131} 132multiclass LMULWriteResImpl<string name, list<ProcResourceKind> resources> { 133 if !exists<SchedWrite>(name # "_WorstCase") then 134 def : WriteRes<!cast<SchedWrite>(name # "_WorstCase"), resources>; 135 foreach mx = SchedMxList in { 136 if !exists<SchedWrite>(name # "_" # mx) then 137 def : WriteRes<!cast<SchedWrite>(name # "_" # mx), resources>; 138 } 139} 140multiclass LMULReadAdvanceImpl<string name, int val, 141 list<SchedWrite> writes = []> { 142 if !exists<SchedRead>(name # "_WorstCase") then 143 def : ReadAdvance<!cast<SchedRead>(name # "_WorstCase"), val, writes>; 144 foreach mx = SchedMxList in { 145 if !exists<SchedRead>(name # "_" # mx) then 146 def : ReadAdvance<!cast<SchedRead>(name # "_" # mx), val, writes>; 147 } 148} 149 150// Define multiclasses to define SchedWrite, SchedRead, WriteRes, and 151// ReadAdvance for each (name, LMUL, SEW) tuple for each LMUL in each of the 152// SchedMxList variants above. Each multiclass is responsible for defining 153// a record that represents the WorseCase behavior for name. 154multiclass LMULSEWSchedWritesImpl<string name, list<string> MxList, bit isF = 0, 155 bit isWidening = 0> { 156 def name # "_WorstCase" : SchedWrite; 157 foreach mx = MxList in { 158 foreach sew = SchedSEWSet<mx, isF, isWidening>.val in 159 def name # "_" # mx # "_E" # sew : SchedWrite; 160 } 161} 162multiclass LMULSEWSchedReadsImpl<string name, list<string> MxList, bit isF = 0, 163 bit isWidening = 0> { 164 def name # "_WorstCase" : SchedRead; 165 foreach mx = MxList in { 166 foreach sew = SchedSEWSet<mx, isF, isWidening>.val in 167 def name # "_" # mx # "_E" # sew : SchedRead; 168 } 169} 170multiclass LMULSEWWriteResImpl<string name, list<ProcResourceKind> resources, 171 list<string> MxList, bit isF = 0, 172 bit isWidening = 0> { 173 if !exists<SchedWrite>(name # "_WorstCase") then 174 def : WriteRes<!cast<SchedWrite>(name # "_WorstCase"), resources>; 175 foreach mx = MxList in { 176 foreach sew = SchedSEWSet<mx, isF, isWidening>.val in 177 if !exists<SchedWrite>(name # "_" # mx # "_E" # sew) then 178 def : WriteRes<!cast<SchedWrite>(name # "_" # mx # "_E" # sew), resources>; 179 } 180} 181multiclass LMULSEWReadAdvanceImpl<string name, int val, list<SchedWrite> writes = [], 182 list<string> MxList, bit isF = 0, 183 bit isWidening = 0> { 184 if !exists<SchedRead>(name # "_WorstCase") then 185 def : ReadAdvance<!cast<SchedRead>(name # "_WorstCase"), val, writes>; 186 foreach mx = MxList in { 187 foreach sew = SchedSEWSet<mx, isF, isWidening>.val in 188 if !exists<SchedRead>(name # "_" # mx # "_E" # sew) then 189 def : ReadAdvance<!cast<SchedRead>(name # "_" # mx # "_E" # sew), val, writes>; 190 } 191} 192// Define classes to define list containing all SchedWrites for each (name, LMUL) 193// pair for each LMUL in each of the SchedMxList variants above and name in 194// argument `names`. These classes can be used to construct a list of existing 195// definitions of writes corresponding to each (name, LMUL) pair, that are needed 196// by the ReadAdvance. For example: 197// ``` 198// defm "" : LMULReadAdvance<"ReadVIALUX", 1, 199// LMULSchedWriteList<["WriteVMovSX"]>.value>; 200// ``` 201class LMULSchedWriteListImpl<list<string> names, list<string> MxList> { 202 list<SchedWrite> value = !foldl([]<SchedWrite>, 203 !foreach(name, names, 204 !foreach(mx, MxList, !cast<SchedWrite>(name # "_" # mx))), 205 all, writes, !listconcat(all, writes)); 206} 207 208multiclass LMULSchedWrites<string name> : LMULSchedWritesImpl<name, SchedMxList>; 209multiclass LMULSchedReads<string name> : LMULSchedReadsImpl<name, SchedMxList>; 210multiclass LMULWriteRes<string name, list<ProcResourceKind> resources> 211 : LMULWriteResImpl<name, resources>; 212multiclass LMULReadAdvance<string name, int val, list<SchedWrite> writes = []> 213 : LMULReadAdvanceImpl<name, val, writes>; 214class LMULSchedWriteList<list<string> names> : LMULSchedWriteListImpl<names, SchedMxList>; 215 216multiclass LMULSEWSchedWrites<string name> : LMULSEWSchedWritesImpl<name, SchedMxList>; 217multiclass LMULSEWSchedReads<string name> : LMULSEWSchedReadsImpl<name, SchedMxList>; 218multiclass LMULSEWWriteRes<string name, list<ProcResourceKind> resources> 219 : LMULSEWWriteResImpl<name, resources, SchedMxList>; 220multiclass LMULSEWReadAdvance<string name, int val, list<SchedWrite> writes = []> 221 : LMULSEWReadAdvanceImpl<name, val, writes, SchedMxList>; 222 223multiclass LMULSEWSchedWritesWRed<string name> 224 : LMULSEWSchedWritesImpl<name, SchedMxListWRed, isWidening=1>; 225multiclass LMULSEWWriteResWRed<string name, list<ProcResourceKind> resources> 226 : LMULSEWWriteResImpl<name, resources, SchedMxListWRed, isWidening=1>; 227 228multiclass LMULSEWSchedWritesFWRed<string name> 229 : LMULSEWSchedWritesImpl<name, SchedMxListFWRed, isF=1, isWidening=1>; 230multiclass LMULSEWWriteResFWRed<string name, list<ProcResourceKind> resources> 231 : LMULSEWWriteResImpl<name, resources, SchedMxListFWRed, isF=1, isWidening=1>; 232 233multiclass LMULSEWSchedWritesF<string name> : LMULSEWSchedWritesImpl<name, SchedMxListF, isF=1>; 234multiclass LMULSEWSchedReadsF<string name> : LMULSEWSchedReadsImpl<name, SchedMxListF, isF=1>; 235multiclass LMULSEWWriteResF<string name, list<ProcResourceKind> resources> 236 : LMULSEWWriteResImpl<name, resources, SchedMxListF, isF=1>; 237multiclass LMULSEWReadAdvanceF<string name, int val, list<SchedWrite> writes = []> 238 : LMULSEWReadAdvanceImpl<name, val, writes, SchedMxListF, isF=1>; 239 240multiclass LMULSchedWritesW<string name> : LMULSchedWritesImpl<name, SchedMxListW>; 241multiclass LMULSchedReadsW<string name> : LMULSchedReadsImpl<name, SchedMxListW>; 242multiclass LMULWriteResW<string name, list<ProcResourceKind> resources> 243 : LMULWriteResImpl<name, resources>; 244multiclass LMULReadAdvanceW<string name, int val, list<SchedWrite> writes = []> 245 : LMULReadAdvanceImpl<name, val, writes>; 246class LMULSchedWriteListW<list<string> names> : LMULSchedWriteListImpl<names, SchedMxListW>; 247 248multiclass LMULSchedWritesFW<string name> : LMULSchedWritesImpl<name, SchedMxListFW>; 249multiclass LMULSchedReadsFW<string name> : LMULSchedReadsImpl<name, SchedMxListFW>; 250multiclass LMULWriteResFW<string name, list<ProcResourceKind> resources> 251 : LMULWriteResImpl<name, resources>; 252multiclass LMULReadAdvanceFW<string name, int val, list<SchedWrite> writes = []> 253 : LMULReadAdvanceImpl<name, val, writes>; 254class LMULSchedWriteListFW<list<string> names> : LMULSchedWriteListImpl<names, SchedMxListFW>; 255 256multiclass LMULSEWSchedWritesW<string name> 257 : LMULSEWSchedWritesImpl<name, SchedMxListW, isF = 0, isWidening = 1>; 258multiclass LMULSEWSchedReadsW<string name> 259 : LMULSEWSchedReadsImpl<name, SchedMxListW, isF = 0, isWidening = 1>; 260multiclass LMULSEWWriteResW<string name, list<ProcResourceKind> resources> 261 : LMULSEWWriteResImpl<name, resources, SchedMxListW, isF = 0, 262 isWidening = 1>; 263multiclass 264 LMULSEWReadAdvanceW<string name, int val, list<SchedWrite> writes = []> 265 : LMULSEWReadAdvanceImpl<name, val, writes, SchedMxListW, isF = 0, 266 isWidening = 1>; 267 268multiclass LMULSEWSchedWritesFW<string name> 269 : LMULSEWSchedWritesImpl<name, SchedMxListFW, isF = 1, isWidening = 1>; 270multiclass LMULSEWSchedReadsFW<string name> 271 : LMULSEWSchedReadsImpl<name, SchedMxListFW, isF = 1, isWidening = 1>; 272multiclass LMULSEWWriteResFW<string name, list<ProcResourceKind> resources> 273 : LMULSEWWriteResImpl<name, resources, SchedMxListFW, isF = 1, 274 isWidening = 1>; 275multiclass 276 LMULSEWReadAdvanceFW<string name, int val, list<SchedWrite> writes = []> 277 : LMULSEWReadAdvanceImpl<name, val, writes, SchedMxListFW, isF = 1, 278 isWidening = 1>; 279 280// 3.6 Vector Byte Length vlenb 281def WriteRdVLENB : SchedWrite; 282 283// 6. Configuration-Setting Instructions 284def WriteVSETVLI : SchedWrite; 285def WriteVSETIVLI : SchedWrite; 286def WriteVSETVL : SchedWrite; 287 288// 7. Vector Loads and Stores 289// 7.4. Vector Unit-Stride Instructions 290defm "" : LMULSchedWrites<"WriteVLDE">; 291defm "" : LMULSchedWrites<"WriteVSTE">; 292// 7.4.1. Vector Unit-Strided Mask 293defm "" : LMULSchedWrites<"WriteVLDM">; 294defm "" : LMULSchedWrites<"WriteVSTM">; 295// 7.5. Vector Strided Instructions 296defm "" : LMULSchedWrites<"WriteVLDS8">; 297defm "" : LMULSchedWrites<"WriteVLDS16">; 298defm "" : LMULSchedWrites<"WriteVLDS32">; 299defm "" : LMULSchedWrites<"WriteVLDS64">; 300defm "" : LMULSchedWrites<"WriteVSTS8">; 301defm "" : LMULSchedWrites<"WriteVSTS16">; 302defm "" : LMULSchedWrites<"WriteVSTS32">; 303defm "" : LMULSchedWrites<"WriteVSTS64">; 304// 7.6. Vector Indexed Instructions 305defm "" : LMULSchedWrites<"WriteVLDUX8">; 306defm "" : LMULSchedWrites<"WriteVLDUX16">; 307defm "" : LMULSchedWrites<"WriteVLDUX32">; 308defm "" : LMULSchedWrites<"WriteVLDUX64">; 309defm "" : LMULSchedWrites<"WriteVLDOX8">; 310defm "" : LMULSchedWrites<"WriteVLDOX16">; 311defm "" : LMULSchedWrites<"WriteVLDOX32">; 312defm "" : LMULSchedWrites<"WriteVLDOX64">; 313defm "" : LMULSchedWrites<"WriteVSTUX8">; 314defm "" : LMULSchedWrites<"WriteVSTUX16">; 315defm "" : LMULSchedWrites<"WriteVSTUX32">; 316defm "" : LMULSchedWrites<"WriteVSTUX64">; 317defm "" : LMULSchedWrites<"WriteVSTOX8">; 318defm "" : LMULSchedWrites<"WriteVSTOX16">; 319defm "" : LMULSchedWrites<"WriteVSTOX32">; 320defm "" : LMULSchedWrites<"WriteVSTOX64">; 321// 7.7. Vector Unit-stride Fault-Only-First Loads 322defm "" : LMULSchedWrites<"WriteVLDFF">; 323// 7.8. Vector Segment Instructions 324foreach nf=2-8 in { 325 foreach eew = [8, 16, 32, 64] in { 326 defm "" : LMULSchedWrites<"WriteVLSEG" # nf # e # eew>; 327 defm "" : LMULSchedWrites<"WriteVSSEG" # nf # e # eew>; 328 defm "" : LMULSchedWrites<"WriteVLSEGFF" # nf # e # eew>; 329 defm "" : LMULSchedWrites<"WriteVLSSEG" # nf # e # eew>; 330 defm "" : LMULSchedWrites<"WriteVSSSEG" # nf # e # eew>; 331 defm "" : LMULSchedWrites<"WriteVLUXSEG" # nf # e # eew>; 332 defm "" : LMULSchedWrites<"WriteVLOXSEG" # nf # e # eew>; 333 defm "" : LMULSchedWrites<"WriteVSUXSEG" # nf # e # eew>; 334 defm "" : LMULSchedWrites<"WriteVSOXSEG" # nf # e # eew>; 335 } 336} 337// 7.9. Vector Whole Register Instructions 338def WriteVLD1R : SchedWrite; 339def WriteVLD2R : SchedWrite; 340def WriteVLD4R : SchedWrite; 341def WriteVLD8R : SchedWrite; 342def WriteVST1R : SchedWrite; 343def WriteVST2R : SchedWrite; 344def WriteVST4R : SchedWrite; 345def WriteVST8R : SchedWrite; 346 347// 11. Vector Integer Arithmetic Instructions 348// 11.1. Vector Single-Width Integer Add and Subtract 349// 11.5. Vector Bitwise Logical Instructions 350defm "" : LMULSchedWrites<"WriteVIALUV">; 351defm "" : LMULSchedWrites<"WriteVIALUX">; 352defm "" : LMULSchedWrites<"WriteVIALUI">; 353// 11.2. Vector Widening Integer Add/Subtract 354defm "" : LMULSchedWritesW<"WriteVIWALUV">; 355defm "" : LMULSchedWritesW<"WriteVIWALUX">; 356defm "" : LMULSchedWritesW<"WriteVIWALUI">; 357// 11.3. Vector Integer Extension 358defm "" : LMULSchedWrites<"WriteVExtV">; 359// 11.4. Vector Integer Arithmetic with Carry or Borrow Instructions 360defm "" : LMULSchedWrites<"WriteVICALUV">; 361defm "" : LMULSchedWrites<"WriteVICALUX">; 362defm "" : LMULSchedWrites<"WriteVICALUI">; 363defm "" : LMULSchedWrites<"WriteVICALUMV">; 364defm "" : LMULSchedWrites<"WriteVICALUMX">; 365defm "" : LMULSchedWrites<"WriteVICALUMI">; 366// 11.6. Vector Single-Width Bit Shift Instructions 367defm "" : LMULSchedWrites<"WriteVShiftV">; 368defm "" : LMULSchedWrites<"WriteVShiftX">; 369defm "" : LMULSchedWrites<"WriteVShiftI">; 370// 11.7. Vector Narrowing Integer Right Shift Instructions 371defm "" : LMULSchedWritesW<"WriteVNShiftV">; 372defm "" : LMULSchedWritesW<"WriteVNShiftX">; 373defm "" : LMULSchedWritesW<"WriteVNShiftI">; 374// 11.8. Vector Integer Comparison Instructions 375defm "" : LMULSchedWrites<"WriteVICmpV">; 376defm "" : LMULSchedWrites<"WriteVICmpX">; 377defm "" : LMULSchedWrites<"WriteVICmpI">; 378// 11.9. Vector Integer Min/Max Instructions 379defm "" : LMULSchedWrites<"WriteVIMinMaxV">; 380defm "" : LMULSchedWrites<"WriteVIMinMaxX">; 381// 11.10. Vector Single-Width Integer Multiply Instructions 382defm "" : LMULSchedWrites<"WriteVIMulV">; 383defm "" : LMULSchedWrites<"WriteVIMulX">; 384// 11.11. Vector Integer Divide Instructions 385defm "" : LMULSEWSchedWrites<"WriteVIDivV">; 386defm "" : LMULSEWSchedWrites<"WriteVIDivX">; 387// 11.12. Vector Widening Integer Multiply Instructions 388defm "" : LMULSchedWritesW<"WriteVIWMulV">; 389defm "" : LMULSchedWritesW<"WriteVIWMulX">; 390// 11.13. Vector Single-Width Integer Multiply-Add Instructions 391defm "" : LMULSchedWrites<"WriteVIMulAddV">; 392defm "" : LMULSchedWrites<"WriteVIMulAddX">; 393// 11.14. Vector Widening Integer Multiply-Add Instructions 394defm "" : LMULSchedWritesW<"WriteVIWMulAddV">; 395defm "" : LMULSchedWritesW<"WriteVIWMulAddX">; 396// 11.15. Vector Integer Merge Instructions 397defm "" : LMULSchedWrites<"WriteVIMergeV">; 398defm "" : LMULSchedWrites<"WriteVIMergeX">; 399defm "" : LMULSchedWrites<"WriteVIMergeI">; 400// 11.16. Vector Integer Move Instructions 401defm "" : LMULSchedWrites<"WriteVIMovV">; 402defm "" : LMULSchedWrites<"WriteVIMovX">; 403defm "" : LMULSchedWrites<"WriteVIMovI">; 404 405// 12. Vector Fixed-Point Arithmetic Instructions 406// 12.1. Vector Single-Width Saturating Add and Subtract 407defm "" : LMULSchedWrites<"WriteVSALUV">; 408defm "" : LMULSchedWrites<"WriteVSALUX">; 409defm "" : LMULSchedWrites<"WriteVSALUI">; 410// 12.2. Vector Single-Width Averaging Add and Subtract 411defm "" : LMULSchedWrites<"WriteVAALUV">; 412defm "" : LMULSchedWrites<"WriteVAALUX">; 413// 12.3. Vector Single-Width Fractional Multiply with Rounding and Saturation 414defm "" : LMULSchedWrites<"WriteVSMulV">; 415defm "" : LMULSchedWrites<"WriteVSMulX">; 416// 12.4. Vector Single-Width Scaling Shift Instructions 417defm "" : LMULSchedWrites<"WriteVSShiftV">; 418defm "" : LMULSchedWrites<"WriteVSShiftX">; 419defm "" : LMULSchedWrites<"WriteVSShiftI">; 420// 12.5. Vector Narrowing Fixed-Point Clip Instructions 421defm "" : LMULSchedWritesW<"WriteVNClipV">; 422defm "" : LMULSchedWritesW<"WriteVNClipX">; 423defm "" : LMULSchedWritesW<"WriteVNClipI">; 424 425// 13. Vector Floating-Point Instructions 426// 13.2. Vector Single-Width Floating-Point Add/Subtract Instructions 427defm "" : LMULSEWSchedWritesF<"WriteVFALUV">; 428defm "" : LMULSEWSchedWritesF<"WriteVFALUF">; 429// 13.3. Vector Widening Floating-Point Add/Subtract Instructions 430defm "" : LMULSEWSchedWritesFW<"WriteVFWALUV">; 431defm "" : LMULSEWSchedWritesFW<"WriteVFWALUF">; 432// 13.4. Vector Single-Width Floating-Point Multiply/Divide Instructions 433defm "" : LMULSEWSchedWritesF<"WriteVFMulV">; 434defm "" : LMULSEWSchedWritesF<"WriteVFMulF">; 435defm "" : LMULSEWSchedWritesF<"WriteVFDivV">; 436defm "" : LMULSEWSchedWritesF<"WriteVFDivF">; 437// 13.5. Vector Widening Floating-Point Multiply 438defm "" : LMULSEWSchedWritesFW<"WriteVFWMulV">; 439defm "" : LMULSEWSchedWritesFW<"WriteVFWMulF">; 440// 13.6. Vector Single-Width Floating-Point Fused Multiply-Add Instructions 441defm "" : LMULSEWSchedWritesF<"WriteVFMulAddV">; 442defm "" : LMULSEWSchedWritesF<"WriteVFMulAddF">; 443// 13.7. Vector Widening Floating-Point Fused Multiply-Add Instructions 444defm "" : LMULSEWSchedWritesFW<"WriteVFWMulAddV">; 445defm "" : LMULSEWSchedWritesFW<"WriteVFWMulAddF">; 446// 13.8. Vector Floating-Point Square-Root Instruction 447defm "" : LMULSEWSchedWritesF<"WriteVFSqrtV">; 448// 13.9. Vector Floating-Point Reciprocal Square-Root Estimate Instruction 449// 13.10. Vector Floating-Point Reciprocal Estimate Instruction 450defm "" : LMULSEWSchedWritesF<"WriteVFRecpV">; 451// 13.11. Vector Floating-Point MIN/MAX Instructions 452defm "" : LMULSEWSchedWritesF<"WriteVFMinMaxV">; 453defm "" : LMULSEWSchedWritesF<"WriteVFMinMaxF">; 454// 13.12. Vector Floating-Point Sign-Injection Instructions 455defm "" : LMULSEWSchedWritesF<"WriteVFSgnjV">; 456defm "" : LMULSEWSchedWritesF<"WriteVFSgnjF">; 457// 13.13. Vector Floating-Point Compare Instructions 458defm "" : LMULSchedWrites<"WriteVFCmpV">; 459defm "" : LMULSchedWrites<"WriteVFCmpF">; 460// 13.14. Vector Floating-Point Classify Instruction 461defm "" : LMULSchedWrites<"WriteVFClassV">; 462// 13.15. Vector Floating-Point Merge Instruction 463defm "" : LMULSchedWrites<"WriteVFMergeV">; 464// 13.16. Vector Floating-Point Move Instruction 465defm "" : LMULSchedWrites<"WriteVFMovV">; 466// 13.17. Single-Width Floating-Point/Integer Type-Convert Instructions 467defm "" : LMULSEWSchedWritesF<"WriteVFCvtIToFV">; 468defm "" : LMULSchedWrites<"WriteVFCvtFToIV">; 469// 13.18. Widening Floating-Point/Integer Type-Convert Instructions 470defm "" : LMULSEWSchedWritesW<"WriteVFWCvtIToFV">; 471defm "" : LMULSchedWritesFW<"WriteVFWCvtFToIV">; 472defm "" : LMULSEWSchedWritesFW<"WriteVFWCvtFToFV">; 473// 13.19. Narrowing Floating-Point/Integer Type-Convert Instructions 474defm "" : LMULSEWSchedWritesFW<"WriteVFNCvtIToFV">; 475defm "" : LMULSchedWritesW<"WriteVFNCvtFToIV">; 476defm "" : LMULSEWSchedWritesFW<"WriteVFNCvtFToFV">; 477 478// 14. Vector Reduction Operations 479// The latency of reduction is determined by the size of the read resource. 480// The LMUL range of read resource(VS2) for reduction operantion is between 481// MF8 and M8. Use the _From suffix to indicate the number of the 482// LMUL from VS2. 483// 14.1. Vector Single-Width Integer Reduction Instructions 484defm "" : LMULSEWSchedWrites<"WriteVIRedV_From">; 485defm "" : LMULSEWSchedWrites<"WriteVIRedMinMaxV_From">; 486// 14.2. Vector Widening Integer Reduction Instructions 487defm "" : LMULSEWSchedWritesWRed<"WriteVIWRedV_From">; 488// 14.3. Vector Single-Width Floating-Point Reduction Instructions 489defm "" : LMULSEWSchedWritesF<"WriteVFRedV_From">; 490defm "" : LMULSEWSchedWritesF<"WriteVFRedOV_From">; 491defm "" : LMULSEWSchedWritesF<"WriteVFRedMinMaxV_From">; 492// 14.4. Vector Widening Floating-Point Reduction Instructions 493defm "" : LMULSEWSchedWritesFWRed<"WriteVFWRedV_From">; 494defm "" : LMULSEWSchedWritesFWRed<"WriteVFWRedOV_From">; 495 496// 15. Vector Mask Instructions 497// 15.1. Vector Mask-Register Logical Instructions 498defm "" : LMULSchedWrites<"WriteVMALUV">; 499// 15.2. Vector Mask Population Count 500defm "" : LMULSchedWrites<"WriteVMPopV">; 501// 15.3. Vector Find-First-Set Mask Bit 502defm "" : LMULSchedWrites<"WriteVMFFSV">; 503// 15.4. Vector Set-Before-First Mask Bit 504// 15.5. Vector Set-Including-First Mask Bit 505// 15.6. Vector Set-only-First Mask Bit 506defm "" : LMULSchedWrites<"WriteVMSFSV">; 507// 15.8. Vector Iota Instruction 508defm "" : LMULSchedWrites<"WriteVIotaV">; 509// 15.9. Vector Element Index Instruction 510defm "" : LMULSchedWrites<"WriteVIdxV">; 511 512// 16. Vector Permutation Instructions 513// 16.1. Integer Scalar Move Instructions 514def WriteVMovSX : SchedWrite; 515def WriteVMovXS : SchedWrite; 516// 16.2. Floating-Point Scalar Move Instructions 517def WriteVMovSF : SchedWrite; 518def WriteVMovFS : SchedWrite; 519// 16.3. Vector Slide Instructions 520defm "" : LMULSchedWrites<"WriteVSlideUpX">; 521defm "" : LMULSchedWrites<"WriteVSlideDownX">; 522defm "" : LMULSchedWrites<"WriteVSlideI">; 523defm "" : LMULSchedWrites<"WriteVISlide1X">; 524defm "" : LMULSchedWrites<"WriteVFSlide1F">; 525// 16.4. Vector Register Gather Instructions 526defm "" : LMULSEWSchedWrites<"WriteVRGatherVV">; 527defm "" : LMULSEWSchedWrites<"WriteVRGatherEI16VV">; 528defm "" : LMULSchedWrites<"WriteVRGatherVX">; 529defm "" : LMULSchedWrites<"WriteVRGatherVI">; 530// 16.5. Vector Compress Instruction 531defm "" : LMULSEWSchedWrites<"WriteVCompressV">; 532// 16.6. Whole Vector Register Move 533// These are already LMUL aware 534def WriteVMov1V : SchedWrite; 535def WriteVMov2V : SchedWrite; 536def WriteVMov4V : SchedWrite; 537def WriteVMov8V : SchedWrite; 538 539//===----------------------------------------------------------------------===// 540/// Define scheduler resources associated with use operands. 541 542// 6. Configuration-Setting Instructions 543def ReadVSETVLI : SchedRead; 544def ReadVSETVL : SchedRead; 545 546// 7. Vector Loads and Stores 547def ReadVLDX : SchedRead; 548def ReadVSTX : SchedRead; 549// 7.4. Vector Unit-Stride Instructions 550defm "" : LMULSchedReads<"ReadVSTEV">; 551// 7.4.1. Vector Unit-Strided Mask 552defm "" : LMULSchedReads<"ReadVSTM">; 553// 7.5. Vector Strided Instructions 554def ReadVLDSX : SchedRead; 555def ReadVSTSX : SchedRead; 556defm "" : LMULSchedReads<"ReadVSTS8V">; 557defm "" : LMULSchedReads<"ReadVSTS16V">; 558defm "" : LMULSchedReads<"ReadVSTS32V">; 559defm "" : LMULSchedReads<"ReadVSTS64V">; 560// 7.6. Vector Indexed Instructions 561defm "" : LMULSchedReads<"ReadVLDUXV">; 562defm "" : LMULSchedReads<"ReadVLDOXV">; 563defm "" : LMULSchedReads<"ReadVSTUX8">; 564defm "" : LMULSchedReads<"ReadVSTUX16">; 565defm "" : LMULSchedReads<"ReadVSTUX32">; 566defm "" : LMULSchedReads<"ReadVSTUX64">; 567defm "" : LMULSchedReads<"ReadVSTUXV">; 568defm "" : LMULSchedReads<"ReadVSTUX8V">; 569defm "" : LMULSchedReads<"ReadVSTUX16V">; 570defm "" : LMULSchedReads<"ReadVSTUX32V">; 571defm "" : LMULSchedReads<"ReadVSTUX64V">; 572defm "" : LMULSchedReads<"ReadVSTOX8">; 573defm "" : LMULSchedReads<"ReadVSTOX16">; 574defm "" : LMULSchedReads<"ReadVSTOX32">; 575defm "" : LMULSchedReads<"ReadVSTOX64">; 576defm "" : LMULSchedReads<"ReadVSTOXV">; 577defm "" : LMULSchedReads<"ReadVSTOX8V">; 578defm "" : LMULSchedReads<"ReadVSTOX16V">; 579defm "" : LMULSchedReads<"ReadVSTOX32V">; 580defm "" : LMULSchedReads<"ReadVSTOX64V">; 581// 7.9. Vector Whole Register Instructions 582// These are already LMUL aware 583def ReadVST1R : SchedRead; 584def ReadVST2R : SchedRead; 585def ReadVST4R : SchedRead; 586def ReadVST8R : SchedRead; 587 588// 11. Vector Integer Arithmetic Instructions 589// 11.1. Vector Single-Width Integer Add and Subtract 590// 11.5. Vector Bitwise Logical Instructions 591defm "" : LMULSchedReads<"ReadVIALUV">; 592defm "" : LMULSchedReads<"ReadVIALUX">; 593// 11.2. Vector Widening Integer Add/Subtract 594defm "" : LMULSchedReadsW<"ReadVIWALUV">; 595defm "" : LMULSchedReadsW<"ReadVIWALUX">; 596// 11.3. Vector Integer Extension 597defm "" : LMULSchedReads<"ReadVExtV">; 598// 11.4. Vector Integer Arithmetic with Carry or Borrow Instructions 599defm "" : LMULSchedReads<"ReadVICALUV">; 600defm "" : LMULSchedReads<"ReadVICALUX">; 601// 11.6. Vector Single-Width Bit Shift Instructions 602defm "" : LMULSchedReads<"ReadVShiftV">; 603defm "" : LMULSchedReads<"ReadVShiftX">; 604// 11.7. Vector Narrowing Integer Right Shift Instructions 605defm "" : LMULSchedReadsW<"ReadVNShiftV">; 606defm "" : LMULSchedReadsW<"ReadVNShiftX">; 607// 11.8. Vector Integer Comparison Instructions 608defm "" : LMULSchedReads<"ReadVICmpV">; 609defm "" : LMULSchedReads<"ReadVICmpX">; 610// 11.9. Vector Integer Min/Max Instructions 611defm "" : LMULSchedReads<"ReadVIMinMaxV">; 612defm "" : LMULSchedReads<"ReadVIMinMaxX">; 613// 11.10. Vector Single-Width Integer Multiply Instructions 614defm "" : LMULSchedReads<"ReadVIMulV">; 615defm "" : LMULSchedReads<"ReadVIMulX">; 616// 11.11. Vector Integer Divide Instructions 617defm "" : LMULSEWSchedReads<"ReadVIDivV">; 618defm "" : LMULSEWSchedReads<"ReadVIDivX">; 619// 11.12. Vector Widening Integer Multiply Instructions 620defm "" : LMULSchedReadsW<"ReadVIWMulV">; 621defm "" : LMULSchedReadsW<"ReadVIWMulX">; 622// 11.13. Vector Single-Width Integer Multiply-Add Instructions 623defm "" : LMULSchedReads<"ReadVIMulAddV">; 624defm "" : LMULSchedReads<"ReadVIMulAddX">; 625// 11.14. Vector Widening Integer Multiply-Add Instructions 626defm "" : LMULSchedReadsW<"ReadVIWMulAddV">; 627defm "" : LMULSchedReadsW<"ReadVIWMulAddX">; 628// 11.15. Vector Integer Merge Instructions 629defm "" : LMULSchedReads<"ReadVIMergeV">; 630defm "" : LMULSchedReads<"ReadVIMergeX">; 631// 11.16. Vector Integer Move Instructions 632defm "" : LMULSchedReads<"ReadVIMovV">; 633defm "" : LMULSchedReads<"ReadVIMovX">; 634 635// 12. Vector Fixed-Point Arithmetic Instructions 636// 12.1. Vector Single-Width Saturating Add and Subtract 637defm "" : LMULSchedReads<"ReadVSALUV">; 638defm "" : LMULSchedReads<"ReadVSALUX">; 639// 12.2. Vector Single-Width Averaging Add and Subtract 640defm "" : LMULSchedReads<"ReadVAALUV">; 641defm "" : LMULSchedReads<"ReadVAALUX">; 642// 12.3. Vector Single-Width Fractional Multiply with Rounding and Saturation 643defm "" : LMULSchedReads<"ReadVSMulV">; 644defm "" : LMULSchedReads<"ReadVSMulX">; 645// 12.4. Vector Single-Width Scaling Shift Instructions 646defm "" : LMULSchedReads<"ReadVSShiftV">; 647defm "" : LMULSchedReads<"ReadVSShiftX">; 648// 12.5. Vector Narrowing Fixed-Point Clip Instructions 649defm "" : LMULSchedReadsW<"ReadVNClipV">; 650defm "" : LMULSchedReadsW<"ReadVNClipX">; 651 652// 13. Vector Floating-Point Instructions 653// 13.2. Vector Single-Width Floating-Point Add/Subtract Instructions 654defm "" : LMULSEWSchedReadsF<"ReadVFALUV">; 655defm "" : LMULSEWSchedReadsF<"ReadVFALUF">; 656// 13.3. Vector Widening Floating-Point Add/Subtract Instructions 657defm "" : LMULSEWSchedReadsFW<"ReadVFWALUV">; 658defm "" : LMULSEWSchedReadsFW<"ReadVFWALUF">; 659// 13.4. Vector Single-Width Floating-Point Multiply/Divide Instructions 660defm "" : LMULSEWSchedReadsF<"ReadVFMulV">; 661defm "" : LMULSEWSchedReadsF<"ReadVFMulF">; 662defm "" : LMULSEWSchedReadsF<"ReadVFDivV">; 663defm "" : LMULSEWSchedReadsF<"ReadVFDivF">; 664// 13.5. Vector Widening Floating-Point Multiply 665defm "" : LMULSEWSchedReadsFW<"ReadVFWMulV">; 666defm "" : LMULSEWSchedReadsFW<"ReadVFWMulF">; 667// 13.6. Vector Single-Width Floating-Point Fused Multiply-Add Instructions 668defm "" : LMULSEWSchedReadsF<"ReadVFMulAddV">; 669defm "" : LMULSEWSchedReadsF<"ReadVFMulAddF">; 670// 13.7. Vector Widening Floating-Point Fused Multiply-Add Instructions 671defm "" : LMULSEWSchedReadsFW<"ReadVFWMulAddV">; 672defm "" : LMULSEWSchedReadsFW<"ReadVFWMulAddF">; 673// 13.8. Vector Floating-Point Square-Root Instruction 674defm "" : LMULSEWSchedReadsF<"ReadVFSqrtV">; 675// 13.9. Vector Floating-Point Reciprocal Square-Root Estimate Instruction 676// 13.10. Vector Floating-Point Reciprocal Estimate Instruction 677defm "" : LMULSEWSchedReadsF<"ReadVFRecpV">; 678// 13.11. Vector Floating-Point MIN/MAX Instructions 679defm "" : LMULSEWSchedReadsF<"ReadVFMinMaxV">; 680defm "" : LMULSEWSchedReadsF<"ReadVFMinMaxF">; 681// 13.12. Vector Floating-Point Sign-Injection Instructions 682defm "" : LMULSEWSchedReadsF<"ReadVFSgnjV">; 683defm "" : LMULSEWSchedReadsF<"ReadVFSgnjF">; 684// 13.13. Vector Floating-Point Compare Instructions 685defm "" : LMULSchedReads<"ReadVFCmpV">; 686defm "" : LMULSchedReads<"ReadVFCmpF">; 687// 13.14. Vector Floating-Point Classify Instruction 688defm "" : LMULSchedReads<"ReadVFClassV">; 689// 13.15. Vector Floating-Point Merge Instruction 690defm "" : LMULSchedReads<"ReadVFMergeV">; 691defm "" : LMULSchedReads<"ReadVFMergeF">; 692// 13.16. Vector Floating-Point Move Instruction 693defm "" : LMULSchedReads<"ReadVFMovF">; 694// 13.17. Single-Width Floating-Point/Integer Type-Convert Instructions 695defm "" : LMULSEWSchedReadsF<"ReadVFCvtIToFV">; 696defm "" : LMULSchedReads<"ReadVFCvtFToIV">; 697// 13.18. Widening Floating-Point/Integer Type-Convert Instructions 698defm "" : LMULSEWSchedReadsW<"ReadVFWCvtIToFV">; 699defm "" : LMULSchedReadsFW<"ReadVFWCvtFToIV">; 700defm "" : LMULSEWSchedReadsFW<"ReadVFWCvtFToFV">; 701// 13.19. Narrowing Floating-Point/Integer Type-Convert Instructions 702defm "" : LMULSEWSchedReadsFW<"ReadVFNCvtIToFV">; 703defm "" : LMULSchedReadsW<"ReadVFNCvtFToIV">; 704defm "" : LMULSEWSchedReadsFW<"ReadVFNCvtFToFV">; 705 706// 14. Vector Reduction Operations 707// 14.1. Vector Single-Width Integer Reduction Instructions 708def ReadVIRedV : SchedRead; 709def ReadVIRedV0 : SchedRead; 710// 14.2. Vector Widening Integer Reduction Instructions 711def ReadVIWRedV : SchedRead; 712def ReadVIWRedV0 : SchedRead; 713// 14.3. Vector Single-Width Floating-Point Reduction Instructions 714def ReadVFRedV : SchedRead; 715def ReadVFRedV0 : SchedRead; 716def ReadVFRedOV : SchedRead; 717def ReadVFRedOV0 : SchedRead; 718def ReadVFRedMinMaxV : SchedRead; 719// 14.4. Vector Widening Floating-Point Reduction Instructions 720def ReadVFWRedV : SchedRead; 721def ReadVFWRedV0 : SchedRead; 722def ReadVFWRedOV : SchedRead; 723def ReadVFWRedOV0 : SchedRead; 724 725// 15. Vector Mask Instructions 726// 15.1. Vector Mask-Register Logical Instructions 727defm "" : LMULSchedReads<"ReadVMALUV">; 728// 15.2. Vector Mask Population Count 729defm "" : LMULSchedReads<"ReadVMPopV">; 730// 15.3. Vector Find-First-Set Mask Bit 731defm "" : LMULSchedReads<"ReadVMFFSV">; 732// 15.4. Vector Set-Before-First Mask Bit 733// 15.5. Vector Set-Including-First Mask Bit 734// 15.6. Vector Set-only-First Mask Bit 735defm "" : LMULSchedReads<"ReadVMSFSV">; 736// 15.8. Vector Iota Instruction 737defm "" : LMULSchedReads<"ReadVIotaV">; 738 739// 16. Vector Permutation Instructions 740// 16.1. Integer Scalar Move Instructions 741def ReadVMovXS : SchedRead; 742def ReadVMovSX_V : SchedRead; 743def ReadVMovSX_X : SchedRead; 744// 16.2. Floating-Point Scalar Move Instructions 745def ReadVMovFS : SchedRead; 746def ReadVMovSF_V : SchedRead; 747def ReadVMovSF_F : SchedRead; 748// 16.3. Vector Slide Instructions 749defm "" : LMULSchedReads<"ReadVISlideV">; 750defm "" : LMULSchedReads<"ReadVISlideX">; 751defm "" : LMULSchedReads<"ReadVFSlideV">; 752defm "" : LMULSchedReads<"ReadVFSlideF">; 753// 16.4. Vector Register Gather Instructions 754defm "" : LMULSEWSchedReads<"ReadVRGatherVV_data">; 755defm "" : LMULSEWSchedReads<"ReadVRGatherVV_index">; 756defm "" : LMULSEWSchedReads<"ReadVRGatherEI16VV_data">; 757defm "" : LMULSEWSchedReads<"ReadVRGatherEI16VV_index">; 758defm "" : LMULSchedReads<"ReadVRGatherVX_data">; 759defm "" : LMULSchedReads<"ReadVRGatherVX_index">; 760defm "" : LMULSchedReads<"ReadVRGatherVI_data">; 761// 16.5. Vector Compress Instruction 762defm "" : LMULSEWSchedReads<"ReadVCompressV">; 763// 16.6. Whole Vector Register Move 764// These are already LMUL aware 765def ReadVMov1V : SchedRead; 766def ReadVMov2V : SchedRead; 767def ReadVMov4V : SchedRead; 768def ReadVMov8V : SchedRead; 769 770// Others 771def ReadVMask : SchedRead; 772def ReadVPassthru_WorstCase : SchedRead; 773foreach mx = SchedMxList in { 774 def ReadVPassthru_ # mx : SchedRead; 775 foreach sew = SchedSEWSet<mx>.val in 776 def ReadVPassthru_ # mx # "_E" # sew : SchedRead; 777} 778 779//===----------------------------------------------------------------------===// 780/// Define default scheduler resources for V. 781 782multiclass UnsupportedSchedV { 783let Unsupported = true in { 784 785// 3.6 Vector Byte Length vlenb 786def : WriteRes<WriteRdVLENB, []>; 787 788// 6. Configuration-Setting Instructions 789def : WriteRes<WriteVSETVLI, []>; 790def : WriteRes<WriteVSETIVLI, []>; 791def : WriteRes<WriteVSETVL, []>; 792 793// 7. Vector Loads and Stores 794defm "" : LMULWriteRes<"WriteVLDE", []>; 795defm "" : LMULWriteRes<"WriteVSTE", []>; 796defm "" : LMULWriteRes<"WriteVLDM", []>; 797defm "" : LMULWriteRes<"WriteVSTM", []>; 798defm "" : LMULWriteRes<"WriteVLDS8", []>; 799defm "" : LMULWriteRes<"WriteVLDS16", []>; 800defm "" : LMULWriteRes<"WriteVLDS32", []>; 801defm "" : LMULWriteRes<"WriteVLDS64", []>; 802defm "" : LMULWriteRes<"WriteVSTS8", []>; 803defm "" : LMULWriteRes<"WriteVSTS16", []>; 804defm "" : LMULWriteRes<"WriteVSTS32", []>; 805defm "" : LMULWriteRes<"WriteVSTS64", []>; 806defm "" : LMULWriteRes<"WriteVLDUX8", []>; 807defm "" : LMULWriteRes<"WriteVLDUX16", []>; 808defm "" : LMULWriteRes<"WriteVLDUX32", []>; 809defm "" : LMULWriteRes<"WriteVLDUX64", []>; 810defm "" : LMULWriteRes<"WriteVLDOX8", []>; 811defm "" : LMULWriteRes<"WriteVLDOX16", []>; 812defm "" : LMULWriteRes<"WriteVLDOX32", []>; 813defm "" : LMULWriteRes<"WriteVLDOX64", []>; 814defm "" : LMULWriteRes<"WriteVSTUX8", []>; 815defm "" : LMULWriteRes<"WriteVSTUX16", []>; 816defm "" : LMULWriteRes<"WriteVSTUX32", []>; 817defm "" : LMULWriteRes<"WriteVSTUX64", []>; 818defm "" : LMULWriteRes<"WriteVSTOX8", []>; 819defm "" : LMULWriteRes<"WriteVSTOX16", []>; 820defm "" : LMULWriteRes<"WriteVSTOX32", []>; 821defm "" : LMULWriteRes<"WriteVSTOX64", []>; 822defm "" : LMULWriteRes<"WriteVLDFF", []>; 823// These are already LMUL aware 824def : WriteRes<WriteVLD1R, []>; 825def : WriteRes<WriteVLD2R, []>; 826def : WriteRes<WriteVLD4R, []>; 827def : WriteRes<WriteVLD8R, []>; 828def : WriteRes<WriteVST1R, []>; 829def : WriteRes<WriteVST2R, []>; 830def : WriteRes<WriteVST4R, []>; 831def : WriteRes<WriteVST8R, []>; 832// Vector Segment Loads and Stores 833foreach nf=2-8 in { 834 foreach eew = [8, 16, 32, 64] in { 835 defm "" : LMULWriteRes <"WriteVLSEG" # nf # "e" # eew, []>; 836 defm "" : LMULWriteRes <"WriteVLSEGFF" # nf # "e" # eew, []>; 837 defm "" : LMULWriteRes <"WriteVSSEG" # nf # "e" # eew, []>; 838 defm "" : LMULWriteRes <"WriteVLSSEG" # nf # "e" # eew, []>; 839 defm "" : LMULWriteRes <"WriteVSSSEG" # nf # "e" # eew, []>; 840 defm "" : LMULWriteRes <"WriteVLUXSEG" # nf # "e" # eew, []>; 841 defm "" : LMULWriteRes <"WriteVLOXSEG" # nf # "e" # eew, []>; 842 defm "" : LMULWriteRes <"WriteVSUXSEG" # nf # "e" # eew, []>; 843 defm "" : LMULWriteRes <"WriteVSOXSEG" # nf # "e" # eew, []>; 844 } 845} 846 847// 11. Vector Integer Arithmetic Instructions 848defm "" : LMULWriteRes<"WriteVIALUV", []>; 849defm "" : LMULWriteRes<"WriteVIALUX", []>; 850defm "" : LMULWriteRes<"WriteVIALUI", []>; 851defm "" : LMULWriteResW<"WriteVIWALUV", []>; 852defm "" : LMULWriteResW<"WriteVIWALUX", []>; 853defm "" : LMULWriteResW<"WriteVIWALUI", []>; 854defm "" : LMULWriteRes<"WriteVExtV", []>; 855defm "" : LMULWriteRes<"WriteVICALUV", []>; 856defm "" : LMULWriteRes<"WriteVICALUX", []>; 857defm "" : LMULWriteRes<"WriteVICALUI", []>; 858defm "" : LMULWriteRes<"WriteVICALUMV", []>; 859defm "" : LMULWriteRes<"WriteVICALUMX", []>; 860defm "" : LMULWriteRes<"WriteVICALUMI", []>; 861defm "" : LMULWriteRes<"WriteVShiftV", []>; 862defm "" : LMULWriteRes<"WriteVShiftX", []>; 863defm "" : LMULWriteRes<"WriteVShiftI", []>; 864defm "" : LMULWriteResW<"WriteVNShiftV", []>; 865defm "" : LMULWriteResW<"WriteVNShiftX", []>; 866defm "" : LMULWriteResW<"WriteVNShiftI", []>; 867defm "" : LMULWriteRes<"WriteVICmpV", []>; 868defm "" : LMULWriteRes<"WriteVICmpX", []>; 869defm "" : LMULWriteRes<"WriteVICmpI", []>; 870defm "" : LMULWriteRes<"WriteVIMinMaxV", []>; 871defm "" : LMULWriteRes<"WriteVIMinMaxX", []>; 872defm "" : LMULWriteRes<"WriteVIMulV", []>; 873defm "" : LMULWriteRes<"WriteVIMulX", []>; 874defm "" : LMULSEWWriteRes<"WriteVIDivV", []>; 875defm "" : LMULSEWWriteRes<"WriteVIDivX", []>; 876defm "" : LMULWriteResW<"WriteVIWMulV", []>; 877defm "" : LMULWriteResW<"WriteVIWMulX", []>; 878defm "" : LMULWriteRes<"WriteVIMulAddV", []>; 879defm "" : LMULWriteRes<"WriteVIMulAddX", []>; 880defm "" : LMULWriteResW<"WriteVIWMulAddV", []>; 881defm "" : LMULWriteResW<"WriteVIWMulAddX", []>; 882defm "" : LMULWriteRes<"WriteVIMergeV", []>; 883defm "" : LMULWriteRes<"WriteVIMergeX", []>; 884defm "" : LMULWriteRes<"WriteVIMergeI", []>; 885defm "" : LMULWriteRes<"WriteVIMovV", []>; 886defm "" : LMULWriteRes<"WriteVIMovX", []>; 887defm "" : LMULWriteRes<"WriteVIMovI", []>; 888 889// 12. Vector Fixed-Point Arithmetic Instructions 890defm "" : LMULWriteRes<"WriteVSALUV", []>; 891defm "" : LMULWriteRes<"WriteVSALUX", []>; 892defm "" : LMULWriteRes<"WriteVSALUI", []>; 893defm "" : LMULWriteRes<"WriteVAALUV", []>; 894defm "" : LMULWriteRes<"WriteVAALUX", []>; 895defm "" : LMULWriteRes<"WriteVSMulV", []>; 896defm "" : LMULWriteRes<"WriteVSMulX", []>; 897defm "" : LMULWriteRes<"WriteVSShiftV", []>; 898defm "" : LMULWriteRes<"WriteVSShiftX", []>; 899defm "" : LMULWriteRes<"WriteVSShiftI", []>; 900defm "" : LMULWriteResW<"WriteVNClipV", []>; 901defm "" : LMULWriteResW<"WriteVNClipX", []>; 902defm "" : LMULWriteResW<"WriteVNClipI", []>; 903 904// 13. Vector Floating-Point Instructions 905defm "" : LMULSEWWriteResF<"WriteVFALUV", []>; 906defm "" : LMULSEWWriteResF<"WriteVFALUF", []>; 907defm "" : LMULSEWWriteResFW<"WriteVFWALUV", []>; 908defm "" : LMULSEWWriteResFW<"WriteVFWALUF", []>; 909defm "" : LMULSEWWriteResF<"WriteVFMulV", []>; 910defm "" : LMULSEWWriteResF<"WriteVFMulF", []>; 911defm "" : LMULSEWWriteResF<"WriteVFDivV", []>; 912defm "" : LMULSEWWriteResF<"WriteVFDivF", []>; 913defm "" : LMULSEWWriteResFW<"WriteVFWMulV", []>; 914defm "" : LMULSEWWriteResFW<"WriteVFWMulF", []>; 915defm "" : LMULSEWWriteResF<"WriteVFMulAddV", []>; 916defm "" : LMULSEWWriteResF<"WriteVFMulAddF", []>; 917defm "" : LMULSEWWriteResFW<"WriteVFWMulAddV", []>; 918defm "" : LMULSEWWriteResFW<"WriteVFWMulAddF", []>; 919defm "" : LMULSEWWriteResF<"WriteVFSqrtV", []>; 920defm "" : LMULSEWWriteResF<"WriteVFRecpV", []>; 921defm "" : LMULSEWWriteResF<"WriteVFMinMaxV", []>; 922defm "" : LMULSEWWriteResF<"WriteVFMinMaxF", []>; 923defm "" : LMULSEWWriteResF<"WriteVFSgnjV", []>; 924defm "" : LMULSEWWriteResF<"WriteVFSgnjF", []>; 925defm "" : LMULWriteRes<"WriteVFCmpV", []>; 926defm "" : LMULWriteRes<"WriteVFCmpF", []>; 927defm "" : LMULWriteRes<"WriteVFClassV", []>; 928defm "" : LMULWriteRes<"WriteVFMergeV", []>; 929defm "" : LMULWriteRes<"WriteVFMovV", []>; 930defm "" : LMULSEWWriteResF<"WriteVFCvtIToFV", []>; 931defm "" : LMULWriteRes<"WriteVFCvtFToIV", []>; 932defm "" : LMULSEWWriteResW<"WriteVFWCvtIToFV", []>; 933defm "" : LMULWriteResFW<"WriteVFWCvtFToIV", []>; 934defm "" : LMULSEWWriteResFW<"WriteVFWCvtFToFV", []>; 935defm "" : LMULSEWWriteResFW<"WriteVFNCvtIToFV", []>; 936defm "" : LMULWriteResW<"WriteVFNCvtFToIV", []>; 937defm "" : LMULSEWWriteResFW<"WriteVFNCvtFToFV", []>; 938 939// 14. Vector Reduction Operations 940defm "" : LMULSEWWriteRes<"WriteVIRedV_From", []>; 941defm "" : LMULSEWWriteRes<"WriteVIRedMinMaxV_From", []>; 942defm "" : LMULSEWWriteResWRed<"WriteVIWRedV_From", []>; 943defm "" : LMULSEWWriteResF<"WriteVFRedV_From", []>; 944defm "" : LMULSEWWriteResF<"WriteVFRedOV_From", []>; 945defm "" : LMULSEWWriteResF<"WriteVFRedMinMaxV_From", []>; 946defm "" : LMULSEWWriteResFWRed<"WriteVFWRedV_From", []>; 947defm "" : LMULSEWWriteResFWRed<"WriteVFWRedOV_From", []>; 948 949// 15. Vector Mask Instructions 950defm "" : LMULWriteRes<"WriteVMALUV", []>; 951defm "" : LMULWriteRes<"WriteVMPopV", []>; 952defm "" : LMULWriteRes<"WriteVMFFSV", []>; 953defm "" : LMULWriteRes<"WriteVMSFSV", []>; 954defm "" : LMULWriteRes<"WriteVIotaV", []>; 955defm "" : LMULWriteRes<"WriteVIdxV", []>; 956 957// 16. Vector Permutation Instructions 958def : WriteRes<WriteVMovSX, []>; 959def : WriteRes<WriteVMovXS, []>; 960def : WriteRes<WriteVMovSF, []>; 961def : WriteRes<WriteVMovFS, []>; 962defm "" : LMULWriteRes<"WriteVSlideUpX", []>; 963defm "" : LMULWriteRes<"WriteVSlideDownX", []>; 964defm "" : LMULWriteRes<"WriteVSlideI", []>; 965defm "" : LMULWriteRes<"WriteVISlide1X", []>; 966defm "" : LMULWriteRes<"WriteVFSlide1F", []>; 967defm "" : LMULSEWWriteRes<"WriteVRGatherVV", []>; 968defm "" : LMULSEWWriteRes<"WriteVRGatherEI16VV", []>; 969defm "" : LMULWriteRes<"WriteVRGatherVX", []>; 970defm "" : LMULWriteRes<"WriteVRGatherVI", []>; 971defm "" : LMULSEWWriteRes<"WriteVCompressV", []>; 972// These are already LMUL aware 973def : WriteRes<WriteVMov1V, []>; 974def : WriteRes<WriteVMov2V, []>; 975def : WriteRes<WriteVMov4V, []>; 976def : WriteRes<WriteVMov8V, []>; 977 978// 6. Configuration-Setting Instructions 979def : ReadAdvance<ReadVSETVLI, 0>; 980def : ReadAdvance<ReadVSETVL, 0>; 981 982// 7. Vector Loads and Stores 983def : ReadAdvance<ReadVLDX, 0>; 984def : ReadAdvance<ReadVSTX, 0>; 985defm "" : LMULReadAdvance<"ReadVSTEV", 0>; 986defm "" : LMULReadAdvance<"ReadVSTM", 0>; 987def : ReadAdvance<ReadVLDSX, 0>; 988def : ReadAdvance<ReadVSTSX, 0>; 989defm "" : LMULReadAdvance<"ReadVSTS8V", 0>; 990defm "" : LMULReadAdvance<"ReadVSTS16V", 0>; 991defm "" : LMULReadAdvance<"ReadVSTS32V", 0>; 992defm "" : LMULReadAdvance<"ReadVSTS64V", 0>; 993defm "" : LMULReadAdvance<"ReadVLDUXV", 0>; 994defm "" : LMULReadAdvance<"ReadVLDOXV", 0>; 995defm "" : LMULReadAdvance<"ReadVSTUXV", 0>; 996defm "" : LMULReadAdvance<"ReadVSTUX8", 0>; 997defm "" : LMULReadAdvance<"ReadVSTUX16", 0>; 998defm "" : LMULReadAdvance<"ReadVSTUX32", 0>; 999defm "" : LMULReadAdvance<"ReadVSTUX64", 0>; 1000defm "" : LMULReadAdvance<"ReadVSTUX8V", 0>; 1001defm "" : LMULReadAdvance<"ReadVSTUX16V", 0>; 1002defm "" : LMULReadAdvance<"ReadVSTUX32V", 0>; 1003defm "" : LMULReadAdvance<"ReadVSTUX64V", 0>; 1004defm "" : LMULReadAdvance<"ReadVSTOX8", 0>; 1005defm "" : LMULReadAdvance<"ReadVSTOX16", 0>; 1006defm "" : LMULReadAdvance<"ReadVSTOX32", 0>; 1007defm "" : LMULReadAdvance<"ReadVSTOX64", 0>; 1008defm "" : LMULReadAdvance<"ReadVSTOXV", 0>; 1009defm "" : LMULReadAdvance<"ReadVSTOX8V", 0>; 1010defm "" : LMULReadAdvance<"ReadVSTOX16V", 0>; 1011defm "" : LMULReadAdvance<"ReadVSTOX32V", 0>; 1012defm "" : LMULReadAdvance<"ReadVSTOX64V", 0>; 1013// These are already LMUL aware 1014def : ReadAdvance<ReadVST1R, 0>; 1015def : ReadAdvance<ReadVST2R, 0>; 1016def : ReadAdvance<ReadVST4R, 0>; 1017def : ReadAdvance<ReadVST8R, 0>; 1018 1019// 11. Vector Integer Arithmetic Instructions 1020defm "" : LMULReadAdvance<"ReadVIALUV", 0>; 1021defm "" : LMULReadAdvance<"ReadVIALUX", 0>; 1022defm "" : LMULReadAdvanceW<"ReadVIWALUV", 0>; 1023defm "" : LMULReadAdvanceW<"ReadVIWALUX", 0>; 1024defm "" : LMULReadAdvance<"ReadVExtV", 0>; 1025defm "" : LMULReadAdvance<"ReadVICALUV", 0>; 1026defm "" : LMULReadAdvance<"ReadVICALUX", 0>; 1027defm "" : LMULReadAdvance<"ReadVShiftV", 0>; 1028defm "" : LMULReadAdvance<"ReadVShiftX", 0>; 1029defm "" : LMULReadAdvanceW<"ReadVNShiftV", 0>; 1030defm "" : LMULReadAdvanceW<"ReadVNShiftX", 0>; 1031defm "" : LMULReadAdvance<"ReadVICmpV", 0>; 1032defm "" : LMULReadAdvance<"ReadVICmpX", 0>; 1033defm "" : LMULReadAdvance<"ReadVIMinMaxV", 0>; 1034defm "" : LMULReadAdvance<"ReadVIMinMaxX", 0>; 1035defm "" : LMULReadAdvance<"ReadVIMulV", 0>; 1036defm "" : LMULReadAdvance<"ReadVIMulX", 0>; 1037defm "" : LMULSEWReadAdvance<"ReadVIDivV", 0>; 1038defm "" : LMULSEWReadAdvance<"ReadVIDivX", 0>; 1039defm "" : LMULReadAdvanceW<"ReadVIWMulV", 0>; 1040defm "" : LMULReadAdvanceW<"ReadVIWMulX", 0>; 1041defm "" : LMULReadAdvance<"ReadVIMulAddV", 0>; 1042defm "" : LMULReadAdvance<"ReadVIMulAddX", 0>; 1043defm "" : LMULReadAdvanceW<"ReadVIWMulAddV", 0>; 1044defm "" : LMULReadAdvanceW<"ReadVIWMulAddX", 0>; 1045defm "" : LMULReadAdvance<"ReadVIMergeV", 0>; 1046defm "" : LMULReadAdvance<"ReadVIMergeX", 0>; 1047defm "" : LMULReadAdvance<"ReadVIMovV", 0>; 1048defm "" : LMULReadAdvance<"ReadVIMovX", 0>; 1049 1050// 12. Vector Fixed-Point Arithmetic Instructions 1051defm "" : LMULReadAdvance<"ReadVSALUV", 0>; 1052defm "" : LMULReadAdvance<"ReadVSALUX", 0>; 1053defm "" : LMULReadAdvance<"ReadVAALUV", 0>; 1054defm "" : LMULReadAdvance<"ReadVAALUX", 0>; 1055defm "" : LMULReadAdvance<"ReadVSMulV", 0>; 1056defm "" : LMULReadAdvance<"ReadVSMulX", 0>; 1057defm "" : LMULReadAdvance<"ReadVSShiftV", 0>; 1058defm "" : LMULReadAdvance<"ReadVSShiftX", 0>; 1059defm "" : LMULReadAdvanceW<"ReadVNClipV", 0>; 1060defm "" : LMULReadAdvanceW<"ReadVNClipX", 0>; 1061 1062// 13. Vector Floating-Point Instructions 1063defm "" : LMULSEWReadAdvanceF<"ReadVFALUV", 0>; 1064defm "" : LMULSEWReadAdvanceF<"ReadVFALUF", 0>; 1065defm "" : LMULSEWReadAdvanceFW<"ReadVFWALUV", 0>; 1066defm "" : LMULSEWReadAdvanceFW<"ReadVFWALUF", 0>; 1067defm "" : LMULSEWReadAdvanceF<"ReadVFMulV", 0>; 1068defm "" : LMULSEWReadAdvanceF<"ReadVFMulF", 0>; 1069defm "" : LMULSEWReadAdvanceF<"ReadVFDivV", 0>; 1070defm "" : LMULSEWReadAdvanceF<"ReadVFDivF", 0>; 1071defm "" : LMULSEWReadAdvanceFW<"ReadVFWMulV", 0>; 1072defm "" : LMULSEWReadAdvanceFW<"ReadVFWMulF", 0>; 1073defm "" : LMULSEWReadAdvanceF<"ReadVFMulAddV", 0>; 1074defm "" : LMULSEWReadAdvanceF<"ReadVFMulAddF", 0>; 1075defm "" : LMULSEWReadAdvanceFW<"ReadVFWMulAddV", 0>; 1076defm "" : LMULSEWReadAdvanceFW<"ReadVFWMulAddF", 0>; 1077defm "" : LMULSEWReadAdvanceF<"ReadVFSqrtV", 0>; 1078defm "" : LMULSEWReadAdvanceF<"ReadVFRecpV", 0>; 1079defm "" : LMULSEWReadAdvanceF<"ReadVFMinMaxV", 0>; 1080defm "" : LMULSEWReadAdvanceF<"ReadVFMinMaxF", 0>; 1081defm "" : LMULSEWReadAdvanceF<"ReadVFSgnjV", 0>; 1082defm "" : LMULSEWReadAdvanceF<"ReadVFSgnjF", 0>; 1083defm "" : LMULReadAdvance<"ReadVFCmpV", 0>; 1084defm "" : LMULReadAdvance<"ReadVFCmpF", 0>; 1085defm "" : LMULReadAdvance<"ReadVFClassV", 0>; 1086defm "" : LMULReadAdvance<"ReadVFMergeV", 0>; 1087defm "" : LMULReadAdvance<"ReadVFMergeF", 0>; 1088defm "" : LMULReadAdvance<"ReadVFMovF", 0>; 1089defm "" : LMULSEWReadAdvanceF<"ReadVFCvtIToFV", 0>; 1090defm "" : LMULReadAdvance<"ReadVFCvtFToIV", 0>; 1091defm "" : LMULSEWReadAdvanceW<"ReadVFWCvtIToFV", 0>; 1092defm "" : LMULReadAdvanceFW<"ReadVFWCvtFToIV", 0>; 1093defm "" : LMULSEWReadAdvanceFW<"ReadVFWCvtFToFV", 0>; 1094defm "" : LMULSEWReadAdvanceFW<"ReadVFNCvtIToFV", 0>; 1095defm "" : LMULReadAdvanceW<"ReadVFNCvtFToIV", 0>; 1096defm "" : LMULSEWReadAdvanceFW<"ReadVFNCvtFToFV", 0>; 1097 1098// 14. Vector Reduction Operations 1099def : ReadAdvance<ReadVIRedV, 0>; 1100def : ReadAdvance<ReadVIRedV0, 0>; 1101def : ReadAdvance<ReadVIWRedV, 0>; 1102def : ReadAdvance<ReadVIWRedV0, 0>; 1103def : ReadAdvance<ReadVFRedV, 0>; 1104def : ReadAdvance<ReadVFRedV0, 0>; 1105def : ReadAdvance<ReadVFRedOV, 0>; 1106def : ReadAdvance<ReadVFRedOV0, 0>; 1107def : ReadAdvance<ReadVFRedMinMaxV, 0>; 1108def : ReadAdvance<ReadVFWRedV, 0>; 1109def : ReadAdvance<ReadVFWRedV0, 0>; 1110def : ReadAdvance<ReadVFWRedOV, 0>; 1111def : ReadAdvance<ReadVFWRedOV0, 0>; 1112 1113// 15. Vector Mask Instructions 1114defm "" : LMULReadAdvance<"ReadVMALUV", 0>; 1115defm "" : LMULReadAdvance<"ReadVMPopV", 0>; 1116defm "" : LMULReadAdvance<"ReadVMFFSV", 0>; 1117defm "" : LMULReadAdvance<"ReadVMSFSV", 0>; 1118defm "" : LMULReadAdvance<"ReadVIotaV", 0>; 1119 1120// 16. Vector Permutation Instructions 1121def : ReadAdvance<ReadVMovXS, 0>; 1122def : ReadAdvance<ReadVMovSX_V, 0>; 1123def : ReadAdvance<ReadVMovSX_X, 0>; 1124def : ReadAdvance<ReadVMovFS, 0>; 1125def : ReadAdvance<ReadVMovSF_V, 0>; 1126def : ReadAdvance<ReadVMovSF_F, 0>; 1127defm "" : LMULReadAdvance<"ReadVISlideV", 0>; 1128defm "" : LMULReadAdvance<"ReadVISlideX", 0>; 1129defm "" : LMULReadAdvance<"ReadVFSlideV", 0>; 1130defm "" : LMULReadAdvance<"ReadVFSlideF", 0>; 1131defm "" : LMULSEWReadAdvance<"ReadVRGatherVV_data", 0>; 1132defm "" : LMULSEWReadAdvance<"ReadVRGatherVV_index", 0>; 1133defm "" : LMULSEWReadAdvance<"ReadVRGatherEI16VV_data", 0>; 1134defm "" : LMULSEWReadAdvance<"ReadVRGatherEI16VV_index", 0>; 1135defm "" : LMULReadAdvance<"ReadVRGatherVX_data", 0>; 1136defm "" : LMULReadAdvance<"ReadVRGatherVX_index", 0>; 1137defm "" : LMULReadAdvance<"ReadVRGatherVI_data", 0>; 1138defm "" : LMULReadAdvance<"ReadVGatherV", 0>; 1139defm "" : LMULSEWReadAdvance<"ReadVCompressV", 0>; 1140// These are already LMUL aware 1141def : ReadAdvance<ReadVMov1V, 0>; 1142def : ReadAdvance<ReadVMov2V, 0>; 1143def : ReadAdvance<ReadVMov4V, 0>; 1144def : ReadAdvance<ReadVMov8V, 0>; 1145 1146// Others 1147def : ReadAdvance<ReadVMask, 0>; 1148def : ReadAdvance<ReadVPassthru_WorstCase, 0>; 1149foreach mx = SchedMxList in { 1150 def : ReadAdvance<!cast<SchedRead>("ReadVPassthru_" # mx), 0>; 1151 foreach sew = SchedSEWSet<mx>.val in 1152 def : ReadAdvance<!cast<SchedRead>("ReadVPassthru_" # mx # "_E" # sew), 0>; 1153} 1154 1155} // Unsupported 1156} // UnsupportedSchedV 1157