[llvm-branch-commits] [llvm] [GVN] Preserve per-bit `poison` and provenance when forwarding a load (PR #237786)

Pedro Lobo via llvm-branch-commits llvm-branch-commits at lists.llvm.org
Sun Nov 1 14:13:16 PST 2026


https://github.com/pedroclobo created https://github.com/llvm/llvm-project/pull/237786

GVN forwards an earlier load to a later load of a different type by casting the loaded value. Memory is `poison` per bit, but an integer is `poison` per value, and a vector per lane. When the later load reads only part of a lane, the forwarded value can be `poison` even though the later load isn't. Casting through an integer also drops pointer provenance if memory holds a pointer.

GVN now turns the earlier load into a byte load, which keeps every bit, and forwards from it:

```diff
-%v = load <4 x i32>, ptr %p
+%v.bytes = load <4 x b32>, ptr %p
+%v = bitcast <4 x b32> %v.bytes to <4 x i32>
 call void @use(<4 x i32> %v)
-%1 = bitcast <4 x i32> %v to b128
+%1 = bitcast <4 x b32> %v.bytes to b128
 %x = bitextract i8, b128 %1, i32 0
```

A pointer forwarded from an integer no longer goes through `inttoptr`:

```diff
-%v = load i64, ptr %p
+%v.bytes = load b64, ptr %p
+%v = bitcast b64 %v.bytes to i64
 call void @use(i64 %v)
-%x = inttoptr i64 %v to ptr
+%x = bitcast b64 %v.bytes to ptr
```

The earlier load stays as is when forwarding is already exact, like when each lane of the later load covers whole lanes of the earlier one, or the earlier load is `!noundef`.
A volatile floating-point load isn't forwarded when it would need a byte load, as a volatile load can't change from floating-point to integer or byte, according to the LangRef.

Fixes #99268.


>From 4a7d2ab7d70afb112281b93b5e46508d9bb917c1 Mon Sep 17 00:00:00 2001
From: Pedro Lobo <pedro.lobo at tecnico.ulisboa.pt>
Date: Sat, 31 Oct 2026 16:46:00 +0000
Subject: [PATCH 1/2] [GVN] Pre-commit tests for per-bit `poison` and
 provenance when forwarding a load

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

diff --git a/llvm/test/Transforms/GVN/load-poison.ll b/llvm/test/Transforms/GVN/load-poison.ll
new file mode 100644
index 00000000000000..23d90be46bca9b
--- /dev/null
+++ b/llvm/test/Transforms/GVN/load-poison.ll
@@ -0,0 +1,424 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 6
+; RUN: opt < %s -passes=gvn -S | FileCheck %s
+; RUN: opt < %s -passes='gvn<memoryssa>' -S | FileCheck %s
+
+declare void @use(...) memory(none)
+
+define <2 x i64> @pr99268(ptr %p) {
+; CHECK-LABEL: define <2 x i64> @pr99268(
+; CHECK-SAME: ptr [[P:%.*]]) {
+; CHECK-NEXT:    [[V:%.*]] = load <2 x i64>, ptr [[P]], align 16
+; CHECK-NEXT:    [[TMP1:%.*]] = bitcast <2 x i64> [[V]] to b128
+; CHECK-NEXT:    [[TMP2:%.*]] = bitextract b64, b128 [[TMP1]], i32 0
+; CHECK-NEXT:    [[TMP3:%.*]] = bitcast b64 [[TMP2]] to <2 x i32>
+; CHECK-NEXT:    [[S:%.*]] = sext <2 x i32> [[TMP3]] to <2 x i64>
+; CHECK-NEXT:    [[R:%.*]] = sub <2 x i64> [[V]], [[S]]
+; CHECK-NEXT:    ret <2 x i64> [[R]]
+;
+  %v = load <2 x i64>, ptr %p
+  %l = load <2 x i32>, ptr %p
+  %s = sext <2 x i32> %l to <2 x i64>
+  %r = sub <2 x i64> %v, %s
+  ret <2 x i64> %r
+}
+
+define i8 @load_i32_to_i8(ptr %p) {
+; CHECK-LABEL: define i8 @load_i32_to_i8(
+; CHECK-SAME: ptr [[P:%.*]]) {
+; CHECK-NEXT:    [[V:%.*]] = load i32, ptr [[P]], align 4
+; CHECK-NEXT:    call void (...) @use(i32 [[V]])
+; CHECK-NEXT:    [[TMP1:%.*]] = trunc i32 [[V]] to i8
+; CHECK-NEXT:    ret i8 [[TMP1]]
+;
+  %v = load i32, ptr %p
+  call void (...) @use(i32 %v)
+  %x = load i8, ptr %p
+  ret i8 %x
+}
+
+define i32 @load_ptr_to_i32(ptr %p) {
+; CHECK-LABEL: define i32 @load_ptr_to_i32(
+; CHECK-SAME: ptr [[P:%.*]]) {
+; CHECK-NEXT:    [[V:%.*]] = load ptr, ptr [[P]], align 8
+; CHECK-NEXT:    call void (...) @use(ptr [[V]])
+; CHECK-NEXT:    [[TMP1:%.*]] = ptrtoint ptr [[V]] to i64
+; CHECK-NEXT:    [[TMP2:%.*]] = trunc i64 [[TMP1]] to i32
+; CHECK-NEXT:    ret i32 [[TMP2]]
+;
+  %v = load ptr, ptr %p
+  call void (...) @use(ptr %v)
+  %x = load i32, ptr %p
+  ret i32 %x
+}
+
+define i32 @load_v4i32_to_i32_straddle(ptr %p) {
+; CHECK-LABEL: define i32 @load_v4i32_to_i32_straddle(
+; CHECK-SAME: ptr [[P:%.*]]) {
+; CHECK-NEXT:    [[V:%.*]] = load <4 x i32>, ptr [[P]], align 16
+; CHECK-NEXT:    call void (...) @use(<4 x i32> [[V]])
+; CHECK-NEXT:    [[Q:%.*]] = getelementptr i8, ptr [[P]], i64 2
+; CHECK-NEXT:    [[TMP1:%.*]] = bitcast <4 x i32> [[V]] to b128
+; CHECK-NEXT:    [[TMP2:%.*]] = bitextract i32, b128 [[TMP1]], i32 16
+; CHECK-NEXT:    ret i32 [[TMP2]]
+;
+  %v = load <4 x i32>, ptr %p
+  call void (...) @use(<4 x i32> %v)
+  %q = getelementptr i8, ptr %p, i64 2
+  %x = load i32, ptr %q, align 1
+  ret i32 %x
+}
+
+define i8 @load_v2i12_to_i8(ptr %p) {
+; CHECK-LABEL: define i8 @load_v2i12_to_i8(
+; CHECK-SAME: ptr [[P:%.*]]) {
+; CHECK-NEXT:    [[V:%.*]] = load <2 x i12>, ptr [[P]], align 4
+; CHECK-NEXT:    call void (...) @use(<2 x i12> [[V]])
+; CHECK-NEXT:    [[TMP1:%.*]] = bitcast <2 x i12> [[V]] to b24
+; CHECK-NEXT:    [[TMP2:%.*]] = bitextract i8, b24 [[TMP1]], i32 0
+; CHECK-NEXT:    ret i8 [[TMP2]]
+;
+  %v = load <2 x i12>, ptr %p
+  call void (...) @use(<2 x i12> %v)
+  %x = load i8, ptr %p
+  ret i8 %x
+}
+
+define i8 @load_float_to_i8(ptr %p) {
+; CHECK-LABEL: define i8 @load_float_to_i8(
+; CHECK-SAME: ptr [[P:%.*]]) {
+; CHECK-NEXT:    [[V:%.*]] = load float, ptr [[P]], align 4
+; CHECK-NEXT:    call void (...) @use(float [[V]])
+; CHECK-NEXT:    [[TMP1:%.*]] = bitcast float [[V]] to i32
+; CHECK-NEXT:    [[TMP2:%.*]] = trunc i32 [[TMP1]] to i8
+; CHECK-NEXT:    ret i8 [[TMP2]]
+;
+  %v = load float, ptr %p
+  call void (...) @use(float %v)
+  %x = load i8, ptr %p
+  ret i8 %x
+}
+
+define b32 @load_i32_to_b32(ptr %p) {
+; CHECK-LABEL: define b32 @load_i32_to_b32(
+; CHECK-SAME: ptr [[P:%.*]]) {
+; CHECK-NEXT:    [[V:%.*]] = load i32, ptr [[P]], align 4
+; CHECK-NEXT:    call void (...) @use(i32 [[V]])
+; CHECK-NEXT:    [[TMP1:%.*]] = bitcast i32 [[V]] to b32
+; CHECK-NEXT:    ret b32 [[TMP1]]
+;
+  %v = load i32, ptr %p
+  call void (...) @use(i32 %v)
+  %x = load b32, ptr %p
+  ret b32 %x
+}
+
+define b32 @load_i32_noundef_to_b32(ptr %p) {
+; CHECK-LABEL: define b32 @load_i32_noundef_to_b32(
+; CHECK-SAME: ptr [[P:%.*]]) {
+; CHECK-NEXT:    [[V:%.*]] = load i32, ptr [[P]], align 4, !noundef [[META0:![0-9]+]]
+; CHECK-NEXT:    call void (...) @use(i32 [[V]])
+; CHECK-NEXT:    [[TMP1:%.*]] = bitcast i32 [[V]] to b32
+; CHECK-NEXT:    ret b32 [[TMP1]]
+;
+  %v = load i32, ptr %p, !noundef !{}
+  call void (...) @use(i32 %v)
+  %x = load b32, ptr %p
+  ret b32 %x
+}
+
+define <vscale x 4 x i32> @load_nxv2i64_to_nxv4i32(ptr %p) {
+; CHECK-LABEL: define <vscale x 4 x i32> @load_nxv2i64_to_nxv4i32(
+; CHECK-SAME: ptr [[P:%.*]]) {
+; CHECK-NEXT:    [[V:%.*]] = load <vscale x 2 x i64>, ptr [[P]], align 16
+; CHECK-NEXT:    call void (...) @use(<vscale x 2 x i64> [[V]])
+; CHECK-NEXT:    [[TMP1:%.*]] = bitcast <vscale x 2 x i64> [[V]] to <vscale x 4 x i32>
+; CHECK-NEXT:    ret <vscale x 4 x i32> [[TMP1]]
+;
+  %v = load <vscale x 2 x i64>, ptr %p
+  call void (...) @use(<vscale x 2 x i64> %v)
+  %x = load <vscale x 4 x i32>, ptr %p
+  ret <vscale x 4 x i32> %x
+}
+
+define ptr @load_i64_to_ptr(ptr %p) {
+; CHECK-LABEL: define ptr @load_i64_to_ptr(
+; CHECK-SAME: ptr [[P:%.*]]) {
+; CHECK-NEXT:    [[V:%.*]] = load i64, ptr [[P]], align 4
+; CHECK-NEXT:    call void (...) @use(i64 [[V]])
+; CHECK-NEXT:    [[TMP1:%.*]] = inttoptr i64 [[V]] to ptr
+; CHECK-NEXT:    ret ptr [[TMP1]]
+;
+  %v = load i64, ptr %p
+  call void (...) @use(i64 %v)
+  %x = load ptr, ptr %p
+  ret ptr %x
+}
+
+define ptr addrspace(1) @load_ptr_to_ptr1(ptr %p) {
+; CHECK-LABEL: define ptr addrspace(1) @load_ptr_to_ptr1(
+; CHECK-SAME: ptr [[P:%.*]]) {
+; CHECK-NEXT:    [[V:%.*]] = load ptr, ptr [[P]], align 8
+; CHECK-NEXT:    call void (...) @use(ptr [[V]])
+; CHECK-NEXT:    [[TMP1:%.*]] = ptrtoint ptr [[V]] to i64
+; CHECK-NEXT:    [[TMP2:%.*]] = inttoptr i64 [[TMP1]] to ptr addrspace(1)
+; CHECK-NEXT:    ret ptr addrspace(1) [[TMP2]]
+;
+  %v = load ptr, ptr %p
+  call void (...) @use(ptr %v)
+  %x = load ptr addrspace(1), ptr %p
+  ret ptr addrspace(1) %x
+}
+
+define i8 @load_volatile_i32_to_i8(ptr %p) {
+; CHECK-LABEL: define i8 @load_volatile_i32_to_i8(
+; CHECK-SAME: ptr [[P:%.*]]) {
+; CHECK-NEXT:    [[V:%.*]] = load volatile i32, ptr [[P]], align 4
+; CHECK-NEXT:    call void (...) @use(i32 [[V]])
+; CHECK-NEXT:    [[TMP1:%.*]] = trunc i32 [[V]] to i8
+; CHECK-NEXT:    ret i8 [[TMP1]]
+;
+  %v = load volatile i32, ptr %p
+  call void (...) @use(i32 %v)
+  %x = load i8, ptr %p
+  ret i8 %x
+}
+
+define i8 @load_i32_to_i16_i8(ptr %p) {
+; CHECK-LABEL: define i8 @load_i32_to_i16_i8(
+; CHECK-SAME: ptr [[P:%.*]]) {
+; CHECK-NEXT:    [[V:%.*]] = load i32, ptr [[P]], align 4
+; CHECK-NEXT:    call void (...) @use(i32 [[V]])
+; CHECK-NEXT:    [[TMP1:%.*]] = trunc i32 [[V]] to i16
+; CHECK-NEXT:    [[Q:%.*]] = getelementptr i8, ptr [[P]], i64 2
+; CHECK-NEXT:    [[TMP2:%.*]] = lshr i32 [[V]], 16
+; CHECK-NEXT:    [[TMP3:%.*]] = trunc i32 [[TMP2]] to i8
+; CHECK-NEXT:    [[T:%.*]] = trunc i16 [[TMP1]] to i8
+; CHECK-NEXT:    [[R:%.*]] = add i8 [[T]], [[TMP3]]
+; CHECK-NEXT:    ret i8 [[R]]
+;
+  %v = load i32, ptr %p
+  call void (...) @use(i32 %v)
+  %x = load i16, ptr %p
+  %q = getelementptr i8, ptr %p, i64 2
+  %y = load i8, ptr %q
+  %t = trunc i16 %x to i8
+  %r = add i8 %t, %y
+  ret i8 %r
+}
+
+define i8 @load_i32_to_i8_nonlocal(ptr %p, i1 %c) {
+; CHECK-LABEL: define i8 @load_i32_to_i8_nonlocal(
+; CHECK-SAME: ptr [[P:%.*]], i1 [[C:%.*]]) {
+; CHECK-NEXT:  [[ENTRY:.*:]]
+; CHECK-NEXT:    br i1 [[C]], label %[[A:.*]], label %[[B:.*]]
+; CHECK:       [[A]]:
+; CHECK-NEXT:    [[V1:%.*]] = load i32, ptr [[P]], align 4
+; CHECK-NEXT:    call void (...) @use(i32 [[V1]])
+; CHECK-NEXT:    [[TMP0:%.*]] = trunc i32 [[V1]] to i8
+; CHECK-NEXT:    br label %[[MERGE:.*]]
+; CHECK:       [[B]]:
+; CHECK-NEXT:    [[V2:%.*]] = load i32, ptr [[P]], align 4
+; CHECK-NEXT:    call void (...) @use(i32 [[V2]])
+; CHECK-NEXT:    [[TMP1:%.*]] = trunc i32 [[V2]] to i8
+; CHECK-NEXT:    br label %[[MERGE]]
+; CHECK:       [[MERGE]]:
+; CHECK-NEXT:    [[X:%.*]] = phi i8 [ [[TMP1]], %[[B]] ], [ [[TMP0]], %[[A]] ]
+; CHECK-NEXT:    ret i8 [[X]]
+;
+entry:
+  br i1 %c, label %a, label %b
+
+a:
+  %v1 = load i32, ptr %p
+  call void (...) @use(i32 %v1)
+  br label %merge
+
+b:
+  %v2 = load i32, ptr %p
+  call void (...) @use(i32 %v2)
+  br label %merge
+
+merge:
+  %x = load i8, ptr %p
+  ret i8 %x
+}
+
+define i8 @load_i32_to_i8_pre(ptr %p, i1 %c) {
+; CHECK-LABEL: define i8 @load_i32_to_i8_pre(
+; CHECK-SAME: ptr [[P:%.*]], i1 [[C:%.*]]) {
+; CHECK-NEXT:  [[ENTRY:.*:]]
+; CHECK-NEXT:    br i1 [[C]], label %[[A:.*]], label %[[B:.*]]
+; CHECK:       [[A]]:
+; CHECK-NEXT:    [[V:%.*]] = load i32, ptr [[P]], align 4
+; CHECK-NEXT:    call void (...) @use(i32 [[V]])
+; CHECK-NEXT:    [[TMP0:%.*]] = trunc i32 [[V]] to i8
+; CHECK-NEXT:    br label %[[MERGE:.*]]
+; CHECK:       [[B]]:
+; CHECK-NEXT:    call void (...) @use()
+; CHECK-NEXT:    [[X_PRE:%.*]] = load i8, ptr [[P]], align 1
+; CHECK-NEXT:    br label %[[MERGE]]
+; CHECK:       [[MERGE]]:
+; CHECK-NEXT:    [[X:%.*]] = phi i8 [ [[X_PRE]], %[[B]] ], [ [[TMP0]], %[[A]] ]
+; CHECK-NEXT:    ret i8 [[X]]
+;
+entry:
+  br i1 %c, label %a, label %b
+
+a:
+  %v = load i32, ptr %p
+  call void (...) @use(i32 %v)
+  br label %merge
+
+b:
+  call void (...) @use()
+  br label %merge
+
+merge:
+  %x = load i8, ptr %p
+  ret i8 %x
+}
+
+; The lanes of %v lie inside %x.
+define i32 @neg_load_v4i32_to_i32(ptr %p) {
+; CHECK-LABEL: define i32 @neg_load_v4i32_to_i32(
+; CHECK-SAME: ptr [[P:%.*]]) {
+; CHECK-NEXT:    [[V:%.*]] = load <4 x i32>, ptr [[P]], align 16
+; CHECK-NEXT:    call void (...) @use(<4 x i32> [[V]])
+; CHECK-NEXT:    [[Q:%.*]] = getelementptr i8, ptr [[P]], i64 4
+; CHECK-NEXT:    [[TMP1:%.*]] = bitcast <4 x i32> [[V]] to b128
+; CHECK-NEXT:    [[TMP2:%.*]] = bitextract i32, b128 [[TMP1]], i32 32
+; CHECK-NEXT:    ret i32 [[TMP2]]
+;
+  %v = load <4 x i32>, ptr %p
+  call void (...) @use(<4 x i32> %v)
+  %q = getelementptr i8, ptr %p, i64 4
+  %x = load i32, ptr %q
+  ret i32 %x
+}
+
+; The lanes of %v lie inside the lanes of %x.
+define <2 x i64> @neg_load_v4i32_to_v2i64(ptr %p) {
+; CHECK-LABEL: define <2 x i64> @neg_load_v4i32_to_v2i64(
+; CHECK-SAME: ptr [[P:%.*]]) {
+; CHECK-NEXT:    [[V:%.*]] = load <4 x i32>, ptr [[P]], align 16
+; CHECK-NEXT:    call void (...) @use(<4 x i32> [[V]])
+; CHECK-NEXT:    [[TMP1:%.*]] = bitcast <4 x i32> [[V]] to <2 x i64>
+; CHECK-NEXT:    ret <2 x i64> [[TMP1]]
+;
+  %v = load <4 x i32>, ptr %p
+  call void (...) @use(<4 x i32> %v)
+  %x = load <2 x i64>, ptr %p
+  ret <2 x i64> %x
+}
+
+; A pointer of the same type keeps provenance.
+define ptr @neg_load_v2ptr_to_ptr(ptr %p) {
+; CHECK-LABEL: define ptr @neg_load_v2ptr_to_ptr(
+; CHECK-SAME: ptr [[P:%.*]]) {
+; CHECK-NEXT:    [[V:%.*]] = load <2 x ptr>, ptr [[P]], align 16
+; CHECK-NEXT:    call void (...) @use(<2 x ptr> [[V]])
+; CHECK-NEXT:    [[Q:%.*]] = getelementptr i8, ptr [[P]], i64 8
+; CHECK-NEXT:    [[TMP1:%.*]] = bitcast <2 x ptr> [[V]] to b128
+; CHECK-NEXT:    [[TMP2:%.*]] = bitextract ptr, b128 [[TMP1]], i32 64
+; CHECK-NEXT:    ret ptr [[TMP2]]
+;
+  %v = load <2 x ptr>, ptr %p
+  call void (...) @use(<2 x ptr> %v)
+  %q = getelementptr i8, ptr %p, i64 8
+  %x = load ptr, ptr %q
+  ret ptr %x
+}
+
+; %v is never poison.
+define i8 @neg_load_i32_noundef_to_i8(ptr %p) {
+; CHECK-LABEL: define i8 @neg_load_i32_noundef_to_i8(
+; CHECK-SAME: ptr [[P:%.*]]) {
+; CHECK-NEXT:    [[V:%.*]] = load i32, ptr [[P]], align 4, !noundef [[META0]]
+; CHECK-NEXT:    call void (...) @use(i32 [[V]])
+; CHECK-NEXT:    [[TMP1:%.*]] = trunc i32 [[V]] to i8
+; CHECK-NEXT:    ret i8 [[TMP1]]
+;
+  %v = load i32, ptr %p, !noundef !{}
+  call void (...) @use(i32 %v)
+  %x = load i8, ptr %p
+  ret i8 %x
+}
+
+; %v is already a byte.
+define i8 @neg_load_b32_to_i8(ptr %p) {
+; CHECK-LABEL: define i8 @neg_load_b32_to_i8(
+; CHECK-SAME: ptr [[P:%.*]]) {
+; CHECK-NEXT:    [[V:%.*]] = load b32, ptr [[P]], align 4
+; CHECK-NEXT:    call void (...) @use(b32 [[V]])
+; CHECK-NEXT:    [[TMP1:%.*]] = bitextract i8, b32 [[V]], i32 0
+; CHECK-NEXT:    ret i8 [[TMP1]]
+;
+  %v = load b32, ptr %p
+  call void (...) @use(b32 %v)
+  %x = load i8, ptr %p
+  ret i8 %x
+}
+
+; %x reads a whole lane of %v.
+define i32 @neg_load_volatile_float_to_i32(ptr %p) {
+; CHECK-LABEL: define i32 @neg_load_volatile_float_to_i32(
+; CHECK-SAME: ptr [[P:%.*]]) {
+; CHECK-NEXT:    [[V:%.*]] = load volatile float, ptr [[P]], align 4
+; CHECK-NEXT:    call void (...) @use(float [[V]])
+; CHECK-NEXT:    [[TMP1:%.*]] = bitcast float [[V]] to i32
+; CHECK-NEXT:    ret i32 [[TMP1]]
+;
+  %v = load volatile float, ptr %p
+  call void (...) @use(float %v)
+  %x = load i32, ptr %p
+  ret i32 %x
+}
+
+; A volatile load can't change from floating-point to integer.
+define i8 @neg_load_volatile_float_to_i8(ptr %p) {
+; CHECK-LABEL: define i8 @neg_load_volatile_float_to_i8(
+; CHECK-SAME: ptr [[P:%.*]]) {
+; CHECK-NEXT:    [[V:%.*]] = load volatile float, ptr [[P]], align 4
+; CHECK-NEXT:    call void (...) @use(float [[V]])
+; CHECK-NEXT:    [[TMP1:%.*]] = bitcast float [[V]] to i32
+; CHECK-NEXT:    [[TMP2:%.*]] = trunc i32 [[TMP1]] to i8
+; CHECK-NEXT:    ret i8 [[TMP2]]
+;
+  %v = load volatile float, ptr %p
+  call void (...) @use(float %v)
+  %x = load i8, ptr %p
+  ret i8 %x
+}
+
+; GVN can't erase %v while it visits the block.
+define void @neg_load_i32_to_i8_loop(ptr %p, i1 %c) {
+; CHECK-LABEL: define void @neg_load_i32_to_i8_loop(
+; CHECK-SAME: ptr [[P:%.*]], i1 [[C:%.*]]) {
+; CHECK-NEXT:  [[ENTRY:.*]]:
+; CHECK-NEXT:    [[X_PRE:%.*]] = load i8, ptr [[P]], align 1
+; CHECK-NEXT:    [[V_PRE:%.*]] = load i32, ptr [[P]], align 4
+; CHECK-NEXT:    br label %[[LOOP:.*]]
+; CHECK:       [[LOOP]]:
+; CHECK-NEXT:    [[X:%.*]] = phi i8 [ [[TMP0:%.*]], %[[LOOP]] ], [ [[X_PRE]], %[[ENTRY]] ]
+; CHECK-NEXT:    call void (...) @use(i8 [[X]], i32 [[V_PRE]])
+; CHECK-NEXT:    [[TMP0]] = trunc i32 [[V_PRE]] to i8
+; CHECK-NEXT:    br i1 [[C]], label %[[LOOP]], label %[[EXIT:.*]]
+; CHECK:       [[EXIT]]:
+; CHECK-NEXT:    ret void
+;
+entry:
+  br label %loop
+
+loop:
+  %x = load i8, ptr %p
+  %v = load i32, ptr %p
+  call void (...) @use(i8 %x, i32 %v)
+  br i1 %c, label %loop, label %exit
+
+exit:
+  ret void
+}
+
+;.
+; CHECK: [[META0]] = !{}
+;.

>From 15204b5884448d478335f43fd9a0d60bc3a54540 Mon Sep 17 00:00:00 2001
From: Pedro Lobo <pedro.lobo at tecnico.ulisboa.pt>
Date: Sat, 31 Oct 2026 17:01:17 +0000
Subject: [PATCH 2/2] [GVN] Preserve per-bit `poison` and provenance when
 forwarding a load

---
 llvm/lib/Transforms/Scalar/GVN.cpp            | 103 +++++++++++++++-
 llvm/test/Transforms/GVN/PRE/atomic.ll        |   5 +-
 llvm/test/Transforms/GVN/PRE/rle.ll           |  53 ++++-----
 llvm/test/Transforms/GVN/invariant.group.ll   |   5 +-
 llvm/test/Transforms/GVN/load-poison.ll       | 111 ++++++++++--------
 llvm/test/Transforms/GVN/metadata.ll          |  10 +-
 .../Transforms/GVN/rle-coerced-noalias.ll     |  14 +--
 7 files changed, 206 insertions(+), 95 deletions(-)

diff --git a/llvm/lib/Transforms/Scalar/GVN.cpp b/llvm/lib/Transforms/Scalar/GVN.cpp
index 297d3cbc1549b0..89ef5efea534b8 100644
--- a/llvm/lib/Transforms/Scalar/GVN.cpp
+++ b/llvm/lib/Transforms/Scalar/GVN.cpp
@@ -414,6 +414,16 @@ class llvm::GVNPassImpl {
                                AvailValInBlkVect &ValuesPerBlock,
                                UnavailBlkVect &UnavailableBlocks);
 
+  /// Return true if \p DepLoad can be forwarded to \p Load at byte \p Offset
+  /// exactly, possibly after turning \p DepLoad into a byte load.
+  bool canForwardLoad(LoadInst *DepLoad, unsigned Offset, LoadInst *Load);
+
+  /// If forwarding \p AV to \p Load loses bits of memory, replace the load it
+  /// forwards from with a byte load. If \p ValuesPerBlock is given, update its
+  /// entries that refer to the old load.
+  void convertToByteLoad(LoadInst *Load, AvailableValue &AV,
+                         AvailValInBlkVect *ValuesPerBlock = nullptr);
+
   /// Given a critical edge from Pred to LoadBB, find a load instruction
   /// which is identical to Load from another successor of Pred.
   LoadInst *findLoadToHoistIntoPred(BasicBlock *Pred, BasicBlock *LoadBB,
@@ -1641,6 +1651,86 @@ GVNPassImpl::analyzeSelectAvailability(LoadInst *Load, SelectInst *Sel,
   return AvailableValue::getSelect(Sel, V1, V2);
 }
 
+/// Return true if forwarding \p DepLoad to \p Load at byte \p Offset can lose
+/// bits that \p Load reads from memory, so \p DepLoad must become a byte load.
+static bool needsByteLoad(LoadInst *DepLoad, unsigned Offset, LoadInst *Load,
+                          AssumptionCache *AC, DominatorTree *DT) {
+  Type *DepTy = DepLoad->getType();
+  Type *LoadTy = Load->getType();
+  if (DepTy->isByteOrByteVectorTy())
+    return false;
+  // Only a byte keeps every bit of memory, including pointer bits.
+  if (LoadTy->isByteOrByteVectorTy())
+    return true;
+  // Only a pointer of the same type keeps the provenance of a pointer.
+  if (LoadTy->isPtrOrPtrVectorTy() &&
+      DepTy->getScalarType() != LoadTy->getScalarType())
+    return true;
+  if (isGuaranteedNotToBePoison(DepLoad, AC, Load, DT))
+    return false;
+  // Memory is poison per bit, while vectors are poison per lane and other types
+  // are poison per value. Each lane of Load must cover whole lanes of DepLoad.
+  const DataLayout &DL = DepLoad->getDataLayout();
+  uint64_t DepBits =
+      DL.getTypeSizeInBits(DepTy->getScalarType()).getFixedValue();
+  uint64_t LoadBits =
+      DL.getTypeSizeInBits(LoadTy->getScalarType()).getFixedValue();
+  return (Offset * 8) % DepBits != 0 || LoadBits % DepBits != 0;
+}
+
+bool GVNPassImpl::canForwardLoad(LoadInst *DepLoad, unsigned Offset,
+                                 LoadInst *Load) {
+  if (!needsByteLoad(DepLoad, Offset, Load, AC, DT))
+    return true;
+  // DepLoad must become a byte load. Bytes lower to integers, and a volatile
+  // load can't change from floating-point to integer.
+  if (DepLoad->isVolatile() && DepLoad->getType()->isFPOrFPVectorTy())
+    return false;
+  // processBlock may already point to a DepLoad that comes after Load.
+  return DepLoad->getParent() != Load->getParent() ||
+         DepLoad->comesBefore(Load);
+}
+
+void GVNPassImpl::convertToByteLoad(LoadInst *Load, AvailableValue &AV,
+                                    AvailValInBlkVect *ValuesPerBlock) {
+  if (!AV.isCoercedLoadValue())
+    return;
+  LoadInst *DepLoad = AV.getCoercedLoadValue();
+  if (!needsByteLoad(DepLoad, AV.Offset, Load, AC, DT))
+    return;
+  LLVM_DEBUG(dbgs() << "GVN CONVERTED TO BYTE LOAD: " << *DepLoad << '\n');
+
+  Type *Ty = DepLoad->getType();
+  Type *ByteTy = Ty->isPtrOrPtrVectorTy()
+                     ? DepLoad->getDataLayout().getBytePtrType(Ty)
+                     : Type::getByteFromIntType(Ty);
+  auto *ByteLoad = new LoadInst(
+      ByteTy, DepLoad->getPointerOperand(), DepLoad->getName() + ".bytes",
+      DepLoad->getProperties(), DepLoad->getIterator());
+  copyMetadataForLoad(*ByteLoad, *DepLoad);
+  if (MSSAU) {
+    auto *NewAccess = MSSAU->createMemoryAccessBefore(
+        ByteLoad, nullptr, MSSAU->getMemorySSA()->getMemoryAccess(DepLoad));
+    if (auto *NewDef = dyn_cast<MemoryDef>(NewAccess))
+      MSSAU->insertDef(NewDef, /*RenameUses=*/true);
+    else
+      MSSAU->insertUse(cast<MemoryUse>(NewAccess), /*RenameUses=*/true);
+  }
+
+  auto *Cast = new BitCastInst(ByteLoad, Ty, "", DepLoad->getIterator());
+  Cast->setDebugLoc(DepLoad->getDebugLoc());
+  Cast->takeName(DepLoad);
+
+  ICF->removeUsersOf(DepLoad);
+  DepLoad->replaceAllUsesWith(Cast);
+  if (ValuesPerBlock)
+    replaceValuesPerBlockEntry(*ValuesPerBlock, DepLoad, Cast);
+  if (uint32_t ValNo = VN.lookup(DepLoad, false))
+    LeaderTable.erase(ValNo, DepLoad, DepLoad->getParent());
+  removeInstruction(DepLoad);
+  AV.Val = ByteLoad;
+}
+
 std::optional<AvailableValue>
 GVNPassImpl::analyzeLoadAvailability(LoadInst *Load, const ReachingMemVal &Dep,
                                      Value *Address) {
@@ -1697,7 +1787,7 @@ GVNPassImpl::analyzeLoadAvailability(LoadInst *Load, const ReachingMemVal &Dep,
         if (Offset == -1)
           Offset =
               analyzeLoadFromClobberingLoad(LoadType, Address, DepLoad, DL);
-        if (Offset != -1)
+        if (Offset != -1 && canForwardLoad(DepLoad, Offset, Load))
           return AvailableValue::getLoad(DepLoad, Offset);
       }
     }
@@ -1761,6 +1851,9 @@ GVNPassImpl::analyzeLoadAvailability(LoadInst *Load, const ReachingMemVal &Dep,
     if (LD->isAtomic() < Load->isAtomic())
       return std::nullopt;
 
+    if (!canForwardLoad(LD, 0, Load))
+      return std::nullopt;
+
     return AvailableValue::getLoad(LD);
   }
 
@@ -1981,6 +2074,9 @@ void GVNPassImpl::eliminatePartiallyRedundantLoad(
     }
   }
 
+  for (AvailableValueInBlock &AV : ValuesPerBlock)
+    convertToByteLoad(Load, AV.AV, &ValuesPerBlock);
+
   // Perform PHI construction.
   Value *V = constructSSAForLoadSet(Load, ValuesPerBlock, getDominatorTree());
   // constructSSAForLoadSet is responsible for combining metadata.
@@ -2436,6 +2532,9 @@ bool GVNPassImpl::processNonLocalLoad(LoadInst *Load,
   if (UnavailableBlocks.empty()) {
     LLVM_DEBUG(dbgs() << "GVN REMOVING NONLOCAL LOAD: " << *Load << '\n');
 
+    for (AvailableValueInBlock &AV : ValuesPerBlock)
+      convertToByteLoad(Load, AV.AV, &ValuesPerBlock);
+
     // Perform PHI construction.
     Value *V = constructSSAForLoadSet(Load, ValuesPerBlock, getDominatorTree());
     // constructSSAForLoadSet is responsible for combining metadata.
@@ -3147,6 +3246,8 @@ bool GVNPassImpl::processLoad(LoadInst *L) {
   if (!AV)
     return false;
 
+  convertToByteLoad(L, *AV);
+
   Value *AvailableValue = AV->MaterializeAdjustedValue(L, L);
 
   // MaterializeAdjustedValue is responsible for combining metadata.
diff --git a/llvm/test/Transforms/GVN/PRE/atomic.ll b/llvm/test/Transforms/GVN/PRE/atomic.ll
index ed530bec22e846..fb60ac26004d2b 100644
--- a/llvm/test/Transforms/GVN/PRE/atomic.ll
+++ b/llvm/test/Transforms/GVN/PRE/atomic.ll
@@ -426,8 +426,9 @@ define i64 @widen1(ptr %P1) {
 define i64 @narrow(ptr %P1) {
 ; CHECK-LABEL: define i64 @narrow
 ; CHECK-SAME: (ptr [[P1:%.*]]) {
-; CHECK-NEXT:    [[A64:%.*]] = load atomic i64, ptr [[P1]] unordered, align 4
-; CHECK-NEXT:    [[TMP1:%.*]] = trunc i64 [[A64]] to i32
+; CHECK-NEXT:    [[A64_BYTES:%.*]] = load atomic b64, ptr [[P1]] unordered, align 4
+; CHECK-NEXT:    [[A64:%.*]] = bitcast b64 [[A64_BYTES]] to i64
+; CHECK-NEXT:    [[TMP1:%.*]] = bitextract i32, b64 [[A64_BYTES]], i32 0
 ; CHECK-NEXT:    [[B64:%.*]] = sext i32 [[TMP1]] to i64
 ; CHECK-NEXT:    [[RES:%.*]] = sub i64 [[A64]], [[B64]]
 ; CHECK-NEXT:    ret i64 [[RES]]
diff --git a/llvm/test/Transforms/GVN/PRE/rle.ll b/llvm/test/Transforms/GVN/PRE/rle.ll
index 49fe873c0141f1..1e8da7a5eff335 100644
--- a/llvm/test/Transforms/GVN/PRE/rle.ll
+++ b/llvm/test/Transforms/GVN/PRE/rle.ll
@@ -951,9 +951,9 @@ define i32 @load_load_partial_alias(ptr %P) nounwind ssp {
 ; LE-LABEL: define i32 @load_load_partial_alias(
 ; LE-SAME: ptr [[P:%.*]]) #[[ATTR0]] {
 ; LE-NEXT:  [[ENTRY:.*:]]
-; LE-NEXT:    [[TTMP2:%.*]] = load i32, ptr [[P]], align 4
-; LE-NEXT:    [[TMP0:%.*]] = lshr i32 [[TTMP2]], 8
-; LE-NEXT:    [[TMP1:%.*]] = trunc i32 [[TMP0]] to i8
+; LE-NEXT:    [[TTMP2_BYTES:%.*]] = load b32, ptr [[P]], align 4
+; LE-NEXT:    [[TTMP2:%.*]] = bitcast b32 [[TTMP2_BYTES]] to i32
+; LE-NEXT:    [[TMP1:%.*]] = bitextract i8, b32 [[TTMP2_BYTES]], i32 8
 ; LE-NEXT:    [[CONV:%.*]] = zext i8 [[TMP1]] to i32
 ; LE-NEXT:    [[ADD:%.*]] = add nsw i32 [[TTMP2]], [[CONV]]
 ; LE-NEXT:    ret i32 [[ADD]]
@@ -961,9 +961,9 @@ define i32 @load_load_partial_alias(ptr %P) nounwind ssp {
 ; BE-LABEL: define i32 @load_load_partial_alias(
 ; BE-SAME: ptr [[P:%.*]]) #[[ATTR0]] {
 ; BE-NEXT:  [[ENTRY:.*:]]
-; BE-NEXT:    [[TTMP2:%.*]] = load i32, ptr [[P]], align 4
-; BE-NEXT:    [[TMP0:%.*]] = lshr i32 [[TTMP2]], 16
-; BE-NEXT:    [[TMP1:%.*]] = trunc i32 [[TMP0]] to i8
+; BE-NEXT:    [[TTMP2_BYTES:%.*]] = load b32, ptr [[P]], align 4
+; BE-NEXT:    [[TTMP2:%.*]] = bitcast b32 [[TTMP2_BYTES]] to i32
+; BE-NEXT:    [[TMP1:%.*]] = bitextract i8, b32 [[TTMP2_BYTES]], i32 16
 ; BE-NEXT:    [[CONV:%.*]] = zext i8 [[TMP1]] to i32
 ; BE-NEXT:    [[ADD:%.*]] = add nsw i32 [[TTMP2]], [[CONV]]
 ; BE-NEXT:    ret i32 [[ADD]]
@@ -1139,21 +1139,22 @@ define void @load_load_partial_alias_loop(ptr %P) {
 ; LE-NEXT:    [[P_1:%.*]] = getelementptr i8, ptr [[P]], i64 1
 ; LE-NEXT:    [[V_1:%.*]] = load i8, ptr [[P_1]], align 1
 ; LE-NEXT:    call void @use.i8(i8 [[V_1]])
-; LE-NEXT:    [[V_1_32:%.*]] = load i32, ptr [[P_1]], align 4
+; LE-NEXT:    [[V_1_32_BYTES:%.*]] = load b32, ptr [[P_1]], align 4
+; LE-NEXT:    [[V_1_32:%.*]] = bitcast b32 [[V_1_32_BYTES]] to i32
 ; LE-NEXT:    call void @use.i32(i32 [[V_1_32]])
-; LE-NEXT:    [[TMP0:%.*]] = trunc i32 [[V_1_32]] to i8
+; LE-NEXT:    [[TMP0:%.*]] = bitextract i8, b32 [[V_1_32_BYTES]], i32 0
 ; LE-NEXT:    br label %[[LOOP:.*]]
 ; LE:       [[LOOP]]:
-; LE-NEXT:    [[V_I:%.*]] = phi i8 [ [[TMP0]], %[[ENTRY]] ], [ [[TMP2:%.*]], %[[LOOP_LOOP_CRIT_EDGE:.*]] ]
+; LE-NEXT:    [[V_I:%.*]] = phi i8 [ [[TMP0]], %[[ENTRY]] ], [ [[TMP1:%.*]], %[[LOOP_LOOP_CRIT_EDGE:.*]] ]
 ; LE-NEXT:    [[I:%.*]] = phi i64 [ 1, %[[ENTRY]] ], [ [[I_INC:%.*]], %[[LOOP_LOOP_CRIT_EDGE]] ]
 ; LE-NEXT:    [[P_I:%.*]] = getelementptr i8, ptr [[P]], i64 [[I]]
 ; LE-NEXT:    call void @use.i8(i8 [[V_I]])
-; LE-NEXT:    [[V_I_32:%.*]] = load i32, ptr [[P_I]], align 4
+; LE-NEXT:    [[V_I_32_BYTES:%.*]] = load b32, ptr [[P_I]], align 4
+; LE-NEXT:    [[V_I_32:%.*]] = bitcast b32 [[V_I_32_BYTES]] to i32
 ; LE-NEXT:    call void @use.i32(i32 [[V_I_32]])
 ; LE-NEXT:    [[I_INC]] = add i64 [[I]], 1
 ; LE-NEXT:    [[CMP:%.*]] = icmp ne i64 [[I_INC]], 64
-; LE-NEXT:    [[TMP1:%.*]] = lshr i32 [[V_I_32]], 8
-; LE-NEXT:    [[TMP2]] = trunc i32 [[TMP1]] to i8
+; LE-NEXT:    [[TMP1]] = bitextract i8, b32 [[V_I_32_BYTES]], i32 8
 ; LE-NEXT:    br i1 [[CMP]], label %[[LOOP_LOOP_CRIT_EDGE]], label %[[EXIT:.*]]
 ; LE:       [[LOOP_LOOP_CRIT_EDGE]]:
 ; LE-NEXT:    br label %[[LOOP]]
@@ -1166,22 +1167,22 @@ define void @load_load_partial_alias_loop(ptr %P) {
 ; BE-NEXT:    [[P_1:%.*]] = getelementptr i8, ptr [[P]], i64 1
 ; BE-NEXT:    [[V_1:%.*]] = load i8, ptr [[P_1]], align 1
 ; BE-NEXT:    call void @use.i8(i8 [[V_1]])
-; BE-NEXT:    [[V_1_32:%.*]] = load i32, ptr [[P_1]], align 4
+; BE-NEXT:    [[V_1_32_BYTES:%.*]] = load b32, ptr [[P_1]], align 4
+; BE-NEXT:    [[V_1_32:%.*]] = bitcast b32 [[V_1_32_BYTES]] to i32
 ; BE-NEXT:    call void @use.i32(i32 [[V_1_32]])
-; BE-NEXT:    [[TMP0:%.*]] = lshr i32 [[V_1_32]], 24
-; BE-NEXT:    [[TMP1:%.*]] = trunc i32 [[TMP0]] to i8
+; BE-NEXT:    [[TMP0:%.*]] = bitextract i8, b32 [[V_1_32_BYTES]], i32 24
 ; BE-NEXT:    br label %[[LOOP:.*]]
 ; BE:       [[LOOP]]:
-; BE-NEXT:    [[V_I:%.*]] = phi i8 [ [[TMP1]], %[[ENTRY]] ], [ [[TMP3:%.*]], %[[LOOP_LOOP_CRIT_EDGE:.*]] ]
+; BE-NEXT:    [[V_I:%.*]] = phi i8 [ [[TMP0]], %[[ENTRY]] ], [ [[TMP1:%.*]], %[[LOOP_LOOP_CRIT_EDGE:.*]] ]
 ; BE-NEXT:    [[I:%.*]] = phi i64 [ 1, %[[ENTRY]] ], [ [[I_INC:%.*]], %[[LOOP_LOOP_CRIT_EDGE]] ]
 ; BE-NEXT:    [[P_I:%.*]] = getelementptr i8, ptr [[P]], i64 [[I]]
 ; BE-NEXT:    call void @use.i8(i8 [[V_I]])
-; BE-NEXT:    [[V_I_32:%.*]] = load i32, ptr [[P_I]], align 4
+; BE-NEXT:    [[V_I_32_BYTES:%.*]] = load b32, ptr [[P_I]], align 4
+; BE-NEXT:    [[V_I_32:%.*]] = bitcast b32 [[V_I_32_BYTES]] to i32
 ; BE-NEXT:    call void @use.i32(i32 [[V_I_32]])
 ; BE-NEXT:    [[I_INC]] = add i64 [[I]], 1
 ; BE-NEXT:    [[CMP:%.*]] = icmp ne i64 [[I_INC]], 64
-; BE-NEXT:    [[TMP2:%.*]] = lshr i32 [[V_I_32]], 16
-; BE-NEXT:    [[TMP3]] = trunc i32 [[TMP2]] to i8
+; BE-NEXT:    [[TMP1]] = bitextract i8, b32 [[V_I_32_BYTES]], i32 16
 ; BE-NEXT:    br i1 [[CMP]], label %[[LOOP_LOOP_CRIT_EDGE]], label %[[EXIT:.*]]
 ; BE:       [[LOOP_LOOP_CRIT_EDGE]]:
 ; BE-NEXT:    br label %[[LOOP]]
@@ -1221,13 +1222,12 @@ define void @load_load_partial_alias_atomic(ptr %arg) {
 ; LE-SAME: ptr [[ARG:%.*]]) {
 ; LE-NEXT:  [[BB:.*]]:
 ; LE-NEXT:    [[TMP2_1:%.*]] = getelementptr inbounds i8, ptr [[ARG]], i64 1
-; LE-NEXT:    [[TMP2_3:%.*]] = load i64, ptr [[TMP2_1]], align 4
+; LE-NEXT:    [[TMP2_3_BYTES:%.*]] = load b64, ptr [[TMP2_1]], align 4
 ; LE-NEXT:    [[TMP3_1:%.*]] = getelementptr inbounds i8, ptr [[ARG]], i64 2
-; LE-NEXT:    [[TMP0:%.*]] = lshr i64 [[TMP2_3]], 8
-; LE-NEXT:    [[TMP1:%.*]] = trunc i64 [[TMP0]] to i8
+; LE-NEXT:    [[TMP0:%.*]] = bitextract i8, b64 [[TMP2_3_BYTES]], i32 8
 ; LE-NEXT:    br label %[[BB5:.*]]
 ; LE:       [[BB5]]:
-; LE-NEXT:    [[TMP4_1:%.*]] = phi i8 [ [[TMP4_1_PRE:%.*]], %[[BB5]] ], [ [[TMP1]], %[[BB]] ]
+; LE-NEXT:    [[TMP4_1:%.*]] = phi i8 [ [[TMP4_1_PRE:%.*]], %[[BB5]] ], [ [[TMP0]], %[[BB]] ]
 ; LE-NEXT:    [[TMP6_1:%.*]] = load atomic i8, ptr @global acquire, align 4
 ; LE-NEXT:    [[TMP7_1:%.*]] = add i8 [[TMP6_1]], [[TMP4_1]]
 ; LE-NEXT:    store i8 [[TMP7_1]], ptr [[ARG]], align 1
@@ -1238,13 +1238,12 @@ define void @load_load_partial_alias_atomic(ptr %arg) {
 ; BE-SAME: ptr [[ARG:%.*]]) {
 ; BE-NEXT:  [[BB:.*]]:
 ; BE-NEXT:    [[TMP2_1:%.*]] = getelementptr inbounds i8, ptr [[ARG]], i64 1
-; BE-NEXT:    [[TMP2_3:%.*]] = load i64, ptr [[TMP2_1]], align 4
+; BE-NEXT:    [[TMP2_3_BYTES:%.*]] = load b64, ptr [[TMP2_1]], align 4
 ; BE-NEXT:    [[TMP3_1:%.*]] = getelementptr inbounds i8, ptr [[ARG]], i64 2
-; BE-NEXT:    [[TMP0:%.*]] = lshr i64 [[TMP2_3]], 48
-; BE-NEXT:    [[TMP1:%.*]] = trunc i64 [[TMP0]] to i8
+; BE-NEXT:    [[TMP0:%.*]] = bitextract i8, b64 [[TMP2_3_BYTES]], i32 48
 ; BE-NEXT:    br label %[[BB5:.*]]
 ; BE:       [[BB5]]:
-; BE-NEXT:    [[TMP4_1:%.*]] = phi i8 [ [[TMP4_1_PRE:%.*]], %[[BB5]] ], [ [[TMP1]], %[[BB]] ]
+; BE-NEXT:    [[TMP4_1:%.*]] = phi i8 [ [[TMP4_1_PRE:%.*]], %[[BB5]] ], [ [[TMP0]], %[[BB]] ]
 ; BE-NEXT:    [[TMP6_1:%.*]] = load atomic i8, ptr @global acquire, align 4
 ; BE-NEXT:    [[TMP7_1:%.*]] = add i8 [[TMP6_1]], [[TMP4_1]]
 ; BE-NEXT:    store i8 [[TMP7_1]], ptr [[ARG]], align 1
diff --git a/llvm/test/Transforms/GVN/invariant.group.ll b/llvm/test/Transforms/GVN/invariant.group.ll
index 50dbfe4f3100b4..80cadc5f463118 100644
--- a/llvm/test/Transforms/GVN/invariant.group.ll
+++ b/llvm/test/Transforms/GVN/invariant.group.ll
@@ -469,11 +469,12 @@ define void @testNotGlobal() {
 ; CHECK-LABEL: define void @testNotGlobal() {
 ; CHECK-NEXT:    [[A:%.*]] = alloca i8, align 1
 ; CHECK-NEXT:    call void @foo(ptr [[A]])
-; CHECK-NEXT:    [[B:%.*]] = load i8, ptr [[A]], align 1, !invariant.group [[META0]]
+; CHECK-NEXT:    [[B_BYTES:%.*]] = load b8, ptr [[A]], align 1, !invariant.group [[META0]]
+; CHECK-NEXT:    [[B:%.*]] = bitcast b8 [[B_BYTES]] to i8
 ; CHECK-NEXT:    call void @foo2(ptr [[A]], i8 [[B]])
 ; CHECK-NEXT:    call void @bar(i8 [[B]])
 ; CHECK-NEXT:    call void @fooBit(ptr [[A]], i1 true)
-; CHECK-NEXT:    [[TMP1:%.*]] = trunc i8 [[B]] to i1
+; CHECK-NEXT:    [[TMP1:%.*]] = bitextract i1, b8 [[B_BYTES]], i32 0
 ; CHECK-NEXT:    call void @fooBit(ptr [[A]], i1 [[TMP1]])
 ; CHECK-NEXT:    call void @fooBit(ptr [[A]], i1 [[TMP1]])
 ; CHECK-NEXT:    ret void
diff --git a/llvm/test/Transforms/GVN/load-poison.ll b/llvm/test/Transforms/GVN/load-poison.ll
index 23d90be46bca9b..dbb54fcb0bc217 100644
--- a/llvm/test/Transforms/GVN/load-poison.ll
+++ b/llvm/test/Transforms/GVN/load-poison.ll
@@ -7,8 +7,9 @@ declare void @use(...) memory(none)
 define <2 x i64> @pr99268(ptr %p) {
 ; CHECK-LABEL: define <2 x i64> @pr99268(
 ; CHECK-SAME: ptr [[P:%.*]]) {
-; CHECK-NEXT:    [[V:%.*]] = load <2 x i64>, ptr [[P]], align 16
-; CHECK-NEXT:    [[TMP1:%.*]] = bitcast <2 x i64> [[V]] to b128
+; CHECK-NEXT:    [[V_BYTES:%.*]] = load <2 x b64>, ptr [[P]], align 16
+; CHECK-NEXT:    [[V:%.*]] = bitcast <2 x b64> [[V_BYTES]] to <2 x i64>
+; CHECK-NEXT:    [[TMP1:%.*]] = bitcast <2 x b64> [[V_BYTES]] to b128
 ; CHECK-NEXT:    [[TMP2:%.*]] = bitextract b64, b128 [[TMP1]], i32 0
 ; CHECK-NEXT:    [[TMP3:%.*]] = bitcast b64 [[TMP2]] to <2 x i32>
 ; CHECK-NEXT:    [[S:%.*]] = sext <2 x i32> [[TMP3]] to <2 x i64>
@@ -25,9 +26,10 @@ define <2 x i64> @pr99268(ptr %p) {
 define i8 @load_i32_to_i8(ptr %p) {
 ; CHECK-LABEL: define i8 @load_i32_to_i8(
 ; CHECK-SAME: ptr [[P:%.*]]) {
-; CHECK-NEXT:    [[V:%.*]] = load i32, ptr [[P]], align 4
+; CHECK-NEXT:    [[V_BYTES:%.*]] = load b32, ptr [[P]], align 4
+; CHECK-NEXT:    [[V:%.*]] = bitcast b32 [[V_BYTES]] to i32
 ; CHECK-NEXT:    call void (...) @use(i32 [[V]])
-; CHECK-NEXT:    [[TMP1:%.*]] = trunc i32 [[V]] to i8
+; CHECK-NEXT:    [[TMP1:%.*]] = bitextract i8, b32 [[V_BYTES]], i32 0
 ; CHECK-NEXT:    ret i8 [[TMP1]]
 ;
   %v = load i32, ptr %p
@@ -39,11 +41,11 @@ define i8 @load_i32_to_i8(ptr %p) {
 define i32 @load_ptr_to_i32(ptr %p) {
 ; CHECK-LABEL: define i32 @load_ptr_to_i32(
 ; CHECK-SAME: ptr [[P:%.*]]) {
-; CHECK-NEXT:    [[V:%.*]] = load ptr, ptr [[P]], align 8
+; CHECK-NEXT:    [[V_BYTES:%.*]] = load b64, ptr [[P]], align 8
+; CHECK-NEXT:    [[V:%.*]] = bitcast b64 [[V_BYTES]] to ptr
 ; CHECK-NEXT:    call void (...) @use(ptr [[V]])
-; CHECK-NEXT:    [[TMP1:%.*]] = ptrtoint ptr [[V]] to i64
-; CHECK-NEXT:    [[TMP2:%.*]] = trunc i64 [[TMP1]] to i32
-; CHECK-NEXT:    ret i32 [[TMP2]]
+; CHECK-NEXT:    [[TMP1:%.*]] = bitextract i32, b64 [[V_BYTES]], i32 0
+; CHECK-NEXT:    ret i32 [[TMP1]]
 ;
   %v = load ptr, ptr %p
   call void (...) @use(ptr %v)
@@ -54,10 +56,11 @@ define i32 @load_ptr_to_i32(ptr %p) {
 define i32 @load_v4i32_to_i32_straddle(ptr %p) {
 ; CHECK-LABEL: define i32 @load_v4i32_to_i32_straddle(
 ; CHECK-SAME: ptr [[P:%.*]]) {
-; CHECK-NEXT:    [[V:%.*]] = load <4 x i32>, ptr [[P]], align 16
+; CHECK-NEXT:    [[V_BYTES:%.*]] = load <4 x b32>, ptr [[P]], align 16
+; CHECK-NEXT:    [[V:%.*]] = bitcast <4 x b32> [[V_BYTES]] to <4 x i32>
 ; CHECK-NEXT:    call void (...) @use(<4 x i32> [[V]])
 ; CHECK-NEXT:    [[Q:%.*]] = getelementptr i8, ptr [[P]], i64 2
-; CHECK-NEXT:    [[TMP1:%.*]] = bitcast <4 x i32> [[V]] to b128
+; CHECK-NEXT:    [[TMP1:%.*]] = bitcast <4 x b32> [[V_BYTES]] to b128
 ; CHECK-NEXT:    [[TMP2:%.*]] = bitextract i32, b128 [[TMP1]], i32 16
 ; CHECK-NEXT:    ret i32 [[TMP2]]
 ;
@@ -71,9 +74,10 @@ define i32 @load_v4i32_to_i32_straddle(ptr %p) {
 define i8 @load_v2i12_to_i8(ptr %p) {
 ; CHECK-LABEL: define i8 @load_v2i12_to_i8(
 ; CHECK-SAME: ptr [[P:%.*]]) {
-; CHECK-NEXT:    [[V:%.*]] = load <2 x i12>, ptr [[P]], align 4
+; CHECK-NEXT:    [[V_BYTES:%.*]] = load <2 x b12>, ptr [[P]], align 4
+; CHECK-NEXT:    [[V:%.*]] = bitcast <2 x b12> [[V_BYTES]] to <2 x i12>
 ; CHECK-NEXT:    call void (...) @use(<2 x i12> [[V]])
-; CHECK-NEXT:    [[TMP1:%.*]] = bitcast <2 x i12> [[V]] to b24
+; CHECK-NEXT:    [[TMP1:%.*]] = bitcast <2 x b12> [[V_BYTES]] to b24
 ; CHECK-NEXT:    [[TMP2:%.*]] = bitextract i8, b24 [[TMP1]], i32 0
 ; CHECK-NEXT:    ret i8 [[TMP2]]
 ;
@@ -86,11 +90,11 @@ define i8 @load_v2i12_to_i8(ptr %p) {
 define i8 @load_float_to_i8(ptr %p) {
 ; CHECK-LABEL: define i8 @load_float_to_i8(
 ; CHECK-SAME: ptr [[P:%.*]]) {
-; CHECK-NEXT:    [[V:%.*]] = load float, ptr [[P]], align 4
+; CHECK-NEXT:    [[V_BYTES:%.*]] = load b32, ptr [[P]], align 4
+; CHECK-NEXT:    [[V:%.*]] = bitcast b32 [[V_BYTES]] to float
 ; CHECK-NEXT:    call void (...) @use(float [[V]])
-; CHECK-NEXT:    [[TMP1:%.*]] = bitcast float [[V]] to i32
-; CHECK-NEXT:    [[TMP2:%.*]] = trunc i32 [[TMP1]] to i8
-; CHECK-NEXT:    ret i8 [[TMP2]]
+; CHECK-NEXT:    [[TMP1:%.*]] = bitextract i8, b32 [[V_BYTES]], i32 0
+; CHECK-NEXT:    ret i8 [[TMP1]]
 ;
   %v = load float, ptr %p
   call void (...) @use(float %v)
@@ -101,10 +105,10 @@ define i8 @load_float_to_i8(ptr %p) {
 define b32 @load_i32_to_b32(ptr %p) {
 ; CHECK-LABEL: define b32 @load_i32_to_b32(
 ; CHECK-SAME: ptr [[P:%.*]]) {
-; CHECK-NEXT:    [[V:%.*]] = load i32, ptr [[P]], align 4
+; CHECK-NEXT:    [[V_BYTES:%.*]] = load b32, ptr [[P]], align 4
+; CHECK-NEXT:    [[V:%.*]] = bitcast b32 [[V_BYTES]] to i32
 ; CHECK-NEXT:    call void (...) @use(i32 [[V]])
-; CHECK-NEXT:    [[TMP1:%.*]] = bitcast i32 [[V]] to b32
-; CHECK-NEXT:    ret b32 [[TMP1]]
+; CHECK-NEXT:    ret b32 [[V_BYTES]]
 ;
   %v = load i32, ptr %p
   call void (...) @use(i32 %v)
@@ -115,10 +119,10 @@ define b32 @load_i32_to_b32(ptr %p) {
 define b32 @load_i32_noundef_to_b32(ptr %p) {
 ; CHECK-LABEL: define b32 @load_i32_noundef_to_b32(
 ; CHECK-SAME: ptr [[P:%.*]]) {
-; CHECK-NEXT:    [[V:%.*]] = load i32, ptr [[P]], align 4, !noundef [[META0:![0-9]+]]
+; CHECK-NEXT:    [[V_BYTES:%.*]] = load b32, ptr [[P]], align 4, !noundef [[META0:![0-9]+]]
+; CHECK-NEXT:    [[V:%.*]] = bitcast b32 [[V_BYTES]] to i32
 ; CHECK-NEXT:    call void (...) @use(i32 [[V]])
-; CHECK-NEXT:    [[TMP1:%.*]] = bitcast i32 [[V]] to b32
-; CHECK-NEXT:    ret b32 [[TMP1]]
+; CHECK-NEXT:    ret b32 [[V_BYTES]]
 ;
   %v = load i32, ptr %p, !noundef !{}
   call void (...) @use(i32 %v)
@@ -129,9 +133,10 @@ define b32 @load_i32_noundef_to_b32(ptr %p) {
 define <vscale x 4 x i32> @load_nxv2i64_to_nxv4i32(ptr %p) {
 ; CHECK-LABEL: define <vscale x 4 x i32> @load_nxv2i64_to_nxv4i32(
 ; CHECK-SAME: ptr [[P:%.*]]) {
-; CHECK-NEXT:    [[V:%.*]] = load <vscale x 2 x i64>, ptr [[P]], align 16
+; CHECK-NEXT:    [[V_BYTES:%.*]] = load <vscale x 2 x b64>, ptr [[P]], align 16
+; CHECK-NEXT:    [[V:%.*]] = bitcast <vscale x 2 x b64> [[V_BYTES]] to <vscale x 2 x i64>
 ; CHECK-NEXT:    call void (...) @use(<vscale x 2 x i64> [[V]])
-; CHECK-NEXT:    [[TMP1:%.*]] = bitcast <vscale x 2 x i64> [[V]] to <vscale x 4 x i32>
+; CHECK-NEXT:    [[TMP1:%.*]] = bitcast <vscale x 2 x b64> [[V_BYTES]] to <vscale x 4 x i32>
 ; CHECK-NEXT:    ret <vscale x 4 x i32> [[TMP1]]
 ;
   %v = load <vscale x 2 x i64>, ptr %p
@@ -143,9 +148,10 @@ define <vscale x 4 x i32> @load_nxv2i64_to_nxv4i32(ptr %p) {
 define ptr @load_i64_to_ptr(ptr %p) {
 ; CHECK-LABEL: define ptr @load_i64_to_ptr(
 ; CHECK-SAME: ptr [[P:%.*]]) {
-; CHECK-NEXT:    [[V:%.*]] = load i64, ptr [[P]], align 4
+; CHECK-NEXT:    [[V_BYTES:%.*]] = load b64, ptr [[P]], align 4
+; CHECK-NEXT:    [[V:%.*]] = bitcast b64 [[V_BYTES]] to i64
 ; CHECK-NEXT:    call void (...) @use(i64 [[V]])
-; CHECK-NEXT:    [[TMP1:%.*]] = inttoptr i64 [[V]] to ptr
+; CHECK-NEXT:    [[TMP1:%.*]] = bitcast b64 [[V_BYTES]] to ptr
 ; CHECK-NEXT:    ret ptr [[TMP1]]
 ;
   %v = load i64, ptr %p
@@ -157,11 +163,11 @@ define ptr @load_i64_to_ptr(ptr %p) {
 define ptr addrspace(1) @load_ptr_to_ptr1(ptr %p) {
 ; CHECK-LABEL: define ptr addrspace(1) @load_ptr_to_ptr1(
 ; CHECK-SAME: ptr [[P:%.*]]) {
-; CHECK-NEXT:    [[V:%.*]] = load ptr, ptr [[P]], align 8
+; CHECK-NEXT:    [[V_BYTES:%.*]] = load b64, ptr [[P]], align 8
+; CHECK-NEXT:    [[V:%.*]] = bitcast b64 [[V_BYTES]] to ptr
 ; CHECK-NEXT:    call void (...) @use(ptr [[V]])
-; CHECK-NEXT:    [[TMP1:%.*]] = ptrtoint ptr [[V]] to i64
-; CHECK-NEXT:    [[TMP2:%.*]] = inttoptr i64 [[TMP1]] to ptr addrspace(1)
-; CHECK-NEXT:    ret ptr addrspace(1) [[TMP2]]
+; CHECK-NEXT:    [[TMP1:%.*]] = bitcast b64 [[V_BYTES]] to ptr addrspace(1)
+; CHECK-NEXT:    ret ptr addrspace(1) [[TMP1]]
 ;
   %v = load ptr, ptr %p
   call void (...) @use(ptr %v)
@@ -172,9 +178,10 @@ define ptr addrspace(1) @load_ptr_to_ptr1(ptr %p) {
 define i8 @load_volatile_i32_to_i8(ptr %p) {
 ; CHECK-LABEL: define i8 @load_volatile_i32_to_i8(
 ; CHECK-SAME: ptr [[P:%.*]]) {
-; CHECK-NEXT:    [[V:%.*]] = load volatile i32, ptr [[P]], align 4
+; CHECK-NEXT:    [[V_BYTES:%.*]] = load volatile b32, ptr [[P]], align 4
+; CHECK-NEXT:    [[V:%.*]] = bitcast b32 [[V_BYTES]] to i32
 ; CHECK-NEXT:    call void (...) @use(i32 [[V]])
-; CHECK-NEXT:    [[TMP1:%.*]] = trunc i32 [[V]] to i8
+; CHECK-NEXT:    [[TMP1:%.*]] = bitextract i8, b32 [[V_BYTES]], i32 0
 ; CHECK-NEXT:    ret i8 [[TMP1]]
 ;
   %v = load volatile i32, ptr %p
@@ -186,14 +193,14 @@ define i8 @load_volatile_i32_to_i8(ptr %p) {
 define i8 @load_i32_to_i16_i8(ptr %p) {
 ; CHECK-LABEL: define i8 @load_i32_to_i16_i8(
 ; CHECK-SAME: ptr [[P:%.*]]) {
-; CHECK-NEXT:    [[V:%.*]] = load i32, ptr [[P]], align 4
+; CHECK-NEXT:    [[V_BYTES:%.*]] = load b32, ptr [[P]], align 4
+; CHECK-NEXT:    [[V:%.*]] = bitcast b32 [[V_BYTES]] to i32
 ; CHECK-NEXT:    call void (...) @use(i32 [[V]])
-; CHECK-NEXT:    [[TMP1:%.*]] = trunc i32 [[V]] to i16
+; CHECK-NEXT:    [[TMP1:%.*]] = bitextract i16, b32 [[V_BYTES]], i32 0
 ; CHECK-NEXT:    [[Q:%.*]] = getelementptr i8, ptr [[P]], i64 2
-; CHECK-NEXT:    [[TMP2:%.*]] = lshr i32 [[V]], 16
-; CHECK-NEXT:    [[TMP3:%.*]] = trunc i32 [[TMP2]] to i8
+; CHECK-NEXT:    [[TMP2:%.*]] = bitextract i8, b32 [[V_BYTES]], i32 16
 ; CHECK-NEXT:    [[T:%.*]] = trunc i16 [[TMP1]] to i8
-; CHECK-NEXT:    [[R:%.*]] = add i8 [[T]], [[TMP3]]
+; CHECK-NEXT:    [[R:%.*]] = add i8 [[T]], [[TMP2]]
 ; CHECK-NEXT:    ret i8 [[R]]
 ;
   %v = load i32, ptr %p
@@ -212,14 +219,16 @@ define i8 @load_i32_to_i8_nonlocal(ptr %p, i1 %c) {
 ; CHECK-NEXT:  [[ENTRY:.*:]]
 ; CHECK-NEXT:    br i1 [[C]], label %[[A:.*]], label %[[B:.*]]
 ; CHECK:       [[A]]:
-; CHECK-NEXT:    [[V1:%.*]] = load i32, ptr [[P]], align 4
+; CHECK-NEXT:    [[V1_BYTES:%.*]] = load b32, ptr [[P]], align 4
+; CHECK-NEXT:    [[V1:%.*]] = bitcast b32 [[V1_BYTES]] to i32
 ; CHECK-NEXT:    call void (...) @use(i32 [[V1]])
-; CHECK-NEXT:    [[TMP0:%.*]] = trunc i32 [[V1]] to i8
+; CHECK-NEXT:    [[TMP0:%.*]] = bitextract i8, b32 [[V1_BYTES]], i32 0
 ; CHECK-NEXT:    br label %[[MERGE:.*]]
 ; CHECK:       [[B]]:
-; CHECK-NEXT:    [[V2:%.*]] = load i32, ptr [[P]], align 4
+; CHECK-NEXT:    [[V2_BYTES:%.*]] = load b32, ptr [[P]], align 4
+; CHECK-NEXT:    [[V2:%.*]] = bitcast b32 [[V2_BYTES]] to i32
 ; CHECK-NEXT:    call void (...) @use(i32 [[V2]])
-; CHECK-NEXT:    [[TMP1:%.*]] = trunc i32 [[V2]] to i8
+; CHECK-NEXT:    [[TMP1:%.*]] = bitextract i8, b32 [[V2_BYTES]], i32 0
 ; CHECK-NEXT:    br label %[[MERGE]]
 ; CHECK:       [[MERGE]]:
 ; CHECK-NEXT:    [[X:%.*]] = phi i8 [ [[TMP1]], %[[B]] ], [ [[TMP0]], %[[A]] ]
@@ -249,9 +258,10 @@ define i8 @load_i32_to_i8_pre(ptr %p, i1 %c) {
 ; CHECK-NEXT:  [[ENTRY:.*:]]
 ; CHECK-NEXT:    br i1 [[C]], label %[[A:.*]], label %[[B:.*]]
 ; CHECK:       [[A]]:
-; CHECK-NEXT:    [[V:%.*]] = load i32, ptr [[P]], align 4
+; CHECK-NEXT:    [[V_BYTES:%.*]] = load b32, ptr [[P]], align 4
+; CHECK-NEXT:    [[V:%.*]] = bitcast b32 [[V_BYTES]] to i32
 ; CHECK-NEXT:    call void (...) @use(i32 [[V]])
-; CHECK-NEXT:    [[TMP0:%.*]] = trunc i32 [[V]] to i8
+; CHECK-NEXT:    [[TMP0:%.*]] = bitextract i8, b32 [[V_BYTES]], i32 0
 ; CHECK-NEXT:    br label %[[MERGE:.*]]
 ; CHECK:       [[B]]:
 ; CHECK-NEXT:    call void (...) @use()
@@ -380,9 +390,8 @@ define i8 @neg_load_volatile_float_to_i8(ptr %p) {
 ; CHECK-SAME: ptr [[P:%.*]]) {
 ; CHECK-NEXT:    [[V:%.*]] = load volatile float, ptr [[P]], align 4
 ; CHECK-NEXT:    call void (...) @use(float [[V]])
-; CHECK-NEXT:    [[TMP1:%.*]] = bitcast float [[V]] to i32
-; CHECK-NEXT:    [[TMP2:%.*]] = trunc i32 [[TMP1]] to i8
-; CHECK-NEXT:    ret i8 [[TMP2]]
+; CHECK-NEXT:    [[X:%.*]] = load i8, ptr [[P]], align 1
+; CHECK-NEXT:    ret i8 [[X]]
 ;
   %v = load volatile float, ptr %p
   call void (...) @use(float %v)
@@ -394,14 +403,12 @@ define i8 @neg_load_volatile_float_to_i8(ptr %p) {
 define void @neg_load_i32_to_i8_loop(ptr %p, i1 %c) {
 ; CHECK-LABEL: define void @neg_load_i32_to_i8_loop(
 ; CHECK-SAME: ptr [[P:%.*]], i1 [[C:%.*]]) {
-; CHECK-NEXT:  [[ENTRY:.*]]:
-; CHECK-NEXT:    [[X_PRE:%.*]] = load i8, ptr [[P]], align 1
-; CHECK-NEXT:    [[V_PRE:%.*]] = load i32, ptr [[P]], align 4
+; CHECK-NEXT:  [[ENTRY:.*:]]
 ; CHECK-NEXT:    br label %[[LOOP:.*]]
 ; CHECK:       [[LOOP]]:
-; CHECK-NEXT:    [[X:%.*]] = phi i8 [ [[TMP0:%.*]], %[[LOOP]] ], [ [[X_PRE]], %[[ENTRY]] ]
-; CHECK-NEXT:    call void (...) @use(i8 [[X]], i32 [[V_PRE]])
-; CHECK-NEXT:    [[TMP0]] = trunc i32 [[V_PRE]] to i8
+; CHECK-NEXT:    [[X:%.*]] = load i8, ptr [[P]], align 1
+; CHECK-NEXT:    [[V:%.*]] = load i32, ptr [[P]], align 4
+; CHECK-NEXT:    call void (...) @use(i8 [[X]], i32 [[V]])
 ; CHECK-NEXT:    br i1 [[C]], label %[[LOOP]], label %[[EXIT:.*]]
 ; CHECK:       [[EXIT]]:
 ; CHECK-NEXT:    ret void
diff --git a/llvm/test/Transforms/GVN/metadata.ll b/llvm/test/Transforms/GVN/metadata.ll
index c2725e99570c6b..0eb0fdd9783490 100644
--- a/llvm/test/Transforms/GVN/metadata.ll
+++ b/llvm/test/Transforms/GVN/metadata.ll
@@ -253,9 +253,10 @@ define void @load_ptr_dereferenceable_or_null_to_i64(ptr %p) {
 define void @load_ptr_nonnull_to_i32(ptr %p) {
 ; CHECK-LABEL: define void @load_ptr_nonnull_to_i32
 ; CHECK-SAME: (ptr [[P:%.*]]) {
-; CHECK-NEXT:    [[VAL:%.*]] = load ptr, ptr [[P]], align 8
+; CHECK-NEXT:    [[VAL_BYTES:%.*]] = load b64, ptr [[P]], align 8
+; CHECK-NEXT:    [[VAL:%.*]] = bitcast b64 [[VAL_BYTES]] to ptr
 ; CHECK-NEXT:    [[VAL_INT:%.*]] = ptrtoint ptr [[VAL]] to i64
-; CHECK-NEXT:    [[TMP1:%.*]] = trunc i64 [[VAL_INT]] to i32
+; CHECK-NEXT:    [[TMP1:%.*]] = bitextract i32, b64 [[VAL_BYTES]], i32 0
 ; CHECK-NEXT:    call void @use.i64(i64 [[VAL_INT]])
 ; CHECK-NEXT:    call void @use.i32(i32 [[TMP1]])
 ; CHECK-NEXT:    ret void
@@ -271,8 +272,9 @@ define void @load_ptr_nonnull_to_i32(ptr %p) {
 define void @load_i64_range_to_i32_range(ptr %p) {
 ; CHECK-LABEL: define void @load_i64_range_to_i32_range
 ; CHECK-SAME: (ptr [[P:%.*]]) {
-; CHECK-NEXT:    [[VAL:%.*]] = load i64, ptr [[P]], align 8
-; CHECK-NEXT:    [[TMP1:%.*]] = trunc i64 [[VAL]] to i32
+; CHECK-NEXT:    [[VAL_BYTES:%.*]] = load b64, ptr [[P]], align 8
+; CHECK-NEXT:    [[VAL:%.*]] = bitcast b64 [[VAL_BYTES]] to i64
+; CHECK-NEXT:    [[TMP1:%.*]] = bitextract i32, b64 [[VAL_BYTES]], i32 0
 ; CHECK-NEXT:    call void @use.i64(i64 [[VAL]])
 ; CHECK-NEXT:    call void @use.i32(i32 [[TMP1]])
 ; CHECK-NEXT:    ret void
diff --git a/llvm/test/Transforms/GVN/rle-coerced-noalias.ll b/llvm/test/Transforms/GVN/rle-coerced-noalias.ll
index 1ae70ee2fa8d34..9c37a3f15bde8c 100644
--- a/llvm/test/Transforms/GVN/rle-coerced-noalias.ll
+++ b/llvm/test/Transforms/GVN/rle-coerced-noalias.ll
@@ -9,15 +9,15 @@
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
 ; The i8 load at P+1 partially aliases the i32 load at P and is coerced from
-; it. The surviving i32 load should keep its !noalias.
+; it. The i32 load becomes a byte load, which should keep its !noalias.
 define i32 @noalias_dropped_local(ptr %p) {
 ; CHECK-LABEL: define i32 @noalias_dropped_local(
 ; CHECK-SAME: ptr [[P:%.*]]) {
 ; CHECK-NEXT:  [[ENTRY:.*:]]
-; CHECK-NEXT:    [[WIDE:%.*]] = load i32, ptr [[P]], align 4, !noalias [[META0:![0-9]+]]
+; CHECK-NEXT:    [[WIDE_BYTES:%.*]] = load b32, ptr [[P]], align 4, !noalias [[META0:![0-9]+]]
+; CHECK-NEXT:    [[WIDE:%.*]] = bitcast b32 [[WIDE_BYTES]] to i32
 ; CHECK-NEXT:    [[P1:%.*]] = getelementptr inbounds i8, ptr [[P]], i64 1
-; CHECK-NEXT:    [[TMP0:%.*]] = lshr i32 [[WIDE]], 8
-; CHECK-NEXT:    [[TMP1:%.*]] = trunc i32 [[TMP0]] to i8
+; CHECK-NEXT:    [[TMP1:%.*]] = bitextract i8, b32 [[WIDE_BYTES]], i32 8
 ; CHECK-NEXT:    [[CONV:%.*]] = zext i8 [[TMP1]] to i32
 ; CHECK-NEXT:    [[ADD:%.*]] = add nsw i32 [[WIDE]], [[CONV]]
 ; CHECK-NEXT:    ret i32 [[ADD]]
@@ -36,10 +36,10 @@ define i32 @alias_scope_dropped_local(ptr %p) {
 ; CHECK-LABEL: define i32 @alias_scope_dropped_local(
 ; CHECK-SAME: ptr [[P:%.*]]) {
 ; CHECK-NEXT:  [[ENTRY:.*:]]
-; CHECK-NEXT:    [[WIDE:%.*]] = load i32, ptr [[P]], align 4, !alias.scope [[META0]]
+; CHECK-NEXT:    [[WIDE_BYTES:%.*]] = load b32, ptr [[P]], align 4, !alias.scope [[META0]]
+; CHECK-NEXT:    [[WIDE:%.*]] = bitcast b32 [[WIDE_BYTES]] to i32
 ; CHECK-NEXT:    [[P1:%.*]] = getelementptr inbounds i8, ptr [[P]], i64 1
-; CHECK-NEXT:    [[TMP0:%.*]] = lshr i32 [[WIDE]], 8
-; CHECK-NEXT:    [[TMP1:%.*]] = trunc i32 [[TMP0]] to i8
+; CHECK-NEXT:    [[TMP1:%.*]] = bitextract i8, b32 [[WIDE_BYTES]], i32 8
 ; CHECK-NEXT:    [[CONV:%.*]] = zext i8 [[TMP1]] to i32
 ; CHECK-NEXT:    [[ADD:%.*]] = add nsw i32 [[WIDE]], [[CONV]]
 ; CHECK-NEXT:    ret i32 [[ADD]]



More information about the llvm-branch-commits mailing list