[UnJ] Pull code out into a separate function NFC

[dmgreen]

Summary

Pulled this code out into a common isInnerLoopIterationCountInvariant
function as it seems generally useful.

[dmgreen]

Renamed to hasConsistentIterationCount, as per comments in D50062.

[SjoerdMeijer]

include/llvm/Transforms/Utils/LoopUtils.h

493 ↗

(On Diff #159267)

Bike shedding names: I was wondering if "consistent" is the right word here. I think what this function does is best described in the implementation:

// Get whether count is invariant to the outer loop

I think "invariant" is describing it better.

lib/Transforms/Utils/LoopUtils.cpp

1524 ↗

(On Diff #159267)

nit: I think I would have called SubLoop InnerLoop.

[SjoerdMeijer]

Ah, sorry, I now see HasConsistentIterationCounts has been suggested in that other ticket. Oh well, as I said, I was bike shedding names (but still think 'invariant' is better :-)) Anyway, please ignore if you disagree.

[Meinersbur]

In D50063#1193750, @SjoerdMeijer wrote:

Ah, sorry, I now see HasConsistentIterationCounts has been suggested in that other ticket. Oh well, as I said, I was bike shedding names (but still think 'invariant' is better :-)) Anyway, please ignore if you disagree.

I suggested the name because the term 'consistent' was used in the D50062 function's comment (which seems to have been replicated here). That is, invariant could have been used in that original comment as well.

I am fine if using 'invariant', I don't have a preference.

Overall, LGTM in either case.

include/llvm/Transforms/Utils/LoopUtils.h

493 ↗

(On Diff #159267)

I suggested the name because the term 'consistent' was used in the D50062 function's comment (which seems to have been replicated here). 'Invariant' would be ok as well.

[dmgreen]

Thanks. I'll go with Invariant as it speaks to what the underlying implementation is doing.

llvm/trunk/include/llvm/Transforms/Utils/LoopUtils.h

 void addStringMetadataToLoop(Loop *TheLoop, const char *MDString,
                              unsigned V = 0);
 
 /// Get a loop's estimated trip count based on branch weight metadata.
 /// Returns 0 when the count is estimated to be 0, or None when a meaningful
 /// estimate can not be made.
 Optional<unsigned> getLoopEstimatedTripCount(Loop *L);
 
+/// Check inner loop (L) backedge count is known to be invariant on all iterations
+/// of its outer loop. If the loop has no parent, this is trivially true.
+bool hasInvariantIterationCount(Loop *L, ScalarEvolution &SE);
+
 /// Helper to consistently add the set of standard passes to a loop pass's \c
 /// AnalysisUsage.
 ///
 /// All loop passes should call this as part of implementing their \c
 /// getAnalysisUsage.
 void getLoopAnalysisUsage(AnalysisUsage &AU);
 
 /// Returns true if is legal to hoist or sink this instruction disregarding the

llvm/trunk/lib/Transforms/Utils/LoopUnrollAndJam.cpp

bool llvm::isSafeToUnrollAndJam(Loop *L, ScalarEvolution &SE, DominatorTree &DT,
   if (AftBlocks.size() != 1) {
     LLVM_DEBUG(dbgs() << "Won't unroll-and-jam; Can't currently handle "
                          "multiple blocks after the loop\n");
     return false;
   }
 
   // Check inner loop backedge count is consistent on all iterations of the
   // outer loop
-  auto CheckInnerLoopIterationCountInvariant = [](Loop *SubLoop, Loop *OuterL,
-                                                  ScalarEvolution &SE) {
-    BasicBlock *SubLoopLatch = SubLoop->getLoopLatch();
-    const SCEV *SubLoopBECountSC = SE.getExitCount(SubLoop, SubLoopLatch);
-    if (isa<SCEVCouldNotCompute>(SubLoopBECountSC) ||
-        !SubLoopBECountSC->getType()->isIntegerTy())
-      return false;
-    ScalarEvolution::LoopDisposition LD =
-        SE.getLoopDisposition(SubLoopBECountSC, OuterL);
-    if (LD != ScalarEvolution::LoopInvariant)
-      return false;
-    return true;
-  };
-  if (!CheckInnerLoopIterationCountInvariant(SubLoop, L, SE)) {
+  if (!hasInvariantIterationCount(SubLoop, SE)) {
     LLVM_DEBUG(dbgs() << "Won't unroll-and-jam; Inner loop iteration count is "
                          "not consistent on each iteration\n");
     return false;
   }
 
   // Check the loop safety info for exceptions.
   LoopSafetyInfo LSI;
   computeLoopSafetyInfo(&LSI, L);

llvm/trunk/lib/Transforms/Utils/LoopUtils.cpp

Optional<unsigned> llvm::getLoopEstimatedTripCount(Loop *L) {
   // Divide the count of the backedge by the count of the edge exiting the loop,
   // rounding to nearest.
   if (LatchBR->getSuccessor(0) == L->getHeader())
     return (TrueVal + (FalseVal / 2)) / FalseVal;
   else
     return (FalseVal + (TrueVal / 2)) / TrueVal;
 }
 
+bool llvm::hasInvariantIterationCount(Loop *InnerLoop,
+                                      ScalarEvolution &SE) {
+  Loop *OuterL = InnerLoop->getParentLoop();
+  if (!OuterL)
+    return true;
+
+  // Get the backedge taken count for the inner loop
+  BasicBlock *InnerLoopLatch = InnerLoop->getLoopLatch();
+  const SCEV *InnerLoopBECountSC = SE.getExitCount(InnerLoop, InnerLoopLatch);
+  if (isa<SCEVCouldNotCompute>(InnerLoopBECountSC) ||
+      !InnerLoopBECountSC->getType()->isIntegerTy())
+    return false;
+
+  // Get whether count is invariant to the outer loop
+  ScalarEvolution::LoopDisposition LD =
+      SE.getLoopDisposition(InnerLoopBECountSC, OuterL);
+  if (LD != ScalarEvolution::LoopInvariant)
+    return false;
+
+  return true;
+}
+
 /// Adds a 'fast' flag to floating point operations.
 static Value *addFastMathFlag(Value *V) {
   if (isa<FPMathOperator>(V)) {
     FastMathFlags Flags;
     Flags.setFast();
     cast<Instruction>(V)->setFastMathFlags(Flags);
   }
   return V;