[llvm-branch-commits] [llvm] [GVN] Keep `poison` per lane when forwarding vectors (PR #237784)

Pedro Lobo via llvm-branch-commits llvm-branch-commits at lists.llvm.org
Sat Nov 14 14:47:27 PST 2026


https://github.com/pedroclobo updated https://github.com/llvm/llvm-project/pull/237784

>From 30a0b7aacea216ae09b6aae69540626ac96df6f8 Mon Sep 17 00:00:00 2001
From: Pedro Lobo <pedro.lobo at tecnico.ulisboa.pt>
Date: Sun, 25 Oct 2026 11:10:30 +0000
Subject: [PATCH 1/3] [GVN] Pre-commit tests for per-lane `poison` in forwarded
 vectors

---
 llvm/test/Transforms/GVN/vector-poison.ll | 244 ++++++++++++++++++++++
 1 file changed, 244 insertions(+)
 create mode 100644 llvm/test/Transforms/GVN/vector-poison.ll

diff --git a/llvm/test/Transforms/GVN/vector-poison.ll b/llvm/test/Transforms/GVN/vector-poison.ll
new file mode 100644
index 00000000000000..f80b5a0ee24c5f
--- /dev/null
+++ b/llvm/test/Transforms/GVN/vector-poison.ll
@@ -0,0 +1,244 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 6
+; RUN: opt < %s -data-layout="e-p:64:64:64-p1:32:32:32-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-n8:16:32:64" -passes=gvn -S | FileCheck %s --check-prefixes=CHECK,LE
+; RUN: opt < %s -data-layout="E-p:64:64:64-p1:32:32:32-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-n8:16:32:64" -passes=gvn -S | FileCheck %s --check-prefixes=CHECK,BE
+
+; Vectors track poison per lane, while integers track poison per value (either
+; the whole integer is valid, or it is poison).
+
+define i64 @pr99268(ptr %p, i1 %c) {
+; LE-LABEL: define i64 @pr99268(
+; LE-SAME: ptr [[P:%.*]], i1 [[C:%.*]]) {
+; LE-NEXT:  [[ENTRY:.*:]]
+; LE-NEXT:    br i1 [[C]], label %[[THEN:.*]], label %[[ELSE:.*]]
+; LE:       [[THEN]]:
+; LE-NEXT:    [[V:%.*]] = load <4 x i32>, ptr [[P]], align 16
+; LE-NEXT:    call void @use(<4 x i32> [[V]])
+; LE-NEXT:    [[TMP0:%.*]] = bitcast <4 x i32> [[V]] to i128
+; LE-NEXT:    [[TMP1:%.*]] = trunc i128 [[TMP0]] to i64
+; LE-NEXT:    br label %[[EXIT:.*]]
+; LE:       [[ELSE]]:
+; LE-NEXT:    [[L_PRE:%.*]] = load i64, ptr [[P]], align 4
+; LE-NEXT:    br label %[[EXIT]]
+; LE:       [[EXIT]]:
+; LE-NEXT:    [[L:%.*]] = phi i64 [ [[L_PRE]], %[[ELSE]] ], [ [[TMP1]], %[[THEN]] ]
+; LE-NEXT:    ret i64 [[L]]
+;
+; BE-LABEL: define i64 @pr99268(
+; BE-SAME: ptr [[P:%.*]], i1 [[C:%.*]]) {
+; BE-NEXT:  [[ENTRY:.*:]]
+; BE-NEXT:    br i1 [[C]], label %[[THEN:.*]], label %[[ELSE:.*]]
+; BE:       [[THEN]]:
+; BE-NEXT:    [[V:%.*]] = load <4 x i32>, ptr [[P]], align 16
+; BE-NEXT:    call void @use(<4 x i32> [[V]])
+; BE-NEXT:    [[TMP0:%.*]] = bitcast <4 x i32> [[V]] to i128
+; BE-NEXT:    [[TMP1:%.*]] = lshr i128 [[TMP0]], 64
+; BE-NEXT:    [[TMP2:%.*]] = trunc i128 [[TMP1]] to i64
+; BE-NEXT:    br label %[[EXIT:.*]]
+; BE:       [[ELSE]]:
+; BE-NEXT:    [[L_PRE:%.*]] = load i64, ptr [[P]], align 4
+; BE-NEXT:    br label %[[EXIT]]
+; BE:       [[EXIT]]:
+; BE-NEXT:    [[L:%.*]] = phi i64 [ [[L_PRE]], %[[ELSE]] ], [ [[TMP2]], %[[THEN]] ]
+; BE-NEXT:    ret i64 [[L]]
+;
+entry:
+  br i1 %c, label %then, label %else
+
+then:
+  %v = load <4 x i32>, ptr %p, align 16
+  call void @use(<4 x i32> %v)
+  br label %exit
+
+else:
+  br label %exit
+
+exit:
+  %l = load i64, ptr %p, align 4
+  ret i64 %l
+}
+
+define <2 x i64> @pr209935(<4 x i64> %v, ptr %p) {
+; LE-LABEL: define <2 x i64> @pr209935(
+; LE-SAME: <4 x i64> [[V:%.*]], ptr [[P:%.*]]) {
+; LE-NEXT:    store <4 x i64> [[V]], ptr [[P]], align 8
+; LE-NEXT:    [[TMP1:%.*]] = bitcast <4 x i64> [[V]] to i256
+; LE-NEXT:    [[TMP2:%.*]] = trunc i256 [[TMP1]] to i128
+; LE-NEXT:    [[TMP3:%.*]] = bitcast i128 [[TMP2]] to <2 x i64>
+; LE-NEXT:    ret <2 x i64> [[TMP3]]
+;
+; BE-LABEL: define <2 x i64> @pr209935(
+; BE-SAME: <4 x i64> [[V:%.*]], ptr [[P:%.*]]) {
+; BE-NEXT:    store <4 x i64> [[V]], ptr [[P]], align 8
+; BE-NEXT:    [[TMP1:%.*]] = bitcast <4 x i64> [[V]] to i256
+; BE-NEXT:    [[TMP2:%.*]] = lshr i256 [[TMP1]], 128
+; BE-NEXT:    [[TMP3:%.*]] = trunc i256 [[TMP2]] to i128
+; BE-NEXT:    [[TMP4:%.*]] = bitcast i128 [[TMP3]] to <2 x i64>
+; BE-NEXT:    ret <2 x i64> [[TMP4]]
+;
+  store <4 x i64> %v, ptr %p, align 8
+  %l = load <2 x i64>, ptr %p, align 8
+  ret <2 x i64> %l
+}
+
+define i16 @store_v4i32_to_i16_straddle(<4 x i32> %v, ptr %p) {
+; LE-LABEL: define i16 @store_v4i32_to_i16_straddle(
+; LE-SAME: <4 x i32> [[V:%.*]], ptr [[P:%.*]]) {
+; LE-NEXT:    store <4 x i32> [[V]], ptr [[P]], align 16
+; LE-NEXT:    [[Q:%.*]] = getelementptr i8, ptr [[P]], i64 3
+; LE-NEXT:    [[TMP1:%.*]] = bitcast <4 x i32> [[V]] to i128
+; LE-NEXT:    [[TMP2:%.*]] = lshr i128 [[TMP1]], 24
+; LE-NEXT:    [[TMP3:%.*]] = trunc i128 [[TMP2]] to i16
+; LE-NEXT:    ret i16 [[TMP3]]
+;
+; BE-LABEL: define i16 @store_v4i32_to_i16_straddle(
+; BE-SAME: <4 x i32> [[V:%.*]], ptr [[P:%.*]]) {
+; BE-NEXT:    store <4 x i32> [[V]], ptr [[P]], align 16
+; BE-NEXT:    [[Q:%.*]] = getelementptr i8, ptr [[P]], i64 3
+; BE-NEXT:    [[TMP1:%.*]] = bitcast <4 x i32> [[V]] to i128
+; BE-NEXT:    [[TMP2:%.*]] = lshr i128 [[TMP1]], 88
+; BE-NEXT:    [[TMP3:%.*]] = trunc i128 [[TMP2]] to i16
+; BE-NEXT:    ret i16 [[TMP3]]
+;
+  store <4 x i32> %v, ptr %p
+  %q = getelementptr i8, ptr %p, i64 3
+  %l = load i16, ptr %q, align 1
+  ret i16 %l
+}
+
+define <4 x float> @store_v4i32_to_v4f32(<4 x i32> %v, ptr %p) {
+; CHECK-LABEL: define <4 x float> @store_v4i32_to_v4f32(
+; CHECK-SAME: <4 x i32> [[V:%.*]], ptr [[P:%.*]]) {
+; CHECK-NEXT:    store <4 x i32> [[V]], ptr [[P]], align 16
+; CHECK-NEXT:    [[TMP1:%.*]] = bitcast <4 x i32> [[V]] to i128
+; CHECK-NEXT:    [[TMP2:%.*]] = bitcast i128 [[TMP1]] to <4 x float>
+; CHECK-NEXT:    ret <4 x float> [[TMP2]]
+;
+  store <4 x i32> %v, ptr %p
+  %l = load <4 x float>, ptr %p
+  ret <4 x float> %l
+}
+
+define i64 @store_v2ptr_to_i64(<2 x ptr> %v, ptr %p) {
+; LE-LABEL: define i64 @store_v2ptr_to_i64(
+; LE-SAME: <2 x ptr> [[V:%.*]], ptr [[P:%.*]]) {
+; LE-NEXT:    store <2 x ptr> [[V]], ptr [[P]], align 16
+; LE-NEXT:    [[Q:%.*]] = getelementptr i8, ptr [[P]], i64 8
+; LE-NEXT:    [[TMP1:%.*]] = ptrtoint <2 x ptr> [[V]] to <2 x i64>
+; LE-NEXT:    [[TMP2:%.*]] = bitcast <2 x i64> [[TMP1]] to i128
+; LE-NEXT:    [[TMP3:%.*]] = lshr i128 [[TMP2]], 64
+; LE-NEXT:    [[TMP4:%.*]] = trunc i128 [[TMP3]] to i64
+; LE-NEXT:    ret i64 [[TMP4]]
+;
+; BE-LABEL: define i64 @store_v2ptr_to_i64(
+; BE-SAME: <2 x ptr> [[V:%.*]], ptr [[P:%.*]]) {
+; BE-NEXT:    store <2 x ptr> [[V]], ptr [[P]], align 16
+; BE-NEXT:    [[Q:%.*]] = getelementptr i8, ptr [[P]], i64 8
+; BE-NEXT:    [[TMP1:%.*]] = ptrtoint <2 x ptr> [[V]] to <2 x i64>
+; BE-NEXT:    [[TMP2:%.*]] = bitcast <2 x i64> [[TMP1]] to i128
+; BE-NEXT:    [[TMP3:%.*]] = trunc i128 [[TMP2]] to i64
+; BE-NEXT:    ret i64 [[TMP3]]
+;
+  store <2 x ptr> %v, ptr %p
+  %q = getelementptr i8, ptr %p, i64 8
+  %l = load i64, ptr %q
+  ret i64 %l
+}
+
+define <4 x i32> @store_v2ptr_to_v4i32(<2 x ptr> %v, ptr %p) {
+; CHECK-LABEL: define <4 x i32> @store_v2ptr_to_v4i32(
+; CHECK-SAME: <2 x ptr> [[V:%.*]], ptr [[P:%.*]]) {
+; CHECK-NEXT:    store <2 x ptr> [[V]], ptr [[P]], align 16
+; CHECK-NEXT:    [[TMP1:%.*]] = ptrtoint <2 x ptr> [[V]] to <2 x i64>
+; CHECK-NEXT:    [[TMP2:%.*]] = bitcast <2 x i64> [[TMP1]] to i128
+; CHECK-NEXT:    [[TMP3:%.*]] = bitcast i128 [[TMP2]] to <4 x i32>
+; CHECK-NEXT:    ret <4 x i32> [[TMP3]]
+;
+  store <2 x ptr> %v, ptr %p
+  %l = load <4 x i32>, ptr %p
+  ret <4 x i32> %l
+}
+
+define <2 x ptr> @store_v4i32_to_v2ptr(<4 x i32> %v, ptr %p) {
+; CHECK-LABEL: define <2 x ptr> @store_v4i32_to_v2ptr(
+; CHECK-SAME: <4 x i32> [[V:%.*]], ptr [[P:%.*]]) {
+; CHECK-NEXT:    store <4 x i32> [[V]], ptr [[P]], align 16
+; CHECK-NEXT:    [[TMP1:%.*]] = bitcast <4 x i32> [[V]] to i128
+; CHECK-NEXT:    [[TMP2:%.*]] = bitcast i128 [[TMP1]] to <2 x i64>
+; CHECK-NEXT:    [[TMP3:%.*]] = inttoptr <2 x i64> [[TMP2]] to <2 x ptr>
+; CHECK-NEXT:    ret <2 x ptr> [[TMP3]]
+;
+  store <4 x i32> %v, ptr %p
+  %l = load <2 x ptr>, ptr %p
+  ret <2 x ptr> %l
+}
+
+define ptr @store_v2i64_to_ptr(<2 x i64> %v, ptr %p) {
+; LE-LABEL: define ptr @store_v2i64_to_ptr(
+; LE-SAME: <2 x i64> [[V:%.*]], ptr [[P:%.*]]) {
+; LE-NEXT:    store <2 x i64> [[V]], ptr [[P]], align 16
+; LE-NEXT:    [[Q:%.*]] = getelementptr i8, ptr [[P]], i64 8
+; LE-NEXT:    [[TMP1:%.*]] = bitcast <2 x i64> [[V]] to i128
+; LE-NEXT:    [[TMP2:%.*]] = lshr i128 [[TMP1]], 64
+; LE-NEXT:    [[TMP3:%.*]] = trunc i128 [[TMP2]] to i64
+; LE-NEXT:    [[TMP4:%.*]] = inttoptr i64 [[TMP3]] to ptr
+; LE-NEXT:    ret ptr [[TMP4]]
+;
+; BE-LABEL: define ptr @store_v2i64_to_ptr(
+; BE-SAME: <2 x i64> [[V:%.*]], ptr [[P:%.*]]) {
+; BE-NEXT:    store <2 x i64> [[V]], ptr [[P]], align 16
+; BE-NEXT:    [[Q:%.*]] = getelementptr i8, ptr [[P]], i64 8
+; BE-NEXT:    [[TMP1:%.*]] = bitcast <2 x i64> [[V]] to i128
+; BE-NEXT:    [[TMP2:%.*]] = trunc i128 [[TMP1]] to i64
+; BE-NEXT:    [[TMP3:%.*]] = inttoptr i64 [[TMP2]] to ptr
+; BE-NEXT:    ret ptr [[TMP3]]
+;
+  store <2 x i64> %v, ptr %p
+  %q = getelementptr i8, ptr %p, i64 8
+  %l = load ptr, ptr %q
+  ret ptr %l
+}
+
+define ptr @store_v2ptr_to_ptr(<2 x ptr> %v, ptr %p) {
+; LE-LABEL: define ptr @store_v2ptr_to_ptr(
+; LE-SAME: <2 x ptr> [[V:%.*]], ptr [[P:%.*]]) {
+; LE-NEXT:    store <2 x ptr> [[V]], ptr [[P]], align 16
+; LE-NEXT:    [[Q:%.*]] = getelementptr i8, ptr [[P]], i64 8
+; LE-NEXT:    [[TMP1:%.*]] = ptrtoint <2 x ptr> [[V]] to <2 x i64>
+; LE-NEXT:    [[TMP2:%.*]] = bitcast <2 x i64> [[TMP1]] to i128
+; LE-NEXT:    [[TMP3:%.*]] = lshr i128 [[TMP2]], 64
+; LE-NEXT:    [[TMP4:%.*]] = trunc i128 [[TMP3]] to i64
+; LE-NEXT:    [[TMP5:%.*]] = inttoptr i64 [[TMP4]] to ptr
+; LE-NEXT:    ret ptr [[TMP5]]
+;
+; BE-LABEL: define ptr @store_v2ptr_to_ptr(
+; BE-SAME: <2 x ptr> [[V:%.*]], ptr [[P:%.*]]) {
+; BE-NEXT:    store <2 x ptr> [[V]], ptr [[P]], align 16
+; BE-NEXT:    [[Q:%.*]] = getelementptr i8, ptr [[P]], i64 8
+; BE-NEXT:    [[TMP1:%.*]] = ptrtoint <2 x ptr> [[V]] to <2 x i64>
+; BE-NEXT:    [[TMP2:%.*]] = bitcast <2 x i64> [[TMP1]] to i128
+; BE-NEXT:    [[TMP3:%.*]] = trunc i128 [[TMP2]] to i64
+; BE-NEXT:    [[TMP4:%.*]] = inttoptr i64 [[TMP3]] to ptr
+; BE-NEXT:    ret ptr [[TMP4]]
+;
+  store <2 x ptr> %v, ptr %p
+  %q = getelementptr i8, ptr %p, i64 8
+  %l = load ptr, ptr %q
+  ret ptr %l
+}
+
+define <4 x ptr addrspace(1)> @store_v2ptr_to_v4ptr1(<2 x ptr> %v, ptr %p) {
+; CHECK-LABEL: define <4 x ptr addrspace(1)> @store_v2ptr_to_v4ptr1(
+; CHECK-SAME: <2 x ptr> [[V:%.*]], ptr [[P:%.*]]) {
+; CHECK-NEXT:    store <2 x ptr> [[V]], ptr [[P]], align 16
+; CHECK-NEXT:    [[TMP1:%.*]] = ptrtoint <2 x ptr> [[V]] to <2 x i64>
+; CHECK-NEXT:    [[TMP2:%.*]] = bitcast <2 x i64> [[TMP1]] to i128
+; CHECK-NEXT:    [[TMP3:%.*]] = bitcast i128 [[TMP2]] to <4 x i32>
+; CHECK-NEXT:    [[TMP4:%.*]] = inttoptr <4 x i32> [[TMP3]] to <4 x ptr addrspace(1)>
+; CHECK-NEXT:    ret <4 x ptr addrspace(1)> [[TMP4]]
+;
+  store <2 x ptr> %v, ptr %p
+  %l = load <4 x ptr addrspace(1)>, ptr %p
+  ret <4 x ptr addrspace(1)> %l
+}
+
+declare void @use(<4 x i32>) memory(none)

>From e8c9f9da2f731888a790fd7e5d970f9470f047d3 Mon Sep 17 00:00:00 2001
From: Pedro Lobo <pedro.lobo at tecnico.ulisboa.pt>
Date: Sun, 25 Oct 2026 17:03:29 +0000
Subject: [PATCH 2/3] [GVN] Keep `poison` per lane when forwarding vectors

---
 llvm/lib/Transforms/Utils/VNCoercion.cpp      |  18 ++-
 llvm/test/Transforms/GVN/pr14166.ll           |   1 -
 llvm/test/Transforms/GVN/pr63059.ll           | 111 ++++++++----------
 .../Transforms/GVN/ptr-vector-coercion.ll     |  13 +-
 llvm/test/Transforms/GVN/vector-poison.ll     |  81 +++++--------
 5 files changed, 95 insertions(+), 129 deletions(-)

diff --git a/llvm/lib/Transforms/Utils/VNCoercion.cpp b/llvm/lib/Transforms/Utils/VNCoercion.cpp
index 845529d90e8e4e..83bb05b528467b 100644
--- a/llvm/lib/Transforms/Utils/VNCoercion.cpp
+++ b/llvm/lib/Transforms/Utils/VNCoercion.cpp
@@ -362,10 +362,16 @@ static Value *getStoreValueForLoadHelper(Value *SrcVal, unsigned Offset,
     ShiftAmt = (StoreSize - LoadSize - Offset) * 8;
 
   // Integers drop provenance, and one poison bit poisons the whole value.
+  // A vector tracks poison per lane.
   if (SrcTy->isByteOrByteVectorTy() ||
-      (SrcTy->isPtrOrPtrVectorTy() && LoadTy->isByteOrByteVectorTy())) {
+      (SrcTy->isPtrOrPtrVectorTy() && LoadTy->isByteOrByteVectorTy()) ||
+      (SrcTy->isVectorTy() && LoadSize != StoreSize)) {
     unsigned SrcBits = DL.getTypeSizeInBits(SrcTy).getFixedValue();
     unsigned LoadBits = DL.getTypeSizeInBits(LoadTy).getFixedValue();
+    // Fold a constant bitextract, as the builder has no DataLayout.
+    if (auto *C = dyn_cast<Constant>(SrcVal))
+      if (Constant *Res = getConstantValueForLoad(C, Offset, LoadTy, DL))
+        return Res;
     if (LoadBits == SrcBits)
       return Builder.CreateBitCast(SrcVal, LoadTy);
     // The lanes of the stored and loaded vectors may not line up, so extract
@@ -383,6 +389,10 @@ static Value *getStoreValueForLoadHelper(Value *SrcVal, unsigned Offset,
   if (SrcVal->getType()->isPtrOrPtrVectorTy())
     SrcVal =
         Builder.CreatePtrToInt(SrcVal, DL.getIntPtrType(SrcVal->getType()));
+  // If the load and store are the same size, there is nothing to shift.
+  // If one lane of a vector is poison, an integer cast would poison all lanes.
+  if (LoadSize == StoreSize)
+    return SrcVal;
   if (!SrcVal->getType()->isIntegerTy())
     SrcVal =
         Builder.CreateBitCast(SrcVal, IntegerType::get(Ctx, StoreSize * 8));
@@ -390,11 +400,7 @@ static Value *getStoreValueForLoadHelper(Value *SrcVal, unsigned Offset,
   if (ShiftAmt)
     SrcVal = Builder.CreateLShr(SrcVal,
                                 ConstantInt::get(SrcVal->getType(), ShiftAmt));
-
-  if (LoadSize != StoreSize)
-    SrcVal = Builder.CreateTruncOrBitCast(SrcVal,
-                                          IntegerType::get(Ctx, LoadSize * 8));
-  return SrcVal;
+  return Builder.CreateTrunc(SrcVal, IntegerType::get(Ctx, LoadSize * 8));
 }
 
 Value *VNCoercion::getValueForLoad(Value *SrcVal, unsigned Offset, Type *LoadTy,
diff --git a/llvm/test/Transforms/GVN/pr14166.ll b/llvm/test/Transforms/GVN/pr14166.ll
index e9d1e4db088bb7..2dd7c1ef02d154 100644
--- a/llvm/test/Transforms/GVN/pr14166.ll
+++ b/llvm/test/Transforms/GVN/pr14166.ll
@@ -9,7 +9,6 @@ define <2 x i32> @test1() {
 ; CHECK-NEXT:    [[V2:%.*]] = load <2 x i32>, ptr [[V1]], align 8
 ; CHECK-NEXT:    [[V3:%.*]] = inttoptr <2 x i32> [[V2]] to <2 x ptr>
 ; CHECK-NEXT:    store <2 x ptr> [[V3]], ptr [[V1]], align 8
-; CHECK-NEXT:    [[TMP1:%.*]] = bitcast <2 x i32> [[V2]] to i64
 ; CHECK-NEXT:    ret <2 x i32> [[V2]]
 ;
   %v1 = alloca <2 x i32>
diff --git a/llvm/test/Transforms/GVN/pr63059.ll b/llvm/test/Transforms/GVN/pr63059.ll
index 3d267f7aa7a50d..2a0038589a2c39 100644
--- a/llvm/test/Transforms/GVN/pr63059.ll
+++ b/llvm/test/Transforms/GVN/pr63059.ll
@@ -8,17 +8,13 @@ define <4 x float> @ConvertVectors_ByRef(ptr %loc) {
 ; CHECK-NEXT:    [[LOAD_VEC:%.*]] = load <4 x float>, ptr [[LOC]], align 16
 ; CHECK-NEXT:    [[SHUF:%.*]] = shufflevector <4 x float> [[LOAD_VEC]], <4 x float> poison, <4 x i32> <i32 0, i32 poison, i32 poison, i32 poison>
 ; CHECK-NEXT:    [[GEP1:%.*]] = getelementptr inbounds [4 x float], ptr [[LOC]], i64 0, i64 1
-; CHECK-NEXT:    [[TMP1:%.*]] = bitcast <4 x float> [[LOAD_VEC]] to i128
-; CHECK-NEXT:    [[TMP2:%.*]] = lshr i128 [[TMP1]], 32
-; CHECK-NEXT:    [[TMP3:%.*]] = trunc i128 [[TMP2]] to i32
-; CHECK-NEXT:    [[TMP4:%.*]] = bitcast i32 [[TMP3]] to float
-; CHECK-NEXT:    [[INS1:%.*]] = insertelement <4 x float> [[SHUF]], float [[TMP4]], i64 1
+; CHECK-NEXT:    [[TMP1:%.*]] = bitcast <4 x float> [[LOAD_VEC]] to b128
+; CHECK-NEXT:    [[TMP2:%.*]] = bitextract float, b128 [[TMP1]], i32 32
+; CHECK-NEXT:    [[INS1:%.*]] = insertelement <4 x float> [[SHUF]], float [[TMP2]], i64 1
 ; CHECK-NEXT:    [[GEP2:%.*]] = getelementptr inbounds [4 x float], ptr [[LOC]], i64 0, i64 2
-; CHECK-NEXT:    [[TMP5:%.*]] = lshr i128 [[TMP1]], 64
-; CHECK-NEXT:    [[TMP6:%.*]] = trunc i128 [[TMP5]] to i32
-; CHECK-NEXT:    [[TMP7:%.*]] = bitcast i32 [[TMP6]] to float
-; CHECK-NEXT:    [[INS2:%.*]] = insertelement <4 x float> [[INS1]], float [[TMP7]], i64 2
-; CHECK-NEXT:    [[INS3:%.*]] = insertelement <4 x float> [[INS2]], float [[TMP7]], i64 3
+; CHECK-NEXT:    [[TMP3:%.*]] = bitextract float, b128 [[TMP1]], i32 64
+; CHECK-NEXT:    [[INS2:%.*]] = insertelement <4 x float> [[INS1]], float [[TMP3]], i64 2
+; CHECK-NEXT:    [[INS3:%.*]] = insertelement <4 x float> [[INS2]], float [[TMP3]], i64 3
 ; CHECK-NEXT:    ret <4 x float> [[INS3]]
 ;
   %load_vec = load <4 x float>, ptr %loc, align 16
@@ -39,10 +35,9 @@ define i64 @store_element_smaller_than_load(ptr %loc, <4 x i32> %v) {
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    store <4 x i32> [[V]], ptr [[LOC]], align 16
 ; CHECK-NEXT:    [[GEP:%.*]] = getelementptr inbounds [4 x i32], ptr [[LOC]], i64 0, i64 2
-; CHECK-NEXT:    [[TMP0:%.*]] = bitcast <4 x i32> [[V]] to i128
-; CHECK-NEXT:    [[TMP1:%.*]] = lshr i128 [[TMP0]], 64
-; CHECK-NEXT:    [[TMP2:%.*]] = trunc i128 [[TMP1]] to i64
-; CHECK-NEXT:    ret i64 [[TMP2]]
+; CHECK-NEXT:    [[TMP0:%.*]] = bitcast <4 x i32> [[V]] to b128
+; CHECK-NEXT:    [[TMP1:%.*]] = bitextract i64, b128 [[TMP0]], i32 64
+; CHECK-NEXT:    ret i64 [[TMP1]]
 ;
   entry:
   store <4 x i32> %v, ptr  %loc
@@ -76,10 +71,9 @@ define i64 @call_before_load_memory_none(ptr %loc, <4 x i32> %v) {
 ; CHECK-NEXT:    store <4 x i32> [[V]], ptr [[LOC]], align 16
 ; CHECK-NEXT:    call void @f_no_mem(<4 x i32> [[V]])
 ; CHECK-NEXT:    [[GEP:%.*]] = getelementptr inbounds [4 x i32], ptr [[LOC]], i64 0, i64 2
-; CHECK-NEXT:    [[TMP0:%.*]] = bitcast <4 x i32> [[V]] to i128
-; CHECK-NEXT:    [[TMP1:%.*]] = lshr i128 [[TMP0]], 64
-; CHECK-NEXT:    [[TMP2:%.*]] = trunc i128 [[TMP1]] to i64
-; CHECK-NEXT:    ret i64 [[TMP2]]
+; CHECK-NEXT:    [[TMP0:%.*]] = bitcast <4 x i32> [[V]] to b128
+; CHECK-NEXT:    [[TMP1:%.*]] = bitextract i64, b128 [[TMP0]], i32 64
+; CHECK-NEXT:    ret i64 [[TMP1]]
 ;
   entry:
   store <4 x i32> %v, ptr  %loc
@@ -95,11 +89,10 @@ define i64 @call_after_load(ptr %loc, <4 x i32> %v) {
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    store <4 x i32> [[V]], ptr [[LOC]], align 16
 ; CHECK-NEXT:    [[GEP:%.*]] = getelementptr inbounds [4 x i32], ptr [[LOC]], i64 0, i64 2
-; CHECK-NEXT:    [[TMP0:%.*]] = bitcast <4 x i32> [[V]] to i128
-; CHECK-NEXT:    [[TMP1:%.*]] = lshr i128 [[TMP0]], 64
-; CHECK-NEXT:    [[TMP2:%.*]] = trunc i128 [[TMP1]] to i64
+; CHECK-NEXT:    [[TMP0:%.*]] = bitcast <4 x i32> [[V]] to b128
+; CHECK-NEXT:    [[TMP1:%.*]] = bitextract i64, b128 [[TMP0]], i32 64
 ; CHECK-NEXT:    call void @f(<4 x i32> [[V]])
-; CHECK-NEXT:    ret i64 [[TMP2]]
+; CHECK-NEXT:    ret i64 [[TMP1]]
 ;
   entry:
   store <4 x i32> %v, ptr  %loc
@@ -114,11 +107,9 @@ define double @store_element_smaller_than_load_float(ptr %loc, <4 x float> %v) {
 ; CHECK-SAME: (ptr [[LOC:%.*]], <4 x float> [[V:%.*]]) {
 ; CHECK-NEXT:    store <4 x float> [[V]], ptr [[LOC]], align 16
 ; CHECK-NEXT:    [[GEP:%.*]] = getelementptr inbounds [4 x float], ptr [[LOC]], i64 0, i64 2
-; CHECK-NEXT:    [[TMP1:%.*]] = bitcast <4 x float> [[V]] to i128
-; CHECK-NEXT:    [[TMP2:%.*]] = lshr i128 [[TMP1]], 64
-; CHECK-NEXT:    [[TMP3:%.*]] = trunc i128 [[TMP2]] to i64
-; CHECK-NEXT:    [[TMP4:%.*]] = bitcast i64 [[TMP3]] to double
-; CHECK-NEXT:    ret double [[TMP4]]
+; CHECK-NEXT:    [[TMP1:%.*]] = bitcast <4 x float> [[V]] to b128
+; CHECK-NEXT:    [[TMP2:%.*]] = bitextract double, b128 [[TMP1]], i32 64
+; CHECK-NEXT:    ret double [[TMP2]]
 ;
   store <4 x float> %v, ptr  %loc
   %gep = getelementptr inbounds [4 x float], ptr %loc, i64 0, i64 2
@@ -144,10 +135,9 @@ define i9 @load_as_scalar_larger(ptr %loc, <4 x i6> %v) {
 ; CHECK-LABEL: define i9 @load_as_scalar_larger
 ; CHECK-SAME: (ptr [[LOC:%.*]], <4 x i6> [[V:%.*]]) {
 ; CHECK-NEXT:    store <4 x i6> [[V]], ptr [[LOC]], align 4
-; CHECK-NEXT:    [[TMP1:%.*]] = bitcast <4 x i6> [[V]] to i24
-; CHECK-NEXT:    [[TMP2:%.*]] = trunc i24 [[TMP1]] to i16
-; CHECK-NEXT:    [[TMP3:%.*]] = trunc i16 [[TMP2]] to i9
-; CHECK-NEXT:    ret i9 [[TMP3]]
+; CHECK-NEXT:    [[TMP1:%.*]] = bitcast <4 x i6> [[V]] to b24
+; CHECK-NEXT:    [[TMP2:%.*]] = bitextract i9, b24 [[TMP1]], i32 0
+; CHECK-NEXT:    ret i9 [[TMP2]]
 ;
   store <4 x i6> %v, ptr  %loc
   %gep = getelementptr i9, ptr %loc, i64 0
@@ -160,10 +150,9 @@ define i4 @load_as_scalar_smaller(ptr %loc, <4 x i6> %v) {
 ; CHECK-LABEL: define i4 @load_as_scalar_smaller
 ; CHECK-SAME: (ptr [[LOC:%.*]], <4 x i6> [[V:%.*]]) {
 ; CHECK-NEXT:    store <4 x i6> [[V]], ptr [[LOC]], align 4
-; CHECK-NEXT:    [[TMP1:%.*]] = bitcast <4 x i6> [[V]] to i24
-; CHECK-NEXT:    [[TMP2:%.*]] = trunc i24 [[TMP1]] to i8
-; CHECK-NEXT:    [[TMP3:%.*]] = trunc i8 [[TMP2]] to i4
-; CHECK-NEXT:    ret i4 [[TMP3]]
+; CHECK-NEXT:    [[TMP1:%.*]] = bitcast <4 x i6> [[V]] to b24
+; CHECK-NEXT:    [[TMP2:%.*]] = bitextract i4, b24 [[TMP1]], i32 0
+; CHECK-NEXT:    ret i4 [[TMP2]]
 ;
   store <4 x i6> %v, ptr  %loc
   %gep = getelementptr i4, ptr %loc, i64 0
@@ -193,9 +182,8 @@ define i64 @load_vec_same_size_different_type1(ptr %loc, <4 x i32> %v) {
 ; CHECK-SAME: (ptr [[LOC:%.*]], <4 x i32> [[V:%.*]]) {
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    store <4 x i32> [[V]], ptr [[LOC]], align 16
-; CHECK-NEXT:    [[TMP0:%.*]] = bitcast <4 x i32> [[V]] to i128
-; CHECK-NEXT:    [[TMP1:%.*]] = bitcast i128 [[TMP0]] to <2 x i64>
-; CHECK-NEXT:    [[R:%.*]] = extractelement <2 x i64> [[TMP1]], i32 1
+; CHECK-NEXT:    [[TMP0:%.*]] = bitcast <4 x i32> [[V]] to <2 x i64>
+; CHECK-NEXT:    [[R:%.*]] = extractelement <2 x i64> [[TMP0]], i32 1
 ; CHECK-NEXT:    ret i64 [[R]]
 ;
   entry:
@@ -211,9 +199,8 @@ define double @load_vec_same_size_different_type2(ptr %loc, <4 x i32> %v) {
 ; CHECK-SAME: (ptr [[LOC:%.*]], <4 x i32> [[V:%.*]]) {
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    store <4 x i32> [[V]], ptr [[LOC]], align 16
-; CHECK-NEXT:    [[TMP0:%.*]] = bitcast <4 x i32> [[V]] to i128
-; CHECK-NEXT:    [[TMP1:%.*]] = bitcast i128 [[TMP0]] to <2 x double>
-; CHECK-NEXT:    [[R:%.*]] = extractelement <2 x double> [[TMP1]], i32 1
+; CHECK-NEXT:    [[TMP0:%.*]] = bitcast <4 x i32> [[V]] to <2 x double>
+; CHECK-NEXT:    [[R:%.*]] = extractelement <2 x double> [[TMP0]], i32 1
 ; CHECK-NEXT:    ret double [[R]]
 ;
   entry:
@@ -229,9 +216,9 @@ define i32 @load_subvector_same_type(ptr %loc, <4 x i32> %v) {
 ; CHECK-SAME: (ptr [[LOC:%.*]], <4 x i32> [[V:%.*]]) {
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    store <4 x i32> [[V]], ptr [[LOC]], align 16
-; CHECK-NEXT:    [[TMP0:%.*]] = bitcast <4 x i32> [[V]] to i128
-; CHECK-NEXT:    [[TMP1:%.*]] = trunc i128 [[TMP0]] to i64
-; CHECK-NEXT:    [[TMP2:%.*]] = bitcast i64 [[TMP1]] to <2 x i32>
+; CHECK-NEXT:    [[TMP0:%.*]] = bitcast <4 x i32> [[V]] to b128
+; CHECK-NEXT:    [[TMP1:%.*]] = bitextract b64, b128 [[TMP0]], i32 0
+; CHECK-NEXT:    [[TMP2:%.*]] = bitcast b64 [[TMP1]] to <2 x i32>
 ; CHECK-NEXT:    [[R:%.*]] = extractelement <2 x i32> [[TMP2]], i32 1
 ; CHECK-NEXT:    ret i32 [[R]]
 ;
@@ -248,9 +235,9 @@ define i64 @load_subvector_different_type(ptr %loc, <8 x i32> %v) {
 ; CHECK-SAME: (ptr [[LOC:%.*]], <8 x i32> [[V:%.*]]) {
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    store <8 x i32> [[V]], ptr [[LOC]], align 32
-; CHECK-NEXT:    [[TMP0:%.*]] = bitcast <8 x i32> [[V]] to i256
-; CHECK-NEXT:    [[TMP1:%.*]] = trunc i256 [[TMP0]] to i128
-; CHECK-NEXT:    [[TMP2:%.*]] = bitcast i128 [[TMP1]] to <2 x i64>
+; CHECK-NEXT:    [[TMP0:%.*]] = bitcast <8 x i32> [[V]] to b256
+; CHECK-NEXT:    [[TMP1:%.*]] = bitextract b128, b256 [[TMP0]], i32 0
+; CHECK-NEXT:    [[TMP2:%.*]] = bitcast b128 [[TMP1]] to <2 x i64>
 ; CHECK-NEXT:    [[R:%.*]] = extractelement <2 x i64> [[TMP2]], i32 1
 ; CHECK-NEXT:    ret i64 [[R]]
 ;
@@ -267,9 +254,9 @@ define i16 @load_subvector_different_type2(ptr %loc, <8 x i32> %v) {
 ; CHECK-SAME: (ptr [[LOC:%.*]], <8 x i32> [[V:%.*]]) {
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    store <8 x i32> [[V]], ptr [[LOC]], align 32
-; CHECK-NEXT:    [[TMP0:%.*]] = bitcast <8 x i32> [[V]] to i256
-; CHECK-NEXT:    [[TMP1:%.*]] = trunc i256 [[TMP0]] to i32
-; CHECK-NEXT:    [[TMP2:%.*]] = bitcast i32 [[TMP1]] to <2 x i16>
+; CHECK-NEXT:    [[TMP0:%.*]] = bitcast <8 x i32> [[V]] to b256
+; CHECK-NEXT:    [[TMP1:%.*]] = bitextract b32, b256 [[TMP0]], i32 0
+; CHECK-NEXT:    [[TMP2:%.*]] = bitcast b32 [[TMP1]] to <2 x i16>
 ; CHECK-NEXT:    [[R:%.*]] = extractelement <2 x i16> [[TMP2]], i32 1
 ; CHECK-NEXT:    ret i16 [[R]]
 ;
@@ -286,11 +273,10 @@ define i4 @load_subvector_different_type3(ptr %loc, <8 x i8> %v) {
 ; CHECK-SAME: (ptr [[LOC:%.*]], <8 x i8> [[V:%.*]]) {
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    store <8 x i8> [[V]], ptr [[LOC]], align 8
-; CHECK-NEXT:    [[TMP0:%.*]] = bitcast <8 x i8> [[V]] to i64
-; CHECK-NEXT:    [[TMP1:%.*]] = trunc i64 [[TMP0]] to i16
-; CHECK-NEXT:    [[TMP2:%.*]] = trunc i16 [[TMP1]] to i12
-; CHECK-NEXT:    [[TMP3:%.*]] = bitcast i12 [[TMP2]] to <3 x i4>
-; CHECK-NEXT:    [[R:%.*]] = extractelement <3 x i4> [[TMP3]], i32 1
+; CHECK-NEXT:    [[TMP0:%.*]] = bitcast <8 x i8> [[V]] to b64
+; CHECK-NEXT:    [[TMP1:%.*]] = bitextract b12, b64 [[TMP0]], i32 0
+; CHECK-NEXT:    [[TMP2:%.*]] = bitcast b12 [[TMP1]] to <3 x i4>
+; CHECK-NEXT:    [[R:%.*]] = extractelement <3 x i4> [[TMP2]], i32 1
 ; CHECK-NEXT:    ret i4 [[R]]
 ;
   entry:
@@ -306,9 +292,9 @@ define i12 @load_subvector_different_type4(ptr %loc, <8 x i8> %v) {
 ; CHECK-SAME: (ptr [[LOC:%.*]], <8 x i8> [[V:%.*]]) {
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    store <8 x i8> [[V]], ptr [[LOC]], align 8
-; CHECK-NEXT:    [[TMP0:%.*]] = bitcast <8 x i8> [[V]] to i64
-; CHECK-NEXT:    [[TMP1:%.*]] = trunc i64 [[TMP0]] to i24
-; CHECK-NEXT:    [[TMP2:%.*]] = bitcast i24 [[TMP1]] to <2 x i12>
+; CHECK-NEXT:    [[TMP0:%.*]] = bitcast <8 x i8> [[V]] to b64
+; CHECK-NEXT:    [[TMP1:%.*]] = bitextract b24, b64 [[TMP0]], i32 0
+; CHECK-NEXT:    [[TMP2:%.*]] = bitcast b24 [[TMP1]] to <2 x i12>
 ; CHECK-NEXT:    [[R:%.*]] = extractelement <2 x i12> [[TMP2]], i32 1
 ; CHECK-NEXT:    ret i12 [[R]]
 ;
@@ -325,11 +311,10 @@ define i6 @load_subvector_different_type5(ptr %loc, <8 x i8> %v) {
 ; CHECK-SAME: (ptr [[LOC:%.*]], <8 x i8> [[V:%.*]]) {
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    store <8 x i8> [[V]], ptr [[LOC]], align 8
-; CHECK-NEXT:    [[TMP0:%.*]] = bitcast <8 x i8> [[V]] to i64
-; CHECK-NEXT:    [[TMP1:%.*]] = trunc i64 [[TMP0]] to i16
-; CHECK-NEXT:    [[TMP2:%.*]] = trunc i16 [[TMP1]] to i12
-; CHECK-NEXT:    [[TMP3:%.*]] = bitcast i12 [[TMP2]] to <2 x i6>
-; CHECK-NEXT:    [[R:%.*]] = extractelement <2 x i6> [[TMP3]], i32 1
+; CHECK-NEXT:    [[TMP0:%.*]] = bitcast <8 x i8> [[V]] to b64
+; CHECK-NEXT:    [[TMP1:%.*]] = bitextract b12, b64 [[TMP0]], i32 0
+; CHECK-NEXT:    [[TMP2:%.*]] = bitcast b12 [[TMP1]] to <2 x i6>
+; CHECK-NEXT:    [[R:%.*]] = extractelement <2 x i6> [[TMP2]], i32 1
 ; CHECK-NEXT:    ret i6 [[R]]
 ;
   entry:
diff --git a/llvm/test/Transforms/GVN/ptr-vector-coercion.ll b/llvm/test/Transforms/GVN/ptr-vector-coercion.ll
index 9544b52927bec6..c368b978927833 100644
--- a/llvm/test/Transforms/GVN/ptr-vector-coercion.ll
+++ b/llvm/test/Transforms/GVN/ptr-vector-coercion.ll
@@ -56,17 +56,12 @@ define <1 x ptr> @neg_ptr1_store_to_v1ptr_load(ptr %p, ptr addrspace(1) %v) {
   ret <1 x ptr> %l
 }
 
-; Pointers of different sizes can't be bitcast to each other.
-; FIXME: Going through integers drops provenance, and a poison lane in %v
-; poisons the loaded pointer.
-define ptr @neg_v2ptr_store_to_ptr_load(ptr %p, <2 x ptr> %v) {
-; CHECK-LABEL: define ptr @neg_v2ptr_store_to_ptr_load(
+define ptr @v2ptr_store_to_ptr_load(ptr %p, <2 x ptr> %v) {
+; CHECK-LABEL: define ptr @v2ptr_store_to_ptr_load(
 ; CHECK-SAME: ptr [[P:%.*]], <2 x ptr> [[V:%.*]]) {
 ; CHECK-NEXT:    store <2 x ptr> [[V]], ptr [[P]], align 16
-; CHECK-NEXT:    [[TMP1:%.*]] = ptrtoint <2 x ptr> [[V]] to <2 x i64>
-; CHECK-NEXT:    [[TMP2:%.*]] = bitcast <2 x i64> [[TMP1]] to i128
-; CHECK-NEXT:    [[TMP3:%.*]] = trunc i128 [[TMP2]] to i64
-; CHECK-NEXT:    [[TMP4:%.*]] = inttoptr i64 [[TMP3]] to ptr
+; CHECK-NEXT:    [[TMP1:%.*]] = bitcast <2 x ptr> [[V]] to b128
+; CHECK-NEXT:    [[TMP4:%.*]] = bitextract ptr, b128 [[TMP1]], i32 0
 ; CHECK-NEXT:    ret ptr [[TMP4]]
 ;
   store <2 x ptr> %v, ptr %p
diff --git a/llvm/test/Transforms/GVN/vector-poison.ll b/llvm/test/Transforms/GVN/vector-poison.ll
index f80b5a0ee24c5f..35dc67a4511aa1 100644
--- a/llvm/test/Transforms/GVN/vector-poison.ll
+++ b/llvm/test/Transforms/GVN/vector-poison.ll
@@ -13,8 +13,8 @@ define i64 @pr99268(ptr %p, i1 %c) {
 ; LE:       [[THEN]]:
 ; LE-NEXT:    [[V:%.*]] = load <4 x i32>, ptr [[P]], align 16
 ; LE-NEXT:    call void @use(<4 x i32> [[V]])
-; LE-NEXT:    [[TMP0:%.*]] = bitcast <4 x i32> [[V]] to i128
-; LE-NEXT:    [[TMP1:%.*]] = trunc i128 [[TMP0]] to i64
+; LE-NEXT:    [[TMP0:%.*]] = bitcast <4 x i32> [[V]] to b128
+; LE-NEXT:    [[TMP1:%.*]] = bitextract i64, b128 [[TMP0]], i32 0
 ; LE-NEXT:    br label %[[EXIT:.*]]
 ; LE:       [[ELSE]]:
 ; LE-NEXT:    [[L_PRE:%.*]] = load i64, ptr [[P]], align 4
@@ -30,15 +30,14 @@ define i64 @pr99268(ptr %p, i1 %c) {
 ; BE:       [[THEN]]:
 ; BE-NEXT:    [[V:%.*]] = load <4 x i32>, ptr [[P]], align 16
 ; BE-NEXT:    call void @use(<4 x i32> [[V]])
-; BE-NEXT:    [[TMP0:%.*]] = bitcast <4 x i32> [[V]] to i128
-; BE-NEXT:    [[TMP1:%.*]] = lshr i128 [[TMP0]], 64
-; BE-NEXT:    [[TMP2:%.*]] = trunc i128 [[TMP1]] to i64
+; BE-NEXT:    [[TMP0:%.*]] = bitcast <4 x i32> [[V]] to b128
+; BE-NEXT:    [[TMP1:%.*]] = bitextract i64, b128 [[TMP0]], i32 64
 ; BE-NEXT:    br label %[[EXIT:.*]]
 ; BE:       [[ELSE]]:
 ; BE-NEXT:    [[L_PRE:%.*]] = load i64, ptr [[P]], align 4
 ; BE-NEXT:    br label %[[EXIT]]
 ; BE:       [[EXIT]]:
-; BE-NEXT:    [[L:%.*]] = phi i64 [ [[L_PRE]], %[[ELSE]] ], [ [[TMP2]], %[[THEN]] ]
+; BE-NEXT:    [[L:%.*]] = phi i64 [ [[L_PRE]], %[[ELSE]] ], [ [[TMP1]], %[[THEN]] ]
 ; BE-NEXT:    ret i64 [[L]]
 ;
 entry:
@@ -61,18 +60,17 @@ define <2 x i64> @pr209935(<4 x i64> %v, ptr %p) {
 ; LE-LABEL: define <2 x i64> @pr209935(
 ; LE-SAME: <4 x i64> [[V:%.*]], ptr [[P:%.*]]) {
 ; LE-NEXT:    store <4 x i64> [[V]], ptr [[P]], align 8
-; LE-NEXT:    [[TMP1:%.*]] = bitcast <4 x i64> [[V]] to i256
-; LE-NEXT:    [[TMP2:%.*]] = trunc i256 [[TMP1]] to i128
-; LE-NEXT:    [[TMP3:%.*]] = bitcast i128 [[TMP2]] to <2 x i64>
+; LE-NEXT:    [[TMP1:%.*]] = bitcast <4 x i64> [[V]] to b256
+; LE-NEXT:    [[TMP2:%.*]] = bitextract b128, b256 [[TMP1]], i32 0
+; LE-NEXT:    [[TMP3:%.*]] = bitcast b128 [[TMP2]] to <2 x i64>
 ; LE-NEXT:    ret <2 x i64> [[TMP3]]
 ;
 ; BE-LABEL: define <2 x i64> @pr209935(
 ; BE-SAME: <4 x i64> [[V:%.*]], ptr [[P:%.*]]) {
 ; BE-NEXT:    store <4 x i64> [[V]], ptr [[P]], align 8
-; BE-NEXT:    [[TMP1:%.*]] = bitcast <4 x i64> [[V]] to i256
-; BE-NEXT:    [[TMP2:%.*]] = lshr i256 [[TMP1]], 128
-; BE-NEXT:    [[TMP3:%.*]] = trunc i256 [[TMP2]] to i128
-; BE-NEXT:    [[TMP4:%.*]] = bitcast i128 [[TMP3]] to <2 x i64>
+; BE-NEXT:    [[TMP1:%.*]] = bitcast <4 x i64> [[V]] to b256
+; BE-NEXT:    [[TMP2:%.*]] = bitextract b128, b256 [[TMP1]], i32 128
+; BE-NEXT:    [[TMP4:%.*]] = bitcast b128 [[TMP2]] to <2 x i64>
 ; BE-NEXT:    ret <2 x i64> [[TMP4]]
 ;
   store <4 x i64> %v, ptr %p, align 8
@@ -85,18 +83,16 @@ define i16 @store_v4i32_to_i16_straddle(<4 x i32> %v, ptr %p) {
 ; LE-SAME: <4 x i32> [[V:%.*]], ptr [[P:%.*]]) {
 ; LE-NEXT:    store <4 x i32> [[V]], ptr [[P]], align 16
 ; LE-NEXT:    [[Q:%.*]] = getelementptr i8, ptr [[P]], i64 3
-; LE-NEXT:    [[TMP1:%.*]] = bitcast <4 x i32> [[V]] to i128
-; LE-NEXT:    [[TMP2:%.*]] = lshr i128 [[TMP1]], 24
-; LE-NEXT:    [[TMP3:%.*]] = trunc i128 [[TMP2]] to i16
+; LE-NEXT:    [[TMP1:%.*]] = bitcast <4 x i32> [[V]] to b128
+; LE-NEXT:    [[TMP3:%.*]] = bitextract i16, b128 [[TMP1]], i32 24
 ; LE-NEXT:    ret i16 [[TMP3]]
 ;
 ; BE-LABEL: define i16 @store_v4i32_to_i16_straddle(
 ; BE-SAME: <4 x i32> [[V:%.*]], ptr [[P:%.*]]) {
 ; BE-NEXT:    store <4 x i32> [[V]], ptr [[P]], align 16
 ; BE-NEXT:    [[Q:%.*]] = getelementptr i8, ptr [[P]], i64 3
-; BE-NEXT:    [[TMP1:%.*]] = bitcast <4 x i32> [[V]] to i128
-; BE-NEXT:    [[TMP2:%.*]] = lshr i128 [[TMP1]], 88
-; BE-NEXT:    [[TMP3:%.*]] = trunc i128 [[TMP2]] to i16
+; BE-NEXT:    [[TMP1:%.*]] = bitcast <4 x i32> [[V]] to b128
+; BE-NEXT:    [[TMP3:%.*]] = bitextract i16, b128 [[TMP1]], i32 88
 ; BE-NEXT:    ret i16 [[TMP3]]
 ;
   store <4 x i32> %v, ptr %p
@@ -109,8 +105,7 @@ define <4 x float> @store_v4i32_to_v4f32(<4 x i32> %v, ptr %p) {
 ; CHECK-LABEL: define <4 x float> @store_v4i32_to_v4f32(
 ; CHECK-SAME: <4 x i32> [[V:%.*]], ptr [[P:%.*]]) {
 ; CHECK-NEXT:    store <4 x i32> [[V]], ptr [[P]], align 16
-; CHECK-NEXT:    [[TMP1:%.*]] = bitcast <4 x i32> [[V]] to i128
-; CHECK-NEXT:    [[TMP2:%.*]] = bitcast i128 [[TMP1]] to <4 x float>
+; CHECK-NEXT:    [[TMP2:%.*]] = bitcast <4 x i32> [[V]] to <4 x float>
 ; CHECK-NEXT:    ret <4 x float> [[TMP2]]
 ;
   store <4 x i32> %v, ptr %p
@@ -123,19 +118,16 @@ define i64 @store_v2ptr_to_i64(<2 x ptr> %v, ptr %p) {
 ; LE-SAME: <2 x ptr> [[V:%.*]], ptr [[P:%.*]]) {
 ; LE-NEXT:    store <2 x ptr> [[V]], ptr [[P]], align 16
 ; LE-NEXT:    [[Q:%.*]] = getelementptr i8, ptr [[P]], i64 8
-; LE-NEXT:    [[TMP1:%.*]] = ptrtoint <2 x ptr> [[V]] to <2 x i64>
-; LE-NEXT:    [[TMP2:%.*]] = bitcast <2 x i64> [[TMP1]] to i128
-; LE-NEXT:    [[TMP3:%.*]] = lshr i128 [[TMP2]], 64
-; LE-NEXT:    [[TMP4:%.*]] = trunc i128 [[TMP3]] to i64
+; LE-NEXT:    [[TMP1:%.*]] = bitcast <2 x ptr> [[V]] to b128
+; LE-NEXT:    [[TMP4:%.*]] = bitextract i64, b128 [[TMP1]], i32 64
 ; LE-NEXT:    ret i64 [[TMP4]]
 ;
 ; BE-LABEL: define i64 @store_v2ptr_to_i64(
 ; BE-SAME: <2 x ptr> [[V:%.*]], ptr [[P:%.*]]) {
 ; BE-NEXT:    store <2 x ptr> [[V]], ptr [[P]], align 16
 ; BE-NEXT:    [[Q:%.*]] = getelementptr i8, ptr [[P]], i64 8
-; BE-NEXT:    [[TMP1:%.*]] = ptrtoint <2 x ptr> [[V]] to <2 x i64>
-; BE-NEXT:    [[TMP2:%.*]] = bitcast <2 x i64> [[TMP1]] to i128
-; BE-NEXT:    [[TMP3:%.*]] = trunc i128 [[TMP2]] to i64
+; BE-NEXT:    [[TMP1:%.*]] = bitcast <2 x ptr> [[V]] to b128
+; BE-NEXT:    [[TMP3:%.*]] = bitextract i64, b128 [[TMP1]], i32 0
 ; BE-NEXT:    ret i64 [[TMP3]]
 ;
   store <2 x ptr> %v, ptr %p
@@ -149,8 +141,7 @@ define <4 x i32> @store_v2ptr_to_v4i32(<2 x ptr> %v, ptr %p) {
 ; CHECK-SAME: <2 x ptr> [[V:%.*]], ptr [[P:%.*]]) {
 ; CHECK-NEXT:    store <2 x ptr> [[V]], ptr [[P]], align 16
 ; CHECK-NEXT:    [[TMP1:%.*]] = ptrtoint <2 x ptr> [[V]] to <2 x i64>
-; CHECK-NEXT:    [[TMP2:%.*]] = bitcast <2 x i64> [[TMP1]] to i128
-; CHECK-NEXT:    [[TMP3:%.*]] = bitcast i128 [[TMP2]] to <4 x i32>
+; CHECK-NEXT:    [[TMP3:%.*]] = bitcast <2 x i64> [[TMP1]] to <4 x i32>
 ; CHECK-NEXT:    ret <4 x i32> [[TMP3]]
 ;
   store <2 x ptr> %v, ptr %p
@@ -162,8 +153,7 @@ define <2 x ptr> @store_v4i32_to_v2ptr(<4 x i32> %v, ptr %p) {
 ; CHECK-LABEL: define <2 x ptr> @store_v4i32_to_v2ptr(
 ; CHECK-SAME: <4 x i32> [[V:%.*]], ptr [[P:%.*]]) {
 ; CHECK-NEXT:    store <4 x i32> [[V]], ptr [[P]], align 16
-; CHECK-NEXT:    [[TMP1:%.*]] = bitcast <4 x i32> [[V]] to i128
-; CHECK-NEXT:    [[TMP2:%.*]] = bitcast i128 [[TMP1]] to <2 x i64>
+; CHECK-NEXT:    [[TMP2:%.*]] = bitcast <4 x i32> [[V]] to <2 x i64>
 ; CHECK-NEXT:    [[TMP3:%.*]] = inttoptr <2 x i64> [[TMP2]] to <2 x ptr>
 ; CHECK-NEXT:    ret <2 x ptr> [[TMP3]]
 ;
@@ -177,19 +167,16 @@ define ptr @store_v2i64_to_ptr(<2 x i64> %v, ptr %p) {
 ; LE-SAME: <2 x i64> [[V:%.*]], ptr [[P:%.*]]) {
 ; LE-NEXT:    store <2 x i64> [[V]], ptr [[P]], align 16
 ; LE-NEXT:    [[Q:%.*]] = getelementptr i8, ptr [[P]], i64 8
-; LE-NEXT:    [[TMP1:%.*]] = bitcast <2 x i64> [[V]] to i128
-; LE-NEXT:    [[TMP2:%.*]] = lshr i128 [[TMP1]], 64
-; LE-NEXT:    [[TMP3:%.*]] = trunc i128 [[TMP2]] to i64
-; LE-NEXT:    [[TMP4:%.*]] = inttoptr i64 [[TMP3]] to ptr
+; LE-NEXT:    [[TMP1:%.*]] = bitcast <2 x i64> [[V]] to b128
+; LE-NEXT:    [[TMP4:%.*]] = bitextract ptr, b128 [[TMP1]], i32 64
 ; LE-NEXT:    ret ptr [[TMP4]]
 ;
 ; BE-LABEL: define ptr @store_v2i64_to_ptr(
 ; BE-SAME: <2 x i64> [[V:%.*]], ptr [[P:%.*]]) {
 ; BE-NEXT:    store <2 x i64> [[V]], ptr [[P]], align 16
 ; BE-NEXT:    [[Q:%.*]] = getelementptr i8, ptr [[P]], i64 8
-; BE-NEXT:    [[TMP1:%.*]] = bitcast <2 x i64> [[V]] to i128
-; BE-NEXT:    [[TMP2:%.*]] = trunc i128 [[TMP1]] to i64
-; BE-NEXT:    [[TMP3:%.*]] = inttoptr i64 [[TMP2]] to ptr
+; BE-NEXT:    [[TMP1:%.*]] = bitcast <2 x i64> [[V]] to b128
+; BE-NEXT:    [[TMP3:%.*]] = bitextract ptr, b128 [[TMP1]], i32 0
 ; BE-NEXT:    ret ptr [[TMP3]]
 ;
   store <2 x i64> %v, ptr %p
@@ -203,21 +190,16 @@ define ptr @store_v2ptr_to_ptr(<2 x ptr> %v, ptr %p) {
 ; LE-SAME: <2 x ptr> [[V:%.*]], ptr [[P:%.*]]) {
 ; LE-NEXT:    store <2 x ptr> [[V]], ptr [[P]], align 16
 ; LE-NEXT:    [[Q:%.*]] = getelementptr i8, ptr [[P]], i64 8
-; LE-NEXT:    [[TMP1:%.*]] = ptrtoint <2 x ptr> [[V]] to <2 x i64>
-; LE-NEXT:    [[TMP2:%.*]] = bitcast <2 x i64> [[TMP1]] to i128
-; LE-NEXT:    [[TMP3:%.*]] = lshr i128 [[TMP2]], 64
-; LE-NEXT:    [[TMP4:%.*]] = trunc i128 [[TMP3]] to i64
-; LE-NEXT:    [[TMP5:%.*]] = inttoptr i64 [[TMP4]] to ptr
+; LE-NEXT:    [[TMP1:%.*]] = bitcast <2 x ptr> [[V]] to b128
+; LE-NEXT:    [[TMP5:%.*]] = bitextract ptr, b128 [[TMP1]], i32 64
 ; LE-NEXT:    ret ptr [[TMP5]]
 ;
 ; BE-LABEL: define ptr @store_v2ptr_to_ptr(
 ; BE-SAME: <2 x ptr> [[V:%.*]], ptr [[P:%.*]]) {
 ; BE-NEXT:    store <2 x ptr> [[V]], ptr [[P]], align 16
 ; BE-NEXT:    [[Q:%.*]] = getelementptr i8, ptr [[P]], i64 8
-; BE-NEXT:    [[TMP1:%.*]] = ptrtoint <2 x ptr> [[V]] to <2 x i64>
-; BE-NEXT:    [[TMP2:%.*]] = bitcast <2 x i64> [[TMP1]] to i128
-; BE-NEXT:    [[TMP3:%.*]] = trunc i128 [[TMP2]] to i64
-; BE-NEXT:    [[TMP4:%.*]] = inttoptr i64 [[TMP3]] to ptr
+; BE-NEXT:    [[TMP1:%.*]] = bitcast <2 x ptr> [[V]] to b128
+; BE-NEXT:    [[TMP4:%.*]] = bitextract ptr, b128 [[TMP1]], i32 0
 ; BE-NEXT:    ret ptr [[TMP4]]
 ;
   store <2 x ptr> %v, ptr %p
@@ -231,8 +213,7 @@ define <4 x ptr addrspace(1)> @store_v2ptr_to_v4ptr1(<2 x ptr> %v, ptr %p) {
 ; CHECK-SAME: <2 x ptr> [[V:%.*]], ptr [[P:%.*]]) {
 ; CHECK-NEXT:    store <2 x ptr> [[V]], ptr [[P]], align 16
 ; CHECK-NEXT:    [[TMP1:%.*]] = ptrtoint <2 x ptr> [[V]] to <2 x i64>
-; CHECK-NEXT:    [[TMP2:%.*]] = bitcast <2 x i64> [[TMP1]] to i128
-; CHECK-NEXT:    [[TMP3:%.*]] = bitcast i128 [[TMP2]] to <4 x i32>
+; CHECK-NEXT:    [[TMP3:%.*]] = bitcast <2 x i64> [[TMP1]] to <4 x i32>
 ; CHECK-NEXT:    [[TMP4:%.*]] = inttoptr <4 x i32> [[TMP3]] to <4 x ptr addrspace(1)>
 ; CHECK-NEXT:    ret <4 x ptr addrspace(1)> [[TMP4]]
 ;

>From 185b0973ab005548a20ddc1ecb37ef04039ced82 Mon Sep 17 00:00:00 2001
From: Pedro Lobo <pedro.lobo at tecnico.ulisboa.pt>
Date: Thu, 5 Nov 2026 09:48:48 +0000
Subject: [PATCH 3/3] [GVN] Explain the address space test in
 `vector-poison.ll`

---
 llvm/test/Transforms/GVN/vector-poison.ll | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/llvm/test/Transforms/GVN/vector-poison.ll b/llvm/test/Transforms/GVN/vector-poison.ll
index 35dc67a4511aa1..1037167ae58426 100644
--- a/llvm/test/Transforms/GVN/vector-poison.ll
+++ b/llvm/test/Transforms/GVN/vector-poison.ll
@@ -208,6 +208,8 @@ define ptr @store_v2ptr_to_ptr(<2 x ptr> %v, ptr %p) {
   ret ptr %l
 }
 
+; Pointers in different address spaces can't be bitcast, so this goes through
+; integer vectors. The bitcast between vectors keeps poison per lane.
 define <4 x ptr addrspace(1)> @store_v2ptr_to_v4ptr1(<2 x ptr> %v, ptr %p) {
 ; CHECK-LABEL: define <4 x ptr addrspace(1)> @store_v2ptr_to_v4ptr1(
 ; CHECK-SAME: <2 x ptr> [[V:%.*]], ptr [[P:%.*]]) {



More information about the llvm-branch-commits mailing list