test/Transforms/InstCombine/fmul.ll

   1 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
   2 ; RUN: opt -S -instcombine < %s | FileCheck %s
   3
   4 ; (-0.0 - X) * C => X * -C
   5 define float @neg_constant(float %x) {
   6 ; CHECK-LABEL: @neg_constant(
   7 ; CHECK-NEXT:    [[MUL:%.*]] = fmul ninf float [[X:%.*]], -2.000000e+01
   8 ; CHECK-NEXT:    ret float [[MUL]]
   9 ;
  10   %sub = fsub float -0.0, %x
  11   %mul = fmul ninf float %sub, 2.0e+1
  12   ret float %mul
  13 }
  14
  15 define float @unary_neg_constant(float %x) {
  16 ; CHECK-LABEL: @unary_neg_constant(
  17 ; CHECK-NEXT:    [[MUL:%.*]] = fmul ninf float [[X:%.*]], -2.000000e+01
  18 ; CHECK-NEXT:    ret float [[MUL]]
  19 ;
  20   %sub = fneg float %x
  21   %mul = fmul ninf float %sub, 2.0e+1
  22   ret float %mul
  23 }
  24
  25 define <2 x float> @neg_constant_vec(<2 x float> %x) {
  26 ; CHECK-LABEL: @neg_constant_vec(
  27 ; CHECK-NEXT:    [[MUL:%.*]] = fmul ninf <2 x float> [[X:%.*]], <float -2.000000e+00, float -3.000000e+00>
  28 ; CHECK-NEXT:    ret <2 x float> [[MUL]]
  29 ;
  30   %sub = fsub <2 x float> <float -0.0, float -0.0>, %x
  31   %mul = fmul ninf <2 x float> %sub, <float 2.0, float 3.0>
  32   ret <2 x float> %mul
  33 }
  34
  35 define <2 x float> @unary_neg_constant_vec(<2 x float> %x) {
  36 ; CHECK-LABEL: @unary_neg_constant_vec(
  37 ; CHECK-NEXT:    [[MUL:%.*]] = fmul ninf <2 x float> [[X:%.*]], <float -2.000000e+00, float -3.000000e+00>
  38 ; CHECK-NEXT:    ret <2 x float> [[MUL]]
  39 ;
  40   %sub = fneg <2 x float> %x
  41   %mul = fmul ninf <2 x float> %sub, <float 2.0, float 3.0>
  42   ret <2 x float> %mul
  43 }
  44
  45 define <2 x float> @neg_constant_vec_undef(<2 x float> %x) {
  46 ; CHECK-LABEL: @neg_constant_vec_undef(
  47 ; CHECK-NEXT:    [[MUL:%.*]] = fmul ninf <2 x float> [[X:%.*]], <float -2.000000e+00, float -3.000000e+00>
  48 ; CHECK-NEXT:    ret <2 x float> [[MUL]]
  49 ;
  50   %sub = fsub <2 x float> <float undef, float -0.0>, %x
  51   %mul = fmul ninf <2 x float> %sub, <float 2.0, float 3.0>
  52   ret <2 x float> %mul
  53 }
  54
  55 ; (0.0 - X) * C => X * -C
  56 define float @neg_nsz_constant(float %x) {
  57 ; CHECK-LABEL: @neg_nsz_constant(
  58 ; CHECK-NEXT:    [[MUL:%.*]] = fmul nnan float [[X:%.*]], -2.000000e+01
  59 ; CHECK-NEXT:    ret float [[MUL]]
  60 ;
  61   %sub = fsub nsz float 0.0, %x
  62   %mul = fmul nnan float %sub, 2.0e+1
  63   ret float %mul
  64 }
  65
  66 define float @unary_neg_nsz_constant(float %x) {
  67 ; CHECK-LABEL: @unary_neg_nsz_constant(
  68 ; CHECK-NEXT:    [[MUL:%.*]] = fmul nnan float [[X:%.*]], -2.000000e+01
  69 ; CHECK-NEXT:    ret float [[MUL]]
  70 ;
  71   %sub = fneg nsz float %x
  72   %mul = fmul nnan float %sub, 2.0e+1
  73   ret float %mul
  74 }
  75
  76 ; (-0.0 - X) * (-0.0 - Y) => X * Y
  77 define float @neg_neg(float %x, float %y) {
  78 ; CHECK-LABEL: @neg_neg(
  79 ; CHECK-NEXT:    [[MUL:%.*]] = fmul arcp float [[X:%.*]], [[Y:%.*]]
  80 ; CHECK-NEXT:    ret float [[MUL]]
  81 ;
  82   %sub1 = fsub float -0.0, %x
  83   %sub2 = fsub float -0.0, %y
  84   %mul = fmul arcp float %sub1, %sub2
  85   ret float %mul
  86 }
  87
  88 define float @unary_neg_unary_neg(float %x, float %y) {
  89 ; CHECK-LABEL: @unary_neg_unary_neg(
  90 ; CHECK-NEXT:    [[MUL:%.*]] = fmul arcp float [[X:%.*]], [[Y:%.*]]
  91 ; CHECK-NEXT:    ret float [[MUL]]
  92 ;
  93   %sub1 = fneg float %x
  94   %sub2 = fneg float %y
  95   %mul = fmul arcp float %sub1, %sub2
  96   ret float %mul
  97 }
  98
  99 define float @unary_neg_neg(float %x, float %y) {
 100 ; CHECK-LABEL: @unary_neg_neg(
 101 ; CHECK-NEXT:    [[MUL:%.*]] = fmul arcp float [[X:%.*]], [[Y:%.*]]
 102 ; CHECK-NEXT:    ret float [[MUL]]
 103 ;
 104   %sub1 = fneg float %x
 105   %sub2 = fsub float -0.0, %y
 106   %mul = fmul arcp float %sub1, %sub2
 107   ret float %mul
 108 }
 109
 110 define float @neg_unary_neg(float %x, float %y) {
 111 ; CHECK-LABEL: @neg_unary_neg(
 112 ; CHECK-NEXT:    [[MUL:%.*]] = fmul arcp float [[X:%.*]], [[Y:%.*]]
 113 ; CHECK-NEXT:    ret float [[MUL]]
 114 ;
 115   %sub1 = fsub float -0.0, %x
 116   %sub2 = fneg float %y
 117   %mul = fmul arcp float %sub1, %sub2
 118   ret float %mul
 119 }
 120
 121 define <2 x float> @neg_neg_vec(<2 x float> %x, <2 x float> %y) {
 122 ; CHECK-LABEL: @neg_neg_vec(
 123 ; CHECK-NEXT:    [[MUL:%.*]] = fmul arcp <2 x float> [[X:%.*]], [[Y:%.*]]
 124 ; CHECK-NEXT:    ret <2 x float> [[MUL]]
 125 ;
 126   %sub1 = fsub <2 x float> <float -0.0, float -0.0>, %x
 127   %sub2 = fsub <2 x float> <float -0.0, float -0.0>, %y
 128   %mul = fmul arcp <2 x float> %sub1, %sub2
 129   ret <2 x float> %mul
 130 }
 131
 132 define <2 x float> @unary_neg_unary_neg_vec(<2 x float> %x, <2 x float> %y) {
 133 ; CHECK-LABEL: @unary_neg_unary_neg_vec(
 134 ; CHECK-NEXT:    [[MUL:%.*]] = fmul arcp <2 x float> [[X:%.*]], [[Y:%.*]]
 135 ; CHECK-NEXT:    ret <2 x float> [[MUL]]
 136 ;
 137   %sub1 = fneg <2 x float> %x
 138   %sub2 = fneg <2 x float> %y
 139   %mul = fmul arcp <2 x float> %sub1, %sub2
 140   ret <2 x float> %mul
 141 }
 142
 143 define <2 x float> @unary_neg_neg_vec(<2 x float> %x, <2 x float> %y) {
 144 ; CHECK-LABEL: @unary_neg_neg_vec(
 145 ; CHECK-NEXT:    [[MUL:%.*]] = fmul arcp <2 x float> [[X:%.*]], [[Y:%.*]]
 146 ; CHECK-NEXT:    ret <2 x float> [[MUL]]
 147 ;
 148   %sub1 = fneg <2 x float> %x
 149   %sub2 = fsub <2 x float> <float -0.0, float -0.0>, %y
 150   %mul = fmul arcp <2 x float> %sub1, %sub2
 151   ret <2 x float> %mul
 152 }
 153
 154 define <2 x float> @neg_unary_neg_vec(<2 x float> %x, <2 x float> %y) {
 155 ; CHECK-LABEL: @neg_unary_neg_vec(
 156 ; CHECK-NEXT:    [[MUL:%.*]] = fmul arcp <2 x float> [[X:%.*]], [[Y:%.*]]
 157 ; CHECK-NEXT:    ret <2 x float> [[MUL]]
 158 ;
 159   %sub1 = fsub <2 x float> <float -0.0, float -0.0>, %x
 160   %sub2 = fneg <2 x float> %y
 161   %mul = fmul arcp <2 x float> %sub1, %sub2
 162   ret <2 x float> %mul
 163 }
 164
 165 define <2 x float> @neg_neg_vec_undef(<2 x float> %x, <2 x float> %y) {
 166 ; CHECK-LABEL: @neg_neg_vec_undef(
 167 ; CHECK-NEXT:    [[MUL:%.*]] = fmul arcp <2 x float> [[X:%.*]], [[Y:%.*]]
 168 ; CHECK-NEXT:    ret <2 x float> [[MUL]]
 169 ;
 170   %sub1 = fsub <2 x float> <float -0.0, float undef>, %x
 171   %sub2 = fsub <2 x float> <float undef, float -0.0>, %y
 172   %mul = fmul arcp <2 x float> %sub1, %sub2
 173   ret <2 x float> %mul
 174 }
 175
 176 define <2 x float> @unary_neg_neg_vec_undef(<2 x float> %x, <2 x float> %y) {
 177 ; CHECK-LABEL: @unary_neg_neg_vec_undef(
 178 ; CHECK-NEXT:    [[MUL:%.*]] = fmul arcp <2 x float> [[X:%.*]], [[Y:%.*]]
 179 ; CHECK-NEXT:    ret <2 x float> [[MUL]]
 180 ;
 181   %neg = fneg <2 x float> %x
 182   %sub = fsub <2 x float> <float undef, float -0.0>, %y
 183   %mul = fmul arcp <2 x float> %neg, %sub
 184   ret <2 x float> %mul
 185 }
 186
 187 define <2 x float> @neg_unary_neg_vec_undef(<2 x float> %x, <2 x float> %y) {
 188 ; CHECK-LABEL: @neg_unary_neg_vec_undef(
 189 ; CHECK-NEXT:    [[MUL:%.*]] = fmul arcp <2 x float> [[X:%.*]], [[Y:%.*]]
 190 ; CHECK-NEXT:    ret <2 x float> [[MUL]]
 191 ;
 192   %sub = fsub <2 x float> <float -0.0, float undef>, %x
 193   %neg = fneg <2 x float> %y
 194   %mul = fmul arcp <2 x float> %sub, %neg
 195   ret <2 x float> %mul
 196 }
 197
 198 ; (0.0 - X) * (0.0 - Y) => X * Y
 199 define float @neg_neg_nsz(float %x, float %y) {
 200 ; CHECK-LABEL: @neg_neg_nsz(
 201 ; CHECK-NEXT:    [[MUL:%.*]] = fmul afn float [[X:%.*]], [[Y:%.*]]
 202 ; CHECK-NEXT:    ret float [[MUL]]
 203 ;
 204   %sub1 = fsub nsz float 0.0, %x
 205   %sub2 = fsub nsz float 0.0, %y
 206   %mul = fmul afn float %sub1, %sub2
 207   ret float %mul
 208 }
 209
 210 declare void @use_f32(float)
 211
 212 define float @neg_neg_multi_use(float %x, float %y) {
 213 ; CHECK-LABEL: @neg_neg_multi_use(
 214 ; CHECK-NEXT:    [[NX:%.*]] = fsub float -0.000000e+00, [[X:%.*]]
 215 ; CHECK-NEXT:    [[NY:%.*]] = fsub float -0.000000e+00, [[Y:%.*]]
 216 ; CHECK-NEXT:    [[MUL:%.*]] = fmul afn float [[X]], [[Y]]
 217 ; CHECK-NEXT:    call void @use_f32(float [[NX]])
 218 ; CHECK-NEXT:    call void @use_f32(float [[NY]])
 219 ; CHECK-NEXT:    ret float [[MUL]]
 220 ;
 221   %nx = fsub float -0.0, %x
 222   %ny = fsub float -0.0, %y
 223   %mul = fmul afn float %nx, %ny
 224   call void @use_f32(float %nx)
 225   call void @use_f32(float %ny)
 226   ret float %mul
 227 }
 228
 229 define float @unary_neg_unary_neg_multi_use(float %x, float %y) {
 230 ; CHECK-LABEL: @unary_neg_unary_neg_multi_use(
 231 ; CHECK-NEXT:    [[NX:%.*]] = fneg float [[X:%.*]]
 232 ; CHECK-NEXT:    [[NY:%.*]] = fneg float [[Y:%.*]]
 233 ; CHECK-NEXT:    [[MUL:%.*]] = fmul afn float [[X]], [[Y]]
 234 ; CHECK-NEXT:    call void @use_f32(float [[NX]])
 235 ; CHECK-NEXT:    call void @use_f32(float [[NY]])
 236 ; CHECK-NEXT:    ret float [[MUL]]
 237 ;
 238   %nx = fneg float %x
 239   %ny = fneg float %y
 240   %mul = fmul afn float %nx, %ny
 241   call void @use_f32(float %nx)
 242   call void @use_f32(float %ny)
 243   ret float %mul
 244 }
 245
 246 define float @unary_neg_neg_multi_use(float %x, float %y) {
 247 ; CHECK-LABEL: @unary_neg_neg_multi_use(
 248 ; CHECK-NEXT:    [[NX:%.*]] = fneg float [[X:%.*]]
 249 ; CHECK-NEXT:    [[NY:%.*]] = fsub float -0.000000e+00, [[Y:%.*]]
 250 ; CHECK-NEXT:    [[MUL:%.*]] = fmul afn float [[X]], [[Y]]
 251 ; CHECK-NEXT:    call void @use_f32(float [[NX]])
 252 ; CHECK-NEXT:    call void @use_f32(float [[NY]])
 253 ; CHECK-NEXT:    ret float [[MUL]]
 254 ;
 255   %nx = fneg float %x
 256   %ny = fsub float -0.0, %y
 257   %mul = fmul afn float %nx, %ny
 258   call void @use_f32(float %nx)
 259   call void @use_f32(float %ny)
 260   ret float %mul
 261 }
 262
 263 define float @neg_unary_neg_multi_use(float %x, float %y) {
 264 ; CHECK-LABEL: @neg_unary_neg_multi_use(
 265 ; CHECK-NEXT:    [[NX:%.*]] = fsub float -0.000000e+00, [[X:%.*]]
 266 ; CHECK-NEXT:    [[NY:%.*]] = fneg float [[Y:%.*]]
 267 ; CHECK-NEXT:    [[MUL:%.*]] = fmul afn float [[X]], [[Y]]
 268 ; CHECK-NEXT:    call void @use_f32(float [[NX]])
 269 ; CHECK-NEXT:    call void @use_f32(float [[NY]])
 270 ; CHECK-NEXT:    ret float [[MUL]]
 271 ;
 272   %nx = fsub float -0.0, %x
 273   %ny = fneg float %y
 274   %mul = fmul afn float %nx, %ny
 275   call void @use_f32(float %nx)
 276   call void @use_f32(float %ny)
 277   ret float %mul
 278 }
 279
 280 ; (-0.0 - X) * Y
 281 define float @neg_mul(float %x, float %y) {
 282 ; CHECK-LABEL: @neg_mul(
 283 ; CHECK-NEXT:    [[SUB:%.*]] = fsub float -0.000000e+00, [[X:%.*]]
 284 ; CHECK-NEXT:    [[MUL:%.*]] = fmul float [[SUB]], [[Y:%.*]]
 285 ; CHECK-NEXT:    ret float [[MUL]]
 286 ;
 287   %sub = fsub float -0.0, %x
 288   %mul = fmul float %sub, %y
 289   ret float %mul
 290 }
 291
 292 define float @unary_neg_mul(float %x, float %y) {
 293 ; CHECK-LABEL: @unary_neg_mul(
 294 ; CHECK-NEXT:    [[NEG:%.*]] = fneg float [[X:%.*]]
 295 ; CHECK-NEXT:    [[MUL:%.*]] = fmul float [[NEG]], [[Y:%.*]]
 296 ; CHECK-NEXT:    ret float [[MUL]]
 297 ;
 298   %neg = fneg float %x
 299   %mul = fmul float %neg, %y
 300   ret float %mul
 301 }
 302
 303 define <2 x float> @neg_mul_vec(<2 x float> %x, <2 x float> %y) {
 304 ; CHECK-LABEL: @neg_mul_vec(
 305 ; CHECK-NEXT:    [[SUB:%.*]] = fsub <2 x float> <float -0.000000e+00, float -0.000000e+00>, [[X:%.*]]
 306 ; CHECK-NEXT:    [[MUL:%.*]] = fmul <2 x float> [[SUB]], [[Y:%.*]]
 307 ; CHECK-NEXT:    ret <2 x float> [[MUL]]
 308 ;
 309   %sub = fsub <2 x float> <float -0.0, float -0.0>, %x
 310   %mul = fmul <2 x float> %sub, %y
 311   ret <2 x float> %mul
 312 }
 313
 314 define <2 x float> @unary_neg_mul_vec(<2 x float> %x, <2 x float> %y) {
 315 ; CHECK-LABEL: @unary_neg_mul_vec(
 316 ; CHECK-NEXT:    [[SUB:%.*]] = fneg <2 x float> [[X:%.*]]
 317 ; CHECK-NEXT:    [[MUL:%.*]] = fmul <2 x float> [[SUB]], [[Y:%.*]]
 318 ; CHECK-NEXT:    ret <2 x float> [[MUL]]
 319 ;
 320   %sub = fneg <2 x float> %x
 321   %mul = fmul <2 x float> %sub, %y
 322   ret <2 x float> %mul
 323 }
 324
 325 define <2 x float> @neg_mul_vec_undef(<2 x float> %x, <2 x float> %y) {
 326 ; CHECK-LABEL: @neg_mul_vec_undef(
 327 ; CHECK-NEXT:    [[SUB:%.*]] = fsub <2 x float> <float undef, float -0.000000e+00>, [[X:%.*]]
 328 ; CHECK-NEXT:    [[MUL:%.*]] = fmul <2 x float> [[SUB]], [[Y:%.*]]
 329 ; CHECK-NEXT:    ret <2 x float> [[MUL]]
 330 ;
 331   %sub = fsub <2 x float> <float undef, float -0.0>, %x
 332   %mul = fmul <2 x float> %sub, %y
 333   ret <2 x float> %mul
 334 }
 335
 336 ; (0.0 - X) * Y
 337 define float @neg_sink_nsz(float %x, float %y) {
 338 ; CHECK-LABEL: @neg_sink_nsz(
 339 ; CHECK-NEXT:    [[SUB1:%.*]] = fsub nsz float -0.000000e+00, [[X:%.*]]
 340 ; CHECK-NEXT:    [[MUL:%.*]] = fmul float [[SUB1]], [[Y:%.*]]
 341 ; CHECK-NEXT:    ret float [[MUL]]
 342 ;
 343   %sub1 = fsub nsz float 0.0, %x
 344   %mul = fmul float %sub1, %y
 345   ret float %mul
 346 }
 347
 348 define float @neg_sink_multi_use(float %x, float %y) {
 349 ; CHECK-LABEL: @neg_sink_multi_use(
 350 ; CHECK-NEXT:    [[SUB1:%.*]] = fsub float -0.000000e+00, [[X:%.*]]
 351 ; CHECK-NEXT:    [[MUL:%.*]] = fmul float [[SUB1]], [[Y:%.*]]
 352 ; CHECK-NEXT:    [[MUL2:%.*]] = fmul float [[MUL]], [[SUB1]]
 353 ; CHECK-NEXT:    ret float [[MUL2]]
 354 ;
 355   %sub1 = fsub float -0.0, %x
 356   %mul = fmul float %sub1, %y
 357   %mul2 = fmul float %mul, %sub1
 358   ret float %mul2
 359 }
 360
 361 define float @unary_neg_mul_multi_use(float %x, float %y) {
 362 ; CHECK-LABEL: @unary_neg_mul_multi_use(
 363 ; CHECK-NEXT:    [[SUB1:%.*]] = fneg float [[X:%.*]]
 364 ; CHECK-NEXT:    [[MUL:%.*]] = fmul float [[SUB1]], [[Y:%.*]]
 365 ; CHECK-NEXT:    [[MUL2:%.*]] = fmul float [[MUL]], [[SUB1]]
 366 ; CHECK-NEXT:    ret float [[MUL2]]
 367 ;
 368   %sub1 = fneg float %x
 369   %mul = fmul float %sub1, %y
 370   %mul2 = fmul float %mul, %sub1
 371   ret float %mul2
 372 }
 373
 374 ; Don't crash when attempting to cast a constant FMul to an instruction.
 375 define void @test8(i32* %inout) {
 376 ; CHECK-LABEL: @test8(
 377 ; CHECK-NEXT:  entry:
 378 ; CHECK-NEXT:    br label [[FOR_COND:%.*]]
 379 ; CHECK:       for.cond:
 380 ; CHECK-NEXT:    [[LOCAL_VAR_7_0:%.*]] = phi <4 x float> [ <float -0.000000e+00, float -0.000000e+00, float -0.000000e+00, float -0.000000e+00>, [[ENTRY:%.*]] ], [ [[TMP0:%.*]], [[FOR_BODY:%.*]] ]
 381 ; CHECK-NEXT:    br i1 undef, label [[FOR_BODY]], label [[FOR_END:%.*]]
 382 ; CHECK:       for.body:
 383 ; CHECK-NEXT:    [[TMP0]] = insertelement <4 x float> [[LOCAL_VAR_7_0]], float 0.000000e+00, i32 2
 384 ; CHECK-NEXT:    br label [[FOR_COND]]
 385 ; CHECK:       for.end:
 386 ; CHECK-NEXT:    ret void
 387 ;
 388 entry:
 389   %0 = load i32, i32* %inout, align 4
 390   %conv = uitofp i32 %0 to float
 391   %vecinit = insertelement <4 x float> <float 0.000000e+00, float 0.000000e+00, float 0.000000e+00, float undef>, float %conv, i32 3
 392   %sub = fsub <4 x float> <float -0.000000e+00, float -0.000000e+00, float -0.000000e+00, float -0.000000e+00>, %vecinit
 393   %1 = shufflevector <4 x float> %sub, <4 x float> undef, <4 x i32> <i32 1, i32 1, i32 1, i32 1>
 394   %mul = fmul <4 x float> zeroinitializer, %1
 395   br label %for.cond
 396
 397 for.cond:                                         ; preds = %for.body, %entry
 398   %local_var_7.0 = phi <4 x float> [ %mul, %entry ], [ %2, %for.body ]
 399   br i1 undef, label %for.body, label %for.end
 400
 401 for.body:                                         ; preds = %for.cond
 402   %2 = insertelement <4 x float> %local_var_7.0, float 0.000000e+00, i32 2
 403   br label %for.cond
 404
 405 for.end:                                          ; preds = %for.cond
 406   ret void
 407 }
 408
 409 ; X * -1.0 => -0.0 - X
 410 define float @test9(float %x) {
 411 ; CHECK-LABEL: @test9(
 412 ; CHECK-NEXT:    [[MUL:%.*]] = fsub float -0.000000e+00, [[X:%.*]]
 413 ; CHECK-NEXT:    ret float [[MUL]]
 414 ;
 415   %mul = fmul float %x, -1.0
 416   ret float %mul
 417 }
 418
 419 ; PR18532
 420 define <4 x float> @test10(<4 x float> %x) {
 421 ; CHECK-LABEL: @test10(
 422 ; CHECK-NEXT:    [[MUL:%.*]] = fsub arcp afn <4 x float> <float -0.000000e+00, float -0.000000e+00, float -0.000000e+00, float -0.000000e+00>, [[X:%.*]]
 423 ; CHECK-NEXT:    ret <4 x float> [[MUL]]
 424 ;
 425   %mul = fmul arcp afn <4 x float> %x, <float -1.0, float -1.0, float -1.0, float -1.0>
 426   ret <4 x float> %mul
 427 }
 428
 429 define float @test11(float %x, float %y) {
 430 ; CHECK-LABEL: @test11(
 431 ; CHECK-NEXT:    [[B:%.*]] = fadd fast float [[X:%.*]], [[Y:%.*]]
 432 ; CHECK-NEXT:    [[C:%.*]] = fadd fast float [[B]], 3.000000e+00
 433 ; CHECK-NEXT:    ret float [[C]]
 434 ;
 435   %a = fadd fast float %x, 1.0
 436   %b = fadd fast float %y, 2.0
 437   %c = fadd fast float %a, %b
 438   ret float %c
 439 }
 440
 441 declare double @llvm.sqrt.f64(double)
 442
 443 ; With unsafe/fast math, sqrt(X) * sqrt(X) is just X,
 444 ; but make sure another use of the sqrt is intact.
 445 ; Note that the remaining fmul is altered but is not 'fast'
 446 ; itself because it was not marked 'fast' originally.
 447 ; Thus, we have an overall fast result, but no more indication of
 448 ; 'fast'ness in the code.
 449 define double @sqrt_squared2(double %f) {
 450 ; CHECK-LABEL: @sqrt_squared2(
 451 ; CHECK-NEXT:    [[SQRT:%.*]] = call double @llvm.sqrt.f64(double [[F:%.*]])
 452 ; CHECK-NEXT:    [[MUL2:%.*]] = fmul double [[SQRT]], [[F]]
 453 ; CHECK-NEXT:    ret double [[MUL2]]
 454 ;
 455   %sqrt = call double @llvm.sqrt.f64(double %f)
 456   %mul1 = fmul fast double %sqrt, %sqrt
 457   %mul2 = fmul double %mul1, %sqrt
 458   ret double %mul2
 459 }
 460
 461 declare float @llvm.fabs.f32(float) nounwind readnone
 462
 463 define float @fabs_squared(float %x) {
 464 ; CHECK-LABEL: @fabs_squared(
 465 ; CHECK-NEXT:    [[MUL:%.*]] = fmul float [[X:%.*]], [[X]]
 466 ; CHECK-NEXT:    ret float [[MUL]]
 467 ;
 468   %x.fabs = call float @llvm.fabs.f32(float %x)
 469   %mul = fmul float %x.fabs, %x.fabs
 470   ret float %mul
 471 }
 472
 473 define float @fabs_squared_fast(float %x) {
 474 ; CHECK-LABEL: @fabs_squared_fast(
 475 ; CHECK-NEXT:    [[MUL:%.*]] = fmul fast float [[X:%.*]], [[X]]
 476 ; CHECK-NEXT:    ret float [[MUL]]
 477 ;
 478   %x.fabs = call float @llvm.fabs.f32(float %x)
 479   %mul = fmul fast float %x.fabs, %x.fabs
 480   ret float %mul
 481 }
 482
 483 define float @fabs_x_fabs(float %x, float %y) {
 484 ; CHECK-LABEL: @fabs_x_fabs(
 485 ; CHECK-NEXT:    [[X_FABS:%.*]] = call float @llvm.fabs.f32(float [[X:%.*]])
 486 ; CHECK-NEXT:    [[Y_FABS:%.*]] = call float @llvm.fabs.f32(float [[Y:%.*]])
 487 ; CHECK-NEXT:    [[MUL:%.*]] = fmul float [[X_FABS]], [[Y_FABS]]
 488 ; CHECK-NEXT:    ret float [[MUL]]
 489 ;
 490   %x.fabs = call float @llvm.fabs.f32(float %x)
 491   %y.fabs = call float @llvm.fabs.f32(float %y)
 492   %mul = fmul float %x.fabs, %y.fabs
 493   ret float %mul
 494 }
 495
 496 ; (X*Y) * X => (X*X) * Y
 497 ; The transform only requires 'reassoc', but test other FMF in
 498 ; the commuted variants to make sure FMF propagates as expected.
 499
 500 define float @reassoc_common_operand1(float %x, float %y) {
 501 ; CHECK-LABEL: @reassoc_common_operand1(
 502 ; CHECK-NEXT:    [[TMP1:%.*]] = fmul reassoc float [[X:%.*]], [[X]]
 503 ; CHECK-NEXT:    [[MUL2:%.*]] = fmul reassoc float [[TMP1]], [[Y:%.*]]
 504 ; CHECK-NEXT:    ret float [[MUL2]]
 505 ;
 506   %mul1 = fmul float %x, %y
 507   %mul2 = fmul reassoc float %mul1, %x
 508   ret float %mul2
 509 }
 510
 511 ; (Y*X) * X => (X*X) * Y
 512
 513 define float @reassoc_common_operand2(float %x, float %y) {
 514 ; CHECK-LABEL: @reassoc_common_operand2(
 515 ; CHECK-NEXT:    [[TMP1:%.*]] = fmul fast float [[X:%.*]], [[X]]
 516 ; CHECK-NEXT:    [[MUL2:%.*]] = fmul fast float [[TMP1]], [[Y:%.*]]
 517 ; CHECK-NEXT:    ret float [[MUL2]]
 518 ;
 519   %mul1 = fmul float %y, %x
 520   %mul2 = fmul fast float %mul1, %x
 521   ret float %mul2
 522 }
 523
 524 ; X * (X*Y) => (X*X) * Y
 525
 526 define float @reassoc_common_operand3(float %x1, float %y) {
 527 ; CHECK-LABEL: @reassoc_common_operand3(
 528 ; CHECK-NEXT:    [[X:%.*]] = fdiv float [[X1:%.*]], 3.000000e+00
 529 ; CHECK-NEXT:    [[TMP1:%.*]] = fmul reassoc nnan float [[X]], [[X]]
 530 ; CHECK-NEXT:    [[MUL2:%.*]] = fmul reassoc nnan float [[TMP1]], [[Y:%.*]]
 531 ; CHECK-NEXT:    ret float [[MUL2]]
 532 ;
 533   %x = fdiv float %x1, 3.0 ; thwart complexity-based canonicalization
 534   %mul1 = fmul float %x, %y
 535   %mul2 = fmul reassoc nnan float %x, %mul1
 536   ret float %mul2
 537 }
 538
 539 ; X * (Y*X) => (X*X) * Y
 540
 541 define float @reassoc_common_operand4(float %x1, float %y) {
 542 ; CHECK-LABEL: @reassoc_common_operand4(
 543 ; CHECK-NEXT:    [[X:%.*]] = fdiv float [[X1:%.*]], 3.000000e+00
 544 ; CHECK-NEXT:    [[TMP1:%.*]] = fmul reassoc ninf float [[X]], [[X]]
 545 ; CHECK-NEXT:    [[MUL2:%.*]] = fmul reassoc ninf float [[TMP1]], [[Y:%.*]]
 546 ; CHECK-NEXT:    ret float [[MUL2]]
 547 ;
 548   %x = fdiv float %x1, 3.0 ; thwart complexity-based canonicalization
 549   %mul1 = fmul float %y, %x
 550   %mul2 = fmul reassoc ninf float %x, %mul1
 551   ret float %mul2
 552 }
 553
 554 ; No change if the first fmul has another use.
 555
 556 define float @reassoc_common_operand_multi_use(float %x, float %y) {
 557 ; CHECK-LABEL: @reassoc_common_operand_multi_use(
 558 ; CHECK-NEXT:    [[MUL1:%.*]] = fmul float [[X:%.*]], [[Y:%.*]]
 559 ; CHECK-NEXT:    [[MUL2:%.*]] = fmul fast float [[MUL1]], [[X]]
 560 ; CHECK-NEXT:    call void @use_f32(float [[MUL1]])
 561 ; CHECK-NEXT:    ret float [[MUL2]]
 562 ;
 563   %mul1 = fmul float %x, %y
 564   %mul2 = fmul fast float %mul1, %x
 565   call void @use_f32(float %mul1)
 566   ret float %mul2
 567 }
 568
 569 declare float @llvm.log2.f32(float)
 570
 571 ; log2(Y * 0.5) * X = log2(Y) * X - X
 572
 573 define float @log2half(float %x, float %y) {
 574 ; CHECK-LABEL: @log2half(
 575 ; CHECK-NEXT:    [[LOG2:%.*]] = call fast float @llvm.log2.f32(float [[Y:%.*]])
 576 ; CHECK-NEXT:    [[TMP1:%.*]] = fmul fast float [[LOG2]], [[X:%.*]]
 577 ; CHECK-NEXT:    [[MUL:%.*]] = fsub fast float [[TMP1]], [[X]]
 578 ; CHECK-NEXT:    ret float [[MUL]]
 579 ;
 580   %halfy = fmul float %y, 0.5
 581   %log2 = call float @llvm.log2.f32(float %halfy)
 582   %mul = fmul fast float %log2, %x
 583   ret float %mul
 584 }
 585
 586 define float @log2half_commute(float %x1, float %y) {
 587 ; CHECK-LABEL: @log2half_commute(
 588 ; CHECK-NEXT:    [[LOG2:%.*]] = call fast float @llvm.log2.f32(float [[Y:%.*]])
 589 ; CHECK-NEXT:    [[TMP1:%.*]] = fmul fast float [[LOG2]], [[X1:%.*]]
 590 ; CHECK-NEXT:    [[TMP2:%.*]] = fsub fast float [[TMP1]], [[X1]]
 591 ; CHECK-NEXT:    [[MUL:%.*]] = fmul fast float [[TMP2]], 0x3FC24924A0000000
 592 ; CHECK-NEXT:    ret float [[MUL]]
 593 ;
 594   %x = fdiv float %x1, 7.0 ; thwart complexity-based canonicalization
 595   %halfy = fmul float %y, 0.5
 596   %log2 = call float @llvm.log2.f32(float %halfy)
 597   %mul = fmul fast float %x, %log2
 598   ret float %mul
 599 }
 600
 601 ; C1/X * C2 => (C1*C2) / X
 602
 603 define float @fdiv_constant_numerator_fmul(float %x) {
 604 ; CHECK-LABEL: @fdiv_constant_numerator_fmul(
 605 ; CHECK-NEXT:    [[T3:%.*]] = fdiv reassoc float 1.200000e+07, [[X:%.*]]
 606 ; CHECK-NEXT:    ret float [[T3]]
 607 ;
 608   %t1 = fdiv float 2.0e+3, %x
 609   %t3 = fmul reassoc float %t1, 6.0e+3
 610   ret float %t3
 611 }
 612
 613 ; C1/X * C2 => (C1*C2) / X is disabled if C1/X has multiple uses
 614
 615 @fmul2_external = external global float
 616
 617 define float @fdiv_constant_numerator_fmul_extra_use(float %x) {
 618 ; CHECK-LABEL: @fdiv_constant_numerator_fmul_extra_use(
 619 ; CHECK-NEXT:    [[DIV:%.*]] = fdiv fast float 1.000000e+00, [[X:%.*]]
 620 ; CHECK-NEXT:    store float [[DIV]], float* @fmul2_external, align 4
 621 ; CHECK-NEXT:    [[MUL:%.*]] = fmul fast float [[DIV]], 2.000000e+00
 622 ; CHECK-NEXT:    ret float [[MUL]]
 623 ;
 624   %div = fdiv fast float 1.0, %x
 625   store float %div, float* @fmul2_external
 626   %mul = fmul fast float %div, 2.0
 627   ret float %mul
 628 }
 629
 630 ; X/C1 * C2 => X * (C2/C1) (if C2/C1 is normal FP)
 631
 632 define float @fdiv_constant_denominator_fmul(float %x) {
 633 ; CHECK-LABEL: @fdiv_constant_denominator_fmul(
 634 ; CHECK-NEXT:    [[T3:%.*]] = fmul reassoc float [[X:%.*]], 3.000000e+00
 635 ; CHECK-NEXT:    ret float [[T3]]
 636 ;
 637   %t1 = fdiv float %x, 2.0e+3
 638   %t3 = fmul reassoc float %t1, 6.0e+3
 639   ret float %t3
 640 }
 641
 642 define <4 x float> @fdiv_constant_denominator_fmul_vec(<4 x float> %x) {
 643 ; CHECK-LABEL: @fdiv_constant_denominator_fmul_vec(
 644 ; CHECK-NEXT:    [[T3:%.*]] = fmul reassoc <4 x float> [[X:%.*]], <float 3.000000e+00, float 2.000000e+00, float 1.000000e+00, float 1.000000e+00>
 645 ; CHECK-NEXT:    ret <4 x float> [[T3]]
 646 ;
 647   %t1 = fdiv <4 x float> %x, <float 2.0e+3, float 3.0e+3, float 2.0e+3, float 1.0e+3>
 648   %t3 = fmul reassoc <4 x float> %t1, <float 6.0e+3, float 6.0e+3, float 2.0e+3, float 1.0e+3>
 649   ret <4 x float> %t3
 650 }
 651
 652 ; Make sure fmul with constant expression doesn't assert.
 653
 654 define <4 x float> @fdiv_constant_denominator_fmul_vec_constexpr(<4 x float> %x) {
 655 ; CHECK-LABEL: @fdiv_constant_denominator_fmul_vec_constexpr(
 656 ; CHECK-NEXT:    [[T3:%.*]] = fmul reassoc <4 x float> [[X:%.*]], <float 3.000000e+00, float 2.000000e+00, float 1.000000e+00, float 1.000000e+00>
 657 ; CHECK-NEXT:    ret <4 x float> [[T3]]
 658 ;
 659   %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>
 660   %t1 = fdiv <4 x float> %x, <float 2.0e+3, float 3.0e+3, float 2.0e+3, float 1.0e+3>
 661   %t3 = fmul reassoc <4 x float> %t1, %constExprMul
 662   ret <4 x float> %t3
 663 }
 664
 665 ; This shows that at least part of instcombine does not check constant
 666 ; values to see if it is creating denorms (0x3800000000000000 is a denorm
 667 ; for 32-bit float), so protecting against denorms in other parts is
 668 ; probably not doing the intended job.
 669
 670 define float @fmul_constant_reassociation(float %x) {
 671 ; CHECK-LABEL: @fmul_constant_reassociation(
 672 ; CHECK-NEXT:    [[R:%.*]] = fmul reassoc nsz float [[X:%.*]], 0x3800000000000000
 673 ; CHECK-NEXT:    ret float [[R]]
 674 ;
 675   %mul_flt_min = fmul reassoc nsz float %x, 0x3810000000000000
 676   %r = fmul reassoc nsz float  %mul_flt_min, 0.5
 677   ret float %r
 678 }
 679
 680 ; Canonicalization "X/C1 * C2 => X * (C2/C1)" still applies if C2/C1 is denormal
 681 ; (otherwise, we should not have allowed the reassociation in the previous test).
 682 ; 0x3810000000000000 == FLT_MIN
 683
 684 define float @fdiv_constant_denominator_fmul_denorm(float %x) {
 685 ; CHECK-LABEL: @fdiv_constant_denominator_fmul_denorm(
 686 ; CHECK-NEXT:    [[T3:%.*]] = fmul fast float [[X:%.*]], 0x3760620000000000
 687 ; CHECK-NEXT:    ret float [[T3]]
 688 ;
 689   %t1 = fdiv float %x, 2.0e+3
 690   %t3 = fmul fast float %t1, 0x3810000000000000
 691   ret float %t3
 692 }
 693
 694 ; X / C1 * C2 => X / (C2/C1) if C1/C2 is abnormal, but C2/C1 is a normal value.
 695 ; TODO: We don't convert the fast fdiv to fmul because that would be multiplication
 696 ; by a denormal, but we could do better when we know that denormals are not a problem.
 697
 698 define float @fdiv_constant_denominator_fmul_denorm_try_harder(float %x) {
 699 ; CHECK-LABEL: @fdiv_constant_denominator_fmul_denorm_try_harder(
 700 ; CHECK-NEXT:    [[T3:%.*]] = fdiv reassoc float [[X:%.*]], 0x47E8000000000000
 701 ; CHECK-NEXT:    ret float [[T3]]
 702 ;
 703   %t1 = fdiv float %x, 3.0
 704   %t3 = fmul reassoc float %t1, 0x3810000000000000
 705   ret float %t3
 706 }
 707
 708 ; Negative test: we should not have 2 divisions instead of the 1 we started with.
 709
 710 define float @fdiv_constant_denominator_fmul_denorm_try_harder_extra_use(float %x) {
 711 ; CHECK-LABEL: @fdiv_constant_denominator_fmul_denorm_try_harder_extra_use(
 712 ; CHECK-NEXT:    [[T1:%.*]] = fdiv float [[X:%.*]], 3.000000e+00
 713 ; CHECK-NEXT:    [[T3:%.*]] = fmul fast float [[T1]], 0x3810000000000000
 714 ; CHECK-NEXT:    [[R:%.*]] = fadd float [[T1]], [[T3]]
 715 ; CHECK-NEXT:    ret float [[R]]
 716 ;
 717   %t1 = fdiv float %x, 3.0e+0
 718   %t3 = fmul fast float %t1, 0x3810000000000000
 719   %r = fadd float %t1, %t3
 720   ret float %r
 721 }
 722
 723 ; (X + C1) * C2 --> (X * C2) + C1*C2
 724
 725 define float @fmul_fadd_distribute(float %x) {
 726 ; CHECK-LABEL: @fmul_fadd_distribute(
 727 ; CHECK-NEXT:    [[TMP1:%.*]] = fmul reassoc float [[X:%.*]], 3.000000e+00
 728 ; CHECK-NEXT:    [[T3:%.*]] = fadd reassoc float [[TMP1]], 6.000000e+00
 729 ; CHECK-NEXT:    ret float [[T3]]
 730 ;
 731   %t2 = fadd float %x, 2.0
 732   %t3 = fmul reassoc float %t2, 3.0
 733   ret float %t3
 734 }
 735
 736 ; (X - C1) * C2 --> (X * C2) - C1*C2
 737
 738 define float @fmul_fsub_distribute1(float %x) {
 739 ; CHECK-LABEL: @fmul_fsub_distribute1(
 740 ; CHECK-NEXT:    [[TMP1:%.*]] = fmul reassoc float [[X:%.*]], 3.000000e+00
 741 ; CHECK-NEXT:    [[T3:%.*]] = fadd reassoc float [[TMP1]], -6.000000e+00
 742 ; CHECK-NEXT:    ret float [[T3]]
 743 ;
 744   %t2 = fsub float %x, 2.0
 745   %t3 = fmul reassoc float %t2, 3.0
 746   ret float %t3
 747 }
 748
 749 ; (C1 - X) * C2 --> C1*C2 - (X * C2)
 750
 751 define float @fmul_fsub_distribute2(float %x) {
 752 ; CHECK-LABEL: @fmul_fsub_distribute2(
 753 ; CHECK-NEXT:    [[TMP1:%.*]] = fmul reassoc float [[X:%.*]], 3.000000e+00
 754 ; CHECK-NEXT:    [[T3:%.*]] = fsub reassoc float 6.000000e+00, [[TMP1]]
 755 ; CHECK-NEXT:    ret float [[T3]]
 756 ;
 757   %t2 = fsub float 2.0, %x
 758   %t3 = fmul reassoc float %t2, 3.0
 759   ret float %t3
 760 }
 761
 762 ; FIXME: This should only need 'reassoc'.
 763 ; ((X*C1) + C2) * C3 => (X * (C1*C3)) + (C2*C3)
 764
 765 define float @fmul_fadd_fmul_distribute(float %x) {
 766 ; CHECK-LABEL: @fmul_fadd_fmul_distribute(
 767 ; CHECK-NEXT:    [[TMP1:%.*]] = fmul fast float [[X:%.*]], 3.000000e+01
 768 ; CHECK-NEXT:    [[T3:%.*]] = fadd fast float [[TMP1]], 1.000000e+01
 769 ; CHECK-NEXT:    ret float [[T3]]
 770 ;
 771   %t1 = fmul float %x, 6.0
 772   %t2 = fadd float %t1, 2.0
 773   %t3 = fmul fast float %t2, 5.0
 774   ret float %t3
 775 }
 776
 777 define float @fmul_fadd_distribute_extra_use(float %x) {
 778 ; CHECK-LABEL: @fmul_fadd_distribute_extra_use(
 779 ; CHECK-NEXT:    [[T1:%.*]] = fmul float [[X:%.*]], 6.000000e+00
 780 ; CHECK-NEXT:    [[T2:%.*]] = fadd float [[T1]], 2.000000e+00
 781 ; CHECK-NEXT:    [[T3:%.*]] = fmul fast float [[T2]], 5.000000e+00
 782 ; CHECK-NEXT:    call void @use_f32(float [[T2]])
 783 ; CHECK-NEXT:    ret float [[T3]]
 784 ;
 785   %t1 = fmul float %x, 6.0
 786   %t2 = fadd float %t1, 2.0
 787   %t3 = fmul fast float %t2, 5.0
 788   call void @use_f32(float %t2)
 789   ret float %t3
 790 }
 791
 792 ; (X/C1 + C2) * C3 => X/(C1/C3) + C2*C3
 793 ; 0x10000000000000 = DBL_MIN
 794 ; TODO: We don't convert the fast fdiv to fmul because that would be multiplication
 795 ; by a denormal, but we could do better when we know that denormals are not a problem.
 796
 797 define double @fmul_fadd_fdiv_distribute2(double %x) {
 798 ; CHECK-LABEL: @fmul_fadd_fdiv_distribute2(
 799 ; CHECK-NEXT:    [[TMP1:%.*]] = fdiv reassoc double [[X:%.*]], 0x7FE8000000000000
 800 ; CHECK-NEXT:    [[T3:%.*]] = fadd reassoc double [[TMP1]], 0x34000000000000
 801 ; CHECK-NEXT:    ret double [[T3]]
 802 ;
 803   %t1 = fdiv double %x, 3.0
 804   %t2 = fadd double %t1, 5.0
 805   %t3 = fmul reassoc double %t2, 0x10000000000000
 806   ret double %t3
 807 }
 808
 809 ; 5.0e-1 * DBL_MIN yields denormal, so "(f1*3.0 + 5.0e-1) * DBL_MIN" cannot
 810 ; be simplified into f1 * (3.0*DBL_MIN) + (5.0e-1*DBL_MIN)
 811
 812 define double @fmul_fadd_fdiv_distribute3(double %x) {
 813 ; CHECK-LABEL: @fmul_fadd_fdiv_distribute3(
 814 ; CHECK-NEXT:    [[TMP1:%.*]] = fdiv reassoc double [[X:%.*]], 0x7FE8000000000000
 815 ; CHECK-NEXT:    [[T3:%.*]] = fadd reassoc double [[TMP1]], 0x34000000000000
 816 ; CHECK-NEXT:    ret double [[T3]]
 817 ;
 818   %t1 = fdiv double %x, 3.0
 819   %t2 = fadd double %t1, 5.0
 820   %t3 = fmul reassoc double %t2, 0x10000000000000
 821   ret double %t3
 822 }
 823
 824 ; FIXME: This should only need 'reassoc'.
 825 ; (C2 - (X*C1)) * C3 => (C2*C3) - (X * (C1*C3))
 826
 827 define float @fmul_fsub_fmul_distribute(float %x) {
 828 ; CHECK-LABEL: @fmul_fsub_fmul_distribute(
 829 ; CHECK-NEXT:    [[TMP1:%.*]] = fmul fast float [[X:%.*]], 3.000000e+01
 830 ; CHECK-NEXT:    [[T3:%.*]] = fsub fast float 1.000000e+01, [[TMP1]]
 831 ; CHECK-NEXT:    ret float [[T3]]
 832 ;
 833   %t1 = fmul float %x, 6.0
 834   %t2 = fsub float 2.0, %t1
 835   %t3 = fmul fast float %t2, 5.0
 836   ret float %t3
 837 }
 838
 839 define float @fmul_fsub_fmul_distribute_extra_use(float %x) {
 840 ; CHECK-LABEL: @fmul_fsub_fmul_distribute_extra_use(
 841 ; CHECK-NEXT:    [[T1:%.*]] = fmul float [[X:%.*]], 6.000000e+00
 842 ; CHECK-NEXT:    [[T2:%.*]] = fsub float 2.000000e+00, [[T1]]
 843 ; CHECK-NEXT:    [[T3:%.*]] = fmul fast float [[T2]], 5.000000e+00
 844 ; CHECK-NEXT:    call void @use_f32(float [[T2]])
 845 ; CHECK-NEXT:    ret float [[T3]]
 846 ;
 847   %t1 = fmul float %x, 6.0
 848   %t2 = fsub float 2.0, %t1
 849   %t3 = fmul fast float %t2, 5.0
 850   call void @use_f32(float %t2)
 851   ret float %t3
 852 }
 853
 854 ; FIXME: This should only need 'reassoc'.
 855 ; ((X*C1) - C2) * C3 => (X * (C1*C3)) - C2*C3
 856
 857 define float @fmul_fsub_fmul_distribute2(float %x) {
 858 ; CHECK-LABEL: @fmul_fsub_fmul_distribute2(
 859 ; CHECK-NEXT:    [[TMP1:%.*]] = fmul fast float [[X:%.*]], 3.000000e+01
 860 ; CHECK-NEXT:    [[T3:%.*]] = fadd fast float [[TMP1]], -1.000000e+01
 861 ; CHECK-NEXT:    ret float [[T3]]
 862 ;
 863   %t1 = fmul float %x, 6.0
 864   %t2 = fsub float %t1, 2.0
 865   %t3 = fmul fast float %t2, 5.0
 866   ret float %t3
 867 }
 868
 869 define float @fmul_fsub_fmul_distribute2_extra_use(float %x) {
 870 ; CHECK-LABEL: @fmul_fsub_fmul_distribute2_extra_use(
 871 ; CHECK-NEXT:    [[T1:%.*]] = fmul float [[X:%.*]], 6.000000e+00
 872 ; CHECK-NEXT:    [[T2:%.*]] = fsub float 2.000000e+00, [[T1]]
 873 ; CHECK-NEXT:    [[T3:%.*]] = fmul fast float [[T2]], 5.000000e+00
 874 ; CHECK-NEXT:    call void @use_f32(float [[T2]])
 875 ; CHECK-NEXT:    ret float [[T3]]
 876 ;
 877   %t1 = fmul float %x, 6.0
 878   %t2 = fsub float 2.0, %t1
 879   %t3 = fmul fast float %t2, 5.0
 880   call void @use_f32(float %t2)
 881   ret float %t3
 882 }
 883
 884 ; "(X*Y) * X => (X*X) * Y" is disabled if "X*Y" has multiple uses
 885
 886 define float @common_factor(float %x, float %y) {
 887 ; CHECK-LABEL: @common_factor(
 888 ; CHECK-NEXT:    [[MUL:%.*]] = fmul float [[X:%.*]], [[Y:%.*]]
 889 ; CHECK-NEXT:    [[MUL1:%.*]] = fmul fast float [[MUL]], [[X]]
 890 ; CHECK-NEXT:    [[ADD:%.*]] = fadd float [[MUL1]], [[MUL]]
 891 ; CHECK-NEXT:    ret float [[ADD]]
 892 ;
 893   %mul = fmul float %x, %y
 894   %mul1 = fmul fast float %mul, %x
 895   %add = fadd float %mul1, %mul
 896   ret float %add
 897 }
 898
 899 define double @fmul_fdiv_factor_squared(double %x, double %y) {
 900 ; CHECK-LABEL: @fmul_fdiv_factor_squared(
 901 ; CHECK-NEXT:    [[DIV:%.*]] = fdiv fast double [[X:%.*]], [[Y:%.*]]
 902 ; CHECK-NEXT:    [[SQUARED:%.*]] = fmul fast double [[DIV]], [[DIV]]
 903 ; CHECK-NEXT:    ret double [[SQUARED]]
 904 ;
 905   %div = fdiv fast double %x, %y
 906   %squared = fmul fast double %div, %div
 907   ret double %squared
 908 }
 909
 910 define double @fmul_fdivs_factor_common_denominator(double %x, double %y, double %z) {
 911 ; CHECK-LABEL: @fmul_fdivs_factor_common_denominator(
 912 ; CHECK-NEXT:    [[TMP1:%.*]] = fmul fast double [[Y:%.*]], [[X:%.*]]
 913 ; CHECK-NEXT:    [[TMP2:%.*]] = fmul fast double [[Z:%.*]], [[Z]]
 914 ; CHECK-NEXT:    [[MUL:%.*]] = fdiv fast double [[TMP1]], [[TMP2]]
 915 ; CHECK-NEXT:    ret double [[MUL]]
 916 ;
 917   %div1 = fdiv double %x, %z
 918   %div2 = fdiv double %y, %z
 919   %mul = fmul fast double %div1, %div2
 920   ret double %mul
 921 }
 922
 923 define double @fmul_fdivs_factor(double %x, double %y, double %z, double %w) {
 924 ; CHECK-LABEL: @fmul_fdivs_factor(
 925 ; CHECK-NEXT:    [[TMP1:%.*]] = fmul reassoc double [[Z:%.*]], [[X:%.*]]
 926 ; CHECK-NEXT:    [[TMP2:%.*]] = fdiv reassoc double [[TMP1]], [[W:%.*]]
 927 ; CHECK-NEXT:    [[MUL:%.*]] = fdiv reassoc double [[TMP2]], [[Y:%.*]]
 928 ; CHECK-NEXT:    ret double [[MUL]]
 929 ;
 930   %div1 = fdiv double %x, %y
 931   %div2 = fdiv double %z, %w
 932   %mul = fmul reassoc double %div1, %div2
 933   ret double %mul
 934 }
 935
 936 define double @fmul_fdiv_factor(double %x, double %y, double %z) {
 937 ; CHECK-LABEL: @fmul_fdiv_factor(
 938 ; CHECK-NEXT:    [[TMP1:%.*]] = fmul reassoc double [[X:%.*]], [[Z:%.*]]
 939 ; CHECK-NEXT:    [[MUL:%.*]] = fdiv reassoc double [[TMP1]], [[Y:%.*]]
 940 ; CHECK-NEXT:    ret double [[MUL]]
 941 ;
 942   %div = fdiv double %x, %y
 943   %mul = fmul reassoc double %div, %z
 944   ret double %mul
 945 }
 946
 947 define double @fmul_fdiv_factor_constant1(double %x, double %y) {
 948 ; CHECK-LABEL: @fmul_fdiv_factor_constant1(
 949 ; CHECK-NEXT:    [[TMP1:%.*]] = fmul reassoc double [[X:%.*]], 4.200000e+01
 950 ; CHECK-NEXT:    [[MUL:%.*]] = fdiv reassoc double [[TMP1]], [[Y:%.*]]
 951 ; CHECK-NEXT:    ret double [[MUL]]
 952 ;
 953   %div = fdiv double %x, %y
 954   %mul = fmul reassoc double %div, 42.0
 955   ret double %mul
 956 }
 957
 958 define <2 x float> @fmul_fdiv_factor_constant2(<2 x float> %x, <2 x float> %y) {
 959 ; CHECK-LABEL: @fmul_fdiv_factor_constant2(
 960 ; CHECK-NEXT:    [[TMP1:%.*]] = fmul reassoc <2 x float> [[X:%.*]], [[Y:%.*]]
 961 ; CHECK-NEXT:    [[MUL:%.*]] = fdiv reassoc <2 x float> [[TMP1]], <float 4.200000e+01, float 1.200000e+01>
 962 ; CHECK-NEXT:    ret <2 x float> [[MUL]]
 963 ;
 964   %div = fdiv <2 x float> %x, <float 42.0, float 12.0>
 965   %mul = fmul reassoc <2 x float> %div, %y
 966   ret <2 x float> %mul
 967 }
 968
 969 define float @fmul_fdiv_factor_extra_use(float %x, float %y) {
 970 ; CHECK-LABEL: @fmul_fdiv_factor_extra_use(
 971 ; CHECK-NEXT:    [[DIV:%.*]] = fdiv float [[X:%.*]], 4.200000e+01
 972 ; CHECK-NEXT:    call void @use_f32(float [[DIV]])
 973 ; CHECK-NEXT:    [[MUL:%.*]] = fmul reassoc float [[DIV]], [[Y:%.*]]
 974 ; CHECK-NEXT:    ret float [[MUL]]
 975 ;
 976   %div = fdiv float %x, 42.0
 977   call void @use_f32(float %div)
 978   %mul = fmul reassoc float %div, %y
 979   ret float %mul
 980 }
 981
 982 ; Avoid infinite looping by moving negation out of a constant expression.
 983
 984 @g = external global {[2 x i8*]}, align 1
 985
 986 define double @fmul_negated_constant_expression(double %x) {
 987 ; CHECK-LABEL: @fmul_negated_constant_expression(
 988 ; CHECK-NEXT:    [[R:%.*]] = fmul double [[X:%.*]], fsub (double -0.000000e+00, double bitcast (i64 ptrtoint (i8** getelementptr inbounds ({ [2 x i8*] }, { [2 x i8*] }* @g, i64 0, inrange i32 0, i64 2) to i64) to double))
 989 ; CHECK-NEXT:    ret double [[R]]
 990 ;
 991   %r = fmul double %x, fsub (double -0.000000e+00, double bitcast (i64 ptrtoint (i8** getelementptr inbounds ({ [2 x i8*] }, { [2 x i8*] }* @g, i64 0, inrange i32 0, i64 2) to i64) to double))
 992   ret double %r
 993 }
 994
 995 define float @negate_if_true(float %x, i1 %cond) {
 996 ; CHECK-LABEL: @negate_if_true(
 997 ; CHECK-NEXT:    [[TMP1:%.*]] = fneg float [[X:%.*]]
 998 ; CHECK-NEXT:    [[TMP2:%.*]] = select i1 [[COND:%.*]], float [[TMP1]], float [[X]]
 999 ; CHECK-NEXT:    ret float [[TMP2]]
1000 ;
1001   %sel = select i1 %cond, float -1.0, float 1.0
1002   %r = fmul float %sel, %x
1003   ret float %r
1004 }
1005
1006 define float @negate_if_false(float %x, i1 %cond) {
1007 ; CHECK-LABEL: @negate_if_false(
1008 ; CHECK-NEXT:    [[TMP1:%.*]] = fneg arcp float [[X:%.*]]
1009 ; CHECK-NEXT:    [[TMP2:%.*]] = select arcp i1 [[COND:%.*]], float [[X]], float [[TMP1]]
1010 ; CHECK-NEXT:    ret float [[TMP2]]
1011 ;
1012   %sel = select i1 %cond, float 1.0, float -1.0
1013   %r = fmul arcp float %sel, %x
1014   ret float %r
1015 }
1016
1017 define <2 x double> @negate_if_true_commute(<2 x double> %px, i1 %cond) {
1018 ; CHECK-LABEL: @negate_if_true_commute(
1019 ; CHECK-NEXT:    [[X:%.*]] = fdiv <2 x double> <double 4.200000e+01, double 4.200000e+01>, [[PX:%.*]]
1020 ; CHECK-NEXT:    [[TMP1:%.*]] = fneg ninf <2 x double> [[X]]
1021 ; CHECK-NEXT:    [[TMP2:%.*]] = select ninf i1 [[COND:%.*]], <2 x double> [[TMP1]], <2 x double> [[X]]
1022 ; CHECK-NEXT:    ret <2 x double> [[TMP2]]
1023 ;
1024   %x = fdiv <2 x double> <double 42.0, double 42.0>, %px  ; thwart complexity-based canonicalization
1025   %sel = select i1 %cond, <2 x double> <double -1.0, double -1.0>, <2 x double> <double 1.0, double 1.0>
1026   %r = fmul ninf <2 x double> %x, %sel
1027   ret <2 x double> %r
1028 }
1029
1030 define <2 x double> @negate_if_false_commute(<2 x double> %px, <2 x i1> %cond) {
1031 ; CHECK-LABEL: @negate_if_false_commute(
1032 ; CHECK-NEXT:    [[X:%.*]] = fdiv <2 x double> <double 4.200000e+01, double 5.100000e+00>, [[PX:%.*]]
1033 ; CHECK-NEXT:    [[TMP1:%.*]] = fneg <2 x double> [[X]]
1034 ; CHECK-NEXT:    [[TMP2:%.*]] = select <2 x i1> [[COND:%.*]], <2 x double> [[X]], <2 x double> [[TMP1]]
1035 ; CHECK-NEXT:    ret <2 x double> [[TMP2]]
1036 ;
1037   %x = fdiv <2 x double> <double 42.0, double 5.1>, %px  ; thwart complexity-based canonicalization
1038   %sel = select <2 x i1> %cond, <2 x double> <double 1.0, double 1.0>, <2 x double> <double -1.0, double -1.0>
1039   %r = fmul <2 x double> %x, %sel
1040   ret <2 x double> %r
1041 }
1042
1043 ; Negative test
1044
1045 define float @negate_if_true_extra_use(float %x, i1 %cond) {
1046 ; CHECK-LABEL: @negate_if_true_extra_use(
1047 ; CHECK-NEXT:    [[SEL:%.*]] = select i1 [[COND:%.*]], float -1.000000e+00, float 1.000000e+00
1048 ; CHECK-NEXT:    call void @use_f32(float [[SEL]])
1049 ; CHECK-NEXT:    [[R:%.*]] = fmul float [[SEL]], [[X:%.*]]
1050 ; CHECK-NEXT:    ret float [[R]]
1051 ;
1052   %sel = select i1 %cond, float -1.0, float 1.0
1053   call void @use_f32(float %sel)
1054   %r = fmul float %sel, %x
1055   ret float %r
1056 }
1057
1058 ; Negative test
1059
1060 define <2 x double> @negate_if_true_wrong_constant(<2 x double> %px, i1 %cond) {
1061 ; CHECK-LABEL: @negate_if_true_wrong_constant(
1062 ; CHECK-NEXT:    [[X:%.*]] = fdiv <2 x double> <double 4.200000e+01, double 4.200000e+01>, [[PX:%.*]]
1063 ; CHECK-NEXT:    [[SEL:%.*]] = select i1 [[COND:%.*]], <2 x double> <double -1.000000e+00, double 0.000000e+00>, <2 x double> <double 1.000000e+00, double 1.000000e+00>
1064 ; CHECK-NEXT:    [[R:%.*]] = fmul <2 x double> [[X]], [[SEL]]
1065 ; CHECK-NEXT:    ret <2 x double> [[R]]
1066 ;
1067   %x = fdiv <2 x double> <double 42.0, double 42.0>, %px  ; thwart complexity-based canonicalization
1068   %sel = select i1 %cond, <2 x double> <double -1.0, double 0.0>, <2 x double> <double 1.0, double 1.0>
1069   %r = fmul <2 x double> %x, %sel
1070   ret <2 x double> %r
1071 }
1072
1073 ; X *fast (C ? 1.0 : 0.0) -> C ? X : 0.0
1074 define float @fmul_select(float %x, i1 %c) {
1075 ; CHECK-LABEL: @fmul_select(
1076 ; CHECK-NEXT:    [[SEL:%.*]] = select i1 [[C:%.*]], float 1.000000e+00, float 0.000000e+00
1077 ; CHECK-NEXT:    [[MUL:%.*]] = fmul fast float [[SEL]], [[X:%.*]]
1078 ; CHECK-NEXT:    ret float [[MUL]]
1079 ;
1080   %sel = select i1 %c, float 1.0, float 0.0
1081   %mul = fmul fast float %sel, %x
1082   ret float %mul
1083 }
1084
1085 ; X *fast (C ? 1.0 : 0.0) -> C ? X : 0.0
1086 define <2 x float> @fmul_select_vec(<2 x float> %x, i1 %c) {
1087 ; CHECK-LABEL: @fmul_select_vec(
1088 ; CHECK-NEXT:    [[SEL:%.*]] = select i1 [[C:%.*]], <2 x float> <float 1.000000e+00, float 1.000000e+00>, <2 x float> zeroinitializer
1089 ; CHECK-NEXT:    [[MUL:%.*]] = fmul fast <2 x float> [[SEL]], [[X:%.*]]
1090 ; CHECK-NEXT:    ret <2 x float> [[MUL]]
1091 ;
1092   %sel = select i1 %c, <2 x float> <float 1.0, float 1.0>, <2 x float> zeroinitializer
1093   %mul = fmul fast <2 x float> %sel, %x
1094   ret <2 x float> %mul
1095 }
1096
1097 ; Without fast math flags we can't optimize X * (C ? 1.0 : 0.0) -> C ? X : 0.0
1098 define float @fmul_select_strict(float %x, i1 %c) {
1099 ; CHECK-LABEL: @fmul_select_strict(
1100 ; CHECK-NEXT:    [[SEL:%.*]] = select i1 [[C:%.*]], float 1.000000e+00, float 0.000000e+00
1101 ; CHECK-NEXT:    [[MUL:%.*]] = fmul float [[SEL]], [[X:%.*]]
1102 ; CHECK-NEXT:    ret float [[MUL]]
1103 ;
1104   %sel = select i1 %c, float 1.0, float 0.0
1105   %mul = fmul float %sel, %x
1106   ret float %mul
1107 }
1108
1109 ; sqrt(X) *fast (C ? sqrt(X) : 1.0) -> C ? X : sqrt(X)
1110 define double @fmul_sqrt_select(double %x, i1 %c) {
1111 ; CHECK-LABEL: @fmul_sqrt_select(
1112 ; CHECK-NEXT:    [[SQR:%.*]] = call double @llvm.sqrt.f64(double [[X:%.*]])
1113 ; CHECK-NEXT:    [[SEL:%.*]] = select i1 [[C:%.*]], double [[SQR]], double 1.000000e+00
1114 ; CHECK-NEXT:    [[MUL:%.*]] = fmul fast double [[SQR]], [[SEL]]
1115 ; CHECK-NEXT:    ret double [[MUL]]
1116 ;
1117   %sqr = call double @llvm.sqrt.f64(double %x)
1118   %sel = select i1 %c, double %sqr, double 1.0
1119   %mul = fmul fast double %sqr, %sel
1120   ret double %mul
1121 }