[VectorCombine] Scalarize vector GEP if that isn't more costly

[lebedev.ri]

Summary

As noted in https://reviews.llvm.org/D111220#3048397,
after masked memory intrinsic has been scalarized,
we may have an opportunity to improve the IR,
because the pointers were scalarized via extractelement,
but we might be able to fold them into getelementptr's.

We'd also need to schedule another VectorCombine run
somewhere after ScalarizeMaskedMemIntrin in backend IR phase.

[RKSimon]

Have you considered handling basic vector support in X86DAGToDAGISel::matchAddressRecursively ?

[lebedev.ri]

Should vector

In D111363#3050509, @RKSimon wrote:

Have you considered handling basic vector support in X86DAGToDAGISel::matchAddressRecursively ?

Hm, i have not. In addition to this or instead of? I'm not too familiar with that function,
so i'm not quite sure what you have in mind, with what/how it would help improve the patterns in question?

[craig.topper]

Did you consider teaching ScalarizeMaskedMemIntrinsic to special case GEPs? Then you wouldn't need to schedule another run of VectorCombine?

[lebedev.ri]

I think we mostly won't need this after all, i've found the real problem - D111460.

[lebedev.ri]

D111460 landed.

llvm/lib/Transforms/Vectorize/VectorCombine.cpp

 //===------- VectorCombine.cpp - Optimize partial vector operations -------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This pass optimizes scalar/vector interactions using target cost models. The
 // transforms implemented here may not fit in traditional loop-based or SLP
 // vectorization passes.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Transforms/Vectorize/VectorCombine.h"
+#include "llvm/ADT/ScopeExit.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/Analysis/AssumptionCache.h"
 #include "llvm/Analysis/BasicAliasAnalysis.h"
 #include "llvm/Analysis/GlobalsModRef.h"
 #include "llvm/Analysis/Loads.h"
 #include "llvm/Analysis/TargetTransformInfo.h"
 #include "llvm/Analysis/ValueTracking.h"
 #include "llvm/Analysis/VectorUtils.h"

 
 STATISTIC(NumVecLoad, "Number of vector loads formed");
 STATISTIC(NumVecCmp, "Number of vector compares formed");
 STATISTIC(NumVecBO, "Number of vector binops formed");
 STATISTIC(NumVecCmpBO, "Number of vector compare + binop formed");
 STATISTIC(NumShufOfBitcast, "Number of shuffles moved after bitcast");
 STATISTIC(NumScalarBO, "Number of scalar binops formed");
 STATISTIC(NumScalarCmp, "Number of scalar compares formed");
+STATISTIC(NumVecGEPsScalarized, "Number of vector GEP's that were scalarized");
 
 static cl::opt<bool> DisableVectorCombine(
     "disable-vector-combine", cl::init(false), cl::Hidden,
     cl::desc("Disable all vector combine transforms"));
 
 static cl::opt<bool> DisableBinopExtractShuffle(
     "disable-binop-extract-shuffle", cl::init(false), cl::Hidden,
     cl::desc("Disable binop extract to shuffle transforms"));
private:
   void foldExtExtBinop(ExtractElementInst *Ext0, ExtractElementInst *Ext1,
                        Instruction &I);
   bool foldExtractExtract(Instruction &I);
   bool foldBitcastShuf(Instruction &I);
   bool scalarizeBinopOrCmp(Instruction &I);
   bool foldExtractedCmps(Instruction &I);
   bool foldSingleElementStore(Instruction &I);
   bool scalarizeLoadExtract(Instruction &I);
+  bool scalarizeGEP(Instruction &I);
 
   void replaceValue(Value &Old, Value &New) {
     Old.replaceAllUsesWith(&New);
     New.takeName(&Old);
     if (auto *NewI = dyn_cast<Instruction>(&New)) {
       Worklist.pushUsersToWorkList(*NewI);
       Worklist.pushValue(NewI);
     }
for (User *U : LI->users()) {
     NewLoad->setAlignment(ScalarOpAlignment);
 
     replaceValue(*EI, *NewLoad);
   }
 
   return true;
 }
 
