Allow LoopBounds to detect the StepValue for a decrementing loop with a subtract StepInst

[aejjehint]

Summary

This change allows the LoopBounds to correctly identify the StepValue when the loop is decrementing and the stepinst is a subtract operation.

llvm/lib/Analysis/LoopInfo.cpp

Loop::LoopBounds::getBounds(const Loop &L, PHINode &IndVar,
   if (!InductionDescriptor::isInductionPHI(&IndVar, &L, &SE, IndDesc))
     return std::nullopt;
 
   Value *InitialIVValue = IndDesc.getStartValue();
   Instruction *StepInst = IndDesc.getInductionBinOp();
   if (!InitialIVValue || !StepInst)
     return std::nullopt;
 
+// We need to make sure we get the right step in case the stepinst is a sub
+  // First, try to get the step as a constant int. If that doesn't work, get it
+  // as a scev, but it needs to be inverted if the stepinst is a sub!
+  Value *StepValue = nullptr;
+  if (ConstantInt *StepConst = IndDesc.getConstIntStepValue()) {
+    StepValue = StepConst;
+  } else {
     const SCEV *Step = IndDesc.getStep();
+    // If the stepinst is a subtract, the SCEV returned for Step will be a
+    // negative number. This will cause the below if/elseif to fail because the
+    // operand in the sub instruction will be a positive number. In this case,
+    // we should check when we have a sub and generate a new SCEV for step that
+    // is equal to -1 * Step.
+    if (StepInst->getOpcode() == Instruction::Sub) {
+      const SCEV *MinusOneSCEV =
+          SE.getConstant(Type::getInt32Ty(SE.getContext()), -1, true);
+      const SCEV *InvertedStep = SE.getMulExpr(MinusOneSCEV, Step);
+      Step = InvertedStep;
+    }
     Value *StepInstOp1 = StepInst->getOperand(1);
     Value *StepInstOp0 = StepInst->getOperand(0);
-  Value *StepValue = nullptr;
     if (SE.getSCEV(StepInstOp1) == Step)
       StepValue = StepInstOp1;
     else if (SE.getSCEV(StepInstOp0) == Step)
       StepValue = StepInstOp0;
+    else
+      return std::nullopt;
+  }
 
   Value *FinalIVValue = findFinalIVValue(L, IndVar, *StepInst);
   if (!FinalIVValue)
     return std::nullopt;
 
   return LoopBounds(L, *InitialIVValue, *StepInst, StepValue, *FinalIVValue,
                     SE);
 }

llvm/unittests/Analysis/LoopInfoTest.cpp

runWithLoopInfoPlus(
         EXPECT_NE(L, nullptr);
 
         std::optional<Loop::LoopBounds> Bounds = L->getBounds(SE);
         EXPECT_NE(Bounds, std::nullopt);
         EXPECT_EQ(Bounds->getInitialIVValue().getName(), "ub");
         EXPECT_EQ(Bounds->getStepInst().getName(), "inc");
         ConstantInt *StepValue =
             dyn_cast_or_null<ConstantInt>(Bounds->getStepValue());
-        EXPECT_EQ(StepValue, nullptr);
+        EXPECT_TRUE(StepValue && StepValue->getSExtValue() == -1);
         ConstantInt *FinalIVValue =
             dyn_cast<ConstantInt>(&Bounds->getFinalIVValue());
         EXPECT_TRUE(FinalIVValue && FinalIVValue->isZero());
         EXPECT_EQ(Bounds->getCanonicalPredicate(), ICmpInst::ICMP_SGT);
         EXPECT_EQ(Bounds->getDirection(),
                   Loop::LoopBounds::Direction::Decreasing);
         EXPECT_EQ(L->getInductionVariable(SE)->getName(), "i");
         EXPECT_EQ(L->getLoopGuardBranch(), Guard);