[llvm] [VPlan] Print metadata via ModuleSlotTracker. (PR #203982)
Florian Hahn via llvm-commits
llvm-commits at lists.llvm.org
Tue Sep 29 06:03:10 PDT 2026
https://github.com/fhahn updated https://github.com/llvm/llvm-project/pull/203982
>From 89549e41b42f475885fbe95a70a02448bf446dc3 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 1/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 05cb353616ee5..fc3aff9ea85e9 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
>From d78f66adc3d0a4e72676aa45d2363522bcc8465c Mon Sep 17 00:00:00 2001
From: Florian Hahn <flo at fhahn.com>
Date: Tue, 29 Sep 2026 14:02:18 +0100
Subject: [PATCH 2/2] !fixup update frequencies
---
.../VPlan/interleave-and-scalarize-only.ll | 2 +-
.../X86/CostModel/masked-load-i16.ll | 12 +++----
.../X86/CostModel/masked-load-i32.ll | 32 +++++++++----------
.../X86/CostModel/masked-load-i64.ll | 32 +++++++++----------
.../X86/CostModel/masked-store-i16.ll | 12 +++----
.../X86/CostModel/masked-store-i32.ll | 32 +++++++++----------
.../X86/CostModel/masked-store-i64.ll | 32 +++++++++----------
7 files changed, 77 insertions(+), 77 deletions(-)
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 341cbfb6f1ad8..f160c03d01bad 100644
--- a/llvm/test/Transforms/LoopVectorize/VPlan/interleave-and-scalarize-only.ll
+++ b/llvm/test/Transforms/LoopVectorize/VPlan/interleave-and-scalarize-only.ll
@@ -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]]> (!vplan.execution.frequency 4611686018427387904 (50%, estimated))
+; CHECK-NEXT: BRANCH-ON-MASK vp<[[VP6]]> (!vplan.execution.frequency 9223372036854775807 (50%, estimated))
; CHECK-NEXT: Successor(s): pred.store.if, pred.store.continue
; CHECK-EMPTY:
; CHECK-NEXT: pred.store.if:
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 c09fccc41f7f4..73b83ab686802 100644
--- a/llvm/test/Transforms/LoopVectorize/X86/CostModel/masked-load-i16.ll
+++ b/llvm/test/Transforms/LoopVectorize/X86/CostModel/masked-load-i16.ll
@@ -40,12 +40,12 @@ define void @test(ptr %B) {
;
; 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> (!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))
+; AVX512: Cost of 2 for VF 2: WIDEN ir<%valB.loaded> = load vp<[[VP6:%[0-9]+]]>, ir<%canLoad> (!alias.scope !7, !vplan.execution.frequency 11529215046068469760 (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 11529215046068469760 (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 11529215046068469760 (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 11529215046068469760 (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 11529215046068469760 (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 11529215046068469760 (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 a982916b9133b..c41a0a25b3d26 100644
--- a/llvm/test/Transforms/LoopVectorize/X86/CostModel/masked-load-i32.ll
+++ b/llvm/test/Transforms/LoopVectorize/X86/CostModel/masked-load-i32.ll
@@ -24,28 +24,28 @@ define void @test(ptr %B) {
;
; 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> (!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))
+; AVX1: Cost of 3 for VF 2: WIDEN ir<%valB.loaded> = load vp<[[VP6:%[0-9]+]]>, ir<%canLoad> (!alias.scope !7, !vplan.execution.frequency 11529215046068469760 (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 11529215046068469760 (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 11529215046068469760 (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 11529215046068469760 (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 11529215046068469760 (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> (!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))
+; AVX2: Cost of 3 for VF 2: WIDEN ir<%valB.loaded> = load vp<[[VP6:%[0-9]+]]>, ir<%canLoad> (!alias.scope !7, !vplan.execution.frequency 11529215046068469760 (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 11529215046068469760 (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 11529215046068469760 (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 11529215046068469760 (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 11529215046068469760 (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> (!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))
+; AVX512: Cost of 2 for VF 2: WIDEN ir<%valB.loaded> = load vp<[[VP6:%[0-9]+]]>, ir<%canLoad> (!alias.scope !7, !vplan.execution.frequency 11529215046068469760 (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 11529215046068469760 (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 11529215046068469760 (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 11529215046068469760 (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 11529215046068469760 (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 11529215046068469760 (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 6886b40542684..8a08b731bc848 100644
--- a/llvm/test/Transforms/LoopVectorize/X86/CostModel/masked-load-i64.ll
+++ b/llvm/test/Transforms/LoopVectorize/X86/CostModel/masked-load-i64.ll
@@ -24,28 +24,28 @@ define void @test(ptr %B) {
;
; 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> (!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))
+; AVX1: Cost of 2 for VF 2: WIDEN ir<%valB.loaded> = load vp<[[VP6:%[0-9]+]]>, ir<%canLoad> (!alias.scope !7, !vplan.execution.frequency 11529215046068469760 (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 11529215046068469760 (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 11529215046068469760 (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 11529215046068469760 (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 11529215046068469760 (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> (!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))
+; AVX2: Cost of 2 for VF 2: WIDEN ir<%valB.loaded> = load vp<[[VP6:%[0-9]+]]>, ir<%canLoad> (!alias.scope !7, !vplan.execution.frequency 11529215046068469760 (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 11529215046068469760 (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 11529215046068469760 (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 11529215046068469760 (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 11529215046068469760 (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> (!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))
+; AVX512: Cost of 1 for VF 2: WIDEN ir<%valB.loaded> = load vp<[[VP6:%[0-9]+]]>, ir<%canLoad> (!alias.scope !7, !vplan.execution.frequency 11529215046068469760 (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 11529215046068469760 (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 11529215046068469760 (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 11529215046068469760 (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 11529215046068469760 (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 11529215046068469760 (62.5%, estimated))
;
entry:
br label %for.body
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 d6d6fd761e31c..800c9eae5e2bb 100644
--- a/llvm/test/Transforms/LoopVectorize/X86/CostModel/masked-store-i16.ll
+++ b/llvm/test/Transforms/LoopVectorize/X86/CostModel/masked-store-i16.ll
@@ -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> (!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))
+; 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 11529215046068469760 (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 11529215046068469760 (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 11529215046068469760 (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 11529215046068469760 (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 11529215046068469760 (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 11529215046068469760 (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 95ae05bbc7c0b..3e6b1f09aca06 100644
--- a/llvm/test/Transforms/LoopVectorize/X86/CostModel/masked-store-i32.ll
+++ b/llvm/test/Transforms/LoopVectorize/X86/CostModel/masked-store-i32.ll
@@ -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> (!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))
+; 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 11529215046068469760 (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 11529215046068469760 (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 11529215046068469760 (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 11529215046068469760 (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 11529215046068469760 (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> (!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))
+; 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 11529215046068469760 (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 11529215046068469760 (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 11529215046068469760 (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 11529215046068469760 (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 11529215046068469760 (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> (!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))
+; 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 11529215046068469760 (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 11529215046068469760 (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 11529215046068469760 (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 11529215046068469760 (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 11529215046068469760 (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 11529215046068469760 (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 542076fd6d5f8..5447e15b3da13 100644
--- a/llvm/test/Transforms/LoopVectorize/X86/CostModel/masked-store-i64.ll
+++ b/llvm/test/Transforms/LoopVectorize/X86/CostModel/masked-store-i64.ll
@@ -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> (!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))
+; 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 11529215046068469760 (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 11529215046068469760 (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 11529215046068469760 (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 11529215046068469760 (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 11529215046068469760 (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> (!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))
+; 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 11529215046068469760 (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 11529215046068469760 (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 11529215046068469760 (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 11529215046068469760 (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 11529215046068469760 (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> (!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))
+; 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 11529215046068469760 (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 11529215046068469760 (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 11529215046068469760 (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 11529215046068469760 (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 11529215046068469760 (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 11529215046068469760 (62.5%, estimated))
;
entry:
br label %for.body
More information about the llvm-commits
mailing list