diff --git a/llvm/include/llvm/Transforms/Vectorize/SandboxVectorizer/Passes/TransactionAlwaysRevert.h b/llvm/include/llvm/Transforms/Vectorize/SandboxVectorizer/Passes/TransactionAlwaysRevert.h
new file mode 100644
index 0000000000000..308ba208d777e
--- /dev/null
+++ b/llvm/include/llvm/Transforms/Vectorize/SandboxVectorizer/Passes/TransactionAlwaysRevert.h
@@ -0,0 +1,34 @@
+//===- TransactionAlwaysRevert.h --------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This is a region pass that always reverts the transaction without checking
+// its cost. This is mainly used as a final pass in lit tests.
+//
+
+#ifndef LLVM_TRANSFORMS_VECTORIZE_SANDBOXVECTORIZER_PASSES_TRANSACTIONALWAYSREVERT_H
+#define LLVM_TRANSFORMS_VECTORIZE_SANDBOXVECTORIZER_PASSES_TRANSACTIONALWAYSREVERT_H
+
+#include "llvm/SandboxIR/Pass.h"
+#include "llvm/SandboxIR/Region.h"
+
+namespace llvm::sandboxir {
+
+class TransactionAlwaysRevert : public RegionPass {
+public:
+  TransactionAlwaysRevert() : RegionPass("tr-revert") {}
+  bool runOnRegion(Region &Rgn, const Analyses &A) final {
+    auto &Tracker = Rgn.getContext().getTracker();
+    bool HasChanges = !Tracker.empty();
+    Tracker.revert();
+    return HasChanges;
+  }
+};
+
+} // namespace llvm::sandboxir
+
+#endif // LLVM_TRANSFORMS_VECTORIZE_SANDBOXVECTORIZER_PASSES_TRANSACTIONALWAYSREVERT_H
diff --git a/llvm/lib/Transforms/Vectorize/SandboxVectorizer/Passes/PassRegistry.def b/llvm/lib/Transforms/Vectorize/SandboxVectorizer/Passes/PassRegistry.def
index f2eb769420e7f..c12bd91997943 100644
--- a/llvm/lib/Transforms/Vectorize/SandboxVectorizer/Passes/PassRegistry.def
+++ b/llvm/lib/Transforms/Vectorize/SandboxVectorizer/Passes/PassRegistry.def
@@ -22,6 +22,7 @@ REGION_PASS("print-instruction-count", ::llvm::sandboxir::PrintInstructionCount)
 REGION_PASS("print-region", ::llvm::sandboxir::PrintRegion)
 REGION_PASS("tr-save", ::llvm::sandboxir::TransactionSave)
 REGION_PASS("tr-accept", ::llvm::sandboxir::TransactionAlwaysAccept)
+REGION_PASS("tr-revert", ::llvm::sandboxir::TransactionAlwaysRevert)
 REGION_PASS("tr-accept-or-revert", ::llvm::sandboxir::TransactionAcceptOrRevert)
 REGION_PASS("bottom-up-vec", ::llvm::sandboxir::BottomUpVec)
 
diff --git a/llvm/lib/Transforms/Vectorize/SandboxVectorizer/SandboxVectorizerPassBuilder.cpp b/llvm/lib/Transforms/Vectorize/SandboxVectorizer/SandboxVectorizerPassBuilder.cpp
index 5918cfd38b374..feeda65b3f6e2 100644
--- a/llvm/lib/Transforms/Vectorize/SandboxVectorizer/SandboxVectorizerPassBuilder.cpp
+++ b/llvm/lib/Transforms/Vectorize/SandboxVectorizer/SandboxVectorizerPassBuilder.cpp
@@ -9,6 +9,7 @@
 #include "llvm/Transforms/Vectorize/SandboxVectorizer/Passes/SeedCollection.h"
 #include "llvm/Transforms/Vectorize/SandboxVectorizer/Passes/TransactionAcceptOrRevert.h"
 #include "llvm/Transforms/Vectorize/SandboxVectorizer/Passes/TransactionAlwaysAccept.h"