+/// Try to scalarize vector GEP only uses of which are `extractelement`'s.
+bool VectorCombine::scalarizeGEP(Instruction &I) {
+  auto *GEP = dyn_cast<GetElementPtrInst>(&I);
+  if (!GEP)
+    return false;
+
+  FixedVectorType *VecPtrTy = dyn_cast<FixedVectorType>(I.getType());
+  if (!VecPtrTy)
+    return false;
+  unsigned NumElts = VecPtrTy->getNumElements();
+  Type *PointeeTy = GEP->getSourceElementType();
+
+  if (GEP->getNumIndices() != 1)
+    return false; // FIXME
+
+  Value *GEPPointerOperand = GEP->getPointerOperand();
+  Value *GEPIndice = *GEP->idx_begin();
+
+  constexpr const int SSONumLanes = 512 / 32;
+  SmallDenseMap<std::pair<Value * /*BasePtr*/, Value * /*Index*/>, Value *,
+                SSONumLanes>
+      ScalarGEPCache;
+  struct ElementDetails {
+    SmallVector<ExtractElementInst *, 1> Uses;
+    Optional<Value *> BasePtr;
+    Optional<Value *> Index;
+  };
+
+  // Analyze uses of this GEP, they all should be `extractelement`'s,
+  // group them by the element index of the computed vector of addresses.
+  // FIXME: deal with non-constant indices?
+  SmallDenseMap<unsigned /*EltIdx*/, ElementDetails, SSONumLanes> GEPUses;
+  APInt GEPDemandedElts(NumElts, 0);
+  for (User *U : GEP->users()) {
+    auto *EEI = dyn_cast<ExtractElementInst>(U);
+    if (!EEI)
+      return false;
+    auto *IndexC = dyn_cast<ConstantInt>(EEI->getIndexOperand());
+    if (!IndexC)
+      return false; // FIXME
+    GEPUses[IndexC->getZExtValue()].Uses.emplace_back(EEI);
+    GEPDemandedElts.setBit(IndexC->getZExtValue());
+  }
+
+  InstructionCost OriginalCost =
+      TTI.getGEPCost(PointeeTy, GEPPointerOperand, GEPIndice) +
+      TTI.getScalarizationOverhead(VecPtrTy, GEPDemandedElts, /*Insert=*/false,
+                                   /*Extract=*/true);
+
+  APInt GEPPointerOperandDemandedElts(NumElts, 0);
+  APInt GEPIndiceDemandedElts(NumElts, 0);
+  for (auto &GEPVectorElement : GEPUses) {
+    unsigned IndexC = GEPVectorElement.first;
+
+    auto FindScalarElement = [IndexC](Value *V) {
+      if (!V->getType()->isVectorTy())
+        return V;
+      return findScalarElement(V, IndexC);
+    };
+
+    ElementDetails &Dsc = GEPVectorElement.second;
+
+    if (Value *ScalarBasePtr = FindScalarElement(GEPPointerOperand))
+      Dsc.BasePtr = ScalarBasePtr;
+    else
+      GEPPointerOperandDemandedElts.setBit(IndexC);
+
+    if (Value *ScalarIndex = FindScalarElement(GEPIndice))
+      Dsc.Index = ScalarIndex;
+    else
+      GEPIndiceDemandedElts.setBit(IndexC);
+  }
+
+  InstructionCost ScalarizedCost = 0;
+
+  if (!GEPPointerOperandDemandedElts.isNullValue())
+    ScalarizedCost += TTI.getScalarizationOverhead(
+        cast<FixedVectorType>(GEPPointerOperand->getType()),
+        GEPPointerOperandDemandedElts, /*Insert=*/false,
+        /*Extract=*/true);
+  if (!GEPIndiceDemandedElts.isNullValue())
+    ScalarizedCost += TTI.getScalarizationOverhead(
+        cast<FixedVectorType>(GEPIndice->getType()), GEPIndiceDemandedElts,
+        /*Insert=*/false,
+        /*Extract=*/true);
+
+  SmallVector<Instruction *, 16> NewInstructions;
+  auto _ = make_scope_exit([&]() {
+    for (Instruction *I : reverse(NewInstructions))
+      I->eraseFromParent();
+  });
+
+  IRBuilder<ConstantFolder, IRBuilderCallbackInserter> VindictiveBuilder(
+      I.getContext(), ConstantFolder(),
+      IRBuilderCallbackInserter(
+          [&](Instruction *I) { NewInstructions.push_back(I); }));
+  Builder.ClearInsertionPoint();
+  VindictiveBuilder.SetInsertPoint(&I);
+
+  for (auto &GEPVectorElement : GEPUses) {
+    unsigned IndexC = GEPVectorElement.first;
+    ElementDetails &Dsc = GEPVectorElement.second;
+
+    if (!Dsc.BasePtr)
+      Dsc.BasePtr =
+          VindictiveBuilder.CreateExtractElement(GEPPointerOperand, IndexC);
+
+    if (!Dsc.Index)
+      Dsc.Index = VindictiveBuilder.CreateExtractElement(GEPIndice, IndexC);
+
+    Value *&ScalarGEP = ScalarGEPCache[{*Dsc.BasePtr, *Dsc.Index}];
+    if (ScalarGEP)
+      continue;
+    ScalarizedCost += TTI.getGEPCost(PointeeTy, *Dsc.BasePtr, *Dsc.Index);
+    ScalarGEP =
+        VindictiveBuilder.CreateGEP(PointeeTy, *Dsc.BasePtr, *Dsc.Index);
+    if (auto *ScalarGEPInst = dyn_cast<GetElementPtrInst>(ScalarGEP))
+      ScalarGEPInst->setIsInBounds(GEP->isInBounds());
+  }
+
+  // Prefer to scalarize if cost is equal.
+  if (OriginalCost < ScalarizedCost)
+    return false;
+  NewInstructions.clear();
+
+  for (ElementDetails &Dsc : make_second_range(GEPUses)) {
+    Value &ScalarGEP = *ScalarGEPCache[{*Dsc.BasePtr, *Dsc.Index}];
+    for (auto *GEPUser : Dsc.Uses)
+      replaceValue(*GEPUser, ScalarGEP);
+  }
+
+  ++NumVecGEPsScalarized;
+  return true;
+}
+
 /// This is the entry point for all transforms. Pass manager differences are
 /// handled in the callers of this function.
 bool VectorCombine::run() {
   if (DisableVectorCombine)
     return false;
 
   // Don't attempt vectorization if the target does not support vectors.
   if (!TTI.getNumberOfRegisters(TTI.getRegisterClassForType(/*Vector*/ true)))
     return false;
 
   bool MadeChange = false;
   auto FoldInst = [this, &MadeChange](Instruction &I) {
     Builder.SetInsertPoint(&I);
     MadeChange |= vectorizeLoadInsert(I);
     MadeChange |= foldExtractExtract(I);
     MadeChange |= foldBitcastShuf(I);
     MadeChange |= scalarizeBinopOrCmp(I);
     MadeChange |= foldExtractedCmps(I);
     MadeChange |= scalarizeLoadExtract(I);
     MadeChange |= foldSingleElementStore(I);
+    MadeChange |= scalarizeGEP(I);
   };
   for (BasicBlock &BB : F) {
     // Ignore unreachable basic blocks.
     if (!DT.isReachableFromEntry(&BB))
       continue;
     // Use early increment range so that we can erase instructions in loop.
     for (Instruction &I : make_early_inc_range(BB)) {
       if (isa<DbgInfoIntrinsic>(I))

llvm/test/Transforms/VectorCombine/X86/scalarize-vector-gep.ll

;
 
   ret void
 }
 
 ;-------------------------------------------------------------------------------
 
 define void @indicies_need_extraction.2elts(i64* %baseptr, <2 x i64> %indices) {
 ; CHECK-LABEL: @indicies_need_extraction.2elts(
-; CHECK-NEXT:    [[PTRS:%.*]] = getelementptr inbounds i64, i64* [[BASEPTR:%.*]], <2 x i64> [[INDICES:%.*]]
-; CHECK-NEXT:    [[PTR_0:%.*]] = extractelement <2 x i64*> [[PTRS]], i64 0
+; CHECK-NEXT:    [[TMP1:%.*]] = extractelement <2 x i64> [[INDICES:%.*]], i64 0
+; CHECK-NEXT:    [[PTR_0:%.*]] = getelementptr inbounds i64, i64* [[BASEPTR:%.*]], i64 [[TMP1]]
+; CHECK-NEXT:    [[TMP2:%.*]] = extractelement <2 x i64> [[INDICES]], i64 1
+; CHECK-NEXT:    [[PTR_1:%.*]] = getelementptr inbounds i64, i64* [[BASEPTR]], i64 [[TMP2]]
 ; CHECK-NEXT:    call void @use(i64* [[PTR_0]])
-; CHECK-NEXT:    [[PTR_1:%.*]] = extractelement <2 x i64*> [[PTRS]], i64 1
 ; CHECK-NEXT:    call void @use(i64* [[PTR_1]])
 ; CHECK-NEXT:    ret void
 ;
   %ptrs = getelementptr inbounds i64, i64* %baseptr, <2 x i64> %indices
 
   %ptr.0 = extractelement <2 x i64*> %ptrs, i64 0
   call void @use(i64* %ptr.0)
 
   %ptr.1 = extractelement <2 x i64*> %ptrs, i64 1
   call void @use(i64* %ptr.1)
 
   ret void
 }
 
 define void @indicies_need_extraction.3elts(i64* %baseptr, <3 x i64> %indices) {
 ; CHECK-LABEL: @indicies_need_extraction.3elts(
-; CHECK-NEXT:    [[PTRS:%.*]] = getelementptr inbounds i64, i64* [[BASEPTR:%.*]], <3 x i64> [[INDICES:%.*]]
-; CHECK-NEXT:    [[PTR_0:%.*]] = extractelement <3 x i64*> [[PTRS]], i64 0
+; CHECK-NEXT:    [[TMP1:%.*]] = extractelement <3 x i64> [[INDICES:%.*]], i64 0
+; CHECK-NEXT:    [[PTR_0:%.*]] = getelementptr inbounds i64, i64* [[BASEPTR:%.*]], i64 [[TMP1]]
+; CHECK-NEXT:    [[TMP2:%.*]] = extractelement <3 x i64> [[INDICES]], i64 1
+; CHECK-NEXT:    [[PTR_1:%.*]] = getelementptr inbounds i64, i64* [[BASEPTR]], i64 [[TMP2]]
+; CHECK-NEXT:    [[TMP3:%.*]] = extractelement <3 x i64> [[INDICES]], i64 2
+; CHECK-NEXT:    [[PTR_2:%.*]] = getelementptr inbounds i64, i64* [[BASEPTR]], i64 [[TMP3]]
 ; CHECK-NEXT:    call void @use(i64* [[PTR_0]])
-; CHECK-NEXT:    [[PTR_1:%.*]] = extractelement <3 x i64*> [[PTRS]], i64 1
 ; CHECK-NEXT:    call void @use(i64* [[PTR_1]])
-; CHECK-NEXT:    [[PTR_2:%.*]] = extractelement <3 x i64*> [[PTRS]], i64 2
 ; CHECK-NEXT:    call void @use(i64* [[PTR_2]])
 ; CHECK-NEXT:    ret void
 ;
   %ptrs = getelementptr inbounds i64, i64* %baseptr, <3 x i64> %indices
 
   %ptr.0 = extractelement <3 x i64*> %ptrs, i64 0
   call void @use(i64* %ptr.0)
 
   %ptr.1 = extractelement <3 x i64*> %ptrs, i64 1
   call void @use(i64* %ptr.1)
 
   %ptr.2 = extractelement <3 x i64*> %ptrs, i64 2
   call void @use(i64* %ptr.2)
 
   ret void
 }
 
 define void @indicies_need_extraction.4elts(i64* %baseptr, <4 x i64> %indices) {
 ; CHECK-LABEL: @indicies_need_extraction.4elts(
-; CHECK-NEXT:    [[PTRS:%.*]] = getelementptr inbounds i64, i64* [[BASEPTR:%.*]], <4 x i64> [[INDICES:%.*]]
-; CHECK-NEXT:    [[PTR_0:%.*]] = extractelement <4 x i64*> [[PTRS]], i64 0
+; CHECK-NEXT:    [[TMP1:%.*]] = extractelement <4 x i64> [[INDICES:%.*]], i64 0
+; CHECK-NEXT:    [[PTR_0:%.*]] = getelementptr inbounds i64, i64* [[BASEPTR:%.*]], i64 [[TMP1]]
+; CHECK-NEXT:    [[TMP2:%.*]] = extractelement <4 x i64> [[INDICES]], i64 1
+; CHECK-NEXT:    [[PTR_1:%.*]] = getelementptr inbounds i64, i64* [[BASEPTR]], i64 [[TMP2]]
+; CHECK-NEXT:    [[TMP3:%.*]] = extractelement <4 x i64> [[INDICES]], i64 2
+; CHECK-NEXT:    [[PTR_2:%.*]] = getelementptr inbounds i64, i64* [[BASEPTR]], i64 [[TMP3]]
+; CHECK-NEXT:    [[TMP4:%.*]] = extractelement <4 x i64> [[INDICES]], i64 3
+; CHECK-NEXT:    [[PTR_3:%.*]] = getelementptr inbounds i64, i64* [[BASEPTR]], i64 [[TMP4]]
 ; CHECK-NEXT:    call void @use(i64* [[PTR_0]])
-; CHECK-NEXT:    [[PTR_1:%.*]] = extractelement <4 x i64*> [[PTRS]], i64 1
 ; CHECK-NEXT:    call void @use(i64* [[PTR_1]])
-; CHECK-NEXT:    [[PTR_2:%.*]] = extractelement <4 x i64*> [[PTRS]], i64 2
 ; CHECK-NEXT:    call void @use(i64* [[PTR_2]])
-; CHECK-NEXT:    [[PTR_3:%.*]] = extractelement <4 x i64*> [[PTRS]], i64 3
 ; CHECK-NEXT:    call void @use(i64* [[PTR_3]])
 ; CHECK-NEXT:    ret void
 ;
   %ptrs = getelementptr inbounds i64, i64* %baseptr, <4 x i64> %indices
 
   %ptr.0 = extractelement <4 x i64*> %ptrs, i64 0
   call void @use(i64* %ptr.0)
 
   %ptr.1 = extractelement <4 x i64*> %ptrs, i64 1
   call void @use(i64* %ptr.1)
 
   %ptr.2 = extractelement <4 x i64*> %ptrs, i64 2
   call void @use(i64* %ptr.2)
 
   %ptr.3 = extractelement <4 x i64*> %ptrs, i64 3
   call void @use(i64* %ptr.3)
 
   ret void
 }
 
 ;-------------------------------------------------------------------------------
 
 define void @baseptrs_need_extraction.2elts(<2 x i64*> %baseptrs, i64 %indice) {
 ; CHECK-LABEL: @baseptrs_need_extraction.2elts(
-; CHECK-NEXT:    [[PTRS:%.*]] = getelementptr inbounds i64, <2 x i64*> [[BASEPTRS:%.*]], i64 [[INDICE:%.*]]
-; CHECK-NEXT:    [[PTR_0:%.*]] = extractelement <2 x i64*> [[PTRS]], i64 0
+; CHECK-NEXT:    [[TMP1:%.*]] = extractelement <2 x i64*> [[BASEPTRS:%.*]], i64 0
+; CHECK-NEXT:    [[PTR_0:%.*]] = getelementptr inbounds i64, i64* [[TMP1]], i64 [[INDICE:%.*]]
+; CHECK-NEXT:    [[TMP2:%.*]] = extractelement <2 x i64*> [[BASEPTRS]], i64 1
+; CHECK-NEXT:    [[PTR_1:%.*]] = getelementptr inbounds i64, i64* [[TMP2]], i64 [[INDICE]]
 ; CHECK-NEXT:    call void @use(i64* [[PTR_0]])
-; CHECK-NEXT:    [[PTR_1:%.*]] = extractelement <2 x i64*> [[PTRS]], i64 1
 ; CHECK-NEXT:    call void @use(i64* [[PTR_1]])
 ; CHECK-NEXT:    ret void
 ;
   %ptrs = getelementptr inbounds i64, <2 x i64*> %baseptrs, i64 %indice
 
   %ptr.0 = extractelement <2 x i64*> %ptrs, i64 0
   call void @use(i64* %ptr.0)
 
   %ptr.1 = extractelement <2 x i64*> %ptrs, i64 1
   call void @use(i64* %ptr.1)
 
   ret void
 }
 
 define void @baseptrs_need_extraction.3elts(<3 x i64*> %baseptrs, i64 %indice) {
 ; CHECK-LABEL: @baseptrs_need_extraction.3elts(
-; CHECK-NEXT:    [[PTRS:%.*]] = getelementptr inbounds i64, <3 x i64*> [[BASEPTRS:%.*]], i64 [[INDICE:%.*]]
-; CHECK-NEXT:    [[PTR_0:%.*]] = extractelement <3 x i64*> [[PTRS]], i64 0
+; CHECK-NEXT:    [[TMP1:%.*]] = extractelement <3 x i64*> [[BASEPTRS:%.*]], i64 0
+; CHECK-NEXT:    [[PTR_0:%.*]] = getelementptr inbounds i64, i64* [[TMP1]], i64 [[INDICE:%.*]]
+; CHECK-NEXT:    [[TMP2:%.*]] = extractelement <3 x i64*> [[BASEPTRS]], i64 1
+; CHECK-NEXT:    [[PTR_1:%.*]] = getelementptr inbounds i64, i64* [[TMP2]], i64 [[INDICE]]
+; CHECK-NEXT:    [[TMP3:%.*]] = extractelement <3 x i64*> [[BASEPTRS]], i64 2
+; CHECK-NEXT:    [[PTR_2:%.*]] = getelementptr inbounds i64, i64* [[TMP3]], i64 [[INDICE]]
 ; CHECK-NEXT:    call void @use(i64* [[PTR_0]])
-; CHECK-NEXT:    [[PTR_1:%.*]] = extractelement <3 x i64*> [[PTRS]], i64 1
 ; CHECK-NEXT:    call void @use(i64* [[PTR_1]])
-; CHECK-NEXT:    [[PTR_2:%.*]] = extractelement <3 x i64*> [[PTRS]], i64 2
 ; CHECK-NEXT:    call void @use(i64* [[PTR_2]])
 ; CHECK-NEXT:    ret void
 ;
   %ptrs = getelementptr inbounds i64, <3 x i64*> %baseptrs, i64 %indice
 
   %ptr.0 = extractelement <3 x i64*> %ptrs, i64 0
   call void @use(i64* %ptr.0)
 
   %ptr.1 = extractelement <3 x i64*> %ptrs, i64 1
   call void @use(i64* %ptr.1)
 
   %ptr.2 = extractelement <3 x i64*> %ptrs, i64 2
   call void @use(i64* %ptr.2)
 
   ret void
 }
 
 define void @baseptrs_need_extraction.4elts(<4 x i64*> %baseptrs, i64 %indice) {
 ; CHECK-LABEL: @baseptrs_need_extraction.4elts(
-; CHECK-NEXT:    [[PTRS:%.*]] = getelementptr inbounds i64, <4 x i64*> [[BASEPTRS:%.*]], i64 [[INDICE:%.*]]
-; CHECK-NEXT:    [[PTR_0:%.*]] = extractelement <4 x i64*> [[PTRS]], i64 0
+; CHECK-NEXT:    [[TMP1:%.*]] = extractelement <4 x i64*> [[BASEPTRS:%.*]], i64 0
+; CHECK-NEXT:    [[PTR_0:%.*]] = getelementptr inbounds i64, i64* [[TMP1]], i64 [[INDICE:%.*]]
+; CHECK-NEXT:    [[TMP2:%.*]] = extractelement <4 x i64*> [[BASEPTRS]], i64 1
+; CHECK-NEXT:    [[PTR_1:%.*]] = getelementptr inbounds i64, i64* [[TMP2]], i64 [[INDICE]]
+; CHECK-NEXT:    [[TMP3:%.*]] = extractelement <4 x i64*> [[BASEPTRS]], i64 2
+; CHECK-NEXT:    [[PTR_2:%.*]] = getelementptr inbounds i64, i64* [[TMP3]], i64 [[INDICE]]
+; CHECK-NEXT:    [[TMP4:%.*]] = extractelement <4 x i64*> [[BASEPTRS]], i64 3
+; CHECK-NEXT:    [[PTR_3:%.*]] = getelementptr inbounds i64, i64* [[TMP4]], i64 [[INDICE]]
 ; CHECK-NEXT:    call void @use(i64* [[PTR_0]])
-; CHECK-NEXT:    [[PTR_1:%.*]] = extractelement <4 x i64*> [[PTRS]], i64 1
 ; CHECK-NEXT:    call void @use(i64* [[PTR_1]])
-; CHECK-NEXT:    [[PTR_2:%.*]] = extractelement <4 x i64*> [[PTRS]], i64 2
 ; CHECK-NEXT:    call void @use(i64* [[PTR_2]])
-; CHECK-NEXT:    [[PTR_3:%.*]] = extractelement <4 x i64*> [[PTRS]], i64 3
 ; CHECK-NEXT:    call void @use(i64* [[PTR_3]])
 ; CHECK-NEXT:    ret void
 ;
   %ptrs = getelementptr inbounds i64, <4 x i64*> %baseptrs, i64 %indice
 
   %ptr.0 = extractelement <4 x i64*> %ptrs, i64 0
   call void @use(i64* %ptr.0)
 
;
 
   ret void
 }
 
 define void @first_indice_and_baseptr_are_known.2elts(<2 x i64*> %baseptrs, i64* %second_baseptr, <2 x i64> %indices, i64 %second_indice) {
 ; CHECK-LABEL: @first_indice_and_baseptr_are_known.2elts(
 ; CHECK-NEXT:    [[BASEPTRS_NEW:%.*]] = insertelement <2 x i64*> [[BASEPTRS:%.*]], i64* [[SECOND_BASEPTR:%.*]], i64 0
 ; CHECK-NEXT:    [[INDICES_NEW:%.*]] = insertelement <2 x i64> [[INDICES:%.*]], i64 [[SECOND_INDICE:%.*]], i64 0
-; CHECK-NEXT:    [[PTRS:%.*]] = getelementptr inbounds i64, <2 x i64*> [[BASEPTRS_NEW]], <2 x i64> [[INDICES_NEW]]
-; CHECK-NEXT:    [[PTR_0:%.*]] = extractelement <2 x i64*> [[PTRS]], i64 0
+; CHECK-NEXT:    [[PTR_0:%.*]] = getelementptr inbounds i64, i64* [[SECOND_BASEPTR]], i64 [[SECOND_INDICE]]
+; CHECK-NEXT:    [[TMP1:%.*]] = extractelement <2 x i64*> [[BASEPTRS_NEW]], i64 1
+; CHECK-NEXT:    [[TMP2:%.*]] = extractelement <2 x i64> [[INDICES_NEW]], i64 1
+; CHECK-NEXT:    [[PTR_1:%.*]] = getelementptr inbounds i64, i64* [[TMP1]], i64 [[TMP2]]
 ; CHECK-NEXT:    call void @use(i64* [[PTR_0]])
-; CHECK-NEXT:    [[PTR_1:%.*]] = extractelement <2 x i64*> [[PTRS]], i64 1
 ; CHECK-NEXT:    call void @use(i64* [[PTR_1]])
 ; CHECK-NEXT:    ret void
 ;
   %baseptrs.new = insertelement <2 x i64*> %baseptrs, i64* %second_baseptr, i64 0
   %indices.new = insertelement <2 x i64> %indices, i64 %second_indice, i64 0
   %ptrs = getelementptr inbounds i64, <2 x i64*> %baseptrs.new, <2 x i64> %indices.new
 
   %ptr.0 = extractelement <2 x i64*> %ptrs, i64 0
;
   call void @use(i64* %ptr.2)
 
   ret void
 }
 
 ;-------------------------------------------------------------------------------
 
 define void @first_two_baseptrs_is_known.3elts(<3 x i64*> %baseptrs, i64* %second_baseptr, i64* %third_baseptr, <3 x i64> %indices) {
-; CHECK-LABEL: @first_two_baseptrs_is_known.3elts(
-; CHECK-NEXT:    [[BASEPTRS_NEW_TMP:%.*]] = insertelement <3 x i64*> [[BASEPTRS:%.*]], i64* [[SECOND_BASEPTR:%.*]], i64 0
-; CHECK-NEXT:    [[BASEPTRS_NEW:%.*]] = insertelement <3 x i64*> [[BASEPTRS_NEW_TMP]], i64* [[THIRD_BASEPTR:%.*]], i64 1
-; CHECK-NEXT:    [[PTRS:%.*]] = getelementptr inbounds i64, <3 x i64*> [[BASEPTRS_NEW]], <3 x i64> [[INDICES:%.*]]
-; CHECK-NEXT:    [[PTR_0:%.*]] = extractelement <3 x i64*> [[PTRS]], i64 0
-; CHECK-NEXT:    call void @use(i64* [[PTR_0]])
-; CHECK-NEXT:    [[PTR_1:%.*]] = extractelement <3 x i64*> [[PTRS]], i64 1
-; CHECK-NEXT:    call void @use(i64* [[PTR_1]])
-; CHECK-NEXT:    [[PTR_2:%.*]] = extractelement <3 x i64*> [[PTRS]], i64 2
-; CHECK-NEXT:    call void @use(i64* [[PTR_2]])
-; CHECK-NEXT:    ret void
+; SSE-LABEL: @first_two_baseptrs_is_known.3elts(
+; SSE-NEXT:    [[BASEPTRS_NEW_TMP:%.*]] = insertelement <3 x i64*> [[BASEPTRS:%.*]], i64* [[SECOND_BASEPTR:%.*]], i64 0
+; SSE-NEXT:    [[BASEPTRS_NEW:%.*]] = insertelement <3 x i64*> [[BASEPTRS_NEW_TMP]], i64* [[THIRD_BASEPTR:%.*]], i64 1
+; SSE-NEXT:    [[TMP1:%.*]] = extractelement <3 x i64> [[INDICES:%.*]], i64 0
+; SSE-NEXT:    [[PTR_0:%.*]] = getelementptr inbounds i64, i64* [[SECOND_BASEPTR]], i64 [[TMP1]]
+; SSE-NEXT:    [[TMP2:%.*]] = extractelement <3 x i64> [[INDICES]], i64 1
+; SSE-NEXT:    [[PTR_1:%.*]] = getelementptr inbounds i64, i64* [[THIRD_BASEPTR]], i64 [[TMP2]]
+; SSE-NEXT:    [[TMP3:%.*]] = extractelement <3 x i64*> [[BASEPTRS_NEW]], i64 2
+; SSE-NEXT:    [[TMP4:%.*]] = extractelement <3 x i64> [[INDICES]], i64 2
+; SSE-NEXT:    [[PTR_2:%.*]] = getelementptr inbounds i64, i64* [[TMP3]], i64 [[TMP4]]
+; SSE-NEXT:    call void @use(i64* [[PTR_0]])
+; SSE-NEXT:    call void @use(i64* [[PTR_1]])
+; SSE-NEXT:    call void @use(i64* [[PTR_2]])
+; SSE-NEXT:    ret void
+;
+; AVX-LABEL: @first_two_baseptrs_is_known.3elts(
+; AVX-NEXT:    [[BASEPTRS_NEW_TMP:%.*]] = insertelement <3 x i64*> [[BASEPTRS:%.*]], i64* [[SECOND_BASEPTR:%.*]], i64 0
+; AVX-NEXT:    [[BASEPTRS_NEW:%.*]] = insertelement <3 x i64*> [[BASEPTRS_NEW_TMP]], i64* [[THIRD_BASEPTR:%.*]], i64 1
+; AVX-NEXT:    [[PTRS:%.*]] = getelementptr inbounds i64, <3 x i64*> [[BASEPTRS_NEW]], <3 x i64> [[INDICES:%.*]]
+; AVX-NEXT:    [[PTR_0:%.*]] = extractelement <3 x i64*> [[PTRS]], i64 0
+; AVX-NEXT:    call void @use(i64* [[PTR_0]])
+; AVX-NEXT:    [[PTR_1:%.*]] = extractelement <3 x i64*> [[PTRS]], i64 1
+; AVX-NEXT:    call void @use(i64* [[PTR_1]])
+; AVX-NEXT:    [[PTR_2:%.*]] = extractelement <3 x i64*> [[PTRS]], i64 2
+; AVX-NEXT:    call void @use(i64* [[PTR_2]])
+; AVX-NEXT:    ret void
 ;
   %baseptrs.new.tmp = insertelement <3 x i64*> %baseptrs, i64* %second_baseptr, i64 0
   %baseptrs.new = insertelement <3 x i64*> %baseptrs.new.tmp, i64* %third_baseptr, i64 1
   %ptrs = getelementptr inbounds i64, <3 x i64*> %baseptrs.new, <3 x i64> %indices
 
   %ptr.0 = extractelement <3 x i64*> %ptrs, i64 0
   call void @use(i64* %ptr.0)
 

 }
 
 define void @first_two_indices_and_first_two_baseptrs_are_known.3elts(<3 x i64*> %baseptrs, i64* %second_baseptr, i64* %third_baseptr, <3 x i64> %indices, i64 %second_indice, i64 %third_indice) {
 ; CHECK-LABEL: @first_two_indices_and_first_two_baseptrs_are_known.3elts(
 ; CHECK-NEXT:    [[BASEPTRS_NEW_TMP:%.*]] = insertelement <3 x i64*> [[BASEPTRS:%.*]], i64* [[SECOND_BASEPTR:%.*]], i64 0
 ; CHECK-NEXT:    [[BASEPTRS_NEW:%.*]] = insertelement <3 x i64*> [[BASEPTRS_NEW_TMP]], i64* [[THIRD_BASEPTR:%.*]], i64 1
 ; CHECK-NEXT:    [[INDICES_NEW_TMP:%.*]] = insertelement <3 x i64> [[INDICES:%.*]], i64 [[SECOND_INDICE:%.*]], i64 0
 ; CHECK-NEXT:    [[INDICES_NEW:%.*]] = insertelement <3 x i64> [[INDICES_NEW_TMP]], i64 [[THIRD_INDICE:%.*]], i64 1
-; CHECK-NEXT:    [[PTRS:%.*]] = getelementptr inbounds i64, <3 x i64*> [[BASEPTRS_NEW]], <3 x i64> [[INDICES_NEW]]
-; CHECK-NEXT:    [[PTR_0:%.*]] = extractelement <3 x i64*> [[PTRS]], i64 0
+; CHECK-NEXT:    [[PTR_0:%.*]] = getelementptr inbounds i64, i64* [[SECOND_BASEPTR]], i64 [[SECOND_INDICE]]
+; CHECK-NEXT:    [[PTR_1:%.*]] = getelementptr inbounds i64, i64* [[THIRD_BASEPTR]], i64 [[THIRD_INDICE]]
+; CHECK-NEXT:    [[TMP1:%.*]] = extractelement <3 x i64*> [[BASEPTRS_NEW]], i64 2
+; CHECK-NEXT:    [[TMP2:%.*]] = extractelement <3 x i64> [[INDICES_NEW]], i64 2
+; CHECK-NEXT:    [[PTR_2:%.*]] = getelementptr inbounds i64, i64* [[TMP1]], i64 [[TMP2]]
 ; CHECK-NEXT:    call void @use(i64* [[PTR_0]])
-; CHECK-NEXT:    [[PTR_1:%.*]] = extractelement <3 x i64*> [[PTRS]], i64 1
 ; CHECK-NEXT:    call void @use(i64* [[PTR_1]])
-; CHECK-NEXT:    [[PTR_2:%.*]] = extractelement <3 x i64*> [[PTRS]], i64 2
 ; CHECK-NEXT:    call void @use(i64* [[PTR_2]])
 ; CHECK-NEXT:    ret void
 ;
   %baseptrs.new.tmp = insertelement <3 x i64*> %baseptrs, i64* %second_baseptr, i64 0
   %baseptrs.new = insertelement <3 x i64*> %baseptrs.new.tmp, i64* %third_baseptr, i64 1
   %indices.new.tmp = insertelement <3 x i64> %indices, i64 %second_indice, i64 0
   %indices.new = insertelement <3 x i64> %indices.new.tmp, i64 %third_indice, i64 1
   %ptrs = getelementptr inbounds i64, <3 x i64*> %baseptrs.new, <3 x i64> %indices.new
 
   %ptr.0 = extractelement <3 x i64*> %ptrs, i64 0
   call void @use(i64* %ptr.0)
 
   %ptr.1 = extractelement <3 x i64*> %ptrs, i64 1
   call void @use(i64* %ptr.1)
 
   %ptr.2 = extractelement <3 x i64*> %ptrs, i64 2
   call void @use(i64* %ptr.2)
 
   ret void
 }
 
 ;-------------------------------------------------------------------------------
 
 define void @first_two_baseptrs_is_knownequal.3elts(<3 x i64*> %baseptrs, i64* %second_baseptr, <3 x i64> %indices) {
-; CHECK-LABEL: @first_two_baseptrs_is_knownequal.3elts(
-; CHECK-NEXT:    [[BASEPTRS_NEW_TMP:%.*]] = insertelement <3 x i64*> [[BASEPTRS:%.*]], i64* [[SECOND_BASEPTR:%.*]], i64 0
-; CHECK-NEXT:    [[BASEPTRS_NEW:%.*]] = insertelement <3 x i64*> [[BASEPTRS_NEW_TMP]], i64* [[SECOND_BASEPTR]], i64 1
-; CHECK-NEXT:    [[PTRS:%.*]] = getelementptr inbounds i64, <3 x i64*> [[BASEPTRS_NEW]], <3 x i64> [[INDICES:%.*]]
-; CHECK-NEXT:    [[PTR_0:%.*]] = extractelement <3 x i64*> [[PTRS]], i64 0
-; CHECK-NEXT:    call void @use(i64* [[PTR_0]])
-; CHECK-NEXT:    [[PTR_1:%.*]] = extractelement <3 x i64*> [[PTRS]], i64 1
-; CHECK-NEXT:    call void @use(i64* [[PTR_1]])
-; CHECK-NEXT:    [[PTR_2:%.*]] = extractelement <3 x i64*> [[PTRS]], i64 2
-; CHECK-NEXT:    call void @use(i64* [[PTR_2]])
-; CHECK-NEXT:    ret void
+; SSE-LABEL: @first_two_baseptrs_is_knownequal.3elts(
+; SSE-NEXT:    [[BASEPTRS_NEW_TMP:%.*]] = insertelement <3 x i64*> [[BASEPTRS:%.*]], i64* [[SECOND_BASEPTR:%.*]], i64 0
+; SSE-NEXT:    [[BASEPTRS_NEW:%.*]] = insertelement <3 x i64*> [[BASEPTRS_NEW_TMP]], i64* [[SECOND_BASEPTR]], i64 1
+; SSE-NEXT:    [[TMP1:%.*]] = extractelement <3 x i64> [[INDICES:%.*]], i64 0
+; SSE-NEXT:    [[PTR_0:%.*]] = getelementptr inbounds i64, i64* [[SECOND_BASEPTR]], i64 [[TMP1]]
+; SSE-NEXT:    [[TMP2:%.*]] = extractelement <3 x i64> [[INDICES]], i64 1
+; SSE-NEXT:    [[PTR_1:%.*]] = getelementptr inbounds i64, i64* [[SECOND_BASEPTR]], i64 [[TMP2]]
+; SSE-NEXT:    [[TMP3:%.*]] = extractelement <3 x i64*> [[BASEPTRS_NEW]], i64 2
+; SSE-NEXT:    [[TMP4:%.*]] = extractelement <3 x i64> [[INDICES]], i64 2
+; SSE-NEXT:    [[PTR_2:%.*]] = getelementptr inbounds i64, i64* [[TMP3]], i64 [[TMP4]]
+; SSE-NEXT:    call void @use(i64* [[PTR_0]])
+; SSE-NEXT:    call void @use(i64* [[PTR_1]])
+; SSE-NEXT:    call void @use(i64* [[PTR_2]])
+; SSE-NEXT:    ret void
+;
+; AVX-LABEL: @first_two_baseptrs_is_knownequal.3elts(
+; AVX-NEXT:    [[BASEPTRS_NEW_TMP:%.*]] = insertelement <3 x i64*> [[BASEPTRS:%.*]], i64* [[SECOND_BASEPTR:%.*]], i64 0
+; AVX-NEXT:    [[BASEPTRS_NEW:%.*]] = insertelement <3 x i64*> [[BASEPTRS_NEW_TMP]], i64* [[SECOND_BASEPTR]], i64 1
+; AVX-NEXT:    [[PTRS:%.*]] = getelementptr inbounds i64, <3 x i64*> [[BASEPTRS_NEW]], <3 x i64> [[INDICES:%.*]]
+; AVX-NEXT:    [[PTR_0:%.*]] = extractelement <3 x i64*> [[PTRS]], i64 0
+; AVX-NEXT:    call void @use(i64* [[PTR_0]])
+; AVX-NEXT:    [[PTR_1:%.*]] = extractelement <3 x i64*> [[PTRS]], i64 1
+; AVX-NEXT:    call void @use(i64* [[PTR_1]])
+; AVX-NEXT:    [[PTR_2:%.*]] = extractelement <3 x i64*> [[PTRS]], i64 2
+; AVX-NEXT:    call void @use(i64* [[PTR_2]])
+; AVX-NEXT:    ret void
 ;
   %baseptrs.new.tmp = insertelement <3 x i64*> %baseptrs, i64* %second_baseptr, i64 0
   %baseptrs.new = insertelement <3 x i64*> %baseptrs.new.tmp, i64* %second_baseptr, i64 1
   %ptrs = getelementptr inbounds i64, <3 x i64*> %baseptrs.new, <3 x i64> %indices
 
   %ptr.0 = extractelement <3 x i64*> %ptrs, i64 0
   call void @use(i64* %ptr.0)
 

 }
 
 define void @first_two_indices_and_first_two_baseptrs_are_knownequal.3elts(<3 x i64*> %baseptrs, i64* %second_baseptr, <3 x i64> %indices, i64 %second_indice) {
 ; CHECK-LABEL: @first_two_indices_and_first_two_baseptrs_are_knownequal.3elts(
 ; CHECK-NEXT:    [[BASEPTRS_NEW_TMP:%.*]] = insertelement <3 x i64*> [[BASEPTRS:%.*]], i64* [[SECOND_BASEPTR:%.*]], i64 0
 ; CHECK-NEXT:    [[BASEPTRS_NEW:%.*]] = insertelement <3 x i64*> [[BASEPTRS_NEW_TMP]], i64* [[SECOND_BASEPTR]], i64 1
 ; CHECK-NEXT:    [[INDICES_NEW_TMP:%.*]] = insertelement <3 x i64> [[INDICES:%.*]], i64 [[SECOND_INDICE:%.*]], i64 0
 ; CHECK-NEXT:    [[INDICES_NEW:%.*]] = insertelement <3 x i64> [[INDICES_NEW_TMP]], i64 [[SECOND_INDICE]], i64 1
-; CHECK-NEXT:    [[PTRS:%.*]] = getelementptr inbounds i64, <3 x i64*> [[BASEPTRS_NEW]], <3 x i64> [[INDICES_NEW]]
-; CHECK-NEXT:    [[PTR_0:%.*]] = extractelement <3 x i64*> [[PTRS]], i64 0
-; CHECK-NEXT:    call void @use(i64* [[PTR_0]])
-; CHECK-NEXT:    [[PTR_1:%.*]] = extractelement <3 x i64*> [[PTRS]], i64 1
+; CHECK-NEXT:    [[PTR_1:%.*]] = getelementptr inbounds i64, i64* [[SECOND_BASEPTR]], i64 [[SECOND_INDICE]]
+; CHECK-NEXT:    [[TMP1:%.*]] = extractelement <3 x i64*> [[BASEPTRS_NEW]], i64 2
+; CHECK-NEXT:    [[TMP2:%.*]] = extractelement <3 x i64> [[INDICES_NEW]], i64 2
+; CHECK-NEXT:    [[PTR_2:%.*]] = getelementptr inbounds i64, i64* [[TMP1]], i64 [[TMP2]]
+; CHECK-NEXT:    call void @use(i64* [[PTR_1]])
 ; CHECK-NEXT:    call void @use(i64* [[PTR_1]])
-; CHECK-NEXT:    [[PTR_2:%.*]] = extractelement <3 x i64*> [[PTRS]], i64 2
 ; CHECK-NEXT:    call void @use(i64* [[PTR_2]])
 ; CHECK-NEXT:    ret void
 ;
   %baseptrs.new.tmp = insertelement <3 x i64*> %baseptrs, i64* %second_baseptr, i64 0
   %baseptrs.new = insertelement <3 x i64*> %baseptrs.new.tmp, i64* %second_baseptr, i64 1
   %indices.new.tmp = insertelement <3 x i64> %indices, i64 %second_indice, i64 0
   %indices.new = insertelement <3 x i64> %indices.new.tmp, i64 %second_indice, i64 1
   %ptrs = getelementptr inbounds i64, <3 x i64*> %baseptrs.new, <3 x i64> %indices.new
;
   call void @use(i64* %ptr.3)
 
   ret void
 }
 
 ;-------------------------------------------------------------------------------
 
 define void @first_two_baseptrs_is_knownequal.4elts(<3 x i64*> %baseptrs, i64* %second_baseptr, <3 x i64> %indices) {
-; CHECK-LABEL: @first_two_baseptrs_is_knownequal.4elts(
-; CHECK-NEXT:    [[BASEPTRS_NEW_TMP:%.*]] = insertelement <3 x i64*> [[BASEPTRS:%.*]], i64* [[SECOND_BASEPTR:%.*]], i64 0
-; CHECK-NEXT:    [[BASEPTRS_NEW:%.*]] = insertelement <3 x i64*> [[BASEPTRS_NEW_TMP]], i64* [[SECOND_BASEPTR]], i64 1
-; CHECK-NEXT:    [[PTRS:%.*]] = getelementptr inbounds i64, <3 x i64*> [[BASEPTRS_NEW]], <3 x i64> [[INDICES:%.*]]
-; CHECK-NEXT:    [[PTR_0:%.*]] = extractelement <3 x i64*> [[PTRS]], i64 0
-; CHECK-NEXT:    call void @use(i64* [[PTR_0]])
-; CHECK-NEXT:    [[PTR_1:%.*]] = extractelement <3 x i64*> [[PTRS]], i64 1
-; CHECK-NEXT:    call void @use(i64* [[PTR_1]])
-; CHECK-NEXT:    [[PTR_2:%.*]] = extractelement <3 x i64*> [[PTRS]], i64 2
-; CHECK-NEXT:    call void @use(i64* [[PTR_2]])
-; CHECK-NEXT:    ret void
+; SSE-LABEL: @first_two_baseptrs_is_knownequal.4elts(
+; SSE-NEXT:    [[BASEPTRS_NEW_TMP:%.*]] = insertelement <3 x i64*> [[BASEPTRS:%.*]], i64* [[SECOND_BASEPTR:%.*]], i64 0
+; SSE-NEXT:    [[BASEPTRS_NEW:%.*]] = insertelement <3 x i64*> [[BASEPTRS_NEW_TMP]], i64* [[SECOND_BASEPTR]], i64 1
+; SSE-NEXT:    [[TMP1:%.*]] = extractelement <3 x i64> [[INDICES:%.*]], i64 0
+; SSE-NEXT:    [[PTR_0:%.*]] = getelementptr inbounds i64, i64* [[SECOND_BASEPTR]], i64 [[TMP1]]
+; SSE-NEXT:    [[TMP2:%.*]] = extractelement <3 x i64> [[INDICES]], i64 1
+; SSE-NEXT:    [[PTR_1:%.*]] = getelementptr inbounds i64, i64* [[SECOND_BASEPTR]], i64 [[TMP2]]
+; SSE-NEXT:    [[TMP3:%.*]] = extractelement <3 x i64*> [[BASEPTRS_NEW]], i64 2
+; SSE-NEXT:    [[TMP4:%.*]] = extractelement <3 x i64> [[INDICES]], i64 2
+; SSE-NEXT:    [[PTR_2:%.*]] = getelementptr inbounds i64, i64* [[TMP3]], i64 [[TMP4]]
+; SSE-NEXT:    call void @use(i64* [[PTR_0]])
+; SSE-NEXT:    call void @use(i64* [[PTR_1]])
+; SSE-NEXT:    call void @use(i64* [[PTR_2]])
+; SSE-NEXT:    ret void
+;
+; AVX-LABEL: @first_two_baseptrs_is_knownequal.4elts(
+; AVX-NEXT:    [[BASEPTRS_NEW_TMP:%.*]] = insertelement <3 x i64*> [[BASEPTRS:%.*]], i64* [[SECOND_BASEPTR:%.*]], i64 0
+; AVX-NEXT:    [[BASEPTRS_NEW:%.*]] = insertelement <3 x i64*> [[BASEPTRS_NEW_TMP]], i64* [[SECOND_BASEPTR]], i64 1
+; AVX-NEXT:    [[PTRS:%.*]] = getelementptr inbounds i64, <3 x i64*> [[BASEPTRS_NEW]], <3 x i64> [[INDICES:%.*]]
+; AVX-NEXT:    [[PTR_0:%.*]] = extractelement <3 x i64*> [[PTRS]], i64 0
+; AVX-NEXT:    call void @use(i64* [[PTR_0]])
+; AVX-NEXT:    [[PTR_1:%.*]] = extractelement <3 x i64*> [[PTRS]], i64 1
+; AVX-NEXT:    call void @use(i64* [[PTR_1]])
+; AVX-NEXT:    [[PTR_2:%.*]] = extractelement <3 x i64*> [[PTRS]], i64 2
+; AVX-NEXT:    call void @use(i64* [[PTR_2]])
+; AVX-NEXT:    ret void
 ;
   %baseptrs.new.tmp = insertelement <3 x i64*> %baseptrs, i64* %second_baseptr, i64 0
   %baseptrs.new = insertelement <3 x i64*> %baseptrs.new.tmp, i64* %second_baseptr, i64 1
   %ptrs = getelementptr inbounds i64, <3 x i64*> %baseptrs.new, <3 x i64> %indices
 
   %ptr.0 = extractelement <3 x i64*> %ptrs, i64 0
   call void @use(i64* %ptr.0)
 

 }
 
 define void @first_two_indices_and_first_two_baseptrs_are_knownequal.4elts(<3 x i64*> %baseptrs, i64* %second_baseptr, <3 x i64> %indices, i64 %second_indice) {
 ; CHECK-LABEL: @first_two_indices_and_first_two_baseptrs_are_knownequal.4elts(
 ; CHECK-NEXT:    [[BASEPTRS_NEW_TMP:%.*]] = insertelement <3 x i64*> [[BASEPTRS:%.*]], i64* [[SECOND_BASEPTR:%.*]], i64 0
 ; CHECK-NEXT:    [[BASEPTRS_NEW:%.*]] = insertelement <3 x i64*> [[BASEPTRS_NEW_TMP]], i64* [[SECOND_BASEPTR]], i64 1
 ; CHECK-NEXT:    [[INDICES_NEW_TMP:%.*]] = insertelement <3 x i64> [[INDICES:%.*]], i64 [[SECOND_INDICE:%.*]], i64 0
 ; CHECK-NEXT:    [[INDICES_NEW:%.*]] = insertelement <3 x i64> [[INDICES_NEW_TMP]], i64 [[SECOND_INDICE]], i64 1
-; CHECK-NEXT:    [[PTRS:%.*]] = getelementptr inbounds i64, <3 x i64*> [[BASEPTRS_NEW]], <3 x i64> [[INDICES_NEW]]
-; CHECK-NEXT:    [[PTR_0:%.*]] = extractelement <3 x i64*> [[PTRS]], i64 0
-; CHECK-NEXT:    call void @use(i64* [[PTR_0]])
-; CHECK-NEXT:    [[PTR_1:%.*]] = extractelement <3 x i64*> [[PTRS]], i64 1
+; CHECK-NEXT:    [[PTR_1:%.*]] = getelementptr inbounds i64, i64* [[SECOND_BASEPTR]], i64 [[SECOND_INDICE]]
+; CHECK-NEXT:    [[TMP1:%.*]] = extractelement <3 x i64*> [[BASEPTRS_NEW]], i64 2
+; CHECK-NEXT:    [[TMP2:%.*]] = extractelement <3 x i64> [[INDICES_NEW]], i64 2
+; CHECK-NEXT:    [[PTR_2:%.*]] = getelementptr inbounds i64, i64* [[TMP1]], i64 [[TMP2]]
+; CHECK-NEXT:    call void @use(i64* [[PTR_1]])
 ; CHECK-NEXT:    call void @use(i64* [[PTR_1]])
-; CHECK-NEXT:    [[PTR_2:%.*]] = extractelement <3 x i64*> [[PTRS]], i64 2
 ; CHECK-NEXT:    call void @use(i64* [[PTR_2]])
 ; CHECK-NEXT:    ret void
 ;
   %baseptrs.new.tmp = insertelement <3 x i64*> %baseptrs, i64* %second_baseptr, i64 0
   %baseptrs.new = insertelement <3 x i64*> %baseptrs.new.tmp, i64* %second_baseptr, i64 1
   %indices.new.tmp = insertelement <3 x i64> %indices, i64 %second_indice, i64 0
   %indices.new = insertelement <3 x i64> %indices.new.tmp, i64 %second_indice, i64 1
   %ptrs = getelementptr inbounds i64, <3 x i64*> %baseptrs.new, <3 x i64> %indices.new