[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
Sat Nov 14 16:17:16 PST 2026
https://github.com/pedroclobo updated https://github.com/llvm/llvm-project/pull/237786
>From 3c4d950bd66453814db01795e35e388f61f89e7d 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 7d33d6d6cb4c6b4b7c0675a57e7bd392035879a1 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 ecf291b86be381..78d0c2b07bf9bb 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.
@@ -2454,6 +2550,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.
@@ -3165,6 +3264,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