Extract out LPPassManager::cloneLoop

[sanjoy]

Summary

This is depended on by the next change.

[reames]

include/llvm/Analysis/LoopPass.h

148

What does PL stand for? ParentLoop? A better name may be called for here.

Also, I'm not sure LPM is the right place for this. Possibly Transforms/Utils/LoopUtils.h?

lib/Analysis/LoopPass.cpp

317

Parens?

include/llvm/Analysis/LoopPass.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_ANALYSIS_LOOPPASS_H
 #define LLVM_ANALYSIS_LOOPPASS_H
 
 #include "llvm/Analysis/LoopInfo.h"
 #include "llvm/IR/LegacyPassManagers.h"
+#include "llvm/Transforms/Utils/ValueMapper.h"
 #include "llvm/Pass.h"
 #include <deque>
 
 namespace llvm {
 
 class LPPassManager;
 class Function;
 class PMStack;
public:
   // Insert a loop into the loop queue.
   void insertLoopIntoQueue(Loop *L);
 
   // Reoptimize this loop. LPPassManager will re-insert this loop into the
   // queue. This allows LoopPass to change loop nest for the loop. This
   // utility may send LPPassManager into infinite loops so use caution.
   void redoLoop(Loop *L);
 
+  /// cloneLoop - Recursively clone the specified loop and all of its
+  /// children, mapping the blocks with the specified map.
+  Loop *cloneLoop(Loop *L, Loop *PL, ValueToValueMapTy &VM, LoopInfo *LI);
+
   //===--------------------------------------------------------------------===//
   /// SimpleAnalysis - Provides simple interface to update analysis info
   /// maintained by various passes. Note, if required this interface can
   /// be extracted into a separate abstract class but it would require
   /// additional use of multiple inheritance in Pass class hierarchy, something
   /// we are trying to avoid.
 
   /// cloneBasicBlockSimpleAnalysis - Invoke cloneBasicBlockAnalysis hook for

lib/Analysis/LoopPass.cpp

bool LPPassManager::runOnFunction(Function &F) {
   for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
     LoopPass *P = getContainedPass(Index);
     Changed |= P->doFinalization();
   }
 
   return Changed;
 }
 
+
+/// cloneLoop - Recursively clone the specified loop and all of its children,
+/// mapping the blocks with the specified map.
+Loop *LPPassManager::cloneLoop(Loop *L, Loop *PL, ValueToValueMapTy &VM,
+                               LoopInfo *LI) {
+  Loop *New = new Loop;
+  insertLoop(New, PL);
+
+  // Add all of the blocks in L to the new loop.
+  for (BasicBlock *BB : L->getBlocks())
+    if (LI->getLoopFor(BB) == L)
+      New->addBasicBlockToLoop(cast<BasicBlock>(VM[BB]), LI->getBase());
+
+  // Add all of the subloops to the new loop.
+  for (Loop::iterator I = L->begin(), E = L->end(); I != E; ++I)
+    cloneLoop(*I, New, VM, LI);
+
+  return New;
+}
+
 /// Print passes managed by this manager
 void LPPassManager::dumpPassStructure(unsigned Offset) {
   errs().indent(Offset*2) << "Loop Pass Manager\n";
   for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
     Pass *P = getContainedPass(Index);
     P->dumpPassStructure(Offset + 1);
     dumpLastUses(P, Offset+1);
   }

lib/Transforms/Scalar/LoopUnswitch.cpp

if (OptimizeForSize ||
       F->getAttributes().hasAttribute(AttributeSet::FunctionIndex,
                                       Attribute::OptimizeForSize))
     return false;
 
   UnswitchNontrivialCondition(LoopCond, Val, currentLoop);
   return true;
 }
 
-/// CloneLoop - Recursively clone the specified loop and all of its children,
-/// mapping the blocks with the specified map.
-static Loop *CloneLoop(Loop *L, Loop *PL, ValueToValueMapTy &VM,
-                       LoopInfo *LI, LPPassManager *LPM) {
-  Loop *New = new Loop();
-  LPM->insertLoop(New, PL);
-
-  // Add all of the blocks in L to the new loop.
-  for (Loop::block_iterator I = L->block_begin(), E = L->block_end();
-       I != E; ++I)
-    if (LI->getLoopFor(*I) == L)
-      New->addBasicBlockToLoop(cast<BasicBlock>(VM[*I]), LI->getBase());
-
-  // Add all of the subloops to the new loop.
-  for (Loop::iterator I = L->begin(), E = L->end(); I != E; ++I)
-    CloneLoop(*I, New, VM, LI, LPM);
-
-  return New;
-}
-
 /// EmitPreheaderBranchOnCondition - Emit a conditional branch on two values
 /// if LIC == Val, branch to TrueDst, otherwise branch to FalseDest.  Insert the
 /// code immediately before InsertPt.
 void LoopUnswitch::EmitPreheaderBranchOnCondition(Value *LIC, Constant *Val,
                                                   BasicBlock *TrueDest,
                                                   BasicBlock *FalseDest,
                                                   Instruction *InsertPt) {
   // Insert a conditional branch on LIC to the two preheaders.  The original
void LoopUnswitch::UnswitchNontrivialCondition(Value *LIC, Constant *Val,
   F->getBasicBlockList().splice(NewPreheader, F->getBasicBlockList(),
                                 NewBlocks[0], F->end());
 
   // FIXME: We could register any cloned assumptions instead of clearing the
   // whole function's cache.
   AT->forgetCachedAssumptions(F);
 
   // Now we create the new Loop object for the versioned loop.
-  Loop *NewLoop = CloneLoop(L, L->getParentLoop(), VMap, LI, LPM);
+  Loop *NewLoop = LPM->cloneLoop(L, L->getParentLoop(), VMap, LI);
 
   // Recalculate unswitching quota, inherit simplified switches info for NewBB,
   // Probably clone more loop-unswitch related loop properties.
   BranchesInfo.cloneData(NewLoop, L, VMap);
 
   Loop *ParentLoop = L->getParentLoop();
   if (ParentLoop) {
     // Make sure to add the cloned preheader and exit blocks to the parent loop