DeadCodeElimination: Make DCE a separate class, called by DCEPass::run().

Instead of manually managing the internal state of the pass.
Also, use BasicBlockSet instead of SmallPtrSet.

Author: eeckstein

lib/SILOptimizer/Transforms/DeadCodeElimination.cpp

@@ -17,6 +17,7 @@
 #include "swift/SIL/SILBuilder.h"
 #include "swift/SIL/SILFunction.h"
 #include "swift/SIL/SILUndef.h"
+#include "swift/SIL/SILBitfield.h"
 #include "swift/SILOptimizer/Analysis/DominanceAnalysis.h"
 #include "swift/SILOptimizer/PassManager/Passes.h"
 #include "swift/SILOptimizer/PassManager/Transforms.h"
@@ -92,11 +93,12 @@ struct ControllingInfo {
   unsigned MinTreePredLevel;
 };
 
-class DCE : public SILFunctionTransform {
+class DCE {
   typedef llvm::DomTreeNodeBase<SILBasicBlock> PostDomTreeNode;
 
+  SILFunction *F;
   llvm::SmallPtrSet<SILNode *, 16> LiveValues;
-  llvm::SmallPtrSet<SILBasicBlock *, 16> LiveBlocks;
+  BasicBlockSet LiveBlocks;
   llvm::SmallVector<SILInstruction *, 64> Worklist;
   PostDominanceInfo *PDT;
   llvm::DenseMap<SILBasicBlock *, ControllingInfo> ControllingInfoMap;
@@ -119,72 +121,20 @@ class DCE : public SILFunctionTransform {
       ReverseDependencies;
 
   /// Tracks if the pass changed branches.
-  bool BranchesChanged;
+  bool BranchesChanged = false;
   /// Tracks if the pass changed ApplyInsts.
-  bool CallsChanged;
+  bool CallsChanged = false;
 
-  /// The entry point to the transformation.
-  void run() override {
-    BranchesChanged = false;
-    CallsChanged = false;
-
-    SILFunction *F = getFunction();
-    auto *DA = PM->getAnalysis<PostDominanceAnalysis>();
-    PDT = DA->get(F);
-
-    // If we have a function that consists of nothing but a
-    // structurally infinite loop like:
-    //   while true {}
-    // we'll have an empty post dominator tree.
-    if (!PDT->getRootNode())
-      return;
-
-    LLVM_DEBUG(F->dump());
-    LLVM_DEBUG(PDT->print(llvm::dbgs()));
-
-    assert(Worklist.empty() && LiveValues.empty() && LiveBlocks.empty() &&
-           ControllingInfoMap.empty() && ReverseDependencies.empty() &&
-           "Expected to start with empty data structures!");
-
-    if (!precomputeControlInfo(*F)) {
-      LiveValues.clear();
-      LiveBlocks.clear();
-      ControllingInfoMap.clear();
-      ReverseDependencies.clear();
-      return;
-    }
-
-    markLive(*F);
-    if (removeDead(*F)) {
-      using InvalidationKind = SILAnalysis::InvalidationKind;
-
-      unsigned Inv = InvalidationKind::Instructions;
-      if (CallsChanged)
-        Inv |= (unsigned)InvalidationKind::Calls;
-      if (BranchesChanged) {
-        removeUnreachableBlocks(*F);
-        Inv |= (unsigned)InvalidationKind::Branches;
-      }
-
-      invalidateAnalysis(SILAnalysis::InvalidationKind(Inv));
-    }
-
-    LiveValues.clear();
-    LiveBlocks.clear();
-    ControllingInfoMap.clear();
-    ReverseDependencies.clear();
-  }
-
-  bool precomputeControlInfo(SILFunction &F);
-  void markLive(SILFunction &F);
+  bool precomputeControlInfo();
+  void markLive();
   /// Record a reverse dependency from \p from to \p to meaning \p to is live
   /// if \p from is also live.
   void addReverseDependency(SILValue from, SILInstruction *to);
-  bool removeDead(SILFunction &F);
+  bool removeDead();
 
   void computeLevelNumbers(PostDomTreeNode *root);
-  bool hasInfiniteLoops(SILFunction &F);
-  void computePredecessorDependence(SILFunction &F);
+  bool hasInfiniteLoops();
+  void computePredecessorDependence();
   void computeMinPredecessorLevels(PostDomTreeNode *root);
   void insertControllingInfo(SILBasicBlock *Block, unsigned Level);
 
@@ -204,6 +154,21 @@ class DCE : public SILFunctionTransform {
   /// If \p value is live, insert a lifetime ending operation in ossa.
   /// destroy_value for @owned value and end_borrow for a @guaranteed value.
   void endLifetimeOfLiveValue(SILValue value, SILInstruction *insertPt);
+
+public:
+  DCE(SILFunction *F, PostDominanceInfo *PDT) : F(F), LiveBlocks(F), PDT(PDT) {}
+
+  /// The entry point to the transformation.
+  bool run() {
+    if (!precomputeControlInfo())
+      return false;
+
+    markLive();
+    return removeDead();
+  }
+  
+  bool mustInvalidateCalls() const { return CallsChanged; }
+  bool mustInvalidateBranches() const { return BranchesChanged; }
 };
 
 // Keep track of the fact that V is live and add it to our worklist
@@ -252,11 +217,11 @@ static BuiltinInst *getProducer(CondFailInst *CFI) {
 }
 
 // Determine which instructions from this function we need to keep.
-void DCE::markLive(SILFunction &F) {
+void DCE::markLive() {
   // Find the initial set of instructions in this function that appear
   // to be live in the sense that they are not trivially something we
   // can delete by examining only that instruction.
-  for (auto &BB : F) {
+  for (auto &BB : *F) {
     for (auto &I : BB) {
       switch (I.getKind()) {
       case SILInstructionKind::CondFailInst: {
@@ -451,7 +416,11 @@ void DCE::propagateLiveness(SILInstruction *I) {
 SILBasicBlock *DCE::nearestUsefulPostDominator(SILBasicBlock *Block) {
   // Find the nearest post-dominator that has useful instructions.
   auto *PostDomNode = PDT->getNode(Block)->getIDom();
-  while (PostDomNode && !LiveBlocks.count(PostDomNode->getBlock()))
+  while (PostDomNode &&
+         // In case the PostDomNode's block is null, it means it's not contained
+         // in LiveBlocks.
+         (!PostDomNode->getBlock() ||
+          !LiveBlocks.contains(PostDomNode->getBlock())))
     PostDomNode = PostDomNode->getIDom();
 
   if (PostDomNode)
@@ -508,10 +477,10 @@ void DCE::endLifetimeOfLiveValue(SILValue value, SILInstruction *insertPt) {
 }
 
 // Remove the instructions that are not potentially useful.
-bool DCE::removeDead(SILFunction &F) {
+bool DCE::removeDead() {
   bool Changed = false;
 
-  for (auto &BB : F) {
+  for (auto &BB : *F) {
     for (unsigned i = 0; i < BB.getArguments().size();) {
       auto *arg = BB.getArgument(i);
       if (LiveValues.count(arg)) {
@@ -524,7 +493,7 @@ bool DCE::removeDead(SILFunction &F) {
 
       arg->replaceAllUsesWithUndef();
 
-      if (!F.hasOwnership() || arg->getOwnershipKind() == OwnershipKind::None) {
+      if (!F->hasOwnership() || arg->getOwnershipKind() == OwnershipKind::None) {
         i++;
         Changed = true;
         BranchesChanged = true;
@@ -591,7 +560,7 @@ bool DCE::removeDead(SILFunction &F) {
       LLVM_DEBUG(llvm::dbgs() << "Removing dead instruction:\n");
       LLVM_DEBUG(Inst->dump());
 
-      if (F.hasOwnership()) {
+      if (F->hasOwnership()) {
         for (auto &Op : Inst->getAllOperands()) {
           if (Op.isLifetimeEnding()) {
             endLifetimeOfLiveValue(Op.get(), Inst);
@@ -631,11 +600,11 @@ bool DCE::removeDead(SILFunction &F) {
 //
 // Returns true upon success, false if nodes that are not present in the
 // post-dominator tree are detected.
-bool DCE::precomputeControlInfo(SILFunction &F) {
+bool DCE::precomputeControlInfo() {
   computeLevelNumbers(PDT->getRootNode());
-  if (hasInfiniteLoops(F))
+  if (hasInfiniteLoops())
     return false;
-  computePredecessorDependence(F);
+  computePredecessorDependence();
   computeMinPredecessorLevels(PDT->getRootNode());
   return true;
 }
@@ -680,8 +649,8 @@ void DCE::computeLevelNumbers(PostDomTreeNode *root) {
 // elimination. Note this will also hit for unreachable code, but
 // presumably we'll run DCE at some point after removing unreachable
 // code.
-bool DCE::hasInfiniteLoops(SILFunction &F) {
-  for (auto &BB : F)
+bool DCE::hasInfiniteLoops() {
+  for (auto &BB : *F)
     if (ControllingInfoMap.find(&BB) == ControllingInfoMap.end())
       return true;
 
@@ -691,8 +660,8 @@ bool DCE::hasInfiniteLoops(SILFunction &F) {
 // For each block, create a list of the direct predecessors that the
 // block is control-dependent on. With each predecessor, also keep the
 // level number of the predecessor in the post-dominator tree.
-void DCE::computePredecessorDependence(SILFunction &F) {
-  for (auto &BB : F) {
+void DCE::computePredecessorDependence() {
+  for (auto &BB : *F) {
     assert(ControllingInfoMap.find(&BB) != ControllingInfoMap.end()
            && "Expected to already have a map entry for block!");
 
@@ -792,7 +761,7 @@ void DCE::collectControllingBlocks(SILBasicBlock *Block,
 }
 
 void DCE::markControllingTerminatorsLive(SILBasicBlock *Block) {
-  if (LiveBlocks.count(Block))
+  if (LiveBlocks.contains(Block))
     return;
 
   LiveBlocks.insert(Block);
@@ -804,8 +773,42 @@ void DCE::markControllingTerminatorsLive(SILBasicBlock *Block) {
     markValueLive(BB->getTerminator());
 }
 
+class DCEPass : public SILFunctionTransform {
+public:
+  /// The entry point to the transformation.
+  void run() override {
+    SILFunction *F = getFunction();
+
+    LLVM_DEBUG(llvm::dbgs() << "*** DCE on function: " << F->getName()
+                            << " ***\n");
+
+    auto *DA = PM->getAnalysis<PostDominanceAnalysis>();
+    PostDominanceInfo *PDT = DA->get(F);
+
+    // If we have a function that consists of nothing but a
+    // structurally infinite loop like:
+    //   while true {}
+    // we'll have an empty post dominator tree.
+    if (!PDT->getRootNode())
+      return;
+
+    DCE dce(F, PDT);
+    if (dce.run()) {
+      using InvalidationKind = SILAnalysis::InvalidationKind;
+      unsigned Inv = InvalidationKind::Instructions;
+      if (dce.mustInvalidateCalls())
+        Inv |= (unsigned)InvalidationKind::Calls;
+      if (dce.mustInvalidateBranches()) {
+        removeUnreachableBlocks(*F);
+        Inv |= (unsigned)InvalidationKind::Branches;
+      }
+      invalidateAnalysis(SILAnalysis::InvalidationKind(Inv));
+    }
+  }
+};
+
 } // end anonymous namespace
 
 SILTransform *swift::createDCE() {
-  return new DCE();
+  return new DCEPass();
 }