[llvm] [VPlan] Create and re-use ModuleSlotTracker for metadata printing. (PR #203982)
Florian Hahn via llvm-commits
llvm-commits at lists.llvm.org
Wed Sep 16 03:02:13 PDT 2026
https://github.com/fhahn updated https://github.com/llvm/llvm-project/pull/203982
>From 51ce97e898ae4948787e159edc101e4cf62def98 Mon Sep 17 00:00:00 2001
From: Florian Hahn <flo at fhahn.com>
Date: Tue, 15 Sep 2026 22:13:03 +0100
Subject: [PATCH 1/2] [VPlan] Create VPSlotTracker's ModuleSlotTracker for the
plan (NFC).
Move the lazy creation of VPSlotTracker's ModuleSlotTracker into a new
getOrCreateMST helper, so it can be shared with other users in the
future (https://github.com/llvm/llvm-project/pull/203982).
Also get the function and module directly from the plan
Create it for the cached module and get the function to incorporate from
the plan, instead of using the module and function of the first unnamed
instruction printed.
---
llvm/lib/Transforms/Vectorize/VPlan.cpp | 29 ++++++++++----------
llvm/lib/Transforms/Vectorize/VPlanHelpers.h | 19 +++++++++----
2 files changed, 28 insertions(+), 20 deletions(-)
diff --git a/llvm/lib/Transforms/Vectorize/VPlan.cpp b/llvm/lib/Transforms/Vectorize/VPlan.cpp
index f3bdf910a6e7b..234c0fee6a384 100644
--- a/llvm/lib/Transforms/Vectorize/VPlan.cpp
+++ b/llvm/lib/Transforms/Vectorize/VPlan.cpp
@@ -1588,27 +1588,28 @@ void VPSlotTracker::assignNames(const VPBasicBlock *VPBB) {
assignName(Def);
}
+ModuleSlotTracker &VPSlotTracker::getOrCreateMST() {
+ // F is null for unit tests with incomplete IR.
+ if (!MST) {
+ MST = std::make_unique<ModuleSlotTracker>(getModule());
+ if (F)
+ MST->incorporateFunction(*F);
+ }
+ return *MST;
+}
+
std::string VPSlotTracker::getName(const Value *V) {
std::string Name;
raw_string_ostream S(Name);
- if (V->hasName() || !isa<Instruction>(V)) {
+ // If V isn't and instruction in a basic block or named, it can be printed
+ // directly without ModuleSlotTracker.
+ auto *I = dyn_cast<Instruction>(V);
+ if (!I || I->hasName() || !I->getParent()) {
V->printAsOperand(S, false);
return Name;
}
- if (!MST) {
- // Lazily create the ModuleSlotTracker when we first hit an unnamed
- // instruction.
- auto *I = cast<Instruction>(V);
- // This check is required to support unit tests with incomplete IR.
- if (I->getParent()) {
- MST = std::make_unique<ModuleSlotTracker>(I->getModule());
- MST->incorporateFunction(*I->getFunction());
- } else {
- MST = std::make_unique<ModuleSlotTracker>(nullptr);
- }
- }
- V->printAsOperand(S, false, *MST);
+ V->printAsOperand(S, false, getOrCreateMST());
return Name;
}
diff --git a/llvm/lib/Transforms/Vectorize/VPlanHelpers.h b/llvm/lib/Transforms/Vectorize/VPlanHelpers.h
index d31c5acdf69a9..4f4a435db00e0 100644
--- a/llvm/lib/Transforms/Vectorize/VPlanHelpers.h
+++ b/llvm/lib/Transforms/Vectorize/VPlanHelpers.h
@@ -32,6 +32,7 @@ class AssumptionCache;
class BasicBlock;
class CallInst;
class DominatorTree;
+class Function;
class InnerLoopVectorizer;
class IRBuilderBase;
class LoopInfo;
@@ -432,20 +433,25 @@ class VPSlotTracker {
/// Cached metadata kind names from the Module's LLVMContext.
SmallVector<StringRef> MDNames;
- /// Cached Module pointer for printing metadata.
- const Module *M = nullptr;
+ /// Cached Function pointer for printing names and metadata.
+ const Function *F = nullptr;
void assignName(const VPValue *V);
LLVM_ABI_FOR_TEST void assignNames(const VPlan &Plan);
void assignNames(const VPBasicBlock *VPBB);
std::string getName(const Value *V);
+ /// Lazily create the ModuleSlotTracker.
+ ModuleSlotTracker &getOrCreateMST();
+
public:
VPSlotTracker(const VPlan *Plan = nullptr) {
if (Plan) {
+ if (auto *ScalarHeader = Plan->getScalarHeader()) {
+ const BasicBlock *ScalarHeaderIRBB = ScalarHeader->getIRBasicBlock();
+ F = ScalarHeaderIRBB->getParent();
+ }
assignNames(*Plan);
- if (auto *ScalarHeader = Plan->getScalarHeader())
- M = ScalarHeader->getIRBasicBlock()->getModule();
}
}
@@ -456,13 +462,14 @@ class VPSlotTracker {
/// Returns the cached metadata kind names.
ArrayRef<StringRef> getMDNames() {
+ const Module *M = getModule();
if (MDNames.empty() && M)
M->getContext().getMDKindNames(MDNames);
return MDNames;
}
- /// Returns the cached Module pointer.
- const Module *getModule() const { return M; }
+ /// Returns the module the plan operates on, if any.
+ const Module *getModule() const { return F ? F->getParent() : nullptr; }
};
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
>From 8fb3ed897b7d26a63c875ca9e184fa11708cdaf2 Mon Sep 17 00:00:00 2001
From: Florian Hahn <flo at fhahn.com>
Date: Tue, 15 Sep 2026 22:14:32 +0100
Subject: [PATCH 2/2] [VPlan] Print recipe metadata using VPlan's
ModuleSlotTracker.
Recipes can reference metadata that is not attached to any IR
instruction, e.g. the alias.scope/noalias metadata generated by loop
versioning. Printing a node via Metadata::printAsOperand(O, M) creates a
fresh ModuleSlotTracker per node, so such unattached nodes are not
numbered consistently across a plan.
Print metadata via the slot tracker's ModuleSlotTracker instead, which is
shared for the whole plan and also assigns stable IDs to metadata not
attached to the module.
With numbering now being deterministic, -vplan-print-metadata is not
needed any longer and is removed together with its uses in tests.
---
llvm/lib/Transforms/Vectorize/VPlan.cpp | 4 +
llvm/lib/Transforms/Vectorize/VPlanHelpers.h | 3 +
.../lib/Transforms/Vectorize/VPlanRecipes.cpp | 13 +-
.../VPlan/epilogue-vectorization-printing.ll | 2 +-
.../VPlan/interleave-and-scalarize-only.ll | 8 +-
.../LoopVectorize/VPlan/memory-checks.ll | 2 +-
.../VPlan/vplan-printing-metadata.ll | 78 ++++
.../WebAssembly/memory-interleave.ll | 358 +++++++++---------
.../X86/CostModel/masked-load-i16.ll | 52 +--
.../X86/CostModel/masked-load-i32.ll | 52 +--
.../X86/CostModel/masked-load-i64.ll | 52 +--
.../X86/CostModel/masked-load-i8.ll | 12 +-
.../X86/CostModel/masked-store-i16.ll | 24 +-
.../X86/CostModel/masked-store-i32.ll | 44 +--
.../X86/CostModel/masked-store-i64.ll | 44 +--
.../X86/CostModel/masked-store-i8.ll | 12 +-
16 files changed, 418 insertions(+), 342 deletions(-)
diff --git a/llvm/lib/Transforms/Vectorize/VPlan.cpp b/llvm/lib/Transforms/Vectorize/VPlan.cpp
index 234c0fee6a384..6590aab26d747 100644
--- a/llvm/lib/Transforms/Vectorize/VPlan.cpp
+++ b/llvm/lib/Transforms/Vectorize/VPlan.cpp
@@ -1613,6 +1613,10 @@ std::string VPSlotTracker::getName(const Value *V) {
return Name;
}
+void VPSlotTracker::printMetadataAsOperand(raw_ostream &O, const MDNode *N) {
+ N->printAsOperand(O, getOrCreateMST(), getModule());
+}
+
std::string VPSlotTracker::getOrCreateName(const VPValue *V) const {
std::string Name = VPValue2Name.lookup(V);
if (!Name.empty())
diff --git a/llvm/lib/Transforms/Vectorize/VPlanHelpers.h b/llvm/lib/Transforms/Vectorize/VPlanHelpers.h
index 4f4a435db00e0..34251ecad7584 100644
--- a/llvm/lib/Transforms/Vectorize/VPlanHelpers.h
+++ b/llvm/lib/Transforms/Vectorize/VPlanHelpers.h
@@ -468,6 +468,9 @@ class VPSlotTracker {
return MDNames;
}
+ /// Print a reference to metadata node \p N to \p O.
+ void printMetadataAsOperand(raw_ostream &O, const MDNode *N);
+
/// Returns the module the plan operates on, if any.
const Module *getModule() const { return F ? F->getParent() : nullptr; }
};
diff --git a/llvm/lib/Transforms/Vectorize/VPlanRecipes.cpp b/llvm/lib/Transforms/Vectorize/VPlanRecipes.cpp
index 5997b6e0fef76..7b3f44caab23f 100644
--- a/llvm/lib/Transforms/Vectorize/VPlanRecipes.cpp
+++ b/llvm/lib/Transforms/Vectorize/VPlanRecipes.cpp
@@ -47,15 +47,6 @@ using namespace llvm::VPlanPatternMatch;
#define LV_NAME "loop-vectorize"
#define DEBUG_TYPE LV_NAME
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-// It is sometimes necessary to disable printing of metadata in tests in order
-// to avoid non-deterministic behaviour due to metadata introduced by VPlan
-// that wasn't present in the original scalar IR.
-static cl::opt<bool> VPlanPrintMetadata(
- "vplan-print-metadata", cl::init(true), cl::Hidden,
- cl::desc("Controls the printing of recipe metadata when debugging."));
-#endif
-
namespace llvm {
extern cl::opt<unsigned> ForceTargetInstructionCost;
} // namespace llvm
@@ -2156,7 +2147,7 @@ void VPIRMetadata::intersect(const VPIRMetadata &Other) {
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
void VPIRMetadata::print(raw_ostream &O, VPSlotTracker &SlotTracker) const {
const Module *M = SlotTracker.getModule();
- if (Metadata.empty() || !M || !VPlanPrintMetadata)
+ if (Metadata.empty() || !M)
return;
ArrayRef<StringRef> MDNames = SlotTracker.getMDNames();
@@ -2185,7 +2176,7 @@ void VPIRMetadata::print(raw_ostream &O, VPSlotTracker &SlotTracker) const {
100.0 * Freq.getFrequency() / vputils::AlwaysExecutesFreq,
IsEstimated ? ", estimated" : "");
} else {
- Node->printAsOperand(O, M);
+ SlotTracker.printMetadataAsOperand(O, Node);
}
});
O << ")";
diff --git a/llvm/test/Transforms/LoopVectorize/VPlan/epilogue-vectorization-printing.ll b/llvm/test/Transforms/LoopVectorize/VPlan/epilogue-vectorization-printing.ll
index 9bf623bfaef49..731c67f6a9f54 100644
--- a/llvm/test/Transforms/LoopVectorize/VPlan/epilogue-vectorization-printing.ll
+++ b/llvm/test/Transforms/LoopVectorize/VPlan/epilogue-vectorization-printing.ll
@@ -1,5 +1,5 @@
; RUN: opt -passes=loop-vectorize -force-vector-width=8 -enable-epilogue-vectorization \
-; RUN: -epilogue-vectorization-force-VF=4 -vplan-print-metadata=false -disable-output \
+; RUN: -epilogue-vectorization-force-VF=4 -disable-output \
; RUN: -vplan-print-after=printFinalVPlan %s 2>&1 | FileCheck %s
; Check how plans for epilogue vectorization are represented in VPlan.
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..341cbfb6f1ad8 100644
--- a/llvm/test/Transforms/LoopVectorize/VPlan/interleave-and-scalarize-only.ll
+++ b/llvm/test/Transforms/LoopVectorize/VPlan/interleave-and-scalarize-only.ll
@@ -1,5 +1,5 @@
; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py UTC_ARGS: --version 6
-; RUN: opt -passes=loop-vectorize -force-vector-width=1 -force-vector-interleave=2 -vplan-print-after=printOptimizedVPlan -disable-output -vplan-print-metadata=false %s 2>&1 | FileCheck %s
+; RUN: opt -passes=loop-vectorize -force-vector-width=1 -force-vector-interleave=2 -vplan-print-after=printOptimizedVPlan -disable-output %s 2>&1 | FileCheck %s
;
define void @test_scalarize_call(i32 %start, ptr %dst) {
@@ -96,7 +96,7 @@ define void @test_scalarize_with_branch_cond(ptr %src, ptr %dst) {
; CHECK-EMPTY:
; CHECK-NEXT: <xVFxUF> pred.store: {
; CHECK-NEXT: pred.store.entry:
-; CHECK-NEXT: BRANCH-ON-MASK vp<[[VP6]]>
+; CHECK-NEXT: BRANCH-ON-MASK vp<[[VP6]]> (!vplan.execution.frequency 4611686018427387904 (50%, estimated))
; CHECK-NEXT: Successor(s): pred.store.if, pred.store.continue
; CHECK-EMPTY:
; CHECK-NEXT: pred.store.if:
@@ -332,7 +332,7 @@ define void @scalarize_ptrtoint(ptr %src, ptr %dst) {
; 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: CLONE ir<%l> = load ir<%gep>
+; CHECK-NEXT: CLONE ir<%l> = load ir<%gep> (!alias.scope !19)
; 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
@@ -343,7 +343,7 @@ define void @scalarize_ptrtoint(ptr %src, ptr %dst) {
; CHECK-NEXT: EMIT-SCALAR ir<%cast> = ptrtoint ir<%l> to i64
; CHECK-NEXT: CLONE ir<%add> = add ir<%cast>, ir<10>
; CHECK-NEXT: EMIT-SCALAR ir<%cast.2> = inttoptr ir<%add> to ptr
-; CHECK-NEXT: CLONE store ir<%cast.2>, ir<%dst>
+; CHECK-NEXT: CLONE store ir<%cast.2>, ir<%dst> (!alias.scope !20, !noalias !19)
; CHECK-NEXT: EMIT vp<%cmp.n> = icmp eq ir<1024>, vp<[[VP2]]>
; CHECK-NEXT: EMIT branch-on-cond vp<%cmp.n>
; CHECK-NEXT: Successor(s): ir-bb<exit>, scalar.ph
diff --git a/llvm/test/Transforms/LoopVectorize/VPlan/memory-checks.ll b/llvm/test/Transforms/LoopVectorize/VPlan/memory-checks.ll
index 344ccf7d03685..938a6a666a6ac 100644
--- a/llvm/test/Transforms/LoopVectorize/VPlan/memory-checks.ll
+++ b/llvm/test/Transforms/LoopVectorize/VPlan/memory-checks.ll
@@ -1,5 +1,5 @@
; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py UTC_ARGS: --filter-out-after "vector.body:" --version 6
-; RUN: opt -passes=loop-vectorize -force-vector-width=4 -force-vector-interleave=1 -disable-output -vplan-print-after="printFinalVPlan" -vplan-print-metadata=false %s 2>&1 | FileCheck %s
+; RUN: opt -passes=loop-vectorize -force-vector-width=4 -force-vector-interleave=1 -disable-output -vplan-print-after="printFinalVPlan" %s 2>&1 | FileCheck %s
define void @three_groups_shared_bounds(ptr %a, ptr %b, ptr %c, i64 %n) {
; CHECK-LABEL: VPlan for loop in 'three_groups_shared_bounds'
diff --git a/llvm/test/Transforms/LoopVectorize/VPlan/vplan-printing-metadata.ll b/llvm/test/Transforms/LoopVectorize/VPlan/vplan-printing-metadata.ll
index ccc4e44dbcf9c..379a2e83e7ef3 100644
--- a/llvm/test/Transforms/LoopVectorize/VPlan/vplan-printing-metadata.ll
+++ b/llvm/test/Transforms/LoopVectorize/VPlan/vplan-printing-metadata.ll
@@ -237,6 +237,84 @@ exit:
ret void
}
+define void @test_noalias_metadata(ptr %a, ptr %b, i64 %n) {
+; CHECK-LABEL: VPlan for loop in 'test_noalias_metadata'
+; CHECK: VPlan 'Initial VPlan for VF={4},UF>=1' {
+; CHECK-NEXT: Live-in vp<[[VP0:%[0-9]+]]> = VF
+; CHECK-NEXT: Live-in vp<[[VP1:%[0-9]+]]> = VF * UF
+; CHECK-NEXT: Live-in vp<[[VP2:%[0-9]+]]> = vector-trip-count
+; CHECK-NEXT: Live-in ir<%n> = original trip-count
+; CHECK-EMPTY:
+; CHECK-NEXT: ir-bb<entry>:
+; CHECK-NEXT: Successor(s): scalar.ph, vector.ph
+; CHECK-EMPTY:
+; CHECK-NEXT: vector.ph:
+; CHECK-NEXT: Successor(s): vector loop
+; CHECK-EMPTY:
+; CHECK-NEXT: <x1> vector loop: {
+; CHECK-NEXT: vp<[[VP3:%[0-9]+]]> = CANONICAL-IV
+; 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: vp<[[VP5:%[0-9]+]]> = vector-pointer inbounds i32, ir<%gep.a>, ir<1>
+; CHECK-NEXT: WIDEN ir<%l> = load vp<[[VP5]]> (!alias.scope [[SCOPE_A:![0-9]+]], !noalias [[SCOPE_B:![0-9]+]])
+; CHECK-NEXT: CLONE ir<%gep.b> = getelementptr inbounds ir<%b>, vp<[[VP4]]>
+; CHECK-NEXT: vp<[[VP6:%[0-9]+]]> = vector-pointer inbounds i32, ir<%gep.b>, ir<1>
+; CHECK-NEXT: WIDEN ir<%l2> = load vp<[[VP6]]> (!alias.scope [[SCOPE_B]])
+; CHECK-NEXT: WIDEN ir<%add> = add ir<%l>, ir<%l2>
+; CHECK-NEXT: vp<[[VP7:%[0-9]+]]> = vector-pointer inbounds i32, ir<%gep.a>, ir<1>
+; CHECK-NEXT: WIDEN store vp<[[VP7]]>, ir<%add> (!alias.scope [[SCOPE_A]], !noalias [[SCOPE_B]])
+; 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
+; CHECK-NEXT: }
+; CHECK-NEXT: Successor(s): middle.block
+; CHECK-EMPTY:
+; CHECK-NEXT: middle.block:
+; CHECK-NEXT: EMIT vp<%cmp.n> = icmp eq ir<%n>, vp<[[VP2]]>
+; CHECK-NEXT: EMIT branch-on-cond vp<%cmp.n>
+; CHECK-NEXT: Successor(s): ir-bb<exit>, scalar.ph
+; CHECK-EMPTY:
+; CHECK-NEXT: ir-bb<exit>:
+; CHECK-NEXT: No successors
+; CHECK-EMPTY:
+; CHECK-NEXT: scalar.ph:
+; CHECK-NEXT: EMIT-SCALAR vp<%bc.resume.val> = phi [ vp<[[VP2]]>, middle.block ], [ ir<0>, ir-bb<entry> ]
+; CHECK-NEXT: Successor(s): ir-bb<loop>
+; CHECK-EMPTY:
+; CHECK-NEXT: ir-bb<loop>:
+; CHECK-NEXT: IR %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop ] (extra operand: vp<%bc.resume.val> from scalar.ph)
+; CHECK-NEXT: IR %gep.a = getelementptr inbounds i32, ptr %a, i64 %iv
+; CHECK-NEXT: IR %l = load i32, ptr %gep.a, align 4
+; CHECK-NEXT: IR %gep.b = getelementptr inbounds i32, ptr %b, i64 %iv
+; CHECK-NEXT: IR %l2 = load i32, ptr %gep.b, align 4
+; CHECK-NEXT: IR %add = add i32 %l, %l2
+; CHECK-NEXT: IR store i32 %add, ptr %gep.a, align 4
+; CHECK-NEXT: IR %iv.next = add nuw nsw i64 %iv, 1
+; CHECK-NEXT: IR %ec = icmp eq i64 %iv.next, %n
+; CHECK-NEXT: No successors
+; CHECK-NEXT: }
+;
+entry:
+ br label %loop
+
+loop:
+ %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop ]
+ %gep.a = getelementptr inbounds i32, ptr %a, i64 %iv
+ %l = load i32, ptr %gep.a, align 4
+ %gep.b = getelementptr inbounds i32, ptr %b, i64 %iv
+ %l2 = load i32, ptr %gep.b, align 4
+ %add = add i32 %l, %l2
+ store i32 %add, ptr %gep.a, align 4
+ %iv.next = add nuw nsw i64 %iv, 1
+ %ec = icmp eq i64 %iv.next, %n
+ br i1 %ec, label %exit, label %loop
+
+exit:
+ ret void
+}
+
!0 = !{!1, !1, i64 0}
!1 = !{!"float", !2}
!2 = !{!"root"}
diff --git a/llvm/test/Transforms/LoopVectorize/WebAssembly/memory-interleave.ll b/llvm/test/Transforms/LoopVectorize/WebAssembly/memory-interleave.ll
index 146e25c2f7f00..4aa45759f40b7 100644
--- a/llvm/test/Transforms/LoopVectorize/WebAssembly/memory-interleave.ll
+++ b/llvm/test/Transforms/LoopVectorize/WebAssembly/memory-interleave.ll
@@ -1,6 +1,6 @@
; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py UTC_ARGS: --filter "Cost of.*INTERLEAVE-GROUP" --filter "LV: Selecting VF:" --filter "Cost for VF" --filter "LV: Scalar loop costs" --filter "Cost of.*REPLICATE.*(load|store)" --filter "^ ir.*load from" --filter "^ store.*to index" --filter-out-after "LV: Selecting VF" --version 6
; REQUIRES: asserts
-; RUN: opt -mattr=+simd128 -passes=loop-vectorize -debug-only=loop-vectorize,vectorutils -disable-output -vplan-print-metadata=false < %s 2>&1 | FileCheck %s
+; RUN: opt -mattr=+simd128 -passes=loop-vectorize -debug-only=loop-vectorize,vectorutils -disable-output < %s 2>&1 | FileCheck %s
target datalayout = "e-m:e-p:32:32-p10:8:8-p20:8:8-i64:64-n32:64-S128-ni:1:10:20"
target triple = "wasm32-unknown-wasi"
@@ -2026,24 +2026,24 @@ define hidden void @scale_uv_row_down2(ptr nocapture noundef readonly %0, i32 no
; CHECK: LV: Scalar loop costs: 10.
; CHECK: Cost of 18 for VF 4: INTERLEAVE-GROUP with factor 4, ir<%10>
; CHECK: ir<%11> = load from index 0
-; CHECK: ir<%13> = load from index 1
+; CHECK: ir<%13> = load from index 1 (!alias.scope !53)
; CHECK: Cost of 11 for VF 4: INTERLEAVE-GROUP with factor 2, vp<%next.gep>.1
; CHECK: store ir<%11> to index 0
-; CHECK: store ir<%13> to index 1
+; CHECK: store ir<%13> to index 1 (!alias.scope !54, !noalias !53)
; CHECK: Cost for VF 4: 34 (Estimated cost per lane: 8.5)
; CHECK: Cost of 26 for VF 8: INTERLEAVE-GROUP with factor 4, ir<%10>
; CHECK: ir<%11> = load from index 0
-; CHECK: ir<%13> = load from index 1
+; CHECK: ir<%13> = load from index 1 (!alias.scope !53)
; CHECK: Cost of 7 for VF 8: INTERLEAVE-GROUP with factor 2, vp<%next.gep>.1
; CHECK: store ir<%11> to index 0
-; CHECK: store ir<%13> to index 1
+; CHECK: store ir<%13> to index 1 (!alias.scope !54, !noalias !53)
; CHECK: Cost for VF 8: 38 (Estimated cost per lane: 4.75)
; CHECK: Cost of 68 for VF 16: INTERLEAVE-GROUP with factor 4, ir<%10>
; CHECK: ir<%11> = load from index 0
-; CHECK: ir<%13> = load from index 1
+; CHECK: ir<%13> = load from index 1 (!alias.scope !53)
; CHECK: Cost of 6 for VF 16: INTERLEAVE-GROUP with factor 2, vp<%next.gep>.1
; CHECK: store ir<%11> to index 0
-; CHECK: store ir<%13> to index 1
+; CHECK: store ir<%13> to index 1 (!alias.scope !54, !noalias !53)
; CHECK: Cost for VF 16: 79 (Estimated cost per lane: 4.94)
; CHECK: LV: Selecting VF: 8.
;
@@ -2074,58 +2074,58 @@ define hidden void @scale_uv_row_down2(ptr nocapture noundef readonly %0, i32 no
define hidden void @scale_uv_row_down2_box(ptr nocapture noundef readonly %0, i32 noundef %1, ptr nocapture noundef writeonly %2, i32 noundef %3) {
; CHECK-LABEL: 'scale_uv_row_down2_box'
; CHECK: LV: Scalar loop costs: 26.
-; CHECK: Cost of 6 for VF 2: REPLICATE ir<%14> = load vp<%next.gep>
-; CHECK: Cost of 6 for VF 2: REPLICATE ir<%17> = load ir<%16>
-; CHECK: Cost of 6 for VF 2: REPLICATE ir<%20> = load ir<%19>
-; CHECK: Cost of 6 for VF 2: REPLICATE ir<%23> = load ir<%22>
-; CHECK: Cost of 6 for VF 2: REPLICATE store ir<%30>, vp<%next.gep>.1
-; CHECK: Cost of 6 for VF 2: REPLICATE ir<%32> = load ir<%31>
-; CHECK: Cost of 6 for VF 2: REPLICATE ir<%35> = load ir<%34>
-; CHECK: Cost of 6 for VF 2: REPLICATE ir<%38> = load ir<%37>
-; CHECK: Cost of 6 for VF 2: REPLICATE ir<%41> = load ir<%40>
-; CHECK: Cost of 6 for VF 2: REPLICATE store ir<%48>, ir<%49>
+; CHECK: Cost of 6 for VF 2: REPLICATE ir<%14> = load vp<%next.gep> (!alias.scope !63)
+; CHECK: Cost of 6 for VF 2: REPLICATE ir<%17> = load ir<%16> (!alias.scope !63)
+; CHECK: Cost of 6 for VF 2: REPLICATE ir<%20> = load ir<%19> (!alias.scope !64)
+; CHECK: Cost of 6 for VF 2: REPLICATE ir<%23> = load ir<%22> (!alias.scope !64)
+; CHECK: Cost of 6 for VF 2: REPLICATE store ir<%30>, vp<%next.gep>.1 (!alias.scope !65, !noalias !62)
+; CHECK: Cost of 6 for VF 2: REPLICATE ir<%32> = load ir<%31> (!alias.scope !63)
+; CHECK: Cost of 6 for VF 2: REPLICATE ir<%35> = load ir<%34> (!alias.scope !63)
+; CHECK: Cost of 6 for VF 2: REPLICATE ir<%38> = load ir<%37> (!alias.scope !64)
+; CHECK: Cost of 6 for VF 2: REPLICATE ir<%41> = load ir<%40> (!alias.scope !64)
+; CHECK: Cost of 6 for VF 2: REPLICATE store ir<%48>, ir<%49> (!alias.scope !65, !noalias !62)
; CHECK: Cost for VF 2: 79 (Estimated cost per lane: 39.5)
; CHECK: Cost of 18 for VF 4: INTERLEAVE-GROUP with factor 4, vp<%next.gep>
; CHECK: ir<%14> = load from index 0
; CHECK: ir<%32> = load from index 1
; CHECK: ir<%17> = load from index 2
-; CHECK: ir<%35> = load from index 3
+; CHECK: ir<%35> = load from index 3 (!alias.scope !63)
; CHECK: Cost of 18 for VF 4: INTERLEAVE-GROUP with factor 4, ir<%19>
; CHECK: ir<%20> = load from index 0
; CHECK: ir<%38> = load from index 1
; CHECK: ir<%23> = load from index 2
-; CHECK: ir<%41> = load from index 3
+; CHECK: ir<%41> = load from index 3 (!alias.scope !64)
; CHECK: Cost of 11 for VF 4: INTERLEAVE-GROUP with factor 2, vp<%next.gep>.1
; CHECK: store ir<%30> to index 0
-; CHECK: store ir<%48> to index 1
+; CHECK: store ir<%48> to index 1 (!alias.scope !65, !noalias !62)
; CHECK: Cost for VF 4: 72 (Estimated cost per lane: 18)
; CHECK: Cost of 26 for VF 8: INTERLEAVE-GROUP with factor 4, vp<%next.gep>
; CHECK: ir<%14> = load from index 0
; CHECK: ir<%32> = load from index 1
; CHECK: ir<%17> = load from index 2
-; CHECK: ir<%35> = load from index 3
+; CHECK: ir<%35> = load from index 3 (!alias.scope !63)
; CHECK: Cost of 26 for VF 8: INTERLEAVE-GROUP with factor 4, ir<%19>
; CHECK: ir<%20> = load from index 0
; CHECK: ir<%38> = load from index 1
; CHECK: ir<%23> = load from index 2
-; CHECK: ir<%41> = load from index 3
+; CHECK: ir<%41> = load from index 3 (!alias.scope !64)
; CHECK: Cost of 7 for VF 8: INTERLEAVE-GROUP with factor 2, vp<%next.gep>.1
; CHECK: store ir<%30> to index 0
-; CHECK: store ir<%48> to index 1
+; CHECK: store ir<%48> to index 1 (!alias.scope !65, !noalias !62)
; CHECK: Cost for VF 8: 88 (Estimated cost per lane: 11)
; CHECK: Cost of 132 for VF 16: INTERLEAVE-GROUP with factor 4, vp<%next.gep>
; CHECK: ir<%14> = load from index 0
; CHECK: ir<%32> = load from index 1
; CHECK: ir<%17> = load from index 2
-; CHECK: ir<%35> = load from index 3
+; CHECK: ir<%35> = load from index 3 (!alias.scope !63)
; CHECK: Cost of 132 for VF 16: INTERLEAVE-GROUP with factor 4, ir<%19>
; CHECK: ir<%20> = load from index 0
; CHECK: ir<%38> = load from index 1
; CHECK: ir<%23> = load from index 2
-; CHECK: ir<%41> = load from index 3
+; CHECK: ir<%41> = load from index 3 (!alias.scope !64)
; CHECK: Cost of 6 for VF 16: INTERLEAVE-GROUP with factor 2, vp<%next.gep>.1
; CHECK: store ir<%30> to index 0
-; CHECK: store ir<%48> to index 1
+; CHECK: store ir<%48> to index 1 (!alias.scope !65, !noalias !62)
; CHECK: Cost for VF 16: 321 (Estimated cost per lane: 20.1)
; CHECK: LV: Selecting VF: 8.
;
@@ -2193,39 +2193,39 @@ define hidden void @scale_uv_row_down2_box(ptr nocapture noundef readonly %0, i3
define hidden void @scale_uv_row_down2_linear(ptr nocapture noundef readonly %0, i32 noundef %1, ptr nocapture noundef writeonly %2, i32 noundef %3) {
; CHECK-LABEL: 'scale_uv_row_down2_linear'
; CHECK: LV: Scalar loop costs: 18.
-; CHECK: Cost of 6 for VF 2: REPLICATE ir<%10> = load vp<%next.gep>
-; CHECK: Cost of 6 for VF 2: REPLICATE ir<%13> = load ir<%12>
-; CHECK: Cost of 6 for VF 2: REPLICATE store ir<%18>, vp<%next.gep>.1
-; CHECK: Cost of 6 for VF 2: REPLICATE ir<%20> = load ir<%19>
-; CHECK: Cost of 6 for VF 2: REPLICATE ir<%23> = load ir<%22>
-; CHECK: Cost of 6 for VF 2: REPLICATE store ir<%28>, ir<%29>
+; CHECK: Cost of 6 for VF 2: REPLICATE ir<%10> = load vp<%next.gep> (!alias.scope !72)
+; CHECK: Cost of 6 for VF 2: REPLICATE ir<%13> = load ir<%12> (!alias.scope !72)
+; CHECK: Cost of 6 for VF 2: REPLICATE store ir<%18>, vp<%next.gep>.1 (!alias.scope !73, !noalias !72)
+; CHECK: Cost of 6 for VF 2: REPLICATE ir<%20> = load ir<%19> (!alias.scope !72)
+; CHECK: Cost of 6 for VF 2: REPLICATE ir<%23> = load ir<%22> (!alias.scope !72)
+; CHECK: Cost of 6 for VF 2: REPLICATE store ir<%28>, ir<%29> (!alias.scope !73, !noalias !72)
; CHECK: Cost for VF 2: 51 (Estimated cost per lane: 25.5)
; CHECK: Cost of 18 for VF 4: INTERLEAVE-GROUP with factor 4, vp<%next.gep>
; CHECK: ir<%10> = load from index 0
; CHECK: ir<%20> = load from index 1
; CHECK: ir<%13> = load from index 2
-; CHECK: ir<%23> = load from index 3
+; CHECK: ir<%23> = load from index 3 (!alias.scope !72)
; CHECK: Cost of 11 for VF 4: INTERLEAVE-GROUP with factor 2, vp<%next.gep>.1
; CHECK: store ir<%18> to index 0
-; CHECK: store ir<%28> to index 1
+; CHECK: store ir<%28> to index 1 (!alias.scope !73, !noalias !72)
; CHECK: Cost for VF 4: 46 (Estimated cost per lane: 11.5)
; CHECK: Cost of 26 for VF 8: INTERLEAVE-GROUP with factor 4, vp<%next.gep>
; CHECK: ir<%10> = load from index 0
; CHECK: ir<%20> = load from index 1
; CHECK: ir<%13> = load from index 2
-; CHECK: ir<%23> = load from index 3
+; CHECK: ir<%23> = load from index 3 (!alias.scope !72)
; CHECK: Cost of 7 for VF 8: INTERLEAVE-GROUP with factor 2, vp<%next.gep>.1
; CHECK: store ir<%18> to index 0
-; CHECK: store ir<%28> to index 1
+; CHECK: store ir<%28> to index 1 (!alias.scope !73, !noalias !72)
; CHECK: Cost for VF 8: 54 (Estimated cost per lane: 6.75)
; CHECK: Cost of 132 for VF 16: INTERLEAVE-GROUP with factor 4, vp<%next.gep>
; CHECK: ir<%10> = load from index 0
; CHECK: ir<%20> = load from index 1
; CHECK: ir<%13> = load from index 2
-; CHECK: ir<%23> = load from index 3
+; CHECK: ir<%23> = load from index 3 (!alias.scope !72)
; CHECK: Cost of 6 for VF 16: INTERLEAVE-GROUP with factor 2, vp<%next.gep>.1
; CHECK: store ir<%18> to index 0
-; CHECK: store ir<%28> to index 1
+; CHECK: store ir<%28> to index 1 (!alias.scope !73, !noalias !72)
; CHECK: Cost for VF 16: 173 (Estimated cost per lane: 10.8)
; CHECK: LV: Selecting VF: 8.
;
@@ -2273,23 +2273,23 @@ define hidden void @two_floats_same_op(ptr noundef readonly captures(none) %a, p
; CHECK: LV: Scalar loop costs: 14.
; CHECK: Cost of 7 for VF 2: INTERLEAVE-GROUP with factor 2, ir<%arrayidx>
; CHECK: ir<%0> = load from index 0
-; CHECK: ir<%2> = load from index 1
+; CHECK: ir<%2> = load from index 1 (!alias.scope !82)
; CHECK: Cost of 7 for VF 2: INTERLEAVE-GROUP with factor 2, ir<%arrayidx1>
; CHECK: ir<%1> = load from index 0
-; CHECK: ir<%3> = load from index 1
+; CHECK: ir<%3> = load from index 1 (!alias.scope !83)
; CHECK: Cost of 7 for VF 2: INTERLEAVE-GROUP with factor 2, ir<%arrayidx3>
; CHECK: store ir<%mul> to index 0
-; CHECK: store ir<%mul8> to index 1
+; CHECK: store ir<%mul8> to index 1 (!alias.scope !84, !noalias !81)
; CHECK: Cost for VF 2: 28 (Estimated cost per lane: 14)
; CHECK: Cost of 6 for VF 4: INTERLEAVE-GROUP with factor 2, ir<%arrayidx>
; CHECK: ir<%0> = load from index 0
-; CHECK: ir<%2> = load from index 1
+; CHECK: ir<%2> = load from index 1 (!alias.scope !82)
; CHECK: Cost of 6 for VF 4: INTERLEAVE-GROUP with factor 2, ir<%arrayidx1>
; CHECK: ir<%1> = load from index 0
-; CHECK: ir<%3> = load from index 1
+; CHECK: ir<%3> = load from index 1 (!alias.scope !83)
; CHECK: Cost of 6 for VF 4: INTERLEAVE-GROUP with factor 2, ir<%arrayidx3>
; CHECK: store ir<%mul> to index 0
-; CHECK: store ir<%mul8> to index 1
+; CHECK: store ir<%mul8> to index 1 (!alias.scope !84, !noalias !81)
; CHECK: Cost for VF 4: 25 (Estimated cost per lane: 6.25)
; CHECK: LV: Selecting VF: 4.
;
@@ -2326,23 +2326,23 @@ define hidden void @two_floats_vary_op(ptr noundef readonly captures(none) %a, p
; CHECK: LV: Scalar loop costs: 14.
; CHECK: Cost of 7 for VF 2: INTERLEAVE-GROUP with factor 2, ir<%arrayidx>
; CHECK: ir<%0> = load from index 0
-; CHECK: ir<%2> = load from index 1
+; CHECK: ir<%2> = load from index 1 (!alias.scope !93)
; CHECK: Cost of 7 for VF 2: INTERLEAVE-GROUP with factor 2, ir<%arrayidx1>
; CHECK: ir<%1> = load from index 0
-; CHECK: ir<%3> = load from index 1
+; CHECK: ir<%3> = load from index 1 (!alias.scope !94)
; CHECK: Cost of 7 for VF 2: INTERLEAVE-GROUP with factor 2, ir<%arrayidx3>
; CHECK: store ir<%add> to index 0
-; CHECK: store ir<%sub> to index 1
+; CHECK: store ir<%sub> to index 1 (!alias.scope !95, !noalias !92)
; CHECK: Cost for VF 2: 28 (Estimated cost per lane: 14)
; CHECK: Cost of 6 for VF 4: INTERLEAVE-GROUP with factor 2, ir<%arrayidx>
; CHECK: ir<%0> = load from index 0
-; CHECK: ir<%2> = load from index 1
+; CHECK: ir<%2> = load from index 1 (!alias.scope !93)
; CHECK: Cost of 6 for VF 4: INTERLEAVE-GROUP with factor 2, ir<%arrayidx1>
; CHECK: ir<%1> = load from index 0
-; CHECK: ir<%3> = load from index 1
+; CHECK: ir<%3> = load from index 1 (!alias.scope !94)
; CHECK: Cost of 6 for VF 4: INTERLEAVE-GROUP with factor 2, ir<%arrayidx3>
; CHECK: store ir<%add> to index 0
-; CHECK: store ir<%sub> to index 1
+; CHECK: store ir<%sub> to index 1 (!alias.scope !95, !noalias !92)
; CHECK: Cost for VF 4: 25 (Estimated cost per lane: 6.25)
; CHECK: LV: Selecting VF: 4.
;
@@ -2377,23 +2377,23 @@ for.body:
define hidden void @two_bytes_two_floats_same_op(ptr noundef readonly captures(none) %a, ptr noundef readonly captures(none) %b, ptr noundef writeonly captures(none) %res, i32 noundef %N) {
; CHECK-LABEL: 'two_bytes_two_floats_same_op'
; CHECK: LV: Scalar loop costs: 18.
-; CHECK: Cost of 6 for VF 2: REPLICATE ir<%0> = load ir<%arrayidx>
-; CHECK: Cost of 6 for VF 2: REPLICATE ir<%1> = load ir<%arrayidx1>
-; CHECK: Cost of 6 for VF 2: REPLICATE ir<%2> = load ir<%y>
-; CHECK: Cost of 6 for VF 2: REPLICATE ir<%3> = load ir<%y9>
+; CHECK: Cost of 6 for VF 2: REPLICATE ir<%0> = load ir<%arrayidx> (!alias.scope !104)
+; CHECK: Cost of 6 for VF 2: REPLICATE ir<%1> = load ir<%arrayidx1> (!alias.scope !105)
+; CHECK: Cost of 6 for VF 2: REPLICATE ir<%2> = load ir<%y> (!alias.scope !104)
+; CHECK: Cost of 6 for VF 2: REPLICATE ir<%3> = load ir<%y9> (!alias.scope !105)
; CHECK: Cost of 7 for VF 2: INTERLEAVE-GROUP with factor 2, ir<%arrayidx4>
; CHECK: store ir<%mul> to index 0
-; CHECK: store ir<%mul11> to index 1
+; CHECK: store ir<%mul11> to index 1 (!alias.scope !106, !noalias !103)
; CHECK: Cost for VF 2: 51 (Estimated cost per lane: 25.5)
; CHECK: Cost of 11 for VF 4: INTERLEAVE-GROUP with factor 2, ir<%arrayidx>
; CHECK: ir<%0> = load from index 0
-; CHECK: ir<%2> = load from index 1
+; CHECK: ir<%2> = load from index 1 (!alias.scope !104)
; CHECK: Cost of 11 for VF 4: INTERLEAVE-GROUP with factor 2, ir<%arrayidx1>
; CHECK: ir<%1> = load from index 0
-; CHECK: ir<%3> = load from index 1
+; CHECK: ir<%3> = load from index 1 (!alias.scope !105)
; CHECK: Cost of 6 for VF 4: INTERLEAVE-GROUP with factor 2, ir<%arrayidx4>
; CHECK: store ir<%mul> to index 0
-; CHECK: store ir<%mul11> to index 1
+; CHECK: store ir<%mul11> to index 1 (!alias.scope !106, !noalias !103)
; CHECK: Cost for VF 4: 47 (Estimated cost per lane: 11.8)
; CHECK: LV: Selecting VF: 4.
;
@@ -2432,23 +2432,23 @@ for.body:
define hidden void @two_bytes_two_floats_vary_op(ptr noundef readonly captures(none) %a, ptr noundef readonly captures(none) %b, ptr noundef writeonly captures(none) %res, i32 noundef %N) {
; CHECK-LABEL: 'two_bytes_two_floats_vary_op'
; CHECK: LV: Scalar loop costs: 18.
-; CHECK: Cost of 6 for VF 2: REPLICATE ir<%0> = load ir<%arrayidx>
-; CHECK: Cost of 6 for VF 2: REPLICATE ir<%1> = load ir<%arrayidx1>
-; CHECK: Cost of 6 for VF 2: REPLICATE ir<%2> = load ir<%y>
-; CHECK: Cost of 6 for VF 2: REPLICATE ir<%3> = load ir<%y9>
+; CHECK: Cost of 6 for VF 2: REPLICATE ir<%0> = load ir<%arrayidx> (!alias.scope !115)
+; CHECK: Cost of 6 for VF 2: REPLICATE ir<%1> = load ir<%arrayidx1> (!alias.scope !116)
+; CHECK: Cost of 6 for VF 2: REPLICATE ir<%2> = load ir<%y> (!alias.scope !115)
+; CHECK: Cost of 6 for VF 2: REPLICATE ir<%3> = load ir<%y9> (!alias.scope !116)
; CHECK: Cost of 7 for VF 2: INTERLEAVE-GROUP with factor 2, ir<%arrayidx4>
; CHECK: store ir<%add> to index 0
-; CHECK: store ir<%sub> to index 1
+; CHECK: store ir<%sub> to index 1 (!alias.scope !117, !noalias !114)
; CHECK: Cost for VF 2: 51 (Estimated cost per lane: 25.5)
; CHECK: Cost of 11 for VF 4: INTERLEAVE-GROUP with factor 2, ir<%arrayidx>
; CHECK: ir<%0> = load from index 0
-; CHECK: ir<%2> = load from index 1
+; CHECK: ir<%2> = load from index 1 (!alias.scope !115)
; CHECK: Cost of 11 for VF 4: INTERLEAVE-GROUP with factor 2, ir<%arrayidx1>
; CHECK: ir<%1> = load from index 0
-; CHECK: ir<%3> = load from index 1
+; CHECK: ir<%3> = load from index 1 (!alias.scope !116)
; CHECK: Cost of 6 for VF 4: INTERLEAVE-GROUP with factor 2, ir<%arrayidx4>
; CHECK: store ir<%add> to index 0
-; CHECK: store ir<%sub> to index 1
+; CHECK: store ir<%sub> to index 1 (!alias.scope !117, !noalias !114)
; CHECK: Cost for VF 4: 47 (Estimated cost per lane: 11.8)
; CHECK: LV: Selecting VF: 4.
;
@@ -2489,22 +2489,22 @@ define hidden void @two_floats_two_bytes_same_op(ptr noundef readonly captures(n
; CHECK: LV: Scalar loop costs: 16.
; CHECK: Cost of 7 for VF 2: INTERLEAVE-GROUP with factor 2, ir<%arrayidx>
; CHECK: ir<%0> = load from index 0
-; CHECK: ir<%2> = load from index 1
+; CHECK: ir<%2> = load from index 1 (!alias.scope !126)
; CHECK: Cost of 7 for VF 2: INTERLEAVE-GROUP with factor 2, ir<%arrayidx1>
; CHECK: ir<%1> = load from index 0
-; CHECK: ir<%3> = load from index 1
-; CHECK: Cost of 6 for VF 2: REPLICATE store ir<%conv>, ir<%arrayidx3>
-; CHECK: Cost of 6 for VF 2: REPLICATE store ir<%conv9>, ir<%y11>
+; CHECK: ir<%3> = load from index 1 (!alias.scope !127)
+; CHECK: Cost of 6 for VF 2: REPLICATE store ir<%conv>, ir<%arrayidx3> (!alias.scope !128, !noalias !125)
+; CHECK: Cost of 6 for VF 2: REPLICATE store ir<%conv9>, ir<%y11> (!alias.scope !128, !noalias !125)
; CHECK: Cost for VF 2: 46 (Estimated cost per lane: 23)
; CHECK: Cost of 6 for VF 4: INTERLEAVE-GROUP with factor 2, ir<%arrayidx>
; CHECK: ir<%0> = load from index 0
-; CHECK: ir<%2> = load from index 1
+; CHECK: ir<%2> = load from index 1 (!alias.scope !126)
; CHECK: Cost of 6 for VF 4: INTERLEAVE-GROUP with factor 2, ir<%arrayidx1>
; CHECK: ir<%1> = load from index 0
-; CHECK: ir<%3> = load from index 1
+; CHECK: ir<%3> = load from index 1 (!alias.scope !127)
; CHECK: Cost of 11 for VF 4: INTERLEAVE-GROUP with factor 2, ir<%arrayidx3>
; CHECK: store ir<%conv> to index 0
-; CHECK: store ir<%conv9> to index 1
+; CHECK: store ir<%conv9> to index 1 (!alias.scope !128, !noalias !125)
; CHECK: Cost for VF 4: 42 (Estimated cost per lane: 10.5)
; CHECK: LV: Selecting VF: 4.
;
@@ -2543,22 +2543,22 @@ define hidden void @two_floats_two_bytes_vary_op(ptr noundef readonly captures(n
; CHECK: LV: Scalar loop costs: 16.
; CHECK: Cost of 7 for VF 2: INTERLEAVE-GROUP with factor 2, ir<%arrayidx>
; CHECK: ir<%0> = load from index 0
-; CHECK: ir<%2> = load from index 1
+; CHECK: ir<%2> = load from index 1 (!alias.scope !137)
; CHECK: Cost of 7 for VF 2: INTERLEAVE-GROUP with factor 2, ir<%arrayidx1>
; CHECK: ir<%1> = load from index 0
-; CHECK: ir<%3> = load from index 1
-; CHECK: Cost of 6 for VF 2: REPLICATE store ir<%conv>, ir<%arrayidx3>
-; CHECK: Cost of 6 for VF 2: REPLICATE store ir<%conv8>, ir<%y10>
+; CHECK: ir<%3> = load from index 1 (!alias.scope !138)
+; CHECK: Cost of 6 for VF 2: REPLICATE store ir<%conv>, ir<%arrayidx3> (!alias.scope !139, !noalias !136)
+; CHECK: Cost of 6 for VF 2: REPLICATE store ir<%conv8>, ir<%y10> (!alias.scope !139, !noalias !136)
; CHECK: Cost for VF 2: 46 (Estimated cost per lane: 23)
; CHECK: Cost of 6 for VF 4: INTERLEAVE-GROUP with factor 2, ir<%arrayidx>
; CHECK: ir<%0> = load from index 0
-; CHECK: ir<%2> = load from index 1
+; CHECK: ir<%2> = load from index 1 (!alias.scope !137)
; CHECK: Cost of 6 for VF 4: INTERLEAVE-GROUP with factor 2, ir<%arrayidx1>
; CHECK: ir<%1> = load from index 0
-; CHECK: ir<%3> = load from index 1
+; CHECK: ir<%3> = load from index 1 (!alias.scope !138)
; CHECK: Cost of 11 for VF 4: INTERLEAVE-GROUP with factor 2, ir<%arrayidx3>
; CHECK: store ir<%conv> to index 0
-; CHECK: store ir<%conv8> to index 1
+; CHECK: store ir<%conv8> to index 1 (!alias.scope !139, !noalias !136)
; CHECK: Cost for VF 4: 42 (Estimated cost per lane: 10.5)
; CHECK: LV: Selecting VF: 4.
;
@@ -2597,23 +2597,23 @@ define hidden void @two_shorts_two_floats_same_op(ptr noundef readonly captures(
; CHECK: LV: Scalar loop costs: 18.
; CHECK: Cost of 11 for VF 2: INTERLEAVE-GROUP with factor 2, ir<%arrayidx>
; CHECK: ir<%0> = load from index 0
-; CHECK: ir<%2> = load from index 1
+; CHECK: ir<%2> = load from index 1 (!alias.scope !148)
; CHECK: Cost of 11 for VF 2: INTERLEAVE-GROUP with factor 2, ir<%arrayidx1>
; CHECK: ir<%1> = load from index 0
-; CHECK: ir<%3> = load from index 1
+; CHECK: ir<%3> = load from index 1 (!alias.scope !149)
; CHECK: Cost of 7 for VF 2: INTERLEAVE-GROUP with factor 2, ir<%arrayidx4>
; CHECK: store ir<%mul> to index 0
-; CHECK: store ir<%mul11> to index 1
+; CHECK: store ir<%mul11> to index 1 (!alias.scope !150, !noalias !147)
; CHECK: Cost for VF 2: 44 (Estimated cost per lane: 22)
; CHECK: Cost of 7 for VF 4: INTERLEAVE-GROUP with factor 2, ir<%arrayidx>
; CHECK: ir<%0> = load from index 0
-; CHECK: ir<%2> = load from index 1
+; CHECK: ir<%2> = load from index 1 (!alias.scope !148)
; CHECK: Cost of 7 for VF 4: INTERLEAVE-GROUP with factor 2, ir<%arrayidx1>
; CHECK: ir<%1> = load from index 0
-; CHECK: ir<%3> = load from index 1
+; CHECK: ir<%3> = load from index 1 (!alias.scope !149)
; CHECK: Cost of 6 for VF 4: INTERLEAVE-GROUP with factor 2, ir<%arrayidx4>
; CHECK: store ir<%mul> to index 0
-; CHECK: store ir<%mul11> to index 1
+; CHECK: store ir<%mul11> to index 1 (!alias.scope !150, !noalias !147)
; CHECK: Cost for VF 4: 35 (Estimated cost per lane: 8.75)
; CHECK: LV: Selecting VF: 4.
;
@@ -2654,23 +2654,23 @@ define hidden void @two_shorts_two_floats_vary_op(ptr noundef readonly captures(
; CHECK: LV: Scalar loop costs: 18.
; CHECK: Cost of 11 for VF 2: INTERLEAVE-GROUP with factor 2, ir<%arrayidx>
; CHECK: ir<%0> = load from index 0
-; CHECK: ir<%2> = load from index 1
+; CHECK: ir<%2> = load from index 1 (!alias.scope !159)
; CHECK: Cost of 11 for VF 2: INTERLEAVE-GROUP with factor 2, ir<%arrayidx1>
; CHECK: ir<%1> = load from index 0
-; CHECK: ir<%3> = load from index 1
+; CHECK: ir<%3> = load from index 1 (!alias.scope !160)
; CHECK: Cost of 7 for VF 2: INTERLEAVE-GROUP with factor 2, ir<%arrayidx4>
; CHECK: store ir<%add> to index 0
-; CHECK: store ir<%sub> to index 1
+; CHECK: store ir<%sub> to index 1 (!alias.scope !161, !noalias !158)
; CHECK: Cost for VF 2: 44 (Estimated cost per lane: 22)
; CHECK: Cost of 7 for VF 4: INTERLEAVE-GROUP with factor 2, ir<%arrayidx>
; CHECK: ir<%0> = load from index 0
-; CHECK: ir<%2> = load from index 1
+; CHECK: ir<%2> = load from index 1 (!alias.scope !159)
; CHECK: Cost of 7 for VF 4: INTERLEAVE-GROUP with factor 2, ir<%arrayidx1>
; CHECK: ir<%1> = load from index 0
-; CHECK: ir<%3> = load from index 1
+; CHECK: ir<%3> = load from index 1 (!alias.scope !160)
; CHECK: Cost of 6 for VF 4: INTERLEAVE-GROUP with factor 2, ir<%arrayidx4>
; CHECK: store ir<%add> to index 0
-; CHECK: store ir<%sub> to index 1
+; CHECK: store ir<%sub> to index 1 (!alias.scope !161, !noalias !158)
; CHECK: Cost for VF 4: 35 (Estimated cost per lane: 8.75)
; CHECK: LV: Selecting VF: 4.
;
@@ -2711,23 +2711,23 @@ define hidden void @two_floats_two_shorts_same_op(ptr noundef readonly captures(
; CHECK: LV: Scalar loop costs: 16.
; CHECK: Cost of 7 for VF 2: INTERLEAVE-GROUP with factor 2, ir<%arrayidx>
; CHECK: ir<%0> = load from index 0
-; CHECK: ir<%2> = load from index 1
+; CHECK: ir<%2> = load from index 1 (!alias.scope !170)
; CHECK: Cost of 7 for VF 2: INTERLEAVE-GROUP with factor 2, ir<%arrayidx1>
; CHECK: ir<%1> = load from index 0
-; CHECK: ir<%3> = load from index 1
+; CHECK: ir<%3> = load from index 1 (!alias.scope !171)
; CHECK: Cost of 11 for VF 2: INTERLEAVE-GROUP with factor 2, ir<%arrayidx3>
; CHECK: store ir<%conv> to index 0
-; CHECK: store ir<%conv9> to index 1
+; CHECK: store ir<%conv9> to index 1 (!alias.scope !172, !noalias !169)
; CHECK: Cost for VF 2: 40 (Estimated cost per lane: 20)
; CHECK: Cost of 6 for VF 4: INTERLEAVE-GROUP with factor 2, ir<%arrayidx>
; CHECK: ir<%0> = load from index 0
-; CHECK: ir<%2> = load from index 1
+; CHECK: ir<%2> = load from index 1 (!alias.scope !170)
; CHECK: Cost of 6 for VF 4: INTERLEAVE-GROUP with factor 2, ir<%arrayidx1>
; CHECK: ir<%1> = load from index 0
-; CHECK: ir<%3> = load from index 1
+; CHECK: ir<%3> = load from index 1 (!alias.scope !171)
; CHECK: Cost of 7 for VF 4: INTERLEAVE-GROUP with factor 2, ir<%arrayidx3>
; CHECK: store ir<%conv> to index 0
-; CHECK: store ir<%conv9> to index 1
+; CHECK: store ir<%conv9> to index 1 (!alias.scope !172, !noalias !169)
; CHECK: Cost for VF 4: 34 (Estimated cost per lane: 8.5)
; CHECK: LV: Selecting VF: 4.
;
@@ -2766,23 +2766,23 @@ define hidden void @two_floats_two_shorts_vary_op(ptr noundef readonly captures(
; CHECK: LV: Scalar loop costs: 16.
; CHECK: Cost of 7 for VF 2: INTERLEAVE-GROUP with factor 2, ir<%arrayidx>
; CHECK: ir<%0> = load from index 0
-; CHECK: ir<%2> = load from index 1
+; CHECK: ir<%2> = load from index 1 (!alias.scope !181)
; CHECK: Cost of 7 for VF 2: INTERLEAVE-GROUP with factor 2, ir<%arrayidx1>
; CHECK: ir<%1> = load from index 0
-; CHECK: ir<%3> = load from index 1
+; CHECK: ir<%3> = load from index 1 (!alias.scope !182)
; CHECK: Cost of 11 for VF 2: INTERLEAVE-GROUP with factor 2, ir<%arrayidx3>
; CHECK: store ir<%conv> to index 0
-; CHECK: store ir<%conv8> to index 1
+; CHECK: store ir<%conv8> to index 1 (!alias.scope !183, !noalias !180)
; CHECK: Cost for VF 2: 40 (Estimated cost per lane: 20)
; CHECK: Cost of 6 for VF 4: INTERLEAVE-GROUP with factor 2, ir<%arrayidx>
; CHECK: ir<%0> = load from index 0
-; CHECK: ir<%2> = load from index 1
+; CHECK: ir<%2> = load from index 1 (!alias.scope !181)
; CHECK: Cost of 6 for VF 4: INTERLEAVE-GROUP with factor 2, ir<%arrayidx1>
; CHECK: ir<%1> = load from index 0
-; CHECK: ir<%3> = load from index 1
+; CHECK: ir<%3> = load from index 1 (!alias.scope !182)
; CHECK: Cost of 7 for VF 4: INTERLEAVE-GROUP with factor 2, ir<%arrayidx3>
; CHECK: store ir<%conv> to index 0
-; CHECK: store ir<%conv8> to index 1
+; CHECK: store ir<%conv8> to index 1 (!alias.scope !183, !noalias !180)
; CHECK: Cost for VF 4: 34 (Estimated cost per lane: 8.5)
; CHECK: LV: Selecting VF: 4.
;
@@ -2823,17 +2823,17 @@ define hidden void @four_floats_same_op(ptr noundef readonly captures(none) %a,
; CHECK: ir<%0> = load from index 0
; CHECK: ir<%2> = load from index 1
; CHECK: ir<%4> = load from index 2
-; CHECK: ir<%6> = load from index 3
+; CHECK: ir<%6> = load from index 3 (!alias.scope !192)
; CHECK: Cost of 14 for VF 2: INTERLEAVE-GROUP with factor 4, ir<%arrayidx1>
; CHECK: ir<%1> = load from index 0
; CHECK: ir<%3> = load from index 1
; CHECK: ir<%5> = load from index 2
-; CHECK: ir<%7> = load from index 3
+; CHECK: ir<%7> = load from index 3 (!alias.scope !193)
; CHECK: Cost of 14 for VF 2: INTERLEAVE-GROUP with factor 4, ir<%arrayidx3>
; CHECK: store ir<%mul> to index 0
; CHECK: store ir<%mul8> to index 1
; CHECK: store ir<%mul14> to index 2
-; CHECK: store ir<%mul20> to index 3
+; CHECK: store ir<%mul20> to index 3 (!alias.scope !194, !noalias !191)
; CHECK: Cost for VF 2: 53 (Estimated cost per lane: 26.5)
; CHECK: Cost for VF 4: 11 (Estimated cost per lane: 2.75)
; CHECK: LV: Selecting VF: 4.
@@ -2887,33 +2887,33 @@ define hidden void @four_floats_vary_op(ptr noundef readonly captures(none) %a,
; CHECK: ir<%0> = load from index 0
; CHECK: ir<%2> = load from index 1
; CHECK: ir<%4> = load from index 2
-; CHECK: ir<%6> = load from index 3
+; CHECK: ir<%6> = load from index 3 (!alias.scope !203)
; CHECK: Cost of 14 for VF 2: INTERLEAVE-GROUP with factor 4, ir<%arrayidx1>
; CHECK: ir<%1> = load from index 0
; CHECK: ir<%3> = load from index 1
; CHECK: ir<%5> = load from index 2
-; CHECK: ir<%7> = load from index 3
+; CHECK: ir<%7> = load from index 3 (!alias.scope !204)
; CHECK: Cost of 14 for VF 2: INTERLEAVE-GROUP with factor 4, ir<%arrayidx3>
; CHECK: store ir<%add> to index 0
; CHECK: store ir<%sub> to index 1
; CHECK: store ir<%mul> to index 2
-; CHECK: store ir<%div> to index 3
+; CHECK: store ir<%div> to index 3 (!alias.scope !205, !noalias !202)
; CHECK: Cost for VF 2: 53 (Estimated cost per lane: 26.5)
; CHECK: Cost of 36 for VF 4: INTERLEAVE-GROUP with factor 4, ir<%arrayidx>
; CHECK: ir<%0> = load from index 0
; CHECK: ir<%2> = load from index 1
; CHECK: ir<%4> = load from index 2
-; CHECK: ir<%6> = load from index 3
+; CHECK: ir<%6> = load from index 3 (!alias.scope !203)
; CHECK: Cost of 36 for VF 4: INTERLEAVE-GROUP with factor 4, ir<%arrayidx1>
; CHECK: ir<%1> = load from index 0
; CHECK: ir<%3> = load from index 1
; CHECK: ir<%5> = load from index 2
-; CHECK: ir<%7> = load from index 3
+; CHECK: ir<%7> = load from index 3 (!alias.scope !204)
; CHECK: Cost of 36 for VF 4: INTERLEAVE-GROUP with factor 4, ir<%arrayidx3>
; CHECK: store ir<%add> to index 0
; CHECK: store ir<%sub> to index 1
; CHECK: store ir<%mul> to index 2
-; CHECK: store ir<%div> to index 3
+; CHECK: store ir<%div> to index 3 (!alias.scope !205, !noalias !202)
; CHECK: Cost for VF 4: 119 (Estimated cost per lane: 29.8)
; CHECK: LV: Selecting VF: 1.
;
@@ -2962,35 +2962,35 @@ for.body:
define hidden void @four_bytes_four_floats_same_op(ptr noundef readonly captures(none) %a, ptr noundef readonly captures(none) %b, ptr noundef writeonly captures(none) %res, i32 noundef %N) {
; CHECK-LABEL: 'four_bytes_four_floats_same_op'
; CHECK: LV: Scalar loop costs: 32.
-; CHECK: Cost of 6 for VF 2: REPLICATE ir<%0> = load ir<%arrayidx>
-; CHECK: Cost of 6 for VF 2: REPLICATE ir<%1> = load ir<%arrayidx1>
-; CHECK: Cost of 6 for VF 2: REPLICATE ir<%2> = load ir<%y>
-; CHECK: Cost of 6 for VF 2: REPLICATE ir<%3> = load ir<%y9>
-; CHECK: Cost of 6 for VF 2: REPLICATE ir<%4> = load ir<%z>
-; CHECK: Cost of 6 for VF 2: REPLICATE ir<%5> = load ir<%z17>
-; CHECK: Cost of 6 for VF 2: REPLICATE ir<%6> = load ir<%w>
-; CHECK: Cost of 6 for VF 2: REPLICATE ir<%7> = load ir<%w25>
+; CHECK: Cost of 6 for VF 2: REPLICATE ir<%0> = load ir<%arrayidx> (!alias.scope !211)
+; CHECK: Cost of 6 for VF 2: REPLICATE ir<%1> = load ir<%arrayidx1> (!alias.scope !212)
+; CHECK: Cost of 6 for VF 2: REPLICATE ir<%2> = load ir<%y> (!alias.scope !211)
+; CHECK: Cost of 6 for VF 2: REPLICATE ir<%3> = load ir<%y9> (!alias.scope !212)
+; CHECK: Cost of 6 for VF 2: REPLICATE ir<%4> = load ir<%z> (!alias.scope !211)
+; CHECK: Cost of 6 for VF 2: REPLICATE ir<%5> = load ir<%z17> (!alias.scope !212)
+; CHECK: Cost of 6 for VF 2: REPLICATE ir<%6> = load ir<%w> (!alias.scope !211)
+; CHECK: Cost of 6 for VF 2: REPLICATE ir<%7> = load ir<%w25> (!alias.scope !212)
; CHECK: Cost of 14 for VF 2: INTERLEAVE-GROUP with factor 4, ir<%arrayidx4>
; CHECK: store ir<%mul> to index 0
; CHECK: store ir<%mul11> to index 1
; CHECK: store ir<%mul19> to index 2
-; CHECK: store ir<%mul27> to index 3
+; CHECK: store ir<%mul27> to index 3 (!alias.scope !213, !noalias !210)
; CHECK: Cost for VF 2: 98 (Estimated cost per lane: 49)
; CHECK: Cost of 18 for VF 4: INTERLEAVE-GROUP with factor 4, ir<%arrayidx>
; CHECK: ir<%0> = load from index 0
; CHECK: ir<%2> = load from index 1
; CHECK: ir<%4> = load from index 2
-; CHECK: ir<%6> = load from index 3
+; CHECK: ir<%6> = load from index 3 (!alias.scope !211)
; CHECK: Cost of 18 for VF 4: INTERLEAVE-GROUP with factor 4, ir<%arrayidx1>
; CHECK: ir<%1> = load from index 0
; CHECK: ir<%3> = load from index 1
; CHECK: ir<%5> = load from index 2
-; CHECK: ir<%7> = load from index 3
+; CHECK: ir<%7> = load from index 3 (!alias.scope !212)
; CHECK: Cost of 36 for VF 4: INTERLEAVE-GROUP with factor 4, ir<%arrayidx4>
; CHECK: store ir<%mul> to index 0
; CHECK: store ir<%mul11> to index 1
; CHECK: store ir<%mul19> to index 2
-; CHECK: store ir<%mul27> to index 3
+; CHECK: store ir<%mul27> to index 3 (!alias.scope !213, !noalias !210)
; CHECK: Cost for VF 4: 107 (Estimated cost per lane: 26.8)
; CHECK: LV: Selecting VF: 4.
;
@@ -3047,35 +3047,35 @@ for.body:
define hidden void @four_bytes_four_floats_vary_op(ptr noundef readonly captures(none) %a, ptr noundef readonly captures(none) %b, ptr noundef writeonly captures(none) %res, i32 noundef %N) {
; CHECK-LABEL: 'four_bytes_four_floats_vary_op'
; CHECK: LV: Scalar loop costs: 32.
-; CHECK: Cost of 6 for VF 2: REPLICATE ir<%0> = load ir<%arrayidx>
-; CHECK: Cost of 6 for VF 2: REPLICATE ir<%1> = load ir<%arrayidx1>
-; CHECK: Cost of 6 for VF 2: REPLICATE ir<%2> = load ir<%y>
-; CHECK: Cost of 6 for VF 2: REPLICATE ir<%3> = load ir<%y9>
-; CHECK: Cost of 6 for VF 2: REPLICATE ir<%4> = load ir<%z>
-; CHECK: Cost of 6 for VF 2: REPLICATE ir<%5> = load ir<%z16>
-; CHECK: Cost of 6 for VF 2: REPLICATE ir<%6> = load ir<%w>
-; CHECK: Cost of 6 for VF 2: REPLICATE ir<%7> = load ir<%w23>
+; CHECK: Cost of 6 for VF 2: REPLICATE ir<%0> = load ir<%arrayidx> (!alias.scope !222)
+; CHECK: Cost of 6 for VF 2: REPLICATE ir<%1> = load ir<%arrayidx1> (!alias.scope !223)
+; CHECK: Cost of 6 for VF 2: REPLICATE ir<%2> = load ir<%y> (!alias.scope !222)
+; CHECK: Cost of 6 for VF 2: REPLICATE ir<%3> = load ir<%y9> (!alias.scope !223)
+; CHECK: Cost of 6 for VF 2: REPLICATE ir<%4> = load ir<%z> (!alias.scope !222)
+; CHECK: Cost of 6 for VF 2: REPLICATE ir<%5> = load ir<%z16> (!alias.scope !223)
+; CHECK: Cost of 6 for VF 2: REPLICATE ir<%6> = load ir<%w> (!alias.scope !222)
+; CHECK: Cost of 6 for VF 2: REPLICATE ir<%7> = load ir<%w23> (!alias.scope !223)
; CHECK: Cost of 14 for VF 2: INTERLEAVE-GROUP with factor 4, ir<%arrayidx4>
; CHECK: store ir<%mul> to index 0
; CHECK: store ir<%add> to index 1
; CHECK: store ir<%div> to index 2
-; CHECK: store ir<%sub> to index 3
+; CHECK: store ir<%sub> to index 3 (!alias.scope !224, !noalias !221)
; CHECK: Cost for VF 2: 98 (Estimated cost per lane: 49)
; CHECK: Cost of 18 for VF 4: INTERLEAVE-GROUP with factor 4, ir<%arrayidx>
; CHECK: ir<%0> = load from index 0
; CHECK: ir<%2> = load from index 1
; CHECK: ir<%4> = load from index 2
-; CHECK: ir<%6> = load from index 3
+; CHECK: ir<%6> = load from index 3 (!alias.scope !222)
; CHECK: Cost of 18 for VF 4: INTERLEAVE-GROUP with factor 4, ir<%arrayidx1>
; CHECK: ir<%1> = load from index 0
; CHECK: ir<%3> = load from index 1
; CHECK: ir<%5> = load from index 2
-; CHECK: ir<%7> = load from index 3
+; CHECK: ir<%7> = load from index 3 (!alias.scope !223)
; CHECK: Cost of 36 for VF 4: INTERLEAVE-GROUP with factor 4, ir<%arrayidx4>
; CHECK: store ir<%mul> to index 0
; CHECK: store ir<%add> to index 1
; CHECK: store ir<%div> to index 2
-; CHECK: store ir<%sub> to index 3
+; CHECK: store ir<%sub> to index 3 (!alias.scope !224, !noalias !221)
; CHECK: Cost for VF 4: 107 (Estimated cost per lane: 26.8)
; CHECK: LV: Selecting VF: 4.
;
@@ -3136,32 +3136,32 @@ define hidden void @four_floats_four_bytes_same_op(ptr noundef readonly captures
; CHECK: ir<%0> = load from index 0
; CHECK: ir<%2> = load from index 1
; CHECK: ir<%4> = load from index 2
-; CHECK: ir<%6> = load from index 3
+; CHECK: ir<%6> = load from index 3 (!alias.scope !233)
; CHECK: Cost of 14 for VF 2: INTERLEAVE-GROUP with factor 4, ir<%arrayidx1>
; CHECK: ir<%1> = load from index 0
; CHECK: ir<%3> = load from index 1
; CHECK: ir<%5> = load from index 2
-; CHECK: ir<%7> = load from index 3
-; CHECK: Cost of 6 for VF 2: REPLICATE store ir<%conv>, ir<%arrayidx3>
-; CHECK: Cost of 6 for VF 2: REPLICATE store ir<%conv9>, ir<%y11>
-; CHECK: Cost of 6 for VF 2: REPLICATE store ir<%conv16>, ir<%z18>
-; CHECK: Cost of 6 for VF 2: REPLICATE store ir<%conv23>, ir<%w25>
+; CHECK: ir<%7> = load from index 3 (!alias.scope !234)
+; CHECK: Cost of 6 for VF 2: REPLICATE store ir<%conv>, ir<%arrayidx3> (!alias.scope !235, !noalias !232)
+; CHECK: Cost of 6 for VF 2: REPLICATE store ir<%conv9>, ir<%y11> (!alias.scope !235, !noalias !232)
+; CHECK: Cost of 6 for VF 2: REPLICATE store ir<%conv16>, ir<%z18> (!alias.scope !235, !noalias !232)
+; CHECK: Cost of 6 for VF 2: REPLICATE store ir<%conv23>, ir<%w25> (!alias.scope !235, !noalias !232)
; CHECK: Cost for VF 2: 88 (Estimated cost per lane: 44)
; CHECK: Cost of 36 for VF 4: INTERLEAVE-GROUP with factor 4, ir<%arrayidx>
; CHECK: ir<%0> = load from index 0
; CHECK: ir<%2> = load from index 1
; CHECK: ir<%4> = load from index 2
-; CHECK: ir<%6> = load from index 3
+; CHECK: ir<%6> = load from index 3 (!alias.scope !233)
; CHECK: Cost of 36 for VF 4: INTERLEAVE-GROUP with factor 4, ir<%arrayidx1>
; CHECK: ir<%1> = load from index 0
; CHECK: ir<%3> = load from index 1
; CHECK: ir<%5> = load from index 2
-; CHECK: ir<%7> = load from index 3
+; CHECK: ir<%7> = load from index 3 (!alias.scope !234)
; CHECK: Cost of 18 for VF 4: INTERLEAVE-GROUP with factor 4, ir<%arrayidx3>
; CHECK: store ir<%conv> to index 0
; CHECK: store ir<%conv9> to index 1
; CHECK: store ir<%conv16> to index 2
-; CHECK: store ir<%conv23> to index 3
+; CHECK: store ir<%conv23> to index 3 (!alias.scope !235, !noalias !232)
; CHECK: Cost for VF 4: 125 (Estimated cost per lane: 31.3)
; CHECK: LV: Selecting VF: 1.
;
@@ -3218,32 +3218,32 @@ define hidden void @four_floats_four_bytes_vary_op(ptr noundef readonly captures
; CHECK: ir<%0> = load from index 0
; CHECK: ir<%2> = load from index 1
; CHECK: ir<%4> = load from index 2
-; CHECK: ir<%6> = load from index 3
+; CHECK: ir<%6> = load from index 3 (!alias.scope !241)
; CHECK: Cost of 14 for VF 2: INTERLEAVE-GROUP with factor 4, ir<%arrayidx1>
; CHECK: ir<%1> = load from index 0
; CHECK: ir<%3> = load from index 1
; CHECK: ir<%5> = load from index 2
-; CHECK: ir<%7> = load from index 3
-; CHECK: Cost of 6 for VF 2: REPLICATE store ir<%conv>, ir<%arrayidx3>
-; CHECK: Cost of 6 for VF 2: REPLICATE store ir<%conv8>, ir<%y10>
-; CHECK: Cost of 6 for VF 2: REPLICATE store ir<%conv14>, ir<%z16>
-; CHECK: Cost of 6 for VF 2: REPLICATE store ir<%conv20>, ir<%w22>
+; CHECK: ir<%7> = load from index 3 (!alias.scope !242)
+; CHECK: Cost of 6 for VF 2: REPLICATE store ir<%conv>, ir<%arrayidx3> (!alias.scope !243, !noalias !240)
+; CHECK: Cost of 6 for VF 2: REPLICATE store ir<%conv8>, ir<%y10> (!alias.scope !243, !noalias !240)
+; CHECK: Cost of 6 for VF 2: REPLICATE store ir<%conv14>, ir<%z16> (!alias.scope !243, !noalias !240)
+; CHECK: Cost of 6 for VF 2: REPLICATE store ir<%conv20>, ir<%w22> (!alias.scope !243, !noalias !240)
; CHECK: Cost for VF 2: 88 (Estimated cost per lane: 44)
; CHECK: Cost of 36 for VF 4: INTERLEAVE-GROUP with factor 4, ir<%arrayidx>
; CHECK: ir<%0> = load from index 0
; CHECK: ir<%2> = load from index 1
; CHECK: ir<%4> = load from index 2
-; CHECK: ir<%6> = load from index 3
+; CHECK: ir<%6> = load from index 3 (!alias.scope !241)
; CHECK: Cost of 36 for VF 4: INTERLEAVE-GROUP with factor 4, ir<%arrayidx1>
; CHECK: ir<%1> = load from index 0
; CHECK: ir<%3> = load from index 1
; CHECK: ir<%5> = load from index 2
-; CHECK: ir<%7> = load from index 3
+; CHECK: ir<%7> = load from index 3 (!alias.scope !242)
; CHECK: Cost of 18 for VF 4: INTERLEAVE-GROUP with factor 4, ir<%arrayidx3>
; CHECK: store ir<%conv> to index 0
; CHECK: store ir<%conv8> to index 1
; CHECK: store ir<%conv14> to index 2
-; CHECK: store ir<%conv20> to index 3
+; CHECK: store ir<%conv20> to index 3 (!alias.scope !243, !noalias !240)
; CHECK: Cost for VF 4: 125 (Estimated cost per lane: 31.3)
; CHECK: LV: Selecting VF: 1.
;
@@ -3300,33 +3300,33 @@ define hidden void @four_shorts_four_floats_same_op(ptr noundef readonly capture
; CHECK: ir<%0> = load from index 0
; CHECK: ir<%2> = load from index 1
; CHECK: ir<%4> = load from index 2
-; CHECK: ir<%6> = load from index 3
+; CHECK: ir<%6> = load from index 3 (!alias.scope !249)
; CHECK: Cost of 18 for VF 2: INTERLEAVE-GROUP with factor 4, ir<%arrayidx1>
; CHECK: ir<%1> = load from index 0
; CHECK: ir<%3> = load from index 1
; CHECK: ir<%5> = load from index 2
-; CHECK: ir<%7> = load from index 3
+; CHECK: ir<%7> = load from index 3 (!alias.scope !250)
; CHECK: Cost of 14 for VF 2: INTERLEAVE-GROUP with factor 4, ir<%arrayidx4>
; CHECK: store ir<%mul> to index 0
; CHECK: store ir<%mul11> to index 1
; CHECK: store ir<%mul19> to index 2
-; CHECK: store ir<%mul27> to index 3
+; CHECK: store ir<%mul27> to index 3 (!alias.scope !251, !noalias !248)
; CHECK: Cost for VF 2: 77 (Estimated cost per lane: 38.5)
; CHECK: Cost of 18 for VF 4: INTERLEAVE-GROUP with factor 4, ir<%arrayidx>
; CHECK: ir<%0> = load from index 0
; CHECK: ir<%2> = load from index 1
; CHECK: ir<%4> = load from index 2
-; CHECK: ir<%6> = load from index 3
+; CHECK: ir<%6> = load from index 3 (!alias.scope !249)
; CHECK: Cost of 18 for VF 4: INTERLEAVE-GROUP with factor 4, ir<%arrayidx1>
; CHECK: ir<%1> = load from index 0
; CHECK: ir<%3> = load from index 1
; CHECK: ir<%5> = load from index 2
-; CHECK: ir<%7> = load from index 3
+; CHECK: ir<%7> = load from index 3 (!alias.scope !250)
; CHECK: Cost of 36 for VF 4: INTERLEAVE-GROUP with factor 4, ir<%arrayidx4>
; CHECK: store ir<%mul> to index 0
; CHECK: store ir<%mul11> to index 1
; CHECK: store ir<%mul19> to index 2
-; CHECK: store ir<%mul27> to index 3
+; CHECK: store ir<%mul27> to index 3 (!alias.scope !251, !noalias !248)
; CHECK: Cost for VF 4: 99 (Estimated cost per lane: 24.8)
; CHECK: LV: Selecting VF: 4.
;
@@ -3387,33 +3387,33 @@ define hidden void @four_shorts_four_floats_vary_op(ptr noundef readonly capture
; CHECK: ir<%0> = load from index 0
; CHECK: ir<%2> = load from index 1
; CHECK: ir<%4> = load from index 2
-; CHECK: ir<%6> = load from index 3
+; CHECK: ir<%6> = load from index 3 (!alias.scope !260)
; CHECK: Cost of 18 for VF 2: INTERLEAVE-GROUP with factor 4, ir<%arrayidx1>
; CHECK: ir<%1> = load from index 0
; CHECK: ir<%3> = load from index 1
; CHECK: ir<%5> = load from index 2
-; CHECK: ir<%7> = load from index 3
+; CHECK: ir<%7> = load from index 3 (!alias.scope !261)
; CHECK: Cost of 14 for VF 2: INTERLEAVE-GROUP with factor 4, ir<%arrayidx4>
; CHECK: store ir<%mul> to index 0
; CHECK: store ir<%add> to index 1
; CHECK: store ir<%div> to index 2
-; CHECK: store ir<%sub> to index 3
+; CHECK: store ir<%sub> to index 3 (!alias.scope !262, !noalias !259)
; CHECK: Cost for VF 2: 77 (Estimated cost per lane: 38.5)
; CHECK: Cost of 18 for VF 4: INTERLEAVE-GROUP with factor 4, ir<%arrayidx>
; CHECK: ir<%0> = load from index 0
; CHECK: ir<%2> = load from index 1
; CHECK: ir<%4> = load from index 2
-; CHECK: ir<%6> = load from index 3
+; CHECK: ir<%6> = load from index 3 (!alias.scope !260)
; CHECK: Cost of 18 for VF 4: INTERLEAVE-GROUP with factor 4, ir<%arrayidx1>
; CHECK: ir<%1> = load from index 0
; CHECK: ir<%3> = load from index 1
; CHECK: ir<%5> = load from index 2
-; CHECK: ir<%7> = load from index 3
+; CHECK: ir<%7> = load from index 3 (!alias.scope !261)
; CHECK: Cost of 36 for VF 4: INTERLEAVE-GROUP with factor 4, ir<%arrayidx4>
; CHECK: store ir<%mul> to index 0
; CHECK: store ir<%add> to index 1
; CHECK: store ir<%div> to index 2
-; CHECK: store ir<%sub> to index 3
+; CHECK: store ir<%sub> to index 3 (!alias.scope !262, !noalias !259)
; CHECK: Cost for VF 4: 99 (Estimated cost per lane: 24.8)
; CHECK: LV: Selecting VF: 4.
;
@@ -3474,33 +3474,33 @@ define hidden void @four_floats_four_shorts_same_op(ptr noundef readonly capture
; CHECK: ir<%0> = load from index 0
; CHECK: ir<%2> = load from index 1
; CHECK: ir<%4> = load from index 2
-; CHECK: ir<%6> = load from index 3
+; CHECK: ir<%6> = load from index 3 (!alias.scope !271)
; CHECK: Cost of 14 for VF 2: INTERLEAVE-GROUP with factor 4, ir<%arrayidx1>
; CHECK: ir<%1> = load from index 0
; CHECK: ir<%3> = load from index 1
; CHECK: ir<%5> = load from index 2
-; CHECK: ir<%7> = load from index 3
+; CHECK: ir<%7> = load from index 3 (!alias.scope !272)
; CHECK: Cost of 18 for VF 2: INTERLEAVE-GROUP with factor 4, ir<%arrayidx3>
; CHECK: store ir<%conv> to index 0
; CHECK: store ir<%conv9> to index 1
; CHECK: store ir<%conv16> to index 2
-; CHECK: store ir<%conv23> to index 3
+; CHECK: store ir<%conv23> to index 3 (!alias.scope !273, !noalias !270)
; CHECK: Cost for VF 2: 73 (Estimated cost per lane: 36.5)
; CHECK: Cost of 36 for VF 4: INTERLEAVE-GROUP with factor 4, ir<%arrayidx>
; CHECK: ir<%0> = load from index 0
; CHECK: ir<%2> = load from index 1
; CHECK: ir<%4> = load from index 2
-; CHECK: ir<%6> = load from index 3
+; CHECK: ir<%6> = load from index 3 (!alias.scope !271)
; CHECK: Cost of 36 for VF 4: INTERLEAVE-GROUP with factor 4, ir<%arrayidx1>
; CHECK: ir<%1> = load from index 0
; CHECK: ir<%3> = load from index 1
; CHECK: ir<%5> = load from index 2
-; CHECK: ir<%7> = load from index 3
+; CHECK: ir<%7> = load from index 3 (!alias.scope !272)
; CHECK: Cost of 18 for VF 4: INTERLEAVE-GROUP with factor 4, ir<%arrayidx3>
; CHECK: store ir<%conv> to index 0
; CHECK: store ir<%conv9> to index 1
; CHECK: store ir<%conv16> to index 2
-; CHECK: store ir<%conv23> to index 3
+; CHECK: store ir<%conv23> to index 3 (!alias.scope !273, !noalias !270)
; CHECK: Cost for VF 4: 117 (Estimated cost per lane: 29.3)
; CHECK: LV: Selecting VF: 1.
;
@@ -3557,33 +3557,33 @@ define hidden void @four_floats_four_shorts_vary_op(ptr noundef readonly capture
; CHECK: ir<%0> = load from index 0
; CHECK: ir<%2> = load from index 1
; CHECK: ir<%4> = load from index 2
-; CHECK: ir<%6> = load from index 3
+; CHECK: ir<%6> = load from index 3 (!alias.scope !279)
; CHECK: Cost of 14 for VF 2: INTERLEAVE-GROUP with factor 4, ir<%arrayidx1>
; CHECK: ir<%1> = load from index 0
; CHECK: ir<%3> = load from index 1
; CHECK: ir<%5> = load from index 2
-; CHECK: ir<%7> = load from index 3
+; CHECK: ir<%7> = load from index 3 (!alias.scope !280)
; CHECK: Cost of 18 for VF 2: INTERLEAVE-GROUP with factor 4, ir<%arrayidx3>
; CHECK: store ir<%conv> to index 0
; CHECK: store ir<%conv8> to index 1
; CHECK: store ir<%conv14> to index 2
-; CHECK: store ir<%conv20> to index 3
+; CHECK: store ir<%conv20> to index 3 (!alias.scope !281, !noalias !278)
; CHECK: Cost for VF 2: 73 (Estimated cost per lane: 36.5)
; CHECK: Cost of 36 for VF 4: INTERLEAVE-GROUP with factor 4, ir<%arrayidx>
; CHECK: ir<%0> = load from index 0
; CHECK: ir<%2> = load from index 1
; CHECK: ir<%4> = load from index 2
-; CHECK: ir<%6> = load from index 3
+; CHECK: ir<%6> = load from index 3 (!alias.scope !279)
; CHECK: Cost of 36 for VF 4: INTERLEAVE-GROUP with factor 4, ir<%arrayidx1>
; CHECK: ir<%1> = load from index 0
; CHECK: ir<%3> = load from index 1
; CHECK: ir<%5> = load from index 2
-; CHECK: ir<%7> = load from index 3
+; CHECK: ir<%7> = load from index 3 (!alias.scope !280)
; CHECK: Cost of 18 for VF 4: INTERLEAVE-GROUP with factor 4, ir<%arrayidx3>
; CHECK: store ir<%conv> to index 0
; CHECK: store ir<%conv8> to index 1
; CHECK: store ir<%conv14> to index 2
-; CHECK: store ir<%conv20> to index 3
+; CHECK: store ir<%conv20> to index 3 (!alias.scope !281, !noalias !278)
; CHECK: Cost for VF 4: 117 (Estimated cost per lane: 29.3)
; CHECK: LV: Selecting VF: 1.
;
diff --git a/llvm/test/Transforms/LoopVectorize/X86/CostModel/masked-load-i16.ll b/llvm/test/Transforms/LoopVectorize/X86/CostModel/masked-load-i16.ll
index 9cb0e482da47c..c09fccc41f7f4 100644
--- a/llvm/test/Transforms/LoopVectorize/X86/CostModel/masked-load-i16.ll
+++ b/llvm/test/Transforms/LoopVectorize/X86/CostModel/masked-load-i16.ll
@@ -1,10 +1,10 @@
; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py UTC_ARGS: --filter "LV: Found an estimated cost of [0-9]+(.[0-9]+)? for VF [0-9]+ For instruction:\s*%valB.loaded = load i16, ptr %inB, align 2" --filter "Cost of [0-9]+(.[0-9]+)? for VF [0-9]+: .* ir<%valB.loaded> = load"
-; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+sse2 --debug-only=loop-vectorize --disable-output -vplan-print-metadata=false < %s 2>&1 | FileCheck %s --check-prefixes=SSE
-; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+sse4.2 --debug-only=loop-vectorize --disable-output -vplan-print-metadata=false < %s 2>&1 | FileCheck %s --check-prefixes=SSE
-; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+avx --debug-only=loop-vectorize --disable-output -vplan-print-metadata=false < %s 2>&1 | FileCheck %s --check-prefixes=AVX1
-; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+avx2,-fast-gather --debug-only=loop-vectorize --disable-output -vplan-print-metadata=false < %s 2>&1 | FileCheck %s --check-prefixes=AVX2
-; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+avx2,+fast-gather --debug-only=loop-vectorize --disable-output -vplan-print-metadata=false < %s 2>&1 | FileCheck %s --check-prefixes=AVX2
-; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+avx512bw --debug-only=loop-vectorize --disable-output -vplan-print-metadata=false < %s 2>&1 | FileCheck %s --check-prefixes=AVX512
+; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+sse2 --debug-only=loop-vectorize --disable-output < %s 2>&1 | FileCheck %s --check-prefixes=SSE
+; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+sse4.2 --debug-only=loop-vectorize --disable-output < %s 2>&1 | FileCheck %s --check-prefixes=SSE
+; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+avx --debug-only=loop-vectorize --disable-output < %s 2>&1 | FileCheck %s --check-prefixes=AVX1
+; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+avx2,-fast-gather --debug-only=loop-vectorize --disable-output < %s 2>&1 | FileCheck %s --check-prefixes=AVX2
+; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+avx2,+fast-gather --debug-only=loop-vectorize --disable-output < %s 2>&1 | FileCheck %s --check-prefixes=AVX2
+; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+avx512bw --debug-only=loop-vectorize --disable-output < %s 2>&1 | FileCheck %s --check-prefixes=AVX512
; REQUIRES: asserts
@@ -17,35 +17,35 @@ target triple = "x86_64-unknown-linux-gnu"
define void @test(ptr %B) {
; SSE-LABEL: 'test'
; SSE: LV: Found an estimated cost of 1 for VF 1 For instruction: %valB.loaded = load i16, ptr %inB, align 2
-; SSE: Cost of 3000000 for VF 2: REPLICATE ir<%valB.loaded> = load ir<%inB> (S->V)
-; SSE: Cost of 3000000 for VF 4: REPLICATE ir<%valB.loaded> = load ir<%inB> (S->V)
-; SSE: Cost of 3000000 for VF 8: REPLICATE ir<%valB.loaded> = load ir<%inB> (S->V)
-; SSE: Cost of 3000000 for VF 16: REPLICATE ir<%valB.loaded> = load ir<%inB> (S->V)
+; SSE: Cost of 3000000 for VF 2: REPLICATE ir<%valB.loaded> = load ir<%inB> (S->V) (!alias.scope !7)
+; SSE: Cost of 3000000 for VF 4: REPLICATE ir<%valB.loaded> = load ir<%inB> (S->V) (!alias.scope !7)
+; SSE: Cost of 3000000 for VF 8: REPLICATE ir<%valB.loaded> = load ir<%inB> (S->V) (!alias.scope !7)
+; SSE: Cost of 3000000 for VF 16: REPLICATE ir<%valB.loaded> = load ir<%inB> (S->V) (!alias.scope !7)
;
; AVX1-LABEL: 'test'
; AVX1: LV: Found an estimated cost of 1 for VF 1 For instruction: %valB.loaded = load i16, ptr %inB, align 2
-; AVX1: Cost of 3000000 for VF 2: REPLICATE ir<%valB.loaded> = load ir<%inB> (S->V)
-; AVX1: Cost of 3000000 for VF 4: REPLICATE ir<%valB.loaded> = load ir<%inB> (S->V)
-; AVX1: Cost of 3000000 for VF 8: REPLICATE ir<%valB.loaded> = load ir<%inB> (S->V)
-; AVX1: Cost of 3000000 for VF 16: REPLICATE ir<%valB.loaded> = load ir<%inB> (S->V)
-; AVX1: Cost of 3000000 for VF 32: REPLICATE ir<%valB.loaded> = load ir<%inB> (S->V)
+; AVX1: Cost of 3000000 for VF 2: REPLICATE ir<%valB.loaded> = load ir<%inB> (S->V) (!alias.scope !7)
+; AVX1: Cost of 3000000 for VF 4: REPLICATE ir<%valB.loaded> = load ir<%inB> (S->V) (!alias.scope !7)
+; AVX1: Cost of 3000000 for VF 8: REPLICATE ir<%valB.loaded> = load ir<%inB> (S->V) (!alias.scope !7)
+; AVX1: Cost of 3000000 for VF 16: REPLICATE ir<%valB.loaded> = load ir<%inB> (S->V) (!alias.scope !7)
+; AVX1: Cost of 3000000 for VF 32: REPLICATE ir<%valB.loaded> = load ir<%inB> (S->V) (!alias.scope !7)
;
; AVX2-LABEL: 'test'
; AVX2: LV: Found an estimated cost of 1 for VF 1 For instruction: %valB.loaded = load i16, ptr %inB, align 2
-; AVX2: Cost of 3000000 for VF 2: REPLICATE ir<%valB.loaded> = load ir<%inB> (S->V)
-; AVX2: Cost of 3000000 for VF 4: REPLICATE ir<%valB.loaded> = load ir<%inB> (S->V)
-; AVX2: Cost of 3000000 for VF 8: REPLICATE ir<%valB.loaded> = load ir<%inB> (S->V)
-; AVX2: Cost of 3000000 for VF 16: REPLICATE ir<%valB.loaded> = load ir<%inB> (S->V)
-; AVX2: Cost of 3000000 for VF 32: REPLICATE ir<%valB.loaded> = load ir<%inB> (S->V)
+; AVX2: Cost of 3000000 for VF 2: REPLICATE ir<%valB.loaded> = load ir<%inB> (S->V) (!alias.scope !7)
+; AVX2: Cost of 3000000 for VF 4: REPLICATE ir<%valB.loaded> = load ir<%inB> (S->V) (!alias.scope !7)
+; AVX2: Cost of 3000000 for VF 8: REPLICATE ir<%valB.loaded> = load ir<%inB> (S->V) (!alias.scope !7)
+; AVX2: Cost of 3000000 for VF 16: REPLICATE ir<%valB.loaded> = load ir<%inB> (S->V) (!alias.scope !7)
+; AVX2: Cost of 3000000 for VF 32: REPLICATE ir<%valB.loaded> = load ir<%inB> (S->V) (!alias.scope !7)
;
; AVX512-LABEL: 'test'
; AVX512: LV: Found an estimated cost of 1 for VF 1 For instruction: %valB.loaded = load i16, ptr %inB, align 2
-; AVX512: Cost of 2 for VF 2: WIDEN ir<%valB.loaded> = load vp<[[VP6:%[0-9]+]]>, ir<%canLoad>
-; AVX512: Cost of 2 for VF 4: WIDEN ir<%valB.loaded> = load vp<[[VP6]]>, ir<%canLoad>
-; AVX512: Cost of 1 for VF 8: WIDEN ir<%valB.loaded> = load vp<[[VP6]]>, ir<%canLoad>
-; AVX512: Cost of 1 for VF 16: WIDEN ir<%valB.loaded> = load vp<[[VP6]]>, ir<%canLoad>
-; AVX512: Cost of 1 for VF 32: WIDEN ir<%valB.loaded> = load vp<[[VP6]]>, ir<%canLoad>
-; AVX512: Cost of 2 for VF 64: WIDEN ir<%valB.loaded> = load vp<[[VP6]]>, ir<%canLoad>
+; AVX512: Cost of 2 for VF 2: WIDEN ir<%valB.loaded> = load vp<[[VP6:%[0-9]+]]>, ir<%canLoad> (!alias.scope !7, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
+; AVX512: Cost of 2 for VF 4: WIDEN ir<%valB.loaded> = load vp<[[VP6]]>, ir<%canLoad> (!alias.scope !7, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
+; AVX512: Cost of 1 for VF 8: WIDEN ir<%valB.loaded> = load vp<[[VP6]]>, ir<%canLoad> (!alias.scope !7, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
+; AVX512: Cost of 1 for VF 16: WIDEN ir<%valB.loaded> = load vp<[[VP6]]>, ir<%canLoad> (!alias.scope !7, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
+; AVX512: Cost of 1 for VF 32: WIDEN ir<%valB.loaded> = load vp<[[VP6]]>, ir<%canLoad> (!alias.scope !7, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
+; AVX512: Cost of 2 for VF 64: WIDEN ir<%valB.loaded> = load vp<[[VP6]]>, ir<%canLoad> (!alias.scope !7, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
;
entry:
br label %for.body
diff --git a/llvm/test/Transforms/LoopVectorize/X86/CostModel/masked-load-i32.ll b/llvm/test/Transforms/LoopVectorize/X86/CostModel/masked-load-i32.ll
index fc42ce6e6f73f..a982916b9133b 100644
--- a/llvm/test/Transforms/LoopVectorize/X86/CostModel/masked-load-i32.ll
+++ b/llvm/test/Transforms/LoopVectorize/X86/CostModel/masked-load-i32.ll
@@ -1,10 +1,10 @@
; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py UTC_ARGS: --filter "LV: Found an estimated cost of [0-9]+(.[0-9]+)? for VF [0-9]+ For instruction:\s*%valB.loaded = load i32, ptr %inB, align 4" --filter "Cost of [0-9]+(.[0-9]+)? for VF [0-9]+: .* ir<%valB.loaded> = load"
-; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+sse2 --debug-only=loop-vectorize --disable-output -vplan-print-metadata=false < %s 2>&1 | FileCheck %s --check-prefixes=SSE
-; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+sse4.2 --debug-only=loop-vectorize --disable-output -vplan-print-metadata=false < %s 2>&1 | FileCheck %s --check-prefixes=SSE
-; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+avx --debug-only=loop-vectorize --disable-output -vplan-print-metadata=false < %s 2>&1 | FileCheck %s --check-prefixes=AVX1
-; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+avx2,-fast-gather --debug-only=loop-vectorize --disable-output -vplan-print-metadata=false < %s 2>&1 | FileCheck %s --check-prefixes=AVX2
-; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+avx2,+fast-gather --debug-only=loop-vectorize --disable-output -vplan-print-metadata=false < %s 2>&1 | FileCheck %s --check-prefixes=AVX2
-; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+avx512bw --debug-only=loop-vectorize --disable-output -vplan-print-metadata=false < %s 2>&1 | FileCheck %s --check-prefixes=AVX512
+; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+sse2 --debug-only=loop-vectorize --disable-output < %s 2>&1 | FileCheck %s --check-prefixes=SSE
+; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+sse4.2 --debug-only=loop-vectorize --disable-output < %s 2>&1 | FileCheck %s --check-prefixes=SSE
+; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+avx --debug-only=loop-vectorize --disable-output < %s 2>&1 | FileCheck %s --check-prefixes=AVX1
+; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+avx2,-fast-gather --debug-only=loop-vectorize --disable-output < %s 2>&1 | FileCheck %s --check-prefixes=AVX2
+; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+avx2,+fast-gather --debug-only=loop-vectorize --disable-output < %s 2>&1 | FileCheck %s --check-prefixes=AVX2
+; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+avx512bw --debug-only=loop-vectorize --disable-output < %s 2>&1 | FileCheck %s --check-prefixes=AVX512
; REQUIRES: asserts
@@ -17,35 +17,35 @@ target triple = "x86_64-unknown-linux-gnu"
define void @test(ptr %B) {
; SSE-LABEL: 'test'
; SSE: LV: Found an estimated cost of 1 for VF 1 For instruction: %valB.loaded = load i32, ptr %inB, align 4
-; SSE: Cost of 3000000 for VF 2: REPLICATE ir<%valB.loaded> = load ir<%inB> (S->V)
-; SSE: Cost of 3000000 for VF 4: REPLICATE ir<%valB.loaded> = load ir<%inB> (S->V)
-; SSE: Cost of 3000000 for VF 8: REPLICATE ir<%valB.loaded> = load ir<%inB> (S->V)
-; SSE: Cost of 3000000 for VF 16: REPLICATE ir<%valB.loaded> = load ir<%inB> (S->V)
+; SSE: Cost of 3000000 for VF 2: REPLICATE ir<%valB.loaded> = load ir<%inB> (S->V) (!alias.scope !7)
+; SSE: Cost of 3000000 for VF 4: REPLICATE ir<%valB.loaded> = load ir<%inB> (S->V) (!alias.scope !7)
+; SSE: Cost of 3000000 for VF 8: REPLICATE ir<%valB.loaded> = load ir<%inB> (S->V) (!alias.scope !7)
+; SSE: Cost of 3000000 for VF 16: REPLICATE ir<%valB.loaded> = load ir<%inB> (S->V) (!alias.scope !7)
;
; AVX1-LABEL: 'test'
; AVX1: LV: Found an estimated cost of 1 for VF 1 For instruction: %valB.loaded = load i32, ptr %inB, align 4
-; AVX1: Cost of 3 for VF 2: WIDEN ir<%valB.loaded> = load vp<[[VP6:%[0-9]+]]>, ir<%canLoad>
-; AVX1: Cost of 2 for VF 4: WIDEN ir<%valB.loaded> = load vp<[[VP6]]>, ir<%canLoad>
-; AVX1: Cost of 2 for VF 8: WIDEN ir<%valB.loaded> = load vp<[[VP6]]>, ir<%canLoad>
-; AVX1: Cost of 4 for VF 16: WIDEN ir<%valB.loaded> = load vp<[[VP6]]>, ir<%canLoad>
-; AVX1: Cost of 8 for VF 32: WIDEN ir<%valB.loaded> = load vp<[[VP6]]>, ir<%canLoad>
+; AVX1: Cost of 3 for VF 2: WIDEN ir<%valB.loaded> = load vp<[[VP6:%[0-9]+]]>, ir<%canLoad> (!alias.scope !7, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
+; AVX1: Cost of 2 for VF 4: WIDEN ir<%valB.loaded> = load vp<[[VP6]]>, ir<%canLoad> (!alias.scope !7, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
+; AVX1: Cost of 2 for VF 8: WIDEN ir<%valB.loaded> = load vp<[[VP6]]>, ir<%canLoad> (!alias.scope !7, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
+; AVX1: Cost of 4 for VF 16: WIDEN ir<%valB.loaded> = load vp<[[VP6]]>, ir<%canLoad> (!alias.scope !7, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
+; AVX1: Cost of 8 for VF 32: WIDEN ir<%valB.loaded> = load vp<[[VP6]]>, ir<%canLoad> (!alias.scope !7, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
;
; AVX2-LABEL: 'test'
; AVX2: LV: Found an estimated cost of 1 for VF 1 For instruction: %valB.loaded = load i32, ptr %inB, align 4
-; AVX2: Cost of 3 for VF 2: WIDEN ir<%valB.loaded> = load vp<[[VP6:%[0-9]+]]>, ir<%canLoad>
-; AVX2: Cost of 2 for VF 4: WIDEN ir<%valB.loaded> = load vp<[[VP6]]>, ir<%canLoad>
-; AVX2: Cost of 2 for VF 8: WIDEN ir<%valB.loaded> = load vp<[[VP6]]>, ir<%canLoad>
-; AVX2: Cost of 4 for VF 16: WIDEN ir<%valB.loaded> = load vp<[[VP6]]>, ir<%canLoad>
-; AVX2: Cost of 8 for VF 32: WIDEN ir<%valB.loaded> = load vp<[[VP6]]>, ir<%canLoad>
+; AVX2: Cost of 3 for VF 2: WIDEN ir<%valB.loaded> = load vp<[[VP6:%[0-9]+]]>, ir<%canLoad> (!alias.scope !7, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
+; AVX2: Cost of 2 for VF 4: WIDEN ir<%valB.loaded> = load vp<[[VP6]]>, ir<%canLoad> (!alias.scope !7, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
+; AVX2: Cost of 2 for VF 8: WIDEN ir<%valB.loaded> = load vp<[[VP6]]>, ir<%canLoad> (!alias.scope !7, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
+; AVX2: Cost of 4 for VF 16: WIDEN ir<%valB.loaded> = load vp<[[VP6]]>, ir<%canLoad> (!alias.scope !7, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
+; AVX2: Cost of 8 for VF 32: WIDEN ir<%valB.loaded> = load vp<[[VP6]]>, ir<%canLoad> (!alias.scope !7, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
;
; AVX512-LABEL: 'test'
; AVX512: LV: Found an estimated cost of 1 for VF 1 For instruction: %valB.loaded = load i32, ptr %inB, align 4
-; AVX512: Cost of 2 for VF 2: WIDEN ir<%valB.loaded> = load vp<[[VP6:%[0-9]+]]>, ir<%canLoad>
-; AVX512: Cost of 1 for VF 4: WIDEN ir<%valB.loaded> = load vp<[[VP6]]>, ir<%canLoad>
-; AVX512: Cost of 1 for VF 8: WIDEN ir<%valB.loaded> = load vp<[[VP6]]>, ir<%canLoad>
-; AVX512: Cost of 1 for VF 16: WIDEN ir<%valB.loaded> = load vp<[[VP6]]>, ir<%canLoad>
-; AVX512: Cost of 2 for VF 32: WIDEN ir<%valB.loaded> = load vp<[[VP6]]>, ir<%canLoad>
-; AVX512: Cost of 4 for VF 64: WIDEN ir<%valB.loaded> = load vp<[[VP6]]>, ir<%canLoad>
+; AVX512: Cost of 2 for VF 2: WIDEN ir<%valB.loaded> = load vp<[[VP6:%[0-9]+]]>, ir<%canLoad> (!alias.scope !7, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
+; AVX512: Cost of 1 for VF 4: WIDEN ir<%valB.loaded> = load vp<[[VP6]]>, ir<%canLoad> (!alias.scope !7, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
+; AVX512: Cost of 1 for VF 8: WIDEN ir<%valB.loaded> = load vp<[[VP6]]>, ir<%canLoad> (!alias.scope !7, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
+; AVX512: Cost of 1 for VF 16: WIDEN ir<%valB.loaded> = load vp<[[VP6]]>, ir<%canLoad> (!alias.scope !7, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
+; AVX512: Cost of 2 for VF 32: WIDEN ir<%valB.loaded> = load vp<[[VP6]]>, ir<%canLoad> (!alias.scope !7, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
+; AVX512: Cost of 4 for VF 64: WIDEN ir<%valB.loaded> = load vp<[[VP6]]>, ir<%canLoad> (!alias.scope !7, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
;
entry:
br label %for.body
diff --git a/llvm/test/Transforms/LoopVectorize/X86/CostModel/masked-load-i64.ll b/llvm/test/Transforms/LoopVectorize/X86/CostModel/masked-load-i64.ll
index 48c9b01beb888..6886b40542684 100644
--- a/llvm/test/Transforms/LoopVectorize/X86/CostModel/masked-load-i64.ll
+++ b/llvm/test/Transforms/LoopVectorize/X86/CostModel/masked-load-i64.ll
@@ -1,10 +1,10 @@
; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py UTC_ARGS: --filter "LV: Found an estimated cost of [0-9]+(.[0-9]+)? for VF [0-9]+ For instruction:\s*%valB.loaded = load i64, ptr %inB, align 8" --filter "Cost of [0-9]+(.[0-9]+)? for VF [0-9]+: .* ir<%valB.loaded> = load"
-; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+sse2 --debug-only=loop-vectorize --disable-output -vplan-print-metadata=false < %s 2>&1 | FileCheck %s --check-prefixes=SSE
-; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+sse4.2 --debug-only=loop-vectorize --disable-output -vplan-print-metadata=false < %s 2>&1 | FileCheck %s --check-prefixes=SSE
-; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+avx --debug-only=loop-vectorize --disable-output -vplan-print-metadata=false < %s 2>&1 | FileCheck %s --check-prefixes=AVX1
-; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+avx2,-fast-gather --debug-only=loop-vectorize --disable-output -vplan-print-metadata=false < %s 2>&1 | FileCheck %s --check-prefixes=AVX2
-; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+avx2,+fast-gather --debug-only=loop-vectorize --disable-output -vplan-print-metadata=false < %s 2>&1 | FileCheck %s --check-prefixes=AVX2
-; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+avx512bw --debug-only=loop-vectorize --disable-output -vplan-print-metadata=false < %s 2>&1 | FileCheck %s --check-prefixes=AVX512
+; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+sse2 --debug-only=loop-vectorize --disable-output < %s 2>&1 | FileCheck %s --check-prefixes=SSE
+; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+sse4.2 --debug-only=loop-vectorize --disable-output < %s 2>&1 | FileCheck %s --check-prefixes=SSE
+; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+avx --debug-only=loop-vectorize --disable-output < %s 2>&1 | FileCheck %s --check-prefixes=AVX1
+; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+avx2,-fast-gather --debug-only=loop-vectorize --disable-output < %s 2>&1 | FileCheck %s --check-prefixes=AVX2
+; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+avx2,+fast-gather --debug-only=loop-vectorize --disable-output < %s 2>&1 | FileCheck %s --check-prefixes=AVX2
+; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+avx512bw --debug-only=loop-vectorize --disable-output < %s 2>&1 | FileCheck %s --check-prefixes=AVX512
; REQUIRES: asserts
@@ -17,35 +17,35 @@ target triple = "x86_64-unknown-linux-gnu"
define void @test(ptr %B) {
; SSE-LABEL: 'test'
; SSE: LV: Found an estimated cost of 1 for VF 1 For instruction: %valB.loaded = load i64, ptr %inB, align 8
-; SSE: Cost of 3000000 for VF 2: REPLICATE ir<%valB.loaded> = load ir<%inB> (S->V)
-; SSE: Cost of 3000000 for VF 4: REPLICATE ir<%valB.loaded> = load ir<%inB> (S->V)
-; SSE: Cost of 3000000 for VF 8: REPLICATE ir<%valB.loaded> = load ir<%inB> (S->V)
-; SSE: Cost of 3000000 for VF 16: REPLICATE ir<%valB.loaded> = load ir<%inB> (S->V)
+; SSE: Cost of 3000000 for VF 2: REPLICATE ir<%valB.loaded> = load ir<%inB> (S->V) (!alias.scope !7)
+; SSE: Cost of 3000000 for VF 4: REPLICATE ir<%valB.loaded> = load ir<%inB> (S->V) (!alias.scope !7)
+; SSE: Cost of 3000000 for VF 8: REPLICATE ir<%valB.loaded> = load ir<%inB> (S->V) (!alias.scope !7)
+; SSE: Cost of 3000000 for VF 16: REPLICATE ir<%valB.loaded> = load ir<%inB> (S->V) (!alias.scope !7)
;
; AVX1-LABEL: 'test'
; AVX1: LV: Found an estimated cost of 1 for VF 1 For instruction: %valB.loaded = load i64, ptr %inB, align 8
-; AVX1: Cost of 2 for VF 2: WIDEN ir<%valB.loaded> = load vp<[[VP6:%[0-9]+]]>, ir<%canLoad>
-; AVX1: Cost of 2 for VF 4: WIDEN ir<%valB.loaded> = load vp<[[VP6]]>, ir<%canLoad>
-; AVX1: Cost of 4 for VF 8: WIDEN ir<%valB.loaded> = load vp<[[VP6]]>, ir<%canLoad>
-; AVX1: Cost of 8 for VF 16: WIDEN ir<%valB.loaded> = load vp<[[VP6]]>, ir<%canLoad>
-; AVX1: Cost of 16 for VF 32: WIDEN ir<%valB.loaded> = load vp<[[VP6]]>, ir<%canLoad>
+; AVX1: Cost of 2 for VF 2: WIDEN ir<%valB.loaded> = load vp<[[VP6:%[0-9]+]]>, ir<%canLoad> (!alias.scope !7, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
+; AVX1: Cost of 2 for VF 4: WIDEN ir<%valB.loaded> = load vp<[[VP6]]>, ir<%canLoad> (!alias.scope !7, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
+; AVX1: Cost of 4 for VF 8: WIDEN ir<%valB.loaded> = load vp<[[VP6]]>, ir<%canLoad> (!alias.scope !7, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
+; AVX1: Cost of 8 for VF 16: WIDEN ir<%valB.loaded> = load vp<[[VP6]]>, ir<%canLoad> (!alias.scope !7, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
+; AVX1: Cost of 16 for VF 32: WIDEN ir<%valB.loaded> = load vp<[[VP6]]>, ir<%canLoad> (!alias.scope !7, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
;
; AVX2-LABEL: 'test'
; AVX2: LV: Found an estimated cost of 1 for VF 1 For instruction: %valB.loaded = load i64, ptr %inB, align 8
-; AVX2: Cost of 2 for VF 2: WIDEN ir<%valB.loaded> = load vp<[[VP6:%[0-9]+]]>, ir<%canLoad>
-; AVX2: Cost of 2 for VF 4: WIDEN ir<%valB.loaded> = load vp<[[VP6]]>, ir<%canLoad>
-; AVX2: Cost of 4 for VF 8: WIDEN ir<%valB.loaded> = load vp<[[VP6]]>, ir<%canLoad>
-; AVX2: Cost of 8 for VF 16: WIDEN ir<%valB.loaded> = load vp<[[VP6]]>, ir<%canLoad>
-; AVX2: Cost of 16 for VF 32: WIDEN ir<%valB.loaded> = load vp<[[VP6]]>, ir<%canLoad>
+; AVX2: Cost of 2 for VF 2: WIDEN ir<%valB.loaded> = load vp<[[VP6:%[0-9]+]]>, ir<%canLoad> (!alias.scope !7, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
+; AVX2: Cost of 2 for VF 4: WIDEN ir<%valB.loaded> = load vp<[[VP6]]>, ir<%canLoad> (!alias.scope !7, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
+; AVX2: Cost of 4 for VF 8: WIDEN ir<%valB.loaded> = load vp<[[VP6]]>, ir<%canLoad> (!alias.scope !7, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
+; AVX2: Cost of 8 for VF 16: WIDEN ir<%valB.loaded> = load vp<[[VP6]]>, ir<%canLoad> (!alias.scope !7, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
+; AVX2: Cost of 16 for VF 32: WIDEN ir<%valB.loaded> = load vp<[[VP6]]>, ir<%canLoad> (!alias.scope !7, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
;
; AVX512-LABEL: 'test'
; AVX512: LV: Found an estimated cost of 1 for VF 1 For instruction: %valB.loaded = load i64, ptr %inB, align 8
-; AVX512: Cost of 1 for VF 2: WIDEN ir<%valB.loaded> = load vp<[[VP6:%[0-9]+]]>, ir<%canLoad>
-; AVX512: Cost of 1 for VF 4: WIDEN ir<%valB.loaded> = load vp<[[VP6]]>, ir<%canLoad>
-; AVX512: Cost of 1 for VF 8: WIDEN ir<%valB.loaded> = load vp<[[VP6]]>, ir<%canLoad>
-; AVX512: Cost of 2 for VF 16: WIDEN ir<%valB.loaded> = load vp<[[VP6]]>, ir<%canLoad>
-; AVX512: Cost of 4 for VF 32: WIDEN ir<%valB.loaded> = load vp<[[VP6]]>, ir<%canLoad>
-; AVX512: Cost of 8 for VF 64: WIDEN ir<%valB.loaded> = load vp<[[VP6]]>, ir<%canLoad>
+; AVX512: Cost of 1 for VF 2: WIDEN ir<%valB.loaded> = load vp<[[VP6:%[0-9]+]]>, ir<%canLoad> (!alias.scope !7, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
+; AVX512: Cost of 1 for VF 4: WIDEN ir<%valB.loaded> = load vp<[[VP6]]>, ir<%canLoad> (!alias.scope !7, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
+; AVX512: Cost of 1 for VF 8: WIDEN ir<%valB.loaded> = load vp<[[VP6]]>, ir<%canLoad> (!alias.scope !7, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
+; AVX512: Cost of 2 for VF 16: WIDEN ir<%valB.loaded> = load vp<[[VP6]]>, ir<%canLoad> (!alias.scope !7, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
+; AVX512: Cost of 4 for VF 32: WIDEN ir<%valB.loaded> = load vp<[[VP6]]>, ir<%canLoad> (!alias.scope !7, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
+; AVX512: Cost of 8 for VF 64: WIDEN ir<%valB.loaded> = load vp<[[VP6]]>, ir<%canLoad> (!alias.scope !7, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
;
entry:
br label %for.body
diff --git a/llvm/test/Transforms/LoopVectorize/X86/CostModel/masked-load-i8.ll b/llvm/test/Transforms/LoopVectorize/X86/CostModel/masked-load-i8.ll
index c822598977704..7a437ee6b1775 100644
--- a/llvm/test/Transforms/LoopVectorize/X86/CostModel/masked-load-i8.ll
+++ b/llvm/test/Transforms/LoopVectorize/X86/CostModel/masked-load-i8.ll
@@ -1,10 +1,10 @@
; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py UTC_ARGS: --filter "LV: Found an estimated cost of [0-9]+(.[0-9]+)? for VF [0-9]+ For instruction:\s*%valB.loaded = load i8, ptr %inB, align 1" --filter "Cost of [0-9]+(.[0-9]+)? for VF [0-9]+: .* ir<%valB.loaded> = load"
-; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+sse2 --debug-only=loop-vectorize --disable-output -vplan-print-metadata=false < %s 2>&1 | FileCheck %s --check-prefixes=SSE
-; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+sse4.2 --debug-only=loop-vectorize --disable-output -vplan-print-metadata=false < %s 2>&1 | FileCheck %s --check-prefixes=SSE
-; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+avx --debug-only=loop-vectorize --disable-output -vplan-print-metadata=false < %s 2>&1 | FileCheck %s --check-prefixes=AVX1
-; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+avx2,-fast-gather --debug-only=loop-vectorize --disable-output -vplan-print-metadata=false < %s 2>&1 | FileCheck %s --check-prefixes=AVX2
-; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+avx2,+fast-gather --debug-only=loop-vectorize --disable-output -vplan-print-metadata=false < %s 2>&1 | FileCheck %s --check-prefixes=AVX2
-; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+avx512bw --debug-only=loop-vectorize --disable-output -vplan-print-metadata=false < %s 2>&1 | FileCheck %s --check-prefixes=AVX512
+; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+sse2 --debug-only=loop-vectorize --disable-output < %s 2>&1 | FileCheck %s --check-prefixes=SSE
+; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+sse4.2 --debug-only=loop-vectorize --disable-output < %s 2>&1 | FileCheck %s --check-prefixes=SSE
+; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+avx --debug-only=loop-vectorize --disable-output < %s 2>&1 | FileCheck %s --check-prefixes=AVX1
+; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+avx2,-fast-gather --debug-only=loop-vectorize --disable-output < %s 2>&1 | FileCheck %s --check-prefixes=AVX2
+; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+avx2,+fast-gather --debug-only=loop-vectorize --disable-output < %s 2>&1 | FileCheck %s --check-prefixes=AVX2
+; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+avx512bw --debug-only=loop-vectorize --disable-output < %s 2>&1 | FileCheck %s --check-prefixes=AVX512
; REQUIRES: asserts
diff --git a/llvm/test/Transforms/LoopVectorize/X86/CostModel/masked-store-i16.ll b/llvm/test/Transforms/LoopVectorize/X86/CostModel/masked-store-i16.ll
index 61436a61dba50..d6d6fd761e31c 100644
--- a/llvm/test/Transforms/LoopVectorize/X86/CostModel/masked-store-i16.ll
+++ b/llvm/test/Transforms/LoopVectorize/X86/CostModel/masked-store-i16.ll
@@ -1,10 +1,10 @@
; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py UTC_ARGS: --filter "LV: Found an estimated cost of [0-9]+(.[0-9]+)? for VF 1 For instruction:\s*store i16 %valB, ptr %out" --filter "Cost of [1-9][0-9]*(.[0-9]+)? for VF [0-9]+: (profitable to scalarize\s+store i16 %valB|WIDEN store .*, ir<%valB>|REPLICATE store ir<%valB>)"
-; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+sse2 --debug-only=loop-vectorize --disable-output -vplan-print-metadata=false < %s 2>&1 | FileCheck %s --check-prefixes=SSE
-; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+sse4.2 --debug-only=loop-vectorize --disable-output -vplan-print-metadata=false < %s 2>&1 | FileCheck %s --check-prefixes=SSE
-; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+avx --debug-only=loop-vectorize --disable-output -vplan-print-metadata=false < %s 2>&1 | FileCheck %s --check-prefixes=AVX1
-; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+avx2,-fast-gather --debug-only=loop-vectorize --disable-output -vplan-print-metadata=false < %s 2>&1 | FileCheck %s --check-prefixes=AVX2
-; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+avx2,+fast-gather --debug-only=loop-vectorize --disable-output -vplan-print-metadata=false < %s 2>&1 | FileCheck %s --check-prefixes=AVX2
-; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+avx512bw --debug-only=loop-vectorize --disable-output -vplan-print-metadata=false < %s 2>&1 | FileCheck %s --check-prefixes=AVX512
+; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+sse2 --debug-only=loop-vectorize --disable-output < %s 2>&1 | FileCheck %s --check-prefixes=SSE
+; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+sse4.2 --debug-only=loop-vectorize --disable-output < %s 2>&1 | FileCheck %s --check-prefixes=SSE
+; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+avx --debug-only=loop-vectorize --disable-output < %s 2>&1 | FileCheck %s --check-prefixes=AVX1
+; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+avx2,-fast-gather --debug-only=loop-vectorize --disable-output < %s 2>&1 | FileCheck %s --check-prefixes=AVX2
+; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+avx2,+fast-gather --debug-only=loop-vectorize --disable-output < %s 2>&1 | FileCheck %s --check-prefixes=AVX2
+; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+avx512bw --debug-only=loop-vectorize --disable-output < %s 2>&1 | FileCheck %s --check-prefixes=AVX512
; REQUIRES: asserts
@@ -40,12 +40,12 @@ define void @test(ptr %C) {
;
; AVX512-LABEL: 'test'
; AVX512: LV: Found an estimated cost of 1 for VF 1 For instruction: store i16 %valB, ptr %out, align 2
-; AVX512: Cost of 2 for VF 2: WIDEN store vp<[[VP7:%[0-9]+]]>, ir<%valB>, ir<%canStore>
-; AVX512: Cost of 2 for VF 4: WIDEN store vp<[[VP7]]>, ir<%valB>, ir<%canStore>
-; AVX512: Cost of 1 for VF 8: WIDEN store vp<[[VP7]]>, ir<%valB>, ir<%canStore>
-; AVX512: Cost of 1 for VF 16: WIDEN store vp<[[VP7]]>, ir<%valB>, ir<%canStore>
-; AVX512: Cost of 1 for VF 32: WIDEN store vp<[[VP7]]>, ir<%valB>, ir<%canStore>
-; AVX512: Cost of 2 for VF 64: WIDEN store vp<[[VP7]]>, ir<%valB>, ir<%canStore>
+; AVX512: Cost of 2 for VF 2: WIDEN store vp<[[VP7:%[0-9]+]]>, ir<%valB>, ir<%canStore> (!alias.scope !8, !noalias !4, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
+; AVX512: Cost of 2 for VF 4: WIDEN store vp<[[VP7]]>, ir<%valB>, ir<%canStore> (!alias.scope !8, !noalias !4, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
+; AVX512: Cost of 1 for VF 8: WIDEN store vp<[[VP7]]>, ir<%valB>, ir<%canStore> (!alias.scope !8, !noalias !4, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
+; AVX512: Cost of 1 for VF 16: WIDEN store vp<[[VP7]]>, ir<%valB>, ir<%canStore> (!alias.scope !8, !noalias !4, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
+; AVX512: Cost of 1 for VF 32: WIDEN store vp<[[VP7]]>, ir<%valB>, ir<%canStore> (!alias.scope !8, !noalias !4, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
+; AVX512: Cost of 2 for VF 64: WIDEN store vp<[[VP7]]>, ir<%valB>, ir<%canStore> (!alias.scope !8, !noalias !4, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
;
entry:
br label %for.body
diff --git a/llvm/test/Transforms/LoopVectorize/X86/CostModel/masked-store-i32.ll b/llvm/test/Transforms/LoopVectorize/X86/CostModel/masked-store-i32.ll
index 0afea8d1664d5..95ae05bbc7c0b 100644
--- a/llvm/test/Transforms/LoopVectorize/X86/CostModel/masked-store-i32.ll
+++ b/llvm/test/Transforms/LoopVectorize/X86/CostModel/masked-store-i32.ll
@@ -1,10 +1,10 @@
; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py UTC_ARGS: --filter "LV: Found an estimated cost of [0-9]+(.[0-9]+)? for VF 1 For instruction:\s*store i32 %valB, ptr %out" --filter "Cost of [1-9][0-9]*(.[0-9]+)? for VF [0-9]+: (profitable to scalarize\s+store i32 %valB|WIDEN store .*, ir<%valB>|REPLICATE store ir<%valB>)"
-; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+sse2 --debug-only=loop-vectorize --disable-output -vplan-print-metadata=false < %s 2>&1 | FileCheck %s --check-prefixes=SSE2
-; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+sse4.2 --debug-only=loop-vectorize --disable-output -vplan-print-metadata=false < %s 2>&1 | FileCheck %s --check-prefixes=SSE42
-; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+avx --debug-only=loop-vectorize --disable-output -vplan-print-metadata=false < %s 2>&1 | FileCheck %s --check-prefixes=AVX1
-; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+avx2,-fast-gather --debug-only=loop-vectorize --disable-output -vplan-print-metadata=false < %s 2>&1 | FileCheck %s --check-prefixes=AVX2
-; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+avx2,+fast-gather --debug-only=loop-vectorize --disable-output -vplan-print-metadata=false < %s 2>&1 | FileCheck %s --check-prefixes=AVX2
-; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+avx512bw --debug-only=loop-vectorize --disable-output -vplan-print-metadata=false < %s 2>&1 | FileCheck %s --check-prefixes=AVX512
+; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+sse2 --debug-only=loop-vectorize --disable-output < %s 2>&1 | FileCheck %s --check-prefixes=SSE2
+; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+sse4.2 --debug-only=loop-vectorize --disable-output < %s 2>&1 | FileCheck %s --check-prefixes=SSE42
+; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+avx --debug-only=loop-vectorize --disable-output < %s 2>&1 | FileCheck %s --check-prefixes=AVX1
+; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+avx2,-fast-gather --debug-only=loop-vectorize --disable-output < %s 2>&1 | FileCheck %s --check-prefixes=AVX2
+; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+avx2,+fast-gather --debug-only=loop-vectorize --disable-output < %s 2>&1 | FileCheck %s --check-prefixes=AVX2
+; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+avx512bw --debug-only=loop-vectorize --disable-output < %s 2>&1 | FileCheck %s --check-prefixes=AVX512
; REQUIRES: asserts
@@ -31,28 +31,28 @@ define void @test(ptr %C) {
;
; AVX1-LABEL: 'test'
; AVX1: LV: Found an estimated cost of 1 for VF 1 For instruction: store i32 %valB, ptr %out, align 4
-; AVX1: Cost of 9 for VF 2: WIDEN store vp<[[VP7:%[0-9]+]]>, ir<%valB>, ir<%canStore>
-; AVX1: Cost of 8 for VF 4: WIDEN store vp<[[VP7]]>, ir<%valB>, ir<%canStore>
-; AVX1: Cost of 8 for VF 8: WIDEN store vp<[[VP7]]>, ir<%valB>, ir<%canStore>
-; AVX1: Cost of 16 for VF 16: WIDEN store vp<[[VP7]]>, ir<%valB>, ir<%canStore>
-; AVX1: Cost of 32 for VF 32: WIDEN store vp<[[VP7]]>, ir<%valB>, ir<%canStore>
+; AVX1: Cost of 9 for VF 2: WIDEN store vp<[[VP7:%[0-9]+]]>, ir<%valB>, ir<%canStore> (!alias.scope !8, !noalias !4, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
+; AVX1: Cost of 8 for VF 4: WIDEN store vp<[[VP7]]>, ir<%valB>, ir<%canStore> (!alias.scope !8, !noalias !4, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
+; AVX1: Cost of 8 for VF 8: WIDEN store vp<[[VP7]]>, ir<%valB>, ir<%canStore> (!alias.scope !8, !noalias !4, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
+; AVX1: Cost of 16 for VF 16: WIDEN store vp<[[VP7]]>, ir<%valB>, ir<%canStore> (!alias.scope !8, !noalias !4, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
+; AVX1: Cost of 32 for VF 32: WIDEN store vp<[[VP7]]>, ir<%valB>, ir<%canStore> (!alias.scope !8, !noalias !4, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
;
; AVX2-LABEL: 'test'
; AVX2: LV: Found an estimated cost of 1 for VF 1 For instruction: store i32 %valB, ptr %out, align 4
-; AVX2: Cost of 9 for VF 2: WIDEN store vp<[[VP7:%[0-9]+]]>, ir<%valB>, ir<%canStore>
-; AVX2: Cost of 8 for VF 4: WIDEN store vp<[[VP7]]>, ir<%valB>, ir<%canStore>
-; AVX2: Cost of 8 for VF 8: WIDEN store vp<[[VP7]]>, ir<%valB>, ir<%canStore>
-; AVX2: Cost of 16 for VF 16: WIDEN store vp<[[VP7]]>, ir<%valB>, ir<%canStore>
-; AVX2: Cost of 32 for VF 32: WIDEN store vp<[[VP7]]>, ir<%valB>, ir<%canStore>
+; AVX2: Cost of 9 for VF 2: WIDEN store vp<[[VP7:%[0-9]+]]>, ir<%valB>, ir<%canStore> (!alias.scope !8, !noalias !4, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
+; AVX2: Cost of 8 for VF 4: WIDEN store vp<[[VP7]]>, ir<%valB>, ir<%canStore> (!alias.scope !8, !noalias !4, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
+; AVX2: Cost of 8 for VF 8: WIDEN store vp<[[VP7]]>, ir<%valB>, ir<%canStore> (!alias.scope !8, !noalias !4, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
+; AVX2: Cost of 16 for VF 16: WIDEN store vp<[[VP7]]>, ir<%valB>, ir<%canStore> (!alias.scope !8, !noalias !4, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
+; AVX2: Cost of 32 for VF 32: WIDEN store vp<[[VP7]]>, ir<%valB>, ir<%canStore> (!alias.scope !8, !noalias !4, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
;
; AVX512-LABEL: 'test'
; AVX512: LV: Found an estimated cost of 1 for VF 1 For instruction: store i32 %valB, ptr %out, align 4
-; AVX512: Cost of 2 for VF 2: WIDEN store vp<[[VP7:%[0-9]+]]>, ir<%valB>, ir<%canStore>
-; AVX512: Cost of 1 for VF 4: WIDEN store vp<[[VP7]]>, ir<%valB>, ir<%canStore>
-; AVX512: Cost of 1 for VF 8: WIDEN store vp<[[VP7]]>, ir<%valB>, ir<%canStore>
-; AVX512: Cost of 1 for VF 16: WIDEN store vp<[[VP7]]>, ir<%valB>, ir<%canStore>
-; AVX512: Cost of 2 for VF 32: WIDEN store vp<[[VP7]]>, ir<%valB>, ir<%canStore>
-; AVX512: Cost of 4 for VF 64: WIDEN store vp<[[VP7]]>, ir<%valB>, ir<%canStore>
+; AVX512: Cost of 2 for VF 2: WIDEN store vp<[[VP7:%[0-9]+]]>, ir<%valB>, ir<%canStore> (!alias.scope !8, !noalias !4, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
+; AVX512: Cost of 1 for VF 4: WIDEN store vp<[[VP7]]>, ir<%valB>, ir<%canStore> (!alias.scope !8, !noalias !4, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
+; AVX512: Cost of 1 for VF 8: WIDEN store vp<[[VP7]]>, ir<%valB>, ir<%canStore> (!alias.scope !8, !noalias !4, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
+; AVX512: Cost of 1 for VF 16: WIDEN store vp<[[VP7]]>, ir<%valB>, ir<%canStore> (!alias.scope !8, !noalias !4, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
+; AVX512: Cost of 2 for VF 32: WIDEN store vp<[[VP7]]>, ir<%valB>, ir<%canStore> (!alias.scope !8, !noalias !4, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
+; AVX512: Cost of 4 for VF 64: WIDEN store vp<[[VP7]]>, ir<%valB>, ir<%canStore> (!alias.scope !8, !noalias !4, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
;
entry:
br label %for.body
diff --git a/llvm/test/Transforms/LoopVectorize/X86/CostModel/masked-store-i64.ll b/llvm/test/Transforms/LoopVectorize/X86/CostModel/masked-store-i64.ll
index ce2d69fca6a3b..542076fd6d5f8 100644
--- a/llvm/test/Transforms/LoopVectorize/X86/CostModel/masked-store-i64.ll
+++ b/llvm/test/Transforms/LoopVectorize/X86/CostModel/masked-store-i64.ll
@@ -1,10 +1,10 @@
; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py UTC_ARGS: --filter "LV: Found an estimated cost of [0-9]+(.[0-9]+)? for VF 1 For instruction:\s*store i64 %valB, ptr %out" --filter "Cost of [1-9][0-9]*(.[0-9]+)? for VF [0-9]+: (profitable to scalarize\s+store i64 %valB|WIDEN store .*, ir<%valB>|REPLICATE store ir<%valB>)"
-; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+sse2 --debug-only=loop-vectorize --disable-output -vplan-print-metadata=false < %s 2>&1 | FileCheck %s --check-prefixes=SSE2
-; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+sse4.2 --debug-only=loop-vectorize --disable-output -vplan-print-metadata=false < %s 2>&1 | FileCheck %s --check-prefixes=SSE42
-; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+avx --debug-only=loop-vectorize --disable-output -vplan-print-metadata=false < %s 2>&1 | FileCheck %s --check-prefixes=AVX1
-; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+avx2,-fast-gather --debug-only=loop-vectorize --disable-output -vplan-print-metadata=false < %s 2>&1 | FileCheck %s --check-prefixes=AVX2
-; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+avx2,+fast-gather --debug-only=loop-vectorize --disable-output -vplan-print-metadata=false < %s 2>&1 | FileCheck %s --check-prefixes=AVX2
-; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+avx512bw --debug-only=loop-vectorize --disable-output -vplan-print-metadata=false < %s 2>&1 | FileCheck %s --check-prefixes=AVX512
+; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+sse2 --debug-only=loop-vectorize --disable-output < %s 2>&1 | FileCheck %s --check-prefixes=SSE2
+; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+sse4.2 --debug-only=loop-vectorize --disable-output < %s 2>&1 | FileCheck %s --check-prefixes=SSE42
+; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+avx --debug-only=loop-vectorize --disable-output < %s 2>&1 | FileCheck %s --check-prefixes=AVX1
+; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+avx2,-fast-gather --debug-only=loop-vectorize --disable-output < %s 2>&1 | FileCheck %s --check-prefixes=AVX2
+; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+avx2,+fast-gather --debug-only=loop-vectorize --disable-output < %s 2>&1 | FileCheck %s --check-prefixes=AVX2
+; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+avx512bw --debug-only=loop-vectorize --disable-output < %s 2>&1 | FileCheck %s --check-prefixes=AVX512
; REQUIRES: asserts
@@ -31,28 +31,28 @@ define void @test(ptr %C) {
;
; AVX1-LABEL: 'test'
; AVX1: LV: Found an estimated cost of 1 for VF 1 For instruction: store i64 %valB, ptr %out, align 8
-; AVX1: Cost of 8 for VF 2: WIDEN store vp<[[VP7:%[0-9]+]]>, ir<%valB>, ir<%canStore>
-; AVX1: Cost of 8 for VF 4: WIDEN store vp<[[VP7]]>, ir<%valB>, ir<%canStore>
-; AVX1: Cost of 16 for VF 8: WIDEN store vp<[[VP7]]>, ir<%valB>, ir<%canStore>
-; AVX1: Cost of 32 for VF 16: WIDEN store vp<[[VP7]]>, ir<%valB>, ir<%canStore>
-; AVX1: Cost of 64 for VF 32: WIDEN store vp<[[VP7]]>, ir<%valB>, ir<%canStore>
+; AVX1: Cost of 8 for VF 2: WIDEN store vp<[[VP7:%[0-9]+]]>, ir<%valB>, ir<%canStore> (!alias.scope !8, !noalias !4, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
+; AVX1: Cost of 8 for VF 4: WIDEN store vp<[[VP7]]>, ir<%valB>, ir<%canStore> (!alias.scope !8, !noalias !4, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
+; AVX1: Cost of 16 for VF 8: WIDEN store vp<[[VP7]]>, ir<%valB>, ir<%canStore> (!alias.scope !8, !noalias !4, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
+; AVX1: Cost of 32 for VF 16: WIDEN store vp<[[VP7]]>, ir<%valB>, ir<%canStore> (!alias.scope !8, !noalias !4, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
+; AVX1: Cost of 64 for VF 32: WIDEN store vp<[[VP7]]>, ir<%valB>, ir<%canStore> (!alias.scope !8, !noalias !4, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
;
; AVX2-LABEL: 'test'
; AVX2: LV: Found an estimated cost of 1 for VF 1 For instruction: store i64 %valB, ptr %out, align 8
-; AVX2: Cost of 8 for VF 2: WIDEN store vp<[[VP7:%[0-9]+]]>, ir<%valB>, ir<%canStore>
-; AVX2: Cost of 8 for VF 4: WIDEN store vp<[[VP7]]>, ir<%valB>, ir<%canStore>
-; AVX2: Cost of 16 for VF 8: WIDEN store vp<[[VP7]]>, ir<%valB>, ir<%canStore>
-; AVX2: Cost of 32 for VF 16: WIDEN store vp<[[VP7]]>, ir<%valB>, ir<%canStore>
-; AVX2: Cost of 64 for VF 32: WIDEN store vp<[[VP7]]>, ir<%valB>, ir<%canStore>
+; AVX2: Cost of 8 for VF 2: WIDEN store vp<[[VP7:%[0-9]+]]>, ir<%valB>, ir<%canStore> (!alias.scope !8, !noalias !4, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
+; AVX2: Cost of 8 for VF 4: WIDEN store vp<[[VP7]]>, ir<%valB>, ir<%canStore> (!alias.scope !8, !noalias !4, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
+; AVX2: Cost of 16 for VF 8: WIDEN store vp<[[VP7]]>, ir<%valB>, ir<%canStore> (!alias.scope !8, !noalias !4, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
+; AVX2: Cost of 32 for VF 16: WIDEN store vp<[[VP7]]>, ir<%valB>, ir<%canStore> (!alias.scope !8, !noalias !4, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
+; AVX2: Cost of 64 for VF 32: WIDEN store vp<[[VP7]]>, ir<%valB>, ir<%canStore> (!alias.scope !8, !noalias !4, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
;
; AVX512-LABEL: 'test'
; AVX512: LV: Found an estimated cost of 1 for VF 1 For instruction: store i64 %valB, ptr %out, align 8
-; AVX512: Cost of 1 for VF 2: WIDEN store vp<[[VP7:%[0-9]+]]>, ir<%valB>, ir<%canStore>
-; AVX512: Cost of 1 for VF 4: WIDEN store vp<[[VP7]]>, ir<%valB>, ir<%canStore>
-; AVX512: Cost of 1 for VF 8: WIDEN store vp<[[VP7]]>, ir<%valB>, ir<%canStore>
-; AVX512: Cost of 2 for VF 16: WIDEN store vp<[[VP7]]>, ir<%valB>, ir<%canStore>
-; AVX512: Cost of 4 for VF 32: WIDEN store vp<[[VP7]]>, ir<%valB>, ir<%canStore>
-; AVX512: Cost of 8 for VF 64: WIDEN store vp<[[VP7]]>, ir<%valB>, ir<%canStore>
+; AVX512: Cost of 1 for VF 2: WIDEN store vp<[[VP7:%[0-9]+]]>, ir<%valB>, ir<%canStore> (!alias.scope !8, !noalias !4, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
+; AVX512: Cost of 1 for VF 4: WIDEN store vp<[[VP7]]>, ir<%valB>, ir<%canStore> (!alias.scope !8, !noalias !4, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
+; AVX512: Cost of 1 for VF 8: WIDEN store vp<[[VP7]]>, ir<%valB>, ir<%canStore> (!alias.scope !8, !noalias !4, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
+; AVX512: Cost of 2 for VF 16: WIDEN store vp<[[VP7]]>, ir<%valB>, ir<%canStore> (!alias.scope !8, !noalias !4, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
+; AVX512: Cost of 4 for VF 32: WIDEN store vp<[[VP7]]>, ir<%valB>, ir<%canStore> (!alias.scope !8, !noalias !4, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
+; AVX512: Cost of 8 for VF 64: WIDEN store vp<[[VP7]]>, ir<%valB>, ir<%canStore> (!alias.scope !8, !noalias !4, !vplan.execution.frequency 5764607523034234880 (62.5%, estimated))
;
entry:
br label %for.body
diff --git a/llvm/test/Transforms/LoopVectorize/X86/CostModel/masked-store-i8.ll b/llvm/test/Transforms/LoopVectorize/X86/CostModel/masked-store-i8.ll
index 9028e1c5525a0..16a7768bbc302 100644
--- a/llvm/test/Transforms/LoopVectorize/X86/CostModel/masked-store-i8.ll
+++ b/llvm/test/Transforms/LoopVectorize/X86/CostModel/masked-store-i8.ll
@@ -1,10 +1,10 @@
; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py UTC_ARGS: --filter "LV: Found an estimated cost of [0-9]+(.[0-9]+)? for VF 1 For instruction:\s*store i8 %valB, ptr %out" --filter "Cost of [1-9][0-9]*(.[0-9]+)? for VF [0-9]+: (profitable to scalarize\s+store i8 %valB|WIDEN store .*, ir<%valB>|REPLICATE store ir<%valB>)"
-; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+sse2 --debug-only=loop-vectorize --disable-output -vplan-print-metadata=false < %s 2>&1 | FileCheck %s --check-prefixes=SSE2
-; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+sse4.2 --debug-only=loop-vectorize --disable-output -vplan-print-metadata=false < %s 2>&1 | FileCheck %s --check-prefixes=SSE42
-; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+avx --debug-only=loop-vectorize --disable-output -vplan-print-metadata=false < %s 2>&1 | FileCheck %s --check-prefixes=AVX1
-; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+avx2,-fast-gather --debug-only=loop-vectorize --disable-output -vplan-print-metadata=false < %s 2>&1 | FileCheck %s --check-prefixes=AVX2
-; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+avx2,+fast-gather --debug-only=loop-vectorize --disable-output -vplan-print-metadata=false < %s 2>&1 | FileCheck %s --check-prefixes=AVX2
-; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+avx512bw --debug-only=loop-vectorize --disable-output -vplan-print-metadata=false < %s 2>&1 | FileCheck %s --check-prefixes=AVX512
+; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+sse2 --debug-only=loop-vectorize --disable-output < %s 2>&1 | FileCheck %s --check-prefixes=SSE2
+; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+sse4.2 --debug-only=loop-vectorize --disable-output < %s 2>&1 | FileCheck %s --check-prefixes=SSE42
+; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+avx --debug-only=loop-vectorize --disable-output < %s 2>&1 | FileCheck %s --check-prefixes=AVX1
+; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+avx2,-fast-gather --debug-only=loop-vectorize --disable-output < %s 2>&1 | FileCheck %s --check-prefixes=AVX2
+; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+avx2,+fast-gather --debug-only=loop-vectorize --disable-output < %s 2>&1 | FileCheck %s --check-prefixes=AVX2
+; RUN: opt -passes=loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+avx512bw --debug-only=loop-vectorize --disable-output < %s 2>&1 | FileCheck %s --check-prefixes=AVX512
; REQUIRES: asserts
More information about the llvm-commits
mailing list