Update comment. nfc

Author: Mel-Chen

llvm/lib/Transforms/Vectorize/VPlan.h

@@ -1823,6 +1823,7 @@ class LLVM_ABI_FOR_TEST VPWidenGEPRecipe : public VPRecipeWithIRFlags {
     return VarIdx;
   }
 
+  /// Returns the element type for the first \p I indices of this recipe.
   Type *getIndexedType(unsigned I) const {
     auto *GEP = cast<GetElementPtrInst>(getUnderlyingInstr());
     SmallVector<Value *, 4> Ops(GEP->idx_begin(), GEP->idx_begin() + I);
@@ -1919,8 +1920,8 @@ class VPVectorEndPointerRecipe : public VPRecipeWithIRFlags,
 #endif
 };
 
-/// A recipe to compute the pointers for widened memory accesses of IndexedTy,
-/// with the Stride expressed in units of IndexedTy.
+/// A recipe to compute the pointers for widened memory accesses of
+/// SourceElementTy, with the Stride expressed in units of SourceElementTy.
 class VPVectorPointerRecipe : public VPRecipeWithIRFlags,
                               public VPUnrollPartAccessor<2> {
   Type *SourceElementTy;
@@ -3351,9 +3352,9 @@ struct VPWidenLoadEVLRecipe final : public VPWidenMemoryRecipe, public VPValue {
   }
 };
 
-/// A recipe for strided load operations, using the base address, stride, and an
-/// optional mask. This recipe will generate an vp.strided.load intrinsic call
-/// to represent memory accesses with a fixed stride.
+/// A recipe for strided load operations, using the base address, stride, VF,
+/// and an optional mask. This recipe will generate a vp.strided.load intrinsic
+/// call to represent memory accesses with a fixed stride.
 struct VPWidenStridedLoadRecipe final : public VPWidenMemoryRecipe,
                                         public VPValue {
   VPWidenStridedLoadRecipe(LoadInst &Load, VPValue *Addr, VPValue *Stride,
@@ -3393,6 +3394,7 @@ struct VPWidenStridedLoadRecipe final : public VPWidenMemoryRecipe,
   bool onlyFirstLaneUsed(const VPValue *Op) const override {
     assert(is_contained(operands(), Op) &&
            "Op must be an operand of the recipe");
+    // All operands except the mask are only used for the first lane.
     return Op == getAddr() || Op == getStride() || Op == getVF();
   }
 };

llvm/lib/Transforms/Vectorize/VPlanTransforms.cpp

@@ -4513,8 +4513,8 @@ static std::pair<VPValue *, VPValue *> matchStridedStart(VPValue *CurIndex) {
   if (Opcode != Instruction::Shl && Opcode != Instruction::Mul)
     return {nullptr, nullptr};
 
-  // Match the pattern binop(variant, invariant), or binop(invariant, variant)
-  // if the binary operator is commutative.
+  // Match the pattern binop(variant, uniform), or binop(uniform, variant) if
+  // the binary operator is commutative.
   bool IsLHSUniform = vputils::isSingleScalar(WidenR->getOperand(0));
   if (IsLHSUniform == vputils::isSingleScalar(WidenR->getOperand(1)) ||
       (IsLHSUniform && !Instruction::isCommutative(Opcode)))
@@ -4538,6 +4538,10 @@ static std::pair<VPValue *, VPValue *> matchStridedStart(VPValue *CurIndex) {
   return {StartR, StrideR};
 }
 
+/// Checks if the given VPWidenGEPRecipe \p WidenGEP represents a strided
+/// access. If so, it creates recipes representing the base pointer and stride
+/// in element type, and returns a tuple of {base pointer, stride, element
+/// type}. Otherwise, returns a tuple where all elements are nullptr.
 static std::tuple<VPValue *, VPValue *, Type *>
 determineBaseAndStride(VPWidenGEPRecipe *WidenGEP) {
   // TODO: Check if the base pointer is strided.