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