Skip to content

Commit 4e8eabd

Browse files
artagnonartagnon
authored
DSE: pre-commit tests for scalable vectors (#110669)
As AliasAnalysis now has support for scalable sizes, add tests to DeadStoreElimination covering the scalable vectors case, in preparation to extend it.
1 parent aa5cdce commit 4e8eabd

File tree

2 files changed

+204
-4
lines changed

2 files changed

+204
-4
lines changed

‎llvm/test/Transforms/DeadStoreElimination/offsetted-overlapping-stores.ll

Lines changed: 112 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -47,6 +47,90 @@ bb:
4747
ret void
4848
}
4949

50+
define void @ScalableVectorTestFullyOverlapping(ptr %arg, i32 %i) vscale_range(1, 2) {
51+
; CHECK-LABEL: @ScalableVectorTestFullyOverlapping(
52+
; CHECK-NEXT: [[I_1:%.*]] = add nuw nsw i32 [[I:%.*]], 1
53+
; CHECK-NEXT: [[EXT_I_1:%.*]] = zext i32 [[I_1]] to i64
54+
; CHECK-NEXT: [[GEP_ARG_I_1:%.*]] = getelementptr inbounds float, ptr [[ARG:%.*]], i64 [[EXT_I_1]]
55+
; CHECK-NEXT: store float 0.000000e+00, ptr [[GEP_ARG_I_1]], align 4
56+
; CHECK-NEXT: [[EXT_I:%.*]] = zext i32 [[I]] to i64
57+
; CHECK-NEXT: [[GEP_ARG_I:%.*]] = getelementptr inbounds float, ptr [[ARG]], i64 [[EXT_I]]
58+
; CHECK-NEXT: store <vscale x 2 x float> zeroinitializer, ptr [[GEP_ARG_I]], align 8
59+
; CHECK-NEXT: ret void
60+
;
61+
%i.1 = add nuw nsw i32 %i, 1
62+
%ext.i.1 = zext i32 %i.1 to i64
63+
%gep.arg.i.1 = getelementptr inbounds float, ptr %arg, i64 %ext.i.1
64+
store float 0.0, ptr %gep.arg.i.1
65+
%ext.i = zext i32 %i to i64
66+
%gep.arg.i = getelementptr inbounds float, ptr %arg, i64 %ext.i
67+
store <vscale x 2 x float> zeroinitializer, ptr %gep.arg.i
68+
ret void
69+
}
70+
71+
define void @ScalableVectorTestFullyOverlapping2(ptr %arg, i32 %i) {
72+
; CHECK-LABEL: @ScalableVectorTestFullyOverlapping2(
73+
; CHECK-NEXT: [[I_1:%.*]] = add nuw nsw i32 [[I:%.*]], 1
74+
; CHECK-NEXT: [[EXT_I_1:%.*]] = zext i32 [[I_1]] to i64
75+
; CHECK-NEXT: [[GEP_ARG_I_1:%.*]] = getelementptr inbounds float, ptr [[ARG:%.*]], i64 [[EXT_I_1]]
76+
; CHECK-NEXT: store <vscale x 2 x float> zeroinitializer, ptr [[GEP_ARG_I_1]], align 8
77+
; CHECK-NEXT: [[EXT_I:%.*]] = zext i32 [[I]] to i64
78+
; CHECK-NEXT: [[GEP_ARG_I:%.*]] = getelementptr inbounds float, ptr [[ARG]], i64 [[EXT_I]]
79+
; CHECK-NEXT: store <vscale x 4 x float> zeroinitializer, ptr [[GEP_ARG_I]], align 16
80+
; CHECK-NEXT: ret void
81+
;
82+
%i.1 = add nuw nsw i32 %i, 1
83+
%ext.i.1 = zext i32 %i.1 to i64
84+
%gep.arg.i.1 = getelementptr inbounds float, ptr %arg, i64 %ext.i.1
85+
store <vscale x 2 x float> zeroinitializer, ptr %gep.arg.i.1
86+
%ext.i = zext i32 %i to i64
87+
%gep.arg.i = getelementptr inbounds float, ptr %arg, i64 %ext.i
88+
store <vscale x 4 x float> zeroinitializer, ptr %gep.arg.i
89+
ret void
90+
}
91+
92+
define void @ScalableVectorTestNonOverlapping(ptr %arg, i32 %i) vscale_range(1, 2) {
93+
; CHECK-LABEL: @ScalableVectorTestNonOverlapping(
94+
; CHECK-NEXT: [[I_10:%.*]] = add nuw nsw i32 [[I:%.*]], 10
95+
; CHECK-NEXT: [[EXT_I_10:%.*]] = zext i32 [[I_10]] to i64
96+
; CHECK-NEXT: [[GEP_ARG_I_10:%.*]] = getelementptr inbounds float, ptr [[ARG:%.*]], i64 [[EXT_I_10]]
97+
; CHECK-NEXT: store float 0.000000e+00, ptr [[GEP_ARG_I_10]], align 4
98+
; CHECK-NEXT: [[EXT_I:%.*]] = zext i32 [[I]] to i64
99+
; CHECK-NEXT: [[GEP_ARG_I:%.*]] = getelementptr inbounds float, ptr [[ARG]], i64 [[EXT_I]]
100+
; CHECK-NEXT: store <vscale x 2 x float> zeroinitializer, ptr [[GEP_ARG_I]], align 8
101+
; CHECK-NEXT: ret void
102+
;
103+
%i.10 = add nuw nsw i32 %i, 10
104+
%ext.i.10 = zext i32 %i.10 to i64
105+
%gep.arg.i.10 = getelementptr inbounds float, ptr %arg, i64 %ext.i.10
106+
store float 0.0, ptr %gep.arg.i.10
107+
%ext.i = zext i32 %i to i64
108+
%gep.arg.i = getelementptr inbounds float, ptr %arg, i64 %ext.i
109+
store <vscale x 2 x float> zeroinitializer, ptr %gep.arg.i
110+
ret void
111+
}
112+
113+
define void @ScalableVectorTestNonOverlapping2(ptr %arg, i32 %i) vscale_range(1, 2) {
114+
; CHECK-LABEL: @ScalableVectorTestNonOverlapping2(
115+
; CHECK-NEXT: [[I_10:%.*]] = add nuw nsw i32 [[I:%.*]], 10
116+
; CHECK-NEXT: [[EXT_I_10:%.*]] = zext i32 [[I_10]] to i64
117+
; CHECK-NEXT: [[GEP_ARG_I_10:%.*]] = getelementptr inbounds float, ptr [[ARG:%.*]], i64 [[EXT_I_10]]
118+
; CHECK-NEXT: store <vscale x 2 x float> zeroinitializer, ptr [[GEP_ARG_I_10]], align 8
119+
; CHECK-NEXT: [[EXT_I:%.*]] = zext i32 [[I]] to i64
120+
; CHECK-NEXT: [[GEP_ARG_I:%.*]] = getelementptr inbounds float, ptr [[ARG]], i64 [[EXT_I]]
121+
; CHECK-NEXT: store <vscale x 4 x float> zeroinitializer, ptr [[GEP_ARG_I]], align 16
122+
; CHECK-NEXT: ret void
123+
;
124+
%i.10 = add nuw nsw i32 %i, 10
125+
%ext.i.10 = zext i32 %i.10 to i64
126+
%gep.arg.i.10 = getelementptr inbounds float, ptr %arg, i64 %ext.i.10
127+
store <vscale x 2 x float> zeroinitializer, ptr %gep.arg.i.10
128+
%ext.i = zext i32 %i to i64
129+
%gep.arg.i = getelementptr inbounds float, ptr %arg, i64 %ext.i
130+
store <vscale x 4 x float> zeroinitializer, ptr %gep.arg.i
131+
ret void
132+
}
133+
50134
define void @ArrayTestPartiallyOverlapping(i64 %0) {
51135
;
52136
; The DSE pass will not kill the store because the overlap is partial
@@ -55,9 +139,9 @@ define void @ArrayTestPartiallyOverlapping(i64 %0) {
55139
; CHECK-LABEL: @ArrayTestPartiallyOverlapping(
56140
; CHECK-NEXT: [[TMP2:%.*]] = add i64 [[TMP0:%.*]], 10
57141
; CHECK-NEXT: [[TMP3:%.*]] = getelementptr inbounds [0 x i8], ptr @BUFFER, i64 0, i64 [[TMP2]]
58-
; CHECK-NEXT: [[TMP5:%.*]] = add i64 [[TMP0]], 15
59-
; CHECK-NEXT: [[TMP6:%.*]] = getelementptr inbounds [0 x i8], ptr @BUFFER, i64 0, i64 [[TMP5]]
60-
; CHECK-NEXT: store i32 1, ptr [[TMP6]], align 4
142+
; CHECK-NEXT: [[TMP4:%.*]] = add i64 [[TMP0]], 15
143+
; CHECK-NEXT: [[TMP5:%.*]] = getelementptr inbounds [0 x i8], ptr @BUFFER, i64 0, i64 [[TMP4]]
144+
; CHECK-NEXT: store i32 1, ptr [[TMP5]], align 4
61145
; CHECK-NEXT: store i64 0, ptr [[TMP3]], align 4
62146
; CHECK-NEXT: ret void
63147
;
@@ -97,3 +181,28 @@ bb:
97181
ret void
98182
}
99183

184+
define void @ScalableVectorTestPartiallyOverlapping(ptr %arg, i32 %i) {
185+
;
186+
; The DSE pass will not kill the store because the overlap is partial
187+
; and won't fully clobber the original store.
188+
;
189+
; CHECK-LABEL: @ScalableVectorTestPartiallyOverlapping(
190+
; CHECK-NEXT: [[EXT_I:%.*]] = zext i32 [[I:%.*]] to i64
191+
; CHECK-NEXT: [[GEP_ARG_I:%.*]] = getelementptr inbounds float, ptr [[ARG:%.*]], i64 [[EXT_I]]
192+
; CHECK-NEXT: store <vscale x 2 x float> zeroinitializer, ptr [[GEP_ARG_I]], align 8
193+
; CHECK-NEXT: [[I_1:%.*]] = add nuw nsw i32 [[I]], 1
194+
; CHECK-NEXT: [[EXT_I_1:%.*]] = zext i32 [[I_1]] to i64
195+
; CHECK-NEXT: [[GEP_ARG_I_1:%.*]] = getelementptr inbounds float, ptr [[ARG]], i64 [[EXT_I_1]]
196+
; CHECK-NEXT: store <vscale x 2 x float> zeroinitializer, ptr [[GEP_ARG_I_1]], align 8
197+
; CHECK-NEXT: ret void
198+
;
199+
%ext.i = zext i32 %i to i64
200+
%gep.arg.i = getelementptr inbounds float, ptr %arg, i64 %ext.i
201+
store <vscale x 2 x float> zeroinitializer, ptr %gep.arg.i
202+
%i.1 = add nuw nsw i32 %i, 1
203+
%ext.i.1 = zext i32 %i.1 to i64
204+
%gep.arg.i.1 = getelementptr inbounds float, ptr %arg, i64 %ext.i.1
205+
store <vscale x 2 x float> zeroinitializer, ptr %gep.arg.i.1
206+
ret void
207+
}
208+

‎llvm/test/Transforms/DeadStoreElimination/stores-of-existing-values.ll

Lines changed: 92 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -641,7 +641,7 @@ define void @later_non_removable_store(i1 %c, ptr %p) {
641641
; CHECK: if:
642642
; CHECK-NEXT: br label [[EXIT]]
643643
; CHECK: exit:
644-
; CHECK-NEXT: call void @use(ptr [[P]]) #[[ATTR6:[0-9]+]]
644+
; CHECK-NEXT: call void @use(ptr [[P]]) #[[ATTR7:[0-9]+]]
645645
; CHECK-NEXT: ret void
646646
;
647647
store i8 1, ptr %p
@@ -655,3 +655,94 @@ exit:
655655
call void @use(ptr %p) argmemonly
656656
ret void
657657
}
658+
659+
define void @scalable_scalable_redundant_store(ptr %ptr) {
660+
; CHECK-LABEL: @scalable_scalable_redundant_store(
661+
; CHECK-NEXT: [[GEP_PTR_2:%.*]] = getelementptr i64, ptr [[PTR:%.*]], i64 2
662+
; CHECK-NEXT: store <vscale x 2 x i64> zeroinitializer, ptr [[GEP_PTR_2]], align 16
663+
; CHECK-NEXT: store <vscale x 4 x i64> zeroinitializer, ptr [[PTR]], align 32
664+
; CHECK-NEXT: ret void
665+
;
666+
%gep.ptr.2 = getelementptr i64, ptr %ptr, i64 2
667+
store <vscale x 2 x i64> zeroinitializer, ptr %gep.ptr.2
668+
store <vscale x 4 x i64> zeroinitializer, ptr %ptr
669+
ret void
670+
}
671+
672+
define void @scalable_scalable_neg(ptr %ptr) {
673+
; CHECK-LABEL: @scalable_scalable_neg(
674+
; CHECK-NEXT: [[GEP_PTR_8:%.*]] = getelementptr i64, ptr [[PTR:%.*]], i64 8
675+
; CHECK-NEXT: store <vscale x 4 x i64> zeroinitializer, ptr [[GEP_PTR_8]], align 32
676+
; CHECK-NEXT: store <vscale x 2 x i64> zeroinitializer, ptr [[PTR]], align 16
677+
; CHECK-NEXT: ret void
678+
;
679+
%gep.ptr.8 = getelementptr i64, ptr %ptr, i64 8
680+
store <vscale x 4 x i64> zeroinitializer, ptr %gep.ptr.8
681+
store <vscale x 2 x i64> zeroinitializer, ptr %ptr
682+
ret void
683+
}
684+
685+
define void @scalable_scalable_nonconst_offset_neg(ptr %ptr, i64 %i) {
686+
; CHECK-LABEL: @scalable_scalable_nonconst_offset_neg(
687+
; CHECK-NEXT: [[GEP_PTR_I:%.*]] = getelementptr i64, ptr [[PTR:%.*]], i64 [[I:%.*]]
688+
; CHECK-NEXT: store <vscale x 2 x i64> zeroinitializer, ptr [[GEP_PTR_I]], align 16
689+
; CHECK-NEXT: store <vscale x 4 x i64> zeroinitializer, ptr [[PTR]], align 32
690+
; CHECK-NEXT: ret void
691+
;
692+
%gep.ptr.i = getelementptr i64, ptr %ptr, i64 %i
693+
store <vscale x 2 x i64> zeroinitializer, ptr %gep.ptr.i
694+
store <vscale x 4 x i64> zeroinitializer, ptr %ptr
695+
ret void
696+
}
697+
698+
define void @scalable_fixed_redundant_store(ptr %ptr) vscale_range(1, 2) {
699+
; CHECK-LABEL: @scalable_fixed_redundant_store(
700+
; CHECK-NEXT: [[GEP_PTR_2:%.*]] = getelementptr i64, ptr [[PTR:%.*]], i64 2
701+
; CHECK-NEXT: store <2 x i64> zeroinitializer, ptr [[GEP_PTR_2]], align 16
702+
; CHECK-NEXT: store <vscale x 4 x i64> zeroinitializer, ptr [[PTR]], align 32
703+
; CHECK-NEXT: ret void
704+
;
705+
%gep.ptr.2 = getelementptr i64, ptr %ptr, i64 2
706+
store <2 x i64> zeroinitializer, ptr %gep.ptr.2
707+
store <vscale x 4 x i64> zeroinitializer, ptr %ptr
708+
ret void
709+
}
710+
711+
define void @scalable_fixed_neg(ptr %ptr) vscale_range(1, 2) {
712+
; CHECK-LABEL: @scalable_fixed_neg(
713+
; CHECK-NEXT: [[GEP_PTR_16:%.*]] = getelementptr i64, ptr [[PTR:%.*]], i64 16
714+
; CHECK-NEXT: store <2 x i64> zeroinitializer, ptr [[GEP_PTR_16]], align 16
715+
; CHECK-NEXT: store <vscale x 4 x i64> zeroinitializer, ptr [[PTR]], align 32
716+
; CHECK-NEXT: ret void
717+
;
718+
%gep.ptr.16 = getelementptr i64, ptr %ptr, i64 16
719+
store <2 x i64> zeroinitializer, ptr %gep.ptr.16
720+
store <vscale x 4 x i64> zeroinitializer, ptr %ptr
721+
ret void
722+
}
723+
724+
define void @fixed_scalable_redundant_store(ptr %ptr) vscale_range(1, 2) {
725+
; CHECK-LABEL: @fixed_scalable_redundant_store(
726+
; CHECK-NEXT: [[GEP_PTR_2:%.*]] = getelementptr i64, ptr [[PTR:%.*]], i64 2
727+
; CHECK-NEXT: store <vscale x 2 x i64> zeroinitializer, ptr [[GEP_PTR_2]], align 16
728+
; CHECK-NEXT: store <8 x i64> zeroinitializer, ptr [[PTR]], align 64
729+
; CHECK-NEXT: ret void
730+
;
731+
%gep.ptr.2 = getelementptr i64, ptr %ptr, i64 2
732+
store <vscale x 2 x i64> zeroinitializer, ptr %gep.ptr.2
733+
store <8 x i64> zeroinitializer, ptr %ptr
734+
ret void
735+
}
736+
737+
define void @fixed_scalable_neg(ptr %ptr) vscale_range(1, 2) {
738+
; CHECK-LABEL: @fixed_scalable_neg(
739+
; CHECK-NEXT: [[GEP_PTR_2:%.*]] = getelementptr i64, ptr [[PTR:%.*]], i64 2
740+
; CHECK-NEXT: store <vscale x 2 x i64> zeroinitializer, ptr [[GEP_PTR_2]], align 16
741+
; CHECK-NEXT: store <4 x i64> zeroinitializer, ptr [[PTR]], align 32
742+
; CHECK-NEXT: ret void
743+
;
744+
%gep.ptr.2 = getelementptr i64, ptr %ptr, i64 2
745+
store <vscale x 2 x i64> zeroinitializer, ptr %gep.ptr.2
746+
store <4 x i64> zeroinitializer, ptr %ptr
747+
ret void
748+
}

0 commit comments

Comments
 (0)