[LoopUnrolling] Fix loop size check for peeling

[mkazantsev]

Summary

We should check if loop size allows us to peel at least one iteration before we do so.

[mkuper]

LGTM with a style nit.

lib/Transforms/Utils/LoopUnrollPeel.cpp

78 ↗

(On Diff #90641)

I would combine this into a single if with a &&, rather than two nested ones.

[mkazantsev]

lib/Transforms/Utils/LoopUnrollPeel.cpp

78 ↗

(On Diff #90641)

We can't combine it with variable's declaration, and declaring the latch externally looks quite ugly.

[mkuper]

lib/Transforms/Utils/LoopUnrollPeel.cpp

78 ↗

(On Diff #90641)

I think having another level of nesting here is worse than declaring the latch externally.
I'd suggest either (1) declaring it externally, or (2) pull this entire thing into a helper function, in which case you can have an early exit.

[mkazantsev]

lib/Transforms/Utils/LoopUnrollPeel.cpp

78 ↗

(On Diff #90641)

I just realized that getLoopPatch never returns null, and this is ensured within isLoopSimplifyForm in canPeel method. So I will replace the condition here and make an assert for latch.

[mkuper]

LGTM.
Also, forgot it before, sorry - please add a test. (No need for a huge test, you can force a small threshold.)

[mkuper]

Do you need someone to check this in for you?

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

void llvm::computePeelCount(Loop *L, unsigned LoopSize,
   // Only try to peel innermost loops.
   if (!L->empty())
     return;
 
   // Try to find a Phi node that has the same loop invariant as an input from
   // its only back edge. If there is such Phi, peeling 1 iteration from the
   // loop is profitable, because starting from 2nd iteration we will have an
   // invariant instead of this Phi.
-  if (auto *BackEdge = L->getLoopLatch()) {
+  if (LoopSize <= UP.Threshold) {
+    BasicBlock *BackEdge = L->getLoopLatch();
+    assert(BackEdge && "Loop is not in simplified form?");
     BasicBlock *Header = L->getHeader();
     // Iterate over Phis to find one with invariant input on back edge.
     bool FoundCandidate = false;
     PHINode *Phi;
     for (auto BI = Header->begin(); isa<PHINode>(&*BI); ++BI) {
       Phi = cast<PHINode>(&*BI);
       Value *Input = Phi->getIncomingValueForBlock(BackEdge);
       if (L->isLoopInvariant(Input)) {

llvm/trunk/test/Transforms/LoopUnroll/peel-loop-not-forced.ll

-; RUN: opt < %s -S -loop-unroll | FileCheck %s
+; RUN: opt < %s -S -loop-unroll -unroll-threshold=4 | FileCheck %s
 
 define i32 @invariant_backedge_1(i32 %a, i32 %b) {
 ; CHECK-LABEL: @invariant_backedge_1
 ; CHECK-NOT:     %plus = phi
 ; CHECK:       loop.peel:
 ; CHECK:       loop:
 ; CHECK:         %i = phi
 ; CHECK:         %sum = phi
 entry:
   br label %loop
 
 loop:
   %i = phi i32 [ 0, %entry ], [ %inc, %loop ]
   %sum = phi i32 [ 0, %entry ], [ %incsum, %loop ]
   %plus = phi i32 [ %a, %entry ], [ %b, %loop ]
 
   %incsum = add i32 %sum, %plus
   %inc = add i32 %i, 1
   %cmp = icmp slt i32 %i, 1000
+
+  br i1 %cmp, label %loop, label %exit
+
+exit:
+  ret i32 %sum
+}
+
+; Peeling should fail due to method size.
+define i32 @invariant_backedge_2(i32 %a, i32 %b) {
+; CHECK-LABEL: @invariant_backedge_2
+; CHECK-NOT:   loop.peel:
+; CHECK:       loop:
+; CHECK:         %i = phi
+; CHECK:         %sum = phi
+; CHECK:         %plus = phi
+entry:
+  br label %loop
+
+loop:
+  %i = phi i32 [ 0, %entry ], [ %inc, %loop ]
+  %sum = phi i32 [ 0, %entry ], [ %incsum2, %loop ]
+  %plus = phi i32 [ %a, %entry ], [ %b, %loop ]
+
+  %incsum = add i32 %sum, %plus
+  %incsum2 = add i32 %incsum, %plus
+  %inc = add i32 %i, 1
+  %cmp = icmp slt i32 %i, 1000
+
   br i1 %cmp, label %loop, label %exit
 
 exit:
   ret i32 %sum
 }