[llvm-branch-commits] [llvm] RISCV: Define macro fusion features separately from predicates (PR #239103)
via llvm-branch-commits
llvm-branch-commits at lists.llvm.org
Wed Nov 4 22:10:22 PST 2026
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
More information about the llvm-branch-commits
mailing list