[LV] Rename CountRoundDown to VectorTripCount (NFC)

[rickyz]

Summary

The name CountRoundDown is potentially misleading, as the number of
iterations can be rounded up when folding the tail.

[rickyz]

Rebase again main.

[fhahn]

Thanks for the patch and sorry for the delay. It's common practice to 'ping' a patch regularly (curtesy ping period is roughly every 7 days), otherwise it is very easy for patches to fall through the cracks.

The renaming makes sense to me and makes the code more consistent as a whole, as VectorTripCount is used elsewhere for the same thing already. Please move the changes unrelated to the renaming to a separate patch.

llvm/lib/Transforms/Vectorize/LoopVectorize.cpp

3602

Can you limit this patch to *only* adjust CountRoundDown -> VectorTripCount? And mov eat either refactoring changes to a separate patch?

[rickyz]

Remove loop refactor so that this change is rename-only.

[rickyz]

In D119681#3480475, @fhahn wrote:

Thanks for the patch and sorry for the delay. It's common practice to 'ping' a patch regularly (curtesy ping period is roughly every 7 days), otherwise it is very easy for patches to fall through the cracks.

Thanks for the tip and for noticing this - will keep in mind in the future!

[fhahn]

LGTM, thanks!

[rickyz]

In D119681#3480870, @fhahn wrote:

LGTM, thanks!

I'm not a committer, so can you land this on my behalf? Thanks!

[fhahn]

In D119681#3481114, @rickyz wrote:

In D119681#3480870, @fhahn wrote:

LGTM, thanks!

I'm not a committer, so can you land this on my behalf? Thanks!

sure, please let me know what name & email to use

[rickyz]

In D119681#3481171, @fhahn wrote:

sure, please let me know what name & email to use

Ricky Zhou <[e-mail]>

Thanks!

llvm/lib/Transforms/Vectorize/LoopVectorize.cpp

protected:
   /// A type for scalarized values in the new loop. Each value from the
   /// original loop, when scalarized, is represented by UF x VF scalar values
   /// in the new unrolled loop, where UF is the unroll factor and VF is the
   /// vectorization factor.
   using ScalarParts = SmallVector<SmallVector<Value *, 4>, 2>;
 
   /// Set up the values of the IVs correctly when exiting the vector loop.
   void fixupIVUsers(PHINode *OrigPhi, const InductionDescriptor &II,
-                    Value *CountRoundDown, Value *EndValue,
+                    Value *VectorTripCount, Value *EndValue,
                     BasicBlock *MiddleBlock);
 
   /// Introduce a conditional branch (on true, condition to be set later) at the
   /// end of the header=latch connecting it to itself (across the backedge) and
   /// to the exit block of \p L.
   void createHeaderBranch(Loop *L);
 
   /// Handle all cross-iteration phis in the header.
