[llvm] 286e98b - [DSE] Add test cases with more complex redundant stores.
Florian Hahn via llvm-commits
llvm-commits at lists.llvm.org
Fri Oct 22 05:51:16 PDT 2021
Author: Florian Hahn
Date: 2021-10-22T13:50:32+01:00
New Revision: 286e98b97ebed4dfed38940d192667f84741fd65
URL: https://github.com/llvm/llvm-project/commit/286e98b97ebed4dfed38940d192667f84741fd65
DIFF: https://github.com/llvm/llvm-project/commit/286e98b97ebed4dfed38940d192667f84741fd65.diff
LOG: [DSE] Add test cases with more complex redundant stores.
This patch adds more complex test cases with redundant stores of an
existing memset, with other stores in between.
It also makes a few of the existing tests more robust.
Added:
Modified:
llvm/test/Transforms/DeadStoreElimination/memset-unknown-sizes.ll
llvm/test/Transforms/DeadStoreElimination/multiblock-throwing.ll
llvm/test/Transforms/DeadStoreElimination/stores-of-existing-values.ll
Removed:
################################################################################
diff --git a/llvm/test/Transforms/DeadStoreElimination/memset-unknown-sizes.ll b/llvm/test/Transforms/DeadStoreElimination/memset-unknown-sizes.ll
index bbd0d01ee475f..d7fc00e3940a3 100644
--- a/llvm/test/Transforms/DeadStoreElimination/memset-unknown-sizes.ll
+++ b/llvm/test/Transforms/DeadStoreElimination/memset-unknown-sizes.ll
@@ -6,17 +6,17 @@ declare i8* @_Znwm() local_unnamed_addr #0
; Function Attrs: argmemonly nounwind willreturn writeonly
declare void @llvm.memset.p0i8.i64(i8* nocapture writeonly, i8, i64, i1 immarg) #1
-define void @test1(i1 %c) {
+define void @test1(i1 %c, i64 %N) {
; CHECK-LABEL: @test1(
; CHECK-NEXT: entry:
; CHECK-NEXT: br i1 [[C:%.*]], label [[COND_TRUE_I_I_I:%.*]], label [[COND_END_I_I_I:%.*]]
; CHECK: cond.true.i.i.i:
; CHECK-NEXT: ret void
; CHECK: cond.end.i.i.i:
-; CHECK-NEXT: [[CALL_I_I_I_I_I:%.*]] = tail call noalias nonnull i8* @_Znam()
-; CHECK-NEXT: [[TMP0:%.*]] = bitcast i8* [[CALL_I_I_I_I_I]] to i64*
-; CHECK-NEXT: tail call void @llvm.memset.p0i8.i64(i8* nonnull align 8 [[CALL_I_I_I_I_I]], i8 0, i64 undef, i1 false)
-; CHECK-NEXT: store i64 0, i64* [[TMP0]], align 8
+; CHECK-NEXT: [[ALLOC:%.*]] = tail call noalias nonnull i8* @_Znam() #[[ATTR2:[0-9]+]]
+; CHECK-NEXT: [[ALLOC_BC:%.*]] = bitcast i8* [[ALLOC]] to i64*
+; CHECK-NEXT: tail call void @llvm.memset.p0i8.i64(i8* nonnull align 8 [[ALLOC]], i8 0, i64 [[N:%.*]], i1 false) #[[ATTR3:[0-9]+]]
+; CHECK-NEXT: store i64 0, i64* [[ALLOC_BC]], align 8
; CHECK-NEXT: ret void
;
entry:
@@ -26,26 +26,26 @@ cond.true.i.i.i: ; preds = %entry
ret void
cond.end.i.i.i: ; preds = %entry
- %call.i.i.i.i.i = tail call noalias nonnull i8* @_Znam() #2
- %0 = bitcast i8* %call.i.i.i.i.i to i64*
- tail call void @llvm.memset.p0i8.i64(i8* nonnull align 8 %call.i.i.i.i.i, i8 0, i64 undef, i1 false) #3
- store i64 0, i64* %0, align 8
+ %alloc = tail call noalias nonnull i8* @_Znam() #2
+ %alloc.bc = bitcast i8* %alloc to i64*
+ tail call void @llvm.memset.p0i8.i64(i8* nonnull align 8 %alloc, i8 0, i64 %N, i1 false) #3
+ store i64 0, i64* %alloc.bc, align 8
ret void
}
-declare i8* @_Znam() local_unnamed_addr #0
+declare i8* @_Znam()
-define void @test2(i1 %c) {
+define void @test2(i1 %c, i64 %N) {
; CHECK-LABEL: @test2(
; CHECK-NEXT: entry:
; CHECK-NEXT: br i1 [[C:%.*]], label [[CLEANUP_CONT104:%.*]], label [[IF_THEN:%.*]]
; CHECK: if.then:
-; CHECK-NEXT: [[MUL_I_I_I_I:%.*]] = shl nuw nsw i64 undef, 3
-; CHECK-NEXT: [[CALL_I_I_I_I_I_I131:%.*]] = call noalias nonnull i8* @_Znwm()
-; CHECK-NEXT: [[DOTCAST_I_I:%.*]] = bitcast i8* [[CALL_I_I_I_I_I_I131]] to i64*
-; CHECK-NEXT: store i64 0, i64* [[DOTCAST_I_I]], align 8
-; CHECK-NEXT: call void @llvm.memset.p0i8.i64(i8* nonnull align 8 [[CALL_I_I_I_I_I_I131]], i8 0, i64 [[MUL_I_I_I_I]], i1 false)
+; CHECK-NEXT: [[MUL:%.*]] = shl nuw nsw i64 [[N:%.*]], 3
+; CHECK-NEXT: [[ALLOC:%.*]] = call noalias nonnull i8* @_Znwm() #[[ATTR2]]
+; CHECK-NEXT: [[ALLOC_BC:%.*]] = bitcast i8* [[ALLOC]] to i64*
+; CHECK-NEXT: store i64 0, i64* [[ALLOC_BC]], align 8
+; CHECK-NEXT: call void @llvm.memset.p0i8.i64(i8* nonnull align 8 [[ALLOC]], i8 0, i64 [[MUL]], i1 false) #[[ATTR3]]
; CHECK-NEXT: ret void
; CHECK: cleanup.cont104:
; CHECK-NEXT: ret void
@@ -54,11 +54,11 @@ entry:
br i1 %c, label %cleanup.cont104, label %if.then
if.then: ; preds = %entry
- %mul.i.i.i.i = shl nuw nsw i64 undef, 3
- %call.i.i.i.i.i.i131 = call noalias nonnull i8* @_Znwm() #2
- %.cast.i.i = bitcast i8* %call.i.i.i.i.i.i131 to i64*
- store i64 0, i64* %.cast.i.i, align 8
- call void @llvm.memset.p0i8.i64(i8* nonnull align 8 %call.i.i.i.i.i.i131, i8 0, i64 %mul.i.i.i.i, i1 false) #3
+ %mul = shl nuw nsw i64 %N, 3
+ %alloc = call noalias nonnull i8* @_Znwm() #2
+ %alloc.bc = bitcast i8* %alloc to i64*
+ store i64 0, i64* %alloc.bc, align 8
+ call void @llvm.memset.p0i8.i64(i8* nonnull align 8 %alloc, i8 0, i64 %mul, i1 false) #3
ret void
cleanup.cont104: ; preds = %entry
diff --git a/llvm/test/Transforms/DeadStoreElimination/multiblock-throwing.ll b/llvm/test/Transforms/DeadStoreElimination/multiblock-throwing.ll
index c067a907892d9..2033b34e05159 100644
--- a/llvm/test/Transforms/DeadStoreElimination/multiblock-throwing.ll
+++ b/llvm/test/Transforms/DeadStoreElimination/multiblock-throwing.ll
@@ -4,9 +4,9 @@
target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
declare void @unknown_func()
-define void @test6(i32* noalias %P) {
-; CHECK-LABEL: @test6(
-; CHECK-NEXT: store i32 0, i32* [[P:%.*]]
+define void @test6_store_same_value(i32* noalias %P) {
+; CHECK-LABEL: @test6_store_same_value(
+; CHECK-NEXT: store i32 0, i32* [[P:%.*]], align 4
; CHECK-NEXT: br i1 true, label [[BB1:%.*]], label [[BB2:%.*]]
; CHECK: bb1:
; CHECK-NEXT: br label [[BB3:%.*]]
@@ -14,7 +14,7 @@ define void @test6(i32* noalias %P) {
; CHECK-NEXT: call void @unknown_func()
; CHECK-NEXT: br label [[BB3]]
; CHECK: bb3:
-; CHECK-NEXT: store i32 0, i32* [[P]]
+; CHECK-NEXT: store i32 0, i32* [[P]], align 4
; CHECK-NEXT: ret void
;
store i32 0, i32* %P
@@ -29,6 +29,31 @@ bb3:
ret void
}
+define void @test6_store_other_value(i32* noalias %P) {
+; CHECK-LABEL: @test6_store_other_value(
+; CHECK-NEXT: store i32 0, i32* [[P:%.*]], align 4
+; CHECK-NEXT: br i1 true, label [[BB1:%.*]], label [[BB2:%.*]]
+; CHECK: bb1:
+; CHECK-NEXT: br label [[BB3:%.*]]
+; CHECK: bb2:
+; CHECK-NEXT: call void @unknown_func()
+; CHECK-NEXT: br label [[BB3]]
+; CHECK: bb3:
+; CHECK-NEXT: store i32 1, i32* [[P]], align 4
+; CHECK-NEXT: ret void
+;
+ store i32 0, i32* %P
+ br i1 true, label %bb1, label %bb2
+bb1:
+ br label %bb3
+bb2:
+ call void @unknown_func()
+ br label %bb3
+bb3:
+ store i32 1, i32* %P
+ ret void
+}
+
define void @test23(i32* noalias %P) {
; CHECK-LABEL: @test23(
; CHECK-NEXT: br i1 true, label [[BB1:%.*]], label [[BB2:%.*]]
@@ -38,7 +63,7 @@ define void @test23(i32* noalias %P) {
; CHECK-NEXT: call void @unknown_func()
; CHECK-NEXT: br label [[BB3]]
; CHECK: bb3:
-; CHECK-NEXT: store i32 0, i32* [[P:%.*]]
+; CHECK-NEXT: store i32 0, i32* [[P:%.*]], align 4
; CHECK-NEXT: ret void
;
br i1 true, label %bb1, label %bb2
@@ -63,7 +88,7 @@ define void @test24(i32* noalias %P) {
; CHECK-NEXT: call void @unknown_func()
; CHECK-NEXT: br label [[BB3]]
; CHECK: bb3:
-; CHECK-NEXT: store i32 0, i32* [[P:%.*]]
+; CHECK-NEXT: store i32 0, i32* [[P:%.*]], align 4
; CHECK-NEXT: ret void
;
br i1 true, label %bb2, label %bb1
diff --git a/llvm/test/Transforms/DeadStoreElimination/stores-of-existing-values.ll b/llvm/test/Transforms/DeadStoreElimination/stores-of-existing-values.ll
index 8abfcbf4444c5..509d4e9763fe9 100644
--- a/llvm/test/Transforms/DeadStoreElimination/stores-of-existing-values.ll
+++ b/llvm/test/Transforms/DeadStoreElimination/stores-of-existing-values.ll
@@ -235,7 +235,7 @@ bb3:
}
; Make sure the store in %bb3 won't be eliminated because it may be clobbered before.
-define void @test8(i32* noalias %P) {
+define void @test8(i32* %P) {
; CHECK-LABEL: @test8(
; CHECK-NEXT: store i32 0, i32* [[P:%.*]], align 4
; CHECK-NEXT: br i1 true, label [[BB1:%.*]], label [[BB2:%.*]]
@@ -287,6 +287,197 @@ bb3:
ret void
}
+; The store in bb3 can be eliminated, because the store in bb1 cannot alias it.
+define void @test10(i32* noalias %P, i32* %Q, i1 %c) {
+; CHECK-LABEL: @test10(
+; CHECK-NEXT: store i32 0, i32* [[P:%.*]], align 4
+; CHECK-NEXT: br i1 [[C:%.*]], label [[BB1:%.*]], label [[BB2:%.*]]
+; CHECK: bb1:
+; CHECK-NEXT: store i32 10, i32* [[Q:%.*]], align 4
+; CHECK-NEXT: br label [[BB3:%.*]]
+; CHECK: bb2:
+; CHECK-NEXT: ret void
+; CHECK: bb3:
+; CHECK-NEXT: store i32 0, i32* [[P]], align 4
+; CHECK-NEXT: ret void
+;
+ store i32 0, i32* %P
+ br i1 %c, label %bb1, label %bb2
+
+bb1:
+ store i32 10, i32* %Q
+ br label %bb3
+
+bb2:
+ ret void
+
+bb3:
+ store i32 0, i32* %P
+ ret void
+}
+
+define void @test11_smaller_later_store(i32* noalias %P, i32* %Q, i1 %c) {
+; CHECK-LABEL: @test11_smaller_later_store(
+; CHECK-NEXT: store i32 0, i32* [[P:%.*]], align 4
+; CHECK-NEXT: br i1 [[C:%.*]], label [[BB1:%.*]], label [[BB2:%.*]]
+; CHECK: bb1:
+; CHECK-NEXT: br label [[BB3:%.*]]
+; CHECK: bb2:
+; CHECK-NEXT: ret void
+; CHECK: bb3:
+; CHECK-NEXT: [[BC:%.*]] = bitcast i32* [[P]] to i8*
+; CHECK-NEXT: store i8 0, i8* [[BC]], align 1
+; CHECK-NEXT: ret void
+;
+ store i32 0, i32* %P
+ br i1 %c, label %bb1, label %bb2
+
+bb1:
+ br label %bb3
+
+bb2:
+ ret void
+
+bb3:
+ %bc = bitcast i32* %P to i8*
+ store i8 0, i8* %bc
+ ret void
+}
+
+define void @test11_smaller_earlier_store(i32* noalias %P, i32* %Q, i1 %c) {
+; CHECK-LABEL: @test11_smaller_earlier_store(
+; CHECK-NEXT: [[BC:%.*]] = bitcast i32* [[P:%.*]] to i8*
+; CHECK-NEXT: store i8 0, i8* [[BC]], align 1
+; CHECK-NEXT: br i1 [[C:%.*]], label [[BB1:%.*]], label [[BB2:%.*]]
+; CHECK: bb1:
+; CHECK-NEXT: br label [[BB3:%.*]]
+; CHECK: bb2:
+; CHECK-NEXT: ret void
+; CHECK: bb3:
+; CHECK-NEXT: store i32 0, i32* [[P]], align 4
+; CHECK-NEXT: ret void
+;
+ %bc = bitcast i32* %P to i8*
+ store i8 0, i8* %bc
+ br i1 %c, label %bb1, label %bb2
+
+bb1:
+ br label %bb3
+
+bb2:
+ ret void
+
+bb3:
+ store i32 0, i32* %P
+ ret void
+}
+
+declare void @llvm.memset.p0i8.i64(i8* nocapture writeonly, i8, i64, i1 immarg) #1
+
+define void @test12_memset_simple(i8* %ptr) {
+; CHECK-LABEL: @test12_memset_simple(
+; CHECK-NEXT: call void @llvm.memset.p0i8.i64(i8* [[PTR:%.*]], i8 0, i64 10, i1 false)
+; CHECK-NEXT: [[PTR_5:%.*]] = getelementptr i8, i8* [[PTR]], i64 4
+; CHECK-NEXT: store i8 0, i8* [[PTR_5]], align 1
+; CHECK-NEXT: ret void
+;
+ call void @llvm.memset.p0i8.i64(i8* %ptr, i8 0, i64 10, i1 false)
+ %ptr.5 = getelementptr i8, i8* %ptr, i64 4
+ store i8 0, i8* %ptr.5
+ ret void
+}
+
+define void @test12_memset_other_store_in_between(i8* %ptr) {
+; CHECK-LABEL: @test12_memset_other_store_in_between(
+; CHECK-NEXT: call void @llvm.memset.p0i8.i64(i8* [[PTR:%.*]], i8 0, i64 10, i1 false)
+; CHECK-NEXT: [[PTR_4:%.*]] = getelementptr i8, i8* [[PTR]], i64 4
+; CHECK-NEXT: store i8 8, i8* [[PTR_4]], align 1
+; CHECK-NEXT: [[PTR_5:%.*]] = getelementptr i8, i8* [[PTR]], i64 5
+; CHECK-NEXT: store i8 0, i8* [[PTR_5]], align 1
+; CHECK-NEXT: ret void
+;
+ call void @llvm.memset.p0i8.i64(i8* %ptr, i8 0, i64 10, i1 false)
+ %ptr.4 = getelementptr i8, i8* %ptr, i64 4
+ store i8 8, i8* %ptr.4
+ %ptr.5 = getelementptr i8, i8* %ptr, i64 5
+ store i8 0, i8* %ptr.5
+ ret void
+}
+
+define void @test12_memset_other_store_in_between_partial_overlap(i8* %ptr) {
+; CHECK-LABEL: @test12_memset_other_store_in_between_partial_overlap(
+; CHECK-NEXT: call void @llvm.memset.p0i8.i64(i8* [[PTR:%.*]], i8 0, i64 10, i1 false)
+; CHECK-NEXT: [[PTR_4:%.*]] = getelementptr i8, i8* [[PTR]], i64 4
+; CHECK-NEXT: [[BC_4:%.*]] = bitcast i8* [[PTR_4]] to i16*
+; CHECK-NEXT: store i16 8, i16* [[BC_4]], align 2
+; CHECK-NEXT: [[PTR_5:%.*]] = getelementptr i8, i8* [[PTR]], i64 5
+; CHECK-NEXT: [[BC_5:%.*]] = bitcast i8* [[PTR_5]] to i16*
+; CHECK-NEXT: store i16 0, i16* [[BC_5]], align 2
+; CHECK-NEXT: ret void
+;
+ call void @llvm.memset.p0i8.i64(i8* %ptr, i8 0, i64 10, i1 false)
+ %ptr.4 = getelementptr i8, i8* %ptr, i64 4
+ %bc.4 = bitcast i8* %ptr.4 to i16*
+ store i16 8, i16* %bc.4
+ %ptr.5 = getelementptr i8, i8* %ptr, i64 5
+ %bc.5 = bitcast i8* %ptr.5 to i16*
+ store i16 0, i16* %bc.5
+ ret void
+}
+
+define void @test12_memset_later_store_exceeds_memset(i8* %ptr) {
+; CHECK-LABEL: @test12_memset_later_store_exceeds_memset(
+; CHECK-NEXT: call void @llvm.memset.p0i8.i64(i8* align 1 [[PTR:%.*]], i8 0, i64 8, i1 false)
+; CHECK-NEXT: [[PTR_4:%.*]] = getelementptr i8, i8* [[PTR]], i64 4
+; CHECK-NEXT: store i8 8, i8* [[PTR_4]], align 1
+; CHECK-NEXT: [[PTR_5:%.*]] = getelementptr i8, i8* [[PTR]], i64 8
+; CHECK-NEXT: [[BC:%.*]] = bitcast i8* [[PTR_5]] to i64*
+; CHECK-NEXT: store i64 0, i64* [[BC]], align 8
+; CHECK-NEXT: ret void
+;
+ call void @llvm.memset.p0i8.i64(i8* %ptr, i8 0, i64 10, i1 false)
+ %ptr.4 = getelementptr i8, i8* %ptr, i64 4
+ store i8 8, i8* %ptr.4
+ %ptr.5 = getelementptr i8, i8* %ptr, i64 8
+ %bc = bitcast i8* %ptr.5 to i64*
+ store i64 0, i64* %bc
+ ret void
+}
+
+define void @test12_memset_later_store_before_memset(i8* %ptr) {
+; CHECK-LABEL: @test12_memset_later_store_before_memset(
+; CHECK-NEXT: [[PTR_1:%.*]] = getelementptr i8, i8* [[PTR:%.*]], i64 1
+; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds i8, i8* [[PTR_1]], i64 7
+; CHECK-NEXT: call void @llvm.memset.p0i8.i64(i8* align 1 [[TMP1]], i8 0, i64 3, i1 false)
+; CHECK-NEXT: [[BC:%.*]] = bitcast i8* [[PTR]] to i64*
+; CHECK-NEXT: store i64 0, i64* [[BC]], align 8
+; CHECK-NEXT: ret void
+;
+ %ptr.1 = getelementptr i8, i8* %ptr, i64 1
+ call void @llvm.memset.p0i8.i64(i8* %ptr.1, i8 0, i64 10, i1 false)
+ %ptr.4 = getelementptr i8, i8* %ptr, i64 4
+ store i8 8, i8* %ptr.4
+ %bc = bitcast i8* %ptr to i64*
+ store i64 0, i64* %bc
+ ret void
+}
+
+; The memset will be shortened and the store will not be redundant afterwards.
+; It cannot be eliminated.
+define void @test13_memset_shortened(i64* %ptr) {
+; CHECK-LABEL: @test13_memset_shortened(
+; CHECK-NEXT: [[PTR_I8:%.*]] = bitcast i64* [[PTR:%.*]] to i8*
+; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds i8, i8* [[PTR_I8]], i64 8
+; CHECK-NEXT: call void @llvm.memset.p0i8.i64(i8* align 1 [[TMP1]], i8 0, i64 16, i1 false)
+; CHECK-NEXT: store i64 0, i64* [[PTR]], align 8
+; CHECK-NEXT: ret void
+;
+ %ptr.i8 = bitcast i64* %ptr to i8*
+ call void @llvm.memset.p0i8.i64(i8* %ptr.i8, i8 0, i64 24, i1 false)
+ store i64 0, i64* %ptr
+ ret void
+}
+
define void @pr49927(i32* %q, i32* %p) {
; CHECK-LABEL: @pr49927(
; CHECK-NEXT: [[V:%.*]] = load i32, i32* [[P:%.*]], align 4
@@ -301,7 +492,6 @@ define void @pr49927(i32* %q, i32* %p) {
ret void
}
-
define void @pr50339(i8* nocapture readonly %0) {
; CHECK-LABEL: @pr50339(
; CHECK-NEXT: tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* noundef nonnull align 16 dereferenceable(16) getelementptr inbounds ([32 x i8], [32 x i8]* @a, i64 0, i64 0), i8* noundef nonnull align 1 dereferenceable(16) [[TMP0:%.*]], i64 16, i1 false)
More information about the llvm-commits
mailing list