[llvm] [CodeGen][NPM] Port MachinePipeliner to NPM (PR #221676)
Vikram Hegde via llvm-commits
llvm-commits at lists.llvm.org
Tue Sep 8 23:46:54 PDT 2026
https://github.com/vikramRH updated https://github.com/llvm/llvm-project/pull/221676
>From 3859ad090b0caa454107224bfa8edf94fea396fe Mon Sep 17 00:00:00 2001
From: vikhegde <vikram.hegde at amd.com>
Date: Mon, 7 Sep 2026 11:04:55 +0530
Subject: [PATCH 1/2] [CodeGen][NPM] Port MachinePipeliner to NPM
---
llvm/include/llvm/CodeGen/MachinePipeliner.h | 39 ++++--
llvm/include/llvm/InitializePasses.h | 2 +-
.../llvm/Passes/MachinePassRegistry.def | 1 +
llvm/lib/CodeGen/CodeGen.cpp | 2 +-
llvm/lib/CodeGen/MachinePipeliner.cpp | 123 +++++++++++++-----
llvm/lib/Passes/PassBuilder.cpp | 1 +
.../lib/Target/AMDGPU/AMDGPUTargetMachine.cpp | 3 +
.../AMDGPU/swp-amdgpu-pipeline-epilog-phi.mir | 1 +
.../swp-amdgpu-pipeline-gen-structure.mir | 1 +
.../swp-amdgpu-pipeline-loop-carried-mem.mir | 1 +
10 files changed, 132 insertions(+), 42 deletions(-)
diff --git a/llvm/include/llvm/CodeGen/MachinePipeliner.h b/llvm/include/llvm/CodeGen/MachinePipeliner.h
index 7b2d1226530d3..295b686a50aac 100644
--- a/llvm/include/llvm/CodeGen/MachinePipeliner.h
+++ b/llvm/include/llvm/CodeGen/MachinePipeliner.h
@@ -57,8 +57,10 @@
namespace llvm {
class AAResults;
+class LiveIntervals;
class NodeSet;
class SMSchedule;
+class TargetMachine;
extern LLVM_ABI cl::opt<bool> SwpEnableCopyToPhi;
extern LLVM_ABI cl::opt<int> SwpForceIssueWidth;
@@ -73,14 +75,17 @@ struct MachinePipelinerPolicy {
/// The main class in the implementation of the target independent
/// software pipeliner pass.
-class LLVM_ABI MachinePipeliner : public MachineFunctionPass {
+class LLVM_ABI MachinePipeliner {
public:
MachineFunction *MF = nullptr;
MachineOptimizationRemarkEmitter *ORE = nullptr;
const MachineLoopInfo *MLI = nullptr;
const InstrItineraryData *InstrItins = nullptr;
const TargetInstrInfo *TII = nullptr;
- const RegisterClassInfo *RegClassInfo = nullptr;
+ RegisterClassInfo *RegClassInfo = nullptr;
+ LiveIntervals *LIS = nullptr;
+ AAResults *AA = nullptr;
+ const TargetMachine *TM = nullptr;
bool disabledByPragma = false;
unsigned II_setByPragma = 0;
@@ -100,13 +105,13 @@ class LLVM_ABI MachinePipeliner : public MachineFunctionPass {
};
LoopInfo LI;
- static char ID;
-
- MachinePipeliner() : MachineFunctionPass(ID) {}
+ MachinePipeliner(MachineFunction &MF, const MachineLoopInfo &MLI,
+ LiveIntervals &LIS, AAResults &AA,
+ MachineOptimizationRemarkEmitter &ORE,
+ RegisterClassInfo &RegClassInfo);
- bool runOnMachineFunction(MachineFunction &MF) override;
-
- void getAnalysisUsage(AnalysisUsage &AU) const override;
+ /// Run the software pipeliner over all loops in the function.
+ bool run();
private:
void preprocessPhiNodes(MachineBasicBlock &B);
@@ -119,6 +124,24 @@ class LLVM_ABI MachinePipeliner : public MachineFunctionPass {
bool useWindowScheduler(bool Changed);
};
+class LLVM_ABI MachinePipelinerLegacy : public MachineFunctionPass {
+public:
+ static char ID;
+
+ MachinePipelinerLegacy() : MachineFunctionPass(ID) {}
+
+ bool runOnMachineFunction(MachineFunction &MF) override;
+
+ void getAnalysisUsage(AnalysisUsage &AU) const override;
+};
+
+class LLVM_ABI MachinePipelinerPass
+ : public OptionalPassInfoMixin<MachinePipelinerPass> {
+public:
+ PreservedAnalyses run(MachineFunction &MF,
+ MachineFunctionAnalysisManager &MFAM);
+};
+
/// Represents a dependence between two instruction.
class SwingSchedulerDDGEdge {
SUnit *Dst = nullptr;
diff --git a/llvm/include/llvm/InitializePasses.h b/llvm/include/llvm/InitializePasses.h
index 1fa4565bef193..1ba2f67d27e5d 100644
--- a/llvm/include/llvm/InitializePasses.h
+++ b/llvm/include/llvm/InitializePasses.h
@@ -215,7 +215,7 @@ initializeMachineOptimizationRemarkEmitterPassPass(PassRegistry &);
LLVM_ABI void initializeMachineOutlinerPass(PassRegistry &);
LLVM_ABI void initializeStaticDataProfileInfoWrapperPassPass(PassRegistry &);
LLVM_ABI void initializeStaticDataAnnotatorLegacyPass(PassRegistry &);
-LLVM_ABI void initializeMachinePipelinerPass(PassRegistry &);
+LLVM_ABI void initializeMachinePipelinerLegacyPass(PassRegistry &);
LLVM_ABI void initializeMachinePostDominatorTreeWrapperPassPass(PassRegistry &);
LLVM_ABI void initializeMachineRegionInfoPassPass(PassRegistry &);
LLVM_ABI void initializeMachineRegisterClassInfoWrapperPassPass(PassRegistry &);
diff --git a/llvm/include/llvm/Passes/MachinePassRegistry.def b/llvm/include/llvm/Passes/MachinePassRegistry.def
index 63c0fa4a65ffe..78253532a8570 100644
--- a/llvm/include/llvm/Passes/MachinePassRegistry.def
+++ b/llvm/include/llvm/Passes/MachinePassRegistry.def
@@ -104,6 +104,7 @@ MACHINE_FUNCTION_PASS("opt-phis", OptimizePHIsPass())
MACHINE_FUNCTION_PASS("patchable-function", PatchableFunctionPass())
MACHINE_FUNCTION_PASS("peephole-opt", PeepholeOptimizerPass())
MACHINE_FUNCTION_PASS("phi-node-elimination", PHIEliminationPass())
+MACHINE_FUNCTION_PASS("pipeliner", MachinePipelinerPass())
MACHINE_FUNCTION_PASS("post-RA-hazard-rec", PostRAHazardRecognizerPass())
MACHINE_FUNCTION_PASS("post-RA-sched", PostRASchedulerPass(TM))
MACHINE_FUNCTION_PASS("postra-machine-sink", PostRAMachineSinkingPass())
diff --git a/llvm/lib/CodeGen/CodeGen.cpp b/llvm/lib/CodeGen/CodeGen.cpp
index c9f14737c392c..efa9bdc635c5f 100644
--- a/llvm/lib/CodeGen/CodeGen.cpp
+++ b/llvm/lib/CodeGen/CodeGen.cpp
@@ -102,7 +102,7 @@ void llvm::initializeCodeGen(PassRegistry &Registry) {
initializeMachineModuleInfoWrapperPassPass(Registry);
initializeMachineOptimizationRemarkEmitterPassPass(Registry);
initializeMachineOutlinerPass(Registry);
- initializeMachinePipelinerPass(Registry);
+ initializeMachinePipelinerLegacyPass(Registry);
initializeMachineSanitizerBinaryMetadataLegacyPass(Registry);
initializeModuloScheduleTestPass(Registry);
initializeMachinePostDominatorTreeWrapperPassPass(Registry);
diff --git a/llvm/lib/CodeGen/MachinePipeliner.cpp b/llvm/lib/CodeGen/MachinePipeliner.cpp
index 8ce8351b2af46..97bc95c999097 100644
--- a/llvm/lib/CodeGen/MachinePipeliner.cpp
+++ b/llvm/lib/CodeGen/MachinePipeliner.cpp
@@ -56,6 +56,7 @@
#include "llvm/CodeGen/MachineLoopInfo.h"
#include "llvm/CodeGen/MachineMemOperand.h"
#include "llvm/CodeGen/MachineOperand.h"
+#include "llvm/CodeGen/MachinePassManager.h"
#include "llvm/CodeGen/MachineRegisterInfo.h"
#include "llvm/CodeGen/ModuloSchedule.h"
#include "llvm/CodeGen/Register.h"
@@ -226,19 +227,19 @@ static cl::opt<WindowSchedulingFlag> WindowSchedulingOption(
"Use window algorithm instead of SMS algorithm.")));
unsigned SwingSchedulerDAG::Circuits::MaxPaths = 5;
-char MachinePipeliner::ID = 0;
+char MachinePipelinerLegacy::ID = 0;
#ifndef NDEBUG
int MachinePipeliner::NumTries = 0;
#endif
-char &llvm::MachinePipelinerID = MachinePipeliner::ID;
+char &llvm::MachinePipelinerID = MachinePipelinerLegacy::ID;
-INITIALIZE_PASS_BEGIN(MachinePipeliner, DEBUG_TYPE,
+INITIALIZE_PASS_BEGIN(MachinePipelinerLegacy, DEBUG_TYPE,
"Modulo Software Pipelining", false, false)
INITIALIZE_PASS_DEPENDENCY(AAResultsWrapperPass)
INITIALIZE_PASS_DEPENDENCY(MachineLoopInfoWrapperPass)
INITIALIZE_PASS_DEPENDENCY(LiveIntervalsWrapperPass)
INITIALIZE_PASS_DEPENDENCY(MachineRegisterClassInfoWrapperPass)
-INITIALIZE_PASS_END(MachinePipeliner, DEBUG_TYPE,
+INITIALIZE_PASS_END(MachinePipelinerLegacy, DEBUG_TYPE,
"Modulo Software Pipelining", false, false)
namespace {
@@ -359,38 +360,100 @@ class LoopCarriedOrderDepsTracker {
} // end anonymous namespace
+MachinePipeliner::MachinePipeliner(MachineFunction &MF,
+ const MachineLoopInfo &MLI,
+ LiveIntervals &LIS, AAResults &AA,
+ MachineOptimizationRemarkEmitter &ORE,
+ RegisterClassInfo &RegClassInfo)
+ : MF(&MF), ORE(&ORE), MLI(&MLI), TII(MF.getSubtarget().getInstrInfo()),
+ RegClassInfo(&RegClassInfo), LIS(&LIS), AA(&AA), TM(&MF.getTarget()) {}
+
/// The "main" function for implementing Swing Modulo Scheduling.
-bool MachinePipeliner::runOnMachineFunction(MachineFunction &mf) {
- if (skipFunction(mf.getFunction()))
- return false;
+bool MachinePipeliner::run() {
+ bool Changed = false;
+ for (const auto &L : *MLI)
+ Changed |= scheduleLoop(*L);
+
+ return Changed;
+}
+static bool runMachinePipeliner(
+ MachineFunction &MF, function_ref<const MachineLoopInfo &()> GetMLI,
+ function_ref<LiveIntervals &()> GetLIS, function_ref<AAResults &()> GetAA,
+ function_ref<MachineOptimizationRemarkEmitter &()> GetORE,
+ function_ref<RegisterClassInfo &()> GetRCI) {
if (!EnableSWP)
return false;
- if (mf.getFunction().getAttributes().hasFnAttr(Attribute::OptimizeForSize) &&
+ if (MF.getFunction().getAttributes().hasFnAttr(Attribute::OptimizeForSize) &&
!EnableSWPOptSize.getPosition())
return false;
- if (!mf.getSubtarget().enableMachinePipeliner())
+ if (!MF.getSubtarget().enableMachinePipeliner())
return false;
// Cannot pipeline loops without instruction itineraries if we are using
// DFA for the pipeliner.
- if (mf.getSubtarget().useDFAforSMS() &&
- (!mf.getSubtarget().getInstrItineraryData() ||
- mf.getSubtarget().getInstrItineraryData()->isEmpty()))
+ if (MF.getSubtarget().useDFAforSMS() &&
+ (!MF.getSubtarget().getInstrItineraryData() ||
+ MF.getSubtarget().getInstrItineraryData()->isEmpty()))
return false;
- MF = &mf;
- MLI = &getAnalysis<MachineLoopInfoWrapperPass>().getLI();
- ORE = &getAnalysis<MachineOptimizationRemarkEmitterPass>().getORE();
- RegClassInfo = &getAnalysis<MachineRegisterClassInfoWrapperPass>().getRCI();
- TII = MF->getSubtarget().getInstrInfo();
+ MachinePipeliner MP(MF, GetMLI(), GetLIS(), GetAA(), GetORE(), GetRCI());
+ return MP.run();
+}
- for (const auto &L : *MLI)
- scheduleLoop(*L);
+bool MachinePipelinerLegacy::runOnMachineFunction(MachineFunction &MF) {
+ if (skipFunction(MF.getFunction()))
+ return false;
- return false;
+ return runMachinePipeliner(
+ MF,
+ [&]() -> const MachineLoopInfo & {
+ return getAnalysis<MachineLoopInfoWrapperPass>().getLI();
+ },
+ [&]() -> LiveIntervals & {
+ return getAnalysis<LiveIntervalsWrapperPass>().getLIS();
+ },
+ [&]() -> AAResults & {
+ return getAnalysis<AAResultsWrapperPass>().getAAResults();
+ },
+ [&]() -> MachineOptimizationRemarkEmitter & {
+ return getAnalysis<MachineOptimizationRemarkEmitterPass>().getORE();
+ },
+ [&]() -> RegisterClassInfo & {
+ return getAnalysis<MachineRegisterClassInfoWrapperPass>().getRCI();
+ });
+}
+
+PreservedAnalyses
+MachinePipelinerPass::run(MachineFunction &MF,
+ MachineFunctionAnalysisManager &MFAM) {
+ if (!runMachinePipeliner(
+ MF,
+ [&]() -> const MachineLoopInfo & {
+ return MFAM.getResult<MachineLoopAnalysis>(MF);
+ },
+ [&]() -> LiveIntervals & {
+ return MFAM.getResult<LiveIntervalsAnalysis>(MF);
+ },
+ [&]() -> AAResults & {
+ return MFAM
+ .getResult<FunctionAnalysisManagerMachineFunctionProxy>(MF)
+ .getManager()
+ .getResult<AAManager>(MF.getFunction());
+ },
+ [&]() -> MachineOptimizationRemarkEmitter & {
+ return MFAM.getResult<MachineOptimizationRemarkEmitterAnalysis>(MF);
+ },
+ [&]() -> RegisterClassInfo & {
+ return MFAM.getResult<MachineRegisterClassAnalysis>(MF);
+ }))
+ return PreservedAnalyses::all();
+
+ PreservedAnalyses PA = getMachineFunctionPassPreservedAnalyses();
+ PA.preserve<MachineRegisterClassAnalysis>();
+ return PA;
}
/// Attempt to perform the SMS algorithm on the specified loop. This function is
@@ -632,8 +695,7 @@ bool MachinePipeliner::canPipelineLoop(MachineLoop &L) {
void MachinePipeliner::preprocessPhiNodes(MachineBasicBlock &B) {
MachineRegisterInfo &MRI = MF->getRegInfo();
- SlotIndexes &Slots =
- *getAnalysis<LiveIntervalsWrapperPass>().getLIS().getSlotIndexes();
+ SlotIndexes &Slots = *LIS->getSlotIndexes();
for (MachineInstr &PI : B.phis()) {
MachineOperand &DefOp = PI.getOperand(0);
@@ -668,10 +730,8 @@ void MachinePipeliner::preprocessPhiNodes(MachineBasicBlock &B) {
bool MachinePipeliner::swingModuloScheduler(MachineLoop &L) {
assert(L.getBlocks().size() == 1 && "SMS works on single blocks only.");
- AliasAnalysis *AA = &getAnalysis<AAResultsWrapperPass>().getAAResults();
- SwingSchedulerDAG SMS(
- *this, L, getAnalysis<LiveIntervalsWrapperPass>().getLIS(), *RegClassInfo,
- II_setByPragma, LI.LoopPipelinerInfo.get(), AA);
+ SwingSchedulerDAG SMS(*this, L, *LIS, *RegClassInfo, II_setByPragma,
+ LI.LoopPipelinerInfo.get(), AA);
MachineBasicBlock *MBB = L.getHeader();
// The kernel should not include any terminator instructions. These
@@ -694,7 +754,7 @@ bool MachinePipeliner::swingModuloScheduler(MachineLoop &L) {
return SMS.hasNewSchedule();
}
-void MachinePipeliner::getAnalysisUsage(AnalysisUsage &AU) const {
+void MachinePipelinerLegacy::getAnalysisUsage(AnalysisUsage &AU) const {
AU.addRequired<AAResultsWrapperPass>();
AU.addPreserved<AAResultsWrapperPass>();
AU.addRequired<MachineLoopInfoWrapperPass>();
@@ -710,11 +770,10 @@ bool MachinePipeliner::runWindowScheduler(MachineLoop &L) {
MachineSchedContext Context;
Context.MF = MF;
Context.MLI = MLI;
- Context.TM = &getAnalysis<TargetPassConfig>().getTM<TargetMachine>();
- Context.AA = &getAnalysis<AAResultsWrapperPass>().getAAResults();
- Context.LIS = &getAnalysis<LiveIntervalsWrapperPass>().getLIS();
- Context.RegClassInfo =
- &getAnalysis<MachineRegisterClassInfoWrapperPass>().getRCI();
+ Context.TM = TM;
+ Context.AA = AA;
+ Context.LIS = LIS;
+ Context.RegClassInfo = RegClassInfo;
WindowScheduler WS(&Context, L);
return WS.run();
}
diff --git a/llvm/lib/Passes/PassBuilder.cpp b/llvm/lib/Passes/PassBuilder.cpp
index 81420f2ab885d..725ce2d589a31 100644
--- a/llvm/lib/Passes/PassBuilder.cpp
+++ b/llvm/lib/Passes/PassBuilder.cpp
@@ -151,6 +151,7 @@
#include "llvm/CodeGen/MachineLICM.h"
#include "llvm/CodeGen/MachineLateInstrsCleanup.h"
#include "llvm/CodeGen/MachinePassManager.h"
+#include "llvm/CodeGen/MachinePipeliner.h"
#include "llvm/CodeGen/MachinePostDominators.h"
#include "llvm/CodeGen/MachineRegionInfo.h"
#include "llvm/CodeGen/MachineRegisterInfo.h"
diff --git a/llvm/lib/Target/AMDGPU/AMDGPUTargetMachine.cpp b/llvm/lib/Target/AMDGPU/AMDGPUTargetMachine.cpp
index aa36e29b0bab6..f25fab4b24721 100644
--- a/llvm/lib/Target/AMDGPU/AMDGPUTargetMachine.cpp
+++ b/llvm/lib/Target/AMDGPU/AMDGPUTargetMachine.cpp
@@ -87,6 +87,7 @@
#include "llvm/CodeGen/MIRParser/MIParser.h"
#include "llvm/CodeGen/MachineCSE.h"
#include "llvm/CodeGen/MachineLICM.h"
+#include "llvm/CodeGen/MachinePipeliner.h"
#include "llvm/CodeGen/MachineScheduler.h"
#include "llvm/CodeGen/PHIElimination.h"
#include "llvm/CodeGen/Passes.h"
@@ -2648,6 +2649,8 @@ Error AMDGPUCodeGenPassBuilder::addOptimizedRegAlloc(PassManagerWrapper &PMW) {
void AMDGPUCodeGenPassBuilder::addPreRegAlloc(PassManagerWrapper &PMW) {
if (getOptLevel() != CodeGenOptLevel::None)
addMachineFunctionPass(AMDGPUPrepareAGPRAllocPass(), PMW);
+ if (getOptLevel() >= CodeGenOptLevel::Default && EnableMachinePipeliner)
+ addMachineFunctionPass(MachinePipelinerPass(), PMW);
}
Expected<bool> AMDGPUCodeGenPassBuilder::addRegAssignAndRewriteOptimized(
diff --git a/llvm/test/CodeGen/AMDGPU/swp-amdgpu-pipeline-epilog-phi.mir b/llvm/test/CodeGen/AMDGPU/swp-amdgpu-pipeline-epilog-phi.mir
index 1c1590eeb9822..56b37b6286da4 100644
--- a/llvm/test/CodeGen/AMDGPU/swp-amdgpu-pipeline-epilog-phi.mir
+++ b/llvm/test/CodeGen/AMDGPU/swp-amdgpu-pipeline-epilog-phi.mir
@@ -1,5 +1,6 @@
# NOTE: Assertions have been autogenerated by utils/update_mir_test_checks.py UTC_ARGS: --version 6
# RUN: llc -mtriple=amdgpu9.50-amd-amdhsa -run-pass=pipeliner -pipeliner-force-ii=12 %s -o - | FileCheck %s
+# RUN: llc -mtriple=amdgpu9.50-amd-amdhsa -passes=pipeliner -pipeliner-force-ii=12 %s -o - | FileCheck %s
# Two independent recurrences (a sum and a product) must be carried across the stage
# boundary without being swapped: each accumulator's kernel result has to flow through
# its own epilog PHI and drain op into its own store.
diff --git a/llvm/test/CodeGen/AMDGPU/swp-amdgpu-pipeline-gen-structure.mir b/llvm/test/CodeGen/AMDGPU/swp-amdgpu-pipeline-gen-structure.mir
index 7bad3042e571a..f2aae2e57fcaf 100644
--- a/llvm/test/CodeGen/AMDGPU/swp-amdgpu-pipeline-gen-structure.mir
+++ b/llvm/test/CodeGen/AMDGPU/swp-amdgpu-pipeline-gen-structure.mir
@@ -1,4 +1,5 @@
# RUN: llc -mtriple=amdgpu9.50-amd-amdhsa -run-pass=pipeliner -pipeliner-force-ii=8 %s -o - | FileCheck %s
+# RUN: llc -mtriple=amdgpu9.50-amd-amdhsa -passes=pipeliner -pipeliner-force-ii=8 %s -o - | FileCheck %s
# Verify the generated prolog / steady-state kernel / epilog structure of a pipelined loop.
# CHECK-LABEL: name: swp_amdgpu_pipeline_gen_structure
diff --git a/llvm/test/CodeGen/AMDGPU/swp-amdgpu-pipeline-loop-carried-mem.mir b/llvm/test/CodeGen/AMDGPU/swp-amdgpu-pipeline-loop-carried-mem.mir
index 9dc50350a8d6c..bb39f0339e6d8 100644
--- a/llvm/test/CodeGen/AMDGPU/swp-amdgpu-pipeline-loop-carried-mem.mir
+++ b/llvm/test/CodeGen/AMDGPU/swp-amdgpu-pipeline-loop-carried-mem.mir
@@ -1,4 +1,5 @@
# RUN: llc -mtriple=amdgpu9.50-amd-amdhsa -run-pass=pipeliner -debug-only=pipeliner %s -filetype=null 2>&1 | FileCheck %s
+# RUN: llc -mtriple=amdgpu9.50-amd-amdhsa -passes=pipeliner -debug-only=pipeliner %s -filetype=null 2>&1 | FileCheck %s
# REQUIRES: asserts
# A loop that loads a[i] and stores a[i+1] must get a loop-carried memory dependence
# between the load and the store, so they are not reordered across iterations.
>From d6ad6238ff4d90557baa372db546b2dd392f6d6a Mon Sep 17 00:00:00 2001
From: vikhegde <vikram.hegde at amd.com>
Date: Wed, 9 Sep 2026 12:16:08 +0530
Subject: [PATCH 2/2] comments
---
llvm/include/llvm/CodeGen/MachinePipeliner.h | 66 ++----------
llvm/lib/CodeGen/MachinePipeliner.cpp | 105 ++++++++++++++-----
2 files changed, 86 insertions(+), 85 deletions(-)
diff --git a/llvm/include/llvm/CodeGen/MachinePipeliner.h b/llvm/include/llvm/CodeGen/MachinePipeliner.h
index 295b686a50aac..dcf54cad0f85a 100644
--- a/llvm/include/llvm/CodeGen/MachinePipeliner.h
+++ b/llvm/include/llvm/CodeGen/MachinePipeliner.h
@@ -60,7 +60,6 @@ class AAResults;
class LiveIntervals;
class NodeSet;
class SMSchedule;
-class TargetMachine;
extern LLVM_ABI cl::opt<bool> SwpEnableCopyToPhi;
extern LLVM_ABI cl::opt<int> SwpForceIssueWidth;
@@ -73,57 +72,6 @@ struct MachinePipelinerPolicy {
bool ShouldLimitRegPressure = false;
};
-/// The main class in the implementation of the target independent
-/// software pipeliner pass.
-class LLVM_ABI MachinePipeliner {
-public:
- MachineFunction *MF = nullptr;
- MachineOptimizationRemarkEmitter *ORE = nullptr;
- const MachineLoopInfo *MLI = nullptr;
- const InstrItineraryData *InstrItins = nullptr;
- const TargetInstrInfo *TII = nullptr;
- RegisterClassInfo *RegClassInfo = nullptr;
- LiveIntervals *LIS = nullptr;
- AAResults *AA = nullptr;
- const TargetMachine *TM = nullptr;
- bool disabledByPragma = false;
- unsigned II_setByPragma = 0;
-
-#ifndef NDEBUG
- static int NumTries;
-#endif
-
- /// Cache the target analysis information about the loop.
- struct LoopInfo {
- MachineBasicBlock *TBB = nullptr;
- MachineBasicBlock *FBB = nullptr;
- SmallVector<MachineOperand, 4> BrCond;
- MachineInstr *LoopInductionVar = nullptr;
- MachineInstr *LoopCompare = nullptr;
- std::unique_ptr<TargetInstrInfo::PipelinerLoopInfo> LoopPipelinerInfo =
- nullptr;
- };
- LoopInfo LI;
-
- MachinePipeliner(MachineFunction &MF, const MachineLoopInfo &MLI,
- LiveIntervals &LIS, AAResults &AA,
- MachineOptimizationRemarkEmitter &ORE,
- RegisterClassInfo &RegClassInfo);
-
- /// Run the software pipeliner over all loops in the function.
- bool run();
-
-private:
- void preprocessPhiNodes(MachineBasicBlock &B);
- bool canPipelineLoop(MachineLoop &L);
- bool scheduleLoop(MachineLoop &L);
- bool swingModuloScheduler(MachineLoop &L);
- void setPragmaPipelineOptions(MachineLoop &L);
- bool runWindowScheduler(MachineLoop &L);
- bool useSwingModuloScheduler();
- bool useWindowScheduler(bool Changed);
-};
-
class LLVM_ABI MachinePipelinerLegacy : public MachineFunctionPass {
public:
static char ID;
@@ -310,7 +258,7 @@ class SwingSchedulerDDG {
/// This class builds the dependence graph for the instructions in a loop,
/// and attempts to schedule the instructions using the SMS algorithm.
class LLVM_ABI SwingSchedulerDAG : public ScheduleDAGInstrs {
- MachinePipeliner &Pass;
+ MachineOptimizationRemarkEmitter *ORE;
std::unique_ptr<SwingSchedulerDDG> DDG;
@@ -414,14 +362,16 @@ class LLVM_ABI SwingSchedulerDAG : public ScheduleDAGInstrs {
};
public:
- SwingSchedulerDAG(MachinePipeliner &P, MachineLoop &L, LiveIntervals &lis,
- const RegisterClassInfo &rci, unsigned II,
- TargetInstrInfo::PipelinerLoopInfo *PLI, AliasAnalysis *AA)
- : ScheduleDAGInstrs(*P.MF, P.MLI, false), Pass(P), Loop(L), LIS(lis),
+ SwingSchedulerDAG(MachineFunction &MF, const MachineLoopInfo *MLI,
+ MachineOptimizationRemarkEmitter *ORE, MachineLoop &L,
+ LiveIntervals &lis, const RegisterClassInfo &rci,
+ unsigned II, TargetInstrInfo::PipelinerLoopInfo *PLI,
+ AliasAnalysis *AA)
+ : ScheduleDAGInstrs(MF, MLI, false), ORE(ORE), Loop(L), LIS(lis),
RegClassInfo(rci), II_setByPragma(II), LoopPipelinerInfo(PLI),
Topo(SUnits, &ExitSU), AA(AA), BAA(*AA) {
initPolicy();
- P.MF->getSubtarget().getSMSMutations(Mutations);
+ MF.getSubtarget().getSMSMutations(Mutations);
if (SwpEnableCopyToPhi)
Mutations.push_back(std::make_unique<CopyToPhiMutation>());
BAA.enableCrossIterationMode();
diff --git a/llvm/lib/CodeGen/MachinePipeliner.cpp b/llvm/lib/CodeGen/MachinePipeliner.cpp
index 97bc95c999097..7b78ceacac1cc 100644
--- a/llvm/lib/CodeGen/MachinePipeliner.cpp
+++ b/llvm/lib/CodeGen/MachinePipeliner.cpp
@@ -228,9 +228,6 @@ static cl::opt<WindowSchedulingFlag> WindowSchedulingOption(
unsigned SwingSchedulerDAG::Circuits::MaxPaths = 5;
char MachinePipelinerLegacy::ID = 0;
-#ifndef NDEBUG
-int MachinePipeliner::NumTries = 0;
-#endif
char &llvm::MachinePipelinerID = MachinePipelinerLegacy::ID;
INITIALIZE_PASS_BEGIN(MachinePipelinerLegacy, DEBUG_TYPE,
@@ -358,18 +355,72 @@ class LoopCarriedOrderDepsTracker {
}
};
+/// The main class in the implementation of the target independent
+/// software pipeliner pass.
+class MachinePipelinerImpl {
+public:
+ MachineFunction *MF = nullptr;
+ MachineOptimizationRemarkEmitter *ORE = nullptr;
+ const MachineLoopInfo *MLI = nullptr;
+ const InstrItineraryData *InstrItins = nullptr;
+ const TargetInstrInfo *TII = nullptr;
+ RegisterClassInfo *RegClassInfo = nullptr;
+ LiveIntervals *LIS = nullptr;
+ AAResults *AA = nullptr;
+ const TargetMachine *TM = nullptr;
+ bool disabledByPragma = false;
+ unsigned II_setByPragma = 0;
+
+#ifndef NDEBUG
+ static int NumTries;
+#endif
+
+ /// Cache the target analysis information about the loop.
+ struct LoopInfo {
+ MachineBasicBlock *TBB = nullptr;
+ MachineBasicBlock *FBB = nullptr;
+ SmallVector<MachineOperand, 4> BrCond;
+ MachineInstr *LoopInductionVar = nullptr;
+ MachineInstr *LoopCompare = nullptr;
+ std::unique_ptr<TargetInstrInfo::PipelinerLoopInfo> LoopPipelinerInfo =
+ nullptr;
+ };
+ LoopInfo LI;
+
+ MachinePipelinerImpl(MachineFunction &MF, const MachineLoopInfo &MLI,
+ LiveIntervals &LIS, AAResults &AA,
+ MachineOptimizationRemarkEmitter &ORE,
+ RegisterClassInfo &RegClassInfo);
+
+ /// Run the software pipeliner over all loops in the function.
+ bool run();
+
+private:
+ void preprocessPhiNodes(MachineBasicBlock &B);
+ bool canPipelineLoop(MachineLoop &L);
+ bool scheduleLoop(MachineLoop &L);
+ bool swingModuloScheduler(MachineLoop &L);
+ void setPragmaPipelineOptions(MachineLoop &L);
+ bool runWindowScheduler(MachineLoop &L);
+ bool useSwingModuloScheduler();
+ bool useWindowScheduler(bool Changed);
+};
+
} // end anonymous namespace
-MachinePipeliner::MachinePipeliner(MachineFunction &MF,
- const MachineLoopInfo &MLI,
- LiveIntervals &LIS, AAResults &AA,
- MachineOptimizationRemarkEmitter &ORE,
- RegisterClassInfo &RegClassInfo)
+#ifndef NDEBUG
+int MachinePipelinerImpl::NumTries = 0;
+#endif
+
+MachinePipelinerImpl::MachinePipelinerImpl(
+ MachineFunction &MF, const MachineLoopInfo &MLI, LiveIntervals &LIS,
+ AAResults &AA, MachineOptimizationRemarkEmitter &ORE,
+ RegisterClassInfo &RegClassInfo)
: MF(&MF), ORE(&ORE), MLI(&MLI), TII(MF.getSubtarget().getInstrInfo()),
RegClassInfo(&RegClassInfo), LIS(&LIS), AA(&AA), TM(&MF.getTarget()) {}
/// The "main" function for implementing Swing Modulo Scheduling.
-bool MachinePipeliner::run() {
+bool MachinePipelinerImpl::run() {
bool Changed = false;
for (const auto &L : *MLI)
Changed |= scheduleLoop(*L);
@@ -399,7 +450,7 @@ static bool runMachinePipeliner(
MF.getSubtarget().getInstrItineraryData()->isEmpty()))
return false;
- MachinePipeliner MP(MF, GetMLI(), GetLIS(), GetAA(), GetORE(), GetRCI());
+ MachinePipelinerImpl MP(MF, GetMLI(), GetLIS(), GetAA(), GetORE(), GetRCI());
return MP.run();
}
@@ -460,7 +511,7 @@ MachinePipelinerPass::run(MachineFunction &MF,
/// the main entry point for the algorithm. The function identifies candidate
/// loops, calculates the minimum initiation interval, and attempts to schedule
/// the loop.
-bool MachinePipeliner::scheduleLoop(MachineLoop &L) {
+bool MachinePipelinerImpl::scheduleLoop(MachineLoop &L) {
bool Changed = false;
for (const auto &InnerLoop : L)
Changed |= scheduleLoop(*InnerLoop);
@@ -499,7 +550,7 @@ bool MachinePipeliner::scheduleLoop(MachineLoop &L) {
return Changed;
}
-void MachinePipeliner::setPragmaPipelineOptions(MachineLoop &L) {
+void MachinePipelinerImpl::setPragmaPipelineOptions(MachineLoop &L) {
// Reset the pragma for the next loop in iteration.
disabledByPragma = false;
II_setByPragma = 0;
@@ -605,7 +656,7 @@ static bool hasPHICycle(const MachineBasicBlock *LoopHeader,
/// Return true if the loop can be software pipelined. The algorithm is
/// restricted to loops with a single basic block. Make sure that the
/// branch in the loop can be analyzed.
-bool MachinePipeliner::canPipelineLoop(MachineLoop &L) {
+bool MachinePipelinerImpl::canPipelineLoop(MachineLoop &L) {
if (L.getNumBlocks() != 1) {
ORE->emit([&]() {
return MachineOptimizationRemarkAnalysis(DEBUG_TYPE, "canPipelineLoop",
@@ -693,7 +744,7 @@ bool MachinePipeliner::canPipelineLoop(MachineLoop &L) {
return true;
}
-void MachinePipeliner::preprocessPhiNodes(MachineBasicBlock &B) {
+void MachinePipelinerImpl::preprocessPhiNodes(MachineBasicBlock &B) {
MachineRegisterInfo &MRI = MF->getRegInfo();
SlotIndexes &Slots = *LIS->getSlotIndexes();
@@ -727,10 +778,10 @@ void MachinePipeliner::preprocessPhiNodes(MachineBasicBlock &B) {
/// 1. Computation and analysis of the dependence graph.
/// 2. Ordering of the nodes (instructions).
/// 3. Attempt to Schedule the loop.
-bool MachinePipeliner::swingModuloScheduler(MachineLoop &L) {
+bool MachinePipelinerImpl::swingModuloScheduler(MachineLoop &L) {
assert(L.getBlocks().size() == 1 && "SMS works on single blocks only.");
- SwingSchedulerDAG SMS(*this, L, *LIS, *RegClassInfo, II_setByPragma,
+ SwingSchedulerDAG SMS(*MF, MLI, ORE, L, *LIS, *RegClassInfo, II_setByPragma,
LI.LoopPipelinerInfo.get(), AA);
MachineBasicBlock *MBB = L.getHeader();
@@ -766,7 +817,7 @@ void MachinePipelinerLegacy::getAnalysisUsage(AnalysisUsage &AU) const {
MachineFunctionPass::getAnalysisUsage(AU);
}
-bool MachinePipeliner::runWindowScheduler(MachineLoop &L) {
+bool MachinePipelinerImpl::runWindowScheduler(MachineLoop &L) {
MachineSchedContext Context;
Context.MF = MF;
Context.MLI = MLI;
@@ -778,12 +829,12 @@ bool MachinePipeliner::runWindowScheduler(MachineLoop &L) {
return WS.run();
}
-bool MachinePipeliner::useSwingModuloScheduler() {
+bool MachinePipelinerImpl::useSwingModuloScheduler() {
// SwingModuloScheduler does not work when WindowScheduler is forced.
return WindowSchedulingOption != WindowSchedulingFlag::WS_Force;
}
-bool MachinePipeliner::useWindowScheduler(bool Changed) {
+bool MachinePipelinerImpl::useWindowScheduler(bool Changed) {
// WindowScheduler does not work for following cases:
// 1. when it is off.
// 2. when SwingModuloScheduler is successfully scheduled.
@@ -858,7 +909,7 @@ void SwingSchedulerDAG::schedule() {
if (MII == 0) {
LLVM_DEBUG(dbgs() << "Invalid Minimal Initiation Interval: 0\n");
NumFailZeroMII++;
- Pass.ORE->emit([&]() {
+ ORE->emit([&]() {
return MachineOptimizationRemarkAnalysis(
DEBUG_TYPE, "schedule", Loop.getStartLoc(), Loop.getHeader())
<< "Invalid Minimal Initiation Interval: 0";
@@ -871,7 +922,7 @@ void SwingSchedulerDAG::schedule() {
LLVM_DEBUG(dbgs() << "MII > " << SwpMaxMii
<< ", we don't pipeline large loops\n");
NumFailLargeMaxMII++;
- Pass.ORE->emit([&]() {
+ ORE->emit([&]() {
return MachineOptimizationRemarkAnalysis(
DEBUG_TYPE, "schedule", Loop.getStartLoc(), Loop.getHeader())
<< "Minimal Initiation Interval too large: "
@@ -915,13 +966,13 @@ void SwingSchedulerDAG::schedule() {
// check for node order issues
checkValidNodeOrder(Circuits);
- SMSchedule Schedule(Pass.MF, this);
+ SMSchedule Schedule(&MF, this);
Scheduled = schedulePipeline(Schedule);
if (!Scheduled){
LLVM_DEBUG(dbgs() << "No schedule found, return\n");
NumFailNoSchedule++;
- Pass.ORE->emit([&]() {
+ ORE->emit([&]() {
return MachineOptimizationRemarkAnalysis(
DEBUG_TYPE, "schedule", Loop.getStartLoc(), Loop.getHeader())
<< "Unable to find schedule";
@@ -934,7 +985,7 @@ void SwingSchedulerDAG::schedule() {
if (numStages == 0) {
LLVM_DEBUG(dbgs() << "No overlapped iterations, skip.\n");
NumFailZeroStage++;
- Pass.ORE->emit([&]() {
+ ORE->emit([&]() {
return MachineOptimizationRemarkAnalysis(
DEBUG_TYPE, "schedule", Loop.getStartLoc(), Loop.getHeader())
<< "No need to pipeline - no overlapped iterations in schedule.";
@@ -946,7 +997,7 @@ void SwingSchedulerDAG::schedule() {
LLVM_DEBUG(dbgs() << "numStages:" << numStages << ">" << SwpMaxStages
<< " : too many stages, abort\n");
NumFailLargeMaxStage++;
- Pass.ORE->emit([&]() {
+ ORE->emit([&]() {
return MachineOptimizationRemarkAnalysis(
DEBUG_TYPE, "schedule", Loop.getStartLoc(), Loop.getHeader())
<< "Too many stages in schedule: "
@@ -957,7 +1008,7 @@ void SwingSchedulerDAG::schedule() {
return;
}
- Pass.ORE->emit([&]() {
+ ORE->emit([&]() {
return MachineOptimizationRemark(DEBUG_TYPE, "schedule", Loop.getStartLoc(),
Loop.getHeader())
<< "Pipelined succesfully!";
@@ -2959,7 +3010,7 @@ bool SwingSchedulerDAG::schedulePipeline(SMSchedule &Schedule) {
if (scheduleFound) {
Schedule.finalizeSchedule(this);
- Pass.ORE->emit([&]() {
+ ORE->emit([&]() {
return MachineOptimizationRemarkAnalysis(
DEBUG_TYPE, "schedule", Loop.getStartLoc(), Loop.getHeader())
<< "Schedule found with Initiation Interval: "
More information about the llvm-commits
mailing list