Revert original solution

Author: dakersnar

llvm/lib/Transforms/Vectorize/LoadStoreVectorizer.cpp

@@ -343,9 +343,6 @@ class Vectorizer {
   /// Postcondition: For all i, ret[i][0].second == 0, because the first instr
   /// in the chain is the leader, and an instr touches distance 0 from itself.
   std::vector<Chain> gatherChains(ArrayRef<Instruction *> Instrs);
-
-  /// Propagates the best alignment in a chain of contiguous accesses
-  void propagateBestAlignmentInChain(ArrayRef<ChainElem> C) const;
 };
 
 class LoadStoreVectorizerLegacyPass : public FunctionPass {
@@ -719,14 +716,6 @@ std::vector<Chain> Vectorizer::splitChainByAlignment(Chain &C) {
   unsigned AS = getLoadStoreAddressSpace(C[0].Inst);
   unsigned VecRegBytes = TTI.getLoadStoreVecRegBitWidth(AS) / 8;
 
-  // We know that the accesses are contiguous. Propagate alignment
-  // information so that slices of the chain can still be vectorized.
-  propagateBestAlignmentInChain(C);
-  LLVM_DEBUG({
-    dbgs() << "LSV: Chain after alignment propagation:\n";
-    dumpChain(C);
-  });
-
   std::vector<Chain> Ret;
   for (unsigned CBegin = 0; CBegin < C.size(); ++CBegin) {
     // Find candidate chains of size not greater than the largest vector reg.
@@ -834,7 +823,6 @@ std::vector<Chain> Vectorizer::splitChainByAlignment(Chain &C) {
                      << Alignment.value() << " to " << NewAlign.value()
                      << "\n");
           Alignment = NewAlign;
-          setLoadStoreAlignment(C[CBegin].Inst, Alignment);
         }
       }
 
@@ -892,6 +880,14 @@ bool Vectorizer::vectorizeChain(Chain &C) {
       VecElemTy, 8 * ChainBytes / DL.getTypeSizeInBits(VecElemTy));
 
   Align Alignment = getLoadStoreAlignment(C[0].Inst);
+  // If this is a load/store of an alloca, we might have upgraded the alloca's
+  // alignment earlier.  Get the new alignment.
+  if (AS == DL.getAllocaAddrSpace()) {
+    Alignment = std::max(
+        Alignment,
+        getOrEnforceKnownAlignment(getLoadStorePointerOperand(C[0].Inst),
+                                   MaybeAlign(), DL, C[0].Inst, nullptr, &DT));
+  }
 
   // All elements of the chain must have the same scalar-type size.
 #ifndef NDEBUG
@@ -1638,24 +1634,3 @@ std::optional<APInt> Vectorizer::getConstantOffset(Value *PtrA, Value *PtrB,
         .sextOrTrunc(OrigBitWidth);
   return std::nullopt;
 }
-
-void Vectorizer::propagateBestAlignmentInChain(ArrayRef<ChainElem> C) const {
-  // Find the element in the chain with the best alignment and its offset.
-  Align BestAlign = getLoadStoreAlignment(C[0].Inst);
-  APInt BestAlignOffset = C[0].OffsetFromLeader;
-  for (const ChainElem &Elem : C) {
-    Align ElemAlign = getLoadStoreAlignment(Elem.Inst);
-    if (ElemAlign > BestAlign) {
-      BestAlign = ElemAlign;
-      BestAlignOffset = Elem.OffsetFromLeader;
-    }
-  }
-
-  // Propagate the best alignment to other elements in the chain, if possible.
-  for (const ChainElem &Elem : C) {
-    APInt OffsetDelta = APIntOps::abdu(Elem.OffsetFromLeader, BestAlignOffset);
-    Align NewAlign = commonAlignment(BestAlign, OffsetDelta.getLimitedValue());
-    if (NewAlign > getLoadStoreAlignment(Elem.Inst))
-      setLoadStoreAlignment(Elem.Inst, NewAlign);
-  }
-}

llvm/test/Transforms/LoadStoreVectorizer/X86/massive_indirection.ll

@@ -155,7 +155,7 @@ define void @variadics1(ptr %vlist) {
 ; CHECK-NEXT:    [[ARGP_NEXT12:%.*]] = getelementptr i8, ptr [[ARGP_CUR11_ALIGNED]], i64 8
 ; CHECK-NEXT:    [[X2:%.*]] = getelementptr i8, ptr [[ARGP_NEXT12]], i32 7
 ; CHECK-NEXT:    [[ARGP_CUR16_ALIGNED:%.*]] = call ptr @llvm.ptrmask.p0.i64(ptr [[X2]], i64 0)
-; CHECK-NEXT:    [[TMP1:%.*]] = load <2 x double>, ptr [[ARGP_CUR16_ALIGNED]], align 8
+; CHECK-NEXT:    [[TMP1:%.*]] = load <2 x double>, ptr [[ARGP_CUR16_ALIGNED]], align 4294967296
 ; CHECK-NEXT:    [[X31:%.*]] = extractelement <2 x double> [[TMP1]], i32 0
 ; CHECK-NEXT:    [[X42:%.*]] = extractelement <2 x double> [[TMP1]], i32 1
 ; CHECK-NEXT:    [[X5:%.*]] = fadd double [[X42]], [[X31]]