test/Transforms/InstCombine/fast-math.ll

   1 ; RUN: opt < %s -instcombine -S | FileCheck %s
   2
   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
   8   ret float %mul1
   9 ; CHECK-LABEL: @fold(
  10 ; CHECK: fmul fast float %a, 0x4006147AE0000000
  11 }
  12
  13 ; Same testing-case as the one used in fold() except that the operators have
  14 ; fixed FP mode.
  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
  20   ret float %mul1
  21 }
  22
  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
  28   ret float %mul1
  29 }
  30
  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
  35   ret double %t2
  36 ; CHECK-LABEL: @fold3(
  37 ; CHECK: fmul fast double %f1, 3.000000e+00
  38 }
  39
  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
  45   ret float %add
  46 ; CHECK-LABEL: @fold4(
  47 ; CHECK: %1 = fadd fast float %f1, %f2
  48 ; CHECK: fsub fast float 9.000000e+00, %1
  49 }
  50
  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
  55   ret float %add1
  56 ; CHECK-LABEL: @fold5(
  57 ; CHECK: fadd fast float %f1, 9.000000e+00
  58 }
  59
  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
  64   ret float %t2
  65 ; CHECK-LABEL: @fold6(
  66 ; CHECK: fmul fast float %f1, 3.000000e+00
  67 }
  68
  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
  74   ret float %t3
  75 ; CHECK-LABEL: @fold7(
  76 ; CHECK: fmul fast float %f1, 7.000000e+00
  77 }
  78
  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
  84   ret float %t3
  85 ; CHECK: fold8
  86 ; CHECK: fmul fast float %f1, 4.000000e+00
  87 }
  88
  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
  93   ret float %t3
  94
  95 ; CHECK-LABEL: @fold9(
  96 ; CHECK: fsub fast float -0.000000e+00, %f2
  97 }
  98
  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.
 103 ;
 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
 108   ret float %t3
 109 ; CHECK-LABEL: @fold10(
 110 ; CHECK: %t3 = fadd fast float %t2, -1.000000e+00
 111 ; CHECK: ret float %t3
 112 }
 113
 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
 119   ret float %add2
 120 ; CHECK-LABEL: @fail1(
 121 ; CHECK: ret
 122 }
 123
 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
 128   ret double %t3
 129 ; CHECK-LABEL: @fail2(
 130 ; CHECK: ret
 131 }
 132
 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
 137   ret float %sub
 138 ; CHECK: fold13
 139 ; CHECK: fmul fast float %x, 6.000000e+00
 140 ; CHECK: ret
 141 }
 142
 143 ; -x + y => y - x
 144 define float @fold14(float %x, float %y) {
 145   %neg = fsub fast float -0.0, %x
 146   %add = fadd fast float %neg, %y
 147   ret float %add
 148 ; CHECK: fold14
 149 ; CHECK: fsub fast float %y, %x
 150 ; CHECK: ret
 151 }
 152
 153 ; x + -y => x - y
 154 define float @fold15(float %x, float %y) {
 155   %neg = fsub fast float -0.0, %y
 156   %add = fadd fast float %x, %neg
 157   ret float %add
 158 ; CHECK: fold15
 159 ; CHECK: fsub fast float %x, %y
 160 ; CHECK: ret
 161 }
 162
 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
 169   ret float %r
 170 ; CHECK: fold16
 171 ; CHECK: fsub fast float
 172 ; CHECK: select
 173 ; CHECK: fadd fast float
 174 ; CHECK: ret
 175 }
 176
 177
 178
 179 ; =========================================================================
 180 ;
 181 ;   Testing-cases about fmul begin
 182 ;
 183 ; =========================================================================
 184
 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
 190   ret float %t3
 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
 194 }
 195
 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
 202   ret double %t3
 203
 204 ; CHECK-LABEL: @fmul_distribute2(
 205 ; CHECK: %1 = fdiv fast double %f1, 0x7FE8000000000000
 206 ; CHECK: fadd fast double %1, 0x69000000000000
 207 }
 208
 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
 215   ret double %t3
 216
 217 ; CHECK-LABEL: @fmul_distribute3(
 218 ; CHECK: fmul fast double %t2, 0x10000000000000
 219 }
 220
 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
 226   ret float %t3
 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
 230 }
 231
 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
 236   ret float %t3
 237 ; CHECK-LABEL: @fmul2(
 238 ; CHECK: fdiv fast float 1.200000e+07, %f1
 239 }
 240
 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
 247   ret float %mul
 248 ; CHECK-LABEL: @fmul2_disable
 249 ; CHECK: store
 250 ; CHECK: fmul fast
 251 }
 252
 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
 257   ret float %t3
 258 ; CHECK-LABEL: @fmul3(
 259 ; CHECK: fmul fast float %f1, 3.000000e+00
 260 }
 261
 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>
 265   ret <4 x float> %t3
 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>
 268 }
 269
 270 ; Rule "X/C1 * C2 => X * (C2/C1) is not applicable if C2/C1 is either a special
 271 ; value of a denormal. The 0x3810000000000000 here take value FLT_MIN
 272 ;
 273 define float @fmul4(float %f1, float %f2) {
 274   %t1 = fdiv float %f1, 2.0e+3
 275   %t3 = fmul fast float %t1, 0x3810000000000000
 276   ret float %t3
 277 ; CHECK-LABEL: @fmul4(
 278 ; CHECK: fmul fast float %t1, 0x3810000000000000
 279 }
 280
 281 ; X / C1 * C2 => X / (C2/C1) if  C1/C2 is either a special value of a denormal,
 282 ;  and C2/C1 is a normal value.
 283 ;
 284 define float @fmul5(float %f1, float %f2) {
 285   %t1 = fdiv float %f1, 3.0e+0
 286   %t3 = fmul fast float %t1, 0x3810000000000000
 287   ret float %t3
 288 ; CHECK-LABEL: @fmul5(
 289 ; CHECK: fdiv fast float %f1, 0x47E8000000000000
 290 }
 291
 292 ; (X*Y) * X => (X*X) * Y
 293 define float @fmul6(float %f1, float %f2) {
 294   %mul = fmul float %f1, %f2
 295   %mul1 = fmul fast float %mul, %f1
 296   ret float %mul1
 297 ; CHECK-LABEL: @fmul6(
 298 ; CHECK: fmul fast float %f1, %f1
 299 }
 300
 301 ; "(X*Y) * X => (X*X) * Y" is disabled if "X*Y" has multiple uses
 302 define float @fmul7(float %f1, float %f2) {
 303   %mul = fmul float %f1, %f2
 304   %mul1 = fmul fast float %mul, %f1
 305   %add = fadd float %mul1, %mul
 306   ret float %add
 307 ; CHECK-LABEL: @fmul7(
 308 ; CHECK: fmul fast float %mul, %f1
 309 }
 310
 311 ; =========================================================================
 312 ;
 313 ;   Testing-cases about negation
 314 ;
 315 ; =========================================================================
 316 define float @fneg1(float %f1, float %f2) {
 317   %sub = fsub float -0.000000e+00, %f1
 318   %sub1 = fsub nsz float 0.000000e+00, %f2
 319   %mul = fmul float %sub, %sub1
 320   ret float %mul
 321 ; CHECK-LABEL: @fneg1(
 322 ; CHECK: fmul float %f1, %f2
 323 }
 324
 325 define float @fneg2(float %x) {
 326   %sub = fsub nsz float 0.0, %x
 327   ret float %sub
 328 ; CHECK-LABEL: @fneg2(
 329 ; CHECK-NEXT: fsub nsz float -0.000000e+00, %x
 330 ; CHECK-NEXT: ret float
 331 }
 332
 333 ; =========================================================================
 334 ;
 335 ;   Testing-cases about div
 336 ;
 337 ; =========================================================================
 338
 339 ; X/C1 / C2 => X * (1/(C2*C1))
 340 define float @fdiv1(float %x) {
 341   %div = fdiv float %x, 0x3FF3333340000000
 342   %div1 = fdiv fast float %div, 0x4002666660000000
 343   ret float %div1
 344 ; 0x3FF3333340000000 = 1.2f
 345 ; 0x4002666660000000 = 2.3f
 346 ; 0x3FD7303B60000000 = 0.36231884057971014492
 347 ; CHECK-LABEL: @fdiv1(
 348 ; CHECK: fmul fast float %x, 0x3FD7303B60000000
 349 }
 350
 351 ; X*C1 / C2 => X * (C1/C2)
 352 define float @fdiv2(float %x) {
 353   %mul = fmul float %x, 0x3FF3333340000000
 354   %div1 = fdiv fast float %mul, 0x4002666660000000
 355   ret float %div1
 356
 357 ; 0x3FF3333340000000 = 1.2f
 358 ; 0x4002666660000000 = 2.3f
 359 ; 0x3FE0B21660000000 = 0.52173918485641479492
 360 ; CHECK-LABEL: @fdiv2(
 361 ; CHECK: fmul fast float %x, 0x3FE0B21660000000
 362 }
 363
 364 define <2 x float> @fdiv2_vec(<2 x float> %x) {
 365   %mul = fmul <2 x float> %x, <float 6.0, float 9.0>
 366   %div1 = fdiv fast <2 x float> %mul, <float 2.0, float 3.0>
 367   ret <2 x float> %div1
 368
 369 ; CHECK-LABEL: @fdiv2_vec(
 370 ; CHECK: fmul fast <2 x float> %x, <float 3.000000e+00, float 3.000000e+00>
 371 }
 372
 373 ; "X/C1 / C2 => X * (1/(C2*C1))" is disabled (for now) is C2/C1 is a denormal
 374 ;
 375 define float @fdiv3(float %x) {
 376   %div = fdiv float %x, 0x47EFFFFFE0000000
 377   %div1 = fdiv fast float %div, 0x4002666660000000
 378   ret float %div1
 379 ; CHECK-LABEL: @fdiv3(
 380 ; CHECK: fdiv float %x, 0x47EFFFFFE0000000
 381 }
 382
 383 ; "X*C1 / C2 => X * (C1/C2)" is disabled if C1/C2 is a denormal
 384 define float @fdiv4(float %x) {
 385   %mul = fmul float %x, 0x47EFFFFFE0000000
 386   %div = fdiv float %mul, 0x3FC99999A0000000
 387   ret float %div
 388 ; CHECK-LABEL: @fdiv4(
 389 ; CHECK: fmul float %x, 0x47EFFFFFE0000000
 390 }
 391
 392 ; (X/Y)/Z = > X/(Y*Z)
 393 define float @fdiv5(float %f1, float %f2, float %f3) {
 394   %t1 = fdiv float %f1, %f2
 395   %t2 = fdiv fast float %t1, %f3
 396   ret float %t2
 397 ; CHECK-LABEL: @fdiv5(
 398 ; CHECK: fmul float %f2, %f3
 399 }
 400
 401 ; Z/(X/Y) = > (Z*Y)/X
 402 define float @fdiv6(float %f1, float %f2, float %f3) {
 403   %t1 = fdiv float %f1, %f2
 404   %t2 = fdiv fast float %f3, %t1
 405   ret float %t2
 406 ; CHECK-LABEL: @fdiv6(
 407 ; CHECK: fmul float %f3, %f2
 408 }
 409
 410 ; C1/(X*C2) => (C1/C2) / X
 411 define float @fdiv7(float %x) {
 412   %t1 = fmul float %x, 3.0e0
 413   %t2 = fdiv fast float 15.0e0, %t1
 414   ret float %t2
 415 ; CHECK-LABEL: @fdiv7(
 416 ; CHECK: fdiv fast float 5.000000e+00, %x
 417 }
 418
 419 ; C1/(X/C2) => (C1*C2) / X
 420 define float @fdiv8(float %x) {
 421   %t1 = fdiv float %x, 3.0e0
 422   %t2 = fdiv fast float 15.0e0, %t1
 423   ret float %t2
 424 ; CHECK-LABEL: @fdiv8(
 425 ; CHECK: fdiv fast float 4.500000e+01, %x
 426 }
 427
 428 ; C1/(C2/X) => (C1/C2) * X
 429 define float @fdiv9(float %x) {
 430   %t1 = fdiv float 3.0e0, %x
 431   %t2 = fdiv fast float 15.0e0, %t1
 432   ret float %t2
 433 ; CHECK-LABEL: @fdiv9(
 434 ; CHECK: fmul fast float %x, 5.000000e+00
 435 }
 436
 437 ; =========================================================================
 438 ;
 439 ;   Testing-cases about factorization
 440 ;
 441 ; =========================================================================
 442 ; x*z + y*z => (x+y) * z
 443 define float @fact_mul1(float %x, float %y, float %z) {
 444   %t1 = fmul fast float %x, %z
 445   %t2 = fmul fast float %y, %z
 446   %t3 = fadd fast float %t1, %t2
 447   ret float %t3
 448 ; CHECK-LABEL: @fact_mul1(
 449 ; CHECK: fmul fast float %1, %z
 450 }
 451
 452 ; z*x + y*z => (x+y) * z
 453 define float @fact_mul2(float %x, float %y, float %z) {
 454   %t1 = fmul fast float %z, %x
 455   %t2 = fmul fast float %y, %z
 456   %t3 = fsub fast float %t1, %t2
 457   ret float %t3
 458 ; CHECK-LABEL: @fact_mul2(
 459 ; CHECK: fmul fast float %1, %z
 460 }
 461
 462 ; z*x - z*y => (x-y) * z
 463 define float @fact_mul3(float %x, float %y, float %z) {
 464   %t2 = fmul fast float %z, %y
 465   %t1 = fmul fast float %z, %x
 466   %t3 = fsub fast float %t1, %t2
 467   ret float %t3
 468 ; CHECK-LABEL: @fact_mul3(
 469 ; CHECK: fmul fast float %1, %z
 470 }
 471
 472 ; x*z - z*y => (x-y) * z
 473 define float @fact_mul4(float %x, float %y, float %z) {
 474   %t1 = fmul fast float %x, %z
 475   %t2 = fmul fast float %z, %y
 476   %t3 = fsub fast float %t1, %t2
 477   ret float %t3
 478 ; CHECK-LABEL: @fact_mul4(
 479 ; CHECK: fmul fast float %1, %z
 480 }
 481
 482 ; x/y + x/z, no xform
 483 define float @fact_div1(float %x, float %y, float %z) {
 484   %t1 = fdiv fast float %x, %y
 485   %t2 = fdiv fast float %x, %z
 486   %t3 = fadd fast float %t1, %t2
 487   ret float %t3
 488 ; CHECK: fact_div1
 489 ; CHECK: fadd fast float %t1, %t2
 490 }
 491
 492 ; x/y + z/x; no xform
 493 define float @fact_div2(float %x, float %y, float %z) {
 494   %t1 = fdiv fast float %x, %y
 495   %t2 = fdiv fast float %z, %x
 496   %t3 = fadd fast float %t1, %t2
 497   ret float %t3
 498 ; CHECK: fact_div2
 499 ; CHECK: fadd fast float %t1, %t2
 500 }
 501
 502 ; y/x + z/x => (y+z)/x
 503 define float @fact_div3(float %x, float %y, float %z) {
 504   %t1 = fdiv fast float %y, %x
 505   %t2 = fdiv fast float %z, %x
 506   %t3 = fadd fast float %t1, %t2
 507   ret float %t3
 508 ; CHECK: fact_div3
 509 ; CHECK: fdiv fast float %1, %x
 510 }
 511
 512 ; y/x - z/x => (y-z)/x
 513 define float @fact_div4(float %x, float %y, float %z) {
 514   %t1 = fdiv fast float %y, %x
 515   %t2 = fdiv fast float %z, %x
 516   %t3 = fsub fast float %t1, %t2
 517   ret float %t3
 518 ; CHECK: fact_div4
 519 ; CHECK: fdiv fast float %1, %x
 520 }
 521
 522 ; y/x - z/x => (y-z)/x is disabled if y-z is denormal.
 523 define float @fact_div5(float %x) {
 524   %t1 = fdiv fast float 0x3810000000000000, %x
 525   %t2 = fdiv fast float 0x3800000000000000, %x
 526   %t3 = fadd fast float %t1, %t2
 527   ret float %t3
 528 ; CHECK: fact_div5
 529 ; CHECK: fdiv fast float 0x3818000000000000, %x
 530 }
 531
 532 ; y/x - z/x => (y-z)/x is disabled if y-z is denormal.
 533 define float @fact_div6(float %x) {
 534   %t1 = fdiv fast float 0x3810000000000000, %x
 535   %t2 = fdiv fast float 0x3800000000000000, %x
 536   %t3 = fsub fast float %t1, %t2
 537   ret float %t3
 538 ; CHECK: fact_div6
 539 ; CHECK: %t3 = fsub fast float %t1, %t2
 540 }
 541
 542 ; =========================================================================
 543 ;
 544 ;   Test-cases for square root
 545 ;
 546 ; =========================================================================
 547
 548 ; A squared factor fed into a square root intrinsic should be hoisted out
 549 ; as a fabs() value.
 550 ; We have to rely on a function-level attribute to enable this optimization
 551 ; because intrinsics don't currently have access to IR-level fast-math
 552 ; flags. If that changes, we can relax the requirement on all of these
 553 ; tests to just specify 'fast' on the sqrt.
 554
 555 attributes #0 = { "unsafe-fp-math" = "true" }
 556
 557 declare double @llvm.sqrt.f64(double)
 558
 559 define double @sqrt_intrinsic_arg_squared(double %x) #0 {
 560   %mul = fmul fast double %x, %x
 561   %sqrt = call double @llvm.sqrt.f64(double %mul)
 562   ret double %sqrt
 563
 564 ; CHECK-LABEL: sqrt_intrinsic_arg_squared(
 565 ; CHECK-NEXT: %fabs = call double @llvm.fabs.f64(double %x)
 566 ; CHECK-NEXT: ret double %fabs
 567 }
 568
 569 ; Check all 6 combinations of a 3-way multiplication tree where
 570 ; one factor is repeated.
 571
 572 define double @sqrt_intrinsic_three_args1(double %x, double %y) #0 {
 573   %mul = fmul fast double %y, %x
 574   %mul2 = fmul fast double %mul, %x
 575   %sqrt = call double @llvm.sqrt.f64(double %mul2)
 576   ret double %sqrt
 577
 578 ; CHECK-LABEL: sqrt_intrinsic_three_args1(
 579 ; CHECK-NEXT: %fabs = call double @llvm.fabs.f64(double %x)
 580 ; CHECK-NEXT: %sqrt1 = call double @llvm.sqrt.f64(double %y)
 581 ; CHECK-NEXT: %1 = fmul fast double %fabs, %sqrt1
 582 ; CHECK-NEXT: ret double %1
 583 }
 584
 585 define double @sqrt_intrinsic_three_args2(double %x, double %y) #0 {
 586   %mul = fmul fast double %x, %y
 587   %mul2 = fmul fast double %mul, %x
 588   %sqrt = call double @llvm.sqrt.f64(double %mul2)
 589   ret double %sqrt
 590
 591 ; CHECK-LABEL: sqrt_intrinsic_three_args2(
 592 ; CHECK-NEXT: %fabs = call double @llvm.fabs.f64(double %x)
 593 ; CHECK-NEXT: %sqrt1 = call double @llvm.sqrt.f64(double %y)
 594 ; CHECK-NEXT: %1 = fmul fast double %fabs, %sqrt1
 595 ; CHECK-NEXT: ret double %1
 596 }
 597
 598 define double @sqrt_intrinsic_three_args3(double %x, double %y) #0 {
 599   %mul = fmul fast double %x, %x
 600   %mul2 = fmul fast double %mul, %y
 601   %sqrt = call double @llvm.sqrt.f64(double %mul2)
 602   ret double %sqrt
 603
 604 ; CHECK-LABEL: sqrt_intrinsic_three_args3(
 605 ; CHECK-NEXT: %fabs = call double @llvm.fabs.f64(double %x)
 606 ; CHECK-NEXT: %sqrt1 = call double @llvm.sqrt.f64(double %y)
 607 ; CHECK-NEXT: %1 = fmul fast double %fabs, %sqrt1
 608 ; CHECK-NEXT: ret double %1
 609 }
 610
 611 define double @sqrt_intrinsic_three_args4(double %x, double %y) #0 {
 612   %mul = fmul fast double %y, %x
 613   %mul2 = fmul fast double %x, %mul
 614   %sqrt = call double @llvm.sqrt.f64(double %mul2)
 615   ret double %sqrt
 616
 617 ; CHECK-LABEL: sqrt_intrinsic_three_args4(
 618 ; CHECK-NEXT: %fabs = call double @llvm.fabs.f64(double %x)
 619 ; CHECK-NEXT: %sqrt1 = call double @llvm.sqrt.f64(double %y)
 620 ; CHECK-NEXT: %1 = fmul fast double %fabs, %sqrt1
 621 ; CHECK-NEXT: ret double %1
 622 }
 623
 624 define double @sqrt_intrinsic_three_args5(double %x, double %y) #0 {
 625   %mul = fmul fast double %x, %y
 626   %mul2 = fmul fast double %x, %mul
 627   %sqrt = call double @llvm.sqrt.f64(double %mul2)
 628   ret double %sqrt
 629
 630 ; CHECK-LABEL: sqrt_intrinsic_three_args5(
 631 ; CHECK-NEXT: %fabs = call double @llvm.fabs.f64(double %x)
 632 ; CHECK-NEXT: %sqrt1 = call double @llvm.sqrt.f64(double %y)
 633 ; CHECK-NEXT: %1 = fmul fast double %fabs, %sqrt1
 634 ; CHECK-NEXT: ret double %1
 635 }
 636
 637 define double @sqrt_intrinsic_three_args6(double %x, double %y) #0 {
 638   %mul = fmul fast double %x, %x
 639   %mul2 = fmul fast double %y, %mul
 640   %sqrt = call double @llvm.sqrt.f64(double %mul2)
 641   ret double %sqrt
 642
 643 ; CHECK-LABEL: sqrt_intrinsic_three_args6(
 644 ; CHECK-NEXT: %fabs = call double @llvm.fabs.f64(double %x)
 645 ; CHECK-NEXT: %sqrt1 = call double @llvm.sqrt.f64(double %y)
 646 ; CHECK-NEXT: %1 = fmul fast double %fabs, %sqrt1
 647 ; CHECK-NEXT: ret double %1
 648 }
 649
 650 define double @sqrt_intrinsic_arg_4th(double %x) #0 {
 651   %mul = fmul fast double %x, %x
 652   %mul2 = fmul fast double %mul, %mul
 653   %sqrt = call double @llvm.sqrt.f64(double %mul2)
 654   ret double %sqrt
 655
 656 ; CHECK-LABEL: sqrt_intrinsic_arg_4th(
 657 ; CHECK-NEXT: %mul = fmul fast double %x, %x
 658 ; CHECK-NEXT: ret double %mul
 659 }
 660
 661 define double @sqrt_intrinsic_arg_5th(double %x) #0 {
 662   %mul = fmul fast double %x, %x
 663   %mul2 = fmul fast double %mul, %x
 664   %mul3 = fmul fast double %mul2, %mul
 665   %sqrt = call double @llvm.sqrt.f64(double %mul3)
 666   ret double %sqrt
 667
 668 ; CHECK-LABEL: sqrt_intrinsic_arg_5th(
 669 ; CHECK-NEXT: %mul = fmul fast double %x, %x
 670 ; CHECK-NEXT: %sqrt1 = call double @llvm.sqrt.f64(double %x)
 671 ; CHECK-NEXT: %1 = fmul fast double %mul, %sqrt1
 672 ; CHECK-NEXT: ret double %1
 673 }
 674
 675 ; Check that square root calls have the same behavior.
 676
 677 declare float @sqrtf(float)
 678 declare double @sqrt(double)
 679 declare fp128 @sqrtl(fp128)
 680
 681 define float @sqrt_call_squared_f32(float %x) #0 {
 682   %mul = fmul fast float %x, %x
 683   %sqrt = call float @sqrtf(float %mul)
 684   ret float %sqrt
 685
 686 ; CHECK-LABEL: sqrt_call_squared_f32(
 687 ; CHECK-NEXT: %fabs = call float @llvm.fabs.f32(float %x)
 688 ; CHECK-NEXT: ret float %fabs
 689 }
 690
 691 define double @sqrt_call_squared_f64(double %x) #0 {
 692   %mul = fmul fast double %x, %x
 693   %sqrt = call double @sqrt(double %mul)
 694   ret double %sqrt
 695
 696 ; CHECK-LABEL: sqrt_call_squared_f64(
 697 ; CHECK-NEXT: %fabs = call double @llvm.fabs.f64(double %x)
 698 ; CHECK-NEXT: ret double %fabs
 699 }
 700
 701 define fp128 @sqrt_call_squared_f128(fp128 %x) #0 {
 702   %mul = fmul fast fp128 %x, %x
 703   %sqrt = call fp128 @sqrtl(fp128 %mul)
 704   ret fp128 %sqrt
 705
 706 ; CHECK-LABEL: sqrt_call_squared_f128(
 707 ; CHECK-NEXT: %fabs = call fp128 @llvm.fabs.f128(fp128 %x)
 708 ; CHECK-NEXT: ret fp128 %fabs
 709 }
 710