llvmorg-github-actions[bot] wrote:
<!--LLVM PR SUMMARY COMMENT--> @llvm/pr-subscribers-backend-risc-v Author: Matt Arsenault (arsenm) <details> <summary>Changes</summary> Move the fusion tuning features to RISCVFeatures.td with the other tuning features, and attach the predicates with SimpleFusionFor and FusionFor. The features no longer depend on the instruction definitions. Co-authored-by: Claude Opus 5.5 <noreply@<!-- -->anthropic.com> --- <sub>Stack created with <a href="https://github.com/github/gh-stack">GitHub Stacks CLI</a> • <a href="https://gh.io/stacks-feedback">Give Feedback 💬</a></sub> --- Patch is 25.87 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/239103.diff 3 Files Affected: - (modified) llvm/lib/Target/RISCV/RISCVFeatures.td (+104) - (modified) llvm/lib/Target/RISCV/RISCVMacroFusion.td (+125-161) - (modified) llvm/lib/Target/RISCV/RISCVMacroFusionXQCI.td (+60-72) ``````````diff diff --git a/llvm/lib/Target/RISCV/RISCVFeatures.td b/llvm/lib/Target/RISCV/RISCVFeatures.td index 6c94edcee2c71..83a4be1cd7bc6 100644 --- a/llvm/lib/Target/RISCV/RISCVFeatures.td +++ b/llvm/lib/Target/RISCV/RISCVFeatures.td @@ -2291,6 +2291,110 @@ def TuneAvoidVXRM : SubtargetFeature<"avoid-vxrm", "AvoidVXRM", "true", "Instructions that use VXRM should be avoided">; +class RISCVFusionFeature<string name, string field_name, string description> + : SubtargetFeature<"fusion-"#name, field_name, "true", description, [], + InlineIgnore>; + +def TuneLUIADDIFusion + : RISCVFusionFeature<"lui-addi", "HasLUIADDIFusion", + "Enable LUI+ADDI macro fusion">; + +def TuneAUIPCADDIFusion + : RISCVFusionFeature<"auipc-addi", "HasAUIPCADDIFusion", + "Enable AUIPC+ADDI macrofusion">; + +def TuneZExtHFusion + : RISCVFusionFeature<"zexth", "HasZExtHFusion", + "Enable SLLI+SRLI to be fused to zero extension of halfword">; + +def TuneZExtWFusion + : RISCVFusionFeature<"zextw", "HasZExtWFusion", + "Enable SLLI+SRLI to be fused to zero extension of word">; + +def TuneShiftedZExtWFusion + : RISCVFusionFeature<"shifted-zextw", "HasShiftedZExtWFusion", + "Enable SLLI+SRLI to be fused when computing (shifted) word zero extension">; + +def TuneLDADDFusion + : RISCVFusionFeature<"ld-add", "HasLDADDFusion", + "Enable LD+ADD macrofusion">; + +def TuneADDLoadFusion + : RISCVFusionFeature<"add-load", "HasADDLoadFusion", + "Enable ADD(.UW) + load macrofusion">; + +def TuneAUIPCLoadFusion + : RISCVFusionFeature<"auipc-load", "HasAUIPCLoadFusion", + "Enable AUIPC + load macrofusion">; + +def TuneLUILoadFusion + : RISCVFusionFeature<"lui-load", "HasLUILoadFusion", + "Enable LUI + load macrofusion">; + +def TuneQCELILoadStoreFusion + : RISCVFusionFeature<"qc-e-li-load-store", "HasQCELILoadStoreFusion", + "Enable QC.E.LI + Load/Store macrofusion">; + +def TuneBFExtFusion + : RISCVFusionFeature<"bfext", "HasBFExtFusion", + "Enable SLLI+SRLI (bitfield extract) macrofusion">; + +def TuneADDILoadFusion + : RISCVFusionFeature<"addi-load", "HasADDILoadFusion", + "Enable ADDI + load macrofusion">; + +def TuneSHXADDLoadFusion + : RISCVFusionFeature<"shxadd-load", "HasSHXADDLoadFusion", + "Enable SH(1|2|3)ADD(.UW) + load macrofusion">; + +def TuneFusionLogicRegReg + : RISCVFusionFeature<"logic-reg-reg", "HasFusionLogicRegReg", + "Enable AND/OR/XOR+AND/OR/XOR macrofusion">; + +def TuneFusionLogicRegImm + : RISCVFusionFeature<"logic-reg-imm", "HasFusionLogicRegImm", + "Enable AND/OR/XOR+ANDI/ORI/XORI macrofusion">; + +def TuneFusionLogicImmReg + : RISCVFusionFeature<"logic-imm-reg", "HasFusionLogicImmReg", + "Enable ANDI/ORI/XORI+AND/OR/XOR macrofusion">; + +def TuneFusionMulAdd + : RISCVFusionFeature<"mul-add", "HasFusionMulAdd", + "Enable MUL+ADD macrofusion">; + +def TuneFusionAddMem + : RISCVFusionFeature<"add-mem", "HasFusionAddMem", + "Enable ADD+LOAD/STORE macrofusion">; + +def TuneFusionShiftBitExtract + : RISCVFusionFeature<"shift-bit-extract", "HasFusionShiftBitExtract", + "Enable SLLI+SRLI/SRAI macrofusion">; + +def TuneMOVIMMALUXqciFusion + : RISCVFusionFeature<"xqci-movimm-alu", "HasMOVIMMALUXqciFusion", + "Enable MOVIMM + ALU operations macrofusion">; + +def TuneMOVIMMMULXqciFusion + : RISCVFusionFeature<"xqci-movimm-mul", "HasMOVIMMMULXqciFusion", + "Enable MOVIMM + multiply macrofusion">; + +def TuneMOVIMMLoadStoreXqciFusion + : RISCVFusionFeature<"xqci-movimm-ldst", "HasMOVIMMLoadStoreXqciFusion", + "Enable MOVIMM + long Load/Store macrofusion">; + +def TuneMOVIMMJumpXqciFusion + : RISCVFusionFeature<"xqci-movimm-jump", "HasMOVIMMJumpXqciFusion", + "Enable MOVIMM + Jump macrofusion">; + +def TuneMOVIMMLongAccumXciFusion + : RISCVFusionFeature<"xqci-movimm-longlogical", "HasMOVIMMLongAccumXqciFusion", + "Enable MOVIMM + long accumulate macrofusion">; + +def TuneMovALUXqciFusion + : RISCVFusionFeature<"xqci-mov-longlogical", "HasMovALUXqciFusion", + "Enable MOV + long accumulate macrofusion">; + //===----------------------------------------------------------------------===// // CPU Families (alphabetized by vendor). //===----------------------------------------------------------------------===// diff --git a/llvm/lib/Target/RISCV/RISCVMacroFusion.td b/llvm/lib/Target/RISCV/RISCVMacroFusion.td index 875cbebc67f0b..08e49f93a4873 100644 --- a/llvm/lib/Target/RISCV/RISCVMacroFusion.td +++ b/llvm/lib/Target/RISCV/RISCVMacroFusion.td @@ -13,77 +13,66 @@ // rd = imm[31:0] which decomposes to // lui rd, imm[31:12] // addi(w) rd, rd, imm[11:0] -def TuneLUIADDIFusion - : SimpleFusion<"lui-addi", "HasLUIADDIFusion", - "Enable LUI+ADDI macro fusion", - CheckOpcode<[LUI]>, - CheckOpcode<[ADDI, ADDIW]>>; +def : SimpleFusionFor<TuneLUIADDIFusion, + CheckOpcode<[LUI]>, + CheckOpcode<[ADDI, ADDIW]>>; // Fuse AUIPC followed by ADDI: // auipc rd, imm20 // addi rd, rd, imm12 -def TuneAUIPCADDIFusion - : SimpleFusion<"auipc-addi", "HasAUIPCADDIFusion", - "Enable AUIPC+ADDI macrofusion", - CheckOpcode<[AUIPC]>, - CheckOpcode<[ADDI]>>; +def : SimpleFusionFor<TuneAUIPCADDIFusion, + CheckOpcode<[AUIPC]>, + CheckOpcode<[ADDI]>>; // Fuse zero extension of halfword: // slli rd, rs1, 48 // srli rd, rd, 48 -def TuneZExtHFusion - : SimpleFusion<"zexth", "HasZExtHFusion", - "Enable SLLI+SRLI to be fused to zero extension of halfword", - CheckAll<[ - CheckOpcode<[SLLI]>, - CheckImmOperand<2, 48> - ]>, - CheckAll<[ - CheckOpcode<[SRLI]>, - CheckImmOperand<2, 48> - ]>>; +def : SimpleFusionFor<TuneZExtHFusion, + CheckAll<[ + CheckOpcode<[SLLI]>, + CheckImmOperand<2, 48> + ]>, + CheckAll<[ + CheckOpcode<[SRLI]>, + CheckImmOperand<2, 48> + ]>>; // Fuse zero extension of word: // slli rd, rs1, 32 // srli rd, rd, 32 -def TuneZExtWFusion - : SimpleFusion<"zextw", "HasZExtWFusion", - "Enable SLLI+SRLI to be fused to zero extension of word", - CheckAll<[ - CheckOpcode<[SLLI]>, - CheckImmOperand<2, 32> - ]>, - CheckAll<[ - CheckOpcode<[SRLI]>, - CheckImmOperand<2, 32> - ]>>; +def : SimpleFusionFor<TuneZExtWFusion, + CheckAll<[ + CheckOpcode<[SLLI]>, + CheckImmOperand<2, 32> + ]>, + CheckAll<[ + CheckOpcode<[SRLI]>, + CheckImmOperand<2, 32> + ]>>; // Fuse shifted zero extension of word: // slli rd, rs1, 32 // srli rd, rd, x // where 0 <= x < 32 -def TuneShiftedZExtWFusion - : SimpleFusion<"shifted-zextw", "HasShiftedZExtWFusion", - "Enable SLLI+SRLI to be fused when computing (shifted) word zero extension", - CheckAll<[ - CheckOpcode<[SLLI]>, - CheckImmOperand<2, 32> - ]>, - CheckAll<[ - CheckOpcode<[SRLI]>, - CheckImmOperandRange<2, 0, 31> - ]>>; +def : SimpleFusionFor<TuneShiftedZExtWFusion, + CheckAll<[ + CheckOpcode<[SLLI]>, + CheckImmOperand<2, 32> + ]>, + CheckAll<[ + CheckOpcode<[SRLI]>, + CheckImmOperandRange<2, 0, 31> + ]>>; // Fuse load with add: // add rd, rs1, rs2 // ld rd, 0(rd) -def TuneLDADDFusion - : SimpleFusion<"ld-add", "HasLDADDFusion", "Enable LD+ADD macrofusion", - CheckOpcode<[ADD]>, - CheckAll<[ - CheckOpcode<[LD]>, - CheckImmOperand<2, 0> - ]>>; +def : SimpleFusionFor<TuneLDADDFusion, + CheckOpcode<[ADD]>, + CheckAll<[ + CheckOpcode<[LD]>, + CheckImmOperand<2, 0> + ]>>; defvar Load = [LB, LH, LW, LD, LBU, LHU, LWU]; defvar LoadStore = [LB, LBU, LH, LHU, LW, LWU, LD, @@ -98,167 +87,142 @@ defvar ShiftRight = [SRLI, SRLIW, SRAI, SRAIW]; // Fuse add(.uw) followed by a load (lb, lh, lw, ld, lbu, lhu, lwu): // add(.uw) rd, rs1, rs2 // load rd, imm12(rd) -def TuneADDLoadFusion - : SimpleFusion<"add-load", "HasADDLoadFusion", "Enable ADD(.UW) + load macrofusion", - CheckOpcode<[ADD, ADD_UW]>, - CheckOpcode<Load>>; +def : SimpleFusionFor<TuneADDLoadFusion, + CheckOpcode<[ADD, ADD_UW]>, + CheckOpcode<Load>>; // Fuse AUIPC followed by by a load (lb, lh, lw, ld, lbu, lhu, lwu) // auipc rd, imm20 // load rd, imm12(rd) -def TuneAUIPCLoadFusion - : SimpleFusion<"auipc-load", "HasAUIPCLoadFusion", - "Enable AUIPC + load macrofusion", - CheckOpcode<[AUIPC]>, - CheckOpcode<Load>>; +def : SimpleFusionFor<TuneAUIPCLoadFusion, + CheckOpcode<[AUIPC]>, + CheckOpcode<Load>>; // Fuse LUI followed by a load (lb, lh, lw, ld, lbu, lhu, lwu) // lui rd, imm[31:12] // load rd, imm12(rd) -def TuneLUILoadFusion - : SimpleFusion<"lui-load", "HasLUILoadFusion", - "Enable LUI + load macrofusion", - CheckOpcode<[LUI]>, - CheckOpcode<Load>>; +def : SimpleFusionFor<TuneLUILoadFusion, + CheckOpcode<[LUI]>, + CheckOpcode<Load>>; defvar RV32GPRLoadStore = [LB, LBU, LH, LHU, LW, SB, SH, SW]; -def TuneQCELILoadStoreFusion - : Fusion<"qc-e-li-load-store", "HasQCELILoadStoreFusion", - "Enable QC.E.LI + Load/Store macrofusion", - [ - SecondFusionPredicateWithMCInstPredicate<CheckOpcode<RV32GPRLoadStore>>, - WildcardTrue, - FirstFusionPredicateWithMCInstPredicate<CheckOpcode<[QC_E_LI]>>, - OneUse, - TieReg<0, 1>, - ]>; +def : FusionFor<TuneQCELILoadStoreFusion, + [ + SecondFusionPredicateWithMCInstPredicate<CheckOpcode<RV32GPRLoadStore>>, + WildcardTrue, + FirstFusionPredicateWithMCInstPredicate<CheckOpcode<[QC_E_LI]>>, + OneUse, + TieReg<0, 1>, + ]>; // Bitfield extract fusion: similar to TuneShiftedZExtWFusion // but without the immediate restriction // slli rd, rs1, imm12 // srli rd, rd, imm12 -def TuneBFExtFusion - : SimpleFusion<"bfext", "HasBFExtFusion", - "Enable SLLI+SRLI (bitfield extract) macrofusion", - CheckOpcode<[SLLI]>, - CheckOpcode<[SRLI]>>; +def : SimpleFusionFor<TuneBFExtFusion, + CheckOpcode<[SLLI]>, + CheckOpcode<[SRLI]>>; // Fuse ADDI followed by a load (lb, lh, lw, ld, lbu, lhu, lwu) // addi rd, rs1, imm12 // load rd, imm12(rd) -def TuneADDILoadFusion - : SimpleFusion<"addi-load", "HasADDILoadFusion", - "Enable ADDI + load macrofusion", - CheckOpcode<[ADDI]>, - CheckOpcode<Load>>; +def : SimpleFusionFor<TuneADDILoadFusion, + CheckOpcode<[ADDI]>, + CheckOpcode<Load>>; // Fuse shXadd(.uw) followed by a load (lb, lh, lw, ld, lbu, lhu, lwu) // shXadd(.uw) rd, rs1, rs2 // load rd, imm12(rd) -def TuneSHXADDLoadFusion - : SimpleFusion<"shxadd-load", "HasSHXADDLoadFusion", - "Enable SH(1|2|3)ADD(.UW) + load macrofusion", - CheckOpcode<[SH1ADD, SH2ADD, SH3ADD, SH1ADD_UW, SH2ADD_UW, SH3ADD_UW]>, - CheckOpcode<Load>>; +def : SimpleFusionFor<TuneSHXADDLoadFusion, + CheckOpcode<[SH1ADD, SH2ADD, SH3ADD, SH1ADD_UW, SH2ADD_UW, SH3ADD_UW]>, + CheckOpcode<Load>>; // Fuse logic operation followed by another logic operation: // and/or/xor rd, rs1, rs2 // and/or/xor rd, rd, rs3 let IsCommutable = 1 in -def TuneFusionLogicRegReg - : SimpleFusion<"logic-reg-reg", "HasFusionLogicRegReg", - "Enable AND/OR/XOR+AND/OR/XOR macrofusion", - CheckOpcode<LogicOp>, - CheckOpcode<LogicOp>>; +def : SimpleFusionFor<TuneFusionLogicRegReg, + CheckOpcode<LogicOp>, + CheckOpcode<LogicOp>>; // Fuse logic operation followed by logic immediate operation: // and/or/xor rd, rs1, rs2 // andi/ori/xori rd, rd, imm -def TuneFusionLogicRegImm - : SimpleFusion<"logic-reg-imm", "HasFusionLogicRegImm", - "Enable AND/OR/XOR+ANDI/ORI/XORI macrofusion", - CheckOpcode<LogicOp>, - CheckOpcode<LogicImmOp>>; +def : SimpleFusionFor<TuneFusionLogicRegImm, + CheckOpcode<LogicOp>, + CheckOpcode<LogicImmOp>>; // Fuse logic immediate operation followed by logic operation: // andi/ori/xori rd, rs1, imm // and/or/xor rd, rd, rs2 let IsCommutable = 1 in -def TuneFusionLogicImmReg - : SimpleFusion<"logic-imm-reg", "HasFusionLogicImmReg", - "Enable ANDI/ORI/XORI+AND/OR/XOR macrofusion", - CheckOpcode<LogicImmOp>, - CheckOpcode<LogicOp>>; +def : SimpleFusionFor<TuneFusionLogicImmReg, + CheckOpcode<LogicImmOp>, + CheckOpcode<LogicOp>>; // Fuse multiply followed by add: // mul(w) rd, rs1, rs2 // add(w) rd, rd, rs3 -def TuneFusionMulAdd - : SimpleFusion<"mul-add", "HasFusionMulAdd", - "Enable MUL+ADD macrofusion", - CheckOpcode<[MUL, MULW]>, - CheckOpcode<[ADD, ADDW]>, - epilog = [ - // Check that both instructions have the same width - FusionPredicateWithCode<[{ - if ((FirstMI->getDesc().TSFlags & RISCVII::IsSignExtendingOpWMask) != - (SecondMI.getDesc().TSFlags & RISCVII::IsSignExtendingOpWMask)) - return false; - }]>, - SecondFusionPredicateWithMCInstPredicate< - CheckNot<CheckSameRegOperand<0, 2>> - > - ]>; +def : SimpleFusionFor<TuneFusionMulAdd, + CheckOpcode<[MUL, MULW]>, + CheckOpcode<[ADD, ADDW]>, + epilog = [ + // Check that both instructions have the same width + FusionPredicateWithCode<[{ + if ((FirstMI->getDesc().TSFlags & RISCVII::IsSignExtendingOpWMask) != + (SecondMI.getDesc().TSFlags & RISCVII::IsSignExtendingOpWMask)) + return false; + }]>, + SecondFusionPredicateWithMCInstPredicate< + CheckNot<CheckSameRegOperand<0, 2>> + > + ]>; // Fuse add with load or store with zero offset: // add rd, rs1, rs2 // load/store rt, 0(rd) -def TuneFusionAddMem - : Fusion<"add-mem", "HasFusionAddMem", - "Enable ADD+LOAD/STORE macrofusion", - [ - SecondFusionPredicateWithMCInstPredicate< - CheckAll<[ - CheckOpcode<LoadStore>, - CheckImmOperand<2, 0> - ]> - >, - WildcardTrue, - FirstFusionPredicateWithMCInstPredicate< - CheckAll<[ - CheckOpcode<[ADD]>, - CheckNot<CheckSameRegOperand<0, 1>>, - CheckNot<CheckSameRegOperand<0, 2>> - ]> - >, - TieReg<0, 1> - ]>; +def : FusionFor<TuneFusionAddMem, + [ + SecondFusionPredicateWithMCInstPredicate< + CheckAll<[ + CheckOpcode<LoadStore>, + CheckImmOperand<2, 0> + ]> + >, + WildcardTrue, + FirstFusionPredicateWithMCInstPredicate< + CheckAll<[ + CheckOpcode<[ADD]>, + CheckNot<CheckSameRegOperand<0, 1>>, + CheckNot<CheckSameRegOperand<0, 2>> + ]> + >, + TieReg<0, 1> + ]>; // Fuse shift left followed by shift right for bit extraction: // slli(w) rd, rs1, imm1 // srli(w)/srai(w) rd, rd, imm2 // where imm1 <= imm2 -def TuneFusionShiftBitExtract - : SimpleFusion<"shift-bit-extract", "HasFusionShiftBitExtract", - "Enable SLLI+SRLI/SRAI macrofusion", - CheckOpcode<ShiftLeft>, - CheckOpcode<ShiftRight>, - epilog = [ - // Check that both instructions have the same width - FusionPredicateWithCode<[{ - if ((FirstMI->getDesc().TSFlags & RISCVII::IsSignExtendingOpWMask) != - (SecondMI.getDesc().TSFlags & RISCVII::IsSignExtendingOpWMask)) - return false; - }]>, - // Check that FirstMI's immediate <= SecondMI's immediate - FusionPredicateWithCode<[{ - if (!(FirstMI->getOperand(2).isImm() && - SecondMI.getOperand(2).isImm() && - FirstMI->getOperand(2).getImm() <= - SecondMI.getOperand(2).getImm())) - return false; - }]>, - ]>; +def : SimpleFusionFor<TuneFusionShiftBitExtract, + CheckOpcode<ShiftLeft>, + CheckOpcode<ShiftRight>, + epilog = [ + // Check that both instructions have the same width + FusionPredicateWithCode<[{ + if ((FirstMI->getDesc().TSFlags & RISCVII::IsSignExtendingOpWMask) != + (SecondMI.getDesc().TSFlags & RISCVII::IsSignExtendingOpWMask)) + return false; + }]>, + // Check that FirstMI's immediate <= SecondMI's immediate + FusionPredicateWithCode<[{ + if (!(FirstMI->getOperand(2).isImm() && + SecondMI.getOperand(2).isImm() && + FirstMI->getOperand(2).getImm() <= + SecondMI.getOperand(2).getImm())) + return false; + }]>, + ]>; // Xqci macro fusions. diff --git a/llvm/lib/Target/RISCV/RISCVMacroFusionXQCI.td b/llvm/lib/Target/RISCV/RISCVMacroFusionXQCI.td index d1fc6ca0db983..9d4d1b8f51acc 100644 --- a/llvm/lib/Target/RISCV/RISCVMacroFusionXQCI.td +++ b/llvm/lib/Target/RISCV/RISCVMacroFusionXQCI.td @@ -18,88 +18,76 @@ defvar LongLoadStoreXqciOp = [QC_E_LB, QC_E_LBU, QC_E_LH, QC_E_LHU, QC_E_LW, defvar LongAccumXqciOp = [QC_E_XORAI, QC_E_ORAI, QC_E_ANDAI, QC_E_ADDAI]; // Fuse ... [truncated] `````````` </details> https://github.com/llvm/llvm-project/pull/239103 _______________________________________________ llvm-branch-commits mailing list [email protected] https://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-branch-commits
