243   LoopInterchangeLegality(Loop *Outer, Loop *Inner, ScalarEvolution *SE,  in LoopInterchangeLegality()  argument
245       : OuterLoop(Outer), InnerLoop(Inner), SE(SE), ORE(ORE) {}  in LoopInterchangeLegality()
270   bool tightlyNested(Loop *Outer, Loop *Inner);
275   /// OuterInnerReductions. When the outer loop is passed, the inner loop needs
290   /// outer loop.
301   LoopInterchangeProfitability(Loop *Outer, Loop *Inner, ScalarEvolution *SE,  in LoopInterchangeProfitability()  argument
303       : OuterLoop(Outer), InnerLoop(Inner), SE(SE), ORE(ORE) {}  in LoopInterchangeProfitability()
334   LoopInterchangeTransform(Loop *Outer, Loop *Inner, ScalarEvolution *SE,  in LoopInterchangeTransform()  argument
337       : OuterLoop(Outer), InnerLoop(Inner), SE(SE), LI(LI), DT(DT), LIL(LIL) {}  in LoopInterchangeTransform()
554   // A perfectly nested loop will not have any branch in between the outer and  in tightlyNested()
555   // inner block i.e. outer header will branch to either inner preheader and  in tightlyNested()
568   // We do not have any basic block in between now make sure the outer header  in tightlyNested()
569   // and outer loop latch doesn't contain any unsafe instructions.  in tightlyNested()
576   // the outer loop header when interchanging.  in tightlyNested()
582   // Ensure the inner loop exit block flows to the outer loop latch possibly  in tightlyNested()
588                       << " does not lead to the outer loop latch.\n";);  in tightlyNested()
591   // The inner loop exit block does flow to the outer loop latch and not some  in tightlyNested()
673     // related variable (Left) with a outer loop invariant (Right).  in isLoopStructureUnderstood()
738       // PHIs in inner loops need to be part of a reduction in the outer loop,  in findInductionAndReductions()
739       // discovered when checking the PHIs of the outer loop earlier.  in findInductionAndReductions()
743                                "across the outer loop.\n");  in findInductionAndReductions()
749         // Check if we have a PHI node in the outer loop that has a reduction  in findInductionAndReductions()
795         dbgs() << "Only outer loops with induction or reduction PHI nodes "  in currentLimitations()
801              << "Only outer loops with induction or reduction PHI nodes can be"  in currentLimitations()
856 // users are either reduction PHIs or PHIs outside the outer loop (which means
877 // We currently support LCSSA PHI nodes in the outer loop exit, if their
878 // incoming values do not come from the outer loop latch or if the
879 // outer loop latch has a single predecessor. In that case, the value will
880 // be available if both the inner and outer loop conditions are true, which
882 // that may not be the case, e.g. because the outer loop latch may be executed
892       // The incoming value is defined in the outer loop latch. Currently we  in areOuterLoopExitPHIsSupported()
893       // only support that in case the outer loop latch has a single predecessor.  in areOuterLoopExitPHIsSupported()
894       // This guarantees that the outer loop latch is executed if and only if  in areOuterLoopExitPHIsSupported()
896       // outer loop header only branches to the inner loop or the outer loop  in areOuterLoopExitPHIsSupported()
912 // after interchange, since the original inner latch will become the new outer
920   // If the original outer latch has only one predecessor, then values defined  in areInnerLoopLatchPHIsSupported()
922   // at the new outer latch after interchange.  in areInnerLoopLatchPHIsSupported()
926   // The outer latch has more than one predecessors, i.e., the inner  in areInnerLoopLatchPHIsSupported()
931   // those incoming values may not be available at the new outer latch.  in areInnerLoopLatchPHIsSupported()
958   // Check if outer and inner loop contain legal instructions only.  in canInterchangeLoops()
1028     LLVM_DEBUG(dbgs() << "Found unsupported PHI nodes in outer loop exit.\n");  in canInterchangeLoops()
1060           // If we find the inner induction after an outer induction e.g.  in getInstrOrderCost()
1074           // If we find the outer induction after an inner induction e.g.  in getInstrOrderCost()
1100   // A smaller index means the loop should be placed an outer loop, and vice  in isProfitablePerLoopCacheAnalysis()
1136     // it is not profitable to move this to outer position, since we are  in isProfitableForVectorization()
1141     // If the outer loop is not loop independent it is not profitable to move  in isProfitableForVectorization()
1147   // If inner loop has dependence and outer loop is loop independent then it  in isProfitableForVectorization()
1207 /// new inner and outer loop after interchanging: NewInner is the original
1208 /// outer loop and NewOuter is the original inner loop.
1211 /// Outer preheader
1212 //  Outer header
1217 //   outer bbs
1218 //   Outer latch
1223 //   Outer preheader
1224 //   Outer header
1226 //     outer bbs
1227 //     Outer latch
1255   // Add BBs from the original outer loop to the original inner loop (excluding  in restructureLoops()
1269     // Remove the new outer loop header and latch from the new inner loop.  in restructureLoops()
1276   // The preheader of the original outer loop becomes part of the new  in restructureLoops()
1277   // outer loop.  in restructureLoops()
1366   // defined in the outer loop header. Move them there, because the original  in transform()
1451   // latch of the new outer loop, and the only possible users can PHI nodes  in moveLCSSAPhis()
1452   // in the exit block of the loop nest or the outer loop header (reduction  in moveLCSSAPhis()
1506   // incoming values defined in the outer loop, we have to add a new PHI  in moveLCSSAPhis()
1507   // in the inner loop latch, which became the exit block of the outer loop,  in moveLCSSAPhis()
1522       // We might have incoming edges from other BBs, i.e., the original outer  in moveLCSSAPhis()
1599   // The branches in the outer loop predecessor and the outer loop header can  in adjustLoopBranches()
1604   // The outer loop header might or might not branch to the outer latch.  in adjustLoopBranches()
1649   // For PHIs in the exit block of the outer loop, outer's latch has been  in adjustLoopBranches()
1654   // Now update the reduction PHIs in the inner and outer loop headers.  in adjustLoopBranches()
1664   // Now move the remaining reduction PHIs from outer to inner loop header and  in adjustLoopBranches()
1666   // outer loop and all the remains to do is and updating the incoming blocks.  in adjustLoopBranches()
1668     LLVM_DEBUG(dbgs() << "Outer loop reduction PHIs:\n"; PHI->dump(););  in adjustLoopBranches()
1684   // Values defined in the outer loop header could be used in the inner loop  in adjustLoopBranches()
1687   // new outer loop.  in adjustLoopBranches()
1698   // Adjust all branches in the inner and outer loop.  in adjustLoopLinks()
1703     // preheader was previously executed inside the outer loop.  in adjustLoopLinks()