llvm/test/Transforms/InstCombine/xor.ll

   1 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
   2 ; RUN: opt < %s -instcombine -S | FileCheck %s
   3
   4 @G1 = global i32 0
   5 @G2 = global i32 0
   6
   7 declare void @use(i8)
   8
   9 define i1 @test0(i1 %A) {
  10 ; CHECK-LABEL: @test0(
  11 ; CHECK-NEXT:    ret i1 [[A:%.*]]
  12 ;
  13   %B = xor i1 %A, false
  14   ret i1 %B
  15 }
  16
  17 define i32 @test1(i32 %A) {
  18 ; CHECK-LABEL: @test1(
  19 ; CHECK-NEXT:    ret i32 [[A:%.*]]
  20 ;
  21   %B = xor i32 %A, 0
  22   ret i32 %B
  23 }
  24
  25 define i1 @test2(i1 %A) {
  26 ; CHECK-LABEL: @test2(
  27 ; CHECK-NEXT:    ret i1 false
  28 ;
  29   %B = xor i1 %A, %A
  30   ret i1 %B
  31 }
  32
  33 define i32 @test3(i32 %A) {
  34 ; CHECK-LABEL: @test3(
  35 ; CHECK-NEXT:    ret i32 0
  36 ;
  37   %B = xor i32 %A, %A
  38   ret i32 %B
  39 }
  40
  41 define i32 @test4(i32 %A) {
  42 ; CHECK-LABEL: @test4(
  43 ; CHECK-NEXT:    ret i32 -1
  44 ;
  45   %NotA = xor i32 -1, %A
  46   %B = xor i32 %A, %NotA
  47   ret i32 %B
  48 }
  49
  50 define i32 @test5(i32 %A) {
  51 ; CHECK-LABEL: @test5(
  52 ; CHECK-NEXT:    [[TMP1:%.*]] = and i32 [[A:%.*]], -124
  53 ; CHECK-NEXT:    ret i32 [[TMP1]]
  54 ;
  55   %t1 = or i32 %A, 123
  56   %r = xor i32 %t1, 123
  57   ret i32 %r
  58 }
  59
  60 define i8 @test6(i8 %A) {
  61 ; CHECK-LABEL: @test6(
  62 ; CHECK-NEXT:    ret i8 [[A:%.*]]
  63 ;
  64   %B = xor i8 %A, 17
  65   %C = xor i8 %B, 17
  66   ret i8 %C
  67 }
  68
  69 define i32 @test7(i32 %A, i32 %B) {
  70 ; CHECK-LABEL: @test7(
  71 ; CHECK-NEXT:    [[A1:%.*]] = and i32 [[A:%.*]], 7
  72 ; CHECK-NEXT:    [[B1:%.*]] = and i32 [[B:%.*]], 128
  73 ; CHECK-NEXT:    [[C11:%.*]] = or i32 [[A1]], [[B1]]
  74 ; CHECK-NEXT:    ret i32 [[C11]]
  75 ;
  76   %A1 = and i32 %A, 7
  77   %B1 = and i32 %B, 128
  78   %C1 = xor i32 %A1, %B1
  79   ret i32 %C1
  80 }
  81
  82 define i8 @test8(i1 %c) {
  83 ; CHECK-LABEL: @test8(
  84 ; CHECK-NEXT:    br i1 [[C:%.*]], label [[FALSE:%.*]], label [[TRUE:%.*]]
  85 ; CHECK:       True:
  86 ; CHECK-NEXT:    ret i8 1
  87 ; CHECK:       False:
  88 ; CHECK-NEXT:    ret i8 3
  89 ;
  90   %d = xor i1 %c, true
  91   br i1 %d, label %True, label %False
  92
  93 True:
  94   ret i8 1
  95
  96 False:
  97   ret i8 3
  98 }
  99
 100 define i1 @test9(i8 %A) {
 101 ; CHECK-LABEL: @test9(
 102 ; CHECK-NEXT:    [[C:%.*]] = icmp eq i8 [[A:%.*]], 89
 103 ; CHECK-NEXT:    ret i1 [[C]]
 104 ;
 105   %B = xor i8 %A, 123
 106   %C = icmp eq i8 %B, 34
 107   ret i1 %C
 108 }
 109
 110 define <2 x i1> @test9vec(<2 x i8> %a) {
 111 ; CHECK-LABEL: @test9vec(
 112 ; CHECK-NEXT:    [[C:%.*]] = icmp eq <2 x i8> [[A:%.*]], <i8 89, i8 89>
 113 ; CHECK-NEXT:    ret <2 x i1> [[C]]
 114 ;
 115   %b = xor <2 x i8> %a, <i8 123, i8 123>
 116   %c = icmp eq <2 x i8> %b, <i8 34, i8 34>
 117   ret <2 x i1> %c
 118 }
 119
 120 define i8 @test10(i8 %A) {
 121 ; CHECK-LABEL: @test10(
 122 ; CHECK-NEXT:    [[B:%.*]] = and i8 [[A:%.*]], 3
 123 ; CHECK-NEXT:    [[C1:%.*]] = or i8 [[B]], 4
 124 ; CHECK-NEXT:    ret i8 [[C1]]
 125 ;
 126   %B = and i8 %A, 3
 127   %C = xor i8 %B, 4
 128   ret i8 %C
 129 }
 130
 131 define i8 @test11(i8 %A) {
 132 ; CHECK-LABEL: @test11(
 133 ; CHECK-NEXT:    [[B:%.*]] = and i8 [[A:%.*]], -13
 134 ; CHECK-NEXT:    [[TMP1:%.*]] = or i8 [[B]], 8
 135 ; CHECK-NEXT:    ret i8 [[TMP1]]
 136 ;
 137   %B = or i8 %A, 12
 138   %C = xor i8 %B, 4
 139   ret i8 %C
 140 }
 141
 142 define i1 @test12(i8 %A) {
 143 ; CHECK-LABEL: @test12(
 144 ; CHECK-NEXT:    [[C:%.*]] = icmp ne i8 [[A:%.*]], 4
 145 ; CHECK-NEXT:    ret i1 [[C]]
 146 ;
 147   %B = xor i8 %A, 4
 148   %c = icmp ne i8 %B, 0
 149   ret i1 %c
 150 }
 151
 152 define <2 x i1> @test12vec(<2 x i8> %a) {
 153 ; CHECK-LABEL: @test12vec(
 154 ; CHECK-NEXT:    [[C:%.*]] = icmp ne <2 x i8> [[A:%.*]], <i8 4, i8 4>
 155 ; CHECK-NEXT:    ret <2 x i1> [[C]]
 156 ;
 157   %b = xor <2 x i8> %a, <i8 4, i8 4>
 158   %c = icmp ne <2 x i8> %b, zeroinitializer
 159   ret <2 x i1> %c
 160 }
 161
 162 define i32 @test18(i32 %A) {
 163 ; CHECK-LABEL: @test18(
 164 ; CHECK-NEXT:    [[C:%.*]] = add i32 [[A:%.*]], 124
 165 ; CHECK-NEXT:    ret i32 [[C]]
 166 ;
 167   %B = xor i32 %A, -1
 168   %C = sub i32 123, %B
 169   ret i32 %C
 170 }
 171
 172 define i32 @test19(i32 %A, i32 %B) {
 173 ; CHECK-LABEL: @test19(
 174 ; CHECK-NEXT:    ret i32 [[B:%.*]]
 175 ;
 176   %C = xor i32 %A, %B
 177   %D = xor i32 %C, %A
 178   ret i32 %D
 179 }
 180
 181 define void @test20(i32 %A, i32 %B) {
 182 ; CHECK-LABEL: @test20(
 183 ; CHECK-NEXT:    store i32 [[B:%.*]], i32* @G1, align 4
 184 ; CHECK-NEXT:    store i32 [[A:%.*]], i32* @G2, align 4
 185 ; CHECK-NEXT:    ret void
 186 ;
 187   %t2 = xor i32 %B, %A
 188   %t5 = xor i32 %t2, %B
 189   %t8 = xor i32 %t5, %t2
 190   store i32 %t8, i32* @G1
 191   store i32 %t5, i32* @G2
 192   ret void
 193 }
 194
 195 define i32 @test22(i1 %X) {
 196 ; CHECK-LABEL: @test22(
 197 ; CHECK-NEXT:    [[Z:%.*]] = zext i1 [[X:%.*]] to i32
 198 ; CHECK-NEXT:    ret i32 [[Z]]
 199 ;
 200   %Y = xor i1 %X, true
 201   %Z = zext i1 %Y to i32
 202   %Q = xor i32 %Z, 1
 203   ret i32 %Q
 204 }
 205
 206 ; Look through a zext between xors.
 207
 208 define i32 @fold_zext_xor_sandwich(i1 %X) {
 209 ; CHECK-LABEL: @fold_zext_xor_sandwich(
 210 ; CHECK-NEXT:    [[Z:%.*]] = zext i1 [[X:%.*]] to i32
 211 ; CHECK-NEXT:    [[Q:%.*]] = xor i32 [[Z]], 3
 212 ; CHECK-NEXT:    ret i32 [[Q]]
 213 ;
 214   %Y = xor i1 %X, true
 215   %Z = zext i1 %Y to i32
 216   %Q = xor i32 %Z, 2
 217   ret i32 %Q
 218 }
 219
 220 define <2 x i32> @fold_zext_xor_sandwich_vec(<2 x i1> %X) {
 221 ; CHECK-LABEL: @fold_zext_xor_sandwich_vec(
 222 ; CHECK-NEXT:    [[Z:%.*]] = zext <2 x i1> [[X:%.*]] to <2 x i32>
 223 ; CHECK-NEXT:    [[Q:%.*]] = xor <2 x i32> [[Z]], <i32 3, i32 3>
 224 ; CHECK-NEXT:    ret <2 x i32> [[Q]]
 225 ;
 226   %Y = xor <2 x i1> %X, <i1 true, i1 true>
 227   %Z = zext <2 x i1> %Y to <2 x i32>
 228   %Q = xor <2 x i32> %Z, <i32 2, i32 2>
 229   ret <2 x i32> %Q
 230 }
 231
 232 define i1 @test23(i32 %a, i32 %b) {
 233 ; CHECK-LABEL: @test23(
 234 ; CHECK-NEXT:    [[T4:%.*]] = icmp eq i32 [[B:%.*]], 0
 235 ; CHECK-NEXT:    ret i1 [[T4]]
 236 ;
 237   %t2 = xor i32 %b, %a
 238   %t4 = icmp eq i32 %t2, %a
 239   ret i1 %t4
 240 }
 241
 242 define i1 @test24(i32 %c, i32 %d) {
 243 ; CHECK-LABEL: @test24(
 244 ; CHECK-NEXT:    [[T4:%.*]] = icmp ne i32 [[D:%.*]], 0
 245 ; CHECK-NEXT:    ret i1 [[T4]]
 246 ;
 247   %t2 = xor i32 %d, %c
 248   %t4 = icmp ne i32 %t2, %c
 249   ret i1 %t4
 250 }
 251
 252 define i32 @test25(i32 %g, i32 %h) {
 253 ; CHECK-LABEL: @test25(
 254 ; CHECK-NEXT:    [[T4:%.*]] = and i32 [[H:%.*]], [[G:%.*]]
 255 ; CHECK-NEXT:    ret i32 [[T4]]
 256 ;
 257   %h2 = xor i32 %h, -1
 258   %t2 = and i32 %h2, %g
 259   %t4 = xor i32 %t2, %g
 260   ret i32 %t4
 261 }
 262
 263 define i32 @test27(i32 %b, i32 %c, i32 %d) {
 264 ; CHECK-LABEL: @test27(
 265 ; CHECK-NEXT:    [[T6:%.*]] = icmp eq i32 [[B:%.*]], [[C:%.*]]
 266 ; CHECK-NEXT:    [[T7:%.*]] = zext i1 [[T6]] to i32
 267 ; CHECK-NEXT:    ret i32 [[T7]]
 268 ;
 269   %t2 = xor i32 %d, %b
 270   %t5 = xor i32 %d, %c
 271   %t6 = icmp eq i32 %t2, %t5
 272   %t7 = zext i1 %t6 to i32
 273   ret i32 %t7
 274 }
 275
 276 define i32 @test28(i32 %indvar) {
 277 ; CHECK-LABEL: @test28(
 278 ; CHECK-NEXT:    [[T214:%.*]] = add i32 [[INDVAR:%.*]], 1
 279 ; CHECK-NEXT:    ret i32 [[T214]]
 280 ;
 281   %t7 = add i32 %indvar, -2147483647
 282   %t214 = xor i32 %t7, -2147483648
 283   ret i32 %t214
 284 }
 285
 286 define <2 x i32> @test28vec(<2 x i32> %indvar) {
 287 ; CHECK-LABEL: @test28vec(
 288 ; CHECK-NEXT:    [[T214:%.*]] = add <2 x i32> [[INDVAR:%.*]], <i32 1, i32 1>
 289 ; CHECK-NEXT:    ret <2 x i32> [[T214]]
 290 ;
 291   %t7 = add <2 x i32> %indvar, <i32 -2147483647, i32 -2147483647>
 292   %t214 = xor <2 x i32> %t7, <i32 -2147483648, i32 -2147483648>
 293   ret <2 x i32> %t214
 294 }
 295
 296 define i32 @test28_sub(i32 %indvar) {
 297 ; CHECK-LABEL: @test28_sub(
 298 ; CHECK-NEXT:    [[T214:%.*]] = sub i32 1, [[INDVAR:%.*]]
 299 ; CHECK-NEXT:    ret i32 [[T214]]
 300 ;
 301   %t7 = sub i32 -2147483647, %indvar
 302   %t214 = xor i32 %t7, -2147483648
 303   ret i32 %t214
 304 }
 305
 306 define <2 x i32> @test28_subvec(<2 x i32> %indvar) {
 307 ; CHECK-LABEL: @test28_subvec(
 308 ; CHECK-NEXT:    [[T214:%.*]] = sub <2 x i32> <i32 1, i32 1>, [[INDVAR:%.*]]
 309 ; CHECK-NEXT:    ret <2 x i32> [[T214]]
 310 ;
 311   %t7 = sub <2 x i32> <i32 -2147483647, i32 -2147483647>, %indvar
 312   %t214 = xor <2 x i32> %t7, <i32 -2147483648, i32 -2147483648>
 313   ret <2 x i32> %t214
 314 }
 315
 316 define i32 @test29(i1 %C) {
 317 ; CHECK-LABEL: @test29(
 318 ; CHECK-NEXT:    [[V:%.*]] = select i1 [[C:%.*]], i32 915, i32 113
 319 ; CHECK-NEXT:    ret i32 [[V]]
 320 ;
 321   %A = select i1 %C, i32 1000, i32 10
 322   %V = xor i32 %A, 123
 323   ret i32 %V
 324 }
 325
 326 define <2 x i32> @test29vec(i1 %C) {
 327 ; CHECK-LABEL: @test29vec(
 328 ; CHECK-NEXT:    [[V:%.*]] = select i1 [[C:%.*]], <2 x i32> <i32 915, i32 915>, <2 x i32> <i32 113, i32 113>
 329 ; CHECK-NEXT:    ret <2 x i32> [[V]]
 330 ;
 331   %A = select i1 %C, <2 x i32> <i32 1000, i32 1000>, <2 x i32> <i32 10, i32 10>
 332   %V = xor <2 x i32> %A, <i32 123, i32 123>
 333   ret <2 x i32> %V
 334 }
 335
 336 define <2 x i32> @test29vec2(i1 %C) {
 337 ; CHECK-LABEL: @test29vec2(
 338 ; CHECK-NEXT:    [[V:%.*]] = select i1 [[C:%.*]], <2 x i32> <i32 915, i32 2185>, <2 x i32> <i32 113, i32 339>
 339 ; CHECK-NEXT:    ret <2 x i32> [[V]]
 340 ;
 341   %A = select i1 %C, <2 x i32> <i32 1000, i32 2500>, <2 x i32> <i32 10, i32 30>
 342   %V = xor <2 x i32> %A, <i32 123, i32 333>
 343   ret <2 x i32> %V
 344 }
 345
 346 define i32 @test30(i1 %which) {
 347 ; CHECK-LABEL: @test30(
 348 ; CHECK-NEXT:  entry:
 349 ; CHECK-NEXT:    br i1 [[WHICH:%.*]], label [[FINAL:%.*]], label [[DELAY:%.*]]
 350 ; CHECK:       delay:
 351 ; CHECK-NEXT:    br label [[FINAL]]
 352 ; CHECK:       final:
 353 ; CHECK-NEXT:    [[A:%.*]] = phi i32 [ 915, [[ENTRY:%.*]] ], [ 113, [[DELAY]] ]
 354 ; CHECK-NEXT:    ret i32 [[A]]
 355 ;
 356 entry:
 357   br i1 %which, label %final, label %delay
 358
 359 delay:
 360   br label %final
 361
 362 final:
 363   %A = phi i32 [ 1000, %entry ], [ 10, %delay ]
 364   %value = xor i32 %A, 123
 365   ret i32 %value
 366 }
 367
 368 define <2 x i32> @test30vec(i1 %which) {
 369 ; CHECK-LABEL: @test30vec(
 370 ; CHECK-NEXT:  entry:
 371 ; CHECK-NEXT:    br i1 [[WHICH:%.*]], label [[FINAL:%.*]], label [[DELAY:%.*]]
 372 ; CHECK:       delay:
 373 ; CHECK-NEXT:    br label [[FINAL]]
 374 ; CHECK:       final:
 375 ; CHECK-NEXT:    [[A:%.*]] = phi <2 x i32> [ <i32 915, i32 915>, [[ENTRY:%.*]] ], [ <i32 113, i32 113>, [[DELAY]] ]
 376 ; CHECK-NEXT:    ret <2 x i32> [[A]]
 377 ;
 378 entry:
 379   br i1 %which, label %final, label %delay
 380
 381 delay:
 382   br label %final
 383
 384 final:
 385   %A = phi <2 x i32> [ <i32 1000, i32 1000>, %entry ], [ <i32 10, i32 10>, %delay ]
 386   %value = xor <2 x i32> %A, <i32 123, i32 123>
 387   ret <2 x i32> %value
 388 }
 389
 390 define <2 x i32> @test30vec2(i1 %which) {
 391 ; CHECK-LABEL: @test30vec2(
 392 ; CHECK-NEXT:  entry:
 393 ; CHECK-NEXT:    br i1 [[WHICH:%.*]], label [[FINAL:%.*]], label [[DELAY:%.*]]
 394 ; CHECK:       delay:
 395 ; CHECK-NEXT:    br label [[FINAL]]
 396 ; CHECK:       final:
 397 ; CHECK-NEXT:    [[A:%.*]] = phi <2 x i32> [ <i32 915, i32 2185>, [[ENTRY:%.*]] ], [ <i32 113, i32 339>, [[DELAY]] ]
 398 ; CHECK-NEXT:    ret <2 x i32> [[A]]
 399 ;
 400 entry:
 401   br i1 %which, label %final, label %delay
 402
 403 delay:
 404   br label %final
 405
 406 final:
 407   %A = phi <2 x i32> [ <i32 1000, i32 2500>, %entry ], [ <i32 10, i32 30>, %delay ]
 408   %value = xor <2 x i32> %A, <i32 123, i32 333>
 409   ret <2 x i32> %value
 410 }
 411
 412 ; B ^ (B | A) --> A & ~B
 413 ; The division ops are here to thwart complexity-based canonicalization: all ops are binops.
 414
 415 define i32 @or_xor_commute1(i32 %p1, i32 %p2) {
 416 ; CHECK-LABEL: @or_xor_commute1(
 417 ; CHECK-NEXT:    [[A:%.*]] = udiv i32 42, [[P1:%.*]]
 418 ; CHECK-NEXT:    [[B:%.*]] = udiv i32 42, [[P2:%.*]]
 419 ; CHECK-NEXT:    [[TMP1:%.*]] = xor i32 [[B]], -1
 420 ; CHECK-NEXT:    [[R:%.*]] = and i32 [[A]], [[TMP1]]
 421 ; CHECK-NEXT:    ret i32 [[R]]
 422 ;
 423   %a = udiv i32 42, %p1
 424   %b = udiv i32 42, %p2
 425   %o = or i32 %b, %a
 426   %r = xor i32 %b, %o
 427   ret i32 %r
 428 }
 429
 430 ; B ^ (B | A) --> A & ~B
 431 ; The division ops are here to thwart complexity-based canonicalization: all ops are binops.
 432
 433 define i32 @or_xor_commute2(i32 %p1, i32 %p2) {
 434 ; CHECK-LABEL: @or_xor_commute2(
 435 ; CHECK-NEXT:    [[A:%.*]] = udiv i32 42, [[P1:%.*]]
 436 ; CHECK-NEXT:    [[B:%.*]] = udiv i32 42, [[P2:%.*]]
 437 ; CHECK-NEXT:    [[TMP1:%.*]] = xor i32 [[B]], -1
 438 ; CHECK-NEXT:    [[R:%.*]] = and i32 [[A]], [[TMP1]]
 439 ; CHECK-NEXT:    ret i32 [[R]]
 440 ;
 441   %a = udiv i32 42, %p1
 442   %b = udiv i32 42, %p2
 443   %o = or i32 %a, %b
 444   %r = xor i32 %o, %b
 445   ret i32 %r
 446 }
 447
 448 ; B ^ (B | A) --> A & ~B
 449 ; The division ops are here to thwart complexity-based canonicalization: all ops are binops.
 450
 451 define i32 @or_xor_commute3(i32 %p1, i32 %p2) {
 452 ; CHECK-LABEL: @or_xor_commute3(
 453 ; CHECK-NEXT:    [[A:%.*]] = udiv i32 42, [[P1:%.*]]
 454 ; CHECK-NEXT:    [[B:%.*]] = udiv i32 42, [[P2:%.*]]
 455 ; CHECK-NEXT:    [[TMP1:%.*]] = xor i32 [[B]], -1
 456 ; CHECK-NEXT:    [[R:%.*]] = and i32 [[A]], [[TMP1]]
 457 ; CHECK-NEXT:    ret i32 [[R]]
 458 ;
 459   %a = udiv i32 42, %p1
 460   %b = udiv i32 42, %p2
 461   %o = or i32 %b, %a
 462   %r = xor i32 %o, %b
 463   ret i32 %r
 464 }
 465
 466 ; B ^ (B | A) --> A & ~B
 467 ; The division ops are here to thwart complexity-based canonicalization: all ops are binops.
 468
 469 define i32 @or_xor_commute4(i32 %p1, i32 %p2) {
 470 ; CHECK-LABEL: @or_xor_commute4(
 471 ; CHECK-NEXT:    [[A:%.*]] = udiv i32 42, [[P1:%.*]]
 472 ; CHECK-NEXT:    [[B:%.*]] = udiv i32 42, [[P2:%.*]]
 473 ; CHECK-NEXT:    [[TMP1:%.*]] = xor i32 [[B]], -1
 474 ; CHECK-NEXT:    [[R:%.*]] = and i32 [[A]], [[TMP1]]
 475 ; CHECK-NEXT:    ret i32 [[R]]
 476 ;
 477   %a = udiv i32 42, %p1
 478   %b = udiv i32 42, %p2
 479   %o = or i32 %a, %b
 480   %r = xor i32 %b, %o
 481   ret i32 %r
 482 }
 483
 484 define i32 @or_xor_extra_use(i32 %a, i32 %b, i32* %p) {
 485 ; CHECK-LABEL: @or_xor_extra_use(
 486 ; CHECK-NEXT:    [[O:%.*]] = or i32 [[A:%.*]], [[B:%.*]]
 487 ; CHECK-NEXT:    store i32 [[O]], i32* [[P:%.*]], align 4
 488 ; CHECK-NEXT:    [[R:%.*]] = xor i32 [[O]], [[B]]
 489 ; CHECK-NEXT:    ret i32 [[R]]
 490 ;
 491   %o = or i32 %a, %b
 492   store i32 %o, i32* %p
 493   %r = xor i32 %b, %o
 494   ret i32 %r
 495 }
 496
 497 ; B ^ (B & A) --> ~A & B
 498 ; The division ops are here to thwart complexity-based canonicalization: all ops are binops.
 499
 500 define i32 @and_xor_commute1(i32 %p1, i32 %p2) {
 501 ; CHECK-LABEL: @and_xor_commute1(
 502 ; CHECK-NEXT:    [[A:%.*]] = udiv i32 42, [[P1:%.*]]
 503 ; CHECK-NEXT:    [[B:%.*]] = udiv i32 42, [[P2:%.*]]
 504 ; CHECK-NEXT:    [[TMP1:%.*]] = xor i32 [[A]], -1
 505 ; CHECK-NEXT:    [[R:%.*]] = and i32 [[B]], [[TMP1]]
 506 ; CHECK-NEXT:    ret i32 [[R]]
 507 ;
 508   %a = udiv i32 42, %p1
 509   %b = udiv i32 42, %p2
 510   %o = and i32 %b, %a
 511   %r = xor i32 %b, %o
 512   ret i32 %r
 513 }
 514
 515 ; B ^ (B & A) --> ~A & B
 516 ; The division ops are here to thwart complexity-based canonicalization: all ops are binops.
 517
 518 define i32 @and_xor_commute2(i32 %p1, i32 %p2) {
 519 ; CHECK-LABEL: @and_xor_commute2(
 520 ; CHECK-NEXT:    [[A:%.*]] = udiv i32 42, [[P1:%.*]]
 521 ; CHECK-NEXT:    [[B:%.*]] = udiv i32 42, [[P2:%.*]]
 522 ; CHECK-NEXT:    [[TMP1:%.*]] = xor i32 [[A]], -1
 523 ; CHECK-NEXT:    [[R:%.*]] = and i32 [[B]], [[TMP1]]
 524 ; CHECK-NEXT:    ret i32 [[R]]
 525 ;
 526   %a = udiv i32 42, %p1
 527   %b = udiv i32 42, %p2
 528   %o = and i32 %a, %b
 529   %r = xor i32 %o, %b
 530   ret i32 %r
 531 }
 532
 533 ; B ^ (B & A) --> ~A & B
 534 ; The division ops are here to thwart complexity-based canonicalization: all ops are binops.
 535
 536 define i32 @and_xor_commute3(i32 %p1, i32 %p2) {
 537 ; CHECK-LABEL: @and_xor_commute3(
 538 ; CHECK-NEXT:    [[A:%.*]] = udiv i32 42, [[P1:%.*]]
 539 ; CHECK-NEXT:    [[B:%.*]] = udiv i32 42, [[P2:%.*]]
 540 ; CHECK-NEXT:    [[TMP1:%.*]] = xor i32 [[A]], -1
 541 ; CHECK-NEXT:    [[R:%.*]] = and i32 [[B]], [[TMP1]]
 542 ; CHECK-NEXT:    ret i32 [[R]]
 543 ;
 544   %a = udiv i32 42, %p1
 545   %b = udiv i32 42, %p2
 546   %o = and i32 %b, %a
 547   %r = xor i32 %o, %b
 548   ret i32 %r
 549 }
 550
 551 ; B ^ (B & A) --> ~A & B
 552 ; The division ops are here to thwart complexity-based canonicalization: all ops are binops.
 553
 554 define i32 @and_xor_commute4(i32 %p1, i32 %p2) {
 555 ; CHECK-LABEL: @and_xor_commute4(
 556 ; CHECK-NEXT:    [[A:%.*]] = udiv i32 42, [[P1:%.*]]
 557 ; CHECK-NEXT:    [[B:%.*]] = udiv i32 42, [[P2:%.*]]
 558 ; CHECK-NEXT:    [[TMP1:%.*]] = xor i32 [[A]], -1
 559 ; CHECK-NEXT:    [[R:%.*]] = and i32 [[B]], [[TMP1]]
 560 ; CHECK-NEXT:    ret i32 [[R]]
 561 ;
 562   %a = udiv i32 42, %p1
 563   %b = udiv i32 42, %p2
 564   %o = and i32 %a, %b
 565   %r = xor i32 %b, %o
 566   ret i32 %r
 567 }
 568
 569 define i32 @and_xor_extra_use(i32 %a, i32 %b, i32* %p) {
 570 ; CHECK-LABEL: @and_xor_extra_use(
 571 ; CHECK-NEXT:    [[O:%.*]] = and i32 [[A:%.*]], [[B:%.*]]
 572 ; CHECK-NEXT:    store i32 [[O]], i32* [[P:%.*]], align 4
 573 ; CHECK-NEXT:    [[R:%.*]] = xor i32 [[O]], [[B]]
 574 ; CHECK-NEXT:    ret i32 [[R]]
 575 ;
 576   %o = and i32 %a, %b
 577   store i32 %o, i32* %p
 578   %r = xor i32 %b, %o
 579   ret i32 %r
 580 }
 581
 582 ; (~X | C2) ^ C1 --> ((X & ~C2) ^ -1) ^ C1 --> (X & ~C2) ^ ~C1
 583 ; The extra use (store) is here because the simpler case
 584 ; may be transformed using demanded bits.
 585
 586 define i8 @xor_or_not(i8 %x, i8* %p) {
 587 ; CHECK-LABEL: @xor_or_not(
 588 ; CHECK-NEXT:    [[NX:%.*]] = xor i8 [[X:%.*]], -1
 589 ; CHECK-NEXT:    store i8 [[NX]], i8* [[P:%.*]], align 1
 590 ; CHECK-NEXT:    [[TMP1:%.*]] = and i8 [[X]], -8
 591 ; CHECK-NEXT:    [[R:%.*]] = xor i8 [[TMP1]], -13
 592 ; CHECK-NEXT:    ret i8 [[R]]
 593 ;
 594   %nx = xor i8 %x, -1
 595   store i8 %nx, i8* %p
 596   %or = or i8 %nx, 7
 597   %r = xor i8 %or, 12
 598   ret i8 %r
 599 }
 600
 601 ; Don't do this if the 'or' has extra uses.
 602
 603 define i8 @xor_or_not_uses(i8 %x, i8* %p) {
 604 ; CHECK-LABEL: @xor_or_not_uses(
 605 ; CHECK-NEXT:    [[NX:%.*]] = xor i8 [[X:%.*]], -1
 606 ; CHECK-NEXT:    [[OR:%.*]] = or i8 [[NX]], 7
 607 ; CHECK-NEXT:    store i8 [[OR]], i8* [[P:%.*]], align 1
 608 ; CHECK-NEXT:    [[R:%.*]] = xor i8 [[OR]], 12
 609 ; CHECK-NEXT:    ret i8 [[R]]
 610 ;
 611   %nx = xor i8 %x, -1
 612   %or = or i8 %nx, 7
 613   store i8 %or, i8* %p
 614   %r = xor i8 %or, 12
 615   ret i8 %r
 616 }
 617
 618 ; (~X & C2) ^ C1 --> ((X | ~C2) ^ -1) ^ C1 --> (X | ~C2) ^ ~C1
 619 ; The extra use (store) is here because the simpler case
 620 ; may be transformed using demanded bits.
 621
 622 define i8 @xor_and_not(i8 %x, i8* %p) {
 623 ; CHECK-LABEL: @xor_and_not(
 624 ; CHECK-NEXT:    [[NX:%.*]] = xor i8 [[X:%.*]], -1
 625 ; CHECK-NEXT:    store i8 [[NX]], i8* [[P:%.*]], align 1
 626 ; CHECK-NEXT:    [[TMP1:%.*]] = or i8 [[X]], -43
 627 ; CHECK-NEXT:    [[R:%.*]] = xor i8 [[TMP1]], -32
 628 ; CHECK-NEXT:    ret i8 [[R]]
 629 ;
 630   %nx = xor i8 %x, -1
 631   store i8 %nx, i8* %p
 632   %and = and i8 %nx, 42
 633   %r = xor i8 %and, 31
 634   ret i8 %r
 635 }
 636
 637 ; Don't do this if the 'and' has extra uses.
 638
 639 define i8 @xor_and_not_uses(i8 %x, i8* %p) {
 640 ; CHECK-LABEL: @xor_and_not_uses(
 641 ; CHECK-NEXT:    [[NX:%.*]] = and i8 [[X:%.*]], 42
 642 ; CHECK-NEXT:    [[AND:%.*]] = xor i8 [[NX]], 42
 643 ; CHECK-NEXT:    store i8 [[AND]], i8* [[P:%.*]], align 1
 644 ; CHECK-NEXT:    [[R:%.*]] = xor i8 [[NX]], 53
 645 ; CHECK-NEXT:    ret i8 [[R]]
 646 ;
 647   %nx = xor i8 %x, -1
 648   %and = and i8 %nx, 42
 649   store i8 %and, i8* %p
 650   %r = xor i8 %and, 31
 651   ret i8 %r
 652 }
 653
 654 ; The tests 39-47 are related to the canonicalization:
 655 ; %notx = xor i32 %x, -1
 656 ; %cmp = icmp sgt i32 %notx, %y
 657 ; %smax = select i1 %cmp, i32 %notx, i32 %y
 658 ; %res = xor i32 %smax, -1
 659 ;   =>
 660 ; %noty = xor i32 %y, -1
 661 ; %cmp2 = icmp slt %x, %noty
 662 ; %res = select i1 %cmp2, i32 %x, i32 %noty
 663 ;
 664 ; Same transformations is valid for smin/umax/umin.
 665
 666 define i32 @test39(i32 %x) {
 667 ; CHECK-LABEL: @test39(
 668 ; CHECK-NEXT:    [[TMP1:%.*]] = icmp slt i32 [[X:%.*]], 255
 669 ; CHECK-NEXT:    [[TMP2:%.*]] = select i1 [[TMP1]], i32 [[X]], i32 255
 670 ; CHECK-NEXT:    ret i32 [[TMP2]]
 671 ;
 672   %1 = xor i32 %x, -1
 673   %2 = icmp sgt i32 %1, -256
 674   %3 = select i1 %2, i32 %1, i32 -256
 675   %res = xor i32 %3, -1
 676   ret i32 %res
 677 }
 678
 679 define i32 @test40(i32 %x, i32 %y) {
 680 ; CHECK-LABEL: @test40(
 681 ; CHECK-NEXT:    [[TMP1:%.*]] = xor i32 [[Y:%.*]], -1
 682 ; CHECK-NEXT:    [[TMP2:%.*]] = icmp sgt i32 [[TMP1]], [[X:%.*]]
 683 ; CHECK-NEXT:    [[RES:%.*]] = select i1 [[TMP2]], i32 [[X]], i32 [[TMP1]]
 684 ; CHECK-NEXT:    ret i32 [[RES]]
 685 ;
 686   %notx = xor i32 %x, -1
 687   %cmp1 = icmp sgt i32 %notx, %y
 688   %smax = select i1 %cmp1, i32 %notx, i32 %y
 689   %res = xor i32 %smax, -1
 690   ret i32 %res
 691 }
 692
 693 define i32 @test41(i32 %x, i32 %y) {
 694 ; CHECK-LABEL: @test41(
 695 ; CHECK-NEXT:    [[TMP1:%.*]] = xor i32 [[Y:%.*]], -1
 696 ; CHECK-NEXT:    [[TMP2:%.*]] = icmp slt i32 [[TMP1]], [[X:%.*]]
 697 ; CHECK-NEXT:    [[RES:%.*]] = select i1 [[TMP2]], i32 [[X]], i32 [[TMP1]]
 698 ; CHECK-NEXT:    ret i32 [[RES]]
 699 ;
 700   %notx = xor i32 %x, -1
 701   %cmp1 = icmp slt i32 %notx, %y
 702   %smin = select i1 %cmp1, i32 %notx, i32 %y
 703   %res = xor i32 %smin, -1
 704   ret i32 %res
 705 }
 706
 707 define i32 @test42(i32 %x, i32 %y) {
 708 ; CHECK-LABEL: @test42(
 709 ; CHECK-NEXT:    [[TMP1:%.*]] = xor i32 [[Y:%.*]], -1
 710 ; CHECK-NEXT:    [[TMP2:%.*]] = icmp ugt i32 [[TMP1]], [[X:%.*]]
 711 ; CHECK-NEXT:    [[RES:%.*]] = select i1 [[TMP2]], i32 [[X]], i32 [[TMP1]]
 712 ; CHECK-NEXT:    ret i32 [[RES]]
 713 ;
 714   %notx = xor i32 %x, -1
 715   %cmp1 = icmp ugt i32 %notx, %y
 716   %umax = select i1 %cmp1, i32 %notx, i32 %y
 717   %res = xor i32 %umax, -1
 718   ret i32 %res
 719 }
 720
 721 define i32 @test43(i32 %x, i32 %y) {
 722 ; CHECK-LABEL: @test43(
 723 ; CHECK-NEXT:    [[TMP1:%.*]] = xor i32 [[Y:%.*]], -1
 724 ; CHECK-NEXT:    [[TMP2:%.*]] = icmp ult i32 [[TMP1]], [[X:%.*]]
 725 ; CHECK-NEXT:    [[RES:%.*]] = select i1 [[TMP2]], i32 [[X]], i32 [[TMP1]]
 726 ; CHECK-NEXT:    ret i32 [[RES]]
 727 ;
 728   %notx = xor i32 %x, -1
 729   %cmp1 = icmp ult i32 %notx, %y
 730   %umin = select i1 %cmp1, i32 %notx, i32 %y
 731   %res = xor i32 %umin, -1
 732   ret i32 %res
 733 }
 734
 735 define i32 @test44(i32 %x, i32 %y) {
 736 ; CHECK-LABEL: @test44(
 737 ; CHECK-NEXT:    [[TMP1:%.*]] = sub i32 -4, [[Y:%.*]]
 738 ; CHECK-NEXT:    [[TMP2:%.*]] = icmp ugt i32 [[TMP1]], [[X:%.*]]
 739 ; CHECK-NEXT:    [[RES:%.*]] = select i1 [[TMP2]], i32 [[TMP1]], i32 [[X]]
 740 ; CHECK-NEXT:    ret i32 [[RES]]
 741 ;
 742   %z = add i32 %y, 3 ; thwart complexity-based canonicalization
 743   %notx = xor i32 %x, -1
 744   %cmp1 = icmp ult i32 %z, %notx
 745   %umin = select i1 %cmp1, i32 %z, i32 %notx
 746   %res = xor i32 %umin, -1
 747   ret i32 %res
 748 }
 749
 750 define i32 @test45(i32 %x, i32 %y) {
 751 ; CHECK-LABEL: @test45(
 752 ; CHECK-NEXT:    [[TMP1:%.*]] = icmp ugt i32 [[Y:%.*]], [[X:%.*]]
 753 ; CHECK-NEXT:    [[TMP2:%.*]] = select i1 [[TMP1]], i32 [[Y]], i32 [[X]]
 754 ; CHECK-NEXT:    ret i32 [[TMP2]]
 755 ;
 756   %z = xor i32 %y, -1
 757   %notx = xor i32 %x, -1
 758   %cmp1 = icmp ult i32 %z, %notx
 759   %umin = select i1 %cmp1, i32 %z, i32 %notx
 760   %res = xor i32 %umin, -1
 761   ret i32 %res
 762 }
 763
 764 ; Check that we work with splat vectors also.
 765 define <4 x i32> @test46(<4 x i32> %x) {
 766 ; CHECK-LABEL: @test46(
 767 ; CHECK-NEXT:    [[TMP1:%.*]] = icmp slt <4 x i32> [[X:%.*]], <i32 255, i32 255, i32 255, i32 255>
 768 ; CHECK-NEXT:    [[TMP2:%.*]] = select <4 x i1> [[TMP1]], <4 x i32> [[X]], <4 x i32> <i32 255, i32 255, i32 255, i32 255>
 769 ; CHECK-NEXT:    ret <4 x i32> [[TMP2]]
 770 ;
 771   %1 = xor <4 x i32> %x, <i32 -1, i32 -1, i32 -1, i32 -1>
 772   %2 = icmp sgt <4 x i32> %1, <i32 -256, i32 -256, i32 -256, i32 -256>
 773   %3 = select <4 x i1> %2, <4 x i32> %1, <4 x i32> <i32 -256, i32 -256, i32 -256, i32 -256>
 774   %4 = xor <4 x i32> %3, <i32 -1, i32 -1, i32 -1, i32 -1>
 775   ret <4 x i32> %4
 776 }
 777
 778 ; Test case when select pattern has more than one use.
 779 define i32 @test47(i32 %x, i32 %y, i32 %z) {
 780 ; CHECK-LABEL: @test47(
 781 ; CHECK-NEXT:    [[NOTX:%.*]] = xor i32 [[X:%.*]], -1
 782 ; CHECK-NEXT:    [[CMP1:%.*]] = icmp ugt i32 [[NOTX]], [[Y:%.*]]
 783 ; CHECK-NEXT:    [[UMAX:%.*]] = select i1 [[CMP1]], i32 [[NOTX]], i32 [[Y]]
 784 ; CHECK-NEXT:    [[UMIN:%.*]] = xor i32 [[UMAX]], -1
 785 ; CHECK-NEXT:    [[ADD:%.*]] = add i32 [[UMAX]], [[Z:%.*]]
 786 ; CHECK-NEXT:    [[RES:%.*]] = mul i32 [[ADD]], [[UMIN]]
 787 ; CHECK-NEXT:    ret i32 [[RES]]
 788 ;
 789   %notx = xor i32 %x, -1
 790   %cmp1 = icmp ugt i32 %notx, %y
 791   %umax = select i1 %cmp1, i32 %notx, i32 %y
 792   %umin = xor i32 %umax, -1
 793   %add = add i32 %umax, %z
 794   %res = mul i32 %umin, %add
 795   ret i32 %res
 796 }
 797
 798 define i32 @test48(i32 %x) {
 799 ; CHECK-LABEL: @test48(
 800 ; CHECK-NEXT:    [[TMP1:%.*]] = add i32 [[X:%.*]], 1
 801 ; CHECK-NEXT:    [[TMP2:%.*]] = icmp slt i32 [[TMP1]], -1
 802 ; CHECK-NEXT:    [[D:%.*]] = select i1 [[TMP2]], i32 [[TMP1]], i32 -1
 803 ; CHECK-NEXT:    ret i32 [[D]]
 804 ;
 805   %a = sub i32 -2, %x
 806   %b = icmp sgt i32 %a, 0
 807   %c = select i1 %b, i32 %a, i32 0
 808   %d = xor i32 %c, -1
 809   ret i32 %d
 810 }
 811
 812 define <2 x i32> @test48vec(<2 x i32> %x) {
 813 ; CHECK-LABEL: @test48vec(
 814 ; CHECK-NEXT:    [[TMP1:%.*]] = add <2 x i32> [[X:%.*]], <i32 1, i32 1>
 815 ; CHECK-NEXT:    [[TMP2:%.*]] = icmp slt <2 x i32> [[TMP1]], <i32 -1, i32 -1>
 816 ; CHECK-NEXT:    [[D:%.*]] = select <2 x i1> [[TMP2]], <2 x i32> [[TMP1]], <2 x i32> <i32 -1, i32 -1>
 817 ; CHECK-NEXT:    ret <2 x i32> [[D]]
 818 ;
 819   %a = sub <2 x i32> <i32 -2, i32 -2>, %x
 820   %b = icmp sgt <2 x i32> %a, zeroinitializer
 821   %c = select <2 x i1> %b, <2 x i32> %a, <2 x i32> zeroinitializer
 822   %d = xor <2 x i32> %c, <i32 -1, i32 -1>
 823   ret <2 x i32> %d
 824 }
 825
 826 define i32 @test49(i32 %x) {
 827 ; CHECK-LABEL: @test49(
 828 ; CHECK-NEXT:    [[TMP1:%.*]] = sub i32 1, [[X:%.*]]
 829 ; CHECK-NEXT:    [[TMP2:%.*]] = icmp sgt i32 [[TMP1]], 0
 830 ; CHECK-NEXT:    [[D:%.*]] = select i1 [[TMP2]], i32 [[TMP1]], i32 0
 831 ; CHECK-NEXT:    ret i32 [[D]]
 832 ;
 833   %a = add i32 %x, -2
 834   %b = icmp slt i32 %a, -1
 835   %c = select i1 %b, i32 %a, i32 -1
 836   %d = xor i32 %c, -1
 837   ret i32 %d
 838 }
 839
 840 define <2 x i32> @test49vec(<2 x i32> %x) {
 841 ; CHECK-LABEL: @test49vec(
 842 ; CHECK-NEXT:    [[TMP1:%.*]] = sub <2 x i32> <i32 1, i32 1>, [[X:%.*]]
 843 ; CHECK-NEXT:    [[TMP2:%.*]] = icmp sgt <2 x i32> [[TMP1]], zeroinitializer
 844 ; CHECK-NEXT:    [[D:%.*]] = select <2 x i1> [[TMP2]], <2 x i32> [[TMP1]], <2 x i32> zeroinitializer
 845 ; CHECK-NEXT:    ret <2 x i32> [[D]]
 846 ;
 847   %a = add <2 x i32> %x, <i32 -2, i32 -2>
 848   %b = icmp slt <2 x i32> %a, <i32 -1, i32 -1>
 849   %c = select <2 x i1> %b, <2 x i32> %a, <2 x i32> <i32 -1, i32 -1>
 850   %d = xor <2 x i32> %c, <i32 -1, i32 -1>
 851   ret <2 x i32> %d
 852 }
 853
 854 define i32 @test50(i32 %x, i32 %y) {
 855 ; CHECK-LABEL: @test50(
 856 ; CHECK-NEXT:    [[TMP1:%.*]] = sub i32 1, [[X:%.*]]
 857 ; CHECK-NEXT:    [[TMP2:%.*]] = add i32 [[Y:%.*]], 1
 858 ; CHECK-NEXT:    [[TMP3:%.*]] = icmp sgt i32 [[TMP1]], [[TMP2]]
 859 ; CHECK-NEXT:    [[E:%.*]] = select i1 [[TMP3]], i32 [[TMP1]], i32 [[TMP2]]
 860 ; CHECK-NEXT:    ret i32 [[E]]
 861 ;
 862   %a = add i32 %x, -2
 863   %b = sub i32 -2, %y
 864   %c = icmp slt i32 %a, %b
 865   %d = select i1 %c, i32 %a, i32 %b
 866   %e = xor i32 %d, -1
 867   ret i32 %e
 868 }
 869
 870 define <2 x i32> @test50vec(<2 x i32> %x, <2 x i32> %y) {
 871 ; CHECK-LABEL: @test50vec(
 872 ; CHECK-NEXT:    [[TMP1:%.*]] = sub <2 x i32> <i32 1, i32 1>, [[X:%.*]]
 873 ; CHECK-NEXT:    [[TMP2:%.*]] = add <2 x i32> [[Y:%.*]], <i32 1, i32 1>
 874 ; CHECK-NEXT:    [[TMP3:%.*]] = icmp sgt <2 x i32> [[TMP1]], [[TMP2]]
 875 ; CHECK-NEXT:    [[E:%.*]] = select <2 x i1> [[TMP3]], <2 x i32> [[TMP1]], <2 x i32> [[TMP2]]
 876 ; CHECK-NEXT:    ret <2 x i32> [[E]]
 877 ;
 878   %a = add <2 x i32> %x, <i32 -2, i32 -2>
 879   %b = sub <2 x i32> <i32 -2, i32 -2>, %y
 880   %c = icmp slt <2 x i32> %a, %b
 881   %d = select <2 x i1> %c, <2 x i32> %a, <2 x i32> %b
 882   %e = xor <2 x i32> %d, <i32 -1, i32 -1>
 883   ret <2 x i32> %e
 884 }
 885
 886 define i32 @test51(i32 %x, i32 %y) {
 887 ; CHECK-LABEL: @test51(
 888 ; CHECK-NEXT:    [[TMP1:%.*]] = sub i32 -3, [[X:%.*]]
 889 ; CHECK-NEXT:    [[TMP2:%.*]] = add i32 [[Y:%.*]], -3
 890 ; CHECK-NEXT:    [[TMP3:%.*]] = icmp slt i32 [[TMP1]], [[TMP2]]
 891 ; CHECK-NEXT:    [[E:%.*]] = select i1 [[TMP3]], i32 [[TMP1]], i32 [[TMP2]]
 892 ; CHECK-NEXT:    ret i32 [[E]]
 893 ;
 894   %a = add i32 %x, 2
 895   %b = sub i32 2, %y
 896   %c = icmp sgt i32 %a, %b
 897   %d = select i1 %c, i32 %a, i32 %b
 898   %e = xor i32 %d, -1
 899   ret i32 %e
 900 }
 901
 902 define <2 x i32> @test51vec(<2 x i32> %x, <2 x i32> %y) {
 903 ; CHECK-LABEL: @test51vec(
 904 ; CHECK-NEXT:    [[TMP1:%.*]] = sub <2 x i32> <i32 -3, i32 -3>, [[X:%.*]]
 905 ; CHECK-NEXT:    [[TMP2:%.*]] = add <2 x i32> [[Y:%.*]], <i32 -3, i32 -3>
 906 ; CHECK-NEXT:    [[TMP3:%.*]] = icmp slt <2 x i32> [[TMP1]], [[TMP2]]
 907 ; CHECK-NEXT:    [[E:%.*]] = select <2 x i1> [[TMP3]], <2 x i32> [[TMP1]], <2 x i32> [[TMP2]]
 908 ; CHECK-NEXT:    ret <2 x i32> [[E]]
 909 ;
 910   %a = add <2 x i32> %x, <i32 2, i32 2>
 911   %b = sub <2 x i32> <i32 2, i32 2>, %y
 912   %c = icmp sgt <2 x i32> %a, %b
 913   %d = select <2 x i1> %c, <2 x i32> %a, <2 x i32> %b
 914   %e = xor <2 x i32> %d, <i32 -1, i32 -1>
 915   ret <2 x i32> %e
 916 }
 917
 918 define i4 @or_or_xor(i4 %x, i4 %y, i4 %z) {
 919 ; CHECK-LABEL: @or_or_xor(
 920 ; CHECK-NEXT:    [[TMP1:%.*]] = xor i4 [[Z:%.*]], -1
 921 ; CHECK-NEXT:    [[TMP2:%.*]] = xor i4 [[X:%.*]], [[Y:%.*]]
 922 ; CHECK-NEXT:    [[R:%.*]] = and i4 [[TMP2]], [[TMP1]]
 923 ; CHECK-NEXT:    ret i4 [[R]]
 924 ;
 925   %o1 = or i4 %z, %x
 926   %o2 = or i4 %z, %y
 927   %r = xor i4 %o1, %o2
 928   ret i4 %r
 929 }
 930
 931 define i4 @or_or_xor_commute1(i4 %x, i4 %y, i4 %z) {
 932 ; CHECK-LABEL: @or_or_xor_commute1(
 933 ; CHECK-NEXT:    [[TMP1:%.*]] = xor i4 [[Z:%.*]], -1
 934 ; CHECK-NEXT:    [[TMP2:%.*]] = xor i4 [[X:%.*]], [[Y:%.*]]
 935 ; CHECK-NEXT:    [[R:%.*]] = and i4 [[TMP2]], [[TMP1]]
 936 ; CHECK-NEXT:    ret i4 [[R]]
 937 ;
 938   %o1 = or i4 %x, %z
 939   %o2 = or i4 %z, %y
 940   %r = xor i4 %o1, %o2
 941   ret i4 %r
 942 }
 943
 944 define i4 @or_or_xor_commute2(i4 %x, i4 %y, i4 %z) {
 945 ; CHECK-LABEL: @or_or_xor_commute2(
 946 ; CHECK-NEXT:    [[TMP1:%.*]] = xor i4 [[Z:%.*]], -1
 947 ; CHECK-NEXT:    [[TMP2:%.*]] = xor i4 [[X:%.*]], [[Y:%.*]]
 948 ; CHECK-NEXT:    [[R:%.*]] = and i4 [[TMP2]], [[TMP1]]
 949 ; CHECK-NEXT:    ret i4 [[R]]
 950 ;
 951   %o1 = or i4 %z, %x
 952   %o2 = or i4 %y, %z
 953   %r = xor i4 %o1, %o2
 954   ret i4 %r
 955 }
 956
 957 define <2 x i4> @or_or_xor_commute3(<2 x i4> %x, <2 x i4> %y, <2 x i4> %z) {
 958 ; CHECK-LABEL: @or_or_xor_commute3(
 959 ; CHECK-NEXT:    [[TMP1:%.*]] = xor <2 x i4> [[Z:%.*]], <i4 -1, i4 -1>
 960 ; CHECK-NEXT:    [[TMP2:%.*]] = xor <2 x i4> [[X:%.*]], [[Y:%.*]]
 961 ; CHECK-NEXT:    [[R:%.*]] = and <2 x i4> [[TMP2]], [[TMP1]]
 962 ; CHECK-NEXT:    ret <2 x i4> [[R]]
 963 ;
 964   %o1 = or <2 x i4> %x, %z
 965   %o2 = or <2 x i4> %y, %z
 966   %r = xor <2 x i4> %o1, %o2
 967   ret <2 x i4> %r
 968 }
 969
 970 define i4 @or_or_xor_use1(i4 %x, i4 %y, i4 %z, i4* %p) {
 971 ; CHECK-LABEL: @or_or_xor_use1(
 972 ; CHECK-NEXT:    [[O1:%.*]] = or i4 [[Z:%.*]], [[X:%.*]]
 973 ; CHECK-NEXT:    store i4 [[O1]], i4* [[P:%.*]], align 1
 974 ; CHECK-NEXT:    [[O2:%.*]] = or i4 [[Z]], [[Y:%.*]]
 975 ; CHECK-NEXT:    [[R:%.*]] = xor i4 [[O1]], [[O2]]
 976 ; CHECK-NEXT:    ret i4 [[R]]
 977 ;
 978   %o1 = or i4 %z, %x
 979   store i4 %o1, i4* %p
 980   %o2 = or i4 %z, %y
 981   %r = xor i4 %o1, %o2
 982   ret i4 %r
 983 }
 984
 985 define i4 @or_or_xor_use2(i4 %x, i4 %y, i4 %z, i4* %p) {
 986 ; CHECK-LABEL: @or_or_xor_use2(
 987 ; CHECK-NEXT:    [[O1:%.*]] = or i4 [[Z:%.*]], [[X:%.*]]
 988 ; CHECK-NEXT:    [[O2:%.*]] = or i4 [[Z]], [[Y:%.*]]
 989 ; CHECK-NEXT:    store i4 [[O2]], i4* [[P:%.*]], align 1
 990 ; CHECK-NEXT:    [[R:%.*]] = xor i4 [[O1]], [[O2]]
 991 ; CHECK-NEXT:    ret i4 [[R]]
 992 ;
 993   %o1 = or i4 %z, %x
 994   %o2 = or i4 %z, %y
 995   store i4 %o2, i4* %p
 996   %r = xor i4 %o1, %o2
 997   ret i4 %r
 998 }
 999
1000 ; PR32706 - https://bugs.llvm.org/show_bug.cgi?id=32706
1001 ; Pin an xor constant operand to -1 if possible because 'not' is better for SCEV and codegen.
1002
1003 define i32 @not_is_canonical(i32 %x, i32 %y) {
1004 ; CHECK-LABEL: @not_is_canonical(
1005 ; CHECK-NEXT:    [[SUB:%.*]] = xor i32 [[X:%.*]], -1
1006 ; CHECK-NEXT:    [[ADD:%.*]] = add i32 [[SUB]], [[Y:%.*]]
1007 ; CHECK-NEXT:    [[MUL:%.*]] = shl i32 [[ADD]], 2
1008 ; CHECK-NEXT:    ret i32 [[MUL]]
1009 ;
1010   %sub = xor i32 %x, 1073741823
1011   %add = add i32 %sub, %y
1012   %mul = shl i32 %add, 2
1013   ret i32 %mul
1014 }
1015
1016 define i8 @not_shl(i8 %x) {
1017 ; CHECK-LABEL: @not_shl(
1018 ; CHECK-NEXT:    [[TMP1:%.*]] = xor i8 [[X:%.*]], -1
1019 ; CHECK-NEXT:    [[R:%.*]] = shl i8 [[TMP1]], 7
1020 ; CHECK-NEXT:    ret i8 [[R]]
1021 ;
1022   %a = shl i8 %x, 7
1023   %r = xor i8 %a, 128
1024   ret i8 %r
1025 }
1026
1027 define <2 x i8> @not_shl_vec(<2 x i8> %x) {
1028 ; CHECK-LABEL: @not_shl_vec(
1029 ; CHECK-NEXT:    [[TMP1:%.*]] = xor <2 x i8> [[X:%.*]], <i8 -1, i8 -1>
1030 ; CHECK-NEXT:    [[R:%.*]] = shl <2 x i8> [[TMP1]], <i8 5, i8 5>
1031 ; CHECK-NEXT:    ret <2 x i8> [[R]]
1032 ;
1033   %a = shl <2 x i8> %x, <i8 5, i8 5>
1034   %r = xor <2 x i8> %a, <i8 224, i8 224>
1035   ret <2 x i8> %r
1036 }
1037
1038 ; negative test
1039
1040 define i8 @not_shl_extra_use(i8 %x) {
1041 ; CHECK-LABEL: @not_shl_extra_use(
1042 ; CHECK-NEXT:    [[A:%.*]] = shl i8 [[X:%.*]], 7
1043 ; CHECK-NEXT:    call void @use(i8 [[A]])
1044 ; CHECK-NEXT:    [[R:%.*]] = xor i8 [[A]], -128
1045 ; CHECK-NEXT:    ret i8 [[R]]
1046 ;
1047   %a = shl i8 %x, 7
1048   call void @use(i8 %a)
1049   %r = xor i8 %a, 128
1050   ret i8 %r
1051 }
1052
1053 ; negative test
1054
1055 define i8 @not_shl_wrong_const(i8 %x) {
1056 ; CHECK-LABEL: @not_shl_wrong_const(
1057 ; CHECK-NEXT:    [[A:%.*]] = shl i8 [[X:%.*]], 6
1058 ; CHECK-NEXT:    [[R:%.*]] = xor i8 [[A]], -128
1059 ; CHECK-NEXT:    ret i8 [[R]]
1060 ;
1061   %a = shl i8 %x, 6
1062   %r = xor i8 %a, 128
1063   ret i8 %r
1064 }
1065
1066 define i8 @not_lshr(i8 %x) {
1067 ; CHECK-LABEL: @not_lshr(
1068 ; CHECK-NEXT:    [[TMP1:%.*]] = xor i8 [[X:%.*]], -1
1069 ; CHECK-NEXT:    [[R:%.*]] = lshr i8 [[TMP1]], 5
1070 ; CHECK-NEXT:    ret i8 [[R]]
1071 ;
1072   %a = lshr i8 %x, 5
1073   %r = xor i8 %a, 7
1074   ret i8 %r
1075 }
1076
1077 define <2 x i8> @not_lshr_vec(<2 x i8> %x) {
1078 ; CHECK-LABEL: @not_lshr_vec(
1079 ; CHECK-NEXT:    [[TMP1:%.*]] = xor <2 x i8> [[X:%.*]], <i8 -1, i8 -1>
1080 ; CHECK-NEXT:    [[R:%.*]] = lshr <2 x i8> [[TMP1]], <i8 7, i8 7>
1081 ; CHECK-NEXT:    ret <2 x i8> [[R]]
1082 ;
1083   %a = lshr <2 x i8> %x, <i8 7, i8 7>
1084   %r = xor <2 x i8> %a, <i8 1, i8 1>
1085   ret <2 x i8> %r
1086 }
1087
1088 ; negative test
1089
1090 define i8 @not_lshr_extra_use(i8 %x) {
1091 ; CHECK-LABEL: @not_lshr_extra_use(
1092 ; CHECK-NEXT:    [[A:%.*]] = lshr i8 [[X:%.*]], 5
1093 ; CHECK-NEXT:    call void @use(i8 [[A]])
1094 ; CHECK-NEXT:    [[R:%.*]] = xor i8 [[A]], 7
1095 ; CHECK-NEXT:    ret i8 [[R]]
1096 ;
1097   %a = lshr i8 %x, 5
1098   call void @use(i8 %a)
1099   %r = xor i8 %a, 7
1100   ret i8 %r
1101 }
1102
1103 ; negative test
1104
1105 define i8 @not_lshr_wrong_const(i8 %x) {
1106 ; CHECK-LABEL: @not_lshr_wrong_const(
1107 ; CHECK-NEXT:    [[A:%.*]] = lshr i8 [[X:%.*]], 5
1108 ; CHECK-NEXT:    [[R:%.*]] = xor i8 [[A]], 3
1109 ; CHECK-NEXT:    ret i8 [[R]]
1110 ;
1111   %a = lshr i8 %x, 5
1112   %r = xor i8 %a, 3
1113   ret i8 %r
1114 }
1115
1116 define i8 @ashr_not(i8 %x) {
1117 ; CHECK-LABEL: @ashr_not(
1118 ; CHECK-NEXT:    [[N:%.*]] = ashr i8 [[X:%.*]], 5
1119 ; CHECK-NEXT:    [[R:%.*]] = xor i8 [[N]], -1
1120 ; CHECK-NEXT:    ret i8 [[R]]
1121 ;
1122   %n = xor i8 %x, -1
1123   %r = ashr i8 %n, 5
1124   ret i8 %r
1125 }
1126
1127 ; Unlike the logicial shifts, 'not' is canonicalized after ashr.
1128
1129 define i8 @not_ashr(i8 %x) {
1130 ; CHECK-LABEL: @not_ashr(
1131 ; CHECK-NEXT:    [[A:%.*]] = ashr i8 [[X:%.*]], 5
1132 ; CHECK-NEXT:    [[R:%.*]] = xor i8 [[A]], -1
1133 ; CHECK-NEXT:    ret i8 [[R]]
1134 ;
1135   %a = ashr i8 %x, 5
1136   %r = xor i8 %a, -1
1137   ret i8 %r
1138 }
1139
1140 define <2 x i8> @not_ashr_vec(<2 x i8> %x) {
1141 ; CHECK-LABEL: @not_ashr_vec(
1142 ; CHECK-NEXT:    [[A:%.*]] = ashr <2 x i8> [[X:%.*]], <i8 7, i8 7>
1143 ; CHECK-NEXT:    [[R:%.*]] = xor <2 x i8> [[A]], <i8 -1, i8 -1>
1144 ; CHECK-NEXT:    ret <2 x i8> [[R]]
1145 ;
1146   %a = ashr <2 x i8> %x, <i8 7, i8 7>
1147   %r = xor <2 x i8> %a, <i8 -1, i8 -1>
1148   ret <2 x i8> %r
1149 }
1150
1151 define i8 @not_ashr_extra_use(i8 %x) {
1152 ; CHECK-LABEL: @not_ashr_extra_use(
1153 ; CHECK-NEXT:    [[A:%.*]] = ashr i8 [[X:%.*]], 5
1154 ; CHECK-NEXT:    call void @use(i8 [[A]])
1155 ; CHECK-NEXT:    [[R:%.*]] = xor i8 [[A]], -1
1156 ; CHECK-NEXT:    ret i8 [[R]]
1157 ;
1158   %a = ashr i8 %x, 5
1159   call void @use(i8 %a)
1160   %r = xor i8 %a, -1
1161   ret i8 %r
1162 }
1163
1164 define i8 @not_ashr_wrong_const(i8 %x) {
1165 ; CHECK-LABEL: @not_ashr_wrong_const(
1166 ; CHECK-NEXT:    [[A:%.*]] = ashr i8 [[X:%.*]], 5
1167 ; CHECK-NEXT:    [[R:%.*]] = xor i8 [[A]], -2
1168 ; CHECK-NEXT:    ret i8 [[R]]
1169 ;
1170   %a = ashr i8 %x, 5
1171   %r = xor i8 %a, -2
1172   ret i8 %r
1173 }
1174
1175 ; (~A & B) ^ A --> A | B
1176
1177 define <2 x i32> @xor_andn_commute1(<2 x i32> %a, <2 x i32> %b) {
1178 ; CHECK-LABEL: @xor_andn_commute1(
1179 ; CHECK-NEXT:    [[Z:%.*]] = or <2 x i32> [[A:%.*]], [[B:%.*]]
1180 ; CHECK-NEXT:    ret <2 x i32> [[Z]]
1181 ;
1182   %nota = xor <2 x i32> %a, <i32 -1, i32 -1>
1183   %r = and <2 x i32> %nota, %b
1184   %z = xor <2 x i32> %r, %a
1185   ret <2 x i32> %z
1186 }
1187
1188 ; (B & ~A) ^ A --> A | B
1189
1190 define i33 @xor_andn_commute2(i33 %a, i33 %pb) {
1191 ; CHECK-LABEL: @xor_andn_commute2(
1192 ; CHECK-NEXT:    [[B:%.*]] = udiv i33 42, [[PB:%.*]]
1193 ; CHECK-NEXT:    [[Z:%.*]] = or i33 [[B]], [[A:%.*]]
1194 ; CHECK-NEXT:    ret i33 [[Z]]
1195 ;
1196   %b = udiv i33 42, %pb ; thwart complexity-based canonicalization
1197   %nota = xor i33 %a, -1
1198   %r = and i33 %b, %nota
1199   %z = xor i33 %r, %a
1200   ret i33 %z
1201 }
1202
1203 ; A ^ (~A & B) --> A | B
1204
1205 define i32 @xor_andn_commute3(i32 %pa, i32 %b) {
1206 ; CHECK-LABEL: @xor_andn_commute3(
1207 ; CHECK-NEXT:    [[A:%.*]] = udiv i32 42, [[PA:%.*]]
1208 ; CHECK-NEXT:    [[Z:%.*]] = or i32 [[A]], [[B:%.*]]
1209 ; CHECK-NEXT:    ret i32 [[Z]]
1210 ;
1211   %a = udiv i32 42, %pa ; thwart complexity-based canonicalization
1212   %nota = xor i32 %a, -1
1213   %r = and i32 %nota, %b
1214   %z = xor i32 %a, %r
1215   ret i32 %z
1216 }
1217
1218 ; A ^ (B & ~A) --> A | B
1219
1220 define i32 @xor_andn_commute4(i32 %pa, i32 %pb) {
1221 ; CHECK-LABEL: @xor_andn_commute4(
1222 ; CHECK-NEXT:    [[A:%.*]] = udiv i32 42, [[PA:%.*]]
1223 ; CHECK-NEXT:    [[B:%.*]] = udiv i32 42, [[PB:%.*]]
1224 ; CHECK-NEXT:    [[Z:%.*]] = or i32 [[A]], [[B]]
1225 ; CHECK-NEXT:    ret i32 [[Z]]
1226 ;
1227   %a = udiv i32 42, %pa ; thwart complexity-based canonicalization
1228   %b = udiv i32 42, %pb ; thwart complexity-based canonicalization
1229   %nota = xor i32 %a, -1
1230   %r = and i32 %b, %nota
1231   %z = xor i32 %a, %r
1232   ret i32 %z
1233 }