| //===-- RISCVScheduleB.td - RISCV Scheduling Definitions B -*- 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. |
| |
| // Zba extension |
| def WriteSHXADD : SchedWrite; // sh1add/sh2add/sh3add |
| def WriteSHXADD32 : SchedWrite; // sh1add.uw/sh2add.uw/sh3add.uw |
| |
| // Zbb extension |
| def WriteRotateImm : SchedWrite; |
| def WriteRotateImm32 : SchedWrite; |
| def WriteRotateReg : SchedWrite; |
| def WriteRotateReg32 : SchedWrite; |
| def WriteCLZ : SchedWrite; |
| def WriteCLZ32 : SchedWrite; |
| def WriteCTZ : SchedWrite; |
| def WriteCTZ32 : SchedWrite; |
| def WriteCPOP : SchedWrite; |
| def WriteCPOP32 : SchedWrite; |
| def WriteREV8 : SchedWrite; |
| def WriteORCB : SchedWrite; |
| |
| // Zbc extension |
| def WriteCLMUL : SchedWrite; // CLMUL/CLMULR/CLMULH |
| |
| // Zbs extension |
| def WriteSingleBit : SchedWrite; // BCLR/BSET/BINV/BEXT |
| def WriteSingleBitImm: SchedWrite; // BCLRI/BSETI/BINVI/BEXTI |
| |
| // Zbe extension |
| def WriteDecompress : SchedWrite; // bdecompress |
| def WriteCompress : SchedWrite; // bcompress |
| def WriteDecompress32: SchedWrite; // bdecompressw |
| def WriteCompress32 : SchedWrite; // bcompressw |
| |
| // Zbf extension |
| def WriteBFP : SchedWrite; // BFP |
| def WriteBFP32 : SchedWrite; // BFPW |
| |
| // Zbm extension |
| def WriteBMatrix : SchedWrite; // bmator/bmatxor/bmatflip |
| |
| // Zbp extension |
| def WriteORC : SchedWrite; // gorc |
| def WriteREV : SchedWrite; // grev |
| def WriteORC32 : SchedWrite; // gorcw |
| def WriteREV32 : SchedWrite; // grevw |
| def WriteREVImm : SchedWrite; // grevi |
| def WriteORCImm : SchedWrite; // gorci |
| def WriteREVImm32 : SchedWrite; // greviw |
| def WriteORCImm32 : SchedWrite; // gorciw |
| def WriteSHFL : SchedWrite; // shfl |
| def WriteUNSHFL : SchedWrite; // unshfl |
| def WriteSHFL32 : SchedWrite; // shflw |
| def WriteUNSHFL32 : SchedWrite; // unshflw |
| def WriteSHFLImm : SchedWrite; // shfli |
| def WriteUNSHFLImm : SchedWrite; // unshfli |
| def WriteXPERMH : SchedWrite; // xperm.h |
| def WriteXPERMW : SchedWrite; // xperm.w |
| def WritePACK : SchedWrite; // pack/packh |
| def WritePACK32 : SchedWrite; // packw |
| def WritePACKU : SchedWrite; // packu |
| def WritePACKU32 : SchedWrite; // packuw |
| |
| // Zbr extension |
| def WriteCRCB : SchedWrite; // crc32.b |
| def WriteCRCH : SchedWrite; // crc32.h |
| def WriteCRCW : SchedWrite; // crc32.w |
| def WriteCRCD : SchedWrite; // crc32.d |
| def WriteCRCCB : SchedWrite; // crc32c.b |
| def WriteCRCCH : SchedWrite; // crc32c.h |
| def WriteCRCCW : SchedWrite; // crc32c.w |
| def WriteCRCCD : SchedWrite; // crc32c.d |
| |
| // Zbt extension |
| def WriteCMix : SchedWrite; // cmix |
| def WriteCMov : SchedWrite; // cmov |
| def WriteFSReg : SchedWrite; // fsl/fsr |
| def WriteFSRImm : SchedWrite; // fsri |
| def WriteFSReg32 : SchedWrite; // fslw/fsrw |
| def WriteFSRImm32 : SchedWrite; // fsriw |
| |
| /// Define scheduler resources associated with use operands. |
| |
| // Zba extension |
| def ReadSHXADD : SchedRead; // sh1add/sh2add/sh3add |
| def ReadSHXADD32 : SchedRead; // sh1add.uw/sh2add.uw/sh3add.uw |
| |
| // Zbb extension |
| def ReadRotateImm : SchedRead; |
| def ReadRotateImm32 : SchedRead; |
| def ReadRotateReg : SchedRead; |
| def ReadRotateReg32 : SchedRead; |
| def ReadCLZ : SchedRead; |
| def ReadCLZ32 : SchedRead; |
| def ReadCTZ : SchedRead; |
| def ReadCTZ32 : SchedRead; |
| def ReadCPOP : SchedRead; |
| def ReadCPOP32 : SchedRead; |
| def ReadREV8 : SchedRead; |
| def ReadORCB : SchedRead; |
| |
| // Zbc extension |
| def ReadCLMUL : SchedRead; // CLMUL/CLMULR/CLMULH |
| |
| // Zbs extension |
| def ReadSingleBit : SchedRead; // BCLR/BSET/BINV/BEXT |
| def ReadSingleBitImm: SchedRead; // BCLRI/BSETI/BINVI/BEXTI |
| |
| // Zbe extension |
| def ReadDecompress : SchedRead; // bdecompress |
| def ReadCompress : SchedRead; // bcompress |
| def ReadDecompress32: SchedRead; // bdecompressw |
| def ReadCompress32 : SchedRead; // bcompressw |
| |
| // Zbf extension |
| def ReadBFP : SchedRead; // BFP |
| def ReadBFP32 : SchedRead; // BFPW |
| |
| // Zbm extension |
| def ReadBMatrix : SchedRead; // bmator/bmatxor/bmatflip |
| |
| // Zbp extension |
| def ReadORC : SchedRead; // gorc |
| def ReadREV : SchedRead; // grev |
| def ReadORC32 : SchedRead; // gorcw |
| def ReadREV32 : SchedRead; // grevw |
| def ReadREVImm : SchedRead; // grevi |
| def ReadORCImm : SchedRead; // groci |
| def ReadREVImm32 : SchedRead; // greviw |
| def ReadORCImm32 : SchedRead; // gorciw |
| def ReadSHFL : SchedRead; // shfl |
| def ReadUNSHFL : SchedRead; // unshfl |
| def ReadSHFL32 : SchedRead; // shflw |
| def ReadUNSHFL32 : SchedRead; // unshflw |
| def ReadSHFLImm : SchedRead; // shfli |
| def ReadUNSHFLImm : SchedRead; // unshfli |
| def ReadXPERMH : SchedRead; // xperm.h |
| def ReadXPERMW : SchedRead; // xperm.w |
| def ReadPACK : SchedRead; // pack/packh |
| def ReadPACK32 : SchedRead; // packw |
| def ReadPACKU : SchedRead; // packu |
| def ReadPACKU32 : SchedRead; // packuw |
| |
| // Zbr extension |
| def ReadCRCB : SchedRead; // crc32.b |
| def ReadCRCH : SchedRead; // crc32.h |
| def ReadCRCW : SchedRead; // crc32.w |
| def ReadCRCD : SchedRead; // crc32.d |
| def ReadCRCCB : SchedRead; // crc32c.b |
| def ReadCRCCH : SchedRead; // crc32c.h |
| def ReadCRCCW : SchedRead; // crc32c.w |
| def ReadCRCCD : SchedRead; // crc32c.d |
| |
| // Zbt extension |
| def ReadCMix : SchedRead; // cmix |
| def ReadCMov : SchedRead; // cmov |
| def ReadFSReg : SchedRead; // fsl/fsr |
| def ReadFSRImm : SchedRead; // fsri |
| def ReadFSReg32 : SchedRead; // fslw/fsrw |
| def ReadFSRImm32 : SchedRead; // fsriw |
| |
| /// Define default scheduler resources for B. |
| |
| multiclass UnsupportedSchedZba { |
| let Unsupported = true in { |
| def : WriteRes<WriteSHXADD, []>; |
| def : WriteRes<WriteSHXADD32, []>; |
| |
| def : ReadAdvance<ReadSHXADD, 0>; |
| def : ReadAdvance<ReadSHXADD32, 0>; |
| } |
| } |
| |
| multiclass UnsupportedSchedZbb { |
| let Unsupported = true in { |
| def : WriteRes<WriteRotateImm, []>; |
| def : WriteRes<WriteRotateImm32, []>; |
| def : WriteRes<WriteRotateReg, []>; |
| def : WriteRes<WriteRotateReg32, []>; |
| def : WriteRes<WriteCLZ, []>; |
| def : WriteRes<WriteCLZ32, []>; |
| def : WriteRes<WriteCTZ, []>; |
| def : WriteRes<WriteCTZ32, []>; |
| def : WriteRes<WriteCPOP, []>; |
| def : WriteRes<WriteCPOP32, []>; |
| def : WriteRes<WriteREV8, []>; |
| def : WriteRes<WriteORCB, []>; |
| |
| def : ReadAdvance<ReadRotateImm, 0>; |
| def : ReadAdvance<ReadRotateImm32, 0>; |
| def : ReadAdvance<ReadRotateReg, 0>; |
| def : ReadAdvance<ReadRotateReg32, 0>; |
| def : ReadAdvance<ReadCLZ, 0>; |
| def : ReadAdvance<ReadCLZ32, 0>; |
| def : ReadAdvance<ReadCTZ, 0>; |
| def : ReadAdvance<ReadCTZ32, 0>; |
| def : ReadAdvance<ReadCPOP, 0>; |
| def : ReadAdvance<ReadCPOP32, 0>; |
| def : ReadAdvance<ReadREV8, 0>; |
| def : ReadAdvance<ReadORCB, 0>; |
| } |
| } |
| |
| multiclass UnsupportedSchedZbc { |
| let Unsupported = true in { |
| def : WriteRes<WriteCLMUL, []>; |
| |
| def : ReadAdvance<ReadCLMUL, 0>; |
| } |
| } |
| |
| multiclass UnsupportedSchedZbs { |
| let Unsupported = true in { |
| def : WriteRes<WriteSingleBit, []>; |
| def : WriteRes<WriteSingleBitImm, []>; |
| |
| def : ReadAdvance<ReadSingleBit, 0>; |
| def : ReadAdvance<ReadSingleBitImm, 0>; |
| } |
| } |
| |
| multiclass UnsupportedSchedZbe { |
| let Unsupported = true in { |
| def : WriteRes<WriteDecompress, []>; |
| def : WriteRes<WriteCompress, []>; |
| def : WriteRes<WriteDecompress32, []>; |
| def : WriteRes<WriteCompress32, []>; |
| |
| def : ReadAdvance<ReadDecompress, 0>; |
| def : ReadAdvance<ReadCompress, 0>; |
| def : ReadAdvance<ReadDecompress32, 0>; |
| def : ReadAdvance<ReadCompress32, 0>; |
| } |
| } |
| |
| multiclass UnsupportedSchedZbf { |
| let Unsupported = true in { |
| def : WriteRes<WriteBFP, []>; |
| def : WriteRes<WriteBFP32, []>; |
| |
| def : ReadAdvance<ReadBFP, 0>; |
| def : ReadAdvance<ReadBFP32, 0>; |
| } |
| } |
| |
| multiclass UnsupportedSchedZbm { |
| let Unsupported = true in { |
| def : WriteRes<WriteBMatrix, []>; |
| |
| def : ReadAdvance<ReadBMatrix, 0>; |
| } |
| } |
| |
| multiclass UnsupportedSchedZbp { |
| let Unsupported = true in { |
| def : WriteRes<WriteORC, []>; |
| def : WriteRes<WriteREV, []>; |
| def : WriteRes<WriteORC32, []>; |
| def : WriteRes<WriteREV32, []>; |
| def : WriteRes<WriteREVImm, []>; |
| def : WriteRes<WriteORCImm, []>; |
| def : WriteRes<WriteREVImm32, []>; |
| def : WriteRes<WriteORCImm32, []>; |
| def : WriteRes<WriteSHFL, []>; |
| def : WriteRes<WriteUNSHFL, []>; |
| def : WriteRes<WriteSHFL32, []>; |
| def : WriteRes<WriteUNSHFL32, []>; |
| def : WriteRes<WriteSHFLImm, []>; |
| def : WriteRes<WriteUNSHFLImm, []>; |
| def : WriteRes<WriteXPERMH, []>; |
| def : WriteRes<WriteXPERMW, []>; |
| def : WriteRes<WritePACK, []>; |
| def : WriteRes<WritePACK32, []>; |
| def : WriteRes<WritePACKU, []>; |
| def : WriteRes<WritePACKU32, []>; |
| |
| def : ReadAdvance<ReadORC, 0>; |
| def : ReadAdvance<ReadREV, 0>; |
| def : ReadAdvance<ReadORC32, 0>; |
| def : ReadAdvance<ReadREV32, 0>; |
| def : ReadAdvance<ReadREVImm, 0>; |
| def : ReadAdvance<ReadORCImm, 0>; |
| def : ReadAdvance<ReadREVImm32, 0>; |
| def : ReadAdvance<ReadORCImm32, 0>; |
| def : ReadAdvance<ReadSHFL, 0>; |
| def : ReadAdvance<ReadUNSHFL, 0>; |
| def : ReadAdvance<ReadSHFL32, 0>; |
| def : ReadAdvance<ReadUNSHFL32, 0>; |
| def : ReadAdvance<ReadSHFLImm, 0>; |
| def : ReadAdvance<ReadUNSHFLImm, 0>; |
| def : ReadAdvance<ReadXPERMH, 0>; |
| def : ReadAdvance<ReadXPERMW, 0>; |
| def : ReadAdvance<ReadPACK, 0>; |
| def : ReadAdvance<ReadPACK32, 0>; |
| def : ReadAdvance<ReadPACKU, 0>; |
| def : ReadAdvance<ReadPACKU32, 0>; |
| } |
| } |
| |
| multiclass UnsupportedSchedZbr { |
| let Unsupported = true in { |
| def : WriteRes<WriteCRCB, []>; |
| def : WriteRes<WriteCRCH, []>; |
| def : WriteRes<WriteCRCW, []>; |
| def : WriteRes<WriteCRCD, []>; |
| def : WriteRes<WriteCRCCB, []>; |
| def : WriteRes<WriteCRCCH, []>; |
| def : WriteRes<WriteCRCCW, []>; |
| def : WriteRes<WriteCRCCD, []>; |
| |
| def : ReadAdvance<ReadCRCB, 0>; |
| def : ReadAdvance<ReadCRCH, 0>; |
| def : ReadAdvance<ReadCRCW, 0>; |
| def : ReadAdvance<ReadCRCD, 0>; |
| def : ReadAdvance<ReadCRCCB, 0>; |
| def : ReadAdvance<ReadCRCCH, 0>; |
| def : ReadAdvance<ReadCRCCW, 0>; |
| def : ReadAdvance<ReadCRCCD, 0>; |
| } |
| } |
| |
| multiclass UnsupportedSchedZbt { |
| let Unsupported = true in { |
| def : WriteRes<WriteCMix, []>; |
| def : WriteRes<WriteCMov, []>; |
| def : WriteRes<WriteFSReg, []>; |
| def : WriteRes<WriteFSRImm, []>; |
| def : WriteRes<WriteFSReg32, []>; |
| def : WriteRes<WriteFSRImm32, []>; |
| |
| def : ReadAdvance<ReadCMix, 0>; |
| def : ReadAdvance<ReadCMov, 0>; |
| def : ReadAdvance<ReadFSReg, 0>; |
| def : ReadAdvance<ReadFSRImm, 0>; |
| def : ReadAdvance<ReadFSReg32, 0>; |
| def : ReadAdvance<ReadFSRImm32, 0>; |
| } |
| } |
