1 ; RUN: opt < %s -instcombine -S | FileCheck %s
3 ; testing-case "float fold(float a) { return 1.2f * a * 2.3f; }"
4 ; 1.2f and 2.3f is supposed to be fold.
5 define float @fold(float %a) {
6 %mul = fmul fast float %a, 0x3FF3333340000000
7 %mul1 = fmul fast float %mul, 0x4002666660000000
10 ; CHECK: fmul fast float %a, 0x4006147AE0000000
13 ; Same testing-case as the one used in fold() except that the operators have
15 define float @notfold(float %a) {
16 ; CHECK-LABEL: @notfold(
17 ; CHECK: %mul = fmul fast float %a, 0x3FF3333340000000
18 %mul = fmul fast float %a, 0x3FF3333340000000
19 %mul1 = fmul float %mul, 0x4002666660000000
23 define float @fold2(float %a) {
24 ; CHECK-LABEL: @fold2(
25 ; CHECK: fmul fast float %a, 0x4006147AE0000000
26 %mul = fmul float %a, 0x3FF3333340000000
27 %mul1 = fmul fast float %mul, 0x4002666660000000
31 ; C * f1 + f1 = (C+1) * f1
32 define double @fold3(double %f1) {
33 %t1 = fmul fast double 2.000000e+00, %f1
34 %t2 = fadd fast double %f1, %t1
36 ; CHECK-LABEL: @fold3(
37 ; CHECK: fmul fast double %f1, 3.000000e+00
40 ; (C1 - X) + (C2 - Y) => (C1+C2) - (X + Y)
41 define float @fold4(float %f1, float %f2) {
42 %sub = fsub float 4.000000e+00, %f1
43 %sub1 = fsub float 5.000000e+00, %f2
44 %add = fadd fast float %sub, %sub1
46 ; CHECK-LABEL: @fold4(
47 ; CHECK: %1 = fadd fast float %f1, %f2
48 ; CHECK: fsub fast float 9.000000e+00, %1
51 ; (X + C1) + C2 => X + (C1 + C2)
52 define float @fold5(float %f1, float %f2) {
53 %add = fadd float %f1, 4.000000e+00
54 %add1 = fadd fast float %add, 5.000000e+00
56 ; CHECK-LABEL: @fold5(
57 ; CHECK: fadd fast float %f1, 9.000000e+00
60 ; (X + X) + X => 3.0 * X
61 define float @fold6(float %f1) {
62 %t1 = fadd fast float %f1, %f1
63 %t2 = fadd fast float %f1, %t1
65 ; CHECK-LABEL: @fold6(
66 ; CHECK: fmul fast float %f1, 3.000000e+00
69 ; C1 * X + (X + X) = (C1 + 2) * X
70 define float @fold7(float %f1) {
71 %t1 = fmul fast float %f1, 5.000000e+00
72 %t2 = fadd fast float %f1, %f1
73 %t3 = fadd fast float %t1, %t2
75 ; CHECK-LABEL: @fold7(
76 ; CHECK: fmul fast float %f1, 7.000000e+00
79 ; (X + X) + (X + X) => 4.0 * X
80 define float @fold8(float %f1) {
81 %t1 = fadd fast float %f1, %f1
82 %t2 = fadd fast float %f1, %f1
83 %t3 = fadd fast float %t1, %t2
86 ; CHECK: fmul fast float %f1, 4.000000e+00
89 ; X - (X + Y) => 0 - Y
90 define float @fold9(float %f1, float %f2) {
91 %t1 = fadd float %f1, %f2
92 %t3 = fsub fast float %f1, %t1
95 ; CHECK-LABEL: @fold9(
96 ; CHECK: fsub fast float -0.000000e+00, %f2
99 ; Let C3 = C1 + C2. (f1 + C1) + (f2 + C2) => (f1 + f2) + C3 instead of
100 ; "(f1 + C3) + f2" or "(f2 + C3) + f1". Placing constant-addend at the
101 ; top of resulting simplified expression tree may potentially reveal some
102 ; optimization opportunities in the super-expression trees.
104 define float @fold10(float %f1, float %f2) {
105 %t1 = fadd fast float 2.000000e+00, %f1
106 %t2 = fsub fast float %f2, 3.000000e+00
107 %t3 = fadd fast float %t1, %t2
109 ; CHECK-LABEL: @fold10(
110 ; CHECK: %t3 = fadd fast float %t2, -1.000000e+00
111 ; CHECK: ret float %t3
114 ; once cause Crash/miscompilation
115 define float @fail1(float %f1, float %f2) {
116 %conv3 = fadd fast float %f1, -1.000000e+00
117 %add = fadd fast float %conv3, %conv3
118 %add2 = fadd fast float %add, %conv3
120 ; CHECK-LABEL: @fail1(
124 define double @fail2(double %f1, double %f2) {
125 %t1 = fsub fast double %f1, %f2
126 %t2 = fadd fast double %f1, %f2
127 %t3 = fsub fast double %t1, %t2
129 ; CHECK-LABEL: @fail2(
133 ; c1 * x - x => (c1 - 1.0) * x
134 define float @fold13(float %x) {
135 %mul = fmul fast float %x, 7.000000e+00
136 %sub = fsub fast float %mul, %x
139 ; CHECK: fmul fast float %x, 6.000000e+00
144 define float @fold14(float %x, float %y) {
145 %neg = fsub fast float -0.0, %x
146 %add = fadd fast float %neg, %y
149 ; CHECK: fsub fast float %y, %x
154 define float @fold15(float %x, float %y) {
155 %neg = fsub fast float -0.0, %y
156 %add = fadd fast float %x, %neg
159 ; CHECK: fsub fast float %x, %y
163 ; (select X+Y, X-Y) => X + (select Y, -Y)
164 define float @fold16(float %x, float %y) {
165 %cmp = fcmp ogt float %x, %y
166 %plus = fadd fast float %x, %y
167 %minus = fsub fast float %x, %y
168 %r = select i1 %cmp, float %plus, float %minus
171 ; CHECK: fsub fast float
173 ; CHECK: fadd fast float
179 ; =========================================================================
181 ; Testing-cases about fmul begin
183 ; =========================================================================
185 ; ((X*C1) + C2) * C3 => (X * (C1*C3)) + (C2*C3) (i.e. distribution)
186 define float @fmul_distribute1(float %f1) {
187 %t1 = fmul float %f1, 6.0e+3
188 %t2 = fadd float %t1, 2.0e+3
189 %t3 = fmul fast float %t2, 5.0e+3
191 ; CHECK-LABEL: @fmul_distribute1(
192 ; CHECK: %1 = fmul fast float %f1, 3.000000e+07
193 ; CHECK: %t3 = fadd fast float %1, 1.000000e+07
196 ; (X/C1 + C2) * C3 => X/(C1/C3) + C2*C3
197 define double @fmul_distribute2(double %f1, double %f2) {
198 %t1 = fdiv double %f1, 3.0e+0
199 %t2 = fadd double %t1, 5.0e+1
200 ; 0x10000000000000 = DBL_MIN
201 %t3 = fmul fast double %t2, 0x10000000000000
204 ; CHECK-LABEL: @fmul_distribute2(
205 ; CHECK: %1 = fdiv fast double %f1, 0x7FE8000000000000
206 ; CHECK: fadd fast double %1, 0x69000000000000
209 ; 5.0e-1 * DBL_MIN yields denormal, so "(f1*3.0 + 5.0e-1) * DBL_MIN" cannot
210 ; be simplified into f1 * (3.0*DBL_MIN) + (5.0e-1*DBL_MIN)
211 define double @fmul_distribute3(double %f1) {
212 %t1 = fdiv double %f1, 3.0e+0
213 %t2 = fadd double %t1, 5.0e-1
214 %t3 = fmul fast double %t2, 0x10000000000000
217 ; CHECK-LABEL: @fmul_distribute3(
218 ; CHECK: fmul fast double %t2, 0x10000000000000
221 ; ((X*C1) + C2) * C3 => (X * (C1*C3)) + (C2*C3) (i.e. distribution)
222 define float @fmul_distribute4(float %f1) {
223 %t1 = fmul float %f1, 6.0e+3
224 %t2 = fsub float 2.0e+3, %t1
225 %t3 = fmul fast float %t2, 5.0e+3
227 ; CHECK-LABEL: @fmul_distribute4(
228 ; CHECK: %1 = fmul fast float %f1, 3.000000e+07
229 ; CHECK: %t3 = fsub fast float 1.000000e+07, %1
232 ; C1/X * C2 => (C1*C2) / X
233 define float @fmul2(float %f1) {
234 %t1 = fdiv float 2.0e+3, %f1
235 %t3 = fmul fast float %t1, 6.0e+3
237 ; CHECK-LABEL: @fmul2(
238 ; CHECK: fdiv fast float 1.200000e+07, %f1
241 ; X/C1 * C2 => X * (C2/C1) is disabled if X/C1 has multiple uses
242 @fmul2_external = external global float
243 define float @fmul2_disable(float %f1) {
244 %div = fdiv fast float 1.000000e+00, %f1
245 store float %div, float* @fmul2_external
246 %mul = fmul fast float %div, 2.000000e+00
248 ; CHECK-LABEL: @fmul2_disable
253 ; X/C1 * C2 => X * (C2/C1) (if C2/C1 is normal Fp)
254 define float @fmul3(float %f1, float %f2) {
255 %t1 = fdiv float %f1, 2.0e+3
256 %t3 = fmul fast float %t1, 6.0e+3
258 ; CHECK-LABEL: @fmul3(
259 ; CHECK: fmul fast float %f1, 3.000000e+00
262 define <4 x float> @fmul3_vec(<4 x float> %f1, <4 x float> %f2) {
263 %t1 = fdiv <4 x float> %f1, <float 2.0e+3, float 3.0e+3, float 2.0e+3, float 1.0e+3>
264 %t3 = fmul fast <4 x float> %t1, <float 6.0e+3, float 6.0e+3, float 2.0e+3, float 1.0e+3>
266 ; CHECK-LABEL: @fmul3_vec(
267 ; CHECK: fmul fast <4 x float> %f1, <float 3.000000e+00, float 2.000000e+00, float 1.000000e+00, float 1.000000e+00>
270 ; Make sure fmul with constant expression doesn't assert.
271 define <4 x float> @fmul3_vec_constexpr(<4 x float> %f1, <4 x float> %f2) {
272 %constExprMul = bitcast i128 trunc (i160 bitcast (<5 x float> <float 6.0e+3, float 6.0e+3, float 2.0e+3, float 1.0e+3, float undef> to i160) to i128) to <4 x float>
273 %t1 = fdiv <4 x float> %f1, <float 2.0e+3, float 3.0e+3, float 2.0e+3, float 1.0e+3>
274 %t3 = fmul fast <4 x float> %t1, %constExprMul
278 ; Rule "X/C1 * C2 => X * (C2/C1) is not applicable if C2/C1 is either a special
279 ; value of a denormal. The 0x3810000000000000 here take value FLT_MIN
281 define float @fmul4(float %f1, float %f2) {
282 %t1 = fdiv float %f1, 2.0e+3
283 %t3 = fmul fast float %t1, 0x3810000000000000
285 ; CHECK-LABEL: @fmul4(
286 ; CHECK: fmul fast float %t1, 0x3810000000000000
289 ; X / C1 * C2 => X / (C2/C1) if C1/C2 is either a special value of a denormal,
290 ; and C2/C1 is a normal value.
292 define float @fmul5(float %f1, float %f2) {
293 %t1 = fdiv float %f1, 3.0e+0
294 %t3 = fmul fast float %t1, 0x3810000000000000
296 ; CHECK-LABEL: @fmul5(
297 ; CHECK: fdiv fast float %f1, 0x47E8000000000000
300 ; (X*Y) * X => (X*X) * Y
301 define float @fmul6(float %f1, float %f2) {
302 %mul = fmul float %f1, %f2
303 %mul1 = fmul fast float %mul, %f1
305 ; CHECK-LABEL: @fmul6(
306 ; CHECK: fmul fast float %f1, %f1
309 ; "(X*Y) * X => (X*X) * Y" is disabled if "X*Y" has multiple uses
310 define float @fmul7(float %f1, float %f2) {
311 %mul = fmul float %f1, %f2
312 %mul1 = fmul fast float %mul, %f1
313 %add = fadd float %mul1, %mul
315 ; CHECK-LABEL: @fmul7(
316 ; CHECK: fmul fast float %mul, %f1
319 ; =========================================================================
321 ; Testing-cases about negation
323 ; =========================================================================
324 define float @fneg1(float %f1, float %f2) {
325 %sub = fsub float -0.000000e+00, %f1
326 %sub1 = fsub nsz float 0.000000e+00, %f2
327 %mul = fmul float %sub, %sub1
329 ; CHECK-LABEL: @fneg1(
330 ; CHECK: fmul float %f1, %f2
333 define float @fneg2(float %x) {
334 %sub = fsub nsz float 0.0, %x
336 ; CHECK-LABEL: @fneg2(
337 ; CHECK-NEXT: fsub nsz float -0.000000e+00, %x
338 ; CHECK-NEXT: ret float
341 ; =========================================================================
343 ; Testing-cases about div
345 ; =========================================================================
347 ; X/C1 / C2 => X * (1/(C2*C1))
348 define float @fdiv1(float %x) {
349 %div = fdiv float %x, 0x3FF3333340000000
350 %div1 = fdiv fast float %div, 0x4002666660000000
352 ; 0x3FF3333340000000 = 1.2f
353 ; 0x4002666660000000 = 2.3f
354 ; 0x3FD7303B60000000 = 0.36231884057971014492
355 ; CHECK-LABEL: @fdiv1(
356 ; CHECK: fmul fast float %x, 0x3FD7303B60000000
359 ; X*C1 / C2 => X * (C1/C2)
360 define float @fdiv2(float %x) {
361 %mul = fmul float %x, 0x3FF3333340000000
362 %div1 = fdiv fast float %mul, 0x4002666660000000
365 ; 0x3FF3333340000000 = 1.2f
366 ; 0x4002666660000000 = 2.3f
367 ; 0x3FE0B21660000000 = 0.52173918485641479492
368 ; CHECK-LABEL: @fdiv2(
369 ; CHECK: fmul fast float %x, 0x3FE0B21660000000
372 define <2 x float> @fdiv2_vec(<2 x float> %x) {
373 %mul = fmul <2 x float> %x, <float 6.0, float 9.0>
374 %div1 = fdiv fast <2 x float> %mul, <float 2.0, float 3.0>
375 ret <2 x float> %div1
377 ; CHECK-LABEL: @fdiv2_vec(
378 ; CHECK: fmul fast <2 x float> %x, <float 3.000000e+00, float 3.000000e+00>
381 ; "X/C1 / C2 => X * (1/(C2*C1))" is disabled (for now) is C2/C1 is a denormal
383 define float @fdiv3(float %x) {
384 %div = fdiv float %x, 0x47EFFFFFE0000000
385 %div1 = fdiv fast float %div, 0x4002666660000000
387 ; CHECK-LABEL: @fdiv3(
388 ; CHECK: fdiv float %x, 0x47EFFFFFE0000000
391 ; "X*C1 / C2 => X * (C1/C2)" is disabled if C1/C2 is a denormal
392 define float @fdiv4(float %x) {
393 %mul = fmul float %x, 0x47EFFFFFE0000000
394 %div = fdiv float %mul, 0x3FC99999A0000000
396 ; CHECK-LABEL: @fdiv4(
397 ; CHECK: fmul float %x, 0x47EFFFFFE0000000
400 ; (X/Y)/Z = > X/(Y*Z)
401 define float @fdiv5(float %f1, float %f2, float %f3) {
402 %t1 = fdiv float %f1, %f2
403 %t2 = fdiv fast float %t1, %f3
405 ; CHECK-LABEL: @fdiv5(
406 ; CHECK: fmul float %f2, %f3
409 ; Z/(X/Y) = > (Z*Y)/X
410 define float @fdiv6(float %f1, float %f2, float %f3) {
411 %t1 = fdiv float %f1, %f2
412 %t2 = fdiv fast float %f3, %t1
414 ; CHECK-LABEL: @fdiv6(
415 ; CHECK: fmul float %f3, %f2
418 ; C1/(X*C2) => (C1/C2) / X
419 define float @fdiv7(float %x) {
420 %t1 = fmul float %x, 3.0e0
421 %t2 = fdiv fast float 15.0e0, %t1
423 ; CHECK-LABEL: @fdiv7(
424 ; CHECK: fdiv fast float 5.000000e+00, %x
427 ; C1/(X/C2) => (C1*C2) / X
428 define float @fdiv8(float %x) {
429 %t1 = fdiv float %x, 3.0e0
430 %t2 = fdiv fast float 15.0e0, %t1
432 ; CHECK-LABEL: @fdiv8(
433 ; CHECK: fdiv fast float 4.500000e+01, %x
436 ; C1/(C2/X) => (C1/C2) * X
437 define float @fdiv9(float %x) {
438 %t1 = fdiv float 3.0e0, %x
439 %t2 = fdiv fast float 15.0e0, %t1
441 ; CHECK-LABEL: @fdiv9(
442 ; CHECK: fmul fast float %x, 5.000000e+00
445 ; =========================================================================
447 ; Testing-cases about factorization
449 ; =========================================================================
450 ; x*z + y*z => (x+y) * z
451 define float @fact_mul1(float %x, float %y, float %z) {
452 %t1 = fmul fast float %x, %z
453 %t2 = fmul fast float %y, %z
454 %t3 = fadd fast float %t1, %t2
456 ; CHECK-LABEL: @fact_mul1(
457 ; CHECK: fmul fast float %1, %z
460 ; z*x + y*z => (x+y) * z
461 define float @fact_mul2(float %x, float %y, float %z) {
462 %t1 = fmul fast float %z, %x
463 %t2 = fmul fast float %y, %z
464 %t3 = fsub fast float %t1, %t2
466 ; CHECK-LABEL: @fact_mul2(
467 ; CHECK: fmul fast float %1, %z
470 ; z*x - z*y => (x-y) * z
471 define float @fact_mul3(float %x, float %y, float %z) {
472 %t2 = fmul fast float %z, %y
473 %t1 = fmul fast float %z, %x
474 %t3 = fsub fast float %t1, %t2
476 ; CHECK-LABEL: @fact_mul3(
477 ; CHECK: fmul fast float %1, %z
480 ; x*z - z*y => (x-y) * z
481 define float @fact_mul4(float %x, float %y, float %z) {
482 %t1 = fmul fast float %x, %z
483 %t2 = fmul fast float %z, %y
484 %t3 = fsub fast float %t1, %t2
486 ; CHECK-LABEL: @fact_mul4(
487 ; CHECK: fmul fast float %1, %z
490 ; x/y + x/z, no xform
491 define float @fact_div1(float %x, float %y, float %z) {
492 %t1 = fdiv fast float %x, %y
493 %t2 = fdiv fast float %x, %z
494 %t3 = fadd fast float %t1, %t2
497 ; CHECK: fadd fast float %t1, %t2
500 ; x/y + z/x; no xform
501 define float @fact_div2(float %x, float %y, float %z) {
502 %t1 = fdiv fast float %x, %y
503 %t2 = fdiv fast float %z, %x
504 %t3 = fadd fast float %t1, %t2
507 ; CHECK: fadd fast float %t1, %t2
510 ; y/x + z/x => (y+z)/x
511 define float @fact_div3(float %x, float %y, float %z) {
512 %t1 = fdiv fast float %y, %x
513 %t2 = fdiv fast float %z, %x
514 %t3 = fadd fast float %t1, %t2
517 ; CHECK: fdiv fast float %1, %x
520 ; y/x - z/x => (y-z)/x
521 define float @fact_div4(float %x, float %y, float %z) {
522 %t1 = fdiv fast float %y, %x
523 %t2 = fdiv fast float %z, %x
524 %t3 = fsub fast float %t1, %t2
527 ; CHECK: fdiv fast float %1, %x
530 ; y/x - z/x => (y-z)/x is disabled if y-z is denormal.
531 define float @fact_div5(float %x) {
532 %t1 = fdiv fast float 0x3810000000000000, %x
533 %t2 = fdiv fast float 0x3800000000000000, %x
534 %t3 = fadd fast float %t1, %t2
537 ; CHECK: fdiv fast float 0x3818000000000000, %x
540 ; y/x - z/x => (y-z)/x is disabled if y-z is denormal.
541 define float @fact_div6(float %x) {
542 %t1 = fdiv fast float 0x3810000000000000, %x
543 %t2 = fdiv fast float 0x3800000000000000, %x
544 %t3 = fsub fast float %t1, %t2
547 ; CHECK: %t3 = fsub fast float %t1, %t2
550 ; =========================================================================
552 ; Test-cases for square root
554 ; =========================================================================
556 ; A squared factor fed into a square root intrinsic should be hoisted out
559 declare double @llvm.sqrt.f64(double)
561 define double @sqrt_intrinsic_arg_squared(double %x) {
562 %mul = fmul fast double %x, %x
563 %sqrt = call fast double @llvm.sqrt.f64(double %mul)
566 ; CHECK-LABEL: sqrt_intrinsic_arg_squared(
567 ; CHECK-NEXT: %fabs = call fast double @llvm.fabs.f64(double %x)
568 ; CHECK-NEXT: ret double %fabs
571 ; Check all 6 combinations of a 3-way multiplication tree where
572 ; one factor is repeated.
574 define double @sqrt_intrinsic_three_args1(double %x, double %y) {
575 %mul = fmul fast double %y, %x
576 %mul2 = fmul fast double %mul, %x
577 %sqrt = call fast double @llvm.sqrt.f64(double %mul2)
580 ; CHECK-LABEL: sqrt_intrinsic_three_args1(
581 ; CHECK-NEXT: %fabs = call fast double @llvm.fabs.f64(double %x)
582 ; CHECK-NEXT: %sqrt1 = call fast double @llvm.sqrt.f64(double %y)
583 ; CHECK-NEXT: %1 = fmul fast double %fabs, %sqrt1
584 ; CHECK-NEXT: ret double %1
587 define double @sqrt_intrinsic_three_args2(double %x, double %y) {
588 %mul = fmul fast double %x, %y
589 %mul2 = fmul fast double %mul, %x
590 %sqrt = call fast double @llvm.sqrt.f64(double %mul2)
593 ; CHECK-LABEL: sqrt_intrinsic_three_args2(
594 ; CHECK-NEXT: %fabs = call fast double @llvm.fabs.f64(double %x)
595 ; CHECK-NEXT: %sqrt1 = call fast double @llvm.sqrt.f64(double %y)
596 ; CHECK-NEXT: %1 = fmul fast double %fabs, %sqrt1
597 ; CHECK-NEXT: ret double %1
600 define double @sqrt_intrinsic_three_args3(double %x, double %y) {
601 %mul = fmul fast double %x, %x
602 %mul2 = fmul fast double %mul, %y
603 %sqrt = call fast double @llvm.sqrt.f64(double %mul2)
606 ; CHECK-LABEL: sqrt_intrinsic_three_args3(
607 ; CHECK-NEXT: %fabs = call fast double @llvm.fabs.f64(double %x)
608 ; CHECK-NEXT: %sqrt1 = call fast double @llvm.sqrt.f64(double %y)
609 ; CHECK-NEXT: %1 = fmul fast double %fabs, %sqrt1
610 ; CHECK-NEXT: ret double %1
613 define double @sqrt_intrinsic_three_args4(double %x, double %y) {
614 %mul = fmul fast double %y, %x
615 %mul2 = fmul fast double %x, %mul
616 %sqrt = call fast double @llvm.sqrt.f64(double %mul2)
619 ; CHECK-LABEL: sqrt_intrinsic_three_args4(
620 ; CHECK-NEXT: %fabs = call fast double @llvm.fabs.f64(double %x)
621 ; CHECK-NEXT: %sqrt1 = call fast double @llvm.sqrt.f64(double %y)
622 ; CHECK-NEXT: %1 = fmul fast double %fabs, %sqrt1
623 ; CHECK-NEXT: ret double %1
626 define double @sqrt_intrinsic_three_args5(double %x, double %y) {
627 %mul = fmul fast double %x, %y
628 %mul2 = fmul fast double %x, %mul
629 %sqrt = call fast double @llvm.sqrt.f64(double %mul2)
632 ; CHECK-LABEL: sqrt_intrinsic_three_args5(
633 ; CHECK-NEXT: %fabs = call fast double @llvm.fabs.f64(double %x)
634 ; CHECK-NEXT: %sqrt1 = call fast double @llvm.sqrt.f64(double %y)
635 ; CHECK-NEXT: %1 = fmul fast double %fabs, %sqrt1
636 ; CHECK-NEXT: ret double %1
639 define double @sqrt_intrinsic_three_args6(double %x, double %y) {
640 %mul = fmul fast double %x, %x
641 %mul2 = fmul fast double %y, %mul
642 %sqrt = call fast double @llvm.sqrt.f64(double %mul2)
645 ; CHECK-LABEL: sqrt_intrinsic_three_args6(
646 ; CHECK-NEXT: %fabs = call fast double @llvm.fabs.f64(double %x)
647 ; CHECK-NEXT: %sqrt1 = call fast double @llvm.sqrt.f64(double %y)
648 ; CHECK-NEXT: %1 = fmul fast double %fabs, %sqrt1
649 ; CHECK-NEXT: ret double %1
652 ; If any operation is not 'fast', we can't simplify.
654 define double @sqrt_intrinsic_not_so_fast(double %x, double %y) {
655 %mul = fmul double %x, %x
656 %mul2 = fmul fast double %mul, %y
657 %sqrt = call fast double @llvm.sqrt.f64(double %mul2)
660 ; CHECK-LABEL: sqrt_intrinsic_not_so_fast(
661 ; CHECK-NEXT: %mul = fmul double %x, %x
662 ; CHECK-NEXT: %mul2 = fmul fast double %mul, %y
663 ; CHECK-NEXT: %sqrt = call fast double @llvm.sqrt.f64(double %mul2)
664 ; CHECK-NEXT: ret double %sqrt
667 define double @sqrt_intrinsic_arg_4th(double %x) {
668 %mul = fmul fast double %x, %x
669 %mul2 = fmul fast double %mul, %mul
670 %sqrt = call fast double @llvm.sqrt.f64(double %mul2)
673 ; CHECK-LABEL: sqrt_intrinsic_arg_4th(
674 ; CHECK-NEXT: %mul = fmul fast double %x, %x
675 ; CHECK-NEXT: ret double %mul
678 define double @sqrt_intrinsic_arg_5th(double %x) {
679 %mul = fmul fast double %x, %x
680 %mul2 = fmul fast double %mul, %x
681 %mul3 = fmul fast double %mul2, %mul
682 %sqrt = call fast double @llvm.sqrt.f64(double %mul3)
685 ; CHECK-LABEL: sqrt_intrinsic_arg_5th(
686 ; CHECK-NEXT: %mul = fmul fast double %x, %x
687 ; CHECK-NEXT: %sqrt1 = call fast double @llvm.sqrt.f64(double %x)
688 ; CHECK-NEXT: %1 = fmul fast double %mul, %sqrt1
689 ; CHECK-NEXT: ret double %1
692 ; Check that square root calls have the same behavior.
694 declare float @sqrtf(float)
695 declare double @sqrt(double)
696 declare fp128 @sqrtl(fp128)
698 define float @sqrt_call_squared_f32(float %x) {
699 %mul = fmul fast float %x, %x
700 %sqrt = call fast float @sqrtf(float %mul)
703 ; CHECK-LABEL: sqrt_call_squared_f32(
704 ; CHECK-NEXT: %fabs = call fast float @llvm.fabs.f32(float %x)
705 ; CHECK-NEXT: ret float %fabs
708 define double @sqrt_call_squared_f64(double %x) {
709 %mul = fmul fast double %x, %x
710 %sqrt = call fast double @sqrt(double %mul)
713 ; CHECK-LABEL: sqrt_call_squared_f64(
714 ; CHECK-NEXT: %fabs = call fast double @llvm.fabs.f64(double %x)
715 ; CHECK-NEXT: ret double %fabs
718 define fp128 @sqrt_call_squared_f128(fp128 %x) {
719 %mul = fmul fast fp128 %x, %x
720 %sqrt = call fast fp128 @sqrtl(fp128 %mul)
723 ; CHECK-LABEL: sqrt_call_squared_f128(
724 ; CHECK-NEXT: %fabs = call fast fp128 @llvm.fabs.f128(fp128 %x)
725 ; CHECK-NEXT: ret fp128 %fabs
728 ; =========================================================================
730 ; Test-cases for fmin / fmax
732 ; =========================================================================
734 declare double @fmax(double, double)
735 declare double @fmin(double, double)
736 declare float @fmaxf(float, float)
737 declare float @fminf(float, float)
738 declare fp128 @fmaxl(fp128, fp128)
739 declare fp128 @fminl(fp128, fp128)
741 ; No NaNs is the minimum requirement to replace these calls.
742 ; This should always be set when unsafe-fp-math is true, but
743 ; alternate the attributes for additional test coverage.
744 ; 'nsz' is implied by the definition of fmax or fmin itself.
746 ; Shrink and remove the call.
747 define float @max1(float %a, float %b) {
748 %c = fpext float %a to double
749 %d = fpext float %b to double
750 %e = call fast double @fmax(double %c, double %d)
751 %f = fptrunc double %e to float
755 ; CHECK-NEXT: fcmp fast ogt float %a, %b
756 ; CHECK-NEXT: select {{.*}} float %a, float %b
760 define float @max2(float %a, float %b) {
761 %c = call nnan float @fmaxf(float %a, float %b)
765 ; CHECK-NEXT: fcmp nnan nsz ogt float %a, %b
766 ; CHECK-NEXT: select {{.*}} float %a, float %b
771 define double @max3(double %a, double %b) {
772 %c = call fast double @fmax(double %a, double %b)
776 ; CHECK-NEXT: fcmp fast ogt double %a, %b
777 ; CHECK-NEXT: select {{.*}} double %a, double %b
781 define fp128 @max4(fp128 %a, fp128 %b) {
782 %c = call nnan fp128 @fmaxl(fp128 %a, fp128 %b)
786 ; CHECK-NEXT: fcmp nnan nsz ogt fp128 %a, %b
787 ; CHECK-NEXT: select {{.*}} fp128 %a, fp128 %b
791 ; Shrink and remove the call.
792 define float @min1(float %a, float %b) {
793 %c = fpext float %a to double
794 %d = fpext float %b to double
795 %e = call nnan double @fmin(double %c, double %d)
796 %f = fptrunc double %e to float
800 ; CHECK-NEXT: fcmp nnan nsz olt float %a, %b
801 ; CHECK-NEXT: select {{.*}} float %a, float %b
805 define float @min2(float %a, float %b) {
806 %c = call fast float @fminf(float %a, float %b)
810 ; CHECK-NEXT: fcmp fast olt float %a, %b
811 ; CHECK-NEXT: select {{.*}} float %a, float %b
815 define double @min3(double %a, double %b) {
816 %c = call nnan double @fmin(double %a, double %b)
820 ; CHECK-NEXT: fcmp nnan nsz olt double %a, %b
821 ; CHECK-NEXT: select {{.*}} double %a, double %b
825 define fp128 @min4(fp128 %a, fp128 %b) {
826 %c = call fast fp128 @fminl(fp128 %a, fp128 %b)
830 ; CHECK-NEXT: fcmp fast olt fp128 %a, %b
831 ; CHECK-NEXT: select {{.*}} fp128 %a, fp128 %b