Subzero: Improve LoopAnalyzer Interface

src/IceCfg.cpp

 //===- subzero/src/IceCfg.cpp - Control flow graph implementation ---------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 625 matching lines @@
           }
         }
       }
     }
   }
 }
 
 void Cfg::loopInvariantCodeMotion() {
   TimerMarker T(TimerStack::TT_loopInvariantCodeMotion, this);
   // Does not introduce new nodes as of now.
-  for (auto &Pair : LoopInfo) {
-    CfgNode *Header = Nodes[Pair.first];
+  for (auto &Loop : LoopInfo) {
+    CfgNode *Header = Loop.Header;
     assert(Header);
     if (Header->getLoopNestDepth() < 1)
-      continue;
-    CfgNode *PreHeader = nullptr;
-    for (auto *Pred : Header->getInEdges()) {
-      if (Pred->getLoopNestDepth() == Header->getLoopNestDepth() - 1) {
-        if (PreHeader == nullptr) {
-          PreHeader = Pred;
-        } else {
-          PreHeader = nullptr;
-          break;
-          // Do not consider cases with two incoming edges.
-          // Will require insertion of nodes.
-        }
-      }
-    }
+      return;
+    CfgNode *PreHeader = Loop.PreHeader;
     if (PreHeader == nullptr || PreHeader->getInsts().size() == 0) {
-      continue; // to next loop
+      return; // try next loop
     }
 
     auto &Insts = PreHeader->getInsts();
     auto &LastInst = Insts.back();
     Insts.pop_back();
 
-    for (auto *Inst : findLoopInvariantInstructions(Pair.first)) {
+    for (auto *Inst : findLoopInvariantInstructions(Loop.Body)) {
       PreHeader->appendInst(Inst);
     }
     PreHeader->appendInst(&LastInst);
   }
 }
 
-Ice::CfgVector<Inst *>
-Cfg::findLoopInvariantInstructions(Ice::SizeT LoopHeaderIndex) {
+CfgVector<Inst *>
+Cfg::findLoopInvariantInstructions(const CfgUnorderedSet<SizeT> &Body) {
   CfgUnorderedSet<Inst *> InvariantInsts;
   CfgUnorderedSet<Variable *> InvariantVars;
   for (auto *Var : getArgs()) {
     InvariantVars.insert(Var);
   }
   bool Changed = false;
   do {
     Changed = false;
-    for (auto NodeIndex : LoopInfo[LoopHeaderIndex]) {
+    for (auto NodeIndex : Body) {
       auto *Node = Nodes[NodeIndex];
       CfgVector<std::reference_wrapper<Inst>> Insts(Node->getInsts().begin(),
                                                     Node->getInsts().end());
 
       for (auto &InstRef : Insts) {
         auto &Inst = InstRef.get();
         if (Inst.isDeleted() ||
             InvariantInsts.find(&Inst) != InvariantInsts.end())
           continue;
         switch (Inst.getKind()) {
@@ skipping 730 matching lines @@
 void Cfg::genFrame() {
   TimerMarker T(TimerStack::TT_genFrame, this);
   getTarget()->addProlog(Entry);
   for (CfgNode *Node : Nodes)
     if (Node->getHasReturn())
       getTarget()->addEpilog(Node);
 }
 
 void Cfg::generateLoopInfo() {
   TimerMarker T(TimerStack::TT_computeLoopNestDepth, this);
-  LoopInfo = LoopAnalyzer(this).getLoopInfo();
+  LoopInfo = ComputeLoopInfo(this);
 }
 
 // This is a lightweight version of live-range-end calculation. Marks the last
 // use of only those variables whose definition and uses are completely with a
 // single block. It is a quick single pass and doesn't need to iterate until
 // convergence.
 void Cfg::livenessLightweight() {
   TimerMarker T(TimerStack::TT_livenessLightweight, this);
   getVMetadata()->init(VMK_Uses);
   for (CfgNode *Node : Nodes)
@@ skipping 328 matching lines @@
     }
   }
   // Print each basic block
   for (CfgNode *Node : Nodes)
     Node->dump(this);
   if (isVerbose(IceV_Instructions))
     Str << "}\n";
 }
 
 } // end of namespace Ice