xref: /llvm-project/llvm/test/Transforms/InstCombine/call.ll (revision cc14ecc281331be8f44b370a437a7f1eb7f5c7c9)
1; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 2
2; RUN: opt < %s -passes=instcombine -S | FileCheck %s
3
4target datalayout = "E-p:64:64:64-p1:16:16:16-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128"
5
6; Simple case, argument translatable without changing the value
7declare void @test1a(ptr)
8
9define void @test1(ptr %A) {
10; CHECK-LABEL: define void @test1
11; CHECK-SAME: (ptr [[A:%.*]]) {
12; CHECK-NEXT:    call void @test1a(ptr [[A]])
13; CHECK-NEXT:    ret void
14;
15  call void @test1a( ptr %A )
16  ret void
17}
18
19
20; Should not do because of change in address space of the parameter
21define void @test1_as1_illegal(ptr addrspace(1) %A) {
22; CHECK-LABEL: define void @test1_as1_illegal
23; CHECK-SAME: (ptr addrspace(1) [[A:%.*]]) {
24; CHECK-NEXT:    call void @test1a(ptr addrspace(1) [[A]])
25; CHECK-NEXT:    ret void
26;
27  call void @test1a(ptr addrspace(1) %A)
28  ret void
29}
30
31; Test1, but the argument has a different sized address-space
32declare void @test1a_as1(ptr addrspace(1))
33
34; This one is OK to perform
35define void @test1_as1(ptr addrspace(1) %A) {
36; CHECK-LABEL: define void @test1_as1
37; CHECK-SAME: (ptr addrspace(1) [[A:%.*]]) {
38; CHECK-NEXT:    call void @test1a_as1(ptr addrspace(1) [[A]])
39; CHECK-NEXT:    ret void
40;
41  call void @test1a_as1(ptr addrspace(1) %A )
42  ret void
43}
44
45; More complex case, translate argument because of resolution.  This is safe
46; because we have the body of the function
47define void @test2a(i8 %A) {
48; CHECK-LABEL: define void @test2a
49; CHECK-SAME: (i8 [[A:%.*]]) {
50; CHECK-NEXT:    ret void
51;
52  ret void
53}
54
55define i32 @test2(i32 %A) {
56; CHECK-LABEL: define i32 @test2
57; CHECK-SAME: (i32 [[A:%.*]]) {
58; CHECK-NEXT:    call void @test2a(i32 [[A]])
59; CHECK-NEXT:    ret i32 [[A]]
60;
61  call void @test2a( i32 %A )
62  ret i32 %A
63}
64
65
66; Resolving this should insert a cast from sbyte to int, following the C
67; promotion rules.
68define void @test3a(i8, ...) {unreachable }
69; CHECK-LABEL: define void @test3a
70; CHECK-SAME: (i8 [[TMP0:%.*]], ...) {
71; CHECK-NEXT:    unreachable
72;
73define void @test3(i8 %A, i8 %B) {
74  call void @test3a( i8 %A, i8 %B)
75  ret void
76}
77
78; test conversion of return value...
79define i8 @test4a() {
80; CHECK-LABEL: define i8 @test4a() {
81; CHECK-NEXT:    ret i8 0
82;
83  ret i8 0
84}
85
86define i32 @test4() {
87; CHECK-LABEL: define i32 @test4() {
88; CHECK-NEXT:    [[X:%.*]] = call i32 @test4a()
89; CHECK-NEXT:    ret i32 [[X]]
90;
91  %X = call i32 @test4a( )            ; <i32> [#uses=1]
92  ret i32 %X
93}
94
95; test conversion of return value... no value conversion occurs so we can do
96; this with just a prototype...
97declare i32 @test5a()
98
99define i32 @test5() {
100; CHECK-LABEL: define i32 @test5() {
101; CHECK-NEXT:    [[X:%.*]] = call i32 @test5a()
102; CHECK-NEXT:    ret i32 [[X]]
103;
104  %X = call i32 @test5a( )                ; <i32> [#uses=1]
105  ret i32 %X
106}
107
108; test addition of new arguments...
109declare i32 @test6a(i32)
110
111define i32 @test6() {
112; CHECK-LABEL: define i32 @test6() {
113; CHECK-NEXT:    [[X:%.*]] = call i32 @test6a()
114; CHECK-NEXT:    ret i32 [[X]]
115;
116  %X = call i32 @test6a( )
117  ret i32 %X
118}
119
120; test removal of arguments, only can happen with a function body
121define void @test7a() {
122; CHECK-LABEL: define void @test7a() {
123; CHECK-NEXT:    ret void
124;
125  ret void
126}
127
128define void @test7() {
129; CHECK-LABEL: define void @test7() {
130; CHECK-NEXT:    call void @test7a()
131; CHECK-NEXT:    ret void
132;
133  call void @test7a( i32 5 )
134  ret void
135}
136
137
138; rdar://7590304
139declare void @test8a()
140
141define ptr @test8() personality ptr @__gxx_personality_v0 {
142; CHECK-LABEL: define ptr @test8() personality ptr @__gxx_personality_v0 {
143; CHECK-NEXT:    invoke void @test8a()
144; CHECK-NEXT:            to label [[INVOKE_CONT:%.*]] unwind label [[TRY_HANDLER:%.*]]
145; CHECK:       invoke.cont:
146; CHECK-NEXT:    unreachable
147; CHECK:       try.handler:
148; CHECK-NEXT:    [[EXN:%.*]] = landingpad { ptr, i32 }
149; CHECK-NEXT:            cleanup
150; CHECK-NEXT:    ret ptr null
151;
152; Don't turn this into "unreachable": the callee and caller don't agree in
153; calling conv, but the implementation of test8a may actually end up using the
154; right calling conv.
155  invoke void @test8a()
156  to label %invoke.cont unwind label %try.handler
157
158invoke.cont:                                      ; preds = %entry
159  unreachable
160
161try.handler:                                      ; preds = %entry
162  %exn = landingpad {ptr, i32}
163  cleanup
164  ret ptr null
165}
166
167declare i32 @__gxx_personality_v0(...)
168
169
170; Don't turn this into a direct call, because test9x is just a prototype and
171; doing so will make it varargs.
172; rdar://9038601
173declare ptr @test9x(ptr, ptr, ...) noredzone
174define ptr @test9(ptr %arg, ptr %tmp3) nounwind ssp noredzone {
175; CHECK-LABEL: define ptr @test9
176; CHECK-SAME: (ptr [[ARG:%.*]], ptr [[TMP3:%.*]]) #[[ATTR1:[0-9]+]] {
177; CHECK-NEXT:  entry:
178; CHECK-NEXT:    [[CALL:%.*]] = call ptr @test9x(ptr [[ARG]], ptr [[TMP3]]) #[[ATTR2:[0-9]+]]
179; CHECK-NEXT:    ret ptr [[CALL]]
180;
181entry:
182  %call = call ptr @test9x(ptr %arg, ptr %tmp3) noredzone
183  ret ptr %call
184}
185
186
187; Parameter that's a vector of pointers
188declare void @test10a(<2 x ptr>)
189
190define void @test10(<2 x ptr> %A) {
191; CHECK-LABEL: define void @test10
192; CHECK-SAME: (<2 x ptr> [[A:%.*]]) {
193; CHECK-NEXT:    call void @test10a(<2 x ptr> [[A]])
194; CHECK-NEXT:    ret void
195;
196  call void @test10a(<2 x ptr> %A)
197  ret void
198}
199
200; Don't transform because different address spaces
201declare void @test10a_mixed_as(<2 x ptr addrspace(1)>)
202
203define void @test10_mixed_as(<2 x ptr> %A) {
204; CHECK-LABEL: define void @test10_mixed_as
205; CHECK-SAME: (<2 x ptr> [[A:%.*]]) {
206; CHECK-NEXT:    call void @test10a_mixed_as(<2 x ptr> [[A]])
207; CHECK-NEXT:    ret void
208;
209  call void @test10a_mixed_as(<2 x ptr> %A)
210  ret void
211}
212
213; Return type that's a pointer
214define ptr @test11a() {
215; CHECK-LABEL: define ptr @test11a() {
216; CHECK-NEXT:    ret ptr null
217;
218  ret ptr zeroinitializer
219}
220
221define ptr @test11() {
222; CHECK-LABEL: define ptr @test11() {
223; CHECK-NEXT:    [[X:%.*]] = call ptr @test11a()
224; CHECK-NEXT:    ret ptr [[X]]
225;
226  %X = call ptr @test11a()
227  ret ptr %X
228}
229
230; Return type that's a pointer with a different address space
231define ptr addrspace(1) @test11a_mixed_as() {
232; CHECK-LABEL: define ptr addrspace(1) @test11a_mixed_as() {
233; CHECK-NEXT:    ret ptr addrspace(1) null
234;
235  ret ptr addrspace(1) zeroinitializer
236}
237
238define ptr @test11_mixed_as() {
239; CHECK-LABEL: define ptr @test11_mixed_as() {
240; CHECK-NEXT:    [[X:%.*]] = call ptr @test11a_mixed_as()
241; CHECK-NEXT:    ret ptr [[X]]
242;
243  %X = call ptr @test11a_mixed_as()
244  ret ptr %X
245}
246
247; Return type that's a vector of pointers
248define <2 x ptr> @test12a() {
249; CHECK-LABEL: define <2 x ptr> @test12a() {
250; CHECK-NEXT:    ret <2 x ptr> zeroinitializer
251;
252  ret <2 x ptr> zeroinitializer
253}
254
255define <2 x ptr> @test12() {
256; CHECK-LABEL: define <2 x ptr> @test12() {
257; CHECK-NEXT:    [[X:%.*]] = call <2 x ptr> @test12a()
258; CHECK-NEXT:    ret <2 x ptr> [[X]]
259;
260  %X = call <2 x ptr> @test12a()
261  ret <2 x ptr> %X
262}
263
264define <2 x ptr addrspace(1)> @test12a_mixed_as() {
265; CHECK-LABEL: define <2 x ptr addrspace(1)> @test12a_mixed_as() {
266; CHECK-NEXT:    ret <2 x ptr addrspace(1)> zeroinitializer
267;
268  ret <2 x ptr addrspace(1)> zeroinitializer
269}
270
271define <2 x ptr> @test12_mixed_as() {
272; CHECK-LABEL: define <2 x ptr> @test12_mixed_as() {
273; CHECK-NEXT:    [[X:%.*]] = call <2 x ptr> @test12a_mixed_as()
274; CHECK-NEXT:    ret <2 x ptr> [[X]]
275;
276  %X = call <2 x ptr> @test12a_mixed_as()
277  ret <2 x ptr> %X
278}
279
280
281; Mix parameter that's a vector of integers and pointers of the same size
282declare void @test13a(<2 x i64>)
283
284define void @test13(<2 x ptr> %A) {
285; CHECK-LABEL: define void @test13
286; CHECK-SAME: (<2 x ptr> [[A:%.*]]) {
287; CHECK-NEXT:    call void @test13a(<2 x ptr> [[A]])
288; CHECK-NEXT:    ret void
289;
290  call void @test13a(<2 x ptr> %A)
291  ret void
292}
293
294; Mix parameter that's a vector of integers and pointers of the same
295; size, but the other way around
296declare void @test14a(<2 x ptr>)
297
298define void @test14(<2 x i64> %A) {
299; CHECK-LABEL: define void @test14
300; CHECK-SAME: (<2 x i64> [[A:%.*]]) {
301; CHECK-NEXT:    call void @test14a(<2 x i64> [[A]])
302; CHECK-NEXT:    ret void
303;
304  call void @test14a(<2 x i64> %A)
305  ret void
306}
307
308
309; Return type that's a vector
310define <2 x i16> @test15a() {
311; CHECK-LABEL: define <2 x i16> @test15a() {
312; CHECK-NEXT:    ret <2 x i16> zeroinitializer
313;
314  ret <2 x i16> zeroinitializer
315}
316
317define i32 @test15() {
318; CHECK-LABEL: define i32 @test15() {
319; CHECK-NEXT:    [[X:%.*]] = call <2 x i16> @test15a()
320; CHECK-NEXT:    [[TMP1:%.*]] = bitcast <2 x i16> [[X]] to i32
321; CHECK-NEXT:    ret i32 [[TMP1]]
322;
323  %X = call i32 @test15a( )
324  ret i32 %X
325}
326
327define i32 @test16a() {
328; CHECK-LABEL: define i32 @test16a() {
329; CHECK-NEXT:    ret i32 0
330;
331  ret i32 0
332}
333
334define <2 x i16> @test16() {
335; CHECK-LABEL: define <2 x i16> @test16() {
336; CHECK-NEXT:    [[X:%.*]] = call i32 @test16a()
337; CHECK-NEXT:    [[TMP1:%.*]] = bitcast i32 [[X]] to <2 x i16>
338; CHECK-NEXT:    ret <2 x i16> [[TMP1]]
339;
340  %X = call <2 x i16> @test16a( )
341  ret <2 x i16> %X
342}
343
344declare i32 @pr28655(i32 returned %V)
345
346define i32 @test17() {
347; CHECK-LABEL: define i32 @test17() {
348; CHECK-NEXT:  entry:
349; CHECK-NEXT:    [[C:%.*]] = call i32 @pr28655(i32 0)
350; CHECK-NEXT:    ret i32 0
351;
352entry:
353  %C = call i32 @pr28655(i32 0)
354  ret i32 %C
355}
356
357define void @non_vararg(ptr, i32) {
358; CHECK-LABEL: define void @non_vararg
359; CHECK-SAME: (ptr [[TMP0:%.*]], i32 [[TMP1:%.*]]) {
360; CHECK-NEXT:    ret void
361;
362  ret void
363}
364
365define void @test_cast_to_vararg(ptr %this) {
366; CHECK-LABEL: define void @test_cast_to_vararg
367; CHECK-SAME: (ptr [[THIS:%.*]]) {
368; CHECK-NEXT:    call void @non_vararg(ptr [[THIS]], i32 42)
369; CHECK-NEXT:    ret void
370;
371  call void (ptr, ...) @non_vararg(ptr %this, i32 42)
372  ret void
373}
374