test/Transforms/InstSimplify/call.ll

   1 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
   2 ; RUN: opt < %s -instsimplify -S | FileCheck %s
   3 ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
   4
   5 declare {i8, i1} @llvm.uadd.with.overflow.i8(i8 %a, i8 %b)
   6 declare {i8, i1} @llvm.sadd.with.overflow.i8(i8 %a, i8 %b)
   7 declare {i8, i1} @llvm.usub.with.overflow.i8(i8 %a, i8 %b)
   8 declare {i8, i1} @llvm.ssub.with.overflow.i8(i8 %a, i8 %b)
   9 declare {i8, i1} @llvm.umul.with.overflow.i8(i8 %a, i8 %b)
  10 declare {i8, i1} @llvm.smul.with.overflow.i8(i8 %a, i8 %b)
  11
  12 define i1 @test_uadd1() {
  13 ; CHECK-LABEL: @test_uadd1(
  14 ; CHECK-NEXT:    ret i1 true
  15 ;
  16   %x = call {i8, i1} @llvm.uadd.with.overflow.i8(i8 254, i8 3)
  17   %overflow = extractvalue {i8, i1} %x, 1
  18   ret i1 %overflow
  19 }
  20
  21 define i8 @test_uadd2() {
  22 ; CHECK-LABEL: @test_uadd2(
  23 ; CHECK-NEXT:    ret i8 42
  24 ;
  25   %x = call {i8, i1} @llvm.uadd.with.overflow.i8(i8 254, i8 44)
  26   %result = extractvalue {i8, i1} %x, 0
  27   ret i8 %result
  28 }
  29
  30 define {i8, i1} @test_uadd3(i8 %v) {
  31 ; CHECK-LABEL: @test_uadd3(
  32 ; CHECK-NEXT:    ret { i8, i1 } { i8 undef, i1 false }
  33 ;
  34   %result = call {i8, i1} @llvm.uadd.with.overflow.i8(i8 %v, i8 undef)
  35   ret {i8, i1} %result
  36 }
  37
  38 define {i8, i1} @test_uadd4(i8 %v) {
  39 ; CHECK-LABEL: @test_uadd4(
  40 ; CHECK-NEXT:    ret { i8, i1 } { i8 undef, i1 false }
  41 ;
  42   %result = call {i8, i1} @llvm.uadd.with.overflow.i8(i8 undef, i8 %v)
  43   ret {i8, i1} %result
  44 }
  45
  46 define i1 @test_sadd1() {
  47 ; CHECK-LABEL: @test_sadd1(
  48 ; CHECK-NEXT:    ret i1 true
  49 ;
  50   %x = call {i8, i1} @llvm.sadd.with.overflow.i8(i8 126, i8 3)
  51   %overflow = extractvalue {i8, i1} %x, 1
  52   ret i1 %overflow
  53 }
  54
  55 define i8 @test_sadd2() {
  56 ; CHECK-LABEL: @test_sadd2(
  57 ; CHECK-NEXT:    ret i8 -86
  58 ;
  59   %x = call {i8, i1} @llvm.sadd.with.overflow.i8(i8 126, i8 44)
  60   %result = extractvalue {i8, i1} %x, 0
  61   ret i8 %result
  62 }
  63
  64 define {i8, i1} @test_sadd3(i8 %v) {
  65 ; CHECK-LABEL: @test_sadd3(
  66 ; CHECK-NEXT:    ret { i8, i1 } { i8 undef, i1 false }
  67 ;
  68   %result = call {i8, i1} @llvm.sadd.with.overflow.i8(i8 %v, i8 undef)
  69   ret {i8, i1} %result
  70 }
  71
  72 define {i8, i1} @test_sadd4(i8 %v) {
  73 ; CHECK-LABEL: @test_sadd4(
  74 ; CHECK-NEXT:    ret { i8, i1 } { i8 undef, i1 false }
  75 ;
  76   %result = call {i8, i1} @llvm.sadd.with.overflow.i8(i8 undef, i8 %v)
  77   ret {i8, i1} %result
  78 }
  79
  80 define {i8, i1} @test_usub1(i8 %V) {
  81 ; CHECK-LABEL: @test_usub1(
  82 ; CHECK-NEXT:    ret { i8, i1 } zeroinitializer
  83 ;
  84   %x = call {i8, i1} @llvm.usub.with.overflow.i8(i8 %V, i8 %V)
  85   ret {i8, i1} %x
  86 }
  87
  88 define {i8, i1} @test_usub2(i8 %V) {
  89 ; CHECK-LABEL: @test_usub2(
  90 ; CHECK-NEXT:    ret { i8, i1 } { i8 undef, i1 false }
  91 ;
  92   %x = call {i8, i1} @llvm.usub.with.overflow.i8(i8 %V, i8 undef)
  93   ret {i8, i1} %x
  94 }
  95
  96 define {i8, i1} @test_usub3(i8 %V) {
  97 ; CHECK-LABEL: @test_usub3(
  98 ; CHECK-NEXT:    ret { i8, i1 } { i8 undef, i1 false }
  99 ;
 100   %x = call {i8, i1} @llvm.usub.with.overflow.i8(i8 undef, i8 %V)
 101   ret {i8, i1} %x
 102 }
 103
 104 define {i8, i1} @test_ssub1(i8 %V) {
 105 ; CHECK-LABEL: @test_ssub1(
 106 ; CHECK-NEXT:    ret { i8, i1 } zeroinitializer
 107 ;
 108   %x = call {i8, i1} @llvm.ssub.with.overflow.i8(i8 %V, i8 %V)
 109   ret {i8, i1} %x
 110 }
 111
 112 define {i8, i1} @test_ssub2(i8 %V) {
 113 ; CHECK-LABEL: @test_ssub2(
 114 ; CHECK-NEXT:    ret { i8, i1 } { i8 undef, i1 false }
 115 ;
 116   %x = call {i8, i1} @llvm.ssub.with.overflow.i8(i8 %V, i8 undef)
 117   ret {i8, i1} %x
 118 }
 119
 120 define {i8, i1} @test_ssub3(i8 %V) {
 121 ; CHECK-LABEL: @test_ssub3(
 122 ; CHECK-NEXT:    ret { i8, i1 } { i8 undef, i1 false }
 123 ;
 124   %x = call {i8, i1} @llvm.ssub.with.overflow.i8(i8 undef, i8 %V)
 125   ret {i8, i1} %x
 126 }
 127
 128 define {i8, i1} @test_umul1(i8 %V) {
 129 ; CHECK-LABEL: @test_umul1(
 130 ; CHECK-NEXT:    ret { i8, i1 } zeroinitializer
 131 ;
 132   %x = call {i8, i1} @llvm.umul.with.overflow.i8(i8 %V, i8 0)
 133   ret {i8, i1} %x
 134 }
 135
 136 define {i8, i1} @test_umul2(i8 %V) {
 137 ; CHECK-LABEL: @test_umul2(
 138 ; CHECK-NEXT:    ret { i8, i1 } zeroinitializer
 139 ;
 140   %x = call {i8, i1} @llvm.umul.with.overflow.i8(i8 %V, i8 undef)
 141   ret {i8, i1} %x
 142 }
 143
 144 define {i8, i1} @test_umul3(i8 %V) {
 145 ; CHECK-LABEL: @test_umul3(
 146 ; CHECK-NEXT:    ret { i8, i1 } zeroinitializer
 147 ;
 148   %x = call {i8, i1} @llvm.umul.with.overflow.i8(i8 0, i8 %V)
 149   ret {i8, i1} %x
 150 }
 151
 152 define {i8, i1} @test_umul4(i8 %V) {
 153 ; CHECK-LABEL: @test_umul4(
 154 ; CHECK-NEXT:    ret { i8, i1 } zeroinitializer
 155 ;
 156   %x = call {i8, i1} @llvm.umul.with.overflow.i8(i8 undef, i8 %V)
 157   ret {i8, i1} %x
 158 }
 159
 160 define {i8, i1} @test_smul1(i8 %V) {
 161 ; CHECK-LABEL: @test_smul1(
 162 ; CHECK-NEXT:    ret { i8, i1 } zeroinitializer
 163 ;
 164   %x = call {i8, i1} @llvm.smul.with.overflow.i8(i8 %V, i8 0)
 165   ret {i8, i1} %x
 166 }
 167
 168 define {i8, i1} @test_smul2(i8 %V) {
 169 ; CHECK-LABEL: @test_smul2(
 170 ; CHECK-NEXT:    ret { i8, i1 } zeroinitializer
 171 ;
 172   %x = call {i8, i1} @llvm.smul.with.overflow.i8(i8 %V, i8 undef)
 173   ret {i8, i1} %x
 174 }
 175
 176 define {i8, i1} @test_smul3(i8 %V) {
 177 ; CHECK-LABEL: @test_smul3(
 178 ; CHECK-NEXT:    ret { i8, i1 } zeroinitializer
 179 ;
 180   %x = call {i8, i1} @llvm.smul.with.overflow.i8(i8 0, i8 %V)
 181   ret {i8, i1} %x
 182 }
 183
 184 define {i8, i1} @test_smul4(i8 %V) {
 185 ; CHECK-LABEL: @test_smul4(
 186 ; CHECK-NEXT:    ret { i8, i1 } zeroinitializer
 187 ;
 188   %x = call {i8, i1} @llvm.smul.with.overflow.i8(i8 undef, i8 %V)
 189   ret {i8, i1} %x
 190 }
 191
 192 ; Test a non-intrinsic that we know about as a library call.
 193 declare float @fabs(float %x)
 194
 195 define float @test_fabs_libcall() {
 196 ; CHECK-LABEL: @test_fabs_libcall(
 197 ; CHECK-NEXT:    [[X:%.*]] = call float @fabs(float -4.200000e+01)
 198 ; CHECK-NEXT:    ret float 4.200000e+01
 199 ;
 200
 201   %x = call float @fabs(float -42.0)
 202 ; This is still a real function call, so instsimplify won't nuke it -- other
 203 ; passes have to do that.
 204
 205   ret float %x
 206 }
 207
 208
 209 declare float @llvm.fabs.f32(float) nounwind readnone
 210 declare float @llvm.floor.f32(float) nounwind readnone
 211 declare float @llvm.ceil.f32(float) nounwind readnone
 212 declare float @llvm.trunc.f32(float) nounwind readnone
 213 declare float @llvm.rint.f32(float) nounwind readnone
 214 declare float @llvm.nearbyint.f32(float) nounwind readnone
 215 declare float @llvm.canonicalize.f32(float) nounwind readnone
 216
 217 ; Test idempotent intrinsics
 218 define float @test_idempotence(float %a) {
 219 ; CHECK-LABEL: @test_idempotence(
 220 ; CHECK-NEXT:    [[A0:%.*]] = call float @llvm.fabs.f32(float [[A:%.*]])
 221 ; CHECK-NEXT:    [[B0:%.*]] = call float @llvm.floor.f32(float [[A]])
 222 ; CHECK-NEXT:    [[C0:%.*]] = call float @llvm.ceil.f32(float [[A]])
 223 ; CHECK-NEXT:    [[D0:%.*]] = call float @llvm.trunc.f32(float [[A]])
 224 ; CHECK-NEXT:    [[E0:%.*]] = call float @llvm.rint.f32(float [[A]])
 225 ; CHECK-NEXT:    [[F0:%.*]] = call float @llvm.nearbyint.f32(float [[A]])
 226 ; CHECK-NEXT:    [[G0:%.*]] = call float @llvm.canonicalize.f32(float [[A]])
 227 ; CHECK-NEXT:    [[R0:%.*]] = fadd float [[A0]], [[B0]]
 228 ; CHECK-NEXT:    [[R1:%.*]] = fadd float [[R0]], [[C0]]
 229 ; CHECK-NEXT:    [[R2:%.*]] = fadd float [[R1]], [[D0]]
 230 ; CHECK-NEXT:    [[R3:%.*]] = fadd float [[R2]], [[E0]]
 231 ; CHECK-NEXT:    [[R4:%.*]] = fadd float [[R3]], [[F0]]
 232 ; CHECK-NEXT:    [[R5:%.*]] = fadd float [[R4]], [[G0]]
 233 ; CHECK-NEXT:    ret float [[R5]]
 234 ;
 235
 236   %a0 = call float @llvm.fabs.f32(float %a)
 237   %a1 = call float @llvm.fabs.f32(float %a0)
 238
 239   %b0 = call float @llvm.floor.f32(float %a)
 240   %b1 = call float @llvm.floor.f32(float %b0)
 241
 242   %c0 = call float @llvm.ceil.f32(float %a)
 243   %c1 = call float @llvm.ceil.f32(float %c0)
 244
 245   %d0 = call float @llvm.trunc.f32(float %a)
 246   %d1 = call float @llvm.trunc.f32(float %d0)
 247
 248   %e0 = call float @llvm.rint.f32(float %a)
 249   %e1 = call float @llvm.rint.f32(float %e0)
 250
 251   %f0 = call float @llvm.nearbyint.f32(float %a)
 252   %f1 = call float @llvm.nearbyint.f32(float %f0)
 253
 254   %g0 = call float @llvm.canonicalize.f32(float %a)
 255   %g1 = call float @llvm.canonicalize.f32(float %g0)
 256
 257   %r0 = fadd float %a1, %b1
 258   %r1 = fadd float %r0, %c1
 259   %r2 = fadd float %r1, %d1
 260   %r3 = fadd float %r2, %e1
 261   %r4 = fadd float %r3, %f1
 262   %r5 = fadd float %r4, %g1
 263
 264   ret float %r5
 265 }
 266
 267 define i8* @operator_new() {
 268 ; CHECK-LABEL: @operator_new(
 269 ; CHECK-NEXT:  entry:
 270 ; CHECK-NEXT:    [[CALL:%.*]] = tail call noalias i8* @_Znwm(i64 8)
 271 ; CHECK-NEXT:    br i1 false, label [[CAST_END:%.*]], label [[CAST_NOTNULL:%.*]]
 272 ; CHECK:       cast.notnull:
 273 ; CHECK-NEXT:    [[ADD_PTR:%.*]] = getelementptr inbounds i8, i8* [[CALL]], i64 4
 274 ; CHECK-NEXT:    br label [[CAST_END]]
 275 ; CHECK:       cast.end:
 276 ; CHECK-NEXT:    [[CAST_RESULT:%.*]] = phi i8* [ [[ADD_PTR]], [[CAST_NOTNULL]] ], [ null, [[ENTRY:%.*]] ]
 277 ; CHECK-NEXT:    ret i8* [[CAST_RESULT]]
 278 ;
 279 entry:
 280   %call = tail call noalias i8* @_Znwm(i64 8)
 281   %cmp = icmp eq i8* %call, null
 282   br i1 %cmp, label %cast.end, label %cast.notnull
 283
 284 cast.notnull:                                     ; preds = %entry
 285   %add.ptr = getelementptr inbounds i8, i8* %call, i64 4
 286   br label %cast.end
 287
 288 cast.end:                                         ; preds = %cast.notnull, %entry
 289   %cast.result = phi i8* [ %add.ptr, %cast.notnull ], [ null, %entry ]
 290   ret i8* %cast.result
 291
 292 }
 293
 294 declare nonnull noalias i8* @_Znwm(i64)
 295
 296 %"struct.std::nothrow_t" = type { i8 }
 297 @_ZSt7nothrow = external global %"struct.std::nothrow_t"
 298
 299 define i8* @operator_new_nothrow_t() {
 300 ; CHECK-LABEL: @operator_new_nothrow_t(
 301 ; CHECK-NEXT:  entry:
 302 ; CHECK-NEXT:    [[CALL:%.*]] = tail call noalias i8* @_ZnamRKSt9nothrow_t(i64 8, %"struct.std::nothrow_t"* @_ZSt7nothrow)
 303 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i8* [[CALL]], null
 304 ; CHECK-NEXT:    br i1 [[CMP]], label [[CAST_END:%.*]], label [[CAST_NOTNULL:%.*]]
 305 ; CHECK:       cast.notnull:
 306 ; CHECK-NEXT:    [[ADD_PTR:%.*]] = getelementptr inbounds i8, i8* [[CALL]], i64 4
 307 ; CHECK-NEXT:    br label [[CAST_END]]
 308 ; CHECK:       cast.end:
 309 ; CHECK-NEXT:    [[CAST_RESULT:%.*]] = phi i8* [ [[ADD_PTR]], [[CAST_NOTNULL]] ], [ null, [[ENTRY:%.*]] ]
 310 ; CHECK-NEXT:    ret i8* [[CAST_RESULT]]
 311 ;
 312 entry:
 313   %call = tail call noalias i8* @_ZnamRKSt9nothrow_t(i64 8, %"struct.std::nothrow_t"* @_ZSt7nothrow)
 314   %cmp = icmp eq i8* %call, null
 315   br i1 %cmp, label %cast.end, label %cast.notnull
 316
 317 cast.notnull:                                     ; preds = %entry
 318   %add.ptr = getelementptr inbounds i8, i8* %call, i64 4
 319   br label %cast.end
 320
 321 cast.end:                                         ; preds = %cast.notnull, %entry
 322   %cast.result = phi i8* [ %add.ptr, %cast.notnull ], [ null, %entry ]
 323   ret i8* %cast.result
 324
 325 }
 326
 327 declare i8* @_ZnamRKSt9nothrow_t(i64, %"struct.std::nothrow_t"*) nounwind
 328
 329 define i8* @malloc_can_return_null() {
 330 ; CHECK-LABEL: @malloc_can_return_null(
 331 ; CHECK-NEXT:  entry:
 332 ; CHECK-NEXT:    [[CALL:%.*]] = tail call noalias i8* @malloc(i64 8)
 333 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i8* [[CALL]], null
 334 ; CHECK-NEXT:    br i1 [[CMP]], label [[CAST_END:%.*]], label [[CAST_NOTNULL:%.*]]
 335 ; CHECK:       cast.notnull:
 336 ; CHECK-NEXT:    [[ADD_PTR:%.*]] = getelementptr inbounds i8, i8* [[CALL]], i64 4
 337 ; CHECK-NEXT:    br label [[CAST_END]]
 338 ; CHECK:       cast.end:
 339 ; CHECK-NEXT:    [[CAST_RESULT:%.*]] = phi i8* [ [[ADD_PTR]], [[CAST_NOTNULL]] ], [ null, [[ENTRY:%.*]] ]
 340 ; CHECK-NEXT:    ret i8* [[CAST_RESULT]]
 341 ;
 342 entry:
 343   %call = tail call noalias i8* @malloc(i64 8)
 344   %cmp = icmp eq i8* %call, null
 345   br i1 %cmp, label %cast.end, label %cast.notnull
 346
 347 cast.notnull:                                     ; preds = %entry
 348   %add.ptr = getelementptr inbounds i8, i8* %call, i64 4
 349   br label %cast.end
 350
 351 cast.end:                                         ; preds = %cast.notnull, %entry
 352   %cast.result = phi i8* [ %add.ptr, %cast.notnull ], [ null, %entry ]
 353   ret i8* %cast.result
 354
 355 }
 356
 357 define i32 @call_null() {
 358 ; CHECK-LABEL: @call_null(
 359 ; CHECK-NEXT:  entry:
 360 ; CHECK-NEXT:    [[CALL:%.*]] = call i32 null()
 361 ; CHECK-NEXT:    ret i32 undef
 362 ;
 363 entry:
 364   %call = call i32 null()
 365   ret i32 %call
 366 }
 367
 368 define i32 @call_undef() {
 369 ; CHECK-LABEL: @call_undef(
 370 ; CHECK-NEXT:  entry:
 371 ; CHECK-NEXT:    [[CALL:%.*]] = call i32 undef()
 372 ; CHECK-NEXT:    ret i32 undef
 373 ;
 374 entry:
 375   %call = call i32 undef()
 376   ret i32 %call
 377 }
 378
 379 @GV = private constant [8 x i32] [i32 42, i32 43, i32 44, i32 45, i32 46, i32 47, i32 48, i32 49]
 380
 381 define <8 x i32> @partial_masked_load() {
 382 ; CHECK-LABEL: @partial_masked_load(
 383 ; CHECK-NEXT:    ret <8 x i32> <i32 undef, i32 undef, i32 42, i32 43, i32 44, i32 45, i32 46, i32 47>
 384 ;
 385   %masked.load = call <8 x i32> @llvm.masked.load.v8i32.p0v8i32(<8 x i32>* bitcast (i32* getelementptr ([8 x i32], [8 x i32]* @GV, i64 0, i64 -2) to <8 x i32>*), i32 4, <8 x i1> <i1 false, i1 false, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true>, <8 x i32> undef)
 386   ret <8 x i32> %masked.load
 387 }
 388
 389 define <8 x i32> @masked_load_undef_mask(<8 x i32>* %V) {
 390 ; CHECK-LABEL: @masked_load_undef_mask(
 391 ; CHECK-NEXT:    ret <8 x i32> <i32 1, i32 0, i32 1, i32 0, i32 1, i32 0, i32 1, i32 0>
 392 ;
 393   %masked.load = call <8 x i32> @llvm.masked.load.v8i32.p0v8i32(<8 x i32>* %V, i32 4, <8 x i1> undef, <8 x i32> <i32 1, i32 0, i32 1, i32 0, i32 1, i32 0, i32 1, i32 0>)
 394   ret <8 x i32> %masked.load
 395 }
 396
 397 declare noalias i8* @malloc(i64)
 398
 399 declare <8 x i32> @llvm.masked.load.v8i32.p0v8i32(<8 x i32>*, i32, <8 x i1>, <8 x i32>)
 400
 401 declare double @llvm.powi.f64(double, i32)
 402 declare <2 x double> @llvm.powi.v2f64(<2 x double>, i32)
 403
 404 define double @constant_fold_powi() {
 405 ; CHECK-LABEL: @constant_fold_powi(
 406 ; CHECK-NEXT:    ret double 9.000000e+00
 407 ;
 408   %t0 = call double @llvm.powi.f64(double 3.00000e+00, i32 2)
 409   ret double %t0
 410 }
 411
 412 define <2 x double> @constant_fold_powi_vec() {
 413 ; CHECK-LABEL: @constant_fold_powi_vec(
 414 ; CHECK-NEXT:    ret <2 x double> <double 9.000000e+00, double 2.500000e+01>
 415 ;
 416   %t0 = call <2 x double> @llvm.powi.v2f64(<2 x double> <double 3.00000e+00, double 5.00000e+00>, i32 2)
 417   ret <2 x double> %t0
 418 }
 419
 420 declare i8 @llvm.fshl.i8(i8, i8, i8)
 421 declare i9 @llvm.fshr.i9(i9, i9, i9)
 422 declare <2 x i7> @llvm.fshl.v2i7(<2 x i7>, <2 x i7>, <2 x i7>)
 423 declare <2 x i8> @llvm.fshr.v2i8(<2 x i8>, <2 x i8>, <2 x i8>)
 424
 425 define i8 @fshl_no_shift(i8 %x, i8 %y) {
 426 ; CHECK-LABEL: @fshl_no_shift(
 427 ; CHECK-NEXT:    ret i8 [[X:%.*]]
 428 ;
 429   %z = call i8 @llvm.fshl.i8(i8 %x, i8 %y, i8 0)
 430   ret i8 %z
 431 }
 432
 433 define i9 @fshr_no_shift(i9 %x, i9 %y) {
 434 ; CHECK-LABEL: @fshr_no_shift(
 435 ; CHECK-NEXT:    ret i9 [[Y:%.*]]
 436 ;
 437   %z = call i9 @llvm.fshr.i9(i9 %x, i9 %y, i9 0)
 438   ret i9 %z
 439 }
 440
 441 define i8 @fshl_no_shift_modulo_bitwidth(i8 %x, i8 %y) {
 442 ; CHECK-LABEL: @fshl_no_shift_modulo_bitwidth(
 443 ; CHECK-NEXT:    ret i8 [[X:%.*]]
 444 ;
 445   %z = call i8 @llvm.fshl.i8(i8 %x, i8 %y, i8 40)
 446   ret i8 %z
 447 }
 448
 449 define i9 @fshr_no_shift_modulo_bitwidth(i9 %x, i9 %y) {
 450 ; CHECK-LABEL: @fshr_no_shift_modulo_bitwidth(
 451 ; CHECK-NEXT:    ret i9 [[Y:%.*]]
 452 ;
 453   %z = call i9 @llvm.fshr.i9(i9 %x, i9 %y, i9 189)
 454   ret i9 %z
 455 }
 456
 457 define <2 x i7> @fshl_no_shift_modulo_bitwidth_splat(<2 x i7> %x, <2 x i7> %y) {
 458 ; CHECK-LABEL: @fshl_no_shift_modulo_bitwidth_splat(
 459 ; CHECK-NEXT:    ret <2 x i7> [[X:%.*]]
 460 ;
 461   %z = call <2 x i7> @llvm.fshl.v2i7(<2 x i7> %x, <2 x i7> %y, <2 x i7> <i7 21, i7 21>)
 462   ret <2 x i7> %z
 463 }
 464
 465 define <2 x i8> @fshr_no_shift_modulo_bitwidth_splat(<2 x i8> %x, <2 x i8> %y) {
 466 ; CHECK-LABEL: @fshr_no_shift_modulo_bitwidth_splat(
 467 ; CHECK-NEXT:    ret <2 x i8> [[Y:%.*]]
 468 ;
 469   %z = call <2 x i8> @llvm.fshr.v2i8(<2 x i8> %x, <2 x i8> %y, <2 x i8> <i8 72, i8 72>)
 470   ret <2 x i8> %z
 471 }
 472
 473 ; If y is poison, eliminating the guard is not safe.
 474
 475 define i8 @fshl_zero_shift_guard(i8 %x, i8 %y, i8 %sh) {
 476 ; CHECK-LABEL: @fshl_zero_shift_guard(
 477 ; CHECK-NEXT:    [[C:%.*]] = icmp eq i8 [[SH:%.*]], 0
 478 ; CHECK-NEXT:    [[F:%.*]] = call i8 @llvm.fshl.i8(i8 [[X:%.*]], i8 [[Y:%.*]], i8 [[SH]])
 479 ; CHECK-NEXT:    [[S:%.*]] = select i1 [[C]], i8 [[X]], i8 [[F]]
 480 ; CHECK-NEXT:    ret i8 [[S]]
 481 ;
 482   %c = icmp eq i8 %sh, 0
 483   %f = call i8 @llvm.fshl.i8(i8 %x, i8 %y, i8 %sh)
 484   %s = select i1 %c, i8 %x, i8 %f
 485   ret i8 %s
 486 }
 487
 488 ; If y is poison, eliminating the guard is not safe.
 489
 490 define i8 @fshl_zero_shift_guard_swapped(i8 %x, i8 %y, i8 %sh) {
 491 ; CHECK-LABEL: @fshl_zero_shift_guard_swapped(
 492 ; CHECK-NEXT:    [[C:%.*]] = icmp ne i8 [[SH:%.*]], 0
 493 ; CHECK-NEXT:    [[F:%.*]] = call i8 @llvm.fshl.i8(i8 [[X:%.*]], i8 [[Y:%.*]], i8 [[SH]])
 494 ; CHECK-NEXT:    [[S:%.*]] = select i1 [[C]], i8 [[F]], i8 [[X]]
 495 ; CHECK-NEXT:    ret i8 [[S]]
 496 ;
 497   %c = icmp ne i8 %sh, 0
 498   %f = call i8 @llvm.fshl.i8(i8 %x, i8 %y, i8 %sh)
 499   %s = select i1 %c, i8 %f, i8 %x
 500   ret i8 %s
 501 }
 502
 503 ; When the shift amount is 0, fshl returns its 1st parameter (x), so everything is deleted.
 504
 505 define i8 @fshl_zero_shift_guard_inverted(i8 %x, i8 %y, i8 %sh) {
 506 ; CHECK-LABEL: @fshl_zero_shift_guard_inverted(
 507 ; CHECK-NEXT:    ret i8 [[X:%.*]]
 508 ;
 509   %c = icmp eq i8 %sh, 0
 510   %f = call i8 @llvm.fshl.i8(i8 %x, i8 %y, i8 %sh)
 511   %s = select i1 %c, i8 %f, i8 %x
 512   ret i8 %s
 513 }
 514
 515 ; When the shift amount is 0, fshl returns its 1st parameter (x), so everything is deleted.
 516
 517 define i8 @fshl_zero_shift_guard_inverted_swapped(i8 %x, i8 %y, i8 %sh) {
 518 ; CHECK-LABEL: @fshl_zero_shift_guard_inverted_swapped(
 519 ; CHECK-NEXT:    ret i8 [[X:%.*]]
 520 ;
 521   %c = icmp ne i8 %sh, 0
 522   %f = call i8 @llvm.fshl.i8(i8 %x, i8 %y, i8 %sh)
 523   %s = select i1 %c, i8 %x, i8 %f
 524   ret i8 %s
 525 }
 526
 527 ; If x is poison, eliminating the guard is not safe.
 528
 529 define i9 @fshr_zero_shift_guard(i9 %x, i9 %y, i9 %sh) {
 530 ; CHECK-LABEL: @fshr_zero_shift_guard(
 531 ; CHECK-NEXT:    [[C:%.*]] = icmp eq i9 [[SH:%.*]], 0
 532 ; CHECK-NEXT:    [[F:%.*]] = call i9 @llvm.fshr.i9(i9 [[X:%.*]], i9 [[Y:%.*]], i9 [[SH]])
 533 ; CHECK-NEXT:    [[S:%.*]] = select i1 [[C]], i9 [[Y]], i9 [[F]]
 534 ; CHECK-NEXT:    ret i9 [[S]]
 535 ;
 536   %c = icmp eq i9 %sh, 0
 537   %f = call i9 @llvm.fshr.i9(i9 %x, i9 %y, i9 %sh)
 538   %s = select i1 %c, i9 %y, i9 %f
 539   ret i9 %s
 540 }
 541
 542 ; If x is poison, eliminating the guard is not safe.
 543
 544 define i9 @fshr_zero_shift_guard_swapped(i9 %x, i9 %y, i9 %sh) {
 545 ; CHECK-LABEL: @fshr_zero_shift_guard_swapped(
 546 ; CHECK-NEXT:    [[C:%.*]] = icmp ne i9 [[SH:%.*]], 0
 547 ; CHECK-NEXT:    [[F:%.*]] = call i9 @llvm.fshr.i9(i9 [[X:%.*]], i9 [[Y:%.*]], i9 [[SH]])
 548 ; CHECK-NEXT:    [[S:%.*]] = select i1 [[C]], i9 [[F]], i9 [[Y]]
 549 ; CHECK-NEXT:    ret i9 [[S]]
 550 ;
 551   %c = icmp ne i9 %sh, 0
 552   %f = call i9 @llvm.fshr.i9(i9 %x, i9 %y, i9 %sh)
 553   %s = select i1 %c, i9 %f, i9 %y
 554   ret i9 %s
 555 }
 556
 557 ; When the shift amount is 0, fshr returns its 2nd parameter (y), so everything is deleted.
 558
 559 define i9 @fshr_zero_shift_guard_inverted(i9 %x, i9 %y, i9 %sh) {
 560 ; CHECK-LABEL: @fshr_zero_shift_guard_inverted(
 561 ; CHECK-NEXT:    ret i9 [[Y:%.*]]
 562 ;
 563   %c = icmp eq i9 %sh, 0
 564   %f = call i9 @llvm.fshr.i9(i9 %x, i9 %y, i9 %sh)
 565   %s = select i1 %c, i9 %f, i9 %y
 566   ret i9 %s
 567 }
 568
 569 ; When the shift amount is 0, fshr returns its 2nd parameter (y), so everything is deleted.
 570
 571 define i9 @fshr_zero_shift_guard_inverted_swapped(i9 %x, i9 %y, i9 %sh) {
 572 ; CHECK-LABEL: @fshr_zero_shift_guard_inverted_swapped(
 573 ; CHECK-NEXT:    ret i9 [[Y:%.*]]
 574 ;
 575   %c = icmp ne i9 %sh, 0
 576   %f = call i9 @llvm.fshr.i9(i9 %x, i9 %y, i9 %sh)
 577   %s = select i1 %c, i9 %y, i9 %f
 578   ret i9 %s
 579 }
 580
 581 ; When the shift amount is 0, fshl returns its 1st parameter (x), so the guard is not needed.
 582
 583 define i8 @rotl_zero_shift_guard(i8 %x, i8 %sh) {
 584 ; CHECK-LABEL: @rotl_zero_shift_guard(
 585 ; CHECK-NEXT:    [[F:%.*]] = call i8 @llvm.fshl.i8(i8 [[X:%.*]], i8 [[X]], i8 [[SH:%.*]])
 586 ; CHECK-NEXT:    ret i8 [[F]]
 587 ;
 588   %c = icmp eq i8 %sh, 0
 589   %f = call i8 @llvm.fshl.i8(i8 %x, i8 %x, i8 %sh)
 590   %s = select i1 %c, i8 %x, i8 %f
 591   ret i8 %s
 592 }
 593
 594 ; When the shift amount is 0, fshl returns its 1st parameter (x), so the guard is not needed.
 595
 596 define i8 @rotl_zero_shift_guard_swapped(i8 %x, i8 %sh) {
 597 ; CHECK-LABEL: @rotl_zero_shift_guard_swapped(
 598 ; CHECK-NEXT:    [[F:%.*]] = call i8 @llvm.fshl.i8(i8 [[X:%.*]], i8 [[X]], i8 [[SH:%.*]])
 599 ; CHECK-NEXT:    ret i8 [[F]]
 600 ;
 601   %c = icmp ne i8 %sh, 0
 602   %f = call i8 @llvm.fshl.i8(i8 %x, i8 %x, i8 %sh)
 603   %s = select i1 %c, i8 %f, i8 %x
 604   ret i8 %s
 605 }
 606
 607 ; When the shift amount is 0, fshl returns its 1st parameter (x), so everything is deleted.
 608
 609 define i8 @rotl_zero_shift_guard_inverted(i8 %x, i8 %sh) {
 610 ; CHECK-LABEL: @rotl_zero_shift_guard_inverted(
 611 ; CHECK-NEXT:    ret i8 [[X:%.*]]
 612 ;
 613   %c = icmp eq i8 %sh, 0
 614   %f = call i8 @llvm.fshl.i8(i8 %x, i8 %x, i8 %sh)
 615   %s = select i1 %c, i8 %f, i8 %x
 616   ret i8 %s
 617 }
 618
 619 ; When the shift amount is 0, fshl returns its 1st parameter (x), so everything is deleted.
 620
 621 define i8 @rotl_zero_shift_guard_inverted_swapped(i8 %x, i8 %sh) {
 622 ; CHECK-LABEL: @rotl_zero_shift_guard_inverted_swapped(
 623 ; CHECK-NEXT:    ret i8 [[X:%.*]]
 624 ;
 625   %c = icmp ne i8 %sh, 0
 626   %f = call i8 @llvm.fshl.i8(i8 %x, i8 %x, i8 %sh)
 627   %s = select i1 %c, i8 %x, i8 %f
 628   ret i8 %s
 629 }
 630
 631 ; When the shift amount is 0, fshr returns its 2nd parameter (x), so the guard is not needed.
 632
 633 define i9 @rotr_zero_shift_guard(i9 %x, i9 %sh) {
 634 ; CHECK-LABEL: @rotr_zero_shift_guard(
 635 ; CHECK-NEXT:    [[F:%.*]] = call i9 @llvm.fshr.i9(i9 [[X:%.*]], i9 [[X]], i9 [[SH:%.*]])
 636 ; CHECK-NEXT:    ret i9 [[F]]
 637 ;
 638   %c = icmp eq i9 %sh, 0
 639   %f = call i9 @llvm.fshr.i9(i9 %x, i9 %x, i9 %sh)
 640   %s = select i1 %c, i9 %x, i9 %f
 641   ret i9 %s
 642 }
 643
 644 ; When the shift amount is 0, fshr returns its 2nd parameter (x), so the guard is not needed.
 645
 646 define i9 @rotr_zero_shift_guard_swapped(i9 %x, i9 %sh) {
 647 ; CHECK-LABEL: @rotr_zero_shift_guard_swapped(
 648 ; CHECK-NEXT:    [[F:%.*]] = call i9 @llvm.fshr.i9(i9 [[X:%.*]], i9 [[X]], i9 [[SH:%.*]])
 649 ; CHECK-NEXT:    ret i9 [[F]]
 650 ;
 651   %c = icmp ne i9 %sh, 0
 652   %f = call i9 @llvm.fshr.i9(i9 %x, i9 %x, i9 %sh)
 653   %s = select i1 %c, i9 %f, i9 %x
 654   ret i9 %s
 655 }
 656
 657 ; When the shift amount is 0, fshr returns its 2nd parameter (x), so everything is deleted.
 658
 659 define i9 @rotr_zero_shift_guard_inverted(i9 %x, i9 %sh) {
 660 ; CHECK-LABEL: @rotr_zero_shift_guard_inverted(
 661 ; CHECK-NEXT:    ret i9 [[X:%.*]]
 662 ;
 663   %c = icmp eq i9 %sh, 0
 664   %f = call i9 @llvm.fshr.i9(i9 %x, i9 %x, i9 %sh)
 665   %s = select i1 %c, i9 %f, i9 %x
 666   ret i9 %s
 667 }
 668
 669 ; When the shift amount is 0, fshr returns its 2nd parameter (x), so everything is deleted.
 670
 671 define i9 @rotr_zero_shift_guard_inverted_swapped(i9 %x, i9 %sh) {
 672 ; CHECK-LABEL: @rotr_zero_shift_guard_inverted_swapped(
 673 ; CHECK-NEXT:    ret i9 [[X:%.*]]
 674 ;
 675   %c = icmp ne i9 %sh, 0
 676   %f = call i9 @llvm.fshr.i9(i9 %x, i9 %x, i9 %sh)
 677   %s = select i1 %c, i9 %x, i9 %f
 678   ret i9 %s
 679 }
 680
 681 ; Negative test - make sure we're matching the correct parameter of fshl.
 682
 683 define i8 @fshl_zero_shift_guard_wrong_select_op(i8 %x, i8 %y, i8 %sh) {
 684 ; CHECK-LABEL: @fshl_zero_shift_guard_wrong_select_op(
 685 ; CHECK-NEXT:    [[C:%.*]] = icmp eq i8 [[SH:%.*]], 0
 686 ; CHECK-NEXT:    [[F:%.*]] = call i8 @llvm.fshl.i8(i8 [[X:%.*]], i8 [[Y:%.*]], i8 [[SH]])
 687 ; CHECK-NEXT:    [[S:%.*]] = select i1 [[C]], i8 [[Y]], i8 [[F]]
 688 ; CHECK-NEXT:    ret i8 [[S]]
 689 ;
 690   %c = icmp eq i8 %sh, 0
 691   %f = call i8 @llvm.fshl.i8(i8 %x, i8 %y, i8 %sh)
 692   %s = select i1 %c, i8 %y, i8 %f
 693   ret i8 %s
 694 }
 695
 696 ; Vector types work too.
 697
 698 define <2 x i8> @rotr_zero_shift_guard_splat(<2 x i8> %x, <2 x i8> %sh) {
 699 ; CHECK-LABEL: @rotr_zero_shift_guard_splat(
 700 ; CHECK-NEXT:    [[F:%.*]] = call <2 x i8> @llvm.fshr.v2i8(<2 x i8> [[X:%.*]], <2 x i8> [[X]], <2 x i8> [[SH:%.*]])
 701 ; CHECK-NEXT:    ret <2 x i8> [[F]]
 702 ;
 703   %c = icmp eq <2 x i8> %sh, zeroinitializer
 704   %f = call <2 x i8> @llvm.fshr.v2i8(<2 x i8> %x, <2 x i8> %x, <2 x i8> %sh)
 705   %s = select <2 x i1> %c, <2 x i8> %x, <2 x i8> %f
 706   ret <2 x i8> %s
 707 }
 708
 709 ; If first two operands of funnel shift are undef, the result is undef
 710
 711 define i8 @fshl_ops_undef(i8 %shamt) {
 712 ; CHECK-LABEL: @fshl_ops_undef(
 713 ; CHECK-NEXT:    ret i8 undef
 714 ;
 715   %r = call i8 @llvm.fshl.i8(i8 undef, i8 undef, i8 %shamt)
 716   ret i8 %r
 717 }
 718
 719 define i9 @fshr_ops_undef(i9 %shamt) {
 720 ; CHECK-LABEL: @fshr_ops_undef(
 721 ; CHECK-NEXT:    ret i9 undef
 722 ;
 723   %r = call i9 @llvm.fshr.i9(i9 undef, i9 undef, i9 %shamt)
 724   ret i9 %r
 725 }
 726
 727 ; If shift amount is undef, treat it as zero, returning operand 0 or 1
 728
 729 define i8 @fshl_shift_undef(i8 %x, i8 %y) {
 730 ; CHECK-LABEL: @fshl_shift_undef(
 731 ; CHECK-NEXT:    ret i8 [[X:%.*]]
 732 ;
 733   %r = call i8 @llvm.fshl.i8(i8 %x, i8 %y, i8 undef)
 734   ret i8 %r
 735 }
 736
 737 define i9 @fshr_shift_undef(i9 %x, i9 %y) {
 738 ; CHECK-LABEL: @fshr_shift_undef(
 739 ; CHECK-NEXT:    ret i9 [[Y:%.*]]
 740 ;
 741   %r = call i9 @llvm.fshr.i9(i9 %x, i9 %y, i9 undef)
 742   ret i9 %r
 743 }
 744
 745 declare double @llvm.fma.f64(double,double,double)
 746 declare double @llvm.fmuladd.f64(double,double,double)
 747
 748 define double @fma_undef_op0(double %x, double %y) {
 749 ; CHECK-LABEL: @fma_undef_op0(
 750 ; CHECK-NEXT:    ret double 0x7FF8000000000000
 751 ;
 752   %r = call double @llvm.fma.f64(double undef, double %x, double %y)
 753   ret double %r
 754 }
 755
 756 define double @fma_undef_op1(double %x, double %y) {
 757 ; CHECK-LABEL: @fma_undef_op1(
 758 ; CHECK-NEXT:    ret double 0x7FF8000000000000
 759 ;
 760   %r = call double @llvm.fma.f64(double %x, double undef, double %y)
 761   ret double %r
 762 }
 763
 764 define double @fma_undef_op2(double %x, double %y) {
 765 ; CHECK-LABEL: @fma_undef_op2(
 766 ; CHECK-NEXT:    ret double 0x7FF8000000000000
 767 ;
 768   %r = call double @llvm.fma.f64(double %x, double %y, double undef)
 769   ret double %r
 770 }
 771
 772 define double @fmuladd_undef_op0(double %x, double %y) {
 773 ; CHECK-LABEL: @fmuladd_undef_op0(
 774 ; CHECK-NEXT:    ret double 0x7FF8000000000000
 775 ;
 776   %r = call double @llvm.fmuladd.f64(double undef, double %x, double %y)
 777   ret double %r
 778 }
 779
 780 define double @fmuladd_undef_op1(double %x, double %y) {
 781 ; CHECK-LABEL: @fmuladd_undef_op1(
 782 ; CHECK-NEXT:    ret double 0x7FF8000000000000
 783 ;
 784   %r = call double @llvm.fmuladd.f64(double %x, double undef, double %y)
 785   ret double %r
 786 }
 787
 788 define double @fmuladd_undef_op2(double %x, double %y) {
 789 ; CHECK-LABEL: @fmuladd_undef_op2(
 790 ; CHECK-NEXT:    ret double 0x7FF8000000000000
 791 ;
 792   %r = call double @llvm.fmuladd.f64(double %x, double %y, double undef)
 793   ret double %r
 794 }
 795
 796 define double @fma_nan_op0(double %x, double %y) {
 797 ; CHECK-LABEL: @fma_nan_op0(
 798 ; CHECK-NEXT:    ret double 0x7FF8000000000000
 799 ;
 800   %r = call double @llvm.fma.f64(double 0x7ff8000000000000, double %x, double %y)
 801   ret double %r
 802 }
 803
 804 define double @fma_nan_op1(double %x, double %y) {
 805 ; CHECK-LABEL: @fma_nan_op1(
 806 ; CHECK-NEXT:    ret double 0x7FF8000000000001
 807 ;
 808   %r = call double @llvm.fma.f64(double %x, double 0x7ff8000000000001, double %y)
 809   ret double %r
 810 }
 811
 812 define double @fma_nan_op2(double %x, double %y) {
 813 ; CHECK-LABEL: @fma_nan_op2(
 814 ; CHECK-NEXT:    ret double 0x7FF8000000000002
 815 ;
 816   %r = call double @llvm.fma.f64(double %x, double %y, double 0x7ff8000000000002)
 817   ret double %r
 818 }
 819
 820 define double @fmuladd_nan_op0_op1(double %x) {
 821 ; CHECK-LABEL: @fmuladd_nan_op0_op1(
 822 ; CHECK-NEXT:    ret double 0x7FF8000000001234
 823 ;
 824   %r = call double @llvm.fmuladd.f64(double 0x7ff8000000001234, double 0x7ff800000000dead, double %x)
 825   ret double %r
 826 }
 827
 828 define double @fmuladd_nan_op0_op2(double %x) {
 829 ; CHECK-LABEL: @fmuladd_nan_op0_op2(
 830 ; CHECK-NEXT:    ret double 0x7FF8000000005678
 831 ;
 832   %r = call double @llvm.fmuladd.f64(double 0x7ff8000000005678, double %x, double 0x7ff800000000dead)
 833   ret double %r
 834 }
 835
 836 define double @fmuladd_nan_op1_op2(double %x) {
 837 ; CHECK-LABEL: @fmuladd_nan_op1_op2(
 838 ; CHECK-NEXT:    ret double 0x7FF80000AAAAAAAA
 839 ;
 840   %r = call double @llvm.fmuladd.f64(double %x, double 0x7ff80000aaaaaaaa, double 0x7ff800000000dead)
 841   ret double %r
 842 }
 843
 844 define double @fma_nan_multiplicand_inf_zero(double %x) {
 845 ; CHECK-LABEL: @fma_nan_multiplicand_inf_zero(
 846 ; CHECK-NEXT:    [[R:%.*]] = call double @llvm.fma.f64(double 0x7FF0000000000000, double 0.000000e+00, double [[X:%.*]])
 847 ; CHECK-NEXT:    ret double [[R]]
 848 ;
 849   %r = call double @llvm.fma.f64(double 0x7ff0000000000000, double 0.0, double %x)
 850   ret double %r
 851 }
 852
 853 define double @fma_nan_multiplicand_zero_inf(double %x) {
 854 ; CHECK-LABEL: @fma_nan_multiplicand_zero_inf(
 855 ; CHECK-NEXT:    [[R:%.*]] = call double @llvm.fma.f64(double 0.000000e+00, double 0x7FF0000000000000, double [[X:%.*]])
 856 ; CHECK-NEXT:    ret double [[R]]
 857 ;
 858   %r = call double @llvm.fma.f64(double 0.0, double 0x7ff0000000000000, double %x)
 859   ret double %r
 860 }
 861
 862 define double @fma_nan_addend_inf_neginf(double %x, i32 %y) {
 863 ; CHECK-LABEL: @fma_nan_addend_inf_neginf(
 864 ; CHECK-NEXT:    [[NOTNAN:%.*]] = uitofp i32 [[Y:%.*]] to double
 865 ; CHECK-NEXT:    [[R:%.*]] = call double @llvm.fma.f64(double 0x7FF0000000000000, double [[NOTNAN]], double 0xFFF0000000000000)
 866 ; CHECK-NEXT:    ret double [[R]]
 867 ;
 868   %notnan = uitofp i32 %y to double
 869   %r = call double @llvm.fma.f64(double 0x7ff0000000000000, double %notnan, double 0xfff0000000000000)
 870   ret double %r
 871 }
 872
 873 define double @fma_nan_addend_neginf_inf(double %x, i1 %y) {
 874 ; CHECK-LABEL: @fma_nan_addend_neginf_inf(
 875 ; CHECK-NEXT:    [[NOTNAN:%.*]] = select i1 [[Y:%.*]], double 4.200000e+01, double -1.000000e-01
 876 ; CHECK-NEXT:    [[R:%.*]] = call double @llvm.fma.f64(double [[NOTNAN]], double 0xFFF0000000000000, double 0x7FF0000000000000)
 877 ; CHECK-NEXT:    ret double [[R]]
 878 ;
 879   %notnan = select i1 %y, double 42.0, double -0.1
 880   %r = call double @llvm.fma.f64(double %notnan, double 0xfff0000000000000, double 0x7ff0000000000000)
 881   ret double %r
 882 }
 883
 884 define double @fmuladd_nan_multiplicand_neginf_zero(double %x) {
 885 ; CHECK-LABEL: @fmuladd_nan_multiplicand_neginf_zero(
 886 ; CHECK-NEXT:    [[R:%.*]] = call double @llvm.fmuladd.f64(double 0xFFF0000000000000, double 0.000000e+00, double [[X:%.*]])
 887 ; CHECK-NEXT:    ret double [[R]]
 888 ;
 889   %r = call double @llvm.fmuladd.f64(double 0xfff0000000000000, double 0.0, double %x)
 890   ret double %r
 891 }
 892
 893 define double @fmuladd_nan_multiplicand_negzero_inf(double %x) {
 894 ; CHECK-LABEL: @fmuladd_nan_multiplicand_negzero_inf(
 895 ; CHECK-NEXT:    [[R:%.*]] = call double @llvm.fmuladd.f64(double -0.000000e+00, double 0x7FF0000000000000, double [[X:%.*]])
 896 ; CHECK-NEXT:    ret double [[R]]
 897 ;
 898   %r = call double @llvm.fmuladd.f64(double -0.0, double 0x7ff0000000000000, double %x)
 899   ret double %r
 900 }
 901
 902 define double @fmuladd_nan_addend_inf_neginf(double %x, i32 %y) {
 903 ; CHECK-LABEL: @fmuladd_nan_addend_inf_neginf(
 904 ; CHECK-NEXT:    [[NOTNAN:%.*]] = sitofp i32 [[Y:%.*]] to double
 905 ; CHECK-NEXT:    [[R:%.*]] = call double @llvm.fmuladd.f64(double 0x7FF0000000000000, double [[NOTNAN]], double 0xFFF0000000000000)
 906 ; CHECK-NEXT:    ret double [[R]]
 907 ;
 908   %notnan = sitofp i32 %y to double
 909   %r = call double @llvm.fmuladd.f64(double 0x7ff0000000000000, double %notnan, double 0xfff0000000000000)
 910   ret double %r
 911 }
 912
 913 define double @fmuladd_nan_addend_neginf_inf(double %x, i1 %y) {
 914 ; CHECK-LABEL: @fmuladd_nan_addend_neginf_inf(
 915 ; CHECK-NEXT:    [[NOTNAN:%.*]] = select i1 [[Y:%.*]], double 4.200000e+01, double -1.000000e-01
 916 ; CHECK-NEXT:    [[R:%.*]] = call double @llvm.fmuladd.f64(double [[NOTNAN]], double 0xFFF0000000000000, double 0x7FF0000000000000)
 917 ; CHECK-NEXT:    ret double [[R]]
 918 ;
 919   %notnan = select i1 %y, double 42.0, double -0.1
 920   %r = call double @llvm.fmuladd.f64(double %notnan, double 0xfff0000000000000, double 0x7ff0000000000000)
 921   ret double %r
 922 }