| blob | 43af1802d706f1ff43936dbda060376701033aab |
1 //===-- RISCVScheduleV.td - RISCV 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 //===----------------------------------------------------------------------===//
9 //===----------------------------------------------------------------------===//
10 /// Define scheduler resources associated with def operands.
12 // 7. Vector Loads and Stores
13 // 7.4. Vector Unit-Stride Instructions
14 def WriteVLDE8 : SchedWrite;
15 def WriteVLDE16 : SchedWrite;
16 def WriteVLDE32 : SchedWrite;
17 def WriteVLDE64 : SchedWrite;
18 def WriteVSTE8 : SchedWrite;
19 def WriteVSTE16 : SchedWrite;
20 def WriteVSTE32 : SchedWrite;
21 def WriteVSTE64 : SchedWrite;
22 // 7.4.1. Vector Unit-Strided Mask
23 def WriteVLDM : SchedWrite;
24 def WriteVSTM : SchedWrite;
25 // 7.5. Vector Strided Instructions
26 def WriteVLDS8 : SchedWrite;
27 def WriteVLDS16 : SchedWrite;
28 def WriteVLDS32 : SchedWrite;
29 def WriteVLDS64 : SchedWrite;
30 def WriteVSTS8 : SchedWrite;
31 def WriteVSTS16 : SchedWrite;
32 def WriteVSTS32 : SchedWrite;
33 def WriteVSTS64 : SchedWrite;
34 // 7.6. Vector Indexed Instructions
35 def WriteVLDUX8 : SchedWrite;
36 def WriteVLDUX16 : SchedWrite;
37 def WriteVLDUX32 : SchedWrite;
38 def WriteVLDUX64 : SchedWrite;
39 def WriteVLDOX8 : SchedWrite;
40 def WriteVLDOX16 : SchedWrite;
41 def WriteVLDOX32 : SchedWrite;
42 def WriteVLDOX64 : SchedWrite;
43 def WriteVSTUX8 : SchedWrite;
44 def WriteVSTUX16 : SchedWrite;
45 def WriteVSTUX32 : SchedWrite;
46 def WriteVSTUX64 : SchedWrite;
47 def WriteVSTOX8 : SchedWrite;
48 def WriteVSTOX16 : SchedWrite;
49 def WriteVSTOX32 : SchedWrite;
50 def WriteVSTOX64 : SchedWrite;
51 // 7.7. Vector Unit-stride Fault-Only-First Loads
52 def WriteVLDFF8 : SchedWrite;
53 def WriteVLDFF16 : SchedWrite;
54 def WriteVLDFF32 : SchedWrite;
55 def WriteVLDFF64 : SchedWrite;
56 // 7.9. Vector Whole Register Instructions
57 def WriteVLD1R8 : SchedWrite;
58 def WriteVLD1R16 : SchedWrite;
59 def WriteVLD1R32 : SchedWrite;
60 def WriteVLD1R64 : SchedWrite;
61 def WriteVLD2R8 : SchedWrite;
62 def WriteVLD2R16 : SchedWrite;
63 def WriteVLD2R32 : SchedWrite;
64 def WriteVLD2R64 : SchedWrite;
65 def WriteVLD4R8 : SchedWrite;
66 def WriteVLD4R16 : SchedWrite;
67 def WriteVLD4R32 : SchedWrite;
68 def WriteVLD4R64 : SchedWrite;
69 def WriteVLD8R8 : SchedWrite;
70 def WriteVLD8R16 : SchedWrite;
71 def WriteVLD8R32 : SchedWrite;
72 def WriteVLD8R64 : SchedWrite;
73 def WriteVST1R : SchedWrite;
74 def WriteVST2R : SchedWrite;
75 def WriteVST4R : SchedWrite;
76 def WriteVST8R : SchedWrite;
78 // 11. Vector Integer Arithmetic Instructions
79 // 11.1. Vector Single-Width Integer Add and Subtract
80 // 11.5. Vector Bitwise Logical Instructions
81 def WriteVIALUV : SchedWrite;
82 def WriteVIALUX : SchedWrite;
83 def WriteVIALUI : SchedWrite;
84 // 11.2. Vector Widening Integer Add/Subtract
85 def WriteVIWALUV : SchedWrite;
86 def WriteVIWALUX : SchedWrite;
87 def WriteVIWALUI : SchedWrite;
88 // 11.3. Vector Integer Extension
89 def WriteVExtV : SchedWrite;
90 // 11.4. Vector Integer Arithmetic with Carry or Borrow Instructions
91 def WriteVICALUV : SchedWrite;
92 def WriteVICALUX : SchedWrite;
93 def WriteVICALUI : SchedWrite;
94 // 11.6. Vector Single-Width Bit Shift Instructions
95 def WriteVShiftV : SchedWrite;
96 def WriteVShiftX : SchedWrite;
97 def WriteVShiftI : SchedWrite;
98 // 11.7. Vector Narrowing Integer Right Shift Instructions
99 def WriteVNShiftV : SchedWrite;
100 def WriteVNShiftX : SchedWrite;
101 def WriteVNShiftI : SchedWrite;
102 // 11.8. Vector Integer Comparison Instructions
103 // 11.9. Vector Integer Min/Max Instructions
104 def WriteVICmpV : SchedWrite;
105 def WriteVICmpX : SchedWrite;
106 def WriteVICmpI : SchedWrite;
107 // 11.10. Vector Single-Width Integer Multiply Instructions
108 def WriteVIMulV : SchedWrite;
109 def WriteVIMulX : SchedWrite;
110 // 11.11. Vector Integer Divide Instructions
111 def WriteVIDivV : SchedWrite;
112 def WriteVIDivX : SchedWrite;
113 // 11.12. Vector Widening Integer Multiply Instructions
114 def WriteVIWMulV : SchedWrite;
115 def WriteVIWMulX : SchedWrite;
116 // 11.13. Vector Single-Width Integer Multiply-Add Instructions
117 def WriteVIMulAddV : SchedWrite;
118 def WriteVIMulAddX : SchedWrite;
119 // 11.14. Vector Widening Integer Multiply-Add Instructions
120 def WriteVIWMulAddV : SchedWrite;
121 def WriteVIWMulAddX : SchedWrite;
122 // 11.15. Vector Integer Merge Instructions
123 def WriteVIMergeV : SchedWrite;
124 def WriteVIMergeX : SchedWrite;
125 def WriteVIMergeI : SchedWrite;
126 // 11.16. Vector Integer Move Instructions
127 def WriteVIMovV : SchedWrite;
128 def WriteVIMovX : SchedWrite;
129 def WriteVIMovI : SchedWrite;
131 // 12. Vector Fixed-Point Arithmetic Instructions
132 // 12.1. Vector Single-Width Saturating Add and Subtract
133 def WriteVSALUV : SchedWrite;
134 def WriteVSALUX : SchedWrite;
135 def WriteVSALUI : SchedWrite;
136 // 12.2. Vector Single-Width Averaging Add and Subtract
137 def WriteVAALUV : SchedWrite;
138 def WriteVAALUX : SchedWrite;
139 // 12.3. Vector Single-Width Fractional Multiply with Rounding and Saturation
140 def WriteVSMulV : SchedWrite;
141 def WriteVSMulX : SchedWrite;
142 // 12.4. Vector Single-Width Scaling Shift Instructions
143 def WriteVSShiftV : SchedWrite;
144 def WriteVSShiftX : SchedWrite;
145 def WriteVSShiftI : SchedWrite;
146 // 12.5. Vector Narrowing Fixed-Point Clip Instructions
147 def WriteVNClipV : SchedWrite;
148 def WriteVNClipX : SchedWrite;
149 def WriteVNClipI : SchedWrite;
151 // 13. Vector Floating-Point Instructions
152 // 13.2. Vector Single-Width Floating-Point Add/Subtract Instructions
153 def WriteVFALUV : SchedWrite;
154 def WriteVFALUF : SchedWrite;
155 // 13.3. Vector Widening Floating-Point Add/Subtract Instructions
156 def WriteVFWALUV : SchedWrite;
157 def WriteVFWALUF : SchedWrite;
158 // 13.4. Vector Single-Width Floating-Point Multiply/Divide Instructions
159 def WriteVFMulV : SchedWrite;
160 def WriteVFMulF : SchedWrite;
161 def WriteVFDivV : SchedWrite;
162 def WriteVFDivF : SchedWrite;
163 // 13.5. Vector Widening Floating-Point Multiply
164 def WriteVFWMulV : SchedWrite;
165 def WriteVFWMulF : SchedWrite;
166 // 13.6. Vector Single-Width Floating-Point Fused Multiply-Add Instructions
167 def WriteVFMulAddV : SchedWrite;
168 def WriteVFMulAddF : SchedWrite;
169 // 13.7. Vector Widening Floating-Point Fused Multiply-Add Instructions
170 def WriteVFWMulAddV : SchedWrite;
171 def WriteVFWMulAddF : SchedWrite;
172 // 13.8. Vector Floating-Point Square-Root Instruction
173 def WriteVFSqrtV : SchedWrite;
174 // 13.9. Vector Floating-Point Reciprocal Square-Root Estimate Instruction
175 // 13.10. Vector Floating-Point Reciprocal Estimate Instruction
176 def WriteVFRecpV : SchedWrite;
177 // 13.11. Vector Floating-Point MIN/MAX Instructions
178 // 13.13. Vector Floating-Point Compare Instructions
179 def WriteVFCmpV : SchedWrite;
180 def WriteVFCmpF : SchedWrite;
181 // 13.12. Vector Floating-Point Sign-Injection Instructions
182 def WriteVFSgnjV : SchedWrite;
183 def WriteVFSgnjF : SchedWrite;
184 // 13.14. Vector Floating-Point Classify Instruction
185 def WriteVFClassV : SchedWrite;
186 // 13.15. Vector Floating-Point Merge Instruction
187 def WriteVFMergeV : SchedWrite;
188 // 13.16. Vector Floating-Point Move Instruction
189 def WriteVFMovV : SchedWrite;
190 // 13.17. Single-Width Floating-Point/Integer Type-Convert Instructions
191 def WriteVFCvtIToFV : SchedWrite;
192 def WriteVFCvtFToIV : SchedWrite;
193 def WriteVFCvtFToFV : SchedWrite;
194 // 13.18. Widening Floating-Point/Integer Type-Convert Instructions
195 def WriteVFWCvtIToFV : SchedWrite;
196 def WriteVFWCvtFToIV : SchedWrite;
197 def WriteVFWCvtFToFV : SchedWrite;
198 // 13.19. Narrowing Floating-Point/Integer Type-Convert Instructions
199 def WriteVFNCvtIToFV : SchedWrite;
200 def WriteVFNCvtFToIV : SchedWrite;
201 def WriteVFNCvtFToFV : SchedWrite;
203 // 14. Vector Reduction Operations
204 // 14.1. Vector Single-Width Integer Reduction Instructions
205 def WriteVIRedV : SchedWrite;
206 // 14.2. Vector Widening Integer Reduction Instructions
207 def WriteVIWRedV : SchedWrite;
208 // 14.3. Vector Single-Width Floating-Point Reduction Instructions
209 def WriteVFRedV : SchedWrite;
210 def WriteVFRedOV : SchedWrite;
211 // 14.4. Vector Widening Floating-Point Reduction Instructions
212 def WriteVFWRedV : SchedWrite;
213 def WriteVFWRedOV : SchedWrite;
215 // 15. Vector Mask Instructions
216 // 15.1. Vector Mask-Register Logical Instructions
217 def WriteVMALUV : SchedWrite;
218 // 15.2. Vector Mask Population Count
219 def WriteVMPopV : SchedWrite;
220 // 15.3. Vector Find-First-Set Mask Bit
221 def WriteVMFFSV : SchedWrite;
222 // 15.4. Vector Set-Before-First Mask Bit
223 // 15.5. Vector Set-Including-First Mask Bit
224 // 15.6. Vector Set-only-First Mask Bit
225 def WriteVMSFSV : SchedWrite;
226 // 15.8. Vector Iota Instruction
227 def WriteVMIotV : SchedWrite;
228 // 15.9. Vector Element Index Instruction
229 def WriteVMIdxV : SchedWrite;
231 // 16. Vector Permutation Instructions
232 // 16.1. Integer Scalar Move Instructions
233 def WriteVIMovVX : SchedWrite;
234 def WriteVIMovXV : SchedWrite;
235 // 16.2. Floating-Point Scalar Move Instructions
236 def WriteVFMovVF : SchedWrite;
237 def WriteVFMovFV : SchedWrite;
238 // 16.3. Vector Slide Instructions
239 def WriteVISlideX : SchedWrite;
240 def WriteVISlideI : SchedWrite;
241 def WriteVISlide1X : SchedWrite;
242 def WriteVFSlide1F : SchedWrite;
243 // 16.4. Vector Register Gather Instructions
244 def WriteVGatherV : SchedWrite;
245 def WriteVGatherX : SchedWrite;
246 def WriteVGatherI : SchedWrite;
247 // 16.5. Vector Compress Instruction
248 def WriteVCompressV : SchedWrite;
249 // 16.6. Whole Vector Register Move
250 def WriteVMov1V : SchedWrite;
251 def WriteVMov2V : SchedWrite;
252 def WriteVMov4V : SchedWrite;
253 def WriteVMov8V : SchedWrite;
255 //===----------------------------------------------------------------------===//
256 /// Define scheduler resources associated with use operands.
258 // 7. Vector Loads and Stores
259 def ReadVLDX : SchedRead;
260 def ReadVSTX : SchedRead;
261 // 7.4. Vector Unit-Stride Instructions
262 def ReadVSTE8V : SchedRead;
263 def ReadVSTE16V : SchedRead;
264 def ReadVSTE32V : SchedRead;
265 def ReadVSTE64V : SchedRead;
266 // 7.4.1. Vector Unit-Strided Mask
267 def ReadVSTM : SchedRead;
268 // 7.5. Vector Strided Instructions
269 def ReadVLDSX : SchedRead;
270 def ReadVSTSX : SchedRead;
271 def ReadVSTS8V : SchedRead;
272 def ReadVSTS16V : SchedRead;
273 def ReadVSTS32V : SchedRead;
274 def ReadVSTS64V : SchedRead;
275 // 7.6. Vector Indexed Instructions
276 def ReadVLDUXV : SchedRead;
277 def ReadVLDOXV : SchedRead;
278 def ReadVSTUX8 : SchedRead;
279 def ReadVSTUX16 : SchedRead;
280 def ReadVSTUX32 : SchedRead;
281 def ReadVSTUX64 : SchedRead;
282 def ReadVSTUXV : SchedRead;
283 def ReadVSTUX8V : SchedRead;
284 def ReadVSTUX16V : SchedRead;
285 def ReadVSTUX32V : SchedRead;
286 def ReadVSTUX64V : SchedRead;
287 def ReadVSTOX8 : SchedRead;
288 def ReadVSTOX16 : SchedRead;
289 def ReadVSTOX32 : SchedRead;
290 def ReadVSTOX64 : SchedRead;
291 def ReadVSTOXV : SchedRead;
292 def ReadVSTOX8V : SchedRead;
293 def ReadVSTOX16V : SchedRead;
294 def ReadVSTOX32V : SchedRead;
295 def ReadVSTOX64V : SchedRead;
296 // 7.9. Vector Whole Register Instructions
297 def ReadVST1R : SchedRead;
298 def ReadVST2R : SchedRead;
299 def ReadVST4R : SchedRead;
300 def ReadVST8R : SchedRead;
302 // 11. Vector Integer Arithmetic Instructions
303 // 11.1. Vector Single-Width Integer Add and Subtract
304 // 11.5. Vector Bitwise Logical Instructions
305 def ReadVIALUV : SchedRead;
306 def ReadVIALUX : SchedRead;
307 // 11.2. Vector Widening Integer Add/Subtract
308 def ReadVIWALUV : SchedRead;
309 def ReadVIWALUX : SchedRead;
310 // 11.3. Vector Integer Extension
311 def ReadVExtV : SchedRead;
312 // 11.4. Vector Integer Arithmetic with Carry or Borrow Instructions
313 def ReadVIALUCV : SchedRead;
314 def ReadVIALUCX : SchedRead;
315 // 11.6. Vector Single-Width Bit Shift Instructions
316 def ReadVShiftV : SchedRead;
317 def ReadVShiftX : SchedRead;
318 // 11.7. Vector Narrowing Integer Right Shift Instructions
319 def ReadVNShiftV : SchedRead;
320 def ReadVNShiftX : SchedRead;
321 // 11.8. Vector Integer Comparison Instructions
322 // 11.9. Vector Integer Min/Max Instructions
323 def ReadVICmpV : SchedRead;
324 def ReadVICmpX : SchedRead;
325 // 11.10. Vector Single-Width Integer Multiply Instructions
326 def ReadVIMulV : SchedRead;
327 def ReadVIMulX : SchedRead;
328 // 11.11. Vector Integer Divide Instructions
329 def ReadVIDivV : SchedRead;
330 def ReadVIDivX : SchedRead;
331 // 11.12. Vector Widening Integer Multiply Instructions
332 def ReadVIWMulV : SchedRead;
333 def ReadVIWMulX : SchedRead;
334 // 11.13. Vector Single-Width Integer Multiply-Add Instructions
335 def ReadVIMulAddV : SchedRead;
336 def ReadVIMulAddX : SchedRead;
337 // 11.14. Vector Widening Integer Multiply-Add Instructions
338 def ReadVIWMulAddV : SchedRead;
339 def ReadVIWMulAddX : SchedRead;
340 // 11.15. Vector Integer Merge Instructions
341 def ReadVIMergeV : SchedRead;
342 def ReadVIMergeX : SchedRead;
343 // 11.16. Vector Integer Move Instructions
344 def ReadVIMovV : SchedRead;
345 def ReadVIMovX : SchedRead;
347 // 12. Vector Fixed-Point Arithmetic Instructions
348 // 12.1. Vector Single-Width Saturating Add and Subtract
349 def ReadVSALUV : SchedRead;
350 def ReadVSALUX : SchedRead;
351 // 12.2. Vector Single-Width Averaging Add and Subtract
352 def ReadVAALUV : SchedRead;
353 def ReadVAALUX : SchedRead;
354 // 12.3. Vector Single-Width Fractional Multiply with Rounding and Saturation
355 def ReadVSMulV : SchedRead;
356 def ReadVSMulX : SchedRead;
357 // 12.4. Vector Single-Width Scaling Shift Instructions
358 def ReadVSShiftV : SchedRead;
359 def ReadVSShiftX : SchedRead;
360 // 12.5. Vector Narrowing Fixed-Point Clip Instructions
361 def ReadVNClipV : SchedRead;
362 def ReadVNClipX : SchedRead;
364 // 13. Vector Floating-Point Instructions
365 // 13.2. Vector Single-Width Floating-Point Add/Subtract Instructions
366 def ReadVFALUV : SchedRead;
367 def ReadVFALUF : SchedRead;
368 // 13.3. Vector Widening Floating-Point Add/Subtract Instructions
369 def ReadVFWALUV : SchedRead;
370 def ReadVFWALUF : SchedRead;
371 // 13.4. Vector Single-Width Floating-Point Multiply/Divide Instructions
372 def ReadVFMulV : SchedRead;
373 def ReadVFMulF : SchedRead;
374 def ReadVFDivV : SchedRead;
375 def ReadVFDivF : SchedRead;
376 // 13.5. Vector Widening Floating-Point Multiply
377 def ReadVFWMulV : SchedRead;
378 def ReadVFWMulF : SchedRead;
379 // 13.6. Vector Single-Width Floating-Point Fused Multiply-Add Instructions
380 def ReadVFMulAddV : SchedRead;
381 def ReadVFMulAddF : SchedRead;
382 // 13.7. Vector Widening Floating-Point Fused Multiply-Add Instructions
383 def ReadVFWMulAddV : SchedRead;
384 def ReadVFWMulAddF : SchedRead;
385 // 13.8. Vector Floating-Point Square-Root Instruction
386 def ReadVFSqrtV : SchedRead;
387 // 13.9. Vector Floating-Point Reciprocal Square-Root Estimate Instruction
388 // 13.10. Vector Floating-Point Reciprocal Estimate Instruction
389 def ReadVFRecpV : SchedRead;
390 // 13.11. Vector Floating-Point MIN/MAX Instructions
391 // 13.13. Vector Floating-Point Compare Instructions
392 def ReadVFCmpV : SchedRead;
393 def ReadVFCmpF : SchedRead;
394 // 13.12. Vector Floating-Point Sign-Injection Instructions
395 def ReadVFSgnjV : SchedRead;
396 def ReadVFSgnjF : SchedRead;
397 // 13.14. Vector Floating-Point Classify Instruction
398 def ReadVFClassV : SchedRead;
399 // 13.15. Vector Floating-Point Merge Instruction
400 def ReadVFMergeV : SchedRead;
401 def ReadVFMergeF : SchedRead;
402 // 13.16. Vector Floating-Point Move Instruction
403 def ReadVFMovF : SchedRead;
404 // 13.17. Single-Width Floating-Point/Integer Type-Convert Instructions
405 def ReadVFCvtIToFV : SchedRead;
406 def ReadVFCvtFToIV : SchedRead;
407 // 13.18. Widening Floating-Point/Integer Type-Convert Instructions
408 def ReadVFWCvtIToFV : SchedRead;
409 def ReadVFWCvtFToIV : SchedRead;
410 def ReadVFWCvtFToFV : SchedRead;
411 // 13.19. Narrowing Floating-Point/Integer Type-Convert Instructions
412 def ReadVFNCvtIToFV : SchedRead;
413 def ReadVFNCvtFToIV : SchedRead;
414 def ReadVFNCvtFToFV : SchedRead;
416 // 14. Vector Reduction Operations
417 // 14.1. Vector Single-Width Integer Reduction Instructions
418 def ReadVIRedV : SchedRead;
419 def ReadVIRedV0 : SchedRead;
420 // 14.2. Vector Widening Integer Reduction Instructions
421 def ReadVIWRedV : SchedRead;
422 def ReadVIWRedV0 : SchedRead;
423 // 14.3. Vector Single-Width Floating-Point Reduction Instructions
424 def ReadVFRedV : SchedRead;
425 def ReadVFRedV0 : SchedRead;
426 def ReadVFRedOV : SchedRead;
427 def ReadVFRedOV0 : SchedRead;
428 // 14.4. Vector Widening Floating-Point Reduction Instructions
429 def ReadVFWRedV : SchedRead;
430 def ReadVFWRedV0 : SchedRead;
431 def ReadVFWRedOV : SchedRead;
432 def ReadVFWRedOV0 : SchedRead;
434 // 15. Vector Mask Instructions
435 // 15.1. Vector Mask-Register Logical Instructions
436 def ReadVMALUV : SchedRead;
437 // 15.2. Vector Mask Population Count
438 def ReadVMPopV : SchedRead;
439 // 15.3. Vector Find-First-Set Mask Bit
440 def ReadVMFFSV : SchedRead;
441 // 15.4. Vector Set-Before-First Mask Bit
442 // 15.5. Vector Set-Including-First Mask Bit
443 // 15.6. Vector Set-only-First Mask Bit
444 def ReadVMSFSV : SchedRead;
445 // 15.8. Vector Iota Instruction
446 def ReadVMIotV : SchedRead;
448 // 16. Vector Permutation Instructions
449 // 16.1. Integer Scalar Move Instructions
450 def ReadVIMovVX : SchedRead;
451 def ReadVIMovXV : SchedRead;
452 def ReadVIMovXX : SchedRead;
453 // 16.2. Floating-Point Scalar Move Instructions
454 def ReadVFMovVF : SchedRead;
455 def ReadVFMovFV : SchedRead;
456 def ReadVFMovFX : SchedRead;
457 // 16.3. Vector Slide Instructions
458 def ReadVISlideV : SchedRead;
459 def ReadVISlideX : SchedRead;
460 def ReadVFSlideV : SchedRead;
461 def ReadVFSlideF : SchedRead;
462 // 16.4. Vector Register Gather Instructions
463 def ReadVGatherV : SchedRead;
464 def ReadVGatherX : SchedRead;
465 // 16.5. Vector Compress Instruction
466 def ReadVCompressV : SchedRead;
467 // 16.6. Whole Vector Register Move
468 def ReadVMov1V : SchedRead;
469 def ReadVMov2V : SchedRead;
470 def ReadVMov4V : SchedRead;
471 def ReadVMov8V : SchedRead;
473 // Others
474 def ReadVMask : SchedRead;
476 //===----------------------------------------------------------------------===//
477 /// Define default scheduler resources for V.
479 multiclass UnsupportedSchedV {
480 let Unsupported = true in {
482 // 7. Vector Loads and Stores
483 def : WriteRes<WriteVLDE8, []>;
484 def : WriteRes<WriteVLDE16, []>;
485 def : WriteRes<WriteVLDE32, []>;
486 def : WriteRes<WriteVLDE64, []>;
487 def : WriteRes<WriteVSTE8, []>;
488 def : WriteRes<WriteVSTE16, []>;
489 def : WriteRes<WriteVSTE32, []>;
490 def : WriteRes<WriteVSTE64, []>;
491 def : WriteRes<WriteVLDM, []>;
492 def : WriteRes<WriteVSTM, []>;
493 def : WriteRes<WriteVLDS8, []>;
494 def : WriteRes<WriteVLDS16, []>;
495 def : WriteRes<WriteVLDS32, []>;
496 def : WriteRes<WriteVLDS64, []>;
497 def : WriteRes<WriteVSTS8, []>;
498 def : WriteRes<WriteVSTS16, []>;
499 def : WriteRes<WriteVSTS32, []>;
500 def : WriteRes<WriteVSTS64, []>;
501 def : WriteRes<WriteVLDUX8, []>;
502 def : WriteRes<WriteVLDUX16, []>;
503 def : WriteRes<WriteVLDUX32, []>;
504 def : WriteRes<WriteVLDUX64, []>;
505 def : WriteRes<WriteVLDOX8, []>;
506 def : WriteRes<WriteVLDOX16, []>;
507 def : WriteRes<WriteVLDOX32, []>;
508 def : WriteRes<WriteVLDOX64, []>;
509 def : WriteRes<WriteVSTUX8, []>;
510 def : WriteRes<WriteVSTUX16, []>;
511 def : WriteRes<WriteVSTUX32, []>;
512 def : WriteRes<WriteVSTUX64, []>;
513 def : WriteRes<WriteVSTOX8, []>;
514 def : WriteRes<WriteVSTOX16, []>;
515 def : WriteRes<WriteVSTOX32, []>;
516 def : WriteRes<WriteVSTOX64, []>;
517 def : WriteRes<WriteVLDFF8, []>;
518 def : WriteRes<WriteVLDFF16, []>;
519 def : WriteRes<WriteVLDFF32, []>;
520 def : WriteRes<WriteVLDFF64, []>;
521 def : WriteRes<WriteVLD1R8, []>;
522 def : WriteRes<WriteVLD1R16, []>;
523 def : WriteRes<WriteVLD1R32, []>;
524 def : WriteRes<WriteVLD1R64, []>;
525 def : WriteRes<WriteVLD2R8, []>;
526 def : WriteRes<WriteVLD2R16, []>;
527 def : WriteRes<WriteVLD2R32, []>;
528 def : WriteRes<WriteVLD2R64, []>;
529 def : WriteRes<WriteVLD4R8, []>;
530 def : WriteRes<WriteVLD4R16, []>;
531 def : WriteRes<WriteVLD4R32, []>;
532 def : WriteRes<WriteVLD4R64, []>;
533 def : WriteRes<WriteVLD8R8, []>;
534 def : WriteRes<WriteVLD8R16, []>;
535 def : WriteRes<WriteVLD8R32, []>;
536 def : WriteRes<WriteVLD8R64, []>;
537 def : WriteRes<WriteVST1R, []>;
538 def : WriteRes<WriteVST2R, []>;
539 def : WriteRes<WriteVST4R, []>;
540 def : WriteRes<WriteVST8R, []>;
542 // 12. Vector Integer Arithmetic Instructions
543 def : WriteRes<WriteVIALUV, []>;
544 def : WriteRes<WriteVIALUX, []>;
545 def : WriteRes<WriteVIALUI, []>;
546 def : WriteRes<WriteVIWALUV, []>;
547 def : WriteRes<WriteVIWALUX, []>;
548 def : WriteRes<WriteVIWALUI, []>;
549 def : WriteRes<WriteVExtV, []>;
550 def : WriteRes<WriteVICALUV, []>;
551 def : WriteRes<WriteVICALUX, []>;
552 def : WriteRes<WriteVICALUI, []>;
553 def : WriteRes<WriteVShiftV, []>;
554 def : WriteRes<WriteVShiftX, []>;
555 def : WriteRes<WriteVShiftI, []>;
556 def : WriteRes<WriteVNShiftV, []>;
557 def : WriteRes<WriteVNShiftX, []>;
558 def : WriteRes<WriteVNShiftI, []>;
559 def : WriteRes<WriteVICmpV, []>;
560 def : WriteRes<WriteVICmpX, []>;
561 def : WriteRes<WriteVICmpI, []>;
562 def : WriteRes<WriteVIMulV, []>;
563 def : WriteRes<WriteVIMulX, []>;
564 def : WriteRes<WriteVIDivV, []>;
565 def : WriteRes<WriteVIDivX, []>;
566 def : WriteRes<WriteVIWMulV, []>;
567 def : WriteRes<WriteVIWMulX, []>;
568 def : WriteRes<WriteVIMulAddV, []>;
569 def : WriteRes<WriteVIMulAddX, []>;
570 def : WriteRes<WriteVIWMulAddV, []>;
571 def : WriteRes<WriteVIWMulAddX, []>;
572 def : WriteRes<WriteVIMergeV, []>;
573 def : WriteRes<WriteVIMergeX, []>;
574 def : WriteRes<WriteVIMergeI, []>;
575 def : WriteRes<WriteVIMovV, []>;
576 def : WriteRes<WriteVIMovX, []>;
577 def : WriteRes<WriteVIMovI, []>;
579 // 13. Vector Fixed-Point Arithmetic Instructions
580 def : WriteRes<WriteVSALUV, []>;
581 def : WriteRes<WriteVSALUX, []>;
582 def : WriteRes<WriteVSALUI, []>;
583 def : WriteRes<WriteVAALUV, []>;
584 def : WriteRes<WriteVAALUX, []>;
585 def : WriteRes<WriteVSMulV, []>;
586 def : WriteRes<WriteVSMulX, []>;
587 def : WriteRes<WriteVSShiftV, []>;
588 def : WriteRes<WriteVSShiftX, []>;
589 def : WriteRes<WriteVSShiftI, []>;
590 def : WriteRes<WriteVNClipV, []>;
591 def : WriteRes<WriteVNClipX, []>;
592 def : WriteRes<WriteVNClipI, []>;
594 // 14. Vector Floating-Point Instructions
595 def : WriteRes<WriteVFALUV, []>;
596 def : WriteRes<WriteVFALUF, []>;
597 def : WriteRes<WriteVFWALUV, []>;
598 def : WriteRes<WriteVFWALUF, []>;
599 def : WriteRes<WriteVFMulV, []>;
600 def : WriteRes<WriteVFMulF, []>;
601 def : WriteRes<WriteVFDivV, []>;
602 def : WriteRes<WriteVFDivF, []>;
603 def : WriteRes<WriteVFWMulV, []>;
604 def : WriteRes<WriteVFWMulF, []>;
605 def : WriteRes<WriteVFMulAddV, []>;
606 def : WriteRes<WriteVFMulAddF, []>;
607 def : WriteRes<WriteVFWMulAddV, []>;
608 def : WriteRes<WriteVFWMulAddF, []>;
609 def : WriteRes<WriteVFSqrtV, []>;
610 def : WriteRes<WriteVFRecpV, []>;
611 def : WriteRes<WriteVFCmpV, []>;
612 def : WriteRes<WriteVFCmpF, []>;
613 def : WriteRes<WriteVFSgnjV, []>;
614 def : WriteRes<WriteVFSgnjF, []>;
615 def : WriteRes<WriteVFClassV, []>;
616 def : WriteRes<WriteVFMergeV, []>;
617 def : WriteRes<WriteVFMovV, []>;
618 def : WriteRes<WriteVFCvtIToFV, []>;
619 def : WriteRes<WriteVFCvtFToIV, []>;
620 def : WriteRes<WriteVFCvtFToFV, []>;
621 def : WriteRes<WriteVFWCvtIToFV, []>;
622 def : WriteRes<WriteVFWCvtFToIV, []>;
623 def : WriteRes<WriteVFWCvtFToFV, []>;
624 def : WriteRes<WriteVFNCvtIToFV, []>;
625 def : WriteRes<WriteVFNCvtFToIV, []>;
626 def : WriteRes<WriteVFNCvtFToFV, []>;
628 // 15. Vector Reduction Operations
629 def : WriteRes<WriteVIRedV, []>;
630 def : WriteRes<WriteVIWRedV, []>;
631 def : WriteRes<WriteVFRedV, []>;
632 def : WriteRes<WriteVFRedOV, []>;
633 def : WriteRes<WriteVFWRedV, []>;
634 def : WriteRes<WriteVFWRedOV, []>;
636 // 16. Vector Mask Instructions
637 def : WriteRes<WriteVMALUV, []>;
638 def : WriteRes<WriteVMPopV, []>;
639 def : WriteRes<WriteVMFFSV, []>;
640 def : WriteRes<WriteVMSFSV, []>;
641 def : WriteRes<WriteVMIotV, []>;
642 def : WriteRes<WriteVMIdxV, []>;
644 // 17. Vector Permutation Instructions
645 def : WriteRes<WriteVIMovVX, []>;
646 def : WriteRes<WriteVIMovXV, []>;
647 def : WriteRes<WriteVFMovVF, []>;
648 def : WriteRes<WriteVFMovFV, []>;
649 def : WriteRes<WriteVISlideX, []>;
650 def : WriteRes<WriteVISlideI, []>;
651 def : WriteRes<WriteVISlide1X, []>;
652 def : WriteRes<WriteVFSlide1F, []>;
653 def : WriteRes<WriteVGatherV, []>;
654 def : WriteRes<WriteVGatherX, []>;
655 def : WriteRes<WriteVGatherI, []>;
656 def : WriteRes<WriteVCompressV, []>;
657 def : WriteRes<WriteVMov1V, []>;
658 def : WriteRes<WriteVMov2V, []>;
659 def : WriteRes<WriteVMov4V, []>;
660 def : WriteRes<WriteVMov8V, []>;
662 // 7. Vector Loads and Stores
663 def : ReadAdvance<ReadVLDX, 0>;
664 def : ReadAdvance<ReadVSTX, 0>;
665 def : ReadAdvance<ReadVSTE8V, 0>;
666 def : ReadAdvance<ReadVSTE16V, 0>;
667 def : ReadAdvance<ReadVSTE32V, 0>;
668 def : ReadAdvance<ReadVSTE64V, 0>;
669 def : ReadAdvance<ReadVSTM, 0>;
670 def : ReadAdvance<ReadVLDSX, 0>;
671 def : ReadAdvance<ReadVSTSX, 0>;
672 def : ReadAdvance<ReadVSTS8V, 0>;
673 def : ReadAdvance<ReadVSTS16V, 0>;
674 def : ReadAdvance<ReadVSTS32V, 0>;
675 def : ReadAdvance<ReadVSTS64V, 0>;
676 def : ReadAdvance<ReadVLDUXV, 0>;
677 def : ReadAdvance<ReadVLDOXV, 0>;
678 def : ReadAdvance<ReadVSTUXV, 0>;
679 def : ReadAdvance<ReadVSTUX8, 0>;
680 def : ReadAdvance<ReadVSTUX16, 0>;
681 def : ReadAdvance<ReadVSTUX32, 0>;
682 def : ReadAdvance<ReadVSTUX64, 0>;
683 def : ReadAdvance<ReadVSTUX8V, 0>;
684 def : ReadAdvance<ReadVSTUX16V, 0>;
685 def : ReadAdvance<ReadVSTUX32V, 0>;
686 def : ReadAdvance<ReadVSTUX64V, 0>;
687 def : ReadAdvance<ReadVSTOX8, 0>;
688 def : ReadAdvance<ReadVSTOX16, 0>;
689 def : ReadAdvance<ReadVSTOX32, 0>;
690 def : ReadAdvance<ReadVSTOX64, 0>;
691 def : ReadAdvance<ReadVSTOXV, 0>;
692 def : ReadAdvance<ReadVSTOX8V, 0>;
693 def : ReadAdvance<ReadVSTOX16V, 0>;
694 def : ReadAdvance<ReadVSTOX32V, 0>;
695 def : ReadAdvance<ReadVSTOX64V, 0>;
696 def : ReadAdvance<ReadVST1R, 0>;
697 def : ReadAdvance<ReadVST2R, 0>;
698 def : ReadAdvance<ReadVST4R, 0>;
699 def : ReadAdvance<ReadVST8R, 0>;
701 // 12. Vector Integer Arithmetic Instructions
702 def : ReadAdvance<ReadVIALUV, 0>;
703 def : ReadAdvance<ReadVIALUX, 0>;
704 def : ReadAdvance<ReadVIWALUV, 0>;
705 def : ReadAdvance<ReadVIWALUX, 0>;
706 def : ReadAdvance<ReadVExtV, 0>;
707 def : ReadAdvance<ReadVIALUCV, 0>;
708 def : ReadAdvance<ReadVIALUCX, 0>;
709 def : ReadAdvance<ReadVShiftV, 0>;
710 def : ReadAdvance<ReadVShiftX, 0>;
711 def : ReadAdvance<ReadVNShiftV, 0>;
712 def : ReadAdvance<ReadVNShiftX, 0>;
713 def : ReadAdvance<ReadVICmpV, 0>;
714 def : ReadAdvance<ReadVICmpX, 0>;
715 def : ReadAdvance<ReadVIMulV, 0>;
716 def : ReadAdvance<ReadVIMulX, 0>;
717 def : ReadAdvance<ReadVIDivV, 0>;
718 def : ReadAdvance<ReadVIDivX, 0>;
719 def : ReadAdvance<ReadVIWMulV, 0>;
720 def : ReadAdvance<ReadVIWMulX, 0>;
721 def : ReadAdvance<ReadVIMulAddV, 0>;
722 def : ReadAdvance<ReadVIMulAddX, 0>;
723 def : ReadAdvance<ReadVIWMulAddV, 0>;
724 def : ReadAdvance<ReadVIWMulAddX, 0>;
725 def : ReadAdvance<ReadVIMergeV, 0>;
726 def : ReadAdvance<ReadVIMergeX, 0>;
727 def : ReadAdvance<ReadVIMovV, 0>;
728 def : ReadAdvance<ReadVIMovX, 0>;
730 // 13. Vector Fixed-Point Arithmetic Instructions
731 def : ReadAdvance<ReadVSALUV, 0>;
732 def : ReadAdvance<ReadVSALUX, 0>;
733 def : ReadAdvance<ReadVAALUV, 0>;
734 def : ReadAdvance<ReadVAALUX, 0>;
735 def : ReadAdvance<ReadVSMulV, 0>;
736 def : ReadAdvance<ReadVSMulX, 0>;
737 def : ReadAdvance<ReadVSShiftV, 0>;
738 def : ReadAdvance<ReadVSShiftX, 0>;
739 def : ReadAdvance<ReadVNClipV, 0>;
740 def : ReadAdvance<ReadVNClipX, 0>;
742 // 14. Vector Floating-Point Instructions
743 def : ReadAdvance<ReadVFALUV, 0>;
744 def : ReadAdvance<ReadVFALUF, 0>;
745 def : ReadAdvance<ReadVFWALUV, 0>;
746 def : ReadAdvance<ReadVFWALUF, 0>;
747 def : ReadAdvance<ReadVFMulV, 0>;
748 def : ReadAdvance<ReadVFMulF, 0>;
749 def : ReadAdvance<ReadVFDivV, 0>;
750 def : ReadAdvance<ReadVFDivF, 0>;
751 def : ReadAdvance<ReadVFWMulV, 0>;
752 def : ReadAdvance<ReadVFWMulF, 0>;
753 def : ReadAdvance<ReadVFMulAddV, 0>;
754 def : ReadAdvance<ReadVFMulAddF, 0>;
755 def : ReadAdvance<ReadVFWMulAddV, 0>;
756 def : ReadAdvance<ReadVFWMulAddF, 0>;
757 def : ReadAdvance<ReadVFSqrtV, 0>;
758 def : ReadAdvance<ReadVFRecpV, 0>;
759 def : ReadAdvance<ReadVFCmpV, 0>;
760 def : ReadAdvance<ReadVFCmpF, 0>;
761 def : ReadAdvance<ReadVFSgnjV, 0>;
762 def : ReadAdvance<ReadVFSgnjF, 0>;
763 def : ReadAdvance<ReadVFClassV, 0>;
764 def : ReadAdvance<ReadVFMergeV, 0>;
765 def : ReadAdvance<ReadVFMergeF, 0>;
766 def : ReadAdvance<ReadVFMovF, 0>;
767 def : ReadAdvance<ReadVFCvtIToFV, 0>;
768 def : ReadAdvance<ReadVFCvtFToIV, 0>;
769 def : ReadAdvance<ReadVFWCvtIToFV, 0>;
770 def : ReadAdvance<ReadVFWCvtFToIV, 0>;
771 def : ReadAdvance<ReadVFWCvtFToFV, 0>;
772 def : ReadAdvance<ReadVFNCvtIToFV, 0>;
773 def : ReadAdvance<ReadVFNCvtFToIV, 0>;
774 def : ReadAdvance<ReadVFNCvtFToFV, 0>;
776 // 15. Vector Reduction Operations
777 def : ReadAdvance<ReadVIRedV, 0>;
778 def : ReadAdvance<ReadVIRedV0, 0>;
779 def : ReadAdvance<ReadVIWRedV, 0>;
780 def : ReadAdvance<ReadVIWRedV0, 0>;
781 def : ReadAdvance<ReadVFRedV, 0>;
782 def : ReadAdvance<ReadVFRedV0, 0>;
783 def : ReadAdvance<ReadVFRedOV, 0>;
784 def : ReadAdvance<ReadVFRedOV0, 0>;
785 def : ReadAdvance<ReadVFWRedV, 0>;
786 def : ReadAdvance<ReadVFWRedV0, 0>;
787 def : ReadAdvance<ReadVFWRedOV, 0>;
788 def : ReadAdvance<ReadVFWRedOV0, 0>;
790 // 16. Vector Mask Instructions
791 def : ReadAdvance<ReadVMALUV, 0>;
792 def : ReadAdvance<ReadVMPopV, 0>;
793 def : ReadAdvance<ReadVMFFSV, 0>;
794 def : ReadAdvance<ReadVMSFSV, 0>;
795 def : ReadAdvance<ReadVMIotV, 0>;
797 // 17. Vector Permutation Instructions
798 def : ReadAdvance<ReadVIMovVX, 0>;
799 def : ReadAdvance<ReadVIMovXV, 0>;
800 def : ReadAdvance<ReadVIMovXX, 0>;
801 def : ReadAdvance<ReadVFMovVF, 0>;
802 def : ReadAdvance<ReadVFMovFV, 0>;
803 def : ReadAdvance<ReadVFMovFX, 0>;
804 def : ReadAdvance<ReadVISlideV, 0>;
805 def : ReadAdvance<ReadVISlideX, 0>;
806 def : ReadAdvance<ReadVFSlideV, 0>;
807 def : ReadAdvance<ReadVFSlideF, 0>;
808 def : ReadAdvance<ReadVGatherV, 0>;
809 def : ReadAdvance<ReadVGatherX, 0>;
810 def : ReadAdvance<ReadVCompressV, 0>;
811 def : ReadAdvance<ReadVMov1V, 0>;
812 def : ReadAdvance<ReadVMov2V, 0>;
813 def : ReadAdvance<ReadVMov4V, 0>;
814 def : ReadAdvance<ReadVMov8V, 0>;
816 // Others
817 def : ReadAdvance<ReadVMask, 0>;
819 } // Unsupported
820 } // UnsupportedSchedV