mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-11-22 02:33:06 +01:00
0c8a79e78d
Add the scheduling resources for the V extension instructions. Differential Revision: https://reviews.llvm.org/D98002 (cherry picked from commit 63a5ac4e0d969f41bf71785cc3979349a45a2892)
821 lines
29 KiB
TableGen
821 lines
29 KiB
TableGen
//===-- 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.
|
|
|
|
// 7. Vector Loads and Stores
|
|
// 7.4. Vector Unit-Stride Instructions
|
|
def WriteVLDE8 : SchedWrite;
|
|
def WriteVLDE16 : SchedWrite;
|
|
def WriteVLDE32 : SchedWrite;
|
|
def WriteVLDE64 : SchedWrite;
|
|
def WriteVSTE8 : SchedWrite;
|
|
def WriteVSTE16 : SchedWrite;
|
|
def WriteVSTE32 : SchedWrite;
|
|
def WriteVSTE64 : SchedWrite;
|
|
// 7.4.1. Vector Unit-Strided Mask
|
|
def WriteVLDM : SchedWrite;
|
|
def WriteVSTM : SchedWrite;
|
|
// 7.5. Vector Strided Instructions
|
|
def WriteVLDS8 : SchedWrite;
|
|
def WriteVLDS16 : SchedWrite;
|
|
def WriteVLDS32 : SchedWrite;
|
|
def WriteVLDS64 : SchedWrite;
|
|
def WriteVSTS8 : SchedWrite;
|
|
def WriteVSTS16 : SchedWrite;
|
|
def WriteVSTS32 : SchedWrite;
|
|
def WriteVSTS64 : SchedWrite;
|
|
// 7.6. Vector Indexed Instructions
|
|
def WriteVLDUX8 : SchedWrite;
|
|
def WriteVLDUX16 : SchedWrite;
|
|
def WriteVLDUX32 : SchedWrite;
|
|
def WriteVLDUX64 : SchedWrite;
|
|
def WriteVLDOX8 : SchedWrite;
|
|
def WriteVLDOX16 : SchedWrite;
|
|
def WriteVLDOX32 : SchedWrite;
|
|
def WriteVLDOX64 : SchedWrite;
|
|
def WriteVSTUX8 : SchedWrite;
|
|
def WriteVSTUX16 : SchedWrite;
|
|
def WriteVSTUX32 : SchedWrite;
|
|
def WriteVSTUX64 : SchedWrite;
|
|
def WriteVSTOX8 : SchedWrite;
|
|
def WriteVSTOX16 : SchedWrite;
|
|
def WriteVSTOX32 : SchedWrite;
|
|
def WriteVSTOX64 : SchedWrite;
|
|
// 7.7. Vector Unit-stride Fault-Only-First Loads
|
|
def WriteVLDFF8 : SchedWrite;
|
|
def WriteVLDFF16 : SchedWrite;
|
|
def WriteVLDFF32 : SchedWrite;
|
|
def WriteVLDFF64 : SchedWrite;
|
|
// 7.9. Vector Whole Register Instructions
|
|
def WriteVLD1R8 : SchedWrite;
|
|
def WriteVLD1R16 : SchedWrite;
|
|
def WriteVLD1R32 : SchedWrite;
|
|
def WriteVLD1R64 : SchedWrite;
|
|
def WriteVLD2R8 : SchedWrite;
|
|
def WriteVLD2R16 : SchedWrite;
|
|
def WriteVLD2R32 : SchedWrite;
|
|
def WriteVLD2R64 : SchedWrite;
|
|
def WriteVLD4R8 : SchedWrite;
|
|
def WriteVLD4R16 : SchedWrite;
|
|
def WriteVLD4R32 : SchedWrite;
|
|
def WriteVLD4R64 : SchedWrite;
|
|
def WriteVLD8R8 : SchedWrite;
|
|
def WriteVLD8R16 : SchedWrite;
|
|
def WriteVLD8R32 : SchedWrite;
|
|
def WriteVLD8R64 : SchedWrite;
|
|
def WriteVST1R : SchedWrite;
|
|
def WriteVST2R : SchedWrite;
|
|
def WriteVST4R : SchedWrite;
|
|
def WriteVST8R : SchedWrite;
|
|
|
|
// 11. Vector Integer Arithmetic Instructions
|
|
// 11.1. Vector Single-Width Integer Add and Subtract
|
|
// 11.5. Vector Bitwise Logical Instructions
|
|
def WriteVIALUV : SchedWrite;
|
|
def WriteVIALUX : SchedWrite;
|
|
def WriteVIALUI : SchedWrite;
|
|
// 11.2. Vector Widening Integer Add/Subtract
|
|
def WriteVIWALUV : SchedWrite;
|
|
def WriteVIWALUX : SchedWrite;
|
|
def WriteVIWALUI : SchedWrite;
|
|
// 11.3. Vector Integer Extension
|
|
def WriteVExtV : SchedWrite;
|
|
// 11.4. Vector Integer Arithmetic with Carry or Borrow Instructions
|
|
def WriteVICALUV : SchedWrite;
|
|
def WriteVICALUX : SchedWrite;
|
|
def WriteVICALUI : SchedWrite;
|
|
// 11.6. Vector Single-Width Bit Shift Instructions
|
|
def WriteVShiftV : SchedWrite;
|
|
def WriteVShiftX : SchedWrite;
|
|
def WriteVShiftI : SchedWrite;
|
|
// 11.7. Vector Narrowing Integer Right Shift Instructions
|
|
def WriteVNShiftV : SchedWrite;
|
|
def WriteVNShiftX : SchedWrite;
|
|
def WriteVNShiftI : SchedWrite;
|
|
// 11.8. Vector Integer Comparison Instructions
|
|
// 11.9. Vector Integer Min/Max Instructions
|
|
def WriteVICmpV : SchedWrite;
|
|
def WriteVICmpX : SchedWrite;
|
|
def WriteVICmpI : SchedWrite;
|
|
// 11.10. Vector Single-Width Integer Multiply Instructions
|
|
def WriteVIMulV : SchedWrite;
|
|
def WriteVIMulX : SchedWrite;
|
|
// 11.11. Vector Integer Divide Instructions
|
|
def WriteVIDivV : SchedWrite;
|
|
def WriteVIDivX : SchedWrite;
|
|
// 11.12. Vector Widening Integer Multiply Instructions
|
|
def WriteVIWMulV : SchedWrite;
|
|
def WriteVIWMulX : SchedWrite;
|
|
// 11.13. Vector Single-Width Integer Multiply-Add Instructions
|
|
def WriteVIMulAddV : SchedWrite;
|
|
def WriteVIMulAddX : SchedWrite;
|
|
// 11.14. Vector Widening Integer Multiply-Add Instructions
|
|
def WriteVIWMulAddV : SchedWrite;
|
|
def WriteVIWMulAddX : SchedWrite;
|
|
// 11.15. Vector Integer Merge Instructions
|
|
def WriteVIMergeV : SchedWrite;
|
|
def WriteVIMergeX : SchedWrite;
|
|
def WriteVIMergeI : SchedWrite;
|
|
// 11.16. Vector Integer Move Instructions
|
|
def WriteVIMovV : SchedWrite;
|
|
def WriteVIMovX : SchedWrite;
|
|
def WriteVIMovI : SchedWrite;
|
|
|
|
// 12. Vector Fixed-Point Arithmetic Instructions
|
|
// 12.1. Vector Single-Width Saturating Add and Subtract
|
|
def WriteVSALUV : SchedWrite;
|
|
def WriteVSALUX : SchedWrite;
|
|
def WriteVSALUI : SchedWrite;
|
|
// 12.2. Vector Single-Width Averaging Add and Subtract
|
|
def WriteVAALUV : SchedWrite;
|
|
def WriteVAALUX : SchedWrite;
|
|
// 12.3. Vector Single-Width Fractional Multiply with Rounding and Saturation
|
|
def WriteVSMulV : SchedWrite;
|
|
def WriteVSMulX : SchedWrite;
|
|
// 12.4. Vector Single-Width Scaling Shift Instructions
|
|
def WriteVSShiftV : SchedWrite;
|
|
def WriteVSShiftX : SchedWrite;
|
|
def WriteVSShiftI : SchedWrite;
|
|
// 12.5. Vector Narrowing Fixed-Point Clip Instructions
|
|
def WriteVNClipV : SchedWrite;
|
|
def WriteVNClipX : SchedWrite;
|
|
def WriteVNClipI : SchedWrite;
|
|
|
|
// 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;
|
|
// 13.4. Vector Single-Width Floating-Point Multiply/Divide Instructions
|
|
def WriteVFMulV : SchedWrite;
|
|
def WriteVFMulF : SchedWrite;
|
|
def WriteVFDivV : SchedWrite;
|
|
def WriteVFDivF : SchedWrite;
|
|
// 13.5. Vector Widening Floating-Point Multiply
|
|
def WriteVFWMulV : SchedWrite;
|
|
def WriteVFWMulF : SchedWrite;
|
|
// 13.6. Vector Single-Width Floating-Point Fused Multiply-Add Instructions
|
|
def WriteVFMulAddV : SchedWrite;
|
|
def WriteVFMulAddF : SchedWrite;
|
|
// 13.7. Vector Widening Floating-Point Fused Multiply-Add Instructions
|
|
def WriteVFWMulAddV : SchedWrite;
|
|
def WriteVFWMulAddF : SchedWrite;
|
|
// 13.8. Vector Floating-Point Square-Root Instruction
|
|
def WriteVFSqrtV : SchedWrite;
|
|
// 13.9. Vector Floating-Point Reciprocal Square-Root Estimate Instruction
|
|
// 13.10. Vector Floating-Point Reciprocal Estimate Instruction
|
|
def WriteVFRecpV : SchedWrite;
|
|
// 13.11. Vector Floating-Point MIN/MAX Instructions
|
|
// 13.13. Vector Floating-Point Compare Instructions
|
|
def WriteVFCmpV : SchedWrite;
|
|
def WriteVFCmpF : SchedWrite;
|
|
// 13.12. Vector Floating-Point Sign-Injection Instructions
|
|
def WriteVFSgnjV : SchedWrite;
|
|
def WriteVFSgnjF : SchedWrite;
|
|
// 13.14. Vector Floating-Point Classify Instruction
|
|
def WriteVFClassV : SchedWrite;
|
|
// 13.15. Vector Floating-Point Merge Instruction
|
|
def WriteVFMergeV : SchedWrite;
|
|
// 13.16. Vector Floating-Point Move Instruction
|
|
def WriteVFMovV : SchedWrite;
|
|
// 13.17. Single-Width Floating-Point/Integer Type-Convert Instructions
|
|
def WriteVFCvtIToFV : SchedWrite;
|
|
def WriteVFCvtFToIV : SchedWrite;
|
|
def WriteVFCvtFToFV : SchedWrite;
|
|
// 13.18. Widening Floating-Point/Integer Type-Convert Instructions
|
|
def WriteVFWCvtIToFV : SchedWrite;
|
|
def WriteVFWCvtFToIV : SchedWrite;
|
|
def WriteVFWCvtFToFV : SchedWrite;
|
|
// 13.19. Narrowing Floating-Point/Integer Type-Convert Instructions
|
|
def WriteVFNCvtIToFV : SchedWrite;
|
|
def WriteVFNCvtFToIV : SchedWrite;
|
|
def WriteVFNCvtFToFV : SchedWrite;
|
|
|
|
// 14. Vector Reduction Operations
|
|
// 14.1. Vector Single-Width Integer Reduction Instructions
|
|
def WriteVIRedV : SchedWrite;
|
|
// 14.2. Vector Widening Integer Reduction Instructions
|
|
def WriteVIWRedV : SchedWrite;
|
|
// 14.3. Vector Single-Width Floating-Point Reduction Instructions
|
|
def WriteVFRedV : SchedWrite;
|
|
def WriteVFRedOV : SchedWrite;
|
|
// 14.4. Vector Widening Floating-Point Reduction Instructions
|
|
def WriteVFWRedV : SchedWrite;
|
|
def WriteVFWRedOV : SchedWrite;
|
|
|
|
// 15. Vector Mask Instructions
|
|
// 15.1. Vector Mask-Register Logical Instructions
|
|
def WriteVMALUV : SchedWrite;
|
|
// 15.2. Vector Mask Population Count
|
|
def WriteVMPopV : SchedWrite;
|
|
// 15.3. Vector Find-First-Set Mask Bit
|
|
def WriteVMFFSV : SchedWrite;
|
|
// 15.4. Vector Set-Before-First Mask Bit
|
|
// 15.5. Vector Set-Including-First Mask Bit
|
|
// 15.6. Vector Set-only-First Mask Bit
|
|
def WriteVMSFSV : SchedWrite;
|
|
// 15.8. Vector Iota Instruction
|
|
def WriteVMIotV : SchedWrite;
|
|
// 15.9. Vector Element Index Instruction
|
|
def WriteVMIdxV : SchedWrite;
|
|
|
|
// 16. Vector Permutation Instructions
|
|
// 16.1. Integer Scalar Move Instructions
|
|
def WriteVIMovVX : SchedWrite;
|
|
def WriteVIMovXV : SchedWrite;
|
|
// 16.2. Floating-Point Scalar Move Instructions
|
|
def WriteVFMovVF : SchedWrite;
|
|
def WriteVFMovFV : SchedWrite;
|
|
// 16.3. Vector Slide Instructions
|
|
def WriteVISlideX : SchedWrite;
|
|
def WriteVISlideI : SchedWrite;
|
|
def WriteVISlide1X : SchedWrite;
|
|
def WriteVFSlide1F : SchedWrite;
|
|
// 16.4. Vector Register Gather Instructions
|
|
def WriteVGatherV : SchedWrite;
|
|
def WriteVGatherX : SchedWrite;
|
|
def WriteVGatherI : SchedWrite;
|
|
// 16.5. Vector Compress Instruction
|
|
def WriteVCompressV : SchedWrite;
|
|
// 16.6. Whole Vector Register Move
|
|
def WriteVMov1V : SchedWrite;
|
|
def WriteVMov2V : SchedWrite;
|
|
def WriteVMov4V : SchedWrite;
|
|
def WriteVMov8V : SchedWrite;
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
/// Define scheduler resources associated with use operands.
|
|
|
|
// 7. Vector Loads and Stores
|
|
def ReadVLDX : SchedRead;
|
|
def ReadVSTX : SchedRead;
|
|
// 7.4. Vector Unit-Stride Instructions
|
|
def ReadVSTE8V : SchedRead;
|
|
def ReadVSTE16V : SchedRead;
|
|
def ReadVSTE32V : SchedRead;
|
|
def ReadVSTE64V : SchedRead;
|
|
// 7.4.1. Vector Unit-Strided Mask
|
|
def ReadVSTM : SchedRead;
|
|
// 7.5. Vector Strided Instructions
|
|
def ReadVLDSX : SchedRead;
|
|
def ReadVSTSX : SchedRead;
|
|
def ReadVSTS8V : SchedRead;
|
|
def ReadVSTS16V : SchedRead;
|
|
def ReadVSTS32V : SchedRead;
|
|
def ReadVSTS64V : SchedRead;
|
|
// 7.6. Vector Indexed Instructions
|
|
def ReadVLDUXV : SchedRead;
|
|
def ReadVLDOXV : SchedRead;
|
|
def ReadVSTUX8 : SchedRead;
|
|
def ReadVSTUX16 : SchedRead;
|
|
def ReadVSTUX32 : SchedRead;
|
|
def ReadVSTUX64 : SchedRead;
|
|
def ReadVSTUXV : SchedRead;
|
|
def ReadVSTUX8V : SchedRead;
|
|
def ReadVSTUX16V : SchedRead;
|
|
def ReadVSTUX32V : SchedRead;
|
|
def ReadVSTUX64V : SchedRead;
|
|
def ReadVSTOX8 : SchedRead;
|
|
def ReadVSTOX16 : SchedRead;
|
|
def ReadVSTOX32 : SchedRead;
|
|
def ReadVSTOX64 : SchedRead;
|
|
def ReadVSTOXV : SchedRead;
|
|
def ReadVSTOX8V : SchedRead;
|
|
def ReadVSTOX16V : SchedRead;
|
|
def ReadVSTOX32V : SchedRead;
|
|
def ReadVSTOX64V : SchedRead;
|
|
// 7.9. Vector Whole Register Instructions
|
|
def ReadVST1R : SchedRead;
|
|
def ReadVST2R : SchedRead;
|
|
def ReadVST4R : SchedRead;
|
|
def ReadVST8R : SchedRead;
|
|
|
|
// 11. Vector Integer Arithmetic Instructions
|
|
// 11.1. Vector Single-Width Integer Add and Subtract
|
|
// 11.5. Vector Bitwise Logical Instructions
|
|
def ReadVIALUV : SchedRead;
|
|
def ReadVIALUX : SchedRead;
|
|
// 11.2. Vector Widening Integer Add/Subtract
|
|
def ReadVIWALUV : SchedRead;
|
|
def ReadVIWALUX : SchedRead;
|
|
// 11.3. Vector Integer Extension
|
|
def ReadVExtV : SchedRead;
|
|
// 11.4. Vector Integer Arithmetic with Carry or Borrow Instructions
|
|
def ReadVIALUCV : SchedRead;
|
|
def ReadVIALUCX : SchedRead;
|
|
// 11.6. Vector Single-Width Bit Shift Instructions
|
|
def ReadVShiftV : SchedRead;
|
|
def ReadVShiftX : SchedRead;
|
|
// 11.7. Vector Narrowing Integer Right Shift Instructions
|
|
def ReadVNShiftV : SchedRead;
|
|
def ReadVNShiftX : SchedRead;
|
|
// 11.8. Vector Integer Comparison Instructions
|
|
// 11.9. Vector Integer Min/Max Instructions
|
|
def ReadVICmpV : SchedRead;
|
|
def ReadVICmpX : SchedRead;
|
|
// 11.10. Vector Single-Width Integer Multiply Instructions
|
|
def ReadVIMulV : SchedRead;
|
|
def ReadVIMulX : SchedRead;
|
|
// 11.11. Vector Integer Divide Instructions
|
|
def ReadVIDivV : SchedRead;
|
|
def ReadVIDivX : SchedRead;
|
|
// 11.12. Vector Widening Integer Multiply Instructions
|
|
def ReadVIWMulV : SchedRead;
|
|
def ReadVIWMulX : SchedRead;
|
|
// 11.13. Vector Single-Width Integer Multiply-Add Instructions
|
|
def ReadVIMulAddV : SchedRead;
|
|
def ReadVIMulAddX : SchedRead;
|
|
// 11.14. Vector Widening Integer Multiply-Add Instructions
|
|
def ReadVIWMulAddV : SchedRead;
|
|
def ReadVIWMulAddX : SchedRead;
|
|
// 11.15. Vector Integer Merge Instructions
|
|
def ReadVIMergeV : SchedRead;
|
|
def ReadVIMergeX : SchedRead;
|
|
// 11.16. Vector Integer Move Instructions
|
|
def ReadVIMovV : SchedRead;
|
|
def ReadVIMovX : SchedRead;
|
|
|
|
// 12. Vector Fixed-Point Arithmetic Instructions
|
|
// 12.1. Vector Single-Width Saturating Add and Subtract
|
|
def ReadVSALUV : SchedRead;
|
|
def ReadVSALUX : SchedRead;
|
|
// 12.2. Vector Single-Width Averaging Add and Subtract
|
|
def ReadVAALUV : SchedRead;
|
|
def ReadVAALUX : SchedRead;
|
|
// 12.3. Vector Single-Width Fractional Multiply with Rounding and Saturation
|
|
def ReadVSMulV : SchedRead;
|
|
def ReadVSMulX : SchedRead;
|
|
// 12.4. Vector Single-Width Scaling Shift Instructions
|
|
def ReadVSShiftV : SchedRead;
|
|
def ReadVSShiftX : SchedRead;
|
|
// 12.5. Vector Narrowing Fixed-Point Clip Instructions
|
|
def ReadVNClipV : SchedRead;
|
|
def ReadVNClipX : SchedRead;
|
|
|
|
// 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;
|
|
// 13.4. Vector Single-Width Floating-Point Multiply/Divide Instructions
|
|
def ReadVFMulV : SchedRead;
|
|
def ReadVFMulF : SchedRead;
|
|
def ReadVFDivV : SchedRead;
|
|
def ReadVFDivF : SchedRead;
|
|
// 13.5. Vector Widening Floating-Point Multiply
|
|
def ReadVFWMulV : SchedRead;
|
|
def ReadVFWMulF : SchedRead;
|
|
// 13.6. Vector Single-Width Floating-Point Fused Multiply-Add Instructions
|
|
def ReadVFMulAddV : SchedRead;
|
|
def ReadVFMulAddF : SchedRead;
|
|
// 13.7. Vector Widening Floating-Point Fused Multiply-Add Instructions
|
|
def ReadVFWMulAddV : SchedRead;
|
|
def ReadVFWMulAddF : SchedRead;
|
|
// 13.8. Vector Floating-Point Square-Root Instruction
|
|
def ReadVFSqrtV : SchedRead;
|
|
// 13.9. Vector Floating-Point Reciprocal Square-Root Estimate Instruction
|
|
// 13.10. Vector Floating-Point Reciprocal Estimate Instruction
|
|
def ReadVFRecpV : SchedRead;
|
|
// 13.11. Vector Floating-Point MIN/MAX Instructions
|
|
// 13.13. Vector Floating-Point Compare Instructions
|
|
def ReadVFCmpV : SchedRead;
|
|
def ReadVFCmpF : SchedRead;
|
|
// 13.12. Vector Floating-Point Sign-Injection Instructions
|
|
def ReadVFSgnjV : SchedRead;
|
|
def ReadVFSgnjF : SchedRead;
|
|
// 13.14. Vector Floating-Point Classify Instruction
|
|
def ReadVFClassV : SchedRead;
|
|
// 13.15. Vector Floating-Point Merge Instruction
|
|
def ReadVFMergeV : SchedRead;
|
|
def ReadVFMergeF : SchedRead;
|
|
// 13.16. Vector Floating-Point Move Instruction
|
|
def ReadVFMovF : SchedRead;
|
|
// 13.17. Single-Width Floating-Point/Integer Type-Convert Instructions
|
|
def ReadVFCvtIToFV : SchedRead;
|
|
def ReadVFCvtFToIV : SchedRead;
|
|
// 13.18. Widening Floating-Point/Integer Type-Convert Instructions
|
|
def ReadVFWCvtIToFV : SchedRead;
|
|
def ReadVFWCvtFToIV : SchedRead;
|
|
def ReadVFWCvtFToFV : SchedRead;
|
|
// 13.19. Narrowing Floating-Point/Integer Type-Convert Instructions
|
|
def ReadVFNCvtIToFV : SchedRead;
|
|
def ReadVFNCvtFToIV : SchedRead;
|
|
def ReadVFNCvtFToFV : SchedRead;
|
|
|
|
// 14. Vector Reduction Operations
|
|
// 14.1. Vector Single-Width Integer Reduction Instructions
|
|
def ReadVIRedV : SchedRead;
|
|
def ReadVIRedV0 : SchedRead;
|
|
// 14.2. Vector Widening Integer Reduction Instructions
|
|
def ReadVIWRedV : SchedRead;
|
|
def ReadVIWRedV0 : SchedRead;
|
|
// 14.3. Vector Single-Width Floating-Point Reduction Instructions
|
|
def ReadVFRedV : SchedRead;
|
|
def ReadVFRedV0 : SchedRead;
|
|
def ReadVFRedOV : SchedRead;
|
|
def ReadVFRedOV0 : SchedRead;
|
|
// 14.4. Vector Widening Floating-Point Reduction Instructions
|
|
def ReadVFWRedV : SchedRead;
|
|
def ReadVFWRedV0 : SchedRead;
|
|
def ReadVFWRedOV : SchedRead;
|
|
def ReadVFWRedOV0 : SchedRead;
|
|
|
|
// 15. Vector Mask Instructions
|
|
// 15.1. Vector Mask-Register Logical Instructions
|
|
def ReadVMALUV : SchedRead;
|
|
// 15.2. Vector Mask Population Count
|
|
def ReadVMPopV : SchedRead;
|
|
// 15.3. Vector Find-First-Set Mask Bit
|
|
def ReadVMFFSV : SchedRead;
|
|
// 15.4. Vector Set-Before-First Mask Bit
|
|
// 15.5. Vector Set-Including-First Mask Bit
|
|
// 15.6. Vector Set-only-First Mask Bit
|
|
def ReadVMSFSV : SchedRead;
|
|
// 15.8. Vector Iota Instruction
|
|
def ReadVMIotV : SchedRead;
|
|
|
|
// 16. Vector Permutation Instructions
|
|
// 16.1. Integer Scalar Move Instructions
|
|
def ReadVIMovVX : SchedRead;
|
|
def ReadVIMovXV : SchedRead;
|
|
def ReadVIMovXX : SchedRead;
|
|
// 16.2. Floating-Point Scalar Move Instructions
|
|
def ReadVFMovVF : SchedRead;
|
|
def ReadVFMovFV : SchedRead;
|
|
def ReadVFMovFX : SchedRead;
|
|
// 16.3. Vector Slide Instructions
|
|
def ReadVISlideV : SchedRead;
|
|
def ReadVISlideX : SchedRead;
|
|
def ReadVFSlideV : SchedRead;
|
|
def ReadVFSlideF : SchedRead;
|
|
// 16.4. Vector Register Gather Instructions
|
|
def ReadVGatherV : SchedRead;
|
|
def ReadVGatherX : SchedRead;
|
|
// 16.5. Vector Compress Instruction
|
|
def ReadVCompressV : SchedRead;
|
|
// 16.6. Whole Vector Register Move
|
|
def ReadVMov1V : SchedRead;
|
|
def ReadVMov2V : SchedRead;
|
|
def ReadVMov4V : SchedRead;
|
|
def ReadVMov8V : SchedRead;
|
|
|
|
// Others
|
|
def ReadVMask : SchedRead;
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
/// Define default scheduler resources for V.
|
|
|
|
multiclass UnsupportedSchedV {
|
|
let Unsupported = true in {
|
|
|
|
// 7. Vector Loads and Stores
|
|
def : WriteRes<WriteVLDE8, []>;
|
|
def : WriteRes<WriteVLDE16, []>;
|
|
def : WriteRes<WriteVLDE32, []>;
|
|
def : WriteRes<WriteVLDE64, []>;
|
|
def : WriteRes<WriteVSTE8, []>;
|
|
def : WriteRes<WriteVSTE16, []>;
|
|
def : WriteRes<WriteVSTE32, []>;
|
|
def : WriteRes<WriteVSTE64, []>;
|
|
def : WriteRes<WriteVLDM, []>;
|
|
def : WriteRes<WriteVSTM, []>;
|
|
def : WriteRes<WriteVLDS8, []>;
|
|
def : WriteRes<WriteVLDS16, []>;
|
|
def : WriteRes<WriteVLDS32, []>;
|
|
def : WriteRes<WriteVLDS64, []>;
|
|
def : WriteRes<WriteVSTS8, []>;
|
|
def : WriteRes<WriteVSTS16, []>;
|
|
def : WriteRes<WriteVSTS32, []>;
|
|
def : WriteRes<WriteVSTS64, []>;
|
|
def : WriteRes<WriteVLDUX8, []>;
|
|
def : WriteRes<WriteVLDUX16, []>;
|
|
def : WriteRes<WriteVLDUX32, []>;
|
|
def : WriteRes<WriteVLDUX64, []>;
|
|
def : WriteRes<WriteVLDOX8, []>;
|
|
def : WriteRes<WriteVLDOX16, []>;
|
|
def : WriteRes<WriteVLDOX32, []>;
|
|
def : WriteRes<WriteVLDOX64, []>;
|
|
def : WriteRes<WriteVSTUX8, []>;
|
|
def : WriteRes<WriteVSTUX16, []>;
|
|
def : WriteRes<WriteVSTUX32, []>;
|
|
def : WriteRes<WriteVSTUX64, []>;
|
|
def : WriteRes<WriteVSTOX8, []>;
|
|
def : WriteRes<WriteVSTOX16, []>;
|
|
def : WriteRes<WriteVSTOX32, []>;
|
|
def : WriteRes<WriteVSTOX64, []>;
|
|
def : WriteRes<WriteVLDFF8, []>;
|
|
def : WriteRes<WriteVLDFF16, []>;
|
|
def : WriteRes<WriteVLDFF32, []>;
|
|
def : WriteRes<WriteVLDFF64, []>;
|
|
def : WriteRes<WriteVLD1R8, []>;
|
|
def : WriteRes<WriteVLD1R16, []>;
|
|
def : WriteRes<WriteVLD1R32, []>;
|
|
def : WriteRes<WriteVLD1R64, []>;
|
|
def : WriteRes<WriteVLD2R8, []>;
|
|
def : WriteRes<WriteVLD2R16, []>;
|
|
def : WriteRes<WriteVLD2R32, []>;
|
|
def : WriteRes<WriteVLD2R64, []>;
|
|
def : WriteRes<WriteVLD4R8, []>;
|
|
def : WriteRes<WriteVLD4R16, []>;
|
|
def : WriteRes<WriteVLD4R32, []>;
|
|
def : WriteRes<WriteVLD4R64, []>;
|
|
def : WriteRes<WriteVLD8R8, []>;
|
|
def : WriteRes<WriteVLD8R16, []>;
|
|
def : WriteRes<WriteVLD8R32, []>;
|
|
def : WriteRes<WriteVLD8R64, []>;
|
|
def : WriteRes<WriteVST1R, []>;
|
|
def : WriteRes<WriteVST2R, []>;
|
|
def : WriteRes<WriteVST4R, []>;
|
|
def : WriteRes<WriteVST8R, []>;
|
|
|
|
// 12. Vector Integer Arithmetic Instructions
|
|
def : WriteRes<WriteVIALUV, []>;
|
|
def : WriteRes<WriteVIALUX, []>;
|
|
def : WriteRes<WriteVIALUI, []>;
|
|
def : WriteRes<WriteVIWALUV, []>;
|
|
def : WriteRes<WriteVIWALUX, []>;
|
|
def : WriteRes<WriteVIWALUI, []>;
|
|
def : WriteRes<WriteVExtV, []>;
|
|
def : WriteRes<WriteVICALUV, []>;
|
|
def : WriteRes<WriteVICALUX, []>;
|
|
def : WriteRes<WriteVICALUI, []>;
|
|
def : WriteRes<WriteVShiftV, []>;
|
|
def : WriteRes<WriteVShiftX, []>;
|
|
def : WriteRes<WriteVShiftI, []>;
|
|
def : WriteRes<WriteVNShiftV, []>;
|
|
def : WriteRes<WriteVNShiftX, []>;
|
|
def : WriteRes<WriteVNShiftI, []>;
|
|
def : WriteRes<WriteVICmpV, []>;
|
|
def : WriteRes<WriteVICmpX, []>;
|
|
def : WriteRes<WriteVICmpI, []>;
|
|
def : WriteRes<WriteVIMulV, []>;
|
|
def : WriteRes<WriteVIMulX, []>;
|
|
def : WriteRes<WriteVIDivV, []>;
|
|
def : WriteRes<WriteVIDivX, []>;
|
|
def : WriteRes<WriteVIWMulV, []>;
|
|
def : WriteRes<WriteVIWMulX, []>;
|
|
def : WriteRes<WriteVIMulAddV, []>;
|
|
def : WriteRes<WriteVIMulAddX, []>;
|
|
def : WriteRes<WriteVIWMulAddV, []>;
|
|
def : WriteRes<WriteVIWMulAddX, []>;
|
|
def : WriteRes<WriteVIMergeV, []>;
|
|
def : WriteRes<WriteVIMergeX, []>;
|
|
def : WriteRes<WriteVIMergeI, []>;
|
|
def : WriteRes<WriteVIMovV, []>;
|
|
def : WriteRes<WriteVIMovX, []>;
|
|
def : WriteRes<WriteVIMovI, []>;
|
|
|
|
// 13. Vector Fixed-Point Arithmetic Instructions
|
|
def : WriteRes<WriteVSALUV, []>;
|
|
def : WriteRes<WriteVSALUX, []>;
|
|
def : WriteRes<WriteVSALUI, []>;
|
|
def : WriteRes<WriteVAALUV, []>;
|
|
def : WriteRes<WriteVAALUX, []>;
|
|
def : WriteRes<WriteVSMulV, []>;
|
|
def : WriteRes<WriteVSMulX, []>;
|
|
def : WriteRes<WriteVSShiftV, []>;
|
|
def : WriteRes<WriteVSShiftX, []>;
|
|
def : WriteRes<WriteVSShiftI, []>;
|
|
def : WriteRes<WriteVNClipV, []>;
|
|
def : WriteRes<WriteVNClipX, []>;
|
|
def : WriteRes<WriteVNClipI, []>;
|
|
|
|
// 14. Vector Floating-Point Instructions
|
|
def : WriteRes<WriteVFALUV, []>;
|
|
def : WriteRes<WriteVFALUF, []>;
|
|
def : WriteRes<WriteVFWALUV, []>;
|
|
def : WriteRes<WriteVFWALUF, []>;
|
|
def : WriteRes<WriteVFMulV, []>;
|
|
def : WriteRes<WriteVFMulF, []>;
|
|
def : WriteRes<WriteVFDivV, []>;
|
|
def : WriteRes<WriteVFDivF, []>;
|
|
def : WriteRes<WriteVFWMulV, []>;
|
|
def : WriteRes<WriteVFWMulF, []>;
|
|
def : WriteRes<WriteVFMulAddV, []>;
|
|
def : WriteRes<WriteVFMulAddF, []>;
|
|
def : WriteRes<WriteVFWMulAddV, []>;
|
|
def : WriteRes<WriteVFWMulAddF, []>;
|
|
def : WriteRes<WriteVFSqrtV, []>;
|
|
def : WriteRes<WriteVFRecpV, []>;
|
|
def : WriteRes<WriteVFCmpV, []>;
|
|
def : WriteRes<WriteVFCmpF, []>;
|
|
def : WriteRes<WriteVFSgnjV, []>;
|
|
def : WriteRes<WriteVFSgnjF, []>;
|
|
def : WriteRes<WriteVFClassV, []>;
|
|
def : WriteRes<WriteVFMergeV, []>;
|
|
def : WriteRes<WriteVFMovV, []>;
|
|
def : WriteRes<WriteVFCvtIToFV, []>;
|
|
def : WriteRes<WriteVFCvtFToIV, []>;
|
|
def : WriteRes<WriteVFCvtFToFV, []>;
|
|
def : WriteRes<WriteVFWCvtIToFV, []>;
|
|
def : WriteRes<WriteVFWCvtFToIV, []>;
|
|
def : WriteRes<WriteVFWCvtFToFV, []>;
|
|
def : WriteRes<WriteVFNCvtIToFV, []>;
|
|
def : WriteRes<WriteVFNCvtFToIV, []>;
|
|
def : WriteRes<WriteVFNCvtFToFV, []>;
|
|
|
|
// 15. Vector Reduction Operations
|
|
def : WriteRes<WriteVIRedV, []>;
|
|
def : WriteRes<WriteVIWRedV, []>;
|
|
def : WriteRes<WriteVFRedV, []>;
|
|
def : WriteRes<WriteVFRedOV, []>;
|
|
def : WriteRes<WriteVFWRedV, []>;
|
|
def : WriteRes<WriteVFWRedOV, []>;
|
|
|
|
// 16. Vector Mask Instructions
|
|
def : WriteRes<WriteVMALUV, []>;
|
|
def : WriteRes<WriteVMPopV, []>;
|
|
def : WriteRes<WriteVMFFSV, []>;
|
|
def : WriteRes<WriteVMSFSV, []>;
|
|
def : WriteRes<WriteVMIotV, []>;
|
|
def : WriteRes<WriteVMIdxV, []>;
|
|
|
|
// 17. Vector Permutation Instructions
|
|
def : WriteRes<WriteVIMovVX, []>;
|
|
def : WriteRes<WriteVIMovXV, []>;
|
|
def : WriteRes<WriteVFMovVF, []>;
|
|
def : WriteRes<WriteVFMovFV, []>;
|
|
def : WriteRes<WriteVISlideX, []>;
|
|
def : WriteRes<WriteVISlideI, []>;
|
|
def : WriteRes<WriteVISlide1X, []>;
|
|
def : WriteRes<WriteVFSlide1F, []>;
|
|
def : WriteRes<WriteVGatherV, []>;
|
|
def : WriteRes<WriteVGatherX, []>;
|
|
def : WriteRes<WriteVGatherI, []>;
|
|
def : WriteRes<WriteVCompressV, []>;
|
|
def : WriteRes<WriteVMov1V, []>;
|
|
def : WriteRes<WriteVMov2V, []>;
|
|
def : WriteRes<WriteVMov4V, []>;
|
|
def : WriteRes<WriteVMov8V, []>;
|
|
|
|
// 7. Vector Loads and Stores
|
|
def : ReadAdvance<ReadVLDX, 0>;
|
|
def : ReadAdvance<ReadVSTX, 0>;
|
|
def : ReadAdvance<ReadVSTE8V, 0>;
|
|
def : ReadAdvance<ReadVSTE16V, 0>;
|
|
def : ReadAdvance<ReadVSTE32V, 0>;
|
|
def : ReadAdvance<ReadVSTE64V, 0>;
|
|
def : ReadAdvance<ReadVSTM, 0>;
|
|
def : ReadAdvance<ReadVLDSX, 0>;
|
|
def : ReadAdvance<ReadVSTSX, 0>;
|
|
def : ReadAdvance<ReadVSTS8V, 0>;
|
|
def : ReadAdvance<ReadVSTS16V, 0>;
|
|
def : ReadAdvance<ReadVSTS32V, 0>;
|
|
def : ReadAdvance<ReadVSTS64V, 0>;
|
|
def : ReadAdvance<ReadVLDUXV, 0>;
|
|
def : ReadAdvance<ReadVLDOXV, 0>;
|
|
def : ReadAdvance<ReadVSTUXV, 0>;
|
|
def : ReadAdvance<ReadVSTUX8, 0>;
|
|
def : ReadAdvance<ReadVSTUX16, 0>;
|
|
def : ReadAdvance<ReadVSTUX32, 0>;
|
|
def : ReadAdvance<ReadVSTUX64, 0>;
|
|
def : ReadAdvance<ReadVSTUX8V, 0>;
|
|
def : ReadAdvance<ReadVSTUX16V, 0>;
|
|
def : ReadAdvance<ReadVSTUX32V, 0>;
|
|
def : ReadAdvance<ReadVSTUX64V, 0>;
|
|
def : ReadAdvance<ReadVSTOX8, 0>;
|
|
def : ReadAdvance<ReadVSTOX16, 0>;
|
|
def : ReadAdvance<ReadVSTOX32, 0>;
|
|
def : ReadAdvance<ReadVSTOX64, 0>;
|
|
def : ReadAdvance<ReadVSTOXV, 0>;
|
|
def : ReadAdvance<ReadVSTOX8V, 0>;
|
|
def : ReadAdvance<ReadVSTOX16V, 0>;
|
|
def : ReadAdvance<ReadVSTOX32V, 0>;
|
|
def : ReadAdvance<ReadVSTOX64V, 0>;
|
|
def : ReadAdvance<ReadVST1R, 0>;
|
|
def : ReadAdvance<ReadVST2R, 0>;
|
|
def : ReadAdvance<ReadVST4R, 0>;
|
|
def : ReadAdvance<ReadVST8R, 0>;
|
|
|
|
// 12. Vector Integer Arithmetic Instructions
|
|
def : ReadAdvance<ReadVIALUV, 0>;
|
|
def : ReadAdvance<ReadVIALUX, 0>;
|
|
def : ReadAdvance<ReadVIWALUV, 0>;
|
|
def : ReadAdvance<ReadVIWALUX, 0>;
|
|
def : ReadAdvance<ReadVExtV, 0>;
|
|
def : ReadAdvance<ReadVIALUCV, 0>;
|
|
def : ReadAdvance<ReadVIALUCX, 0>;
|
|
def : ReadAdvance<ReadVShiftV, 0>;
|
|
def : ReadAdvance<ReadVShiftX, 0>;
|
|
def : ReadAdvance<ReadVNShiftV, 0>;
|
|
def : ReadAdvance<ReadVNShiftX, 0>;
|
|
def : ReadAdvance<ReadVICmpV, 0>;
|
|
def : ReadAdvance<ReadVICmpX, 0>;
|
|
def : ReadAdvance<ReadVIMulV, 0>;
|
|
def : ReadAdvance<ReadVIMulX, 0>;
|
|
def : ReadAdvance<ReadVIDivV, 0>;
|
|
def : ReadAdvance<ReadVIDivX, 0>;
|
|
def : ReadAdvance<ReadVIWMulV, 0>;
|
|
def : ReadAdvance<ReadVIWMulX, 0>;
|
|
def : ReadAdvance<ReadVIMulAddV, 0>;
|
|
def : ReadAdvance<ReadVIMulAddX, 0>;
|
|
def : ReadAdvance<ReadVIWMulAddV, 0>;
|
|
def : ReadAdvance<ReadVIWMulAddX, 0>;
|
|
def : ReadAdvance<ReadVIMergeV, 0>;
|
|
def : ReadAdvance<ReadVIMergeX, 0>;
|
|
def : ReadAdvance<ReadVIMovV, 0>;
|
|
def : ReadAdvance<ReadVIMovX, 0>;
|
|
|
|
// 13. Vector Fixed-Point Arithmetic Instructions
|
|
def : ReadAdvance<ReadVSALUV, 0>;
|
|
def : ReadAdvance<ReadVSALUX, 0>;
|
|
def : ReadAdvance<ReadVAALUV, 0>;
|
|
def : ReadAdvance<ReadVAALUX, 0>;
|
|
def : ReadAdvance<ReadVSMulV, 0>;
|
|
def : ReadAdvance<ReadVSMulX, 0>;
|
|
def : ReadAdvance<ReadVSShiftV, 0>;
|
|
def : ReadAdvance<ReadVSShiftX, 0>;
|
|
def : ReadAdvance<ReadVNClipV, 0>;
|
|
def : ReadAdvance<ReadVNClipX, 0>;
|
|
|
|
// 14. 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>;
|
|
def : ReadAdvance<ReadVFDivV, 0>;
|
|
def : ReadAdvance<ReadVFDivF, 0>;
|
|
def : ReadAdvance<ReadVFWMulV, 0>;
|
|
def : ReadAdvance<ReadVFWMulF, 0>;
|
|
def : ReadAdvance<ReadVFMulAddV, 0>;
|
|
def : ReadAdvance<ReadVFMulAddF, 0>;
|
|
def : ReadAdvance<ReadVFWMulAddV, 0>;
|
|
def : ReadAdvance<ReadVFWMulAddF, 0>;
|
|
def : ReadAdvance<ReadVFSqrtV, 0>;
|
|
def : ReadAdvance<ReadVFRecpV, 0>;
|
|
def : ReadAdvance<ReadVFCmpV, 0>;
|
|
def : ReadAdvance<ReadVFCmpF, 0>;
|
|
def : ReadAdvance<ReadVFSgnjV, 0>;
|
|
def : ReadAdvance<ReadVFSgnjF, 0>;
|
|
def : ReadAdvance<ReadVFClassV, 0>;
|
|
def : ReadAdvance<ReadVFMergeV, 0>;
|
|
def : ReadAdvance<ReadVFMergeF, 0>;
|
|
def : ReadAdvance<ReadVFMovF, 0>;
|
|
def : ReadAdvance<ReadVFCvtIToFV, 0>;
|
|
def : ReadAdvance<ReadVFCvtFToIV, 0>;
|
|
def : ReadAdvance<ReadVFWCvtIToFV, 0>;
|
|
def : ReadAdvance<ReadVFWCvtFToIV, 0>;
|
|
def : ReadAdvance<ReadVFWCvtFToFV, 0>;
|
|
def : ReadAdvance<ReadVFNCvtIToFV, 0>;
|
|
def : ReadAdvance<ReadVFNCvtFToIV, 0>;
|
|
def : ReadAdvance<ReadVFNCvtFToFV, 0>;
|
|
|
|
// 15. Vector Reduction Operations
|
|
def : ReadAdvance<ReadVIRedV, 0>;
|
|
def : ReadAdvance<ReadVIRedV0, 0>;
|
|
def : ReadAdvance<ReadVIWRedV, 0>;
|
|
def : ReadAdvance<ReadVIWRedV0, 0>;
|
|
def : ReadAdvance<ReadVFRedV, 0>;
|
|
def : ReadAdvance<ReadVFRedV0, 0>;
|
|
def : ReadAdvance<ReadVFRedOV, 0>;
|
|
def : ReadAdvance<ReadVFRedOV0, 0>;
|
|
def : ReadAdvance<ReadVFWRedV, 0>;
|
|
def : ReadAdvance<ReadVFWRedV0, 0>;
|
|
def : ReadAdvance<ReadVFWRedOV, 0>;
|
|
def : ReadAdvance<ReadVFWRedOV0, 0>;
|
|
|
|
// 16. Vector Mask Instructions
|
|
def : ReadAdvance<ReadVMALUV, 0>;
|
|
def : ReadAdvance<ReadVMPopV, 0>;
|
|
def : ReadAdvance<ReadVMFFSV, 0>;
|
|
def : ReadAdvance<ReadVMSFSV, 0>;
|
|
def : ReadAdvance<ReadVMIotV, 0>;
|
|
|
|
// 17. Vector Permutation Instructions
|
|
def : ReadAdvance<ReadVIMovVX, 0>;
|
|
def : ReadAdvance<ReadVIMovXV, 0>;
|
|
def : ReadAdvance<ReadVIMovXX, 0>;
|
|
def : ReadAdvance<ReadVFMovVF, 0>;
|
|
def : ReadAdvance<ReadVFMovFV, 0>;
|
|
def : ReadAdvance<ReadVFMovFX, 0>;
|
|
def : ReadAdvance<ReadVISlideV, 0>;
|
|
def : ReadAdvance<ReadVISlideX, 0>;
|
|
def : ReadAdvance<ReadVFSlideV, 0>;
|
|
def : ReadAdvance<ReadVFSlideF, 0>;
|
|
def : ReadAdvance<ReadVGatherV, 0>;
|
|
def : ReadAdvance<ReadVGatherX, 0>;
|
|
def : ReadAdvance<ReadVCompressV, 0>;
|
|
def : ReadAdvance<ReadVMov1V, 0>;
|
|
def : ReadAdvance<ReadVMov2V, 0>;
|
|
def : ReadAdvance<ReadVMov4V, 0>;
|
|
def : ReadAdvance<ReadVMov8V, 0>;
|
|
|
|
// Others
|
|
def : ReadAdvance<ReadVMask, 0>;
|
|
|
|
} // Unsupported
|
|
} // UnsupportedSchedV
|