1 ; Test 8-bit conditional stores that are presented as selects.
3 ; RUN: llc < %s -mtriple=s390x-linux-gnu | FileCheck %s
5 declare void @foo(i8 *)
7 ; Test the simple case, with the loaded value first.
8 define void @f1(i8 *%ptr, i8 %alt, i32 %limit) {
11 ; CHECK: jl [[LABEL:[^ ]*]]
13 ; CHECK: stc %r3, 0(%r2)
16 %cond = icmp ult i32 %limit, 42
18 %res = select i1 %cond, i8 %orig, i8 %alt
19 store i8 %res, i8 *%ptr
23 ; ...and with the loaded value second
24 define void @f2(i8 *%ptr, i8 %alt, i32 %limit) {
27 ; CHECK: jnl [[LABEL:[^ ]*]]
29 ; CHECK: stc %r3, 0(%r2)
32 %cond = icmp ult i32 %limit, 42
34 %res = select i1 %cond, i8 %alt, i8 %orig
35 store i8 %res, i8 *%ptr
39 ; Test cases where the value is explicitly sign-extended to 32 bits, with the
41 define void @f3(i8 *%ptr, i32 %alt, i32 %limit) {
44 ; CHECK: jl [[LABEL:[^ ]*]]
46 ; CHECK: stc %r3, 0(%r2)
49 %cond = icmp ult i32 %limit, 42
51 %ext = sext i8 %orig to i32
52 %res = select i1 %cond, i32 %ext, i32 %alt
53 %trunc = trunc i32 %res to i8
54 store i8 %trunc, i8 *%ptr
58 ; ...and with the loaded value second
59 define void @f4(i8 *%ptr, i32 %alt, i32 %limit) {
62 ; CHECK: jnl [[LABEL:[^ ]*]]
64 ; CHECK: stc %r3, 0(%r2)
67 %cond = icmp ult i32 %limit, 42
69 %ext = sext i8 %orig to i32
70 %res = select i1 %cond, i32 %alt, i32 %ext
71 %trunc = trunc i32 %res to i8
72 store i8 %trunc, i8 *%ptr
76 ; Test cases where the value is explicitly zero-extended to 32 bits, with the
78 define void @f5(i8 *%ptr, i32 %alt, i32 %limit) {
81 ; CHECK: jl [[LABEL:[^ ]*]]
83 ; CHECK: stc %r3, 0(%r2)
86 %cond = icmp ult i32 %limit, 42
88 %ext = zext i8 %orig to i32
89 %res = select i1 %cond, i32 %ext, i32 %alt
90 %trunc = trunc i32 %res to i8
91 store i8 %trunc, i8 *%ptr
95 ; ...and with the loaded value second
96 define void @f6(i8 *%ptr, i32 %alt, i32 %limit) {
99 ; CHECK: jnl [[LABEL:[^ ]*]]
101 ; CHECK: stc %r3, 0(%r2)
104 %cond = icmp ult i32 %limit, 42
105 %orig = load i8 *%ptr
106 %ext = zext i8 %orig to i32
107 %res = select i1 %cond, i32 %alt, i32 %ext
108 %trunc = trunc i32 %res to i8
109 store i8 %trunc, i8 *%ptr
113 ; Test cases where the value is explicitly sign-extended to 64 bits, with the
114 ; loaded value first.
115 define void @f7(i8 *%ptr, i64 %alt, i32 %limit) {
118 ; CHECK: jl [[LABEL:[^ ]*]]
120 ; CHECK: stc %r3, 0(%r2)
123 %cond = icmp ult i32 %limit, 42
124 %orig = load i8 *%ptr
125 %ext = sext i8 %orig to i64
126 %res = select i1 %cond, i64 %ext, i64 %alt
127 %trunc = trunc i64 %res to i8
128 store i8 %trunc, i8 *%ptr
132 ; ...and with the loaded value second
133 define void @f8(i8 *%ptr, i64 %alt, i32 %limit) {
136 ; CHECK: jnl [[LABEL:[^ ]*]]
138 ; CHECK: stc %r3, 0(%r2)
141 %cond = icmp ult i32 %limit, 42
142 %orig = load i8 *%ptr
143 %ext = sext i8 %orig to i64
144 %res = select i1 %cond, i64 %alt, i64 %ext
145 %trunc = trunc i64 %res to i8
146 store i8 %trunc, i8 *%ptr
150 ; Test cases where the value is explicitly zero-extended to 64 bits, with the
151 ; loaded value first.
152 define void @f9(i8 *%ptr, i64 %alt, i32 %limit) {
155 ; CHECK: jl [[LABEL:[^ ]*]]
157 ; CHECK: stc %r3, 0(%r2)
160 %cond = icmp ult i32 %limit, 42
161 %orig = load i8 *%ptr
162 %ext = zext i8 %orig to i64
163 %res = select i1 %cond, i64 %ext, i64 %alt
164 %trunc = trunc i64 %res to i8
165 store i8 %trunc, i8 *%ptr
169 ; ...and with the loaded value second
170 define void @f10(i8 *%ptr, i64 %alt, i32 %limit) {
173 ; CHECK: jnl [[LABEL:[^ ]*]]
175 ; CHECK: stc %r3, 0(%r2)
178 %cond = icmp ult i32 %limit, 42
179 %orig = load i8 *%ptr
180 %ext = zext i8 %orig to i64
181 %res = select i1 %cond, i64 %alt, i64 %ext
182 %trunc = trunc i64 %res to i8
183 store i8 %trunc, i8 *%ptr
187 ; Check the high end of the STC range.
188 define void @f11(i8 *%base, i8 %alt, i32 %limit) {
191 ; CHECK: jl [[LABEL:[^ ]*]]
193 ; CHECK: stc %r3, 4095(%r2)
196 %ptr = getelementptr i8 *%base, i64 4095
197 %cond = icmp ult i32 %limit, 42
198 %orig = load i8 *%ptr
199 %res = select i1 %cond, i8 %orig, i8 %alt
200 store i8 %res, i8 *%ptr
204 ; Check the next byte up, which should use STCY instead of STC.
205 define void @f12(i8 *%base, i8 %alt, i32 %limit) {
208 ; CHECK: jl [[LABEL:[^ ]*]]
210 ; CHECK: stcy %r3, 4096(%r2)
213 %ptr = getelementptr i8 *%base, i64 4096
214 %cond = icmp ult i32 %limit, 42
215 %orig = load i8 *%ptr
216 %res = select i1 %cond, i8 %orig, i8 %alt
217 store i8 %res, i8 *%ptr
221 ; Check the high end of the STCY range.
222 define void @f13(i8 *%base, i8 %alt, i32 %limit) {
225 ; CHECK: jl [[LABEL:[^ ]*]]
227 ; CHECK: stcy %r3, 524287(%r2)
230 %ptr = getelementptr i8 *%base, i64 524287
231 %cond = icmp ult i32 %limit, 42
232 %orig = load i8 *%ptr
233 %res = select i1 %cond, i8 %orig, i8 %alt
234 store i8 %res, i8 *%ptr
238 ; Check the next byte up, which needs separate address logic.
239 ; Other sequences besides this one would be OK.
240 define void @f14(i8 *%base, i8 %alt, i32 %limit) {
243 ; CHECK: jl [[LABEL:[^ ]*]]
245 ; CHECK: agfi %r2, 524288
246 ; CHECK: stc %r3, 0(%r2)
249 %ptr = getelementptr i8 *%base, i64 524288
250 %cond = icmp ult i32 %limit, 42
251 %orig = load i8 *%ptr
252 %res = select i1 %cond, i8 %orig, i8 %alt
253 store i8 %res, i8 *%ptr
257 ; Check the low end of the STCY range.
258 define void @f15(i8 *%base, i8 %alt, i32 %limit) {
261 ; CHECK: jl [[LABEL:[^ ]*]]
263 ; CHECK: stcy %r3, -524288(%r2)
266 %ptr = getelementptr i8 *%base, i64 -524288
267 %cond = icmp ult i32 %limit, 42
268 %orig = load i8 *%ptr
269 %res = select i1 %cond, i8 %orig, i8 %alt
270 store i8 %res, i8 *%ptr
274 ; Check the next byte down, which needs separate address logic.
275 ; Other sequences besides this one would be OK.
276 define void @f16(i8 *%base, i8 %alt, i32 %limit) {
279 ; CHECK: jl [[LABEL:[^ ]*]]
281 ; CHECK: agfi %r2, -524289
282 ; CHECK: stc %r3, 0(%r2)
285 %ptr = getelementptr i8 *%base, i64 -524289
286 %cond = icmp ult i32 %limit, 42
287 %orig = load i8 *%ptr
288 %res = select i1 %cond, i8 %orig, i8 %alt
289 store i8 %res, i8 *%ptr
293 ; Check that STCY allows an index.
294 define void @f17(i64 %base, i64 %index, i8 %alt, i32 %limit) {
297 ; CHECK: jl [[LABEL:[^ ]*]]
299 ; CHECK: stcy %r4, 4096(%r3,%r2)
302 %add1 = add i64 %base, %index
303 %add2 = add i64 %add1, 4096
304 %ptr = inttoptr i64 %add2 to i8 *
305 %cond = icmp ult i32 %limit, 42
306 %orig = load i8 *%ptr
307 %res = select i1 %cond, i8 %orig, i8 %alt
308 store i8 %res, i8 *%ptr
312 ; Check that volatile loads are not matched.
313 define void @f18(i8 *%ptr, i8 %alt, i32 %limit) {
315 ; CHECK: lb {{%r[0-5]}}, 0(%r2)
316 ; CHECK: {{jl|jnl}} [[LABEL:[^ ]*]]
318 ; CHECK: stc {{%r[0-5]}}, 0(%r2)
320 %cond = icmp ult i32 %limit, 42
321 %orig = load volatile i8 *%ptr
322 %res = select i1 %cond, i8 %orig, i8 %alt
323 store i8 %res, i8 *%ptr
327 ; ...likewise stores. In this case we should have a conditional load into %r3.
328 define void @f19(i8 *%ptr, i8 %alt, i32 %limit) {
330 ; CHECK: jnl [[LABEL:[^ ]*]]
331 ; CHECK: lb %r3, 0(%r2)
333 ; CHECK: stc %r3, 0(%r2)
335 %cond = icmp ult i32 %limit, 42
336 %orig = load i8 *%ptr
337 %res = select i1 %cond, i8 %orig, i8 %alt
338 store volatile i8 %res, i8 *%ptr
342 ; Check that atomic loads are not matched. The transformation is OK for
343 ; the "unordered" case tested here, but since we don't try to handle atomic
344 ; operations at all in this context, it seems better to assert that than
345 ; to restrict the test to a stronger ordering.
346 define void @f20(i8 *%ptr, i8 %alt, i32 %limit) {
347 ; FIXME: should use a normal load instead of CS.
349 ; CHECK: cs {{%r[0-9]+}},
350 ; CHECK: {{jl|jnl}} [[LABEL:[^ ]*]]
352 ; CHECK: stc {{%r[0-9]+}},
354 %cond = icmp ult i32 %limit, 42
355 %orig = load atomic i8 *%ptr unordered, align 1
356 %res = select i1 %cond, i8 %orig, i8 %alt
357 store i8 %res, i8 *%ptr
361 ; ...likewise stores.
362 define void @f21(i8 *%ptr, i8 %alt, i32 %limit) {
363 ; FIXME: should use a normal store instead of CS.
365 ; CHECK: jnl [[LABEL:[^ ]*]]
366 ; CHECK: lb %r3, 0(%r2)
368 ; CHECK: cs {{%r[0-9]+}},
370 %cond = icmp ult i32 %limit, 42
371 %orig = load i8 *%ptr
372 %res = select i1 %cond, i8 %orig, i8 %alt
373 store atomic i8 %res, i8 *%ptr unordered, align 1
377 ; Try a frame index base.
378 define void @f22(i8 %alt, i32 %limit) {
380 ; CHECK: brasl %r14, foo@PLT
382 ; CHECK: jl [[LABEL:[^ ]*]]
384 ; CHECK: stc {{%r[0-9]+}}, {{[0-9]+}}(%r15)
386 ; CHECK: brasl %r14, foo@PLT
389 call void @foo(i8 *%ptr)
390 %cond = icmp ult i32 %limit, 42
391 %orig = load i8 *%ptr
392 %res = select i1 %cond, i8 %orig, i8 %alt
393 store i8 %res, i8 *%ptr
394 call void @foo(i8 *%ptr)