[CodeGen][NPM] Port UnreachableMachineBlockElim to NPM

llvm/include/llvm/CodeGen/UnreachableBlockElim.h

@@ -22,6 +22,7 @@
 #ifndef LLVM_CODEGEN_UNREACHABLEBLOCKELIM_H
 #define LLVM_CODEGEN_UNREACHABLEBLOCKELIM_H
 
+#include "llvm/CodeGen/MachinePassManager.h"
 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
@@ -31,6 +32,13 @@ class UnreachableBlockElimPass
 public:
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
 };
+
+class UnreachableMachineBlockElimPass
+    : public PassInfoMixin<UnreachableMachineBlockElimPass> {
+public:
+  PreservedAnalyses run(MachineFunction &F, MachineFunctionAnalysisManager &AM);
+};
+
 } // end namespace llvm
 
 #endif // LLVM_CODEGEN_UNREACHABLEBLOCKELIM_H

llvm/include/llvm/InitializePasses.h

@@ -315,7 +315,7 @@ void initializeUniformityInfoWrapperPassPass(PassRegistry &);
 void initializeUnifyLoopExitsLegacyPassPass(PassRegistry &);
 void initializeUnpackMachineBundlesPass(PassRegistry &);
 void initializeUnreachableBlockElimLegacyPassPass(PassRegistry &);
-void initializeUnreachableMachineBlockElimPass(PassRegistry &);
+void initializeUnreachableMachineBlockElimLegacyPass(PassRegistry &);
 void initializeVerifierLegacyPassPass(PassRegistry &);
 void initializeVirtRegMapWrapperLegacyPass(PassRegistry &);
 void initializeVirtRegRewriterPass(PassRegistry &);

llvm/include/llvm/Passes/CodeGenPassBuilder.h

@@ -47,6 +47,7 @@
 #include "llvm/CodeGen/JMCInstrumenter.h"
 #include "llvm/CodeGen/LiveDebugValuesPass.h"
 #include "llvm/CodeGen/LiveIntervals.h"
+#include "llvm/CodeGen/LiveVariables.h"
 #include "llvm/CodeGen/LocalStackSlotAllocation.h"
 #include "llvm/CodeGen/LowerEmuTLS.h"
 #include "llvm/CodeGen/MIRPrinter.h"
