[llvm] [VPlan] Introduce VPGEPInstruction (PR #193510)
Ramkumar Ramachandra via llvm-commits
llvm-commits at lists.llvm.org
Wed Sep 9 01:53:37 PDT 2026
https://github.com/artagnon updated https://github.com/llvm/llvm-project/pull/193510
>From 4d4ce7f6cee129b42de7ca255b95ba5d12f01715 Mon Sep 17 00:00:00 2001
From: Ramkumar Ramachandra <artagnon at tenstorrent.com>
Date: Wed, 22 Apr 2026 13:26:53 +0100
Subject: [PATCH] [VPlan] Introduce VPGEPInstruction
Currently, WidenGEP, Replicate, and VPInstruction recipes can all
hold a Instruction::GetElementPtr. Introduce a first-class "scalar GEP"
VPInstructionWithType, similar to the existing "scalar cast", with the
additional benefit of being able to query the source element type of the
GEP directly without going to the underlying value. Planned follow-ups
include unifying WidenGEP and Replicate GEPs with this VPInstruction
GEP.
---
.../Vectorize/LoopVectorizationPlanner.h | 16 ++
.../Transforms/Vectorize/LoopVectorize.cpp | 3 +-
llvm/lib/Transforms/Vectorize/VPlan.h | 53 ++++-
.../Vectorize/VPlanConstruction.cpp | 4 +
.../Transforms/Vectorize/VPlanPatternMatch.h | 6 +-
.../lib/Transforms/Vectorize/VPlanRecipes.cpp | 24 +++
.../Transforms/Vectorize/VPlanTransforms.cpp | 22 +--
llvm/lib/Transforms/Vectorize/VPlanUtils.cpp | 17 +-
llvm/lib/Transforms/Vectorize/VPlanUtils.h | 4 +
.../LoopVectorize/AArch64/cmp_cost.ll | 32 +--
.../AArch64/synthesize-mask-for-call.ll | 24 +--
.../LoopVectorize/ARM/mve-icmpcost.ll | 12 +-
.../VPlan/AArch64/call-decisions.ll | 8 +-
.../VPlan/AArch64/partial-reduce-usabs.ll | 8 +-
.../VPlan/AArch64/single-scalar-cast.ll | 4 +-
.../VPlan/AArch64/sve-tail-folding-forced.ll | 2 +-
.../VPlan/AArch64/sve2-histcnt-vplan.ll | 6 +-
.../AArch64/vplan-memory-op-decisions.ll | 58 +++---
.../AArch64/vplan-printing-alias-mask.ll | 6 +-
.../VPlan/AArch64/vplan-printing.ll | 12 +-
.../widen-call-with-intrinsic-or-libfunc.ll | 4 +-
.../PowerPC/vplan-force-tail-with-evl.ll | 4 +-
.../VPlan/RISCV/cse-loads-evl.ll | 46 ++---
.../LoopVectorize/VPlan/RISCV/expand-scev.ll | 4 +-
.../VPlan/RISCV/partial-reduce-dot-product.ll | 4 +-
.../VPlan/RISCV/reductions-evl.ll | 26 +--
.../VPlan/RISCV/vplan-riscv-vector-reverse.ll | 4 +-
...an-vp-intrinsics-fixed-order-recurrence.ll | 4 +-
.../RISCV/vplan-vp-intrinsics-reduction.ll | 10 +-
.../VPlan/RISCV/vplan-vp-intrinsics.ll | 20 +-
.../VPlan/X86/cse-loads-gather.ll | 10 +-
.../scalarize-wide-load-for-address-use.ll | 18 +-
.../VPlan/X86/vplan-vp-intrinsics.ll | 12 +-
.../conditional-scalar-assignment-vplan.ll | 10 +-
.../LoopVectorize/VPlan/constant-fold.ll | 14 +-
.../LoopVectorize/VPlan/cse-loads-masked.ll | 22 +--
.../LoopVectorize/VPlan/cse-loads-tailfold.ll | 4 +-
.../LoopVectorize/VPlan/cse-loads.ll | 90 ++++-----
.../VPlan/dissolve-replicate-regions.ll | 18 +-
.../VPlan/early_exit_with_stores_vplan.ll | 12 +-
.../VPlan/epilogue-vectorization-printing.ll | 26 +--
.../VPlan/execution-frequencies-match-bfi.ll | 66 +++----
.../LoopVectorize/VPlan/find-last.ll | 4 +-
.../first-order-recurrence-chains-vplan.ll | 8 +-
.../VPlan/interleave-and-scalarize-only.ll | 12 +-
...ave-conditional-scalar-assignment-vplan.ll | 4 +-
.../VPlan/phi-with-fastflags-vplan.ll | 2 +-
.../LoopVectorize/VPlan/predicator.ll | 22 +--
.../LoopVectorize/VPlan/print-attributes.ll | 8 +-
.../VPlan/scalarize-irregular-type-memops.ll | 20 +-
.../VPlan/simplify-reverse-reverse.ll | 4 +-
.../LoopVectorize/VPlan/tail-folding.ll | 6 +-
.../VPlan/uncountable-early-exit-vplan.ll | 10 +-
.../VPlan/vplan-based-stride-mv.ll | 184 +++++++++---------
.../LoopVectorize/VPlan/vplan-dot-printing.ll | 4 +-
.../VPlan/vplan-iv-transforms.ll | 6 +-
.../VPlan/vplan-narrow-iv-users.ll | 12 +-
.../VPlan/vplan-printing-alias-mask.ll | 12 +-
.../VPlan/vplan-printing-branch-weights.ll | 20 +-
.../VPlan/vplan-printing-flags.ll | 6 +-
.../VPlan/vplan-printing-metadata.ll | 48 ++---
.../VPlan/vplan-printing-outer-loop.ll | 4 +-
.../vplan-printing-reductions-tail-folded.ll | 46 ++---
.../VPlan/vplan-printing-reductions.ll | 46 ++---
.../LoopVectorize/VPlan/vplan-printing.ll | 38 ++--
.../VPlan/vplan-scev-address-idioms.ll | 64 +++---
.../VPlan/vplan-sink-scalars-and-merge-vf1.ll | 2 +-
.../VPlan/vplan-sink-scalars-and-merge.ll | 4 +-
.../VPlan/vplan-widen-struct-return.ll | 12 +-
.../widen-canonical-iv-register-pressure.ll | 8 +-
.../LoopVectorize/VPlan/widen_mem_idioms.ll | 8 +-
.../X86/CostModel/vpinstruction-cost.ll | 20 +-
.../LoopVectorize/X86/reduction-small-size.ll | 4 +-
.../LoopVectorize/iv-select-cmp-decreasing.ll | 90 +++------
.../test/Transforms/LoopVectorize/metadata.ll | 8 +-
.../Inputs/vplan.ll.expected | 2 +-
.../Transforms/Vectorize/VPlanHCFGTest.cpp | 4 +-
77 files changed, 784 insertions(+), 717 deletions(-)
diff --git a/llvm/lib/Transforms/Vectorize/LoopVectorizationPlanner.h b/llvm/lib/Transforms/Vectorize/LoopVectorizationPlanner.h
index 4ceac108ae8c7..bf84a125eda27 100644
--- a/llvm/lib/Transforms/Vectorize/LoopVectorizationPlanner.h
+++ b/llvm/lib/Transforms/Vectorize/LoopVectorizationPlanner.h
@@ -499,10 +499,26 @@ class VPBuilder {
VPI->setUnderlyingValue(UV);
return VPI;
}
+ if (Opcode == Instruction::GetElementPtr) {
+ assert(!Mask && "GetElementPtr cannot be predicated");
+ Type *SourceElementTy =
+ cast<GetElementPtrInst>(UV)->getSourceElementType();
+ return new VPGEPInstruction(SourceElementTy, Operands, Flags, Metadata,
+ DL, UV->getName(), UV);
+ }
return new VPReplicateRecipe(UV, Operands, /*IsSingleScalar=*/true, Mask,
Flags, Metadata, DL);
}
+ VPSingleDefRecipe *createScalarGEP(Type *SourceElementTy,
+ ArrayRef<VPValue *> Ops,
+ const VPIRFlags &Flags,
+ const VPIRMetadata &Metadata, DebugLoc DL,
+ Instruction *UV) {
+ return tryInsertInstruction(createSingleScalarOp(
+ Instruction::GetElementPtr, Ops, {}, Flags, Metadata, DL, UV));
+ }
+
VPScalarIVStepsRecipe *
createScalarIVSteps(Instruction::BinaryOps InductionOpcode,
FPMathOperator *FPBinOp, VPValue *IV, VPValue *Step,
diff --git a/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp b/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp
index 2493d2aca6265..8323f0dd00f8a 100644
--- a/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp
+++ b/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp
@@ -6619,7 +6619,8 @@ VPlanPtr LoopVectorizationPlanner::tryToBuildVPlan(VPlanPtr Plan,
VPReplicateRecipe, VPWidenLoadRecipe, VPWidenStoreRecipe,
VPWidenCallRecipe, VPWidenIntrinsicRecipe, VPVectorPointerRecipe,
VPVectorEndPointerRecipe, VPHistogramRecipe>(&R) ||
- (Instruction::isCast(cast<VPInstruction>(R).getOpcode()) &&
+ ((Instruction::isCast(cast<VPInstruction>(R).getOpcode()) ||
+ isa<VPGEPInstruction>(R)) &&
vputils::onlyFirstLaneUsed(R.getVPSingleValue())))
continue;
auto *VPI = cast<VPInstruction>(&R);
diff --git a/llvm/lib/Transforms/Vectorize/VPlan.h b/llvm/lib/Transforms/Vectorize/VPlan.h
index a9d292314bde7..d0853e6db1ef0 100644
--- a/llvm/lib/Transforms/Vectorize/VPlan.h
+++ b/llvm/lib/Transforms/Vectorize/VPlan.h
@@ -1569,6 +1569,53 @@ class LLVM_ABI_FOR_TEST VPInstruction : public VPRecipeWithIRFlags,
#endif
};
+class VPGEPInstruction : public VPInstruction {
+ /// The source element type of the GEP.
+ Type *SourceElementTy;
+
+public:
+ VPGEPInstruction(Type *SourceElementTy, ArrayRef<VPValue *> Operands,
+ const VPIRFlags &Flags = {},
+ const VPIRMetadata &Metadata = {},
+ DebugLoc DL = DebugLoc::getUnknown(), Twine Name = "",
+ Value *UV = nullptr)
+ : VPInstruction(Instruction::GetElementPtr, Operands, Flags, Metadata, DL,
+ Name, Operands[0]->getScalarType()),
+ SourceElementTy(SourceElementTy) {
+ setUnderlyingValue(UV);
+ }
+
+ static inline bool classof(const VPRecipeBase *R) {
+ auto *VPI = dyn_cast<VPInstruction>(R);
+ return VPI && VPI->getOpcode() == Instruction::GetElementPtr;
+ }
+
+ Type *getSourceElementType() const { return SourceElementTy; }
+
+ VPGEPInstruction *clone() override {
+ return new VPGEPInstruction(getSourceElementType(), operands(), *this,
+ *this, getDebugLoc(), getName(),
+ getUnderlyingValue());
+ }
+
+ InstructionCost computeCost(ElementCount VF,
+ VPCostContext &Ctx) const override {
+ // We mark this instruction as zero-cost because the cost of GEPs in
+ // vectorized code depends on whether the corresponding memory instruction
+ // is scalarized or not. Therefore, we handle GEPs with the memory
+ // instruction cost.
+ return 0;
+ }
+
+ void execute(VPTransformState &State) override;
+
+protected:
+#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+ void printRecipe(raw_ostream &O, const Twine &Indent,
+ VPSlotTracker &SlotTracker) const override;
+#endif
+};
+
/// Helper type to provide functions to access incoming values and blocks for
/// phi-like recipes.
class VPPhiAccessors {
@@ -3371,8 +3418,10 @@ class LLVM_ABI_FOR_TEST VPReplicateRecipe : public VPRecipeWithIRFlags,
computeScalarType(I, Operands), Flags, DL),
VPIRMetadata(Metadata), IsSingleScalar(IsSingleScalar),
IsPredicated(Mask) {
- assert((!IsSingleScalar || !I->isCast()) &&
- "Single-scalar casts should use VPInstruction");
+ assert((!IsSingleScalar ||
+ (!I->isCast() && I->getOpcode() != Instruction::GetElementPtr)) &&
+ "single-scalar casts should use VPInstruction, and single-scalar "
+ "GEPs should use VPGEPInstruction");
setUnderlyingValue(I);
if (Mask)
addOperand(Mask);
diff --git a/llvm/lib/Transforms/Vectorize/VPlanConstruction.cpp b/llvm/lib/Transforms/Vectorize/VPlanConstruction.cpp
index c0c63f3e87842..f9d80551718f7 100644
--- a/llvm/lib/Transforms/Vectorize/VPlanConstruction.cpp
+++ b/llvm/lib/Transforms/Vectorize/VPlanConstruction.cpp
@@ -271,6 +271,10 @@ void PlainCFGBuilder::createVPInstructionsForVPBB(VPBasicBlock *VPBB,
CI->getType(), CI->getDebugLoc(),
VPIRFlags(*CI), MD);
NewR->setUnderlyingValue(CI);
+ } else if (auto *GEP = dyn_cast<GetElementPtrInst>(Inst)) {
+ NewR = VPIRBuilder.createScalarGEP(GEP->getSourceElementType(),
+ VPOperands, VPIRFlags(*GEP), MD,
+ GEP->getDebugLoc(), GEP);
} else if (auto *LI = dyn_cast<LoadInst>(Inst)) {
NewR = VPIRBuilder.createScalarLoad(LI->getType(), VPOperands[0],
LI->getDebugLoc(), MD);
diff --git a/llvm/lib/Transforms/Vectorize/VPlanPatternMatch.h b/llvm/lib/Transforms/Vectorize/VPlanPatternMatch.h
index df49dbb3c2289..2a3e6f8a877de 100644
--- a/llvm/lib/Transforms/Vectorize/VPlanPatternMatch.h
+++ b/llvm/lib/Transforms/Vectorize/VPlanPatternMatch.h
@@ -818,8 +818,8 @@ template <typename Op0_t, typename Op1_t>
inline auto m_GetElementPtr(const Op0_t &Op0, const Op1_t &Op1) {
return m_CombineOr(
Recipe_match<std::tuple<Op0_t, Op1_t>, Instruction::GetElementPtr,
- /*Commutative*/ false, VPReplicateRecipe, VPWidenGEPRecipe>(
- Op0, Op1),
+ /*Commutative*/ false, VPReplicateRecipe, VPWidenGEPRecipe,
+ VPGEPInstruction>(Op0, Op1),
VPInstruction_match<VPInstruction::PtrAdd, Op0_t, Op1_t>(Op0, Op1),
VPInstruction_match<VPInstruction::WidePtrAdd, Op0_t, Op1_t>(Op0, Op1));
}
@@ -1116,6 +1116,8 @@ struct GetElementPtr_match {
if constexpr (std::is_same_v<RecipeTy, VPWidenGEPRecipe>) {
SourceElementType = DefR->getSourceElementType();
+ } else if constexpr (std::is_same_v<RecipeTy, VPGEPInstruction>) {
+ SourceElementType = DefR->getSourceElementType();
} else if (DefR->getOpcode() == Instruction::GetElementPtr) {
SourceElementType = cast<GetElementPtrInst>(DefR->getUnderlyingInstr())
->getSourceElementType();
diff --git a/llvm/lib/Transforms/Vectorize/VPlanRecipes.cpp b/llvm/lib/Transforms/Vectorize/VPlanRecipes.cpp
index 02ea01880ff4a..7a0cdb9e828b3 100644
--- a/llvm/lib/Transforms/Vectorize/VPlanRecipes.cpp
+++ b/llvm/lib/Transforms/Vectorize/VPlanRecipes.cpp
@@ -1574,6 +1574,7 @@ bool VPInstruction::isVectorToScalar() const {
bool VPInstruction::isSingleScalar() const {
switch (getOpcode()) {
+ case Instruction::GetElementPtr:
case Instruction::Load:
case Instruction::PHI:
case VPInstruction::ExplicitVectorLength:
@@ -1738,6 +1739,7 @@ bool VPInstruction::usesFirstLaneOnly(const VPValue *Op) const {
case Instruction::FCmp:
case Instruction::ICmp:
case Instruction::Select:
+ case Instruction::GetElementPtr:
case Instruction::Or:
case Instruction::Freeze:
case VPInstruction::Not:
@@ -1964,6 +1966,28 @@ static void executePhiRecipe(VPSingleDefRecipe *R, VPPhiAccessors &Phi,
State.set(R, NewPhi, IsScalar);
}
+void VPGEPInstruction::execute(VPTransformState &State) {
+ auto Ops = map_to_vector(operands(),
+ [&](VPValue *Op) { return State.get(Op, true); });
+ Value *GEP =
+ State.Builder.CreateGEP(getSourceElementType(), Ops.front(),
+ drop_begin(Ops), "", getGEPNoWrapFlags());
+ State.set(this, GEP, true);
+}
+
+#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+void VPGEPInstruction::printRecipe(raw_ostream &O, const Twine &Indent,
+ VPSlotTracker &SlotTracker) const {
+ O << Indent << "EMIT-SCALAR ";
+ printAsOperand(O, SlotTracker);
+ O << " = getelementptr";
+ printFlags(O);
+ getSourceElementType()->print(O);
+ O << ", ";
+ printOperands(O, SlotTracker);
+}
+#endif
+
void VPPhi::execute(VPTransformState &State) {
executePhiRecipe(this, *this, State, /*IsScalar=*/true, getName());
}
diff --git a/llvm/lib/Transforms/Vectorize/VPlanTransforms.cpp b/llvm/lib/Transforms/Vectorize/VPlanTransforms.cpp
index 42ee24f3f5014..9ea35d28823f1 100644
--- a/llvm/lib/Transforms/Vectorize/VPlanTransforms.cpp
+++ b/llvm/lib/Transforms/Vectorize/VPlanTransforms.cpp
@@ -25,7 +25,6 @@
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/SetVector.h"
#include "llvm/ADT/SmallPtrSet.h"
-#include "llvm/ADT/TypeSwitch.h"
#include "llvm/Analysis/IVDescriptors.h"
#include "llvm/Analysis/Loads.h"
#include "llvm/Analysis/LoopInfo.h"
@@ -2219,22 +2218,6 @@ void VPlanTransforms::clearReductionWrapFlags(VPlan &Plan) {
namespace {
struct VPCSEDenseMapInfo : public DenseMapInfo<VPSingleDefRecipe *> {
- /// If recipe \p R will lower to a GEP with a non-i8 source element type,
- /// return that source element type.
- static Type *getGEPSourceElementType(const VPSingleDefRecipe *R) {
- // All VPInstructions that lower to GEPs must have the i8 source element
- // type (as they are PtrAdds), so we omit it.
- return TypeSwitch<const VPSingleDefRecipe *, Type *>(R)
- .Case([](const VPReplicateRecipe *I) -> Type * {
- if (auto *GEP = dyn_cast<GetElementPtrInst>(I->getUnderlyingValue()))
- return GEP->getSourceElementType();
- return nullptr;
- })
- .Case<VPVectorPointerRecipe, VPWidenGEPRecipe>(
- [](auto *I) { return I->getSourceElementType(); })
- .Default([](auto *) { return nullptr; });
- }
-
/// Returns true if recipe \p Def can be safely handed for CSE.
static bool canHandle(const VPSingleDefRecipe *Def) {
// We can extend the list of handled recipes in the future,
@@ -2262,7 +2245,7 @@ struct VPCSEDenseMapInfo : public DenseMapInfo<VPSingleDefRecipe *> {
static unsigned getHashValue(const VPSingleDefRecipe *Def) {
hash_code Result = hash_combine(
Def->getVPRecipeID(), vputils::getOpcodeOrIntrinsicID(Def),
- getGEPSourceElementType(Def), Def->getScalarType(),
+ vputils::getGEPSourceElementType(Def), Def->getScalarType(),
vputils::isSingleScalar(Def), hash_combine_range(Def->operands()));
if (auto *RFlags = dyn_cast<VPRecipeWithIRFlags>(Def))
if (RFlags->hasPredicate())
@@ -2281,7 +2264,8 @@ struct VPCSEDenseMapInfo : public DenseMapInfo<VPSingleDefRecipe *> {
if (L->getVPRecipeID() != R->getVPRecipeID() ||
vputils::getOpcodeOrIntrinsicID(L) !=
vputils::getOpcodeOrIntrinsicID(R) ||
- getGEPSourceElementType(L) != getGEPSourceElementType(R) ||
+ vputils::getGEPSourceElementType(L) !=
+ vputils::getGEPSourceElementType(R) ||
vputils::isSingleScalar(L) != vputils::isSingleScalar(R) ||
!equal(L->operands(), R->operands()))
return false;
diff --git a/llvm/lib/Transforms/Vectorize/VPlanUtils.cpp b/llvm/lib/Transforms/Vectorize/VPlanUtils.cpp
index befc2d477aac4..4bc2d3ae0541e 100644
--- a/llvm/lib/Transforms/Vectorize/VPlanUtils.cpp
+++ b/llvm/lib/Transforms/Vectorize/VPlanUtils.cpp
@@ -129,6 +129,20 @@ GEPNoWrapFlags vputils::getGEPFlagsForPtr(VPValue *Ptr) {
return GEPNoWrapFlags::none();
}
+Type *vputils::getGEPSourceElementType(const VPSingleDefRecipe *R) {
+ // All VPInstructions that lower to GEPs must have the i8 source element
+ // type (as they are PtrAdds), so we omit it.
+ return TypeSwitch<const VPSingleDefRecipe *, Type *>(R)
+ .Case([](const VPReplicateRecipe *I) -> Type * {
+ if (auto *GEP = dyn_cast<GetElementPtrInst>(I->getUnderlyingValue()))
+ return GEP->getSourceElementType();
+ return nullptr;
+ })
+ .Case<VPVectorPointerRecipe, VPWidenGEPRecipe, VPGEPInstruction>(
+ [](auto *I) { return I->getSourceElementType(); })
+ .Default([](auto *) { return nullptr; });
+}
+
const SCEV *vputils::getSCEVExprForVPValue(const VPValue *V,
PredicatedScalarEvolution &PSE,
const Loop *L) {
@@ -1304,8 +1318,7 @@ VPIRValue *vputils::tryToFoldLiveIns(VPSingleDefRecipe &R,
Ops[1]);
case Instruction::GetElementPtr: {
auto &RFlags = cast<VPRecipeWithIRFlags>(R);
- auto *GEP = cast<GetElementPtrInst>(RFlags.getUnderlyingInstr());
- return Folder.FoldGEP(GEP->getSourceElementType(), Ops[0],
+ return Folder.FoldGEP(getGEPSourceElementType(&RFlags), Ops[0],
drop_begin(Ops), RFlags.getGEPNoWrapFlags());
}
case VPInstruction::PtrAdd:
diff --git a/llvm/lib/Transforms/Vectorize/VPlanUtils.h b/llvm/lib/Transforms/Vectorize/VPlanUtils.h
index cb9d1e5607a4a..df083f23cf592 100644
--- a/llvm/lib/Transforms/Vectorize/VPlanUtils.h
+++ b/llvm/lib/Transforms/Vectorize/VPlanUtils.h
@@ -174,6 +174,10 @@ VPInstruction *findCanonicalIVIncrement(VPlan &Plan);
/// mirroring Value::stripPointerCasts.
GEPNoWrapFlags getGEPFlagsForPtr(VPValue *Ptr);
+/// If recipe \p R will lower to a GEP with a non-i8 source element type,
+/// return that source element type.
+Type *getGEPSourceElementType(const VPSingleDefRecipe *R);
+
/// Returns true if \p V is used as part of the address of another load or
/// store.
bool isUsedByLoadStoreAddress(const VPValue *V);
diff --git a/llvm/test/Transforms/LoopVectorize/AArch64/cmp_cost.ll b/llvm/test/Transforms/LoopVectorize/AArch64/cmp_cost.ll
index a25edccb60514..715a3497f292f 100644
--- a/llvm/test/Transforms/LoopVectorize/AArch64/cmp_cost.ll
+++ b/llvm/test/Transforms/LoopVectorize/AArch64/cmp_cost.ll
@@ -149,7 +149,7 @@ define i32 @switch_to_cmp(ptr %s, ptr %dst, i64 %n) {
; CHECK: Cost of 0 for VF 2: forced scalar %dst.gep = getelementptr i8, ptr %dst, i64 %iv
; CHECK: Cost of 0 for VF 2: WIDEN-REDUCTION-PHI ir<%c> = phi (add) vp<[[VP3:%[0-9]+]]>, ir<%c.next>
; CHECK: Cost of 0 for VF 2: vp<[[VP5:%[0-9]+]]> = SCALAR-STEPS vp<[[VP4:%[0-9]+]]>, ir<1>, vp<[[VP0:%[0-9]+]]>
-; CHECK: Cost of 0 for VF 2: CLONE ir<%gep> = getelementptr ir<%s>, vp<[[VP5]]>
+; CHECK: Cost of 0 for VF 2: EMIT-SCALAR ir<%gep> = getelementptr i8, ir<%s>, vp<[[VP5]]>
; CHECK: Cost of 0 for VF 2: vp<[[VP6:%[0-9]+]]> = vector-pointer i8, ir<%gep>, ir<1>
; CHECK: Cost of 4 for VF 2: WIDEN ir<%l> = load vp<[[VP6]]>
; CHECK: Cost of 1 for VF 2: EMIT vp<[[VP7:%[0-9]+]]> = icmp eq ir<%l>, ir<1>
@@ -185,7 +185,7 @@ define i32 @switch_to_cmp(ptr %s, ptr %dst, i64 %n) {
; CHECK: Cost of 1 for VF 2: WIDEN ir<%c.4> = add ir<%c>, ir<4>
; CHECK: Cost of 1 for VF 2: WIDEN ir<%c.1> = add ir<%c>, ir<1>
; CHECK: Cost of 7 for VF 2: BLEND ir<%c.next> = ir<%c> ir<%c.4>/vp<[[VP22]]> ir<%c.1>/vp<[[VP36]]>
-; CHECK: Cost of 0 for VF 2: CLONE ir<%dst.gep> = getelementptr ir<%dst>, vp<[[VP5]]>
+; CHECK: Cost of 0 for VF 2: EMIT-SCALAR ir<%dst.gep> = getelementptr i8, ir<%dst>, vp<[[VP5]]>
; CHECK: Cost of 0 for VF 2: vp<[[VP37:%[0-9]+]]> = vector-pointer i8, ir<%dst.gep>, ir<1>
; CHECK: Cost of 4 for VF 2: WIDEN store vp<[[VP37]]>, ir<%l>
; CHECK: Cost of 0 for VF 2: EMIT vp<%index.next> = add nuw vp<[[VP4]]>, vp<[[VP1:%[0-9]+]]>
@@ -207,7 +207,7 @@ define i32 @switch_to_cmp(ptr %s, ptr %dst, i64 %n) {
; CHECK: Cost of 0 for VF 4: forced scalar %dst.gep = getelementptr i8, ptr %dst, i64 %iv
; CHECK: Cost of 0 for VF 4: WIDEN-REDUCTION-PHI ir<%c> = phi (add) vp<[[VP3]]>, ir<%c.next>
; CHECK: Cost of 0 for VF 4: vp<[[VP5]]> = SCALAR-STEPS vp<[[VP4]]>, ir<1>, vp<[[VP0]]>
-; CHECK: Cost of 0 for VF 4: CLONE ir<%gep> = getelementptr ir<%s>, vp<[[VP5]]>
+; CHECK: Cost of 0 for VF 4: EMIT-SCALAR ir<%gep> = getelementptr i8, ir<%s>, vp<[[VP5]]>
; CHECK: Cost of 0 for VF 4: vp<[[VP6]]> = vector-pointer i8, ir<%gep>, ir<1>
; CHECK: Cost of 2 for VF 4: WIDEN ir<%l> = load vp<[[VP6]]>
; CHECK: Cost of 1 for VF 4: EMIT vp<[[VP7]]> = icmp eq ir<%l>, ir<1>
@@ -243,7 +243,7 @@ define i32 @switch_to_cmp(ptr %s, ptr %dst, i64 %n) {
; CHECK: Cost of 1 for VF 4: WIDEN ir<%c.4> = add ir<%c>, ir<4>
; CHECK: Cost of 1 for VF 4: WIDEN ir<%c.1> = add ir<%c>, ir<1>
; CHECK: Cost of 13 for VF 4: BLEND ir<%c.next> = ir<%c> ir<%c.4>/vp<[[VP22]]> ir<%c.1>/vp<[[VP36]]>
-; CHECK: Cost of 0 for VF 4: CLONE ir<%dst.gep> = getelementptr ir<%dst>, vp<[[VP5]]>
+; CHECK: Cost of 0 for VF 4: EMIT-SCALAR ir<%dst.gep> = getelementptr i8, ir<%dst>, vp<[[VP5]]>
; CHECK: Cost of 0 for VF 4: vp<[[VP37]]> = vector-pointer i8, ir<%dst.gep>, ir<1>
; CHECK: Cost of 2 for VF 4: WIDEN store vp<[[VP37]]>, ir<%l>
; CHECK: Cost of 0 for VF 4: EMIT vp<%index.next> = add nuw vp<[[VP4]]>, vp<[[VP1]]>
@@ -265,7 +265,7 @@ define i32 @switch_to_cmp(ptr %s, ptr %dst, i64 %n) {
; CHECK: Cost of 0 for VF 8: forced scalar %dst.gep = getelementptr i8, ptr %dst, i64 %iv
; CHECK: Cost of 0 for VF 8: WIDEN-REDUCTION-PHI ir<%c> = phi (add) vp<[[VP3]]>, ir<%c.next>
; CHECK: Cost of 0 for VF 8: vp<[[VP5]]> = SCALAR-STEPS vp<[[VP4]]>, ir<1>, vp<[[VP0]]>
-; CHECK: Cost of 0 for VF 8: CLONE ir<%gep> = getelementptr ir<%s>, vp<[[VP5]]>
+; CHECK: Cost of 0 for VF 8: EMIT-SCALAR ir<%gep> = getelementptr i8, ir<%s>, vp<[[VP5]]>
; CHECK: Cost of 0 for VF 8: vp<[[VP6]]> = vector-pointer i8, ir<%gep>, ir<1>
; CHECK: Cost of 1 for VF 8: WIDEN ir<%l> = load vp<[[VP6]]>
; CHECK: Cost of 1 for VF 8: EMIT vp<[[VP7]]> = icmp eq ir<%l>, ir<1>
@@ -301,7 +301,7 @@ define i32 @switch_to_cmp(ptr %s, ptr %dst, i64 %n) {
; CHECK: Cost of 2 for VF 8: WIDEN ir<%c.4> = add ir<%c>, ir<4>
; CHECK: Cost of 2 for VF 8: WIDEN ir<%c.1> = add ir<%c>, ir<1>
; CHECK: Cost of 10 for VF 8: BLEND ir<%c.next> = ir<%c> ir<%c.4>/vp<[[VP22]]> ir<%c.1>/vp<[[VP36]]>
-; CHECK: Cost of 0 for VF 8: CLONE ir<%dst.gep> = getelementptr ir<%dst>, vp<[[VP5]]>
+; CHECK: Cost of 0 for VF 8: EMIT-SCALAR ir<%dst.gep> = getelementptr i8, ir<%dst>, vp<[[VP5]]>
; CHECK: Cost of 0 for VF 8: vp<[[VP37]]> = vector-pointer i8, ir<%dst.gep>, ir<1>
; CHECK: Cost of 1 for VF 8: WIDEN store vp<[[VP37]]>, ir<%l>
; CHECK: Cost of 0 for VF 8: EMIT vp<%index.next> = add nuw vp<[[VP4]]>, vp<[[VP1]]>
@@ -323,7 +323,7 @@ define i32 @switch_to_cmp(ptr %s, ptr %dst, i64 %n) {
; CHECK: Cost of 0 for VF 16: forced scalar %dst.gep = getelementptr i8, ptr %dst, i64 %iv
; CHECK: Cost of 0 for VF 16: WIDEN-REDUCTION-PHI ir<%c> = phi (add) vp<[[VP3]]>, ir<%c.next>
; CHECK: Cost of 0 for VF 16: vp<[[VP5]]> = SCALAR-STEPS vp<[[VP4]]>, ir<1>, vp<[[VP0]]>
-; CHECK: Cost of 0 for VF 16: CLONE ir<%gep> = getelementptr ir<%s>, vp<[[VP5]]>
+; CHECK: Cost of 0 for VF 16: EMIT-SCALAR ir<%gep> = getelementptr i8, ir<%s>, vp<[[VP5]]>
; CHECK: Cost of 0 for VF 16: vp<[[VP6]]> = vector-pointer i8, ir<%gep>, ir<1>
; CHECK: Cost of 1 for VF 16: WIDEN ir<%l> = load vp<[[VP6]]>
; CHECK: Cost of 1 for VF 16: EMIT vp<[[VP7]]> = icmp eq ir<%l>, ir<1>
@@ -359,7 +359,7 @@ define i32 @switch_to_cmp(ptr %s, ptr %dst, i64 %n) {
; CHECK: Cost of 4 for VF 16: WIDEN ir<%c.4> = add ir<%c>, ir<4>
; CHECK: Cost of 4 for VF 16: WIDEN ir<%c.1> = add ir<%c>, ir<1>
; CHECK: Cost of 20 for VF 16: BLEND ir<%c.next> = ir<%c> ir<%c.4>/vp<[[VP22]]> ir<%c.1>/vp<[[VP36]]>
-; CHECK: Cost of 0 for VF 16: CLONE ir<%dst.gep> = getelementptr ir<%dst>, vp<[[VP5]]>
+; CHECK: Cost of 0 for VF 16: EMIT-SCALAR ir<%dst.gep> = getelementptr i8, ir<%dst>, vp<[[VP5]]>
; CHECK: Cost of 0 for VF 16: vp<[[VP37]]> = vector-pointer i8, ir<%dst.gep>, ir<1>
; CHECK: Cost of 1 for VF 16: WIDEN store vp<[[VP37]]>, ir<%l>
; CHECK: Cost of 0 for VF 16: EMIT vp<%index.next> = add nuw vp<[[VP4]]>, vp<[[VP1]]>
@@ -435,13 +435,13 @@ define void @blend_fcmp_olt_f32(ptr noalias %dst, ptr noalias %src, i64 %n) {
; CHECK: Cost of 0 for VF 2: forced scalar %src.gep = getelementptr inbounds float, ptr %src, i64 %iv
; CHECK: Cost of 0 for VF 2: forced scalar %dst.gep = getelementptr inbounds float, ptr %dst, i64 %iv
; CHECK: Cost of 0 for VF 2: vp<[[VP4:%[0-9]+]]> = SCALAR-STEPS vp<[[VP3:%[0-9]+]]>, ir<1>, vp<[[VP0:%[0-9]+]]>
-; CHECK: Cost of 0 for VF 2: CLONE ir<%src.gep> = getelementptr inbounds ir<%src>, vp<[[VP4]]>
+; CHECK: Cost of 0 for VF 2: EMIT-SCALAR ir<%src.gep> = getelementptr inbounds float, ir<%src>, vp<[[VP4]]>
; CHECK: Cost of 0 for VF 2: vp<[[VP5:%[0-9]+]]> = vector-pointer inbounds float, ir<%src.gep>, ir<1>
; CHECK: Cost of 1 for VF 2: WIDEN ir<%l> = load vp<[[VP5]]>
; CHECK: Cost of 1 for VF 2: WIDEN ir<%c> = fcmp olt ir<%l>, ir<0.000000e+00>
; CHECK: Cost of 1 for VF 2: WIDEN ir<%add> = fadd ir<%l>, ir<1.000000e+00>
; CHECK: Cost of 1 for VF 2: BLEND ir<%p> = ir<%l> ir<%add>/ir<%c>
-; CHECK: Cost of 0 for VF 2: CLONE ir<%dst.gep> = getelementptr inbounds ir<%dst>, vp<[[VP4]]>
+; CHECK: Cost of 0 for VF 2: EMIT-SCALAR ir<%dst.gep> = getelementptr inbounds float, ir<%dst>, vp<[[VP4]]>
; CHECK: Cost of 0 for VF 2: vp<[[VP6:%[0-9]+]]> = vector-pointer inbounds float, ir<%dst.gep>, ir<1>
; CHECK: Cost of 1 for VF 2: WIDEN store vp<[[VP6]]>, ir<%p>
; CHECK: Cost of 0 for VF 2: EMIT vp<%index.next> = add nuw vp<[[VP3]]>, vp<[[VP1:%[0-9]+]]>
@@ -458,13 +458,13 @@ define void @blend_fcmp_olt_f32(ptr noalias %dst, ptr noalias %src, i64 %n) {
; CHECK: Cost of 0 for VF 4: forced scalar %src.gep = getelementptr inbounds float, ptr %src, i64 %iv
; CHECK: Cost of 0 for VF 4: forced scalar %dst.gep = getelementptr inbounds float, ptr %dst, i64 %iv
; CHECK: Cost of 0 for VF 4: vp<[[VP4]]> = SCALAR-STEPS vp<[[VP3]]>, ir<1>, vp<[[VP0]]>
-; CHECK: Cost of 0 for VF 4: CLONE ir<%src.gep> = getelementptr inbounds ir<%src>, vp<[[VP4]]>
+; CHECK: Cost of 0 for VF 4: EMIT-SCALAR ir<%src.gep> = getelementptr inbounds float, ir<%src>, vp<[[VP4]]>
; CHECK: Cost of 0 for VF 4: vp<[[VP5]]> = vector-pointer inbounds float, ir<%src.gep>, ir<1>
; CHECK: Cost of 1 for VF 4: WIDEN ir<%l> = load vp<[[VP5]]>
; CHECK: Cost of 1 for VF 4: WIDEN ir<%c> = fcmp olt ir<%l>, ir<0.000000e+00>
; CHECK: Cost of 1 for VF 4: WIDEN ir<%add> = fadd ir<%l>, ir<1.000000e+00>
; CHECK: Cost of 1 for VF 4: BLEND ir<%p> = ir<%l> ir<%add>/ir<%c>
-; CHECK: Cost of 0 for VF 4: CLONE ir<%dst.gep> = getelementptr inbounds ir<%dst>, vp<[[VP4]]>
+; CHECK: Cost of 0 for VF 4: EMIT-SCALAR ir<%dst.gep> = getelementptr inbounds float, ir<%dst>, vp<[[VP4]]>
; CHECK: Cost of 0 for VF 4: vp<[[VP6]]> = vector-pointer inbounds float, ir<%dst.gep>, ir<1>
; CHECK: Cost of 1 for VF 4: WIDEN store vp<[[VP6]]>, ir<%p>
; CHECK: Cost of 0 for VF 4: EMIT vp<%index.next> = add nuw vp<[[VP3]]>, vp<[[VP1]]>
@@ -511,13 +511,13 @@ define void @blend_fcmp_uno_f32(ptr noalias %dst, ptr noalias %src, i64 %n) {
; CHECK: Cost of 0 for VF 2: forced scalar %src.gep = getelementptr inbounds float, ptr %src, i64 %iv
; CHECK: Cost of 0 for VF 2: forced scalar %dst.gep = getelementptr inbounds float, ptr %dst, i64 %iv
; CHECK: Cost of 0 for VF 2: vp<[[VP4:%[0-9]+]]> = SCALAR-STEPS vp<[[VP3:%[0-9]+]]>, ir<1>, vp<[[VP0:%[0-9]+]]>
-; CHECK: Cost of 0 for VF 2: CLONE ir<%src.gep> = getelementptr inbounds ir<%src>, vp<[[VP4]]>
+; CHECK: Cost of 0 for VF 2: EMIT-SCALAR ir<%src.gep> = getelementptr inbounds float, ir<%src>, vp<[[VP4]]>
; CHECK: Cost of 0 for VF 2: vp<[[VP5:%[0-9]+]]> = vector-pointer inbounds float, ir<%src.gep>, ir<1>
; CHECK: Cost of 1 for VF 2: WIDEN ir<%l> = load vp<[[VP5]]>
; CHECK: Cost of 3 for VF 2: WIDEN ir<%c> = fcmp uno ir<%l>, ir<0.000000e+00>
; CHECK: Cost of 1 for VF 2: WIDEN ir<%add> = fadd ir<%l>, ir<1.000000e+00>
; CHECK: Cost of 2 for VF 2: BLEND ir<%p> = ir<%l> ir<%add>/ir<%c>
-; CHECK: Cost of 0 for VF 2: CLONE ir<%dst.gep> = getelementptr inbounds ir<%dst>, vp<[[VP4]]>
+; CHECK: Cost of 0 for VF 2: EMIT-SCALAR ir<%dst.gep> = getelementptr inbounds float, ir<%dst>, vp<[[VP4]]>
; CHECK: Cost of 0 for VF 2: vp<[[VP6:%[0-9]+]]> = vector-pointer inbounds float, ir<%dst.gep>, ir<1>
; CHECK: Cost of 1 for VF 2: WIDEN store vp<[[VP6]]>, ir<%p>
; CHECK: Cost of 0 for VF 2: EMIT vp<%index.next> = add nuw vp<[[VP3]]>, vp<[[VP1:%[0-9]+]]>
@@ -534,13 +534,13 @@ define void @blend_fcmp_uno_f32(ptr noalias %dst, ptr noalias %src, i64 %n) {
; CHECK: Cost of 0 for VF 4: forced scalar %src.gep = getelementptr inbounds float, ptr %src, i64 %iv
; CHECK: Cost of 0 for VF 4: forced scalar %dst.gep = getelementptr inbounds float, ptr %dst, i64 %iv
; CHECK: Cost of 0 for VF 4: vp<[[VP4]]> = SCALAR-STEPS vp<[[VP3]]>, ir<1>, vp<[[VP0]]>
-; CHECK: Cost of 0 for VF 4: CLONE ir<%src.gep> = getelementptr inbounds ir<%src>, vp<[[VP4]]>
+; CHECK: Cost of 0 for VF 4: EMIT-SCALAR ir<%src.gep> = getelementptr inbounds float, ir<%src>, vp<[[VP4]]>
; CHECK: Cost of 0 for VF 4: vp<[[VP5]]> = vector-pointer inbounds float, ir<%src.gep>, ir<1>
; CHECK: Cost of 1 for VF 4: WIDEN ir<%l> = load vp<[[VP5]]>
; CHECK: Cost of 3 for VF 4: WIDEN ir<%c> = fcmp uno ir<%l>, ir<0.000000e+00>
; CHECK: Cost of 1 for VF 4: WIDEN ir<%add> = fadd ir<%l>, ir<1.000000e+00>
; CHECK: Cost of 2 for VF 4: BLEND ir<%p> = ir<%l> ir<%add>/ir<%c>
-; CHECK: Cost of 0 for VF 4: CLONE ir<%dst.gep> = getelementptr inbounds ir<%dst>, vp<[[VP4]]>
+; CHECK: Cost of 0 for VF 4: EMIT-SCALAR ir<%dst.gep> = getelementptr inbounds float, ir<%dst>, vp<[[VP4]]>
; CHECK: Cost of 0 for VF 4: vp<[[VP6]]> = vector-pointer inbounds float, ir<%dst.gep>, ir<1>
; CHECK: Cost of 1 for VF 4: WIDEN store vp<[[VP6]]>, ir<%p>
; CHECK: Cost of 0 for VF 4: EMIT vp<%index.next> = add nuw vp<[[VP3]]>, vp<[[VP1]]>
diff --git a/llvm/test/Transforms/LoopVectorize/AArch64/synthesize-mask-for-call.ll b/llvm/test/Transforms/LoopVectorize/AArch64/synthesize-mask-for-call.ll
index 85be765387e68..f5fa19e5375f5 100644
--- a/llvm/test/Transforms/LoopVectorize/AArch64/synthesize-mask-for-call.ll
+++ b/llvm/test/Transforms/LoopVectorize/AArch64/synthesize-mask-for-call.ll
@@ -26,11 +26,11 @@ target triple = "aarch64-unknown-linux-gnu"
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: vp<[[STEPS:%.+]]> = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>, vp<[[VF]]>
-; CHECK-NEXT: CLONE ir<%gep> = getelementptr ir<%b>, vp<[[STEPS]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr i64, ir<%b>, vp<[[STEPS]]>
; CHECK-NEXT: vp<[[VEC_PTR:%.+]]> = vector-pointer i64, ir<%gep>
; CHECK-NEXT: WIDEN ir<%load> = load vp<[[VEC_PTR]]>
; CHECK-NEXT: REPLICATE ir<%call> = call @foo(ir<%load>)
-; CHECK-NEXT: CLONE ir<%arrayidx> = getelementptr inbounds ir<%a>, vp<[[STEPS]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%arrayidx> = getelementptr inbounds i64, ir<%a>, vp<[[STEPS]]>
; CHECK-NEXT: vp<[[VEC_PTR2:%.+]]> = vector-pointer inbounds i64, ir<%arrayidx>
; CHECK-NEXT: WIDEN store vp<[[VEC_PTR2]]>, ir<%call>
; CHECK-NEXT: EMIT vp<[[CAN_IV_NEXT:%.+]]> = add nuw vp<[[CAN_IV]]>, vp<[[VFxUF]]>
@@ -74,11 +74,11 @@ target triple = "aarch64-unknown-linux-gnu"
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: vp<[[STEPS]]> = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>, vp<[[VF]]>
-; CHECK-NEXT: CLONE ir<%gep> = getelementptr ir<%b>, vp<[[STEPS]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr i64, ir<%b>, vp<[[STEPS]]>
; CHECK-NEXT: vp<[[VEC_PTR:%.+]]> = vector-pointer i64, ir<%gep>
; CHECK-NEXT: WIDEN ir<%load> = load vp<[[VEC_PTR]]>
; CHECK-NEXT: WIDEN-CALL ir<%call> = call @foo(ir<%load>) (using library function: foo_vector_fixed4_nomask)
-; CHECK-NEXT: CLONE ir<%arrayidx> = getelementptr inbounds ir<%a>, vp<[[STEPS]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%arrayidx> = getelementptr inbounds i64, ir<%a>, vp<[[STEPS]]>
; CHECK-NEXT: vp<[[VEC_PTR2:%.+]]> = vector-pointer inbounds i64, ir<%arrayidx>
; CHECK-NEXT: WIDEN store vp<[[VEC_PTR2]]>, ir<%call>
; CHECK-NEXT: EMIT vp<[[CAN_IV_NEXT:%.+]]> = add nuw vp<[[CAN_IV]]>, vp<[[VFxUF]]>
@@ -127,11 +127,11 @@ target triple = "aarch64-unknown-linux-gnu"
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: vp<[[STEPS:%.+]]> = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>, vp<[[VF]]>
-; CHECK-NEXT: CLONE ir<%gep> = getelementptr ir<%b>, vp<[[STEPS]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr i64, ir<%b>, vp<[[STEPS]]>
; CHECK-NEXT: vp<[[VEC_PTR:%.+]]> = vector-pointer i64, ir<%gep>
; CHECK-NEXT: WIDEN ir<%load> = load vp<[[VEC_PTR]]>
; CHECK-NEXT: WIDEN-CALL ir<%call> = call @foo(ir<%load>) (using library function: foo_vector_fixed2_nomask)
-; CHECK-NEXT: CLONE ir<%arrayidx> = getelementptr inbounds ir<%a>, vp<[[STEPS]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%arrayidx> = getelementptr inbounds i64, ir<%a>, vp<[[STEPS]]>
; CHECK-NEXT: vp<[[VEC_PTR:%.+]]> = vector-pointer inbounds i64, ir<%arrayidx>
; CHECK-NEXT: WIDEN store vp<[[VEC_PTR]]>, ir<%call>
; CHECK-NEXT: EMIT vp<[[CAN_IV_NEXST:%.+]]> = add nuw vp<[[CAN_IV]]>, vp<[[VFxUF]]>
@@ -175,11 +175,11 @@ target triple = "aarch64-unknown-linux-gnu"
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: vp<[[STEPS:%.+]]> = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>, vp<[[VF]]>
-; CHECK-NEXT: CLONE ir<%gep> = getelementptr ir<%b>, vp<[[STEPS]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr i64, ir<%b>, vp<[[STEPS]]>
; CHECK-NEXT: vp<[[VEC_PTR:%.+]]> = vector-pointer i64, ir<%gep>
; CHECK-NEXT: WIDEN ir<%load> = load vp<[[VEC_PTR]]>
; CHECK-NEXT: WIDEN-CALL ir<%call> = call @foo(ir<%load>, ir<true>) (using library function: foo_vector_fixed4_mask)
-; CHECK-NEXT: CLONE ir<%arrayidx> = getelementptr inbounds ir<%a>, vp<[[STEPS]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%arrayidx> = getelementptr inbounds i64, ir<%a>, vp<[[STEPS]]>
; CHECK-NEXT: vp<[[VEC_PTR2:%.+]]> = vector-pointer inbounds i64, ir<%arrayidx>
; CHECK-NEXT: WIDEN store vp<[[VEC_PTR2]]>, ir<%call>
; CHECK-NEXT: EMIT vp<[[CAN_IV_NEXT:%.+]]> = add nuw vp<[[CAN_IV]]>, vp<[[VFxUF]]>
@@ -227,11 +227,11 @@ target triple = "aarch64-unknown-linux-gnu"
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: vp<[[STEPS:%.+]]> = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>, vp<[[VF]]>
-; CHECK-NEXT: CLONE ir<%gep> = getelementptr ir<%b>, vp<[[STEPS]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr i64, ir<%b>, vp<[[STEPS]]>
; CHECK-NEXT: vp<[[VEC_PTR:%.+]]> = vector-pointer i64, ir<%gep>
; CHECK-NEXT: WIDEN ir<%load> = load vp<[[VEC_PTR]]>
; CHECK-NEXT: WIDEN-CALL ir<%call> = call @foo(ir<%load>) (using library function: foo_vector_fixed2_nomask)
-; CHECK-NEXT: CLONE ir<%arrayidx> = getelementptr inbounds ir<%a>, vp<[[STEPS]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%arrayidx> = getelementptr inbounds i64, ir<%a>, vp<[[STEPS]]>
; CHECK-NEXT: vp<[[VEC_PTR2:%.+]]> = vector-pointer inbounds i64, ir<%arrayidx>
; CHECK-NEXT: WIDEN store vp<[[VEC_PTR2]]>, ir<%call>
; CHECK-NEXT: EMIT vp<[[CAN_IV_NEXT:%.+]]> = add nuw vp<[[CAN_IV]]>, vp<[[VFxUF]]>
@@ -275,11 +275,11 @@ target triple = "aarch64-unknown-linux-gnu"
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: vp<[[STEPS:%.+]]> = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>, vp<[[VF]]>
-; CHECK-NEXT: CLONE ir<%gep> = getelementptr ir<%b>, vp<[[STEPS]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr i64, ir<%b>, vp<[[STEPS]]>
; CHECK-NEXT: vp<[[VEC_PTR:%.+]]> = vector-pointer i64, ir<%gep>
; CHECK-NEXT: WIDEN ir<%load> = load vp<[[VEC_PTR]]>
; CHECK-NEXT: WIDEN-CALL ir<%call> = call @foo(ir<%load>) (using library function: foo_vector_fixed4_nomask)
-; CHECK-NEXT: CLONE ir<%arrayidx> = getelementptr inbounds ir<%a>, vp<[[STEPS]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%arrayidx> = getelementptr inbounds i64, ir<%a>, vp<[[STEPS]]>
; CHECK-NEXT: vp<[[VEC_PTR2:%.+]]> = vector-pointer inbounds i64, ir<%arrayidx>
; CHECK-NEXT: WIDEN store vp<[[VEC_PTR2]]>, ir<%call>
; CHECK-NEXT: EMIT vp<[[CAN_IV_NEXT:%.+]]> = add nuw vp<[[CAN_IV]]>, vp<[[VFxUF]]>
diff --git a/llvm/test/Transforms/LoopVectorize/ARM/mve-icmpcost.ll b/llvm/test/Transforms/LoopVectorize/ARM/mve-icmpcost.ll
index ebf62272564ef..cce6d7904cb5d 100644
--- a/llvm/test/Transforms/LoopVectorize/ARM/mve-icmpcost.ll
+++ b/llvm/test/Transforms/LoopVectorize/ARM/mve-icmpcost.ll
@@ -21,13 +21,13 @@ define void @expensive_icmp(ptr noalias nocapture %d, ptr nocapture readonly %s,
; CHECK: LV: Found an estimated cost of 1 for VF 1 For instruction: %exitcond.not = icmp eq i32 %inc, %n
; CHECK: LV: Found an estimated cost of 0 for VF 1 For instruction: br i1 %exitcond.not, label %for.cond.cleanup.loopexit, label %for.body
; CHECK: Cost of 0 for VF 2: vp<[[VP4:%[0-9]+]]> = SCALAR-STEPS vp<[[VP3:%[0-9]+]]>, ir<1>, vp<[[VP0:%[0-9]+]]>
-; CHECK: Cost of 0 for VF 2: CLONE ir<%arrayidx> = getelementptr inbounds ir<%s>, vp<[[VP4]]>
+; CHECK: Cost of 0 for VF 2: EMIT-SCALAR ir<%arrayidx> = getelementptr inbounds i16, ir<%s>, vp<[[VP4]]>
; CHECK: Cost of 0 for VF 2: vp<[[VP5:%[0-9]+]]> = vector-pointer inbounds i16, ir<%arrayidx>, ir<1>
; CHECK: Cost of 18 for VF 2: WIDEN ir<%1> = load vp<[[VP5]]>
; CHECK: Cost of 4 for VF 2: WIDEN-CAST ir<%conv> = sext ir<%1> to i32
; CHECK: Cost of 20 for VF 2: WIDEN ir<%cmp2> = icmp sgt ir<%conv>, ir<%conv1>
; CHECK: Cost of 26 for VF 2: WIDEN ir<%conv6> = add ir<%1>, ir<%0>
-; CHECK: Cost of 0 for VF 2: CLONE ir<%arrayidx7> = getelementptr ir<%d>, vp<[[VP4]]>
+; CHECK: Cost of 0 for VF 2: EMIT-SCALAR ir<%arrayidx7> = getelementptr i16, ir<%d>, vp<[[VP4]]>
; CHECK: Cost of 0 for VF 2: vp<[[VP6:%[0-9]+]]> = vector-pointer i16, ir<%arrayidx7>, ir<1>
; CHECK: Cost of 16 for VF 2: WIDEN store vp<[[VP6]]>, ir<%conv6>, ir<%cmp2>
; CHECK: Cost of 0 for VF 2: EMIT vp<%index.next> = add nuw vp<[[VP3]]>, vp<[[VP1:%[0-9]+]]>
@@ -46,13 +46,13 @@ define void @expensive_icmp(ptr noalias nocapture %d, ptr nocapture readonly %s,
; CHECK: Cost of 0 for VF 2: EMIT branch-on-cond vp<%cmp.n>
; CHECK: Cost for VF 2: 86 (Estimated cost per lane: 43)
; CHECK: Cost of 0 for VF 4: vp<[[VP4]]> = SCALAR-STEPS vp<[[VP3]]>, ir<1>, vp<[[VP0]]>
-; CHECK: Cost of 0 for VF 4: CLONE ir<%arrayidx> = getelementptr inbounds ir<%s>, vp<[[VP4]]>
+; CHECK: Cost of 0 for VF 4: EMIT-SCALAR ir<%arrayidx> = getelementptr inbounds i16, ir<%s>, vp<[[VP4]]>
; CHECK: Cost of 0 for VF 4: vp<[[VP5]]> = vector-pointer inbounds i16, ir<%arrayidx>, ir<1>
; CHECK: Cost of 2 for VF 4: WIDEN ir<%1> = load vp<[[VP5]]>
; CHECK: Cost of 0 for VF 4: WIDEN-CAST ir<%conv> = sext ir<%1> to i32
; CHECK: Cost of 2 for VF 4: WIDEN ir<%cmp2> = icmp sgt ir<%conv>, ir<%conv1>
; CHECK: Cost of 2 for VF 4: WIDEN ir<%conv6> = add ir<%1>, ir<%0>
-; CHECK: Cost of 0 for VF 4: CLONE ir<%arrayidx7> = getelementptr ir<%d>, vp<[[VP4]]>
+; CHECK: Cost of 0 for VF 4: EMIT-SCALAR ir<%arrayidx7> = getelementptr i16, ir<%d>, vp<[[VP4]]>
; CHECK: Cost of 0 for VF 4: vp<[[VP6]]> = vector-pointer i16, ir<%arrayidx7>, ir<1>
; CHECK: Cost of 2 for VF 4: WIDEN store vp<[[VP6]]>, ir<%conv6>, ir<%cmp2>
; CHECK: Cost of 0 for VF 4: EMIT vp<%index.next> = add nuw vp<[[VP3]]>, vp<[[VP1]]>
@@ -71,13 +71,13 @@ define void @expensive_icmp(ptr noalias nocapture %d, ptr nocapture readonly %s,
; CHECK: Cost of 0 for VF 4: EMIT branch-on-cond vp<%cmp.n>
; CHECK: Cost for VF 4: 10 (Estimated cost per lane: 2.5)
; CHECK: Cost of 0 for VF 8: vp<[[VP4]]> = SCALAR-STEPS vp<[[VP3]]>, ir<1>, vp<[[VP0]]>
-; CHECK: Cost of 0 for VF 8: CLONE ir<%arrayidx> = getelementptr inbounds ir<%s>, vp<[[VP4]]>
+; CHECK: Cost of 0 for VF 8: EMIT-SCALAR ir<%arrayidx> = getelementptr inbounds i16, ir<%s>, vp<[[VP4]]>
; CHECK: Cost of 0 for VF 8: vp<[[VP5]]> = vector-pointer inbounds i16, ir<%arrayidx>, ir<1>
; CHECK: Cost of 2 for VF 8: WIDEN ir<%1> = load vp<[[VP5]]>
; CHECK: Cost of 2 for VF 8: WIDEN-CAST ir<%conv> = sext ir<%1> to i32
; CHECK: Cost of 36 for VF 8: WIDEN ir<%cmp2> = icmp sgt ir<%conv>, ir<%conv1>
; CHECK: Cost of 2 for VF 8: WIDEN ir<%conv6> = add ir<%1>, ir<%0>
-; CHECK: Cost of 0 for VF 8: CLONE ir<%arrayidx7> = getelementptr ir<%d>, vp<[[VP4]]>
+; CHECK: Cost of 0 for VF 8: EMIT-SCALAR ir<%arrayidx7> = getelementptr i16, ir<%d>, vp<[[VP4]]>
; CHECK: Cost of 0 for VF 8: vp<[[VP6]]> = vector-pointer i16, ir<%arrayidx7>, ir<1>
; CHECK: Cost of 2 for VF 8: WIDEN store vp<[[VP6]]>, ir<%conv6>, ir<%cmp2>
; CHECK: Cost of 0 for VF 8: EMIT vp<%index.next> = add nuw vp<[[VP3]]>, vp<[[VP1]]>
diff --git a/llvm/test/Transforms/LoopVectorize/VPlan/AArch64/call-decisions.ll b/llvm/test/Transforms/LoopVectorize/VPlan/AArch64/call-decisions.ll
index f141aa0a6420c..2fab456203aa9 100644
--- a/llvm/test/Transforms/LoopVectorize/VPlan/AArch64/call-decisions.ll
+++ b/llvm/test/Transforms/LoopVectorize/VPlan/AArch64/call-decisions.ll
@@ -24,11 +24,11 @@ define void @pick_wide_call(ptr noalias %in.ptr, ptr noalias %out.ptr) {
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION nuw nsw ir<0>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%in.gep> = getelementptr inbounds ir<%in.ptr>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%in.gep> = getelementptr inbounds double, ir<%in.ptr>, ir<%iv>
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = vector-pointer inbounds double, ir<%in.gep>, ir<1>
; CHECK-NEXT: WIDEN ir<%in> = load vp<[[VP4]]>
; CHECK-NEXT: WIDEN-CALL ir<%call> = call @acos(ir<%in>) (using library function: _ZGVnN2v_acos)
-; CHECK-NEXT: CLONE ir<%out.gep> = getelementptr inbounds ir<%out.ptr>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%out.gep> = getelementptr inbounds double, ir<%out.ptr>, ir<%iv>
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = vector-pointer inbounds double, ir<%out.gep>, ir<1>
; CHECK-NEXT: WIDEN store vp<[[VP5]]>, ir<%call>
; CHECK-NEXT: EMIT ir<%iv.next> = add nuw nsw ir<%iv>, ir<1>
@@ -78,11 +78,11 @@ define void @pick_intrinsic_call(ptr noalias %in.ptr, ptr noalias %out.ptr) {
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION nuw nsw ir<0>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%in.gep> = getelementptr inbounds ir<%in.ptr>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%in.gep> = getelementptr inbounds i64, ir<%in.ptr>, ir<%iv>
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = vector-pointer inbounds i64, ir<%in.gep>, ir<1>
; CHECK-NEXT: WIDEN ir<%in> = load vp<[[VP4]]>
; CHECK-NEXT: WIDEN-INTRINSIC ir<%call> = call llvm.umin(ir<100>, ir<%in>)
-; CHECK-NEXT: CLONE ir<%out.gep> = getelementptr inbounds ir<%out.ptr>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%out.gep> = getelementptr inbounds i64, ir<%out.ptr>, ir<%iv>
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = vector-pointer inbounds i64, ir<%out.gep>, ir<1>
; CHECK-NEXT: WIDEN store vp<[[VP5]]>, ir<%call>
; CHECK-NEXT: EMIT ir<%iv.next> = add nuw nsw ir<%iv>, ir<1>
diff --git a/llvm/test/Transforms/LoopVectorize/VPlan/AArch64/partial-reduce-usabs.ll b/llvm/test/Transforms/LoopVectorize/VPlan/AArch64/partial-reduce-usabs.ll
index 4e96d743722da..db41f263cefbf 100644
--- a/llvm/test/Transforms/LoopVectorize/VPlan/AArch64/partial-reduce-usabs.ll
+++ b/llvm/test/Transforms/LoopVectorize/VPlan/AArch64/partial-reduce-usabs.ll
@@ -25,10 +25,10 @@ define i32 @unsigned_absolute_difference(ptr noalias %x, ptr noalias %y) {
; CHECK-NEXT: vector.body:
; CHECK-NEXT: WIDEN-REDUCTION-PHI ir<%sum.0> = phi (add) vp<[[VP3]]>, vp<[[VP13:%[0-9]+]]> (VF scaled by 1/4)
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = SCALAR-STEPS vp<[[VP4]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%x.ptr> = getelementptr inbounds nuw ir<%x>, vp<[[VP5]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%x.ptr> = getelementptr inbounds nuw i8, ir<%x>, vp<[[VP5]]>
; CHECK-NEXT: vp<[[VP6:%[0-9]+]]> = vector-pointer inbounds nuw i8, ir<%x.ptr>, ir<1>
; CHECK-NEXT: WIDEN ir<%x.val> = load vp<[[VP6]]>
-; CHECK-NEXT: CLONE ir<%y.ptr> = getelementptr inbounds nuw ir<%y>, vp<[[VP5]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%y.ptr> = getelementptr inbounds nuw i8, ir<%y>, vp<[[VP5]]>
; CHECK-NEXT: vp<[[VP7:%[0-9]+]]> = vector-pointer inbounds nuw i8, ir<%y.ptr>, ir<1>
; CHECK-NEXT: WIDEN ir<%y.val> = load vp<[[VP7]]>
; CHECK-NEXT: WIDEN vp<[[VP8:%[0-9]+]]> = freeze ir<%x.val>
@@ -99,10 +99,10 @@ define i32 @signed_absolute_difference(ptr noalias %x, ptr noalias %y) {
; CHECK-NEXT: vector.body:
; CHECK-NEXT: WIDEN-REDUCTION-PHI ir<%sum.0> = phi (add) vp<[[VP3]]>, vp<[[VP13:%[0-9]+]]> (VF scaled by 1/4)
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = SCALAR-STEPS vp<[[VP4]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%x.ptr> = getelementptr inbounds nuw ir<%x>, vp<[[VP5]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%x.ptr> = getelementptr inbounds nuw i8, ir<%x>, vp<[[VP5]]>
; CHECK-NEXT: vp<[[VP6:%[0-9]+]]> = vector-pointer inbounds nuw i8, ir<%x.ptr>, ir<1>
; CHECK-NEXT: WIDEN ir<%x.val> = load vp<[[VP6]]>
-; CHECK-NEXT: CLONE ir<%y.ptr> = getelementptr inbounds nuw ir<%y>, vp<[[VP5]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%y.ptr> = getelementptr inbounds nuw i8, ir<%y>, vp<[[VP5]]>
; CHECK-NEXT: vp<[[VP7:%[0-9]+]]> = vector-pointer inbounds nuw i8, ir<%y.ptr>, ir<1>
; CHECK-NEXT: WIDEN ir<%y.val> = load vp<[[VP7]]>
; CHECK-NEXT: WIDEN vp<[[VP8:%[0-9]+]]> = freeze ir<%x.val>
diff --git a/llvm/test/Transforms/LoopVectorize/VPlan/AArch64/single-scalar-cast.ll b/llvm/test/Transforms/LoopVectorize/VPlan/AArch64/single-scalar-cast.ll
index 39a400c94f705..6bf46c550cc8f 100644
--- a/llvm/test/Transforms/LoopVectorize/VPlan/AArch64/single-scalar-cast.ll
+++ b/llvm/test/Transforms/LoopVectorize/VPlan/AArch64/single-scalar-cast.ll
@@ -24,7 +24,7 @@ define i16 @narrow_iv_cast_to_single_scalar(ptr %p, ptr %q) {
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = SCALAR-STEPS vp<[[VP3]]>, ir<1>, vp<[[VP0]]>
; CHECK-NEXT: CLONE ir<%shr> = lshr vp<[[VP4]]>, ir<1>
; CHECK-NEXT: EMIT-SCALAR ir<%shr.ext> = zext ir<%shr> to i64
-; CHECK-NEXT: CLONE ir<%gep.p> = getelementptr ir<%p>, ir<%shr.ext>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.p> = getelementptr i8, ir<%p>, ir<%shr.ext>
; CHECK-NEXT: CLONE ir<%l> = load ir<%gep.p>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<[[VP3]]>, vp<[[VP1]]>
; CHECK-NEXT: EMIT branch-on-count vp<%index.next>, vp<[[VP2]]>
@@ -77,7 +77,7 @@ define void @sink_replicate_region_with_cast(ptr %dst, i64 %n) {
; CHECK-NEXT: vector.body:
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = SCALAR-STEPS vp<[[VP4]]>, ir<1>, vp<[[VP0]]>
; CHECK-NEXT: EMIT-SCALAR ir<%conv> = zext vp<[[VP5]]> to i64
-; CHECK-NEXT: CLONE ir<%gep> = getelementptr ir<%dst>, ir<%conv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr double, ir<%dst>, ir<%conv>
; CHECK-NEXT: vp<[[VP6:%[0-9]+]]> = vector-pointer double, ir<%gep>, ir<1>
; CHECK-NEXT: WIDEN ir<%l> = load vp<[[VP6]]>
; CHECK-NEXT: WIDEN ir<%c> = fcmp olt ir<%l>, ir<0.000000e+00>
diff --git a/llvm/test/Transforms/LoopVectorize/VPlan/AArch64/sve-tail-folding-forced.ll b/llvm/test/Transforms/LoopVectorize/VPlan/AArch64/sve-tail-folding-forced.ll
index ddf757691047d..11881df108a22 100644
--- a/llvm/test/Transforms/LoopVectorize/VPlan/AArch64/sve-tail-folding-forced.ll
+++ b/llvm/test/Transforms/LoopVectorize/VPlan/AArch64/sve-tail-folding-forced.ll
@@ -28,7 +28,7 @@ target triple = "aarch64-unknown-linux-gnu"
; VPLANS-NEXT: vector.body:
; VPLANS-NEXT: ACTIVE-LANE-MASK-PHI vp<[[LANEMASK_PHI:%[0-9]+]]> = phi vp<[[LANEMASK_ENTRY_EXTRACT]]>, vp<[[LANEMASK_LOOP:%.+]]>
; VPLANS-NEXT: vp<[[STEP:%[0-9]+]]> = SCALAR-STEPS vp<[[INDV]]>, ir<1>, vp<[[VF]]>
-; VPLANS-NEXT: CLONE ir<%gep> = getelementptr ir<%ptr>, vp<[[STEP]]>
+; VPLANS-NEXT: EMIT-SCALAR ir<%gep> = getelementptr i32, ir<%ptr>, vp<[[STEP]]>
; VPLANS-NEXT: vp<[[VEC_PTR:%[0-9]+]]> = vector-pointer i32, ir<%gep>
; VPLANS-NEXT: WIDEN store vp<[[VEC_PTR]]>, ir<%val>, vp<[[LANEMASK_PHI]]>
; VPLANS-NEXT: EMIT vp<[[INDV_UPDATE:%.+]]> = add vp<[[INDV]]>, vp<[[VFxUF]]>
diff --git a/llvm/test/Transforms/LoopVectorize/VPlan/AArch64/sve2-histcnt-vplan.ll b/llvm/test/Transforms/LoopVectorize/VPlan/AArch64/sve2-histcnt-vplan.ll
index bceb53bb131c8..49f5851c11600 100644
--- a/llvm/test/Transforms/LoopVectorize/VPlan/AArch64/sve2-histcnt-vplan.ll
+++ b/llvm/test/Transforms/LoopVectorize/VPlan/AArch64/sve2-histcnt-vplan.ll
@@ -27,10 +27,10 @@ target triple = "aarch64-unknown-linux-gnu"
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: [[STEPS:vp.*]] = SCALAR-STEPS [[IV]], ir<1>, [[VF]]
-; CHECK-NEXT: CLONE [[GEP_IDX:.*]] = getelementptr inbounds ir<%indices>, [[STEPS]]
+; CHECK-NEXT: EMIT-SCALAR [[GEP_IDX:.*]] = getelementptr inbounds i32, ir<%indices>, [[STEPS]]
; CHECK-NEXT: CLONE [[IDX:.*]] = load [[GEP_IDX]]
; CHECK-NEXT: EMIT-SCALAR [[EXT_IDX:.*]] = zext [[IDX]]
-; CHECK-NEXT: CLONE [[GEP_BUCKET:.*]] = getelementptr inbounds ir<%buckets>, [[EXT_IDX]]
+; CHECK-NEXT: EMIT-SCALAR [[GEP_BUCKET:.*]] = getelementptr inbounds i32, ir<%buckets>, [[EXT_IDX]]
; CHECK-NEXT: CLONE [[HISTVAL:.*]] = load [[GEP_BUCKET]]
; CHECK-NEXT: CLONE [[UPDATE:.*]] = add nsw [[HISTVAL]], ir<1>
; CHECK-NEXT: CLONE store [[UPDATE]], [[GEP_BUCKET]]
@@ -76,7 +76,7 @@ target triple = "aarch64-unknown-linux-gnu"
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: [[STEPS:vp.*]] = SCALAR-STEPS [[IV]], ir<1>, [[VF]]
-; CHECK-NEXT: CLONE [[GEP_IDX:.*]] = getelementptr inbounds ir<%indices>, [[STEPS]]
+; CHECK-NEXT: EMIT-SCALAR [[GEP_IDX:.*]] = getelementptr inbounds i32, ir<%indices>, [[STEPS]]
; CHECK-NEXT: [[VECP_IDX:vp.*]] = vector-pointer inbounds i32, [[GEP_IDX]]
; CHECK-NEXT: WIDEN [[IDX:.*]] = load [[VECP_IDX]]
; CHECK-NEXT: WIDEN-CAST [[EXT_IDX:.*]] = zext [[IDX]] to i64
diff --git a/llvm/test/Transforms/LoopVectorize/VPlan/AArch64/vplan-memory-op-decisions.ll b/llvm/test/Transforms/LoopVectorize/VPlan/AArch64/vplan-memory-op-decisions.ll
index af2978f1bfab4..d788ea298bf6a 100644
--- a/llvm/test/Transforms/LoopVectorize/VPlan/AArch64/vplan-memory-op-decisions.ll
+++ b/llvm/test/Transforms/LoopVectorize/VPlan/AArch64/vplan-memory-op-decisions.ll
@@ -23,7 +23,7 @@ define void @replicating_load_used_as_store_addr(ptr noalias %A) {
; CHECK-NEXT: vector.body:
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION ir<0>, ir<1>, vp<[[VP0]]>
; CHECK-NEXT: EMIT ir<%iv.next> = add ir<%iv>, ir<1>
-; CHECK-NEXT: EMIT ir<%gep.A> = getelementptr ir<%A>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.A> = getelementptr ptr, ir<%A>, ir<%iv>
; CHECK-NEXT: REPLICATE ir<%l.p> = load ir<%gep.A>
; CHECK-NEXT: EMIT-SCALAR ir<%iv.trunc> = trunc ir<%iv.next> to i32
; CHECK-NEXT: EMIT store ir<%iv.trunc>, ir<%l.p>
@@ -74,14 +74,14 @@ define void @load_feeding_only_mask_not_scalarized(ptr noalias %A, ptr noalias %
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION ir<0>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: EMIT ir<%gep.C> = getelementptr ir<%C>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.C> = getelementptr i32, ir<%C>, ir<%iv>
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = vector-pointer i32, ir<%gep.C>, ir<1>
; CHECK-NEXT: WIDEN ir<%c> = load vp<[[VP4]]>
; CHECK-NEXT: EMIT ir<%cmp> = icmp sgt ir<%c>, ir<0>
; CHECK-NEXT: Successor(s): then
; CHECK-EMPTY:
; CHECK-NEXT: then:
-; CHECK-NEXT: EMIT ir<%gep.B> = getelementptr ir<%B>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.B> = getelementptr ptr, ir<%B>, ir<%iv>
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = vector-pointer ptr, ir<%gep.B>, ir<1>
; CHECK-NEXT: WIDEN ir<%l.p> = load vp<[[VP5]]>, ir<%cmp>
; CHECK-NEXT: EMIT store ir<42>, ir<%l.p>, ir<%cmp>
@@ -146,7 +146,7 @@ define void @single_scalar_load_used_as_store_addr(ptr noalias %p) {
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION ir<0>, ir<1>, vp<[[VP0]]>
; CHECK-NEXT: EMIT ir<%iv.next> = add ir<%iv>, ir<1>
; CHECK-NEXT: CLONE ir<%l.p> = load ir<%p>
-; CHECK-NEXT: EMIT ir<%gep> = getelementptr ir<%l.p>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr i32, ir<%l.p>, ir<%iv>
; CHECK-NEXT: EMIT-SCALAR ir<%iv.trunc> = trunc ir<%iv.next> to i32
; CHECK-NEXT: EMIT store ir<%iv.trunc>, ir<%gep>
; CHECK-NEXT: EMIT ir<%ec> = icmp eq ir<%iv>, ir<100>
@@ -197,11 +197,11 @@ define void @consecutive_load_store(ptr noalias %a, ptr noalias %b) {
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION nuw nsw ir<0>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: EMIT ir<%gep.a> = getelementptr inbounds ir<%a>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.a> = getelementptr inbounds i32, ir<%a>, ir<%iv>
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = vector-pointer inbounds i32, ir<%gep.a>, ir<1>
; CHECK-NEXT: WIDEN ir<%lv> = load vp<[[VP4]]>
; CHECK-NEXT: EMIT ir<%add> = add ir<%lv>, ir<1>
-; CHECK-NEXT: EMIT ir<%gep.b> = getelementptr inbounds ir<%b>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.b> = getelementptr inbounds i32, ir<%b>, ir<%iv>
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = vector-pointer inbounds i32, ir<%gep.b>, ir<1>
; CHECK-NEXT: WIDEN store vp<[[VP5]]>, ir<%add>
; CHECK-NEXT: EMIT ir<%iv.next> = add nuw nsw ir<%iv>, ir<1>
@@ -252,12 +252,12 @@ define void @reverse_load_store(ptr noalias %a, ptr noalias %b) {
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION nsw ir<1023>, ir<-1>, vp<[[VP0]]>
-; CHECK-NEXT: EMIT ir<%gep.a> = getelementptr inbounds ir<%a>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.a> = getelementptr inbounds i32, ir<%a>, ir<%iv>
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = vector-end-pointer inbounds i32, ir<%gep.a>, vp<[[VP0]]>
; CHECK-NEXT: WIDEN ir<%lv> = load vp<[[VP4]]>
; CHECK-NEXT: EMIT vp<[[VP5:%[0-9]+]]> = reverse ir<%lv>
; CHECK-NEXT: EMIT ir<%add> = add vp<[[VP5]]>, ir<1>
-; CHECK-NEXT: EMIT ir<%gep.b> = getelementptr inbounds ir<%b>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.b> = getelementptr inbounds i32, ir<%b>, ir<%iv>
; CHECK-NEXT: vp<[[VP6:%[0-9]+]]> = vector-end-pointer inbounds i32, ir<%gep.b>, vp<[[VP0]]>
; CHECK-NEXT: EMIT vp<[[VP7:%[0-9]+]]> = reverse ir<%add>
; CHECK-NEXT: WIDEN store vp<[[VP6]]>, vp<[[VP7]]>
@@ -315,9 +315,9 @@ define void @consecutive_load_with_first_order_recurrence_address(ptr noalias %a
; CHECK-NEXT: EMIT ir<%inc> = add ir<%narrow>, ir<1>
; CHECK-NEXT: EMIT-SCALAR ir<%ext> = zext ir<%inc> to i64
; CHECK-NEXT: EMIT vp<[[VP4:%[0-9]+]]> = first-order splice ir<%prev>, ir<%ext>
-; CHECK-NEXT: EMIT ir<%gep.a> = getelementptr inbounds ir<%a>, vp<[[VP4]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.a> = getelementptr inbounds i32, ir<%a>, vp<[[VP4]]>
; CHECK-NEXT: EMIT-SCALAR ir<%lv> = load ir<%gep.a>
-; CHECK-NEXT: EMIT ir<%gep.b> = getelementptr inbounds ir<%b>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.b> = getelementptr inbounds i32, ir<%b>, ir<%iv>
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = vector-pointer inbounds i32, ir<%gep.b>, ir<1>
; CHECK-NEXT: WIDEN store vp<[[VP5]]>, ir<%lv>
; CHECK-NEXT: EMIT ir<%ec> = icmp eq ir<%iv.next>, ir<%n>
@@ -370,18 +370,18 @@ define void @cond_load_store(ptr noalias %a, ptr noalias %b, ptr noalias %cond,
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION nuw nsw ir<0>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: EMIT ir<%gep.cond> = getelementptr inbounds ir<%cond>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.cond> = getelementptr inbounds i32, ir<%cond>, ir<%iv>
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = vector-pointer inbounds i32, ir<%gep.cond>, ir<1>
; CHECK-NEXT: WIDEN ir<%c> = load vp<[[VP4]]>
; CHECK-NEXT: EMIT ir<%cmp> = icmp sgt ir<%c>, ir<0>
; CHECK-NEXT: Successor(s): then
; CHECK-EMPTY:
; CHECK-NEXT: then:
-; CHECK-NEXT: EMIT ir<%gep.a> = getelementptr inbounds ir<%a>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.a> = getelementptr inbounds i32, ir<%a>, ir<%iv>
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = vector-pointer inbounds i32, ir<%gep.a>, ir<1>
; CHECK-NEXT: WIDEN ir<%lv> = load vp<[[VP5]]>, ir<%cmp>
; CHECK-NEXT: EMIT ir<%add> = add ir<%lv>, ir<1>, ir<%cmp>
-; CHECK-NEXT: EMIT ir<%gep.b> = getelementptr inbounds ir<%b>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.b> = getelementptr inbounds i32, ir<%b>, ir<%iv>
; CHECK-NEXT: vp<[[VP6:%[0-9]+]]> = vector-pointer inbounds i32, ir<%gep.b>, ir<1>
; CHECK-NEXT: WIDEN store vp<[[VP6]]>, ir<%add>, ir<%cmp>
; CHECK-NEXT: Successor(s): latch
@@ -445,7 +445,7 @@ define void @cond_reverse_load_store(ptr noalias %a, ptr noalias %b, ptr noalias
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION nsw ir<1023>, ir<-1>, vp<[[VP0]]>
-; CHECK-NEXT: EMIT ir<%gep.cond> = getelementptr inbounds ir<%cond>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.cond> = getelementptr inbounds i32, ir<%cond>, ir<%iv>
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = vector-end-pointer inbounds i32, ir<%gep.cond>, vp<[[VP0]]>
; CHECK-NEXT: WIDEN ir<%c> = load vp<[[VP4]]>
; CHECK-NEXT: EMIT vp<[[VP5:%[0-9]+]]> = reverse ir<%c>
@@ -453,13 +453,13 @@ define void @cond_reverse_load_store(ptr noalias %a, ptr noalias %b, ptr noalias
; CHECK-NEXT: Successor(s): then
; CHECK-EMPTY:
; CHECK-NEXT: then:
-; CHECK-NEXT: EMIT ir<%gep.a> = getelementptr inbounds ir<%a>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.a> = getelementptr inbounds i32, ir<%a>, ir<%iv>
; CHECK-NEXT: vp<[[VP6:%[0-9]+]]> = vector-end-pointer inbounds i32, ir<%gep.a>, vp<[[VP0]]>
; CHECK-NEXT: EMIT vp<[[VP7:%[0-9]+]]> = reverse ir<%cmp>
; CHECK-NEXT: WIDEN ir<%lv> = load vp<[[VP6]]>, vp<[[VP7]]>
; CHECK-NEXT: EMIT vp<[[VP8:%[0-9]+]]> = reverse ir<%lv>
; CHECK-NEXT: EMIT ir<%add> = add vp<[[VP8]]>, ir<1>, ir<%cmp>
-; CHECK-NEXT: EMIT ir<%gep.b> = getelementptr inbounds ir<%b>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.b> = getelementptr inbounds i32, ir<%b>, ir<%iv>
; CHECK-NEXT: vp<[[VP9:%[0-9]+]]> = vector-end-pointer inbounds i32, ir<%gep.b>, vp<[[VP0]]>
; CHECK-NEXT: EMIT vp<[[VP10:%[0-9]+]]> = reverse ir<%cmp>
; CHECK-NEXT: EMIT vp<[[VP11:%[0-9]+]]> = reverse ir<%add>
@@ -525,7 +525,7 @@ define void @or_disjoint_address(ptr noalias %A) {
; CHECK-NEXT: vector.body:
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION nuw nsw ir<0>, ir<1>, vp<[[VP0]]>
; CHECK-NEXT: EMIT ir<%or> = or disjoint ir<%iv>, ir<1>
-; CHECK-NEXT: EMIT ir<%gep> = getelementptr inbounds ir<%A>, ir<%or>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr inbounds i32, ir<%A>, ir<%or>
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = vector-pointer inbounds i32, ir<%gep>, ir<1>
; CHECK-NEXT: WIDEN ir<%lv> = load vp<[[VP4]]>
; CHECK-NEXT: EMIT ir<%add> = add ir<%lv>, ir<1>
@@ -582,7 +582,7 @@ define void @sdiv_with_nonnegative_operands_address(ptr noalias %A) {
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION nuw nsw ir<0>, ir<1>, vp<[[VP0]]>
; CHECK-NEXT: EMIT ir<%mul> = mul nuw nsw ir<%iv>, ir<4>
; CHECK-NEXT: EMIT ir<%div> = sdiv ir<%mul>, ir<4>
-; CHECK-NEXT: EMIT ir<%gep> = getelementptr inbounds ir<%A>, ir<%div>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr inbounds i32, ir<%A>, ir<%div>
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = vector-pointer inbounds i32, ir<%gep>, ir<1>
; CHECK-NEXT: WIDEN ir<%lv> = load vp<[[VP4]]>
; CHECK-NEXT: EMIT ir<%add> = add ir<%lv>, ir<1>
@@ -640,7 +640,7 @@ define void @ashr_of_shl_address(ptr noalias %A) {
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION nuw nsw ir<0>, ir<1>, vp<[[VP0]]>
; CHECK-NEXT: EMIT ir<%shl> = shl ir<%iv>, ir<32>
; CHECK-NEXT: EMIT ir<%ashr> = ashr ir<%shl>, ir<32>
-; CHECK-NEXT: EMIT ir<%gep> = getelementptr inbounds ir<%A>, ir<%ashr>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr inbounds i32, ir<%A>, ir<%ashr>
; CHECK-NEXT: EMIT-SCALAR ir<%lv> = load ir<%gep>
; CHECK-NEXT: EMIT ir<%add> = add ir<%lv>, ir<1>
; CHECK-NEXT: EMIT store ir<%add>, ir<%gep>
@@ -697,7 +697,7 @@ define void @extractvalue_of_with_overflow_address(ptr noalias %A) {
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION nuw nsw ir<0>, ir<1>, vp<[[VP0]]>
; CHECK-NEXT: EMIT ir<%res> = call ir<%iv>, ir<1>, ir<@llvm.sadd.with.overflow.i64>
; CHECK-NEXT: EMIT ir<%idx> = extractvalue ir<%res>
-; CHECK-NEXT: EMIT ir<%gep> = getelementptr inbounds ir<%A>, ir<%idx>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr inbounds i32, ir<%A>, ir<%idx>
; CHECK-NEXT: EMIT-SCALAR ir<%lv> = load ir<%gep>
; CHECK-NEXT: EMIT ir<%add> = add ir<%lv>, ir<1>
; CHECK-NEXT: EMIT store ir<%add>, ir<%gep>
@@ -763,7 +763,7 @@ define void @blend_with_identical_incoming_values_address(ptr noalias %A, i1 %c)
; CHECK-EMPTY:
; CHECK-NEXT: latch:
; CHECK-NEXT: BLEND ir<%idx> = ir<%idx.else>/vp<[[VP4]]> ir<%idx.then>/ir<%c>
-; CHECK-NEXT: EMIT ir<%gep> = getelementptr inbounds ir<%A>, ir<%idx>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr inbounds i32, ir<%A>, ir<%idx>
; CHECK-NEXT: EMIT-SCALAR ir<%lv> = load ir<%gep>
; CHECK-NEXT: EMIT ir<%add> = add ir<%lv>, ir<1>
; CHECK-NEXT: EMIT store ir<%add>, ir<%gep>
@@ -828,9 +828,9 @@ define void @or_without_disjoint_address(ptr noalias %A, ptr noalias %B) {
; CHECK-NEXT: vector.body:
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION nuw nsw ir<0>, ir<1>, vp<[[VP0]]>
; CHECK-NEXT: EMIT ir<%idx> = or ir<%iv>, ir<1>
-; CHECK-NEXT: EMIT ir<%gep.B> = getelementptr inbounds ir<%B>, ir<%idx>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.B> = getelementptr inbounds i32, ir<%B>, ir<%idx>
; CHECK-NEXT: EMIT-SCALAR ir<%lv> = load ir<%gep.B>
-; CHECK-NEXT: EMIT ir<%gep.A> = getelementptr inbounds ir<%A>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.A> = getelementptr inbounds i32, ir<%A>, ir<%iv>
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = vector-pointer inbounds i32, ir<%gep.A>, ir<1>
; CHECK-NEXT: WIDEN store vp<[[VP4]]>, ir<%lv>
; CHECK-NEXT: EMIT ir<%iv.next> = add nuw nsw ir<%iv>, ir<1>
@@ -883,9 +883,9 @@ define void @sdiv_with_negative_operand_address(ptr noalias %A, ptr noalias %B)
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION nuw nsw ir<0>, ir<1>, vp<[[VP0]]>
; CHECK-NEXT: EMIT ir<%mul> = mul nuw nsw ir<%iv>, ir<4>
; CHECK-NEXT: EMIT ir<%idx> = sdiv ir<%mul>, ir<-4>
-; CHECK-NEXT: EMIT ir<%gep.B> = getelementptr inbounds ir<%B>, ir<%idx>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.B> = getelementptr inbounds i32, ir<%B>, ir<%idx>
; CHECK-NEXT: EMIT-SCALAR ir<%lv> = load ir<%gep.B>
-; CHECK-NEXT: EMIT ir<%gep.A> = getelementptr inbounds ir<%A>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.A> = getelementptr inbounds i32, ir<%A>, ir<%iv>
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = vector-pointer inbounds i32, ir<%gep.A>, ir<1>
; CHECK-NEXT: WIDEN store vp<[[VP4]]>, ir<%lv>
; CHECK-NEXT: EMIT ir<%iv.next> = add nuw nsw ir<%iv>, ir<1>
@@ -939,9 +939,9 @@ define void @ashr_amount_larger_than_shl_address(ptr noalias %A, ptr noalias %B)
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION nuw nsw ir<0>, ir<1>, vp<[[VP0]]>
; CHECK-NEXT: EMIT ir<%shl> = shl ir<%iv>, ir<16>
; CHECK-NEXT: EMIT ir<%idx> = ashr ir<%shl>, ir<32>
-; CHECK-NEXT: EMIT ir<%gep.B> = getelementptr inbounds ir<%B>, ir<%idx>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.B> = getelementptr inbounds i32, ir<%B>, ir<%idx>
; CHECK-NEXT: EMIT-SCALAR ir<%lv> = load ir<%gep.B>
-; CHECK-NEXT: EMIT ir<%gep.A> = getelementptr inbounds ir<%A>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.A> = getelementptr inbounds i32, ir<%A>, ir<%iv>
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = vector-pointer inbounds i32, ir<%gep.A>, ir<1>
; CHECK-NEXT: WIDEN store vp<[[VP4]]>, ir<%lv>
; CHECK-NEXT: EMIT ir<%iv.next> = add nuw nsw ir<%iv>, ir<1>
@@ -1006,9 +1006,9 @@ define void @blend_with_different_incoming_values_address(ptr noalias %A, ptr no
; CHECK-EMPTY:
; CHECK-NEXT: latch:
; CHECK-NEXT: BLEND ir<%idx> = ir<%idx.else>/vp<[[VP4]]> ir<%idx.then>/ir<%c>
-; CHECK-NEXT: EMIT ir<%gep.B> = getelementptr inbounds ir<%B>, ir<%idx>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.B> = getelementptr inbounds i32, ir<%B>, ir<%idx>
; CHECK-NEXT: EMIT-SCALAR ir<%lv> = load ir<%gep.B>
-; CHECK-NEXT: EMIT ir<%gep.A> = getelementptr inbounds ir<%A>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.A> = getelementptr inbounds i32, ir<%A>, ir<%iv>
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = vector-pointer inbounds i32, ir<%gep.A>, ir<1>
; CHECK-NEXT: WIDEN store vp<[[VP5]]>, ir<%lv>
; CHECK-NEXT: EMIT ir<%iv.next> = add nuw nsw ir<%iv>, ir<1>
diff --git a/llvm/test/Transforms/LoopVectorize/VPlan/AArch64/vplan-printing-alias-mask.ll b/llvm/test/Transforms/LoopVectorize/VPlan/AArch64/vplan-printing-alias-mask.ll
index c40aad62202dd..30e40e256a3c2 100644
--- a/llvm/test/Transforms/LoopVectorize/VPlan/AArch64/vplan-printing-alias-mask.ll
+++ b/llvm/test/Transforms/LoopVectorize/VPlan/AArch64/vplan-printing-alias-mask.ll
@@ -33,12 +33,12 @@ define void @alias_mask(ptr noalias %a, ptr %b, ptr %c, i64 %n) {
; FINAL-NEXT: EMIT-SCALAR vp<%index> = phi [ ir<0>, vector.ph ], [ vp<%index.next>, vector.body ]
; FINAL-NEXT: ACTIVE-LANE-MASK-PHI vp<[[VP8:%[0-9]+]]> = phi vp<%extract.entry.alm.part>, vp<%extract.next.alm.part>
; FINAL-NEXT: EMIT vp<[[VP9:%[0-9]+]]> = and vp<[[VP8]]>, vp<[[VP4]]>
-; FINAL-NEXT: CLONE ir<%ptr.a> = getelementptr inbounds ir<%a>, vp<%index>
+; FINAL-NEXT: EMIT-SCALAR ir<%ptr.a> = getelementptr inbounds i8, ir<%a>, vp<%index>
; FINAL-NEXT: WIDEN ir<%ld.a> = load ir<%ptr.a>, vp<[[VP9]]>
-; FINAL-NEXT: CLONE ir<%ptr.b> = getelementptr inbounds ir<%b>, vp<%index>
+; FINAL-NEXT: EMIT-SCALAR ir<%ptr.b> = getelementptr inbounds i8, ir<%b>, vp<%index>
; FINAL-NEXT: WIDEN ir<%ld.b> = load ir<%ptr.b>, vp<[[VP9]]>
; FINAL-NEXT: WIDEN ir<%add> = add ir<%ld.b>, ir<%ld.a>
-; FINAL-NEXT: CLONE ir<%ptr.c> = getelementptr inbounds ir<%c>, vp<%index>
+; FINAL-NEXT: EMIT-SCALAR ir<%ptr.c> = getelementptr inbounds i8, ir<%c>, vp<%index>
; FINAL-NEXT: WIDEN store ir<%ptr.c>, ir<%add>, vp<[[VP9]]>
; FINAL-NEXT: EMIT vp<%index.next> = add vp<%index>, vp<%num.active.lanes>
; FINAL-NEXT: EMIT vp<%active.lane.mask.next> = wide active lane mask vp<%index.next>, ir<%n>, ir<1>
diff --git a/llvm/test/Transforms/LoopVectorize/VPlan/AArch64/vplan-printing.ll b/llvm/test/Transforms/LoopVectorize/VPlan/AArch64/vplan-printing.ll
index 8111b770e3c4b..65a9d88f110f3 100644
--- a/llvm/test/Transforms/LoopVectorize/VPlan/AArch64/vplan-printing.ll
+++ b/llvm/test/Transforms/LoopVectorize/VPlan/AArch64/vplan-printing.ll
@@ -27,10 +27,10 @@ define i32 @print_partial_reduction(ptr %a, ptr %b) "target-features"="+neon,+do
; CHECK-NEXT: vector.body:
; CHECK-NEXT: WIDEN-REDUCTION-PHI ir<%accum> = phi (add) vp<[[VP3]]>, vp<[[VP8:%[0-9]+]]> (VF scaled by 1/4)
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = SCALAR-STEPS vp<[[VP4]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%gep.a> = getelementptr ir<%a>, vp<[[VP5]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.a> = getelementptr i8, ir<%a>, vp<[[VP5]]>
; CHECK-NEXT: vp<[[VP6:%[0-9]+]]> = vector-pointer i8, ir<%gep.a>, ir<1>
; CHECK-NEXT: WIDEN ir<%load.a> = load vp<[[VP6]]>
-; CHECK-NEXT: CLONE ir<%gep.b> = getelementptr ir<%b>, vp<[[VP5]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.b> = getelementptr i8, ir<%b>, vp<[[VP5]]>
; CHECK-NEXT: vp<[[VP7:%[0-9]+]]> = vector-pointer i8, ir<%gep.b>, ir<1>
; CHECK-NEXT: WIDEN ir<%load.b> = load vp<[[VP7]]>
; CHECK-NEXT: EXPRESSION vp<[[VP8]]> = ir<%accum> + partial.reduce.add (mul (ir<%load.b> zext to i32), (ir<%load.a> zext to i32))
@@ -117,10 +117,10 @@ define i32 @print_partial_reduction_predication(ptr %a, ptr %b, i64 %N) "target-
; CHECK-NEXT: ACTIVE-LANE-MASK-PHI vp<[[VP6:%[0-9]+]]> = phi vp<%extract.entry.alm.part>, vp<%extract.next.alm.part>
; CHECK-NEXT: WIDEN-REDUCTION-PHI ir<%accum> = phi (add) vp<[[VP3]]>, vp<[[VP10:%[0-9]+]]> (VF scaled by 1/4)
; CHECK-NEXT: vp<[[VP7:%[0-9]+]]> = SCALAR-STEPS vp<[[VP4]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%gep.a> = getelementptr ir<%a>, vp<[[VP7]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.a> = getelementptr i8, ir<%a>, vp<[[VP7]]>
; CHECK-NEXT: vp<[[VP8:%[0-9]+]]> = vector-pointer i8, ir<%gep.a>, ir<1>
; CHECK-NEXT: WIDEN ir<%load.a> = load vp<[[VP8]]>, vp<[[VP6]]>
-; CHECK-NEXT: CLONE ir<%gep.b> = getelementptr ir<%b>, vp<[[VP7]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.b> = getelementptr i8, ir<%b>, vp<[[VP7]]>
; CHECK-NEXT: vp<[[VP9:%[0-9]+]]> = vector-pointer i8, ir<%gep.b>, ir<1>
; CHECK-NEXT: WIDEN ir<%load.b> = load vp<[[VP9]]>, vp<[[VP6]]>
; CHECK-NEXT: EXPRESSION vp<[[VP10]]> = ir<%accum> + partial.reduce.add (mul (ir<%load.b> zext to i32), (ir<%load.a> zext to i32), vp<[[VP6]]>)
@@ -203,10 +203,10 @@ define i32 @print_partial_reduction_ext_mul(ptr %a, ptr %b) "target-features"="+
; CHECK-NEXT: vector.body:
; CHECK-NEXT: WIDEN-REDUCTION-PHI ir<%accum> = phi (add) vp<[[VP3]]>, vp<[[VP8:%[0-9]+]]> (VF scaled by 1/4)
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = SCALAR-STEPS vp<[[VP4]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%gep.a> = getelementptr ir<%a>, vp<[[VP5]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.a> = getelementptr i8, ir<%a>, vp<[[VP5]]>
; CHECK-NEXT: vp<[[VP6:%[0-9]+]]> = vector-pointer i8, ir<%gep.a>, ir<1>
; CHECK-NEXT: WIDEN ir<%load.a> = load vp<[[VP6]]>
-; CHECK-NEXT: CLONE ir<%gep.b> = getelementptr ir<%b>, vp<[[VP5]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.b> = getelementptr i8, ir<%b>, vp<[[VP5]]>
; CHECK-NEXT: vp<[[VP7:%[0-9]+]]> = vector-pointer i8, ir<%gep.b>, ir<1>
; CHECK-NEXT: WIDEN ir<%load.b> = load vp<[[VP7]]>
; CHECK-NEXT: EXPRESSION vp<[[VP8]]> = ir<%accum> + partial.reduce.add (mul (ir<%load.b> zext to i32), (ir<%load.a> zext to i32))
diff --git a/llvm/test/Transforms/LoopVectorize/VPlan/AArch64/widen-call-with-intrinsic-or-libfunc.ll b/llvm/test/Transforms/LoopVectorize/VPlan/AArch64/widen-call-with-intrinsic-or-libfunc.ll
index 021da3088c28f..c9086d229045d 100644
--- a/llvm/test/Transforms/LoopVectorize/VPlan/AArch64/widen-call-with-intrinsic-or-libfunc.ll
+++ b/llvm/test/Transforms/LoopVectorize/VPlan/AArch64/widen-call-with-intrinsic-or-libfunc.ll
@@ -23,7 +23,7 @@ target triple = "arm64-apple-ios"
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: vp<[[STEPS:%.+]]> = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>, vp<[[VF]]>
-; CHECK-NEXT: CLONE ir<%gep.src> = getelementptr inbounds ir<%src>, vp<[[STEPS]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.src> = getelementptr inbounds float, ir<%src>, vp<[[STEPS]]>
; CHECK-NEXT: vp<[[VEC_PTR:%.+]]> = vector-pointer inbounds float, ir<%gep.src>
; CHECK-NEXT: WIDEN ir<%l> = load vp<[[VEC_PTR]]>
; CHECK-NEXT: WIDEN-CAST ir<%conv> = fpext ir<%l> to double
@@ -71,7 +71,7 @@ target triple = "arm64-apple-ios"
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: vp<[[STEPS:%.+]]> = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>, vp<[[VF]]>
-; CHECK-NEXT: CLONE ir<%gep.src> = getelementptr inbounds ir<%src>, vp<[[STEPS]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.src> = getelementptr inbounds float, ir<%src>, vp<[[STEPS]]>
; CHECK-NEXT: vp<[[VEC_PTR:%.+]]> = vector-pointer inbounds float, ir<%gep.src>
; CHECK-NEXT: WIDEN ir<%l> = load vp<[[VEC_PTR]]>
; CHECK-NEXT: WIDEN-CAST ir<%conv> = fpext ir<%l> to double
diff --git a/llvm/test/Transforms/LoopVectorize/VPlan/PowerPC/vplan-force-tail-with-evl.ll b/llvm/test/Transforms/LoopVectorize/VPlan/PowerPC/vplan-force-tail-with-evl.ll
index f01e9adca91d4..d852dd54e873b 100644
--- a/llvm/test/Transforms/LoopVectorize/VPlan/PowerPC/vplan-force-tail-with-evl.ll
+++ b/llvm/test/Transforms/LoopVectorize/VPlan/PowerPC/vplan-force-tail-with-evl.ll
@@ -94,11 +94,11 @@ define void @safe_dep(ptr %p) {
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = SCALAR-STEPS vp<[[VP3]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%a1> = getelementptr ir<%p>, vp<[[VP4]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%a1> = getelementptr i64, ir<%p>, vp<[[VP4]]>
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = vector-pointer i64, ir<%a1>, ir<1>
; CHECK-NEXT: WIDEN ir<%v> = load vp<[[VP5]]>
; CHECK-NEXT: CLONE ir<%offset> = add vp<[[VP4]]>, ir<100>
-; CHECK-NEXT: CLONE ir<%a2> = getelementptr ir<%p>, ir<%offset>
+; CHECK-NEXT: EMIT-SCALAR ir<%a2> = getelementptr i64, ir<%p>, ir<%offset>
; CHECK-NEXT: vp<[[VP6:%[0-9]+]]> = vector-pointer i64, ir<%a2>, ir<1>
; CHECK-NEXT: WIDEN store vp<[[VP6]]>, ir<%v>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<[[VP3]]>, vp<[[VP1]]>
diff --git a/llvm/test/Transforms/LoopVectorize/VPlan/RISCV/cse-loads-evl.ll b/llvm/test/Transforms/LoopVectorize/VPlan/RISCV/cse-loads-evl.ll
index 705293083950f..a590b9d05cb1b 100644
--- a/llvm/test/Transforms/LoopVectorize/VPlan/RISCV/cse-loads-evl.ll
+++ b/llvm/test/Transforms/LoopVectorize/VPlan/RISCV/cse-loads-evl.ll
@@ -22,10 +22,10 @@ define void @cse_duplicate_load(ptr noalias %a, ptr noalias %b, i64 %n) {
; CHECK-NEXT: EMIT-SCALAR vp<%index> = phi [ ir<0>, vector.ph ], [ vp<%current.iteration.next>, vector.body ]
; CHECK-NEXT: EMIT-SCALAR vp<%avl> = phi [ ir<%n>, vector.ph ], [ vp<%avl.next>, vector.body ]
; CHECK-NEXT: EMIT-SCALAR vp<%evl> = EXPLICIT-VECTOR-LENGTH vp<%avl>
-; CHECK-NEXT: CLONE ir<%gep.a> = getelementptr inbounds ir<%a>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.a> = getelementptr inbounds i32, ir<%a>, vp<%index>
; CHECK-NEXT: WIDEN ir<%x> = vp.load ir<%gep.a>, vp<%evl>
; CHECK-NEXT: WIDEN ir<%sum> = add ir<%x>, ir<%x>
-; CHECK-NEXT: CLONE ir<%gep.b> = getelementptr inbounds ir<%b>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.b> = getelementptr inbounds i32, ir<%b>, vp<%index>
; CHECK-NEXT: WIDEN vp.store ir<%gep.b>, ir<%sum>, vp<%evl>
; CHECK-NEXT: EMIT-SCALAR vp<[[VP2:%[0-9]+]]> = zext vp<%evl> to i64
; CHECK-NEXT: EMIT vp<%current.iteration.next> = add vp<[[VP2]]>, vp<%index>
@@ -69,7 +69,7 @@ define void @no_cse_across_store(ptr %a, i64 %n) {
; CHECK-NEXT: EMIT-SCALAR vp<%index> = phi [ ir<0>, vector.ph ], [ vp<%current.iteration.next>, vector.body ]
; CHECK-NEXT: EMIT-SCALAR vp<%avl> = phi [ ir<%n>, vector.ph ], [ vp<%avl.next>, vector.body ]
; CHECK-NEXT: EMIT-SCALAR vp<%evl> = EXPLICIT-VECTOR-LENGTH vp<%avl>
-; CHECK-NEXT: CLONE ir<%gep> = getelementptr inbounds ir<%a>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr inbounds i32, ir<%a>, vp<%index>
; CHECK-NEXT: WIDEN ir<%x> = vp.load ir<%gep>, vp<%evl>
; CHECK-NEXT: WIDEN ir<%inc> = add ir<%x>, ir<1>
; CHECK-NEXT: WIDEN vp.store ir<%gep>, ir<%inc>, vp<%evl>
@@ -119,14 +119,14 @@ define void @two_masked_same_mask(ptr noalias %a, ptr noalias %b, ptr noalias %c
; CHECK-NEXT: EMIT-SCALAR vp<%index> = phi [ ir<0>, vector.ph ], [ vp<%current.iteration.next>, vector.body ]
; CHECK-NEXT: EMIT-SCALAR vp<%avl> = phi [ ir<%n>, vector.ph ], [ vp<%avl.next>, vector.body ]
; CHECK-NEXT: EMIT-SCALAR vp<%evl> = EXPLICIT-VECTOR-LENGTH vp<%avl>
-; CHECK-NEXT: CLONE ir<%gep.c> = getelementptr inbounds ir<%cond>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.c> = getelementptr inbounds i32, ir<%cond>, vp<%index>
; CHECK-NEXT: WIDEN ir<%c> = vp.load ir<%gep.c>, vp<%evl>
; CHECK-NEXT: WIDEN ir<%cmp> = icmp ne ir<%c>, ir<0>
-; CHECK-NEXT: CLONE ir<%gep.a> = getelementptr ir<%a>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.a> = getelementptr i32, ir<%a>, vp<%index>
; CHECK-NEXT: WIDEN ir<%x> = vp.load ir<%gep.a>, vp<%evl>, ir<%cmp>
; CHECK-NEXT: WIDEN ir<%s> = add ir<%x>, ir<%x>
; CHECK-NEXT: EMIT vp<%predphi> = select ir<%cmp>, ir<%s>, ir<0>
-; CHECK-NEXT: CLONE ir<%gep.b> = getelementptr inbounds ir<%b>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.b> = getelementptr inbounds i32, ir<%b>, vp<%index>
; CHECK-NEXT: WIDEN vp.store ir<%gep.b>, vp<%predphi>, vp<%evl>
; CHECK-NEXT: EMIT-SCALAR vp<[[VP2:%[0-9]+]]> = zext vp<%evl> to i64
; CHECK-NEXT: EMIT vp<%current.iteration.next> = add vp<[[VP2]]>, vp<%index>
@@ -180,19 +180,19 @@ define void @two_masked_diff_mask(ptr noalias %a, ptr noalias %b, ptr noalias %c
; CHECK-NEXT: EMIT-SCALAR vp<%index> = phi [ ir<0>, vector.ph ], [ vp<%current.iteration.next>, vector.body ]
; CHECK-NEXT: EMIT-SCALAR vp<%avl> = phi [ ir<%n>, vector.ph ], [ vp<%avl.next>, vector.body ]
; CHECK-NEXT: EMIT-SCALAR vp<%evl> = EXPLICIT-VECTOR-LENGTH vp<%avl>
-; CHECK-NEXT: CLONE ir<%gep.a> = getelementptr ir<%a>, vp<%index>
-; CHECK-NEXT: CLONE ir<%gp1> = getelementptr inbounds ir<%c1>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.a> = getelementptr i32, ir<%a>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%gp1> = getelementptr inbounds i32, ir<%c1>, vp<%index>
; CHECK-NEXT: WIDEN ir<%v1> = vp.load ir<%gp1>, vp<%evl>
; CHECK-NEXT: WIDEN ir<%cmp1> = icmp ne ir<%v1>, ir<0>
; CHECK-NEXT: WIDEN ir<%x> = vp.load ir<%gep.a>, vp<%evl>, ir<%cmp1>
; CHECK-NEXT: EMIT vp<%predphi> = select ir<%cmp1>, ir<%x>, ir<0>
-; CHECK-NEXT: CLONE ir<%gp2> = getelementptr inbounds ir<%c2>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%gp2> = getelementptr inbounds i32, ir<%c2>, vp<%index>
; CHECK-NEXT: WIDEN ir<%v2> = vp.load ir<%gp2>, vp<%evl>
; CHECK-NEXT: WIDEN ir<%cmp2> = icmp ne ir<%v2>, ir<0>
; CHECK-NEXT: WIDEN ir<%y> = vp.load ir<%gep.a>, vp<%evl>, ir<%cmp2>
; CHECK-NEXT: EMIT vp<%predphi>.1 = select ir<%cmp2>, ir<%y>, ir<0>
; CHECK-NEXT: WIDEN ir<%sum> = add vp<%predphi>, vp<%predphi>.1
-; CHECK-NEXT: CLONE ir<%gep.b> = getelementptr inbounds ir<%b>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.b> = getelementptr inbounds i32, ir<%b>, vp<%index>
; CHECK-NEXT: WIDEN vp.store ir<%gep.b>, ir<%sum>, vp<%evl>
; CHECK-NEXT: EMIT-SCALAR vp<[[VP2:%[0-9]+]]> = zext vp<%evl> to i64
; CHECK-NEXT: EMIT vp<%current.iteration.next> = add vp<[[VP2]]>, vp<%index>
@@ -256,11 +256,11 @@ define void @cse_three_duplicate_loads(ptr noalias %a, ptr noalias %b, i64 %n) {
; CHECK-NEXT: EMIT-SCALAR vp<%index> = phi [ ir<0>, vector.ph ], [ vp<%current.iteration.next>, vector.body ]
; CHECK-NEXT: EMIT-SCALAR vp<%avl> = phi [ ir<%n>, vector.ph ], [ vp<%avl.next>, vector.body ]
; CHECK-NEXT: EMIT-SCALAR vp<%evl> = EXPLICIT-VECTOR-LENGTH vp<%avl>
-; CHECK-NEXT: CLONE ir<%gep.a> = getelementptr inbounds ir<%a>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.a> = getelementptr inbounds i32, ir<%a>, vp<%index>
; CHECK-NEXT: WIDEN ir<%x> = vp.load ir<%gep.a>, vp<%evl>
; CHECK-NEXT: WIDEN ir<%t> = add ir<%x>, ir<%x>
; CHECK-NEXT: WIDEN ir<%sum> = add ir<%t>, ir<%x>
-; CHECK-NEXT: CLONE ir<%gep.b> = getelementptr inbounds ir<%b>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.b> = getelementptr inbounds i32, ir<%b>, vp<%index>
; CHECK-NEXT: WIDEN vp.store ir<%gep.b>, ir<%sum>, vp<%evl>
; CHECK-NEXT: EMIT-SCALAR vp<[[VP2:%[0-9]+]]> = zext vp<%evl> to i64
; CHECK-NEXT: EMIT vp<%current.iteration.next> = add vp<[[VP2]]>, vp<%index>
@@ -306,14 +306,14 @@ define void @two_dup_groups(ptr noalias %a, ptr noalias %b, ptr noalias %out, i6
; CHECK-NEXT: EMIT-SCALAR vp<%index> = phi [ ir<0>, vector.ph ], [ vp<%current.iteration.next>, vector.body ]
; CHECK-NEXT: EMIT-SCALAR vp<%avl> = phi [ ir<%n>, vector.ph ], [ vp<%avl.next>, vector.body ]
; CHECK-NEXT: EMIT-SCALAR vp<%evl> = EXPLICIT-VECTOR-LENGTH vp<%avl>
-; CHECK-NEXT: CLONE ir<%pa> = getelementptr inbounds ir<%a>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%pa> = getelementptr inbounds i32, ir<%a>, vp<%index>
; CHECK-NEXT: WIDEN ir<%a1> = vp.load ir<%pa>, vp<%evl>
-; CHECK-NEXT: CLONE ir<%pb> = getelementptr inbounds ir<%b>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%pb> = getelementptr inbounds i32, ir<%b>, vp<%index>
; CHECK-NEXT: WIDEN ir<%b1> = vp.load ir<%pb>, vp<%evl>
; CHECK-NEXT: WIDEN ir<%sa> = add ir<%a1>, ir<%a1>
; CHECK-NEXT: WIDEN ir<%sb> = add ir<%b1>, ir<%b1>
; CHECK-NEXT: WIDEN ir<%s> = add ir<%sa>, ir<%sb>
-; CHECK-NEXT: CLONE ir<%po> = getelementptr inbounds ir<%out>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%po> = getelementptr inbounds i32, ir<%out>, vp<%index>
; CHECK-NEXT: WIDEN vp.store ir<%po>, ir<%s>, vp<%evl>
; CHECK-NEXT: EMIT-SCALAR vp<[[VP2:%[0-9]+]]> = zext vp<%evl> to i64
; CHECK-NEXT: EMIT vp<%current.iteration.next> = add vp<[[VP2]]>, vp<%index>
@@ -362,10 +362,10 @@ define void @cse_stronger_align_first(ptr noalias %a, ptr noalias %b, i64 %n) {
; CHECK-NEXT: EMIT-SCALAR vp<%index> = phi [ ir<0>, vector.ph ], [ vp<%current.iteration.next>, vector.body ]
; CHECK-NEXT: EMIT-SCALAR vp<%avl> = phi [ ir<%n>, vector.ph ], [ vp<%avl.next>, vector.body ]
; CHECK-NEXT: EMIT-SCALAR vp<%evl> = EXPLICIT-VECTOR-LENGTH vp<%avl>
-; CHECK-NEXT: CLONE ir<%gep> = getelementptr inbounds ir<%a>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr inbounds i32, ir<%a>, vp<%index>
; CHECK-NEXT: WIDEN ir<%x> = vp.load ir<%gep>, vp<%evl>
; CHECK-NEXT: WIDEN ir<%sum> = add ir<%x>, ir<%x>
-; CHECK-NEXT: CLONE ir<%gep.b> = getelementptr inbounds ir<%b>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.b> = getelementptr inbounds i32, ir<%b>, vp<%index>
; CHECK-NEXT: WIDEN vp.store ir<%gep.b>, ir<%sum>, vp<%evl>
; CHECK-NEXT: EMIT-SCALAR vp<[[VP2:%[0-9]+]]> = zext vp<%evl> to i64
; CHECK-NEXT: EMIT vp<%current.iteration.next> = add vp<[[VP2]]>, vp<%index>
@@ -409,11 +409,11 @@ define void @no_cse_weaker_align_first(ptr noalias %a, ptr noalias %b, i64 %n) {
; CHECK-NEXT: EMIT-SCALAR vp<%index> = phi [ ir<0>, vector.ph ], [ vp<%current.iteration.next>, vector.body ]
; CHECK-NEXT: EMIT-SCALAR vp<%avl> = phi [ ir<%n>, vector.ph ], [ vp<%avl.next>, vector.body ]
; CHECK-NEXT: EMIT-SCALAR vp<%evl> = EXPLICIT-VECTOR-LENGTH vp<%avl>
-; CHECK-NEXT: CLONE ir<%gep> = getelementptr inbounds ir<%a>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr inbounds i32, ir<%a>, vp<%index>
; CHECK-NEXT: WIDEN ir<%x> = vp.load ir<%gep>, vp<%evl>
; CHECK-NEXT: WIDEN ir<%y> = vp.load ir<%gep>, vp<%evl>
; CHECK-NEXT: WIDEN ir<%sum> = add ir<%x>, ir<%y>
-; CHECK-NEXT: CLONE ir<%gep.b> = getelementptr inbounds ir<%b>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.b> = getelementptr inbounds i32, ir<%b>, vp<%index>
; CHECK-NEXT: WIDEN vp.store ir<%gep.b>, ir<%sum>, vp<%evl>
; CHECK-NEXT: EMIT-SCALAR vp<[[VP2:%[0-9]+]]> = zext vp<%evl> to i64
; CHECK-NEXT: EMIT vp<%current.iteration.next> = add vp<[[VP2]]>, vp<%index>
@@ -457,9 +457,9 @@ define void @no_cse_across_noalias_store(ptr noalias %a, ptr noalias %b, i64 %n)
; CHECK-NEXT: EMIT-SCALAR vp<%index> = phi [ ir<0>, vector.ph ], [ vp<%current.iteration.next>, vector.body ]
; CHECK-NEXT: EMIT-SCALAR vp<%avl> = phi [ ir<%n>, vector.ph ], [ vp<%avl.next>, vector.body ]
; CHECK-NEXT: EMIT-SCALAR vp<%evl> = EXPLICIT-VECTOR-LENGTH vp<%avl>
-; CHECK-NEXT: CLONE ir<%gep.a> = getelementptr inbounds ir<%a>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.a> = getelementptr inbounds i32, ir<%a>, vp<%index>
; CHECK-NEXT: WIDEN ir<%x> = vp.load ir<%gep.a>, vp<%evl>
-; CHECK-NEXT: CLONE ir<%gep.b> = getelementptr inbounds ir<%b>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.b> = getelementptr inbounds i32, ir<%b>, vp<%index>
; CHECK-NEXT: WIDEN vp.store ir<%gep.b>, ir<%x>, vp<%evl>
; CHECK-NEXT: WIDEN ir<%y> = vp.load ir<%gep.a>, vp<%evl>
; CHECK-NEXT: WIDEN ir<%sum> = add ir<%x>, ir<%y>
@@ -507,12 +507,12 @@ define void @dup_gather(ptr noalias %a, ptr noalias %idx, ptr noalias %out, i64
; CHECK-NEXT: EMIT-SCALAR vp<%index> = phi [ ir<0>, vector.ph ], [ vp<%current.iteration.next>, vector.body ]
; CHECK-NEXT: EMIT-SCALAR vp<%avl> = phi [ ir<%n>, vector.ph ], [ vp<%avl.next>, vector.body ]
; CHECK-NEXT: EMIT-SCALAR vp<%evl> = EXPLICIT-VECTOR-LENGTH vp<%avl>
-; CHECK-NEXT: CLONE ir<%gep.idx> = getelementptr inbounds ir<%idx>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.idx> = getelementptr inbounds i64, ir<%idx>, vp<%index>
; CHECK-NEXT: WIDEN ir<%i> = vp.load ir<%gep.idx>, vp<%evl>
; CHECK-NEXT: WIDEN-GEP ir<%gep.a> = getelementptr inbounds ir<%a>, ir<%i>
; CHECK-NEXT: WIDEN ir<%x> = vp.load ir<%gep.a>, vp<%evl>
; CHECK-NEXT: WIDEN ir<%sum> = add ir<%x>, ir<%x>
-; CHECK-NEXT: CLONE ir<%gep.o> = getelementptr inbounds ir<%out>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.o> = getelementptr inbounds i32, ir<%out>, vp<%index>
; CHECK-NEXT: WIDEN vp.store ir<%gep.o>, ir<%sum>, vp<%evl>
; CHECK-NEXT: EMIT-SCALAR vp<[[VP2:%[0-9]+]]> = zext vp<%evl> to i64
; CHECK-NEXT: EMIT vp<%current.iteration.next> = add vp<[[VP2]]>, vp<%index>
diff --git a/llvm/test/Transforms/LoopVectorize/VPlan/RISCV/expand-scev.ll b/llvm/test/Transforms/LoopVectorize/VPlan/RISCV/expand-scev.ll
index b9494f6fdcf28..023dbab0f50b0 100644
--- a/llvm/test/Transforms/LoopVectorize/VPlan/RISCV/expand-scev.ll
+++ b/llvm/test/Transforms/LoopVectorize/VPlan/RISCV/expand-scev.ll
@@ -22,7 +22,7 @@ define void @scev_ptradd_strided(ptr noalias %a, ptr noalias %dst, i64 %n) {
; CHECK-NEXT: EMIT vp<[[VP3:%[0-9]+]]> = shl nuw vp<%index>, ir<4>
; CHECK-NEXT: EMIT vp<[[VP4:%[0-9]+]]> = ptradd nuw vp<[[VP2]]>, vp<[[VP3]]>
; CHECK-NEXT: WIDEN-INTRINSIC vp<[[VP5:%[0-9]+]]> = call llvm.experimental.vp.strided.load(vp<[[VP4]]>, ir<16>, ir<true>, vp<%evl>)
-; CHECK-NEXT: CLONE ir<%gd> = getelementptr inbounds ir<%dst>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%gd> = getelementptr inbounds i32, ir<%dst>, vp<%index>
; CHECK-NEXT: WIDEN vp.store ir<%gd>, vp<[[VP5]]>, vp<%evl>
; CHECK-NEXT: EMIT-SCALAR vp<[[VP6:%[0-9]+]]> = zext vp<%evl> to i64
; CHECK-NEXT: EMIT vp<%current.iteration.next> = add vp<[[VP6]]>, vp<%index>
@@ -76,7 +76,7 @@ define void @scev_ptradd_strided_var_offset(ptr noalias %a, ptr noalias %dst, i6
; CHECK-NEXT: EMIT vp<[[VP5:%[0-9]+]]> = shl vp<%index>, ir<4>
; CHECK-NEXT: EMIT vp<[[VP6:%[0-9]+]]> = ptradd vp<[[VP4]]>, vp<[[VP5]]>
; CHECK-NEXT: WIDEN-INTRINSIC vp<[[VP7:%[0-9]+]]> = call llvm.experimental.vp.strided.load(vp<[[VP6]]>, ir<16>, ir<true>, vp<%evl>)
-; CHECK-NEXT: CLONE ir<%gd> = getelementptr inbounds ir<%dst>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%gd> = getelementptr inbounds i32, ir<%dst>, vp<%index>
; CHECK-NEXT: WIDEN vp.store ir<%gd>, vp<[[VP7]]>, vp<%evl>
; CHECK-NEXT: EMIT-SCALAR vp<[[VP8:%[0-9]+]]> = zext vp<%evl> to i64
; CHECK-NEXT: EMIT vp<%current.iteration.next> = add vp<[[VP8]]>, vp<%index>
diff --git a/llvm/test/Transforms/LoopVectorize/VPlan/RISCV/partial-reduce-dot-product.ll b/llvm/test/Transforms/LoopVectorize/VPlan/RISCV/partial-reduce-dot-product.ll
index c636351d89960..e420ebdb40ad0 100644
--- a/llvm/test/Transforms/LoopVectorize/VPlan/RISCV/partial-reduce-dot-product.ll
+++ b/llvm/test/Transforms/LoopVectorize/VPlan/RISCV/partial-reduce-dot-product.ll
@@ -25,10 +25,10 @@ define i32 @vdota4(ptr %a, ptr %b) vscale_range(2, 1024) {
; CHECK-NEXT: EMIT-SCALAR vp<%evl> = EXPLICIT-VECTOR-LENGTH vp<%avl>
; CHECK-NEXT: EMIT-SCALAR vp<[[VP6:%[0-9]+]]> = zext vp<%evl> to i64
; CHECK-NEXT: vp<[[VP7:%[0-9]+]]> = SCALAR-STEPS vp<[[VP5]]>, ir<1>, vp<[[VP6]]>
-; CHECK-NEXT: CLONE ir<%gep.a> = getelementptr ir<%a>, vp<[[VP7]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.a> = getelementptr i8, ir<%a>, vp<[[VP7]]>
; CHECK-NEXT: vp<[[VP8:%[0-9]+]]> = vector-pointer i8, ir<%gep.a>, ir<1>
; CHECK-NEXT: WIDEN ir<%load.a> = vp.load vp<[[VP8]]>, vp<%evl>
-; CHECK-NEXT: CLONE ir<%gep.b> = getelementptr ir<%b>, vp<[[VP7]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.b> = getelementptr i8, ir<%b>, vp<[[VP7]]>
; CHECK-NEXT: vp<[[VP9:%[0-9]+]]> = vector-pointer i8, ir<%gep.b>, ir<1>
; CHECK-NEXT: WIDEN ir<%load.b> = vp.load vp<[[VP9]]>, vp<%evl>
; CHECK-NEXT: EXPRESSION vp<[[VP10]]> = ir<%accum> + partial.reduce.add (mul (ir<%load.b> zext to i32), (ir<%load.a> sext to i32), vp<%evl>)
diff --git a/llvm/test/Transforms/LoopVectorize/VPlan/RISCV/reductions-evl.ll b/llvm/test/Transforms/LoopVectorize/VPlan/RISCV/reductions-evl.ll
index 7bab46500720a..979151d9ed85a 100644
--- a/llvm/test/Transforms/LoopVectorize/VPlan/RISCV/reductions-evl.ll
+++ b/llvm/test/Transforms/LoopVectorize/VPlan/RISCV/reductions-evl.ll
@@ -27,7 +27,7 @@ define float @print_reduction(i64 %n, ptr noalias %y) vscale_range(2, 1024) {
; CHECK-NEXT: EMIT-SCALAR vp<%evl> = EXPLICIT-VECTOR-LENGTH vp<%avl>
; CHECK-NEXT: EMIT-SCALAR vp<[[VP6:%[0-9]+]]> = zext vp<%evl> to i64
; CHECK-NEXT: vp<[[VP7:%[0-9]+]]> = SCALAR-STEPS vp<[[VP5]]>, ir<1>, vp<[[VP6]]>
-; CHECK-NEXT: CLONE ir<%arrayidx> = getelementptr inbounds ir<%y>, vp<[[VP7]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%arrayidx> = getelementptr inbounds float, ir<%y>, vp<[[VP7]]>
; CHECK-NEXT: vp<[[VP8:%[0-9]+]]> = vector-pointer inbounds float, ir<%arrayidx>, ir<1>
; CHECK-NEXT: WIDEN ir<%lv> = vp.load vp<[[VP8]]>, vp<%evl>
; CHECK-NEXT: REDUCE ir<%red.next> = ir<%red> + fast vp.reduce.fadd (ir<%lv>, vp<%evl>)
@@ -85,7 +85,7 @@ define void @print_reduction_with_invariant_store(i64 %n, ptr noalias %y, ptr no
; CHECK-NEXT: EMIT-SCALAR vp<%evl> = EXPLICIT-VECTOR-LENGTH vp<%avl>
; CHECK-NEXT: EMIT-SCALAR vp<[[VP6:%[0-9]+]]> = zext vp<%evl> to i64
; CHECK-NEXT: vp<[[VP7:%[0-9]+]]> = SCALAR-STEPS vp<[[VP5]]>, ir<1>, vp<[[VP6]]>
-; CHECK-NEXT: CLONE ir<%arrayidx> = getelementptr inbounds ir<%y>, vp<[[VP7]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%arrayidx> = getelementptr inbounds float, ir<%y>, vp<[[VP7]]>
; CHECK-NEXT: vp<[[VP8:%[0-9]+]]> = vector-pointer inbounds float, ir<%arrayidx>, ir<1>
; CHECK-NEXT: WIDEN ir<%lv> = vp.load vp<[[VP8]]>, vp<%evl>
; CHECK-NEXT: REDUCE ir<%red.next> = ir<%red> + fast vp.reduce.fadd (ir<%lv>, vp<%evl>)
@@ -145,10 +145,10 @@ define float @print_fmuladd_strict(ptr %a, ptr %b, i64 %n) vscale_range(2, 1024)
; CHECK-NEXT: EMIT-SCALAR vp<%evl> = EXPLICIT-VECTOR-LENGTH vp<%avl>
; CHECK-NEXT: EMIT-SCALAR vp<[[VP6:%[0-9]+]]> = zext vp<%evl> to i64
; CHECK-NEXT: vp<[[VP7:%[0-9]+]]> = SCALAR-STEPS vp<[[VP5]]>, ir<1>, vp<[[VP6]]>
-; CHECK-NEXT: CLONE ir<%arrayidx> = getelementptr inbounds ir<%a>, vp<[[VP7]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%arrayidx> = getelementptr inbounds float, ir<%a>, vp<[[VP7]]>
; CHECK-NEXT: vp<[[VP8:%[0-9]+]]> = vector-pointer inbounds float, ir<%arrayidx>, ir<1>
; CHECK-NEXT: WIDEN ir<%l.a> = vp.load vp<[[VP8]]>, vp<%evl>
-; CHECK-NEXT: CLONE ir<%arrayidx2> = getelementptr inbounds ir<%b>, vp<[[VP7]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%arrayidx2> = getelementptr inbounds float, ir<%b>, vp<[[VP7]]>
; CHECK-NEXT: vp<[[VP9:%[0-9]+]]> = vector-pointer inbounds float, ir<%arrayidx2>, ir<1>
; CHECK-NEXT: WIDEN ir<%l.b> = vp.load vp<[[VP9]]>, vp<%evl>
; CHECK-NEXT: EMIT vp<[[VP10:%[0-9]+]]> = fmul reassoc nnan ninf nsz ir<%l.a>, ir<%l.b>
@@ -209,7 +209,7 @@ define i64 @find_last_iv(ptr %a, i64 %n, i64 %start) vscale_range(2, 1024) {
; CHECK-NEXT: EMIT-SCALAR vp<%evl> = EXPLICIT-VECTOR-LENGTH vp<%avl>
; CHECK-NEXT: EMIT-SCALAR vp<[[VP5]]> = zext vp<%evl> to i64
; CHECK-NEXT: vp<[[VP6:%[0-9]+]]> = SCALAR-STEPS vp<[[VP4]]>, ir<1>, vp<[[VP5]]>
-; CHECK-NEXT: CLONE ir<%gep.a> = getelementptr inbounds ir<%a>, vp<[[VP6]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.a> = getelementptr inbounds i64, ir<%a>, vp<[[VP6]]>
; CHECK-NEXT: vp<[[VP7:%[0-9]+]]> = vector-pointer inbounds i64, ir<%gep.a>, ir<1>
; CHECK-NEXT: WIDEN ir<%l.a> = vp.load vp<[[VP7]]>, vp<%evl>
; CHECK-NEXT: WIDEN ir<%cmp2> = icmp eq ir<%l.a>, ir<%start>
@@ -270,7 +270,7 @@ define i64 @print_extended_reduction(ptr nocapture readonly %x, ptr nocapture re
; CHECK-NEXT: EMIT-SCALAR vp<%avl> = phi [ ir<%n>, vector.ph ], [ vp<%avl.next>, vector.body ]
; CHECK-NEXT: EMIT-SCALAR vp<%evl> = EXPLICIT-VECTOR-LENGTH vp<%avl>
; CHECK-NEXT: vp<[[VP6:%[0-9]+]]> = SCALAR-STEPS vp<[[VP5]]>, ir<1>, vp<%evl>
-; CHECK-NEXT: CLONE ir<%arrayidx> = getelementptr inbounds ir<%x>, vp<[[VP6]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%arrayidx> = getelementptr inbounds i32, ir<%x>, vp<[[VP6]]>
; CHECK-NEXT: vp<[[VP7:%[0-9]+]]> = vector-pointer inbounds i32, ir<%arrayidx>, ir<1>
; CHECK-NEXT: WIDEN ir<%load0> = vp.load vp<[[VP7]]>, vp<%evl>
; CHECK-NEXT: EXPRESSION vp<[[VP8]]> = vp<%evl> + reduce.add (ir<%load0> zext to i64, vp<%evl>)
@@ -328,10 +328,10 @@ define i64 @print_mulacc(ptr nocapture readonly %x, ptr nocapture readonly %y, i
; CHECK-NEXT: EMIT-SCALAR vp<%avl> = phi [ ir<%n>, vector.ph ], [ vp<%avl.next>, vector.body ]
; CHECK-NEXT: EMIT-SCALAR vp<%evl> = EXPLICIT-VECTOR-LENGTH vp<%avl>
; CHECK-NEXT: vp<[[VP6:%[0-9]+]]> = SCALAR-STEPS vp<[[VP5]]>, ir<1>, vp<%evl>
-; CHECK-NEXT: CLONE ir<%arrayidx> = getelementptr inbounds ir<%x>, vp<[[VP6]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%arrayidx> = getelementptr inbounds i64, ir<%x>, vp<[[VP6]]>
; CHECK-NEXT: vp<[[VP7:%[0-9]+]]> = vector-pointer inbounds i64, ir<%arrayidx>, ir<1>
; CHECK-NEXT: WIDEN ir<%load0> = vp.load vp<[[VP7]]>, vp<%evl>
-; CHECK-NEXT: CLONE ir<%arrayidx1> = getelementptr inbounds ir<%y>, vp<[[VP6]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%arrayidx1> = getelementptr inbounds i64, ir<%y>, vp<[[VP6]]>
; CHECK-NEXT: vp<[[VP8:%[0-9]+]]> = vector-pointer inbounds i64, ir<%arrayidx1>, ir<1>
; CHECK-NEXT: WIDEN ir<%load1> = vp.load vp<[[VP8]]>, vp<%evl>
; CHECK-NEXT: WIDEN ir<%mul> = mul nsw ir<%load0>, ir<%load1>
@@ -392,10 +392,10 @@ define i64 @print_mulacc_extended(ptr nocapture readonly %x, ptr nocapture reado
; CHECK-NEXT: EMIT-SCALAR vp<%avl> = phi [ ir<%n>, vector.ph ], [ vp<%avl.next>, vector.body ]
; CHECK-NEXT: EMIT-SCALAR vp<%evl> = EXPLICIT-VECTOR-LENGTH vp<%avl>
; CHECK-NEXT: vp<[[VP6:%[0-9]+]]> = SCALAR-STEPS vp<[[VP5]]>, ir<1>, vp<%evl>
-; CHECK-NEXT: CLONE ir<%arrayidx> = getelementptr inbounds ir<%x>, vp<[[VP6]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%arrayidx> = getelementptr inbounds i16, ir<%x>, vp<[[VP6]]>
; CHECK-NEXT: vp<[[VP7:%[0-9]+]]> = vector-pointer inbounds i16, ir<%arrayidx>, ir<1>
; CHECK-NEXT: WIDEN ir<%load0> = vp.load vp<[[VP7]]>, vp<%evl>
-; CHECK-NEXT: CLONE ir<%arrayidx1> = getelementptr inbounds ir<%y>, vp<[[VP6]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%arrayidx1> = getelementptr inbounds i16, ir<%y>, vp<[[VP6]]>
; CHECK-NEXT: vp<[[VP8:%[0-9]+]]> = vector-pointer inbounds i16, ir<%arrayidx1>, ir<1>
; CHECK-NEXT: WIDEN ir<%load1> = vp.load vp<[[VP8]]>, vp<%evl>
; CHECK-NEXT: WIDEN-CAST ir<%conv0> = sext ir<%load0> to i32
@@ -462,11 +462,11 @@ define i32 @print_mulacc_negated(ptr %a, ptr %b) vscale_range(2, 1024) {
; CHECK-NEXT: EMIT-SCALAR vp<%evl> = EXPLICIT-VECTOR-LENGTH vp<%avl>
; CHECK-NEXT: EMIT-SCALAR vp<[[VP6:%[0-9]+]]> = zext vp<%evl> to i64
; CHECK-NEXT: vp<[[VP7:%[0-9]+]]> = SCALAR-STEPS vp<[[VP5]]>, ir<1>, vp<[[VP6]]>
-; CHECK-NEXT: CLONE ir<%gep.a> = getelementptr ir<%a>, vp<[[VP7]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.a> = getelementptr i8, ir<%a>, vp<[[VP7]]>
; CHECK-NEXT: vp<[[VP8:%[0-9]+]]> = vector-pointer i8, ir<%gep.a>, ir<1>
; CHECK-NEXT: WIDEN ir<%load.a> = vp.load vp<[[VP8]]>, vp<%evl>
; CHECK-NEXT: WIDEN-CAST ir<%ext.a> = zext ir<%load.a> to i32
-; CHECK-NEXT: CLONE ir<%gep.b> = getelementptr ir<%b>, vp<[[VP7]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.b> = getelementptr i8, ir<%b>, vp<[[VP7]]>
; CHECK-NEXT: vp<[[VP9:%[0-9]+]]> = vector-pointer i8, ir<%gep.b>, ir<1>
; CHECK-NEXT: WIDEN ir<%load.b> = vp.load vp<[[VP9]]>, vp<%evl>
; CHECK-NEXT: WIDEN-CAST ir<%ext.b> = zext ir<%load.b> to i32
@@ -914,7 +914,7 @@ define i32 @print_umax_reduction(ptr %y) vscale_range(2, 1024) {
; CHECK-NEXT: EMIT-SCALAR vp<%evl> = EXPLICIT-VECTOR-LENGTH vp<%avl>
; CHECK-NEXT: EMIT-SCALAR vp<[[VP5:%[0-9]+]]> = zext vp<%evl> to i64
; CHECK-NEXT: vp<[[VP6:%[0-9]+]]> = SCALAR-STEPS vp<[[VP4]]>, ir<1>, vp<[[VP5]]>
-; CHECK-NEXT: CLONE ir<%gep> = getelementptr inbounds ir<%y>, vp<[[VP6]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr inbounds i32, ir<%y>, vp<[[VP6]]>
; CHECK-NEXT: vp<[[VP7:%[0-9]+]]> = vector-pointer inbounds i32, ir<%gep>, ir<1>
; CHECK-NEXT: WIDEN ir<%lv> = vp.load vp<[[VP7]]>, vp<%evl>
; CHECK-NEXT: WIDEN-INTRINSIC ir<%red.next> = call llvm.umax(ir<%lv>, ir<%red>)
diff --git a/llvm/test/Transforms/LoopVectorize/VPlan/RISCV/vplan-riscv-vector-reverse.ll b/llvm/test/Transforms/LoopVectorize/VPlan/RISCV/vplan-riscv-vector-reverse.ll
index edf4cda6a507f..79a9067b2112f 100644
--- a/llvm/test/Transforms/LoopVectorize/VPlan/RISCV/vplan-riscv-vector-reverse.ll
+++ b/llvm/test/Transforms/LoopVectorize/VPlan/RISCV/vplan-riscv-vector-reverse.ll
@@ -34,11 +34,11 @@ define void @vector_reverse_i64(ptr nocapture noundef writeonly %A, ptr nocaptur
; CHECK-NEXT: vp<[[VP7:%[0-9]+]]> = SCALAR-STEPS vp<[[VP6]]>, ir<-1>, vp<%evl>
; CHECK-NEXT: CLONE ir<%i.0> = add nsw vp<[[VP7]]>, ir<-1>
; CHECK-NEXT: EMIT-SCALAR ir<%idxprom> = zext ir<%i.0> to i64
-; CHECK-NEXT: CLONE ir<%arrayidx> = getelementptr inbounds ir<%B>, ir<%idxprom>
+; CHECK-NEXT: EMIT-SCALAR ir<%arrayidx> = getelementptr inbounds i32, ir<%B>, ir<%idxprom>
; CHECK-NEXT: vp<[[VP8:%[0-9]+]]> = vector-end-pointer i32, ir<%arrayidx>, vp<%evl>
; CHECK-NEXT: WIDEN ir<%0> = vp.load vp<[[VP8]]>, vp<%evl>
; CHECK-NEXT: WIDEN ir<%add9> = add ir<%0>, ir<1>
-; CHECK-NEXT: CLONE ir<%arrayidx3> = getelementptr inbounds ir<%A>, ir<%idxprom>
+; CHECK-NEXT: EMIT-SCALAR ir<%arrayidx3> = getelementptr inbounds i32, ir<%A>, ir<%idxprom>
; CHECK-NEXT: vp<[[VP9:%[0-9]+]]> = vector-end-pointer i32, ir<%arrayidx3>, vp<%evl>
; CHECK-NEXT: WIDEN vp.store vp<[[VP9]]>, ir<%add9>, vp<%evl>
; CHECK-NEXT: EMIT vp<%current.iteration.next> = add vp<%evl>, vp<[[VP5]]>
diff --git a/llvm/test/Transforms/LoopVectorize/VPlan/RISCV/vplan-vp-intrinsics-fixed-order-recurrence.ll b/llvm/test/Transforms/LoopVectorize/VPlan/RISCV/vplan-vp-intrinsics-fixed-order-recurrence.ll
index ed2dd44a484c8..dd52551622410 100644
--- a/llvm/test/Transforms/LoopVectorize/VPlan/RISCV/vplan-vp-intrinsics-fixed-order-recurrence.ll
+++ b/llvm/test/Transforms/LoopVectorize/VPlan/RISCV/vplan-vp-intrinsics-fixed-order-recurrence.ll
@@ -30,12 +30,12 @@ define void @first_order_recurrence(ptr noalias %A, ptr noalias %B, i64 %TC) {
; IF-EVL-NEXT: EMIT-SCALAR vp<[[EVL]]> = EXPLICIT-VECTOR-LENGTH vp<[[AVL]]>
; IF-EVL-NEXT: EMIT-SCALAR vp<[[CAST:%[0-9]+]]> = zext vp<[[EVL]]> to i64
; IF-EVL-NEXT: vp<[[ST:%[0-9]+]]> = SCALAR-STEPS vp<[[EVL_PHI]]>, ir<1>, vp<[[CAST]]>
-; IF-EVL-NEXT: CLONE ir<[[GEP1:%.+]]> = getelementptr inbounds nuw ir<%A>, vp<[[ST]]
+; IF-EVL-NEXT: EMIT-SCALAR ir<[[GEP1:%.+]]> = getelementptr inbounds nuw i32, ir<%A>, vp<[[ST]]
; IF-EVL-NEXT: vp<[[PTR1:%[0-9]+]]> = vector-pointer inbounds nuw i32, ir<[[GEP1]]>
; IF-EVL-NEXT: WIDEN ir<[[LD]]> = vp.load vp<[[PTR1]]>, vp<[[EVL]]>
; IF-EVL-NEXT: WIDEN-INTRINSIC vp<[[SPLICE:%[0-9]+]]> = call llvm.experimental.vp.splice(ir<[[FOR_PHI]]>, ir<[[LD]]>, ir<-1>, ir<true>, vp<[[PREV_EVL]]>, vp<[[EVL]]>)
; IF-EVL-NEXT: WIDEN ir<[[ADD:%.+]]> = add nsw vp<[[SPLICE]]>, ir<[[LD]]>
-; IF-EVL-NEXT: CLONE ir<[[GEP2:%.+]]> = getelementptr inbounds nuw ir<%B>, vp<[[ST]]>
+; IF-EVL-NEXT: EMIT-SCALAR ir<[[GEP2:%.+]]> = getelementptr inbounds nuw i32, ir<%B>, vp<[[ST]]>
; IF-EVL-NEXT: vp<[[PTR2:%[0-9]+]]> = vector-pointer inbounds nuw i32, ir<[[GEP2]]>
; IF-EVL-NEXT: WIDEN vp.store vp<[[PTR2]]>, ir<[[ADD]]>, vp<[[EVL]]>
; IF-EVL-NEXT: EMIT-SCALAR vp<[[CAST2:%[0-9]+]]> = zext vp<[[EVL]]> to i64
diff --git a/llvm/test/Transforms/LoopVectorize/VPlan/RISCV/vplan-vp-intrinsics-reduction.ll b/llvm/test/Transforms/LoopVectorize/VPlan/RISCV/vplan-vp-intrinsics-reduction.ll
index 4b84e9bcb687f..82509e7f82b3a 100644
--- a/llvm/test/Transforms/LoopVectorize/VPlan/RISCV/vplan-vp-intrinsics-reduction.ll
+++ b/llvm/test/Transforms/LoopVectorize/VPlan/RISCV/vplan-vp-intrinsics-reduction.ll
@@ -44,7 +44,7 @@ define i32 @reduction(ptr %a, i64 %n, i32 %start) {
; IF-EVL-NEXT: vector.body:
; IF-EVL-NEXT: WIDEN-REDUCTION-PHI ir<%rdx> = phi (add) vp<[[VP3]]>, ir<%add>
; IF-EVL-NEXT: vp<[[VP5:%[0-9]+]]> = SCALAR-STEPS vp<[[VP4]]>, ir<1>, vp<[[VP0]]>
-; IF-EVL-NEXT: CLONE ir<%arrayidx> = getelementptr inbounds ir<%a>, vp<[[VP5]]>
+; IF-EVL-NEXT: EMIT-SCALAR ir<%arrayidx> = getelementptr inbounds i32, ir<%a>, vp<[[VP5]]>
; IF-EVL-NEXT: CLONE ir<%0> = load ir<%arrayidx>
; IF-EVL-NEXT: CLONE ir<%add> = add ir<%0>, ir<%rdx>
; IF-EVL-NEXT: EMIT vp<%index.next> = add nuw vp<[[VP4]]>, vp<[[VP1]]>
@@ -88,7 +88,7 @@ define i32 @reduction(ptr %a, i64 %n, i32 %start) {
; IF-EVL-OUTLOOP-NEXT: EMIT-SCALAR vp<%evl> = EXPLICIT-VECTOR-LENGTH vp<%avl>
; IF-EVL-OUTLOOP-NEXT: EMIT-SCALAR vp<[[VP6:%[0-9]+]]> = zext vp<%evl> to i64
; IF-EVL-OUTLOOP-NEXT: vp<[[VP7:%[0-9]+]]> = SCALAR-STEPS vp<[[VP5]]>, ir<1>, vp<[[VP6]]>
-; IF-EVL-OUTLOOP-NEXT: CLONE ir<%arrayidx> = getelementptr inbounds ir<%a>, vp<[[VP7]]>
+; IF-EVL-OUTLOOP-NEXT: EMIT-SCALAR ir<%arrayidx> = getelementptr inbounds i32, ir<%a>, vp<[[VP7]]>
; IF-EVL-OUTLOOP-NEXT: vp<[[VP8:%[0-9]+]]> = vector-pointer inbounds i32, ir<%arrayidx>, ir<1>
; IF-EVL-OUTLOOP-NEXT: WIDEN ir<%0> = vp.load vp<[[VP8]]>, vp<%evl>
; IF-EVL-OUTLOOP-NEXT: WIDEN ir<%add> = add ir<%0>, ir<%rdx>
@@ -135,7 +135,7 @@ define i32 @reduction(ptr %a, i64 %n, i32 %start) {
; IF-EVL-INLOOP-NEXT: EMIT-SCALAR vp<%evl> = EXPLICIT-VECTOR-LENGTH vp<%avl>
; IF-EVL-INLOOP-NEXT: EMIT-SCALAR vp<[[VP6:%[0-9]+]]> = zext vp<%evl> to i64
; IF-EVL-INLOOP-NEXT: vp<[[VP7:%[0-9]+]]> = SCALAR-STEPS vp<[[VP5]]>, ir<1>, vp<[[VP6]]>
-; IF-EVL-INLOOP-NEXT: CLONE ir<%arrayidx> = getelementptr inbounds ir<%a>, vp<[[VP7]]>
+; IF-EVL-INLOOP-NEXT: EMIT-SCALAR ir<%arrayidx> = getelementptr inbounds i32, ir<%a>, vp<[[VP7]]>
; IF-EVL-INLOOP-NEXT: vp<[[VP8:%[0-9]+]]> = vector-pointer inbounds i32, ir<%arrayidx>, ir<1>
; IF-EVL-INLOOP-NEXT: WIDEN ir<%0> = vp.load vp<[[VP8]]>, vp<%evl>
; IF-EVL-INLOOP-NEXT: REDUCE ir<%add> = ir<%rdx> + vp.reduce.add (ir<%0>, vp<%evl>)
@@ -178,7 +178,7 @@ define i32 @reduction(ptr %a, i64 %n, i32 %start) {
; NO-VP-OUTLOOP-NEXT: vector.body:
; NO-VP-OUTLOOP-NEXT: WIDEN-REDUCTION-PHI ir<%rdx> = phi (add) vp<[[VP3]]>, ir<%add>
; NO-VP-OUTLOOP-NEXT: vp<[[VP5:%[0-9]+]]> = SCALAR-STEPS vp<[[VP4]]>, ir<1>, vp<[[VP0]]>
-; NO-VP-OUTLOOP-NEXT: CLONE ir<%arrayidx> = getelementptr inbounds ir<%a>, vp<[[VP5]]>
+; NO-VP-OUTLOOP-NEXT: EMIT-SCALAR ir<%arrayidx> = getelementptr inbounds i32, ir<%a>, vp<[[VP5]]>
; NO-VP-OUTLOOP-NEXT: vp<[[VP6:%[0-9]+]]> = vector-pointer inbounds i32, ir<%arrayidx>, ir<1>
; NO-VP-OUTLOOP-NEXT: WIDEN ir<%0> = load vp<[[VP6]]>
; NO-VP-OUTLOOP-NEXT: WIDEN ir<%add> = add ir<%0>, ir<%rdx>
@@ -220,7 +220,7 @@ define i32 @reduction(ptr %a, i64 %n, i32 %start) {
; NO-VP-INLOOP-NEXT: vector.body:
; NO-VP-INLOOP-NEXT: WIDEN-REDUCTION-PHI ir<%rdx> = phi (add) vp<[[VP3]]>, ir<%add>
; NO-VP-INLOOP-NEXT: vp<[[VP5:%[0-9]+]]> = SCALAR-STEPS vp<[[VP4]]>, ir<1>, vp<[[VP0]]>
-; NO-VP-INLOOP-NEXT: CLONE ir<%arrayidx> = getelementptr inbounds ir<%a>, vp<[[VP5]]>
+; NO-VP-INLOOP-NEXT: EMIT-SCALAR ir<%arrayidx> = getelementptr inbounds i32, ir<%a>, vp<[[VP5]]>
; NO-VP-INLOOP-NEXT: vp<[[VP6:%[0-9]+]]> = vector-pointer inbounds i32, ir<%arrayidx>, ir<1>
; NO-VP-INLOOP-NEXT: WIDEN ir<%0> = load vp<[[VP6]]>
; NO-VP-INLOOP-NEXT: REDUCE ir<%add> = ir<%rdx> + reduce.add (ir<%0>)
diff --git a/llvm/test/Transforms/LoopVectorize/VPlan/RISCV/vplan-vp-intrinsics.ll b/llvm/test/Transforms/LoopVectorize/VPlan/RISCV/vplan-vp-intrinsics.ll
index e2ab868cd3366..e07b429dd5890 100644
--- a/llvm/test/Transforms/LoopVectorize/VPlan/RISCV/vplan-vp-intrinsics.ll
+++ b/llvm/test/Transforms/LoopVectorize/VPlan/RISCV/vplan-vp-intrinsics.ll
@@ -31,14 +31,14 @@ define void @foo(ptr noalias %a, ptr noalias %b, ptr noalias %c, i64 %N) {
; IF-EVL-NEXT: EMIT-SCALAR vp<%evl> = EXPLICIT-VECTOR-LENGTH vp<%avl>
; IF-EVL-NEXT: EMIT-SCALAR vp<[[VP5:%[0-9]+]]> = zext vp<%evl> to i64
; IF-EVL-NEXT: vp<[[VP6:%[0-9]+]]> = SCALAR-STEPS vp<[[VP4]]>, ir<1>, vp<[[VP5]]>
-; IF-EVL-NEXT: CLONE ir<%arrayidx> = getelementptr inbounds ir<%b>, vp<[[VP6]]>
+; IF-EVL-NEXT: EMIT-SCALAR ir<%arrayidx> = getelementptr inbounds i32, ir<%b>, vp<[[VP6]]>
; IF-EVL-NEXT: vp<[[VP7:%[0-9]+]]> = vector-pointer inbounds i32, ir<%arrayidx>, ir<1>
; IF-EVL-NEXT: WIDEN ir<%0> = vp.load vp<[[VP7]]>, vp<%evl>
-; IF-EVL-NEXT: CLONE ir<%arrayidx2> = getelementptr inbounds ir<%c>, vp<[[VP6]]>
+; IF-EVL-NEXT: EMIT-SCALAR ir<%arrayidx2> = getelementptr inbounds i32, ir<%c>, vp<[[VP6]]>
; IF-EVL-NEXT: vp<[[VP8:%[0-9]+]]> = vector-pointer inbounds i32, ir<%arrayidx2>, ir<1>
; IF-EVL-NEXT: WIDEN ir<%1> = vp.load vp<[[VP8]]>, vp<%evl>
; IF-EVL-NEXT: WIDEN ir<%add> = add nsw ir<%1>, ir<%0>
-; IF-EVL-NEXT: CLONE ir<%arrayidx4> = getelementptr inbounds ir<%a>, vp<[[VP6]]>
+; IF-EVL-NEXT: EMIT-SCALAR ir<%arrayidx4> = getelementptr inbounds i32, ir<%a>, vp<[[VP6]]>
; IF-EVL-NEXT: vp<[[VP9:%[0-9]+]]> = vector-pointer inbounds i32, ir<%arrayidx4>, ir<1>
; IF-EVL-NEXT: WIDEN vp.store vp<[[VP9]]>, ir<%add>, vp<%evl>
; IF-EVL-NEXT: EMIT-SCALAR vp<[[VP10:%[0-9]+]]> = zext vp<%evl> to i64
@@ -68,14 +68,14 @@ define void @foo(ptr noalias %a, ptr noalias %b, ptr noalias %c, i64 %N) {
; NO-VP-EMPTY:
; NO-VP-NEXT: vector.body:
; NO-VP-NEXT: vp<[[VP4:%[0-9]+]]> = SCALAR-STEPS vp<[[VP3]]>, ir<1>, vp<[[VP0]]>
-; NO-VP-NEXT: CLONE ir<%arrayidx> = getelementptr inbounds ir<%b>, vp<[[VP4]]>
+; NO-VP-NEXT: EMIT-SCALAR ir<%arrayidx> = getelementptr inbounds i32, ir<%b>, vp<[[VP4]]>
; NO-VP-NEXT: vp<[[VP5:%[0-9]+]]> = vector-pointer inbounds i32, ir<%arrayidx>, ir<1>
; NO-VP-NEXT: WIDEN ir<%0> = load vp<[[VP5]]>
-; NO-VP-NEXT: CLONE ir<%arrayidx2> = getelementptr inbounds ir<%c>, vp<[[VP4]]>
+; NO-VP-NEXT: EMIT-SCALAR ir<%arrayidx2> = getelementptr inbounds i32, ir<%c>, vp<[[VP4]]>
; NO-VP-NEXT: vp<[[VP6:%[0-9]+]]> = vector-pointer inbounds i32, ir<%arrayidx2>, ir<1>
; NO-VP-NEXT: WIDEN ir<%1> = load vp<[[VP6]]>
; NO-VP-NEXT: WIDEN ir<%add> = add nsw ir<%1>, ir<%0>
-; NO-VP-NEXT: CLONE ir<%arrayidx4> = getelementptr inbounds ir<%a>, vp<[[VP4]]>
+; NO-VP-NEXT: EMIT-SCALAR ir<%arrayidx4> = getelementptr inbounds i32, ir<%a>, vp<[[VP4]]>
; NO-VP-NEXT: vp<[[VP7:%[0-9]+]]> = vector-pointer inbounds i32, ir<%arrayidx4>, ir<1>
; NO-VP-NEXT: WIDEN store vp<[[VP7]]>, ir<%add>
; NO-VP-NEXT: EMIT vp<%index.next> = add nuw vp<[[VP3]]>, vp<[[VP1]]>
@@ -125,11 +125,11 @@ define void @safe_dep(ptr %p) {
; IF-EVL-EMPTY:
; IF-EVL-NEXT: vector.body:
; IF-EVL-NEXT: vp<[[VP4:%[0-9]+]]> = SCALAR-STEPS vp<[[VP3]]>, ir<1>, vp<[[VP0]]>
-; IF-EVL-NEXT: CLONE ir<%a1> = getelementptr ir<%p>, vp<[[VP4]]>
+; IF-EVL-NEXT: EMIT-SCALAR ir<%a1> = getelementptr i64, ir<%p>, vp<[[VP4]]>
; IF-EVL-NEXT: vp<[[VP5:%[0-9]+]]> = vector-pointer i64, ir<%a1>, ir<1>
; IF-EVL-NEXT: WIDEN ir<%v> = load vp<[[VP5]]>
; IF-EVL-NEXT: CLONE ir<%offset> = add vp<[[VP4]]>, ir<100>
-; IF-EVL-NEXT: CLONE ir<%a2> = getelementptr ir<%p>, ir<%offset>
+; IF-EVL-NEXT: EMIT-SCALAR ir<%a2> = getelementptr i64, ir<%p>, ir<%offset>
; IF-EVL-NEXT: vp<[[VP6:%[0-9]+]]> = vector-pointer i64, ir<%a2>, ir<1>
; IF-EVL-NEXT: WIDEN store vp<[[VP6]]>, ir<%v>
; IF-EVL-NEXT: EMIT vp<%index.next> = add nuw vp<[[VP3]]>, vp<[[VP1]]>
@@ -156,11 +156,11 @@ define void @safe_dep(ptr %p) {
; NO-VP-EMPTY:
; NO-VP-NEXT: vector.body:
; NO-VP-NEXT: vp<[[VP4:%[0-9]+]]> = SCALAR-STEPS vp<[[VP3]]>, ir<1>, vp<[[VP0]]>
-; NO-VP-NEXT: CLONE ir<%a1> = getelementptr ir<%p>, vp<[[VP4]]>
+; NO-VP-NEXT: EMIT-SCALAR ir<%a1> = getelementptr i64, ir<%p>, vp<[[VP4]]>
; NO-VP-NEXT: vp<[[VP5:%[0-9]+]]> = vector-pointer i64, ir<%a1>, ir<1>
; NO-VP-NEXT: WIDEN ir<%v> = load vp<[[VP5]]>
; NO-VP-NEXT: CLONE ir<%offset> = add vp<[[VP4]]>, ir<100>
-; NO-VP-NEXT: CLONE ir<%a2> = getelementptr ir<%p>, ir<%offset>
+; NO-VP-NEXT: EMIT-SCALAR ir<%a2> = getelementptr i64, ir<%p>, ir<%offset>
; NO-VP-NEXT: vp<[[VP6:%[0-9]+]]> = vector-pointer i64, ir<%a2>, ir<1>
; NO-VP-NEXT: WIDEN store vp<[[VP6]]>, ir<%v>
; NO-VP-NEXT: EMIT vp<%index.next> = add nuw vp<[[VP3]]>, vp<[[VP1]]>
diff --git a/llvm/test/Transforms/LoopVectorize/VPlan/X86/cse-loads-gather.ll b/llvm/test/Transforms/LoopVectorize/VPlan/X86/cse-loads-gather.ll
index 1560305ba90ce..9eab478396ed5 100644
--- a/llvm/test/Transforms/LoopVectorize/VPlan/X86/cse-loads-gather.ll
+++ b/llvm/test/Transforms/LoopVectorize/VPlan/X86/cse-loads-gather.ll
@@ -20,12 +20,12 @@ define void @dup_gather(ptr noalias %a, ptr noalias %b, ptr noalias %out) {
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: EMIT-SCALAR vp<%index> = phi [ ir<0>, vector.ph ], [ vp<%index.next>, vector.body ]
-; CHECK-NEXT: CLONE ir<%gep.b> = getelementptr inbounds ir<%b>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.b> = getelementptr inbounds i64, ir<%b>, vp<%index>
; CHECK-NEXT: WIDEN ir<%idx> = load ir<%gep.b>
; CHECK-NEXT: WIDEN-GEP ir<%gep.a> = getelementptr inbounds ir<%a>, ir<%idx>
; CHECK-NEXT: WIDEN ir<%x> = load ir<%gep.a>
; CHECK-NEXT: WIDEN ir<%sum> = add ir<%x>, ir<%x>
-; CHECK-NEXT: CLONE ir<%gep.o> = getelementptr inbounds ir<%out>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.o> = getelementptr inbounds i32, ir<%out>, vp<%index>
; CHECK-NEXT: WIDEN store ir<%gep.o>, ir<%sum>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<%index>, ir<4>
; CHECK-NEXT: EMIT vp<[[VP1:%[0-9]+]]> = icmp eq vp<%index.next>, ir<1024>
@@ -67,16 +67,16 @@ define void @dup_gather_diff_index(ptr noalias %a, ptr noalias %b, ptr noalias %
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: EMIT-SCALAR vp<%index> = phi [ ir<0>, vector.ph ], [ vp<%index.next>, vector.body ]
-; CHECK-NEXT: CLONE ir<%gep.b> = getelementptr inbounds ir<%b>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.b> = getelementptr inbounds i64, ir<%b>, vp<%index>
; CHECK-NEXT: WIDEN ir<%idx1> = load ir<%gep.b>
-; CHECK-NEXT: CLONE ir<%gep.c> = getelementptr inbounds ir<%c>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.c> = getelementptr inbounds i64, ir<%c>, vp<%index>
; CHECK-NEXT: WIDEN ir<%idx2> = load ir<%gep.c>
; CHECK-NEXT: WIDEN-GEP ir<%gep.a1> = getelementptr inbounds ir<%a>, ir<%idx1>
; CHECK-NEXT: WIDEN-GEP ir<%gep.a2> = getelementptr inbounds ir<%a>, ir<%idx2>
; CHECK-NEXT: WIDEN ir<%x> = load ir<%gep.a1>
; CHECK-NEXT: WIDEN ir<%y> = load ir<%gep.a2>
; CHECK-NEXT: WIDEN ir<%sum> = add ir<%x>, ir<%y>
-; CHECK-NEXT: CLONE ir<%gep.o> = getelementptr inbounds ir<%out>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.o> = getelementptr inbounds i32, ir<%out>, vp<%index>
; CHECK-NEXT: WIDEN store ir<%gep.o>, ir<%sum>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<%index>, ir<4>
; CHECK-NEXT: EMIT vp<[[VP1:%[0-9]+]]> = icmp eq vp<%index.next>, ir<1024>
diff --git a/llvm/test/Transforms/LoopVectorize/VPlan/X86/scalarize-wide-load-for-address-use.ll b/llvm/test/Transforms/LoopVectorize/VPlan/X86/scalarize-wide-load-for-address-use.ll
index 9a614e99505dd..9f179f160b50a 100644
--- a/llvm/test/Transforms/LoopVectorize/VPlan/X86/scalarize-wide-load-for-address-use.ll
+++ b/llvm/test/Transforms/LoopVectorize/VPlan/X86/scalarize-wide-load-for-address-use.ll
@@ -28,7 +28,7 @@ define void @reverse_unmasked_load_feeds_address(ptr noalias %src, i64 %n) {
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION ir<%n.minus.1>, ir<-1>, vp<[[VP0]]>
-; CHECK-NEXT: EMIT ir<%gep> = getelementptr ir<%src>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr double, ir<%src>, ir<%iv>
; CHECK-NEXT: REPLICATE ir<%val> = load ir<%gep>
; CHECK-NEXT: EMIT ir<%cmp> = fcmp oeq ir<%val>, ir<0.000000e+00>
; CHECK-NEXT: EMIT ir<%ptr.sel> = select ir<%cmp>, ir<@tbl.a>, ir<@tbl.b>
@@ -83,13 +83,13 @@ define void @mixed_address_and_vector_uses(ptr noalias %src, ptr noalias %dst, i
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION ir<0>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: EMIT ir<%gep.src> = getelementptr ir<%src>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.src> = getelementptr double, ir<%src>, ir<%iv>
; CHECK-NEXT: REPLICATE ir<%val> = load ir<%gep.src>
; CHECK-NEXT: EMIT ir<%cmp> = fcmp oeq ir<%val>, ir<0.000000e+00>
; CHECK-NEXT: EMIT ir<%ptr.sel> = select ir<%cmp>, ir<@tbl.a>, ir<@tbl.b>
; CHECK-NEXT: REPLICATE store ir<1.000000e+00>, ir<%ptr.sel>
; CHECK-NEXT: EMIT ir<%doubled> = fmul ir<%val>, ir<2.000000e+00>
-; CHECK-NEXT: EMIT ir<%gep.dst> = getelementptr ir<%dst>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.dst> = getelementptr double, ir<%dst>, ir<%iv>
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = vector-pointer double, ir<%gep.dst>, ir<1>
; CHECK-NEXT: WIDEN store vp<[[VP4]]>, ir<%doubled>
; CHECK-NEXT: EMIT ir<%iv.next> = add ir<%iv>, ir<1>
@@ -144,9 +144,9 @@ define void @interleave_member_feeds_address(ptr noalias %arr, i64 %n) {
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION ir<0>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: EMIT ir<%gep.p> = getelementptr ir<%arr>, ir<%iv>, ir<0>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.p> = getelementptr %struct.pair = type { ptr, double }, ir<%arr>, ir<%iv>, ir<0>
; CHECK-NEXT: REPLICATE ir<%p> = load ir<%gep.p>
-; CHECK-NEXT: EMIT ir<%gep.v> = getelementptr ir<%arr>, ir<%iv>, ir<1>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.v> = getelementptr %struct.pair = type { ptr, double }, ir<%arr>, ir<%iv>, ir<1>
; CHECK-NEXT: REPLICATE ir<%v> = load ir<%gep.v>
; CHECK-NEXT: REPLICATE store ir<%v>, ir<%p>
; CHECK-NEXT: EMIT ir<%iv.next> = add ir<%iv>, ir<1>
@@ -198,7 +198,7 @@ define void @load_feeds_mask_reaching_address(ptr noalias %src, ptr noalias %dst
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION ir<0>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: EMIT ir<%gep> = getelementptr ir<%src>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr double, ir<%src>, ir<%iv>
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = vector-pointer double, ir<%gep>, ir<1>
; CHECK-NEXT: WIDEN ir<%val> = load vp<[[VP4]]>
; CHECK-NEXT: EMIT ir<%cmp> = fcmp ole ir<0.000000e+00>, ir<%val>
@@ -206,7 +206,7 @@ define void @load_feeds_mask_reaching_address(ptr noalias %src, ptr noalias %dst
; CHECK-EMPTY:
; CHECK-NEXT: then:
; CHECK-NEXT: EMIT ir<%idx> = add ir<%iv>, ir<1>, ir<%cmp>
-; CHECK-NEXT: EMIT ir<%gep2> = getelementptr ir<@tbl.a>, ir<%idx>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep2> = getelementptr double, ir<@tbl.a>, ir<%idx>
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = vector-pointer double, ir<%gep2>, ir<1>
; CHECK-NEXT: WIDEN ir<%val2> = load vp<[[VP5]]>, ir<%cmp>
; CHECK-NEXT: REPLICATE store ir<%val2>, ir<%dst>, ir<%cmp>
@@ -269,11 +269,11 @@ define void @symbolic_stride_versioned_to_one(ptr noalias %src, ptr noalias %dst
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION ir<0>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: EMIT ir<%gep.src> = getelementptr ir<%src>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.src> = getelementptr double, ir<%src>, ir<%iv>
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = vector-pointer double, ir<%gep.src>, ir<1>
; CHECK-NEXT: WIDEN ir<%val> = load vp<[[VP4]]>
; CHECK-NEXT: EMIT ir<%doubled> = fmul ir<%val>, ir<2.000000e+00>
-; CHECK-NEXT: EMIT ir<%gep.dst> = getelementptr ir<%dst>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.dst> = getelementptr double, ir<%dst>, ir<%iv>
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = vector-pointer double, ir<%gep.dst>, ir<1>
; CHECK-NEXT: WIDEN store vp<[[VP5]]>, ir<%doubled>
; CHECK-NEXT: EMIT ir<%iv.next> = add ir<%iv>, ir<1>
diff --git a/llvm/test/Transforms/LoopVectorize/VPlan/X86/vplan-vp-intrinsics.ll b/llvm/test/Transforms/LoopVectorize/VPlan/X86/vplan-vp-intrinsics.ll
index 4a777d20166cd..00c0364a40e18 100644
--- a/llvm/test/Transforms/LoopVectorize/VPlan/X86/vplan-vp-intrinsics.ll
+++ b/llvm/test/Transforms/LoopVectorize/VPlan/X86/vplan-vp-intrinsics.ll
@@ -30,14 +30,14 @@ define void @foo(ptr noalias %a, ptr noalias %b, ptr noalias %c, i64 %N) {
; IF-EVL-NEXT: EMIT vp<[[VP6:%[0-9]+]]> = WIDEN-CANONICAL-INDUCTION nuw vp<[[VP4]]>
; IF-EVL-NEXT: EMIT vp<[[VP7:%[0-9]+]]> = icmp ule vp<[[VP6]]>, vp<[[VP3]]>
; IF-EVL-NEXT: vp<[[VP8:%[0-9]+]]> = SCALAR-STEPS vp<[[VP4]]>, ir<1>, vp<[[VP0]]>
-; IF-EVL-NEXT: CLONE ir<%arrayidx> = getelementptr inbounds ir<%b>, vp<[[VP8]]>
+; IF-EVL-NEXT: EMIT-SCALAR ir<%arrayidx> = getelementptr inbounds i32, ir<%b>, vp<[[VP8]]>
; IF-EVL-NEXT: vp<[[VP9:%[0-9]+]]> = vector-pointer inbounds i32, ir<%arrayidx>, ir<1>
; IF-EVL-NEXT: WIDEN ir<%0> = load vp<[[VP9]]>, vp<[[VP7]]>
-; IF-EVL-NEXT: CLONE ir<%arrayidx2> = getelementptr inbounds ir<%c>, vp<[[VP8]]>
+; IF-EVL-NEXT: EMIT-SCALAR ir<%arrayidx2> = getelementptr inbounds i32, ir<%c>, vp<[[VP8]]>
; IF-EVL-NEXT: vp<[[VP10:%[0-9]+]]> = vector-pointer inbounds i32, ir<%arrayidx2>, ir<1>
; IF-EVL-NEXT: WIDEN ir<%1> = load vp<[[VP10]]>, vp<[[VP7]]>
; IF-EVL-NEXT: WIDEN ir<%add> = add nsw ir<%1>, ir<%0>
-; IF-EVL-NEXT: CLONE ir<%arrayidx4> = getelementptr inbounds ir<%a>, vp<[[VP8]]>
+; IF-EVL-NEXT: EMIT-SCALAR ir<%arrayidx4> = getelementptr inbounds i32, ir<%a>, vp<[[VP8]]>
; IF-EVL-NEXT: vp<[[VP11:%[0-9]+]]> = vector-pointer inbounds i32, ir<%arrayidx4>, ir<1>
; IF-EVL-NEXT: WIDEN store vp<[[VP11]]>, ir<%add>, vp<[[VP7]]>
; IF-EVL-NEXT: EMIT vp<%index.next> = add vp<[[VP4]]>, vp<[[VP1]]>
@@ -64,14 +64,14 @@ define void @foo(ptr noalias %a, ptr noalias %b, ptr noalias %c, i64 %N) {
; NO-VP-EMPTY:
; NO-VP-NEXT: vector.body:
; NO-VP-NEXT: vp<[[VP4:%[0-9]+]]> = SCALAR-STEPS vp<[[VP3]]>, ir<1>, vp<[[VP0]]>
-; NO-VP-NEXT: CLONE ir<%arrayidx> = getelementptr inbounds ir<%b>, vp<[[VP4]]>
+; NO-VP-NEXT: EMIT-SCALAR ir<%arrayidx> = getelementptr inbounds i32, ir<%b>, vp<[[VP4]]>
; NO-VP-NEXT: vp<[[VP5:%[0-9]+]]> = vector-pointer inbounds i32, ir<%arrayidx>, ir<1>
; NO-VP-NEXT: WIDEN ir<%0> = load vp<[[VP5]]>
-; NO-VP-NEXT: CLONE ir<%arrayidx2> = getelementptr inbounds ir<%c>, vp<[[VP4]]>
+; NO-VP-NEXT: EMIT-SCALAR ir<%arrayidx2> = getelementptr inbounds i32, ir<%c>, vp<[[VP4]]>
; NO-VP-NEXT: vp<[[VP6:%[0-9]+]]> = vector-pointer inbounds i32, ir<%arrayidx2>, ir<1>
; NO-VP-NEXT: WIDEN ir<%1> = load vp<[[VP6]]>
; NO-VP-NEXT: WIDEN ir<%add> = add nsw ir<%1>, ir<%0>
-; NO-VP-NEXT: CLONE ir<%arrayidx4> = getelementptr inbounds ir<%a>, vp<[[VP4]]>
+; NO-VP-NEXT: EMIT-SCALAR ir<%arrayidx4> = getelementptr inbounds i32, ir<%a>, vp<[[VP4]]>
; NO-VP-NEXT: vp<[[VP7:%[0-9]+]]> = vector-pointer inbounds i32, ir<%arrayidx4>, ir<1>
; NO-VP-NEXT: WIDEN store vp<[[VP7]]>, ir<%add>
; NO-VP-NEXT: EMIT vp<%index.next> = add nuw vp<[[VP3]]>, vp<[[VP1]]>
diff --git a/llvm/test/Transforms/LoopVectorize/VPlan/conditional-scalar-assignment-vplan.ll b/llvm/test/Transforms/LoopVectorize/VPlan/conditional-scalar-assignment-vplan.ll
index 5e31279f2a013..a2bdf71ab371a 100644
--- a/llvm/test/Transforms/LoopVectorize/VPlan/conditional-scalar-assignment-vplan.ll
+++ b/llvm/test/Transforms/LoopVectorize/VPlan/conditional-scalar-assignment-vplan.ll
@@ -36,7 +36,7 @@ define i32 @simple_csa_int_select(i64 %N, ptr %data, i32 %a) {
; CHECK-NEXT: WIDEN-REDUCTION-PHI ir<%data.phi> = phi (find-last) ir<-1>, vp<[[VP9:%[0-9]+]]>
; CHECK-NEXT: WIDEN-PHI vp<[[VP4:%[0-9]+]]> = phi [ ir<false>, vector.ph ], [ vp<[[VP8:%[0-9]+]]>, vector.body ]
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = SCALAR-STEPS vp<[[VP3]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%ld.addr> = getelementptr inbounds ir<%data>, vp<[[VP5]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%ld.addr> = getelementptr inbounds i32, ir<%data>, vp<[[VP5]]>
; CHECK-NEXT: vp<[[VP6:%[0-9]+]]> = vector-pointer inbounds i32, ir<%ld.addr>, ir<1>
; CHECK-NEXT: WIDEN ir<%ld> = load vp<[[VP6]]>
; CHECK-NEXT: WIDEN ir<%select.cmp> = icmp slt ir<%a>, ir<%ld>
@@ -98,7 +98,7 @@ define i32 @simple_csa_int_select(i64 %N, ptr %data, i32 %a) {
; CHECK-TF-NEXT: EMIT vp<[[VP7:%[0-9]+]]> = WIDEN-CANONICAL-INDUCTION nuw vp<[[VP4]]>
; CHECK-TF-NEXT: EMIT vp<[[VP8:%[0-9]+]]> = icmp ule vp<[[VP7]]>, vp<[[VP3]]>
; CHECK-TF-NEXT: vp<[[VP9:%[0-9]+]]> = SCALAR-STEPS vp<[[VP4]]>, ir<1>, vp<[[VP0]]>
-; CHECK-TF-NEXT: CLONE ir<%ld.addr> = getelementptr inbounds ir<%data>, vp<[[VP9]]>
+; CHECK-TF-NEXT: EMIT-SCALAR ir<%ld.addr> = getelementptr inbounds i32, ir<%data>, vp<[[VP9]]>
; CHECK-TF-NEXT: vp<[[VP10:%[0-9]+]]> = vector-pointer inbounds i32, ir<%ld.addr>, ir<1>
; CHECK-TF-NEXT: WIDEN ir<%ld> = load vp<[[VP10]]>, vp<[[VP8]]>
; CHECK-TF-NEXT: WIDEN ir<%select.cmp> = icmp slt ir<%a>, ir<%ld>
@@ -182,7 +182,7 @@ define i32 @simple_csa_int_load(ptr noalias %a, ptr noalias %b, i32 %default_val
; CHECK-NEXT: WIDEN-REDUCTION-PHI ir<%data.phi> = phi (find-last) ir<%default_val>, vp<[[VP11:%[0-9]+]]>
; CHECK-NEXT: WIDEN-PHI vp<[[VP4:%[0-9]+]]> = phi [ ir<false>, vector.ph ], [ vp<[[VP10:%[0-9]+]]>, if.then.0 ]
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = SCALAR-STEPS vp<[[VP3]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%a.addr> = getelementptr inbounds nuw ir<%a>, vp<[[VP5]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%a.addr> = getelementptr inbounds nuw i32, ir<%a>, vp<[[VP5]]>
; CHECK-NEXT: vp<[[VP6:%[0-9]+]]> = vector-pointer inbounds nuw i32, ir<%a.addr>, ir<1>
; CHECK-NEXT: WIDEN ir<%ld.a> = load vp<[[VP6]]>
; CHECK-NEXT: WIDEN ir<%if.cond> = icmp sgt ir<%ld.a>, ir<%threshold>
@@ -261,12 +261,12 @@ define i32 @simple_csa_int_load(ptr noalias %a, ptr noalias %b, i32 %default_val
; CHECK-TF-NEXT: EMIT vp<[[VP7:%[0-9]+]]> = WIDEN-CANONICAL-INDUCTION nuw vp<[[VP4]]>
; CHECK-TF-NEXT: EMIT vp<[[VP8:%[0-9]+]]> = icmp ule vp<[[VP7]]>, vp<[[VP3]]>
; CHECK-TF-NEXT: vp<[[VP9:%[0-9]+]]> = SCALAR-STEPS vp<[[VP4]]>, ir<1>, vp<[[VP0]]>
-; CHECK-TF-NEXT: CLONE ir<%a.addr> = getelementptr inbounds nuw ir<%a>, vp<[[VP9]]>
+; CHECK-TF-NEXT: EMIT-SCALAR ir<%a.addr> = getelementptr inbounds nuw i32, ir<%a>, vp<[[VP9]]>
; CHECK-TF-NEXT: vp<[[VP10:%[0-9]+]]> = vector-pointer inbounds nuw i32, ir<%a.addr>, ir<1>
; CHECK-TF-NEXT: WIDEN ir<%ld.a> = load vp<[[VP10]]>, vp<[[VP8]]>
; CHECK-TF-NEXT: WIDEN ir<%if.cond> = icmp sgt ir<%ld.a>, ir<%threshold>
; CHECK-TF-NEXT: EMIT vp<[[VP11:%[0-9]+]]> = logical-and vp<[[VP8]]>, ir<%if.cond>
-; CHECK-TF-NEXT: CLONE ir<%b.addr> = getelementptr ir<%b>, vp<[[VP9]]>
+; CHECK-TF-NEXT: EMIT-SCALAR ir<%b.addr> = getelementptr i32, ir<%b>, vp<[[VP9]]>
; CHECK-TF-NEXT: vp<[[VP12:%[0-9]+]]> = vector-pointer i32, ir<%b.addr>, ir<1>
; CHECK-TF-NEXT: WIDEN ir<%ld.b> = load vp<[[VP12]]>, vp<[[VP11]]>
; CHECK-TF-NEXT: EMIT vp<[[VP13:%[0-9]+]]> = any-of vp<[[VP11]]>
diff --git a/llvm/test/Transforms/LoopVectorize/VPlan/constant-fold.ll b/llvm/test/Transforms/LoopVectorize/VPlan/constant-fold.ll
index 057e2c71eacd5..2dbc1fee0adea 100644
--- a/llvm/test/Transforms/LoopVectorize/VPlan/constant-fold.ll
+++ b/llvm/test/Transforms/LoopVectorize/VPlan/constant-fold.ll
@@ -26,7 +26,7 @@ define void @f1() {
; CHECK-NEXT: bb2:
; CHECK-NEXT: EMIT-SCALAR ir<%c.1.0> = phi [ ir<0>, vector.ph ], [ ir<%_tmp9>, bb2 ]
; CHECK-NEXT: EMIT-SCALAR ir<%_tmp6> = sext ir<%c.1.0> to i64
-; CHECK-NEXT: EMIT ir<%_tmp7> = getelementptr ir<@b>, ir<0>, ir<%_tmp6>
+; CHECK-NEXT: EMIT-SCALAR ir<%_tmp7> = getelementptr [2 x ptr], ir<@b>, ir<0>, ir<%_tmp6>
; CHECK-NEXT: EMIT store ir<@a>, ir<%_tmp7>
; CHECK-NEXT: EMIT ir<%_tmp9> = add nsw ir<%c.1.0>, ir<1>
; CHECK-NEXT: EMIT ir<%_tmp11> = icmp sge ir<%_tmp9>, ir<2>
@@ -76,7 +76,7 @@ define void @redundant_or_1(ptr %dst, i1 %c.0, i1 %c.1) {
; CHECK-NEXT: Successor(s): then.2, loop.latch
; CHECK-EMPTY:
; CHECK-NEXT: then.2:
-; CHECK-NEXT: EMIT ir<%gep> = getelementptr inbounds ir<%dst>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr inbounds i32, ir<%dst>, ir<%iv>
; CHECK-NEXT: EMIT store ir<0>, ir<%gep>
; CHECK-NEXT: Successor(s): loop.latch
; CHECK-EMPTY:
@@ -136,7 +136,7 @@ define void @redundant_or_2(ptr %dst, i1 %c.0, i1 %c.1) {
; CHECK-NEXT: Successor(s): then.2, loop.latch
; CHECK-EMPTY:
; CHECK-NEXT: then.2:
-; CHECK-NEXT: EMIT ir<%gep> = getelementptr inbounds ir<%dst>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr inbounds i32, ir<%dst>, ir<%iv>
; CHECK-NEXT: EMIT store ir<0>, ir<%gep>
; CHECK-NEXT: Successor(s): loop.latch
; CHECK-EMPTY:
@@ -197,7 +197,7 @@ define void @redundant_and_1(ptr %dst, i1 %c.0, i1 %c.1) {
; CHECK-NEXT: Successor(s): then.2, loop.latch
; CHECK-EMPTY:
; CHECK-NEXT: then.2:
-; CHECK-NEXT: EMIT ir<%gep> = getelementptr inbounds ir<%dst>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr inbounds i32, ir<%dst>, ir<%iv>
; CHECK-NEXT: EMIT store ir<0>, ir<%gep>
; CHECK-NEXT: Successor(s): loop.latch
; CHECK-EMPTY:
@@ -258,7 +258,7 @@ define void @redundant_and_2(ptr %dst, i1 %c.0, i1 %c.1) {
; CHECK-NEXT: Successor(s): then.2, loop.latch
; CHECK-EMPTY:
; CHECK-NEXT: then.2:
-; CHECK-NEXT: EMIT ir<%gep> = getelementptr inbounds ir<%dst>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr inbounds i32, ir<%dst>, ir<%iv>
; CHECK-NEXT: EMIT store ir<0>, ir<%gep>
; CHECK-NEXT: Successor(s): loop.latch
; CHECK-EMPTY:
@@ -308,14 +308,14 @@ define void @fold_replicating_umax_equal_live_ins(ptr noalias %dst, ptr %cond, i
; CHECK-EMPTY:
; CHECK-NEXT: loop:
; CHECK-NEXT: EMIT-SCALAR ir<%iv> = phi [ ir<0>, vector.ph ], [ ir<%iv.next>, latch ]
-; CHECK-NEXT: EMIT ir<%cond.gep> = getelementptr ir<%cond>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%cond.gep> = getelementptr i8, ir<%cond>, ir<%iv>
; CHECK-NEXT: EMIT-SCALAR ir<%c> = load ir<%cond.gep>
; CHECK-NEXT: EMIT ir<%tobool> = icmp ne ir<%c>, ir<0>
; CHECK-NEXT: EMIT branch-on-cond ir<%tobool>
; CHECK-NEXT: Successor(s): then, latch
; CHECK-EMPTY:
; CHECK-NEXT: then:
-; CHECK-NEXT: EMIT ir<%gep> = getelementptr ir<%dst>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr i32, ir<%dst>, ir<%iv>
; CHECK-NEXT: EMIT store ir<%x>, ir<%gep>
; CHECK-NEXT: Successor(s): latch
; CHECK-EMPTY:
diff --git a/llvm/test/Transforms/LoopVectorize/VPlan/cse-loads-masked.ll b/llvm/test/Transforms/LoopVectorize/VPlan/cse-loads-masked.ll
index fbb21329dbaa5..fe1c7302112bf 100644
--- a/llvm/test/Transforms/LoopVectorize/VPlan/cse-loads-masked.ll
+++ b/llvm/test/Transforms/LoopVectorize/VPlan/cse-loads-masked.ll
@@ -20,14 +20,14 @@ define void @two_masked_same_mask(ptr noalias %a, ptr noalias %b, ptr noalias %c
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: EMIT-SCALAR vp<%index> = phi [ ir<0>, vector.ph ], [ vp<%index.next>, vector.body ]
-; CHECK-NEXT: CLONE ir<%gep.c> = getelementptr inbounds ir<%cond>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.c> = getelementptr inbounds i32, ir<%cond>, vp<%index>
; CHECK-NEXT: WIDEN ir<%c> = load ir<%gep.c>
; CHECK-NEXT: WIDEN ir<%cmp> = icmp ne ir<%c>, ir<0>
-; CHECK-NEXT: CLONE ir<%gep.a> = getelementptr ir<%a>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.a> = getelementptr i32, ir<%a>, vp<%index>
; CHECK-NEXT: WIDEN ir<%x> = load ir<%gep.a>, ir<%cmp>
; CHECK-NEXT: WIDEN ir<%s> = add ir<%x>, ir<%x>
; CHECK-NEXT: EMIT vp<%predphi> = select ir<%cmp>, ir<%s>, ir<0>
-; CHECK-NEXT: CLONE ir<%gep.b> = getelementptr inbounds ir<%b>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.b> = getelementptr inbounds i32, ir<%b>, vp<%index>
; CHECK-NEXT: WIDEN store ir<%gep.b>, vp<%predphi>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<%index>, ir<4>
; CHECK-NEXT: EMIT vp<[[VP1:%[0-9]+]]> = icmp eq vp<%index.next>, ir<1024>
@@ -77,19 +77,19 @@ define void @two_masked_diff_mask(ptr noalias %a, ptr noalias %b, ptr noalias %c
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: EMIT-SCALAR vp<%index> = phi [ ir<0>, vector.ph ], [ vp<%index.next>, vector.body ]
-; CHECK-NEXT: CLONE ir<%gep.a> = getelementptr ir<%a>, vp<%index>
-; CHECK-NEXT: CLONE ir<%gp1> = getelementptr inbounds ir<%c1>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.a> = getelementptr i32, ir<%a>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%gp1> = getelementptr inbounds i32, ir<%c1>, vp<%index>
; CHECK-NEXT: WIDEN ir<%v1> = load ir<%gp1>
; CHECK-NEXT: WIDEN ir<%cmp1> = icmp ne ir<%v1>, ir<0>
; CHECK-NEXT: WIDEN ir<%x> = load ir<%gep.a>, ir<%cmp1>
; CHECK-NEXT: EMIT vp<%predphi> = select ir<%cmp1>, ir<%x>, ir<0>
-; CHECK-NEXT: CLONE ir<%gp2> = getelementptr inbounds ir<%c2>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%gp2> = getelementptr inbounds i32, ir<%c2>, vp<%index>
; CHECK-NEXT: WIDEN ir<%v2> = load ir<%gp2>
; CHECK-NEXT: WIDEN ir<%cmp2> = icmp ne ir<%v2>, ir<0>
; CHECK-NEXT: WIDEN ir<%y> = load ir<%gep.a>, ir<%cmp2>
; CHECK-NEXT: EMIT vp<%predphi>.1 = select ir<%cmp2>, ir<%y>, ir<0>
; CHECK-NEXT: WIDEN ir<%sum> = add vp<%predphi>, vp<%predphi>.1
-; CHECK-NEXT: CLONE ir<%gep.b> = getelementptr inbounds ir<%b>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.b> = getelementptr inbounds i32, ir<%b>, vp<%index>
; CHECK-NEXT: WIDEN store ir<%gep.b>, ir<%sum>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<%index>, ir<4>
; CHECK-NEXT: EMIT vp<[[VP1:%[0-9]+]]> = icmp eq vp<%index.next>, ir<1024>
@@ -150,18 +150,18 @@ define void @masked_and_regular_mix(ptr noalias %a, ptr noalias %b, ptr noalias
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: EMIT-SCALAR vp<%index> = phi [ ir<0>, vector.ph ], [ vp<%index.next>, vector.body ]
-; CHECK-NEXT: CLONE ir<%gep.a> = getelementptr inbounds ir<%a>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.a> = getelementptr inbounds i32, ir<%a>, vp<%index>
; CHECK-NEXT: WIDEN ir<%r1> = load ir<%gep.a>
-; CHECK-NEXT: CLONE ir<%gep.c> = getelementptr inbounds ir<%cond>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.c> = getelementptr inbounds i32, ir<%cond>, vp<%index>
; CHECK-NEXT: WIDEN ir<%c> = load ir<%gep.c>
; CHECK-NEXT: WIDEN ir<%cmp> = icmp ne ir<%c>, ir<0>
-; CHECK-NEXT: CLONE ir<%gep.b> = getelementptr ir<%b>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.b> = getelementptr i32, ir<%b>, vp<%index>
; CHECK-NEXT: WIDEN ir<%m1> = load ir<%gep.b>, ir<%cmp>
; CHECK-NEXT: WIDEN ir<%ms> = add ir<%m1>, ir<%m1>
; CHECK-NEXT: EMIT vp<%predphi> = select ir<%cmp>, ir<%ms>, ir<0>
; CHECK-NEXT: WIDEN ir<%rr> = add ir<%r1>, ir<%r1>
; CHECK-NEXT: WIDEN ir<%sum> = add ir<%rr>, vp<%predphi>
-; CHECK-NEXT: CLONE ir<%gep.o> = getelementptr inbounds ir<%out>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.o> = getelementptr inbounds i32, ir<%out>, vp<%index>
; CHECK-NEXT: WIDEN store ir<%gep.o>, ir<%sum>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<%index>, ir<4>
; CHECK-NEXT: EMIT vp<[[VP1:%[0-9]+]]> = icmp eq vp<%index.next>, ir<1024>
diff --git a/llvm/test/Transforms/LoopVectorize/VPlan/cse-loads-tailfold.ll b/llvm/test/Transforms/LoopVectorize/VPlan/cse-loads-tailfold.ll
index ac97db6b4947a..244f81af59cc0 100644
--- a/llvm/test/Transforms/LoopVectorize/VPlan/cse-loads-tailfold.ll
+++ b/llvm/test/Transforms/LoopVectorize/VPlan/cse-loads-tailfold.ll
@@ -23,10 +23,10 @@ define void @cse_duplicate_masked_load(ptr noalias %a, ptr noalias %b, i64 %n) {
; CHECK-NEXT: vector.body:
; CHECK-NEXT: EMIT-SCALAR vp<%index> = phi [ ir<0>, vector.ph ], [ vp<%index.next>, vector.body ]
; CHECK-NEXT: EMIT vp<%active.lane.mask> = active lane mask vp<%index>, ir<%n>
-; CHECK-NEXT: CLONE ir<%gep.a> = getelementptr inbounds ir<%a>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.a> = getelementptr inbounds i32, ir<%a>, vp<%index>
; CHECK-NEXT: WIDEN ir<%x> = load ir<%gep.a>, vp<%active.lane.mask>
; CHECK-NEXT: WIDEN ir<%sum> = add ir<%x>, ir<%x>
-; CHECK-NEXT: CLONE ir<%gep.b> = getelementptr inbounds ir<%b>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.b> = getelementptr inbounds i32, ir<%b>, vp<%index>
; CHECK-NEXT: WIDEN store ir<%gep.b>, ir<%sum>, vp<%active.lane.mask>
; CHECK-NEXT: EMIT vp<%index.next> = add vp<%index>, ir<4>
; CHECK-NEXT: EMIT vp<[[VP3:%[0-9]+]]> = icmp eq vp<%index.next>, vp<%n.vec>
diff --git a/llvm/test/Transforms/LoopVectorize/VPlan/cse-loads.ll b/llvm/test/Transforms/LoopVectorize/VPlan/cse-loads.ll
index 34dbaef2b17a0..52147c9183cb4 100644
--- a/llvm/test/Transforms/LoopVectorize/VPlan/cse-loads.ll
+++ b/llvm/test/Transforms/LoopVectorize/VPlan/cse-loads.ll
@@ -19,10 +19,10 @@ define void @cse_duplicate_load(ptr noalias %a, ptr noalias %b) {
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: EMIT-SCALAR vp<%index> = phi [ ir<0>, vector.ph ], [ vp<%index.next>, vector.body ]
-; CHECK-NEXT: CLONE ir<%gep.a> = getelementptr inbounds ir<%a>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.a> = getelementptr inbounds i32, ir<%a>, vp<%index>
; CHECK-NEXT: WIDEN ir<%x> = load ir<%gep.a>
; CHECK-NEXT: WIDEN ir<%sum> = add ir<%x>, ir<%x>
-; CHECK-NEXT: CLONE ir<%gep.b> = getelementptr inbounds ir<%b>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.b> = getelementptr inbounds i32, ir<%b>, vp<%index>
; CHECK-NEXT: WIDEN store ir<%gep.b>, ir<%sum>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<%index>, ir<4>
; CHECK-NEXT: EMIT vp<[[VP1:%[0-9]+]]> = icmp eq vp<%index.next>, ir<1024>
@@ -62,11 +62,11 @@ define void @cse_three_duplicate_loads(ptr noalias %a, ptr noalias %b) {
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: EMIT-SCALAR vp<%index> = phi [ ir<0>, vector.ph ], [ vp<%index.next>, vector.body ]
-; CHECK-NEXT: CLONE ir<%gep.a> = getelementptr inbounds ir<%a>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.a> = getelementptr inbounds i32, ir<%a>, vp<%index>
; CHECK-NEXT: WIDEN ir<%x> = load ir<%gep.a>
; CHECK-NEXT: WIDEN ir<%t> = add ir<%x>, ir<%x>
; CHECK-NEXT: WIDEN ir<%sum> = add ir<%t>, ir<%x>
-; CHECK-NEXT: CLONE ir<%gep.b> = getelementptr inbounds ir<%b>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.b> = getelementptr inbounds i32, ir<%b>, vp<%index>
; CHECK-NEXT: WIDEN store ir<%gep.b>, ir<%sum>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<%index>, ir<4>
; CHECK-NEXT: EMIT vp<[[VP1:%[0-9]+]]> = icmp eq vp<%index.next>, ir<1024>
@@ -108,14 +108,14 @@ define void @two_dup_groups(ptr noalias %a, ptr noalias %b, ptr noalias %out) {
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: EMIT-SCALAR vp<%index> = phi [ ir<0>, vector.ph ], [ vp<%index.next>, vector.body ]
-; CHECK-NEXT: CLONE ir<%pa> = getelementptr inbounds ir<%a>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%pa> = getelementptr inbounds i32, ir<%a>, vp<%index>
; CHECK-NEXT: WIDEN ir<%a1> = load ir<%pa>
-; CHECK-NEXT: CLONE ir<%pb> = getelementptr inbounds ir<%b>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%pb> = getelementptr inbounds i32, ir<%b>, vp<%index>
; CHECK-NEXT: WIDEN ir<%b1> = load ir<%pb>
; CHECK-NEXT: WIDEN ir<%sa> = add ir<%a1>, ir<%a1>
; CHECK-NEXT: WIDEN ir<%sb> = add ir<%b1>, ir<%b1>
; CHECK-NEXT: WIDEN ir<%s> = add ir<%sa>, ir<%sb>
-; CHECK-NEXT: CLONE ir<%po> = getelementptr inbounds ir<%out>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%po> = getelementptr inbounds i32, ir<%out>, vp<%index>
; CHECK-NEXT: WIDEN store ir<%po>, ir<%s>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<%index>, ir<4>
; CHECK-NEXT: EMIT vp<[[VP1:%[0-9]+]]> = icmp eq vp<%index.next>, ir<1024>
@@ -160,11 +160,11 @@ define void @load_then_dup_add(ptr noalias %a, ptr noalias %out) {
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: EMIT-SCALAR vp<%index> = phi [ ir<0>, vector.ph ], [ vp<%index.next>, vector.body ]
-; CHECK-NEXT: CLONE ir<%p> = getelementptr inbounds ir<%a>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%p> = getelementptr inbounds i32, ir<%a>, vp<%index>
; CHECK-NEXT: WIDEN ir<%x> = load ir<%p>
; CHECK-NEXT: WIDEN ir<%ax> = add ir<%x>, ir<7>
; CHECK-NEXT: WIDEN ir<%m> = mul ir<%ax>, ir<%ax>
-; CHECK-NEXT: CLONE ir<%po> = getelementptr inbounds ir<%out>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%po> = getelementptr inbounds i32, ir<%out>, vp<%index>
; CHECK-NEXT: WIDEN store ir<%po>, ir<%m>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<%index>, ir<4>
; CHECK-NEXT: EMIT vp<[[VP1:%[0-9]+]]> = icmp eq vp<%index.next>, ir<1024>
@@ -206,7 +206,7 @@ define void @no_cse_across_store(ptr %a) {
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: EMIT-SCALAR vp<%index> = phi [ ir<0>, vector.ph ], [ vp<%index.next>, vector.body ]
-; CHECK-NEXT: CLONE ir<%gep> = getelementptr inbounds ir<%a>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr inbounds i32, ir<%a>, vp<%index>
; CHECK-NEXT: WIDEN ir<%x> = load ir<%gep>
; CHECK-NEXT: WIDEN ir<%inc> = add ir<%x>, ir<1>
; CHECK-NEXT: WIDEN store ir<%gep>, ir<%inc>
@@ -254,13 +254,13 @@ define void @cse_duplicate_loads_after_store(ptr noalias %a, ptr noalias %b) {
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: EMIT-SCALAR vp<%index> = phi [ ir<0>, vector.ph ], [ vp<%index.next>, vector.body ]
-; CHECK-NEXT: CLONE ir<%gep> = getelementptr inbounds ir<%a>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr inbounds i32, ir<%a>, vp<%index>
; CHECK-NEXT: WIDEN ir<%x> = load ir<%gep>
; CHECK-NEXT: WIDEN ir<%inc> = add ir<%x>, ir<1>
; CHECK-NEXT: WIDEN store ir<%gep>, ir<%inc>
; CHECK-NEXT: WIDEN ir<%y> = load ir<%gep>
; CHECK-NEXT: WIDEN ir<%sum> = add ir<%y>, ir<%y>
-; CHECK-NEXT: CLONE ir<%gep.b> = getelementptr inbounds ir<%b>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.b> = getelementptr inbounds i32, ir<%b>, vp<%index>
; CHECK-NEXT: WIDEN store ir<%gep.b>, ir<%sum>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<%index>, ir<4>
; CHECK-NEXT: EMIT vp<[[VP1:%[0-9]+]]> = icmp eq vp<%index.next>, ir<1024>
@@ -303,12 +303,12 @@ define void @no_cse_different_address(ptr noalias %a, ptr noalias %b, ptr noalia
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: EMIT-SCALAR vp<%index> = phi [ ir<0>, vector.ph ], [ vp<%index.next>, vector.body ]
-; CHECK-NEXT: CLONE ir<%gep.a> = getelementptr inbounds ir<%a>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.a> = getelementptr inbounds i32, ir<%a>, vp<%index>
; CHECK-NEXT: WIDEN ir<%x> = load ir<%gep.a>
-; CHECK-NEXT: CLONE ir<%gep.b> = getelementptr inbounds ir<%b>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.b> = getelementptr inbounds i32, ir<%b>, vp<%index>
; CHECK-NEXT: WIDEN ir<%y> = load ir<%gep.b>
; CHECK-NEXT: WIDEN ir<%sum> = add ir<%x>, ir<%y>
-; CHECK-NEXT: CLONE ir<%gep.c> = getelementptr inbounds ir<%c>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.c> = getelementptr inbounds i32, ir<%c>, vp<%index>
; CHECK-NEXT: WIDEN store ir<%gep.c>, ir<%sum>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<%index>, ir<4>
; CHECK-NEXT: EMIT vp<[[VP1:%[0-9]+]]> = icmp eq vp<%index.next>, ir<1024>
@@ -352,10 +352,10 @@ define void @no_cse_different_type(ptr noalias %a, ptr noalias %b) {
; CHECK-NEXT: vp<[[VP1:%[0-9]+]]> = SCALAR-STEPS vp<%index>, ir<1>, ir<4>, ir<1>
; CHECK-NEXT: vp<[[VP2:%[0-9]+]]> = SCALAR-STEPS vp<%index>, ir<1>, ir<4>, ir<2>
; CHECK-NEXT: vp<[[VP3:%[0-9]+]]> = SCALAR-STEPS vp<%index>, ir<1>, ir<4>, ir<3>
-; CHECK-NEXT: CLONE ir<%gep> = getelementptr inbounds ir<%a>, vp<%index>
-; CHECK-NEXT: CLONE ir<%gep>.1 = getelementptr inbounds ir<%a>, vp<[[VP1]]>
-; CHECK-NEXT: CLONE ir<%gep>.2 = getelementptr inbounds ir<%a>, vp<[[VP2]]>
-; CHECK-NEXT: CLONE ir<%gep>.3 = getelementptr inbounds ir<%a>, vp<[[VP3]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr inbounds i64, ir<%a>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep>.1 = getelementptr inbounds i64, ir<%a>, vp<[[VP1]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep>.2 = getelementptr inbounds i64, ir<%a>, vp<[[VP2]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep>.3 = getelementptr inbounds i64, ir<%a>, vp<[[VP3]]>
; CHECK-NEXT: CLONE ir<%x> = load ir<%gep>
; CHECK-NEXT: CLONE ir<%x>.1 = load ir<%gep>.1
; CHECK-NEXT: CLONE ir<%x>.2 = load ir<%gep>.2
@@ -364,7 +364,7 @@ define void @no_cse_different_type(ptr noalias %a, ptr noalias %b) {
; CHECK-NEXT: WIDEN ir<%y> = load ir<%gep>
; CHECK-NEXT: WIDEN-CAST ir<%xe> = zext vp<[[VP4]]> to i64
; CHECK-NEXT: WIDEN ir<%sum> = add ir<%xe>, ir<%y>
-; CHECK-NEXT: CLONE ir<%gep.b> = getelementptr inbounds ir<%b>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.b> = getelementptr inbounds i64, ir<%b>, vp<%index>
; CHECK-NEXT: WIDEN store ir<%gep.b>, ir<%sum>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<%index>, ir<4>
; CHECK-NEXT: EMIT vp<[[VP5:%[0-9]+]]> = icmp eq vp<%index.next>, ir<1024>
@@ -406,10 +406,10 @@ define void @cse_stronger_align_first(ptr noalias %a, ptr noalias %b) {
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: EMIT-SCALAR vp<%index> = phi [ ir<0>, vector.ph ], [ vp<%index.next>, vector.body ]
-; CHECK-NEXT: CLONE ir<%gep> = getelementptr inbounds ir<%a>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr inbounds i32, ir<%a>, vp<%index>
; CHECK-NEXT: WIDEN ir<%x> = load ir<%gep>
; CHECK-NEXT: WIDEN ir<%sum> = add ir<%x>, ir<%x>
-; CHECK-NEXT: CLONE ir<%gep.b> = getelementptr inbounds ir<%b>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.b> = getelementptr inbounds i32, ir<%b>, vp<%index>
; CHECK-NEXT: WIDEN store ir<%gep.b>, ir<%sum>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<%index>, ir<4>
; CHECK-NEXT: EMIT vp<[[VP1:%[0-9]+]]> = icmp eq vp<%index.next>, ir<1024>
@@ -450,11 +450,11 @@ define void @no_cse_weaker_align_first(ptr noalias %a, ptr noalias %b) {
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: EMIT-SCALAR vp<%index> = phi [ ir<0>, vector.ph ], [ vp<%index.next>, vector.body ]
-; CHECK-NEXT: CLONE ir<%gep> = getelementptr inbounds ir<%a>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr inbounds i32, ir<%a>, vp<%index>
; CHECK-NEXT: WIDEN ir<%x> = load ir<%gep>
; CHECK-NEXT: WIDEN ir<%y> = load ir<%gep>
; CHECK-NEXT: WIDEN ir<%sum> = add ir<%x>, ir<%y>
-; CHECK-NEXT: CLONE ir<%gep.b> = getelementptr inbounds ir<%b>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.b> = getelementptr inbounds i32, ir<%b>, vp<%index>
; CHECK-NEXT: WIDEN store ir<%gep.b>, ir<%sum>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<%index>, ir<4>
; CHECK-NEXT: EMIT vp<[[VP1:%[0-9]+]]> = icmp eq vp<%index.next>, ir<1024>
@@ -495,10 +495,10 @@ define void @dup_load_diff_tbaa(ptr noalias %a, ptr noalias %out) {
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: EMIT-SCALAR vp<%index> = phi [ ir<0>, vector.ph ], [ vp<%index.next>, vector.body ]
-; CHECK-NEXT: CLONE ir<%p> = getelementptr inbounds ir<%a>, vp<%index>
-; CHECK-NEXT: WIDEN ir<%x> = load ir<%p>{{$}}
+; CHECK-NEXT: EMIT-SCALAR ir<%p> = getelementptr inbounds i32, ir<%a>, vp<%index>
+; CHECK-NEXT: WIDEN ir<%x> = load ir<%p>
; CHECK-NEXT: WIDEN ir<%sum> = add ir<%x>, ir<%x>
-; CHECK-NEXT: CLONE ir<%po> = getelementptr inbounds ir<%out>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%po> = getelementptr inbounds i32, ir<%out>, vp<%index>
; CHECK-NEXT: WIDEN store ir<%po>, ir<%sum>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<%index>, ir<4>
; CHECK-NEXT: EMIT vp<[[VP1:%[0-9]+]]> = icmp eq vp<%index.next>, ir<1024>
@@ -540,13 +540,13 @@ define void @no_cse_across_noalias_store(ptr %a, ptr %b) {
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: EMIT-SCALAR vp<%index> = phi [ ir<0>, vector.ph ], [ vp<%index.next>, vector.body ]
-; CHECK-NEXT: CLONE ir<%gep.a> = getelementptr inbounds ir<%a>, vp<%index>
-; CHECK-NEXT: WIDEN ir<%x> = load ir<%gep.a> (!alias.scope ![[SCOPE:[0-9]+]], !noalias ![[NOALIAS:[0-9]+]])
-; CHECK-NEXT: CLONE ir<%gep.b> = getelementptr inbounds ir<%b>, vp<%index>
-; CHECK-NEXT: WIDEN store ir<%gep.b>, ir<%x> (!alias.scope ![[NOALIAS]], !noalias ![[SCOPE]])
-; CHECK-NEXT: WIDEN ir<%y> = load ir<%gep.a> (!alias.scope ![[SCOPE]], !noalias ![[NOALIAS]])
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.a> = getelementptr inbounds i32, ir<%a>, vp<%index>
+; CHECK-NEXT: WIDEN ir<%x> = load ir<%gep.a> (!alias.scope !5, !noalias !10)
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.b> = getelementptr inbounds i32, ir<%b>, vp<%index>
+; CHECK-NEXT: WIDEN store ir<%gep.b>, ir<%x> (!alias.scope !10, !noalias !5)
+; CHECK-NEXT: WIDEN ir<%y> = load ir<%gep.a> (!alias.scope !5, !noalias !10)
; CHECK-NEXT: WIDEN ir<%sum> = add ir<%x>, ir<%y>
-; CHECK-NEXT: WIDEN store ir<%gep.b>, ir<%sum> (!alias.scope ![[NOALIAS]], !noalias ![[SCOPE]])
+; CHECK-NEXT: WIDEN store ir<%gep.b>, ir<%sum> (!alias.scope !10, !noalias !5)
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<%index>, ir<4>
; CHECK-NEXT: EMIT vp<[[VP1:%[0-9]+]]> = icmp eq vp<%index.next>, ir<1024>
; CHECK-NEXT: EMIT branch-on-cond vp<[[VP1]]>
@@ -587,11 +587,11 @@ define void @no_cse_across_store_without_scopes(ptr noalias %a, ptr noalias %b)
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: EMIT-SCALAR vp<%index> = phi [ ir<0>, vector.ph ], [ vp<%index.next>, vector.body ]
-; CHECK-NEXT: CLONE ir<%gep.a> = getelementptr inbounds ir<%a>, vp<%index>
-; CHECK-NEXT: WIDEN ir<%x> = load ir<%gep.a> (!alias.scope ![[SCOPE2:[0-9]+]], !noalias ![[NOALIAS2:[0-9]+]])
-; CHECK-NEXT: CLONE ir<%gep.b> = getelementptr inbounds ir<%b>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.a> = getelementptr inbounds i32, ir<%a>, vp<%index>
+; CHECK-NEXT: WIDEN ir<%x> = load ir<%gep.a> (!alias.scope !5, !noalias !10)
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.b> = getelementptr inbounds i32, ir<%b>, vp<%index>
; CHECK-NEXT: WIDEN store ir<%gep.b>, ir<%x>
-; CHECK-NEXT: WIDEN ir<%y> = load ir<%gep.a> (!alias.scope ![[SCOPE2]], !noalias ![[NOALIAS2]])
+; CHECK-NEXT: WIDEN ir<%y> = load ir<%gep.a> (!alias.scope !5, !noalias !10)
; CHECK-NEXT: WIDEN ir<%sum> = add ir<%x>, ir<%y>
; CHECK-NEXT: WIDEN store ir<%gep.b>, ir<%sum>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<%index>, ir<4>
@@ -633,7 +633,7 @@ define void @dup_load_across_replicate_region(ptr noalias %a, ptr noalias %b, pt
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: EMIT-SCALAR vp<%index> = phi [ ir<0>, vector.ph ], [ vp<%index.next>, pred.load.continue ]
-; CHECK-NEXT: CLONE ir<%p> = getelementptr inbounds ir<%a>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%p> = getelementptr inbounds i32, ir<%a>, vp<%index>
; CHECK-NEXT: WIDEN ir<%x> = load ir<%p>
; CHECK-NEXT: WIDEN ir<%c> = icmp sgt ir<%x>, ir<0>
; CHECK-NEXT: WIDEN-CAST ir<%idx> = sext ir<%x> to i64
@@ -643,7 +643,7 @@ define void @dup_load_across_replicate_region(ptr noalias %a, ptr noalias %b, pt
; CHECK-EMPTY:
; CHECK-NEXT: pred.load.if:
; CHECK-NEXT: EMIT vp<[[VP3:%[0-9]+]]> = extractelement ir<%idx>, ir<0>
-; CHECK-NEXT: CLONE ir<%gep2> = getelementptr inbounds ir<%b>, vp<[[VP3]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep2> = getelementptr inbounds i32, ir<%b>, vp<[[VP3]]>
; CHECK-NEXT: CLONE ir<%ld> = load ir<%gep2>
; CHECK-NEXT: EMIT vp<[[VP4:%[0-9]+]]> = insertelement ir<poison>, ir<%ld>, ir<0>
; CHECK-NEXT: Successor(s): pred.load.continue
@@ -656,7 +656,7 @@ define void @dup_load_across_replicate_region(ptr noalias %a, ptr noalias %b, pt
; CHECK-EMPTY:
; CHECK-NEXT: pred.load.if:
; CHECK-NEXT: EMIT vp<[[VP8:%[0-9]+]]> = extractelement ir<%idx>, ir<1>
-; CHECK-NEXT: CLONE ir<%gep2>.1 = getelementptr inbounds ir<%b>, vp<[[VP8]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep2>.1 = getelementptr inbounds i32, ir<%b>, vp<[[VP8]]>
; CHECK-NEXT: CLONE ir<%ld>.1 = load ir<%gep2>.1
; CHECK-NEXT: EMIT vp<[[VP9:%[0-9]+]]> = insertelement vp<[[VP5]]>, ir<%ld>.1, ir<1>
; CHECK-NEXT: Successor(s): pred.load.continue
@@ -669,7 +669,7 @@ define void @dup_load_across_replicate_region(ptr noalias %a, ptr noalias %b, pt
; CHECK-EMPTY:
; CHECK-NEXT: pred.load.if:
; CHECK-NEXT: EMIT vp<[[VP13:%[0-9]+]]> = extractelement ir<%idx>, ir<2>
-; CHECK-NEXT: CLONE ir<%gep2>.2 = getelementptr inbounds ir<%b>, vp<[[VP13]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep2>.2 = getelementptr inbounds i32, ir<%b>, vp<[[VP13]]>
; CHECK-NEXT: CLONE ir<%ld>.2 = load ir<%gep2>.2
; CHECK-NEXT: EMIT vp<[[VP14:%[0-9]+]]> = insertelement vp<[[VP10]]>, ir<%ld>.2, ir<2>
; CHECK-NEXT: Successor(s): pred.load.continue
@@ -682,7 +682,7 @@ define void @dup_load_across_replicate_region(ptr noalias %a, ptr noalias %b, pt
; CHECK-EMPTY:
; CHECK-NEXT: pred.load.if:
; CHECK-NEXT: EMIT vp<[[VP18:%[0-9]+]]> = extractelement ir<%idx>, ir<3>
-; CHECK-NEXT: CLONE ir<%gep2>.3 = getelementptr inbounds ir<%b>, vp<[[VP18]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep2>.3 = getelementptr inbounds i32, ir<%b>, vp<[[VP18]]>
; CHECK-NEXT: CLONE ir<%ld>.3 = load ir<%gep2>.3
; CHECK-NEXT: EMIT vp<[[VP19:%[0-9]+]]> = insertelement vp<[[VP15]]>, ir<%ld>.3, ir<3>
; CHECK-NEXT: Successor(s): pred.load.continue
@@ -692,7 +692,7 @@ define void @dup_load_across_replicate_region(ptr noalias %a, ptr noalias %b, pt
; CHECK-NEXT: EMIT vp<%predphi> = select ir<%c>, vp<[[VP20]]>, ir<0>
; CHECK-NEXT: WIDEN ir<%y> = load ir<%p>
; CHECK-NEXT: WIDEN ir<%sum> = add vp<%predphi>, ir<%y>
-; CHECK-NEXT: CLONE ir<%po> = getelementptr inbounds ir<%out>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%po> = getelementptr inbounds i32, ir<%out>, vp<%index>
; CHECK-NEXT: WIDEN store ir<%po>, ir<%sum>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<%index>, ir<4>
; CHECK-NEXT: EMIT vp<[[VP21:%[0-9]+]]> = icmp eq vp<%index.next>, ir<1024>
@@ -744,12 +744,12 @@ define void @cse_after_weaker_align_first(ptr noalias %a, ptr noalias %b) {
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: EMIT-SCALAR vp<%index> = phi [ ir<0>, vector.ph ], [ vp<%index.next>, vector.body ]
-; CHECK-NEXT: CLONE ir<%gep> = getelementptr inbounds ir<%a>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr inbounds i32, ir<%a>, vp<%index>
; CHECK-NEXT: WIDEN ir<%x> = load ir<%gep>
; CHECK-NEXT: WIDEN ir<%y> = load ir<%gep>
; CHECK-NEXT: WIDEN ir<%s1> = add ir<%x>, ir<%y>
; CHECK-NEXT: WIDEN ir<%sum> = add ir<%s1>, ir<%y>
-; CHECK-NEXT: CLONE ir<%gep.b> = getelementptr inbounds ir<%b>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.b> = getelementptr inbounds i32, ir<%b>, vp<%index>
; CHECK-NEXT: WIDEN store ir<%gep.b>, ir<%sum>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<%index>, ir<4>
; CHECK-NEXT: EMIT vp<[[VP1:%[0-9]+]]> = icmp eq vp<%index.next>, ir<1024>
diff --git a/llvm/test/Transforms/LoopVectorize/VPlan/dissolve-replicate-regions.ll b/llvm/test/Transforms/LoopVectorize/VPlan/dissolve-replicate-regions.ll
index de1f217a4a25b..125e7eff14515 100644
--- a/llvm/test/Transforms/LoopVectorize/VPlan/dissolve-replicate-regions.ll
+++ b/llvm/test/Transforms/LoopVectorize/VPlan/dissolve-replicate-regions.ll
@@ -35,7 +35,7 @@ define void @predicated_load(i1 %c, ptr %ptr, ptr %dst) {
; SCALAR-NEXT: Successor(s): pred.load.if, pred.load.continue
; SCALAR-EMPTY:
; SCALAR-NEXT: pred.load.if:
-; SCALAR-NEXT: CLONE ir<%gep> = getelementptr ir<%ptr>, vp<[[VP6]]>
+; SCALAR-NEXT: EMIT-SCALAR ir<%gep> = getelementptr i8, ir<%ptr>, vp<[[VP6]]>
; SCALAR-NEXT: CLONE ir<%lv> = load ir<%gep>
; SCALAR-NEXT: Successor(s): pred.load.continue
; SCALAR-EMPTY:
@@ -45,7 +45,7 @@ define void @predicated_load(i1 %c, ptr %ptr, ptr %dst) {
; SCALAR-NEXT: Successor(s): pred.load.if, pred.load.continue
; SCALAR-EMPTY:
; SCALAR-NEXT: pred.load.if:
-; SCALAR-NEXT: CLONE ir<%gep>.1 = getelementptr ir<%ptr>, vp<[[VP7]]>
+; SCALAR-NEXT: EMIT-SCALAR ir<%gep>.1 = getelementptr i8, ir<%ptr>, vp<[[VP7]]>
; SCALAR-NEXT: CLONE ir<%lv>.1 = load ir<%gep>.1
; SCALAR-NEXT: Successor(s): pred.load.continue
; SCALAR-EMPTY:
@@ -53,8 +53,8 @@ define void @predicated_load(i1 %c, ptr %ptr, ptr %dst) {
; SCALAR-NEXT: EMIT-SCALAR vp<[[VP11:%[0-9]+]]> = phi [ ir<poison>, pred.load.continue ], [ ir<%lv>.1, pred.load.if ]
; SCALAR-NEXT: BLEND ir<%pred.val> = ir<0> vp<%9>/ir<%c>
; SCALAR-NEXT: BLEND ir<%pred.val>.1 = ir<0> vp<%11>/ir<%c>
-; SCALAR-NEXT: CLONE ir<%gep.dst> = getelementptr ir<%dst>, vp<[[VP6]]>
-; SCALAR-NEXT: CLONE ir<%gep.dst>.1 = getelementptr ir<%dst>, vp<[[VP7]]>
+; SCALAR-NEXT: EMIT-SCALAR ir<%gep.dst> = getelementptr i8, ir<%dst>, vp<[[VP6]]>
+; SCALAR-NEXT: EMIT-SCALAR ir<%gep.dst>.1 = getelementptr i8, ir<%dst>, vp<[[VP7]]>
; SCALAR-NEXT: CLONE store ir<%pred.val>, ir<%gep.dst>
; SCALAR-NEXT: CLONE store ir<%pred.val>.1, ir<%gep.dst>.1
; SCALAR-NEXT: EMIT vp<%index.next> = add nuw vp<[[VP5]]>, vp<[[VP1]]>
@@ -113,7 +113,7 @@ define void @predicated_load(i1 %c, ptr %ptr, ptr %dst) {
; VECTOR-EMPTY:
; VECTOR-NEXT: pred.load.if:
; VECTOR-NEXT: vp<[[VP9:%[0-9]+]]> = SCALAR-STEPS vp<[[VP6]]>, ir<1>, vp<[[VP0]]>
-; VECTOR-NEXT: CLONE ir<%gep> = getelementptr ir<%ptr>, vp<[[VP9]]>
+; VECTOR-NEXT: EMIT-SCALAR ir<%gep> = getelementptr i8, ir<%ptr>, vp<[[VP9]]>
; VECTOR-NEXT: CLONE ir<%lv> = load ir<%gep>
; VECTOR-NEXT: EMIT vp<[[VP10:%[0-9]+]]> = insertelement ir<poison>, ir<%lv>, ir<0>
; VECTOR-NEXT: Successor(s): pred.load.continue
@@ -125,7 +125,7 @@ define void @predicated_load(i1 %c, ptr %ptr, ptr %dst) {
; VECTOR-EMPTY:
; VECTOR-NEXT: pred.load.if:
; VECTOR-NEXT: vp<[[VP13:%[0-9]+]]> = SCALAR-STEPS vp<[[VP6]]>, ir<1>, vp<[[VP0]]>, ir<1>
-; VECTOR-NEXT: CLONE ir<%gep>.1 = getelementptr ir<%ptr>, vp<[[VP13]]>
+; VECTOR-NEXT: EMIT-SCALAR ir<%gep>.1 = getelementptr i8, ir<%ptr>, vp<[[VP13]]>
; VECTOR-NEXT: CLONE ir<%lv>.1 = load ir<%gep>.1
; VECTOR-NEXT: EMIT vp<[[VP14:%[0-9]+]]> = insertelement vp<[[VP11]]>, ir<%lv>.1, ir<1>
; VECTOR-NEXT: Successor(s): pred.load.continue
@@ -137,7 +137,7 @@ define void @predicated_load(i1 %c, ptr %ptr, ptr %dst) {
; VECTOR-EMPTY:
; VECTOR-NEXT: pred.load.if:
; VECTOR-NEXT: vp<[[VP17:%[0-9]+]]> = SCALAR-STEPS vp<[[VP6]]>, ir<1>, vp<[[VP0]]>, vp<[[VP0]]>
-; VECTOR-NEXT: CLONE ir<%gep>.2 = getelementptr ir<%ptr>, vp<[[VP17]]>
+; VECTOR-NEXT: EMIT-SCALAR ir<%gep>.2 = getelementptr i8, ir<%ptr>, vp<[[VP17]]>
; VECTOR-NEXT: CLONE ir<%lv>.2 = load ir<%gep>.2
; VECTOR-NEXT: EMIT vp<[[VP18:%[0-9]+]]> = insertelement ir<poison>, ir<%lv>.2, ir<0>
; VECTOR-NEXT: Successor(s): pred.load.continue
@@ -150,7 +150,7 @@ define void @predicated_load(i1 %c, ptr %ptr, ptr %dst) {
; VECTOR-NEXT: pred.load.if:
; VECTOR-NEXT: EMIT vp<[[VP21:%[0-9]+]]> = add vp<[[VP0]]>, ir<1>
; VECTOR-NEXT: vp<[[VP22:%[0-9]+]]> = SCALAR-STEPS vp<[[VP6]]>, ir<1>, vp<[[VP0]]>, vp<[[VP21]]>
-; VECTOR-NEXT: CLONE ir<%gep>.3 = getelementptr ir<%ptr>, vp<[[VP22]]>
+; VECTOR-NEXT: EMIT-SCALAR ir<%gep>.3 = getelementptr i8, ir<%ptr>, vp<[[VP22]]>
; VECTOR-NEXT: CLONE ir<%lv>.3 = load ir<%gep>.3
; VECTOR-NEXT: EMIT vp<[[VP23:%[0-9]+]]> = insertelement vp<[[VP19]]>, ir<%lv>.3, ir<1>
; VECTOR-NEXT: Successor(s): pred.load.continue
@@ -159,7 +159,7 @@ define void @predicated_load(i1 %c, ptr %ptr, ptr %dst) {
; VECTOR-NEXT: WIDEN-PHI vp<[[VP24:%[0-9]+]]> = phi [ vp<[[VP19]]>, pred.load.continue ], [ vp<[[VP23]]>, pred.load.if ]
; VECTOR-NEXT: BLEND ir<%pred.val> = ir<0> vp<%15>/vp<[[VP5]]>
; VECTOR-NEXT: BLEND ir<%pred.val>.1 = ir<0> vp<%24>/vp<[[VP5]]>
-; VECTOR-NEXT: CLONE ir<%gep.dst> = getelementptr ir<%dst>, vp<[[VP7]]>
+; VECTOR-NEXT: EMIT-SCALAR ir<%gep.dst> = getelementptr i8, ir<%dst>, vp<[[VP7]]>
; VECTOR-NEXT: EMIT vp<[[VP25:%[0-9]+]]> = mul nuw nsw vp<[[VP0]]>, ir<1>
; VECTOR-NEXT: vp<[[VP26:%[0-9]+]]> = vector-pointer i8, ir<%gep.dst>, ir<1>
; VECTOR-NEXT: vp<[[VP27:%[0-9]+]]> = vector-pointer i8, ir<%gep.dst>, ir<1>, vp<[[VP25]]>
diff --git a/llvm/test/Transforms/LoopVectorize/VPlan/early_exit_with_stores_vplan.ll b/llvm/test/Transforms/LoopVectorize/VPlan/early_exit_with_stores_vplan.ll
index 70bed19a17a62..faf5d785bb7b4 100644
--- a/llvm/test/Transforms/LoopVectorize/VPlan/early_exit_with_stores_vplan.ll
+++ b/llvm/test/Transforms/LoopVectorize/VPlan/early_exit_with_stores_vplan.ll
@@ -23,13 +23,13 @@ define void @loop_contains_store_condition_load_has_single_user(ptr dereferencea
; CHECK-NEXT: vector.body:
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION nuw nsw ir<0>, ir<1>, vp<[[VP0]]>
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = SCALAR-STEPS vp<[[VP3]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%ee.addr> = getelementptr inbounds nuw ir<%pred>, vp<[[VP4]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%ee.addr> = getelementptr inbounds nuw i16, ir<%pred>, vp<[[VP4]]>
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = vector-pointer inbounds nuw i16, ir<%ee.addr>, ir<1>
; CHECK-NEXT: WIDEN ir<%ee.val> = load vp<[[VP5]]>
; CHECK-NEXT: WIDEN ir<%ee.cond> = icmp sgt ir<%ee.val>, ir<500>
; CHECK-NEXT: EMIT vp<[[VP6:%[0-9]+]]> = first-active-lane ir<%ee.cond>
; CHECK-NEXT: EMIT vp<%uncountable.exit.mask> = active lane mask ir<0>, vp<[[VP6]]>
-; CHECK-NEXT: CLONE ir<%st.addr> = getelementptr ir<%array>, vp<[[VP4]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%st.addr> = getelementptr i16, ir<%array>, vp<[[VP4]]>
; CHECK-NEXT: vp<[[VP7:%[0-9]+]]> = vector-pointer i16, ir<%st.addr>, ir<1>
; CHECK-NEXT: WIDEN ir<%data> = load vp<[[VP7]]>, vp<%uncountable.exit.mask>
; CHECK-NEXT: WIDEN ir<%inc> = add nsw ir<%data>, ir<1>
@@ -112,13 +112,13 @@ define void @loop_contains_store_after_uncountable_exit(ptr dereferenceable(40)
; CHECK-NEXT: vector.body:
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION nuw nsw ir<0>, ir<1>, vp<[[VP0]]>
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = SCALAR-STEPS vp<[[VP3]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%ee.addr> = getelementptr inbounds nuw ir<%pred>, vp<[[VP4]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%ee.addr> = getelementptr inbounds nuw i16, ir<%pred>, vp<[[VP4]]>
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = vector-pointer inbounds nuw i16, ir<%ee.addr>, ir<1>
; CHECK-NEXT: WIDEN ir<%ee.val> = load vp<[[VP5]]>
; CHECK-NEXT: WIDEN ir<%ee.cond> = icmp sgt ir<%ee.val>, ir<500>
; CHECK-NEXT: EMIT vp<[[VP6:%[0-9]+]]> = first-active-lane ir<%ee.cond>
; CHECK-NEXT: EMIT vp<%uncountable.exit.mask> = active lane mask ir<0>, vp<[[VP6]]>
-; CHECK-NEXT: CLONE ir<%st.addr> = getelementptr ir<%array>, vp<[[VP4]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%st.addr> = getelementptr i16, ir<%array>, vp<[[VP4]]>
; CHECK-NEXT: vp<[[VP7:%[0-9]+]]> = vector-pointer i16, ir<%st.addr>, ir<1>
; CHECK-NEXT: WIDEN ir<%data> = load vp<[[VP7]]>, vp<%uncountable.exit.mask>
; CHECK-NEXT: WIDEN ir<%inc> = add nsw ir<%data>, ir<1>
@@ -197,13 +197,13 @@ define i16 @uncountable_exit_with_live_out(ptr dereferenceable(40) noalias %arra
; CHECK-NEXT: vector.body:
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION nuw nsw ir<0>, ir<1>, vp<[[VP0]]>
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = SCALAR-STEPS vp<[[VP3]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%ee.addr> = getelementptr inbounds nuw ir<%pred>, vp<[[VP4]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%ee.addr> = getelementptr inbounds nuw i16, ir<%pred>, vp<[[VP4]]>
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = vector-pointer inbounds nuw i16, ir<%ee.addr>, ir<1>
; CHECK-NEXT: WIDEN ir<%ee.val> = load vp<[[VP5]]>
; CHECK-NEXT: WIDEN ir<%ee.cond> = icmp sgt ir<%ee.val>, ir<500>
; CHECK-NEXT: EMIT vp<[[VP6:%[0-9]+]]> = first-active-lane ir<%ee.cond>
; CHECK-NEXT: EMIT vp<%uncountable.exit.mask> = active lane mask ir<0>, vp<[[VP6]]>
-; CHECK-NEXT: CLONE ir<%st.addr> = getelementptr ir<%array>, vp<[[VP4]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%st.addr> = getelementptr i16, ir<%array>, vp<[[VP4]]>
; CHECK-NEXT: vp<[[VP7:%[0-9]+]]> = vector-pointer i16, ir<%st.addr>, ir<1>
; CHECK-NEXT: WIDEN ir<%data> = load vp<[[VP7]]>, vp<%uncountable.exit.mask>
; CHECK-NEXT: WIDEN ir<%inc> = add nsw ir<%data>, ir<1>
diff --git a/llvm/test/Transforms/LoopVectorize/VPlan/epilogue-vectorization-printing.ll b/llvm/test/Transforms/LoopVectorize/VPlan/epilogue-vectorization-printing.ll
index 9bf623bfaef49..fe0004a4bdde3 100644
--- a/llvm/test/Transforms/LoopVectorize/VPlan/epilogue-vectorization-printing.ll
+++ b/llvm/test/Transforms/LoopVectorize/VPlan/epilogue-vectorization-printing.ll
@@ -28,7 +28,7 @@ define i64 @resume_values(ptr noalias %A, i64 %n) {
; CHECK-NEXT: vector.body:
; CHECK-NEXT: EMIT-SCALAR vp<%index> = phi [ ir<0>, vector.ph ], [ vp<%index.next>, vector.body ]
; CHECK-NEXT: WIDEN-REDUCTION-PHI ir<%red> = phi (add) vp<[[VP5]]>, ir<%red.next>
-; CHECK-NEXT: CLONE ir<%gep> = getelementptr inbounds ir<%A>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr inbounds i64, ir<%A>, vp<%index>
; CHECK-NEXT: WIDEN ir<%l> = load ir<%gep>
; CHECK-NEXT: WIDEN ir<%red.next> = add ir<%red>, ir<%l>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<%index>, ir<8>
@@ -85,7 +85,7 @@ define i64 @resume_values(ptr noalias %A, i64 %n) {
; CHECK-NEXT: vec.epilog.vector.body:
; CHECK-NEXT: EMIT-SCALAR vp<%index> = phi [ ir<%vec.epilog.resume.val>, vec.epilog.ph ], [ vp<%index.next>, vec.epilog.vector.body ]
; CHECK-NEXT: WIDEN-REDUCTION-PHI ir<%red> = phi (add) vp<[[VP4]]>, ir<%red.next>
-; CHECK-NEXT: CLONE ir<%gep> = getelementptr inbounds ir<%A>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr inbounds i64, ir<%A>, vp<%index>
; CHECK-NEXT: WIDEN ir<%l> = load ir<%gep>
; CHECK-NEXT: WIDEN ir<%red.next> = add ir<%red>, ir<%l>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<%index>, ir<4>
@@ -178,10 +178,10 @@ define i64 @bypass_blocks(ptr %A, ptr %B, i32 %n) {
; CHECK-NEXT: EMIT-SCALAR vp<%index> = phi [ ir<0>, vector.ph ], [ vp<%index.next>, vector.body ]
; CHECK-NEXT: WIDEN-REDUCTION-PHI ir<%red> = phi (add) vp<[[VP7]]>, ir<%red.next>
; CHECK-NEXT: EMIT-SCALAR ir<%iv.ext> = sext vp<%index> to i64
-; CHECK-NEXT: CLONE ir<%gep.a> = getelementptr inbounds ir<%A>, ir<%iv.ext>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.a> = getelementptr inbounds i64, ir<%A>, ir<%iv.ext>
; CHECK-NEXT: WIDEN ir<%l> = load ir<%gep.a>
; CHECK-NEXT: WIDEN ir<%red.next> = add ir<%red>, ir<%l>
-; CHECK-NEXT: CLONE ir<%gep.b> = getelementptr inbounds ir<%B>, ir<%iv.ext>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.b> = getelementptr inbounds i64, ir<%B>, ir<%iv.ext>
; CHECK-NEXT: WIDEN store ir<%gep.b>, ir<%l>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<%index>, ir<8>
; CHECK-NEXT: EMIT vp<[[VP8:%[0-9]+]]> = icmp eq vp<%index.next>, vp<%n.vec>
@@ -241,10 +241,10 @@ define i64 @bypass_blocks(ptr %A, ptr %B, i32 %n) {
; CHECK-NEXT: EMIT-SCALAR vp<%index> = phi [ ir<%vec.epilog.resume.val>, vec.epilog.ph ], [ vp<%index.next>, vec.epilog.vector.body ]
; CHECK-NEXT: WIDEN-REDUCTION-PHI ir<%red> = phi (add) vp<[[VP4]]>, ir<%red.next>
; CHECK-NEXT: EMIT-SCALAR ir<%iv.ext> = sext vp<%index> to i64
-; CHECK-NEXT: CLONE ir<%gep.a> = getelementptr inbounds ir<%A>, ir<%iv.ext>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.a> = getelementptr inbounds i64, ir<%A>, ir<%iv.ext>
; CHECK-NEXT: WIDEN ir<%l> = load ir<%gep.a>
; CHECK-NEXT: WIDEN ir<%red.next> = add ir<%red>, ir<%l>
-; CHECK-NEXT: CLONE ir<%gep.b> = getelementptr inbounds ir<%B>, ir<%iv.ext>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.b> = getelementptr inbounds i64, ir<%B>, ir<%iv.ext>
; CHECK-NEXT: WIDEN store ir<%gep.b>, ir<%l>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<%index>, ir<4>
; CHECK-NEXT: EMIT vp<[[VP5:%[0-9]+]]> = icmp eq vp<%index.next>, vp<%n.vec>
@@ -331,10 +331,10 @@ define void @all_iterations_in_main_loop_with_memcheck(ptr %dst, ptr %src) {
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: EMIT-SCALAR vp<%index> = phi [ ir<0>, vector.ph ], [ vp<%index.next>, vector.body ]
-; CHECK-NEXT: CLONE ir<%gep.src> = getelementptr inbounds ir<%src>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.src> = getelementptr inbounds i32, ir<%src>, vp<%index>
; CHECK-NEXT: WIDEN ir<%l> = load ir<%gep.src>
; CHECK-NEXT: WIDEN ir<%add> = add ir<%l>, ir<1>
-; CHECK-NEXT: CLONE ir<%gep.dst> = getelementptr inbounds ir<%dst>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.dst> = getelementptr inbounds i32, ir<%dst>, vp<%index>
; CHECK-NEXT: WIDEN store ir<%gep.dst>, ir<%add>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<%index>, ir<8>
; CHECK-NEXT: EMIT vp<[[VP4:%[0-9]+]]> = icmp eq vp<%index.next>, ir<16>
@@ -381,10 +381,10 @@ define void @all_iterations_in_main_loop_with_memcheck(ptr %dst, ptr %src) {
; CHECK-EMPTY:
; CHECK-NEXT: vec.epilog.vector.body:
; CHECK-NEXT: EMIT-SCALAR vp<%index> = phi [ ir<%vec.epilog.resume.val>, vec.epilog.ph ], [ vp<%index.next>, vec.epilog.vector.body ]
-; CHECK-NEXT: CLONE ir<%gep.src> = getelementptr inbounds ir<%src>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.src> = getelementptr inbounds i32, ir<%src>, vp<%index>
; CHECK-NEXT: WIDEN ir<%l> = load ir<%gep.src>
; CHECK-NEXT: WIDEN ir<%add> = add ir<%l>, ir<1>
-; CHECK-NEXT: CLONE ir<%gep.dst> = getelementptr inbounds ir<%dst>, vp<%index>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.dst> = getelementptr inbounds i32, ir<%dst>, vp<%index>
; CHECK-NEXT: WIDEN store ir<%gep.dst>, ir<%add>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<%index>, ir<4>
; CHECK-NEXT: EMIT vp<[[VP2:%[0-9]+]]> = icmp eq vp<%index.next>, ir<16>
@@ -462,7 +462,7 @@ define void @all_iterations_in_main_loop_with_scevcheck(ptr %p, i32 %off) {
; CHECK-NEXT: EMIT-SCALAR vp<[[VP5:%[0-9]+]]> = trunc vp<%index> to i32
; CHECK-NEXT: EMIT vp<[[VP6:%[0-9]+]]> = add ir<%off>, vp<[[VP5]]>
; CHECK-NEXT: EMIT-SCALAR ir<%idx> = zext vp<[[VP6]]> to i64
-; CHECK-NEXT: CLONE ir<%gep> = getelementptr inbounds ir<%p>, ir<%idx>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr inbounds i32, ir<%p>, ir<%idx>
; CHECK-NEXT: WIDEN store ir<%gep>, ir<1>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<%index>, ir<8>
; CHECK-NEXT: EMIT vp<[[VP7:%[0-9]+]]> = icmp eq vp<%index.next>, ir<16>
@@ -516,7 +516,7 @@ define void @all_iterations_in_main_loop_with_scevcheck(ptr %p, i32 %off) {
; CHECK-NEXT: EMIT-SCALAR vp<[[VP3:%[0-9]+]]> = trunc vp<%index> to i32
; CHECK-NEXT: EMIT vp<[[VP4:%[0-9]+]]> = add ir<%off>, vp<[[VP3]]>
; CHECK-NEXT: EMIT-SCALAR ir<%idx> = zext vp<[[VP4]]> to i64
-; CHECK-NEXT: CLONE ir<%gep> = getelementptr inbounds ir<%p>, ir<%idx>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr inbounds i32, ir<%p>, ir<%idx>
; CHECK-NEXT: WIDEN store ir<%gep>, ir<1>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<%index>, ir<4>
; CHECK-NEXT: EMIT vp<[[VP5:%[0-9]+]]> = icmp eq vp<%index.next>, ir<16>
@@ -630,7 +630,7 @@ define void @dead_main_vector_loop(ptr %dst, i64 %n) {
; CHECK-NEXT: Successor(s): vec.epilog.vector.body
; CHECK-EMPTY:
; CHECK-NEXT: vec.epilog.vector.body:
-; CHECK-NEXT: CLONE ir<%gep> = getelementptr inbounds ir<%dst>, ir<%vec.epilog.resume.val>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr inbounds i32, ir<%dst>, ir<%vec.epilog.resume.val>
; CHECK-NEXT: WIDEN store ir<%gep>, ir<1>
; CHECK-NEXT: Successor(s): vec.epilog.middle.block
; CHECK-EMPTY:
diff --git a/llvm/test/Transforms/LoopVectorize/VPlan/execution-frequencies-match-bfi.ll b/llvm/test/Transforms/LoopVectorize/VPlan/execution-frequencies-match-bfi.ll
index 0b0a698b42bf2..4d19d0e577a02 100644
--- a/llvm/test/Transforms/LoopVectorize/VPlan/execution-frequencies-match-bfi.ll
+++ b/llvm/test/Transforms/LoopVectorize/VPlan/execution-frequencies-match-bfi.ll
@@ -25,15 +25,15 @@ define void @single_pred(ptr noalias %a, ptr noalias %b, ptr noalias %idx) {
; VPLAN-LABEL: VPlan for loop in 'single_pred'
; VPLAN: vector.body:
; VPLAN-NEXT: ir<%iv> = WIDEN-INDUCTION ir<0>, ir<1>, vp<%{{.+}}>
-; VPLAN-NEXT: EMIT ir<%gep.idx> = getelementptr inbounds ir<%idx>, ir<%iv>
+; VPLAN-NEXT: EMIT-SCALAR ir<%gep.idx> = getelementptr inbounds i32, ir<%idx>, ir<%iv>
; VPLAN-NEXT: EMIT-SCALAR ir<%i> = load ir<%gep.idx>
-; VPLAN-NEXT: EMIT ir<%gep.b> = getelementptr inbounds ir<%b>, ir<%iv>
+; VPLAN-NEXT: EMIT-SCALAR ir<%gep.b> = getelementptr inbounds i32, ir<%b>, ir<%iv>
; VPLAN-NEXT: EMIT store ir<%i>, ir<%gep.b>{{$}}
; VPLAN-NEXT: EMIT ir<%c.0> = icmp sgt ir<%i>, ir<0>
; VPLAN-NEXT: Successor(s): if.then
; VPLAN-EMPTY:
; VPLAN-NEXT: if.then:
-; VPLAN-NEXT: EMIT ir<%gep.a> = getelementptr inbounds ir<%a>, ir<%iv>
+; VPLAN-NEXT: EMIT-SCALAR ir<%gep.a> = getelementptr inbounds i32, ir<%a>, ir<%iv>
; VPLAN-NEXT: EMIT store ir<%i>, ir<%gep.a>, ir<%c.0> (!vplan.execution.frequency 2305843009213693952 (25%))
; VPLAN-NEXT: Successor(s): latch
; VPLAN-EMPTY:
@@ -89,27 +89,27 @@ define void @two_preds(ptr noalias %a, ptr noalias %b, ptr noalias %c, ptr noali
; VPLAN-LABEL: VPlan for loop in 'two_preds'
; VPLAN: vector.body:
; VPLAN-NEXT: ir<%iv> = WIDEN-INDUCTION ir<0>, ir<1>, vp<%{{.+}}>
-; VPLAN-NEXT: EMIT ir<%gep.idx> = getelementptr inbounds ir<%idx>, ir<%iv>
+; VPLAN-NEXT: EMIT-SCALAR ir<%gep.idx> = getelementptr inbounds i32, ir<%idx>, ir<%iv>
; VPLAN-NEXT: EMIT-SCALAR ir<%i> = load ir<%gep.idx>
; VPLAN-NEXT: EMIT ir<%c.0> = icmp sgt ir<%i>, ir<0>
; VPLAN-NEXT: Successor(s): else
; VPLAN-EMPTY:
; VPLAN-NEXT: else:
; VPLAN-NEXT: EMIT vp<[[NOT_C0:%.+]]> = not ir<%c.0>
-; VPLAN-NEXT: EMIT ir<%gep.c> = getelementptr inbounds ir<%c>, ir<%iv>
+; VPLAN-NEXT: EMIT-SCALAR ir<%gep.c> = getelementptr inbounds i32, ir<%c>, ir<%iv>
; VPLAN-NEXT: EMIT store ir<%i>, ir<%gep.c>, vp<[[NOT_C0]]> (!vplan.execution.frequency 6917529027641081856 (75%))
; VPLAN-NEXT: EMIT ir<%c.1> = icmp slt ir<%i>, ir<-100>, vp<[[NOT_C0]]> (!vplan.execution.frequency 6917529027641081856 (75%))
; VPLAN-NEXT: Successor(s): then
; VPLAN-EMPTY:
; VPLAN-NEXT: then:
-; VPLAN-NEXT: EMIT ir<%gep.a> = getelementptr inbounds ir<%a>, ir<%iv>
+; VPLAN-NEXT: EMIT-SCALAR ir<%gep.a> = getelementptr inbounds i32, ir<%a>, ir<%iv>
; VPLAN-NEXT: EMIT store ir<%i>, ir<%gep.a>, ir<%c.0> (!vplan.execution.frequency 2305843009213693952 (25%))
; VPLAN-NEXT: Successor(s): merge
; VPLAN-EMPTY:
; VPLAN-NEXT: merge:
; VPLAN-NEXT: EMIT vp<[[AND:%.+]]> = logical-and vp<[[NOT_C0]]>, ir<%c.1>
; VPLAN-NEXT: EMIT vp<[[MASK:%.+]]> = or vp<[[AND]]>, ir<%c.0>
-; VPLAN-NEXT: EMIT ir<%gep.b> = getelementptr inbounds ir<%b>, ir<%iv>
+; VPLAN-NEXT: EMIT-SCALAR ir<%gep.b> = getelementptr inbounds i32, ir<%b>, ir<%iv>
; VPLAN-NEXT: EMIT store ir<%i>, ir<%gep.b>, vp<[[MASK]]> (!vplan.execution.frequency 4611686019501129728 (50%))
; VPLAN-NEXT: Successor(s): latch
; VPLAN-EMPTY:
@@ -171,20 +171,20 @@ define void @nested_ifs(ptr noalias %a, ptr noalias %b, ptr noalias %idx) {
; VPLAN-LABEL: VPlan for loop in 'nested_ifs'
; VPLAN: vector.body:
; VPLAN-NEXT: ir<%iv> = WIDEN-INDUCTION ir<0>, ir<1>, vp<%{{.+}}>
-; VPLAN-NEXT: EMIT ir<%gep.idx> = getelementptr inbounds ir<%idx>, ir<%iv>
+; VPLAN-NEXT: EMIT-SCALAR ir<%gep.idx> = getelementptr inbounds i32, ir<%idx>, ir<%iv>
; VPLAN-NEXT: EMIT-SCALAR ir<%i> = load ir<%gep.idx>
; VPLAN-NEXT: EMIT ir<%c.0> = icmp sgt ir<%i>, ir<0>
; VPLAN-NEXT: Successor(s): if.0
; VPLAN-EMPTY:
; VPLAN-NEXT: if.0:
-; VPLAN-NEXT: EMIT ir<%gep.b> = getelementptr inbounds ir<%b>, ir<%iv>
+; VPLAN-NEXT: EMIT-SCALAR ir<%gep.b> = getelementptr inbounds i32, ir<%b>, ir<%iv>
; VPLAN-NEXT: EMIT store ir<%i>, ir<%gep.b>, ir<%c.0> (!vplan.execution.frequency 2305843009213693952 (25%))
; VPLAN-NEXT: EMIT ir<%c.1> = icmp slt ir<%i>, ir<100>, ir<%c.0> (!vplan.execution.frequency 2305843009213693952 (25%))
; VPLAN-NEXT: Successor(s): if.1
; VPLAN-EMPTY:
; VPLAN-NEXT: if.1:
; VPLAN-NEXT: EMIT vp<[[MASK:%.+]]> = logical-and ir<%c.0>, ir<%c.1>
-; VPLAN-NEXT: EMIT ir<%gep.a> = getelementptr inbounds ir<%a>, ir<%iv>
+; VPLAN-NEXT: EMIT-SCALAR ir<%gep.a> = getelementptr inbounds i32, ir<%a>, ir<%iv>
; VPLAN-NEXT: EMIT store ir<%i>, ir<%gep.a>, vp<[[MASK]]> (!vplan.execution.frequency 1152921504606846976 (12.5%))
; VPLAN-NEXT: Successor(s): latch
; VPLAN-EMPTY:
@@ -243,7 +243,7 @@ define void @second_branch_without_weights(ptr noalias %a, ptr noalias %b, ptr n
;
; VPLAN-LABEL: VPlan for loop in 'second_branch_without_weights'
; VPLAN: if.then.1:
-; VPLAN-NEXT: EMIT ir<%gep.a> = getelementptr inbounds ir<%a>, ir<%iv>
+; VPLAN-NEXT: EMIT-SCALAR ir<%gep.a> = getelementptr inbounds i32, ir<%a>, ir<%iv>
; VPLAN-NEXT: EMIT store ir<%i>, ir<%gep.a>, ir<%c.0> (!vplan.execution.frequency 2305843009213693952 (25%))
; VPLAN-NEXT: Successor(s): merge
; VPLAN-EMPTY:
@@ -251,7 +251,7 @@ define void @second_branch_without_weights(ptr noalias %a, ptr noalias %b, ptr n
; VPLAN-NEXT: Successor(s): if.then.2
; VPLAN-EMPTY:
; VPLAN-NEXT: if.then.2:
-; VPLAN-NEXT: EMIT ir<%gep.b> = getelementptr inbounds ir<%b>, ir<%iv>
+; VPLAN-NEXT: EMIT-SCALAR ir<%gep.b> = getelementptr inbounds i32, ir<%b>, ir<%iv>
; VPLAN-NEXT: EMIT store ir<%i>, ir<%gep.b>, ir<%c.0>{{$}}
; VPLAN-NEXT: Successor(s): latch
;
@@ -309,7 +309,7 @@ define void @switch_common_dest(ptr noalias %a, ptr noalias %b, ptr noalias %c,
; VPLAN-LABEL: VPlan for loop in 'switch_common_dest'
; VPLAN: vector.body:
; VPLAN-NEXT: ir<%iv> = WIDEN-INDUCTION ir<0>, ir<1>, vp<%{{.+}}>
-; VPLAN-NEXT: EMIT ir<%gep.idx> = getelementptr inbounds ir<%idx>, ir<%iv>
+; VPLAN-NEXT: EMIT-SCALAR ir<%gep.idx> = getelementptr inbounds i8, ir<%idx>, ir<%iv>
; VPLAN-NEXT: EMIT-SCALAR ir<%l> = load ir<%gep.idx>
; VPLAN-NEXT: Successor(s): other
; VPLAN-EMPTY:
@@ -320,17 +320,17 @@ define void @switch_common_dest(ptr noalias %a, ptr noalias %b, ptr noalias %c,
; VPLAN-NEXT: EMIT vp<[[C0_OR_C1:%.+]]> = or vp<[[C0]]>, vp<[[C1]]>
; VPLAN-NEXT: EMIT vp<[[ANY:%.+]]> = or vp<[[C0_OR_C1]]>, vp<[[C2]]>
; VPLAN-NEXT: EMIT vp<[[DEFAULT:%.+]]> = not vp<[[ANY]]>
-; VPLAN-NEXT: EMIT ir<%gep.b> = getelementptr inbounds ir<%b>, ir<%iv>
+; VPLAN-NEXT: EMIT-SCALAR ir<%gep.b> = getelementptr inbounds i8, ir<%b>, ir<%iv>
; VPLAN-NEXT: EMIT store ir<2>, ir<%gep.b>, vp<[[C2]]> (!vplan.execution.frequency 1152921504606846976 (12.5%))
; VPLAN-NEXT: Successor(s): if.then
; VPLAN-EMPTY:
; VPLAN-NEXT: if.then:
-; VPLAN-NEXT: EMIT ir<%gep.a> = getelementptr inbounds ir<%a>, ir<%iv>
+; VPLAN-NEXT: EMIT-SCALAR ir<%gep.a> = getelementptr inbounds i8, ir<%a>, ir<%iv>
; VPLAN-NEXT: EMIT store ir<1>, ir<%gep.a>, vp<[[C0_OR_C1]]> (!vplan.execution.frequency 3458764513820540928 (37.5%))
; VPLAN-NEXT: Successor(s): default
; VPLAN-EMPTY:
; VPLAN-NEXT: default:
-; VPLAN-NEXT: EMIT ir<%gep.c> = getelementptr inbounds ir<%c>, ir<%iv>
+; VPLAN-NEXT: EMIT-SCALAR ir<%gep.c> = getelementptr inbounds i8, ir<%c>, ir<%iv>
; VPLAN-NEXT: EMIT store ir<0>, ir<%gep.c>, vp<[[DEFAULT]]> (!vplan.execution.frequency 4611686018427387904 (50%))
; VPLAN-NEXT: Successor(s): latch
; VPLAN-EMPTY:
@@ -396,7 +396,7 @@ define void @switch_common_dest_weight_sum_not_a_power_of_two(ptr noalias %a, pt
; VPLAN-LABEL: VPlan for loop in 'switch_common_dest_weight_sum_not_a_power_of_two'
; VPLAN: vector.body:
; VPLAN-NEXT: ir<%iv> = WIDEN-INDUCTION ir<0>, ir<1>, vp<%{{.+}}>
-; VPLAN-NEXT: EMIT ir<%gep.idx> = getelementptr inbounds ir<%idx>, ir<%iv>
+; VPLAN-NEXT: EMIT-SCALAR ir<%gep.idx> = getelementptr inbounds i8, ir<%idx>, ir<%iv>
; VPLAN-NEXT: EMIT-SCALAR ir<%l> = load ir<%gep.idx>
; VPLAN-NEXT: Successor(s): if.then
; VPLAN-EMPTY:
@@ -405,12 +405,12 @@ define void @switch_common_dest_weight_sum_not_a_power_of_two(ptr noalias %a, pt
; VPLAN-NEXT: EMIT vp<[[C1:%.+]]> = icmp eq ir<%l>, ir<1>
; VPLAN-NEXT: EMIT vp<[[C0_OR_C1:%.+]]> = or vp<[[C0]]>, vp<[[C1]]>
; VPLAN-NEXT: EMIT vp<[[DEFAULT:%.+]]> = not vp<[[C0_OR_C1]]>
-; VPLAN-NEXT: EMIT ir<%gep.a> = getelementptr inbounds ir<%a>, ir<%iv>
+; VPLAN-NEXT: EMIT-SCALAR ir<%gep.a> = getelementptr inbounds i8, ir<%a>, ir<%iv>
; VPLAN-NEXT: EMIT store ir<1>, ir<%gep.a>, vp<[[C0_OR_C1]]> (!vplan.execution.frequency 6148914689804861440 (66.67%))
; VPLAN-NEXT: Successor(s): default
; VPLAN-EMPTY:
; VPLAN-NEXT: default:
-; VPLAN-NEXT: EMIT ir<%gep.b> = getelementptr inbounds ir<%b>, ir<%iv>
+; VPLAN-NEXT: EMIT-SCALAR ir<%gep.b> = getelementptr inbounds i8, ir<%b>, ir<%iv>
; VPLAN-NEXT: EMIT store ir<0>, ir<%gep.b>, vp<[[DEFAULT]]> (!vplan.execution.frequency 3074457347049914368 (33.33%))
; VPLAN-NEXT: Successor(s): latch
; VPLAN-EMPTY:
@@ -469,7 +469,7 @@ define void @switch_common_dest_almost_always_taken(ptr noalias %a, ptr noalias
; VPLAN-LABEL: VPlan for loop in 'switch_common_dest_almost_always_taken'
; VPLAN: vector.body:
; VPLAN-NEXT: ir<%iv> = WIDEN-INDUCTION ir<0>, ir<1>, vp<%{{.+}}>
-; VPLAN-NEXT: EMIT ir<%gep.idx> = getelementptr inbounds ir<%idx>, ir<%iv>
+; VPLAN-NEXT: EMIT-SCALAR ir<%gep.idx> = getelementptr inbounds i8, ir<%idx>, ir<%iv>
; VPLAN-NEXT: EMIT-SCALAR ir<%l> = load ir<%gep.idx>
; VPLAN-NEXT: Successor(s): if.then
; VPLAN-EMPTY:
@@ -478,12 +478,12 @@ define void @switch_common_dest_almost_always_taken(ptr noalias %a, ptr noalias
; VPLAN-NEXT: EMIT vp<[[C1:%.+]]> = icmp eq ir<%l>, ir<1>
; VPLAN-NEXT: EMIT vp<[[C0_OR_C1:%.+]]> = or vp<[[C0]]>, vp<[[C1]]>
; VPLAN-NEXT: EMIT vp<[[DEFAULT:%.+]]> = not vp<[[C0_OR_C1]]>
-; VPLAN-NEXT: EMIT ir<%gep.a> = getelementptr inbounds ir<%a>, ir<%iv>
+; VPLAN-NEXT: EMIT-SCALAR ir<%gep.a> = getelementptr inbounds i8, ir<%a>, ir<%iv>
; VPLAN-NEXT: EMIT store ir<1>, ir<%gep.a>, vp<[[C0_OR_C1]]> (!vplan.execution.frequency 9223372032559808512 (100%))
; VPLAN-NEXT: Successor(s): default
; VPLAN-EMPTY:
; VPLAN-NEXT: default:
-; VPLAN-NEXT: EMIT ir<%gep.b> = getelementptr inbounds ir<%b>, ir<%iv>
+; VPLAN-NEXT: EMIT-SCALAR ir<%gep.b> = getelementptr inbounds i8, ir<%b>, ir<%iv>
; VPLAN-NEXT: EMIT store ir<0>, ir<%gep.b>, vp<[[DEFAULT]]> (!vplan.execution.frequency 4294967296 (4.657e-08%))
; VPLAN-NEXT: Successor(s): latch
; VPLAN-EMPTY:
@@ -544,13 +544,13 @@ define void @switch_common_dest_almost_never_taken(ptr noalias %a, ptr noalias %
; VPLAN-LABEL: VPlan for loop in 'switch_common_dest_almost_never_taken'
; VPLAN: vector.body:
; VPLAN-NEXT: ir<%iv> = WIDEN-INDUCTION ir<0>, ir<1>, vp<%{{.+}}>
-; VPLAN-NEXT: EMIT ir<%gep.idx> = getelementptr inbounds ir<%idx>, ir<%iv>
+; VPLAN-NEXT: EMIT-SCALAR ir<%gep.idx> = getelementptr inbounds i8, ir<%idx>, ir<%iv>
; VPLAN-NEXT: EMIT-SCALAR ir<%l> = load ir<%gep.idx>
; VPLAN-NEXT: EMIT ir<%c> = icmp sgt ir<%l>, ir<0>
; VPLAN-NEXT: Successor(s): mid
; VPLAN-EMPTY:
; VPLAN-NEXT: mid:
-; VPLAN-NEXT: EMIT ir<%gep.b> = getelementptr inbounds ir<%b>, ir<%iv>
+; VPLAN-NEXT: EMIT-SCALAR ir<%gep.b> = getelementptr inbounds i8, ir<%b>, ir<%iv>
; VPLAN-NEXT: EMIT store ir<0>, ir<%gep.b>, ir<%c> (!vplan.execution.frequency 4294967296 (4.657e-08%))
; VPLAN-NEXT: Successor(s): if.then
; VPLAN-EMPTY:
@@ -565,7 +565,7 @@ define void @switch_common_dest_almost_never_taken(ptr noalias %a, ptr noalias %
; VPLAN-NEXT: EMIT vp<[[MASK:%.+]]> = logical-and ir<%c>, vp<[[ANY]]>
; VPLAN-NEXT: EMIT vp<[[NOT_MASK:%.+]]> = not vp<[[MASK]]>
; VPLAN-NEXT: EMIT vp<[[DEFAULT:%.+]]> = logical-and ir<%c>, vp<[[NOT_MASK]]>
-; VPLAN-NEXT: EMIT ir<%gep.a> = getelementptr inbounds ir<%a>, ir<%iv>
+; VPLAN-NEXT: EMIT-SCALAR ir<%gep.a> = getelementptr inbounds i8, ir<%a>, ir<%iv>
; VPLAN-NEXT: EMIT store ir<1>, ir<%gep.a>, vp<[[MASK]]> (!vplan.execution.frequency 3435973836 (3.725e-08%))
; VPLAN-NEXT: Successor(s): latch
; VPLAN-EMPTY:
@@ -628,13 +628,13 @@ define void @switch_common_dest_many_edges_almost_never_taken(ptr noalias %a, pt
; VPLAN-LABEL: VPlan for loop in 'switch_common_dest_many_edges_almost_never_taken'
; VPLAN: vector.body:
; VPLAN-NEXT: ir<%iv> = WIDEN-INDUCTION ir<0>, ir<1>, vp<%{{.+}}>
-; VPLAN-NEXT: EMIT ir<%gep.idx> = getelementptr inbounds ir<%idx>, ir<%iv>
+; VPLAN-NEXT: EMIT-SCALAR ir<%gep.idx> = getelementptr inbounds i8, ir<%idx>, ir<%iv>
; VPLAN-NEXT: EMIT-SCALAR ir<%l> = load ir<%gep.idx>
; VPLAN-NEXT: EMIT ir<%c> = icmp sgt ir<%l>, ir<0>
; VPLAN-NEXT: Successor(s): mid
; VPLAN-EMPTY:
; VPLAN-NEXT: mid:
-; VPLAN-NEXT: EMIT ir<%gep.b> = getelementptr inbounds ir<%b>, ir<%iv>
+; VPLAN-NEXT: EMIT-SCALAR ir<%gep.b> = getelementptr inbounds i8, ir<%b>, ir<%iv>
; VPLAN-NEXT: EMIT store ir<0>, ir<%gep.b>, ir<%c> (!vplan.execution.frequency 4294967296 (4.657e-08%))
; VPLAN-NEXT: Successor(s): if.then
; VPLAN-EMPTY:
@@ -642,7 +642,7 @@ define void @switch_common_dest_many_edges_almost_never_taken(ptr noalias %a, pt
; VPLAN: EMIT vp<[[MASK:%.+]]> = logical-and ir<%c>, vp<%{{.+}}>
; VPLAN-NEXT: EMIT vp<[[NOT_MASK:%.+]]> = not vp<[[MASK]]>
; VPLAN-NEXT: EMIT vp<[[DEFAULT:%.+]]> = logical-and ir<%c>, vp<[[NOT_MASK]]>
-; VPLAN-NEXT: EMIT ir<%gep.a> = getelementptr inbounds ir<%a>, ir<%iv>
+; VPLAN-NEXT: EMIT-SCALAR ir<%gep.a> = getelementptr inbounds i8, ir<%a>, ir<%iv>
; VPLAN-NEXT: EMIT store ir<1>, ir<%gep.a>, vp<[[MASK]]> (!vplan.execution.frequency 3817748708 (4.139e-08%))
; VPLAN-NEXT: Successor(s): latch
; VPLAN-EMPTY:
@@ -708,7 +708,7 @@ define void @switch_common_dest_weight_sum_exceeds_32_bits(ptr noalias %a, ptr n
; VPLAN-LABEL: VPlan for loop in 'switch_common_dest_weight_sum_exceeds_32_bits'
; VPLAN: vector.body:
; VPLAN-NEXT: ir<%iv> = WIDEN-INDUCTION ir<0>, ir<1>, vp<%{{.+}}>
-; VPLAN-NEXT: EMIT ir<%gep.idx> = getelementptr inbounds ir<%idx>, ir<%iv>
+; VPLAN-NEXT: EMIT-SCALAR ir<%gep.idx> = getelementptr inbounds i32, ir<%idx>, ir<%iv>
; VPLAN-NEXT: EMIT-SCALAR ir<%l> = load ir<%gep.idx>
; VPLAN-NEXT: Successor(s): if.then
; VPLAN-EMPTY:
@@ -723,7 +723,7 @@ define void @switch_common_dest_weight_sum_exceeds_32_bits(ptr noalias %a, ptr n
; VPLAN-NEXT: EMIT vp<[[OR2:%.+]]> = or vp<[[OR1]]>, vp<[[C3]]>
; VPLAN-NEXT: EMIT vp<[[MASK:%.+]]> = or vp<[[OR2]]>, vp<[[C4]]>
; VPLAN-NEXT: EMIT vp<{{.+}}> = not vp<[[MASK]]>
-; VPLAN-NEXT: EMIT ir<%gep.a> = getelementptr inbounds ir<%a>, ir<%iv>
+; VPLAN-NEXT: EMIT-SCALAR ir<%gep.a> = getelementptr inbounds i32, ir<%a>, ir<%iv>
; VPLAN-NEXT: EMIT store ir<1>, ir<%gep.a>, vp<[[MASK]]> (!vplan.execution.frequency 9223372023969873920 (100%))
; VPLAN-NEXT: Successor(s): latch
;
@@ -856,12 +856,12 @@ define void @switch_weights_clamped_at_both_ends(ptr noalias %a, ptr noalias %b,
; VPLAN-LABEL: VPlan for loop in 'switch_weights_clamped_at_both_ends'
; VPLAN: if.then:
; VPLAN: EMIT vp<[[DEFAULT:%.+]]> = not vp<[[MASK:%.+]]>
-; VPLAN-NEXT: EMIT ir<%gep.a> = getelementptr inbounds ir<%a>, ir<%iv>
+; VPLAN-NEXT: EMIT-SCALAR ir<%gep.a> = getelementptr inbounds i32, ir<%a>, ir<%iv>
; VPLAN-NEXT: EMIT store ir<1>, ir<%gep.a>, vp<[[MASK]]> (!vplan.execution.frequency 9223372032559808512 (100%))
; VPLAN-NEXT: Successor(s): default
; VPLAN-EMPTY:
; VPLAN-NEXT: default:
-; VPLAN-NEXT: EMIT ir<%gep.b> = getelementptr inbounds ir<%b>, ir<%iv>
+; VPLAN-NEXT: EMIT-SCALAR ir<%gep.b> = getelementptr inbounds i32, ir<%b>, ir<%iv>
; VPLAN-NEXT: EMIT store ir<0>, ir<%gep.b>, vp<[[DEFAULT]]> (!vplan.execution.frequency 4294967296 (4.657e-08%))
; VPLAN-NEXT: Successor(s): latch
;
@@ -927,7 +927,7 @@ define void @nested_blocks_almost_never_entered(ptr noalias %a, ptr noalias %idx
; VPLAN-EMPTY:
; VPLAN-NEXT: if.then.3:
; VPLAN-NEXT: EMIT vp<[[MASK:%.+]]> = logical-and vp<[[AND]]>, ir<%c.2>
-; VPLAN-NEXT: EMIT ir<%gep.a> = getelementptr inbounds ir<%a>, ir<%iv>
+; VPLAN-NEXT: EMIT-SCALAR ir<%gep.a> = getelementptr inbounds i32, ir<%a>, ir<%iv>
; VPLAN-NEXT: EMIT store ir<1>, ir<%gep.a>, vp<[[MASK]]> (!vplan.execution.frequency 1 (1.084e-17%))
; VPLAN-NEXT: Successor(s): latch
;
diff --git a/llvm/test/Transforms/LoopVectorize/VPlan/find-last.ll b/llvm/test/Transforms/LoopVectorize/VPlan/find-last.ll
index d7188f4ffd59d..16863bb8deef3 100644
--- a/llvm/test/Transforms/LoopVectorize/VPlan/find-last.ll
+++ b/llvm/test/Transforms/LoopVectorize/VPlan/find-last.ll
@@ -21,10 +21,10 @@ define i32 @find_last_with_select(ptr noalias %a, ptr noalias %b) {
; CHECK-NEXT: vector.body:
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION nuw nsw ir<0>, ir<1>, vp<[[VP0]]>
; CHECK-NEXT: WIDEN-REDUCTION-PHI ir<%rdx> = phi (find-last) ir<1>, ir<%sel>
-; CHECK-NEXT: CLONE ir<%gep.a> = getelementptr inbounds ir<%a>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.a> = getelementptr inbounds i32, ir<%a>, ir<%iv>
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = vector-pointer inbounds i32, ir<%gep.a>, ir<1>
; CHECK-NEXT: WIDEN ir<%load.a> = load vp<[[VP4]]>
-; CHECK-NEXT: CLONE ir<%gep.b> = getelementptr inbounds ir<%b>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.b> = getelementptr inbounds i32, ir<%b>, ir<%iv>
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = vector-pointer inbounds i32, ir<%gep.b>, ir<1>
; CHECK-NEXT: WIDEN ir<%load.b> = load vp<[[VP5]]>
; CHECK-NEXT: WIDEN ir<%cmp> = icmp slt ir<%load.a>, ir<%load.b>
diff --git a/llvm/test/Transforms/LoopVectorize/VPlan/first-order-recurrence-chains-vplan.ll b/llvm/test/Transforms/LoopVectorize/VPlan/first-order-recurrence-chains-vplan.ll
index 014331c600dc9..0d6625159d64c 100644
--- a/llvm/test/Transforms/LoopVectorize/VPlan/first-order-recurrence-chains-vplan.ll
+++ b/llvm/test/Transforms/LoopVectorize/VPlan/first-order-recurrence-chains-vplan.ll
@@ -23,7 +23,7 @@ define void @test_chained_first_order_recurrences_1(ptr %ptr) {
; CHECK-NEXT: FIRST-ORDER-RECURRENCE-PHI ir<%for.1> = phi ir<22>, ir<%for.1.next>
; CHECK-NEXT: FIRST-ORDER-RECURRENCE-PHI ir<%for.2> = phi ir<33>, vp<[[VP6:%[0-9]+]]>
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = SCALAR-STEPS vp<[[VP3]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%gep.ptr> = getelementptr inbounds ir<%ptr>, vp<[[VP4]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.ptr> = getelementptr inbounds i16, ir<%ptr>, vp<[[VP4]]>
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = vector-pointer inbounds i16, ir<%gep.ptr>, ir<1>
; CHECK-NEXT: WIDEN ir<%for.1.next> = load vp<[[VP5]]>
; CHECK-NEXT: EMIT vp<[[VP6]]> = first-order splice ir<%for.1>, ir<%for.1.next>
@@ -109,7 +109,7 @@ define void @test_chained_first_order_recurrences_3(ptr %ptr) {
; CHECK-NEXT: FIRST-ORDER-RECURRENCE-PHI ir<%for.2> = phi ir<33>, vp<[[VP6:%[0-9]+]]>
; CHECK-NEXT: FIRST-ORDER-RECURRENCE-PHI ir<%for.3> = phi ir<33>, vp<[[VP7:%[0-9]+]]>
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = SCALAR-STEPS vp<[[VP3]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%gep.ptr> = getelementptr inbounds ir<%ptr>, vp<[[VP4]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.ptr> = getelementptr inbounds i16, ir<%ptr>, vp<[[VP4]]>
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = vector-pointer inbounds i16, ir<%gep.ptr>, ir<1>
; CHECK-NEXT: WIDEN ir<%for.1.next> = load vp<[[VP5]]>
; CHECK-NEXT: EMIT vp<[[VP6]]> = first-order splice ir<%for.1>, ir<%for.1.next>
@@ -208,7 +208,7 @@ define i32 @test_chained_first_order_recurrences_4(ptr %base, i64 %x) {
; CHECK-NEXT: FIRST-ORDER-RECURRENCE-PHI ir<%for.x> = phi ir<0>, vp<[[VP3]]>
; CHECK-NEXT: FIRST-ORDER-RECURRENCE-PHI ir<%for.y> = phi ir<0>, ir<%for.x.prev>
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = SCALAR-STEPS vp<[[VP4]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%gep> = getelementptr ir<%base>, vp<[[VP5]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr i64, ir<%base>, vp<[[VP5]]>
; CHECK-NEXT: EMIT vp<[[VP6:%[0-9]+]]> = first-order splice ir<%for.x>, vp<[[VP3]]>
; CHECK-NEXT: WIDEN-CAST ir<%for.x.prev> = trunc vp<[[VP6]]> to i32
; CHECK-NEXT: EMIT vp<[[VP7:%[0-9]+]]> = first-order splice ir<%for.y>, ir<%for.x.prev>
@@ -294,7 +294,7 @@ define i32 @test_chained_first_order_recurrences_5_hoist_to_load(ptr %base) {
; CHECK-NEXT: FIRST-ORDER-RECURRENCE-PHI ir<%for.x> = phi ir<0>, vp<[[VP6:%[0-9]+]]>
; CHECK-NEXT: FIRST-ORDER-RECURRENCE-PHI ir<%for.y> = phi ir<0>, ir<%for.x.prev>
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = SCALAR-STEPS vp<[[VP3]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%gep> = getelementptr ir<%base>, vp<[[VP4]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr i64, ir<%base>, vp<[[VP4]]>
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = vector-pointer i64, ir<%gep>, ir<1>
; CHECK-NEXT: WIDEN ir<%l> = load vp<[[VP5]]>
; CHECK-NEXT: EMIT vp<[[VP6]]> = shl ir<%l>, ir<1>
diff --git a/llvm/test/Transforms/LoopVectorize/VPlan/interleave-and-scalarize-only.ll b/llvm/test/Transforms/LoopVectorize/VPlan/interleave-and-scalarize-only.ll
index 1cc75db39a7b4..27f36c60dc18c 100644
--- a/llvm/test/Transforms/LoopVectorize/VPlan/interleave-and-scalarize-only.ll
+++ b/llvm/test/Transforms/LoopVectorize/VPlan/interleave-and-scalarize-only.ll
@@ -25,7 +25,7 @@ define void @test_scalarize_call(i32 %start, ptr %dst) {
; CHECK-NEXT: vp<[[VP6:%[0-9]+]]> = DERIVED-IV ir<%start> + vp<[[VP5]]> * ir<1>
; CHECK-NEXT: vp<[[VP7:%[0-9]+]]> = SCALAR-STEPS vp<[[VP6]]>, ir<1>, vp<[[VP0]]>
; CHECK-NEXT: CLONE ir<%min> = call @llvm.smin.i32(vp<[[VP7]]>, ir<65535>)
-; CHECK-NEXT: CLONE ir<%arrayidx> = getelementptr inbounds ir<%dst>, vp<[[VP7]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%arrayidx> = getelementptr inbounds i32, ir<%dst>, vp<[[VP7]]>
; CHECK-NEXT: CLONE store ir<%min>, ir<%arrayidx>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<[[VP5]]>, vp<[[VP1]]>
; CHECK-NEXT: EMIT branch-on-count vp<%index.next>, vp<[[VP2]]>
@@ -101,9 +101,9 @@ define void @test_scalarize_with_branch_cond(ptr %src, ptr %dst) {
; CHECK-EMPTY:
; CHECK-NEXT: pred.store.if:
; CHECK-NEXT: vp<[[VP7:%[0-9]+]]> = SCALAR-STEPS vp<[[VP4]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%gep.src> = getelementptr inbounds ir<%src>, vp<[[VP7]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.src> = getelementptr inbounds i32, ir<%src>, vp<[[VP7]]>
; CHECK-NEXT: CLONE ir<%l> = load ir<%gep.src>
-; CHECK-NEXT: CLONE ir<%gep.dst> = getelementptr inbounds ir<%dst>, vp<[[VP7]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.dst> = getelementptr inbounds i32, ir<%dst>, vp<[[VP7]]>
; CHECK-NEXT: CLONE store ir<%l>, ir<%gep.dst>
; CHECK-NEXT: Successor(s): pred.store.continue
; CHECK-EMPTY:
@@ -331,7 +331,7 @@ define void @scalarize_ptrtoint(ptr %src, ptr %dst) {
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = SCALAR-STEPS vp<[[VP3]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%gep> = getelementptr ir<%src>, vp<[[VP4]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr ptr, ir<%src>, vp<[[VP4]]>
; CHECK-NEXT: CLONE ir<%l> = load ir<%gep>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<[[VP3]]>, vp<[[VP1]]>
; CHECK-NEXT: EMIT branch-on-count vp<%index.next>, vp<[[VP2]]>
@@ -407,12 +407,12 @@ define void @pr76986_trunc_sext_interleaving_only(i16 %arg, ptr noalias %src, pt
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = SCALAR-STEPS vp<[[VP3]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%gep.src> = getelementptr inbounds ir<%src>, vp<[[VP4]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.src> = getelementptr inbounds i8, ir<%src>, vp<[[VP4]]>
; CHECK-NEXT: CLONE ir<%l> = load ir<%gep.src>
; CHECK-NEXT: EMIT-SCALAR ir<%sext> = sext ir<%l> to i32
; CHECK-NEXT: EMIT-SCALAR ir<%trunc> = trunc ir<%sext> to i16
; CHECK-NEXT: CLONE ir<%sdiv> = sdiv ir<%trunc>, ir<%arg>
-; CHECK-NEXT: CLONE ir<%gep.dst> = getelementptr inbounds ir<%dst>, vp<[[VP4]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.dst> = getelementptr inbounds i16, ir<%dst>, vp<[[VP4]]>
; CHECK-NEXT: CLONE store ir<%sdiv>, ir<%gep.dst>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<[[VP3]]>, vp<[[VP1]]>
; CHECK-NEXT: EMIT branch-on-count vp<%index.next>, vp<[[VP2]]>
diff --git a/llvm/test/Transforms/LoopVectorize/VPlan/interleave-conditional-scalar-assignment-vplan.ll b/llvm/test/Transforms/LoopVectorize/VPlan/interleave-conditional-scalar-assignment-vplan.ll
index d5e9bb529a487..fcd635c127ab7 100644
--- a/llvm/test/Transforms/LoopVectorize/VPlan/interleave-conditional-scalar-assignment-vplan.ll
+++ b/llvm/test/Transforms/LoopVectorize/VPlan/interleave-conditional-scalar-assignment-vplan.ll
@@ -36,7 +36,7 @@ define i32 @find_last_int_select(i64 %N, ptr %data, i32 %a) {
; IC2-NEXT: WIDEN-REDUCTION-PHI ir<%data.phi>.1 = phi (find-last) ir<-1>, vp<[[VP12:%[0-9]+]]>
; IC2-NEXT: WIDEN-PHI vp<[[VP5:%[0-9]+]]> = phi [ ir<false>, vector.ph ], [ vp<[[VP9:%[0-9]+]]>, vector.body ]
; IC2-NEXT: WIDEN-PHI vp<[[VP6:%[0-9]+]]> = phi [ ir<false>, vector.ph ], [ vp<[[VP10:%[0-9]+]]>, vector.body ]
-; IC2-NEXT: CLONE ir<%ld.addr> = getelementptr inbounds ir<%data>, vp<%index>
+; IC2-NEXT: EMIT-SCALAR ir<%ld.addr> = getelementptr inbounds i32, ir<%data>, vp<%index>
; IC2-NEXT: vp<[[VP7:%[0-9]+]]> = vector-pointer inbounds i32, ir<%ld.addr>, ir<1>, ir<4>
; IC2-NEXT: WIDEN ir<%ld> = load ir<%ld.addr>
; IC2-NEXT: WIDEN ir<%ld>.1 = load vp<[[VP7]]>
@@ -109,7 +109,7 @@ define i32 @find_last_int_select(i64 %N, ptr %data, i32 %a) {
; IC2-TF-NEXT: EMIT vp<%vec.iv>.1 = add nuw vp<[[VP7]]>, vp<[[VP10]]>
; IC2-TF-NEXT: EMIT vp<[[VP11:%[0-9]+]]> = icmp ule vp<%vec.iv>, vp<[[VP3]]>
; IC2-TF-NEXT: EMIT vp<[[VP12:%[0-9]+]]> = icmp ule vp<%vec.iv>.1, vp<[[VP3]]>
-; IC2-TF-NEXT: CLONE ir<%ld.addr> = getelementptr inbounds ir<%data>, vp<%index>
+; IC2-TF-NEXT: EMIT-SCALAR ir<%ld.addr> = getelementptr inbounds i32, ir<%data>, vp<%index>
; IC2-TF-NEXT: vp<[[VP13:%[0-9]+]]> = vector-pointer inbounds i32, ir<%ld.addr>, ir<1>, ir<4>
; IC2-TF-NEXT: WIDEN ir<%ld> = load ir<%ld.addr>, vp<[[VP11]]>
; IC2-TF-NEXT: WIDEN ir<%ld>.1 = load vp<[[VP13]]>, vp<[[VP12]]>
diff --git a/llvm/test/Transforms/LoopVectorize/VPlan/phi-with-fastflags-vplan.ll b/llvm/test/Transforms/LoopVectorize/VPlan/phi-with-fastflags-vplan.ll
index 35ba001b2fb50..1a66d89c879cc 100644
--- a/llvm/test/Transforms/LoopVectorize/VPlan/phi-with-fastflags-vplan.ll
+++ b/llvm/test/Transforms/LoopVectorize/VPlan/phi-with-fastflags-vplan.ll
@@ -20,7 +20,7 @@ define void @f(ptr noalias %p, i1 %c) {
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = SCALAR-STEPS vp<[[VP3]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%gep> = getelementptr ir<%p>, vp<[[VP4]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr float, ir<%p>, vp<[[VP4]]>
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = vector-pointer float, ir<%gep>, ir<1>
; CHECK-NEXT: WIDEN ir<%x> = load vp<[[VP5]]>
; CHECK-NEXT: BLEND ir<%phi> = fast ir<%x> ir<0.000000e+00>/ir<%c>
diff --git a/llvm/test/Transforms/LoopVectorize/VPlan/predicator.ll b/llvm/test/Transforms/LoopVectorize/VPlan/predicator.ll
index 483ab8ad94b50..bab7fd96b5e9c 100644
--- a/llvm/test/Transforms/LoopVectorize/VPlan/predicator.ll
+++ b/llvm/test/Transforms/LoopVectorize/VPlan/predicator.ll
@@ -8,7 +8,7 @@ define void @diamond_phi(ptr %a) {
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION nuw nsw ir<0>, ir<1>, vp<[[VP0:%[0-9]+]]>
-; CHECK-NEXT: EMIT ir<%gep> = getelementptr ir<%a>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr i64, ir<%a>, ir<%iv>
; CHECK-NEXT: EMIT ir<%c0> = icmp sle ir<%iv>, ir<0>
; CHECK-NEXT: Successor(s): bb2
; CHECK-EMPTY:
@@ -73,7 +73,7 @@ define void @mask_reuse(ptr %a) {
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION nuw nsw ir<0>, ir<1>, vp<[[VP0:%[0-9]+]]>
-; CHECK-NEXT: EMIT ir<%gep> = getelementptr ir<%a>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr i64, ir<%a>, ir<%iv>
; CHECK-NEXT: EMIT ir<%c0> = icmp sle ir<%iv>, ir<0>
; CHECK-NEXT: Successor(s): bb1
; CHECK-EMPTY:
@@ -158,7 +158,7 @@ define void @optimized_mask(ptr %a) {
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION nuw nsw ir<0>, ir<1>, vp<[[VP0:%[0-9]+]]>
-; CHECK-NEXT: EMIT ir<%gep> = getelementptr ir<%a>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr i64, ir<%a>, ir<%iv>
; CHECK-NEXT: EMIT ir<%c0> = icmp sle ir<%iv>, ir<0>
; CHECK-NEXT: Successor(s): bb6
; CHECK-EMPTY:
@@ -283,7 +283,7 @@ define void @switch(ptr %a) {
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION nuw nsw ir<0>, ir<1>, vp<[[VP0:%[0-9]+]]>
-; CHECK-NEXT: EMIT ir<%gep> = getelementptr ir<%a>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr i64, ir<%a>, ir<%iv>
; CHECK-NEXT: EMIT ir<%c0> = icmp sle ir<%iv>, ir<0>
; CHECK-NEXT: Successor(s): bb2
; CHECK-EMPTY:
@@ -417,7 +417,7 @@ define void @diamond_phi2(ptr %a, i1 %c1, i1 %c2) {
; CHECK-NEXT: EMIT vp<[[VP6:%[0-9]+]]> = logical-and ir<%c0>, ir<%c1>
; CHECK-NEXT: EMIT vp<[[VP7:%[0-9]+]]> = or vp<[[VP5]]>, vp<[[VP6]]>
; CHECK-NEXT: BLEND ir<%phi> = ir<%add2>/vp<[[VP5]]> ir<%add1>/vp<[[VP6]]>
-; CHECK-NEXT: EMIT ir<%gep> = getelementptr ir<%a>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr i64, ir<%a>, ir<%iv>
; CHECK-NEXT: EMIT store ir<%phi>, ir<%gep>, vp<[[VP7]]>
; CHECK-NEXT: Successor(s): bb5
; CHECK-EMPTY:
@@ -518,7 +518,7 @@ define void @blend_masks(ptr noalias %p, i1 %c0, i1 %c1, i1 %c2, i1 %c3, i1 %c4)
; CHECK-NEXT: EMIT vp<[[VP15:%[0-9]+]]> = logical-and vp<[[VP9]]>, ir<%c4>
; CHECK-NEXT: EMIT vp<[[VP16:%[0-9]+]]> = or vp<[[VP15]]>, vp<[[VP14]]>
; CHECK-NEXT: BLEND ir<%phi> = ir<1>/vp<[[VP15]]> ir<0>/vp<[[VP14]]>
-; CHECK-NEXT: EMIT ir<%gep> = getelementptr ir<%p>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr i32, ir<%p>, ir<%iv>
; CHECK-NEXT: EMIT store ir<%phi>, ir<%gep>, vp<[[VP16]]>
; CHECK-NEXT: Successor(s): bb8
; CHECK-EMPTY:
@@ -604,7 +604,7 @@ define void @blend_masks_triangle_phi(ptr noalias %p, i1 %c0, i1 %c1) {
; CHECK-NEXT: bb3:
; CHECK-NEXT: EMIT vp<[[VP8:%[0-9]+]]> = logical-and ir<%c0>, ir<%c1>
; CHECK-NEXT: BLEND ir<%phi> = ir<1>/vp<[[VP7]]> ir<0>/vp<[[VP8]]>
-; CHECK-NEXT: EMIT ir<%gep> = getelementptr ir<%p>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr i32, ir<%p>, ir<%iv>
; CHECK-NEXT: EMIT store ir<%phi>, ir<%gep>
; CHECK-NEXT: EMIT ir<%iv.next> = add ir<%iv>, ir<1>
; CHECK-NEXT: EMIT ir<%ec> = icmp eq ir<%iv.next>, ir<128>
@@ -649,7 +649,7 @@ define void @blend_chain_non_trivial(ptr noalias %a, ptr noalias %b) {
; CHECK-NEXT: EMIT-SCALAR ir<%lb> = load ir<%b>
; CHECK-NEXT: EMIT ir<%v1> = add ir<%iv>, ir<%lb>
; CHECK-NEXT: EMIT ir<%v2> = mul ir<%iv>, ir<3>
-; CHECK-NEXT: EMIT ir<%gep> = getelementptr ir<%a>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr i64, ir<%a>, ir<%iv>
; CHECK-NEXT: EMIT ir<%c0> = icmp sle ir<%iv>, ir<0>
; CHECK-NEXT: Successor(s): if.a
; CHECK-EMPTY:
@@ -786,7 +786,7 @@ define void @simplifiable_blend(i1 %c1, i1 %c2, i1 %c3, i32 %x, i32 %y, ptr %p)
; CHECK-EMPTY:
; CHECK-NEXT: latch:
; CHECK-NEXT: BLEND ir<%phi> = ir<%y>/vp<[[VP4]]> ir<%x>/ir<%c1>
-; CHECK-NEXT: EMIT ir<%gep> = getelementptr ir<%p>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr i32, ir<%p>, ir<%iv>
; CHECK-NEXT: EMIT store ir<%phi>, ir<%gep>
; CHECK-NEXT: EMIT ir<%iv.next> = add ir<%iv>, ir<1>
; CHECK-NEXT: EMIT ir<%ec> = icmp eq ir<%iv.next>, ir<128>
@@ -860,7 +860,7 @@ define void @phi_doesnt_postdom_incoming(i1 %c1, i1 %c2, i32 %x, i32 %y, ptr %p)
; CHECK-NEXT: EMIT vp<[[VP5:%[0-9]+]]> = logical-and ir<%c1>, ir<%c2>
; CHECK-NEXT: EMIT vp<[[VP6:%[0-9]+]]> = or vp<[[VP4]]>, vp<[[VP5]]>
; CHECK-NEXT: BLEND ir<%phi> = ir<%y>/vp<[[VP4]]> ir<%x>/vp<[[VP5]]>
-; CHECK-NEXT: EMIT ir<%gep> = getelementptr ir<%p>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr i32, ir<%p>, ir<%iv>
; CHECK-NEXT: EMIT store ir<%phi>, ir<%gep>, vp<[[VP6]]>
; CHECK-NEXT: Successor(s): latch
; CHECK-EMPTY:
@@ -922,7 +922,7 @@ define void @phi_switch_same_edge(ptr %p) {
; CHECK-NEXT: EMIT vp<[[VP5:%[0-9]+]]> = icmp eq ir<%iv>, ir<1>
; CHECK-NEXT: EMIT vp<[[VP6:%[0-9]+]]> = or vp<[[VP4]]>, vp<[[VP5]]>
; CHECK-NEXT: EMIT vp<[[VP7:%[0-9]+]]> = not vp<[[VP6]]>
-; CHECK-NEXT: EMIT ir<%gep> = getelementptr ir<%p>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr i32, ir<%p>, ir<%iv>
; CHECK-NEXT: EMIT store ir<0>, ir<%gep>, vp<[[VP6]]>
; CHECK-NEXT: Successor(s): latch
; CHECK-EMPTY:
diff --git a/llvm/test/Transforms/LoopVectorize/VPlan/print-attributes.ll b/llvm/test/Transforms/LoopVectorize/VPlan/print-attributes.ll
index 4c73f77b6f05b..e03618bb8847c 100644
--- a/llvm/test/Transforms/LoopVectorize/VPlan/print-attributes.ll
+++ b/llvm/test/Transforms/LoopVectorize/VPlan/print-attributes.ll
@@ -25,11 +25,11 @@ define void @wide_call_attrs(ptr noalias %in.ptr, ptr noalias %out.ptr) {
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION nuw nsw ir<0>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%in.gep> = getelementptr inbounds ir<%in.ptr>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%in.gep> = getelementptr inbounds double, ir<%in.ptr>, ir<%iv>
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = vector-pointer inbounds double, ir<%in.gep>, ir<1>
; CHECK-NEXT: WIDEN ir<%in> = load vp<[[VP4]]>
; CHECK-NEXT: WIDEN-CALL ir<%call> = call @acos(ir<%in>) (using library function: vec_acos)
-; CHECK-NEXT: CLONE ir<%out.gep> = getelementptr inbounds ir<%out.ptr>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%out.gep> = getelementptr inbounds double, ir<%out.ptr>, ir<%iv>
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = vector-pointer inbounds double, ir<%out.gep>, ir<1>
; CHECK-NEXT: WIDEN store vp<[[VP5]]>, ir<%call>
; CHECK-NEXT: EMIT ir<%iv.next> = add nuw nsw ir<%iv>, ir<1>
@@ -88,8 +88,8 @@ define void @test_intrinsic_with_arg_and_ret_attrs(ptr noalias %A, ptr noalias %
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: ir<%i> = WIDEN-INDUCTION ir<0>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%gep.A> = getelementptr inbounds ir<%A>, ir<%i>
-; CHECK-NEXT: CLONE ir<%gep.B> = getelementptr inbounds ir<%B>, ir<%i>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.A> = getelementptr inbounds float, ir<%A>, ir<%i>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.B> = getelementptr inbounds float, ir<%B>, ir<%i>
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = vector-pointer inbounds float, ir<%gep.A>, ir<1>
; CHECK-NEXT: WIDEN ir<%a> = load vp<[[VP4]]>
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = vector-pointer inbounds float, ir<%gep.B>, ir<1>
diff --git a/llvm/test/Transforms/LoopVectorize/VPlan/scalarize-irregular-type-memops.ll b/llvm/test/Transforms/LoopVectorize/VPlan/scalarize-irregular-type-memops.ll
index c01f2eccf2149..3fa84f125faca 100644
--- a/llvm/test/Transforms/LoopVectorize/VPlan/scalarize-irregular-type-memops.ll
+++ b/llvm/test/Transforms/LoopVectorize/VPlan/scalarize-irregular-type-memops.ll
@@ -18,9 +18,9 @@ define void @scalarize_irregular_types(ptr noalias %p1, ptr noalias %p2) {
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION ir<0>, ir<1>, vp<[[VP0:%[0-9]+]]>
-; CHECK-NEXT: EMIT ir<%gep1> = getelementptr ir<%p1>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep1> = getelementptr [8 x i8], ir<%p1>, ir<%iv>
; CHECK-NEXT: EMIT-SCALAR ir<%load1> = load ir<%gep1>
-; CHECK-NEXT: EMIT ir<%gep2> = getelementptr ir<%p2>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep2> = getelementptr [8 x i8], ir<%p2>, ir<%iv>
; CHECK-NEXT: REPLICATE ir<%load2> = load ir<%gep2>
; CHECK-NEXT: EMIT-SCALAR ir<%load2.zext> = zext ir<%load2> to i64
; CHECK-NEXT: EMIT ir<%add> = add ir<%load1>, ir<%load2.zext>
@@ -39,10 +39,10 @@ define void @scalarize_irregular_types(ptr noalias %p1, ptr noalias %p2) {
; ALL-MEMOP-WIDEN-EMPTY:
; ALL-MEMOP-WIDEN-NEXT: vector.body:
; ALL-MEMOP-WIDEN-NEXT: ir<%iv> = WIDEN-INDUCTION ir<0>, ir<1>, vp<[[VP0:%[0-9]+]]>
-; ALL-MEMOP-WIDEN-NEXT: EMIT ir<%gep1> = getelementptr ir<%p1>, ir<%iv>
+; ALL-MEMOP-WIDEN-NEXT: EMIT-SCALAR ir<%gep1> = getelementptr [8 x i8], ir<%p1>, ir<%iv>
; ALL-MEMOP-WIDEN-NEXT: vp<[[VP4:%[0-9]+]]> = vector-pointer i64, ir<%gep1>, ir<1>
; ALL-MEMOP-WIDEN-NEXT: WIDEN ir<%load1> = load vp<[[VP4]]>
-; ALL-MEMOP-WIDEN-NEXT: EMIT ir<%gep2> = getelementptr ir<%p2>, ir<%iv>
+; ALL-MEMOP-WIDEN-NEXT: EMIT-SCALAR ir<%gep2> = getelementptr [8 x i8], ir<%p2>, ir<%iv>
; ALL-MEMOP-WIDEN-NEXT: REPLICATE ir<%load2> = load ir<%gep2>
; ALL-MEMOP-WIDEN-NEXT: EMIT-SCALAR ir<%load2.zext> = zext ir<%load2> to i64
; ALL-MEMOP-WIDEN-NEXT: EMIT ir<%add> = add ir<%load1>, ir<%load2.zext>
@@ -83,11 +83,11 @@ define void @irregular_gather(ptr noalias %p, ptr noalias %idx, ptr noalias %out
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION ir<0>, ir<1>, vp<[[VP0:%[0-9]+]]>
-; CHECK-NEXT: EMIT ir<%gep.idx> = getelementptr inbounds ir<%idx>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.idx> = getelementptr inbounds i64, ir<%idx>, ir<%iv>
; CHECK-NEXT: EMIT-SCALAR ir<%offset> = load ir<%gep.idx>
-; CHECK-NEXT: EMIT ir<%gep.p> = getelementptr inbounds ir<%p>, ir<%offset>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.p> = getelementptr inbounds i62, ir<%p>, ir<%offset>
; CHECK-NEXT: REPLICATE ir<%v> = load ir<%gep.p>
-; CHECK-NEXT: EMIT ir<%gep.out> = getelementptr inbounds ir<%out>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.out> = getelementptr inbounds i62, ir<%out>, ir<%iv>
; CHECK-NEXT: REPLICATE store ir<%v>, ir<%gep.out>
; CHECK-NEXT: EMIT ir<%iv.next> = add ir<%iv>, ir<1>
; CHECK-NEXT: EMIT ir<%ec> = icmp eq ir<%iv.next>, ir<100>
@@ -103,12 +103,12 @@ define void @irregular_gather(ptr noalias %p, ptr noalias %idx, ptr noalias %out
; ALL-MEMOP-WIDEN-EMPTY:
; ALL-MEMOP-WIDEN-NEXT: vector.body:
; ALL-MEMOP-WIDEN-NEXT: ir<%iv> = WIDEN-INDUCTION ir<0>, ir<1>, vp<[[VP0:%[0-9]+]]>
-; ALL-MEMOP-WIDEN-NEXT: EMIT ir<%gep.idx> = getelementptr inbounds ir<%idx>, ir<%iv>
+; ALL-MEMOP-WIDEN-NEXT: EMIT-SCALAR ir<%gep.idx> = getelementptr inbounds i64, ir<%idx>, ir<%iv>
; ALL-MEMOP-WIDEN-NEXT: vp<[[VP4:%[0-9]+]]> = vector-pointer inbounds i64, ir<%gep.idx>, ir<1>
; ALL-MEMOP-WIDEN-NEXT: WIDEN ir<%offset> = load vp<[[VP4]]>
-; ALL-MEMOP-WIDEN-NEXT: EMIT ir<%gep.p> = getelementptr inbounds ir<%p>, ir<%offset>
+; ALL-MEMOP-WIDEN-NEXT: EMIT-SCALAR ir<%gep.p> = getelementptr inbounds i62, ir<%p>, ir<%offset>
; ALL-MEMOP-WIDEN-NEXT: REPLICATE ir<%v> = load ir<%gep.p>
-; ALL-MEMOP-WIDEN-NEXT: EMIT ir<%gep.out> = getelementptr inbounds ir<%out>, ir<%iv>
+; ALL-MEMOP-WIDEN-NEXT: EMIT-SCALAR ir<%gep.out> = getelementptr inbounds i62, ir<%out>, ir<%iv>
; ALL-MEMOP-WIDEN-NEXT: REPLICATE store ir<%v>, ir<%gep.out>
; ALL-MEMOP-WIDEN-NEXT: EMIT ir<%iv.next> = add ir<%iv>, ir<1>
; ALL-MEMOP-WIDEN-NEXT: EMIT ir<%ec> = icmp eq ir<%iv.next>, ir<100>
diff --git a/llvm/test/Transforms/LoopVectorize/VPlan/simplify-reverse-reverse.ll b/llvm/test/Transforms/LoopVectorize/VPlan/simplify-reverse-reverse.ll
index e836418da28f0..2f105547b3678 100644
--- a/llvm/test/Transforms/LoopVectorize/VPlan/simplify-reverse-reverse.ll
+++ b/llvm/test/Transforms/LoopVectorize/VPlan/simplify-reverse-reverse.ll
@@ -25,11 +25,11 @@ define void @reverse_copy(ptr noalias %src, ptr noalias %dst, i32 %n) {
; CHECK-NEXT: vp<[[VP6:%[0-9]+]]> = DERIVED-IV ir<%n> + vp<[[VP5]]> * ir<-1>
; CHECK-NEXT: vp<[[VP7:%[0-9]+]]> = SCALAR-STEPS vp<[[VP6]]>, ir<-1>, vp<[[VP0]]>
; CHECK-NEXT: CLONE ir<%iv.next> = add nsw vp<[[VP7]]>, ir<-1>
-; CHECK-NEXT: CLONE ir<%gep.src> = getelementptr ir<%src>, ir<%iv.next>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.src> = getelementptr i32, ir<%src>, ir<%iv.next>
; CHECK-NEXT: vp<[[VP8:%[0-9]+]]> = vector-end-pointer i32, ir<%gep.src>, vp<[[VP0]]>
; CHECK-NEXT: WIDEN ir<%x> = load vp<[[VP8]]>
; CHECK-NEXT: EMIT vp<[[VP9:%[0-9]+]]> = reverse ir<%x>
-; CHECK-NEXT: CLONE ir<%gep.dst> = getelementptr ir<%dst>, ir<%iv.next>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.dst> = getelementptr i32, ir<%dst>, ir<%iv.next>
; CHECK-NEXT: vp<[[VP10:%[0-9]+]]> = vector-end-pointer i32, ir<%gep.dst>, vp<[[VP0]]>
; CHECK-NEXT: EMIT vp<[[VP11:%[0-9]+]]> = reverse vp<[[VP9]]>
; CHECK-NEXT: WIDEN store vp<[[VP10]]>, ir<%x>
diff --git a/llvm/test/Transforms/LoopVectorize/VPlan/tail-folding.ll b/llvm/test/Transforms/LoopVectorize/VPlan/tail-folding.ll
index e4bada3c3a4c9..bca499dcd2bcf 100644
--- a/llvm/test/Transforms/LoopVectorize/VPlan/tail-folding.ll
+++ b/llvm/test/Transforms/LoopVectorize/VPlan/tail-folding.ll
@@ -25,7 +25,7 @@ define i32 @live_out(ptr noalias %p, i32 %n) {
; CHECK-NEXT: Successor(s): vector.body.split, vector.latch
; CHECK-EMPTY:
; CHECK-NEXT: vector.body.split:
-; CHECK-NEXT: EMIT ir<%gep> = getelementptr ir<%p>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr i32, ir<%p>, ir<%iv>
; CHECK-NEXT: EMIT-SCALAR ir<%x> = load ir<%gep>
; CHECK-NEXT: EMIT ir<%y> = add ir<%x>, ir<1>
; CHECK-NEXT: EMIT store ir<%y>, ir<%gep>
@@ -115,7 +115,7 @@ define i32 @conditional_live_out(ptr noalias %p, i32 %n, i1 %c) {
; CHECK-NEXT: Successor(s): if, latch
; CHECK-EMPTY:
; CHECK-NEXT: if:
-; CHECK-NEXT: EMIT ir<%gep> = getelementptr ir<%p>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr i32, ir<%p>, ir<%iv>
; CHECK-NEXT: EMIT-SCALAR ir<%x> = load ir<%gep>
; CHECK-NEXT: EMIT ir<%y> = add ir<%x>, ir<1>
; CHECK-NEXT: EMIT store ir<%y>, ir<%gep>
@@ -279,7 +279,7 @@ define i32 @reduction(ptr noalias %p, i32 %n) {
; CHECK-NEXT: Successor(s): vector.body.split, vector.latch
; CHECK-EMPTY:
; CHECK-NEXT: vector.body.split:
-; CHECK-NEXT: EMIT ir<%gep> = getelementptr ir<%p>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr i32, ir<%p>, ir<%iv>
; CHECK-NEXT: EMIT-SCALAR ir<%x> = load ir<%gep>
; CHECK-NEXT: EMIT ir<%rdx.next> = add ir<%rdx>, ir<%x>
; CHECK-NEXT: EMIT ir<%iv.next> = add ir<%iv>, ir<1>
diff --git a/llvm/test/Transforms/LoopVectorize/VPlan/uncountable-early-exit-vplan.ll b/llvm/test/Transforms/LoopVectorize/VPlan/uncountable-early-exit-vplan.ll
index 87c0606029738..655da34694dee 100644
--- a/llvm/test/Transforms/LoopVectorize/VPlan/uncountable-early-exit-vplan.ll
+++ b/llvm/test/Transforms/LoopVectorize/VPlan/uncountable-early-exit-vplan.ll
@@ -24,7 +24,7 @@ define i64 @multi_exiting_to_different_exits_live_in_exit_values() {
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = SCALAR-STEPS vp<[[VP3]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%gep.src> = getelementptr inbounds ir<%src>, vp<[[VP4]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.src> = getelementptr inbounds i32, ir<%src>, vp<[[VP4]]>
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = vector-pointer inbounds i32, ir<%gep.src>, ir<1>
; CHECK-NEXT: WIDEN ir<%l> = load vp<[[VP5]]>
; CHECK-NEXT: WIDEN ir<%c.1> = icmp eq ir<%l>, ir<10>
@@ -111,7 +111,7 @@ define i64 @multi_exiting_to_same_exit_live_in_exit_values() {
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = SCALAR-STEPS vp<[[VP3]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%gep.src> = getelementptr inbounds ir<%src>, vp<[[VP4]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.src> = getelementptr inbounds i32, ir<%src>, vp<[[VP4]]>
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = vector-pointer inbounds i32, ir<%gep.src>, ir<1>
; CHECK-NEXT: WIDEN ir<%l> = load vp<[[VP5]]>
; CHECK-NEXT: WIDEN ir<%c.1> = icmp eq ir<%l>, ir<10>
@@ -191,7 +191,7 @@ define i64 @multi_exiting_to_same_exit_live_in_exit_values_2() {
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = SCALAR-STEPS vp<[[VP3]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%gep.src> = getelementptr inbounds ir<%src>, vp<[[VP4]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.src> = getelementptr inbounds i32, ir<%src>, vp<[[VP4]]>
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = vector-pointer inbounds i32, ir<%gep.src>, ir<1>
; CHECK-NEXT: WIDEN ir<%l> = load vp<[[VP5]]>
; CHECK-NEXT: WIDEN ir<%c.1> = icmp eq ir<%l>, ir<10>
@@ -276,11 +276,11 @@ define i64 @two_early_exits_same_exit_with_constant_live_outs() {
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = SCALAR-STEPS vp<[[VP3]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%gep.A> = getelementptr inbounds ir<%A>, vp<[[VP4]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.A> = getelementptr inbounds i8, ir<%A>, vp<[[VP4]]>
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = vector-pointer inbounds i8, ir<%gep.A>, ir<1>
; CHECK-NEXT: WIDEN ir<%ld.A> = load vp<[[VP5]]>
; CHECK-NEXT: WIDEN ir<%cmp1> = icmp eq ir<%ld.A>, ir<42>
-; CHECK-NEXT: CLONE ir<%gep.B> = getelementptr inbounds ir<%B>, vp<[[VP4]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.B> = getelementptr inbounds i8, ir<%B>, vp<[[VP4]]>
; CHECK-NEXT: vp<[[VP6:%[0-9]+]]> = vector-pointer inbounds i8, ir<%gep.B>, ir<1>
; CHECK-NEXT: WIDEN ir<%ld.B> = load vp<[[VP6]]>
; CHECK-NEXT: WIDEN ir<%cmp2> = icmp eq ir<%ld.A>, ir<%ld.B>
diff --git a/llvm/test/Transforms/LoopVectorize/VPlan/vplan-based-stride-mv.ll b/llvm/test/Transforms/LoopVectorize/VPlan/vplan-based-stride-mv.ll
index ea44f400bf4a3..a954c1f5a02f8 100644
--- a/llvm/test/Transforms/LoopVectorize/VPlan/vplan-based-stride-mv.ll
+++ b/llvm/test/Transforms/LoopVectorize/VPlan/vplan-based-stride-mv.ll
@@ -24,9 +24,9 @@ define void @basic(ptr noalias %p.out, ptr %p, i64 %stride) {
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION nsw ir<0>, ir<1>, vp<[[VP0]]>
; CHECK-NEXT: EMIT ir<%iv.next> = add nsw ir<%iv>, ir<1>
; CHECK-NEXT: EMIT ir<%idx> = mul ir<%iv>, ir<%stride>
-; CHECK-NEXT: EMIT ir<%gep.ld> = getelementptr ir<%p>, ir<%idx>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.ld> = getelementptr i64, ir<%p>, ir<%idx>
; CHECK-NEXT: EMIT-SCALAR ir<%ld> = load ir<%gep.ld>
-; CHECK-NEXT: EMIT ir<%gep.st> = getelementptr ir<%p.out>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.st> = getelementptr i64, ir<%p.out>, ir<%iv>
; CHECK-NEXT: EMIT store ir<%ld>, ir<%gep.st>
; CHECK-NEXT: EMIT ir<%exitcond> = icmp sge ir<%iv.next>, ir<128>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<[[VP3]]>, vp<[[VP1]]>
@@ -91,9 +91,9 @@ define void @basic_optsize(ptr noalias %p.out, ptr %p, i64 %stride) #0 {
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION nsw ir<0>, ir<1>, vp<[[VP0]]>
; CHECK-NEXT: EMIT ir<%iv.next> = add nsw ir<%iv>, ir<1>
; CHECK-NEXT: EMIT ir<%idx> = mul ir<%iv>, ir<%stride>
-; CHECK-NEXT: EMIT ir<%gep.ld> = getelementptr ir<%p>, ir<%idx>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.ld> = getelementptr i64, ir<%p>, ir<%idx>
; CHECK-NEXT: EMIT-SCALAR ir<%ld> = load ir<%gep.ld>
-; CHECK-NEXT: EMIT ir<%gep.st> = getelementptr ir<%p.out>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.st> = getelementptr i64, ir<%p.out>, ir<%iv>
; CHECK-NEXT: EMIT store ir<%ld>, ir<%gep.st>
; CHECK-NEXT: EMIT ir<%exitcond> = icmp sge ir<%iv.next>, ir<128>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<[[VP3]]>, vp<[[VP1]]>
@@ -160,9 +160,9 @@ define void @basic_minsize(ptr noalias %p.out, ptr %p, i64 %stride) #1 {
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION nsw ir<0>, ir<1>, vp<[[VP0]]>
; CHECK-NEXT: EMIT ir<%iv.next> = add nsw ir<%iv>, ir<1>
; CHECK-NEXT: EMIT ir<%idx> = mul ir<%iv>, ir<%stride>
-; CHECK-NEXT: EMIT ir<%gep.ld> = getelementptr ir<%p>, ir<%idx>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.ld> = getelementptr i64, ir<%p>, ir<%idx>
; CHECK-NEXT: EMIT-SCALAR ir<%ld> = load ir<%gep.ld>
-; CHECK-NEXT: EMIT ir<%gep.st> = getelementptr ir<%p.out>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.st> = getelementptr i64, ir<%p.out>, ir<%iv>
; CHECK-NEXT: EMIT store ir<%ld>, ir<%gep.st>
; CHECK-NEXT: EMIT ir<%exitcond> = icmp sge ir<%iv.next>, ir<128>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<[[VP3]]>, vp<[[VP1]]>
@@ -234,9 +234,9 @@ define void @byte_gep_scaled_stride(ptr noalias %p.out, ptr %p, i64 %stride) {
; CHECK-NEXT: EMIT ir<%iv.next> = add nsw ir<%iv>, ir<1>
; CHECK-NEXT: EMIT ir<%stride.x8> = mul ir<%stride>, ir<8>
; CHECK-NEXT: EMIT ir<%idx> = mul ir<%iv>, ir<%stride.x8>
-; CHECK-NEXT: EMIT ir<%gep.ld> = getelementptr ir<%p>, ir<%idx>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.ld> = getelementptr i8, ir<%p>, ir<%idx>
; CHECK-NEXT: EMIT-SCALAR ir<%ld> = load ir<%gep.ld>
-; CHECK-NEXT: EMIT ir<%gep.st> = getelementptr ir<%p.out>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.st> = getelementptr i64, ir<%p.out>, ir<%iv>
; CHECK-NEXT: EMIT store ir<%ld>, ir<%gep.st>
; CHECK-NEXT: EMIT ir<%exitcond> = icmp sge ir<%iv.next>, ir<128>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<[[VP3]]>, vp<[[VP1]]>
@@ -305,9 +305,9 @@ define void @byte_gep_under_scaled_stride(ptr noalias %p.out, ptr %p, i64 %strid
; CHECK-NEXT: EMIT ir<%iv.next> = add nsw ir<%iv>, ir<1>
; CHECK-NEXT: EMIT ir<%stride.x8> = mul ir<%stride>, ir<4>
; CHECK-NEXT: EMIT ir<%idx> = mul ir<%iv>, ir<%stride.x8>
-; CHECK-NEXT: EMIT ir<%gep.ld> = getelementptr ir<%p>, ir<%idx>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.ld> = getelementptr i8, ir<%p>, ir<%idx>
; CHECK-NEXT: EMIT-SCALAR ir<%ld> = load ir<%gep.ld>
-; CHECK-NEXT: EMIT ir<%gep.st> = getelementptr ir<%p.out>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.st> = getelementptr i64, ir<%p.out>, ir<%iv>
; CHECK-NEXT: EMIT store ir<%ld>, ir<%gep.st>
; CHECK-NEXT: EMIT ir<%exitcond> = icmp sge ir<%iv.next>, ir<128>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<[[VP3]]>, vp<[[VP1]]>
@@ -377,9 +377,9 @@ define void @byte_gep_over_scaled_stride(ptr noalias %p.out, ptr %p, i64 %stride
; CHECK-NEXT: EMIT ir<%iv.next> = add nsw ir<%iv>, ir<1>
; CHECK-NEXT: EMIT ir<%stride.x8> = mul ir<%stride>, ir<16>
; CHECK-NEXT: EMIT ir<%idx> = mul ir<%iv>, ir<%stride.x8>
-; CHECK-NEXT: EMIT ir<%gep.ld> = getelementptr ir<%p>, ir<%idx>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.ld> = getelementptr i8, ir<%p>, ir<%idx>
; CHECK-NEXT: EMIT-SCALAR ir<%ld> = load ir<%gep.ld>
-; CHECK-NEXT: EMIT ir<%gep.st> = getelementptr ir<%p.out>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.st> = getelementptr i64, ir<%p.out>, ir<%iv>
; CHECK-NEXT: EMIT store ir<%ld>, ir<%gep.st>
; CHECK-NEXT: EMIT ir<%exitcond> = icmp sge ir<%iv.next>, ir<128>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<[[VP3]]>, vp<[[VP1]]>
@@ -448,9 +448,9 @@ define void @byte_gep_non_power_of_two_scaled_stride(ptr noalias %p.out, ptr %p,
; CHECK-NEXT: EMIT ir<%iv.next> = add nsw ir<%iv>, ir<1>
; CHECK-NEXT: EMIT ir<%stride.x8> = mul ir<%stride>, ir<11>
; CHECK-NEXT: EMIT ir<%idx> = mul ir<%iv>, ir<%stride.x8>
-; CHECK-NEXT: EMIT ir<%gep.ld> = getelementptr ir<%p>, ir<%idx>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.ld> = getelementptr i8, ir<%p>, ir<%idx>
; CHECK-NEXT: EMIT-SCALAR ir<%ld> = load ir<%gep.ld>
-; CHECK-NEXT: EMIT ir<%gep.st> = getelementptr ir<%p.out>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.st> = getelementptr i64, ir<%p.out>, ir<%iv>
; CHECK-NEXT: EMIT store ir<%ld>, ir<%gep.st>
; CHECK-NEXT: EMIT ir<%exitcond> = icmp sge ir<%iv.next>, ir<128>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<[[VP3]]>, vp<[[VP1]]>
@@ -517,9 +517,9 @@ define void @byte_gep_nonscaled_stride(ptr noalias %p.out, ptr %p, i64 %stride)
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION nsw ir<0>, ir<1>, vp<[[VP0]]>
; CHECK-NEXT: EMIT ir<%iv.next> = add nsw ir<%iv>, ir<1>
; CHECK-NEXT: EMIT ir<%idx> = mul ir<%iv>, ir<%stride>
-; CHECK-NEXT: EMIT ir<%gep.ld> = getelementptr ir<%p>, ir<%idx>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.ld> = getelementptr i8, ir<%p>, ir<%idx>
; CHECK-NEXT: EMIT-SCALAR ir<%ld> = load ir<%gep.ld>
-; CHECK-NEXT: EMIT ir<%gep.st> = getelementptr ir<%p.out>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.st> = getelementptr i64, ir<%p.out>, ir<%iv>
; CHECK-NEXT: EMIT store ir<%ld>, ir<%gep.st>
; CHECK-NEXT: EMIT ir<%exitcond> = icmp sge ir<%iv.next>, ir<128>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<[[VP3]]>, vp<[[VP1]]>
@@ -588,9 +588,9 @@ define void @byte_gep_negated_stride(ptr noalias %p.out, ptr %p, i64 %stride) {
; CHECK-NEXT: EMIT ir<%iv.next> = add nsw ir<%iv>, ir<1>
; CHECK-NEXT: EMIT ir<%stride.neg> = sub ir<0>, ir<%stride>
; CHECK-NEXT: EMIT ir<%idx> = mul ir<%iv>, ir<%stride.neg>
-; CHECK-NEXT: EMIT ir<%gep.ld> = getelementptr ir<%p>, ir<%idx>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.ld> = getelementptr i8, ir<%p>, ir<%idx>
; CHECK-NEXT: EMIT-SCALAR ir<%ld> = load ir<%gep.ld>
-; CHECK-NEXT: EMIT ir<%gep.st> = getelementptr ir<%p.out>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.st> = getelementptr i64, ir<%p.out>, ir<%iv>
; CHECK-NEXT: EMIT store ir<%ld>, ir<%gep.st>
; CHECK-NEXT: EMIT ir<%exitcond> = icmp sge ir<%iv.next>, ir<128>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<[[VP3]]>, vp<[[VP1]]>
@@ -657,12 +657,12 @@ define void @shared_stride(ptr noalias %p.out, ptr %p0, ptr %p1, i64 %stride) {
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION nsw ir<0>, ir<1>, vp<[[VP0]]>
; CHECK-NEXT: EMIT ir<%iv.next> = add nsw ir<%iv>, ir<1>
; CHECK-NEXT: EMIT ir<%idx> = mul ir<%iv>, ir<%stride>
-; CHECK-NEXT: EMIT ir<%gep.ld0> = getelementptr ir<%p0>, ir<%idx>
-; CHECK-NEXT: EMIT ir<%gep.ld1> = getelementptr ir<%p1>, ir<%idx>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.ld0> = getelementptr i64, ir<%p0>, ir<%idx>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.ld1> = getelementptr i64, ir<%p1>, ir<%idx>
; CHECK-NEXT: EMIT-SCALAR ir<%ld0> = load ir<%gep.ld0>
; CHECK-NEXT: EMIT-SCALAR ir<%ld1> = load ir<%gep.ld1>
; CHECK-NEXT: EMIT ir<%val> = add ir<%ld0>, ir<%ld1>
-; CHECK-NEXT: EMIT ir<%gep.st> = getelementptr ir<%p.out>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.st> = getelementptr i64, ir<%p.out>, ir<%iv>
; CHECK-NEXT: EMIT store ir<%val>, ir<%gep.st>
; CHECK-NEXT: EMIT ir<%exitcond> = icmp sge ir<%iv.next>, ir<128>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<[[VP3]]>, vp<[[VP1]]>
@@ -732,12 +732,12 @@ define void @independent_strides(ptr noalias %p.out, ptr %p0, ptr %p1, i64 %stri
; CHECK-NEXT: EMIT ir<%iv.next> = add nsw ir<%iv>, ir<1>
; CHECK-NEXT: EMIT ir<%idx0> = mul ir<%iv>, ir<%stride0>
; CHECK-NEXT: EMIT ir<%idx1> = mul ir<%iv>, ir<%stride1>
-; CHECK-NEXT: EMIT ir<%gep.ld0> = getelementptr ir<%p0>, ir<%idx0>
-; CHECK-NEXT: EMIT ir<%gep.ld1> = getelementptr ir<%p1>, ir<%idx1>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.ld0> = getelementptr i64, ir<%p0>, ir<%idx0>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.ld1> = getelementptr i64, ir<%p1>, ir<%idx1>
; CHECK-NEXT: EMIT-SCALAR ir<%ld0> = load ir<%gep.ld0>
; CHECK-NEXT: EMIT-SCALAR ir<%ld1> = load ir<%gep.ld1>
; CHECK-NEXT: EMIT ir<%val> = add ir<%ld0>, ir<%ld1>
-; CHECK-NEXT: EMIT ir<%gep.st> = getelementptr ir<%p.out>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.st> = getelementptr i64, ir<%p.out>, ir<%iv>
; CHECK-NEXT: EMIT store ir<%val>, ir<%gep.st>
; CHECK-NEXT: EMIT ir<%exitcond> = icmp sge ir<%iv.next>, ir<128>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<[[VP3]]>, vp<[[VP1]]>
@@ -809,12 +809,12 @@ define void @dependent_strides(ptr noalias %p.out, ptr %p0, ptr %p1, i64 %stride
; CHECK-NEXT: EMIT ir<%stride1> = add ir<%stride>, ir<1>
; CHECK-NEXT: EMIT ir<%idx0> = mul ir<%iv>, ir<%stride>
; CHECK-NEXT: EMIT ir<%idx1> = mul ir<%iv>, ir<%stride1>
-; CHECK-NEXT: EMIT ir<%gep.ld0> = getelementptr ir<%p0>, ir<%idx0>
-; CHECK-NEXT: EMIT ir<%gep.ld1> = getelementptr ir<%p1>, ir<%idx1>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.ld0> = getelementptr i64, ir<%p0>, ir<%idx0>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.ld1> = getelementptr i64, ir<%p1>, ir<%idx1>
; CHECK-NEXT: EMIT-SCALAR ir<%ld0> = load ir<%gep.ld0>
; CHECK-NEXT: EMIT-SCALAR ir<%ld1> = load ir<%gep.ld1>
; CHECK-NEXT: EMIT ir<%val> = add ir<%ld0>, ir<%ld1>
-; CHECK-NEXT: EMIT ir<%gep.st> = getelementptr ir<%p.out>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.st> = getelementptr i64, ir<%p.out>, ir<%iv>
; CHECK-NEXT: EMIT store ir<%val>, ir<%gep.st>
; CHECK-NEXT: EMIT ir<%exitcond> = icmp sge ir<%iv.next>, ir<128>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<[[VP3]]>, vp<[[VP1]]>
@@ -889,12 +889,12 @@ define void @dependent_strides_reverse_order(ptr noalias %p.out, ptr %p0, ptr %p
; CHECK-NEXT: EMIT ir<%stride0> = add ir<%stride>, ir<1>
; CHECK-NEXT: EMIT ir<%idx0> = mul ir<%iv>, ir<%stride0>
; CHECK-NEXT: EMIT ir<%idx1> = mul ir<%iv>, ir<%stride>
-; CHECK-NEXT: EMIT ir<%gep.ld0> = getelementptr ir<%p0>, ir<%idx0>
-; CHECK-NEXT: EMIT ir<%gep.ld1> = getelementptr ir<%p1>, ir<%idx1>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.ld0> = getelementptr i64, ir<%p0>, ir<%idx0>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.ld1> = getelementptr i64, ir<%p1>, ir<%idx1>
; CHECK-NEXT: EMIT-SCALAR ir<%ld0> = load ir<%gep.ld0>
; CHECK-NEXT: EMIT-SCALAR ir<%ld1> = load ir<%gep.ld1>
; CHECK-NEXT: EMIT ir<%val> = add ir<%ld0>, ir<%ld1>
-; CHECK-NEXT: EMIT ir<%gep.st> = getelementptr ir<%p.out>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.st> = getelementptr i64, ir<%p.out>, ir<%iv>
; CHECK-NEXT: EMIT store ir<%val>, ir<%gep.st>
; CHECK-NEXT: EMIT ir<%exitcond> = icmp sge ir<%iv.next>, ir<128>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<[[VP3]]>, vp<[[VP1]]>
@@ -966,13 +966,13 @@ define void @byte_dependent_byte_geps(ptr noalias %p.out, ptr %p0, ptr %p1, i64
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION nsw ir<0>, ir<1>, vp<[[VP0]]>
; CHECK-NEXT: EMIT ir<%iv.next> = add nsw ir<%iv>, ir<1>
; CHECK-NEXT: EMIT ir<%idx> = mul ir<%iv>, ir<%stride>
-; CHECK-NEXT: EMIT ir<%gep.ld0> = getelementptr ir<%p0>, ir<%idx>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.ld0> = getelementptr i8, ir<%p0>, ir<%idx>
; CHECK-NEXT: EMIT-SCALAR ir<%ld0> = load ir<%gep.ld0>
-; CHECK-NEXT: EMIT ir<%gep.ld1> = getelementptr ir<%p1>, ir<%idx>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.ld1> = getelementptr i8, ir<%p1>, ir<%idx>
; CHECK-NEXT: EMIT-SCALAR ir<%ld1> = load ir<%gep.ld1>
; CHECK-NEXT: EMIT-SCALAR ir<%ld1.ext> = sext ir<%ld1> to i64
; CHECK-NEXT: EMIT ir<%val> = add ir<%ld0>, ir<%ld1.ext>
-; CHECK-NEXT: EMIT ir<%gep.st> = getelementptr ir<%p.out>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.st> = getelementptr i64, ir<%p.out>, ir<%iv>
; CHECK-NEXT: EMIT store ir<%val>, ir<%gep.st>
; CHECK-NEXT: EMIT ir<%exitcond> = icmp sge ir<%iv.next>, ir<128>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<[[VP3]]>, vp<[[VP1]]>
@@ -1044,13 +1044,13 @@ define void @byte_dependent_byte_geps_reverse_order(ptr noalias %p.out, ptr %p0,
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION nsw ir<0>, ir<1>, vp<[[VP0]]>
; CHECK-NEXT: EMIT ir<%iv.next> = add nsw ir<%iv>, ir<1>
; CHECK-NEXT: EMIT ir<%idx> = mul ir<%iv>, ir<%stride>
-; CHECK-NEXT: EMIT ir<%gep.ld1> = getelementptr ir<%p1>, ir<%idx>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.ld1> = getelementptr i8, ir<%p1>, ir<%idx>
; CHECK-NEXT: EMIT-SCALAR ir<%ld1> = load ir<%gep.ld1>
; CHECK-NEXT: EMIT-SCALAR ir<%ld1.ext> = sext ir<%ld1> to i64
-; CHECK-NEXT: EMIT ir<%gep.ld0> = getelementptr ir<%p0>, ir<%idx>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.ld0> = getelementptr i8, ir<%p0>, ir<%idx>
; CHECK-NEXT: EMIT-SCALAR ir<%ld0> = load ir<%gep.ld0>
; CHECK-NEXT: EMIT ir<%val> = add ir<%ld0>, ir<%ld1.ext>
-; CHECK-NEXT: EMIT ir<%gep.st> = getelementptr ir<%p.out>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.st> = getelementptr i64, ir<%p.out>, ir<%iv>
; CHECK-NEXT: EMIT store ir<%val>, ir<%gep.st>
; CHECK-NEXT: EMIT ir<%exitcond> = icmp sge ir<%iv.next>, ir<128>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<[[VP3]]>, vp<[[VP1]]>
@@ -1124,12 +1124,12 @@ define void @strided_interleave(ptr noalias %p.out, ptr %p, i64 %stride) {
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION nsw ir<0>, ir<1>, vp<[[VP0]]>
; CHECK-NEXT: EMIT ir<%iv.next> = add nsw ir<%iv>, ir<1>
; CHECK-NEXT: EMIT ir<%idx> = mul ir<%iv>, ir<%stride>
-; CHECK-NEXT: EMIT ir<%gep.ld0> = getelementptr ir<%p>, ir<%idx>
-; CHECK-NEXT: EMIT ir<%gep.ld1> = getelementptr ir<%gep.ld0>, ir<1>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.ld0> = getelementptr i64, ir<%p>, ir<%idx>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.ld1> = getelementptr i64, ir<%gep.ld0>, ir<1>
; CHECK-NEXT: EMIT-SCALAR ir<%ld0> = load ir<%gep.ld0>
; CHECK-NEXT: EMIT-SCALAR ir<%ld1> = load ir<%gep.ld1>
; CHECK-NEXT: EMIT ir<%val> = add ir<%ld0>, ir<%ld1>
-; CHECK-NEXT: EMIT ir<%gep.st> = getelementptr ir<%p.out>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.st> = getelementptr i64, ir<%p.out>, ir<%iv>
; CHECK-NEXT: EMIT store ir<%val>, ir<%gep.st>
; CHECK-NEXT: EMIT ir<%exitcond> = icmp sge ir<%iv.next>, ir<128>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<[[VP3]]>, vp<[[VP1]]>
@@ -1201,10 +1201,10 @@ define void @in_loop_base(ptr noalias %p.out, ptr %p, i64 %stride, i64 %offset)
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION nsw ir<0>, ir<1>, vp<[[VP0]]>
; CHECK-NEXT: EMIT ir<%iv.next> = add nsw ir<%iv>, ir<1>
; CHECK-NEXT: EMIT ir<%mul> = mul ir<%iv>, ir<%stride>
-; CHECK-NEXT: EMIT ir<%gep.ld.base> = getelementptr ir<%p>, ir<%offset>
-; CHECK-NEXT: EMIT ir<%gep.ld> = getelementptr ir<%gep.ld.base>, ir<%mul>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.ld.base> = getelementptr i64, ir<%p>, ir<%offset>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.ld> = getelementptr i64, ir<%gep.ld.base>, ir<%mul>
; CHECK-NEXT: EMIT-SCALAR ir<%ld> = load ir<%gep.ld>
-; CHECK-NEXT: EMIT ir<%gep.st> = getelementptr ir<%p.out>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.st> = getelementptr i64, ir<%p.out>, ir<%iv>
; CHECK-NEXT: EMIT store ir<%ld>, ir<%gep.st>
; CHECK-NEXT: EMIT ir<%exitcond> = icmp sge ir<%iv.next>, ir<128>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<[[VP3]]>, vp<[[VP1]]>
@@ -1274,9 +1274,9 @@ define void @base_not_in_ir(ptr noalias %p.out, ptr %p, i64 %stride, i64 %offset
; CHECK-NEXT: EMIT ir<%iv.next> = add nsw ir<%iv>, ir<1>
; CHECK-NEXT: EMIT ir<%mul> = mul ir<%iv>, ir<%stride>
; CHECK-NEXT: EMIT ir<%idx> = add ir<%mul>, ir<%offset>
-; CHECK-NEXT: EMIT ir<%gep.ld> = getelementptr ir<%p>, ir<%idx>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.ld> = getelementptr i64, ir<%p>, ir<%idx>
; CHECK-NEXT: EMIT-SCALAR ir<%ld> = load ir<%gep.ld>
-; CHECK-NEXT: EMIT ir<%gep.st> = getelementptr ir<%p.out>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.st> = getelementptr i64, ir<%p.out>, ir<%iv>
; CHECK-NEXT: EMIT store ir<%ld>, ir<%gep.st>
; CHECK-NEXT: EMIT ir<%exitcond> = icmp sge ir<%iv.next>, ir<128>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<[[VP3]]>, vp<[[VP1]]>
@@ -1346,9 +1346,9 @@ define void @non_invariant_uniform_base(ptr noalias %p.out, ptr %p, i64 %stride)
; CHECK-NEXT: EMIT ir<%iv.sdiv32> = sdiv ir<%iv>, ir<32>
; CHECK-NEXT: EMIT ir<%mul> = mul ir<%iv>, ir<%stride>
; CHECK-NEXT: EMIT ir<%idx> = add ir<%mul>, ir<%iv.sdiv32>
-; CHECK-NEXT: EMIT ir<%gep.ld> = getelementptr ir<%p>, ir<%idx>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.ld> = getelementptr i64, ir<%p>, ir<%idx>
; CHECK-NEXT: EMIT-SCALAR ir<%ld> = load ir<%gep.ld>
-; CHECK-NEXT: EMIT ir<%gep.st> = getelementptr ir<%p.out>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.st> = getelementptr i64, ir<%p.out>, ir<%iv>
; CHECK-NEXT: EMIT store ir<%ld>, ir<%gep.st>
; CHECK-NEXT: EMIT ir<%exitcond> = icmp sge ir<%iv.next>, ir<128>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<[[VP3]]>, vp<[[VP1]]>
@@ -1416,12 +1416,12 @@ define void @non_invariant_uniform_stride(ptr noalias %p.out, ptr %p, ptr %p.uni
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION nsw ir<0>, ir<1>, vp<[[VP0]]>
; CHECK-NEXT: EMIT ir<%iv.next> = add nsw ir<%iv>, ir<1>
; CHECK-NEXT: EMIT ir<%iv.sdiv32> = sdiv ir<%iv>, ir<32>
-; CHECK-NEXT: EMIT ir<%gep.uni> = getelementptr ir<%p.uni>, ir<%iv.sdiv32>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.uni> = getelementptr i64, ir<%p.uni>, ir<%iv.sdiv32>
; CHECK-NEXT: EMIT-SCALAR ir<%stride> = load ir<%gep.uni>
; CHECK-NEXT: EMIT ir<%idx> = mul ir<%iv>, ir<%stride>
-; CHECK-NEXT: EMIT ir<%gep.ld> = getelementptr ir<%p>, ir<%idx>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.ld> = getelementptr i64, ir<%p>, ir<%idx>
; CHECK-NEXT: EMIT-SCALAR ir<%ld> = load ir<%gep.ld>
-; CHECK-NEXT: EMIT ir<%gep.st> = getelementptr ir<%p.out>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.st> = getelementptr i64, ir<%p.out>, ir<%iv>
; CHECK-NEXT: EMIT store ir<%ld>, ir<%gep.st>
; CHECK-NEXT: EMIT ir<%exitcond> = icmp sge ir<%iv.next>, ir<128>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<[[VP3]]>, vp<[[VP1]]>
@@ -1496,9 +1496,9 @@ define void @non_constant_btc(ptr noalias %p.out, ptr %p, i64 %stride, i64 %n) {
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION nsw ir<0>, ir<1>, vp<[[VP0]]>
; CHECK-NEXT: EMIT ir<%iv.next> = add nsw ir<%iv>, ir<1>
; CHECK-NEXT: EMIT ir<%idx> = mul ir<%iv>, ir<%stride>
-; CHECK-NEXT: EMIT ir<%gep.ld> = getelementptr ir<%p>, ir<%idx>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.ld> = getelementptr i64, ir<%p>, ir<%idx>
; CHECK-NEXT: EMIT-SCALAR ir<%ld> = load ir<%gep.ld>
-; CHECK-NEXT: EMIT ir<%gep.st> = getelementptr ir<%p.out>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.st> = getelementptr i64, ir<%p.out>, ir<%iv>
; CHECK-NEXT: EMIT store ir<%ld>, ir<%gep.st>
; CHECK-NEXT: EMIT ir<%exitcond> = icmp sge ir<%iv.next>, ir<%n>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<[[VP4]]>, vp<[[VP1]]>
@@ -1566,9 +1566,9 @@ define void @stride_as_btc(ptr noalias %p.out, ptr %p, i64 %stride) {
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION nsw ir<0>, ir<1>, vp<[[VP0]]>
; CHECK-NEXT: EMIT ir<%iv.next> = add nsw ir<%iv>, ir<1>
; CHECK-NEXT: EMIT ir<%idx> = mul ir<%iv>, ir<%stride>
-; CHECK-NEXT: EMIT ir<%gep.ld> = getelementptr ir<%p>, ir<%idx>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.ld> = getelementptr i64, ir<%p>, ir<%idx>
; CHECK-NEXT: EMIT-SCALAR ir<%ld> = load ir<%gep.ld>
-; CHECK-NEXT: EMIT ir<%gep.st> = getelementptr ir<%p.out>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.st> = getelementptr i64, ir<%p.out>, ir<%iv>
; CHECK-NEXT: EMIT store ir<%ld>, ir<%gep.st>
; CHECK-NEXT: EMIT ir<%exitcond> = icmp sge ir<%iv.next>, ir<%stride>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<[[VP4]]>, vp<[[VP1]]>
@@ -1637,9 +1637,9 @@ define void @stride_dependent_btc(ptr noalias %p.out, ptr %p, i64 %stride) {
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION nsw ir<0>, ir<1>, vp<[[VP0]]>
; CHECK-NEXT: EMIT ir<%iv.next> = add nsw ir<%iv>, ir<1>
; CHECK-NEXT: EMIT ir<%idx> = mul ir<%iv>, ir<%stride>
-; CHECK-NEXT: EMIT ir<%gep.ld> = getelementptr ir<%p>, ir<%idx>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.ld> = getelementptr i64, ir<%p>, ir<%idx>
; CHECK-NEXT: EMIT-SCALAR ir<%ld> = load ir<%gep.ld>
-; CHECK-NEXT: EMIT ir<%gep.st> = getelementptr ir<%p.out>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.st> = getelementptr i64, ir<%p.out>, ir<%iv>
; CHECK-NEXT: EMIT store ir<%ld>, ir<%gep.st>
; CHECK-NEXT: EMIT ir<%exitcond> = icmp sge ir<%iv.next>, ir<%n>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<[[VP4]]>, vp<[[VP1]]>
@@ -1710,9 +1710,9 @@ define void @stride_btc_checks_order(ptr noalias %p.out, ptr %p, i64 %stride, i6
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION nsw ir<0>, ir<1>, vp<[[VP0]]>
; CHECK-NEXT: EMIT ir<%iv.next> = add nsw ir<%iv>, ir<1>
; CHECK-NEXT: EMIT ir<%idx> = mul ir<%iv>, ir<%stride>
-; CHECK-NEXT: EMIT ir<%gep.ld> = getelementptr ir<%p>, ir<%idx>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.ld> = getelementptr i64, ir<%p>, ir<%idx>
; CHECK-NEXT: EMIT-SCALAR ir<%ld> = load ir<%gep.ld>
-; CHECK-NEXT: EMIT ir<%gep.st> = getelementptr ir<%p.out>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.st> = getelementptr i64, ir<%p.out>, ir<%iv>
; CHECK-NEXT: EMIT store ir<%ld>, ir<%gep.st>
; CHECK-NEXT: EMIT ir<%exitcond> = icmp sge ir<%iv.next>, ir<%n>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<[[VP4]]>, vp<[[VP1]]>
@@ -1781,9 +1781,9 @@ define void @stride_dependent_btc_non_preventive(ptr noalias %p.out, ptr %p, i64
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION nsw ir<0>, ir<1>, vp<[[VP0]]>
; CHECK-NEXT: EMIT ir<%iv.next> = add nsw ir<%iv>, ir<1>
; CHECK-NEXT: EMIT ir<%idx> = mul ir<%iv>, ir<%stride>
-; CHECK-NEXT: EMIT ir<%gep.ld> = getelementptr ir<%p>, ir<%idx>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.ld> = getelementptr i64, ir<%p>, ir<%idx>
; CHECK-NEXT: EMIT-SCALAR ir<%ld> = load ir<%gep.ld>
-; CHECK-NEXT: EMIT ir<%gep.st> = getelementptr ir<%p.out>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.st> = getelementptr i64, ir<%p.out>, ir<%iv>
; CHECK-NEXT: EMIT store ir<%ld>, ir<%gep.st>
; CHECK-NEXT: EMIT ir<%exitcond> = icmp sge ir<%iv.next>, ir<%n>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<[[VP4]]>, vp<[[VP1]]>
@@ -1885,12 +1885,12 @@ define void @stride_btc_independent_memdep_triple_check(ptr %p, ptr noalias %p2,
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION nsw ir<0>, ir<1>, vp<[[VP0]]>
; CHECK-NEXT: EMIT ir<%iv.next> = add nsw ir<%iv>, ir<1>
; CHECK-NEXT: EMIT ir<%idx> = mul ir<%iv>, ir<%stride>
-; CHECK-NEXT: EMIT ir<%gep.ld> = getelementptr ir<%p>, ir<%idx>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.ld> = getelementptr i64, ir<%p>, ir<%idx>
; CHECK-NEXT: EMIT-SCALAR ir<%ld> = load ir<%gep.ld>
-; CHECK-NEXT: EMIT ir<%gep.ld2> = getelementptr ir<%p2>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.ld2> = getelementptr i64, ir<%p2>, ir<%iv>
; CHECK-NEXT: EMIT-SCALAR ir<%ld2> = load ir<%gep.ld2>
; CHECK-NEXT: EMIT ir<%val> = add ir<%ld>, ir<%ld2>
-; CHECK-NEXT: EMIT ir<%gep.st> = getelementptr ir<%p.out>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.st> = getelementptr i64, ir<%p.out>, ir<%iv>
; CHECK-NEXT: EMIT store ir<%val>, ir<%gep.st>
; CHECK-NEXT: EMIT ir<%exitcond> = icmp sge ir<%iv.next>, ir<%n>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<[[VP4]]>, vp<[[VP1]]>
@@ -1962,10 +1962,10 @@ define void @actual_stride_not_in_ir(ptr noalias %p.out, ptr %p, i64 %stride) {
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION nsw ir<0>, ir<1>, vp<[[VP0]]>
; CHECK-NEXT: EMIT ir<%iv.next> = add nsw ir<%iv>, ir<1>
; CHECK-NEXT: EMIT ir<%idx> = mul ir<%iv>, ir<%stride>
-; CHECK-NEXT: EMIT ir<%base> = getelementptr ir<%p>, ir<%idx>
-; CHECK-NEXT: EMIT ir<%gep.ld> = getelementptr ir<%base>, ir<%idx>
+; CHECK-NEXT: EMIT-SCALAR ir<%base> = getelementptr i64, ir<%p>, ir<%idx>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.ld> = getelementptr i64, ir<%base>, ir<%idx>
; CHECK-NEXT: EMIT-SCALAR ir<%ld> = load ir<%gep.ld>
-; CHECK-NEXT: EMIT ir<%gep.st> = getelementptr ir<%p.out>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.st> = getelementptr i64, ir<%p.out>, ir<%iv>
; CHECK-NEXT: EMIT store ir<%ld>, ir<%gep.st>
; CHECK-NEXT: EMIT ir<%exitcond> = icmp sge ir<%iv.next>, ir<128>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<[[VP3]]>, vp<[[VP1]]>
@@ -2034,9 +2034,9 @@ define void @nd_array_last_idx(ptr noalias %p.out, ptr %p, i64 %stride) {
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION nsw ir<0>, ir<1>, vp<[[VP0]]>
; CHECK-NEXT: EMIT ir<%iv.next> = add nsw ir<%iv>, ir<1>
; CHECK-NEXT: EMIT ir<%idx> = mul ir<%iv>, ir<%stride>
-; CHECK-NEXT: EMIT ir<%gep.ld> = getelementptr ir<%p>, ir<1>, ir<42>, ir<%idx>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.ld> = getelementptr [256 x [256 x i64]], ir<%p>, ir<1>, ir<42>, ir<%idx>
; CHECK-NEXT: EMIT-SCALAR ir<%ld> = load ir<%gep.ld>
-; CHECK-NEXT: EMIT ir<%gep.st> = getelementptr ir<%p.out>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.st> = getelementptr i64, ir<%p.out>, ir<%iv>
; CHECK-NEXT: EMIT store ir<%ld>, ir<%gep.st>
; CHECK-NEXT: EMIT ir<%exitcond> = icmp sge ir<%iv.next>, ir<128>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<[[VP3]]>, vp<[[VP1]]>
@@ -2104,9 +2104,9 @@ define void @nd_array_non_last_idx(ptr noalias %p.out, ptr %p, i64 %stride) {
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION nsw ir<0>, ir<1>, vp<[[VP0]]>
; CHECK-NEXT: EMIT ir<%iv.next> = add nsw ir<%iv>, ir<1>
; CHECK-NEXT: EMIT ir<%idx> = mul ir<%iv>, ir<%stride>
-; CHECK-NEXT: EMIT ir<%gep.ld> = getelementptr ir<%p>, ir<1>, ir<%idx>, ir<42>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.ld> = getelementptr [256 x [256 x i64]], ir<%p>, ir<1>, ir<%idx>, ir<42>
; CHECK-NEXT: EMIT-SCALAR ir<%ld> = load ir<%gep.ld>
-; CHECK-NEXT: EMIT ir<%gep.st> = getelementptr ir<%p.out>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.st> = getelementptr i64, ir<%p.out>, ir<%iv>
; CHECK-NEXT: EMIT store ir<%ld>, ir<%gep.st>
; CHECK-NEXT: EMIT ir<%exitcond> = icmp sge ir<%iv.next>, ir<128>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<[[VP3]]>, vp<[[VP1]]>
@@ -2172,9 +2172,9 @@ define void @nd_array_multiple_idxs(ptr noalias %p.out, ptr %p, i64 %stride) {
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION nsw ir<0>, ir<1>, vp<[[VP0]]>
; CHECK-NEXT: EMIT ir<%iv.next> = add nsw ir<%iv>, ir<1>
; CHECK-NEXT: EMIT ir<%idx> = mul ir<%iv>, ir<%stride>
-; CHECK-NEXT: EMIT ir<%gep.ld> = getelementptr ir<%p>, ir<1>, ir<%idx>, ir<%idx>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.ld> = getelementptr [256 x [256 x i64]], ir<%p>, ir<1>, ir<%idx>, ir<%idx>
; CHECK-NEXT: EMIT-SCALAR ir<%ld> = load ir<%gep.ld>
-; CHECK-NEXT: EMIT ir<%gep.st> = getelementptr ir<%p.out>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.st> = getelementptr i64, ir<%p.out>, ir<%iv>
; CHECK-NEXT: EMIT store ir<%ld>, ir<%gep.st>
; CHECK-NEXT: EMIT ir<%exitcond> = icmp sge ir<%iv.next>, ir<128>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<[[VP3]]>, vp<[[VP1]]>
@@ -2241,9 +2241,9 @@ define void @sext_stride(ptr noalias %p.out, ptr %p, i32 %stride.i32) {
; CHECK-NEXT: EMIT-SCALAR ir<%stride> = sext ir<%stride.i32> to i64
; CHECK-NEXT: EMIT ir<%iv.next> = add nsw ir<%iv>, ir<1>
; CHECK-NEXT: EMIT ir<%idx> = mul ir<%iv>, ir<%stride>
-; CHECK-NEXT: EMIT ir<%gep.ld> = getelementptr ir<%p>, ir<%idx>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.ld> = getelementptr i64, ir<%p>, ir<%idx>
; CHECK-NEXT: EMIT-SCALAR ir<%ld> = load ir<%gep.ld>
-; CHECK-NEXT: EMIT ir<%gep.st> = getelementptr ir<%p.out>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.st> = getelementptr i64, ir<%p.out>, ir<%iv>
; CHECK-NEXT: EMIT store ir<%ld>, ir<%gep.st>
; CHECK-NEXT: EMIT ir<%exitcond> = icmp sge ir<%iv.next>, ir<128>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<[[VP3]]>, vp<[[VP1]]>
@@ -2311,9 +2311,9 @@ define void @trunc_stride(ptr noalias %p.out, ptr %p, i64 %stride.i64) {
; CHECK-NEXT: EMIT-SCALAR ir<%stride> = trunc ir<%stride.i64> to i32
; CHECK-NEXT: EMIT ir<%iv.next> = add nsw ir<%iv>, ir<1>
; CHECK-NEXT: EMIT ir<%idx> = mul ir<%iv>, ir<%stride>
-; CHECK-NEXT: EMIT ir<%gep.ld> = getelementptr ir<%p>, ir<%idx>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.ld> = getelementptr i32, ir<%p>, ir<%idx>
; CHECK-NEXT: EMIT-SCALAR ir<%ld> = load ir<%gep.ld>
-; CHECK-NEXT: EMIT ir<%gep.st> = getelementptr ir<%p.out>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.st> = getelementptr i32, ir<%p.out>, ir<%iv>
; CHECK-NEXT: EMIT store ir<%ld>, ir<%gep.st>
; CHECK-NEXT: EMIT ir<%exitcond> = icmp sge ir<%iv.next>, ir<128>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<[[VP3]]>, vp<[[VP1]]>
@@ -2385,12 +2385,12 @@ define void @trunc_ext_stride(ptr noalias %p.out, ptr %p0, ptr %p1, i32 %stride)
; CHECK-NEXT: EMIT-SCALAR ir<%iv.ext> = sext ir<%iv> to i64
; CHECK-NEXT: EMIT ir<%idx.trunc> = mul ir<%iv.trunc>, ir<%stride.trunc>
; CHECK-NEXT: EMIT ir<%idx.ext> = mul ir<%iv.ext>, ir<%stride.ext>
-; CHECK-NEXT: EMIT ir<%gep.trunc> = getelementptr ir<%p0>, ir<%idx.trunc>
-; CHECK-NEXT: EMIT ir<%gep.ext> = getelementptr ir<%p0>, ir<%idx.ext>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.trunc> = getelementptr i32, ir<%p0>, ir<%idx.trunc>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.ext> = getelementptr i32, ir<%p0>, ir<%idx.ext>
; CHECK-NEXT: EMIT-SCALAR ir<%ld.trunc> = load ir<%gep.trunc>
; CHECK-NEXT: EMIT-SCALAR ir<%ld.ext> = load ir<%gep.ext>
; CHECK-NEXT: EMIT ir<%val> = add ir<%ld.trunc>, ir<%ld.ext>
-; CHECK-NEXT: EMIT ir<%gep.st> = getelementptr ir<%p.out>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.st> = getelementptr i32, ir<%p.out>, ir<%iv>
; CHECK-NEXT: EMIT store ir<%val>, ir<%gep.st>
; CHECK-NEXT: EMIT ir<%exitcond> = icmp sge ir<%iv.next>, ir<128>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<[[VP3]]>, vp<[[VP1]]>
@@ -2472,9 +2472,9 @@ define void @basic_masked(ptr noalias %p.out, ptr %p, i64 %stride, i64 %x) {
; CHECK-EMPTY:
; CHECK-NEXT: if:
; CHECK-NEXT: EMIT ir<%idx> = mul ir<%iv>, ir<%stride>, ir<%c>
-; CHECK-NEXT: EMIT ir<%gep.ld> = getelementptr ir<%p>, ir<%idx>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.ld> = getelementptr i64, ir<%p>, ir<%idx>
; CHECK-NEXT: EMIT-SCALAR ir<%ld> = load ir<%gep.ld>, ir<%c>
-; CHECK-NEXT: EMIT ir<%gep.st> = getelementptr ir<%p.out>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.st> = getelementptr i64, ir<%p.out>, ir<%iv>
; CHECK-NEXT: EMIT store ir<%ld>, ir<%gep.st>, ir<%c>
; CHECK-NEXT: Successor(s): latch
; CHECK-EMPTY:
@@ -2548,9 +2548,9 @@ define void @stride_poison(ptr noalias %p.out, ptr %p, i64 %stride) {
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION nsw ir<0>, ir<1>, vp<[[VP0]]>
; CHECK-NEXT: EMIT ir<%iv.next> = add nsw ir<%iv>, ir<1>
; CHECK-NEXT: EMIT ir<%idx> = mul ir<%iv>, ir<poison>
-; CHECK-NEXT: EMIT ir<%gep.ld> = getelementptr ir<%p>, ir<%idx>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.ld> = getelementptr i64, ir<%p>, ir<%idx>
; CHECK-NEXT: EMIT-SCALAR ir<%ld> = load ir<%gep.ld>
-; CHECK-NEXT: EMIT ir<%gep.st> = getelementptr ir<%p.out>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.st> = getelementptr i64, ir<%p.out>, ir<%iv>
; CHECK-NEXT: EMIT store ir<%ld>, ir<%gep.st>
; CHECK-NEXT: EMIT ir<%exitcond> = icmp sge ir<%iv.next>, ir<128>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<[[VP3]]>, vp<[[VP1]]>
@@ -2616,9 +2616,9 @@ define void @basic_strided_store(ptr noalias %p.out, ptr %p, i64 %stride) {
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION nsw ir<0>, ir<1>, vp<[[VP0]]>
; CHECK-NEXT: EMIT ir<%iv.next> = add nsw ir<%iv>, ir<1>
; CHECK-NEXT: EMIT ir<%idx> = mul ir<%iv>, ir<%stride>
-; CHECK-NEXT: EMIT ir<%gep.ld> = getelementptr ir<%p>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.ld> = getelementptr i64, ir<%p>, ir<%iv>
; CHECK-NEXT: EMIT-SCALAR ir<%ld> = load ir<%gep.ld>
-; CHECK-NEXT: EMIT ir<%gep.st> = getelementptr ir<%p.out>, ir<%idx>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.st> = getelementptr i64, ir<%p.out>, ir<%idx>
; CHECK-NEXT: EMIT store ir<%ld>, ir<%gep.st>
; CHECK-NEXT: EMIT ir<%exitcond> = icmp sge ir<%iv.next>, ir<128>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<[[VP3]]>, vp<[[VP1]]>
@@ -2685,11 +2685,11 @@ define void @ptr_vec_use(ptr noalias %p.out, ptr noalias %p.ptr.out, ptr %p, i64
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION nsw ir<0>, ir<1>, vp<[[VP0]]>
; CHECK-NEXT: EMIT ir<%iv.next> = add nsw ir<%iv>, ir<1>
; CHECK-NEXT: EMIT ir<%idx> = mul ir<%iv>, ir<%stride>
-; CHECK-NEXT: EMIT ir<%gep.ld> = getelementptr ir<%p>, ir<%idx>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.ld> = getelementptr i64, ir<%p>, ir<%idx>
; CHECK-NEXT: EMIT-SCALAR ir<%ld> = load ir<%gep.ld>
-; CHECK-NEXT: EMIT ir<%gep.st> = getelementptr ir<%p.out>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.st> = getelementptr i64, ir<%p.out>, ir<%iv>
; CHECK-NEXT: EMIT store ir<%ld>, ir<%gep.st>
-; CHECK-NEXT: EMIT ir<%gep.ptr.st> = getelementptr ir<%p.ptr.out>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.ptr.st> = getelementptr ptr, ir<%p.ptr.out>, ir<%iv>
; CHECK-NEXT: EMIT store ir<%gep.ld>, ir<%gep.ptr.st>
; CHECK-NEXT: EMIT ir<%exitcond> = icmp sge ir<%iv.next>, ir<128>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<[[VP3]]>, vp<[[VP1]]>
@@ -2759,10 +2759,10 @@ define void @stride_idx_vec_use(ptr noalias %p.out, ptr %p, i64 %stride) {
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION nsw ir<0>, ir<1>, vp<[[VP0]]>
; CHECK-NEXT: EMIT ir<%iv.next> = add nsw ir<%iv>, ir<1>
; CHECK-NEXT: EMIT ir<%idx> = mul ir<%iv>, ir<%stride>
-; CHECK-NEXT: EMIT ir<%gep.ld> = getelementptr ir<%p>, ir<%idx>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.ld> = getelementptr i64, ir<%p>, ir<%idx>
; CHECK-NEXT: EMIT-SCALAR ir<%ld> = load ir<%gep.ld>
; CHECK-NEXT: EMIT ir<%val> = mul ir<%ld>, ir<%idx>
-; CHECK-NEXT: EMIT ir<%gep.st> = getelementptr ir<%p.out>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.st> = getelementptr i64, ir<%p.out>, ir<%iv>
; CHECK-NEXT: EMIT store ir<%val>, ir<%gep.st>
; CHECK-NEXT: EMIT ir<%exitcond> = icmp sge ir<%iv.next>, ir<128>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<[[VP3]]>, vp<[[VP1]]>
@@ -2831,10 +2831,10 @@ define void @offset_stride_idx_vec_use(ptr noalias %p.out, ptr %p, i64 %stride)
; CHECK-NEXT: EMIT ir<%iv.next> = add nsw ir<%iv>, ir<1>
; CHECK-NEXT: EMIT ir<%iv.times.stride> = mul ir<%iv>, ir<%stride>
; CHECK-NEXT: EMIT ir<%idx> = add ir<%iv.times.stride>, ir<42>
-; CHECK-NEXT: EMIT ir<%gep.ld> = getelementptr ir<%p>, ir<%idx>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.ld> = getelementptr i64, ir<%p>, ir<%idx>
; CHECK-NEXT: EMIT-SCALAR ir<%ld> = load ir<%gep.ld>
; CHECK-NEXT: EMIT ir<%val> = mul ir<%ld>, ir<%idx>
-; CHECK-NEXT: EMIT ir<%gep.st> = getelementptr ir<%p.out>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.st> = getelementptr i64, ir<%p.out>, ir<%iv>
; CHECK-NEXT: EMIT store ir<%val>, ir<%gep.st>
; CHECK-NEXT: EMIT ir<%exitcond> = icmp sge ir<%iv.next>, ir<128>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<[[VP3]]>, vp<[[VP1]]>
@@ -2930,7 +2930,7 @@ define void @test_rewrite_iv_scevs(i32 %start, ptr %dst) {
; CHECK-NEXT: vector.body:
; CHECK-NEXT: ir<%iv.0> = WIDEN-INDUCTION ir<%start.ext>, ir<1>, vp<[[VP0]]>
; CHECK-NEXT: ir<%iv.1> = WIDEN-INDUCTION ir<0>, vp<[[VP3]]>, vp<[[VP0]]>
-; CHECK-NEXT: EMIT ir<%gep.dst> = getelementptr ir<%dst>, ir<%iv.1>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.dst> = getelementptr float, ir<%dst>, ir<%iv.1>
; CHECK-NEXT: EMIT store ir<0.000000e+00>, ir<%gep.dst>
; CHECK-NEXT: EMIT ir<%iv.1.next> = add ir<%iv.1>, vp<[[VP3]]>
; CHECK-NEXT: EMIT ir<%iv.0.next> = add ir<%iv.0>, ir<1>
diff --git a/llvm/test/Transforms/LoopVectorize/VPlan/vplan-dot-printing.ll b/llvm/test/Transforms/LoopVectorize/VPlan/vplan-dot-printing.ll
index b76d2277b7559..91f311c046bb5 100644
--- a/llvm/test/Transforms/LoopVectorize/VPlan/vplan-dot-printing.ll
+++ b/llvm/test/Transforms/LoopVectorize/VPlan/vplan-dot-printing.ll
@@ -39,11 +39,11 @@ define void @print_call_and_memory(i64 %n, ptr noalias %y, ptr noalias %x) {
; CHECK-NEXT: N4 [label =
; CHECK-NEXT: "vector.body:\l" +
; CHECK-NEXT: " vp\<[[STEPS:%.+]]\> = SCALAR-STEPS vp\<[[CAN_IV]]\>, ir\<1\>, vp\<[[VF]]\>\l" +
-; CHECK-NEXT: " CLONE ir\<%arrayidx\> = getelementptr inbounds ir\<%y\>, vp\<[[STEPS]]\>\l" +
+; CHECK-NEXT: " EMIT-SCALAR ir\<%arrayidx\> = getelementptr inbounds float, ir\<%y\>, vp\<[[STEPS]]\>\l" +
; CHECK-NEXT: " vp\<[[VEC_PTR:%.+]]\> = vector-pointer inbounds float, ir\<%arrayidx\>, ir\<1\>\l" +
; CHECK-NEXT: " WIDEN ir\<%lv\> = load vp\<[[VEC_PTR]]\>\l" +
; CHECK-NEXT: " WIDEN-INTRINSIC ir\<%call\> = call llvm.sqrt(ir\<%lv\>)\l" +
-; CHECK-NEXT: " CLONE ir\<%arrayidx2\> = getelementptr inbounds ir\<%x\>, vp\<[[STEPS]]\>\l" +
+; CHECK-NEXT: " EMIT-SCALAR ir\<%arrayidx2\> = getelementptr inbounds float, ir\<%x\>, vp\<[[STEPS]]\>\l" +
; CHECK-NEXT: " vp\<[[VEC_PTR2:%.+]]\> = vector-pointer inbounds float, ir\<%arrayidx2\>, ir\<1\>\l" +
; CHECK-NEXT: " WIDEN store vp\<[[VEC_PTR2]]\>, ir\<%call\>\l" +
; CHECK-NEXT: " EMIT vp\<[[CAN_IV_NEXT:%.+]]\> = add nuw vp\<[[CAN_IV]]\>, vp\<[[VFxUF]]\>\l" +
diff --git a/llvm/test/Transforms/LoopVectorize/VPlan/vplan-iv-transforms.ll b/llvm/test/Transforms/LoopVectorize/VPlan/vplan-iv-transforms.ll
index 4f2c35fb98a1b..42141a89e935a 100644
--- a/llvm/test/Transforms/LoopVectorize/VPlan/vplan-iv-transforms.ll
+++ b/llvm/test/Transforms/LoopVectorize/VPlan/vplan-iv-transforms.ll
@@ -21,7 +21,7 @@ define void @iv_no_binary_op_in_descriptor(i1 %c, ptr %dst) {
; CHECK-NEXT: vector.body:
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION ir<0>, ir<1>, vp<[[VP0]]>
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = SCALAR-STEPS vp<[[VP3]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%gep> = getelementptr inbounds ir<%dst>, vp<[[VP4]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr inbounds i64, ir<%dst>, vp<[[VP4]]>
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = vector-pointer inbounds i64, ir<%gep>, ir<1>
; CHECK-NEXT: WIDEN store vp<[[VP5]]>, ir<%iv>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<[[VP3]]>, vp<[[VP1]]>
@@ -91,7 +91,7 @@ define void @iv_expand(ptr %p, i64 %n) {
; CHECK-NEXT: vector.body:
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION ir<0>, ir<1>, vp<[[VP0]]>
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = SCALAR-STEPS vp<[[VP3]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%q> = getelementptr ir<%p>, vp<[[VP4]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%q> = getelementptr i64, ir<%p>, vp<[[VP4]]>
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = vector-pointer i64, ir<%q>, ir<1>
; CHECK-NEXT: WIDEN ir<%x> = load vp<[[VP5]]>
; CHECK-NEXT: WIDEN ir<%y> = add ir<%x>, ir<%iv>
@@ -165,7 +165,7 @@ define void @iv_truncated_wrap_flags(ptr %dst, i64 %n) {
; CHECK-NEXT: vector.body:
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION ir<0>, ir<1>, vp<[[VP0]]> (truncated to i16)
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = SCALAR-STEPS vp<[[VP3]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%ptr> = getelementptr inbounds ir<%dst>, vp<[[VP4]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%ptr> = getelementptr inbounds i16, ir<%dst>, vp<[[VP4]]>
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = vector-pointer inbounds i16, ir<%ptr>, ir<1>
; CHECK-NEXT: WIDEN store vp<[[VP5]]>, ir<%iv>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<[[VP3]]>, vp<[[VP1]]>
diff --git a/llvm/test/Transforms/LoopVectorize/VPlan/vplan-narrow-iv-users.ll b/llvm/test/Transforms/LoopVectorize/VPlan/vplan-narrow-iv-users.ll
index 7cb871ab734e0..3da0bf6ea78a2 100644
--- a/llvm/test/Transforms/LoopVectorize/VPlan/vplan-narrow-iv-users.ll
+++ b/llvm/test/Transforms/LoopVectorize/VPlan/vplan-narrow-iv-users.ll
@@ -23,10 +23,10 @@ define void @narrow_iv_user_chain(ptr noalias %A, ptr noalias %B) {
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = DERIVED-IV ir<0> + vp<[[VP3]]> * ir<1>
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = SCALAR-STEPS vp<[[VP4]]>, ir<1>, vp<[[VP0]]>
; CHECK-NEXT: CLONE ir<%and> = and vp<[[VP5]]>, ir<-4>
-; CHECK-NEXT: CLONE ir<%gep.ld> = getelementptr inbounds ir<%A>, ir<%and>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.ld> = getelementptr inbounds i64, ir<%A>, ir<%and>
; CHECK-NEXT: CLONE ir<%ld> = load ir<%gep.ld>
; CHECK-NEXT: CLONE ir<%calc> = add nsw ir<%ld>, ir<42>
-; CHECK-NEXT: CLONE ir<%gep.st> = getelementptr inbounds ir<%B>, ir<%and>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.st> = getelementptr inbounds i64, ir<%B>, ir<%and>
; CHECK-NEXT: REPLICATE store ir<%calc>, ir<%gep.st>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<[[VP3]]>, vp<[[VP1]]>
; CHECK-NEXT: EMIT branch-on-count vp<%index.next>, vp<[[VP2]]>
@@ -78,11 +78,11 @@ define void @narrow_iv_user_chain_multiple_levels(ptr noalias %A, ptr noalias %B
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = DERIVED-IV ir<0> + vp<[[VP3]]> * ir<1>
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = SCALAR-STEPS vp<[[VP4]]>, ir<1>, vp<[[VP0]]>
; CHECK-NEXT: CLONE ir<%and> = and vp<[[VP5]]>, ir<-4>
-; CHECK-NEXT: CLONE ir<%gep.ld> = getelementptr inbounds ir<%A>, ir<%and>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.ld> = getelementptr inbounds i64, ir<%A>, ir<%and>
; CHECK-NEXT: CLONE ir<%ld> = load ir<%gep.ld>
; CHECK-NEXT: CLONE ir<%calc> = add nsw ir<%ld>, ir<42>
; CHECK-NEXT: CLONE ir<%calc2> = mul nsw ir<%calc>, ir<3>
-; CHECK-NEXT: CLONE ir<%gep.st> = getelementptr inbounds ir<%B>, ir<%and>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.st> = getelementptr inbounds i64, ir<%B>, ir<%and>
; CHECK-NEXT: REPLICATE store ir<%calc2>, ir<%gep.st>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<[[VP3]]>, vp<[[VP1]]>
; CHECK-NEXT: EMIT branch-on-count vp<%index.next>, vp<[[VP2]]>
@@ -133,11 +133,11 @@ define void @no_narrowing_if_all_lanes_used(ptr noalias %A, ptr noalias %B) {
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION nsw ir<0>, ir<1>, vp<[[VP0]]>
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = DERIVED-IV ir<0> + vp<[[VP3]]> * ir<1>
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = SCALAR-STEPS vp<[[VP4]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%gep.ld> = getelementptr inbounds ir<%A>, vp<[[VP5]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.ld> = getelementptr inbounds i64, ir<%A>, vp<[[VP5]]>
; CHECK-NEXT: vp<[[VP6:%[0-9]+]]> = vector-pointer inbounds i64, ir<%gep.ld>, ir<1>
; CHECK-NEXT: WIDEN ir<%ld> = load vp<[[VP6]]>
; CHECK-NEXT: WIDEN ir<%calc> = add nsw ir<%ld>, ir<42>
-; CHECK-NEXT: CLONE ir<%gep.st> = getelementptr inbounds ir<%B>, vp<[[VP5]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.st> = getelementptr inbounds i64, ir<%B>, vp<[[VP5]]>
; CHECK-NEXT: vp<[[VP7:%[0-9]+]]> = vector-pointer inbounds i64, ir<%gep.st>, ir<1>
; CHECK-NEXT: WIDEN store vp<[[VP7]]>, ir<%calc>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<[[VP3]]>, vp<[[VP1]]>
diff --git a/llvm/test/Transforms/LoopVectorize/VPlan/vplan-printing-alias-mask.ll b/llvm/test/Transforms/LoopVectorize/VPlan/vplan-printing-alias-mask.ll
index fa965e28d58fe..82a8b5c13f4ea 100644
--- a/llvm/test/Transforms/LoopVectorize/VPlan/vplan-printing-alias-mask.ll
+++ b/llvm/test/Transforms/LoopVectorize/VPlan/vplan-printing-alias-mask.ll
@@ -27,14 +27,14 @@ define void @alias_mask(ptr noalias %a, ptr %b, ptr %c, i64 %n) {
; INITIAL-NEXT: Successor(s): vector.body.split
; INITIAL-EMPTY:
; INITIAL-NEXT: vector.body.split:
-; INITIAL-NEXT: CLONE ir<%ptr.a> = getelementptr inbounds ir<%a>, ir<%iv>
+; INITIAL-NEXT: EMIT-SCALAR ir<%ptr.a> = getelementptr inbounds i8, ir<%a>, ir<%iv>
; INITIAL-NEXT: vp<[[VP6:%[0-9]+]]> = vector-pointer inbounds i8, ir<%ptr.a>, ir<1>
; INITIAL-NEXT: WIDEN ir<%ld.a> = load vp<[[VP6]]>, vp<[[VP5]]>
-; INITIAL-NEXT: CLONE ir<%ptr.b> = getelementptr inbounds ir<%b>, ir<%iv>
+; INITIAL-NEXT: EMIT-SCALAR ir<%ptr.b> = getelementptr inbounds i8, ir<%b>, ir<%iv>
; INITIAL-NEXT: vp<[[VP7:%[0-9]+]]> = vector-pointer inbounds i8, ir<%ptr.b>, ir<1>
; INITIAL-NEXT: WIDEN ir<%ld.b> = load vp<[[VP7]]>, vp<[[VP5]]>
; INITIAL-NEXT: WIDEN ir<%add> = add ir<%ld.b>, ir<%ld.a>
-; INITIAL-NEXT: CLONE ir<%ptr.c> = getelementptr inbounds ir<%c>, ir<%iv>
+; INITIAL-NEXT: EMIT-SCALAR ir<%ptr.c> = getelementptr inbounds i8, ir<%c>, ir<%iv>
; INITIAL-NEXT: vp<[[VP8:%[0-9]+]]> = vector-pointer inbounds i8, ir<%ptr.c>, ir<1>
; INITIAL-NEXT: WIDEN store vp<[[VP8]]>, ir<%add>, vp<[[VP5]]>
; INITIAL-NEXT: CLONE ir<%iv.next> = add nuw nsw ir<%iv>, ir<1>
@@ -85,12 +85,12 @@ define void @alias_mask(ptr noalias %a, ptr %b, ptr %c, i64 %n) {
; FINAL-NEXT: WIDEN-PHI vp<[[VP12:%[0-9]+]]> = phi [ vp<[[VP10]]>, vector.ph ], [ vp<%vec.ind.next>, vector.body ]
; FINAL-NEXT: EMIT vp<[[VP13:%[0-9]+]]> = icmp ule vp<[[VP12]]>, vp<[[VP9]]>
; FINAL-NEXT: EMIT vp<[[VP14:%[0-9]+]]> = and vp<[[VP13]]>, vp<[[VP4]]>
-; FINAL-NEXT: CLONE ir<%ptr.a> = getelementptr inbounds ir<%a>, vp<%index>
+; FINAL-NEXT: EMIT-SCALAR ir<%ptr.a> = getelementptr inbounds i8, ir<%a>, vp<%index>
; FINAL-NEXT: WIDEN ir<%ld.a> = load ir<%ptr.a>, vp<[[VP14]]>
-; FINAL-NEXT: CLONE ir<%ptr.b> = getelementptr inbounds ir<%b>, vp<%index>
+; FINAL-NEXT: EMIT-SCALAR ir<%ptr.b> = getelementptr inbounds i8, ir<%b>, vp<%index>
; FINAL-NEXT: WIDEN ir<%ld.b> = load ir<%ptr.b>, vp<[[VP14]]>
; FINAL-NEXT: WIDEN ir<%add> = add ir<%ld.b>, ir<%ld.a>
-; FINAL-NEXT: CLONE ir<%ptr.c> = getelementptr inbounds ir<%c>, vp<%index>
+; FINAL-NEXT: EMIT-SCALAR ir<%ptr.c> = getelementptr inbounds i8, ir<%c>, vp<%index>
; FINAL-NEXT: WIDEN store ir<%ptr.c>, ir<%add>, vp<[[VP14]]>
; FINAL-NEXT: EMIT vp<%index.next> = add vp<%index>, vp<%num.active.lanes>
; FINAL-NEXT: EMIT vp<%vec.ind.next> = add nuw vp<[[VP12]]>, vp<[[VP11]]>
diff --git a/llvm/test/Transforms/LoopVectorize/VPlan/vplan-printing-branch-weights.ll b/llvm/test/Transforms/LoopVectorize/VPlan/vplan-printing-branch-weights.ll
index e89172c1286bb..74c98630b292b 100644
--- a/llvm/test/Transforms/LoopVectorize/VPlan/vplan-printing-branch-weights.ll
+++ b/llvm/test/Transforms/LoopVectorize/VPlan/vplan-printing-branch-weights.ll
@@ -35,7 +35,7 @@ define void @predicated_block(ptr noalias %a, ptr noalias %idx) {
; PREDICATE-EMPTY:
; PREDICATE-NEXT: vector.body:
; PREDICATE-NEXT: ir<%iv> = WIDEN-INDUCTION ir<0>, ir<1>, vp<[[VP0]]>
-; PREDICATE-NEXT: EMIT ir<%gep.idx> = getelementptr inbounds ir<%idx>, ir<%iv>
+; PREDICATE-NEXT: EMIT-SCALAR ir<%gep.idx> = getelementptr inbounds i32, ir<%idx>, ir<%iv>
; PREDICATE-NEXT: EMIT-SCALAR ir<%i> = load ir<%gep.idx>
; PREDICATE-NEXT: EMIT ir<%cmp> = icmp sgt ir<%i>, ir<0>
; PREDICATE-NEXT: Successor(s): if.then
@@ -44,7 +44,7 @@ define void @predicated_block(ptr noalias %a, ptr noalias %idx) {
; PREDICATE-NEXT: EMIT ir<%add> = add ir<%i>, ir<1>, ir<%cmp> (!vplan.execution.frequency 2305843009213693952 (25%))
; PREDICATE-NEXT: EMIT-SCALAR ir<%t> = trunc ir<%add> to i16
; PREDICATE-NEXT: EMIT-SCALAR ir<%ext> = sext ir<%t> to i64
-; PREDICATE-NEXT: EMIT ir<%gep.a> = getelementptr inbounds ir<%a>, ir<%ext>
+; PREDICATE-NEXT: EMIT-SCALAR ir<%gep.a> = getelementptr inbounds i32, ir<%a>, ir<%ext>
; PREDICATE-NEXT: EMIT store ir<%add>, ir<%gep.a>, ir<%cmp> (!vplan.execution.frequency 2305843009213693952 (25%))
; PREDICATE-NEXT: Successor(s): latch
; PREDICATE-EMPTY:
@@ -77,7 +77,7 @@ define void @predicated_block(ptr noalias %a, ptr noalias %idx) {
; CONSTRUCT-EMPTY:
; CONSTRUCT-NEXT: vector.body:
; CONSTRUCT-NEXT: ir<%iv> = WIDEN-INDUCTION ir<0>, ir<1>, vp<[[VP0]]>
-; CONSTRUCT-NEXT: CLONE ir<%gep.idx> = getelementptr inbounds ir<%idx>, ir<%iv>
+; CONSTRUCT-NEXT: EMIT-SCALAR ir<%gep.idx> = getelementptr inbounds i32, ir<%idx>, ir<%iv>
; CONSTRUCT-NEXT: vp<[[VP4:%[0-9]+]]> = vector-pointer inbounds i32, ir<%gep.idx>, ir<1>
; CONSTRUCT-NEXT: WIDEN ir<%i> = load vp<[[VP4]]>
; CONSTRUCT-NEXT: EMIT ir<%cmp> = icmp sgt ir<%i>, ir<0>
@@ -87,7 +87,7 @@ define void @predicated_block(ptr noalias %a, ptr noalias %idx) {
; CONSTRUCT-NEXT: EMIT ir<%add> = add ir<%i>, ir<1>, ir<%cmp> (!vplan.execution.frequency 2305843009213693952 (25%))
; CONSTRUCT-NEXT: EMIT-SCALAR ir<%t> = trunc ir<%add> to i16
; CONSTRUCT-NEXT: EMIT-SCALAR ir<%ext> = sext ir<%t> to i64
-; CONSTRUCT-NEXT: EMIT ir<%gep.a> = getelementptr inbounds ir<%a>, ir<%ext>
+; CONSTRUCT-NEXT: EMIT-SCALAR ir<%gep.a> = getelementptr inbounds i32, ir<%a>, ir<%ext>
; CONSTRUCT-NEXT: REPLICATE store ir<%add>, ir<%gep.a>, ir<%cmp> (!vplan.execution.frequency 2305843009213693952 (25%))
; CONSTRUCT-NEXT: Successor(s): latch
; CONSTRUCT-EMPTY:
@@ -120,11 +120,11 @@ define void @predicated_block(ptr noalias %a, ptr noalias %idx) {
; REGION-EMPTY:
; REGION-NEXT: vector.body:
; REGION-NEXT: vp<[[VP4:%[0-9]+]]> = SCALAR-STEPS vp<[[VP3]]>, ir<1>, vp<[[VP0]]>
-; REGION-NEXT: CLONE ir<%gep.idx> = getelementptr inbounds ir<%idx>, vp<[[VP4]]>
+; REGION-NEXT: EMIT-SCALAR ir<%gep.idx> = getelementptr inbounds i32, ir<%idx>, vp<[[VP4]]>
; REGION-NEXT: vp<[[VP5:%[0-9]+]]> = vector-pointer inbounds i32, ir<%gep.idx>, ir<1>
; REGION-NEXT: WIDEN ir<%i> = load vp<[[VP5]]>
; REGION-NEXT: WIDEN ir<%cmp> = icmp sgt ir<%i>, ir<0>
-; REGION-NEXT: WIDEN ir<%add> = add ir<%i>, ir<1>
+; REGION-NEXT: WIDEN ir<%add> = add ir<%i>, ir<1> (!vplan.execution.frequency 2305843009213693952 (25%))
; REGION-NEXT: WIDEN-CAST ir<%t> = trunc ir<%add> to i16
; REGION-NEXT: WIDEN-CAST ir<%ext> = sext ir<%t> to i64
; REGION-NEXT: Successor(s): pred.store
@@ -166,10 +166,10 @@ define void @predicated_block(ptr noalias %a, ptr noalias %idx) {
; DISSOLVE-EMPTY:
; DISSOLVE-NEXT: vector.body:
; DISSOLVE-NEXT: EMIT-SCALAR vp<%index> = phi [ ir<0>, vector.ph ], [ vp<%index.next>, pred.store.continue ]
-; DISSOLVE-NEXT: CLONE ir<%gep.idx> = getelementptr inbounds ir<%idx>, vp<%index>
+; DISSOLVE-NEXT: EMIT-SCALAR ir<%gep.idx> = getelementptr inbounds i32, ir<%idx>, vp<%index>
; DISSOLVE-NEXT: WIDEN ir<%i> = load ir<%gep.idx>
; DISSOLVE-NEXT: WIDEN ir<%cmp> = icmp sgt ir<%i>, ir<0>
-; DISSOLVE-NEXT: WIDEN ir<%add> = add ir<%i>, ir<1>
+; DISSOLVE-NEXT: WIDEN ir<%add> = add ir<%i>, ir<1> (!vplan.execution.frequency 2305843009213693952 (25%))
; DISSOLVE-NEXT: WIDEN-CAST ir<%t> = trunc ir<%add> to i16
; DISSOLVE-NEXT: WIDEN-CAST ir<%ext> = sext ir<%t> to i64
; DISSOLVE-NEXT: EMIT vp<[[VP1:%[0-9]+]]> = extractelement ir<%cmp>, ir<0>
@@ -178,7 +178,7 @@ define void @predicated_block(ptr noalias %a, ptr noalias %idx) {
; DISSOLVE-EMPTY:
; DISSOLVE-NEXT: pred.store.if:
; DISSOLVE-NEXT: EMIT vp<[[VP3:%[0-9]+]]> = extractelement ir<%ext>, ir<0>
-; DISSOLVE-NEXT: CLONE ir<%gep.a> = getelementptr inbounds ir<%a>, vp<[[VP3]]>
+; DISSOLVE-NEXT: EMIT-SCALAR ir<%gep.a> = getelementptr inbounds i32, ir<%a>, vp<[[VP3]]>
; DISSOLVE-NEXT: EMIT vp<[[VP4:%[0-9]+]]> = extractelement ir<%add>, ir<0>
; DISSOLVE-NEXT: CLONE store vp<[[VP4]]>, ir<%gep.a>
; DISSOLVE-NEXT: Successor(s): pred.store.continue
@@ -190,7 +190,7 @@ define void @predicated_block(ptr noalias %a, ptr noalias %idx) {
; DISSOLVE-EMPTY:
; DISSOLVE-NEXT: pred.store.if:
; DISSOLVE-NEXT: EMIT vp<[[VP7:%[0-9]+]]> = extractelement ir<%ext>, ir<1>
-; DISSOLVE-NEXT: CLONE ir<%gep.a>.1 = getelementptr inbounds ir<%a>, vp<[[VP7]]>
+; DISSOLVE-NEXT: EMIT-SCALAR ir<%gep.a>.1 = getelementptr inbounds i32, ir<%a>, vp<[[VP7]]>
; DISSOLVE-NEXT: EMIT vp<[[VP8:%[0-9]+]]> = extractelement ir<%add>, ir<1>
; DISSOLVE-NEXT: CLONE store vp<[[VP8]]>, ir<%gep.a>.1
; DISSOLVE-NEXT: Successor(s): pred.store.continue
diff --git a/llvm/test/Transforms/LoopVectorize/VPlan/vplan-printing-flags.ll b/llvm/test/Transforms/LoopVectorize/VPlan/vplan-printing-flags.ll
index 673c8f9e56142..7840b86219d57 100644
--- a/llvm/test/Transforms/LoopVectorize/VPlan/vplan-printing-flags.ll
+++ b/llvm/test/Transforms/LoopVectorize/VPlan/vplan-printing-flags.ll
@@ -16,8 +16,8 @@ define void @cast_flags_mixed(ptr noalias %A, ptr noalias %B) {
; CHECK-NEXT: Successor(s): scalar.ph, vector.ph
; CHECK-EMPTY:
; CHECK-NEXT: vector.ph:
-; CHECK-NEXT: CLONE ir<%gep.zext> = getelementptr ir<%A>, ir<3>
-; CHECK-NEXT: CLONE ir<%gep.trunc> = getelementptr ir<%B>, ir<3>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.zext> = getelementptr ptr, ir<%A>, ir<3>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.trunc> = getelementptr [4 x i8], ir<%B>, ir<3>
; CHECK-NEXT: EMIT vp<[[VP5:%[0-9]+]]> = wide-iv-step vp<[[VP0]]>, ir<1>
; CHECK-NEXT: EMIT vp<[[VP6:%[0-9]+]]> = wide-iv-step vp<[[VP0]]>, ir<1>
; CHECK-NEXT: Successor(s): vector loop
@@ -218,7 +218,7 @@ define void @fpiv_wideivstep_flags(float %init, ptr %p, i64 %n) {
; CHECK-NEXT: ir<%x> = WIDEN-INDUCTION fast ir<%init>, ir<1.000000e+00>, vp<[[VP0]]>, vp<[[VP5]]>, vp<%step.add>
; CHECK-NEXT: EMIT vp<%step.add> = fadd fast ir<%x>, vp<[[VP5]]>
; CHECK-NEXT: vp<[[VP7:%[0-9]+]]> = SCALAR-STEPS vp<[[VP6]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%arrayidx> = getelementptr inbounds ir<%p>, vp<[[VP7]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%arrayidx> = getelementptr inbounds float, ir<%p>, vp<[[VP7]]>
; CHECK-NEXT: EMIT vp<[[VP8:%[0-9]+]]> = mul nuw nsw vp<[[VP0]]>, ir<1>
; CHECK-NEXT: vp<[[VP9:%[0-9]+]]> = vector-pointer inbounds float, ir<%arrayidx>, ir<1>
; CHECK-NEXT: vp<[[VP10:%[0-9]+]]> = vector-pointer inbounds float, ir<%arrayidx>, ir<1>, vp<[[VP8]]>
diff --git a/llvm/test/Transforms/LoopVectorize/VPlan/vplan-printing-metadata.ll b/llvm/test/Transforms/LoopVectorize/VPlan/vplan-printing-metadata.ll
index ccc4e44dbcf9c..210cbbde9532e 100644
--- a/llvm/test/Transforms/LoopVectorize/VPlan/vplan-printing-metadata.ll
+++ b/llvm/test/Transforms/LoopVectorize/VPlan/vplan-printing-metadata.ll
@@ -21,15 +21,15 @@ define void @test_widen_metadata(ptr noalias %A, ptr noalias %B, i32 %n) {
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = SCALAR-STEPS vp<[[VP3]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%gep.A> = getelementptr inbounds ir<%A>, vp<[[VP4]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.A> = getelementptr inbounds i32, ir<%A>, vp<[[VP4]]>
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = vector-pointer inbounds i32, ir<%gep.A>, ir<1>
-; CHECK-NEXT: WIDEN ir<%lv> = load vp<[[VP5]]> (!tbaa !{{[0-9]+}})
-; CHECK-NEXT: WIDEN-CAST ir<%conv> = sitofp ir<%lv> to float (!fpmath !{{[0-9]+}})
-; CHECK-NEXT: WIDEN ir<%mul> = fmul ir<%conv>, ir<2.000000e+00> (!fpmath !{{[0-9]+}})
+; CHECK-NEXT: WIDEN ir<%lv> = load vp<[[VP5]]> (!tbaa !4)
+; CHECK-NEXT: WIDEN-CAST ir<%conv> = sitofp ir<%lv> to float (!fpmath !8)
+; CHECK-NEXT: WIDEN ir<%mul> = fmul ir<%conv>, ir<2.000000e+00> (!fpmath !8)
; CHECK-NEXT: WIDEN-CAST ir<%conv.back> = fptosi ir<%mul> to i32
-; CHECK-NEXT: CLONE ir<%gep.B> = getelementptr inbounds ir<%B>, vp<[[VP4]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.B> = getelementptr inbounds i32, ir<%B>, vp<[[VP4]]>
; CHECK-NEXT: vp<[[VP6:%[0-9]+]]> = vector-pointer inbounds i32, ir<%gep.B>, ir<1>
-; CHECK-NEXT: WIDEN store vp<[[VP6]]>, ir<%conv.back> (!tbaa !{{[0-9]+}})
+; CHECK-NEXT: WIDEN store vp<[[VP6]]>, ir<%conv.back> (!tbaa !4)
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<[[VP3]]>, vp<[[VP1]]>
; CHECK-NEXT: EMIT branch-on-count vp<%index.next>, vp<[[VP2]]>
; CHECK-NEXT: No successors
@@ -51,12 +51,12 @@ define void @test_widen_metadata(ptr noalias %A, ptr noalias %B, i32 %n) {
; CHECK-NEXT: ir-bb<loop>:
; CHECK-NEXT: IR %i = phi i32 [ 0, %entry ], [ %i.next, %loop ] (extra operand: vp<%bc.resume.val> from scalar.ph)
; CHECK-NEXT: IR %gep.A = getelementptr inbounds i32, ptr %A, i32 %i
-; CHECK-NEXT: IR %lv = load i32, ptr %gep.A, align 4, !tbaa !{{[0-9]+}}, !range !{{[0-9]+}}
-; CHECK-NEXT: IR %conv = sitofp i32 %lv to float, !fpmath !{{[0-9]+}}
-; CHECK-NEXT: IR %mul = fmul float %conv, 2.000000e+00, !fpmath !{{[0-9]+}}
+; CHECK-NEXT: IR %lv = load i32, ptr %gep.A, align 4, !tbaa !4, !range !9
+; CHECK-NEXT: IR %conv = sitofp i32 %lv to float, !fpmath !8
+; CHECK-NEXT: IR %mul = fmul float %conv, 2.000000e+00, !fpmath !8
; CHECK-NEXT: IR %conv.back = fptosi float %mul to i32
; CHECK-NEXT: IR %gep.B = getelementptr inbounds i32, ptr %B, i32 %i
-; CHECK-NEXT: IR store i32 %conv.back, ptr %gep.B, align 4, !tbaa !{{[0-9]+}}
+; CHECK-NEXT: IR store i32 %conv.back, ptr %gep.B, align 4, !tbaa !4
; CHECK-NEXT: IR %i.next = add i32 %i, 1
; CHECK-NEXT: IR %cond = icmp eq i32 %i.next, %n
; CHECK-NEXT: No successors
@@ -102,13 +102,13 @@ define void @test_intrinsic_with_metadata(ptr noalias %A, ptr noalias %B, i32 %n
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = SCALAR-STEPS vp<[[VP3]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%gep.A> = getelementptr inbounds ir<%A>, vp<[[VP4]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.A> = getelementptr inbounds float, ir<%A>, vp<[[VP4]]>
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = vector-pointer inbounds float, ir<%gep.A>, ir<1>
-; CHECK-NEXT: WIDEN ir<%lv> = load vp<[[VP5]]> (!tbaa !{{[0-9]+}})
-; CHECK-NEXT: WIDEN-INTRINSIC ir<%sqrt> = call llvm.sqrt(ir<%lv>) (!fpmath !{{[0-9]+}})
-; CHECK-NEXT: CLONE ir<%gep.B> = getelementptr inbounds ir<%B>, vp<[[VP4]]>
+; CHECK-NEXT: WIDEN ir<%lv> = load vp<[[VP5]]> (!tbaa !4)
+; CHECK-NEXT: WIDEN-INTRINSIC ir<%sqrt> = call llvm.sqrt(ir<%lv>) (!fpmath !8)
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.B> = getelementptr inbounds float, ir<%B>, vp<[[VP4]]>
; CHECK-NEXT: vp<[[VP6:%[0-9]+]]> = vector-pointer inbounds float, ir<%gep.B>, ir<1>
-; CHECK-NEXT: WIDEN store vp<[[VP6]]>, ir<%sqrt> (!tbaa !{{[0-9]+}})
+; CHECK-NEXT: WIDEN store vp<[[VP6]]>, ir<%sqrt> (!tbaa !4)
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<[[VP3]]>, vp<[[VP1]]>
; CHECK-NEXT: EMIT branch-on-count vp<%index.next>, vp<[[VP2]]>
; CHECK-NEXT: No successors
@@ -130,10 +130,10 @@ define void @test_intrinsic_with_metadata(ptr noalias %A, ptr noalias %B, i32 %n
; CHECK-NEXT: ir-bb<loop>:
; CHECK-NEXT: IR %i = phi i32 [ 0, %entry ], [ %i.next, %loop ] (extra operand: vp<%bc.resume.val> from scalar.ph)
; CHECK-NEXT: IR %gep.A = getelementptr inbounds float, ptr %A, i32 %i
-; CHECK-NEXT: IR %lv = load float, ptr %gep.A, align 4, !tbaa !{{[0-9]+}}
-; CHECK-NEXT: IR %sqrt = call float @llvm.sqrt.f32(float %lv), !fpmath !{{[0-9]+}}
+; CHECK-NEXT: IR %lv = load float, ptr %gep.A, align 4, !tbaa !4
+; CHECK-NEXT: IR %sqrt = call float @llvm.sqrt.f32(float %lv), !fpmath !8
; CHECK-NEXT: IR %gep.B = getelementptr inbounds float, ptr %B, i32 %i
-; CHECK-NEXT: IR store float %sqrt, ptr %gep.B, align 4, !tbaa !{{[0-9]+}}
+; CHECK-NEXT: IR store float %sqrt, ptr %gep.B, align 4, !tbaa !4
; CHECK-NEXT: IR %i.next = add i32 %i, 1
; CHECK-NEXT: IR %cond = icmp eq i32 %i.next, %n
; CHECK-NEXT: No successors
@@ -176,15 +176,15 @@ define void @test_widen_with_multiple_metadata(ptr noalias %A, ptr noalias %B, i
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = SCALAR-STEPS vp<[[VP3]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%gep.A> = getelementptr inbounds ir<%A>, vp<[[VP4]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.A> = getelementptr inbounds i32, ir<%A>, vp<[[VP4]]>
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = vector-pointer inbounds i32, ir<%gep.A>, ir<1>
-; CHECK-NEXT: WIDEN ir<%lv> = load vp<[[VP5]]> (!tbaa !{{[0-9]+}})
+; CHECK-NEXT: WIDEN ir<%lv> = load vp<[[VP5]]> (!tbaa !4)
; CHECK-NEXT: WIDEN-CAST ir<%conv> = sitofp ir<%lv> to float
; CHECK-NEXT: WIDEN ir<%mul> = fmul ir<%conv>, ir<2.000000e+00>
; CHECK-NEXT: WIDEN-CAST ir<%conv.back> = fptosi ir<%mul> to i32
-; CHECK-NEXT: CLONE ir<%gep.B> = getelementptr inbounds ir<%B>, vp<[[VP4]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.B> = getelementptr inbounds i32, ir<%B>, vp<[[VP4]]>
; CHECK-NEXT: vp<[[VP6:%[0-9]+]]> = vector-pointer inbounds i32, ir<%gep.B>, ir<1>
-; CHECK-NEXT: WIDEN store vp<[[VP6]]>, ir<%conv.back> (!tbaa !{{[0-9]+}})
+; CHECK-NEXT: WIDEN store vp<[[VP6]]>, ir<%conv.back> (!tbaa !4)
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<[[VP3]]>, vp<[[VP1]]>
; CHECK-NEXT: EMIT branch-on-count vp<%index.next>, vp<[[VP2]]>
; CHECK-NEXT: No successors
@@ -206,12 +206,12 @@ define void @test_widen_with_multiple_metadata(ptr noalias %A, ptr noalias %B, i
; CHECK-NEXT: ir-bb<loop>:
; CHECK-NEXT: IR %i = phi i32 [ 0, %entry ], [ %i.next, %loop ] (extra operand: vp<%bc.resume.val> from scalar.ph)
; CHECK-NEXT: IR %gep.A = getelementptr inbounds i32, ptr %A, i32 %i
-; CHECK-NEXT: IR %lv = load i32, ptr %gep.A, align 4, !tbaa !{{[0-9]+}}, !range !{{[0-9]+}}
+; CHECK-NEXT: IR %lv = load i32, ptr %gep.A, align 4, !tbaa !4, !range !9
; CHECK-NEXT: IR %conv = sitofp i32 %lv to float
; CHECK-NEXT: IR %mul = fmul float %conv, 2.000000e+00
; CHECK-NEXT: IR %conv.back = fptosi float %mul to i32
; CHECK-NEXT: IR %gep.B = getelementptr inbounds i32, ptr %B, i32 %i
-; CHECK-NEXT: IR store i32 %conv.back, ptr %gep.B, align 4, !tbaa !{{[0-9]+}}
+; CHECK-NEXT: IR store i32 %conv.back, ptr %gep.B, align 4, !tbaa !4
; CHECK-NEXT: IR %i.next = add i32 %i, 1
; CHECK-NEXT: IR %cond = icmp eq i32 %i.next, %n
; CHECK-NEXT: No successors
diff --git a/llvm/test/Transforms/LoopVectorize/VPlan/vplan-printing-outer-loop.ll b/llvm/test/Transforms/LoopVectorize/VPlan/vplan-printing-outer-loop.ll
index a86a211bf1417..ddc6beed64fd8 100644
--- a/llvm/test/Transforms/LoopVectorize/VPlan/vplan-printing-outer-loop.ll
+++ b/llvm/test/Transforms/LoopVectorize/VPlan/vplan-printing-outer-loop.ll
@@ -15,14 +15,14 @@ define void @foo(i64 %n) {
; CHECK-EMPTY:
; CHECK-NEXT: outer.header:
; CHECK-NEXT: EMIT-SCALAR ir<%outer.iv> = phi [ ir<%outer.iv.next>, outer.latch ], [ ir<0>, ir-bb<entry> ]
-; CHECK-NEXT: EMIT ir<%gep.1> = getelementptr inbounds ir<@arr2>, ir<0>, ir<%outer.iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.1> = getelementptr inbounds [8 x i64], ir<@arr2>, ir<0>, ir<%outer.iv>
; CHECK-NEXT: EMIT store ir<%outer.iv>, ir<%gep.1>
; CHECK-NEXT: EMIT ir<%add> = add nsw ir<%outer.iv>, ir<%n>
; CHECK-NEXT: Successor(s): inner
; CHECK-EMPTY:
; CHECK-NEXT: inner:
; CHECK-NEXT: EMIT-SCALAR ir<%inner.iv> = phi [ ir<%inner.iv.next>, inner ], [ ir<0>, outer.header ]
-; CHECK-NEXT: EMIT ir<%gep.2> = getelementptr inbounds ir<@arr>, ir<0>, ir<%inner.iv>, ir<%outer.iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.2> = getelementptr inbounds [8 x [8 x i64]], ir<@arr>, ir<0>, ir<%inner.iv>, ir<%outer.iv>
; CHECK-NEXT: EMIT store ir<%add>, ir<%gep.2>
; CHECK-NEXT: EMIT ir<%inner.iv.next> = add nuw nsw ir<%inner.iv>, ir<1>
; CHECK-NEXT: EMIT ir<%inner.ec> = icmp eq ir<%inner.iv.next>, ir<8>
diff --git a/llvm/test/Transforms/LoopVectorize/VPlan/vplan-printing-reductions-tail-folded.ll b/llvm/test/Transforms/LoopVectorize/VPlan/vplan-printing-reductions-tail-folded.ll
index 3b3fd961f69b3..2614f5d4d32c8 100644
--- a/llvm/test/Transforms/LoopVectorize/VPlan/vplan-printing-reductions-tail-folded.ll
+++ b/llvm/test/Transforms/LoopVectorize/VPlan/vplan-printing-reductions-tail-folded.ll
@@ -26,7 +26,7 @@ define float @print_reduction(i64 %n, ptr noalias %y) {
; CHECK-NEXT: EMIT vp<[[VP7:%[0-9]+]]> = WIDEN-CANONICAL-INDUCTION nuw vp<[[VP5]]>
; CHECK-NEXT: EMIT vp<[[VP8:%[0-9]+]]> = icmp ule vp<[[VP7]]>, vp<[[VP3]]>
; CHECK-NEXT: vp<[[VP9:%[0-9]+]]> = SCALAR-STEPS vp<[[VP5]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%arrayidx> = getelementptr inbounds ir<%y>, vp<[[VP9]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%arrayidx> = getelementptr inbounds float, ir<%y>, vp<[[VP9]]>
; CHECK-NEXT: vp<[[VP10:%[0-9]+]]> = vector-pointer inbounds float, ir<%arrayidx>, ir<1>
; CHECK-NEXT: WIDEN ir<%lv> = load vp<[[VP10]]>, vp<[[VP8]]>
; CHECK-NEXT: REDUCE ir<%red.next> = ir<%red> + fast reduce.fadd (ir<%lv>, vp<[[VP8]]>)
@@ -86,7 +86,7 @@ define void @print_reduction_with_invariant_store(i64 %n, ptr noalias %y, ptr no
; CHECK-NEXT: EMIT vp<[[VP7:%[0-9]+]]> = WIDEN-CANONICAL-INDUCTION nuw vp<[[VP5]]>
; CHECK-NEXT: EMIT vp<[[VP8:%[0-9]+]]> = icmp ule vp<[[VP7]]>, vp<[[VP3]]>
; CHECK-NEXT: vp<[[VP9:%[0-9]+]]> = SCALAR-STEPS vp<[[VP5]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%arrayidx> = getelementptr inbounds ir<%y>, vp<[[VP9]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%arrayidx> = getelementptr inbounds float, ir<%y>, vp<[[VP9]]>
; CHECK-NEXT: vp<[[VP10:%[0-9]+]]> = vector-pointer inbounds float, ir<%arrayidx>, ir<1>
; CHECK-NEXT: WIDEN ir<%lv> = load vp<[[VP10]]>, vp<[[VP8]]>
; CHECK-NEXT: REDUCE ir<%red.next> = ir<%red> + fast reduce.fadd (ir<%lv>, vp<[[VP8]]>)
@@ -147,10 +147,10 @@ define float @print_fmuladd_strict(ptr %a, ptr %b, i64 %n) {
; CHECK-NEXT: EMIT vp<[[VP7:%[0-9]+]]> = WIDEN-CANONICAL-INDUCTION nuw vp<[[VP5]]>
; CHECK-NEXT: EMIT vp<[[VP8:%[0-9]+]]> = icmp ule vp<[[VP7]]>, vp<[[VP3]]>
; CHECK-NEXT: vp<[[VP9:%[0-9]+]]> = SCALAR-STEPS vp<[[VP5]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%arrayidx> = getelementptr inbounds ir<%a>, vp<[[VP9]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%arrayidx> = getelementptr inbounds float, ir<%a>, vp<[[VP9]]>
; CHECK-NEXT: vp<[[VP10:%[0-9]+]]> = vector-pointer inbounds float, ir<%arrayidx>, ir<1>
; CHECK-NEXT: WIDEN ir<%l.a> = load vp<[[VP10]]>, vp<[[VP8]]>
-; CHECK-NEXT: CLONE ir<%arrayidx2> = getelementptr inbounds ir<%b>, vp<[[VP9]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%arrayidx2> = getelementptr inbounds float, ir<%b>, vp<[[VP9]]>
; CHECK-NEXT: vp<[[VP11:%[0-9]+]]> = vector-pointer inbounds float, ir<%arrayidx2>, ir<1>
; CHECK-NEXT: WIDEN ir<%l.b> = load vp<[[VP11]]>, vp<[[VP8]]>
; CHECK-NEXT: EMIT vp<[[VP12:%[0-9]+]]> = fmul nnan ninf nsz ir<%l.a>, ir<%l.b>
@@ -214,7 +214,7 @@ define i64 @find_last_iv(ptr %a, i64 %n, i64 %start) {
; CHECK-NEXT: EMIT vp<[[VP6:%[0-9]+]]> = WIDEN-CANONICAL-INDUCTION nuw vp<[[VP4]]>
; CHECK-NEXT: EMIT vp<[[VP7:%[0-9]+]]> = icmp ule vp<[[VP6]]>, vp<[[VP3]]>
; CHECK-NEXT: vp<[[VP8:%[0-9]+]]> = SCALAR-STEPS vp<[[VP4]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%gep.a> = getelementptr inbounds ir<%a>, vp<[[VP8]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.a> = getelementptr inbounds i64, ir<%a>, vp<[[VP8]]>
; CHECK-NEXT: vp<[[VP9:%[0-9]+]]> = vector-pointer inbounds i64, ir<%gep.a>, ir<1>
; CHECK-NEXT: WIDEN ir<%l.a> = load vp<[[VP9]]>, vp<[[VP7]]>
; CHECK-NEXT: WIDEN ir<%cmp2> = icmp eq ir<%l.a>, ir<%start>
@@ -279,7 +279,7 @@ define i64 @print_extended_reduction(ptr nocapture readonly %x, ptr nocapture re
; CHECK-NEXT: EMIT vp<[[VP7:%[0-9]+]]> = WIDEN-CANONICAL-INDUCTION nuw vp<[[VP5]]>
; CHECK-NEXT: EMIT vp<[[VP8:%[0-9]+]]> = icmp ule vp<[[VP7]]>, vp<[[VP3]]>
; CHECK-NEXT: vp<[[VP9:%[0-9]+]]> = SCALAR-STEPS vp<[[VP5]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%arrayidx> = getelementptr inbounds ir<%x>, vp<[[VP9]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%arrayidx> = getelementptr inbounds i32, ir<%x>, vp<[[VP9]]>
; CHECK-NEXT: vp<[[VP10:%[0-9]+]]> = vector-pointer inbounds i32, ir<%arrayidx>, ir<1>
; CHECK-NEXT: WIDEN ir<%load0> = load vp<[[VP10]]>, vp<[[VP8]]>
; CHECK-NEXT: EXPRESSION vp<[[VP11]]> = vp<[[VP8]]> + reduce.add (ir<%load0> zext to i64, vp<[[VP8]]>)
@@ -341,10 +341,10 @@ define i64 @print_mulacc(ptr nocapture readonly %x, ptr nocapture readonly %y, i
; CHECK-NEXT: EMIT vp<[[VP7:%[0-9]+]]> = WIDEN-CANONICAL-INDUCTION nuw vp<[[VP5]]>
; CHECK-NEXT: EMIT vp<[[VP8:%[0-9]+]]> = icmp ule vp<[[VP7]]>, vp<[[VP3]]>
; CHECK-NEXT: vp<[[VP9:%[0-9]+]]> = SCALAR-STEPS vp<[[VP5]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%arrayidx> = getelementptr inbounds ir<%x>, vp<[[VP9]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%arrayidx> = getelementptr inbounds i64, ir<%x>, vp<[[VP9]]>
; CHECK-NEXT: vp<[[VP10:%[0-9]+]]> = vector-pointer inbounds i64, ir<%arrayidx>, ir<1>
; CHECK-NEXT: WIDEN ir<%load0> = load vp<[[VP10]]>, vp<[[VP8]]>
-; CHECK-NEXT: CLONE ir<%arrayidx1> = getelementptr inbounds ir<%y>, vp<[[VP9]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%arrayidx1> = getelementptr inbounds i64, ir<%y>, vp<[[VP9]]>
; CHECK-NEXT: vp<[[VP11:%[0-9]+]]> = vector-pointer inbounds i64, ir<%arrayidx1>, ir<1>
; CHECK-NEXT: WIDEN ir<%load1> = load vp<[[VP11]]>, vp<[[VP8]]>
; CHECK-NEXT: EXPRESSION vp<[[VP12]]> = ir<%rdx> + reduce.add (mul nsw ir<%load0>, ir<%load1>, vp<[[VP8]]>)
@@ -408,10 +408,10 @@ define i64 @print_mulacc_extended(ptr nocapture readonly %x, ptr nocapture reado
; CHECK-NEXT: EMIT vp<[[VP7:%[0-9]+]]> = WIDEN-CANONICAL-INDUCTION nuw vp<[[VP5]]>
; CHECK-NEXT: EMIT vp<[[VP8:%[0-9]+]]> = icmp ule vp<[[VP7]]>, vp<[[VP3]]>
; CHECK-NEXT: vp<[[VP9:%[0-9]+]]> = SCALAR-STEPS vp<[[VP5]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%arrayidx> = getelementptr inbounds ir<%x>, vp<[[VP9]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%arrayidx> = getelementptr inbounds i16, ir<%x>, vp<[[VP9]]>
; CHECK-NEXT: vp<[[VP10:%[0-9]+]]> = vector-pointer inbounds i16, ir<%arrayidx>, ir<1>
; CHECK-NEXT: WIDEN ir<%load0> = load vp<[[VP10]]>, vp<[[VP8]]>
-; CHECK-NEXT: CLONE ir<%arrayidx1> = getelementptr inbounds ir<%y>, vp<[[VP9]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%arrayidx1> = getelementptr inbounds i16, ir<%y>, vp<[[VP9]]>
; CHECK-NEXT: vp<[[VP11:%[0-9]+]]> = vector-pointer inbounds i16, ir<%arrayidx1>, ir<1>
; CHECK-NEXT: WIDEN ir<%load1> = load vp<[[VP11]]>, vp<[[VP8]]>
; CHECK-NEXT: EXPRESSION vp<[[VP12]]> = ir<%rdx> + reduce.add (mul nsw (ir<%load0> sext to i64), (ir<%load1> sext to i64), vp<[[VP8]]>)
@@ -478,7 +478,7 @@ define i64 @print_extended_sub_reduction(ptr nocapture readonly %x, ptr nocaptur
; CHECK-NEXT: EMIT vp<[[VP7:%[0-9]+]]> = WIDEN-CANONICAL-INDUCTION nuw vp<[[VP5]]>
; CHECK-NEXT: EMIT vp<[[VP8:%[0-9]+]]> = icmp ule vp<[[VP7]]>, vp<[[VP3]]>
; CHECK-NEXT: vp<[[VP9:%[0-9]+]]> = SCALAR-STEPS vp<[[VP5]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%arrayidx> = getelementptr inbounds ir<%x>, vp<[[VP9]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%arrayidx> = getelementptr inbounds i32, ir<%x>, vp<[[VP9]]>
; CHECK-NEXT: vp<[[VP10:%[0-9]+]]> = vector-pointer inbounds i32, ir<%arrayidx>, ir<1>
; CHECK-NEXT: WIDEN ir<%load0> = load vp<[[VP10]]>, vp<[[VP8]]>
; CHECK-NEXT: EXPRESSION vp<[[VP11]]> = vp<[[VP8]]> + reduce.sub (ir<%load0> zext to i64, vp<[[VP8]]>)
@@ -538,10 +538,10 @@ define i32 @print_mulacc_sub(ptr %a, ptr %b) {
; CHECK-NEXT: vector.body:
; CHECK-NEXT: WIDEN-REDUCTION-PHI ir<%accum> = phi (sub) vp<[[VP3]]>, vp<[[VP8:%[0-9]+]]>
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = SCALAR-STEPS vp<[[VP4]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%gep.a> = getelementptr ir<%a>, vp<[[VP5]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.a> = getelementptr i8, ir<%a>, vp<[[VP5]]>
; CHECK-NEXT: vp<[[VP6:%[0-9]+]]> = vector-pointer i8, ir<%gep.a>, ir<1>
; CHECK-NEXT: WIDEN ir<%load.a> = load vp<[[VP6]]>
-; CHECK-NEXT: CLONE ir<%gep.b> = getelementptr ir<%b>, vp<[[VP5]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.b> = getelementptr i8, ir<%b>, vp<[[VP5]]>
; CHECK-NEXT: vp<[[VP7:%[0-9]+]]> = vector-pointer i8, ir<%gep.b>, ir<1>
; CHECK-NEXT: WIDEN ir<%load.b> = load vp<[[VP7]]>
; CHECK-NEXT: EXPRESSION vp<[[VP8]]> = ir<%accum> + reduce.sub (mul (ir<%load.b> zext to i32), (ir<%load.a> zext to i32))
@@ -606,10 +606,10 @@ define i32 @print_mulacc_negated(ptr %a, ptr %b) {
; CHECK-NEXT: vector.body:
; CHECK-NEXT: WIDEN-REDUCTION-PHI ir<%accum> = phi (add) vp<[[VP3]]>, vp<[[VP8:%[0-9]+]]>
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = SCALAR-STEPS vp<[[VP4]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%gep.a> = getelementptr ir<%a>, vp<[[VP5]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.a> = getelementptr i8, ir<%a>, vp<[[VP5]]>
; CHECK-NEXT: vp<[[VP6:%[0-9]+]]> = vector-pointer i8, ir<%gep.a>, ir<1>
; CHECK-NEXT: WIDEN ir<%load.a> = load vp<[[VP6]]>
-; CHECK-NEXT: CLONE ir<%gep.b> = getelementptr ir<%b>, vp<[[VP5]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.b> = getelementptr i8, ir<%b>, vp<[[VP5]]>
; CHECK-NEXT: vp<[[VP7:%[0-9]+]]> = vector-pointer i8, ir<%gep.b>, ir<1>
; CHECK-NEXT: WIDEN ir<%load.b> = load vp<[[VP7]]>
; CHECK-NEXT: EXPRESSION vp<[[VP8]]> = ir<%accum> + reduce.add (sub (0, mul (ir<%load.b> zext to i32), (ir<%load.a> zext to i32)))
@@ -677,10 +677,10 @@ define i64 @print_mulacc_sub_extended(ptr nocapture readonly %x, ptr nocapture r
; CHECK-NEXT: EMIT vp<[[VP7:%[0-9]+]]> = WIDEN-CANONICAL-INDUCTION nuw vp<[[VP5]]>
; CHECK-NEXT: EMIT vp<[[VP8:%[0-9]+]]> = icmp ule vp<[[VP7]]>, vp<[[VP3]]>
; CHECK-NEXT: vp<[[VP9:%[0-9]+]]> = SCALAR-STEPS vp<[[VP5]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%arrayidx> = getelementptr inbounds ir<%x>, vp<[[VP9]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%arrayidx> = getelementptr inbounds i16, ir<%x>, vp<[[VP9]]>
; CHECK-NEXT: vp<[[VP10:%[0-9]+]]> = vector-pointer inbounds i16, ir<%arrayidx>, ir<1>
; CHECK-NEXT: WIDEN ir<%load0> = load vp<[[VP10]]>, vp<[[VP8]]>
-; CHECK-NEXT: CLONE ir<%arrayidx1> = getelementptr inbounds ir<%y>, vp<[[VP9]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%arrayidx1> = getelementptr inbounds i16, ir<%y>, vp<[[VP9]]>
; CHECK-NEXT: vp<[[VP11:%[0-9]+]]> = vector-pointer inbounds i16, ir<%arrayidx1>, ir<1>
; CHECK-NEXT: WIDEN ir<%load1> = load vp<[[VP11]]>, vp<[[VP8]]>
; CHECK-NEXT: EXPRESSION vp<[[VP12]]> = ir<%rdx> + reduce.sub (mul nsw (ir<%load0> sext to i64), (ir<%load1> sext to i64), vp<[[VP8]]>)
@@ -747,7 +747,7 @@ define i64 @print_mulacc_duplicate_extends(ptr nocapture readonly %x, ptr nocapt
; CHECK-NEXT: EMIT vp<[[VP7:%[0-9]+]]> = WIDEN-CANONICAL-INDUCTION nuw vp<[[VP5]]>
; CHECK-NEXT: EMIT vp<[[VP8:%[0-9]+]]> = icmp ule vp<[[VP7]]>, vp<[[VP3]]>
; CHECK-NEXT: vp<[[VP9:%[0-9]+]]> = SCALAR-STEPS vp<[[VP5]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%arrayidx> = getelementptr inbounds ir<%x>, vp<[[VP9]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%arrayidx> = getelementptr inbounds i16, ir<%x>, vp<[[VP9]]>
; CHECK-NEXT: vp<[[VP10:%[0-9]+]]> = vector-pointer inbounds i16, ir<%arrayidx>, ir<1>
; CHECK-NEXT: WIDEN ir<%load0> = load vp<[[VP10]]>, vp<[[VP8]]>
; CHECK-NEXT: EXPRESSION vp<[[VP11]]> = ir<%rdx> + reduce.sub (mul nsw (ir<%load0> sext to i64), (ir<%load0> sext to i64), vp<[[VP8]]>)
@@ -1194,7 +1194,7 @@ define i32 @print_umax_reduction_out_of_loop(ptr %y) {
; CHECK-NEXT: vector.body:
; CHECK-NEXT: WIDEN-REDUCTION-PHI ir<%red> = phi (umax) ir<0>, ir<%red.next>
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = SCALAR-STEPS vp<[[VP3]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%gep> = getelementptr inbounds ir<%y>, vp<[[VP4]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr inbounds i32, ir<%y>, vp<[[VP4]]>
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = vector-pointer inbounds i32, ir<%gep>, ir<1>
; CHECK-NEXT: WIDEN ir<%lv> = load vp<[[VP5]]>
; CHECK-NEXT: WIDEN-INTRINSIC ir<%red.next> = call llvm.umax(ir<%lv>, ir<%red>)
@@ -1253,7 +1253,7 @@ define i32 @print_umax_reduction(ptr %y) {
; CHECK-NEXT: vector.body:
; CHECK-NEXT: WIDEN-REDUCTION-PHI ir<%red> = phi (umax) ir<0>, ir<%red.next>
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = SCALAR-STEPS vp<[[VP3]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%gep> = getelementptr inbounds ir<%y>, vp<[[VP4]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr inbounds i32, ir<%y>, vp<[[VP4]]>
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = vector-pointer inbounds i32, ir<%gep>, ir<1>
; CHECK-NEXT: WIDEN ir<%lv> = load vp<[[VP5]]>
; CHECK-NEXT: WIDEN-INTRINSIC ir<%red.next> = call llvm.umax(ir<%red>, ir<%lv>)
@@ -1312,7 +1312,7 @@ define i32 @print_umin_reduction(ptr %y) {
; CHECK-NEXT: vector.body:
; CHECK-NEXT: WIDEN-REDUCTION-PHI ir<%red> = phi (umin) ir<0>, ir<%red.next>
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = SCALAR-STEPS vp<[[VP3]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%gep> = getelementptr inbounds ir<%y>, vp<[[VP4]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr inbounds i32, ir<%y>, vp<[[VP4]]>
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = vector-pointer inbounds i32, ir<%gep>, ir<1>
; CHECK-NEXT: WIDEN ir<%lv> = load vp<[[VP5]]>
; CHECK-NEXT: WIDEN-INTRINSIC ir<%red.next> = call llvm.umin(ir<%lv>, ir<%red>)
@@ -1371,7 +1371,7 @@ define i32 @print_smax_reduction(ptr %y) {
; CHECK-NEXT: vector.body:
; CHECK-NEXT: WIDEN-REDUCTION-PHI ir<%red> = phi (smax) ir<0>, ir<%red.next>
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = SCALAR-STEPS vp<[[VP3]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%gep> = getelementptr inbounds ir<%y>, vp<[[VP4]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr inbounds i32, ir<%y>, vp<[[VP4]]>
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = vector-pointer inbounds i32, ir<%gep>, ir<1>
; CHECK-NEXT: WIDEN ir<%lv> = load vp<[[VP5]]>
; CHECK-NEXT: WIDEN-INTRINSIC ir<%red.next> = call llvm.smax(ir<%red>, ir<%lv>)
@@ -1430,7 +1430,7 @@ define i32 @print_smin_reduction(ptr %y) {
; CHECK-NEXT: vector.body:
; CHECK-NEXT: WIDEN-REDUCTION-PHI ir<%red> = phi (smin) ir<0>, ir<%red.next>
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = SCALAR-STEPS vp<[[VP3]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%gep> = getelementptr inbounds ir<%y>, vp<[[VP4]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr inbounds i32, ir<%y>, vp<[[VP4]]>
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = vector-pointer inbounds i32, ir<%gep>, ir<1>
; CHECK-NEXT: WIDEN ir<%lv> = load vp<[[VP5]]>
; CHECK-NEXT: WIDEN-INTRINSIC ir<%red.next> = call llvm.smin(ir<%lv>, ir<%red>)
diff --git a/llvm/test/Transforms/LoopVectorize/VPlan/vplan-printing-reductions.ll b/llvm/test/Transforms/LoopVectorize/VPlan/vplan-printing-reductions.ll
index 4159dccd2d301..99728093b566f 100644
--- a/llvm/test/Transforms/LoopVectorize/VPlan/vplan-printing-reductions.ll
+++ b/llvm/test/Transforms/LoopVectorize/VPlan/vplan-printing-reductions.ll
@@ -25,7 +25,7 @@ define float @print_reduction(i64 %n, ptr noalias %y) {
; CHECK-NEXT: vector.body:
; CHECK-NEXT: WIDEN-REDUCTION-PHI ir<%red> = phi (fadd) fast vp<[[VP3]]>, ir<%red.next>
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = SCALAR-STEPS vp<[[VP4]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%arrayidx> = getelementptr inbounds ir<%y>, vp<[[VP5]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%arrayidx> = getelementptr inbounds float, ir<%y>, vp<[[VP5]]>
; CHECK-NEXT: vp<[[VP6:%[0-9]+]]> = vector-pointer inbounds float, ir<%arrayidx>, ir<1>
; CHECK-NEXT: WIDEN ir<%lv> = load vp<[[VP6]]>
; CHECK-NEXT: REDUCE ir<%red.next> = ir<%red> + fast reduce.fadd (ir<%lv>)
@@ -99,7 +99,7 @@ define void @print_reduction_with_invariant_store(i64 %n, ptr noalias %y, ptr no
; CHECK-NEXT: vector.body:
; CHECK-NEXT: WIDEN-REDUCTION-PHI ir<%red> = phi (fadd) fast vp<[[VP3]]>, ir<%red.next>
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = SCALAR-STEPS vp<[[VP4]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%arrayidx> = getelementptr inbounds ir<%y>, vp<[[VP5]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%arrayidx> = getelementptr inbounds float, ir<%y>, vp<[[VP5]]>
; CHECK-NEXT: vp<[[VP6:%[0-9]+]]> = vector-pointer inbounds float, ir<%arrayidx>, ir<1>
; CHECK-NEXT: WIDEN ir<%lv> = load vp<[[VP6]]>
; CHECK-NEXT: REDUCE ir<%red.next> = ir<%red> + fast reduce.fadd (ir<%lv>)
@@ -175,10 +175,10 @@ define float @print_fmuladd_strict(ptr %a, ptr %b, i64 %n) {
; CHECK-NEXT: vector.body:
; CHECK-NEXT: WIDEN-REDUCTION-PHI ir<%sum.07> = phi (fmuladd) nnan ninf nsz vp<[[VP3]]>, ir<%muladd>
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = SCALAR-STEPS vp<[[VP4]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%arrayidx> = getelementptr inbounds ir<%a>, vp<[[VP5]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%arrayidx> = getelementptr inbounds float, ir<%a>, vp<[[VP5]]>
; CHECK-NEXT: vp<[[VP6:%[0-9]+]]> = vector-pointer inbounds float, ir<%arrayidx>, ir<1>
; CHECK-NEXT: WIDEN ir<%l.a> = load vp<[[VP6]]>
-; CHECK-NEXT: CLONE ir<%arrayidx2> = getelementptr inbounds ir<%b>, vp<[[VP5]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%arrayidx2> = getelementptr inbounds float, ir<%b>, vp<[[VP5]]>
; CHECK-NEXT: vp<[[VP7:%[0-9]+]]> = vector-pointer inbounds float, ir<%arrayidx2>, ir<1>
; CHECK-NEXT: WIDEN ir<%l.b> = load vp<[[VP7]]>
; CHECK-NEXT: EMIT vp<[[VP8:%[0-9]+]]> = fmul nnan ninf nsz ir<%l.a>, ir<%l.b>
@@ -258,7 +258,7 @@ define i64 @find_last_iv(ptr %a, i64 %n, i64 %start) {
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION nuw nsw ir<0>, ir<1>, vp<[[VP0]]>
; CHECK-NEXT: WIDEN-REDUCTION-PHI ir<%rdx> = phi (find-iv) ir<-9223372036854775808>, ir<%cond>
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = SCALAR-STEPS vp<[[VP3]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%gep.a> = getelementptr inbounds ir<%a>, vp<[[VP4]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.a> = getelementptr inbounds i64, ir<%a>, vp<[[VP4]]>
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = vector-pointer inbounds i64, ir<%gep.a>, ir<1>
; CHECK-NEXT: WIDEN ir<%l.a> = load vp<[[VP5]]>
; CHECK-NEXT: WIDEN ir<%cmp2> = icmp eq ir<%l.a>, ir<%start>
@@ -337,7 +337,7 @@ define i64 @print_extended_reduction(ptr nocapture readonly %x, ptr nocapture re
; CHECK-NEXT: vector.body:
; CHECK-NEXT: WIDEN-REDUCTION-PHI ir<%rdx> = phi (add) vp<[[VP3]]>, vp<[[VP7:%[0-9]+]]>
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = SCALAR-STEPS vp<[[VP4]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%arrayidx> = getelementptr inbounds ir<%x>, vp<[[VP5]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%arrayidx> = getelementptr inbounds i32, ir<%x>, vp<[[VP5]]>
; CHECK-NEXT: vp<[[VP6:%[0-9]+]]> = vector-pointer inbounds i32, ir<%arrayidx>, ir<1>
; CHECK-NEXT: WIDEN ir<%load0> = load vp<[[VP6]]>
; CHECK-NEXT: EXPRESSION vp<[[VP7]]> = ir<%rdx> + reduce.add (ir<%load0> zext to i64)
@@ -414,10 +414,10 @@ define i64 @print_mulacc(ptr nocapture readonly %x, ptr nocapture readonly %y, i
; CHECK-NEXT: vector.body:
; CHECK-NEXT: WIDEN-REDUCTION-PHI ir<%rdx> = phi (add) vp<[[VP3]]>, vp<[[VP8:%[0-9]+]]>
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = SCALAR-STEPS vp<[[VP4]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%arrayidx> = getelementptr inbounds ir<%x>, vp<[[VP5]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%arrayidx> = getelementptr inbounds i64, ir<%x>, vp<[[VP5]]>
; CHECK-NEXT: vp<[[VP6:%[0-9]+]]> = vector-pointer inbounds i64, ir<%arrayidx>, ir<1>
; CHECK-NEXT: WIDEN ir<%load0> = load vp<[[VP6]]>
-; CHECK-NEXT: CLONE ir<%arrayidx1> = getelementptr inbounds ir<%y>, vp<[[VP5]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%arrayidx1> = getelementptr inbounds i64, ir<%y>, vp<[[VP5]]>
; CHECK-NEXT: vp<[[VP7:%[0-9]+]]> = vector-pointer inbounds i64, ir<%arrayidx1>, ir<1>
; CHECK-NEXT: WIDEN ir<%load1> = load vp<[[VP7]]>
; CHECK-NEXT: EXPRESSION vp<[[VP8]]> = ir<%rdx> + reduce.add (mul nsw ir<%load0>, ir<%load1>)
@@ -498,10 +498,10 @@ define i64 @print_mulacc_extended(ptr nocapture readonly %x, ptr nocapture reado
; CHECK-NEXT: vector.body:
; CHECK-NEXT: WIDEN-REDUCTION-PHI ir<%rdx> = phi (add) vp<[[VP3]]>, vp<[[VP8:%[0-9]+]]>
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = SCALAR-STEPS vp<[[VP4]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%arrayidx> = getelementptr inbounds ir<%x>, vp<[[VP5]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%arrayidx> = getelementptr inbounds i16, ir<%x>, vp<[[VP5]]>
; CHECK-NEXT: vp<[[VP6:%[0-9]+]]> = vector-pointer inbounds i16, ir<%arrayidx>, ir<1>
; CHECK-NEXT: WIDEN ir<%load0> = load vp<[[VP6]]>
-; CHECK-NEXT: CLONE ir<%arrayidx1> = getelementptr inbounds ir<%y>, vp<[[VP5]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%arrayidx1> = getelementptr inbounds i16, ir<%y>, vp<[[VP5]]>
; CHECK-NEXT: vp<[[VP7:%[0-9]+]]> = vector-pointer inbounds i16, ir<%arrayidx1>, ir<1>
; CHECK-NEXT: WIDEN ir<%load1> = load vp<[[VP7]]>
; CHECK-NEXT: EXPRESSION vp<[[VP8]]> = ir<%rdx> + reduce.add (mul nsw (ir<%load0> sext to i64), (ir<%load1> sext to i64))
@@ -588,7 +588,7 @@ define i64 @print_extended_sub_reduction(ptr nocapture readonly %x, ptr nocaptur
; CHECK-NEXT: vector.body:
; CHECK-NEXT: WIDEN-REDUCTION-PHI ir<%rdx> = phi (sub) vp<[[VP3]]>, vp<[[VP7:%[0-9]+]]>
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = SCALAR-STEPS vp<[[VP4]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%arrayidx> = getelementptr inbounds ir<%x>, vp<[[VP5]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%arrayidx> = getelementptr inbounds i32, ir<%x>, vp<[[VP5]]>
; CHECK-NEXT: vp<[[VP6:%[0-9]+]]> = vector-pointer inbounds i32, ir<%arrayidx>, ir<1>
; CHECK-NEXT: WIDEN ir<%load0> = load vp<[[VP6]]>
; CHECK-NEXT: EXPRESSION vp<[[VP7]]> = ir<%rdx> + reduce.sub (ir<%load0> zext to i64)
@@ -665,10 +665,10 @@ define i32 @print_mulacc_sub(ptr %a, ptr %b) {
; CHECK-NEXT: vector.body:
; CHECK-NEXT: WIDEN-REDUCTION-PHI ir<%accum> = phi (sub) vp<[[VP3]]>, vp<[[VP8:%[0-9]+]]>
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = SCALAR-STEPS vp<[[VP4]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%gep.a> = getelementptr ir<%a>, vp<[[VP5]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.a> = getelementptr i8, ir<%a>, vp<[[VP5]]>
; CHECK-NEXT: vp<[[VP6:%[0-9]+]]> = vector-pointer i8, ir<%gep.a>, ir<1>
; CHECK-NEXT: WIDEN ir<%load.a> = load vp<[[VP6]]>
-; CHECK-NEXT: CLONE ir<%gep.b> = getelementptr ir<%b>, vp<[[VP5]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.b> = getelementptr i8, ir<%b>, vp<[[VP5]]>
; CHECK-NEXT: vp<[[VP7:%[0-9]+]]> = vector-pointer i8, ir<%gep.b>, ir<1>
; CHECK-NEXT: WIDEN ir<%load.b> = load vp<[[VP7]]>
; CHECK-NEXT: EXPRESSION vp<[[VP8]]> = ir<%accum> + reduce.sub (mul (ir<%load.b> zext to i32), (ir<%load.a> zext to i32))
@@ -752,10 +752,10 @@ define i32 @print_mulacc_negated(ptr %a, ptr %b) {
; CHECK-NEXT: vector.body:
; CHECK-NEXT: WIDEN-REDUCTION-PHI ir<%accum> = phi (add) vp<[[VP3]]>, vp<[[VP8:%[0-9]+]]>
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = SCALAR-STEPS vp<[[VP4]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%gep.a> = getelementptr ir<%a>, vp<[[VP5]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.a> = getelementptr i8, ir<%a>, vp<[[VP5]]>
; CHECK-NEXT: vp<[[VP6:%[0-9]+]]> = vector-pointer i8, ir<%gep.a>, ir<1>
; CHECK-NEXT: WIDEN ir<%load.a> = load vp<[[VP6]]>
-; CHECK-NEXT: CLONE ir<%gep.b> = getelementptr ir<%b>, vp<[[VP5]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.b> = getelementptr i8, ir<%b>, vp<[[VP5]]>
; CHECK-NEXT: vp<[[VP7:%[0-9]+]]> = vector-pointer i8, ir<%gep.b>, ir<1>
; CHECK-NEXT: WIDEN ir<%load.b> = load vp<[[VP7]]>
; CHECK-NEXT: EXPRESSION vp<[[VP8]]> = ir<%accum> + reduce.add (sub (0, mul (ir<%load.b> zext to i32), (ir<%load.a> zext to i32)))
@@ -841,10 +841,10 @@ define i64 @print_mulacc_sub_extended(ptr nocapture readonly %x, ptr nocapture r
; CHECK-NEXT: vector.body:
; CHECK-NEXT: WIDEN-REDUCTION-PHI ir<%rdx> = phi (sub) vp<[[VP3]]>, vp<[[VP8:%[0-9]+]]>
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = SCALAR-STEPS vp<[[VP4]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%arrayidx> = getelementptr inbounds ir<%x>, vp<[[VP5]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%arrayidx> = getelementptr inbounds i16, ir<%x>, vp<[[VP5]]>
; CHECK-NEXT: vp<[[VP6:%[0-9]+]]> = vector-pointer inbounds i16, ir<%arrayidx>, ir<1>
; CHECK-NEXT: WIDEN ir<%load0> = load vp<[[VP6]]>
-; CHECK-NEXT: CLONE ir<%arrayidx1> = getelementptr inbounds ir<%y>, vp<[[VP5]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%arrayidx1> = getelementptr inbounds i16, ir<%y>, vp<[[VP5]]>
; CHECK-NEXT: vp<[[VP7:%[0-9]+]]> = vector-pointer inbounds i16, ir<%arrayidx1>, ir<1>
; CHECK-NEXT: WIDEN ir<%load1> = load vp<[[VP7]]>
; CHECK-NEXT: EXPRESSION vp<[[VP8]]> = ir<%rdx> + reduce.sub (mul nsw (ir<%load0> sext to i64), (ir<%load1> sext to i64))
@@ -931,7 +931,7 @@ define i64 @print_mulacc_duplicate_extends(ptr nocapture readonly %x, ptr nocapt
; CHECK-NEXT: vector.body:
; CHECK-NEXT: WIDEN-REDUCTION-PHI ir<%rdx> = phi (sub) vp<[[VP3]]>, vp<[[VP7:%[0-9]+]]>
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = SCALAR-STEPS vp<[[VP4]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%arrayidx> = getelementptr inbounds ir<%x>, vp<[[VP5]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%arrayidx> = getelementptr inbounds i16, ir<%x>, vp<[[VP5]]>
; CHECK-NEXT: vp<[[VP6:%[0-9]+]]> = vector-pointer inbounds i16, ir<%arrayidx>, ir<1>
; CHECK-NEXT: WIDEN ir<%load0> = load vp<[[VP6]]>
; CHECK-NEXT: EXPRESSION vp<[[VP7]]> = ir<%rdx> + reduce.sub (mul nsw (ir<%load0> sext to i64), (ir<%load0> sext to i64))
@@ -1509,7 +1509,7 @@ define i32 @print_umax_reduction_out_of_loop(ptr %y) {
; CHECK-NEXT: vector.body:
; CHECK-NEXT: WIDEN-REDUCTION-PHI ir<%red> = phi (umax) ir<0>, ir<%red.next>
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = SCALAR-STEPS vp<[[VP3]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%gep> = getelementptr inbounds ir<%y>, vp<[[VP4]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr inbounds i32, ir<%y>, vp<[[VP4]]>
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = vector-pointer inbounds i32, ir<%gep>, ir<1>
; CHECK-NEXT: WIDEN ir<%lv> = load vp<[[VP5]]>
; CHECK-NEXT: WIDEN-INTRINSIC ir<%red.next> = call llvm.umax(ir<%lv>, ir<%red>)
@@ -1582,7 +1582,7 @@ define i32 @print_umax_reduction(ptr %y) {
; CHECK-NEXT: vector.body:
; CHECK-NEXT: WIDEN-REDUCTION-PHI ir<%red> = phi (umax) ir<0>, ir<%red.next>
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = SCALAR-STEPS vp<[[VP3]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%gep> = getelementptr inbounds ir<%y>, vp<[[VP4]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr inbounds i32, ir<%y>, vp<[[VP4]]>
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = vector-pointer inbounds i32, ir<%gep>, ir<1>
; CHECK-NEXT: WIDEN ir<%lv> = load vp<[[VP5]]>
; CHECK-NEXT: WIDEN-INTRINSIC ir<%red.next> = call llvm.umax(ir<%red>, ir<%lv>)
@@ -1655,7 +1655,7 @@ define i32 @print_umin_reduction(ptr %y) {
; CHECK-NEXT: vector.body:
; CHECK-NEXT: WIDEN-REDUCTION-PHI ir<%red> = phi (umin) ir<0>, ir<%red.next>
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = SCALAR-STEPS vp<[[VP3]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%gep> = getelementptr inbounds ir<%y>, vp<[[VP4]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr inbounds i32, ir<%y>, vp<[[VP4]]>
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = vector-pointer inbounds i32, ir<%gep>, ir<1>
; CHECK-NEXT: WIDEN ir<%lv> = load vp<[[VP5]]>
; CHECK-NEXT: WIDEN-INTRINSIC ir<%red.next> = call llvm.umin(ir<%lv>, ir<%red>)
@@ -1728,7 +1728,7 @@ define i32 @print_smax_reduction(ptr %y) {
; CHECK-NEXT: vector.body:
; CHECK-NEXT: WIDEN-REDUCTION-PHI ir<%red> = phi (smax) ir<0>, ir<%red.next>
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = SCALAR-STEPS vp<[[VP3]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%gep> = getelementptr inbounds ir<%y>, vp<[[VP4]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr inbounds i32, ir<%y>, vp<[[VP4]]>
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = vector-pointer inbounds i32, ir<%gep>, ir<1>
; CHECK-NEXT: WIDEN ir<%lv> = load vp<[[VP5]]>
; CHECK-NEXT: WIDEN-INTRINSIC ir<%red.next> = call llvm.smax(ir<%red>, ir<%lv>)
@@ -1801,7 +1801,7 @@ define i32 @print_smin_reduction(ptr %y) {
; CHECK-NEXT: vector.body:
; CHECK-NEXT: WIDEN-REDUCTION-PHI ir<%red> = phi (smin) ir<0>, ir<%red.next>
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = SCALAR-STEPS vp<[[VP3]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%gep> = getelementptr inbounds ir<%y>, vp<[[VP4]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr inbounds i32, ir<%y>, vp<[[VP4]]>
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = vector-pointer inbounds i32, ir<%gep>, ir<1>
; CHECK-NEXT: WIDEN ir<%lv> = load vp<[[VP5]]>
; CHECK-NEXT: WIDEN-INTRINSIC ir<%red.next> = call llvm.smin(ir<%lv>, ir<%red>)
diff --git a/llvm/test/Transforms/LoopVectorize/VPlan/vplan-printing.ll b/llvm/test/Transforms/LoopVectorize/VPlan/vplan-printing.ll
index bdc7b1f5d29bf..d79fa820d0c72 100644
--- a/llvm/test/Transforms/LoopVectorize/VPlan/vplan-printing.ll
+++ b/llvm/test/Transforms/LoopVectorize/VPlan/vplan-printing.ll
@@ -25,11 +25,11 @@ define void @print_call_and_memory(i64 %n, ptr noalias %y, ptr noalias %x) {
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = SCALAR-STEPS vp<[[VP3]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%arrayidx> = getelementptr inbounds ir<%y>, vp<[[VP4]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%arrayidx> = getelementptr inbounds float, ir<%y>, vp<[[VP4]]>
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = vector-pointer inbounds float, ir<%arrayidx>, ir<1>
; CHECK-NEXT: WIDEN ir<%lv> = load vp<[[VP5]]>
; CHECK-NEXT: WIDEN-INTRINSIC ir<%call> = call llvm.sqrt(ir<%lv>)
-; CHECK-NEXT: CLONE ir<%arrayidx2> = getelementptr inbounds ir<%x>, vp<[[VP4]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%arrayidx2> = getelementptr inbounds float, ir<%x>, vp<[[VP4]]>
; CHECK-NEXT: vp<[[VP6:%[0-9]+]]> = vector-pointer inbounds float, ir<%arrayidx2>, ir<1>
; CHECK-NEXT: WIDEN store vp<[[VP6]]>, ir<%call>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<[[VP3]]>, vp<[[VP1]]>
@@ -107,7 +107,7 @@ define void @print_widen_gep_and_select(i64 %n, ptr noalias %y, ptr noalias %x,
; CHECK-NEXT: WIDEN ir<%cmp> = icmp eq ir<%arrayidx>, ir<%z>
; CHECK-NEXT: WIDEN ir<%sel> = select ir<%cmp>, ir<1.000000e+01>, ir<2.000000e+01>
; CHECK-NEXT: WIDEN ir<%add> = fadd ir<%lv>, ir<%sel>
-; CHECK-NEXT: CLONE ir<%arrayidx2> = getelementptr inbounds ir<%x>, vp<[[VP4]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%arrayidx2> = getelementptr inbounds float, ir<%x>, vp<[[VP4]]>
; CHECK-NEXT: vp<[[VP6:%[0-9]+]]> = vector-pointer inbounds float, ir<%arrayidx2>, ir<1>
; CHECK-NEXT: WIDEN store vp<[[VP6]]>, ir<%add>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<[[VP3]]>, vp<[[VP1]]>
@@ -205,7 +205,7 @@ define void @print_replicate_predicated_phi(i64 %n, ptr %x) {
; CHECK-EMPTY:
; CHECK-NEXT: if.then.0:
; CHECK-NEXT: BLEND ir<%d> = ir<0> vp<%7>/ir<%cmp>
-; CHECK-NEXT: CLONE ir<%idx> = getelementptr ir<%x>, vp<[[VP5]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%idx> = getelementptr i64, ir<%x>, vp<[[VP5]]>
; CHECK-NEXT: vp<[[VP8:%[0-9]+]]> = vector-pointer i64, ir<%idx>, ir<1>
; CHECK-NEXT: WIDEN store vp<[[VP8]]>, ir<%d>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<[[VP4]]>, vp<[[VP1]]>
@@ -280,13 +280,13 @@ define void @print_interleave_groups(i32 %C, i32 %D) {
; CHECK-NEXT: vector.body:
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = DERIVED-IV nuw ir<0> + vp<[[VP4]]> * ir<4>
; CHECK-NEXT: vp<[[VP6:%[0-9]+]]> = SCALAR-STEPS vp<[[VP5]]>, ir<4>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%gep.AB.0> = getelementptr inbounds ir<@AB>, ir<0>, vp<[[VP6]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.AB.0> = getelementptr inbounds [1024 x i32], ir<@AB>, ir<0>, vp<[[VP6]]>
; CHECK-NEXT: INTERLEAVE-GROUP with factor 4, ir<%gep.AB.0>
; CHECK-NEXT: ir<%AB.0> = load from index 0
; CHECK-NEXT: ir<%AB.1> = load from index 1
; CHECK-NEXT: ir<%AB.3> = load from index 3
; CHECK-NEXT: WIDEN ir<%add> = add nsw ir<%AB.0>, ir<%AB.1>
-; CHECK-NEXT: CLONE ir<%gep.CD.0> = getelementptr inbounds ir<@CD>, ir<0>, vp<[[VP6]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.CD.0> = getelementptr inbounds [1024 x i32], ir<@CD>, ir<0>, vp<[[VP6]]>
; CHECK-NEXT: INTERLEAVE-GROUP with factor 4, ir<%gep.CD.0>
; CHECK-NEXT: store ir<%add> to index 0
; CHECK-NEXT: store ir<1> to index 1
@@ -385,7 +385,7 @@ define void @recipe_debug_loc_location(ptr nocapture %src) !dbg !5 {
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = SCALAR-STEPS vp<[[VP3]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%isd> = getelementptr inbounds ir<%src>, vp<[[VP4]]>, !dbg /tmp/s.c:5:3
+; CHECK-NEXT: EMIT-SCALAR ir<%isd> = getelementptr inbounds i32, ir<%src>, vp<[[VP4]]>, !dbg /tmp/s.c:5:3
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = vector-pointer inbounds i32, ir<%isd>, ir<1>, !dbg /tmp/s.c:6:3
; CHECK-NEXT: WIDEN ir<%lsd> = load vp<[[VP5]]>, !dbg /tmp/s.c:6:3
; CHECK-NEXT: WIDEN ir<%psd> = add nuw nsw ir<%lsd>, ir<23>, !dbg /tmp/s.c:7:3
@@ -570,7 +570,7 @@ define i32 @print_exit_value(ptr %ptr, i32 %off) {
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = SCALAR-STEPS vp<[[VP3]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%gep> = getelementptr inbounds ir<%ptr>, vp<[[VP4]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr inbounds i8, ir<%ptr>, vp<[[VP4]]>
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = vector-pointer inbounds i8, ir<%gep>, ir<1>
; CHECK-NEXT: WIDEN store vp<[[VP5]]>, ir<0>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<[[VP3]]>, vp<[[VP1]]>
@@ -640,13 +640,13 @@ define void @print_fast_math_flags(i64 %n, ptr noalias %y, ptr noalias %x, ptr %
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = SCALAR-STEPS vp<[[VP3]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%gep.y> = getelementptr inbounds ir<%y>, vp<[[VP4]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.y> = getelementptr inbounds float, ir<%y>, vp<[[VP4]]>
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = vector-pointer inbounds float, ir<%gep.y>, ir<1>
; CHECK-NEXT: WIDEN ir<%lv> = load vp<[[VP5]]>
; CHECK-NEXT: WIDEN ir<%add> = fadd nnan ir<%lv>, ir<1.000000e+00>
; CHECK-NEXT: WIDEN ir<%mul> = fmul fast ir<%add>, ir<2.000000e+00>
; CHECK-NEXT: WIDEN ir<%div> = fdiv reassoc nsz contract ir<%mul>, ir<2.000000e+00>
-; CHECK-NEXT: CLONE ir<%gep.x> = getelementptr inbounds ir<%x>, vp<[[VP4]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.x> = getelementptr inbounds float, ir<%x>, vp<[[VP4]]>
; CHECK-NEXT: vp<[[VP6:%[0-9]+]]> = vector-pointer inbounds float, ir<%gep.x>, ir<1>
; CHECK-NEXT: WIDEN store vp<[[VP6]]>, ir<%div>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<[[VP3]]>, vp<[[VP1]]>
@@ -720,7 +720,7 @@ define void @print_exact_flags(i64 %n, ptr noalias %x) {
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = SCALAR-STEPS vp<[[VP3]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%gep.x> = getelementptr inbounds ir<%x>, vp<[[VP4]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.x> = getelementptr inbounds i32, ir<%x>, vp<[[VP4]]>
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = vector-pointer inbounds i32, ir<%gep.x>, ir<1>
; CHECK-NEXT: WIDEN ir<%lv> = load vp<[[VP5]]>
; CHECK-NEXT: WIDEN ir<%div.1> = udiv exact ir<%lv>, ir<20>
@@ -797,7 +797,7 @@ define void @print_call_flags(ptr readonly %src, ptr noalias %dest, i64 %n) {
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = SCALAR-STEPS vp<[[VP3]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%ld.addr> = getelementptr inbounds ir<%src>, vp<[[VP4]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%ld.addr> = getelementptr inbounds float, ir<%src>, vp<[[VP4]]>
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = vector-pointer inbounds float, ir<%ld.addr>, ir<1>
; CHECK-NEXT: WIDEN ir<%ld.value> = load vp<[[VP5]]>
; CHECK-NEXT: WIDEN ir<%ifcond> = fcmp oeq ir<%ld.value>, ir<5.000000e+00>
@@ -823,7 +823,7 @@ define void @print_call_flags(ptr readonly %src, ptr noalias %dest, i64 %n) {
; CHECK-NEXT: if.then.1:
; CHECK-NEXT: WIDEN ir<%fadd> = fadd vp<[[VP6]]>, vp<[[VP7]]>
; CHECK-NEXT: BLEND ir<%st.value> = ir<%ld.value> ir<%fadd>/ir<%ifcond>
-; CHECK-NEXT: CLONE ir<%st.addr> = getelementptr inbounds ir<%dest>, vp<[[VP4]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%st.addr> = getelementptr inbounds float, ir<%dest>, vp<[[VP4]]>
; CHECK-NEXT: vp<[[VP8:%[0-9]+]]> = vector-pointer inbounds float, ir<%st.addr>, ir<1>
; CHECK-NEXT: WIDEN store vp<[[VP8]]>, ir<%st.value>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<[[VP3]]>, vp<[[VP1]]>
@@ -900,7 +900,7 @@ define void @print_disjoint_flags(i64 %n, ptr noalias %x) {
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = SCALAR-STEPS vp<[[VP3]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%gep.x> = getelementptr inbounds ir<%x>, vp<[[VP4]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.x> = getelementptr inbounds i32, ir<%x>, vp<[[VP4]]>
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = vector-pointer inbounds i32, ir<%gep.x>, ir<1>
; CHECK-NEXT: WIDEN ir<%lv> = load vp<[[VP5]]>
; CHECK-NEXT: WIDEN ir<%or.1> = or disjoint ir<%lv>, ir<1>
@@ -977,7 +977,7 @@ define void @zext_nneg(ptr noalias %p, ptr noalias %p1) {
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = SCALAR-STEPS vp<[[VP3]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%idx> = getelementptr ir<%p>, vp<[[VP4]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%idx> = getelementptr i32, ir<%p>, vp<[[VP4]]>
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = vector-pointer i32, ir<%idx>, ir<1>
; CHECK-NEXT: WIDEN ir<%l> = load vp<[[VP5]]>
; CHECK-NEXT: WIDEN-CAST ir<%zext> = zext nneg ir<%l> to i64
@@ -1050,7 +1050,7 @@ define i16 @print_first_order_recurrence_and_result(ptr %ptr) {
; CHECK-NEXT: vector.body:
; CHECK-NEXT: FIRST-ORDER-RECURRENCE-PHI ir<%for.1> = phi ir<22>, ir<%for.1.next>
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = SCALAR-STEPS vp<[[VP3]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%gep.ptr> = getelementptr inbounds ir<%ptr>, vp<[[VP4]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.ptr> = getelementptr inbounds i16, ir<%ptr>, vp<[[VP4]]>
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = vector-pointer inbounds i16, ir<%gep.ptr>, ir<1>
; CHECK-NEXT: WIDEN ir<%for.1.next> = load vp<[[VP5]]>
; CHECK-NEXT: EMIT vp<[[VP6:%[0-9]+]]> = first-order splice ir<%for.1>, ir<%for.1.next>
@@ -1129,16 +1129,16 @@ define void @print_select_with_fastmath_flags(ptr noalias %a, ptr noalias %b, pt
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = SCALAR-STEPS vp<[[VP3]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%gep> = getelementptr inbounds nuw ir<%b>, vp<[[VP4]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr inbounds nuw float, ir<%b>, vp<[[VP4]]>
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = vector-pointer inbounds nuw float, ir<%gep>, ir<1>
; CHECK-NEXT: WIDEN ir<%0> = load vp<[[VP5]]>
-; CHECK-NEXT: CLONE ir<%gep3> = getelementptr inbounds nuw ir<%c>, vp<[[VP4]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep3> = getelementptr inbounds nuw float, ir<%c>, vp<[[VP4]]>
; CHECK-NEXT: vp<[[VP6:%[0-9]+]]> = vector-pointer inbounds nuw float, ir<%gep3>, ir<1>
; CHECK-NEXT: WIDEN ir<%1> = load vp<[[VP6]]>
; CHECK-NEXT: WIDEN ir<%cmp4> = fcmp ogt fast ir<%0>, ir<%1>
; CHECK-NEXT: WIDEN ir<%add> = fadd fast ir<%0>, ir<1.000000e+01>
; CHECK-NEXT: WIDEN ir<%cond> = select fast ir<%cmp4>, ir<%add>, ir<%1>
-; CHECK-NEXT: CLONE ir<%gep11> = getelementptr inbounds nuw ir<%a>, vp<[[VP4]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep11> = getelementptr inbounds nuw float, ir<%a>, vp<[[VP4]]>
; CHECK-NEXT: vp<[[VP7:%[0-9]+]]> = vector-pointer inbounds nuw float, ir<%gep11>, ir<1>
; CHECK-NEXT: WIDEN store vp<[[VP7]]>, ir<%cond>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<[[VP3]]>, vp<[[VP1]]>
diff --git a/llvm/test/Transforms/LoopVectorize/VPlan/vplan-scev-address-idioms.ll b/llvm/test/Transforms/LoopVectorize/VPlan/vplan-scev-address-idioms.ll
index c09553eb14127..72ed7094ffe1b 100644
--- a/llvm/test/Transforms/LoopVectorize/VPlan/vplan-scev-address-idioms.ll
+++ b/llvm/test/Transforms/LoopVectorize/VPlan/vplan-scev-address-idioms.ll
@@ -21,10 +21,10 @@ define void @bitcast_noop(ptr noalias %A, ptr noalias %B) {
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION nuw nsw ir<0>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: EMIT ir<%gep> = getelementptr inbounds ir<%A>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr inbounds i32, ir<%A>, ir<%iv>
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = vector-pointer inbounds i32, ir<%gep>, ir<1>
; CHECK-NEXT: WIDEN ir<%l> = load vp<[[VP4]]>
-; CHECK-NEXT: EMIT ir<%gep.b> = getelementptr inbounds ir<%B>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.b> = getelementptr inbounds i32, ir<%B>, ir<%iv>
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = vector-pointer inbounds i32, ir<%gep.b>, ir<1>
; CHECK-NEXT: WIDEN store vp<[[VP5]]>, ir<%l>
; CHECK-NEXT: EMIT ir<%iv.next> = add nuw nsw ir<%iv>, ir<1>
@@ -85,9 +85,9 @@ define void @ashr_zero(ptr noalias %A, ptr noalias %B) {
; CHECK-NEXT: vector.body:
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION nuw nsw ir<0>, ir<1>, vp<[[VP0]]>
; CHECK-NEXT: EMIT ir<%idx> = ashr ir<%iv>, ir<0>
-; CHECK-NEXT: EMIT ir<%gep> = getelementptr inbounds ir<%A>, ir<%idx>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr inbounds i32, ir<%A>, ir<%idx>
; CHECK-NEXT: EMIT-SCALAR ir<%l> = load ir<%gep>
-; CHECK-NEXT: EMIT ir<%gep.b> = getelementptr inbounds ir<%B>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.b> = getelementptr inbounds i32, ir<%B>, ir<%iv>
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = vector-pointer inbounds i32, ir<%gep.b>, ir<1>
; CHECK-NEXT: WIDEN store vp<[[VP4]]>, ir<%l>
; CHECK-NEXT: EMIT ir<%iv.next> = add nuw nsw ir<%iv>, ir<1>
@@ -150,9 +150,9 @@ define void @ashr_of_add_of_shl(ptr noalias %A, ptr noalias %B) {
; CHECK-NEXT: EMIT ir<%s> = shl nsw ir<%iv>, ir<3>
; CHECK-NEXT: EMIT ir<%a> = add ir<%s>, ir<8>
; CHECK-NEXT: EMIT ir<%idx> = ashr ir<%a>, ir<3>
-; CHECK-NEXT: EMIT ir<%gep> = getelementptr inbounds ir<%A>, ir<%idx>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr inbounds i32, ir<%A>, ir<%idx>
; CHECK-NEXT: EMIT-SCALAR ir<%l> = load ir<%gep>
-; CHECK-NEXT: EMIT ir<%gep.b> = getelementptr inbounds ir<%B>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.b> = getelementptr inbounds i32, ir<%B>, ir<%iv>
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = vector-pointer inbounds i32, ir<%gep.b>, ir<1>
; CHECK-NEXT: WIDEN store vp<[[VP4]]>, ir<%l>
; CHECK-NEXT: EMIT ir<%iv.next> = add nuw nsw ir<%iv>, ir<1>
@@ -215,9 +215,9 @@ define void @ashr_variable(ptr noalias %A, ptr noalias %B, i64 %n) {
; CHECK-NEXT: vector.body:
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION nuw nsw ir<0>, ir<1>, vp<[[VP0]]>
; CHECK-NEXT: EMIT ir<%idx> = ashr ir<%iv>, ir<%n>
-; CHECK-NEXT: EMIT ir<%gep> = getelementptr inbounds ir<%A>, ir<%idx>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr inbounds i32, ir<%A>, ir<%idx>
; CHECK-NEXT: EMIT-SCALAR ir<%l> = load ir<%gep>
-; CHECK-NEXT: EMIT ir<%gep.b> = getelementptr inbounds ir<%B>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.b> = getelementptr inbounds i32, ir<%B>, ir<%iv>
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = vector-pointer inbounds i32, ir<%gep.b>, ir<1>
; CHECK-NEXT: WIDEN store vp<[[VP4]]>, ir<%l>
; CHECK-NEXT: EMIT ir<%iv.next> = add nuw nsw ir<%iv>, ir<1>
@@ -280,9 +280,9 @@ define void @ashr_bitwidth(ptr noalias %A, ptr noalias %B) {
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION nuw nsw ir<0>, ir<1>, vp<[[VP0]]>
; CHECK-NEXT: EMIT ir<%s> = shl nsw ir<%iv>, ir<64>
; CHECK-NEXT: EMIT ir<%idx> = ashr ir<%s>, ir<64>
-; CHECK-NEXT: EMIT ir<%gep> = getelementptr inbounds ir<%A>, ir<%idx>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr inbounds i32, ir<%A>, ir<%idx>
; CHECK-NEXT: EMIT-SCALAR ir<%l> = load ir<%gep>
-; CHECK-NEXT: EMIT ir<%gep.b> = getelementptr inbounds ir<%B>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.b> = getelementptr inbounds i32, ir<%B>, ir<%iv>
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = vector-pointer inbounds i32, ir<%gep.b>, ir<1>
; CHECK-NEXT: WIDEN store vp<[[VP4]]>, ir<%l>
; CHECK-NEXT: EMIT ir<%iv.next> = add nuw nsw ir<%iv>, ir<1>
@@ -344,9 +344,9 @@ define void @usub_sat(ptr noalias %A, ptr noalias %B) {
; CHECK-NEXT: vector.body:
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION nuw nsw ir<0>, ir<1>, vp<[[VP0]]>
; CHECK-NEXT: EMIT ir<%idx> = call ir<%iv>, ir<0>, ir<@llvm.usub.sat.i64>
-; CHECK-NEXT: EMIT ir<%gep> = getelementptr inbounds ir<%A>, ir<%idx>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr inbounds i32, ir<%A>, ir<%idx>
; CHECK-NEXT: EMIT-SCALAR ir<%l> = load ir<%gep>
-; CHECK-NEXT: EMIT ir<%gep.b> = getelementptr inbounds ir<%B>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.b> = getelementptr inbounds i32, ir<%B>, ir<%iv>
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = vector-pointer inbounds i32, ir<%gep.b>, ir<1>
; CHECK-NEXT: WIDEN store vp<[[VP4]]>, ir<%l>
; CHECK-NEXT: EMIT ir<%iv.next> = add nuw nsw ir<%iv>, ir<1>
@@ -407,9 +407,9 @@ define void @uadd_sat(ptr noalias %A, ptr noalias %B) {
; CHECK-NEXT: vector.body:
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION nuw nsw ir<0>, ir<1>, vp<[[VP0]]>
; CHECK-NEXT: EMIT ir<%idx> = call ir<%iv>, ir<0>, ir<@llvm.uadd.sat.i64>
-; CHECK-NEXT: EMIT ir<%gep> = getelementptr inbounds ir<%A>, ir<%idx>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr inbounds i32, ir<%A>, ir<%idx>
; CHECK-NEXT: EMIT-SCALAR ir<%l> = load ir<%gep>
-; CHECK-NEXT: EMIT ir<%gep.b> = getelementptr inbounds ir<%B>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.b> = getelementptr inbounds i32, ir<%B>, ir<%iv>
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = vector-pointer inbounds i32, ir<%gep.b>, ir<1>
; CHECK-NEXT: WIDEN store vp<[[VP4]]>, ir<%l>
; CHECK-NEXT: EMIT ir<%iv.next> = add nuw nsw ir<%iv>, ir<1>
@@ -471,9 +471,9 @@ define void @usub_sat_clamped(ptr noalias %A, ptr noalias %B) {
; CHECK-NEXT: vector.body:
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION nuw nsw ir<0>, ir<1>, vp<[[VP0]]>
; CHECK-NEXT: EMIT ir<%idx> = call ir<4>, ir<%iv>, ir<@llvm.usub.sat.i64>
-; CHECK-NEXT: EMIT ir<%gep> = getelementptr inbounds ir<%A>, ir<%idx>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr inbounds i32, ir<%A>, ir<%idx>
; CHECK-NEXT: EMIT-SCALAR ir<%l> = load ir<%gep>
-; CHECK-NEXT: EMIT ir<%gep.b> = getelementptr inbounds ir<%B>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.b> = getelementptr inbounds i32, ir<%B>, ir<%iv>
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = vector-pointer inbounds i32, ir<%gep.b>, ir<1>
; CHECK-NEXT: WIDEN store vp<[[VP4]]>, ir<%l>
; CHECK-NEXT: EMIT ir<%iv.next> = add nuw nsw ir<%iv>, ir<1>
@@ -533,12 +533,12 @@ define void @ptrtoaddr_gep(ptr noalias %A, ptr noalias %B) {
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION nuw nsw ir<0>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: EMIT ir<%p> = getelementptr inbounds ir<null>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%p> = getelementptr inbounds i8, ir<null>, ir<%iv>
; CHECK-NEXT: EMIT-SCALAR ir<%idx> = ptrtoaddr ir<%p> to i64
-; CHECK-NEXT: EMIT ir<%gep> = getelementptr inbounds ir<%A>, ir<%idx>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr inbounds i32, ir<%A>, ir<%idx>
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = vector-pointer inbounds i32, ir<%gep>, ir<1>
; CHECK-NEXT: WIDEN ir<%l> = load vp<[[VP4]]>
-; CHECK-NEXT: EMIT ir<%gep.b> = getelementptr inbounds ir<%B>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.b> = getelementptr inbounds i32, ir<%B>, ir<%iv>
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = vector-pointer inbounds i32, ir<%gep.b>, ir<1>
; CHECK-NEXT: WIDEN store vp<[[VP5]]>, ir<%l>
; CHECK-NEXT: EMIT ir<%iv.next> = add nuw nsw ir<%iv>, ir<1>
@@ -600,11 +600,11 @@ define void @ptrtoint_gep(ptr noalias %A, ptr noalias %B) {
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION nuw nsw ir<0>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: EMIT ir<%p> = getelementptr inbounds ir<null>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%p> = getelementptr inbounds i8, ir<null>, ir<%iv>
; CHECK-NEXT: EMIT-SCALAR ir<%idx> = ptrtoint ir<%p> to i64
-; CHECK-NEXT: EMIT ir<%gep> = getelementptr inbounds ir<%A>, ir<%idx>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr inbounds i32, ir<%A>, ir<%idx>
; CHECK-NEXT: EMIT-SCALAR ir<%l> = load ir<%gep>
-; CHECK-NEXT: EMIT ir<%gep.b> = getelementptr inbounds ir<%B>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.b> = getelementptr inbounds i32, ir<%B>, ir<%iv>
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = vector-pointer inbounds i32, ir<%gep.b>, ir<1>
; CHECK-NEXT: WIDEN store vp<[[VP4]]>, ir<%l>
; CHECK-NEXT: EMIT ir<%iv.next> = add nuw nsw ir<%iv>, ir<1>
@@ -668,9 +668,9 @@ define void @xor_signmask(ptr noalias %A, ptr noalias %B) {
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION nuw nsw ir<0>, ir<1>, vp<[[VP0]]>
; CHECK-NEXT: EMIT ir<%x> = xor ir<%iv>, ir<-9223372036854775808>
; CHECK-NEXT: EMIT ir<%idx> = add ir<%x>, ir<-9223372036854775808>
-; CHECK-NEXT: EMIT ir<%gep> = getelementptr inbounds ir<%A>, ir<%idx>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr inbounds i32, ir<%A>, ir<%idx>
; CHECK-NEXT: EMIT-SCALAR ir<%l> = load ir<%gep>
-; CHECK-NEXT: EMIT ir<%gep.b> = getelementptr inbounds ir<%B>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.b> = getelementptr inbounds i32, ir<%B>, ir<%iv>
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = vector-pointer inbounds i32, ir<%gep.b>, ir<1>
; CHECK-NEXT: WIDEN store vp<[[VP4]]>, ir<%l>
; CHECK-NEXT: EMIT ir<%iv.next> = add nuw nsw ir<%iv>, ir<1>
@@ -732,9 +732,9 @@ define void @xor_not_signmask(ptr noalias %A, ptr noalias %B) {
; CHECK-NEXT: vector.body:
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION nuw nsw ir<0>, ir<1>, vp<[[VP0]]>
; CHECK-NEXT: EMIT ir<%idx> = xor ir<%iv>, ir<12>
-; CHECK-NEXT: EMIT ir<%gep> = getelementptr inbounds ir<%A>, ir<%idx>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr inbounds i32, ir<%A>, ir<%idx>
; CHECK-NEXT: EMIT-SCALAR ir<%l> = load ir<%gep>
-; CHECK-NEXT: EMIT ir<%gep.b> = getelementptr inbounds ir<%B>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.b> = getelementptr inbounds i32, ir<%B>, ir<%iv>
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = vector-pointer inbounds i32, ir<%gep.b>, ir<1>
; CHECK-NEXT: WIDEN store vp<[[VP4]]>, ir<%l>
; CHECK-NEXT: EMIT ir<%iv.next> = add nuw nsw ir<%iv>, ir<1>
@@ -795,9 +795,9 @@ define void @select_constant_cond(ptr noalias %A, ptr noalias %B) {
; CHECK-NEXT: vector.body:
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION nuw nsw ir<0>, ir<1>, vp<[[VP0]]>
; CHECK-NEXT: EMIT ir<%idx> = select ir<true>, ir<%iv>, ir<0>
-; CHECK-NEXT: EMIT ir<%gep> = getelementptr inbounds ir<%A>, ir<%idx>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr inbounds i32, ir<%A>, ir<%idx>
; CHECK-NEXT: EMIT-SCALAR ir<%l> = load ir<%gep>
-; CHECK-NEXT: EMIT ir<%gep.b> = getelementptr inbounds ir<%B>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.b> = getelementptr inbounds i32, ir<%B>, ir<%iv>
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = vector-pointer inbounds i32, ir<%gep.b>, ir<1>
; CHECK-NEXT: WIDEN store vp<[[VP4]]>, ir<%l>
; CHECK-NEXT: EMIT ir<%iv.next> = add nuw nsw ir<%iv>, ir<1>
@@ -861,9 +861,9 @@ define void @select_equal_arms(ptr noalias %A, ptr noalias %B, i64 %n) {
; CHECK-NEXT: EMIT ir<%b> = or disjoint ir<%iv>, ir<4>
; CHECK-NEXT: EMIT ir<%c> = icmp ult ir<%iv>, ir<%n>
; CHECK-NEXT: EMIT ir<%idx> = select ir<%c>, ir<%a>, ir<%b>
-; CHECK-NEXT: EMIT ir<%gep> = getelementptr inbounds ir<%A>, ir<%idx>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr inbounds i32, ir<%A>, ir<%idx>
; CHECK-NEXT: EMIT-SCALAR ir<%l> = load ir<%gep>
-; CHECK-NEXT: EMIT ir<%gep.b> = getelementptr inbounds ir<%B>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.b> = getelementptr inbounds i32, ir<%B>, ir<%iv>
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = vector-pointer inbounds i32, ir<%gep.b>, ir<1>
; CHECK-NEXT: WIDEN store vp<[[VP4]]>, ir<%l>
; CHECK-NEXT: EMIT ir<%iv.next> = add nuw nsw ir<%iv>, ir<1>
@@ -930,9 +930,9 @@ define void @select_different_arms(ptr noalias %A, ptr noalias %B, i64 %n) {
; CHECK-NEXT: EMIT ir<%b> = add ir<%iv>, ir<8>
; CHECK-NEXT: EMIT ir<%c> = icmp ult ir<%iv>, ir<%n>
; CHECK-NEXT: EMIT ir<%idx> = select ir<%c>, ir<%a>, ir<%b>
-; CHECK-NEXT: EMIT ir<%gep> = getelementptr inbounds ir<%A>, ir<%idx>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr inbounds i32, ir<%A>, ir<%idx>
; CHECK-NEXT: EMIT-SCALAR ir<%l> = load ir<%gep>
-; CHECK-NEXT: EMIT ir<%gep.b> = getelementptr inbounds ir<%B>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.b> = getelementptr inbounds i32, ir<%B>, ir<%iv>
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = vector-pointer inbounds i32, ir<%gep.b>, ir<1>
; CHECK-NEXT: WIDEN store vp<[[VP4]]>, ir<%l>
; CHECK-NEXT: EMIT ir<%iv.next> = add nuw nsw ir<%iv>, ir<1>
diff --git a/llvm/test/Transforms/LoopVectorize/VPlan/vplan-sink-scalars-and-merge-vf1.ll b/llvm/test/Transforms/LoopVectorize/VPlan/vplan-sink-scalars-and-merge-vf1.ll
index 1bdf23d5de144..d400c09fd9fec 100644
--- a/llvm/test/Transforms/LoopVectorize/VPlan/vplan-sink-scalars-and-merge-vf1.ll
+++ b/llvm/test/Transforms/LoopVectorize/VPlan/vplan-sink-scalars-and-merge-vf1.ll
@@ -25,7 +25,7 @@ define void @sink_with_sideeffects(i1 %c, ptr %ptr) {
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = SCALAR-STEPS vp<[[VP4]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%tmp2> = getelementptr ir<%ptr>, vp<[[VP5]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%tmp2> = getelementptr i8, ir<%ptr>, vp<[[VP5]]>
; CHECK-NEXT: CLONE ir<%tmp3> = load ir<%tmp2>
; CHECK-NEXT: CLONE store ir<0>, ir<%tmp2>
; CHECK-NEXT: Successor(s): pred.store
diff --git a/llvm/test/Transforms/LoopVectorize/VPlan/vplan-sink-scalars-and-merge.ll b/llvm/test/Transforms/LoopVectorize/VPlan/vplan-sink-scalars-and-merge.ll
index bd9da43107f38..39fa06edb894d 100644
--- a/llvm/test/Transforms/LoopVectorize/VPlan/vplan-sink-scalars-and-merge.ll
+++ b/llvm/test/Transforms/LoopVectorize/VPlan/vplan-sink-scalars-and-merge.ll
@@ -1247,7 +1247,7 @@ define void @sinking_requires_duplication(ptr %addr) {
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = SCALAR-STEPS vp<[[VP3]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%gep> = getelementptr ir<%addr>, vp<[[VP4]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr float, ir<%addr>, vp<[[VP4]]>
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = vector-pointer float, ir<%gep>, ir<1>
; CHECK-NEXT: WIDEN ir<%0> = load vp<[[VP5]]>
; CHECK-NEXT: WIDEN ir<%pred> = fcmp une ir<%0>, ir<0.000000e+00>
@@ -1434,7 +1434,7 @@ define void @ptr_induction_remove_dead_recipe(ptr %start, ptr %end) {
; CHECK-NEXT: vp<[[VP6:%[0-9]+]]> = DERIVED-IV ir<0> + vp<[[VP5]]> * ir<-1>
; CHECK-NEXT: vp<[[VP7:%[0-9]+]]> = SCALAR-STEPS vp<[[VP6]]>, ir<-1>, vp<[[VP0]]>
; CHECK-NEXT: EMIT vp<%next.gep> = ptradd ir<%start>, vp<[[VP7]]>
-; CHECK-NEXT: CLONE ir<%ptr.iv.next> = getelementptr inbounds vp<%next.gep>, ir<-1>
+; CHECK-NEXT: EMIT-SCALAR ir<%ptr.iv.next> = getelementptr inbounds i8, vp<%next.gep>, ir<-1>
; CHECK-NEXT: vp<[[VP8:%[0-9]+]]> = vector-end-pointer inbounds i8, ir<%ptr.iv.next>, vp<[[VP0]]>
; CHECK-NEXT: WIDEN ir<%l> = load vp<[[VP8]]>
; CHECK-NEXT: EMIT vp<[[VP9:%[0-9]+]]> = reverse ir<%l>
diff --git a/llvm/test/Transforms/LoopVectorize/VPlan/vplan-widen-struct-return.ll b/llvm/test/Transforms/LoopVectorize/VPlan/vplan-widen-struct-return.ll
index e35f1fe69e22a..646130480ee05 100644
--- a/llvm/test/Transforms/LoopVectorize/VPlan/vplan-widen-struct-return.ll
+++ b/llvm/test/Transforms/LoopVectorize/VPlan/vplan-widen-struct-return.ll
@@ -20,16 +20,16 @@ define void @struct_return_f32_widen(ptr noalias %in, ptr noalias writeonly %out
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = SCALAR-STEPS vp<[[VP3]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%arrayidx> = getelementptr inbounds ir<%in>, vp<[[VP4]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%arrayidx> = getelementptr inbounds float, ir<%in>, vp<[[VP4]]>
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = vector-pointer inbounds float, ir<%arrayidx>
; CHECK-NEXT: WIDEN ir<%in_val> = load vp<[[VP5]]>
; CHECK-NEXT: WIDEN-CALL ir<%call> = call @foo(ir<%in_val>) (using library function: fixed_vec_foo)
; CHECK-NEXT: WIDEN ir<%extract_a> = extractvalue ir<%call>, ir<0>
; CHECK-NEXT: WIDEN ir<%extract_b> = extractvalue ir<%call>, ir<1>
-; CHECK-NEXT: CLONE ir<%arrayidx2> = getelementptr inbounds ir<%out_a>, vp<[[VP4]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%arrayidx2> = getelementptr inbounds float, ir<%out_a>, vp<[[VP4]]>
; CHECK-NEXT: vp<[[VP6:%[0-9]+]]> = vector-pointer inbounds float, ir<%arrayidx2>
; CHECK-NEXT: WIDEN store vp<[[VP6]]>, ir<%extract_a>
-; CHECK-NEXT: CLONE ir<%arrayidx4> = getelementptr inbounds ir<%out_b>, vp<[[VP4]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%arrayidx4> = getelementptr inbounds float, ir<%out_b>, vp<[[VP4]]>
; CHECK-NEXT: vp<[[VP7:%[0-9]+]]> = vector-pointer inbounds float, ir<%arrayidx4>
; CHECK-NEXT: WIDEN store vp<[[VP7]]>, ir<%extract_b>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<[[VP3]]>, vp<[[VP1]]>
@@ -107,16 +107,16 @@ define void @struct_return_f32_replicate(ptr noalias %in, ptr noalias writeonly
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = SCALAR-STEPS vp<[[VP3]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%arrayidx> = getelementptr inbounds ir<%in>, vp<[[VP4]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%arrayidx> = getelementptr inbounds float, ir<%in>, vp<[[VP4]]>
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = vector-pointer inbounds float, ir<%arrayidx>
; CHECK-NEXT: WIDEN ir<%in_val> = load vp<[[VP5]]>
; CHECK-NEXT: REPLICATE ir<%call> = call @foo(ir<%in_val>)
; CHECK-NEXT: WIDEN ir<%extract_a> = extractvalue ir<%call>, ir<0>
; CHECK-NEXT: WIDEN ir<%extract_b> = extractvalue ir<%call>, ir<1>
-; CHECK-NEXT: CLONE ir<%arrayidx2> = getelementptr inbounds ir<%out_a>, vp<[[VP4]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%arrayidx2> = getelementptr inbounds float, ir<%out_a>, vp<[[VP4]]>
; CHECK-NEXT: vp<[[VP6:%[0-9]+]]> = vector-pointer inbounds float, ir<%arrayidx2>
; CHECK-NEXT: WIDEN store vp<[[VP6]]>, ir<%extract_a>
-; CHECK-NEXT: CLONE ir<%arrayidx4> = getelementptr inbounds ir<%out_b>, vp<[[VP4]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%arrayidx4> = getelementptr inbounds float, ir<%out_b>, vp<[[VP4]]>
; CHECK-NEXT: vp<[[VP7:%[0-9]+]]> = vector-pointer inbounds float, ir<%arrayidx4>
; CHECK-NEXT: WIDEN store vp<[[VP7]]>, ir<%extract_b>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<[[VP3]]>, vp<[[VP1]]>
diff --git a/llvm/test/Transforms/LoopVectorize/VPlan/widen-canonical-iv-register-pressure.ll b/llvm/test/Transforms/LoopVectorize/VPlan/widen-canonical-iv-register-pressure.ll
index a78d72131c957..b6a8e27e92101 100644
--- a/llvm/test/Transforms/LoopVectorize/VPlan/widen-canonical-iv-register-pressure.ll
+++ b/llvm/test/Transforms/LoopVectorize/VPlan/widen-canonical-iv-register-pressure.ll
@@ -33,8 +33,8 @@ define i32 @two_reductions(i64 %N, ptr %a, ptr %b) {
; UF1-NEXT: WIDEN-REDUCTION-PHI ir<%sum.b> = phi (add) vp<[[VP3]]>, ir<%sum.b.next>
; UF1-NEXT: WIDEN-PHI vp<[[VP7:%[0-9]+]]> = phi [ vp<[[VP5]]>, vector.ph ], [ vp<%vec.ind.next>, vector.body ]
; UF1-NEXT: EMIT vp<[[VP8:%[0-9]+]]> = icmp ule vp<[[VP7]]>, vp<[[VP4]]>
-; UF1-NEXT: CLONE ir<%ga> = getelementptr inbounds ir<%a>, vp<%index>
-; UF1-NEXT: CLONE ir<%gb> = getelementptr inbounds ir<%b>, vp<%index>
+; UF1-NEXT: EMIT-SCALAR ir<%ga> = getelementptr inbounds i32, ir<%a>, vp<%index>
+; UF1-NEXT: EMIT-SCALAR ir<%gb> = getelementptr inbounds i32, ir<%b>, vp<%index>
; UF1-NEXT: WIDEN ir<%la> = load ir<%ga>, vp<[[VP8]]>
; UF1-NEXT: WIDEN ir<%lb> = load ir<%gb>, vp<[[VP8]]>
; UF1-NEXT: WIDEN ir<%sum.a.next> = add ir<%sum.a>, ir<%la>
@@ -89,8 +89,8 @@ define i32 @two_reductions(i64 %N, ptr %a, ptr %b) {
; UF4-NEXT: EMIT vp<[[VP14:%[0-9]+]]> = icmp ule vp<%vec.iv>.1, vp<[[VP4]]>
; UF4-NEXT: EMIT vp<[[VP15:%[0-9]+]]> = icmp ule vp<%vec.iv>.2, vp<[[VP4]]>
; UF4-NEXT: EMIT vp<[[VP16:%[0-9]+]]> = icmp ule vp<%vec.iv>.3, vp<[[VP4]]>
-; UF4-NEXT: CLONE ir<%ga> = getelementptr inbounds ir<%a>, vp<%index>
-; UF4-NEXT: CLONE ir<%gb> = getelementptr inbounds ir<%b>, vp<%index>
+; UF4-NEXT: EMIT-SCALAR ir<%ga> = getelementptr inbounds i32, ir<%a>, vp<%index>
+; UF4-NEXT: EMIT-SCALAR ir<%gb> = getelementptr inbounds i32, ir<%b>, vp<%index>
; UF4-NEXT: vp<[[VP17:%[0-9]+]]> = vector-pointer inbounds i32, ir<%ga>, ir<1>, ir<4>
; UF4-NEXT: vp<[[VP18:%[0-9]+]]> = vector-pointer inbounds i32, ir<%ga>, ir<1>, ir<8>
; UF4-NEXT: vp<[[VP19:%[0-9]+]]> = vector-pointer inbounds i32, ir<%ga>, ir<1>, ir<12>
diff --git a/llvm/test/Transforms/LoopVectorize/VPlan/widen_mem_idioms.ll b/llvm/test/Transforms/LoopVectorize/VPlan/widen_mem_idioms.ll
index 6c9bc6339c997..09c53b4289f6c 100644
--- a/llvm/test/Transforms/LoopVectorize/VPlan/widen_mem_idioms.ll
+++ b/llvm/test/Transforms/LoopVectorize/VPlan/widen_mem_idioms.ll
@@ -21,10 +21,10 @@ define void @simple_histogram(ptr noalias %buckets, ptr readonly %indices, i64 %
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION nuw nsw ir<0>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: EMIT ir<%gep.indices> = getelementptr inbounds ir<%indices>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.indices> = getelementptr inbounds i32, ir<%indices>, ir<%iv>
; CHECK-NEXT: EMIT-SCALAR ir<%l.idx> = load ir<%gep.indices>
; CHECK-NEXT: EMIT-SCALAR ir<%idxprom1> = zext ir<%l.idx> to i64
-; CHECK-NEXT: EMIT ir<%gep.bucket> = getelementptr inbounds ir<%buckets>, ir<%idxprom1>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.bucket> = getelementptr inbounds i32, ir<%buckets>, ir<%idxprom1>
; CHECK-NEXT: EMIT-SCALAR ir<%l.bucket> = load ir<%gep.bucket>
; CHECK-NEXT: EMIT ir<%inc> = add nsw ir<%l.bucket>, ir<1>
; CHECK-NEXT: WIDEN-HISTOGRAM buckets: ir<%gep.bucket>, inc: ir<1>
@@ -104,11 +104,11 @@ define void @reduc_store_inside_unrolled(ptr noalias %dst, ptr noalias readonly
; CHECK-NEXT: vector.body:
; CHECK-NEXT: ir<%iv> = WIDEN-INDUCTION nuw nsw ir<0>, ir<2>, vp<[[VP0]]>
; CHECK-NEXT: WIDEN-REDUCTION-PHI ir<%sum> = phi (add) ir<0>, ir<%sum.2>
-; CHECK-NEXT: EMIT ir<%gep.src> = getelementptr inbounds ir<%src>, ir<%iv>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.src> = getelementptr inbounds i32, ir<%src>, ir<%iv>
; CHECK-NEXT: EMIT-SCALAR ir<%0> = load ir<%gep.src>
; CHECK-NEXT: EMIT ir<%sum.1> = add nsw ir<%0>, ir<%sum>
; CHECK-NEXT: EMIT ir<%1> = or disjoint ir<%iv>, ir<1>
-; CHECK-NEXT: EMIT ir<%gep.src.1> = getelementptr inbounds ir<%src>, ir<%1>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep.src.1> = getelementptr inbounds i32, ir<%src>, ir<%1>
; CHECK-NEXT: EMIT-SCALAR ir<%2> = load ir<%gep.src.1>
; CHECK-NEXT: EMIT ir<%sum.2> = add nsw ir<%2>, ir<%sum.1>
; CHECK-NEXT: EMIT ir<%iv.next> = add nuw nsw ir<%iv>, ir<2>
diff --git a/llvm/test/Transforms/LoopVectorize/X86/CostModel/vpinstruction-cost.ll b/llvm/test/Transforms/LoopVectorize/X86/CostModel/vpinstruction-cost.ll
index 84cc4631202cd..eeae015636339 100644
--- a/llvm/test/Transforms/LoopVectorize/X86/CostModel/vpinstruction-cost.ll
+++ b/llvm/test/Transforms/LoopVectorize/X86/CostModel/vpinstruction-cost.ll
@@ -22,13 +22,13 @@ define void @wide_or_replaced_with_add_vpinstruction(ptr %src, ptr noalias %dst)
; CHECK: LV: Found an estimated cost of 0 for VF 1 For instruction: br i1 %exitcond, label %exit, label %loop.header
; CHECK: Cost of 1 for VF 2: ir<%iv> = WIDEN-INDUCTION nuw nsw ir<0>, ir<1>, vp<[[VP0:%[0-9]+]]>
; CHECK: Cost of 0 for VF 2: vp<[[VP4:%[0-9]+]]> = SCALAR-STEPS vp<[[VP3:%[0-9]+]]>, ir<1>, vp<[[VP0]]>
-; CHECK: Cost of 0 for VF 2: CLONE ir<%g.src> = getelementptr inbounds ir<%src>, vp<[[VP4]]>
+; CHECK: Cost of 0 for VF 2: EMIT-SCALAR ir<%g.src> = getelementptr inbounds i64, ir<%src>, vp<[[VP4]]>
; CHECK: Cost of 0 for VF 2: vp<[[VP5:%[0-9]+]]> = vector-pointer inbounds i64, ir<%g.src>, ir<1>
; CHECK: Cost of 1 for VF 2: WIDEN ir<%l> = load vp<[[VP5]]>
; CHECK: Cost of 1 for VF 2: WIDEN ir<%iv.4> = add ir<%iv>, ir<4>
; CHECK: Cost of 1 for VF 2: WIDEN ir<%c> = icmp ule ir<%l>, ir<128>
; CHECK: Cost of 1 for VF 2: EMIT ir<%or> = add ir<%iv.4>, ir<1>
-; CHECK: Cost of 0 for VF 2: CLONE ir<%g.dst> = getelementptr ir<%dst>, ir<%or>
+; CHECK: Cost of 0 for VF 2: EMIT-SCALAR ir<%g.dst> = getelementptr i64, ir<%dst>, ir<%or>
; CHECK: Cost of 0 for VF 2: vp<[[VP6:%[0-9]+]]> = vector-pointer i64, ir<%g.dst>, ir<1>
; CHECK: Cost of 1 for VF 2: WIDEN store vp<[[VP6]]>, ir<%iv.4>, ir<%c>
; CHECK: Cost of 0 for VF 2: EMIT vp<%index.next> = add nuw vp<[[VP3]]>, vp<[[VP1:%[0-9]+]]>
@@ -45,13 +45,13 @@ define void @wide_or_replaced_with_add_vpinstruction(ptr %src, ptr noalias %dst)
; CHECK: Cost of 0 for VF 2: EMIT branch-on-cond vp<%cmp.n>
; CHECK: Cost of 1 for VF 4: ir<%iv> = WIDEN-INDUCTION nuw nsw ir<0>, ir<1>, vp<[[VP0]]>
; CHECK: Cost of 0 for VF 4: vp<[[VP4]]> = SCALAR-STEPS vp<[[VP3]]>, ir<1>, vp<[[VP0]]>
-; CHECK: Cost of 0 for VF 4: CLONE ir<%g.src> = getelementptr inbounds ir<%src>, vp<[[VP4]]>
+; CHECK: Cost of 0 for VF 4: EMIT-SCALAR ir<%g.src> = getelementptr inbounds i64, ir<%src>, vp<[[VP4]]>
; CHECK: Cost of 0 for VF 4: vp<[[VP5]]> = vector-pointer inbounds i64, ir<%g.src>, ir<1>
; CHECK: Cost of 1 for VF 4: WIDEN ir<%l> = load vp<[[VP5]]>
; CHECK: Cost of 1 for VF 4: WIDEN ir<%iv.4> = add ir<%iv>, ir<4>
; CHECK: Cost of 1 for VF 4: WIDEN ir<%c> = icmp ule ir<%l>, ir<128>
; CHECK: Cost of 1 for VF 4: EMIT ir<%or> = add ir<%iv.4>, ir<1>
-; CHECK: Cost of 0 for VF 4: CLONE ir<%g.dst> = getelementptr ir<%dst>, ir<%or>
+; CHECK: Cost of 0 for VF 4: EMIT-SCALAR ir<%g.dst> = getelementptr i64, ir<%dst>, ir<%or>
; CHECK: Cost of 0 for VF 4: vp<[[VP6]]> = vector-pointer i64, ir<%g.dst>, ir<1>
; CHECK: Cost of 1 for VF 4: WIDEN store vp<[[VP6]]>, ir<%iv.4>, ir<%c>
; CHECK: Cost of 0 for VF 4: EMIT vp<%index.next> = add nuw vp<[[VP3]]>, vp<[[VP1]]>
@@ -107,11 +107,11 @@ define void @test_vpinstruction_freeze_cost(ptr %src, ptr noalias %dst) {
; CHECK: LV: Found an estimated cost of 1 for VF 1 For instruction: %ec = icmp eq i64 %iv.next, 32
; CHECK: LV: Found an estimated cost of 0 for VF 1 For instruction: br i1 %ec, label %exit, label %loop
; CHECK: Cost of 0 for VF 2: vp<[[VP4:%[0-9]+]]> = SCALAR-STEPS vp<[[VP3:%[0-9]+]]>, ir<1>, vp<[[VP0:%[0-9]+]]>
-; CHECK: Cost of 0 for VF 2: CLONE ir<%g.src> = getelementptr inbounds ir<%src>, vp<[[VP4]]>
+; CHECK: Cost of 0 for VF 2: EMIT-SCALAR ir<%g.src> = getelementptr inbounds i64, ir<%src>, vp<[[VP4]]>
; CHECK: Cost of 0 for VF 2: vp<[[VP5:%[0-9]+]]> = vector-pointer inbounds i64, ir<%g.src>, ir<1>
; CHECK: Cost of 1 for VF 2: WIDEN ir<%l> = load vp<[[VP5]]>
; CHECK: Cost of 0 for VF 2: WIDEN ir<%fr> = freeze ir<%l>
-; CHECK: Cost of 0 for VF 2: CLONE ir<%g.dst> = getelementptr inbounds ir<%dst>, vp<[[VP4]]>
+; CHECK: Cost of 0 for VF 2: EMIT-SCALAR ir<%g.dst> = getelementptr inbounds i64, ir<%dst>, vp<[[VP4]]>
; CHECK: Cost of 0 for VF 2: vp<[[VP6:%[0-9]+]]> = vector-pointer inbounds i64, ir<%g.dst>, ir<1>
; CHECK: Cost of 1 for VF 2: WIDEN store vp<[[VP6]]>, ir<%fr>
; CHECK: Cost of 0 for VF 2: EMIT vp<%index.next> = add nuw vp<[[VP3]]>, vp<[[VP1:%[0-9]+]]>
@@ -130,11 +130,11 @@ define void @test_vpinstruction_freeze_cost(ptr %src, ptr noalias %dst) {
; CHECK: Cost of 1 for VF 2: EMIT vp<%cmp.n> = icmp eq ir<32>, vp<[[VP2]]>
; CHECK: Cost of 0 for VF 2: EMIT branch-on-cond vp<%cmp.n>
; CHECK: Cost of 0 for VF 4: vp<[[VP4]]> = SCALAR-STEPS vp<[[VP3]]>, ir<1>, vp<[[VP0]]>
-; CHECK: Cost of 0 for VF 4: CLONE ir<%g.src> = getelementptr inbounds ir<%src>, vp<[[VP4]]>
+; CHECK: Cost of 0 for VF 4: EMIT-SCALAR ir<%g.src> = getelementptr inbounds i64, ir<%src>, vp<[[VP4]]>
; CHECK: Cost of 0 for VF 4: vp<[[VP5]]> = vector-pointer inbounds i64, ir<%g.src>, ir<1>
; CHECK: Cost of 1 for VF 4: WIDEN ir<%l> = load vp<[[VP5]]>
; CHECK: Cost of 0 for VF 4: WIDEN ir<%fr> = freeze ir<%l>
-; CHECK: Cost of 0 for VF 4: CLONE ir<%g.dst> = getelementptr inbounds ir<%dst>, vp<[[VP4]]>
+; CHECK: Cost of 0 for VF 4: EMIT-SCALAR ir<%g.dst> = getelementptr inbounds i64, ir<%dst>, vp<[[VP4]]>
; CHECK: Cost of 0 for VF 4: vp<[[VP6]]> = vector-pointer inbounds i64, ir<%g.dst>, ir<1>
; CHECK: Cost of 1 for VF 4: WIDEN store vp<[[VP6]]>, ir<%fr>
; CHECK: Cost of 0 for VF 4: EMIT vp<%index.next> = add nuw vp<[[VP3]]>, vp<[[VP1]]>
@@ -303,7 +303,7 @@ define void @test_vpinstruction_extractvalue_cost(ptr noalias %dst, {i64, i64} %
; CHECK: LV: Found an estimated cost of 1 for VF 1 For instruction: %ec = icmp eq i64 %iv.next, 1000
; CHECK: LV: Found an estimated cost of 0 for VF 1 For instruction: br i1 %ec, label %exit, label %loop
; CHECK: Cost of 0 for VF 2: vp<[[VP4:%[0-9]+]]> = SCALAR-STEPS vp<[[VP3:%[0-9]+]]>, ir<1>, vp<[[VP0:%[0-9]+]]>
-; CHECK: Cost of 0 for VF 2: CLONE ir<%g.dst> = getelementptr inbounds ir<%dst>, vp<[[VP4]]>
+; CHECK: Cost of 0 for VF 2: EMIT-SCALAR ir<%g.dst> = getelementptr inbounds i64, ir<%dst>, vp<[[VP4]]>
; CHECK: Cost of 0 for VF 2: vp<[[VP5:%[0-9]+]]> = vector-pointer inbounds i64, ir<%g.dst>, ir<1>
; CHECK: Cost of 1 for VF 2: WIDEN store vp<[[VP5]]>, ir<%add>
; CHECK: Cost of 0 for VF 2: EMIT vp<%index.next> = add nuw vp<[[VP3]]>, vp<[[VP1:%[0-9]+]]>
@@ -325,7 +325,7 @@ define void @test_vpinstruction_extractvalue_cost(ptr noalias %dst, {i64, i64} %
; CHECK: Cost of 1 for VF 2: EMIT vp<%cmp.n> = icmp eq ir<1000>, vp<[[VP2]]>
; CHECK: Cost of 0 for VF 2: EMIT branch-on-cond vp<%cmp.n>
; CHECK: Cost of 0 for VF 4: vp<[[VP4]]> = SCALAR-STEPS vp<[[VP3]]>, ir<1>, vp<[[VP0]]>
-; CHECK: Cost of 0 for VF 4: CLONE ir<%g.dst> = getelementptr inbounds ir<%dst>, vp<[[VP4]]>
+; CHECK: Cost of 0 for VF 4: EMIT-SCALAR ir<%g.dst> = getelementptr inbounds i64, ir<%dst>, vp<[[VP4]]>
; CHECK: Cost of 0 for VF 4: vp<[[VP5]]> = vector-pointer inbounds i64, ir<%g.dst>, ir<1>
; CHECK: Cost of 1 for VF 4: WIDEN store vp<[[VP5]]>, ir<%add>
; CHECK: Cost of 0 for VF 4: EMIT vp<%index.next> = add nuw vp<[[VP3]]>, vp<[[VP1]]>
diff --git a/llvm/test/Transforms/LoopVectorize/X86/reduction-small-size.ll b/llvm/test/Transforms/LoopVectorize/X86/reduction-small-size.ll
index c51b7ff07e19e..b8f1fef6ea3cb 100644
--- a/llvm/test/Transforms/LoopVectorize/X86/reduction-small-size.ll
+++ b/llvm/test/Transforms/LoopVectorize/X86/reduction-small-size.ll
@@ -30,11 +30,11 @@ target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
; CHECK: LV: Found an estimated cost of {{[0-9]+}} for VF 1 For instruction: br
; CHECK: Cost of 1 for VF 2: WIDEN-REDUCTION-PHI ir<%sum.013> = phi (add) vp<{{.+}}>, vp<[[EXT:%.+]]>
; CHECK: Cost of 0 for VF 2: vp<[[STEPS:%.+]]> = SCALAR-STEPS vp<[[CAN_IV:%.+]]>, ir<1>
-; CHECK: Cost of 0 for VF 2: CLONE ir<%arrayidx> = getelementptr inbounds ir<%a>, vp<[[STEPS]]>
+; CHECK: Cost of 0 for VF 2: EMIT-SCALAR ir<%arrayidx> = getelementptr inbounds i8, ir<%a>, vp<[[STEPS]]>
; CHECK: Cost of 0 for VF 2: vp<[[VECP1:%.+]]> = vector-pointer inbounds i8, ir<%arrayidx>
; CHECK: Cost of 1 for VF 2: WIDEN ir<%0> = load vp<[[VECP1]]>
; CHECK: Cost of 0 for VF 2: WIDEN-CAST ir<%conv> = zext ir<%0> to i32
-; CHECK: Cost of 0 for VF 2: CLONE ir<%arrayidx2> = getelementptr inbounds ir<%b>, vp<[[STEPS]]>
+; CHECK: Cost of 0 for VF 2: EMIT-SCALAR ir<%arrayidx2> = getelementptr inbounds i8, ir<%b>, vp<[[STEPS]]>
; CHECK: Cost of 0 for VF 2: vp<[[VECP2:%.+]]> = vector-pointer inbounds i8, ir<%arrayidx2>
; CHECK: Cost of 1 for VF 2: WIDEN ir<%1> = load vp<[[VECP2]]>
; CHECK: Cost of 0 for VF 2: WIDEN-CAST ir<%conv3> = zext ir<%1> to i32
diff --git a/llvm/test/Transforms/LoopVectorize/iv-select-cmp-decreasing.ll b/llvm/test/Transforms/LoopVectorize/iv-select-cmp-decreasing.ll
index 83d5615e500c9..95d8517f10507 100644
--- a/llvm/test/Transforms/LoopVectorize/iv-select-cmp-decreasing.ll
+++ b/llvm/test/Transforms/LoopVectorize/iv-select-cmp-decreasing.ll
@@ -203,120 +203,105 @@ define i16 @select_decreasing_induction_icmp_table_i16(i16 noundef %val) {
; IC4VF4-NEXT: [[TMP3:%.*]] = phi <4 x i16> [ poison, %[[VECTOR_BODY]] ], [ [[TMP2]], %[[PRED_LOAD_IF]] ]
; IC4VF4-NEXT: br i1 true, label %[[PRED_LOAD_IF15:.*]], label %[[PRED_LOAD_CONTINUE16:.*]]
; IC4VF4: [[PRED_LOAD_IF15]]:
-; IC4VF4-NEXT: [[TMP12:%.*]] = getelementptr inbounds [13 x i16], ptr @table, i16 0, i16 11
-; IC4VF4-NEXT: [[TMP13:%.*]] = load i16, ptr [[TMP12]], align 1
+; IC4VF4-NEXT: [[TMP13:%.*]] = load i16, ptr getelementptr inbounds ([13 x i16], ptr @table, i16 0, i16 11), align 1
; IC4VF4-NEXT: [[TMP8:%.*]] = insertelement <4 x i16> [[TMP3]], i16 [[TMP13]], i64 1
; IC4VF4-NEXT: br label %[[PRED_LOAD_CONTINUE16]]
; IC4VF4: [[PRED_LOAD_CONTINUE16]]:
; IC4VF4-NEXT: [[TMP9:%.*]] = phi <4 x i16> [ [[TMP3]], %[[PRED_LOAD_CONTINUE]] ], [ [[TMP8]], %[[PRED_LOAD_IF15]] ]
; IC4VF4-NEXT: br i1 true, label %[[PRED_LOAD_IF17:.*]], label %[[PRED_LOAD_CONTINUE18:.*]]
; IC4VF4: [[PRED_LOAD_IF17]]:
-; IC4VF4-NEXT: [[TMP18:%.*]] = getelementptr inbounds [13 x i16], ptr @table, i16 0, i16 10
-; IC4VF4-NEXT: [[TMP19:%.*]] = load i16, ptr [[TMP18]], align 1
+; IC4VF4-NEXT: [[TMP19:%.*]] = load i16, ptr getelementptr inbounds ([13 x i16], ptr @table, i16 0, i16 10), align 1
; IC4VF4-NEXT: [[TMP10:%.*]] = insertelement <4 x i16> [[TMP9]], i16 [[TMP19]], i64 2
; IC4VF4-NEXT: br label %[[PRED_LOAD_CONTINUE18]]
; IC4VF4: [[PRED_LOAD_CONTINUE18]]:
; IC4VF4-NEXT: [[TMP11:%.*]] = phi <4 x i16> [ [[TMP9]], %[[PRED_LOAD_CONTINUE16]] ], [ [[TMP10]], %[[PRED_LOAD_IF17]] ]
; IC4VF4-NEXT: br i1 true, label %[[PRED_LOAD_IF19:.*]], label %[[PRED_LOAD_CONTINUE20:.*]]
; IC4VF4: [[PRED_LOAD_IF19]]:
-; IC4VF4-NEXT: [[TMP24:%.*]] = getelementptr inbounds [13 x i16], ptr @table, i16 0, i16 9
-; IC4VF4-NEXT: [[TMP25:%.*]] = load i16, ptr [[TMP24]], align 1
+; IC4VF4-NEXT: [[TMP25:%.*]] = load i16, ptr getelementptr inbounds ([13 x i16], ptr @table, i16 0, i16 9), align 1
; IC4VF4-NEXT: [[TMP14:%.*]] = insertelement <4 x i16> [[TMP11]], i16 [[TMP25]], i64 3
; IC4VF4-NEXT: br label %[[PRED_LOAD_CONTINUE20]]
; IC4VF4: [[PRED_LOAD_CONTINUE20]]:
; IC4VF4-NEXT: [[TMP27:%.*]] = phi <4 x i16> [ [[TMP11]], %[[PRED_LOAD_CONTINUE18]] ], [ [[TMP14]], %[[PRED_LOAD_IF19]] ]
; IC4VF4-NEXT: br i1 true, label %[[PRED_LOAD_IF21:.*]], label %[[PRED_LOAD_CONTINUE22:.*]]
; IC4VF4: [[PRED_LOAD_IF21]]:
-; IC4VF4-NEXT: [[TMP30:%.*]] = getelementptr inbounds [13 x i16], ptr @table, i16 0, i16 8
-; IC4VF4-NEXT: [[TMP31:%.*]] = load i16, ptr [[TMP30]], align 1
+; IC4VF4-NEXT: [[TMP31:%.*]] = load i16, ptr getelementptr inbounds ([13 x i16], ptr @table, i16 0, i16 8), align 1
; IC4VF4-NEXT: [[TMP20:%.*]] = insertelement <4 x i16> poison, i16 [[TMP31]], i64 0
; IC4VF4-NEXT: br label %[[PRED_LOAD_CONTINUE22]]
; IC4VF4: [[PRED_LOAD_CONTINUE22]]:
; IC4VF4-NEXT: [[TMP21:%.*]] = phi <4 x i16> [ poison, %[[PRED_LOAD_CONTINUE20]] ], [ [[TMP20]], %[[PRED_LOAD_IF21]] ]
; IC4VF4-NEXT: br i1 true, label %[[PRED_LOAD_IF23:.*]], label %[[PRED_LOAD_CONTINUE24:.*]]
; IC4VF4: [[PRED_LOAD_IF23]]:
-; IC4VF4-NEXT: [[TMP36:%.*]] = getelementptr inbounds [13 x i16], ptr @table, i16 0, i16 7
-; IC4VF4-NEXT: [[TMP37:%.*]] = load i16, ptr [[TMP36]], align 1
+; IC4VF4-NEXT: [[TMP37:%.*]] = load i16, ptr getelementptr inbounds ([13 x i16], ptr @table, i16 0, i16 7), align 1
; IC4VF4-NEXT: [[TMP22:%.*]] = insertelement <4 x i16> [[TMP21]], i16 [[TMP37]], i64 1
; IC4VF4-NEXT: br label %[[PRED_LOAD_CONTINUE24]]
; IC4VF4: [[PRED_LOAD_CONTINUE24]]:
; IC4VF4-NEXT: [[TMP23:%.*]] = phi <4 x i16> [ [[TMP21]], %[[PRED_LOAD_CONTINUE22]] ], [ [[TMP22]], %[[PRED_LOAD_IF23]] ]
; IC4VF4-NEXT: br i1 true, label %[[PRED_LOAD_IF25:.*]], label %[[PRED_LOAD_CONTINUE26:.*]]
; IC4VF4: [[PRED_LOAD_IF25]]:
-; IC4VF4-NEXT: [[TMP42:%.*]] = getelementptr inbounds [13 x i16], ptr @table, i16 0, i16 6
-; IC4VF4-NEXT: [[TMP43:%.*]] = load i16, ptr [[TMP42]], align 1
+; IC4VF4-NEXT: [[TMP43:%.*]] = load i16, ptr getelementptr inbounds ([13 x i16], ptr @table, i16 0, i16 6), align 1
; IC4VF4-NEXT: [[TMP26:%.*]] = insertelement <4 x i16> [[TMP23]], i16 [[TMP43]], i64 2
; IC4VF4-NEXT: br label %[[PRED_LOAD_CONTINUE26]]
; IC4VF4: [[PRED_LOAD_CONTINUE26]]:
; IC4VF4-NEXT: [[TMP28:%.*]] = phi <4 x i16> [ [[TMP23]], %[[PRED_LOAD_CONTINUE24]] ], [ [[TMP26]], %[[PRED_LOAD_IF25]] ]
; IC4VF4-NEXT: br i1 true, label %[[PRED_LOAD_IF27:.*]], label %[[PRED_LOAD_CONTINUE28:.*]]
; IC4VF4: [[PRED_LOAD_IF27]]:
-; IC4VF4-NEXT: [[TMP48:%.*]] = getelementptr inbounds [13 x i16], ptr @table, i16 0, i16 5
-; IC4VF4-NEXT: [[TMP49:%.*]] = load i16, ptr [[TMP48]], align 1
+; IC4VF4-NEXT: [[TMP49:%.*]] = load i16, ptr getelementptr inbounds ([13 x i16], ptr @table, i16 0, i16 5), align 1
; IC4VF4-NEXT: [[TMP32:%.*]] = insertelement <4 x i16> [[TMP28]], i16 [[TMP49]], i64 3
; IC4VF4-NEXT: br label %[[PRED_LOAD_CONTINUE28]]
; IC4VF4: [[PRED_LOAD_CONTINUE28]]:
; IC4VF4-NEXT: [[TMP51:%.*]] = phi <4 x i16> [ [[TMP28]], %[[PRED_LOAD_CONTINUE26]] ], [ [[TMP32]], %[[PRED_LOAD_IF27]] ]
; IC4VF4-NEXT: br i1 true, label %[[PRED_LOAD_IF29:.*]], label %[[PRED_LOAD_CONTINUE30:.*]]
; IC4VF4: [[PRED_LOAD_IF29]]:
-; IC4VF4-NEXT: [[TMP54:%.*]] = getelementptr inbounds [13 x i16], ptr @table, i16 0, i16 4
-; IC4VF4-NEXT: [[TMP55:%.*]] = load i16, ptr [[TMP54]], align 1
+; IC4VF4-NEXT: [[TMP55:%.*]] = load i16, ptr getelementptr inbounds ([13 x i16], ptr @table, i16 0, i16 4), align 1
; IC4VF4-NEXT: [[TMP34:%.*]] = insertelement <4 x i16> poison, i16 [[TMP55]], i64 0
; IC4VF4-NEXT: br label %[[PRED_LOAD_CONTINUE30]]
; IC4VF4: [[PRED_LOAD_CONTINUE30]]:
; IC4VF4-NEXT: [[TMP35:%.*]] = phi <4 x i16> [ poison, %[[PRED_LOAD_CONTINUE28]] ], [ [[TMP34]], %[[PRED_LOAD_IF29]] ]
; IC4VF4-NEXT: br i1 true, label %[[PRED_LOAD_IF31:.*]], label %[[PRED_LOAD_CONTINUE32:.*]]
; IC4VF4: [[PRED_LOAD_IF31]]:
-; IC4VF4-NEXT: [[TMP60:%.*]] = getelementptr inbounds [13 x i16], ptr @table, i16 0, i16 3
-; IC4VF4-NEXT: [[TMP61:%.*]] = load i16, ptr [[TMP60]], align 1
+; IC4VF4-NEXT: [[TMP61:%.*]] = load i16, ptr getelementptr inbounds ([13 x i16], ptr @table, i16 0, i16 3), align 1
; IC4VF4-NEXT: [[TMP38:%.*]] = insertelement <4 x i16> [[TMP35]], i16 [[TMP61]], i64 1
; IC4VF4-NEXT: br label %[[PRED_LOAD_CONTINUE32]]
; IC4VF4: [[PRED_LOAD_CONTINUE32]]:
; IC4VF4-NEXT: [[TMP39:%.*]] = phi <4 x i16> [ [[TMP35]], %[[PRED_LOAD_CONTINUE30]] ], [ [[TMP38]], %[[PRED_LOAD_IF31]] ]
; IC4VF4-NEXT: br i1 true, label %[[PRED_LOAD_IF33:.*]], label %[[PRED_LOAD_CONTINUE34:.*]]
; IC4VF4: [[PRED_LOAD_IF33]]:
-; IC4VF4-NEXT: [[TMP66:%.*]] = getelementptr inbounds [13 x i16], ptr @table, i16 0, i16 2
-; IC4VF4-NEXT: [[TMP67:%.*]] = load i16, ptr [[TMP66]], align 1
+; IC4VF4-NEXT: [[TMP67:%.*]] = load i16, ptr getelementptr inbounds ([13 x i16], ptr @table, i16 0, i16 2), align 1
; IC4VF4-NEXT: [[TMP44:%.*]] = insertelement <4 x i16> [[TMP39]], i16 [[TMP67]], i64 2
; IC4VF4-NEXT: br label %[[PRED_LOAD_CONTINUE34]]
; IC4VF4: [[PRED_LOAD_CONTINUE34]]:
; IC4VF4-NEXT: [[TMP45:%.*]] = phi <4 x i16> [ [[TMP39]], %[[PRED_LOAD_CONTINUE32]] ], [ [[TMP44]], %[[PRED_LOAD_IF33]] ]
; IC4VF4-NEXT: br i1 true, label %[[PRED_LOAD_IF35:.*]], label %[[PRED_LOAD_CONTINUE36:.*]]
; IC4VF4: [[PRED_LOAD_IF35]]:
-; IC4VF4-NEXT: [[TMP72:%.*]] = getelementptr inbounds [13 x i16], ptr @table, i16 0, i16 1
-; IC4VF4-NEXT: [[TMP73:%.*]] = load i16, ptr [[TMP72]], align 1
+; IC4VF4-NEXT: [[TMP73:%.*]] = load i16, ptr getelementptr inbounds ([13 x i16], ptr @table, i16 0, i16 1), align 1
; IC4VF4-NEXT: [[TMP46:%.*]] = insertelement <4 x i16> [[TMP45]], i16 [[TMP73]], i64 3
; IC4VF4-NEXT: br label %[[PRED_LOAD_CONTINUE36]]
; IC4VF4: [[PRED_LOAD_CONTINUE36]]:
; IC4VF4-NEXT: [[TMP75:%.*]] = phi <4 x i16> [ [[TMP45]], %[[PRED_LOAD_CONTINUE34]] ], [ [[TMP46]], %[[PRED_LOAD_IF35]] ]
; IC4VF4-NEXT: br i1 false, label %[[PRED_LOAD_IF37:.*]], label %[[PRED_LOAD_CONTINUE38:.*]]
; IC4VF4: [[PRED_LOAD_IF37]]:
-; IC4VF4-NEXT: [[TMP78:%.*]] = getelementptr inbounds [13 x i16], ptr @table, i16 0, i16 0
-; IC4VF4-NEXT: [[TMP79:%.*]] = load i16, ptr [[TMP78]], align 1
+; IC4VF4-NEXT: [[TMP79:%.*]] = load i16, ptr @table, align 1
; IC4VF4-NEXT: [[TMP50:%.*]] = insertelement <4 x i16> poison, i16 [[TMP79]], i64 0
; IC4VF4-NEXT: br label %[[PRED_LOAD_CONTINUE38]]
; IC4VF4: [[PRED_LOAD_CONTINUE38]]:
; IC4VF4-NEXT: [[TMP52:%.*]] = phi <4 x i16> [ poison, %[[PRED_LOAD_CONTINUE36]] ], [ [[TMP50]], %[[PRED_LOAD_IF37]] ]
; IC4VF4-NEXT: br i1 false, label %[[PRED_LOAD_IF39:.*]], label %[[PRED_LOAD_CONTINUE40:.*]]
; IC4VF4: [[PRED_LOAD_IF39]]:
-; IC4VF4-NEXT: [[TMP84:%.*]] = getelementptr inbounds [13 x i16], ptr @table, i16 0, i16 -1
-; IC4VF4-NEXT: [[TMP85:%.*]] = load i16, ptr [[TMP84]], align 1
+; IC4VF4-NEXT: [[TMP85:%.*]] = load i16, ptr getelementptr inbounds ([13 x i16], ptr @table, i16 0, i16 -1), align 1
; IC4VF4-NEXT: [[TMP56:%.*]] = insertelement <4 x i16> [[TMP52]], i16 [[TMP85]], i64 1
; IC4VF4-NEXT: br label %[[PRED_LOAD_CONTINUE40]]
; IC4VF4: [[PRED_LOAD_CONTINUE40]]:
; IC4VF4-NEXT: [[TMP57:%.*]] = phi <4 x i16> [ [[TMP52]], %[[PRED_LOAD_CONTINUE38]] ], [ [[TMP56]], %[[PRED_LOAD_IF39]] ]
; IC4VF4-NEXT: br i1 false, label %[[PRED_LOAD_IF41:.*]], label %[[PRED_LOAD_CONTINUE42:.*]]
; IC4VF4: [[PRED_LOAD_IF41]]:
-; IC4VF4-NEXT: [[TMP90:%.*]] = getelementptr inbounds [13 x i16], ptr @table, i16 0, i16 -2
-; IC4VF4-NEXT: [[TMP91:%.*]] = load i16, ptr [[TMP90]], align 1
+; IC4VF4-NEXT: [[TMP91:%.*]] = load i16, ptr getelementptr inbounds ([13 x i16], ptr @table, i16 0, i16 -2), align 1
; IC4VF4-NEXT: [[TMP58:%.*]] = insertelement <4 x i16> [[TMP57]], i16 [[TMP91]], i64 2
; IC4VF4-NEXT: br label %[[PRED_LOAD_CONTINUE42]]
; IC4VF4: [[PRED_LOAD_CONTINUE42]]:
; IC4VF4-NEXT: [[TMP59:%.*]] = phi <4 x i16> [ [[TMP57]], %[[PRED_LOAD_CONTINUE40]] ], [ [[TMP58]], %[[PRED_LOAD_IF41]] ]
; IC4VF4-NEXT: br i1 false, label %[[PRED_LOAD_IF43:.*]], label %[[PRED_LOAD_CONTINUE44:.*]]
; IC4VF4: [[PRED_LOAD_IF43]]:
-; IC4VF4-NEXT: [[TMP96:%.*]] = getelementptr inbounds [13 x i16], ptr @table, i16 0, i16 -3
-; IC4VF4-NEXT: [[TMP97:%.*]] = load i16, ptr [[TMP96]], align 1
+; IC4VF4-NEXT: [[TMP97:%.*]] = load i16, ptr getelementptr inbounds ([13 x i16], ptr @table, i16 0, i16 -3), align 1
; IC4VF4-NEXT: [[TMP62:%.*]] = insertelement <4 x i16> [[TMP59]], i16 [[TMP97]], i64 3
; IC4VF4-NEXT: br label %[[PRED_LOAD_CONTINUE44]]
; IC4VF4: [[PRED_LOAD_CONTINUE44]]:
@@ -468,120 +453,105 @@ define i16 @select_decreasing_induction_icmp_table_half(half noundef %val) {
; IC4VF4-NEXT: [[TMP3:%.*]] = phi <4 x half> [ poison, %[[VECTOR_BODY]] ], [ [[TMP2]], %[[PRED_LOAD_IF]] ]
; IC4VF4-NEXT: br i1 true, label %[[PRED_LOAD_IF15:.*]], label %[[PRED_LOAD_CONTINUE16:.*]]
; IC4VF4: [[PRED_LOAD_IF15]]:
-; IC4VF4-NEXT: [[TMP12:%.*]] = getelementptr inbounds [13 x i16], ptr @table, i16 0, i16 11
-; IC4VF4-NEXT: [[TMP13:%.*]] = load half, ptr [[TMP12]], align 1
+; IC4VF4-NEXT: [[TMP13:%.*]] = load half, ptr getelementptr inbounds ([13 x i16], ptr @table, i16 0, i16 11), align 1
; IC4VF4-NEXT: [[TMP8:%.*]] = insertelement <4 x half> [[TMP3]], half [[TMP13]], i64 1
; IC4VF4-NEXT: br label %[[PRED_LOAD_CONTINUE16]]
; IC4VF4: [[PRED_LOAD_CONTINUE16]]:
; IC4VF4-NEXT: [[TMP9:%.*]] = phi <4 x half> [ [[TMP3]], %[[PRED_LOAD_CONTINUE]] ], [ [[TMP8]], %[[PRED_LOAD_IF15]] ]
; IC4VF4-NEXT: br i1 true, label %[[PRED_LOAD_IF17:.*]], label %[[PRED_LOAD_CONTINUE18:.*]]
; IC4VF4: [[PRED_LOAD_IF17]]:
-; IC4VF4-NEXT: [[TMP18:%.*]] = getelementptr inbounds [13 x i16], ptr @table, i16 0, i16 10
-; IC4VF4-NEXT: [[TMP19:%.*]] = load half, ptr [[TMP18]], align 1
+; IC4VF4-NEXT: [[TMP19:%.*]] = load half, ptr getelementptr inbounds ([13 x i16], ptr @table, i16 0, i16 10), align 1
; IC4VF4-NEXT: [[TMP10:%.*]] = insertelement <4 x half> [[TMP9]], half [[TMP19]], i64 2
; IC4VF4-NEXT: br label %[[PRED_LOAD_CONTINUE18]]
; IC4VF4: [[PRED_LOAD_CONTINUE18]]:
; IC4VF4-NEXT: [[TMP11:%.*]] = phi <4 x half> [ [[TMP9]], %[[PRED_LOAD_CONTINUE16]] ], [ [[TMP10]], %[[PRED_LOAD_IF17]] ]
; IC4VF4-NEXT: br i1 true, label %[[PRED_LOAD_IF19:.*]], label %[[PRED_LOAD_CONTINUE20:.*]]
; IC4VF4: [[PRED_LOAD_IF19]]:
-; IC4VF4-NEXT: [[TMP24:%.*]] = getelementptr inbounds [13 x i16], ptr @table, i16 0, i16 9
-; IC4VF4-NEXT: [[TMP25:%.*]] = load half, ptr [[TMP24]], align 1
+; IC4VF4-NEXT: [[TMP25:%.*]] = load half, ptr getelementptr inbounds ([13 x i16], ptr @table, i16 0, i16 9), align 1
; IC4VF4-NEXT: [[TMP14:%.*]] = insertelement <4 x half> [[TMP11]], half [[TMP25]], i64 3
; IC4VF4-NEXT: br label %[[PRED_LOAD_CONTINUE20]]
; IC4VF4: [[PRED_LOAD_CONTINUE20]]:
; IC4VF4-NEXT: [[TMP27:%.*]] = phi <4 x half> [ [[TMP11]], %[[PRED_LOAD_CONTINUE18]] ], [ [[TMP14]], %[[PRED_LOAD_IF19]] ]
; IC4VF4-NEXT: br i1 true, label %[[PRED_LOAD_IF21:.*]], label %[[PRED_LOAD_CONTINUE22:.*]]
; IC4VF4: [[PRED_LOAD_IF21]]:
-; IC4VF4-NEXT: [[TMP30:%.*]] = getelementptr inbounds [13 x i16], ptr @table, i16 0, i16 8
-; IC4VF4-NEXT: [[TMP31:%.*]] = load half, ptr [[TMP30]], align 1
+; IC4VF4-NEXT: [[TMP31:%.*]] = load half, ptr getelementptr inbounds ([13 x i16], ptr @table, i16 0, i16 8), align 1
; IC4VF4-NEXT: [[TMP20:%.*]] = insertelement <4 x half> poison, half [[TMP31]], i64 0
; IC4VF4-NEXT: br label %[[PRED_LOAD_CONTINUE22]]
; IC4VF4: [[PRED_LOAD_CONTINUE22]]:
; IC4VF4-NEXT: [[TMP21:%.*]] = phi <4 x half> [ poison, %[[PRED_LOAD_CONTINUE20]] ], [ [[TMP20]], %[[PRED_LOAD_IF21]] ]
; IC4VF4-NEXT: br i1 true, label %[[PRED_LOAD_IF23:.*]], label %[[PRED_LOAD_CONTINUE24:.*]]
; IC4VF4: [[PRED_LOAD_IF23]]:
-; IC4VF4-NEXT: [[TMP36:%.*]] = getelementptr inbounds [13 x i16], ptr @table, i16 0, i16 7
-; IC4VF4-NEXT: [[TMP37:%.*]] = load half, ptr [[TMP36]], align 1
+; IC4VF4-NEXT: [[TMP37:%.*]] = load half, ptr getelementptr inbounds ([13 x i16], ptr @table, i16 0, i16 7), align 1
; IC4VF4-NEXT: [[TMP22:%.*]] = insertelement <4 x half> [[TMP21]], half [[TMP37]], i64 1
; IC4VF4-NEXT: br label %[[PRED_LOAD_CONTINUE24]]
; IC4VF4: [[PRED_LOAD_CONTINUE24]]:
; IC4VF4-NEXT: [[TMP23:%.*]] = phi <4 x half> [ [[TMP21]], %[[PRED_LOAD_CONTINUE22]] ], [ [[TMP22]], %[[PRED_LOAD_IF23]] ]
; IC4VF4-NEXT: br i1 true, label %[[PRED_LOAD_IF25:.*]], label %[[PRED_LOAD_CONTINUE26:.*]]
; IC4VF4: [[PRED_LOAD_IF25]]:
-; IC4VF4-NEXT: [[TMP42:%.*]] = getelementptr inbounds [13 x i16], ptr @table, i16 0, i16 6
-; IC4VF4-NEXT: [[TMP43:%.*]] = load half, ptr [[TMP42]], align 1
+; IC4VF4-NEXT: [[TMP43:%.*]] = load half, ptr getelementptr inbounds ([13 x i16], ptr @table, i16 0, i16 6), align 1
; IC4VF4-NEXT: [[TMP26:%.*]] = insertelement <4 x half> [[TMP23]], half [[TMP43]], i64 2
; IC4VF4-NEXT: br label %[[PRED_LOAD_CONTINUE26]]
; IC4VF4: [[PRED_LOAD_CONTINUE26]]:
; IC4VF4-NEXT: [[TMP28:%.*]] = phi <4 x half> [ [[TMP23]], %[[PRED_LOAD_CONTINUE24]] ], [ [[TMP26]], %[[PRED_LOAD_IF25]] ]
; IC4VF4-NEXT: br i1 true, label %[[PRED_LOAD_IF27:.*]], label %[[PRED_LOAD_CONTINUE28:.*]]
; IC4VF4: [[PRED_LOAD_IF27]]:
-; IC4VF4-NEXT: [[TMP48:%.*]] = getelementptr inbounds [13 x i16], ptr @table, i16 0, i16 5
-; IC4VF4-NEXT: [[TMP49:%.*]] = load half, ptr [[TMP48]], align 1
+; IC4VF4-NEXT: [[TMP49:%.*]] = load half, ptr getelementptr inbounds ([13 x i16], ptr @table, i16 0, i16 5), align 1
; IC4VF4-NEXT: [[TMP32:%.*]] = insertelement <4 x half> [[TMP28]], half [[TMP49]], i64 3
; IC4VF4-NEXT: br label %[[PRED_LOAD_CONTINUE28]]
; IC4VF4: [[PRED_LOAD_CONTINUE28]]:
; IC4VF4-NEXT: [[TMP51:%.*]] = phi <4 x half> [ [[TMP28]], %[[PRED_LOAD_CONTINUE26]] ], [ [[TMP32]], %[[PRED_LOAD_IF27]] ]
; IC4VF4-NEXT: br i1 true, label %[[PRED_LOAD_IF29:.*]], label %[[PRED_LOAD_CONTINUE30:.*]]
; IC4VF4: [[PRED_LOAD_IF29]]:
-; IC4VF4-NEXT: [[TMP54:%.*]] = getelementptr inbounds [13 x i16], ptr @table, i16 0, i16 4
-; IC4VF4-NEXT: [[TMP55:%.*]] = load half, ptr [[TMP54]], align 1
+; IC4VF4-NEXT: [[TMP55:%.*]] = load half, ptr getelementptr inbounds ([13 x i16], ptr @table, i16 0, i16 4), align 1
; IC4VF4-NEXT: [[TMP34:%.*]] = insertelement <4 x half> poison, half [[TMP55]], i64 0
; IC4VF4-NEXT: br label %[[PRED_LOAD_CONTINUE30]]
; IC4VF4: [[PRED_LOAD_CONTINUE30]]:
; IC4VF4-NEXT: [[TMP35:%.*]] = phi <4 x half> [ poison, %[[PRED_LOAD_CONTINUE28]] ], [ [[TMP34]], %[[PRED_LOAD_IF29]] ]
; IC4VF4-NEXT: br i1 true, label %[[PRED_LOAD_IF31:.*]], label %[[PRED_LOAD_CONTINUE32:.*]]
; IC4VF4: [[PRED_LOAD_IF31]]:
-; IC4VF4-NEXT: [[TMP60:%.*]] = getelementptr inbounds [13 x i16], ptr @table, i16 0, i16 3
-; IC4VF4-NEXT: [[TMP61:%.*]] = load half, ptr [[TMP60]], align 1
+; IC4VF4-NEXT: [[TMP61:%.*]] = load half, ptr getelementptr inbounds ([13 x i16], ptr @table, i16 0, i16 3), align 1
; IC4VF4-NEXT: [[TMP38:%.*]] = insertelement <4 x half> [[TMP35]], half [[TMP61]], i64 1
; IC4VF4-NEXT: br label %[[PRED_LOAD_CONTINUE32]]
; IC4VF4: [[PRED_LOAD_CONTINUE32]]:
; IC4VF4-NEXT: [[TMP39:%.*]] = phi <4 x half> [ [[TMP35]], %[[PRED_LOAD_CONTINUE30]] ], [ [[TMP38]], %[[PRED_LOAD_IF31]] ]
; IC4VF4-NEXT: br i1 true, label %[[PRED_LOAD_IF33:.*]], label %[[PRED_LOAD_CONTINUE34:.*]]
; IC4VF4: [[PRED_LOAD_IF33]]:
-; IC4VF4-NEXT: [[TMP66:%.*]] = getelementptr inbounds [13 x i16], ptr @table, i16 0, i16 2
-; IC4VF4-NEXT: [[TMP67:%.*]] = load half, ptr [[TMP66]], align 1
+; IC4VF4-NEXT: [[TMP67:%.*]] = load half, ptr getelementptr inbounds ([13 x i16], ptr @table, i16 0, i16 2), align 1
; IC4VF4-NEXT: [[TMP44:%.*]] = insertelement <4 x half> [[TMP39]], half [[TMP67]], i64 2
; IC4VF4-NEXT: br label %[[PRED_LOAD_CONTINUE34]]
; IC4VF4: [[PRED_LOAD_CONTINUE34]]:
; IC4VF4-NEXT: [[TMP45:%.*]] = phi <4 x half> [ [[TMP39]], %[[PRED_LOAD_CONTINUE32]] ], [ [[TMP44]], %[[PRED_LOAD_IF33]] ]
; IC4VF4-NEXT: br i1 true, label %[[PRED_LOAD_IF35:.*]], label %[[PRED_LOAD_CONTINUE36:.*]]
; IC4VF4: [[PRED_LOAD_IF35]]:
-; IC4VF4-NEXT: [[TMP72:%.*]] = getelementptr inbounds [13 x i16], ptr @table, i16 0, i16 1
-; IC4VF4-NEXT: [[TMP73:%.*]] = load half, ptr [[TMP72]], align 1
+; IC4VF4-NEXT: [[TMP73:%.*]] = load half, ptr getelementptr inbounds ([13 x i16], ptr @table, i16 0, i16 1), align 1
; IC4VF4-NEXT: [[TMP46:%.*]] = insertelement <4 x half> [[TMP45]], half [[TMP73]], i64 3
; IC4VF4-NEXT: br label %[[PRED_LOAD_CONTINUE36]]
; IC4VF4: [[PRED_LOAD_CONTINUE36]]:
; IC4VF4-NEXT: [[TMP75:%.*]] = phi <4 x half> [ [[TMP45]], %[[PRED_LOAD_CONTINUE34]] ], [ [[TMP46]], %[[PRED_LOAD_IF35]] ]
; IC4VF4-NEXT: br i1 false, label %[[PRED_LOAD_IF37:.*]], label %[[PRED_LOAD_CONTINUE38:.*]]
; IC4VF4: [[PRED_LOAD_IF37]]:
-; IC4VF4-NEXT: [[TMP78:%.*]] = getelementptr inbounds [13 x i16], ptr @table, i16 0, i16 0
-; IC4VF4-NEXT: [[TMP79:%.*]] = load half, ptr [[TMP78]], align 1
+; IC4VF4-NEXT: [[TMP79:%.*]] = load half, ptr @table, align 1
; IC4VF4-NEXT: [[TMP50:%.*]] = insertelement <4 x half> poison, half [[TMP79]], i64 0
; IC4VF4-NEXT: br label %[[PRED_LOAD_CONTINUE38]]
; IC4VF4: [[PRED_LOAD_CONTINUE38]]:
; IC4VF4-NEXT: [[TMP52:%.*]] = phi <4 x half> [ poison, %[[PRED_LOAD_CONTINUE36]] ], [ [[TMP50]], %[[PRED_LOAD_IF37]] ]
; IC4VF4-NEXT: br i1 false, label %[[PRED_LOAD_IF39:.*]], label %[[PRED_LOAD_CONTINUE40:.*]]
; IC4VF4: [[PRED_LOAD_IF39]]:
-; IC4VF4-NEXT: [[TMP84:%.*]] = getelementptr inbounds [13 x i16], ptr @table, i16 0, i16 -1
-; IC4VF4-NEXT: [[TMP85:%.*]] = load half, ptr [[TMP84]], align 1
+; IC4VF4-NEXT: [[TMP85:%.*]] = load half, ptr getelementptr inbounds ([13 x i16], ptr @table, i16 0, i16 -1), align 1
; IC4VF4-NEXT: [[TMP56:%.*]] = insertelement <4 x half> [[TMP52]], half [[TMP85]], i64 1
; IC4VF4-NEXT: br label %[[PRED_LOAD_CONTINUE40]]
; IC4VF4: [[PRED_LOAD_CONTINUE40]]:
; IC4VF4-NEXT: [[TMP57:%.*]] = phi <4 x half> [ [[TMP52]], %[[PRED_LOAD_CONTINUE38]] ], [ [[TMP56]], %[[PRED_LOAD_IF39]] ]
; IC4VF4-NEXT: br i1 false, label %[[PRED_LOAD_IF41:.*]], label %[[PRED_LOAD_CONTINUE42:.*]]
; IC4VF4: [[PRED_LOAD_IF41]]:
-; IC4VF4-NEXT: [[TMP90:%.*]] = getelementptr inbounds [13 x i16], ptr @table, i16 0, i16 -2
-; IC4VF4-NEXT: [[TMP91:%.*]] = load half, ptr [[TMP90]], align 1
+; IC4VF4-NEXT: [[TMP91:%.*]] = load half, ptr getelementptr inbounds ([13 x i16], ptr @table, i16 0, i16 -2), align 1
; IC4VF4-NEXT: [[TMP58:%.*]] = insertelement <4 x half> [[TMP57]], half [[TMP91]], i64 2
; IC4VF4-NEXT: br label %[[PRED_LOAD_CONTINUE42]]
; IC4VF4: [[PRED_LOAD_CONTINUE42]]:
; IC4VF4-NEXT: [[TMP59:%.*]] = phi <4 x half> [ [[TMP57]], %[[PRED_LOAD_CONTINUE40]] ], [ [[TMP58]], %[[PRED_LOAD_IF41]] ]
; IC4VF4-NEXT: br i1 false, label %[[PRED_LOAD_IF43:.*]], label %[[PRED_LOAD_CONTINUE44:.*]]
; IC4VF4: [[PRED_LOAD_IF43]]:
-; IC4VF4-NEXT: [[TMP96:%.*]] = getelementptr inbounds [13 x i16], ptr @table, i16 0, i16 -3
-; IC4VF4-NEXT: [[TMP97:%.*]] = load half, ptr [[TMP96]], align 1
+; IC4VF4-NEXT: [[TMP97:%.*]] = load half, ptr getelementptr inbounds ([13 x i16], ptr @table, i16 0, i16 -3), align 1
; IC4VF4-NEXT: [[TMP62:%.*]] = insertelement <4 x half> [[TMP59]], half [[TMP97]], i64 3
; IC4VF4-NEXT: br label %[[PRED_LOAD_CONTINUE44]]
; IC4VF4: [[PRED_LOAD_CONTINUE44]]:
diff --git a/llvm/test/Transforms/LoopVectorize/metadata.ll b/llvm/test/Transforms/LoopVectorize/metadata.ll
index 4cc50326cdb2d..ac0273682f859 100644
--- a/llvm/test/Transforms/LoopVectorize/metadata.ll
+++ b/llvm/test/Transforms/LoopVectorize/metadata.ll
@@ -401,7 +401,7 @@ define void @unknown_metadata(ptr nocapture %a, ptr noalias %b, i64 %size) {
; CHECK-NEXT: [[INDEX:%.*]] = phi i64 [ 0, %[[VECTOR_PH]] ], [ [[INDEX_NEXT:%.*]], %[[VECTOR_BODY]] ]
; CHECK-NEXT: [[VEC_IND:%.*]] = phi <2 x i64> [ <i64 0, i64 1>, %[[VECTOR_PH]] ], [ [[VEC_IND_NEXT:%.*]], %[[VECTOR_BODY]] ]
; CHECK-NEXT: [[VEC_IND1:%.*]] = phi <2 x i32> [ <i32 0, i32 1>, %[[VECTOR_PH]] ], [ [[VEC_IND_NEXT2:%.*]], %[[VECTOR_BODY]] ]
-; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds ptr, ptr [[A]], i64 [[INDEX]], !custom_md [[META2:![0-9]+]]
+; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds ptr, ptr [[A]], i64 [[INDEX]]
; CHECK-NEXT: [[WIDE_GEP:%.*]] = getelementptr inbounds i32, ptr [[B]], <2 x i64> [[VEC_IND]]
; CHECK-NEXT: [[TMP2:%.*]] = extractelement <2 x ptr> [[WIDE_GEP]], i64 0
; CHECK-NEXT: store <2 x i32> [[VEC_IND1]], ptr [[TMP2]], align 4
@@ -419,7 +419,7 @@ define void @unknown_metadata(ptr nocapture %a, ptr noalias %b, i64 %size) {
; CHECK-NEXT: br label %[[LOOP:.*]]
; CHECK: [[LOOP]]:
; CHECK-NEXT: [[IV:%.*]] = phi i64 [ [[BC_RESUME_VAL]], %[[SCALAR_PH]] ], [ [[IV_NEXT:%.*]], %[[LOOP]] ]
-; CHECK-NEXT: [[ARRAYIDX_1:%.*]] = getelementptr inbounds ptr, ptr [[A]], i64 [[IV]], !custom_md [[META2]]
+; CHECK-NEXT: [[ARRAYIDX_1:%.*]] = getelementptr inbounds ptr, ptr [[A]], i64 [[IV]], !custom_md [[META2:![0-9]+]]
; CHECK-NEXT: [[ARRAYIDX_2:%.*]] = getelementptr inbounds i32, ptr [[B]], i64 [[IV]], !custom_md [[META2]]
; CHECK-NEXT: [[T:%.*]] = trunc i64 [[IV]] to i32, !custom_md [[META3]]
; CHECK-NEXT: store i32 [[T]], ptr [[ARRAYIDX_2]], align 4, !custom_md [[META2]]
@@ -445,7 +445,7 @@ define void @unknown_metadata(ptr nocapture %a, ptr noalias %b, i64 %size) {
; INTERLEAVE-NEXT: [[VEC_IND1:%.*]] = phi <2 x i32> [ <i32 0, i32 1>, %[[VECTOR_PH]] ], [ [[VEC_IND_NEXT4:%.*]], %[[VECTOR_BODY]] ]
; INTERLEAVE-NEXT: [[STEP_ADD:%.*]] = add nuw <2 x i64> [[VEC_IND]], splat (i64 2)
; INTERLEAVE-NEXT: [[STEP_ADD2:%.*]] = add <2 x i32> [[VEC_IND1]], splat (i32 2)
-; INTERLEAVE-NEXT: [[TMP1:%.*]] = getelementptr inbounds ptr, ptr [[A]], i64 [[INDEX]], !custom_md [[META2:![0-9]+]]
+; INTERLEAVE-NEXT: [[TMP1:%.*]] = getelementptr inbounds ptr, ptr [[A]], i64 [[INDEX]]
; INTERLEAVE-NEXT: [[WIDE_GEP:%.*]] = getelementptr inbounds i32, ptr [[B]], <2 x i64> [[VEC_IND]]
; INTERLEAVE-NEXT: [[TMP2:%.*]] = extractelement <2 x ptr> [[WIDE_GEP]], i64 0
; INTERLEAVE-NEXT: [[WIDE_GEP3:%.*]] = getelementptr inbounds i32, ptr [[B]], <2 x i64> [[STEP_ADD]]
@@ -468,7 +468,7 @@ define void @unknown_metadata(ptr nocapture %a, ptr noalias %b, i64 %size) {
; INTERLEAVE-NEXT: br label %[[LOOP:.*]]
; INTERLEAVE: [[LOOP]]:
; INTERLEAVE-NEXT: [[IV:%.*]] = phi i64 [ [[BC_RESUME_VAL]], %[[SCALAR_PH]] ], [ [[IV_NEXT:%.*]], %[[LOOP]] ]
-; INTERLEAVE-NEXT: [[ARRAYIDX_1:%.*]] = getelementptr inbounds ptr, ptr [[A]], i64 [[IV]], !custom_md [[META2]]
+; INTERLEAVE-NEXT: [[ARRAYIDX_1:%.*]] = getelementptr inbounds ptr, ptr [[A]], i64 [[IV]], !custom_md [[META2:![0-9]+]]
; INTERLEAVE-NEXT: [[ARRAYIDX_2:%.*]] = getelementptr inbounds i32, ptr [[B]], i64 [[IV]], !custom_md [[META2]]
; INTERLEAVE-NEXT: [[T:%.*]] = trunc i64 [[IV]] to i32, !custom_md [[META3]]
; INTERLEAVE-NEXT: store i32 [[T]], ptr [[ARRAYIDX_2]], align 4, !custom_md [[META2]]
diff --git a/llvm/test/tools/UpdateTestChecks/update_analyze_test_checks/Inputs/vplan.ll.expected b/llvm/test/tools/UpdateTestChecks/update_analyze_test_checks/Inputs/vplan.ll.expected
index 846aa74340956..ebc7bed44b3e7 100644
--- a/llvm/test/tools/UpdateTestChecks/update_analyze_test_checks/Inputs/vplan.ll.expected
+++ b/llvm/test/tools/UpdateTestChecks/update_analyze_test_checks/Inputs/vplan.ll.expected
@@ -22,7 +22,7 @@ define void @simple(ptr %p, i64 %n) {
; CHECK-EMPTY:
; CHECK-NEXT: vector.body:
; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = SCALAR-STEPS vp<[[VP4]]>, ir<1>, vp<[[VP0]]>
-; CHECK-NEXT: CLONE ir<%gep> = getelementptr ir<%p>, vp<[[VP5]]>
+; CHECK-NEXT: EMIT-SCALAR ir<%gep> = getelementptr i32, ir<%p>, vp<[[VP5]]>
; CHECK-NEXT: vp<[[VP6:%[0-9]+]]> = vector-pointer i32, ir<%gep>, ir<1>
; CHECK-NEXT: WIDEN store vp<[[VP6]]>, ir<0>
; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<[[VP4]]>, vp<[[VP1]]>
diff --git a/llvm/unittests/Transforms/Vectorize/VPlanHCFGTest.cpp b/llvm/unittests/Transforms/Vectorize/VPlanHCFGTest.cpp
index eaa9c978d6252..c5379ef737b8f 100644
--- a/llvm/unittests/Transforms/Vectorize/VPlanHCFGTest.cpp
+++ b/llvm/unittests/Transforms/Vectorize/VPlanHCFGTest.cpp
@@ -140,7 +140,7 @@ compound=true
N4 [label =
"vector.body:\l" +
" EMIT-SCALAR ir\<%indvars.iv\> = phi [ ir\<0\>, vector.ph ], [ ir\<%indvars.iv.next\>, vector.body ]\l" +
- " EMIT ir\<%arr.idx\> = getelementptr inbounds ir\<%A\>, ir\<%indvars.iv\>\l" +
+ " EMIT-SCALAR ir\<%arr.idx\> = getelementptr inbounds i32, ir\<%A\>, ir\<%indvars.iv\>\l" +
" EMIT-SCALAR ir\<%l1\> = load ir\<%arr.idx\>\l" +
" EMIT ir\<%res\> = add ir\<%l1\>, ir\<10\>\l" +
" EMIT store ir\<%res\>, ir\<%arr.idx\>\l" +
@@ -310,7 +310,7 @@ compound=true
N4 [label =
"vector.body:\l" +
" EMIT-SCALAR ir\<%iv\> = phi [ ir\<0\>, vector.ph ], [ ir\<%iv.next\>, loop.latch ]\l" +
- " EMIT ir\<%arr.idx\> = getelementptr inbounds ir\<%A\>, ir\<%iv\>\l" +
+ " EMIT-SCALAR ir\<%arr.idx\> = getelementptr inbounds i32, ir\<%A\>, ir\<%iv\>\l" +
" EMIT-SCALAR ir\<%l1\> = load ir\<%arr.idx\>\l" +
" EMIT ir\<%c\> = icmp eq ir\<%l1\>, ir\<0\>\l" +
"Successor(s): loop.latch\l"
More information about the llvm-commits
mailing list