[SLP] Rename IsUniformStride to IsUnitStride. NFCI

[luke]

Summary

IsUniformStride is only used when the stride is a unit-stride, i.e. in a
plain wide vector load. This tightens the condition and renames it to
isUnitStride. It removes the old unused getUniformStrided() variant, as
isUnitStride should now imply that the stride is known.

[ABataev]

LG

[vdmitrie]

LGTM

llvm/include/llvm/Analysis/TargetTransformInfo.h

getGEPCost(Type *PointeeType, const Value *Ptr,
              ArrayRef<const Value *> Operands,
              TargetCostKind CostKind = TCK_SizeAndLatency) const;
 
   /// Describe known properties for a set of pointers.
   struct PointersChainInfo {
     /// All the GEPs in a set have same base address.
     unsigned IsSameBaseAddress : 1;
     /// These properties only valid if SameBaseAddress is set.
-    /// True if distance between any two neigbouring pointers is same value.
-    unsigned IsUniformStride : 1;
+    /// True if all pointers are separated by a unit stride.
+    unsigned IsUnitStride : 1;
     /// True if distance between any two neigbouring pointers is a known value.
     unsigned IsKnownStride : 1;
     unsigned Reserved : 29;
 
     bool isSameBase() const { return IsSameBaseAddress; }
-    bool isUniformStride() const {
-      return IsSameBaseAddress && IsUniformStride;
-    }
+    bool isUnitStride() const { return IsSameBaseAddress && IsUnitStride; }
     bool isKnownStride() const { return IsSameBaseAddress && IsKnownStride; }
 
-    static PointersChainInfo getKnownUniformStrided() {
-      return {/*IsSameBaseAddress=*/1, /*IsUniformStride=*/1,
+    static PointersChainInfo getUnitStride() {
+      return {/*IsSameBaseAddress=*/1, /*IsUnitStride=*/1,
               /*IsKnownStride=*/1, 0};
     }
-    static PointersChainInfo getUniformStrided() {
-      return {/*IsSameBaseAddress=*/1, /*IsUniformStride=*/1,
-              /*IsKnownStride=*/0, 0};
-    }
-    static PointersChainInfo getKnownNonUniformStrided() {
-      return {/*IsSameBaseAddress=*/1, /*IsUniformStride=*/0,
+    static PointersChainInfo getKnownStride() {
+      return {/*IsSameBaseAddress=*/1, /*IsUnitStride=*/0,
               /*IsKnownStride=*/1, 0};
     }
-    static PointersChainInfo getNonUniformStrided() {
-      return {/*IsSameBaseAddress=*/1, /*IsUniformStride=*/0,
+    static PointersChainInfo getUnknownStride() {
+      return {/*IsSameBaseAddress=*/1, /*IsUnitStride=*/0,
               /*IsKnownStride=*/0, 0};
     }
   };
   static_assert(sizeof(PointersChainInfo) == 4, "Was size increase justified?");
 
   /// Estimate the cost of a chain of pointers (typically pointer operands of a
   /// chain of loads or stores within same block) operations set when lowered.
   InstructionCost

llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp

if (isa<LoadInst, StoreInst>(VL0)) {
       // a wide load/store.
       // Scalar cost is estimated as a set of pointers with known relationship
       // between them.
       // For vector code we will use BasePtr as argument for the wide load/store
       // but we also need to account all the instructions which are going to
       // stay in vectorized code due to uses outside of these scalar
       // loads/stores.
       ScalarCost = TTI->getPointersChainCost(
-          Ptrs, BasePtr, TTI::PointersChainInfo::getKnownUniformStrided(),
-          CostKind);
+          Ptrs, BasePtr, TTI::PointersChainInfo::getUnitStride(), CostKind);
 
       SmallVector<const Value *> PtrsRetainedInVecCode;
       for (Value *V : Ptrs) {
         if (V == BasePtr) {
           PtrsRetainedInVecCode.push_back(V);
           continue;
         }
         auto *Ptr = dyn_cast<GetElementPtrInst>(V);
if (isa<LoadInst, StoreInst>(VL0)) {
         // If all pointers stay in vectorized code then we don't have
         // any savings on that.
         LLVM_DEBUG(dumpTreeCosts(E, 0, ScalarCost, ScalarCost,
                                  "Calculated GEPs cost for Tree"));
         return InstructionCost{TTI::TCC_Free};
       }
       VecCost = TTI->getPointersChainCost(
           PtrsRetainedInVecCode, BasePtr,
-          TTI::PointersChainInfo::getKnownNonUniformStrided(), CostKind);
+          TTI::PointersChainInfo::getKnownStride(), CostKind);
     } else {
       // Case 1: Ptrs are the arguments of loads that we are going to transform
       // into masked gather load intrinsic.
       // All the scalar GEPs will be removed as a result of vectorization.
       // For any external uses of some lanes extract element instructions will
       // be generated (which cost is estimated separately).
       TTI::PointersChainInfo PtrsInfo =
           all_of(Ptrs,
                  [](const Value *V) {
                    auto *Ptr = dyn_cast<GetElementPtrInst>(V);
                    return Ptr && !Ptr->hasAllConstantIndices();
                  })
-              ? TTI::PointersChainInfo::getNonUniformStrided()
-              : TTI::PointersChainInfo::getKnownNonUniformStrided();
+              ? TTI::PointersChainInfo::getUnknownStride()
+              : TTI::PointersChainInfo::getKnownStride();
 
       ScalarCost = TTI->getPointersChainCost(Ptrs, BasePtr, PtrsInfo, CostKind);
 
       // Remark: it not quite correct to use scalar GEP cost for a vector GEP,
       // but it's not clear how to do that without having vector GEP arguments
       // ready.
       // Perhaps using just TTI::TCC_Free/TTI::TCC_Basic would be better option.
       if (const auto *Base = dyn_cast<GetElementPtrInst>(BasePtr)) {