|
173
|
1 // RUN: %clang_cc1 %s -O0 -fno-experimental-new-pass-manager -emit-llvm -triple x86_64-unknown-unknown -o - | FileCheck %s --check-prefix=X86
|
|
|
2 // RUN: %clang_cc1 %s -O0 -fno-experimental-new-pass-manager -emit-llvm -triple x86_64-pc-win64 -o - | FileCheck %s --check-prefix=X86
|
|
|
3 // RUN: %clang_cc1 %s -O0 -fno-experimental-new-pass-manager -emit-llvm -triple i686-unknown-unknown -o - | FileCheck %s --check-prefix=X86
|
|
|
4 // RUN: %clang_cc1 %s -O0 -fno-experimental-new-pass-manager -emit-llvm -triple powerpc-unknown-unknown -o - | FileCheck %s --check-prefix=PPC
|
|
|
5 // RUN: %clang_cc1 %s -O0 -fno-experimental-new-pass-manager -emit-llvm -triple armv7-none-linux-gnueabi -o - | FileCheck %s --check-prefix=ARM
|
|
|
6 // RUN: %clang_cc1 %s -O0 -fno-experimental-new-pass-manager -emit-llvm -triple armv7-none-linux-gnueabihf -o - | FileCheck %s --check-prefix=ARMHF
|
|
|
7 // RUN: %clang_cc1 %s -O0 -fno-experimental-new-pass-manager -emit-llvm -triple thumbv7k-apple-watchos2.0 -o - -target-abi aapcs16 | FileCheck %s --check-prefix=ARM7K
|
|
207
|
8 // RUN: %clang_cc1 %s -O0 -fno-experimental-new-pass-manager -emit-llvm -triple aarch64-unknown-unknown -ffast-math -ffp-contract=fast -o - | FileCheck %s --check-prefix=AARCH64-FASTMATH
|
|
|
9 // RUN: %clang_cc1 %s -O0 -fno-experimental-new-pass-manager -emit-llvm -triple spir -o - | FileCheck %s --check-prefix=SPIR
|
|
150
|
10
|
|
|
11 float _Complex add_float_rr(float a, float b) {
|
|
|
12 // X86-LABEL: @add_float_rr(
|
|
|
13 // X86: fadd
|
|
|
14 // X86-NOT: fadd
|
|
|
15 // X86: ret
|
|
|
16 return a + b;
|
|
|
17 }
|
|
|
18 float _Complex add_float_cr(float _Complex a, float b) {
|
|
|
19 // X86-LABEL: @add_float_cr(
|
|
|
20 // X86: fadd
|
|
|
21 // X86-NOT: fadd
|
|
|
22 // X86: ret
|
|
|
23 return a + b;
|
|
|
24 }
|
|
|
25 float _Complex add_float_rc(float a, float _Complex b) {
|
|
|
26 // X86-LABEL: @add_float_rc(
|
|
|
27 // X86: fadd
|
|
|
28 // X86-NOT: fadd
|
|
|
29 // X86: ret
|
|
|
30 return a + b;
|
|
|
31 }
|
|
|
32 float _Complex add_float_cc(float _Complex a, float _Complex b) {
|
|
|
33 // X86-LABEL: @add_float_cc(
|
|
|
34 // X86: fadd
|
|
|
35 // X86: fadd
|
|
|
36 // X86-NOT: fadd
|
|
|
37 // X86: ret
|
|
|
38 return a + b;
|
|
|
39 }
|
|
|
40
|
|
|
41 float _Complex sub_float_rr(float a, float b) {
|
|
|
42 // X86-LABEL: @sub_float_rr(
|
|
|
43 // X86: fsub
|
|
|
44 // X86-NOT: fsub
|
|
|
45 // X86: ret
|
|
|
46 return a - b;
|
|
|
47 }
|
|
|
48 float _Complex sub_float_cr(float _Complex a, float b) {
|
|
|
49 // X86-LABEL: @sub_float_cr(
|
|
|
50 // X86: fsub
|
|
|
51 // X86-NOT: fsub
|
|
|
52 // X86: ret
|
|
|
53 return a - b;
|
|
|
54 }
|
|
|
55 float _Complex sub_float_rc(float a, float _Complex b) {
|
|
|
56 // X86-LABEL: @sub_float_rc(
|
|
|
57 // X86: fsub
|
|
|
58 // X86: fneg
|
|
|
59 // X86-NOT: fsub
|
|
|
60 // X86: ret
|
|
|
61 return a - b;
|
|
|
62 }
|
|
|
63 float _Complex sub_float_cc(float _Complex a, float _Complex b) {
|
|
|
64 // X86-LABEL: @sub_float_cc(
|
|
|
65 // X86: fsub
|
|
|
66 // X86: fsub
|
|
|
67 // X86-NOT: fsub
|
|
|
68 // X86: ret
|
|
|
69 return a - b;
|
|
|
70 }
|
|
|
71
|
|
|
72 float _Complex mul_float_rr(float a, float b) {
|
|
|
73 // X86-LABEL: @mul_float_rr(
|
|
|
74 // X86: fmul
|
|
|
75 // X86-NOT: fmul
|
|
|
76 // X86: ret
|
|
|
77 return a * b;
|
|
|
78 }
|
|
|
79 float _Complex mul_float_cr(float _Complex a, float b) {
|
|
|
80 // X86-LABEL: @mul_float_cr(
|
|
|
81 // X86: fmul
|
|
|
82 // X86: fmul
|
|
|
83 // X86-NOT: fmul
|
|
|
84 // X86: ret
|
|
|
85 return a * b;
|
|
|
86 }
|
|
|
87 float _Complex mul_float_rc(float a, float _Complex b) {
|
|
|
88 // X86-LABEL: @mul_float_rc(
|
|
|
89 // X86: fmul
|
|
|
90 // X86: fmul
|
|
|
91 // X86-NOT: fmul
|
|
|
92 // X86: ret
|
|
|
93 return a * b;
|
|
|
94 }
|
|
173
|
95
|
|
150
|
96 float _Complex mul_float_cc(float _Complex a, float _Complex b) {
|
|
|
97 // X86-LABEL: @mul_float_cc(
|
|
|
98 // X86: %[[AC:[^ ]+]] = fmul
|
|
|
99 // X86: %[[BD:[^ ]+]] = fmul
|
|
|
100 // X86: %[[AD:[^ ]+]] = fmul
|
|
|
101 // X86: %[[BC:[^ ]+]] = fmul
|
|
173
|
102 // X86: %[[RR:[^ ]+]] = fsub
|
|
|
103 // X86: %[[RI:[^ ]+]] = fadd
|
|
150
|
104 // X86-DAG: %[[AD]]
|
|
|
105 // X86-DAG: ,
|
|
|
106 // X86-DAG: %[[BC]]
|
|
|
107 // X86: fcmp uno float %[[RR]]
|
|
|
108 // X86: fcmp uno float %[[RI]]
|
|
|
109 // X86: call {{.*}} @__mulsc3(
|
|
|
110 // X86: ret
|
|
207
|
111 // SPIR: call spir_func {{.*}} @__mulsc3(
|
|
150
|
112 return a * b;
|
|
|
113 }
|
|
|
114
|
|
|
115 float _Complex div_float_rr(float a, float b) {
|
|
|
116 // X86-LABEL: @div_float_rr(
|
|
|
117 // X86: fdiv
|
|
|
118 // X86-NOT: fdiv
|
|
|
119 // X86: ret
|
|
|
120 return a / b;
|
|
|
121 }
|
|
|
122 float _Complex div_float_cr(float _Complex a, float b) {
|
|
|
123 // X86-LABEL: @div_float_cr(
|
|
|
124 // X86: fdiv
|
|
|
125 // X86: fdiv
|
|
|
126 // X86-NOT: fdiv
|
|
|
127 // X86: ret
|
|
|
128 return a / b;
|
|
|
129 }
|
|
|
130 float _Complex div_float_rc(float a, float _Complex b) {
|
|
|
131 // X86-LABEL: @div_float_rc(
|
|
|
132 // X86-NOT: fdiv
|
|
|
133 // X86: call {{.*}} @__divsc3(
|
|
|
134 // X86: ret
|
|
|
135
|
|
207
|
136 // SPIR: call spir_func {{.*}} @__divsc3(
|
|
|
137
|
|
150
|
138 // a / b = (A+iB) / (C+iD) = ((AC+BD)/(CC+DD)) + i((BC-AD)/(CC+DD))
|
|
|
139 // AARCH64-FASTMATH-LABEL: @div_float_rc(float %a, [2 x float] %b.coerce)
|
|
|
140 // A = a
|
|
|
141 // B = 0
|
|
|
142 //
|
|
173
|
143 // AARCH64-FASTMATH: [[AC:%.*]] = fmul fast float
|
|
150
|
144 // BD = 0
|
|
|
145 // ACpBD = AC
|
|
|
146 //
|
|
173
|
147 // AARCH64-FASTMATH: [[CC:%.*]] = fmul fast float
|
|
|
148 // AARCH64-FASTMATH: [[DD:%.*]] = fmul fast float
|
|
|
149 // AARCH64-FASTMATH: [[CCpDD:%.*]] = fadd fast float
|
|
150
|
150 //
|
|
|
151 // BC = 0
|
|
173
|
152 // AARCH64-FASTMATH: [[AD:%.*]] = fmul fast float
|
|
150
|
153 //
|
|
173
|
154 // AARCH64-FASTMATH: fdiv fast float
|
|
|
155 // AARCH64-FASTMATH: fdiv fast float
|
|
150
|
156 // AARCH64-FASTMATH: ret
|
|
|
157 return a / b;
|
|
|
158 }
|
|
|
159 float _Complex div_float_cc(float _Complex a, float _Complex b) {
|
|
|
160 // X86-LABEL: @div_float_cc(
|
|
|
161 // X86-NOT: fdiv
|
|
|
162 // X86: call {{.*}} @__divsc3(
|
|
|
163 // X86: ret
|
|
|
164
|
|
207
|
165 // SPIR: call spir_func {{.*}} @__divsc3(
|
|
|
166
|
|
150
|
167 // a / b = (A+iB) / (C+iD) = ((AC+BD)/(CC+DD)) + i((BC-AD)/(CC+DD))
|
|
|
168 // AARCH64-FASTMATH-LABEL: @div_float_cc([2 x float] %a.coerce, [2 x float] %b.coerce)
|
|
|
169 //
|
|
173
|
170 // AARCH64-FASTMATH: [[AC:%.*]] = fmul fast float
|
|
|
171 // AARCH64-FASTMATH: [[BD:%.*]] = fmul fast float
|
|
|
172 // AARCH64-FASTMATH: [[ACpBD:%.*]] = fadd fast float
|
|
150
|
173 //
|
|
173
|
174 // AARCH64-FASTMATH: [[CC:%.*]] = fmul fast float
|
|
|
175 // AARCH64-FASTMATH: [[DD:%.*]] = fmul fast float
|
|
|
176 // AARCH64-FASTMATH: [[CCpDD:%.*]] = fadd fast float
|
|
150
|
177 //
|
|
173
|
178 // AARCH64-FASTMATH: [[BC:%.*]] = fmul fast float
|
|
|
179 // AARCH64-FASTMATH: [[AD:%.*]] = fmul fast float
|
|
|
180 // AARCH64-FASTMATH: [[BCmAD:%.*]] = fsub fast float
|
|
150
|
181 //
|
|
173
|
182 // AARCH64-FASTMATH: fdiv fast float
|
|
|
183 // AARCH64-FASTMATH: fdiv fast float
|
|
150
|
184 // AARCH64-FASTMATH: ret
|
|
|
185 return a / b;
|
|
|
186 }
|
|
|
187
|
|
|
188 double _Complex add_double_rr(double a, double b) {
|
|
|
189 // X86-LABEL: @add_double_rr(
|
|
|
190 // X86: fadd
|
|
|
191 // X86-NOT: fadd
|
|
|
192 // X86: ret
|
|
|
193 return a + b;
|
|
|
194 }
|
|
|
195 double _Complex add_double_cr(double _Complex a, double b) {
|
|
|
196 // X86-LABEL: @add_double_cr(
|
|
|
197 // X86: fadd
|
|
|
198 // X86-NOT: fadd
|
|
|
199 // X86: ret
|
|
|
200 return a + b;
|
|
|
201 }
|
|
|
202 double _Complex add_double_rc(double a, double _Complex b) {
|
|
|
203 // X86-LABEL: @add_double_rc(
|
|
|
204 // X86: fadd
|
|
|
205 // X86-NOT: fadd
|
|
|
206 // X86: ret
|
|
|
207 return a + b;
|
|
|
208 }
|
|
|
209 double _Complex add_double_cc(double _Complex a, double _Complex b) {
|
|
|
210 // X86-LABEL: @add_double_cc(
|
|
|
211 // X86: fadd
|
|
|
212 // X86: fadd
|
|
|
213 // X86-NOT: fadd
|
|
|
214 // X86: ret
|
|
|
215 return a + b;
|
|
|
216 }
|
|
|
217
|
|
|
218 double _Complex sub_double_rr(double a, double b) {
|
|
|
219 // X86-LABEL: @sub_double_rr(
|
|
|
220 // X86: fsub
|
|
|
221 // X86-NOT: fsub
|
|
|
222 // X86: ret
|
|
|
223 return a - b;
|
|
|
224 }
|
|
|
225 double _Complex sub_double_cr(double _Complex a, double b) {
|
|
|
226 // X86-LABEL: @sub_double_cr(
|
|
|
227 // X86: fsub
|
|
|
228 // X86-NOT: fsub
|
|
|
229 // X86: ret
|
|
|
230 return a - b;
|
|
|
231 }
|
|
|
232 double _Complex sub_double_rc(double a, double _Complex b) {
|
|
|
233 // X86-LABEL: @sub_double_rc(
|
|
|
234 // X86: fsub
|
|
|
235 // X86: fneg
|
|
|
236 // X86-NOT: fsub
|
|
|
237 // X86: ret
|
|
|
238 return a - b;
|
|
|
239 }
|
|
|
240 double _Complex sub_double_cc(double _Complex a, double _Complex b) {
|
|
|
241 // X86-LABEL: @sub_double_cc(
|
|
|
242 // X86: fsub
|
|
|
243 // X86: fsub
|
|
|
244 // X86-NOT: fsub
|
|
|
245 // X86: ret
|
|
|
246 return a - b;
|
|
|
247 }
|
|
|
248
|
|
|
249 double _Complex mul_double_rr(double a, double b) {
|
|
|
250 // X86-LABEL: @mul_double_rr(
|
|
|
251 // X86: fmul
|
|
|
252 // X86-NOT: fmul
|
|
|
253 // X86: ret
|
|
|
254 return a * b;
|
|
|
255 }
|
|
|
256 double _Complex mul_double_cr(double _Complex a, double b) {
|
|
|
257 // X86-LABEL: @mul_double_cr(
|
|
|
258 // X86: fmul
|
|
|
259 // X86: fmul
|
|
|
260 // X86-NOT: fmul
|
|
|
261 // X86: ret
|
|
|
262 return a * b;
|
|
|
263 }
|
|
|
264 double _Complex mul_double_rc(double a, double _Complex b) {
|
|
|
265 // X86-LABEL: @mul_double_rc(
|
|
|
266 // X86: fmul
|
|
|
267 // X86: fmul
|
|
|
268 // X86-NOT: fmul
|
|
|
269 // X86: ret
|
|
|
270 return a * b;
|
|
|
271 }
|
|
|
272 double _Complex mul_double_cc(double _Complex a, double _Complex b) {
|
|
|
273 // X86-LABEL: @mul_double_cc(
|
|
|
274 // X86: %[[AC:[^ ]+]] = fmul
|
|
|
275 // X86: %[[BD:[^ ]+]] = fmul
|
|
|
276 // X86: %[[AD:[^ ]+]] = fmul
|
|
|
277 // X86: %[[BC:[^ ]+]] = fmul
|
|
|
278 // X86: %[[RR:[^ ]+]] = fsub double %[[AC]], %[[BD]]
|
|
|
279 // X86: %[[RI:[^ ]+]] = fadd double
|
|
|
280 // X86-DAG: %[[AD]]
|
|
|
281 // X86-DAG: ,
|
|
|
282 // X86-DAG: %[[BC]]
|
|
|
283 // X86: fcmp uno double %[[RR]]
|
|
|
284 // X86: fcmp uno double %[[RI]]
|
|
|
285 // X86: call {{.*}} @__muldc3(
|
|
|
286 // X86: ret
|
|
207
|
287
|
|
|
288 // SPIR: call spir_func {{.*}} @__muldc3(
|
|
150
|
289 return a * b;
|
|
|
290 }
|
|
|
291
|
|
|
292 double _Complex div_double_rr(double a, double b) {
|
|
|
293 // X86-LABEL: @div_double_rr(
|
|
|
294 // X86: fdiv
|
|
|
295 // X86-NOT: fdiv
|
|
|
296 // X86: ret
|
|
|
297 return a / b;
|
|
|
298 }
|
|
|
299 double _Complex div_double_cr(double _Complex a, double b) {
|
|
|
300 // X86-LABEL: @div_double_cr(
|
|
|
301 // X86: fdiv
|
|
|
302 // X86: fdiv
|
|
|
303 // X86-NOT: fdiv
|
|
|
304 // X86: ret
|
|
|
305 return a / b;
|
|
|
306 }
|
|
|
307 double _Complex div_double_rc(double a, double _Complex b) {
|
|
|
308 // X86-LABEL: @div_double_rc(
|
|
|
309 // X86-NOT: fdiv
|
|
|
310 // X86: call {{.*}} @__divdc3(
|
|
|
311 // X86: ret
|
|
|
312
|
|
207
|
313 // SPIR: call spir_func {{.*}} @__divdc3(
|
|
|
314
|
|
150
|
315 // a / b = (A+iB) / (C+iD) = ((AC+BD)/(CC+DD)) + i((BC-AD)/(CC+DD))
|
|
|
316 // AARCH64-FASTMATH-LABEL: @div_double_rc(double %a, [2 x double] %b.coerce)
|
|
|
317 // A = a
|
|
|
318 // B = 0
|
|
|
319 //
|
|
173
|
320 // AARCH64-FASTMATH: [[AC:%.*]] = fmul fast double
|
|
150
|
321 // BD = 0
|
|
|
322 // ACpBD = AC
|
|
|
323 //
|
|
173
|
324 // AARCH64-FASTMATH: [[CC:%.*]] = fmul fast double
|
|
|
325 // AARCH64-FASTMATH: [[DD:%.*]] = fmul fast double
|
|
|
326 // AARCH64-FASTMATH: [[CCpDD:%.*]] = fadd fast double
|
|
150
|
327 //
|
|
|
328 // BC = 0
|
|
173
|
329 // AARCH64-FASTMATH: [[AD:%.*]] = fmul fast double
|
|
150
|
330 //
|
|
173
|
331 // AARCH64-FASTMATH: fdiv fast double
|
|
|
332 // AARCH64-FASTMATH: fdiv fast double
|
|
150
|
333 // AARCH64-FASTMATH: ret
|
|
|
334 return a / b;
|
|
|
335 }
|
|
|
336 double _Complex div_double_cc(double _Complex a, double _Complex b) {
|
|
|
337 // X86-LABEL: @div_double_cc(
|
|
|
338 // X86-NOT: fdiv
|
|
|
339 // X86: call {{.*}} @__divdc3(
|
|
|
340 // X86: ret
|
|
|
341
|
|
207
|
342 // SPIR: call spir_func {{.*}} @__divdc3(
|
|
|
343
|
|
150
|
344 // a / b = (A+iB) / (C+iD) = ((AC+BD)/(CC+DD)) + i((BC-AD)/(CC+DD))
|
|
|
345 // AARCH64-FASTMATH-LABEL: @div_double_cc([2 x double] %a.coerce, [2 x double] %b.coerce)
|
|
|
346 //
|
|
173
|
347 // AARCH64-FASTMATH: [[AC:%.*]] = fmul fast double
|
|
|
348 // AARCH64-FASTMATH: [[BD:%.*]] = fmul fast double
|
|
|
349 // AARCH64-FASTMATH: [[ACpBD:%.*]] = fadd fast double
|
|
150
|
350 //
|
|
173
|
351 // AARCH64-FASTMATH: [[CC:%.*]] = fmul fast double
|
|
|
352 // AARCH64-FASTMATH: [[DD:%.*]] = fmul fast double
|
|
|
353 // AARCH64-FASTMATH: [[CCpDD:%.*]] = fadd fast double
|
|
150
|
354 //
|
|
173
|
355 // AARCH64-FASTMATH: [[BC:%.*]] = fmul fast double
|
|
|
356 // AARCH64-FASTMATH: [[AD:%.*]] = fmul fast double
|
|
|
357 // AARCH64-FASTMATH: [[BCmAD:%.*]] = fsub fast double
|
|
150
|
358 //
|
|
173
|
359 // AARCH64-FASTMATH: fdiv fast double
|
|
|
360 // AARCH64-FASTMATH: fdiv fast double
|
|
150
|
361 // AARCH64-FASTMATH: ret
|
|
|
362 return a / b;
|
|
|
363 }
|
|
|
364
|
|
|
365 long double _Complex add_long_double_rr(long double a, long double b) {
|
|
|
366 // X86-LABEL: @add_long_double_rr(
|
|
|
367 // X86: fadd
|
|
|
368 // X86-NOT: fadd
|
|
|
369 // X86: ret
|
|
|
370 return a + b;
|
|
|
371 }
|
|
|
372 long double _Complex add_long_double_cr(long double _Complex a, long double b) {
|
|
|
373 // X86-LABEL: @add_long_double_cr(
|
|
|
374 // X86: fadd
|
|
|
375 // X86-NOT: fadd
|
|
|
376 // X86: ret
|
|
|
377 return a + b;
|
|
|
378 }
|
|
|
379 long double _Complex add_long_double_rc(long double a, long double _Complex b) {
|
|
|
380 // X86-LABEL: @add_long_double_rc(
|
|
|
381 // X86: fadd
|
|
|
382 // X86-NOT: fadd
|
|
|
383 // X86: ret
|
|
|
384 return a + b;
|
|
|
385 }
|
|
|
386 long double _Complex add_long_double_cc(long double _Complex a, long double _Complex b) {
|
|
|
387 // X86-LABEL: @add_long_double_cc(
|
|
|
388 // X86: fadd
|
|
|
389 // X86: fadd
|
|
|
390 // X86-NOT: fadd
|
|
|
391 // X86: ret
|
|
|
392 return a + b;
|
|
|
393 }
|
|
|
394
|
|
|
395 long double _Complex sub_long_double_rr(long double a, long double b) {
|
|
|
396 // X86-LABEL: @sub_long_double_rr(
|
|
|
397 // X86: fsub
|
|
|
398 // X86-NOT: fsub
|
|
|
399 // X86: ret
|
|
|
400 return a - b;
|
|
|
401 }
|
|
|
402 long double _Complex sub_long_double_cr(long double _Complex a, long double b) {
|
|
|
403 // X86-LABEL: @sub_long_double_cr(
|
|
|
404 // X86: fsub
|
|
|
405 // X86-NOT: fsub
|
|
|
406 // X86: ret
|
|
|
407 return a - b;
|
|
|
408 }
|
|
|
409 long double _Complex sub_long_double_rc(long double a, long double _Complex b) {
|
|
|
410 // X86-LABEL: @sub_long_double_rc(
|
|
|
411 // X86: fsub
|
|
|
412 // X86: fneg
|
|
|
413 // X86-NOT: fsub
|
|
|
414 // X86: ret
|
|
|
415 return a - b;
|
|
|
416 }
|
|
|
417 long double _Complex sub_long_double_cc(long double _Complex a, long double _Complex b) {
|
|
|
418 // X86-LABEL: @sub_long_double_cc(
|
|
|
419 // X86: fsub
|
|
|
420 // X86: fsub
|
|
|
421 // X86-NOT: fsub
|
|
|
422 // X86: ret
|
|
|
423 return a - b;
|
|
|
424 }
|
|
|
425
|
|
|
426 long double _Complex mul_long_double_rr(long double a, long double b) {
|
|
|
427 // X86-LABEL: @mul_long_double_rr(
|
|
|
428 // X86: fmul
|
|
|
429 // X86-NOT: fmul
|
|
|
430 // X86: ret
|
|
|
431 return a * b;
|
|
|
432 }
|
|
|
433 long double _Complex mul_long_double_cr(long double _Complex a, long double b) {
|
|
|
434 // X86-LABEL: @mul_long_double_cr(
|
|
|
435 // X86: fmul
|
|
|
436 // X86: fmul
|
|
|
437 // X86-NOT: fmul
|
|
|
438 // X86: ret
|
|
|
439 return a * b;
|
|
|
440 }
|
|
|
441 long double _Complex mul_long_double_rc(long double a, long double _Complex b) {
|
|
|
442 // X86-LABEL: @mul_long_double_rc(
|
|
|
443 // X86: fmul
|
|
|
444 // X86: fmul
|
|
|
445 // X86-NOT: fmul
|
|
|
446 // X86: ret
|
|
|
447 return a * b;
|
|
|
448 }
|
|
|
449 long double _Complex mul_long_double_cc(long double _Complex a, long double _Complex b) {
|
|
|
450 // X86-LABEL: @mul_long_double_cc(
|
|
|
451 // X86: %[[AC:[^ ]+]] = fmul
|
|
|
452 // X86: %[[BD:[^ ]+]] = fmul
|
|
|
453 // X86: %[[AD:[^ ]+]] = fmul
|
|
|
454 // X86: %[[BC:[^ ]+]] = fmul
|
|
|
455 // X86: %[[RR:[^ ]+]] = fsub x86_fp80 %[[AC]], %[[BD]]
|
|
|
456 // X86: %[[RI:[^ ]+]] = fadd x86_fp80
|
|
|
457 // X86-DAG: %[[AD]]
|
|
|
458 // X86-DAG: ,
|
|
|
459 // X86-DAG: %[[BC]]
|
|
|
460 // X86: fcmp uno x86_fp80 %[[RR]]
|
|
|
461 // X86: fcmp uno x86_fp80 %[[RI]]
|
|
|
462 // X86: call {{.*}} @__mulxc3(
|
|
|
463 // X86: ret
|
|
|
464 // PPC-LABEL: @mul_long_double_cc(
|
|
|
465 // PPC: %[[AC:[^ ]+]] = fmul
|
|
|
466 // PPC: %[[BD:[^ ]+]] = fmul
|
|
|
467 // PPC: %[[AD:[^ ]+]] = fmul
|
|
|
468 // PPC: %[[BC:[^ ]+]] = fmul
|
|
|
469 // PPC: %[[RR:[^ ]+]] = fsub ppc_fp128 %[[AC]], %[[BD]]
|
|
|
470 // PPC: %[[RI:[^ ]+]] = fadd ppc_fp128
|
|
|
471 // PPC-DAG: %[[AD]]
|
|
|
472 // PPC-DAG: ,
|
|
|
473 // PPC-DAG: %[[BC]]
|
|
|
474 // PPC: fcmp uno ppc_fp128 %[[RR]]
|
|
|
475 // PPC: fcmp uno ppc_fp128 %[[RI]]
|
|
|
476 // PPC: call {{.*}} @__multc3(
|
|
|
477 // PPC: ret
|
|
207
|
478 // SPIR: call spir_func {{.*}} @__muldc3(
|
|
150
|
479 return a * b;
|
|
|
480 }
|
|
|
481
|
|
|
482 long double _Complex div_long_double_rr(long double a, long double b) {
|
|
|
483 // X86-LABEL: @div_long_double_rr(
|
|
|
484 // X86: fdiv
|
|
|
485 // X86-NOT: fdiv
|
|
|
486 // X86: ret
|
|
|
487 return a / b;
|
|
|
488 }
|
|
|
489 long double _Complex div_long_double_cr(long double _Complex a, long double b) {
|
|
|
490 // X86-LABEL: @div_long_double_cr(
|
|
|
491 // X86: fdiv
|
|
|
492 // X86: fdiv
|
|
|
493 // X86-NOT: fdiv
|
|
|
494 // X86: ret
|
|
|
495 return a / b;
|
|
|
496 }
|
|
|
497 long double _Complex div_long_double_rc(long double a, long double _Complex b) {
|
|
|
498 // X86-LABEL: @div_long_double_rc(
|
|
|
499 // X86-NOT: fdiv
|
|
|
500 // X86: call {{.*}} @__divxc3(
|
|
|
501 // X86: ret
|
|
|
502 // PPC-LABEL: @div_long_double_rc(
|
|
|
503 // PPC-NOT: fdiv
|
|
|
504 // PPC: call {{.*}} @__divtc3(
|
|
|
505 // PPC: ret
|
|
207
|
506 // SPIR: call spir_func {{.*}} @__divdc3(
|
|
150
|
507
|
|
|
508 // a / b = (A+iB) / (C+iD) = ((AC+BD)/(CC+DD)) + i((BC-AD)/(CC+DD))
|
|
|
509 // AARCH64-FASTMATH-LABEL: @div_long_double_rc(fp128 %a, [2 x fp128] %b.coerce)
|
|
|
510 // A = a
|
|
|
511 // B = 0
|
|
|
512 //
|
|
173
|
513 // AARCH64-FASTMATH: [[AC:%.*]] = fmul fast fp128
|
|
150
|
514 // BD = 0
|
|
|
515 // ACpBD = AC
|
|
|
516 //
|
|
173
|
517 // AARCH64-FASTMATH: [[CC:%.*]] = fmul fast fp128
|
|
|
518 // AARCH64-FASTMATH: [[DD:%.*]] = fmul fast fp128
|
|
|
519 // AARCH64-FASTMATH: [[CCpDD:%.*]] = fadd fast fp128
|
|
150
|
520 //
|
|
|
521 // BC = 0
|
|
173
|
522 // AARCH64-FASTMATH: [[AD:%.*]] = fmul fast fp128
|
|
150
|
523 //
|
|
173
|
524 // AARCH64-FASTMATH: fdiv fast fp128
|
|
|
525 // AARCH64-FASTMATH: fdiv fast fp128
|
|
150
|
526 // AARCH64-FASTMATH: ret
|
|
|
527 return a / b;
|
|
|
528 }
|
|
|
529 long double _Complex div_long_double_cc(long double _Complex a, long double _Complex b) {
|
|
|
530 // X86-LABEL: @div_long_double_cc(
|
|
|
531 // X86-NOT: fdiv
|
|
|
532 // X86: call {{.*}} @__divxc3(
|
|
|
533 // X86: ret
|
|
|
534 // PPC-LABEL: @div_long_double_cc(
|
|
|
535 // PPC-NOT: fdiv
|
|
|
536 // PPC: call {{.*}} @__divtc3(
|
|
|
537 // PPC: ret
|
|
207
|
538 // SPIR: call spir_func {{.*}} @__divdc3(
|
|
150
|
539
|
|
|
540 // a / b = (A+iB) / (C+iD) = ((AC+BD)/(CC+DD)) + i((BC-AD)/(CC+DD))
|
|
|
541 // AARCH64-FASTMATH-LABEL: @div_long_double_cc([2 x fp128] %a.coerce, [2 x fp128] %b.coerce)
|
|
|
542 //
|
|
173
|
543 // AARCH64-FASTMATH: [[AC:%.*]] = fmul fast fp128
|
|
|
544 // AARCH64-FASTMATH: [[BD:%.*]] = fmul fast fp128
|
|
|
545 // AARCH64-FASTMATH: [[ACpBD:%.*]] = fadd fast fp128
|
|
150
|
546 //
|
|
173
|
547 // AARCH64-FASTMATH: [[CC:%.*]] = fmul fast fp128
|
|
|
548 // AARCH64-FASTMATH: [[DD:%.*]] = fmul fast fp128
|
|
|
549 // AARCH64-FASTMATH: [[CCpDD:%.*]] = fadd fast fp128
|
|
150
|
550 //
|
|
173
|
551 // AARCH64-FASTMATH: [[BC:%.*]] = fmul fast fp128
|
|
|
552 // AARCH64-FASTMATH: [[AD:%.*]] = fmul fast fp128
|
|
|
553 // AARCH64-FASTMATH: [[BCmAD:%.*]] = fsub fast fp128
|
|
150
|
554 //
|
|
173
|
555 // AARCH64-FASTMATH: fdiv fast fp128
|
|
|
556 // AARCH64-FASTMATH: fdiv fast fp128
|
|
150
|
557 // AARCH64-FASTMATH: ret
|
|
|
558 return a / b;
|
|
|
559 }
|
|
|
560
|
|
|
561 // Comparison operators don't rely on library calls or have interseting math
|
|
|
562 // properties, but test that mixed types work correctly here.
|
|
|
563 _Bool eq_float_cr(float _Complex a, float b) {
|
|
|
564 // X86-LABEL: @eq_float_cr(
|
|
|
565 // X86: fcmp oeq
|
|
|
566 // X86: fcmp oeq
|
|
|
567 // X86: and i1
|
|
|
568 // X86: ret
|
|
|
569 return a == b;
|
|
|
570 }
|
|
|
571 _Bool eq_float_rc(float a, float _Complex b) {
|
|
|
572 // X86-LABEL: @eq_float_rc(
|
|
|
573 // X86: fcmp oeq
|
|
|
574 // X86: fcmp oeq
|
|
|
575 // X86: and i1
|
|
|
576 // X86: ret
|
|
|
577 return a == b;
|
|
|
578 }
|
|
|
579 _Bool eq_float_cc(float _Complex a, float _Complex b) {
|
|
|
580 // X86-LABEL: @eq_float_cc(
|
|
|
581 // X86: fcmp oeq
|
|
|
582 // X86: fcmp oeq
|
|
|
583 // X86: and i1
|
|
|
584 // X86: ret
|
|
|
585 return a == b;
|
|
|
586 }
|
|
|
587 _Bool ne_float_cr(float _Complex a, float b) {
|
|
|
588 // X86-LABEL: @ne_float_cr(
|
|
|
589 // X86: fcmp une
|
|
|
590 // X86: fcmp une
|
|
|
591 // X86: or i1
|
|
|
592 // X86: ret
|
|
|
593 return a != b;
|
|
|
594 }
|
|
|
595 _Bool ne_float_rc(float a, float _Complex b) {
|
|
|
596 // X86-LABEL: @ne_float_rc(
|
|
|
597 // X86: fcmp une
|
|
|
598 // X86: fcmp une
|
|
|
599 // X86: or i1
|
|
|
600 // X86: ret
|
|
|
601 return a != b;
|
|
|
602 }
|
|
|
603 _Bool ne_float_cc(float _Complex a, float _Complex b) {
|
|
|
604 // X86-LABEL: @ne_float_cc(
|
|
|
605 // X86: fcmp une
|
|
|
606 // X86: fcmp une
|
|
|
607 // X86: or i1
|
|
|
608 // X86: ret
|
|
|
609 return a != b;
|
|
|
610 }
|
|
|
611
|
|
|
612 // Check that the libcall will obtain proper calling convention on ARM
|
|
|
613 _Complex double foo(_Complex double a, _Complex double b) {
|
|
|
614 // These functions are not defined as floating point helper functions in
|
|
|
615 // Run-time ABI for the ARM architecture document so they must not always
|
|
|
616 // use the base AAPCS.
|
|
|
617
|
|
|
618 // ARM-LABEL: @foo(
|
|
|
619 // ARM: call void @__muldc3
|
|
|
620
|
|
207
|
621 // SPIR: call spir_func void @__muldc3
|
|
|
622
|
|
150
|
623 // ARMHF-LABEL: @foo(
|
|
|
624 // ARMHF: call { double, double } @__muldc3
|
|
|
625
|
|
|
626 // ARM7K-LABEL: @foo(
|
|
|
627 // ARM7K: call { double, double } @__muldc3
|
|
|
628 return a*b;
|
|
|
629 }
|