if (OrigPhi == OldInduction) {
 
       // Fast-math-flags propagate from the original induction instruction.
       if (II.getInductionBinOp() && isa<FPMathOperator>(II.getInductionBinOp()))
         B.setFastMathFlags(II.getInductionBinOp()->getFastMathFlags());
 
       Type *StepType = II.getStep()->getType();
       Instruction::CastOps CastOp =
           CastInst::getCastOpcode(VectorTripCount, true, StepType, true);
-      Value *CRD = B.CreateCast(CastOp, VectorTripCount, StepType, "cast.crd");
+      Value *VTC = B.CreateCast(CastOp, VectorTripCount, StepType, "cast.vtc");
       Value *Step =
           CreateStepValue(II.getStep(), *PSE.getSE(), &*B.GetInsertPoint());
-      EndValue = emitTransformedIndex(B, CRD, II.getStartValue(), Step, II);
+      EndValue = emitTransformedIndex(B, VTC, II.getStartValue(), Step, II);
       EndValue->setName("ind.end");
 
       // Compute the end value for the additional bypass (if applicable).
       if (AdditionalBypass.first) {
         B.SetInsertPoint(&(*AdditionalBypass.first->getFirstInsertionPt()));
         CastOp = CastInst::getCastOpcode(AdditionalBypass.second, true,
                                          StepType, true);
         Value *Step =
             CreateStepValue(II.getStep(), *PSE.getSE(), &*B.GetInsertPoint());
-        CRD =
-            B.CreateCast(CastOp, AdditionalBypass.second, StepType, "cast.crd");
+        VTC =
+            B.CreateCast(CastOp, AdditionalBypass.second, StepType, "cast.vtc");
         EndValueFromAdditionalBypass =
-            emitTransformedIndex(B, CRD, II.getStartValue(), Step, II);
+            emitTransformedIndex(B, VTC, II.getStartValue(), Step, II);
         EndValueFromAdditionalBypass->setName("ind.end");
       }
     }
     // The new PHI merges the original incoming value, in case of a bypass,
     // or the value at the end of the vectorized loop.
     BCResumeVal->addIncoming(EndValue, LoopMiddleBlock);
 
     // Fix the scalar body counter (PHI node).

 }
 
 // Fix up external users of the induction variable. At this point, we are
 // in LCSSA form, with all external PHIs that use the IV having one input value,
 // coming from the remainder loop. We need those PHIs to also have a correct
 // value for the IV when arriving directly from the middle block.
 void InnerLoopVectorizer::fixupIVUsers(PHINode *OrigPhi,
                                        const InductionDescriptor &II,
-                                       Value *CountRoundDown, Value *EndValue,
+                                       Value *VectorTripCount, Value *EndValue,
                                        BasicBlock *MiddleBlock) {
   // There are two kinds of external IV usages - those that use the value
   // computed in the last iteration (the PHI) and those that use the penultimate
   // value (the value that feeds into the phi from the loop latch).
   // We allow both, but they, obviously, have different values.
 
   assert(OrigLoop->getUniqueExitBlock() && "Expected a single exit block");
 
   DenseMap<Value *, Value *> MissingVals;
 
   // An external user of the last iteration's value should see the value that
   // the remainder loop uses to initialize its own IV.
   Value *PostInc = OrigPhi->getIncomingValueForBlock(OrigLoop->getLoopLatch());
   for (User *U : PostInc->users()) {
     Instruction *UI = cast<Instruction>(U);
     if (!OrigLoop->contains(UI)) {
       assert(isa<PHINode>(UI) && "Expected LCSSA form");
       MissingVals[UI] = EndValue;
     }
   }
 
   // An external user of the penultimate value need to see EndValue - Step.
   // The simplest way to get this is to recompute it from the constituent SCEVs,
-  // that is Start + (Step * (CRD - 1)).
+  // that is Start + (Step * (VTC - 1)).
   for (User *U : OrigPhi->users()) {
     auto *UI = cast<Instruction>(U);
-    if (!OrigLoop->contains(UI)) {
-      assert(isa<PHINode>(UI) && "Expected LCSSA form");
+    if (OrigLoop->contains(UI))
+      continue;
+
 
-      IRBuilder<> B(MiddleBlock->getTerminator());
 
-      // Fast-math-flags propagate from the original induction instruction.
-      if (II.getInductionBinOp() && isa<FPMathOperator>(II.getInductionBinOp()))
-        B.setFastMathFlags(II.getInductionBinOp()->getFastMathFlags());
 
-      Value *CountMinusOne = B.CreateSub(
-          CountRoundDown, ConstantInt::get(CountRoundDown->getType(), 1));
-      Value *CMO =
-          !II.getStep()->getType()->isIntegerTy()
-              ? B.CreateCast(Instruction::SIToFP, CountMinusOne,
-                             II.getStep()->getType())
-              : B.CreateSExtOrTrunc(CountMinusOne, II.getStep()->getType());
-      CMO->setName("cast.cmo");
+        VectorTripCount, ConstantInt::get(VectorTripCount->getType(), 1));
 
-      Value *Step = CreateStepValue(II.getStep(), *PSE.getSE(),
-                                    LoopVectorBody->getTerminator());
-      Value *Escape =
-          emitTransformedIndex(B, CMO, II.getStartValue(), Step, II);
-      Escape->setName("ind.escape");
-      MissingVals[UI] = Escape;
-    }
-  }
+    Value *Escape = emitTransformedIndex(B, CMO, II.getStartValue(), Step, II);
 
   for (auto &I : MissingVals) {
     PHINode *PHI = cast<PHINode>(I.first);
     // One corner case we have to handle is two IVs "chasing" each-other,
     // that is %IV2 = phi [...], [ %IV1, %latch ]
     // In this case, if IV1 has an external use, we need to avoid adding both
     // "last value of IV1" and "penultimate value of IV2". So, verify that we
     // don't already have an incoming value for the middle block.
EpilogueVectorizerMainLoop::createEpilogueVectorizedLoopSkeleton() {
   // that goes directly through the vector epilogue. The longer-path length for
   // the main loop is compensated for, by the gain from vectorizing the larger
   // trip count. Note: the branch will get updated later on when we vectorize
   // the epilogue.
   EPI.MainLoopIterationCountCheck =
       emitMinimumIterationCountCheck(Lp, LoopScalarPreHeader, false);
 
   // Generate the induction variable.
-  Value *CountRoundDown = getOrCreateVectorTripCount(Lp);
-  EPI.VectorTripCount = CountRoundDown;
+  EPI.VectorTripCount = getOrCreateVectorTripCount(Lp);
   createHeaderBranch(Lp);
 
   // Skip induction resume value creation here because they will be created in
   // the second pass. If we created them here, they wouldn't be used anyway,
   // because the vplan in the second pass still contains the inductions from the
   // original loop.
 
   return {completeLoopSkeleton(Lp, OrigLoopID), nullptr};