[llvm] r230806 - MachineDominators: Move applySplitCriticalEdges into the cpp file.

Benjamin Kramer benny.kra at GOOGLEMAIL.com
Fri Feb 27 15:13:14 PST 2015


Author: d0k
Date: Fri Feb 27 17:13:13 2015
New Revision: 230806

URL: http://llvm.org/viewvc/llvm-project?rev=230806&view=rev
Log:
MachineDominators: Move applySplitCriticalEdges into the cpp file.

It's too big for inlining anyways. Also clean it up slightly. No functionality
change intended.

Modified:
    llvm/trunk/include/llvm/CodeGen/MachineDominators.h
    llvm/trunk/lib/CodeGen/MachineDominators.cpp

Modified: llvm/trunk/include/llvm/CodeGen/MachineDominators.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/CodeGen/MachineDominators.h?rev=230806&r1=230805&r2=230806&view=diff
==============================================================================
--- llvm/trunk/include/llvm/CodeGen/MachineDominators.h (original)
+++ llvm/trunk/include/llvm/CodeGen/MachineDominators.h Fri Feb 27 17:13:13 2015
@@ -45,9 +45,6 @@ class MachineDominatorTree : public Mach
     MachineBasicBlock *FromBB;
     MachineBasicBlock *ToBB;
     MachineBasicBlock *NewBB;
-    CriticalEdge(MachineBasicBlock *FromBB, MachineBasicBlock *ToBB,
-                 MachineBasicBlock *NewBB)
-        : FromBB(FromBB), ToBB(ToBB), NewBB(NewBB) {}
   };
 
   /// \brief Pile up all the critical edges to be split.
@@ -67,74 +64,7 @@ class MachineDominatorTree : public Mach
   /// the fast query path of DT as much as possible.
   ///
   /// \post CriticalEdgesToSplit.empty().
-  void applySplitCriticalEdges() const {
-    // Bail out early if there is nothing to do.
-    if (CriticalEdgesToSplit.empty())
-      return;
-
-    // For each element in CriticalEdgesToSplit, remember whether or
-    // not element is the new immediate domminator of its successor.
-    // The mapping is done by index, i.e., the information for the ith
-    // element of CriticalEdgesToSplit is the ith element of IsNewIDom.
-    SmallVector<bool, 32> IsNewIDom;
-    IsNewIDom.resize(CriticalEdgesToSplit.size());
-    size_t Idx = 0;
-
-    // Collect all the dominance properties info, before invalidating
-    // the underlying DT.
-    for (CriticalEdge &Edge : CriticalEdgesToSplit) {
-      // Update dominator information.
-      MachineBasicBlock *Succ = Edge.ToBB;
-      MachineDomTreeNode *SucccDTNode = DT->getNode(Succ);
-
-      IsNewIDom[Idx] = true;
-      for (MachineBasicBlock *PredBB : Succ->predecessors()) {
-        if (PredBB == Edge.NewBB)
-          continue;
-        // If we are in this situation:
-        // FromBB1        FromBB2
-        //    +              +
-        //   + +            + +
-        //  +   +          +   +
-        // ...  Split1  Split2 ...
-        //           +   +
-        //            + +
-        //             +
-        //            Succ
-        // Instead of checking the domiance property with Split2, we
-        // check it with FromBB2 since Split2 is still unknown of the
-        // underlying DT structure.
-        if (NewBBs.count(PredBB)) {
-          assert(PredBB->pred_size() == 1 && "A basic block resulting from a "
-                                             "critical edge split has more "
-                                             "than one predecessor!");
-          PredBB = *PredBB->pred_begin();
-        }
-        if (!DT->dominates(SucccDTNode, DT->getNode(PredBB))) {
-          IsNewIDom[Idx] = false;
-          break;
-        }
-      }
-      ++Idx;
-    }
-
-    // Now, update DT with the collected dominance properties info.
-    Idx = 0;
-    for (CriticalEdge &Edge : CriticalEdgesToSplit) {
-      // We know FromBB dominates NewBB.
-      MachineDomTreeNode *NewDTNode = DT->addNewBlock(Edge.NewBB, Edge.FromBB);
-      MachineDomTreeNode *SucccDTNode = DT->getNode(Edge.ToBB);
-
-      // If all the other predecessors of "Succ" are dominated by "Succ" itself
-      // then the new block is the new immediate dominator of "Succ". Otherwise,
-      // the new block doesn't dominate anything.
-      if (IsNewIDom[Idx])
-        DT->changeImmediateDominator(SucccDTNode, NewDTNode);
-      ++Idx;
-    }
-    NewBBs.clear();
-    CriticalEdgesToSplit.clear();
-  }
+  void applySplitCriticalEdges() const;
 
 public:
   static char ID; // Pass ID, replacement for typeid