+#include "llvm/Transforms/Vectorize/SandboxVectorizer/Passes/TransactionAlwaysRevert.h"
 #include "llvm/Transforms/Vectorize/SandboxVectorizer/Passes/TransactionSave.h"
 
 namespace llvm::sandboxir {
diff --git a/llvm/test/Transforms/SandboxVectorizer/bottomup_basic.ll b/llvm/test/Transforms/SandboxVectorizer/bottomup_basic.ll
index e0c70e4b03dd4..76dd3694b71b5 100644
--- a/llvm/test/Transforms/SandboxVectorizer/bottomup_basic.ll
+++ b/llvm/test/Transforms/SandboxVectorizer/bottomup_basic.ll
@@ -1,13 +1,24 @@
 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 5
 ; RUN: opt -passes=sandbox-vectorizer -sbvec-vec-reg-bits=1024 -sbvec-allow-non-pow2 -sbvec-passes="seed-collection<tr-save,bottom-up-vec,tr-accept>" %s -S | FileCheck %s
+; RUN: opt -passes=sandbox-vectorizer -sbvec-vec-reg-bits=1024 -sbvec-allow-non-pow2 -sbvec-passes="seed-collection<tr-save,bottom-up-vec,tr-revert>" %s -S | FileCheck %s --check-prefix REVERT
 
 define void @store_load(ptr %ptr) {
 ; CHECK-LABEL: define void @store_load(
 ; CHECK-SAME: ptr [[PTR:%.*]]) {
 ; CHECK-NEXT:    [[PTR0:%.*]] = getelementptr float, ptr [[PTR]], i32 0
-; CHECK-NEXT:    [[VECL:%.*]] = load <2 x float>, ptr [[PTR0]], align 4
-; CHECK-NEXT:    store <2 x float> [[VECL]], ptr [[PTR0]], align 4
+; CHECK-NEXT:    [[VECL:%.*]] = load <2 x float>, ptr [[PTR0]], align 4, !sandboxvec [[META0:![0-9]+]]
+; CHECK-NEXT:    store <2 x float> [[VECL]], ptr [[PTR0]], align 4, !sandboxvec [[META0]]
 ; CHECK-NEXT:    ret void
+;
+; REVERT-LABEL: define void @store_load(
+; REVERT-SAME: ptr [[PTR:%.*]]) {
+; REVERT-NEXT:    [[PTR0:%.*]] = getelementptr float, ptr [[PTR]], i32 0
+; REVERT-NEXT:    [[PTR1:%.*]] = getelementptr float, ptr [[PTR]], i32 1, !sandboxvec [[META0:![0-9]+]]
+; REVERT-NEXT:    [[LD0:%.*]] = load float, ptr [[PTR0]], align 4, !sandboxvec [[META0]]
+; REVERT-NEXT:    [[LD1:%.*]] = load float, ptr [[PTR1]], align 4, !sandboxvec [[META0]]
+; REVERT-NEXT:    store float [[LD0]], ptr [[PTR0]], align 4, !sandboxvec [[META0]]
+; REVERT-NEXT:    store float [[LD1]], ptr [[PTR1]], align 4, !sandboxvec [[META0]]
+; REVERT-NEXT:    ret void
 ;
   %ptr0 = getelementptr float, ptr %ptr, i32 0
   %ptr1 = getelementptr float, ptr %ptr, i32 1
@@ -24,10 +35,24 @@ define void @store_fpext_load(ptr %ptr) {
 ; CHECK-SAME: ptr [[PTR:%.*]]) {
 ; CHECK-NEXT:    [[PTR0:%.*]] = getelementptr float, ptr [[PTR]], i32 0
 ; CHECK-NEXT:    [[PTRD0:%.*]] = getelementptr double, ptr [[PTR]], i32 0
-; CHECK-NEXT:    [[VECL:%.*]] = load <2 x float>, ptr [[PTR0]], align 4
-; CHECK-NEXT:    [[VCAST:%.*]] = fpext <2 x float> [[VECL]] to <2 x double>
-; CHECK-NEXT:    store <2 x double> [[VCAST]], ptr [[PTRD0]], align 8
+; CHECK-NEXT:    [[VECL:%.*]] = load <2 x float>, ptr [[PTR0]], align 4, !sandboxvec [[META1:![0-9]+]]
+; CHECK-NEXT:    [[VCAST:%.*]] = fpext <2 x float> [[VECL]] to <2 x double>, !sandboxvec [[META1]]
+; CHECK-NEXT:    store <2 x double> [[VCAST]], ptr [[PTRD0]], align 8, !sandboxvec [[META1]]
 ; CHECK-NEXT:    ret void
+;
+; REVERT-LABEL: define void @store_fpext_load(
+; REVERT-SAME: ptr [[PTR:%.*]]) {
+; REVERT-NEXT:    [[PTR0:%.*]] = getelementptr float, ptr [[PTR]], i32 0
+; REVERT-NEXT:    [[PTR1:%.*]] = getelementptr float, ptr [[PTR]], i32 1, !sandboxvec [[META1:![0-9]+]]
+; REVERT-NEXT:    [[PTRD0:%.*]] = getelementptr double, ptr [[PTR]], i32 0
+; REVERT-NEXT:    [[PTRD1:%.*]] = getelementptr double, ptr [[PTR]], i32 1, !sandboxvec [[META1]]
+; REVERT-NEXT:    [[LD0:%.*]] = load float, ptr [[PTR0]], align 4, !sandboxvec [[META1]]
+; REVERT-NEXT:    [[LD1:%.*]] = load float, ptr [[PTR1]], align 4, !sandboxvec [[META1]]
+; REVERT-NEXT:    [[FPEXT0:%.*]] = fpext float [[LD0]] to double, !sandboxvec [[META1]]
+; REVERT-NEXT:    [[FPEXT1:%.*]] = fpext float [[LD1]] to double, !sandboxvec [[META1]]
+; REVERT-NEXT:    store double [[FPEXT0]], ptr [[PTRD0]], align 8, !sandboxvec [[META1]]
+; REVERT-NEXT:    store double [[FPEXT1]], ptr [[PTRD1]], align 8, !sandboxvec [[META1]]
+; REVERT-NEXT:    ret void
 ;
   %ptr0 = getelementptr float, ptr %ptr, i32 0
   %ptr1 = getelementptr float, ptr %ptr, i32 1
@@ -47,12 +72,30 @@ define void @store_fcmp_zext_load(ptr %ptr) {
 ; CHECK-SAME: ptr [[PTR:%.*]]) {
 ; CHECK-NEXT:    [[PTR0:%.*]] = getelementptr float, ptr [[PTR]], i32 0
 ; CHECK-NEXT:    [[PTRB0:%.*]] = getelementptr i32, ptr [[PTR]], i32 0
-; CHECK-NEXT:    [[VECL1:%.*]] = load <2 x float>, ptr [[PTR0]], align 4
-; CHECK-NEXT:    [[VECL:%.*]] = load <2 x float>, ptr [[PTR0]], align 4
-; CHECK-NEXT:    [[VCMP:%.*]] = fcmp ogt <2 x float> [[VECL]], [[VECL1]]
-; CHECK-NEXT:    [[VCAST:%.*]] = zext <2 x i1> [[VCMP]] to <2 x i32>
-; CHECK-NEXT:    store <2 x i32> [[VCAST]], ptr [[PTRB0]], align 4
+; CHECK-NEXT:    [[VECL1:%.*]] = load <2 x float>, ptr [[PTR0]], align 4, !sandboxvec [[META2:![0-9]+]]
+; CHECK-NEXT:    [[VECL:%.*]] = load <2 x float>, ptr [[PTR0]], align 4, !sandboxvec [[META2]]
+; CHECK-NEXT:    [[VCMP:%.*]] = fcmp ogt <2 x float> [[VECL]], [[VECL1]], !sandboxvec [[META2]]
+; CHECK-NEXT:    [[VCAST:%.*]] = zext <2 x i1> [[VCMP]] to <2 x i32>, !sandboxvec [[META2]]
+; CHECK-NEXT:    store <2 x i32> [[VCAST]], ptr [[PTRB0]], align 4, !sandboxvec [[META2]]
 ; CHECK-NEXT:    ret void
+;
+; REVERT-LABEL: define void @store_fcmp_zext_load(
+; REVERT-SAME: ptr [[PTR:%.*]]) {
+; REVERT-NEXT:    [[PTR0:%.*]] = getelementptr float, ptr [[PTR]], i32 0
+; REVERT-NEXT:    [[PTR1:%.*]] = getelementptr float, ptr [[PTR]], i32 1, !sandboxvec [[META2:![0-9]+]]
+; REVERT-NEXT:    [[PTRB0:%.*]] = getelementptr i32, ptr [[PTR]], i32 0
+; REVERT-NEXT:    [[PTRB1:%.*]] = getelementptr i32, ptr [[PTR]], i32 1, !sandboxvec [[META2]]
+; REVERT-NEXT:    [[LDB0:%.*]] = load float, ptr [[PTR0]], align 4, !sandboxvec [[META2]]
+; REVERT-NEXT:    [[LDB1:%.*]] = load float, ptr [[PTR1]], align 4, !sandboxvec [[META2]]
+; REVERT-NEXT:    [[LDA0:%.*]] = load float, ptr [[PTR0]], align 4, !sandboxvec [[META2]]
+; REVERT-NEXT:    [[LDA1:%.*]] = load float, ptr [[PTR1]], align 4, !sandboxvec [[META2]]
+; REVERT-NEXT:    [[FCMP0:%.*]] = fcmp ogt float [[LDA0]], [[LDB0]], !sandboxvec [[META2]]
+; REVERT-NEXT:    [[FCMP1:%.*]] = fcmp ogt float [[LDA1]], [[LDB1]], !sandboxvec [[META2]]
+; REVERT-NEXT:    [[ZEXT0:%.*]] = zext i1 [[FCMP0]] to i32, !sandboxvec [[META2]]
+; REVERT-NEXT:    [[ZEXT1:%.*]] = zext i1 [[FCMP1]] to i32, !sandboxvec [[META2]]
+; REVERT-NEXT:    store i32 [[ZEXT0]], ptr [[PTRB0]], align 4, !sandboxvec [[META2]]
+; REVERT-NEXT:    store i32 [[ZEXT1]], ptr [[PTRB1]], align 4, !sandboxvec [[META2]]
+; REVERT-NEXT:    ret void
 ;
   %ptr0 = getelementptr float, ptr %ptr, i32 0
   %ptr1 = getelementptr float, ptr %ptr, i32 1
@@ -75,11 +118,25 @@ define void @store_fadd_load(ptr %ptr) {
 ; CHECK-LABEL: define void @store_fadd_load(
 ; CHECK-SAME: ptr [[PTR:%.*]]) {
 ; CHECK-NEXT:    [[PTR0:%.*]] = getelementptr float, ptr [[PTR]], i32 0
-; CHECK-NEXT:    [[VECL:%.*]] = load <2 x float>, ptr [[PTR0]], align 4
-; CHECK-NEXT:    [[VECL1:%.*]] = load <2 x float>, ptr [[PTR0]], align 4
-; CHECK-NEXT:    [[VEC:%.*]] = fadd <2 x float> [[VECL1]], [[VECL]]
-; CHECK-NEXT:    store <2 x float> [[VEC]], ptr [[PTR0]], align 4
+; CHECK-NEXT:    [[VECL1:%.*]] = load <2 x float>, ptr [[PTR0]], align 4, !sandboxvec [[META3:![0-9]+]]
+; CHECK-NEXT:    [[VECL:%.*]] = load <2 x float>, ptr [[PTR0]], align 4, !sandboxvec [[META3]]
+; CHECK-NEXT:    [[VEC:%.*]] = fadd <2 x float> [[VECL]], [[VECL1]], !sandboxvec [[META3]]
+; CHECK-NEXT:    store <2 x float> [[VEC]], ptr [[PTR0]], align 4, !sandboxvec [[META3]]
 ; CHECK-NEXT:    ret void
+;
+; REVERT-LABEL: define void @store_fadd_load(
+; REVERT-SAME: ptr [[PTR:%.*]]) {
+; REVERT-NEXT:    [[PTR0:%.*]] = getelementptr float, ptr [[PTR]], i32 0
+; REVERT-NEXT:    [[PTR1:%.*]] = getelementptr float, ptr [[PTR]], i32 1, !sandboxvec [[META3:![0-9]+]]
+; REVERT-NEXT:    [[LDA0:%.*]] = load float, ptr [[PTR0]], align 4, !sandboxvec [[META3]]
+; REVERT-NEXT:    [[LDA1:%.*]] = load float, ptr [[PTR1]], align 4, !sandboxvec [[META3]]
+; REVERT-NEXT:    [[LDB0:%.*]] = load float, ptr [[PTR0]], align 4, !sandboxvec [[META3]]
+; REVERT-NEXT:    [[LDB1:%.*]] = load float, ptr [[PTR1]], align 4, !sandboxvec [[META3]]
+; REVERT-NEXT:    [[FADD0:%.*]] = fadd float [[LDA0]], [[LDB0]], !sandboxvec [[META3]]
+; REVERT-NEXT:    [[FADD1:%.*]] = fadd float [[LDA1]], [[LDB1]], !sandboxvec [[META3]]
+; REVERT-NEXT:    store float [[FADD0]], ptr [[PTR0]], align 4, !sandboxvec [[META3]]
+; REVERT-NEXT:    store float [[FADD1]], ptr [[PTR1]], align 4, !sandboxvec [[META3]]
+; REVERT-NEXT:    ret void
 ;
   %ptr0 = getelementptr float, ptr %ptr, i32 0
   %ptr1 = getelementptr float, ptr %ptr, i32 1
@@ -98,10 +155,22 @@ define void @store_fneg_load(ptr %ptr) {
 ; CHECK-LABEL: define void @store_fneg_load(
 ; CHECK-SAME: ptr [[PTR:%.*]]) {
 ; CHECK-NEXT:    [[PTR0:%.*]] = getelementptr float, ptr [[PTR]], i32 0
-; CHECK-NEXT:    [[VECL:%.*]] = load <2 x float>, ptr [[PTR0]], align 4
-; CHECK-NEXT:    [[VEC:%.*]] = fneg <2 x float> [[VECL]]
-; CHECK-NEXT:    store <2 x float> [[VEC]], ptr [[PTR0]], align 4
+; CHECK-NEXT:    [[VECL:%.*]] = load <2 x float>, ptr [[PTR0]], align 4, !sandboxvec [[META4:![0-9]+]]
+; CHECK-NEXT:    [[VEC:%.*]] = fneg <2 x float> [[VECL]], !sandboxvec [[META4]]
+; CHECK-NEXT:    store <2 x float> [[VEC]], ptr [[PTR0]], align 4, !sandboxvec [[META4]]
 ; CHECK-NEXT:    ret void
+;
+; REVERT-LABEL: define void @store_fneg_load(
+; REVERT-SAME: ptr [[PTR:%.*]]) {
+; REVERT-NEXT:    [[PTR0:%.*]] = getelementptr float, ptr [[PTR]], i32 0
+; REVERT-NEXT:    [[PTR1:%.*]] = getelementptr float, ptr [[PTR]], i32 1, !sandboxvec [[META4:![0-9]+]]
+; REVERT-NEXT:    [[LD0:%.*]] = load float, ptr [[PTR0]], align 4, !sandboxvec [[META4]]
+; REVERT-NEXT:    [[LD1:%.*]] = load float, ptr [[PTR1]], align 4, !sandboxvec [[META4]]
+; REVERT-NEXT:    [[FNEG0:%.*]] = fneg float [[LD0]], !sandboxvec [[META4]]
+; REVERT-NEXT:    [[FNEG1:%.*]] = fneg float [[LD1]], !sandboxvec [[META4]]
+; REVERT-NEXT:    store float [[FNEG0]], ptr [[PTR0]], align 4, !sandboxvec [[META4]]
+; REVERT-NEXT:    store float [[FNEG1]], ptr [[PTR1]], align 4, !sandboxvec [[META4]]
+; REVERT-NEXT:    ret void
 ;
   %ptr0 = getelementptr float, ptr %ptr, i32 0
   %ptr1 = getelementptr float, ptr %ptr, i32 1
@@ -121,10 +190,21 @@ define float @scalars_with_external_uses_not_dead(ptr %ptr) {
 ; CHECK-NEXT:    [[PTR1:%.*]] = getelementptr float, ptr [[PTR]], i32 1
 ; CHECK-NEXT:    [[LD0:%.*]] = load float, ptr [[PTR0]], align 4
 ; CHECK-NEXT:    [[LD1:%.*]] = load float, ptr [[PTR1]], align 4
-; CHECK-NEXT:    [[VECL:%.*]] = load <2 x float>, ptr [[PTR0]], align 4
-; CHECK-NEXT:    store <2 x float> [[VECL]], ptr [[PTR0]], align 4
+; CHECK-NEXT:    [[VECL:%.*]] = load <2 x float>, ptr [[PTR0]], align 4, !sandboxvec [[META5:![0-9]+]]
+; CHECK-NEXT:    store <2 x float> [[VECL]], ptr [[PTR0]], align 4, !sandboxvec [[META5]]
 ; CHECK-NEXT:    [[USER:%.*]] = fneg float [[LD1]]
 ; CHECK-NEXT:    ret float [[LD0]]
+;
+; REVERT-LABEL: define float @scalars_with_external_uses_not_dead(
+; REVERT-SAME: ptr [[PTR:%.*]]) {
+; REVERT-NEXT:    [[PTR0:%.*]] = getelementptr float, ptr [[PTR]], i32 0
+; REVERT-NEXT:    [[PTR1:%.*]] = getelementptr float, ptr [[PTR]], i32 1
+; REVERT-NEXT:    [[LD0:%.*]] = load float, ptr [[PTR0]], align 4
+; REVERT-NEXT:    [[LD1:%.*]] = load float, ptr [[PTR1]], align 4
+; REVERT-NEXT:    store float [[LD0]], ptr [[PTR0]], align 4, !sandboxvec [[META5:![0-9]+]]
+; REVERT-NEXT:    store float [[LD1]], ptr [[PTR1]], align 4, !sandboxvec [[META5]]
+; REVERT-NEXT:    [[USER:%.*]] = fneg float [[LD1]]
+; REVERT-NEXT:    ret float [[LD0]]
 ;
   %ptr0 = getelementptr float, ptr %ptr, i32 0
   %ptr1 = getelementptr float, ptr %ptr, i32 1
@@ -142,10 +222,20 @@ define void @pack_scalars(ptr %ptr, ptr %ptr2) {
 ; CHECK-NEXT:    [[PTR0:%.*]] = getelementptr float, ptr [[PTR]], i32 0
 ; CHECK-NEXT:    [[LD0:%.*]] = load float, ptr [[PTR0]], align 4
 ; CHECK-NEXT:    [[LD1:%.*]] = load float, ptr [[PTR2]], align 4
-; CHECK-NEXT:    [[PACK:%.*]] = insertelement <2 x float> poison, float [[LD0]], i32 0
-; CHECK-NEXT:    [[PACK1:%.*]] = insertelement <2 x float> [[PACK]], float [[LD1]], i32 1
-; CHECK-NEXT:    store <2 x float> [[PACK1]], ptr [[PTR0]], align 4
+; CHECK-NEXT:    [[PACK:%.*]] = insertelement <2 x float> poison, float [[LD0]], i32 0, !sandboxvec [[META6:![0-9]+]]
+; CHECK-NEXT:    [[PACK1:%.*]] = insertelement <2 x float> [[PACK]], float [[LD1]], i32 1, !sandboxvec [[META6]]
+; CHECK-NEXT:    store <2 x float> [[PACK1]], ptr [[PTR0]], align 4, !sandboxvec [[META6]]
 ; CHECK-NEXT:    ret void
+;
+; REVERT-LABEL: define void @pack_scalars(
+; REVERT-SAME: ptr [[PTR:%.*]], ptr [[PTR2:%.*]]) {
+; REVERT-NEXT:    [[PTR0:%.*]] = getelementptr float, ptr [[PTR]], i32 0
+; REVERT-NEXT:    [[PTR1:%.*]] = getelementptr float, ptr [[PTR]], i32 1, !sandboxvec [[META6:![0-9]+]]
+; REVERT-NEXT:    [[LD0:%.*]] = load float, ptr [[PTR0]], align 4
+; REVERT-NEXT:    [[LD1:%.*]] = load float, ptr [[PTR2]], align 4
+; REVERT-NEXT:    store float [[LD0]], ptr [[PTR0]], align 4, !sandboxvec [[META6]]
+; REVERT-NEXT:    store float [[LD1]], ptr [[PTR1]], align 4, !sandboxvec [[META6]]
+; REVERT-NEXT:    ret void
 ;
   %ptr0 = getelementptr float, ptr %ptr, i32 0
   %ptr1 = getelementptr float, ptr %ptr, i32 1
@@ -168,6 +258,17 @@ define void @cant_vectorize_seeds(ptr %ptr) {
 ; CHECK-NEXT:    call void @foo()
 ; CHECK-NEXT:    store float [[LD1]], ptr [[PTR1]], align 4
 ; CHECK-NEXT:    ret void
+;
+; REVERT-LABEL: define void @cant_vectorize_seeds(
+; REVERT-SAME: ptr [[PTR:%.*]]) {
+; REVERT-NEXT:    [[PTR0:%.*]] = getelementptr float, ptr [[PTR]], i32 0
+; REVERT-NEXT:    [[PTR1:%.*]] = getelementptr float, ptr [[PTR]], i32 1
+; REVERT-NEXT:    [[LD0:%.*]] = load float, ptr [[PTR0]], align 4
+; REVERT-NEXT:    [[LD1:%.*]] = load float, ptr [[PTR1]], align 4
+; REVERT-NEXT:    store float [[LD1]], ptr [[PTR1]], align 4
+; REVERT-NEXT:    call void @foo()
+; REVERT-NEXT:    store float [[LD1]], ptr [[PTR1]], align 4
+; REVERT-NEXT:    ret void
 ;
   %ptr0 = getelementptr float, ptr %ptr, i32 0
   %ptr1 = getelementptr float, ptr %ptr, i32 1
@@ -185,13 +286,23 @@ define void @pack_vectors(ptr %ptr, ptr %ptr2) {
 ; CHECK-NEXT:    [[PTR0:%.*]] = getelementptr <2 x float>, ptr [[PTR]], i32 0
 ; CHECK-NEXT:    [[LD0:%.*]] = load <2 x float>, ptr [[PTR0]], align 8
 ; CHECK-NEXT:    [[LD1:%.*]] = load float, ptr [[PTR2]], align 4
-; CHECK-NEXT:    [[VPACK:%.*]] = extractelement <2 x float> [[LD0]], i32 0
-; CHECK-NEXT:    [[VPACK1:%.*]] = insertelement <3 x float> poison, float [[VPACK]], i32 0
-; CHECK-NEXT:    [[VPACK2:%.*]] = extractelement <2 x float> [[LD0]], i32 1
-; CHECK-NEXT:    [[VPACK3:%.*]] = insertelement <3 x float> [[VPACK1]], float [[VPACK2]], i32 1
-; CHECK-NEXT:    [[PACK:%.*]] = insertelement <3 x float> [[VPACK3]], float [[LD1]], i32 2
-; CHECK-NEXT:    store <3 x float> [[PACK]], ptr [[PTR0]], align 8
+; CHECK-NEXT:    [[VPACK:%.*]] = extractelement <2 x float> [[LD0]], i32 0, !sandboxvec [[META7:![0-9]+]]
+; CHECK-NEXT:    [[VPACK1:%.*]] = insertelement <3 x float> poison, float [[VPACK]], i32 0, !sandboxvec [[META7]]
+; CHECK-NEXT:    [[VPACK2:%.*]] = extractelement <2 x float> [[LD0]], i32 1, !sandboxvec [[META7]]
+; CHECK-NEXT:    [[VPACK3:%.*]] = insertelement <3 x float> [[VPACK1]], float [[VPACK2]], i32 1, !sandboxvec [[META7]]
+; CHECK-NEXT:    [[PACK:%.*]] = insertelement <3 x float> [[VPACK3]], float [[LD1]], i32 2, !sandboxvec [[META7]]
+; CHECK-NEXT:    store <3 x float> [[PACK]], ptr [[PTR0]], align 8, !sandboxvec [[META7]]
 ; CHECK-NEXT:    ret void
+;
+; REVERT-LABEL: define void @pack_vectors(
+; REVERT-SAME: ptr [[PTR:%.*]], ptr [[PTR2:%.*]]) {
+; REVERT-NEXT:    [[PTR0:%.*]] = getelementptr <2 x float>, ptr [[PTR]], i32 0
+; REVERT-NEXT:    [[PTR1:%.*]] = getelementptr float, ptr [[PTR]], i32 2, !sandboxvec [[META7:![0-9]+]]
+; REVERT-NEXT:    [[LD0:%.*]] = load <2 x float>, ptr [[PTR0]], align 8
+; REVERT-NEXT:    [[LD1:%.*]] = load float, ptr [[PTR2]], align 4
+; REVERT-NEXT:    store <2 x float> [[LD0]], ptr [[PTR0]], align 8, !sandboxvec [[META7]]
+; REVERT-NEXT:    store float [[LD1]], ptr [[PTR1]], align 4, !sandboxvec [[META7]]
+; REVERT-NEXT:    ret void
 ;
   %ptr0 = getelementptr <2 x float>, ptr %ptr, i32 0
   %ptr1 = getelementptr float, ptr %ptr, i32 2
@@ -206,10 +317,22 @@ define void @diamond(ptr %ptr) {
 ; CHECK-LABEL: define void @diamond(
 ; CHECK-SAME: ptr [[PTR:%.*]]) {
 ; CHECK-NEXT:    [[PTR0:%.*]] = getelementptr float, ptr [[PTR]], i32 0
-; CHECK-NEXT:    [[VECL:%.*]] = load <2 x float>, ptr [[PTR0]], align 4
-; CHECK-NEXT:    [[VEC:%.*]] = fsub <2 x float> [[VECL]], [[VECL]]
-; CHECK-NEXT:    store <2 x float> [[VEC]], ptr [[PTR0]], align 4
+; CHECK-NEXT:    [[VECL:%.*]] = load <2 x float>, ptr [[PTR0]], align 4, !sandboxvec [[META8:![0-9]+]]
+; CHECK-NEXT:    [[VEC:%.*]] = fsub <2 x float> [[VECL]], [[VECL]], !sandboxvec [[META8]]
+; CHECK-NEXT:    store <2 x float> [[VEC]], ptr [[PTR0]], align 4, !sandboxvec [[META8]]
 ; CHECK-NEXT:    ret void
+;
+; REVERT-LABEL: define void @diamond(
+; REVERT-SAME: ptr [[PTR:%.*]]) {
+; REVERT-NEXT:    [[PTR0:%.*]] = getelementptr float, ptr [[PTR]], i32 0
+; REVERT-NEXT:    [[PTR1:%.*]] = getelementptr float, ptr [[PTR]], i32 1, !sandboxvec [[META8:![0-9]+]]
+; REVERT-NEXT:    [[LD0:%.*]] = load float, ptr [[PTR0]], align 4, !sandboxvec [[META8]]
+; REVERT-NEXT:    [[LD1:%.*]] = load float, ptr [[PTR1]], align 4, !sandboxvec [[META8]]
+; REVERT-NEXT:    [[SUB0:%.*]] = fsub float [[LD0]], [[LD0]], !sandboxvec [[META8]]
+; REVERT-NEXT:    [[SUB1:%.*]] = fsub float [[LD1]], [[LD1]], !sandboxvec [[META8]]
+; REVERT-NEXT:    store float [[SUB0]], ptr [[PTR0]], align 4, !sandboxvec [[META8]]
+; REVERT-NEXT:    store float [[SUB1]], ptr [[PTR1]], align 4, !sandboxvec [[META8]]
+; REVERT-NEXT:    ret void
 ;
   %ptr0 = getelementptr float, ptr %ptr, i32 0
   %ptr1 = getelementptr float, ptr %ptr, i32 1
@@ -226,11 +349,23 @@ define void @diamondWithShuffle(ptr %ptr) {
 ; CHECK-LABEL: define void @diamondWithShuffle(
 ; CHECK-SAME: ptr [[PTR:%.*]]) {
 ; CHECK-NEXT:    [[PTR0:%.*]] = getelementptr float, ptr [[PTR]], i32 0
-; CHECK-NEXT:    [[VECL:%.*]] = load <2 x float>, ptr [[PTR0]], align 4
-; CHECK-NEXT:    [[VSHUF:%.*]] = shufflevector <2 x float> [[VECL]], <2 x float> [[VECL]], <2 x i32> <i32 1, i32 0>
-; CHECK-NEXT:    [[VEC:%.*]] = fsub <2 x float> [[VECL]], [[VSHUF]]
-; CHECK-NEXT:    store <2 x float> [[VEC]], ptr [[PTR0]], align 4
+; CHECK-NEXT:    [[VECL:%.*]] = load <2 x float>, ptr [[PTR0]], align 4, !sandboxvec [[META9:![0-9]+]]
+; CHECK-NEXT:    [[VSHUF:%.*]] = shufflevector <2 x float> [[VECL]], <2 x float> [[VECL]], <2 x i32> <i32 1, i32 0>, !sandboxvec [[META9]]
+; CHECK-NEXT:    [[VEC:%.*]] = fsub <2 x float> [[VECL]], [[VSHUF]], !sandboxvec [[META9]]
+; CHECK-NEXT:    store <2 x float> [[VEC]], ptr [[PTR0]], align 4, !sandboxvec [[META9]]
 ; CHECK-NEXT:    ret void
+;
+; REVERT-LABEL: define void @diamondWithShuffle(
+; REVERT-SAME: ptr [[PTR:%.*]]) {
+; REVERT-NEXT:    [[PTR0:%.*]] = getelementptr float, ptr [[PTR]], i32 0
+; REVERT-NEXT:    [[PTR1:%.*]] = getelementptr float, ptr [[PTR]], i32 1, !sandboxvec [[META9:![0-9]+]]
+; REVERT-NEXT:    [[LD0:%.*]] = load float, ptr [[PTR0]], align 4, !sandboxvec [[META9]]
+; REVERT-NEXT:    [[LD1:%.*]] = load float, ptr [[PTR1]], align 4, !sandboxvec [[META9]]
+; REVERT-NEXT:    [[SUB0:%.*]] = fsub float [[LD0]], [[LD1]], !sandboxvec [[META9]]
+; REVERT-NEXT:    [[SUB1:%.*]] = fsub float [[LD1]], [[LD0]], !sandboxvec [[META9]]
+; REVERT-NEXT:    store float [[SUB0]], ptr [[PTR0]], align 4, !sandboxvec [[META9]]
+; REVERT-NEXT:    store float [[SUB1]], ptr [[PTR1]], align 4, !sandboxvec [[META9]]
+; REVERT-NEXT:    ret void
 ;
   %ptr0 = getelementptr float, ptr %ptr, i32 0
   %ptr1 = getelementptr float, ptr %ptr, i32 1
@@ -248,11 +383,23 @@ define void @diamondWithShuffleFromVec(ptr %ptr) {
 ; CHECK-LABEL: define void @diamondWithShuffleFromVec(
 ; CHECK-SAME: ptr [[PTR:%.*]]) {
 ; CHECK-NEXT:    [[PTR0:%.*]] = getelementptr <2 x float>, ptr [[PTR]], i32 0
-; CHECK-NEXT:    [[VECL:%.*]] = load <4 x float>, ptr [[PTR0]], align 8
-; CHECK-NEXT:    [[VSHUF:%.*]] = shufflevector <4 x float> [[VECL]], <4 x float> [[VECL]], <4 x i32> <i32 2, i32 3, i32 0, i32 1>
-; CHECK-NEXT:    [[VEC:%.*]] = fsub <4 x float> [[VECL]], [[VSHUF]]
-; CHECK-NEXT:    store <4 x float> [[VEC]], ptr [[PTR0]], align 8
+; CHECK-NEXT:    [[VECL:%.*]] = load <4 x float>, ptr [[PTR0]], align 8, !sandboxvec [[META10:![0-9]+]]
+; CHECK-NEXT:    [[VSHUF:%.*]] = shufflevector <4 x float> [[VECL]], <4 x float> [[VECL]], <4 x i32> <i32 2, i32 3, i32 0, i32 1>, !sandboxvec [[META10]]
+; CHECK-NEXT:    [[VEC:%.*]] = fsub <4 x float> [[VECL]], [[VSHUF]], !sandboxvec [[META10]]
+; CHECK-NEXT:    store <4 x float> [[VEC]], ptr [[PTR0]], align 8, !sandboxvec [[META10]]
 ; CHECK-NEXT:    ret void
+;
+; REVERT-LABEL: define void @diamondWithShuffleFromVec(
+; REVERT-SAME: ptr [[PTR:%.*]]) {
+; REVERT-NEXT:    [[PTR0:%.*]] = getelementptr <2 x float>, ptr [[PTR]], i32 0
+; REVERT-NEXT:    [[PTR1:%.*]] = getelementptr <2 x float>, ptr [[PTR]], i32 1, !sandboxvec [[META10:![0-9]+]]
+; REVERT-NEXT:    [[LD0:%.*]] = load <2 x float>, ptr [[PTR0]], align 8, !sandboxvec [[META10]]
+; REVERT-NEXT:    [[LD1:%.*]] = load <2 x float>, ptr [[PTR1]], align 8, !sandboxvec [[META10]]
+; REVERT-NEXT:    [[SUB0:%.*]] = fsub <2 x float> [[LD0]], [[LD1]], !sandboxvec [[META10]]
+; REVERT-NEXT:    [[SUB1:%.*]] = fsub <2 x float> [[LD1]], [[LD0]], !sandboxvec [[META10]]
+; REVERT-NEXT:    store <2 x float> [[SUB0]], ptr [[PTR0]], align 8, !sandboxvec [[META10]]
+; REVERT-NEXT:    store <2 x float> [[SUB1]], ptr [[PTR1]], align 8, !sandboxvec [[META10]]
+; REVERT-NEXT:    ret void
 ;
   %ptr0 = getelementptr <2 x float>, ptr %ptr, i32 0
   %ptr1 = getelementptr <2 x float>, ptr %ptr, i32 1
@@ -270,13 +417,26 @@ define void @diamondMultiInput(ptr %ptr, ptr %ptrX) {
 ; CHECK-SAME: ptr [[PTR:%.*]], ptr [[PTRX:%.*]]) {
 ; CHECK-NEXT:    [[PTR0:%.*]] = getelementptr float, ptr [[PTR]], i32 0
 ; CHECK-NEXT:    [[LDX:%.*]] = load float, ptr [[PTRX]], align 4
-; CHECK-NEXT:    [[VECL:%.*]] = load <2 x float>, ptr [[PTR0]], align 4
-; CHECK-NEXT:    [[VINS:%.*]] = insertelement <2 x float> poison, float [[LDX]], i32 0
-; CHECK-NEXT:    [[VEXT:%.*]] = extractelement <2 x float> [[VECL]], i32 0
-; CHECK-NEXT:    [[VINS1:%.*]] = insertelement <2 x float> [[VINS]], float [[VEXT]], i32 1
-; CHECK-NEXT:    [[VEC:%.*]] = fsub <2 x float> [[VECL]], [[VINS1]]
-; CHECK-NEXT:    store <2 x float> [[VEC]], ptr [[PTR0]], align 4
+; CHECK-NEXT:    [[VECL:%.*]] = load <2 x float>, ptr [[PTR0]], align 4, !sandboxvec [[META11:![0-9]+]]
+; CHECK-NEXT:    [[VINS:%.*]] = insertelement <2 x float> poison, float [[LDX]], i32 0, !sandboxvec [[META11]]
+; CHECK-NEXT:    [[VEXT:%.*]] = extractelement <2 x float> [[VECL]], i32 0, !sandboxvec [[META11]]
+; CHECK-NEXT:    [[VINS1:%.*]] = insertelement <2 x float> [[VINS]], float [[VEXT]], i32 1, !sandboxvec [[META11]]
+; CHECK-NEXT:    [[VEC:%.*]] = fsub <2 x float> [[VECL]], [[VINS1]], !sandboxvec [[META11]]
+; CHECK-NEXT:    store <2 x float> [[VEC]], ptr [[PTR0]], align 4, !sandboxvec [[META11]]
 ; CHECK-NEXT:    ret void
+;
+; REVERT-LABEL: define void @diamondMultiInput(
+; REVERT-SAME: ptr [[PTR:%.*]], ptr [[PTRX:%.*]]) {
+; REVERT-NEXT:    [[PTR0:%.*]] = getelementptr float, ptr [[PTR]], i32 0
+; REVERT-NEXT:    [[PTR1:%.*]] = getelementptr float, ptr [[PTR]], i32 1, !sandboxvec [[META11:![0-9]+]]
+; REVERT-NEXT:    [[LD0:%.*]] = load float, ptr [[PTR0]], align 4, !sandboxvec [[META11]]
+; REVERT-NEXT:    [[LD1:%.*]] = load float, ptr [[PTR1]], align 4, !sandboxvec [[META11]]
+; REVERT-NEXT:    [[LDX:%.*]] = load float, ptr [[PTRX]], align 4
+; REVERT-NEXT:    [[SUB0:%.*]] = fsub float [[LD0]], [[LDX]], !sandboxvec [[META11]]
+; REVERT-NEXT:    [[SUB1:%.*]] = fsub float [[LD1]], [[LD0]], !sandboxvec [[META11]]
+; REVERT-NEXT:    store float [[SUB0]], ptr [[PTR0]], align 4, !sandboxvec [[META11]]
+; REVERT-NEXT:    store float [[SUB1]], ptr [[PTR1]], align 4, !sandboxvec [[META11]]
+; REVERT-NEXT:    ret void
 ;
   %ptr0 = getelementptr float, ptr %ptr, i32 0
   %ptr1 = getelementptr float, ptr %ptr, i32 1
@@ -298,18 +458,31 @@ define void @diamondMultiInputVector(ptr %ptr, ptr %ptrX) {
 ; CHECK-SAME: ptr [[PTR:%.*]], ptr [[PTRX:%.*]]) {
 ; CHECK-NEXT:    [[PTR0:%.*]] = getelementptr <2 x float>, ptr [[PTR]], i32 0
 ; CHECK-NEXT:    [[LDX:%.*]] = load <2 x float>, ptr [[PTRX]], align 8
-; CHECK-NEXT:    [[VECL:%.*]] = load <4 x float>, ptr [[PTR0]], align 8
-; CHECK-NEXT:    [[VEXT:%.*]] = extractelement <2 x float> [[LDX]], i32 0
-; CHECK-NEXT:    [[INSI:%.*]] = insertelement <4 x float> poison, float [[VEXT]], i32 0
-; CHECK-NEXT:    [[VEXT1:%.*]] = extractelement <2 x float> [[LDX]], i32 1
-; CHECK-NEXT:    [[INSI2:%.*]] = insertelement <4 x float> [[INSI]], float [[VEXT1]], i32 1
-; CHECK-NEXT:    [[VEXT3:%.*]] = extractelement <4 x float> [[VECL]], i32 0
-; CHECK-NEXT:    [[VINS4:%.*]] = insertelement <4 x float> [[INSI2]], float [[VEXT3]], i32 2
-; CHECK-NEXT:    [[VEXT4:%.*]] = extractelement <4 x float> [[VECL]], i32 1
-; CHECK-NEXT:    [[VINS5:%.*]] = insertelement <4 x float> [[VINS4]], float [[VEXT4]], i32 3
-; CHECK-NEXT:    [[VEC:%.*]] = fsub <4 x float> [[VECL]], [[VINS5]]
-; CHECK-NEXT:    store <4 x float> [[VEC]], ptr [[PTR0]], align 8
+; CHECK-NEXT:    [[VECL:%.*]] = load <4 x float>, ptr [[PTR0]], align 8, !sandboxvec [[META12:![0-9]+]]
+; CHECK-NEXT:    [[VEXT:%.*]] = extractelement <2 x float> [[LDX]], i32 0, !sandboxvec [[META12]]
+; CHECK-NEXT:    [[VINS:%.*]] = insertelement <4 x float> poison, float [[VEXT]], i32 0, !sandboxvec [[META12]]
+; CHECK-NEXT:    [[VEXT1:%.*]] = extractelement <2 x float> [[LDX]], i32 1, !sandboxvec [[META12]]
+; CHECK-NEXT:    [[VINS2:%.*]] = insertelement <4 x float> [[VINS]], float [[VEXT1]], i32 1, !sandboxvec [[META12]]
+; CHECK-NEXT:    [[VEXT3:%.*]] = extractelement <4 x float> [[VECL]], i32 0, !sandboxvec [[META12]]
+; CHECK-NEXT:    [[VINS4:%.*]] = insertelement <4 x float> [[VINS2]], float [[VEXT3]], i32 2, !sandboxvec [[META12]]
+; CHECK-NEXT:    [[VEXT5:%.*]] = extractelement <4 x float> [[VECL]], i32 1, !sandboxvec [[META12]]
+; CHECK-NEXT:    [[VINS6:%.*]] = insertelement <4 x float> [[VINS4]], float [[VEXT5]], i32 3, !sandboxvec [[META12]]
+; CHECK-NEXT:    [[VEC:%.*]] = fsub <4 x float> [[VECL]], [[VINS6]], !sandboxvec [[META12]]
+; CHECK-NEXT:    store <4 x float> [[VEC]], ptr [[PTR0]], align 8, !sandboxvec [[META12]]
 ; CHECK-NEXT:    ret void
+;
+; REVERT-LABEL: define void @diamondMultiInputVector(
+; REVERT-SAME: ptr [[PTR:%.*]], ptr [[PTRX:%.*]]) {
+; REVERT-NEXT:    [[PTR0:%.*]] = getelementptr <2 x float>, ptr [[PTR]], i32 0
+; REVERT-NEXT:    [[PTR1:%.*]] = getelementptr <2 x float>, ptr [[PTR]], i32 1, !sandboxvec [[META12:![0-9]+]]
+; REVERT-NEXT:    [[LD0:%.*]] = load <2 x float>, ptr [[PTR0]], align 8, !sandboxvec [[META12]]
+; REVERT-NEXT:    [[LD1:%.*]] = load <2 x float>, ptr [[PTR1]], align 8, !sandboxvec [[META12]]
+; REVERT-NEXT:    [[LDX:%.*]] = load <2 x float>, ptr [[PTRX]], align 8
+; REVERT-NEXT:    [[SUB0:%.*]] = fsub <2 x float> [[LD0]], [[LDX]], !sandboxvec [[META12]]
+; REVERT-NEXT:    [[SUB1:%.*]] = fsub <2 x float> [[LD1]], [[LD0]], !sandboxvec [[META12]]
+; REVERT-NEXT:    store <2 x float> [[SUB0]], ptr [[PTR0]], align 8, !sandboxvec [[META12]]
+; REVERT-NEXT:    store <2 x float> [[SUB1]], ptr [[PTR1]], align 8, !sandboxvec [[META12]]
+; REVERT-NEXT:    ret void
 ;
   %ptr0 = getelementptr <2 x float>, ptr %ptr, i32 0
   %ptr1 = getelementptr <2 x float>, ptr %ptr, i32 1
@@ -330,9 +503,25 @@ define void @diamondWithConstantVector(ptr %ptr) {
 ; CHECK-SAME: ptr [[PTR:%.*]]) {
 ; CHECK-NEXT:    [[GEPA0:%.*]] = getelementptr i32, ptr [[PTR]], i64 0
 ; CHECK-NEXT:    [[GEPB0:%.*]] = getelementptr i32, ptr [[PTR]], i64 10
-; CHECK-NEXT:    store <2 x i32> zeroinitializer, ptr [[GEPA0]], align 4
-; CHECK-NEXT:    store <2 x i32> zeroinitializer, ptr [[GEPB0]], align 4
+; CHECK-NEXT:    store <2 x i32> zeroinitializer, ptr [[GEPA0]], align 4, !sandboxvec [[META13:![0-9]+]]
+; CHECK-NEXT:    store <2 x i32> zeroinitializer, ptr [[GEPB0]], align 4, !sandboxvec [[META14:![0-9]+]]
 ; CHECK-NEXT:    ret void
+;
+; REVERT-LABEL: define void @diamondWithConstantVector(
+; REVERT-SAME: ptr [[PTR:%.*]]) {
+; REVERT-NEXT:    [[GEPA0:%.*]] = getelementptr i32, ptr [[PTR]], i64 0
+; REVERT-NEXT:    [[GEPA1:%.*]] = getelementptr i32, ptr [[PTR]], i64 1, !sandboxvec [[META13:![0-9]+]]
+; REVERT-NEXT:    [[GEPB0:%.*]] = getelementptr i32, ptr [[PTR]], i64 10
+; REVERT-NEXT:    [[GEPB1:%.*]] = getelementptr i32, ptr [[PTR]], i64 11, !sandboxvec [[META14:![0-9]+]]
+; REVERT-NEXT:    [[ZEXT0:%.*]] = zext i16 0 to i32
+; REVERT-NEXT:    [[ZEXT1:%.*]] = zext i16 0 to i32
+; REVERT-NEXT:    store i32 [[ZEXT0]], ptr [[GEPA0]], align 4, !sandboxvec [[META13]]
+; REVERT-NEXT:    store i32 [[ZEXT1]], ptr [[GEPA1]], align 4, !sandboxvec [[META13]]
+; REVERT-NEXT:    [[ORB0:%.*]] = or i32 0, [[ZEXT0]], !sandboxvec [[META14]]
+; REVERT-NEXT:    [[ORB1:%.*]] = or i32 0, [[ZEXT1]], !sandboxvec [[META14]]
+; REVERT-NEXT:    store i32 [[ORB0]], ptr [[GEPB0]], align 4, !sandboxvec [[META14]]
+; REVERT-NEXT:    store i32 [[ORB1]], ptr [[GEPB1]], align 4, !sandboxvec [[META14]]
+; REVERT-NEXT:    ret void
 ;
   %gepA0 = getelementptr i32, ptr %ptr, i64 0
   %gepA1 = getelementptr i32, ptr %ptr, i64 1
@@ -358,13 +547,30 @@ define void @diamondWithConstantVector(ptr %ptr) {
 define void @vecInstrsPlacement(ptr %ptr0) {
 ; CHECK-LABEL: define void @vecInstrsPlacement(
 ; CHECK-SAME: ptr [[PTR0:%.*]]) {
-; CHECK-NEXT:    [[VECL2:%.*]] = load <2 x double>, ptr [[PTR0]], align 8
-; CHECK-NEXT:    [[VECL:%.*]] = load <2 x double>, ptr [[PTR0]], align 8
-; CHECK-NEXT:    [[VEC2:%.*]] = fmul <2 x double> [[VECL2]], [[VECL]]
-; CHECK-NEXT:    [[VEC:%.*]] = fmul <2 x double> [[VECL2]], [[VECL]]
-; CHECK-NEXT:    [[VEC5:%.*]] = fadd <2 x double> [[VEC]], [[VEC2]]
-; CHECK-NEXT:    store <2 x double> [[VEC5]], ptr [[PTR0]], align 8
+; CHECK-NEXT:    [[VECL:%.*]] = load <2 x double>, ptr [[PTR0]], align 8, !sandboxvec [[META15:![0-9]+]]
+; CHECK-NEXT:    [[VECL1:%.*]] = load <2 x double>, ptr [[PTR0]], align 8, !sandboxvec [[META15]]
+; CHECK-NEXT:    [[VEC2:%.*]] = fmul <2 x double> [[VECL]], [[VECL1]], !sandboxvec [[META15]]
+; CHECK-NEXT:    [[VEC:%.*]] = fmul <2 x double> [[VECL]], [[VECL1]], !sandboxvec [[META15]]
+; CHECK-NEXT:    [[VEC3:%.*]] = fadd <2 x double> [[VEC]], [[VEC2]], !sandboxvec [[META15]]
+; CHECK-NEXT:    store <2 x double> [[VEC3]], ptr [[PTR0]], align 8, !sandboxvec [[META15]]
 ; CHECK-NEXT:    ret void
+;
+; REVERT-LABEL: define void @vecInstrsPlacement(
+; REVERT-SAME: ptr [[PTR0:%.*]]) {
+; REVERT-NEXT:    [[PTR1:%.*]] = getelementptr inbounds double, ptr [[PTR0]], i64 1, !sandboxvec [[META15:![0-9]+]]
+; REVERT-NEXT:    [[LDA_0:%.*]] = load double, ptr [[PTR0]], align 8, !sandboxvec [[META15]]
+; REVERT-NEXT:    [[LDA_1:%.*]] = load double, ptr [[PTR1]], align 8, !sandboxvec [[META15]]
+; REVERT-NEXT:    [[LDB_0:%.*]] = load double, ptr [[PTR0]], align 8, !sandboxvec [[META15]]
+; REVERT-NEXT:    [[LDB_1:%.*]] = load double, ptr [[PTR1]], align 8, !sandboxvec [[META15]]
+; REVERT-NEXT:    [[MUL0:%.*]] = fmul double [[LDA_0]], [[LDB_0]], !sandboxvec [[META15]]
+; REVERT-NEXT:    [[MUL1:%.*]] = fmul double [[LDA_1]], [[LDB_1]], !sandboxvec [[META15]]
+; REVERT-NEXT:    [[MUL2:%.*]] = fmul double [[LDA_0]], [[LDB_0]], !sandboxvec [[META15]]
+; REVERT-NEXT:    [[MUL3:%.*]] = fmul double [[LDA_1]], [[LDB_1]], !sandboxvec [[META15]]
+; REVERT-NEXT:    [[ADD0:%.*]] = fadd double [[MUL0]], [[MUL2]], !sandboxvec [[META15]]
+; REVERT-NEXT:    [[ADD1:%.*]] = fadd double [[MUL1]], [[MUL3]], !sandboxvec [[META15]]
+; REVERT-NEXT:    store double [[ADD0]], ptr [[PTR0]], align 8, !sandboxvec [[META15]]
+; REVERT-NEXT:    store double [[ADD1]], ptr [[PTR1]], align 8, !sandboxvec [[META15]]
+; REVERT-NEXT:    ret void
 ;
   %ptr1 = getelementptr inbounds double, ptr %ptr0, i64 1
   %ldA_0 = load double, ptr %ptr0
@@ -396,13 +602,27 @@ define void @instrsInMultipleBundles(ptr noalias %ptr) {
 ; CHECK-NEXT:    [[GEP0:%.*]] = getelementptr i8, ptr [[PTR]], i64 0
 ; CHECK-NEXT:    [[GEP2:%.*]] = getelementptr i8, ptr [[PTR]], i64 2
 ; CHECK-NEXT:    [[LDA2:%.*]] = load i8, ptr [[GEP2]], align 1
-; CHECK-NEXT:    [[VECL:%.*]] = load <2 x i8>, ptr [[GEP0]], align 1
-; CHECK-NEXT:    [[VEXT:%.*]] = extractelement <2 x i8> [[VECL]], i32 1
-; CHECK-NEXT:    [[VINS:%.*]] = insertelement <2 x i8> poison, i8 [[VEXT]], i32 0
-; CHECK-NEXT:    [[VINS1:%.*]] = insertelement <2 x i8> [[VINS]], i8 [[LDA2]], i32 1
-; CHECK-NEXT:    [[VEC:%.*]] = add <2 x i8> [[VECL]], [[VINS1]]
-; CHECK-NEXT:    store <2 x i8> [[VEC]], ptr [[GEP0]], align 1
+; CHECK-NEXT:    [[VECL:%.*]] = load <2 x i8>, ptr [[GEP0]], align 1, !sandboxvec [[META16:![0-9]+]]
+; CHECK-NEXT:    [[VEXT:%.*]] = extractelement <2 x i8> [[VECL]], i32 1, !sandboxvec [[META16]]
+; CHECK-NEXT:    [[VINS:%.*]] = insertelement <2 x i8> poison, i8 [[VEXT]], i32 0, !sandboxvec [[META16]]
+; CHECK-NEXT:    [[VINS1:%.*]] = insertelement <2 x i8> [[VINS]], i8 [[LDA2]], i32 1, !sandboxvec [[META16]]
+; CHECK-NEXT:    [[VEC:%.*]] = add <2 x i8> [[VECL]], [[VINS1]], !sandboxvec [[META16]]
+; CHECK-NEXT:    store <2 x i8> [[VEC]], ptr [[GEP0]], align 1, !sandboxvec [[META16]]
 ; CHECK-NEXT:    ret void
+;
+; REVERT-LABEL: define void @instrsInMultipleBundles(
+; REVERT-SAME: ptr noalias [[PTR:%.*]]) {
+; REVERT-NEXT:    [[GEP0:%.*]] = getelementptr i8, ptr [[PTR]], i64 0
+; REVERT-NEXT:    [[GEP1:%.*]] = getelementptr i8, ptr [[PTR]], i64 1, !sandboxvec [[META16:![0-9]+]]
+; REVERT-NEXT:    [[GEP2:%.*]] = getelementptr i8, ptr [[PTR]], i64 2
+; REVERT-NEXT:    [[LDA0:%.*]] = load i8, ptr [[GEP0]], align 1, !sandboxvec [[META16]]
+; REVERT-NEXT:    [[LDA1:%.*]] = load i8, ptr [[GEP1]], align 1, !sandboxvec [[META16]]
+; REVERT-NEXT:    [[LDA2:%.*]] = load i8, ptr [[GEP2]], align 1
+; REVERT-NEXT:    [[ADD0:%.*]] = add i8 [[LDA0]], [[LDA1]], !sandboxvec [[META16]]
+; REVERT-NEXT:    [[ADD1:%.*]] = add i8 [[LDA1]], [[LDA2]], !sandboxvec [[META16]]
+; REVERT-NEXT:    store i8 [[ADD0]], ptr [[GEP0]], align 1, !sandboxvec [[META16]]
+; REVERT-NEXT:    store i8 [[ADD1]], ptr [[GEP1]], align 1, !sandboxvec [[META16]]
+; REVERT-NEXT:    ret void
 ;
   %gep0 = getelementptr i8, ptr %ptr, i64 0
   %gep1 = getelementptr i8, ptr %ptr, i64 1
@@ -421,10 +641,22 @@ define void @vectorize_constants(ptr %ptr) {
 ; CHECK-LABEL: define void @vectorize_constants(
 ; CHECK-SAME: ptr [[PTR:%.*]]) {
 ; CHECK-NEXT:    [[PTR0:%.*]] = getelementptr i8, ptr [[PTR]], i32 0
-; CHECK-NEXT:    [[VECL:%.*]] = load <2 x i8>, ptr [[PTR0]], align 1
-; CHECK-NEXT:    [[VEC:%.*]] = add <2 x i8> [[VECL]], <i8 0, i8 1>
-; CHECK-NEXT:    store <2 x i8> [[VEC]], ptr [[PTR0]], align 1
+; CHECK-NEXT:    [[VECL:%.*]] = load <2 x i8>, ptr [[PTR0]], align 1, !sandboxvec [[META17:![0-9]+]]
+; CHECK-NEXT:    [[VEC:%.*]] = add <2 x i8> [[VECL]], <i8 0, i8 1>, !sandboxvec [[META17]]
+; CHECK-NEXT:    store <2 x i8> [[VEC]], ptr [[PTR0]], align 1, !sandboxvec [[META17]]
 ; CHECK-NEXT:    ret void
+;
+; REVERT-LABEL: define void @vectorize_constants(
+; REVERT-SAME: ptr [[PTR:%.*]]) {
+; REVERT-NEXT:    [[PTR0:%.*]] = getelementptr i8, ptr [[PTR]], i32 0
+; REVERT-NEXT:    [[PTR1:%.*]] = getelementptr i8, ptr [[PTR]], i32 1, !sandboxvec [[META17:![0-9]+]]
+; REVERT-NEXT:    [[LD0:%.*]] = load i8, ptr [[PTR0]], align 1, !sandboxvec [[META17]]
+; REVERT-NEXT:    [[LD1:%.*]] = load i8, ptr [[PTR1]], align 1, !sandboxvec [[META17]]
+; REVERT-NEXT:    [[ADD0:%.*]] = add i8 [[LD0]], 0, !sandboxvec [[META17]]
+; REVERT-NEXT:    [[ADD1:%.*]] = add i8 [[LD1]], 1, !sandboxvec [[META17]]
+; REVERT-NEXT:    store i8 [[ADD0]], ptr [[PTR0]], align 1, !sandboxvec [[META17]]
+; REVERT-NEXT:    store i8 [[ADD1]], ptr [[PTR1]], align 1, !sandboxvec [[META17]]
+; REVERT-NEXT:    ret void
 ;
   %ptr0 = getelementptr i8, ptr %ptr, i32 0
   %ptr1 = getelementptr i8, ptr %ptr, i32 1
@@ -441,10 +673,22 @@ define void @vectorize_constant_vectors(ptr %ptr) {
 ; CHECK-LABEL: define void @vectorize_constant_vectors(
 ; CHECK-SAME: ptr [[PTR:%.*]]) {
 ; CHECK-NEXT:    [[PTR0:%.*]] = getelementptr <2 x i8>, ptr [[PTR]], i32 0
-; CHECK-NEXT:    [[VECL:%.*]] = load <4 x i8>, ptr [[PTR0]], align 2
-; CHECK-NEXT:    [[VEC:%.*]] = sub <4 x i8> [[VECL]], <i8 0, i8 0, i8 1, i8 1>
-; CHECK-NEXT:    store <4 x i8> [[VEC]], ptr [[PTR0]], align 2
+; CHECK-NEXT:    [[VECL:%.*]] = load <4 x i8>, ptr [[PTR0]], align 2, !sandboxvec [[META18:![0-9]+]]
+; CHECK-NEXT:    [[VEC:%.*]] = sub <4 x i8> [[VECL]], <i8 0, i8 0, i8 1, i8 1>, !sandboxvec [[META18]]
+; CHECK-NEXT:    store <4 x i8> [[VEC]], ptr [[PTR0]], align 2, !sandboxvec [[META18]]
 ; CHECK-NEXT:    ret void
+;
+; REVERT-LABEL: define void @vectorize_constant_vectors(
+; REVERT-SAME: ptr [[PTR:%.*]]) {
+; REVERT-NEXT:    [[PTR0:%.*]] = getelementptr <2 x i8>, ptr [[PTR]], i32 0
+; REVERT-NEXT:    [[PTR1:%.*]] = getelementptr <2 x i8>, ptr [[PTR]], i32 1, !sandboxvec [[META18:![0-9]+]]
+; REVERT-NEXT:    [[LD0:%.*]] = load <2 x i8>, ptr [[PTR0]], align 2, !sandboxvec [[META18]]
+; REVERT-NEXT:    [[LD1:%.*]] = load <2 x i8>, ptr [[PTR1]], align 2, !sandboxvec [[META18]]
+; REVERT-NEXT:    [[SUB0:%.*]] = sub <2 x i8> [[LD0]], zeroinitializer, !sandboxvec [[META18]]
+; REVERT-NEXT:    [[SUB1:%.*]] = sub <2 x i8> [[LD1]], splat (i8 1), !sandboxvec [[META18]]
+; REVERT-NEXT:    store <2 x i8> [[SUB0]], ptr [[PTR0]], align 2, !sandboxvec [[META18]]
+; REVERT-NEXT:    store <2 x i8> [[SUB1]], ptr [[PTR1]], align 2, !sandboxvec [[META18]]
+; REVERT-NEXT:    ret void
 ;
   %ptr0 = getelementptr <2 x i8>, ptr %ptr, i32 0
   %ptr1 = getelementptr <2 x i8>, ptr %ptr, i32 1
@@ -456,3 +700,44 @@ define void @vectorize_constant_vectors(ptr %ptr) {
   store <2 x i8> %sub1, ptr %ptr1
   ret void
 }
+;.
+; CHECK: [[META0]] = distinct !{!"sandboxregion"}
+; CHECK: [[META1]] = distinct !{!"sandboxregion"}
+; CHECK: [[META2]] = distinct !{!"sandboxregion"}
+; CHECK: [[META3]] = distinct !{!"sandboxregion"}
+; CHECK: [[META4]] = distinct !{!"sandboxregion"}
+; CHECK: [[META5]] = distinct !{!"sandboxregion"}
+; CHECK: [[META6]] = distinct !{!"sandboxregion"}
+; CHECK: [[META7]] = distinct !{!"sandboxregion"}
+; CHECK: [[META8]] = distinct !{!"sandboxregion"}
+; CHECK: [[META9]] = distinct !{!"sandboxregion"}
+; CHECK: [[META10]] = distinct !{!"sandboxregion"}
+; CHECK: [[META11]] = distinct !{!"sandboxregion"}
+; CHECK: [[META12]] = distinct !{!"sandboxregion"}
+; CHECK: [[META13]] = distinct !{!"sandboxregion"}
+; CHECK: [[META14]] = distinct !{!"sandboxregion"}
+; CHECK: [[META15]] = distinct !{!"sandboxregion"}
+; CHECK: [[META16]] = distinct !{!"sandboxregion"}
+; CHECK: [[META17]] = distinct !{!"sandboxregion"}
+; CHECK: [[META18]] = distinct !{!"sandboxregion"}
+;.
+; REVERT: [[META0]] = distinct !{!"sandboxregion"}
+; REVERT: [[META1]] = distinct !{!"sandboxregion"}
+; REVERT: [[META2]] = distinct !{!"sandboxregion"}
+; REVERT: [[META3]] = distinct !{!"sandboxregion"}
+; REVERT: [[META4]] = distinct !{!"sandboxregion"}
+; REVERT: [[META5]] = distinct !{!"sandboxregion"}
+; REVERT: [[META6]] = distinct !{!"sandboxregion"}
+; REVERT: [[META7]] = distinct !{!"sandboxregion"}
+; REVERT: [[META8]] = distinct !{!"sandboxregion"}
+; REVERT: [[META9]] = distinct !{!"sandboxregion"}
+; REVERT: [[META10]] = distinct !{!"sandboxregion"}
+; REVERT: [[META11]] = distinct !{!"sandboxregion"}
+; REVERT: [[META12]] = distinct !{!"sandboxregion"}
+; REVERT: [[META13]] = distinct !{!"sandboxregion"}
+; REVERT: [[META14]] = distinct !{!"sandboxregion"}
+; REVERT: [[META15]] = distinct !{!"sandboxregion"}
+; REVERT: [[META16]] = distinct !{!"sandboxregion"}
+; REVERT: [[META17]] = distinct !{!"sandboxregion"}
+; REVERT: [[META18]] = distinct !{!"sandboxregion"}
+;.