@@ -1172,7 +1173,21 @@ void CodeGenPassBuilder<Derived, TargetMachineT>::addOptimizedRegAlloc(
 
   addPass(ProcessImplicitDefsPass());
 
+  // LiveVariables currently requires pure SSA form.
+  //
+  // FIXME: Once TwoAddressInstruction pass no longer uses kill flags,
+  // LiveVariables can be removed completely, and LiveIntervals can be directly
+  // computed. (We still either need to regenerate kill flags after regalloc, or
+  // preferably fix the scavenger to not depend on them).
+  // FIXME: UnreachableMachineBlockElim is a dependant pass of LiveVariables.
+  // When LiveVariables is removed this has to be removed/moved either.
+  // Explicit addition of UnreachableMachineBlockElim allows stopping before or
+  // after it with -stop-before/-stop-after.
+  addPass(UnreachableMachineBlockElimPass());
+  addPass(RequireAnalysisPass<LiveVariablesAnalysis, MachineFunction>());
+
   // Edge splitting is smarter with machine loop info.
+  addPass(RequireAnalysisPass<MachineLoopAnalysis, MachineFunction>());
   addPass(PHIEliminationPass());
 
   // Eventually, we want to run LiveIntervals before PHI elimination.

llvm/include/llvm/Passes/MachinePassRegistry.def

@@ -194,6 +194,8 @@ MACHINE_FUNCTION_PASS("stack-slot-coloring", StackSlotColoringPass())
 MACHINE_FUNCTION_PASS("tailduplication", TailDuplicatePass())
 MACHINE_FUNCTION_PASS("trigger-verifier-error", TriggerVerifierErrorPass())
 MACHINE_FUNCTION_PASS("two-address-instruction", TwoAddressInstructionPass())
+MACHINE_FUNCTION_PASS("unreachable-mbb-elimination", 
+                      UnreachableMachineBlockElimPass())
 MACHINE_FUNCTION_PASS("verify", MachineVerifierPass())
 MACHINE_FUNCTION_PASS("verify<machine-trace-metrics>", MachineTraceMetricsVerifierPass())
 MACHINE_FUNCTION_PASS("xray-instrumentation", XRayInstrumentationPass())

llvm/lib/CodeGen/CodeGen.cpp

@@ -140,7 +140,7 @@ void llvm::initializeCodeGen(PassRegistry &Registry) {
   initializeTypePromotionLegacyPass(Registry);
   initializeUnpackMachineBundlesPass(Registry);
   initializeUnreachableBlockElimLegacyPassPass(Registry);
-  initializeUnreachableMachineBlockElimPass(Registry);
+  initializeUnreachableMachineBlockElimLegacyPass(Registry);
   initializeVirtRegMapWrapperLegacyPass(Registry);
   initializeVirtRegRewriterPass(Registry);
   initializeWasmEHPreparePass(Registry);

llvm/lib/CodeGen/LiveVariables.cpp

@@ -61,7 +61,7 @@ char LiveVariablesWrapperPass::ID = 0;
 char &llvm::LiveVariablesID = LiveVariablesWrapperPass::ID;
 INITIALIZE_PASS_BEGIN(LiveVariablesWrapperPass, "livevars",
                       "Live Variable Analysis", false, false)
-INITIALIZE_PASS_DEPENDENCY(UnreachableMachineBlockElim)
+INITIALIZE_PASS_DEPENDENCY(UnreachableMachineBlockElimLegacy)
 INITIALIZE_PASS_END(LiveVariablesWrapperPass, "livevars",
                     "Live Variable Analysis", false, false)
 

llvm/lib/CodeGen/UnreachableBlockElim.cpp

@@ -72,39 +72,72 @@ PreservedAnalyses UnreachableBlockElimPass::run(Function &F,
 }
 
 namespace {
-  class UnreachableMachineBlockElim : public MachineFunctionPass {
-    bool runOnMachineFunction(MachineFunction &F) override;
-    void getAnalysisUsage(AnalysisUsage &AU) const override;
-
-  public:
-    static char ID; // Pass identification, replacement for typeid
-    UnreachableMachineBlockElim() : MachineFunctionPass(ID) {}
-  };
-}
-char UnreachableMachineBlockElim::ID = 0;
+class UnreachableMachineBlockElim {
+  MachineDominatorTree *MDT;
+  MachineLoopInfo *MLI;
+
+public:
+  UnreachableMachineBlockElim(MachineDominatorTree *MDT, MachineLoopInfo *MLI)
+      : MDT(MDT), MLI(MLI) {}
+  bool run(MachineFunction &MF);
+};
+
+class UnreachableMachineBlockElimLegacy : public MachineFunctionPass {
+  bool runOnMachineFunction(MachineFunction &F) override;
+  void getAnalysisUsage(AnalysisUsage &AU) const override;
+
+public:
+  static char ID; // Pass identification, replacement for typeid
+  UnreachableMachineBlockElimLegacy() : MachineFunctionPass(ID) {}
+};
+} // namespace
+
+char UnreachableMachineBlockElimLegacy::ID = 0;
 
-INITIALIZE_PASS(UnreachableMachineBlockElim, "unreachable-mbb-elimination",
-  "Remove unreachable machine basic blocks", false, false)
+INITIALIZE_PASS(UnreachableMachineBlockElimLegacy,
+                "unreachable-mbb-elimination",
+                "Remove unreachable machine basic blocks", false, false)
 
-char &llvm::UnreachableMachineBlockElimID = UnreachableMachineBlockElim::ID;
+char &llvm::UnreachableMachineBlockElimID =
+    UnreachableMachineBlockElimLegacy::ID;
 
-void UnreachableMachineBlockElim::getAnalysisUsage(AnalysisUsage &AU) const {
+void UnreachableMachineBlockElimLegacy::getAnalysisUsage(
+    AnalysisUsage &AU) const {
   AU.addPreserved<MachineLoopInfoWrapperPass>();
   AU.addPreserved<MachineDominatorTreeWrapperPass>();
   MachineFunctionPass::getAnalysisUsage(AU);
 }
 
-bool UnreachableMachineBlockElim::runOnMachineFunction(MachineFunction &F) {
-  df_iterator_default_set<MachineBasicBlock*> Reachable;
-  bool ModifiedPHI = false;
+PreservedAnalyses
+UnreachableMachineBlockElimPass::run(MachineFunction &MF,
+                                     MachineFunctionAnalysisManager &AM) {
+  auto *MDT = AM.getCachedResult<MachineDominatorTreeAnalysis>(MF);
+  auto *MLI = AM.getCachedResult<MachineLoopAnalysis>(MF);
+
+  if (!UnreachableMachineBlockElim(MDT, MLI).run(MF))
+    return PreservedAnalyses::all();
+
+  return getMachineFunctionPassPreservedAnalyses()
+      .preserve<MachineLoopAnalysis>()
+      .preserve<MachineDominatorTreeAnalysis>();
+}
 
+bool UnreachableMachineBlockElimLegacy::runOnMachineFunction(
+    MachineFunction &MF) {
   MachineDominatorTreeWrapperPass *MDTWrapper =
       getAnalysisIfAvailable<MachineDominatorTreeWrapperPass>();
   MachineDominatorTree *MDT = MDTWrapper ? &MDTWrapper->getDomTree() : nullptr;
   MachineLoopInfoWrapperPass *MLIWrapper =
       getAnalysisIfAvailable<MachineLoopInfoWrapperPass>();
   MachineLoopInfo *MLI = MLIWrapper ? &MLIWrapper->getLI() : nullptr;
 
+  return UnreachableMachineBlockElim(MDT, MLI).run(MF);
+}
+
+bool UnreachableMachineBlockElim::run(MachineFunction &F) {
+  df_iterator_default_set<MachineBasicBlock *> Reachable;
+  bool ModifiedPHI = false;
+
   // Mark all reachable blocks.
   for (MachineBasicBlock *BB : depth_first_ext(&F, Reachable))
     (void)BB/* Mark all reachable blocks */;

llvm/lib/Passes/PassBuilder.cpp

@@ -167,6 +167,7 @@
 #include "llvm/CodeGen/TargetPassConfig.h"
 #include "llvm/CodeGen/TwoAddressInstructionPass.h"
 #include "llvm/CodeGen/TypePromotion.h"
+#include "llvm/CodeGen/UnreachableBlockElim.h"
 #include "llvm/CodeGen/VirtRegMap.h"
 #include "llvm/CodeGen/WasmEHPrepare.h"
 #include "llvm/CodeGen/WinEHPrepare.h"

llvm/test/CodeGen/Hexagon/unreachable-mbb-phi-subreg.mir

@@ -1,4 +1,5 @@
 # RUN: llc -mtriple=hexagon -run-pass unreachable-mbb-elimination %s -o - | FileCheck %s
+# RUN: llc -mtriple=hexagon -passes unreachable-mbb-elimination %s -o - | FileCheck %s
 
 ---
 name: fred

llvm/test/DebugInfo/MIR/X86/unreachable-block-call-site.mir

@@ -1,4 +1,5 @@
 # RUN: llc -emit-call-site-info -mtriple=x86_64-pc-linux -run-pass=unreachable-mbb-elimination -o - %s | FileCheck %s
+# RUN: llc -emit-call-site-info -mtriple=x86_64-pc-linux -passes=unreachable-mbb-elimination -o - %s | FileCheck %s
 
 # Verify that the call site information for the call residing in the eliminated
 # block is removed. This test case would previously trigger an assertion when