@@ -307,7 +237,7 @@ public:
     (void)Inserted;
     assert(Inserted &&
            "A basic block inserted via edge splitting cannot appear twice");
-    CriticalEdgesToSplit.push_back(CriticalEdge(FromBB, ToBB, NewBB));
+    CriticalEdgesToSplit.push_back({FromBB, ToBB, NewBB});
   }
 };
 

Modified: llvm/trunk/lib/CodeGen/MachineDominators.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/MachineDominators.cpp?rev=230806&r1=230805&r2=230806&view=diff
==============================================================================
--- llvm/trunk/lib/CodeGen/MachineDominators.cpp (original)
+++ llvm/trunk/lib/CodeGen/MachineDominators.cpp Fri Feb 27 17:13:13 2015
@@ -14,6 +14,7 @@
 
 #include "llvm/CodeGen/MachineDominators.h"
 #include "llvm/CodeGen/Passes.h"
+#include "llvm/ADT/SmallBitVector.h"
 
 using namespace llvm;
 
@@ -59,3 +60,68 @@ void MachineDominatorTree::releaseMemory
 void MachineDominatorTree::print(raw_ostream &OS, const Module*) const {
   DT->print(OS);
 }
+
+void MachineDominatorTree::applySplitCriticalEdges() const {
+  // Bail out early if there is nothing to do.
+  if (CriticalEdgesToSplit.empty())
+    return;
+
+  // For each element in CriticalEdgesToSplit, remember whether or not element
+  // is the new immediate domminator of its successor. The mapping is done by
+  // index, i.e., the information for the ith element of CriticalEdgesToSplit is
+  // the ith element of IsNewIDom.
+  SmallBitVector IsNewIDom(CriticalEdgesToSplit.size(), true);
+  size_t Idx = 0;
+
+  // Collect all the dominance properties info, before invalidating
+  // the underlying DT.
+  for (CriticalEdge &Edge : CriticalEdgesToSplit) {
+    // Update dominator information.
+    MachineBasicBlock *Succ = Edge.ToBB;
+    MachineDomTreeNode *SuccDTNode = DT->getNode(Succ);
+
+    for (MachineBasicBlock *PredBB : Succ->predecessors()) {
+      if (PredBB == Edge.NewBB)
+        continue;
+      // If we are in this situation:
+      // FromBB1        FromBB2
+      //    +              +
+      //   + +            + +
+      //  +   +          +   +
+      // ...  Split1  Split2 ...
+      //           +   +
+      //            + +
+      //             +
+      //            Succ
+      // Instead of checking the domiance property with Split2, we check it with
+      // FromBB2 since Split2 is still unknown of the underlying DT structure.
+      if (NewBBs.count(PredBB)) {
+        assert(PredBB->pred_size() == 1 && "A basic block resulting from a "
+                                           "critical edge split has more "
+                                           "than one predecessor!");
+        PredBB = *PredBB->pred_begin();
+      }
+      if (!DT->dominates(SuccDTNode, DT->getNode(PredBB))) {
+        IsNewIDom[Idx] = false;
+        break;
+      }
+    }
+    ++Idx;
+  }
+
+  // Now, update DT with the collected dominance properties info.
+  Idx = 0;
+  for (CriticalEdge &Edge : CriticalEdgesToSplit) {
+    // We know FromBB dominates NewBB.
+    MachineDomTreeNode *NewDTNode = DT->addNewBlock(Edge.NewBB, Edge.FromBB);
+
+    // If all the other predecessors of "Succ" are dominated by "Succ" itself
+    // then the new block is the new immediate dominator of "Succ". Otherwise,
+    // the new block doesn't dominate anything.
+    if (IsNewIDom[Idx])
+      DT->changeImmediateDominator(DT->getNode(Edge.ToBB), NewDTNode);
+    ++Idx;
+  }
+  NewBBs.clear();
+  CriticalEdgesToSplit.clear();
+}





More information about the llvm-commits mailing list