xref: /llvm-project/llvm/test/tools/llvm-reduce/reduce-opcodes-call.ll (revision 4638ba7b45f896132f3ee8c665ed390167b5d6b4)
1; RUN: llvm-reduce --abort-on-invalid-reduction --delta-passes=opcodes --test FileCheck --test-arg --check-prefix=ALL --test-arg %s --test-arg --input-file %s -o %t
2; RUN: FileCheck -check-prefixes=RESULT,ALL %s < %t
3
4target datalayout = "A5"
5
6declare token @llvm.return.token()
7declare void @llvm.uses.token(token)
8
9; ALL-LABEL: @call_token(
10; RESULT-NEXT: %token = call token @llvm.return.token()
11; RESULT-NEXT: call void @llvm.uses.token(token %token)
12; RESULT-NEXT: ret void
13define void @call_token() {
14  %token = call token @llvm.return.token()
15  call void @llvm.uses.token(token %token)
16  ret void
17}
18
19; ALL-LABEL: @call_void_0_size_arg(
20; RESULT-NEXT: store volatile {} %arg, ptr addrspace(5) null, align 1
21; RESULT-NEXT: ret void
22define void @call_void_0_size_arg({} %arg) {
23  call void @void_0_size_arg({} %arg)
24  ret void
25}
26
27; ALL-LABEL: @call_return_0_size(
28; RESULT-NEXT:  %op = load volatile {}, ptr %ptr, align 1
29; RESULT-NEXT: ret {} %op
30define {} @call_return_0_size(ptr %ptr) {
31  %op = call {} @return_0_size(ptr %ptr)
32  ret {} %op
33}
34
35; ALL-LABEL: define void @call_void_no_args(
36; RESULT-NEXT: store volatile i32 0, ptr addrspace(5) null, align 4
37; RESULT-NEXT: ret void
38define void @call_void_no_args() {
39  call void @void_no_args()
40  ret void
41}
42
43; ALL-LABEL: @call_store_like_i16(
44; RESULT-NEXT: store volatile i16 %val, ptr addrspace(1) %ptr, align 2
45; RESULT-NEXT: ret void
46define void @call_store_like_i16(i16 %val, ptr addrspace(1) %ptr) {
47  call void @store_like_i16(i16 %val, ptr addrspace(1) %ptr)
48  ret void
49}
50
51; ALL-LABEL: @keep_call_store_like_i16(
52; ALL-NEXT: call void @store_like_i16(i16 %val, ptr addrspace(1) %ptr)
53; ALL-NEXT: ret void
54define void @keep_call_store_like_i16(i16 %val, ptr addrspace(1) %ptr) {
55  call void @store_like_i16(i16 %val, ptr addrspace(1) %ptr)
56  ret void
57}
58
59; ALL-LABEL: @call_store_like_i16_swap(
60; RESULT-NEXT: store volatile i16 %val, ptr addrspace(1) %ptr
61; RESULT-NEXT: ret void
62define void @call_store_like_i16_swap(ptr addrspace(1) %ptr, i16 %val) {
63  call void @store_like_i16_swap(ptr addrspace(1) %ptr, i16 %val)
64  ret void
65}
66
67; ALL-LABEL: @call_store_like_i16_extra_arg(
68; RESULT-NEXT: call void @store_like_i16_extra_arg(i16 %val, ptr addrspace(1) %ptr, i32 %extra)
69; RESULT-NEXT: ret void
70define void @call_store_like_i16_extra_arg(i16 %val, ptr addrspace(1) %ptr, i32 %extra) {
71  call void @store_like_i16_extra_arg(i16 %val, ptr addrspace(1) %ptr, i32 %extra)
72  ret void
73}
74
75; ALL-LABEL: @call_store_like_i16_extra_ptr_arg(
76; RESULT-NEXT: call void @store_like_i16_extra_ptr_arg(i16 %val, ptr addrspace(1) %ptr, ptr addrspace(1) %extra)
77; RESULT-NEXT: ret void
78define void @call_store_like_i16_extra_ptr_arg(i16 %val, ptr addrspace(1) %ptr, ptr addrspace(1) %extra) {
79  call void @store_like_i16_extra_ptr_arg(i16 %val, ptr addrspace(1) %ptr, ptr addrspace(1) %extra)
80  ret void
81}
82
83; ALL-LABEL: @call_store_like_ptr_store(
84; RESULT-NEXT: store volatile ptr addrspace(1) %ptr, ptr addrspace(3) %ptr.val, align 8
85; RESULT-NEXT: ret void
86define void @call_store_like_ptr_store(ptr addrspace(3) %ptr.val, ptr addrspace(1) %ptr) {
87  call void @store_like_ptr_store(ptr addrspace(3) %ptr.val, ptr addrspace(1) %ptr)
88  ret void
89}
90
91; ALL-LABEL: @call_store_like_ptr_store_swap(
92; RESULT-NEXT: store volatile ptr addrspace(3) %ptr.val, ptr addrspace(1) %ptr, align 8
93; RESULT-NEXT: ret void
94define void @call_store_like_ptr_store_swap(ptr addrspace(1) %ptr, ptr addrspace(3) %ptr.val) {
95  call void @store_like_ptr_store_swap(ptr addrspace(1) %ptr, ptr addrspace(3) %ptr.val)
96  ret void
97}
98
99; ALL-LABEL: @call_store_like_ptr_store_different_element_type(
100; RESULT-NEXT: store volatile ptr addrspace(1) %ptr, ptr addrspace(3) %ptr.val, align 8
101; RESULT-NEXT: ret void
102define void @call_store_like_ptr_store_different_element_type(ptr addrspace(3) %ptr.val, ptr addrspace(1) %ptr) {
103  call void @store_like_ptr_store_different_element_type(ptr addrspace(3) %ptr.val, ptr addrspace(1) %ptr)
104  ret void
105}
106
107; ALL-LABEL: @call_store_like_ptr_store_different_element_type_swap(
108; RESULT-NEXT: store volatile ptr addrspace(3) %ptr.val, ptr addrspace(1) %ptr, align 8
109; RESULT-NEXT: ret void
110define void @call_store_like_ptr_store_different_element_type_swap(ptr addrspace(1) %ptr, ptr addrspace(3) %ptr.val) {
111  call void @store_like_ptr_store_different_element_type_swap(ptr addrspace(1) %ptr, ptr addrspace(3) %ptr.val)
112  ret void
113}
114
115; ALL-LABEL: @call_load_like_i32(
116; RESULT-NEXT: %op = load volatile i32, ptr addrspace(1) %ptr, align 4
117; RESULT-NEXT: ret i32 %op
118define i32 @call_load_like_i32(ptr addrspace(1) %ptr) {
119  %op = call i32 @load_like_i32(ptr addrspace(1) %ptr)
120  ret i32 %op
121}
122
123; ALL-LABEL: @keep_call_load_like_i32(
124; ALL-NEXT: %op = call i32 @load_like_i32(ptr addrspace(1) %ptr)
125; ALL-NEXT: ret i32 %op
126define i32 @keep_call_load_like_i32(ptr addrspace(1) %ptr) {
127  %op = call i32 @load_like_i32(ptr addrspace(1) %ptr)
128  ret i32 %op
129}
130
131; ALL-LABEL: @call_load_like_i32_extra_arg(
132; RESULT-NEXT: %op = call i32 @load_like_i32_extra_arg(ptr addrspace(1) %ptr, i32 %extra)
133; RESULT-NEXT: ret i32 %op
134define i32 @call_load_like_i32_extra_arg(ptr addrspace(1) %ptr, i32 %extra) {
135  %op = call i32 @load_like_i32_extra_arg(ptr addrspace(1) %ptr, i32 %extra)
136  ret i32 %op
137}
138
139; ALL-LABEL: @call_load_like_ptr_mismatch(
140; RESULT-NEXT: %op = load volatile i32, ptr addrspace(1) %ptr, align 4
141; RESULT-NEXT: ret i32 %op
142define i32 @call_load_like_ptr_mismatch(ptr addrspace(1) %ptr) {
143  %op = call i32 @load_like_ptr_mismatch(ptr addrspace(1) %ptr)
144  ret i32 %op
145}
146
147; ALL-LABEL: @call_load_like_skip_arg(
148; RESULT-NEXT: %op = load volatile i32, ptr addrspace(1) %ptr, align 4
149; RESULT-NEXT: ret i32 %op
150define i32 @call_load_like_skip_arg(float, ptr addrspace(1) %ptr) {
151  %op = call i32 @load_like_skip_arg(float poison, ptr addrspace(1) %ptr)
152  ret i32 %op
153}
154
155; ALL-LABEL: @call_fp_scalar_noargs(
156; RESULT-NEXT: %op = load volatile float, ptr addrspace(5) null, align 4
157; RESULT-NEXT: ret float %op
158define float @call_fp_scalar_noargs() {
159  %op = call nsz float @fp_scalar_noargs()
160  ret float %op
161}
162
163; ALL-LABEL: @call_fp_vector_noargs(
164; RESULT-NEXT: %op = load volatile <2 x half>, ptr addrspace(5) null, align 4
165; RESULT-NEXT: ret <2 x half> %op
166define <2 x half> @call_fp_vector_noargs() {
167  %op = call nsz <2 x half> @fp_vector_noargs()
168  ret <2 x half> %op
169}
170
171; ALL-LABEL: @call_unary_fp_scalar(
172; RESULT-NEXT: %op = fneg nsz float %a
173; RESULT-NEXT: ret float %op
174define float @call_unary_fp_scalar(float %a) {
175  %op = call nsz float @unary_fp_scalar(float %a)
176  ret float %op
177}
178
179; ALL-LABEL: @call_unary_fp_vector(
180; RESULT-NEXT: %op = fneg nsz <2 x half> %a
181; RESULT-NEXT: ret <2 x half> %op
182define <2 x half> @call_unary_fp_vector(<2 x half> %a) {
183  %op = call nsz <2 x half> @unary_fp_vector(<2 x half> %a)
184  ret <2 x half> %op
185}
186
187; ALL-LABEL: @ignore_undef_args_unary_fp(
188; RESULT-NEXT: %op = fneg nnan float %a
189; RESULT-NEXT: ret float %op
190define float @ignore_undef_args_unary_fp(float %a) {
191  %op = call nnan float @func_i32_f32_i32(i32 poison, float %a, i32 poison)
192  ret float %op
193}
194
195; ALL-LABEL: @call_binary_fp_scalar(
196; RESULT: %op = fmul afn float %a, %b
197; RESULT-NEXT: ret float %op
198define float @call_binary_fp_scalar(float %a, float %b) {
199  %op = call afn float @binary_fp_scalar(float %a, float %b)
200  ret float %op
201}
202
203; ALL-LABEL: @call_binary_fp_vector(
204; RESULT-NEXT: %op = fmul afn <2 x half> %a, %b
205; RESULT-NEXT: ret <2 x half> %op
206define <2 x half> @call_binary_fp_vector(<2 x half> %a, <2 x half> %b) {
207  %op = call afn <2 x half> @binary_fp_vector(<2 x half> %a, <2 x half> %b)
208  ret <2 x half> %op
209}
210
211; ALL-LABEL: @call_ternary_fp_scalar(
212; RESULT-NEXT: %op = call afn float @llvm.fma.f32(float %a, float %b, float %c)
213; RESULT-NEXT: ret float %op
214define float @call_ternary_fp_scalar(float %a, float %b, float %c) {
215  %op = call afn float @ternary_fp_scalar(float %a, float %b, float %c)
216  ret float %op
217}
218
219; ALL-LABEL: @call_ternary_fp_vector(
220; RESULT-NEXT: %op = call afn <2 x half> @llvm.fma.v2f16(<2 x half> %a, <2 x half> %b, <2 x half> %c)
221; RESULT-NEXT: ret <2 x half> %op
222define <2 x half> @call_ternary_fp_vector(<2 x half> %a, <2 x half> %b, <2 x half> %c) {
223  %op = call afn <2 x half> @ternary_fp_vector(<2 x half> %a, <2 x half> %b, <2 x half> %c)
224  ret <2 x half> %op
225}
226
227; ALL-LABEL: @call_unary_int_scalar(
228; RESULT-NEXT: %op = call i32 @llvm.bswap.i32(i32 %a)
229; RESULT-NEXT: ret i32 %op
230define i32 @call_unary_int_scalar(i32 %a) {
231  %op = call i32 @unary_int_scalar(i32 %a)
232  ret i32 %op
233}
234
235; ALL-LABEL: @call_unary_int_vector(
236; RESULT-NEXT: %op = call <2 x i16> @llvm.bswap.v2i16(<2 x i16> %a)
237; RESULT-NEXT: ret <2 x i16> %op
238define <2 x i16> @call_unary_int_vector(<2 x i16> %a) {
239  %op = call <2 x i16> @unary_int_vector(<2 x i16> %a)
240  ret <2 x i16> %op
241}
242
243; ALL-LABEL: @call_binary_int_scalar(
244; RESULT-NEXT: %op = and i32 %a, %b
245; RESULT-NEXT: ret i32 %op
246define i32 @call_binary_int_scalar(i32 %a, i32 %b) {
247  %op = call i32 @binary_int_scalar(i32 %a, i32 %b)
248  ret i32 %op
249}
250
251; ALL-LABEL: @call_binary_int_vector(
252; RESULT-NEXT: %op = and <2 x i16> %a, %b
253; RESULT-NEXT: ret <2 x i16> %op
254define <2 x i16> @call_binary_int_vector(<2 x i16> %a, <2 x i16> %b) {
255  %op = call <2 x i16> @binary_int_vector(<2 x i16> %a, <2 x i16> %b)
256  ret <2 x i16> %op
257}
258
259; ALL-LABEL: @call_ternary_int_scalar(
260; RESULT-NEXT: %op = call i32 @llvm.fshl.i32(i32 %a, i32 %b, i32 %c)
261; RESULT-NEXT: ret i32 %op
262define i32 @call_ternary_int_scalar(i32 %a, i32 %b, i32 %c) {
263  %op = call i32 @ternary_int_scalar(i32 %a, i32 %b, i32 %c)
264  ret i32 %op
265}
266
267; ALL-LABEL: @call_ternary_int_vector(
268; RESULT-NEXT: %op = call <2 x i16> @llvm.fshl.v2i16(<2 x i16> %a, <2 x i16> %b, <2 x i16> %c)
269; RESULT-NEXT: ret <2 x i16> %op
270define <2 x i16> @call_ternary_int_vector(<2 x i16> %a, <2 x i16> %b, <2 x i16> %c) {
271  %op = call <2 x i16> @ternary_int_vector(<2 x i16> %a, <2 x i16> %b, <2 x i16> %c)
272  ret <2 x i16> %op
273}
274
275; ALL-LABEL: @call_quaternary_int_scalar(
276; RESULT-NEXT: %op = call i32 @quaternary_int_scalar(i32 %a, i32 %b, i32 %c, i32 %d)
277; RESULT-NEXT: ret i32 %op
278define i32 @call_quaternary_int_scalar(i32 %a, i32 %b, i32 %c, i32 %d) {
279  %op = call i32 @quaternary_int_scalar(i32 %a, i32 %b, i32 %c, i32 %d)
280  ret i32 %op
281}
282
283; ALL-LABEL: @call_quaternary_int_vector(
284; RESULT-NEXT: %op = call <2 x i16> @quaternary_int_vector(<2 x i16> %a, <2 x i16> %b, <2 x i16> %c, <2 x i16> %d)
285; RESULT-NEXT: ret <2 x i16> %op
286define <2 x i16> @call_quaternary_int_vector(<2 x i16> %a, <2 x i16> %b, <2 x i16> %c, <2 x i16> %d) {
287  %op = call <2 x i16> @quaternary_int_vector(<2 x i16> %a, <2 x i16> %b, <2 x i16> %c, <2 x i16> %d)
288  ret <2 x i16> %op
289}
290
291declare void @void_0_size_arg({})
292declare {} @return_0_size(ptr)
293declare void @void_no_args()
294declare void @store_like_i16(i16, ptr addrspace(1))
295declare void @store_like_i16_swap(ptr addrspace(1), i16)
296declare void @store_like_i16_extra_arg(i16, ptr addrspace(1), i32)
297declare void @store_like_i16_extra_ptr_arg(i16, ptr addrspace(1), ptr addrspace(1))
298declare void @store_like_ptr_store(ptr addrspace(3), ptr addrspace(1))
299declare void @store_like_ptr_store_swap(ptr addrspace(1), ptr addrspace(3))
300declare void @store_like_ptr_store_different_element_type(ptr addrspace(3), ptr addrspace(1))
301declare void @store_like_ptr_store_different_element_type_swap(ptr addrspace(1), ptr addrspace(3))
302declare i32 @load_like_i32(ptr addrspace(1))
303
304declare i32 @load_like_i32_extra_arg(ptr addrspace(1), i32)
305
306declare i32 @load_like_ptr_mismatch(ptr addrspace(1))
307declare i32 @load_like_skip_arg(float, ptr addrspace(1))
308
309declare float @fp_scalar_noargs()
310declare i32 @int_scalar_noargs()
311
312declare <2 x half> @fp_vector_noargs()
313declare <2 x i16> @int_vector_noargs()
314
315declare float @unary_fp_scalar(float)
316declare <2 x half> @unary_fp_vector(<2 x half>)
317declare float @func_i32_f32_i32(i32, float, i32)
318
319declare float @binary_fp_scalar(float, float)
320declare <2 x half> @binary_fp_vector(<2 x half>, <2 x half>)
321
322declare float @ternary_fp_scalar(float, float, float)
323declare <2 x half> @ternary_fp_vector(<2 x half>, <2 x half>, <2 x half>)
324
325declare float @quaternary_fp_scalar(float, float, float, float)
326declare <2 x half> @quaternary_fp_vector(<2 x half>, <2 x half>, <2 x half>, <2 x half>)
327
328declare i32 @unary_int_scalar(i32)
329declare <2 x i16> @unary_int_vector(<2 x i16>)
330declare i32 @binary_int_scalar(i32, i32)
331declare <2 x i16> @binary_int_vector(<2 x i16>, <2 x i16>)
332declare i32 @ternary_int_scalar(i32, i32, i32)
333declare <2 x i16> @ternary_int_vector(<2 x i16>, <2 x i16>, <2 x i16>)
334declare i32 @quaternary_int_scalar(i32, i32, i32, i32)
335declare <2 x i16> @quaternary_int_vector(<2 x i16>, <2 x i16>, <2 x i16>, <2 x i16>)
336