test/Transforms/InstSimplify/floating-point-compare.ll

   1 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
   2 ; RUN: opt < %s -instsimplify -S | FileCheck %s
   3
   4 ; Infinity
   5
   6 define i1 @inf0(double %arg) {
   7 ; CHECK-LABEL: @inf0(
   8 ; CHECK-NEXT:    ret i1 false
   9 ;
  10   %tmp = fcmp ogt double %arg, 0x7FF0000000000000
  11   ret i1 %tmp
  12 }
  13
  14 define i1 @inf1(double %arg) {
  15 ; CHECK-LABEL: @inf1(
  16 ; CHECK-NEXT:    ret i1 true
  17 ;
  18   %tmp = fcmp ule double %arg, 0x7FF0000000000000
  19   ret i1 %tmp
  20 }
  21
  22 ; Negative infinity
  23
  24 define i1 @ninf0(double %arg) {
  25 ; CHECK-LABEL: @ninf0(
  26 ; CHECK-NEXT:    ret i1 false
  27 ;
  28   %tmp = fcmp olt double %arg, 0xFFF0000000000000
  29   ret i1 %tmp
  30 }
  31
  32 define i1 @ninf1(double %arg) {
  33 ; CHECK-LABEL: @ninf1(
  34 ; CHECK-NEXT:    ret i1 true
  35 ;
  36   %tmp = fcmp uge double %arg, 0xFFF0000000000000
  37   ret i1 %tmp
  38 }
  39
  40 ; NaNs
  41
  42 define i1 @nan0(double %arg) {
  43 ; CHECK-LABEL: @nan0(
  44 ; CHECK-NEXT:    ret i1 false
  45 ;
  46   %tmp = fcmp ord double %arg, 0x7FF00000FFFFFFFF
  47   ret i1 %tmp
  48 }
  49
  50 define i1 @nan1(double %arg) {
  51 ; CHECK-LABEL: @nan1(
  52 ; CHECK-NEXT:    ret i1 false
  53 ;
  54   %tmp = fcmp oeq double %arg, 0x7FF00000FFFFFFFF
  55   ret i1 %tmp
  56 }
  57
  58 define i1 @nan2(double %arg) {
  59 ; CHECK-LABEL: @nan2(
  60 ; CHECK-NEXT:    ret i1 false
  61 ;
  62   %tmp = fcmp olt double %arg, 0x7FF00000FFFFFFFF
  63   ret i1 %tmp
  64 }
  65
  66 define i1 @nan3(double %arg) {
  67 ; CHECK-LABEL: @nan3(
  68 ; CHECK-NEXT:    ret i1 true
  69 ;
  70   %tmp = fcmp uno double %arg, 0x7FF00000FFFFFFFF
  71   ret i1 %tmp
  72 }
  73
  74 define i1 @nan4(double %arg) {
  75 ; CHECK-LABEL: @nan4(
  76 ; CHECK-NEXT:    ret i1 true
  77 ;
  78   %tmp = fcmp une double %arg, 0x7FF00000FFFFFFFF
  79   ret i1 %tmp
  80 }
  81
  82 define i1 @nan5(double %arg) {
  83 ; CHECK-LABEL: @nan5(
  84 ; CHECK-NEXT:    ret i1 true
  85 ;
  86   %tmp = fcmp ult double %arg, 0x7FF00000FFFFFFFF
  87   ret i1 %tmp
  88 }
  89
  90 ; Negative NaN.
  91
  92 define i1 @nnan0(double %arg) {
  93 ; CHECK-LABEL: @nnan0(
  94 ; CHECK-NEXT:    ret i1 false
  95 ;
  96   %tmp = fcmp ord double %arg, 0xFFF00000FFFFFFFF
  97   ret i1 %tmp
  98 }
  99
 100 define i1 @nnan1(double %arg) {
 101 ; CHECK-LABEL: @nnan1(
 102 ; CHECK-NEXT:    ret i1 false
 103 ;
 104   %tmp = fcmp oeq double %arg, 0xFFF00000FFFFFFFF
 105   ret i1 %tmp
 106 }
 107
 108 define i1 @nnan2(double %arg) {
 109 ; CHECK-LABEL: @nnan2(
 110 ; CHECK-NEXT:    ret i1 false
 111 ;
 112   %tmp = fcmp olt double %arg, 0xFFF00000FFFFFFFF
 113   ret i1 %tmp
 114 }
 115
 116 define i1 @nnan3(double %arg) {
 117 ; CHECK-LABEL: @nnan3(
 118 ; CHECK-NEXT:    ret i1 true
 119 ;
 120   %tmp = fcmp uno double %arg, 0xFFF00000FFFFFFFF
 121   ret i1 %tmp
 122 }
 123
 124 define i1 @nnan4(double %arg) {
 125 ; CHECK-LABEL: @nnan4(
 126 ; CHECK-NEXT:    ret i1 true
 127 ;
 128   %tmp = fcmp une double %arg, 0xFFF00000FFFFFFFF
 129   ret i1 %tmp
 130 }
 131
 132 define i1 @nnan5(double %arg) {
 133 ; CHECK-LABEL: @nnan5(
 134 ; CHECK-NEXT:    ret i1 true
 135 ;
 136   %tmp = fcmp ult double %arg, 0xFFF00000FFFFFFFF
 137   ret i1 %tmp
 138 }
 139
 140 ; Negative zero.
 141
 142 define i1 @nzero0() {
 143 ; CHECK-LABEL: @nzero0(
 144 ; CHECK-NEXT:    ret i1 true
 145 ;
 146   %tmp = fcmp oeq double 0.0, -0.0
 147   ret i1 %tmp
 148 }
 149
 150 define i1 @nzero1() {
 151 ; CHECK-LABEL: @nzero1(
 152 ; CHECK-NEXT:    ret i1 false
 153 ;
 154   %tmp = fcmp ogt double 0.0, -0.0
 155   ret i1 %tmp
 156 }
 157
 158 ; No enlightenment here.
 159
 160 define i1 @one_with_self(double %arg) {
 161 ; CHECK-LABEL: @one_with_self(
 162 ; CHECK-NEXT:    ret i1 false
 163 ;
 164   %tmp = fcmp one double %arg, %arg
 165   ret i1 %tmp
 166 }
 167
 168 ; These tests choose arbitrarily between float and double,
 169 ; and between uge and olt, to give reasonble coverage
 170 ; without combinatorial explosion.
 171
 172 declare half @llvm.fabs.f16(half)
 173 declare float @llvm.fabs.f32(float)
 174 declare double @llvm.fabs.f64(double)
 175 declare <2 x float> @llvm.fabs.v2f32(<2 x float>)
 176 declare <3 x float> @llvm.fabs.v3f32(<3 x float>)
 177 declare <2 x double> @llvm.fabs.v2f64(<2 x double>)
 178 declare float @llvm.sqrt.f32(float)
 179 declare double @llvm.powi.f64(double,i32)
 180 declare float @llvm.exp.f32(float)
 181 declare float @llvm.minnum.f32(float, float)
 182 declare <2 x float> @llvm.minnum.v2f32(<2 x float>, <2 x float>)
 183 declare float @llvm.maxnum.f32(float, float)
 184 declare <2 x float> @llvm.maxnum.v2f32(<2 x float>, <2 x float>)
 185 declare float @llvm.maximum.f32(float, float)
 186 declare double @llvm.exp2.f64(double)
 187 declare float @llvm.fma.f32(float,float,float)
 188
 189 declare void @expect_equal(i1,i1)
 190
 191 define i1 @orderedLessZeroTree(float,float,float,float) {
 192 ; CHECK-LABEL: @orderedLessZeroTree(
 193 ; CHECK-NEXT:    ret i1 true
 194 ;
 195   %square = fmul float %0, %0
 196   %abs = call float @llvm.fabs.f32(float %1)
 197   %sqrt = call float @llvm.sqrt.f32(float %2)
 198   %fma = call float @llvm.fma.f32(float %3, float %3, float %sqrt)
 199   %div = fdiv float %square, %abs
 200   %rem = frem float %sqrt, %fma
 201   %add = fadd float %div, %rem
 202   %uge = fcmp uge float %add, 0.000000e+00
 203   ret i1 %uge
 204 }
 205
 206 define i1 @orderedLessZeroExpExt(float) {
 207 ; CHECK-LABEL: @orderedLessZeroExpExt(
 208 ; CHECK-NEXT:    ret i1 true
 209 ;
 210   %a = call float @llvm.exp.f32(float %0)
 211   %b = fpext float %a to double
 212   %uge = fcmp uge double %b, 0.000000e+00
 213   ret i1 %uge
 214 }
 215
 216 define i1 @orderedLessZeroExp2Trunc(double) {
 217 ; CHECK-LABEL: @orderedLessZeroExp2Trunc(
 218 ; CHECK-NEXT:    ret i1 false
 219 ;
 220   %a = call double @llvm.exp2.f64(double %0)
 221   %b = fptrunc double %a to float
 222   %olt = fcmp olt float %b, 0.000000e+00
 223   ret i1 %olt
 224 }
 225
 226 define i1 @orderedLessZeroPowi(double,double) {
 227 ; CHECK-LABEL: @orderedLessZeroPowi(
 228 ; CHECK-NEXT:    ret i1 false
 229 ;
 230   ; Even constant exponent
 231   %a = call double @llvm.powi.f64(double %0, i32 2)
 232   %square = fmul double %1, %1
 233   ; Odd constant exponent with provably non-negative base
 234   %b = call double @llvm.powi.f64(double %square, i32 3)
 235   %c = fadd double %a, %b
 236   %olt = fcmp olt double %b, 0.000000e+00
 237   ret i1 %olt
 238 }
 239
 240 define i1 @UIToFP_is_nan_or_positive_or_zero(i32 %x) {
 241 ; CHECK-LABEL: @UIToFP_is_nan_or_positive_or_zero(
 242 ; CHECK-NEXT:    ret i1 true
 243 ;
 244   %a = uitofp i32 %x to float
 245   %r = fcmp uge float %a, 0.000000e+00
 246   ret i1 %r
 247 }
 248
 249 define <2 x i1> @UIToFP_is_nan_or_positive_or_zero_vec(<2 x i32> %x) {
 250 ; CHECK-LABEL: @UIToFP_is_nan_or_positive_or_zero_vec(
 251 ; CHECK-NEXT:    ret <2 x i1> <i1 true, i1 true>
 252 ;
 253   %a = uitofp <2 x i32> %x to <2 x float>
 254   %r = fcmp uge <2 x float> %a, zeroinitializer
 255   ret <2 x i1> %r
 256 }
 257
 258 define i1 @UIToFP_is_positive_or_zero(i32 %x) {
 259 ; CHECK-LABEL: @UIToFP_is_positive_or_zero(
 260 ; CHECK-NEXT:    ret i1 true
 261 ;
 262   %a = uitofp i32 %x to float
 263   %r = fcmp oge float %a, 0.000000e+00
 264   ret i1 %r
 265 }
 266
 267 define <2 x i1> @UIToFP_is_positive_or_zero_vec(<2 x i32> %x) {
 268 ; CHECK-LABEL: @UIToFP_is_positive_or_zero_vec(
 269 ; CHECK-NEXT:    ret <2 x i1> <i1 true, i1 true>
 270 ;
 271   %a = uitofp <2 x i32> %x to <2 x float>
 272   %r = fcmp oge <2 x float> %a, zeroinitializer
 273   ret <2 x i1> %r
 274 }
 275
 276 define i1 @UIToFP_nnan_is_positive_or_zero(i32 %x) {
 277 ; CHECK-LABEL: @UIToFP_nnan_is_positive_or_zero(
 278 ; CHECK-NEXT:    ret i1 true
 279 ;
 280   %a = uitofp i32 %x to float
 281   %r = fcmp nnan oge float %a, 0.000000e+00
 282   ret i1 %r
 283 }
 284
 285 define <2 x i1> @UIToFP_nnan_is_positive_or_zero_vec(<2 x i32> %x) {
 286 ; CHECK-LABEL: @UIToFP_nnan_is_positive_or_zero_vec(
 287 ; CHECK-NEXT:    ret <2 x i1> <i1 true, i1 true>
 288 ;
 289   %a = uitofp <2 x i32> %x to <2 x float>
 290   %r = fcmp nnan oge <2 x float> %a, zeroinitializer
 291   ret <2 x i1> %r
 292 }
 293
 294 define i1 @UIToFP_is_not_negative(i32 %x) {
 295 ; CHECK-LABEL: @UIToFP_is_not_negative(
 296 ; CHECK-NEXT:    ret i1 false
 297 ;
 298   %a = uitofp i32 %x to float
 299   %r = fcmp olt float %a, 0.000000e+00
 300   ret i1 %r
 301 }
 302
 303 define <2 x i1> @UIToFP_is_not_negative_vec(<2 x i32> %x) {
 304 ; CHECK-LABEL: @UIToFP_is_not_negative_vec(
 305 ; CHECK-NEXT:    ret <2 x i1> zeroinitializer
 306 ;
 307   %a = uitofp <2 x i32> %x to <2 x float>
 308   %r = fcmp olt <2 x float> %a, zeroinitializer
 309   ret <2 x i1> %r
 310 }
 311
 312 ; No FMF are required for this transform.
 313
 314 define i1 @UIToFP_is_not_negative_or_nan(i32 %x) {
 315 ; CHECK-LABEL: @UIToFP_is_not_negative_or_nan(
 316 ; CHECK-NEXT:    ret i1 false
 317 ;
 318   %a = uitofp i32 %x to float
 319   %r = fcmp ult float %a, 0.000000e+00
 320   ret i1 %r
 321 }
 322
 323 define <2 x i1> @UIToFP_is_not_negative_or_nan_vec(<2 x i32> %x) {
 324 ; CHECK-LABEL: @UIToFP_is_not_negative_or_nan_vec(
 325 ; CHECK-NEXT:    ret <2 x i1> zeroinitializer
 326 ;
 327   %a = uitofp <2 x i32> %x to <2 x float>
 328   %r = fcmp ult <2 x float> %a, zeroinitializer
 329   ret <2 x i1> %r
 330 }
 331
 332 define i1 @UIToFP_nnan_is_not_negative(i32 %x) {
 333 ; CHECK-LABEL: @UIToFP_nnan_is_not_negative(
 334 ; CHECK-NEXT:    ret i1 false
 335 ;
 336   %a = uitofp i32 %x to float
 337   %r = fcmp nnan ult float %a, 0.000000e+00
 338   ret i1 %r
 339 }
 340
 341 define <2 x i1> @UIToFP_nnan_is_not_negative_vec(<2 x i32> %x) {
 342 ; CHECK-LABEL: @UIToFP_nnan_is_not_negative_vec(
 343 ; CHECK-NEXT:    ret <2 x i1> zeroinitializer
 344 ;
 345   %a = uitofp <2 x i32> %x to <2 x float>
 346   %r = fcmp nnan ult <2 x float> %a, zeroinitializer
 347   ret <2 x i1> %r
 348 }
 349
 350 define i1 @fabs_is_nan_or_positive_or_zero(double %x) {
 351 ; CHECK-LABEL: @fabs_is_nan_or_positive_or_zero(
 352 ; CHECK-NEXT:    ret i1 true
 353 ;
 354   %fabs = tail call double @llvm.fabs.f64(double %x)
 355   %cmp = fcmp uge double %fabs, 0.0
 356   ret i1 %cmp
 357 }
 358
 359 define <2 x i1> @fabs_is_nan_or_positive_or_zero_vec(<2 x double> %x) {
 360 ; CHECK-LABEL: @fabs_is_nan_or_positive_or_zero_vec(
 361 ; CHECK-NEXT:    ret <2 x i1> <i1 true, i1 true>
 362 ;
 363   %fabs = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %x)
 364   %cmp = fcmp uge <2 x double> %fabs, zeroinitializer
 365   ret <2 x i1> %cmp
 366 }
 367
 368 define i1 @fabs_nnan_is_positive_or_zero(double %x) {
 369 ; CHECK-LABEL: @fabs_nnan_is_positive_or_zero(
 370 ; CHECK-NEXT:    ret i1 true
 371 ;
 372   %fabs = tail call nnan double @llvm.fabs.f64(double %x)
 373   %cmp = fcmp oge double %fabs, 0.0
 374   ret i1 %cmp
 375 }
 376
 377 define <2 x i1> @fabs_nnan_is_positive_or_zero_vec(<2 x double> %x) {
 378 ; CHECK-LABEL: @fabs_nnan_is_positive_or_zero_vec(
 379 ; CHECK-NEXT:    ret <2 x i1> <i1 true, i1 true>
 380 ;
 381   %fabs = tail call nnan <2 x double> @llvm.fabs.v2f64(<2 x double> %x)
 382   %cmp = fcmp oge <2 x double> %fabs, zeroinitializer
 383   ret <2 x i1> %cmp
 384 }
 385
 386 define i1 @fabs_fcmp-nnan_is_positive_or_zero(double %x) {
 387 ; CHECK-LABEL: @fabs_fcmp-nnan_is_positive_or_zero(
 388 ; CHECK-NEXT:    ret i1 true
 389 ;
 390   %fabs = tail call double @llvm.fabs.f64(double %x)
 391   %cmp = fcmp nnan oge double %fabs, 0.0
 392   ret i1 %cmp
 393 }
 394
 395 define <2 x i1> @fabs_fcmp-nnan_is_positive_or_zero_vec(<2 x double> %x) {
 396 ; CHECK-LABEL: @fabs_fcmp-nnan_is_positive_or_zero_vec(
 397 ; CHECK-NEXT:    ret <2 x i1> <i1 true, i1 true>
 398 ;
 399   %fabs = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %x)
 400   %cmp = fcmp nnan oge <2 x double> %fabs, zeroinitializer
 401   ret <2 x i1> %cmp
 402 }
 403
 404 define i1 @fabs_is_not_negative(double %x) {
 405 ; CHECK-LABEL: @fabs_is_not_negative(
 406 ; CHECK-NEXT:    ret i1 false
 407 ;
 408   %fabs = tail call double @llvm.fabs.f64(double %x)
 409   %cmp = fcmp olt double %fabs, 0.0
 410   ret i1 %cmp
 411 }
 412
 413 define <2 x i1> @fabs_is_not_negative_vec(<2 x double> %x) {
 414 ; CHECK-LABEL: @fabs_is_not_negative_vec(
 415 ; CHECK-NEXT:    ret <2 x i1> zeroinitializer
 416 ;
 417   %fabs = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %x)
 418   %cmp = fcmp olt <2 x double> %fabs, zeroinitializer
 419   ret <2 x i1> %cmp
 420 }
 421
 422 define i1 @fabs_nnan_is_not_negative(double %x) {
 423 ; CHECK-LABEL: @fabs_nnan_is_not_negative(
 424 ; CHECK-NEXT:    ret i1 false
 425 ;
 426   %fabs = tail call nnan double @llvm.fabs.f64(double %x)
 427   %cmp = fcmp ult double %fabs, 0.0
 428   ret i1 %cmp
 429 }
 430
 431 define <2 x i1> @fabs_nnan_is_not_negative_vec(<2 x double> %x) {
 432 ; CHECK-LABEL: @fabs_nnan_is_not_negative_vec(
 433 ; CHECK-NEXT:    ret <2 x i1> zeroinitializer
 434 ;
 435   %fabs = tail call nnan <2 x double> @llvm.fabs.v2f64(<2 x double> %x)
 436   %cmp = fcmp ult <2 x double> %fabs, zeroinitializer
 437   ret <2 x i1> %cmp
 438 }
 439
 440 define i1 @fabs_fcmp-nnan_is_not_negative(double %x) {
 441 ; CHECK-LABEL: @fabs_fcmp-nnan_is_not_negative(
 442 ; CHECK-NEXT:    ret i1 false
 443 ;
 444   %fabs = tail call double @llvm.fabs.f64(double %x)
 445   %cmp = fcmp nnan ult double %fabs, 0.0
 446   ret i1 %cmp
 447 }
 448
 449 define <2 x i1> @fabs_fcmp-nnan_is_not_negative_vec(<2 x double> %x) {
 450 ; CHECK-LABEL: @fabs_fcmp-nnan_is_not_negative_vec(
 451 ; CHECK-NEXT:    ret <2 x i1> zeroinitializer
 452 ;
 453   %fabs = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %x)
 454   %cmp = fcmp nnan ult <2 x double> %fabs, zeroinitializer
 455   ret <2 x i1> %cmp
 456 }
 457
 458 define <2 x i1> @fabs_is_not_negative_negzero(<2 x float> %V) {
 459 ; CHECK-LABEL: @fabs_is_not_negative_negzero(
 460 ; CHECK-NEXT:    ret <2 x i1> zeroinitializer
 461 ;
 462   %abs = call <2 x float> @llvm.fabs.v2f32(<2 x float> %V)
 463   %cmp = fcmp olt <2 x float> %abs, <float -0.0, float -0.0>
 464   ret <2 x i1> %cmp
 465 }
 466
 467 define <2 x i1> @fabs_is_not_negative_poszero(<2 x float> %V) {
 468 ; CHECK-LABEL: @fabs_is_not_negative_poszero(
 469 ; CHECK-NEXT:    ret <2 x i1> zeroinitializer
 470 ;
 471   %abs = call <2 x float> @llvm.fabs.v2f32(<2 x float> %V)
 472   %cmp = fcmp olt <2 x float> %abs, <float 0.0, float 0.0>
 473   ret <2 x i1> %cmp
 474 }
 475
 476 define <2 x i1> @fabs_is_not_negative_anyzero(<2 x float> %V) {
 477 ; CHECK-LABEL: @fabs_is_not_negative_anyzero(
 478 ; CHECK-NEXT:    ret <2 x i1> zeroinitializer
 479 ;
 480   %abs = call <2 x float> @llvm.fabs.v2f32(<2 x float> %V)
 481   %cmp = fcmp olt <2 x float> %abs, <float 0.0, float -0.0>
 482   ret <2 x i1> %cmp
 483 }
 484
 485 define <3 x i1> @fabs_is_not_negative_negzero_undef(<3 x float> %V) {
 486 ; CHECK-LABEL: @fabs_is_not_negative_negzero_undef(
 487 ; CHECK-NEXT:    ret <3 x i1> zeroinitializer
 488 ;
 489   %abs = call <3 x float> @llvm.fabs.v3f32(<3 x float> %V)
 490   %cmp = fcmp olt <3 x float> %abs, <float -0.0, float -0.0, float undef>
 491   ret <3 x i1> %cmp
 492 }
 493
 494 define <3 x i1> @fabs_is_not_negative_poszero_undef(<3 x float> %V) {
 495 ; CHECK-LABEL: @fabs_is_not_negative_poszero_undef(
 496 ; CHECK-NEXT:    ret <3 x i1> zeroinitializer
 497 ;
 498   %abs = call <3 x float> @llvm.fabs.v3f32(<3 x float> %V)
 499   %cmp = fcmp olt <3 x float> %abs, <float 0.0, float 0.0, float undef>
 500   ret <3 x i1> %cmp
 501 }
 502
 503 define <3 x i1> @fabs_is_not_negative_anyzero_undef(<3 x float> %V) {
 504 ; CHECK-LABEL: @fabs_is_not_negative_anyzero_undef(
 505 ; CHECK-NEXT:    ret <3 x i1> zeroinitializer
 506 ;
 507   %abs = call <3 x float> @llvm.fabs.v3f32(<3 x float> %V)
 508   %cmp = fcmp olt <3 x float> %abs, <float 0.0, float -0.0, float undef>
 509   ret <3 x i1> %cmp
 510 }
 511
 512 define i1 @orderedLessZeroSelect(float, float) {
 513 ; CHECK-LABEL: @orderedLessZeroSelect(
 514 ; CHECK-NEXT:    ret i1 true
 515 ;
 516   %a = call float @llvm.exp.f32(float %0)
 517   %b = call float @llvm.fabs.f32(float %1)
 518   %c = fcmp olt float %0, %1
 519   %d = select i1 %c, float %a, float %b
 520   %e = fadd float %d, 1.0
 521   %uge = fcmp uge float %e, 0.000000e+00
 522   ret i1 %uge
 523 }
 524
 525 define i1 @orderedLessZeroMinNum(float, float) {
 526 ; CHECK-LABEL: @orderedLessZeroMinNum(
 527 ; CHECK-NEXT:    ret i1 true
 528 ;
 529   %a = call float @llvm.exp.f32(float %0)
 530   %b = call float @llvm.fabs.f32(float %1)
 531   %c = call float @llvm.minnum.f32(float %a, float %b)
 532   %uge = fcmp uge float %c, 0.000000e+00
 533   ret i1 %uge
 534 }
 535
 536 ; PR37776: https://bugs.llvm.org/show_bug.cgi?id=37776
 537 ; exp() may return nan, leaving %1 as the unknown result, so we can't simplify.
 538
 539 define i1 @orderedLessZeroMaxNum(float, float) {
 540 ; CHECK-LABEL: @orderedLessZeroMaxNum(
 541 ; CHECK-NEXT:    [[A:%.*]] = call float @llvm.exp.f32(float [[TMP0:%.*]])
 542 ; CHECK-NEXT:    [[B:%.*]] = call float @llvm.maxnum.f32(float [[A]], float [[TMP1:%.*]])
 543 ; CHECK-NEXT:    [[UGE:%.*]] = fcmp uge float [[B]], 0.000000e+00
 544 ; CHECK-NEXT:    ret i1 [[UGE]]
 545 ;
 546   %a = call float @llvm.exp.f32(float %0)
 547   %b = call float @llvm.maxnum.f32(float %a, float %1)
 548   %uge = fcmp uge float %b, 0.000000e+00
 549   ret i1 %uge
 550 }
 551
 552 ; But using maximum, we can simplify, since the NaN would be propagated
 553
 554 define i1 @orderedLessZeroMaximum(float, float) {
 555 ; CHECK-LABEL: @orderedLessZeroMaximum(
 556 ; CHECK-NEXT:    ret i1 true
 557 ;
 558   %a = call float @llvm.exp.f32(float %0)
 559   %b = call float @llvm.maximum.f32(float %a, float %1)
 560   %uge = fcmp uge float %b, 0.000000e+00
 561   ret i1 %uge
 562 }
 563
 564 define i1 @minnum_non_nan(float %x) {
 565 ; CHECK-LABEL: @minnum_non_nan(
 566 ; CHECK-NEXT:    ret i1 true
 567 ;
 568   %min = call float @llvm.minnum.f32(float 0.5, float %x)
 569   %cmp = fcmp ord float %min, 1.0
 570   ret i1 %cmp
 571 }
 572
 573 define i1 @maxnum_non_nan(float %x) {
 574 ; CHECK-LABEL: @maxnum_non_nan(
 575 ; CHECK-NEXT:    ret i1 false
 576 ;
 577   %min = call float @llvm.maxnum.f32(float %x, float 42.0)
 578   %cmp = fcmp uno float %min, 12.0
 579   ret i1 %cmp
 580 }
 581
 582 ; min(x, 0.5) == 1.0 --> false
 583
 584 define i1 @minnum_oeq_small_min_constant(float %x) {
 585 ; CHECK-LABEL: @minnum_oeq_small_min_constant(
 586 ; CHECK-NEXT:    ret i1 false
 587 ;
 588   %min = call float @llvm.minnum.f32(float %x, float 0.5)
 589   %cmp = fcmp oeq float %min, 1.0
 590   ret i1 %cmp
 591 }
 592
 593 ; min(x, 0.5) > 1.0 --> false
 594
 595 define i1 @minnum_ogt_small_min_constant(float %x) {
 596 ; CHECK-LABEL: @minnum_ogt_small_min_constant(
 597 ; CHECK-NEXT:    ret i1 false
 598 ;
 599   %min = call float @llvm.minnum.f32(float %x, float 0.5)
 600   %cmp = fcmp ogt float %min, 1.0
 601   ret i1 %cmp
 602 }
 603
 604 ; min(x, 0.5) >= 1.0 --> false
 605
 606 define i1 @minnum_oge_small_min_constant(float %x) {
 607 ; CHECK-LABEL: @minnum_oge_small_min_constant(
 608 ; CHECK-NEXT:    ret i1 false
 609 ;
 610   %min = call float @llvm.minnum.f32(float %x, float 0.5)
 611   %cmp = fcmp oge float %min, 1.0
 612   ret i1 %cmp
 613 }
 614
 615 ; min(x, 0.5) == 1.0 --> false
 616
 617 define i1 @minnum_ueq_small_min_constant(float %x) {
 618 ; CHECK-LABEL: @minnum_ueq_small_min_constant(
 619 ; CHECK-NEXT:    ret i1 false
 620 ;
 621   %min = call float @llvm.minnum.f32(float %x, float 0.5)
 622   %cmp = fcmp ueq float %min, 1.0
 623   ret i1 %cmp
 624 }
 625
 626 ; min(x, 0.5) > 1.0 --> false
 627
 628 define i1 @minnum_ugt_small_min_constant(float %x) {
 629 ; CHECK-LABEL: @minnum_ugt_small_min_constant(
 630 ; CHECK-NEXT:    ret i1 false
 631 ;
 632   %min = call float @llvm.minnum.f32(float %x, float 0.5)
 633   %cmp = fcmp ugt float %min, 1.0
 634   ret i1 %cmp
 635 }
 636
 637 ; min(x, 0.5) >= 1.0 --> false
 638
 639 define <2 x i1> @minnum_uge_small_min_constant(<2 x float> %x) {
 640 ; CHECK-LABEL: @minnum_uge_small_min_constant(
 641 ; CHECK-NEXT:    ret <2 x i1> zeroinitializer
 642 ;
 643   %min = call <2 x float> @llvm.minnum.v2f32(<2 x float> %x, <2 x float> <float 0.5, float 0.5>)
 644   %cmp = fcmp uge <2 x float> %min, <float 1.0, float 1.0>
 645   ret <2 x i1> %cmp
 646 }
 647
 648 ; min(x, 0.5) < 1.0 --> true
 649
 650 define <2 x i1> @minnum_olt_small_min_constant(<2 x float> %x) {
 651 ; CHECK-LABEL: @minnum_olt_small_min_constant(
 652 ; CHECK-NEXT:    ret <2 x i1> <i1 true, i1 true>
 653 ;
 654   %min = call <2 x float> @llvm.minnum.v2f32(<2 x float> %x, <2 x float> <float 0.5, float 0.5>)
 655   %cmp = fcmp olt <2 x float> %min, <float 1.0, float 1.0>
 656   ret <2 x i1> %cmp
 657 }
 658
 659 ; min(x, 0.5) <= 1.0 --> true
 660
 661 define i1 @minnum_ole_small_min_constant(float %x) {
 662 ; CHECK-LABEL: @minnum_ole_small_min_constant(
 663 ; CHECK-NEXT:    ret i1 true
 664 ;
 665   %min = call float @llvm.minnum.f32(float %x, float 0.5)
 666   %cmp = fcmp ole float %min, 1.0
 667   ret i1 %cmp
 668 }
 669
 670 ; min(x, 0.5) != 1.0 --> true
 671
 672 define i1 @minnum_one_small_min_constant(float %x) {
 673 ; CHECK-LABEL: @minnum_one_small_min_constant(
 674 ; CHECK-NEXT:    ret i1 true
 675 ;
 676   %min = call float @llvm.minnum.f32(float %x, float 0.5)
 677   %cmp = fcmp one float %min, 1.0
 678   ret i1 %cmp
 679 }
 680
 681 ; min(x, 0.5) < 1.0 --> true
 682
 683 define i1 @minnum_ult_small_min_constant(float %x) {
 684 ; CHECK-LABEL: @minnum_ult_small_min_constant(
 685 ; CHECK-NEXT:    ret i1 true
 686 ;
 687   %min = call float @llvm.minnum.f32(float %x, float 0.5)
 688   %cmp = fcmp ult float %min, 1.0
 689   ret i1 %cmp
 690 }
 691
 692 ; min(x, 0.5) <= 1.0 --> true
 693
 694 define i1 @minnum_ule_small_min_constant(float %x) {
 695 ; CHECK-LABEL: @minnum_ule_small_min_constant(
 696 ; CHECK-NEXT:    ret i1 true
 697 ;
 698   %min = call float @llvm.minnum.f32(float %x, float 0.5)
 699   %cmp = fcmp ule float %min, 1.0
 700   ret i1 %cmp
 701 }
 702
 703 ; min(x, 0.5) != 1.0 --> true
 704
 705 define i1 @minnum_une_small_min_constant(float %x) {
 706 ; CHECK-LABEL: @minnum_une_small_min_constant(
 707 ; CHECK-NEXT:    ret i1 true
 708 ;
 709   %min = call float @llvm.minnum.f32(float %x, float 0.5)
 710   %cmp = fcmp une float %min, 1.0
 711   ret i1 %cmp
 712 }
 713
 714 ; Negative test:
 715 ; min(x, 1.0) != 1.0 --> ?
 716
 717 define i1 @minnum_une_equal_min_constant(float %x) {
 718 ; CHECK-LABEL: @minnum_une_equal_min_constant(
 719 ; CHECK-NEXT:    [[MIN:%.*]] = call float @llvm.minnum.f32(float [[X:%.*]], float 1.000000e+00)
 720 ; CHECK-NEXT:    [[CMP:%.*]] = fcmp une float [[MIN]], 1.000000e+00
 721 ; CHECK-NEXT:    ret i1 [[CMP]]
 722 ;
 723   %min = call float @llvm.minnum.f32(float %x, float 1.0)
 724   %cmp = fcmp une float %min, 1.0
 725   ret i1 %cmp
 726 }
 727
 728 ; Negative test:
 729 ; min(x, 2.0) != 1.0 --> ?
 730
 731 define i1 @minnum_une_large_min_constant(float %x) {
 732 ; CHECK-LABEL: @minnum_une_large_min_constant(
 733 ; CHECK-NEXT:    [[MIN:%.*]] = call float @llvm.minnum.f32(float [[X:%.*]], float 2.000000e+00)
 734 ; CHECK-NEXT:    [[CMP:%.*]] = fcmp une float [[MIN]], 1.000000e+00
 735 ; CHECK-NEXT:    ret i1 [[CMP]]
 736 ;
 737   %min = call float @llvm.minnum.f32(float %x, float 2.0)
 738   %cmp = fcmp une float %min, 1.0
 739   ret i1 %cmp
 740 }
 741
 742 ; Partial negative test (the minnum simplifies):
 743 ; min(x, NaN) != 1.0 --> x != 1.0
 744
 745 define i1 @minnum_une_nan_min_constant(float %x) {
 746 ; CHECK-LABEL: @minnum_une_nan_min_constant(
 747 ; CHECK-NEXT:    [[CMP:%.*]] = fcmp une float [[X:%.*]], 1.000000e+00
 748 ; CHECK-NEXT:    ret i1 [[CMP]]
 749 ;
 750   %min = call float @llvm.minnum.f32(float %x, float 0x7FF8000000000000)
 751   %cmp = fcmp une float %min, 1.0
 752   ret i1 %cmp
 753 }
 754
 755 ; max(x, 1.5) == 1.0 --> false
 756
 757 define i1 @maxnum_oeq_large_max_constant(float %x) {
 758 ; CHECK-LABEL: @maxnum_oeq_large_max_constant(
 759 ; CHECK-NEXT:    ret i1 false
 760 ;
 761   %max = call float @llvm.maxnum.f32(float %x, float 1.5)
 762   %cmp = fcmp oeq float %max, 1.0
 763   ret i1 %cmp
 764 }
 765
 766 ; max(x, 1.5) < 1.0 --> false
 767
 768 define i1 @maxnum_olt_large_max_constant(float %x) {
 769 ; CHECK-LABEL: @maxnum_olt_large_max_constant(
 770 ; CHECK-NEXT:    ret i1 false
 771 ;
 772   %max = call float @llvm.maxnum.f32(float %x, float 1.5)
 773   %cmp = fcmp olt float %max, 1.0
 774   ret i1 %cmp
 775 }
 776
 777 ; max(x, 1.5) <= 1.0 --> false
 778
 779 define i1 @maxnum_ole_large_max_constant(float %x) {
 780 ; CHECK-LABEL: @maxnum_ole_large_max_constant(
 781 ; CHECK-NEXT:    ret i1 false
 782 ;
 783   %max = call float @llvm.maxnum.f32(float %x, float 1.5)
 784   %cmp = fcmp ole float %max, 1.0
 785   ret i1 %cmp
 786 }
 787
 788 ; max(x, 1.5) == 1.0 --> false
 789
 790 define i1 @maxnum_ueq_large_max_constant(float %x) {
 791 ; CHECK-LABEL: @maxnum_ueq_large_max_constant(
 792 ; CHECK-NEXT:    ret i1 false
 793 ;
 794   %max = call float @llvm.maxnum.f32(float %x, float 1.5)
 795   %cmp = fcmp ueq float %max, 1.0
 796   ret i1 %cmp
 797 }
 798
 799 ; max(x, 1.5) < 1.0 --> false
 800
 801 define i1 @maxnum_ult_large_max_constant(float %x) {
 802 ; CHECK-LABEL: @maxnum_ult_large_max_constant(
 803 ; CHECK-NEXT:    ret i1 false
 804 ;
 805   %max = call float @llvm.maxnum.f32(float %x, float 1.5)
 806   %cmp = fcmp ult float %max, 1.0
 807   ret i1 %cmp
 808 }
 809
 810 ; max(x, 1.5) <= 1.0 --> false
 811
 812 define <2 x i1> @maxnum_ule_large_max_constant(<2 x float> %x) {
 813 ; CHECK-LABEL: @maxnum_ule_large_max_constant(
 814 ; CHECK-NEXT:    ret <2 x i1> zeroinitializer
 815 ;
 816   %max = call <2 x float> @llvm.maxnum.v2f32(<2 x float> %x, <2 x float> <float 1.5, float 1.5>)
 817   %cmp = fcmp ule <2 x float> %max, <float 1.0, float 1.0>
 818   ret <2 x i1> %cmp
 819 }
 820
 821 ; max(x, 1.5) > 1.0 --> true
 822
 823 define <2 x i1> @maxnum_ogt_large_max_constant(<2 x float> %x) {
 824 ; CHECK-LABEL: @maxnum_ogt_large_max_constant(
 825 ; CHECK-NEXT:    ret <2 x i1> <i1 true, i1 true>
 826 ;
 827   %max = call <2 x float> @llvm.maxnum.v2f32(<2 x float> %x, <2 x float> <float 1.5, float 1.5>)
 828   %cmp = fcmp ogt <2 x float> %max, <float 1.0, float 1.0>
 829   ret <2 x i1> %cmp
 830 }
 831
 832 ; max(x, 1.5) >= 1.0 --> true
 833
 834 define i1 @maxnum_oge_large_max_constant(float %x) {
 835 ; CHECK-LABEL: @maxnum_oge_large_max_constant(
 836 ; CHECK-NEXT:    ret i1 true
 837 ;
 838   %max = call float @llvm.maxnum.f32(float %x, float 1.5)
 839   %cmp = fcmp oge float %max, 1.0
 840   ret i1 %cmp
 841 }
 842
 843 ; max(x, 1.5) != 1.0 --> true
 844
 845 define i1 @maxnum_one_large_max_constant(float %x) {
 846 ; CHECK-LABEL: @maxnum_one_large_max_constant(
 847 ; CHECK-NEXT:    ret i1 true
 848 ;
 849   %max = call float @llvm.maxnum.f32(float %x, float 1.5)
 850   %cmp = fcmp one float %max, 1.0
 851   ret i1 %cmp
 852 }
 853
 854 ; max(x, 1.5) > 1.0 --> true
 855
 856 define i1 @maxnum_ugt_large_max_constant(float %x) {
 857 ; CHECK-LABEL: @maxnum_ugt_large_max_constant(
 858 ; CHECK-NEXT:    ret i1 true
 859 ;
 860   %max = call float @llvm.maxnum.f32(float %x, float 1.5)
 861   %cmp = fcmp ugt float %max, 1.0
 862   ret i1 %cmp
 863 }
 864
 865 ; max(x, 1.5) >= 1.0 --> true
 866
 867 define i1 @maxnum_uge_large_max_constant(float %x) {
 868 ; CHECK-LABEL: @maxnum_uge_large_max_constant(
 869 ; CHECK-NEXT:    ret i1 true
 870 ;
 871   %max = call float @llvm.maxnum.f32(float %x, float 1.5)
 872   %cmp = fcmp uge float %max, 1.0
 873   ret i1 %cmp
 874 }
 875
 876 ; max(x, 1.5) != 1.0 --> true
 877
 878 define i1 @maxnum_une_large_max_constant(float %x) {
 879 ; CHECK-LABEL: @maxnum_une_large_max_constant(
 880 ; CHECK-NEXT:    ret i1 true
 881 ;
 882   %max = call float @llvm.maxnum.f32(float %x, float 1.5)
 883   %cmp = fcmp une float %max, 1.0
 884   ret i1 %cmp
 885 }
 886
 887 ; Negative test:
 888 ; max(x, 1.0) != 1.0 --> ?
 889
 890 define i1 @maxnum_une_equal_max_constant(float %x) {
 891 ; CHECK-LABEL: @maxnum_une_equal_max_constant(
 892 ; CHECK-NEXT:    [[MAX:%.*]] = call float @llvm.maxnum.f32(float [[X:%.*]], float 1.000000e+00)
 893 ; CHECK-NEXT:    [[CMP:%.*]] = fcmp une float [[MAX]], 1.000000e+00
 894 ; CHECK-NEXT:    ret i1 [[CMP]]
 895 ;
 896   %max = call float @llvm.maxnum.f32(float %x, float 1.0)
 897   %cmp = fcmp une float %max, 1.0
 898   ret i1 %cmp
 899 }
 900
 901 ; Negative test:
 902 ; max(x, 0.5) != 1.0 --> ?
 903
 904 define i1 @maxnum_une_small_max_constant(float %x) {
 905 ; CHECK-LABEL: @maxnum_une_small_max_constant(
 906 ; CHECK-NEXT:    [[MAX:%.*]] = call float @llvm.maxnum.f32(float [[X:%.*]], float 5.000000e-01)
 907 ; CHECK-NEXT:    [[CMP:%.*]] = fcmp une float [[MAX]], 1.000000e+00
 908 ; CHECK-NEXT:    ret i1 [[CMP]]
 909 ;
 910   %max = call float @llvm.maxnum.f32(float %x, float 0.5)
 911   %cmp = fcmp une float %max, 1.0
 912   ret i1 %cmp
 913 }
 914
 915 ; Partial negative test (the maxnum simplifies):
 916 ; max(x, NaN) != 1.0 --> x != 1.0
 917
 918 define i1 @maxnum_une_nan_max_constant(float %x) {
 919 ; CHECK-LABEL: @maxnum_une_nan_max_constant(
 920 ; CHECK-NEXT:    [[CMP:%.*]] = fcmp une float [[X:%.*]], 1.000000e+00
 921 ; CHECK-NEXT:    ret i1 [[CMP]]
 922 ;
 923   %max = call float @llvm.maxnum.f32(float %x, float 0x7FF8000000000000)
 924   %cmp = fcmp une float %max, 1.0
 925   ret i1 %cmp
 926 }
 927
 928 define i1 @known_positive_olt_with_negative_constant(double %a) {
 929 ; CHECK-LABEL: @known_positive_olt_with_negative_constant(
 930 ; CHECK-NEXT:    ret i1 false
 931 ;
 932   %call = call double @llvm.fabs.f64(double %a)
 933   %cmp = fcmp olt double %call, -1.0
 934   ret i1 %cmp
 935 }
 936
 937 define <2 x i1> @known_positive_ole_with_negative_constant_splat_vec(<2 x i32> %a) {
 938 ; CHECK-LABEL: @known_positive_ole_with_negative_constant_splat_vec(
 939 ; CHECK-NEXT:    ret <2 x i1> zeroinitializer
 940 ;
 941   %call = uitofp <2 x i32> %a to <2 x double>
 942   %cmp = fcmp ole <2 x double> %call, <double -2.0, double -2.0>
 943   ret <2 x i1> %cmp
 944 }
 945
 946 define i1 @known_positive_ugt_with_negative_constant(i32 %a) {
 947 ; CHECK-LABEL: @known_positive_ugt_with_negative_constant(
 948 ; CHECK-NEXT:    ret i1 true
 949 ;
 950   %call = uitofp i32 %a to float
 951   %cmp = fcmp ugt float %call, -3.0
 952   ret i1 %cmp
 953 }
 954
 955 define <2 x i1> @known_positive_uge_with_negative_constant_splat_vec(<2 x float> %a) {
 956 ; CHECK-LABEL: @known_positive_uge_with_negative_constant_splat_vec(
 957 ; CHECK-NEXT:    ret <2 x i1> <i1 true, i1 true>
 958 ;
 959   %call = call <2 x float> @llvm.fabs.v2f32(<2 x float> %a)
 960   %cmp = fcmp uge <2 x float> %call, <float -4.0, float -4.0>
 961   ret <2 x i1> %cmp
 962 }
 963
 964 define i1 @known_positive_oeq_with_negative_constant(half %a) {
 965 ; CHECK-LABEL: @known_positive_oeq_with_negative_constant(
 966 ; CHECK-NEXT:    ret i1 false
 967 ;
 968   %call = call half @llvm.fabs.f16(half %a)
 969   %cmp = fcmp oeq half %call, -5.0
 970   ret i1 %cmp
 971 }
 972
 973 define <2 x i1> @known_positive_une_with_negative_constant_splat_vec(<2 x i32> %a) {
 974 ; CHECK-LABEL: @known_positive_une_with_negative_constant_splat_vec(
 975 ; CHECK-NEXT:    ret <2 x i1> <i1 true, i1 true>
 976 ;
 977   %call = uitofp <2 x i32> %a to <2 x half>
 978   %cmp = fcmp une <2 x half> %call, <half -6.0, half -6.0>
 979   ret <2 x i1> %cmp
 980 }
 981
 982 define i1 @nonans1(double %in1, double %in2) {
 983 ; CHECK-LABEL: @nonans1(
 984 ; CHECK-NEXT:    ret i1 false
 985 ;
 986   %cmp = fcmp nnan uno double %in1, %in2
 987   ret i1 %cmp
 988 }
 989
 990 define i1 @nonans2(double %in1, double %in2) {
 991 ; CHECK-LABEL: @nonans2(
 992 ; CHECK-NEXT:    ret i1 true
 993 ;
 994   %cmp = fcmp nnan ord double %in1, %in2
 995   ret i1 %cmp
 996 }
 997
 998 define <2 x i1> @orderedCompareWithNaNVector(<2 x double> %A) {
 999 ; CHECK-LABEL: @orderedCompareWithNaNVector(
1000 ; CHECK-NEXT:    ret <2 x i1> zeroinitializer
1001 ;
1002   %cmp = fcmp olt <2 x double> %A, <double 0xFFFFFFFFFFFFFFFF, double 0xFFFFFFFFFFFFFFFF>
1003   ret <2 x i1> %cmp
1004 }
1005
1006 define <2 x i1> @orderedCompareWithNaNVector_undef_elt(<2 x double> %A) {
1007 ; CHECK-LABEL: @orderedCompareWithNaNVector_undef_elt(
1008 ; CHECK-NEXT:    ret <2 x i1> zeroinitializer
1009 ;
1010   %cmp = fcmp olt <2 x double> %A, <double 0xFFFFFFFFFFFFFFFF, double undef>
1011   ret <2 x i1> %cmp
1012 }
1013
1014 define <2 x i1> @unorderedCompareWithNaNVector_undef_elt(<2 x double> %A) {
1015 ; CHECK-LABEL: @unorderedCompareWithNaNVector_undef_elt(
1016 ; CHECK-NEXT:    ret <2 x i1> <i1 true, i1 true>
1017 ;
1018   %cmp = fcmp ult <2 x double> %A, <double undef, double 0xFFFFFFFFFFFFFFFF>
1019   ret <2 x i1> %cmp
1020 }