llvm/test/Transforms/InstCombine/icmp-or.ll

   1 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
   2 ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
   3
   4 declare void @use(i8)
   5
   6 define i1 @set_low_bit_mask_eq(i8 %x) {
   7 ; CHECK-LABEL: @set_low_bit_mask_eq(
   8 ; CHECK-NEXT:    [[TMP1:%.*]] = and i8 [[X:%.*]], -2
   9 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i8 [[TMP1]], 18
  10 ; CHECK-NEXT:    ret i1 [[CMP]]
  11 ;
  12   %sub = or i8 %x, 1
  13   %cmp = icmp eq i8 %sub, 19
  14   ret i1 %cmp
  15 }
  16
  17 define <2 x i1> @set_low_bit_mask_ne(<2 x i8> %x) {
  18 ; CHECK-LABEL: @set_low_bit_mask_ne(
  19 ; CHECK-NEXT:    [[TMP1:%.*]] = and <2 x i8> [[X:%.*]], splat (i8 -4)
  20 ; CHECK-NEXT:    [[CMP:%.*]] = icmp ne <2 x i8> [[TMP1]], splat (i8 16)
  21 ; CHECK-NEXT:    ret <2 x i1> [[CMP]]
  22 ;
  23   %sub = or <2 x i8> %x, <i8 3, i8 3>
  24   %cmp = icmp ne <2 x i8> %sub, <i8 19, i8 19>
  25   ret <2 x i1> %cmp
  26 }
  27
  28 define i1 @set_low_bit_mask_ugt(i8 %x) {
  29 ; CHECK-LABEL: @set_low_bit_mask_ugt(
  30 ; CHECK-NEXT:    [[CMP:%.*]] = icmp ugt i8 [[X:%.*]], 19
  31 ; CHECK-NEXT:    ret i1 [[CMP]]
  32 ;
  33   %sub = or i8 %x, 3
  34   %cmp = icmp ugt i8 %sub, 19
  35   ret i1 %cmp
  36 }
  37
  38 define i1 @set_low_bit_mask_ult(i8 %x) {
  39 ; CHECK-LABEL: @set_low_bit_mask_ult(
  40 ; CHECK-NEXT:    [[SUB:%.*]] = or i8 [[X:%.*]], 3
  41 ; CHECK-NEXT:    [[CMP:%.*]] = icmp ult i8 [[SUB]], 19
  42 ; CHECK-NEXT:    ret i1 [[CMP]]
  43 ;
  44   %sub = or i8 %x, 3
  45   %cmp = icmp ult i8 %sub, 19
  46   ret i1 %cmp
  47 }
  48
  49 define i1 @set_low_bit_mask_uge(i8 %x) {
  50 ; CHECK-LABEL: @set_low_bit_mask_uge(
  51 ; CHECK-NEXT:    [[CMP:%.*]] = icmp ugt i8 [[X:%.*]], 19
  52 ; CHECK-NEXT:    ret i1 [[CMP]]
  53 ;
  54   %sub = or i8 %x, 3
  55   %cmp = icmp uge i8 %sub, 20
  56   ret i1 %cmp
  57 }
  58
  59 define i1 @set_low_bit_mask_ule(i8 %x) {
  60 ; CHECK-LABEL: @set_low_bit_mask_ule(
  61 ; CHECK-NEXT:    [[SUB:%.*]] = or i8 [[X:%.*]], 3
  62 ; CHECK-NEXT:    [[CMP:%.*]] = icmp ult i8 [[SUB]], 19
  63 ; CHECK-NEXT:    ret i1 [[CMP]]
  64 ;
  65   %sub = or i8 %x, 3
  66   %cmp = icmp ule i8 %sub, 18
  67   ret i1 %cmp
  68 }
  69
  70 define i1 @set_low_bit_mask_sgt(i8 %x) {
  71 ; CHECK-LABEL: @set_low_bit_mask_sgt(
  72 ; CHECK-NEXT:    [[SUB:%.*]] = or i8 [[X:%.*]], 3
  73 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i8 [[SUB]], 20
  74 ; CHECK-NEXT:    ret i1 [[CMP]]
  75 ;
  76   %sub = or i8 %x, 3
  77   %cmp = icmp sgt i8 %sub, 20
  78   ret i1 %cmp
  79 }
  80
  81 define i1 @set_low_bit_mask_slt(i8 %x) {
  82 ; CHECK-LABEL: @set_low_bit_mask_slt(
  83 ; CHECK-NEXT:    [[SUB:%.*]] = or i8 [[X:%.*]], 15
  84 ; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i8 [[SUB]], 19
  85 ; CHECK-NEXT:    ret i1 [[CMP]]
  86 ;
  87   %sub = or i8 %x, 15
  88   %cmp = icmp slt i8 %sub, 19
  89   ret i1 %cmp
  90 }
  91
  92 define i1 @set_low_bit_mask_sge(i8 %x) {
  93 ; CHECK-LABEL: @set_low_bit_mask_sge(
  94 ; CHECK-NEXT:    [[SUB:%.*]] = or i8 [[X:%.*]], 31
  95 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i8 [[SUB]], 50
  96 ; CHECK-NEXT:    ret i1 [[CMP]]
  97 ;
  98   %sub = or i8 %x, 31
  99   %cmp = icmp sge i8 %sub, 51
 100   ret i1 %cmp
 101 }
 102
 103 define i1 @set_low_bit_mask_sle(i8 %x) {
 104 ; CHECK-LABEL: @set_low_bit_mask_sle(
 105 ; CHECK-NEXT:    [[SUB:%.*]] = or i8 [[X:%.*]], 63
 106 ; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i8 [[SUB]], 69
 107 ; CHECK-NEXT:    ret i1 [[CMP]]
 108 ;
 109   %sub = or i8 %x, 63
 110   %cmp = icmp sle i8 %sub, 68
 111   ret i1 %cmp
 112 }
 113
 114 define i1 @eq_const_mask(i8 %x, i8 %y) {
 115 ; CHECK-LABEL: @eq_const_mask(
 116 ; CHECK-NEXT:    [[TMP1:%.*]] = xor i8 [[X:%.*]], [[Y:%.*]]
 117 ; CHECK-NEXT:    [[TMP2:%.*]] = and i8 [[TMP1]], -43
 118 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i8 [[TMP2]], 0
 119 ; CHECK-NEXT:    ret i1 [[CMP]]
 120 ;
 121   %b0 = or i8 %x, 42
 122   %b1 = or i8 %y, 42
 123   %cmp = icmp eq i8 %b0, %b1
 124   ret i1 %cmp
 125 }
 126
 127 define <2 x i1> @ne_const_mask(<2 x i8> %x, <2 x i8> %y) {
 128 ; CHECK-LABEL: @ne_const_mask(
 129 ; CHECK-NEXT:    [[TMP1:%.*]] = xor <2 x i8> [[X:%.*]], [[Y:%.*]]
 130 ; CHECK-NEXT:    [[TMP2:%.*]] = and <2 x i8> [[TMP1]], <i8 105, i8 -6>
 131 ; CHECK-NEXT:    [[CMP:%.*]] = icmp ne <2 x i8> [[TMP2]], zeroinitializer
 132 ; CHECK-NEXT:    ret <2 x i1> [[CMP]]
 133 ;
 134   %b0 = or <2 x i8> %x, <i8 150, i8 5>
 135   %b1 = or <2 x i8> %y, <i8 150, i8 5>
 136   %cmp = icmp ne <2 x i8> %b0, %b1
 137   ret <2 x i1> %cmp
 138 }
 139
 140 ; negative test - predicate
 141
 142 define i1 @eq_const_mask_not_equality(i8 %x, i8 %y) {
 143 ; CHECK-LABEL: @eq_const_mask_not_equality(
 144 ; CHECK-NEXT:    [[B0:%.*]] = or i8 [[X:%.*]], 5
 145 ; CHECK-NEXT:    [[B1:%.*]] = or i8 [[Y:%.*]], 5
 146 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i8 [[B0]], [[B1]]
 147 ; CHECK-NEXT:    ret i1 [[CMP]]
 148 ;
 149   %b0 = or i8 %x, 5
 150   %b1 = or i8 %y, 5
 151   %cmp = icmp sgt i8 %b0, %b1
 152   ret i1 %cmp
 153 }
 154
 155 ; negative test - mismatched constants
 156
 157 define i1 @eq_const_mask_not_same(i8 %x, i8 %y) {
 158 ; CHECK-LABEL: @eq_const_mask_not_same(
 159 ; CHECK-NEXT:    [[B0:%.*]] = or i8 [[X:%.*]], 5
 160 ; CHECK-NEXT:    [[B1:%.*]] = or i8 [[Y:%.*]], 6
 161 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i8 [[B0]], [[B1]]
 162 ; CHECK-NEXT:    ret i1 [[CMP]]
 163 ;
 164   %b0 = or i8 %x, 5
 165   %b1 = or i8 %y, 6
 166   %cmp = icmp eq i8 %b0, %b1
 167   ret i1 %cmp
 168 }
 169
 170 ; negative test - mismatched logic
 171
 172 define i1 @eq_const_mask_wrong_opcode(i8 %x, i8 %y) {
 173 ; CHECK-LABEL: @eq_const_mask_wrong_opcode(
 174 ; CHECK-NEXT:    [[B0:%.*]] = or i8 [[X:%.*]], 5
 175 ; CHECK-NEXT:    [[TMP1:%.*]] = xor i8 [[Y:%.*]], [[B0]]
 176 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i8 [[TMP1]], 5
 177 ; CHECK-NEXT:    ret i1 [[CMP]]
 178 ;
 179   %b0 = or i8 %x, 5
 180   %b1 = xor i8 %y, 5
 181   %cmp = icmp eq i8 %b0, %b1
 182   ret i1 %cmp
 183 }
 184
 185 ; negative test - no extra uses
 186
 187 define i1 @eq_const_mask_use1(i8 %x, i8 %y) {
 188 ; CHECK-LABEL: @eq_const_mask_use1(
 189 ; CHECK-NEXT:    [[B0:%.*]] = or i8 [[X:%.*]], 5
 190 ; CHECK-NEXT:    call void @use(i8 [[B0]])
 191 ; CHECK-NEXT:    [[B1:%.*]] = or i8 [[Y:%.*]], 5
 192 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i8 [[B0]], [[B1]]
 193 ; CHECK-NEXT:    ret i1 [[CMP]]
 194 ;
 195   %b0 = or i8 %x, 5
 196   call void @use(i8 %b0)
 197   %b1 = or i8 %y, 5
 198   %cmp = icmp eq i8 %b0, %b1
 199   ret i1 %cmp
 200 }
 201
 202 ; negative test - no extra uses
 203
 204 define i1 @eq_const_mask_use2(i8 %x, i8 %y) {
 205 ; CHECK-LABEL: @eq_const_mask_use2(
 206 ; CHECK-NEXT:    [[B0:%.*]] = or i8 [[X:%.*]], 5
 207 ; CHECK-NEXT:    [[B1:%.*]] = or i8 [[Y:%.*]], 5
 208 ; CHECK-NEXT:    call void @use(i8 [[B1]])
 209 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i8 [[B0]], [[B1]]
 210 ; CHECK-NEXT:    ret i1 [[CMP]]
 211 ;
 212   %b0 = or i8 %x, 5
 213   %b1 = or i8 %y, 5
 214   call void @use(i8 %b1)
 215   %cmp = icmp eq i8 %b0, %b1
 216   ret i1 %cmp
 217 }
 218
 219 ; (x | (x - 1)) s< 0
 220
 221 define <2 x i1> @decrement_slt_0(<2 x i8> %x) {
 222 ; CHECK-LABEL: @decrement_slt_0(
 223 ; CHECK-NEXT:    [[R:%.*]] = icmp slt <2 x i8> [[X:%.*]], splat (i8 1)
 224 ; CHECK-NEXT:    ret <2 x i1> [[R]]
 225 ;
 226   %dec = add <2 x i8> %x, <i8 -1, i8 -1>
 227   %or = or <2 x i8> %dec, %x
 228   %r = icmp slt <2 x i8> %or, zeroinitializer
 229   ret <2 x i1> %r
 230 }
 231
 232 define i1 @decrement_slt_0_commute_use1(i8 %px) {
 233 ; CHECK-LABEL: @decrement_slt_0_commute_use1(
 234 ; CHECK-NEXT:    [[X:%.*]] = mul i8 [[PX:%.*]], 42
 235 ; CHECK-NEXT:    [[DEC:%.*]] = add i8 [[X]], -1
 236 ; CHECK-NEXT:    call void @use(i8 [[DEC]])
 237 ; CHECK-NEXT:    [[R:%.*]] = icmp slt i8 [[X]], 1
 238 ; CHECK-NEXT:    ret i1 [[R]]
 239 ;
 240   %x = mul i8 %px, 42 ; thwart complexity-based canonicalization
 241   %dec = add i8 %x, -1
 242   call void @use(i8 %dec)
 243   %or = or i8 %x, %dec
 244   %r = icmp slt i8 %or, 0
 245   ret i1 %r
 246 }
 247
 248 define i1 @decrement_slt_0_use2(i8 %x) {
 249 ; CHECK-LABEL: @decrement_slt_0_use2(
 250 ; CHECK-NEXT:    [[DEC:%.*]] = add i8 [[X:%.*]], -1
 251 ; CHECK-NEXT:    [[OR:%.*]] = or i8 [[DEC]], [[X]]
 252 ; CHECK-NEXT:    call void @use(i8 [[OR]])
 253 ; CHECK-NEXT:    [[R:%.*]] = icmp slt i8 [[X]], 1
 254 ; CHECK-NEXT:    ret i1 [[R]]
 255 ;
 256   %dec = add i8 %x, -1
 257   %or = or i8 %dec, %x
 258   call void @use(i8 %or)
 259   %r = icmp slt i8 %or, 0
 260   ret i1 %r
 261 }
 262
 263 ; negative test - wrong cmp constant
 264
 265 define i1 @decrement_slt_n1(i8 %x) {
 266 ; CHECK-LABEL: @decrement_slt_n1(
 267 ; CHECK-NEXT:    [[DEC:%.*]] = add i8 [[X:%.*]], -1
 268 ; CHECK-NEXT:    [[OR:%.*]] = or i8 [[DEC]], [[X]]
 269 ; CHECK-NEXT:    [[R:%.*]] = icmp slt i8 [[OR]], -1
 270 ; CHECK-NEXT:    ret i1 [[R]]
 271 ;
 272   %dec = add i8 %x, -1
 273   %or = or i8 %dec, %x
 274   %r = icmp slt i8 %or, -1
 275   ret i1 %r
 276 }
 277
 278 ; negative test - wrong add constant
 279
 280 define i1 @not_decrement_slt_0(i8 %x) {
 281 ; CHECK-LABEL: @not_decrement_slt_0(
 282 ; CHECK-NEXT:    [[DEC:%.*]] = add i8 [[X:%.*]], -2
 283 ; CHECK-NEXT:    [[OR:%.*]] = or i8 [[DEC]], [[X]]
 284 ; CHECK-NEXT:    [[R:%.*]] = icmp slt i8 [[OR]], 0
 285 ; CHECK-NEXT:    ret i1 [[R]]
 286 ;
 287   %dec = add i8 %x, -2
 288   %or = or i8 %dec, %x
 289   %r = icmp slt i8 %or, 0
 290   ret i1 %r
 291 }
 292
 293 ; (x | (x - 1)) s> -1
 294
 295 define <2 x i1> @decrement_sgt_n1(<2 x i8> %x) {
 296 ; CHECK-LABEL: @decrement_sgt_n1(
 297 ; CHECK-NEXT:    [[R:%.*]] = icmp sgt <2 x i8> [[X:%.*]], zeroinitializer
 298 ; CHECK-NEXT:    ret <2 x i1> [[R]]
 299 ;
 300   %dec = add <2 x i8> %x, <i8 -1, i8 -1>
 301   %or = or <2 x i8> %dec, %x
 302   %r = icmp sgt <2 x i8> %or, <i8 -1, i8 -1>
 303   ret <2 x i1> %r
 304 }
 305
 306 define i1 @decrement_sgt_n1_commute_use1(i8 %px) {
 307 ; CHECK-LABEL: @decrement_sgt_n1_commute_use1(
 308 ; CHECK-NEXT:    [[X:%.*]] = mul i8 [[PX:%.*]], 42
 309 ; CHECK-NEXT:    [[DEC:%.*]] = add i8 [[X]], -1
 310 ; CHECK-NEXT:    call void @use(i8 [[DEC]])
 311 ; CHECK-NEXT:    [[R:%.*]] = icmp sgt i8 [[X]], 0
 312 ; CHECK-NEXT:    ret i1 [[R]]
 313 ;
 314   %x = mul i8 %px, 42 ; thwart complexity-based canonicalization
 315   %dec = add i8 %x, -1
 316   call void @use(i8 %dec)
 317   %or = or i8 %x, %dec
 318   %r = icmp sgt i8 %or, -1
 319   ret i1 %r
 320 }
 321
 322 define i1 @decrement_sgt_n1_use2(i8 %x) {
 323 ; CHECK-LABEL: @decrement_sgt_n1_use2(
 324 ; CHECK-NEXT:    [[DEC:%.*]] = add i8 [[X:%.*]], -1
 325 ; CHECK-NEXT:    [[OR:%.*]] = or i8 [[DEC]], [[X]]
 326 ; CHECK-NEXT:    call void @use(i8 [[OR]])
 327 ; CHECK-NEXT:    [[R:%.*]] = icmp sgt i8 [[X]], 0
 328 ; CHECK-NEXT:    ret i1 [[R]]
 329 ;
 330   %dec = add i8 %x, -1
 331   %or = or i8 %dec, %x
 332   call void @use(i8 %or)
 333   %r = icmp sgt i8 %or, -1
 334   ret i1 %r
 335 }
 336
 337 ; negative test - wrong cmp constant
 338
 339 define i1 @decrement_sgt_0(i8 %x) {
 340 ; CHECK-LABEL: @decrement_sgt_0(
 341 ; CHECK-NEXT:    [[DEC:%.*]] = add i8 [[X:%.*]], -1
 342 ; CHECK-NEXT:    [[OR:%.*]] = or i8 [[DEC]], [[X]]
 343 ; CHECK-NEXT:    [[R:%.*]] = icmp sgt i8 [[OR]], 0
 344 ; CHECK-NEXT:    ret i1 [[R]]
 345 ;
 346   %dec = add i8 %x, -1
 347   %or = or i8 %dec, %x
 348   %r = icmp sgt i8 %or, 0
 349   ret i1 %r
 350 }
 351
 352 ; negative test - wrong add constant
 353
 354 define i1 @not_decrement_sgt_n1(i8 %x) {
 355 ; CHECK-LABEL: @not_decrement_sgt_n1(
 356 ; CHECK-NEXT:    [[DEC:%.*]] = add i8 [[X:%.*]], -2
 357 ; CHECK-NEXT:    [[OR:%.*]] = or i8 [[DEC]], [[X]]
 358 ; CHECK-NEXT:    [[R:%.*]] = icmp sgt i8 [[OR]], -1
 359 ; CHECK-NEXT:    ret i1 [[R]]
 360 ;
 361   %dec = add i8 %x, -2
 362   %or = or i8 %dec, %x
 363   %r = icmp sgt i8 %or, -1
 364   ret i1 %r
 365 }
 366
 367 define i1 @icmp_or_xor_2_eq(i64 %x1, i64 %y1, i64 %x2, i64 %y2) {
 368 ; CHECK-LABEL: @icmp_or_xor_2_eq(
 369 ; CHECK-NEXT:    [[TMP1:%.*]] = icmp eq i64 [[X1:%.*]], [[Y1:%.*]]
 370 ; CHECK-NEXT:    [[TMP2:%.*]] = icmp eq i64 [[X2:%.*]], [[Y2:%.*]]
 371 ; CHECK-NEXT:    [[CMP:%.*]] = and i1 [[TMP1]], [[TMP2]]
 372 ; CHECK-NEXT:    ret i1 [[CMP]]
 373 ;
 374   %xor = xor i64 %x1, %y1
 375   %xor1 = xor i64 %x2, %y2
 376   %or = or i64 %xor, %xor1
 377   %cmp = icmp eq i64 %or, 0
 378   ret i1 %cmp
 379 }
 380
 381 define i1 @icmp_or_xor_2_ne(i64 %x1, i64 %y1, i64 %x2, i64 %y2) {
 382 ; CHECK-LABEL: @icmp_or_xor_2_ne(
 383 ; CHECK-NEXT:    [[TMP1:%.*]] = icmp ne i64 [[X1:%.*]], [[Y1:%.*]]
 384 ; CHECK-NEXT:    [[TMP2:%.*]] = icmp ne i64 [[X2:%.*]], [[Y2:%.*]]
 385 ; CHECK-NEXT:    [[CMP:%.*]] = or i1 [[TMP1]], [[TMP2]]
 386 ; CHECK-NEXT:    ret i1 [[CMP]]
 387 ;
 388   %xor = xor i64 %x1, %y1
 389   %xor1 = xor i64 %x2, %y2
 390   %or = or i64 %xor, %xor1
 391   %cmp = icmp ne i64 %or, 0
 392   ret i1 %cmp
 393 }
 394
 395 ; negative test - wrong cmp constant
 396
 397 define i1 @icmp_or_xor_2_eq_fail(i64 %x1, i64 %y1, i64 %x2, i64 %y2) {
 398 ; CHECK-LABEL: @icmp_or_xor_2_eq_fail(
 399 ; CHECK-NEXT:    [[XOR:%.*]] = xor i64 [[X1:%.*]], [[Y1:%.*]]
 400 ; CHECK-NEXT:    [[XOR1:%.*]] = xor i64 [[X2:%.*]], [[Y2:%.*]]
 401 ; CHECK-NEXT:    [[OR:%.*]] = or i64 [[XOR]], [[XOR1]]
 402 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i64 [[OR]], 1
 403 ; CHECK-NEXT:    ret i1 [[CMP]]
 404 ;
 405   %xor = xor i64 %x1, %y1
 406   %xor1 = xor i64 %x2, %y2
 407   %or = or i64 %xor, %xor1
 408   %cmp = icmp eq i64 %or, 1
 409   ret i1 %cmp
 410 }
 411
 412 ; negative test - wrong cmp constant
 413
 414 define i1 @icmp_or_xor_2_ne_fail(i64 %x1, i64 %y1, i64 %x2, i64 %y2) {
 415 ; CHECK-LABEL: @icmp_or_xor_2_ne_fail(
 416 ; CHECK-NEXT:    [[XOR:%.*]] = xor i64 [[X1:%.*]], [[Y1:%.*]]
 417 ; CHECK-NEXT:    [[XOR1:%.*]] = xor i64 [[X2:%.*]], [[Y2:%.*]]
 418 ; CHECK-NEXT:    [[OR:%.*]] = or i64 [[XOR]], [[XOR1]]
 419 ; CHECK-NEXT:    [[CMP:%.*]] = icmp ne i64 [[OR]], 1
 420 ; CHECK-NEXT:    ret i1 [[CMP]]
 421 ;
 422   %xor = xor i64 %x1, %y1
 423   %xor1 = xor i64 %x2, %y2
 424   %or = or i64 %xor, %xor1
 425   %cmp = icmp ne i64 %or, 1
 426   ret i1 %cmp
 427 }
 428
 429 ; negative test - xor multiuse
 430
 431 ; NB: This requires more than 1 iteration to simplify. After we
 432 ; simplify `%cmp_1 = icmp eq i64 %xor, 0`, `%xor = xor i64 %x1, %y1`
 433 ; has one use which allows for complete simplification (rooted on
 434 ; `%or1 = or i1 %cmp, %cmp_1` so we don't end up adding it back).
 435 define i1 @icmp_or_xor_2_3_fail(i64 %x1, i64 %y1, i64 %x2, i64 %y2) "instcombine-no-verify-fixpoint" {
 436 ; CHECK-LABEL: @icmp_or_xor_2_3_fail(
 437 ; CHECK-NEXT:    [[XOR:%.*]] = xor i64 [[X1:%.*]], [[Y1:%.*]]
 438 ; CHECK-NEXT:    [[XOR1:%.*]] = xor i64 [[X2:%.*]], [[Y2:%.*]]
 439 ; CHECK-NEXT:    [[OR:%.*]] = or i64 [[XOR]], [[XOR1]]
 440 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i64 [[OR]], 0
 441 ; CHECK-NEXT:    [[CMP_1:%.*]] = icmp eq i64 [[X1]], [[Y1]]
 442 ; CHECK-NEXT:    [[OR1:%.*]] = or i1 [[CMP]], [[CMP_1]]
 443 ; CHECK-NEXT:    ret i1 [[OR1]]
 444 ;
 445   %xor = xor i64 %x1, %y1
 446   %xor1 = xor i64 %x2, %y2
 447   %or = or i64 %xor, %xor1
 448   %cmp = icmp eq i64 %or, 0
 449   %cmp_1 = icmp eq i64 %xor, 0
 450   %or1 = or i1 %cmp, %cmp_1
 451   ret i1 %or1
 452 }
 453
 454 ; negative test - xor multiuse
 455
 456 define i1 @icmp_or_xor_2_4_fail(i64 %x1, i64 %y1, i64 %x2, i64 %y2) "instcombine-no-verify-fixpoint" {
 457 ; CHECK-LABEL: @icmp_or_xor_2_4_fail(
 458 ; CHECK-NEXT:    [[XOR:%.*]] = xor i64 [[X1:%.*]], [[Y1:%.*]]
 459 ; CHECK-NEXT:    [[XOR1:%.*]] = xor i64 [[X2:%.*]], [[Y2:%.*]]
 460 ; CHECK-NEXT:    [[OR:%.*]] = or i64 [[XOR]], [[XOR1]]
 461 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i64 [[OR]], 0
 462 ; CHECK-NEXT:    [[CMP_1:%.*]] = icmp eq i64 [[X2]], [[Y2]]
 463 ; CHECK-NEXT:    [[OR1:%.*]] = or i1 [[CMP]], [[CMP_1]]
 464 ; CHECK-NEXT:    ret i1 [[OR1]]
 465 ;
 466   %xor = xor i64 %x1, %y1
 467   %xor1 = xor i64 %x2, %y2
 468   %or = or i64 %xor, %xor1
 469   %cmp = icmp eq i64 %or, 0
 470   %cmp_1 = icmp eq i64 %xor1, 0
 471   %or1 = or i1 %cmp, %cmp_1
 472   ret i1 %or1
 473 }
 474
 475 define i1 @icmp_or_xor_3_1(i64 %x1, i64 %y1, i64 %x2, i64 %y2, i64 %x3, i64 %y3) {
 476 ; CHECK-LABEL: @icmp_or_xor_3_1(
 477 ; CHECK-NEXT:    [[TMP1:%.*]] = icmp eq i64 [[X1:%.*]], [[Y1:%.*]]
 478 ; CHECK-NEXT:    [[TMP2:%.*]] = icmp eq i64 [[X2:%.*]], [[Y2:%.*]]
 479 ; CHECK-NEXT:    [[TMP3:%.*]] = and i1 [[TMP1]], [[TMP2]]
 480 ; CHECK-NEXT:    [[TMP4:%.*]] = icmp eq i64 [[X3:%.*]], [[Y3:%.*]]
 481 ; CHECK-NEXT:    [[CMP:%.*]] = and i1 [[TMP3]], [[TMP4]]
 482 ; CHECK-NEXT:    ret i1 [[CMP]]
 483 ;
 484   %xor = xor i64 %x1, %y1
 485   %xor1 = xor i64 %x2, %y2
 486   %or = or i64 %xor, %xor1
 487   %xor2 = xor i64 %x3, %y3
 488   %or1 = or i64 %or, %xor2
 489   %cmp = icmp eq i64 %or1, 0
 490   ret i1 %cmp
 491 }
 492
 493 ; negative test - and instead of or
 494
 495 define i1 @icmp_or_xor_3_2_fail(i64 %x1, i64 %y1, i64 %x2, i64 %y2, i64 %x3, i64 %y3) {
 496 ; CHECK-LABEL: @icmp_or_xor_3_2_fail(
 497 ; CHECK-NEXT:    [[XOR:%.*]] = xor i64 [[X1:%.*]], [[Y1:%.*]]
 498 ; CHECK-NEXT:    [[XOR1:%.*]] = xor i64 [[X2:%.*]], [[Y2:%.*]]
 499 ; CHECK-NEXT:    [[AND:%.*]] = and i64 [[XOR]], [[XOR1]]
 500 ; CHECK-NEXT:    [[XOR2:%.*]] = xor i64 [[X3:%.*]], [[Y3:%.*]]
 501 ; CHECK-NEXT:    [[OR1:%.*]] = or i64 [[AND]], [[XOR2]]
 502 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i64 [[OR1]], 0
 503 ; CHECK-NEXT:    ret i1 [[CMP]]
 504 ;
 505   %xor = xor i64 %x1, %y1
 506   %xor1 = xor i64 %x2, %y2
 507   %and = and i64 %xor, %xor1
 508   %xor2 = xor i64 %x3, %y3
 509   %or1 = or i64 %and, %xor2
 510   %cmp = icmp eq i64 %or1, 0
 511   ret i1 %cmp
 512 }
 513
 514 define i1 @icmp_or_xor_3_3(i64 %x1, i64 %y1, i64 %x2, i64 %y2, i64 %x3, i64 %y3) {
 515 ; CHECK-LABEL: @icmp_or_xor_3_3(
 516 ; CHECK-NEXT:    [[TMP1:%.*]] = icmp eq i64 [[X1:%.*]], [[Y1:%.*]]
 517 ; CHECK-NEXT:    [[TMP2:%.*]] = icmp eq i64 [[X2:%.*]], [[Y2:%.*]]
 518 ; CHECK-NEXT:    [[TMP3:%.*]] = and i1 [[TMP1]], [[TMP2]]
 519 ; CHECK-NEXT:    [[TMP4:%.*]] = icmp eq i64 [[X3:%.*]], [[Y3:%.*]]
 520 ; CHECK-NEXT:    [[CMP:%.*]] = and i1 [[TMP3]], [[TMP4]]
 521 ; CHECK-NEXT:    ret i1 [[CMP]]
 522 ;
 523   %xor = xor i64 %x1, %y1
 524   %xor1 = xor i64 %x2, %y2
 525   %or = or i64 %xor, %xor1
 526   %xor2 = xor i64 %x3, %y3
 527   %or1 = or i64 %xor2, %or
 528   %cmp = icmp eq i64 %or1, 0
 529   ret i1 %cmp
 530 }
 531
 532 ; negative test - and instead of or
 533
 534 define i1 @icmp_or_xor_3_4_fail(i64 %x1, i64 %y1, i64 %x2, i64 %y2, i64 %x3, i64 %y3) {
 535 ; CHECK-LABEL: @icmp_or_xor_3_4_fail(
 536 ; CHECK-NEXT:    [[XOR:%.*]] = xor i64 [[X1:%.*]], [[Y1:%.*]]
 537 ; CHECK-NEXT:    [[XOR1:%.*]] = xor i64 [[X2:%.*]], [[Y2:%.*]]
 538 ; CHECK-NEXT:    [[AND:%.*]] = and i64 [[XOR]], [[XOR1]]
 539 ; CHECK-NEXT:    [[XOR2:%.*]] = xor i64 [[X3:%.*]], [[Y3:%.*]]
 540 ; CHECK-NEXT:    [[OR1:%.*]] = or i64 [[XOR2]], [[AND]]
 541 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i64 [[OR1]], 0
 542 ; CHECK-NEXT:    ret i1 [[CMP]]
 543 ;
 544   %xor = xor i64 %x1, %y1
 545   %xor1 = xor i64 %x2, %y2
 546   %and = and i64 %xor, %xor1
 547   %xor2 = xor i64 %x3, %y3
 548   %or1 = or i64 %xor2, %and
 549   %cmp = icmp eq i64 %or1, 0
 550   ret i1 %cmp
 551 }
 552
 553 define i1 @icmp_or_xor_4_1(i64 %x1, i64 %y1, i64 %x2, i64 %y2, i64 %x3, i64 %y3, i64 %x4, i64 %y4) {
 554 ; CHECK-LABEL: @icmp_or_xor_4_1(
 555 ; CHECK-NEXT:    [[TMP1:%.*]] = icmp eq i64 [[X3:%.*]], [[Y3:%.*]]
 556 ; CHECK-NEXT:    [[TMP2:%.*]] = icmp eq i64 [[X4:%.*]], [[Y4:%.*]]
 557 ; CHECK-NEXT:    [[TMP3:%.*]] = and i1 [[TMP1]], [[TMP2]]
 558 ; CHECK-NEXT:    [[TMP4:%.*]] = icmp eq i64 [[X1:%.*]], [[Y1:%.*]]
 559 ; CHECK-NEXT:    [[TMP5:%.*]] = and i1 [[TMP3]], [[TMP4]]
 560 ; CHECK-NEXT:    [[TMP6:%.*]] = icmp eq i64 [[X2:%.*]], [[Y2:%.*]]
 561 ; CHECK-NEXT:    [[CMP:%.*]] = and i1 [[TMP5]], [[TMP6]]
 562 ; CHECK-NEXT:    ret i1 [[CMP]]
 563 ;
 564   %xor = xor i64 %x1, %y1
 565   %xor1 = xor i64 %x2, %y2
 566   %or = or i64 %xor, %xor1
 567   %xor2 = xor i64 %x3, %y3
 568   %xor3 = xor i64 %x4, %y4
 569   %or1 = or i64 %xor2, %xor3
 570   %or2 = or i64 %or, %or1
 571   %cmp = icmp eq i64 %or2, 0
 572   ret i1 %cmp
 573 }
 574
 575 define i1 @icmp_or_xor_4_2(i64 %x1, i64 %y1, i64 %x2, i64 %y2, i64 %x3, i64 %y3, i64 %x4, i64 %y4) {
 576 ; CHECK-LABEL: @icmp_or_xor_4_2(
 577 ; CHECK-NEXT:    [[TMP1:%.*]] = icmp eq i64 [[X1:%.*]], [[Y1:%.*]]
 578 ; CHECK-NEXT:    [[TMP2:%.*]] = icmp eq i64 [[X2:%.*]], [[Y2:%.*]]
 579 ; CHECK-NEXT:    [[TMP3:%.*]] = and i1 [[TMP1]], [[TMP2]]
 580 ; CHECK-NEXT:    [[TMP4:%.*]] = icmp eq i64 [[X3:%.*]], [[Y3:%.*]]
 581 ; CHECK-NEXT:    [[TMP5:%.*]] = and i1 [[TMP3]], [[TMP4]]
 582 ; CHECK-NEXT:    [[TMP6:%.*]] = icmp eq i64 [[X4:%.*]], [[Y4:%.*]]
 583 ; CHECK-NEXT:    [[CMP:%.*]] = and i1 [[TMP5]], [[TMP6]]
 584 ; CHECK-NEXT:    ret i1 [[CMP]]
 585 ;
 586   %xor = xor i64 %x1, %y1
 587   %xor1 = xor i64 %x2, %y2
 588   %or = or i64 %xor, %xor1
 589   %xor2 = xor i64 %x3, %y3
 590   %xor3 = xor i64 %x4, %y4
 591   %or1 = or i64 %xor2, %xor3
 592   %or2 = or i64 %or1, %or
 593   %cmp = icmp eq i64 %or2, 0
 594   ret i1 %cmp
 595 }
 596
 597 define i1 @icmp_or_sub_2_eq(i64 %x1, i64 %y1, i64 %x2, i64 %y2) {
 598 ; CHECK-LABEL: @icmp_or_sub_2_eq(
 599 ; CHECK-NEXT:    [[TMP1:%.*]] = icmp eq i64 [[X1:%.*]], [[Y1:%.*]]
 600 ; CHECK-NEXT:    [[TMP2:%.*]] = icmp eq i64 [[X2:%.*]], [[Y2:%.*]]
 601 ; CHECK-NEXT:    [[CMP:%.*]] = and i1 [[TMP1]], [[TMP2]]
 602 ; CHECK-NEXT:    ret i1 [[CMP]]
 603 ;
 604   %sub = sub i64 %x1, %y1
 605   %sub1 = sub i64 %x2, %y2
 606   %or = or i64 %sub, %sub1
 607   %cmp = icmp eq i64 %or, 0
 608   ret i1 %cmp
 609 }
 610
 611 define i1 @icmp_or_sub_2_ne(i64 %x1, i64 %y1, i64 %x2, i64 %y2) {
 612 ; CHECK-LABEL: @icmp_or_sub_2_ne(
 613 ; CHECK-NEXT:    [[TMP1:%.*]] = icmp ne i64 [[X1:%.*]], [[Y1:%.*]]
 614 ; CHECK-NEXT:    [[TMP2:%.*]] = icmp ne i64 [[X2:%.*]], [[Y2:%.*]]
 615 ; CHECK-NEXT:    [[CMP:%.*]] = or i1 [[TMP1]], [[TMP2]]
 616 ; CHECK-NEXT:    ret i1 [[CMP]]
 617 ;
 618   %sub = sub i64 %x1, %y1
 619   %sub1 = sub i64 %x2, %y2
 620   %or = or i64 %sub, %sub1
 621   %cmp = icmp ne i64 %or, 0
 622   ret i1 %cmp
 623 }
 624
 625 ; negative test - wrong cmp constant
 626
 627 define i1 @icmp_or_sub_2_eq_fail(i64 %x1, i64 %y1, i64 %x2, i64 %y2) {
 628 ; CHECK-LABEL: @icmp_or_sub_2_eq_fail(
 629 ; CHECK-NEXT:    [[SUB:%.*]] = sub i64 [[X1:%.*]], [[Y1:%.*]]
 630 ; CHECK-NEXT:    [[SUB1:%.*]] = sub i64 [[X2:%.*]], [[Y2:%.*]]
 631 ; CHECK-NEXT:    [[OR:%.*]] = or i64 [[SUB]], [[SUB1]]
 632 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i64 [[OR]], 1
 633 ; CHECK-NEXT:    ret i1 [[CMP]]
 634 ;
 635   %sub = sub i64 %x1, %y1
 636   %sub1 = sub i64 %x2, %y2
 637   %or = or i64 %sub, %sub1
 638   %cmp = icmp eq i64 %or, 1
 639   ret i1 %cmp
 640 }
 641
 642 ; negative test - wrong cmp constant
 643
 644 define i1 @icmp_or_sub_2_ne_fail(i64 %x1, i64 %y1, i64 %x2, i64 %y2) {
 645 ; CHECK-LABEL: @icmp_or_sub_2_ne_fail(
 646 ; CHECK-NEXT:    [[SUB:%.*]] = sub i64 [[X1:%.*]], [[Y1:%.*]]
 647 ; CHECK-NEXT:    [[SUB1:%.*]] = sub i64 [[X2:%.*]], [[Y2:%.*]]
 648 ; CHECK-NEXT:    [[OR:%.*]] = or i64 [[SUB]], [[SUB1]]
 649 ; CHECK-NEXT:    [[CMP:%.*]] = icmp ne i64 [[OR]], 1
 650 ; CHECK-NEXT:    ret i1 [[CMP]]
 651 ;
 652   %sub = sub i64 %x1, %y1
 653   %sub1 = sub i64 %x2, %y2
 654   %or = or i64 %sub, %sub1
 655   %cmp = icmp ne i64 %or, 1
 656   ret i1 %cmp
 657 }
 658
 659 ; negative test - sub multiuse
 660
 661 define i1 @icmp_or_sub_2_3_fail(i64 %x1, i64 %y1, i64 %x2, i64 %y2) {
 662 ; CHECK-LABEL: @icmp_or_sub_2_3_fail(
 663 ; CHECK-NEXT:    [[SUB:%.*]] = sub i64 [[X1:%.*]], [[Y1:%.*]]
 664 ; CHECK-NEXT:    [[SUB1:%.*]] = sub i64 [[X2:%.*]], [[Y2:%.*]]
 665 ; CHECK-NEXT:    [[OR:%.*]] = or i64 [[SUB]], [[SUB1]]
 666 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i64 [[OR]], 0
 667 ; CHECK-NEXT:    [[CMP_1:%.*]] = icmp eq i64 [[SUB]], 1
 668 ; CHECK-NEXT:    [[OR1:%.*]] = or i1 [[CMP]], [[CMP_1]]
 669 ; CHECK-NEXT:    ret i1 [[OR1]]
 670 ;
 671   %sub = sub i64 %x1, %y1
 672   %sub1 = sub i64 %x2, %y2
 673   %or = or i64 %sub, %sub1
 674   %cmp = icmp eq i64 %or, 0
 675   %cmp_1 = icmp eq i64 %sub, 1
 676   %or1 = or i1 %cmp, %cmp_1
 677   ret i1 %or1
 678 }
 679
 680 ; negative test - sub multiuse
 681
 682 define i1 @icmp_or_sub_2_4_fail(i64 %x1, i64 %y1, i64 %x2, i64 %y2) {
 683 ; CHECK-LABEL: @icmp_or_sub_2_4_fail(
 684 ; CHECK-NEXT:    [[SUB:%.*]] = sub i64 [[X1:%.*]], [[Y1:%.*]]
 685 ; CHECK-NEXT:    [[SUB1:%.*]] = sub i64 [[X2:%.*]], [[Y2:%.*]]
 686 ; CHECK-NEXT:    [[OR:%.*]] = or i64 [[SUB]], [[SUB1]]
 687 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i64 [[OR]], 0
 688 ; CHECK-NEXT:    [[CMP_1:%.*]] = icmp eq i64 [[SUB1]], 1
 689 ; CHECK-NEXT:    [[OR1:%.*]] = or i1 [[CMP]], [[CMP_1]]
 690 ; CHECK-NEXT:    ret i1 [[OR1]]
 691 ;
 692   %sub = sub i64 %x1, %y1
 693   %sub1 = sub i64 %x2, %y2
 694   %or = or i64 %sub, %sub1
 695   %cmp = icmp eq i64 %or, 0
 696   %cmp_1 = icmp eq i64 %sub1, 1
 697   %or1 = or i1 %cmp, %cmp_1
 698   ret i1 %or1
 699 }
 700
 701 define i1 @icmp_or_sub_3_1(i64 %x1, i64 %y1, i64 %x2, i64 %y2, i64 %x3, i64 %y3) {
 702 ; CHECK-LABEL: @icmp_or_sub_3_1(
 703 ; CHECK-NEXT:    [[TMP1:%.*]] = icmp eq i64 [[X1:%.*]], [[Y1:%.*]]
 704 ; CHECK-NEXT:    [[TMP2:%.*]] = icmp eq i64 [[X2:%.*]], [[Y2:%.*]]
 705 ; CHECK-NEXT:    [[TMP3:%.*]] = and i1 [[TMP1]], [[TMP2]]
 706 ; CHECK-NEXT:    [[TMP4:%.*]] = icmp eq i64 [[X3:%.*]], [[Y3:%.*]]
 707 ; CHECK-NEXT:    [[CMP:%.*]] = and i1 [[TMP3]], [[TMP4]]
 708 ; CHECK-NEXT:    ret i1 [[CMP]]
 709 ;
 710   %sub = sub i64 %x1, %y1
 711   %sub1 = sub i64 %x2, %y2
 712   %or = or i64 %sub, %sub1
 713   %sub2 = sub i64 %x3, %y3
 714   %or1 = or i64 %or, %sub2
 715   %cmp = icmp eq i64 %or1, 0
 716   ret i1 %cmp
 717 }
 718
 719 ; negative test - and instead of or
 720
 721 define i1 @icmp_or_sub_3_2_fail(i64 %x1, i64 %y1, i64 %x2, i64 %y2, i64 %x3, i64 %y3) {
 722 ; CHECK-LABEL: @icmp_or_sub_3_2_fail(
 723 ; CHECK-NEXT:    [[SUB:%.*]] = sub i64 [[X1:%.*]], [[Y1:%.*]]
 724 ; CHECK-NEXT:    [[SUB1:%.*]] = sub i64 [[X2:%.*]], [[Y2:%.*]]
 725 ; CHECK-NEXT:    [[AND:%.*]] = and i64 [[SUB]], [[SUB1]]
 726 ; CHECK-NEXT:    [[SUB2:%.*]] = sub i64 [[X3:%.*]], [[Y3:%.*]]
 727 ; CHECK-NEXT:    [[OR1:%.*]] = or i64 [[AND]], [[SUB2]]
 728 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i64 [[OR1]], 0
 729 ; CHECK-NEXT:    ret i1 [[CMP]]
 730 ;
 731   %sub = sub i64 %x1, %y1
 732   %sub1 = sub i64 %x2, %y2
 733   %and = and i64 %sub, %sub1
 734   %sub2 = sub i64 %x3, %y3
 735   %or1 = or i64 %and, %sub2
 736   %cmp = icmp eq i64 %or1, 0
 737   ret i1 %cmp
 738 }
 739
 740 define i1 @icmp_or_sub_3_3(i64 %x1, i64 %y1, i64 %x2, i64 %y2, i64 %x3, i64 %y3) {
 741 ; CHECK-LABEL: @icmp_or_sub_3_3(
 742 ; CHECK-NEXT:    [[TMP1:%.*]] = icmp eq i64 [[X1:%.*]], [[Y1:%.*]]
 743 ; CHECK-NEXT:    [[TMP2:%.*]] = icmp eq i64 [[X2:%.*]], [[Y2:%.*]]
 744 ; CHECK-NEXT:    [[TMP3:%.*]] = and i1 [[TMP1]], [[TMP2]]
 745 ; CHECK-NEXT:    [[TMP4:%.*]] = icmp eq i64 [[X3:%.*]], [[Y3:%.*]]
 746 ; CHECK-NEXT:    [[CMP:%.*]] = and i1 [[TMP3]], [[TMP4]]
 747 ; CHECK-NEXT:    ret i1 [[CMP]]
 748 ;
 749   %sub = sub i64 %x1, %y1
 750   %sub1 = sub i64 %x2, %y2
 751   %or = or i64 %sub, %sub1
 752   %sub2 = sub i64 %x3, %y3
 753   %or1 = or i64 %sub2, %or
 754   %cmp = icmp eq i64 %or1, 0
 755   ret i1 %cmp
 756 }
 757
 758 ; negative test - and instead of or
 759
 760 define i1 @icmp_or_sub_3_4_fail(i64 %x1, i64 %y1, i64 %x2, i64 %y2, i64 %x3, i64 %y3) {
 761 ; CHECK-LABEL: @icmp_or_sub_3_4_fail(
 762 ; CHECK-NEXT:    [[SUB:%.*]] = sub i64 [[X1:%.*]], [[Y1:%.*]]
 763 ; CHECK-NEXT:    [[SUB1:%.*]] = sub i64 [[X2:%.*]], [[Y2:%.*]]
 764 ; CHECK-NEXT:    [[AND:%.*]] = and i64 [[SUB]], [[SUB1]]
 765 ; CHECK-NEXT:    [[SUB2:%.*]] = sub i64 [[X3:%.*]], [[Y3:%.*]]
 766 ; CHECK-NEXT:    [[OR1:%.*]] = or i64 [[SUB2]], [[AND]]
 767 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i64 [[OR1]], 0
 768 ; CHECK-NEXT:    ret i1 [[CMP]]
 769 ;
 770   %sub = sub i64 %x1, %y1
 771   %sub1 = sub i64 %x2, %y2
 772   %and = and i64 %sub, %sub1
 773   %sub2 = sub i64 %x3, %y3
 774   %or1 = or i64 %sub2, %and
 775   %cmp = icmp eq i64 %or1, 0
 776   ret i1 %cmp
 777 }
 778
 779 define i1 @icmp_or_sub_4_1(i64 %x1, i64 %y1, i64 %x2, i64 %y2, i64 %x3, i64 %y3, i64 %x4, i64 %y4) {
 780 ; CHECK-LABEL: @icmp_or_sub_4_1(
 781 ; CHECK-NEXT:    [[TMP1:%.*]] = icmp eq i64 [[X3:%.*]], [[Y3:%.*]]
 782 ; CHECK-NEXT:    [[TMP2:%.*]] = icmp eq i64 [[X4:%.*]], [[Y4:%.*]]
 783 ; CHECK-NEXT:    [[TMP3:%.*]] = and i1 [[TMP1]], [[TMP2]]
 784 ; CHECK-NEXT:    [[TMP4:%.*]] = icmp eq i64 [[X1:%.*]], [[Y1:%.*]]
 785 ; CHECK-NEXT:    [[TMP5:%.*]] = and i1 [[TMP3]], [[TMP4]]
 786 ; CHECK-NEXT:    [[TMP6:%.*]] = icmp eq i64 [[X2:%.*]], [[Y2:%.*]]
 787 ; CHECK-NEXT:    [[CMP:%.*]] = and i1 [[TMP5]], [[TMP6]]
 788 ; CHECK-NEXT:    ret i1 [[CMP]]
 789 ;
 790   %sub = sub i64 %x1, %y1
 791   %sub1 = sub i64 %x2, %y2
 792   %or = or i64 %sub, %sub1
 793   %sub2 = sub i64 %x3, %y3
 794   %sub3 = sub i64 %x4, %y4
 795   %or1 = or i64 %sub2, %sub3
 796   %or2 = or i64 %or, %or1
 797   %cmp = icmp eq i64 %or2, 0
 798   ret i1 %cmp
 799 }
 800
 801 define i1 @icmp_or_sub_4_2(i64 %x1, i64 %y1, i64 %x2, i64 %y2, i64 %x3, i64 %y3, i64 %x4, i64 %y4) {
 802 ; CHECK-LABEL: @icmp_or_sub_4_2(
 803 ; CHECK-NEXT:    [[TMP1:%.*]] = icmp eq i64 [[X1:%.*]], [[Y1:%.*]]
 804 ; CHECK-NEXT:    [[TMP2:%.*]] = icmp eq i64 [[X2:%.*]], [[Y2:%.*]]
 805 ; CHECK-NEXT:    [[TMP3:%.*]] = and i1 [[TMP1]], [[TMP2]]
 806 ; CHECK-NEXT:    [[TMP4:%.*]] = icmp eq i64 [[X3:%.*]], [[Y3:%.*]]
 807 ; CHECK-NEXT:    [[TMP5:%.*]] = and i1 [[TMP3]], [[TMP4]]
 808 ; CHECK-NEXT:    [[TMP6:%.*]] = icmp eq i64 [[X4:%.*]], [[Y4:%.*]]
 809 ; CHECK-NEXT:    [[CMP:%.*]] = and i1 [[TMP5]], [[TMP6]]
 810 ; CHECK-NEXT:    ret i1 [[CMP]]
 811 ;
 812   %sub = sub i64 %x1, %y1
 813   %sub1 = sub i64 %x2, %y2
 814   %or = or i64 %sub, %sub1
 815   %sub2 = sub i64 %x3, %y3
 816   %sub3 = sub i64 %x4, %y4
 817   %or1 = or i64 %sub2, %sub3
 818   %or2 = or i64 %or1, %or
 819   %cmp = icmp eq i64 %or2, 0
 820   ret i1 %cmp
 821 }
 822
 823 define i1 @icmp_or_xor_with_sub_2_eq(i64 %x1, i64 %y1, i64 %x2, i64 %y2) {
 824 ; CHECK-LABEL: @icmp_or_xor_with_sub_2_eq(
 825 ; CHECK-NEXT:    [[TMP1:%.*]] = icmp eq i64 [[X1:%.*]], [[Y1:%.*]]
 826 ; CHECK-NEXT:    [[TMP2:%.*]] = icmp eq i64 [[X2:%.*]], [[Y2:%.*]]
 827 ; CHECK-NEXT:    [[CMP:%.*]] = and i1 [[TMP1]], [[TMP2]]
 828 ; CHECK-NEXT:    ret i1 [[CMP]]
 829 ;
 830   %xor = xor i64 %x1, %y1
 831   %sub = sub i64 %x2, %y2
 832   %or = or i64 %xor, %sub
 833   %cmp = icmp eq i64 %or, 0
 834   ret i1 %cmp
 835 }
 836
 837 define i1 @icmp_or_xor_with_sub_2_ne(i64 %x1, i64 %y1, i64 %x2, i64 %y2) {
 838 ; CHECK-LABEL: @icmp_or_xor_with_sub_2_ne(
 839 ; CHECK-NEXT:    [[TMP1:%.*]] = icmp ne i64 [[X1:%.*]], [[Y1:%.*]]
 840 ; CHECK-NEXT:    [[TMP2:%.*]] = icmp ne i64 [[X2:%.*]], [[Y2:%.*]]
 841 ; CHECK-NEXT:    [[CMP:%.*]] = or i1 [[TMP1]], [[TMP2]]
 842 ; CHECK-NEXT:    ret i1 [[CMP]]
 843 ;
 844   %xor = xor i64 %x1, %y1
 845   %sub = sub i64 %x2, %y2
 846   %or = or i64 %xor, %sub
 847   %cmp = icmp ne i64 %or, 0
 848   ret i1 %cmp
 849 }
 850
 851 define i1 @icmp_or_xor_with_sub_3_1(i64 %x1, i64 %y1, i64 %x2, i64 %y2, i64 %x3, i64 %y3) {
 852 ; CHECK-LABEL: @icmp_or_xor_with_sub_3_1(
 853 ; CHECK-NEXT:    [[TMP1:%.*]] = icmp eq i64 [[X1:%.*]], [[Y1:%.*]]
 854 ; CHECK-NEXT:    [[TMP2:%.*]] = icmp eq i64 [[X2:%.*]], [[Y2:%.*]]
 855 ; CHECK-NEXT:    [[TMP3:%.*]] = and i1 [[TMP1]], [[TMP2]]
 856 ; CHECK-NEXT:    [[TMP4:%.*]] = icmp eq i64 [[X3:%.*]], [[Y3:%.*]]
 857 ; CHECK-NEXT:    [[CMP:%.*]] = and i1 [[TMP3]], [[TMP4]]
 858 ; CHECK-NEXT:    ret i1 [[CMP]]
 859 ;
 860   %xor = xor i64 %x1, %y1
 861   %xor1 = xor i64 %x2, %y2
 862   %or = or i64 %xor, %xor1
 863   %sub1 = sub i64 %x3, %y3
 864   %or1 = or i64 %or, %sub1
 865   %cmp = icmp eq i64 %or1, 0
 866   ret i1 %cmp
 867 }
 868
 869 define i1 @icmp_or_xor_with_sub_3_2(i64 %x1, i64 %y1, i64 %x2, i64 %y2, i64 %x3, i64 %y3) {
 870 ; CHECK-LABEL: @icmp_or_xor_with_sub_3_2(
 871 ; CHECK-NEXT:    [[TMP1:%.*]] = icmp eq i64 [[X1:%.*]], [[Y1:%.*]]
 872 ; CHECK-NEXT:    [[TMP2:%.*]] = icmp eq i64 [[X2:%.*]], [[Y2:%.*]]
 873 ; CHECK-NEXT:    [[TMP3:%.*]] = and i1 [[TMP1]], [[TMP2]]
 874 ; CHECK-NEXT:    [[TMP4:%.*]] = icmp eq i64 [[X3:%.*]], [[Y3:%.*]]
 875 ; CHECK-NEXT:    [[CMP:%.*]] = and i1 [[TMP3]], [[TMP4]]
 876 ; CHECK-NEXT:    ret i1 [[CMP]]
 877 ;
 878   %xor = xor i64 %x1, %y1
 879   %sub = sub i64 %x2, %y2
 880   %or = or i64 %xor, %sub
 881   %xor1 = xor i64 %x3, %y3
 882   %or1 = or i64 %or, %xor1
 883   %cmp = icmp eq i64 %or1, 0
 884   ret i1 %cmp
 885 }
 886
 887 define i1 @icmp_or_xor_with_sub_3_3(i64 %x1, i64 %y1, i64 %x2, i64 %y2, i64 %x3, i64 %y3) {
 888 ; CHECK-LABEL: @icmp_or_xor_with_sub_3_3(
 889 ; CHECK-NEXT:    [[TMP1:%.*]] = icmp eq i64 [[X1:%.*]], [[Y1:%.*]]
 890 ; CHECK-NEXT:    [[TMP2:%.*]] = icmp eq i64 [[X2:%.*]], [[Y2:%.*]]
 891 ; CHECK-NEXT:    [[TMP3:%.*]] = and i1 [[TMP1]], [[TMP2]]
 892 ; CHECK-NEXT:    [[TMP4:%.*]] = icmp eq i64 [[X3:%.*]], [[Y3:%.*]]
 893 ; CHECK-NEXT:    [[CMP:%.*]] = and i1 [[TMP3]], [[TMP4]]
 894 ; CHECK-NEXT:    ret i1 [[CMP]]
 895 ;
 896   %xor = xor i64 %x1, %y1
 897   %sub = sub i64 %x2, %y2
 898   %or = or i64 %xor, %sub
 899   %sub1 = sub i64 %x3, %y3
 900   %or1 = or i64 %or, %sub1
 901   %cmp = icmp eq i64 %or1, 0
 902   ret i1 %cmp
 903 }
 904
 905 define i1 @icmp_or_xor_with_sub_3_4(i64 %x1, i64 %y1, i64 %x2, i64 %y2, i64 %x3, i64 %y3) {
 906 ; CHECK-LABEL: @icmp_or_xor_with_sub_3_4(
 907 ; CHECK-NEXT:    [[TMP1:%.*]] = icmp eq i64 [[X1:%.*]], [[Y1:%.*]]
 908 ; CHECK-NEXT:    [[TMP2:%.*]] = icmp eq i64 [[X2:%.*]], [[Y2:%.*]]
 909 ; CHECK-NEXT:    [[TMP3:%.*]] = and i1 [[TMP1]], [[TMP2]]
 910 ; CHECK-NEXT:    [[TMP4:%.*]] = icmp eq i64 [[X3:%.*]], [[Y3:%.*]]
 911 ; CHECK-NEXT:    [[CMP:%.*]] = and i1 [[TMP3]], [[TMP4]]
 912 ; CHECK-NEXT:    ret i1 [[CMP]]
 913 ;
 914   %sub = sub i64 %x1, %y1
 915   %xor = xor i64 %x2, %y2
 916   %or = or i64 %sub, %xor
 917   %xor1 = xor i64 %x3, %y3
 918   %or1 = or i64 %or, %xor1
 919   %cmp = icmp eq i64 %or1, 0
 920   ret i1 %cmp
 921 }
 922
 923 define i1 @icmp_or_xor_with_sub_3_5(i64 %x1, i64 %y1, i64 %x2, i64 %y2, i64 %x3, i64 %y3) {
 924 ; CHECK-LABEL: @icmp_or_xor_with_sub_3_5(
 925 ; CHECK-NEXT:    [[TMP1:%.*]] = icmp eq i64 [[X1:%.*]], [[Y1:%.*]]
 926 ; CHECK-NEXT:    [[TMP2:%.*]] = icmp eq i64 [[X2:%.*]], [[Y2:%.*]]
 927 ; CHECK-NEXT:    [[TMP3:%.*]] = and i1 [[TMP1]], [[TMP2]]
 928 ; CHECK-NEXT:    [[TMP4:%.*]] = icmp eq i64 [[X3:%.*]], [[Y3:%.*]]
 929 ; CHECK-NEXT:    [[CMP:%.*]] = and i1 [[TMP3]], [[TMP4]]
 930 ; CHECK-NEXT:    ret i1 [[CMP]]
 931 ;
 932   %sub = sub i64 %x1, %y1
 933   %xor = xor i64 %x2, %y2
 934   %or = or i64 %sub, %xor
 935   %sub1 = sub i64 %x3, %y3
 936   %or1 = or i64 %or, %sub1
 937   %cmp = icmp eq i64 %or1, 0
 938   ret i1 %cmp
 939 }
 940
 941 define i1 @icmp_or_xor_with_sub_3_6(i64 %x1, i64 %y1, i64 %x2, i64 %y2, i64 %x3, i64 %y3) {
 942 ; CHECK-LABEL: @icmp_or_xor_with_sub_3_6(
 943 ; CHECK-NEXT:    [[TMP1:%.*]] = icmp eq i64 [[X1:%.*]], [[Y1:%.*]]
 944 ; CHECK-NEXT:    [[TMP2:%.*]] = icmp eq i64 [[X2:%.*]], [[Y2:%.*]]
 945 ; CHECK-NEXT:    [[TMP3:%.*]] = and i1 [[TMP1]], [[TMP2]]
 946 ; CHECK-NEXT:    [[TMP4:%.*]] = icmp eq i64 [[X3:%.*]], [[Y3:%.*]]
 947 ; CHECK-NEXT:    [[CMP:%.*]] = and i1 [[TMP3]], [[TMP4]]
 948 ; CHECK-NEXT:    ret i1 [[CMP]]
 949 ;
 950   %sub = sub i64 %x1, %y1
 951   %sub1 = sub i64 %x2, %y2
 952   %or = or i64 %sub, %sub1
 953   %xor = xor i64 %x3, %y3
 954   %or1 = or i64 %or, %xor
 955   %cmp = icmp eq i64 %or1, 0
 956   ret i1 %cmp
 957 }
 958
 959
 960 define i1 @or_disjoint_with_constants(i8 %x) {
 961 ; CHECK-LABEL: @or_disjoint_with_constants(
 962 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i8 [[X:%.*]], 18
 963 ; CHECK-NEXT:    ret i1 [[CMP]]
 964 ;
 965   %or = or disjoint i8 %x, 1
 966   %cmp = icmp eq i8 %or, 19
 967   ret i1 %cmp
 968 }
 969
 970
 971 define i1 @or_disjoint_with_constants2(i8 %x) {
 972 ; CHECK-LABEL: @or_disjoint_with_constants2(
 973 ; CHECK-NEXT:    [[OR:%.*]] = or disjoint i8 [[X:%.*]], 5
 974 ; CHECK-NEXT:    [[CMP:%.*]] = icmp ne i8 [[X]], 66
 975 ; CHECK-NEXT:    call void @use(i8 [[OR]])
 976 ; CHECK-NEXT:    ret i1 [[CMP]]
 977 ;
 978   %or = or disjoint i8 %x, 5
 979   %cmp = icmp ne i8 %or, 71
 980   call void @use(i8 %or)
 981   ret i1 %cmp
 982 }
 983
 984
 985 define i1 @or_disjoint_with_constants_fail_missing_const1(i8 %x, i8 %y) {
 986 ; CHECK-LABEL: @or_disjoint_with_constants_fail_missing_const1(
 987 ; CHECK-NEXT:    [[OR:%.*]] = or disjoint i8 [[X:%.*]], [[Y:%.*]]
 988 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i8 [[OR]], 19
 989 ; CHECK-NEXT:    ret i1 [[CMP]]
 990 ;
 991   %or = or disjoint i8 %x, %y
 992   %cmp = icmp eq i8 %or, 19
 993   ret i1 %cmp
 994 }
 995
 996 define i1 @or_disjoint_with_constants_fail_missing_const2(i8 %x, i8 %y) {
 997 ; CHECK-LABEL: @or_disjoint_with_constants_fail_missing_const2(
 998 ; CHECK-NEXT:    [[OR:%.*]] = or disjoint i8 [[X:%.*]], 19
 999 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i8 [[OR]], [[Y:%.*]]
1000 ; CHECK-NEXT:    ret i1 [[CMP]]
1001 ;
1002   %or = or disjoint i8 %x, 19
1003   %cmp = icmp eq i8 %or, %y
1004   ret i1 %cmp
1005 }
1006