[llvm] r309758 - [SCEV/IndVars] Always compute loop exiting values if the backedge count is 0

[Sanjoy Das via llvm-commits]

Hi,

On Tue, Aug 1, 2017 at 3:45 PM, Davide Italiano <davide at freebsd.org> wrote:
> Sanjoy, Hans, can we backport this one to 5.0?

SGTM, but I'd like to bake this in tree for a day or two before we do that.

Davide, can you please verify that this fixes the issue?

Thanks!
-- Sanjoy

>
> Thanks,
>
> --
> Davide
>
> On Tue, Aug 1, 2017 at 3:37 PM, Sanjoy Das via llvm-commits
> <llvm-commits at lists.llvm.org> wrote:
>> Author: sanjoy
>> Date: Tue Aug  1 15:37:58 2017
>> New Revision: 309758
>>
>> URL: http://llvm.org/viewvc/llvm-project?rev=309758&view=rev
>> Log:
>> [SCEV/IndVars] Always compute loop exiting values if the backedge count is 0
>>
>> If SCEV can prove that the backedge taken count for a loop is zero, it does not
>> need to "understand" a recursive PHI to compute its exiting value.
>>
>> This should fix PR33885.
>>
>> Modified:
>>     llvm/trunk/lib/Analysis/ScalarEvolution.cpp
>>     llvm/trunk/test/Transforms/IndVarSimplify/exit_value_test2.ll
>>
>> Modified: llvm/trunk/lib/Analysis/ScalarEvolution.cpp
>> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/ScalarEvolution.cpp?rev=309758&r1=309757&r2=309758&view=diff
>> ==============================================================================
>> --- llvm/trunk/lib/Analysis/ScalarEvolution.cpp (original)
>> +++ llvm/trunk/lib/Analysis/ScalarEvolution.cpp Tue Aug  1 15:37:58 2017
>> @@ -7597,6 +7597,25 @@ const SCEV *ScalarEvolution::computeSCEV
>>              const SCEV *BackedgeTakenCount = getBackedgeTakenCount(LI);
>>              if (const SCEVConstant *BTCC =
>>                    dyn_cast<SCEVConstant>(BackedgeTakenCount)) {
>> +
>> +              // This trivial case can show up in some degenerate cases where
>> +              // the incoming IR has not yet been fully simplified.
>> +              if (BTCC->getValue()->isZero()) {
>> +                Value *InitValue = nullptr;
>> +                bool MultipleInitValues = false;
>> +                for (unsigned i = 0; i < PN->getNumIncomingValues(); i++) {
>> +                  if (!LI->contains(PN->getIncomingBlock(i))) {
>> +                    if (!InitValue)
>> +                      InitValue = PN->getIncomingValue(i);
>> +                    else if (InitValue != PN->getIncomingValue(i)) {
>> +                      MultipleInitValues = true;
>> +                      break;
>> +                    }
>> +                  }
>> +                  if (!MultipleInitValues && InitValue)
>> +                    return getSCEV(InitValue);
>> +                }
>> +              }
>>                // Okay, we know how many times the containing loop executes.  If
>>                // this is a constant evolving PHI node, get the final value at
>>                // the specified iteration number.
>>
>> Modified: llvm/trunk/test/Transforms/IndVarSimplify/exit_value_test2.ll
>> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Transforms/IndVarSimplify/exit_value_test2.ll?rev=309758&r1=309757&r2=309758&view=diff
>> ==============================================================================
>> --- llvm/trunk/test/Transforms/IndVarSimplify/exit_value_test2.ll (original)
>> +++ llvm/trunk/test/Transforms/IndVarSimplify/exit_value_test2.ll Tue Aug  1 15:37:58 2017
>> @@ -3,15 +3,14 @@
>>
>>  ; Check IndVarSimplify should not replace exit value because or else
>>  ; udiv will be introduced by expand and the cost will be high.
>> -;
>> -; CHECK-LABEL: @_Z3fooPKcjj(
>> -; CHECK-NOT: udiv
>>
>>  declare void @_Z3mixRjj(i32* dereferenceable(4), i32)
>>  declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture)
>>  declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture)
>>
>>  define i32 @_Z3fooPKcjj(i8* nocapture readonly %s, i32 %len, i32 %c) {
>> +; CHECK-LABEL: @_Z3fooPKcjj(
>> +; CHECK-NOT: udiv
>>  entry:
>>    %a = alloca i32, align 4
>>    %tmp = bitcast i32* %a to i8*
>> @@ -50,3 +49,26 @@ while.end:
>>    call void @llvm.lifetime.end.p0i8(i64 4, i8* %tmp)
>>    ret i32 %tmp4
>>  }
>> +
>> +define i32 @zero_backedge_count_test(i32 %unknown_init, i32* %unknown_mem) {
>> +; CHECK-LABEL: @zero_backedge_count_test(
>> +entry:
>> +  br label %loop
>> +
>> +loop:
>> +  %iv = phi i32 [ 0, %entry], [ %iv.inc, %loop ]
>> +  %unknown_phi = phi i32 [ %unknown_init, %entry ], [ %unknown_next, %loop ]
>> +  %iv.inc = add i32 %iv, 1
>> +  %be_taken = icmp ne i32 %iv.inc, 1
>> +  %unknown_next = load volatile i32, i32* %unknown_mem
>> +  br i1 %be_taken, label %loop, label %leave
>> +
>> +leave:
>> +; We can fold %unknown_phi even though the backedge value for it is completely
>> +; unknown, since we can prove that the loop's backedge taken count is 0.
>> +
>> +; CHECK: leave:
>> +; CHECK: ret i32 %unknown_init
>> +  %exit_val = phi i32 [ %unknown_phi, %loop ]
>> +  ret i32 %exit_val
>> +}
>>
>>
>> _______________________________________________
>> llvm-commits mailing list
>> llvm-commits at lists.llvm.org
>> http://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-commits
>
>
>
> --
> Davide
>
> "There are no solved problems; there are only problems that are more
> or less solved" -- Henri Poincare