llvm/test/Transforms/InstCombine/and-or-icmp-min-max.ll

   1 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
   2 ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
   3
   4 ; There are 12 basic patterns (or 6 with DeMorganized equivalent) with
   5 ;    2 (commute logic op) *
   6 ;    2 (swap compare operands) *
   7 ;    2 (signed/unsigned)
   8 ; variations for a total of 96 tests.
   9
  10 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  11 ;
  12 ; (X == MAX) && (X < Y) --> false
  13 ;
  14 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  15
  16 define i1 @slt_and_max(i8 %x, i8 %y)  {
  17 ; CHECK-LABEL: @slt_and_max(
  18 ; CHECK-NEXT:    ret i1 false
  19 ;
  20   %cmp = icmp slt i8 %x, %y
  21   %cmpeq = icmp eq i8 %x, 127
  22   %r = and i1 %cmp, %cmpeq
  23   ret i1 %r
  24 }
  25
  26 define i1 @slt_and_max_logical(i8 %x, i8 %y)  {
  27 ; CHECK-LABEL: @slt_and_max_logical(
  28 ; CHECK-NEXT:    ret i1 false
  29 ;
  30   %cmp = icmp slt i8 %x, %y
  31   %cmpeq = icmp eq i8 %x, 127
  32   %r = select i1 %cmp, i1 %cmpeq, i1 false
  33   ret i1 %r
  34 }
  35
  36 define <2 x i1> @slt_and_max_commute(<2 x i8> %x, <2 x i8> %y)  {
  37 ; CHECK-LABEL: @slt_and_max_commute(
  38 ; CHECK-NEXT:    ret <2 x i1> zeroinitializer
  39 ;
  40   %cmp = icmp slt <2 x i8> %x, %y
  41   %cmpeq = icmp eq <2 x i8> %x, <i8 127, i8 127>
  42   %r = and <2 x i1> %cmpeq, %cmp
  43   ret <2 x i1> %r
  44 }
  45
  46 define i1 @slt_swap_and_max(i8 %x, i8 %y)  {
  47 ; CHECK-LABEL: @slt_swap_and_max(
  48 ; CHECK-NEXT:    ret i1 false
  49 ;
  50   %cmp = icmp sgt i8 %y, %x
  51   %cmpeq = icmp eq i8 %x, 127
  52   %r = and i1 %cmp, %cmpeq
  53   ret i1 %r
  54 }
  55
  56 define i1 @slt_swap_and_max_logical(i8 %x, i8 %y)  {
  57 ; CHECK-LABEL: @slt_swap_and_max_logical(
  58 ; CHECK-NEXT:    ret i1 false
  59 ;
  60   %cmp = icmp sgt i8 %y, %x
  61   %cmpeq = icmp eq i8 %x, 127
  62   %r = select i1 %cmp, i1 %cmpeq, i1 false
  63   ret i1 %r
  64 }
  65
  66 define i1 @slt_swap_and_max_commute(i8 %x, i8 %y)  {
  67 ; CHECK-LABEL: @slt_swap_and_max_commute(
  68 ; CHECK-NEXT:    ret i1 false
  69 ;
  70   %cmp = icmp sgt i8 %y, %x
  71   %cmpeq = icmp eq i8 %x, 127
  72   %r = and i1 %cmpeq, %cmp
  73   ret i1 %r
  74 }
  75
  76 define i1 @slt_swap_and_max_commute_logical(i8 %x, i8 %y)  {
  77 ; CHECK-LABEL: @slt_swap_and_max_commute_logical(
  78 ; CHECK-NEXT:    ret i1 false
  79 ;
  80   %cmp = icmp sgt i8 %y, %x
  81   %cmpeq = icmp eq i8 %x, 127
  82   %r = select i1 %cmpeq, i1 %cmp, i1 false
  83   ret i1 %r
  84 }
  85
  86 define i1 @ult_and_max(i8 %x, i8 %y)  {
  87 ; CHECK-LABEL: @ult_and_max(
  88 ; CHECK-NEXT:    ret i1 false
  89 ;
  90   %cmp = icmp ult i8 %x, %y
  91   %cmpeq = icmp eq i8 %x, 255
  92   %r = and i1 %cmp, %cmpeq
  93   ret i1 %r
  94 }
  95
  96 define i1 @ult_and_max_logical(i8 %x, i8 %y)  {
  97 ; CHECK-LABEL: @ult_and_max_logical(
  98 ; CHECK-NEXT:    ret i1 false
  99 ;
 100   %cmp = icmp ult i8 %x, %y
 101   %cmpeq = icmp eq i8 %x, 255
 102   %r = select i1 %cmp, i1 %cmpeq, i1 false
 103   ret i1 %r
 104 }
 105
 106 define i1 @ult_and_max_commute(i8 %x, i8 %y)  {
 107 ; CHECK-LABEL: @ult_and_max_commute(
 108 ; CHECK-NEXT:    ret i1 false
 109 ;
 110   %cmp = icmp ult i8 %x, %y
 111   %cmpeq = icmp eq i8 %x, 255
 112   %r = and i1 %cmpeq, %cmp
 113   ret i1 %r
 114 }
 115
 116 define i1 @ult_and_max_commute_logical(i8 %x, i8 %y)  {
 117 ; CHECK-LABEL: @ult_and_max_commute_logical(
 118 ; CHECK-NEXT:    ret i1 false
 119 ;
 120   %cmp = icmp ult i8 %x, %y
 121   %cmpeq = icmp eq i8 %x, 255
 122   %r = select i1 %cmpeq, i1 %cmp, i1 false
 123   ret i1 %r
 124 }
 125
 126 define i1 @ult_swap_and_max(i8 %x, i8 %y)  {
 127 ; CHECK-LABEL: @ult_swap_and_max(
 128 ; CHECK-NEXT:    ret i1 false
 129 ;
 130   %cmp = icmp ugt i8 %y, %x
 131   %cmpeq = icmp eq i8 %x, 255
 132   %r = and i1 %cmp, %cmpeq
 133   ret i1 %r
 134 }
 135
 136 define i1 @ult_swap_and_max_logical(i8 %x, i8 %y)  {
 137 ; CHECK-LABEL: @ult_swap_and_max_logical(
 138 ; CHECK-NEXT:    ret i1 false
 139 ;
 140   %cmp = icmp ugt i8 %y, %x
 141   %cmpeq = icmp eq i8 %x, 255
 142   %r = select i1 %cmp, i1 %cmpeq, i1 false
 143   ret i1 %r
 144 }
 145
 146 define i1 @ult_swap_and_max_commute(i8 %x, i8 %y)  {
 147 ; CHECK-LABEL: @ult_swap_and_max_commute(
 148 ; CHECK-NEXT:    ret i1 false
 149 ;
 150   %cmp = icmp ugt i8 %y, %x
 151   %cmpeq = icmp eq i8 %x, 255
 152   %r = and i1 %cmpeq, %cmp
 153   ret i1 %r
 154 }
 155
 156 define i1 @ult_swap_and_max_commute_logical(i8 %x, i8 %y)  {
 157 ; CHECK-LABEL: @ult_swap_and_max_commute_logical(
 158 ; CHECK-NEXT:    ret i1 false
 159 ;
 160   %cmp = icmp ugt i8 %y, %x
 161   %cmpeq = icmp eq i8 %x, 255
 162   %r = select i1 %cmpeq, i1 %cmp, i1 false
 163   ret i1 %r
 164 }
 165
 166 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 167 ;
 168 ; (X == MIN) && (X > Y) --> false
 169 ;
 170 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 171
 172 define i1 @sgt_and_min(i9 %x, i9 %y)  {
 173 ; CHECK-LABEL: @sgt_and_min(
 174 ; CHECK-NEXT:    ret i1 false
 175 ;
 176   %cmp = icmp sgt i9 %x, %y
 177   %cmpeq = icmp eq i9 %x, 256
 178   %r = and i1 %cmp, %cmpeq
 179   ret i1 %r
 180 }
 181
 182 define i1 @sgt_and_min_logical(i9 %x, i9 %y)  {
 183 ; CHECK-LABEL: @sgt_and_min_logical(
 184 ; CHECK-NEXT:    ret i1 false
 185 ;
 186   %cmp = icmp sgt i9 %x, %y
 187   %cmpeq = icmp eq i9 %x, 256
 188   %r = select i1 %cmp, i1 %cmpeq, i1 false
 189   ret i1 %r
 190 }
 191
 192 define i1 @sgt_and_min_commute(i8 %x, i8 %y)  {
 193 ; CHECK-LABEL: @sgt_and_min_commute(
 194 ; CHECK-NEXT:    ret i1 false
 195 ;
 196   %cmp = icmp sgt i8 %x, %y
 197   %cmpeq = icmp eq i8 %x, 128
 198   %r = and i1 %cmpeq, %cmp
 199   ret i1 %r
 200 }
 201
 202 define i1 @sgt_and_min_commute_logical(i8 %x, i8 %y)  {
 203 ; CHECK-LABEL: @sgt_and_min_commute_logical(
 204 ; CHECK-NEXT:    ret i1 false
 205 ;
 206   %cmp = icmp sgt i8 %x, %y
 207   %cmpeq = icmp eq i8 %x, 128
 208   %r = select i1 %cmpeq, i1 %cmp, i1 false
 209   ret i1 %r
 210 }
 211
 212 define i1 @sgt_swap_and_min(i8 %x, i8 %y)  {
 213 ; CHECK-LABEL: @sgt_swap_and_min(
 214 ; CHECK-NEXT:    ret i1 false
 215 ;
 216   %cmp = icmp slt i8 %y, %x
 217   %cmpeq = icmp eq i8 %x, 128
 218   %r = and i1 %cmp, %cmpeq
 219   ret i1 %r
 220 }
 221
 222 define i1 @sgt_swap_and_min_logical(i8 %x, i8 %y)  {
 223 ; CHECK-LABEL: @sgt_swap_and_min_logical(
 224 ; CHECK-NEXT:    ret i1 false
 225 ;
 226   %cmp = icmp slt i8 %y, %x
 227   %cmpeq = icmp eq i8 %x, 128
 228   %r = select i1 %cmp, i1 %cmpeq, i1 false
 229   ret i1 %r
 230 }
 231
 232 define i1 @sgt_swap_and_min_commute(i8 %x, i8 %y)  {
 233 ; CHECK-LABEL: @sgt_swap_and_min_commute(
 234 ; CHECK-NEXT:    ret i1 false
 235 ;
 236   %cmp = icmp slt i8 %y, %x
 237   %cmpeq = icmp eq i8 %x, 128
 238   %r = and i1 %cmpeq, %cmp
 239   ret i1 %r
 240 }
 241
 242 define i1 @sgt_swap_and_min_commute_logical(i8 %x, i8 %y)  {
 243 ; CHECK-LABEL: @sgt_swap_and_min_commute_logical(
 244 ; CHECK-NEXT:    ret i1 false
 245 ;
 246   %cmp = icmp slt i8 %y, %x
 247   %cmpeq = icmp eq i8 %x, 128
 248   %r = select i1 %cmpeq, i1 %cmp, i1 false
 249   ret i1 %r
 250 }
 251
 252 define i1 @ugt_and_min(i8 %x, i8 %y)  {
 253 ; CHECK-LABEL: @ugt_and_min(
 254 ; CHECK-NEXT:    ret i1 false
 255 ;
 256   %cmp = icmp ugt i8 %x, %y
 257   %cmpeq = icmp eq i8 %x, 0
 258   %r = and i1 %cmp, %cmpeq
 259   ret i1 %r
 260 }
 261
 262 define i1 @ugt_and_min_logical(i8 %x, i8 %y)  {
 263 ; CHECK-LABEL: @ugt_and_min_logical(
 264 ; CHECK-NEXT:    ret i1 false
 265 ;
 266   %cmp = icmp ugt i8 %x, %y
 267   %cmpeq = icmp eq i8 %x, 0
 268   %r = select i1 %cmp, i1 %cmpeq, i1 false
 269   ret i1 %r
 270 }
 271
 272 define i1 @ugt_and_min_commute(i8 %x, i8 %y)  {
 273 ; CHECK-LABEL: @ugt_and_min_commute(
 274 ; CHECK-NEXT:    ret i1 false
 275 ;
 276   %cmp = icmp ugt i8 %x, %y
 277   %cmpeq = icmp eq i8 %x, 0
 278   %r = and i1 %cmpeq, %cmp
 279   ret i1 %r
 280 }
 281
 282 define i1 @ugt_and_min_commute_logical(i8 %x, i8 %y)  {
 283 ; CHECK-LABEL: @ugt_and_min_commute_logical(
 284 ; CHECK-NEXT:    ret i1 false
 285 ;
 286   %cmp = icmp ugt i8 %x, %y
 287   %cmpeq = icmp eq i8 %x, 0
 288   %r = select i1 %cmpeq, i1 %cmp, i1 false
 289   ret i1 %r
 290 }
 291
 292 define i1 @ugt_swap_and_min(i8 %x, i8 %y)  {
 293 ; CHECK-LABEL: @ugt_swap_and_min(
 294 ; CHECK-NEXT:    ret i1 false
 295 ;
 296   %cmp = icmp ult i8 %y, %x
 297   %cmpeq = icmp eq i8 %x, 0
 298   %r = and i1 %cmp, %cmpeq
 299   ret i1 %r
 300 }
 301
 302 define i1 @ugt_swap_and_min_logical(i8 %x, i8 %y)  {
 303 ; CHECK-LABEL: @ugt_swap_and_min_logical(
 304 ; CHECK-NEXT:    ret i1 false
 305 ;
 306   %cmp = icmp ult i8 %y, %x
 307   %cmpeq = icmp eq i8 %x, 0
 308   %r = select i1 %cmp, i1 %cmpeq, i1 false
 309   ret i1 %r
 310 }
 311
 312 define i1 @ugt_swap_and_min_commute(i8 %x, i8 %y)  {
 313 ; CHECK-LABEL: @ugt_swap_and_min_commute(
 314 ; CHECK-NEXT:    ret i1 false
 315 ;
 316   %cmp = icmp ult i8 %y, %x
 317   %cmpeq = icmp eq i8 %x, 0
 318   %r = and i1 %cmpeq, %cmp
 319   ret i1 %r
 320 }
 321
 322 define i1 @ugt_swap_and_min_commute_logical(i8 %x, i8 %y)  {
 323 ; CHECK-LABEL: @ugt_swap_and_min_commute_logical(
 324 ; CHECK-NEXT:    ret i1 false
 325 ;
 326   %cmp = icmp ult i8 %y, %x
 327   %cmpeq = icmp eq i8 %x, 0
 328   %r = select i1 %cmpeq, i1 %cmp, i1 false
 329   ret i1 %r
 330 }
 331
 332 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 333 ;
 334 ; (X != MAX) || (X >= Y) --> true
 335 ;
 336 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 337
 338 define i1 @sge_or_not_max(i8 %x, i8 %y)  {
 339 ; CHECK-LABEL: @sge_or_not_max(
 340 ; CHECK-NEXT:    ret i1 true
 341 ;
 342   %cmp = icmp sge i8 %x, %y
 343   %cmpeq = icmp ne i8 %x, 127
 344   %r = or i1 %cmp, %cmpeq
 345   ret i1 %r
 346 }
 347
 348 define i1 @sge_or_not_max_logical(i8 %x, i8 %y)  {
 349 ; CHECK-LABEL: @sge_or_not_max_logical(
 350 ; CHECK-NEXT:    ret i1 true
 351 ;
 352   %cmp = icmp sge i8 %x, %y
 353   %cmpeq = icmp ne i8 %x, 127
 354   %r = select i1 %cmp, i1 true, i1 %cmpeq
 355   ret i1 %r
 356 }
 357
 358 define i1 @sge_or_not_max_commute(i8 %x, i8 %y)  {
 359 ; CHECK-LABEL: @sge_or_not_max_commute(
 360 ; CHECK-NEXT:    ret i1 true
 361 ;
 362   %cmp = icmp sge i8 %x, %y
 363   %cmpeq = icmp ne i8 %x, 127
 364   %r = or i1 %cmpeq, %cmp
 365   ret i1 %r
 366 }
 367
 368 define i1 @sge_or_not_max_commute_logical(i8 %x, i8 %y)  {
 369 ; CHECK-LABEL: @sge_or_not_max_commute_logical(
 370 ; CHECK-NEXT:    ret i1 true
 371 ;
 372   %cmp = icmp sge i8 %x, %y
 373   %cmpeq = icmp ne i8 %x, 127
 374   %r = select i1 %cmpeq, i1 true, i1 %cmp
 375   ret i1 %r
 376 }
 377
 378 define i1 @sge_swap_or_not_max(i8 %x, i8 %y)  {
 379 ; CHECK-LABEL: @sge_swap_or_not_max(
 380 ; CHECK-NEXT:    ret i1 true
 381 ;
 382   %cmp = icmp sle i8 %y, %x
 383   %cmpeq = icmp ne i8 %x, 127
 384   %r = or i1 %cmp, %cmpeq
 385   ret i1 %r
 386 }
 387
 388 define i1 @sge_swap_or_not_max_logical(i8 %x, i8 %y)  {
 389 ; CHECK-LABEL: @sge_swap_or_not_max_logical(
 390 ; CHECK-NEXT:    ret i1 true
 391 ;
 392   %cmp = icmp sle i8 %y, %x
 393   %cmpeq = icmp ne i8 %x, 127
 394   %r = select i1 %cmp, i1 true, i1 %cmpeq
 395   ret i1 %r
 396 }
 397
 398 define i1 @sge_swap_or_not_max_commute(i8 %x, i8 %y)  {
 399 ; CHECK-LABEL: @sge_swap_or_not_max_commute(
 400 ; CHECK-NEXT:    ret i1 true
 401 ;
 402   %cmp = icmp sle i8 %y, %x
 403   %cmpeq = icmp ne i8 %x, 127
 404   %r = or i1 %cmpeq, %cmp
 405   ret i1 %r
 406 }
 407
 408 define i1 @sge_swap_or_not_max_commute_logical(i8 %x, i8 %y)  {
 409 ; CHECK-LABEL: @sge_swap_or_not_max_commute_logical(
 410 ; CHECK-NEXT:    ret i1 true
 411 ;
 412   %cmp = icmp sle i8 %y, %x
 413   %cmpeq = icmp ne i8 %x, 127
 414   %r = select i1 %cmpeq, i1 true, i1 %cmp
 415   ret i1 %r
 416 }
 417
 418 define i1 @uge_or_not_max(i8 %x, i8 %y)  {
 419 ; CHECK-LABEL: @uge_or_not_max(
 420 ; CHECK-NEXT:    ret i1 true
 421 ;
 422   %cmp = icmp uge i8 %x, %y
 423   %cmpeq = icmp ne i8 %x, 255
 424   %r = or i1 %cmp, %cmpeq
 425   ret i1 %r
 426 }
 427
 428 define i1 @uge_or_not_max_logical(i8 %x, i8 %y)  {
 429 ; CHECK-LABEL: @uge_or_not_max_logical(
 430 ; CHECK-NEXT:    ret i1 true
 431 ;
 432   %cmp = icmp uge i8 %x, %y
 433   %cmpeq = icmp ne i8 %x, 255
 434   %r = select i1 %cmp, i1 true, i1 %cmpeq
 435   ret i1 %r
 436 }
 437
 438 define i1 @uge_or_not_max_commute(i8 %x, i8 %y)  {
 439 ; CHECK-LABEL: @uge_or_not_max_commute(
 440 ; CHECK-NEXT:    ret i1 true
 441 ;
 442   %cmp = icmp uge i8 %x, %y
 443   %cmpeq = icmp ne i8 %x, 255
 444   %r = or i1 %cmpeq, %cmp
 445   ret i1 %r
 446 }
 447
 448 define i1 @uge_or_not_max_commute_logical(i8 %x, i8 %y)  {
 449 ; CHECK-LABEL: @uge_or_not_max_commute_logical(
 450 ; CHECK-NEXT:    ret i1 true
 451 ;
 452   %cmp = icmp uge i8 %x, %y
 453   %cmpeq = icmp ne i8 %x, 255
 454   %r = select i1 %cmpeq, i1 true, i1 %cmp
 455   ret i1 %r
 456 }
 457
 458 define i1 @uge_swap_or_not_max(i8 %x, i8 %y)  {
 459 ; CHECK-LABEL: @uge_swap_or_not_max(
 460 ; CHECK-NEXT:    ret i1 true
 461 ;
 462   %cmp = icmp ule i8 %y, %x
 463   %cmpeq = icmp ne i8 %x, 255
 464   %r = or i1 %cmp, %cmpeq
 465   ret i1 %r
 466 }
 467
 468 define i1 @uge_swap_or_not_max_logical(i8 %x, i8 %y)  {
 469 ; CHECK-LABEL: @uge_swap_or_not_max_logical(
 470 ; CHECK-NEXT:    ret i1 true
 471 ;
 472   %cmp = icmp ule i8 %y, %x
 473   %cmpeq = icmp ne i8 %x, 255
 474   %r = select i1 %cmp, i1 true, i1 %cmpeq
 475   ret i1 %r
 476 }
 477
 478 define i1 @uge_swap_or_not_max_commute(i8 %x, i8 %y)  {
 479 ; CHECK-LABEL: @uge_swap_or_not_max_commute(
 480 ; CHECK-NEXT:    ret i1 true
 481 ;
 482   %cmp = icmp ule i8 %y, %x
 483   %cmpeq = icmp ne i8 %x, 255
 484   %r = or i1 %cmpeq, %cmp
 485   ret i1 %r
 486 }
 487
 488 define i1 @uge_swap_or_not_max_commute_logical(i8 %x, i8 %y)  {
 489 ; CHECK-LABEL: @uge_swap_or_not_max_commute_logical(
 490 ; CHECK-NEXT:    ret i1 true
 491 ;
 492   %cmp = icmp ule i8 %y, %x
 493   %cmpeq = icmp ne i8 %x, 255
 494   %r = select i1 %cmpeq, i1 true, i1 %cmp
 495   ret i1 %r
 496 }
 497
 498 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 499 ;
 500 ; (X != MIN) || (X <= Y) --> true
 501 ;
 502 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 503
 504 define i1 @sle_or_not_min(i8 %x, i8 %y)  {
 505 ; CHECK-LABEL: @sle_or_not_min(
 506 ; CHECK-NEXT:    ret i1 true
 507 ;
 508   %cmp = icmp sle i8 %x, %y
 509   %cmpeq = icmp ne i8 %x, 128
 510   %r = or i1 %cmp, %cmpeq
 511   ret i1 %r
 512 }
 513
 514 define i1 @sle_or_not_min_logical(i8 %x, i8 %y)  {
 515 ; CHECK-LABEL: @sle_or_not_min_logical(
 516 ; CHECK-NEXT:    ret i1 true
 517 ;
 518   %cmp = icmp sle i8 %x, %y
 519   %cmpeq = icmp ne i8 %x, 128
 520   %r = select i1 %cmp, i1 true, i1 %cmpeq
 521   ret i1 %r
 522 }
 523
 524 define i1 @sle_or_not_min_commute(i8 %x, i8 %y)  {
 525 ; CHECK-LABEL: @sle_or_not_min_commute(
 526 ; CHECK-NEXT:    ret i1 true
 527 ;
 528   %cmp = icmp sle i8 %x, %y
 529   %cmpeq = icmp ne i8 %x, 128
 530   %r = or i1 %cmpeq, %cmp
 531   ret i1 %r
 532 }
 533
 534 define i1 @sle_or_not_min_commute_logical(i8 %x, i8 %y)  {
 535 ; CHECK-LABEL: @sle_or_not_min_commute_logical(
 536 ; CHECK-NEXT:    ret i1 true
 537 ;
 538   %cmp = icmp sle i8 %x, %y
 539   %cmpeq = icmp ne i8 %x, 128
 540   %r = select i1 %cmpeq, i1 true, i1 %cmp
 541   ret i1 %r
 542 }
 543
 544 define i1 @sle_swap_or_not_min(i8 %x, i8 %y)  {
 545 ; CHECK-LABEL: @sle_swap_or_not_min(
 546 ; CHECK-NEXT:    ret i1 true
 547 ;
 548   %cmp = icmp sge i8 %y, %x
 549   %cmpeq = icmp ne i8 %x, 128
 550   %r = or i1 %cmp, %cmpeq
 551   ret i1 %r
 552 }
 553
 554 define i1 @sle_swap_or_not_min_logical(i8 %x, i8 %y)  {
 555 ; CHECK-LABEL: @sle_swap_or_not_min_logical(
 556 ; CHECK-NEXT:    ret i1 true
 557 ;
 558   %cmp = icmp sge i8 %y, %x
 559   %cmpeq = icmp ne i8 %x, 128
 560   %r = select i1 %cmp, i1 true, i1 %cmpeq
 561   ret i1 %r
 562 }
 563
 564 define i1 @sle_swap_or_not_min_commute(i8 %x, i8 %y)  {
 565 ; CHECK-LABEL: @sle_swap_or_not_min_commute(
 566 ; CHECK-NEXT:    ret i1 true
 567 ;
 568   %cmp = icmp sge i8 %y, %x
 569   %cmpeq = icmp ne i8 %x, 128
 570   %r = or i1 %cmpeq, %cmp
 571   ret i1 %r
 572 }
 573
 574 define i1 @sle_swap_or_not_min_commute_logical(i8 %x, i8 %y)  {
 575 ; CHECK-LABEL: @sle_swap_or_not_min_commute_logical(
 576 ; CHECK-NEXT:    ret i1 true
 577 ;
 578   %cmp = icmp sge i8 %y, %x
 579   %cmpeq = icmp ne i8 %x, 128
 580   %r = select i1 %cmpeq, i1 true, i1 %cmp
 581   ret i1 %r
 582 }
 583
 584 define i1 @ule_or_not_min(i427 %x, i427 %y)  {
 585 ; CHECK-LABEL: @ule_or_not_min(
 586 ; CHECK-NEXT:    ret i1 true
 587 ;
 588   %cmp = icmp ule i427 %x, %y
 589   %cmpeq = icmp ne i427 %x, 0
 590   %r = or i1 %cmp, %cmpeq
 591   ret i1 %r
 592 }
 593
 594 define i1 @ule_or_not_min_logical(i427 %x, i427 %y)  {
 595 ; CHECK-LABEL: @ule_or_not_min_logical(
 596 ; CHECK-NEXT:    ret i1 true
 597 ;
 598   %cmp = icmp ule i427 %x, %y
 599   %cmpeq = icmp ne i427 %x, 0
 600   %r = select i1 %cmp, i1 true, i1 %cmpeq
 601   ret i1 %r
 602 }
 603
 604 define i1 @ule_or_not_min_commute(i8 %x, i8 %y)  {
 605 ; CHECK-LABEL: @ule_or_not_min_commute(
 606 ; CHECK-NEXT:    ret i1 true
 607 ;
 608   %cmp = icmp ule i8 %x, %y
 609   %cmpeq = icmp ne i8 %x, 0
 610   %r = or i1 %cmpeq, %cmp
 611   ret i1 %r
 612 }
 613
 614 define i1 @ule_or_not_min_commute_logical(i8 %x, i8 %y)  {
 615 ; CHECK-LABEL: @ule_or_not_min_commute_logical(
 616 ; CHECK-NEXT:    ret i1 true
 617 ;
 618   %cmp = icmp ule i8 %x, %y
 619   %cmpeq = icmp ne i8 %x, 0
 620   %r = select i1 %cmpeq, i1 true, i1 %cmp
 621   ret i1 %r
 622 }
 623
 624 define i1 @ule_swap_or_not_min(i8 %x, i8 %y)  {
 625 ; CHECK-LABEL: @ule_swap_or_not_min(
 626 ; CHECK-NEXT:    ret i1 true
 627 ;
 628   %cmp = icmp uge i8 %y, %x
 629   %cmpeq = icmp ne i8 %x, 0
 630   %r = or i1 %cmp, %cmpeq
 631   ret i1 %r
 632 }
 633
 634 define i1 @ule_swap_or_not_min_logical(i8 %x, i8 %y)  {
 635 ; CHECK-LABEL: @ule_swap_or_not_min_logical(
 636 ; CHECK-NEXT:    ret i1 true
 637 ;
 638   %cmp = icmp uge i8 %y, %x
 639   %cmpeq = icmp ne i8 %x, 0
 640   %r = select i1 %cmp, i1 true, i1 %cmpeq
 641   ret i1 %r
 642 }
 643
 644 define i1 @ule_swap_or_not_min_commute(i8 %x, i8 %y)  {
 645 ; CHECK-LABEL: @ule_swap_or_not_min_commute(
 646 ; CHECK-NEXT:    ret i1 true
 647 ;
 648   %cmp = icmp uge i8 %y, %x
 649   %cmpeq = icmp ne i8 %x, 0
 650   %r = or i1 %cmpeq, %cmp
 651   ret i1 %r
 652 }
 653
 654 define i1 @ule_swap_or_not_min_commute_logical(i8 %x, i8 %y)  {
 655 ; CHECK-LABEL: @ule_swap_or_not_min_commute_logical(
 656 ; CHECK-NEXT:    ret i1 true
 657 ;
 658   %cmp = icmp uge i8 %y, %x
 659   %cmpeq = icmp ne i8 %x, 0
 660   %r = select i1 %cmpeq, i1 true, i1 %cmp
 661   ret i1 %r
 662 }
 663
 664 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 665 ;
 666 ; (X == MAX) && (X >= Y) --> X == MAX
 667 ;
 668 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 669
 670 define i1 @sge_and_max(i8 %x, i8 %y)  {
 671 ; CHECK-LABEL: @sge_and_max(
 672 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp eq i8 [[X:%.*]], 127
 673 ; CHECK-NEXT:    ret i1 [[CMPEQ]]
 674 ;
 675   %cmp = icmp sge i8 %x, %y
 676   %cmpeq = icmp eq i8 %x, 127
 677   %r = and i1 %cmp, %cmpeq
 678   ret i1 %r
 679 }
 680
 681 define i1 @sge_and_max_logical(i8 %x, i8 %y)  {
 682 ; CHECK-LABEL: @sge_and_max_logical(
 683 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp eq i8 [[X:%.*]], 127
 684 ; CHECK-NEXT:    ret i1 [[CMPEQ]]
 685 ;
 686   %cmp = icmp sge i8 %x, %y
 687   %cmpeq = icmp eq i8 %x, 127
 688   %r = select i1 %cmp, i1 %cmpeq, i1 false
 689   ret i1 %r
 690 }
 691
 692 define i1 @sge_and_max_logical_samesign(i8 %x, i8 %y)  {
 693 ; CHECK-LABEL: @sge_and_max_logical_samesign(
 694 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp eq i8 [[X:%.*]], 127
 695 ; CHECK-NEXT:    ret i1 [[CMPEQ]]
 696 ;
 697   %cmp = icmp sge i8 %x, %y
 698   %cmpeq = icmp samesign eq i8 %x, 127
 699   %r = select i1 %cmp, i1 %cmpeq, i1 false
 700   ret i1 %r
 701 }
 702
 703 define i1 @sge_and_max_commute(i8 %x, i8 %y)  {
 704 ; CHECK-LABEL: @sge_and_max_commute(
 705 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp eq i8 [[X:%.*]], 127
 706 ; CHECK-NEXT:    ret i1 [[CMPEQ]]
 707 ;
 708   %cmp = icmp sge i8 %x, %y
 709   %cmpeq = icmp eq i8 %x, 127
 710   %r = and i1 %cmpeq, %cmp
 711   ret i1 %r
 712 }
 713
 714 define i1 @sge_and_max_commute_logical(i8 %x, i8 %y)  {
 715 ; CHECK-LABEL: @sge_and_max_commute_logical(
 716 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp eq i8 [[X:%.*]], 127
 717 ; CHECK-NEXT:    ret i1 [[CMPEQ]]
 718 ;
 719   %cmp = icmp sge i8 %x, %y
 720   %cmpeq = icmp eq i8 %x, 127
 721   %r = select i1 %cmpeq, i1 %cmp, i1 false
 722   ret i1 %r
 723 }
 724
 725 define i1 @sge_swap_and_max(i8 %x, i8 %y)  {
 726 ; CHECK-LABEL: @sge_swap_and_max(
 727 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp eq i8 [[X:%.*]], 127
 728 ; CHECK-NEXT:    ret i1 [[CMPEQ]]
 729 ;
 730   %cmp = icmp sle i8 %y, %x
 731   %cmpeq = icmp eq i8 %x, 127
 732   %r = and i1 %cmp, %cmpeq
 733   ret i1 %r
 734 }
 735
 736 define i1 @sge_swap_and_max_logical(i8 %x, i8 %y)  {
 737 ; CHECK-LABEL: @sge_swap_and_max_logical(
 738 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp eq i8 [[X:%.*]], 127
 739 ; CHECK-NEXT:    ret i1 [[CMPEQ]]
 740 ;
 741   %cmp = icmp sle i8 %y, %x
 742   %cmpeq = icmp eq i8 %x, 127
 743   %r = select i1 %cmp, i1 %cmpeq, i1 false
 744   ret i1 %r
 745 }
 746
 747 define i1 @sge_swap_and_max_commute(i8 %x, i8 %y)  {
 748 ; CHECK-LABEL: @sge_swap_and_max_commute(
 749 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp eq i8 [[X:%.*]], 127
 750 ; CHECK-NEXT:    ret i1 [[CMPEQ]]
 751 ;
 752   %cmp = icmp sle i8 %y, %x
 753   %cmpeq = icmp eq i8 %x, 127
 754   %r = and i1 %cmpeq, %cmp
 755   ret i1 %r
 756 }
 757
 758 define i1 @sge_swap_and_max_commute_logical(i8 %x, i8 %y)  {
 759 ; CHECK-LABEL: @sge_swap_and_max_commute_logical(
 760 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp eq i8 [[X:%.*]], 127
 761 ; CHECK-NEXT:    ret i1 [[CMPEQ]]
 762 ;
 763   %cmp = icmp sle i8 %y, %x
 764   %cmpeq = icmp eq i8 %x, 127
 765   %r = select i1 %cmpeq, i1 %cmp, i1 false
 766   ret i1 %r
 767 }
 768
 769 define i1 @uge_and_max(i8 %x, i8 %y)  {
 770 ; CHECK-LABEL: @uge_and_max(
 771 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp eq i8 [[X:%.*]], -1
 772 ; CHECK-NEXT:    ret i1 [[CMPEQ]]
 773 ;
 774   %cmp = icmp uge i8 %x, %y
 775   %cmpeq = icmp eq i8 %x, 255
 776   %r = and i1 %cmp, %cmpeq
 777   ret i1 %r
 778 }
 779
 780 define i1 @uge_and_max_logical(i8 %x, i8 %y)  {
 781 ; CHECK-LABEL: @uge_and_max_logical(
 782 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp eq i8 [[X:%.*]], -1
 783 ; CHECK-NEXT:    ret i1 [[CMPEQ]]
 784 ;
 785   %cmp = icmp uge i8 %x, %y
 786   %cmpeq = icmp eq i8 %x, 255
 787   %r = select i1 %cmp, i1 %cmpeq, i1 false
 788   ret i1 %r
 789 }
 790
 791 define i1 @uge_and_max_commute(i8 %x, i8 %y)  {
 792 ; CHECK-LABEL: @uge_and_max_commute(
 793 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp eq i8 [[X:%.*]], -1
 794 ; CHECK-NEXT:    ret i1 [[CMPEQ]]
 795 ;
 796   %cmp = icmp uge i8 %x, %y
 797   %cmpeq = icmp eq i8 %x, 255
 798   %r = and i1 %cmpeq, %cmp
 799   ret i1 %r
 800 }
 801
 802 define i1 @uge_and_max_commute_logical(i8 %x, i8 %y)  {
 803 ; CHECK-LABEL: @uge_and_max_commute_logical(
 804 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp eq i8 [[X:%.*]], -1
 805 ; CHECK-NEXT:    ret i1 [[CMPEQ]]
 806 ;
 807   %cmp = icmp uge i8 %x, %y
 808   %cmpeq = icmp eq i8 %x, 255
 809   %r = select i1 %cmpeq, i1 %cmp, i1 false
 810   ret i1 %r
 811 }
 812
 813 define i1 @uge_swap_and_max(i8 %x, i8 %y)  {
 814 ; CHECK-LABEL: @uge_swap_and_max(
 815 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp eq i8 [[X:%.*]], -1
 816 ; CHECK-NEXT:    ret i1 [[CMPEQ]]
 817 ;
 818   %cmp = icmp ule i8 %y, %x
 819   %cmpeq = icmp eq i8 %x, 255
 820   %r = and i1 %cmp, %cmpeq
 821   ret i1 %r
 822 }
 823
 824 define i1 @uge_swap_and_max_logical(i8 %x, i8 %y)  {
 825 ; CHECK-LABEL: @uge_swap_and_max_logical(
 826 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp eq i8 [[X:%.*]], -1
 827 ; CHECK-NEXT:    ret i1 [[CMPEQ]]
 828 ;
 829   %cmp = icmp ule i8 %y, %x
 830   %cmpeq = icmp eq i8 %x, 255
 831   %r = select i1 %cmp, i1 %cmpeq, i1 false
 832   ret i1 %r
 833 }
 834
 835 define i1 @uge_swap_and_max_commute(i8 %x, i8 %y)  {
 836 ; CHECK-LABEL: @uge_swap_and_max_commute(
 837 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp eq i8 [[X:%.*]], -1
 838 ; CHECK-NEXT:    ret i1 [[CMPEQ]]
 839 ;
 840   %cmp = icmp ule i8 %y, %x
 841   %cmpeq = icmp eq i8 %x, 255
 842   %r = and i1 %cmpeq, %cmp
 843   ret i1 %r
 844 }
 845
 846 define i1 @uge_swap_and_max_commute_logical(i8 %x, i8 %y)  {
 847 ; CHECK-LABEL: @uge_swap_and_max_commute_logical(
 848 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp eq i8 [[X:%.*]], -1
 849 ; CHECK-NEXT:    ret i1 [[CMPEQ]]
 850 ;
 851   %cmp = icmp ule i8 %y, %x
 852   %cmpeq = icmp eq i8 %x, 255
 853   %r = select i1 %cmpeq, i1 %cmp, i1 false
 854   ret i1 %r
 855 }
 856
 857 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 858 ;
 859 ; (X == MIN) && (X <= Y) --> X == MIN
 860 ;
 861 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 862
 863 define i1 @sle_and_min(i8 %x, i8 %y)  {
 864 ; CHECK-LABEL: @sle_and_min(
 865 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp eq i8 [[X:%.*]], -128
 866 ; CHECK-NEXT:    ret i1 [[CMPEQ]]
 867 ;
 868   %cmp = icmp sle i8 %x, %y
 869   %cmpeq = icmp eq i8 %x, 128
 870   %r = and i1 %cmp, %cmpeq
 871   ret i1 %r
 872 }
 873
 874 define i1 @sle_and_min_logical(i8 %x, i8 %y)  {
 875 ; CHECK-LABEL: @sle_and_min_logical(
 876 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp eq i8 [[X:%.*]], -128
 877 ; CHECK-NEXT:    ret i1 [[CMPEQ]]
 878 ;
 879   %cmp = icmp sle i8 %x, %y
 880   %cmpeq = icmp eq i8 %x, 128
 881   %r = select i1 %cmp, i1 %cmpeq, i1 false
 882   ret i1 %r
 883 }
 884
 885 define i1 @sle_and_min_commute(i8 %x, i8 %y)  {
 886 ; CHECK-LABEL: @sle_and_min_commute(
 887 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp eq i8 [[X:%.*]], -128
 888 ; CHECK-NEXT:    ret i1 [[CMPEQ]]
 889 ;
 890   %cmp = icmp sle i8 %x, %y
 891   %cmpeq = icmp eq i8 %x, 128
 892   %r = and i1 %cmpeq, %cmp
 893   ret i1 %r
 894 }
 895
 896 define i1 @sle_and_min_commute_logical(i8 %x, i8 %y)  {
 897 ; CHECK-LABEL: @sle_and_min_commute_logical(
 898 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp eq i8 [[X:%.*]], -128
 899 ; CHECK-NEXT:    ret i1 [[CMPEQ]]
 900 ;
 901   %cmp = icmp sle i8 %x, %y
 902   %cmpeq = icmp eq i8 %x, 128
 903   %r = select i1 %cmpeq, i1 %cmp, i1 false
 904   ret i1 %r
 905 }
 906
 907 define i1 @sle_swap_and_min(i8 %x, i8 %y)  {
 908 ; CHECK-LABEL: @sle_swap_and_min(
 909 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp eq i8 [[X:%.*]], -128
 910 ; CHECK-NEXT:    ret i1 [[CMPEQ]]
 911 ;
 912   %cmp = icmp sge i8 %y, %x
 913   %cmpeq = icmp eq i8 %x, 128
 914   %r = and i1 %cmp, %cmpeq
 915   ret i1 %r
 916 }
 917
 918 define i1 @sle_swap_and_min_logical(i8 %x, i8 %y)  {
 919 ; CHECK-LABEL: @sle_swap_and_min_logical(
 920 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp eq i8 [[X:%.*]], -128
 921 ; CHECK-NEXT:    ret i1 [[CMPEQ]]
 922 ;
 923   %cmp = icmp sge i8 %y, %x
 924   %cmpeq = icmp eq i8 %x, 128
 925   %r = select i1 %cmp, i1 %cmpeq, i1 false
 926   ret i1 %r
 927 }
 928
 929 define i1 @sle_swap_and_min_commute(i8 %x, i8 %y)  {
 930 ; CHECK-LABEL: @sle_swap_and_min_commute(
 931 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp eq i8 [[X:%.*]], -128
 932 ; CHECK-NEXT:    ret i1 [[CMPEQ]]
 933 ;
 934   %cmp = icmp sge i8 %y, %x
 935   %cmpeq = icmp eq i8 %x, 128
 936   %r = and i1 %cmpeq, %cmp
 937   ret i1 %r
 938 }
 939
 940 define i1 @sle_swap_and_min_commute_logical(i8 %x, i8 %y)  {
 941 ; CHECK-LABEL: @sle_swap_and_min_commute_logical(
 942 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp eq i8 [[X:%.*]], -128
 943 ; CHECK-NEXT:    ret i1 [[CMPEQ]]
 944 ;
 945   %cmp = icmp sge i8 %y, %x
 946   %cmpeq = icmp eq i8 %x, 128
 947   %r = select i1 %cmpeq, i1 %cmp, i1 false
 948   ret i1 %r
 949 }
 950
 951 define i1 @ule_and_min(i8 %x, i8 %y)  {
 952 ; CHECK-LABEL: @ule_and_min(
 953 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp eq i8 [[X:%.*]], 0
 954 ; CHECK-NEXT:    ret i1 [[CMPEQ]]
 955 ;
 956   %cmp = icmp ule i8 %x, %y
 957   %cmpeq = icmp eq i8 %x, 0
 958   %r = and i1 %cmp, %cmpeq
 959   ret i1 %r
 960 }
 961
 962 define i1 @ule_and_min_logical(i8 %x, i8 %y)  {
 963 ; CHECK-LABEL: @ule_and_min_logical(
 964 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp eq i8 [[X:%.*]], 0
 965 ; CHECK-NEXT:    ret i1 [[CMPEQ]]
 966 ;
 967   %cmp = icmp ule i8 %x, %y
 968   %cmpeq = icmp eq i8 %x, 0
 969   %r = select i1 %cmp, i1 %cmpeq, i1 false
 970   ret i1 %r
 971 }
 972
 973 define i1 @ule_and_min_commute(i8 %x, i8 %y)  {
 974 ; CHECK-LABEL: @ule_and_min_commute(
 975 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp eq i8 [[X:%.*]], 0
 976 ; CHECK-NEXT:    ret i1 [[CMPEQ]]
 977 ;
 978   %cmp = icmp ule i8 %x, %y
 979   %cmpeq = icmp eq i8 %x, 0
 980   %r = and i1 %cmpeq, %cmp
 981   ret i1 %r
 982 }
 983
 984 define i1 @ule_and_min_commute_logical(i8 %x, i8 %y)  {
 985 ; CHECK-LABEL: @ule_and_min_commute_logical(
 986 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp eq i8 [[X:%.*]], 0
 987 ; CHECK-NEXT:    ret i1 [[CMPEQ]]
 988 ;
 989   %cmp = icmp ule i8 %x, %y
 990   %cmpeq = icmp eq i8 %x, 0
 991   %r = select i1 %cmpeq, i1 %cmp, i1 false
 992   ret i1 %r
 993 }
 994
 995 define i1 @ule_swap_and_min(i8 %x, i8 %y)  {
 996 ; CHECK-LABEL: @ule_swap_and_min(
 997 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp eq i8 [[X:%.*]], 0
 998 ; CHECK-NEXT:    ret i1 [[CMPEQ]]
 999 ;
1000   %cmp = icmp uge i8 %y, %x
1001   %cmpeq = icmp eq i8 %x, 0
1002   %r = and i1 %cmp, %cmpeq
1003   ret i1 %r
1004 }
1005
1006 define i1 @ule_swap_and_min_logical(i8 %x, i8 %y)  {
1007 ; CHECK-LABEL: @ule_swap_and_min_logical(
1008 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp eq i8 [[X:%.*]], 0
1009 ; CHECK-NEXT:    ret i1 [[CMPEQ]]
1010 ;
1011   %cmp = icmp uge i8 %y, %x
1012   %cmpeq = icmp eq i8 %x, 0
1013   %r = select i1 %cmp, i1 %cmpeq, i1 false
1014   ret i1 %r
1015 }
1016
1017 define i1 @ule_swap_and_min_commute(i8 %x, i8 %y)  {
1018 ; CHECK-LABEL: @ule_swap_and_min_commute(
1019 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp eq i8 [[X:%.*]], 0
1020 ; CHECK-NEXT:    ret i1 [[CMPEQ]]
1021 ;
1022   %cmp = icmp uge i8 %y, %x
1023   %cmpeq = icmp eq i8 %x, 0
1024   %r = and i1 %cmpeq, %cmp
1025   ret i1 %r
1026 }
1027
1028 define i1 @ule_swap_and_min_commute_logical(i8 %x, i8 %y)  {
1029 ; CHECK-LABEL: @ule_swap_and_min_commute_logical(
1030 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp eq i8 [[X:%.*]], 0
1031 ; CHECK-NEXT:    ret i1 [[CMPEQ]]
1032 ;
1033   %cmp = icmp uge i8 %y, %x
1034   %cmpeq = icmp eq i8 %x, 0
1035   %r = select i1 %cmpeq, i1 %cmp, i1 false
1036   ret i1 %r
1037 }
1038
1039 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1040 ;
1041 ; (X == MAX) || (X >= Y) --> X >= Y
1042 ;
1043 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1044
1045 define i1 @sge_or_max(i8 %x, i8 %y)  {
1046 ; CHECK-LABEL: @sge_or_max(
1047 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sge i8 [[X:%.*]], [[Y:%.*]]
1048 ; CHECK-NEXT:    ret i1 [[CMP]]
1049 ;
1050   %cmp = icmp sge i8 %x, %y
1051   %cmpeq = icmp eq i8 %x, 127
1052   %r = or i1 %cmp, %cmpeq
1053   ret i1 %r
1054 }
1055
1056 define i1 @sge_or_max_logical(i8 %x, i8 %y)  {
1057 ; CHECK-LABEL: @sge_or_max_logical(
1058 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sge i8 [[X:%.*]], [[Y:%.*]]
1059 ; CHECK-NEXT:    ret i1 [[CMP]]
1060 ;
1061   %cmp = icmp sge i8 %x, %y
1062   %cmpeq = icmp eq i8 %x, 127
1063   %r = select i1 %cmp, i1 true, i1 %cmpeq
1064   ret i1 %r
1065 }
1066
1067 define i1 @sge_or_max_commute(i8 %x, i8 %y)  {
1068 ; CHECK-LABEL: @sge_or_max_commute(
1069 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sge i8 [[X:%.*]], [[Y:%.*]]
1070 ; CHECK-NEXT:    ret i1 [[CMP]]
1071 ;
1072   %cmp = icmp sge i8 %x, %y
1073   %cmpeq = icmp eq i8 %x, 127
1074   %r = or i1 %cmpeq, %cmp
1075   ret i1 %r
1076 }
1077
1078 define i1 @sge_or_max_commute_logical(i8 %x, i8 %y)  {
1079 ; CHECK-LABEL: @sge_or_max_commute_logical(
1080 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sge i8 [[X:%.*]], [[Y:%.*]]
1081 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp eq i8 [[X]], 127
1082 ; CHECK-NEXT:    [[R:%.*]] = select i1 [[CMPEQ]], i1 true, i1 [[CMP]]
1083 ; CHECK-NEXT:    ret i1 [[R]]
1084 ;
1085   %cmp = icmp sge i8 %x, %y
1086   %cmpeq = icmp eq i8 %x, 127
1087   %r = select i1 %cmpeq, i1 true, i1 %cmp
1088   ret i1 %r
1089 }
1090
1091 define i1 @sge_swap_or_max(i8 %x, i8 %y)  {
1092 ; CHECK-LABEL: @sge_swap_or_max(
1093 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sle i8 [[Y:%.*]], [[X:%.*]]
1094 ; CHECK-NEXT:    ret i1 [[CMP]]
1095 ;
1096   %cmp = icmp sle i8 %y, %x
1097   %cmpeq = icmp eq i8 %x, 127
1098   %r = or i1 %cmp, %cmpeq
1099   ret i1 %r
1100 }
1101
1102 define i1 @sge_swap_or_max_logical(i8 %x, i8 %y)  {
1103 ; CHECK-LABEL: @sge_swap_or_max_logical(
1104 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sle i8 [[Y:%.*]], [[X:%.*]]
1105 ; CHECK-NEXT:    ret i1 [[CMP]]
1106 ;
1107   %cmp = icmp sle i8 %y, %x
1108   %cmpeq = icmp eq i8 %x, 127
1109   %r = select i1 %cmp, i1 true, i1 %cmpeq
1110   ret i1 %r
1111 }
1112
1113 define i1 @sge_swap_or_max_commute(i8 %x, i8 %y)  {
1114 ; CHECK-LABEL: @sge_swap_or_max_commute(
1115 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sle i8 [[Y:%.*]], [[X:%.*]]
1116 ; CHECK-NEXT:    ret i1 [[CMP]]
1117 ;
1118   %cmp = icmp sle i8 %y, %x
1119   %cmpeq = icmp eq i8 %x, 127
1120   %r = or i1 %cmpeq, %cmp
1121   ret i1 %r
1122 }
1123
1124 define i1 @sge_swap_or_max_commute_logical(i8 %x, i8 %y)  {
1125 ; CHECK-LABEL: @sge_swap_or_max_commute_logical(
1126 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sle i8 [[Y:%.*]], [[X:%.*]]
1127 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp eq i8 [[X]], 127
1128 ; CHECK-NEXT:    [[R:%.*]] = select i1 [[CMPEQ]], i1 true, i1 [[CMP]]
1129 ; CHECK-NEXT:    ret i1 [[R]]
1130 ;
1131   %cmp = icmp sle i8 %y, %x
1132   %cmpeq = icmp eq i8 %x, 127
1133   %r = select i1 %cmpeq, i1 true, i1 %cmp
1134   ret i1 %r
1135 }
1136
1137 define i1 @uge_or_max(i8 %x, i8 %y)  {
1138 ; CHECK-LABEL: @uge_or_max(
1139 ; CHECK-NEXT:    [[CMP:%.*]] = icmp uge i8 [[X:%.*]], [[Y:%.*]]
1140 ; CHECK-NEXT:    ret i1 [[CMP]]
1141 ;
1142   %cmp = icmp uge i8 %x, %y
1143   %cmpeq = icmp eq i8 %x, 255
1144   %r = or i1 %cmp, %cmpeq
1145   ret i1 %r
1146 }
1147
1148 define i1 @uge_or_max_logical(i8 %x, i8 %y)  {
1149 ; CHECK-LABEL: @uge_or_max_logical(
1150 ; CHECK-NEXT:    [[CMP:%.*]] = icmp uge i8 [[X:%.*]], [[Y:%.*]]
1151 ; CHECK-NEXT:    ret i1 [[CMP]]
1152 ;
1153   %cmp = icmp uge i8 %x, %y
1154   %cmpeq = icmp eq i8 %x, 255
1155   %r = select i1 %cmp, i1 true, i1 %cmpeq
1156   ret i1 %r
1157 }
1158
1159 define i1 @uge_or_max_commute(i8 %x, i8 %y)  {
1160 ; CHECK-LABEL: @uge_or_max_commute(
1161 ; CHECK-NEXT:    [[CMP:%.*]] = icmp uge i8 [[X:%.*]], [[Y:%.*]]
1162 ; CHECK-NEXT:    ret i1 [[CMP]]
1163 ;
1164   %cmp = icmp uge i8 %x, %y
1165   %cmpeq = icmp eq i8 %x, 255
1166   %r = or i1 %cmpeq, %cmp
1167   ret i1 %r
1168 }
1169
1170 define i1 @uge_or_max_commute_logical(i8 %x, i8 %y)  {
1171 ; CHECK-LABEL: @uge_or_max_commute_logical(
1172 ; CHECK-NEXT:    [[CMP:%.*]] = icmp uge i8 [[X:%.*]], [[Y:%.*]]
1173 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp eq i8 [[X]], -1
1174 ; CHECK-NEXT:    [[R:%.*]] = select i1 [[CMPEQ]], i1 true, i1 [[CMP]]
1175 ; CHECK-NEXT:    ret i1 [[R]]
1176 ;
1177   %cmp = icmp uge i8 %x, %y
1178   %cmpeq = icmp eq i8 %x, 255
1179   %r = select i1 %cmpeq, i1 true, i1 %cmp
1180   ret i1 %r
1181 }
1182
1183 define i1 @uge_swap_or_max(i8 %x, i8 %y)  {
1184 ; CHECK-LABEL: @uge_swap_or_max(
1185 ; CHECK-NEXT:    [[CMP:%.*]] = icmp ule i8 [[Y:%.*]], [[X:%.*]]
1186 ; CHECK-NEXT:    ret i1 [[CMP]]
1187 ;
1188   %cmp = icmp ule i8 %y, %x
1189   %cmpeq = icmp eq i8 %x, 255
1190   %r = or i1 %cmp, %cmpeq
1191   ret i1 %r
1192 }
1193
1194 define i1 @uge_swap_or_max_logical(i8 %x, i8 %y)  {
1195 ; CHECK-LABEL: @uge_swap_or_max_logical(
1196 ; CHECK-NEXT:    [[CMP:%.*]] = icmp ule i8 [[Y:%.*]], [[X:%.*]]
1197 ; CHECK-NEXT:    ret i1 [[CMP]]
1198 ;
1199   %cmp = icmp ule i8 %y, %x
1200   %cmpeq = icmp eq i8 %x, 255
1201   %r = select i1 %cmp, i1 true, i1 %cmpeq
1202   ret i1 %r
1203 }
1204
1205 define i1 @uge_swap_or_max_commute(i8 %x, i8 %y)  {
1206 ; CHECK-LABEL: @uge_swap_or_max_commute(
1207 ; CHECK-NEXT:    [[CMP:%.*]] = icmp ule i8 [[Y:%.*]], [[X:%.*]]
1208 ; CHECK-NEXT:    ret i1 [[CMP]]
1209 ;
1210   %cmp = icmp ule i8 %y, %x
1211   %cmpeq = icmp eq i8 %x, 255
1212   %r = or i1 %cmpeq, %cmp
1213   ret i1 %r
1214 }
1215
1216 define i1 @uge_swap_or_max_commute_logical(i8 %x, i8 %y)  {
1217 ; CHECK-LABEL: @uge_swap_or_max_commute_logical(
1218 ; CHECK-NEXT:    [[CMP:%.*]] = icmp ule i8 [[Y:%.*]], [[X:%.*]]
1219 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp eq i8 [[X]], -1
1220 ; CHECK-NEXT:    [[R:%.*]] = select i1 [[CMPEQ]], i1 true, i1 [[CMP]]
1221 ; CHECK-NEXT:    ret i1 [[R]]
1222 ;
1223   %cmp = icmp ule i8 %y, %x
1224   %cmpeq = icmp eq i8 %x, 255
1225   %r = select i1 %cmpeq, i1 true, i1 %cmp
1226   ret i1 %r
1227 }
1228
1229 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1230 ;
1231 ; (X == MIN) || (X <= Y) --> X <= Y
1232 ;
1233 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1234
1235 define i1 @sle_or_min(i8 %x, i8 %y)  {
1236 ; CHECK-LABEL: @sle_or_min(
1237 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sle i8 [[X:%.*]], [[Y:%.*]]
1238 ; CHECK-NEXT:    ret i1 [[CMP]]
1239 ;
1240   %cmp = icmp sle i8 %x, %y
1241   %cmpeq = icmp eq i8 %x, 128
1242   %r = or i1 %cmp, %cmpeq
1243   ret i1 %r
1244 }
1245
1246 define i1 @sle_or_min_logical(i8 %x, i8 %y)  {
1247 ; CHECK-LABEL: @sle_or_min_logical(
1248 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sle i8 [[X:%.*]], [[Y:%.*]]
1249 ; CHECK-NEXT:    ret i1 [[CMP]]
1250 ;
1251   %cmp = icmp sle i8 %x, %y
1252   %cmpeq = icmp eq i8 %x, 128
1253   %r = select i1 %cmp, i1 true, i1 %cmpeq
1254   ret i1 %r
1255 }
1256
1257 define i1 @sle_or_min_commute(i8 %x, i8 %y)  {
1258 ; CHECK-LABEL: @sle_or_min_commute(
1259 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sle i8 [[X:%.*]], [[Y:%.*]]
1260 ; CHECK-NEXT:    ret i1 [[CMP]]
1261 ;
1262   %cmp = icmp sle i8 %x, %y
1263   %cmpeq = icmp eq i8 %x, 128
1264   %r = or i1 %cmpeq, %cmp
1265   ret i1 %r
1266 }
1267
1268 define i1 @sle_or_min_commute_logical(i8 %x, i8 %y)  {
1269 ; CHECK-LABEL: @sle_or_min_commute_logical(
1270 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sle i8 [[X:%.*]], [[Y:%.*]]
1271 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp eq i8 [[X]], -128
1272 ; CHECK-NEXT:    [[R:%.*]] = select i1 [[CMPEQ]], i1 true, i1 [[CMP]]
1273 ; CHECK-NEXT:    ret i1 [[R]]
1274 ;
1275   %cmp = icmp sle i8 %x, %y
1276   %cmpeq = icmp eq i8 %x, 128
1277   %r = select i1 %cmpeq, i1 true, i1 %cmp
1278   ret i1 %r
1279 }
1280
1281 define i1 @sle_swap_or_min(i8 %x, i8 %y)  {
1282 ; CHECK-LABEL: @sle_swap_or_min(
1283 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sge i8 [[Y:%.*]], [[X:%.*]]
1284 ; CHECK-NEXT:    ret i1 [[CMP]]
1285 ;
1286   %cmp = icmp sge i8 %y, %x
1287   %cmpeq = icmp eq i8 %x, 128
1288   %r = or i1 %cmp, %cmpeq
1289   ret i1 %r
1290 }
1291
1292 define i1 @sle_swap_or_min_logical(i8 %x, i8 %y)  {
1293 ; CHECK-LABEL: @sle_swap_or_min_logical(
1294 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sge i8 [[Y:%.*]], [[X:%.*]]
1295 ; CHECK-NEXT:    ret i1 [[CMP]]
1296 ;
1297   %cmp = icmp sge i8 %y, %x
1298   %cmpeq = icmp eq i8 %x, 128
1299   %r = select i1 %cmp, i1 true, i1 %cmpeq
1300   ret i1 %r
1301 }
1302
1303 define i1 @sle_swap_or_min_commute(i8 %x, i8 %y)  {
1304 ; CHECK-LABEL: @sle_swap_or_min_commute(
1305 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sge i8 [[Y:%.*]], [[X:%.*]]
1306 ; CHECK-NEXT:    ret i1 [[CMP]]
1307 ;
1308   %cmp = icmp sge i8 %y, %x
1309   %cmpeq = icmp eq i8 %x, 128
1310   %r = or i1 %cmpeq, %cmp
1311   ret i1 %r
1312 }
1313
1314 define i1 @sle_swap_or_min_commute_logical(i8 %x, i8 %y)  {
1315 ; CHECK-LABEL: @sle_swap_or_min_commute_logical(
1316 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sge i8 [[Y:%.*]], [[X:%.*]]
1317 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp eq i8 [[X]], -128
1318 ; CHECK-NEXT:    [[R:%.*]] = select i1 [[CMPEQ]], i1 true, i1 [[CMP]]
1319 ; CHECK-NEXT:    ret i1 [[R]]
1320 ;
1321   %cmp = icmp sge i8 %y, %x
1322   %cmpeq = icmp eq i8 %x, 128
1323   %r = select i1 %cmpeq, i1 true, i1 %cmp
1324   ret i1 %r
1325 }
1326
1327 define i1 @ule_or_min(i8 %x, i8 %y)  {
1328 ; CHECK-LABEL: @ule_or_min(
1329 ; CHECK-NEXT:    [[CMP:%.*]] = icmp ule i8 [[X:%.*]], [[Y:%.*]]
1330 ; CHECK-NEXT:    ret i1 [[CMP]]
1331 ;
1332   %cmp = icmp ule i8 %x, %y
1333   %cmpeq = icmp eq i8 %x, 0
1334   %r = or i1 %cmp, %cmpeq
1335   ret i1 %r
1336 }
1337
1338 define i1 @ule_or_min_logical(i8 %x, i8 %y)  {
1339 ; CHECK-LABEL: @ule_or_min_logical(
1340 ; CHECK-NEXT:    [[CMP:%.*]] = icmp ule i8 [[X:%.*]], [[Y:%.*]]
1341 ; CHECK-NEXT:    ret i1 [[CMP]]
1342 ;
1343   %cmp = icmp ule i8 %x, %y
1344   %cmpeq = icmp eq i8 %x, 0
1345   %r = select i1 %cmp, i1 true, i1 %cmpeq
1346   ret i1 %r
1347 }
1348
1349 define i1 @ule_or_min_commute(i8 %x, i8 %y)  {
1350 ; CHECK-LABEL: @ule_or_min_commute(
1351 ; CHECK-NEXT:    [[CMP:%.*]] = icmp ule i8 [[X:%.*]], [[Y:%.*]]
1352 ; CHECK-NEXT:    ret i1 [[CMP]]
1353 ;
1354   %cmp = icmp ule i8 %x, %y
1355   %cmpeq = icmp eq i8 %x, 0
1356   %r = or i1 %cmpeq, %cmp
1357   ret i1 %r
1358 }
1359
1360 define i1 @ule_or_min_commute_logical(i8 %x, i8 %y)  {
1361 ; CHECK-LABEL: @ule_or_min_commute_logical(
1362 ; CHECK-NEXT:    [[CMP:%.*]] = icmp ule i8 [[X:%.*]], [[Y:%.*]]
1363 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp eq i8 [[X]], 0
1364 ; CHECK-NEXT:    [[R:%.*]] = select i1 [[CMPEQ]], i1 true, i1 [[CMP]]
1365 ; CHECK-NEXT:    ret i1 [[R]]
1366 ;
1367   %cmp = icmp ule i8 %x, %y
1368   %cmpeq = icmp eq i8 %x, 0
1369   %r = select i1 %cmpeq, i1 true, i1 %cmp
1370   ret i1 %r
1371 }
1372
1373 define i1 @ule_swap_or_min(i8 %x, i8 %y)  {
1374 ; CHECK-LABEL: @ule_swap_or_min(
1375 ; CHECK-NEXT:    [[CMP:%.*]] = icmp uge i8 [[Y:%.*]], [[X:%.*]]
1376 ; CHECK-NEXT:    ret i1 [[CMP]]
1377 ;
1378   %cmp = icmp uge i8 %y, %x
1379   %cmpeq = icmp eq i8 %x, 0
1380   %r = or i1 %cmp, %cmpeq
1381   ret i1 %r
1382 }
1383
1384 define i1 @ule_swap_or_min_logical(i8 %x, i8 %y)  {
1385 ; CHECK-LABEL: @ule_swap_or_min_logical(
1386 ; CHECK-NEXT:    [[CMP:%.*]] = icmp uge i8 [[Y:%.*]], [[X:%.*]]
1387 ; CHECK-NEXT:    ret i1 [[CMP]]
1388 ;
1389   %cmp = icmp uge i8 %y, %x
1390   %cmpeq = icmp eq i8 %x, 0
1391   %r = select i1 %cmp, i1 true, i1 %cmpeq
1392   ret i1 %r
1393 }
1394
1395 define i1 @ule_swap_or_min_commute(i8 %x, i8 %y)  {
1396 ; CHECK-LABEL: @ule_swap_or_min_commute(
1397 ; CHECK-NEXT:    [[CMP:%.*]] = icmp uge i8 [[Y:%.*]], [[X:%.*]]
1398 ; CHECK-NEXT:    ret i1 [[CMP]]
1399 ;
1400   %cmp = icmp uge i8 %y, %x
1401   %cmpeq = icmp eq i8 %x, 0
1402   %r = or i1 %cmpeq, %cmp
1403   ret i1 %r
1404 }
1405
1406 define i1 @ule_swap_or_min_commute_logical(i8 %x, i8 %y)  {
1407 ; CHECK-LABEL: @ule_swap_or_min_commute_logical(
1408 ; CHECK-NEXT:    [[CMP:%.*]] = icmp uge i8 [[Y:%.*]], [[X:%.*]]
1409 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp eq i8 [[X]], 0
1410 ; CHECK-NEXT:    [[R:%.*]] = select i1 [[CMPEQ]], i1 true, i1 [[CMP]]
1411 ; CHECK-NEXT:    ret i1 [[R]]
1412 ;
1413   %cmp = icmp uge i8 %y, %x
1414   %cmpeq = icmp eq i8 %x, 0
1415   %r = select i1 %cmpeq, i1 true, i1 %cmp
1416   ret i1 %r
1417 }
1418
1419 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1420 ;
1421 ; (X != MAX) && (X < Y) --> X < Y
1422 ;
1423 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1424
1425 define i1 @slt_and_not_max(i8 %x, i8 %y)  {
1426 ; CHECK-LABEL: @slt_and_not_max(
1427 ; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i8 [[X:%.*]], [[Y:%.*]]
1428 ; CHECK-NEXT:    ret i1 [[CMP]]
1429 ;
1430   %cmp = icmp slt i8 %x, %y
1431   %cmpeq = icmp ne i8 %x, 127
1432   %r = and i1 %cmp, %cmpeq
1433   ret i1 %r
1434 }
1435
1436 define i1 @slt_and_not_max_logical(i8 %x, i8 %y)  {
1437 ; CHECK-LABEL: @slt_and_not_max_logical(
1438 ; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i8 [[X:%.*]], [[Y:%.*]]
1439 ; CHECK-NEXT:    ret i1 [[CMP]]
1440 ;
1441   %cmp = icmp slt i8 %x, %y
1442   %cmpeq = icmp ne i8 %x, 127
1443   %r = select i1 %cmp, i1 %cmpeq, i1 false
1444   ret i1 %r
1445 }
1446
1447 define i1 @slt_and_not_max_commute(i8 %x, i8 %y)  {
1448 ; CHECK-LABEL: @slt_and_not_max_commute(
1449 ; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i8 [[X:%.*]], [[Y:%.*]]
1450 ; CHECK-NEXT:    ret i1 [[CMP]]
1451 ;
1452   %cmp = icmp slt i8 %x, %y
1453   %cmpeq = icmp ne i8 %x, 127
1454   %r = and i1 %cmpeq, %cmp
1455   ret i1 %r
1456 }
1457
1458 define i1 @slt_and_not_max_commute_logical(i8 %x, i8 %y)  {
1459 ; CHECK-LABEL: @slt_and_not_max_commute_logical(
1460 ; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i8 [[X:%.*]], [[Y:%.*]]
1461 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp ne i8 [[X]], 127
1462 ; CHECK-NEXT:    [[R:%.*]] = select i1 [[CMPEQ]], i1 [[CMP]], i1 false
1463 ; CHECK-NEXT:    ret i1 [[R]]
1464 ;
1465   %cmp = icmp slt i8 %x, %y
1466   %cmpeq = icmp ne i8 %x, 127
1467   %r = select i1 %cmpeq, i1 %cmp, i1 false
1468   ret i1 %r
1469 }
1470
1471 define i1 @slt_swap_and_not_max(i8 %x, i8 %y)  {
1472 ; CHECK-LABEL: @slt_swap_and_not_max(
1473 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i8 [[Y:%.*]], [[X:%.*]]
1474 ; CHECK-NEXT:    ret i1 [[CMP]]
1475 ;
1476   %cmp = icmp sgt i8 %y, %x
1477   %cmpeq = icmp ne i8 %x, 127
1478   %r = and i1 %cmp, %cmpeq
1479   ret i1 %r
1480 }
1481
1482 define i1 @slt_swap_and_not_max_logical(i8 %x, i8 %y)  {
1483 ; CHECK-LABEL: @slt_swap_and_not_max_logical(
1484 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i8 [[Y:%.*]], [[X:%.*]]
1485 ; CHECK-NEXT:    ret i1 [[CMP]]
1486 ;
1487   %cmp = icmp sgt i8 %y, %x
1488   %cmpeq = icmp ne i8 %x, 127
1489   %r = select i1 %cmp, i1 %cmpeq, i1 false
1490   ret i1 %r
1491 }
1492
1493 define i1 @slt_swap_and_not_max_commute(i8 %x, i8 %y)  {
1494 ; CHECK-LABEL: @slt_swap_and_not_max_commute(
1495 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i8 [[Y:%.*]], [[X:%.*]]
1496 ; CHECK-NEXT:    ret i1 [[CMP]]
1497 ;
1498   %cmp = icmp sgt i8 %y, %x
1499   %cmpeq = icmp ne i8 %x, 127
1500   %r = and i1 %cmpeq, %cmp
1501   ret i1 %r
1502 }
1503
1504 define i1 @slt_swap_and_not_max_commute_logical(i8 %x, i8 %y)  {
1505 ; CHECK-LABEL: @slt_swap_and_not_max_commute_logical(
1506 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i8 [[Y:%.*]], [[X:%.*]]
1507 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp ne i8 [[X]], 127
1508 ; CHECK-NEXT:    [[R:%.*]] = select i1 [[CMPEQ]], i1 [[CMP]], i1 false
1509 ; CHECK-NEXT:    ret i1 [[R]]
1510 ;
1511   %cmp = icmp sgt i8 %y, %x
1512   %cmpeq = icmp ne i8 %x, 127
1513   %r = select i1 %cmpeq, i1 %cmp, i1 false
1514   ret i1 %r
1515 }
1516
1517 define i1 @ult_and_not_max(i8 %x, i8 %y)  {
1518 ; CHECK-LABEL: @ult_and_not_max(
1519 ; CHECK-NEXT:    [[CMP:%.*]] = icmp ult i8 [[X:%.*]], [[Y:%.*]]
1520 ; CHECK-NEXT:    ret i1 [[CMP]]
1521 ;
1522   %cmp = icmp ult i8 %x, %y
1523   %cmpeq = icmp ne i8 %x, 255
1524   %r = and i1 %cmp, %cmpeq
1525   ret i1 %r
1526 }
1527
1528 define i1 @ult_and_not_max_logical(i8 %x, i8 %y)  {
1529 ; CHECK-LABEL: @ult_and_not_max_logical(
1530 ; CHECK-NEXT:    [[CMP:%.*]] = icmp ult i8 [[X:%.*]], [[Y:%.*]]
1531 ; CHECK-NEXT:    ret i1 [[CMP]]
1532 ;
1533   %cmp = icmp ult i8 %x, %y
1534   %cmpeq = icmp ne i8 %x, 255
1535   %r = select i1 %cmp, i1 %cmpeq, i1 false
1536   ret i1 %r
1537 }
1538
1539 define i1 @ult_and_not_max_commute(i8 %x, i8 %y)  {
1540 ; CHECK-LABEL: @ult_and_not_max_commute(
1541 ; CHECK-NEXT:    [[CMP:%.*]] = icmp ult i8 [[X:%.*]], [[Y:%.*]]
1542 ; CHECK-NEXT:    ret i1 [[CMP]]
1543 ;
1544   %cmp = icmp ult i8 %x, %y
1545   %cmpeq = icmp ne i8 %x, 255
1546   %r = and i1 %cmpeq, %cmp
1547   ret i1 %r
1548 }
1549
1550 define i1 @ult_and_not_max_commute_logical(i8 %x, i8 %y)  {
1551 ; CHECK-LABEL: @ult_and_not_max_commute_logical(
1552 ; CHECK-NEXT:    [[CMP:%.*]] = icmp ult i8 [[X:%.*]], [[Y:%.*]]
1553 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp ne i8 [[X]], -1
1554 ; CHECK-NEXT:    [[R:%.*]] = select i1 [[CMPEQ]], i1 [[CMP]], i1 false
1555 ; CHECK-NEXT:    ret i1 [[R]]
1556 ;
1557   %cmp = icmp ult i8 %x, %y
1558   %cmpeq = icmp ne i8 %x, 255
1559   %r = select i1 %cmpeq, i1 %cmp, i1 false
1560   ret i1 %r
1561 }
1562
1563 define i1 @ult_swap_and_not_max(i8 %x, i8 %y)  {
1564 ; CHECK-LABEL: @ult_swap_and_not_max(
1565 ; CHECK-NEXT:    [[CMP:%.*]] = icmp ugt i8 [[Y:%.*]], [[X:%.*]]
1566 ; CHECK-NEXT:    ret i1 [[CMP]]
1567 ;
1568   %cmp = icmp ugt i8 %y, %x
1569   %cmpeq = icmp ne i8 %x, 255
1570   %r = and i1 %cmp, %cmpeq
1571   ret i1 %r
1572 }
1573
1574 define i1 @ult_swap_and_not_max_logical(i8 %x, i8 %y)  {
1575 ; CHECK-LABEL: @ult_swap_and_not_max_logical(
1576 ; CHECK-NEXT:    [[CMP:%.*]] = icmp ugt i8 [[Y:%.*]], [[X:%.*]]
1577 ; CHECK-NEXT:    ret i1 [[CMP]]
1578 ;
1579   %cmp = icmp ugt i8 %y, %x
1580   %cmpeq = icmp ne i8 %x, 255
1581   %r = select i1 %cmp, i1 %cmpeq, i1 false
1582   ret i1 %r
1583 }
1584
1585 define i1 @ult_swap_and_not_max_commute(i8 %x, i8 %y)  {
1586 ; CHECK-LABEL: @ult_swap_and_not_max_commute(
1587 ; CHECK-NEXT:    [[CMP:%.*]] = icmp ugt i8 [[Y:%.*]], [[X:%.*]]
1588 ; CHECK-NEXT:    ret i1 [[CMP]]
1589 ;
1590   %cmp = icmp ugt i8 %y, %x
1591   %cmpeq = icmp ne i8 %x, 255
1592   %r = and i1 %cmpeq, %cmp
1593   ret i1 %r
1594 }
1595
1596 define i1 @ult_swap_and_not_max_commute_logical(i8 %x, i8 %y)  {
1597 ; CHECK-LABEL: @ult_swap_and_not_max_commute_logical(
1598 ; CHECK-NEXT:    [[CMP:%.*]] = icmp ugt i8 [[Y:%.*]], [[X:%.*]]
1599 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp ne i8 [[X]], -1
1600 ; CHECK-NEXT:    [[R:%.*]] = select i1 [[CMPEQ]], i1 [[CMP]], i1 false
1601 ; CHECK-NEXT:    ret i1 [[R]]
1602 ;
1603   %cmp = icmp ugt i8 %y, %x
1604   %cmpeq = icmp ne i8 %x, 255
1605   %r = select i1 %cmpeq, i1 %cmp, i1 false
1606   ret i1 %r
1607 }
1608
1609 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1610 ;
1611 ; (X != MIN) && (X > Y) --> X > Y
1612 ;
1613 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1614
1615 define i1 @sgt_and_not_min(i8 %x, i8 %y)  {
1616 ; CHECK-LABEL: @sgt_and_not_min(
1617 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i8 [[X:%.*]], [[Y:%.*]]
1618 ; CHECK-NEXT:    ret i1 [[CMP]]
1619 ;
1620   %cmp = icmp sgt i8 %x, %y
1621   %cmpeq = icmp ne i8 %x, 128
1622   %r = and i1 %cmp, %cmpeq
1623   ret i1 %r
1624 }
1625
1626 define i1 @sgt_and_not_min_logical(i8 %x, i8 %y)  {
1627 ; CHECK-LABEL: @sgt_and_not_min_logical(
1628 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i8 [[X:%.*]], [[Y:%.*]]
1629 ; CHECK-NEXT:    ret i1 [[CMP]]
1630 ;
1631   %cmp = icmp sgt i8 %x, %y
1632   %cmpeq = icmp ne i8 %x, 128
1633   %r = select i1 %cmp, i1 %cmpeq, i1 false
1634   ret i1 %r
1635 }
1636
1637 define i1 @sgt_and_not_min_commute(i8 %x, i8 %y)  {
1638 ; CHECK-LABEL: @sgt_and_not_min_commute(
1639 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i8 [[X:%.*]], [[Y:%.*]]
1640 ; CHECK-NEXT:    ret i1 [[CMP]]
1641 ;
1642   %cmp = icmp sgt i8 %x, %y
1643   %cmpeq = icmp ne i8 %x, 128
1644   %r = and i1 %cmpeq, %cmp
1645   ret i1 %r
1646 }
1647
1648 define i1 @sgt_and_not_min_commute_logical(i8 %x, i8 %y)  {
1649 ; CHECK-LABEL: @sgt_and_not_min_commute_logical(
1650 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i8 [[X:%.*]], [[Y:%.*]]
1651 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp ne i8 [[X]], -128
1652 ; CHECK-NEXT:    [[R:%.*]] = select i1 [[CMPEQ]], i1 [[CMP]], i1 false
1653 ; CHECK-NEXT:    ret i1 [[R]]
1654 ;
1655   %cmp = icmp sgt i8 %x, %y
1656   %cmpeq = icmp ne i8 %x, 128
1657   %r = select i1 %cmpeq, i1 %cmp, i1 false
1658   ret i1 %r
1659 }
1660
1661 define i1 @sgt_swap_and_not_min(i8 %x, i8 %y)  {
1662 ; CHECK-LABEL: @sgt_swap_and_not_min(
1663 ; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i8 [[Y:%.*]], [[X:%.*]]
1664 ; CHECK-NEXT:    ret i1 [[CMP]]
1665 ;
1666   %cmp = icmp slt i8 %y, %x
1667   %cmpeq = icmp ne i8 %x, 128
1668   %r = and i1 %cmp, %cmpeq
1669   ret i1 %r
1670 }
1671
1672 define i1 @sgt_swap_and_not_min_logical(i8 %x, i8 %y)  {
1673 ; CHECK-LABEL: @sgt_swap_and_not_min_logical(
1674 ; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i8 [[Y:%.*]], [[X:%.*]]
1675 ; CHECK-NEXT:    ret i1 [[CMP]]
1676 ;
1677   %cmp = icmp slt i8 %y, %x
1678   %cmpeq = icmp ne i8 %x, 128
1679   %r = select i1 %cmp, i1 %cmpeq, i1 false
1680   ret i1 %r
1681 }
1682
1683 define i1 @sgt_swap_and_not_min_commute(i8 %x, i8 %y)  {
1684 ; CHECK-LABEL: @sgt_swap_and_not_min_commute(
1685 ; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i8 [[Y:%.*]], [[X:%.*]]
1686 ; CHECK-NEXT:    ret i1 [[CMP]]
1687 ;
1688   %cmp = icmp slt i8 %y, %x
1689   %cmpeq = icmp ne i8 %x, 128
1690   %r = and i1 %cmpeq, %cmp
1691   ret i1 %r
1692 }
1693
1694 define i1 @sgt_swap_and_not_min_commute_logical(i8 %x, i8 %y)  {
1695 ; CHECK-LABEL: @sgt_swap_and_not_min_commute_logical(
1696 ; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i8 [[Y:%.*]], [[X:%.*]]
1697 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp ne i8 [[X]], -128
1698 ; CHECK-NEXT:    [[R:%.*]] = select i1 [[CMPEQ]], i1 [[CMP]], i1 false
1699 ; CHECK-NEXT:    ret i1 [[R]]
1700 ;
1701   %cmp = icmp slt i8 %y, %x
1702   %cmpeq = icmp ne i8 %x, 128
1703   %r = select i1 %cmpeq, i1 %cmp, i1 false
1704   ret i1 %r
1705 }
1706
1707 define i1 @ugt_and_not_min(i8 %x, i8 %y)  {
1708 ; CHECK-LABEL: @ugt_and_not_min(
1709 ; CHECK-NEXT:    [[CMP:%.*]] = icmp ugt i8 [[X:%.*]], [[Y:%.*]]
1710 ; CHECK-NEXT:    ret i1 [[CMP]]
1711 ;
1712   %cmp = icmp ugt i8 %x, %y
1713   %cmpeq = icmp ne i8 %x, 0
1714   %r = and i1 %cmp, %cmpeq
1715   ret i1 %r
1716 }
1717
1718 define i1 @ugt_and_not_min_logical(i8 %x, i8 %y)  {
1719 ; CHECK-LABEL: @ugt_and_not_min_logical(
1720 ; CHECK-NEXT:    [[CMP:%.*]] = icmp ugt i8 [[X:%.*]], [[Y:%.*]]
1721 ; CHECK-NEXT:    ret i1 [[CMP]]
1722 ;
1723   %cmp = icmp ugt i8 %x, %y
1724   %cmpeq = icmp ne i8 %x, 0
1725   %r = select i1 %cmp, i1 %cmpeq, i1 false
1726   ret i1 %r
1727 }
1728
1729 define i1 @ugt_and_not_min_commute(i8 %x, i8 %y)  {
1730 ; CHECK-LABEL: @ugt_and_not_min_commute(
1731 ; CHECK-NEXT:    [[CMP:%.*]] = icmp ugt i8 [[X:%.*]], [[Y:%.*]]
1732 ; CHECK-NEXT:    ret i1 [[CMP]]
1733 ;
1734   %cmp = icmp ugt i8 %x, %y
1735   %cmpeq = icmp ne i8 %x, 0
1736   %r = and i1 %cmpeq, %cmp
1737   ret i1 %r
1738 }
1739
1740 define i1 @ugt_and_not_min_commute_logical(i8 %x, i8 %y)  {
1741 ; CHECK-LABEL: @ugt_and_not_min_commute_logical(
1742 ; CHECK-NEXT:    [[CMP:%.*]] = icmp ugt i8 [[X:%.*]], [[Y:%.*]]
1743 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp ne i8 [[X]], 0
1744 ; CHECK-NEXT:    [[R:%.*]] = select i1 [[CMPEQ]], i1 [[CMP]], i1 false
1745 ; CHECK-NEXT:    ret i1 [[R]]
1746 ;
1747   %cmp = icmp ugt i8 %x, %y
1748   %cmpeq = icmp ne i8 %x, 0
1749   %r = select i1 %cmpeq, i1 %cmp, i1 false
1750   ret i1 %r
1751 }
1752
1753 define i1 @ugt_swap_and_not_min(i8 %x, i8 %y)  {
1754 ; CHECK-LABEL: @ugt_swap_and_not_min(
1755 ; CHECK-NEXT:    [[CMP:%.*]] = icmp ult i8 [[Y:%.*]], [[X:%.*]]
1756 ; CHECK-NEXT:    ret i1 [[CMP]]
1757 ;
1758   %cmp = icmp ult i8 %y, %x
1759   %cmpeq = icmp ne i8 %x, 0
1760   %r = and i1 %cmp, %cmpeq
1761   ret i1 %r
1762 }
1763
1764 define i1 @ugt_swap_and_not_min_logical(i8 %x, i8 %y)  {
1765 ; CHECK-LABEL: @ugt_swap_and_not_min_logical(
1766 ; CHECK-NEXT:    [[CMP:%.*]] = icmp ult i8 [[Y:%.*]], [[X:%.*]]
1767 ; CHECK-NEXT:    ret i1 [[CMP]]
1768 ;
1769   %cmp = icmp ult i8 %y, %x
1770   %cmpeq = icmp ne i8 %x, 0
1771   %r = select i1 %cmp, i1 %cmpeq, i1 false
1772   ret i1 %r
1773 }
1774
1775 define i1 @ugt_swap_and_not_min_commute(i8 %x, i8 %y)  {
1776 ; CHECK-LABEL: @ugt_swap_and_not_min_commute(
1777 ; CHECK-NEXT:    [[CMP:%.*]] = icmp ult i8 [[Y:%.*]], [[X:%.*]]
1778 ; CHECK-NEXT:    ret i1 [[CMP]]
1779 ;
1780   %cmp = icmp ult i8 %y, %x
1781   %cmpeq = icmp ne i8 %x, 0
1782   %r = and i1 %cmpeq, %cmp
1783   ret i1 %r
1784 }
1785
1786 define i1 @ugt_swap_and_not_min_commute_logical(i8 %x, i8 %y)  {
1787 ; CHECK-LABEL: @ugt_swap_and_not_min_commute_logical(
1788 ; CHECK-NEXT:    [[CMP:%.*]] = icmp ult i8 [[Y:%.*]], [[X:%.*]]
1789 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp ne i8 [[X]], 0
1790 ; CHECK-NEXT:    [[R:%.*]] = select i1 [[CMPEQ]], i1 [[CMP]], i1 false
1791 ; CHECK-NEXT:    ret i1 [[R]]
1792 ;
1793   %cmp = icmp ult i8 %y, %x
1794   %cmpeq = icmp ne i8 %x, 0
1795   %r = select i1 %cmpeq, i1 %cmp, i1 false
1796   ret i1 %r
1797 }
1798
1799 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1800 ;
1801 ; (X != MAX) || (X < Y) --> X != MAX
1802 ;
1803 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1804
1805 define i1 @slt_or_not_max(i8 %x, i8 %y)  {
1806 ; CHECK-LABEL: @slt_or_not_max(
1807 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp ne i8 [[X:%.*]], 127
1808 ; CHECK-NEXT:    ret i1 [[CMPEQ]]
1809 ;
1810   %cmp = icmp slt i8 %x, %y
1811   %cmpeq = icmp ne i8 %x, 127
1812   %r = or i1 %cmp, %cmpeq
1813   ret i1 %r
1814 }
1815
1816 define i1 @slt_or_not_max_logical(i8 %x, i8 %y)  {
1817 ; CHECK-LABEL: @slt_or_not_max_logical(
1818 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp ne i8 [[X:%.*]], 127
1819 ; CHECK-NEXT:    ret i1 [[CMPEQ]]
1820 ;
1821   %cmp = icmp slt i8 %x, %y
1822   %cmpeq = icmp ne i8 %x, 127
1823   %r = select i1 %cmp, i1 true, i1 %cmpeq
1824   ret i1 %r
1825 }
1826
1827 define i1 @slt_or_not_max_commute(i8 %x, i8 %y)  {
1828 ; CHECK-LABEL: @slt_or_not_max_commute(
1829 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp ne i8 [[X:%.*]], 127
1830 ; CHECK-NEXT:    ret i1 [[CMPEQ]]
1831 ;
1832   %cmp = icmp slt i8 %x, %y
1833   %cmpeq = icmp ne i8 %x, 127
1834   %r = or i1 %cmpeq, %cmp
1835   ret i1 %r
1836 }
1837
1838 define i1 @slt_or_not_max_commute_logical(i8 %x, i8 %y)  {
1839 ; CHECK-LABEL: @slt_or_not_max_commute_logical(
1840 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp ne i8 [[X:%.*]], 127
1841 ; CHECK-NEXT:    ret i1 [[CMPEQ]]
1842 ;
1843   %cmp = icmp slt i8 %x, %y
1844   %cmpeq = icmp ne i8 %x, 127
1845   %r = select i1 %cmpeq, i1 true, i1 %cmp
1846   ret i1 %r
1847 }
1848
1849 define i1 @slt_swap_or_not_max(i8 %x, i8 %y)  {
1850 ; CHECK-LABEL: @slt_swap_or_not_max(
1851 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp ne i8 [[X:%.*]], 127
1852 ; CHECK-NEXT:    ret i1 [[CMPEQ]]
1853 ;
1854   %cmp = icmp sgt i8 %y, %x
1855   %cmpeq = icmp ne i8 %x, 127
1856   %r = or i1 %cmp, %cmpeq
1857   ret i1 %r
1858 }
1859
1860 define i1 @slt_swap_or_not_max_logical(i8 %x, i8 %y)  {
1861 ; CHECK-LABEL: @slt_swap_or_not_max_logical(
1862 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp ne i8 [[X:%.*]], 127
1863 ; CHECK-NEXT:    ret i1 [[CMPEQ]]
1864 ;
1865   %cmp = icmp sgt i8 %y, %x
1866   %cmpeq = icmp ne i8 %x, 127
1867   %r = select i1 %cmp, i1 true, i1 %cmpeq
1868   ret i1 %r
1869 }
1870
1871 define i1 @slt_swap_or_not_max_commute(i8 %x, i8 %y)  {
1872 ; CHECK-LABEL: @slt_swap_or_not_max_commute(
1873 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp ne i8 [[X:%.*]], 127
1874 ; CHECK-NEXT:    ret i1 [[CMPEQ]]
1875 ;
1876   %cmp = icmp sgt i8 %y, %x
1877   %cmpeq = icmp ne i8 %x, 127
1878   %r = or i1 %cmpeq, %cmp
1879   ret i1 %r
1880 }
1881
1882 define i1 @slt_swap_or_not_max_commute_logical(i8 %x, i8 %y)  {
1883 ; CHECK-LABEL: @slt_swap_or_not_max_commute_logical(
1884 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp ne i8 [[X:%.*]], 127
1885 ; CHECK-NEXT:    ret i1 [[CMPEQ]]
1886 ;
1887   %cmp = icmp sgt i8 %y, %x
1888   %cmpeq = icmp ne i8 %x, 127
1889   %r = select i1 %cmpeq, i1 true, i1 %cmp
1890   ret i1 %r
1891 }
1892
1893 define i1 @ult_or_not_max(i8 %x, i8 %y)  {
1894 ; CHECK-LABEL: @ult_or_not_max(
1895 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp ne i8 [[X:%.*]], -1
1896 ; CHECK-NEXT:    ret i1 [[CMPEQ]]
1897 ;
1898   %cmp = icmp ult i8 %x, %y
1899   %cmpeq = icmp ne i8 %x, 255
1900   %r = or i1 %cmp, %cmpeq
1901   ret i1 %r
1902 }
1903
1904 define i1 @ult_or_not_max_logical(i8 %x, i8 %y)  {
1905 ; CHECK-LABEL: @ult_or_not_max_logical(
1906 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp ne i8 [[X:%.*]], -1
1907 ; CHECK-NEXT:    ret i1 [[CMPEQ]]
1908 ;
1909   %cmp = icmp ult i8 %x, %y
1910   %cmpeq = icmp ne i8 %x, 255
1911   %r = select i1 %cmp, i1 true, i1 %cmpeq
1912   ret i1 %r
1913 }
1914
1915 define i1 @ult_or_not_max_commute(i8 %x, i8 %y)  {
1916 ; CHECK-LABEL: @ult_or_not_max_commute(
1917 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp ne i8 [[X:%.*]], -1
1918 ; CHECK-NEXT:    ret i1 [[CMPEQ]]
1919 ;
1920   %cmp = icmp ult i8 %x, %y
1921   %cmpeq = icmp ne i8 %x, 255
1922   %r = or i1 %cmpeq, %cmp
1923   ret i1 %r
1924 }
1925
1926 define i1 @ult_or_not_max_commute_logical(i8 %x, i8 %y)  {
1927 ; CHECK-LABEL: @ult_or_not_max_commute_logical(
1928 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp ne i8 [[X:%.*]], -1
1929 ; CHECK-NEXT:    ret i1 [[CMPEQ]]
1930 ;
1931   %cmp = icmp ult i8 %x, %y
1932   %cmpeq = icmp ne i8 %x, 255
1933   %r = select i1 %cmpeq, i1 true, i1 %cmp
1934   ret i1 %r
1935 }
1936
1937 define i1 @ult_swap_or_not_max(i8 %x, i8 %y)  {
1938 ; CHECK-LABEL: @ult_swap_or_not_max(
1939 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp ne i8 [[X:%.*]], -1
1940 ; CHECK-NEXT:    ret i1 [[CMPEQ]]
1941 ;
1942   %cmp = icmp ugt i8 %y, %x
1943   %cmpeq = icmp ne i8 %x, 255
1944   %r = or i1 %cmp, %cmpeq
1945   ret i1 %r
1946 }
1947
1948 define i1 @ult_swap_or_not_max_logical(i8 %x, i8 %y)  {
1949 ; CHECK-LABEL: @ult_swap_or_not_max_logical(
1950 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp ne i8 [[X:%.*]], -1
1951 ; CHECK-NEXT:    ret i1 [[CMPEQ]]
1952 ;
1953   %cmp = icmp ugt i8 %y, %x
1954   %cmpeq = icmp ne i8 %x, 255
1955   %r = select i1 %cmp, i1 true, i1 %cmpeq
1956   ret i1 %r
1957 }
1958
1959 define i1 @ult_swap_or_not_max_commute(i8 %x, i8 %y)  {
1960 ; CHECK-LABEL: @ult_swap_or_not_max_commute(
1961 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp ne i8 [[X:%.*]], -1
1962 ; CHECK-NEXT:    ret i1 [[CMPEQ]]
1963 ;
1964   %cmp = icmp ugt i8 %y, %x
1965   %cmpeq = icmp ne i8 %x, 255
1966   %r = or i1 %cmpeq, %cmp
1967   ret i1 %r
1968 }
1969
1970 define i1 @ult_swap_or_not_max_commute_logical(i8 %x, i8 %y)  {
1971 ; CHECK-LABEL: @ult_swap_or_not_max_commute_logical(
1972 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp ne i8 [[X:%.*]], -1
1973 ; CHECK-NEXT:    ret i1 [[CMPEQ]]
1974 ;
1975   %cmp = icmp ugt i8 %y, %x
1976   %cmpeq = icmp ne i8 %x, 255
1977   %r = select i1 %cmpeq, i1 true, i1 %cmp
1978   ret i1 %r
1979 }
1980
1981 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1982 ;
1983 ; (X != MIN) || (X > Y) --> X != MIN
1984 ;
1985 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1986
1987 define i1 @sgt_or_not_min(i8 %x, i8 %y)  {
1988 ; CHECK-LABEL: @sgt_or_not_min(
1989 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp ne i8 [[X:%.*]], -128
1990 ; CHECK-NEXT:    ret i1 [[CMPEQ]]
1991 ;
1992   %cmp = icmp sgt i8 %x, %y
1993   %cmpeq = icmp ne i8 %x, 128
1994   %r = or i1 %cmp, %cmpeq
1995   ret i1 %r
1996 }
1997
1998 define i1 @sgt_or_not_min_logical(i8 %x, i8 %y)  {
1999 ; CHECK-LABEL: @sgt_or_not_min_logical(
2000 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp ne i8 [[X:%.*]], -128
2001 ; CHECK-NEXT:    ret i1 [[CMPEQ]]
2002 ;
2003   %cmp = icmp sgt i8 %x, %y
2004   %cmpeq = icmp ne i8 %x, 128
2005   %r = select i1 %cmp, i1 true, i1 %cmpeq
2006   ret i1 %r
2007 }
2008
2009 define i1 @sgt_or_not_min_commute(i8 %x, i8 %y)  {
2010 ; CHECK-LABEL: @sgt_or_not_min_commute(
2011 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp ne i8 [[X:%.*]], -128
2012 ; CHECK-NEXT:    ret i1 [[CMPEQ]]
2013 ;
2014   %cmp = icmp sgt i8 %x, %y
2015   %cmpeq = icmp ne i8 %x, 128
2016   %r = or i1 %cmpeq, %cmp
2017   ret i1 %r
2018 }
2019
2020 define i1 @sgt_or_not_min_commute_logical(i8 %x, i8 %y)  {
2021 ; CHECK-LABEL: @sgt_or_not_min_commute_logical(
2022 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp ne i8 [[X:%.*]], -128
2023 ; CHECK-NEXT:    ret i1 [[CMPEQ]]
2024 ;
2025   %cmp = icmp sgt i8 %x, %y
2026   %cmpeq = icmp ne i8 %x, 128
2027   %r = select i1 %cmpeq, i1 true, i1 %cmp
2028   ret i1 %r
2029 }
2030
2031 define i1 @sgt_swap_or_not_min(i8 %x, i8 %y)  {
2032 ; CHECK-LABEL: @sgt_swap_or_not_min(
2033 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp ne i8 [[X:%.*]], -128
2034 ; CHECK-NEXT:    ret i1 [[CMPEQ]]
2035 ;
2036   %cmp = icmp slt i8 %y, %x
2037   %cmpeq = icmp ne i8 %x, 128
2038   %r = or i1 %cmp, %cmpeq
2039   ret i1 %r
2040 }
2041
2042 define i1 @sgt_swap_or_not_min_logical(i8 %x, i8 %y)  {
2043 ; CHECK-LABEL: @sgt_swap_or_not_min_logical(
2044 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp ne i8 [[X:%.*]], -128
2045 ; CHECK-NEXT:    ret i1 [[CMPEQ]]
2046 ;
2047   %cmp = icmp slt i8 %y, %x
2048   %cmpeq = icmp ne i8 %x, 128
2049   %r = select i1 %cmp, i1 true, i1 %cmpeq
2050   ret i1 %r
2051 }
2052
2053 define i1 @sgt_swap_or_not_min_commute(i8 %x, i8 %y)  {
2054 ; CHECK-LABEL: @sgt_swap_or_not_min_commute(
2055 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp ne i8 [[X:%.*]], -128
2056 ; CHECK-NEXT:    ret i1 [[CMPEQ]]
2057 ;
2058   %cmp = icmp slt i8 %y, %x
2059   %cmpeq = icmp ne i8 %x, 128
2060   %r = or i1 %cmpeq, %cmp
2061   ret i1 %r
2062 }
2063
2064 define i1 @sgt_swap_or_not_min_commute_logical(i8 %x, i8 %y)  {
2065 ; CHECK-LABEL: @sgt_swap_or_not_min_commute_logical(
2066 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp ne i8 [[X:%.*]], -128
2067 ; CHECK-NEXT:    ret i1 [[CMPEQ]]
2068 ;
2069   %cmp = icmp slt i8 %y, %x
2070   %cmpeq = icmp ne i8 %x, 128
2071   %r = select i1 %cmpeq, i1 true, i1 %cmp
2072   ret i1 %r
2073 }
2074
2075 define i1 @ugt_or_not_min(i8 %x, i8 %y)  {
2076 ; CHECK-LABEL: @ugt_or_not_min(
2077 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp ne i8 [[X:%.*]], 0
2078 ; CHECK-NEXT:    ret i1 [[CMPEQ]]
2079 ;
2080   %cmp = icmp ugt i8 %x, %y
2081   %cmpeq = icmp ne i8 %x, 0
2082   %r = or i1 %cmp, %cmpeq
2083   ret i1 %r
2084 }
2085
2086 define i1 @ugt_or_not_min_logical(i8 %x, i8 %y)  {
2087 ; CHECK-LABEL: @ugt_or_not_min_logical(
2088 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp ne i8 [[X:%.*]], 0
2089 ; CHECK-NEXT:    ret i1 [[CMPEQ]]
2090 ;
2091   %cmp = icmp ugt i8 %x, %y
2092   %cmpeq = icmp ne i8 %x, 0
2093   %r = select i1 %cmp, i1 true, i1 %cmpeq
2094   ret i1 %r
2095 }
2096
2097 define i1 @ugt_or_not_min_commute(i8 %x, i8 %y)  {
2098 ; CHECK-LABEL: @ugt_or_not_min_commute(
2099 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp ne i8 [[X:%.*]], 0
2100 ; CHECK-NEXT:    ret i1 [[CMPEQ]]
2101 ;
2102   %cmp = icmp ugt i8 %x, %y
2103   %cmpeq = icmp ne i8 %x, 0
2104   %r = or i1 %cmpeq, %cmp
2105   ret i1 %r
2106 }
2107
2108 define i1 @ugt_or_not_min_commute_logical(i8 %x, i8 %y)  {
2109 ; CHECK-LABEL: @ugt_or_not_min_commute_logical(
2110 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp ne i8 [[X:%.*]], 0
2111 ; CHECK-NEXT:    ret i1 [[CMPEQ]]
2112 ;
2113   %cmp = icmp ugt i8 %x, %y
2114   %cmpeq = icmp ne i8 %x, 0
2115   %r = select i1 %cmpeq, i1 true, i1 %cmp
2116   ret i1 %r
2117 }
2118
2119 define i1 @ugt_swap_or_not_min(i8 %x, i8 %y)  {
2120 ; CHECK-LABEL: @ugt_swap_or_not_min(
2121 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp ne i8 [[X:%.*]], 0
2122 ; CHECK-NEXT:    ret i1 [[CMPEQ]]
2123 ;
2124   %cmp = icmp ult i8 %y, %x
2125   %cmpeq = icmp ne i8 %x, 0
2126   %r = or i1 %cmp, %cmpeq
2127   ret i1 %r
2128 }
2129
2130 define i1 @ugt_swap_or_not_min_logical(i8 %x, i8 %y)  {
2131 ; CHECK-LABEL: @ugt_swap_or_not_min_logical(
2132 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp ne i8 [[X:%.*]], 0
2133 ; CHECK-NEXT:    ret i1 [[CMPEQ]]
2134 ;
2135   %cmp = icmp ult i8 %y, %x
2136   %cmpeq = icmp ne i8 %x, 0
2137   %r = select i1 %cmp, i1 true, i1 %cmpeq
2138   ret i1 %r
2139 }
2140
2141 define i1 @ugt_swap_or_not_min_commute(i823 %x, i823 %y)  {
2142 ; CHECK-LABEL: @ugt_swap_or_not_min_commute(
2143 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp ne i823 [[X:%.*]], 0
2144 ; CHECK-NEXT:    ret i1 [[CMPEQ]]
2145 ;
2146   %cmp = icmp ult i823 %y, %x
2147   %cmpeq = icmp ne i823 %x, 0
2148   %r = or i1 %cmpeq, %cmp
2149   ret i1 %r
2150 }
2151
2152 define i1 @ugt_swap_or_not_min_commute_logical(i823 %x, i823 %y)  {
2153 ; CHECK-LABEL: @ugt_swap_or_not_min_commute_logical(
2154 ; CHECK-NEXT:    [[CMPEQ:%.*]] = icmp ne i823 [[X:%.*]], 0
2155 ; CHECK-NEXT:    ret i1 [[CMPEQ]]
2156 ;
2157   %cmp = icmp ult i823 %y, %x
2158   %cmpeq = icmp ne i823 %x, 0
2159   %r = select i1 %cmpeq, i1 true, i1 %cmp
2160   ret i1 %r
2161 }