Small cleanup of MachineLICM.cpp

[djasper]

Summary

Specifically:

• Calculate the loop pre-header once at the start of HoistOutOfLoop, so:
  • We don't DFS-walk the MachineDomTree if we aren't going to do anything
  • Don't call getCurPreheader for each Scope
• Don't needlessly use a do-while loop
• Use early exit for Scopes.size() == 0

No functional changes intended.

[chandlerc]

LGTM, nice cleanup.

[djasper]

Committed as r228350.

lib/CodeGen/MachineLICM.cpp

 
 /// HoistOutOfLoop - Walk the specified loop in the CFG (defined by all
 /// blocks dominated by the specified header block, and that are in the
 /// current loop) in depth first order w.r.t the DominatorTree. This allows
 /// us to visit definitions before uses, allowing us to hoist a loop body in
 /// one pass without iteration.
 ///
 void MachineLICM::HoistOutOfLoop(MachineDomTreeNode *HeaderN) {
+  MachineBasicBlock *Preheader = getCurPreheader();
+  if (!Preheader)
+    return;
+
   SmallVector<MachineDomTreeNode*, 32> Scopes;
   SmallVector<MachineDomTreeNode*, 8> WorkList;
   DenseMap<MachineDomTreeNode*, MachineDomTreeNode*> ParentMap;
   DenseMap<MachineDomTreeNode*, unsigned> OpenChildren;
 
   // Perform a DFS walk to determine the order of visit.
   WorkList.push_back(HeaderN);
-  do {
+  while (!WorkList.empty()) {
     MachineDomTreeNode *Node = WorkList.pop_back_val();
     assert(Node && "Null dominator tree node?");
     MachineBasicBlock *BB = Node->getBlock();
 
     // If the header of the loop containing this basic block is a landing pad,
     // then don't try to hoist instructions out of this loop.
     const MachineLoop *ML = MLI->getLoopFor(BB);
     if (ML && ML->getHeader()->isLandingPad())
while (!WorkList.empty()) {
     // Add children in reverse order as then the next popped worklist node is
     // the first child of this node.  This means we ultimately traverse the
     // DOM tree in exactly the same order as if we'd recursed.
     for (int i = (int)NumChildren-1; i >= 0; --i) {
       MachineDomTreeNode *Child = Children[i];
       ParentMap[Child] = Node;
       WorkList.push_back(Child);
     }
-  } while (!WorkList.empty());
+  }
 
-  if (Scopes.size() != 0) {
-    MachineBasicBlock *Preheader = getCurPreheader();
-    if (!Preheader)
-      return;
+  if (Scopes.size() == 0)
 
-    // Compute registers which are livein into the loop headers.
-    RegSeen.clear();
-    BackTrace.clear();
-    InitRegPressure(Preheader);
-  }
 
   // Now perform LICM.
   for (unsigned i = 0, e = Scopes.size(); i != e; ++i) {
     MachineDomTreeNode *Node = Scopes[i];
     MachineBasicBlock *MBB = Node->getBlock();
 
-    MachineBasicBlock *Preheader = getCurPreheader();
-    if (!Preheader)
-      continue;
-
     EnterScope(MBB);
 
     // Process the block
     SpeculationState = SpeculateUnknown;
     for (MachineBasicBlock::iterator
          MII = MBB->begin(), E = MBB->end(); MII != E; ) {
       MachineBasicBlock::iterator NextMII = MII; ++NextMII;
       MachineInstr *MI = &*MII;