3 files changed, 54 insertions, 24 deletions
diff --git a/llvm/lib/CodeGen/CodeGen.cpp b/llvm/lib/CodeGen/CodeGen.cpp
index e7e8a12..013a9b3 100644
--- a/llvm/lib/CodeGen/CodeGen.cpp
+++ b/llvm/lib/CodeGen/CodeGen.cpp
@@ -114,7 +114,7 @@ void llvm::initializeCodeGen(PassRegistry &Registry) {
   initializeRAGreedyPass(Registry);
   initializeRegAllocFastPass(Registry);
   initializeRegUsageInfoCollectorLegacyPass(Registry);
-  initializeRegUsageInfoPropagationPass(Registry);
+  initializeRegUsageInfoPropagationLegacyPass(Registry);
   initializeRegisterCoalescerPass(Registry);
   initializeRemoveLoadsIntoFakeUsesPass(Registry);
   initializeRemoveRedundantDebugValuesPass(Registry);
diff --git a/llvm/lib/CodeGen/RegUsageInfoPropagate.cpp b/llvm/lib/CodeGen/RegUsageInfoPropagate.cpp
index 5ffe6ac..3ca2e30 100644
--- a/llvm/lib/CodeGen/RegUsageInfoPropagate.cpp
+++ b/llvm/lib/CodeGen/RegUsageInfoPropagate.cpp
@@ -18,6 +18,7 @@
 ///
 //===----------------------------------------------------------------------===//
 
+#include "llvm/CodeGen/RegUsageInfoPropagate.h"
 #include "llvm/CodeGen/MachineBasicBlock.h"
 #include "llvm/CodeGen/MachineFrameInfo.h"
 #include "llvm/CodeGen/MachineFunctionPass.h"
@@ -25,8 +26,10 @@
 #include "llvm/CodeGen/MachineRegisterInfo.h"
 #include "llvm/CodeGen/Passes.h"
 #include "llvm/CodeGen/RegisterUsageInfo.h"
+#include "llvm/IR/Analysis.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Pass.h"
+#include "llvm/Passes/CodeGenPassBuilder.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 
@@ -38,26 +41,16 @@ using namespace llvm;
 
 namespace {
 
-class RegUsageInfoPropagation : public MachineFunctionPass {
+class RegUsageInfoPropagation {
 public:
-  RegUsageInfoPropagation() : MachineFunctionPass(ID) {
-    PassRegistry &Registry = *PassRegistry::getPassRegistry();
-    initializeRegUsageInfoPropagationPass(Registry);
-  }
+  explicit RegUsageInfoPropagation(PhysicalRegisterUsageInfo *PRUI)
+      : PRUI(PRUI) {}
 
-  StringRef getPassName() const override { return RUIP_NAME; }
-
-  bool runOnMachineFunction(MachineFunction &MF) override;
-
-  void getAnalysisUsage(AnalysisUsage &AU) const override {
-    AU.addRequired<PhysicalRegisterUsageInfoWrapperLegacy>();
-    AU.setPreservesAll();
-    MachineFunctionPass::getAnalysisUsage(AU);
-  }
-
-  static char ID;
+  bool run(MachineFunction &MF);
 
 private:
+  PhysicalRegisterUsageInfo *PRUI;
+
   static void setRegMask(MachineInstr &MI, ArrayRef<uint32_t> RegMask) {
     assert(RegMask.size() ==
            MachineOperand::getRegMaskSize(MI.getParent()->getParent()
@@ -71,15 +64,34 @@ private:
   }
 };
 
+class RegUsageInfoPropagationLegacy : public MachineFunctionPass {
+public:
+  static char ID;
+  RegUsageInfoPropagationLegacy() : MachineFunctionPass(ID) {
+    PassRegistry &Registry = *PassRegistry::getPassRegistry();
+    initializeRegUsageInfoPropagationLegacyPass(Registry);
+  }
+
+  StringRef getPassName() const override { return RUIP_NAME; }
+
+  bool runOnMachineFunction(MachineFunction &MF) override;
+
+  void getAnalysisUsage(AnalysisUsage &AU) const override {
+    AU.addRequired<PhysicalRegisterUsageInfoWrapperLegacy>();
+    AU.setPreservesAll();
+    MachineFunctionPass::getAnalysisUsage(AU);
+  }
+};
+
 } // end of anonymous namespace
 
-INITIALIZE_PASS_BEGIN(RegUsageInfoPropagation, "reg-usage-propagation",
+INITIALIZE_PASS_BEGIN(RegUsageInfoPropagationLegacy, "reg-usage-propagation",
                       RUIP_NAME, false, false)
 INITIALIZE_PASS_DEPENDENCY(PhysicalRegisterUsageInfoWrapperLegacy)
-INITIALIZE_PASS_END(RegUsageInfoPropagation, "reg-usage-propagation",
+INITIALIZE_PASS_END(RegUsageInfoPropagationLegacy, "reg-usage-propagation",
                     RUIP_NAME, false, false)
 
-char RegUsageInfoPropagation::ID = 0;
+char RegUsageInfoPropagationLegacy::ID = 0;
 
 // Assumes call instructions have a single reference to a function.
 static const Function *findCalledFunction(const Module &M,
@@ -95,12 +107,29 @@ static const Function *findCalledFunction(const Module &M,
   return nullptr;
 }
 
-bool RegUsageInfoPropagation::runOnMachineFunction(MachineFunction &MF) {
-  const Module &M = *MF.getFunction().getParent();
+bool RegUsageInfoPropagationLegacy::runOnMachineFunction(MachineFunction &MF) {
   PhysicalRegisterUsageInfo *PRUI =
       &getAnalysis<PhysicalRegisterUsageInfoWrapperLegacy>().getPRUI();
 
-  LLVM_DEBUG(dbgs() << " ++++++++++++++++++++ " << getPassName()
+  RegUsageInfoPropagation RUIP(PRUI);
+  return RUIP.run(MF);
+}
+
+PreservedAnalyses
+RegUsageInfoPropagationPass::run(MachineFunction &MF,
+                                 MachineFunctionAnalysisManager &MFAM) {
+  Module &MFA = *MF.getFunction().getParent();
+  auto *PRUI = MFAM.getResult<ModuleAnalysisManagerMachineFunctionProxy>(MF)
+                   .getCachedResult<PhysicalRegisterUsageAnalysis>(MFA);
+  assert(PRUI && "PhysicalRegisterUsageAnalysis not available");
+  RegUsageInfoPropagation(PRUI).run(MF);
+  return PreservedAnalyses::all();
+}
+
+bool RegUsageInfoPropagation::run(MachineFunction &MF) {
+  const Module &M = *MF.getFunction().getParent();
+
+  LLVM_DEBUG(dbgs() << " ++++++++++++++++++++ " << RUIP_NAME
                     << " ++++++++++++++++++++  \n");
   LLVM_DEBUG(dbgs() << "MachineFunction : " << MF.getName() << "\n");
 
@@ -151,5 +180,5 @@ bool RegUsageInfoPropagation::runOnMachineFunction(MachineFunction &MF) {
 }
 
 FunctionPass *llvm::createRegUsageInfoPropPass() {
-  return new RegUsageInfoPropagation();
+  return new RegUsageInfoPropagationLegacy();
 }
diff --git a/llvm/lib/Passes/PassBuilder.cpp b/llvm/lib/Passes/PassBuilder.cpp
index 88be4339..a181a28 100644
--- a/llvm/lib/Passes/PassBuilder.cpp
+++ b/llvm/lib/Passes/PassBuilder.cpp
@@ -121,6 +121,7 @@
 #include "llvm/CodeGen/PreISelIntrinsicLowering.h"
 #include "llvm/CodeGen/RegAllocFast.h"
 #include "llvm/CodeGen/RegUsageInfoCollector.h"
+#include "llvm/CodeGen/RegUsageInfoPropagate.h"
 #include "llvm/CodeGen/RegisterUsageInfo.h"
 #include "llvm/CodeGen/SafeStack.h"
 #include "llvm/CodeGen/SelectOptimize.h"