IndVarSimplify: Allow LFTR to fire more often

[majnemer]

Summary

I added a pessimization in r217102 to prevent miscompiles when the
incremented induction variable was used in a comparison; it would be
poison.

Try to use the incremented induction variable more often when we can be
sure that the increment won't end in poison.

[atrick]

LGTM.

A short comment might help the reader. Something like “Check if InitIV + BECount+1 requires sign/zero extension. If not, clear the corresponding flag from WrappingFlags because it is not necessary for those flags in the IncrementedIndvarSCEV expression.”

[majnemer]

Closed by commit rL222213 (authored by @majnemer).

lib/Transforms/Scalar/IndVarSimplify.cpp

const auto *IncrementedIndvarSCEV =
         cast<SCEVAddRecExpr>(SE->getSCEV(IncrementedIndvar));
     // It is unsafe to use the incremented indvar if it has a wrapping flag, we
     // don't want to compare against a poison value.  Check the SCEV that
     // corresponds to the incremented indvar, the SCEVExpander will only insert
     // flags in the IR if the SCEV originally had wrapping flags.
     // FIXME: In theory, SCEV could drop flags even though they exist in IR.
     // A more robust solution would involve getting a new expression for
     // CmpIndVar by applying non-NSW/NUW AddExprs.
+    auto WrappingFlags =
+        ScalarEvolution::setFlags(SCEV::FlagNUW, SCEV::FlagNSW);
+    const SCEV *IVInit = IncrementedIndvarSCEV->getStart();
+    if (SE->getTypeSizeInBits(IVInit->getType()) >
+        SE->getTypeSizeInBits(IVCount->getType()))
+      IVInit = SE->getTruncateExpr(IVInit, IVCount->getType());
+    unsigned BitWidth = SE->getTypeSizeInBits(IVCount->getType());
+    Type *WideTy = IntegerType::get(SE->getContext(), BitWidth + 1);
+    if (SE->getSignExtendExpr(SE->getAddExpr(IVInit, BackedgeTakenCount),
+                              WideTy) ==
+        SE->getAddExpr(SE->getSignExtendExpr(IVInit, WideTy),
+                       SE->getSignExtendExpr(BackedgeTakenCount, WideTy)))
+      WrappingFlags = ScalarEvolution::clearFlags(WrappingFlags, SCEV::FlagNSW);
+    if (SE->getZeroExtendExpr(SE->getAddExpr(IVInit, BackedgeTakenCount),
+                              WideTy) ==
+        SE->getAddExpr(SE->getZeroExtendExpr(IVInit, WideTy),
+                       SE->getZeroExtendExpr(BackedgeTakenCount, WideTy)))
+      WrappingFlags = ScalarEvolution::clearFlags(WrappingFlags, SCEV::FlagNUW);
     if (!ScalarEvolution::maskFlags(IncrementedIndvarSCEV->getNoWrapFlags(),
-                                    SCEV::FlagNUW | SCEV::FlagNSW)) {
+                                    WrappingFlags)) {
       // Add one to the "backedge-taken" count to get the trip count.
       // This addition may overflow, which is valid as long as the comparison is
       // truncated to BackedgeTakenCount->getType().
       IVCount =
           SE->getAddExpr(BackedgeTakenCount,
                          SE->getConstant(BackedgeTakenCount->getType(), 1));
       CmpIndVar = IncrementedIndvar;
     }

test/Transforms/IndVarSimplify/lftr-extend-const.ll

 ;RUN: opt -S %s -indvars | FileCheck %s
 
 ; CHECK-LABEL: @foo(
 ; CHECK-NOT: %lftr.wideiv = trunc i32 %indvars.iv.next to i16
-; CHECK: %exitcond = icmp ne i32 %indvars.iv, 511
+; CHECK: %exitcond = icmp ne i32 %indvars.iv.next, 512
 define void @foo() #0 {
 entry:
   br label %for.body
 
 for.body:                                         ; preds = %entry, %for.body
   %i.01 = phi i16 [ 0, %entry ], [ %inc, %for.body ]
   %conv2 = sext i16 %i.01 to i32
   call void @bar(i32 %conv2) #1