Revert "[InstCombine] Hoist xor-by-constant from xor-by-value"

[bgraur]

Summary

Changes in commit d9ebaeeb468d6a8f29eb479f18d2790f7efb8565 cause the
compiler to enter an infinite loop.

This reverts commit d9ebaeeb468d6a8f29eb479f18d2790f7efb8565.

[SureYeaah]

LGTM

[lebedev.ri]

Reproducer?

[bgraur]

@lebedev.ri: I'll need some time to localize and minimize a test for this.
The infinite loop occurs while compiling an internal source file @Google while validating the upstream.

Is it OK for you to send you this later (this evening or tomorrow)?

[lebedev.ri]

It would be best to have the reproducer beforehand.
Usually it should be fine to just dump the whole module's IR
in InstCombinerImpl::run() as the first thing in that loop,
save the IR that is clearly stuck within the inf combine loop,
and feed it to llvm-reduce..

[bgraur]

Here's a small repro:

#include <cstdint>

static int v;

void foo(unsigned char x[2]) {
  x[0] = static_cast<unsigned char>(reinterpret_cast<uintptr_t>(&v));
  x[1] = ~static_cast<unsigned char>(0);

  for (int i = 0; i < 2; i++) {
    unsigned char s0 = x[0];
    unsigned char s1 = x[1];
    s1 ^= s0;
    x[0] = s1 ^ (s1 << 1);
    x[1] = (s1 << 4) | (s1 >> 4);
  }
}

[lebedev.ri]

Yep, as i expected, constant expressions as usual.
Let me just fix this instead.

[bgraur]

How about submitting this revert and you work on the fix separately?
If another problem is added with the fix reverting will be harder.

[lebedev.ri]

Thank you very much for the reproducer!
Fixed in d4ccef38d0bbcd70f56d586b4dfc988db863e388
Sorry for the trouble!

[bgraur]

Roman fixed forward the cause of the infinite loop.
This revert is no longer necessary.

llvm/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp

if (auto *Sel = dyn_cast<SelectInst>(Op0)) {
         return replaceInstUsesWith(I, Sel);
       }
     }
   }
 
   if (Instruction *NewXor = sinkNotIntoXor(I, Builder))
     return NewXor;
 
-  // Otherwise, if all else failed, try to hoist the xor-by-constant:
-  // (X ^ C) ^ Y --> (X ^ Y) ^ C
-  // FIXME: does this need hardening against ConstantExpr's
-  //        to prevent infinite combine loops?
-  if (match(&I,
-            m_c_Xor(m_OneUse(m_Xor(m_Value(X), m_Constant(C1))), m_Value(Y))))
-    return BinaryOperator::CreateXor(Builder.CreateXor(X, Y), C1);
-
   return nullptr;
 }

llvm/test/Transforms/InstCombine/hoist-xor-by-constant-from-xor-by-value.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -instcombine -S | FileCheck %s
 
 declare i8 @gen8()
 declare void @use8(i8)
 
 @a = global i8 17
 
 define i8 @t0_scalar(i8 %x, i8 %y) {
 ; CHECK-LABEL: @t0_scalar(
-; CHECK-NEXT:    [[TMP1:%.*]] = xor i8 [[X:%.*]], [[Y:%.*]]
-; CHECK-NEXT:    [[R:%.*]] = xor i8 [[TMP1]], 42
+; CHECK-NEXT:    [[I0:%.*]] = xor i8 [[X:%.*]], 42
+; CHECK-NEXT:    [[R:%.*]] = xor i8 [[I0]], [[Y:%.*]]
 ; CHECK-NEXT:    ret i8 [[R]]
 ;
   %i0 = xor i8 %x, 42
   %r = xor i8 %i0, %y
   ret i8 %r
 }
 
 define <2 x i8> @t1_splatvec(<2 x i8> %x, <2 x i8> %y) {
 ; CHECK-LABEL: @t1_splatvec(
-; CHECK-NEXT:    [[TMP1:%.*]] = xor <2 x i8> [[X:%.*]], [[Y:%.*]]
-; CHECK-NEXT:    [[R:%.*]] = xor <2 x i8> [[TMP1]], <i8 42, i8 42>
+; CHECK-NEXT:    [[I0:%.*]] = xor <2 x i8> [[X:%.*]], <i8 42, i8 42>
+; CHECK-NEXT:    [[R:%.*]] = xor <2 x i8> [[I0]], [[Y:%.*]]
 ; CHECK-NEXT:    ret <2 x i8> [[R]]
 ;
   %i0 = xor <2 x i8> %x, <i8 42, i8 42>
   %r = xor <2 x i8> %i0, %y
   ret <2 x i8> %r
 }
 define <2 x i8> @t2_vec(<2 x i8> %x, <2 x i8> %y) {
 ; CHECK-LABEL: @t2_vec(
-; CHECK-NEXT:    [[TMP1:%.*]] = xor <2 x i8> [[X:%.*]], [[Y:%.*]]
-; CHECK-NEXT:    [[R:%.*]] = xor <2 x i8> [[TMP1]], <i8 42, i8 24>
+; CHECK-NEXT:    [[I0:%.*]] = xor <2 x i8> [[X:%.*]], <i8 42, i8 24>
+; CHECK-NEXT:    [[R:%.*]] = xor <2 x i8> [[I0]], [[Y:%.*]]
 ; CHECK-NEXT:    ret <2 x i8> [[R]]
 ;
   %i0 = xor <2 x i8> %x, <i8 42, i8 24>
   %r = xor <2 x i8> %i0, %y
   ret <2 x i8> %r
 }
 define <2 x i8> @t3_vec_undef(<2 x i8> %x, <2 x i8> %y) {
 ; CHECK-LABEL: @t3_vec_undef(
-; CHECK-NEXT:    [[TMP1:%.*]] = xor <2 x i8> [[X:%.*]], [[Y:%.*]]
-; CHECK-NEXT:    [[R:%.*]] = xor <2 x i8> [[TMP1]], <i8 42, i8 undef>
+; CHECK-NEXT:    [[I0:%.*]] = xor <2 x i8> [[X:%.*]], <i8 42, i8 undef>
+; CHECK-NEXT:    [[R:%.*]] = xor <2 x i8> [[I0]], [[Y:%.*]]
 ; CHECK-NEXT:    ret <2 x i8> [[R]]
 ;
   %i0 = xor <2 x i8> %x, <i8 42, i8 undef>
   %r = xor <2 x i8> %i0, %y
   ret <2 x i8> %r
 }
 
 define i8 @t4_extrause(i8 %x, i8 %y) {
 ; CHECK-LABEL: @t4_extrause(
 ; CHECK-NEXT:    [[I0:%.*]] = xor i8 [[X:%.*]], 42
 ; CHECK-NEXT:    call void @use8(i8 [[I0]])
 ; CHECK-NEXT:    [[R:%.*]] = xor i8 [[I0]], [[Y:%.*]]
 ; CHECK-NEXT:    ret i8 [[R]]
 ;
   %i0 = xor i8 %x, 42
   call void @use8(i8 %i0)
   %r = xor i8 %i0, %y
   ret i8 %r
 }
 
 define i8 @t5_commutativity(i8 %x) {
 ; CHECK-LABEL: @t5_commutativity(
+; CHECK-NEXT:    [[I0:%.*]] = xor i8 [[X:%.*]], 42
 ; CHECK-NEXT:    [[Y:%.*]] = call i8 @gen8()
-; CHECK-NEXT:    [[TMP1:%.*]] = xor i8 [[Y]], [[X:%.*]]
-; CHECK-NEXT:    [[R:%.*]] = xor i8 [[TMP1]], 42
+; CHECK-NEXT:    [[R:%.*]] = xor i8 [[Y]], [[I0]]
 ; CHECK-NEXT:    ret i8 [[R]]
 ;
   %i0 = xor i8 %x, 42
   %y = call i8 @gen8()
   %r = xor i8 %y, %i0
   ret i8 %r
 }

llvm/test/Transforms/InstCombine/invert-variable-mask-in-masked-merge-scalar.ll

;
   %n0 = xor i4 %x, 6 ; %x
   %n1 = and i4 %n0, %notmask
   %r = xor i4 %n1, 6
   ret i4 %r
 }
 
 define i4 @in_constant_mone_vary_invmask(i4 %y, i4 %mask) {
 ; CHECK-LABEL: @in_constant_mone_vary_invmask(
-; CHECK-NEXT:    [[MASK_NOT:%.*]] = xor i4 [[MASK:%.*]], -1
-; CHECK-NEXT:    [[R:%.*]] = or i4 [[MASK_NOT]], [[Y:%.*]]
+; CHECK-NEXT:    [[N1_DEMORGAN:%.*]] = or i4 [[Y:%.*]], [[MASK:%.*]]
+; CHECK-NEXT:    [[N1:%.*]] = xor i4 [[N1_DEMORGAN]], -1
+; CHECK-NEXT:    [[R:%.*]] = xor i4 [[N1]], [[Y]]
 ; CHECK-NEXT:    ret i4 [[R]]
 ;
   %notmask = xor i4 %mask, -1
   %n0 = xor i4 -1, %y ; %x
   %n1 = and i4 %n0, %notmask
   %r = xor i4 %n1, %y
   ret i4 %r
 }

llvm/test/Transforms/InstCombine/invert-variable-mask-in-masked-merge-vector.ll

;
   %n0 = xor <3 x i4> %x, <i4 6, i4 undef, i4 7> ; %x
   %n1 = and <3 x i4> %n0, %notmask
   %r = xor <3 x i4> %n1, <i4 6, i4 undef, i4 7>
   ret <3 x i4> %r
 }
 
 define <2 x i4> @in_constant_mone_vary_invmask(<2 x i4> %y, <2 x i4> %mask) {
 ; CHECK-LABEL: @in_constant_mone_vary_invmask(
-; CHECK-NEXT:    [[MASK_NOT:%.*]] = xor <2 x i4> [[MASK:%.*]], <i4 -1, i4 -1>
-; CHECK-NEXT:    [[R:%.*]] = or <2 x i4> [[MASK_NOT]], [[Y:%.*]]
+; CHECK-NEXT:    [[N1_DEMORGAN:%.*]] = or <2 x i4> [[Y:%.*]], [[MASK:%.*]]
+; CHECK-NEXT:    [[N1:%.*]] = xor <2 x i4> [[N1_DEMORGAN]], <i4 -1, i4 -1>
+; CHECK-NEXT:    [[R:%.*]] = xor <2 x i4> [[N1]], [[Y]]
 ; CHECK-NEXT:    ret <2 x i4> [[R]]
 ;
   %notmask = xor <2 x i4> %mask, <i4 -1, i4 -1>
   %n0 = xor <2 x i4> <i4 -1, i4 -1>, %y ; %x
   %n1 = and <2 x i4> %n0, %notmask
   %r = xor <2 x i4> %n1, %y
   ret <2 x i4> %r
 }

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

 ; CHECK-NEXT:    ret i32 [[Z]]
 ;
   %not = xor i32 %x, -1
   %xor = xor i32 %not, %y
   %z = or i32 %x, %xor
   ret i32 %z
 }
 
-; (A ^ B) | (~A ^ B) --> -1
-
 define i32 @test10(i32 %A, i32 %B) {
 ; CHECK-LABEL: @test10(
-; CHECK-NEXT:    [[XOR1:%.*]] = xor i32 [[B:%.*]], [[A:%.*]]
-; CHECK-NEXT:    [[TMP1:%.*]] = xor i32 [[A]], [[B]]
-; CHECK-NEXT:    [[XOR2:%.*]] = xor i32 [[TMP1]], -1
-; CHECK-NEXT:    [[OR:%.*]] = or i32 [[XOR1]], [[XOR2]]
-; CHECK-NEXT:    ret i32 [[OR]]
+; CHECK-NEXT:    ret i32 -1
 ;
   %xor1 = xor i32 %B, %A
   %not = xor i32 %A, -1
   %xor2 = xor i32 %not, %B
   %or = or i32 %xor1, %xor2
   ret i32 %or
 }
 
 define i32 @test10_commuted(i32 %A, i32 %B) {
 ; CHECK-LABEL: @test10_commuted(
-; CHECK-NEXT:    [[XOR1:%.*]] = xor i32 [[B:%.*]], [[A:%.*]]
-; CHECK-NEXT:    [[TMP1:%.*]] = xor i32 [[A]], [[B]]
-; CHECK-NEXT:    [[XOR2:%.*]] = xor i32 [[TMP1]], -1
-; CHECK-NEXT:    [[OR:%.*]] = or i32 [[XOR1]], [[XOR2]]
-; CHECK-NEXT:    ret i32 [[OR]]
-;
-  %xor1 = xor i32 %B, %A
-  %not = xor i32 %A, -1
-  %xor2 = xor i32 %not, %B
-  %or = or i32 %xor2, %xor1
-  ret i32 %or
-}
-
-define i32 @test10_extrause(i32 %A, i32 %B, i32* %dst) {
-; CHECK-LABEL: @test10_extrause(
-; CHECK-NEXT:    [[NOT:%.*]] = xor i32 [[A:%.*]], -1
-; CHECK-NEXT:    store i32 [[NOT]], i32* [[DST:%.*]], align 4
-; CHECK-NEXT:    ret i32 -1
-;
-  %xor1 = xor i32 %B, %A
-  %not = xor i32 %A, -1
-  store i32 %not, i32* %dst
-  %xor2 = xor i32 %not, %B
-  %or = or i32 %xor1, %xor2
-  ret i32 %or
-}
-
-define i32 @test10_commuted_extrause(i32 %A, i32 %B, i32* %dst) {
-; CHECK-LABEL: @test10_commuted_extrause(
-; CHECK-NEXT:    [[NOT:%.*]] = xor i32 [[A:%.*]], -1
-; CHECK-NEXT:    store i32 [[NOT]], i32* [[DST:%.*]], align 4
 ; CHECK-NEXT:    ret i32 -1
 ;
   %xor1 = xor i32 %B, %A
   %not = xor i32 %A, -1
-  store i32 %not, i32* %dst
   %xor2 = xor i32 %not, %B
   %or = or i32 %xor2, %xor1
   ret i32 %or
 }
 
-; (A ^ B) | ~(A ^ B) --> -1
-define i32 @test10_canonical(i32 %A, i32 %B) {
-; CHECK-LABEL: @test10_canonical(
-; CHECK-NEXT:    [[XOR1:%.*]] = xor i32 [[B:%.*]], [[A:%.*]]
-; CHECK-NEXT:    [[XOR2:%.*]] = xor i32 [[A]], [[B]]
-; CHECK-NEXT:    [[NOT:%.*]] = xor i32 [[XOR2]], -1
-; CHECK-NEXT:    [[OR:%.*]] = or i32 [[XOR1]], [[NOT]]
-; CHECK-NEXT:    ret i32 [[OR]]
-;
-  %xor1 = xor i32 %B, %A
-  %xor2 = xor i32 %A, %B
-  %not = xor i32 %xor2, -1
-  %or = or i32 %xor1, %not
-  ret i32 %or
-}
-
 ; (x | y) & ((~x) ^ y) -> (x & y)
 define i32 @test11(i32 %x, i32 %y) {
 ; CHECK-LABEL: @test11(
 ; CHECK-NEXT:    [[AND:%.*]] = and i32 [[X:%.*]], [[Y:%.*]]
 ; CHECK-NEXT:    ret i32 [[AND]]
 ;
   %or = or i32 %x, %y
   %neg = xor i32 %x, -1
;
   %xor = xor i8 %or1, 12
   %or2 = or i8 %xor, 7
   ret i8 %or2
 }
 
 define i8 @test17(i8 %A, i8 %B) {
 ; CHECK-LABEL: @test17(
 ; CHECK-NEXT:    [[XOR1:%.*]] = xor i8 [[B:%.*]], [[A:%.*]]
-; CHECK-NEXT:    [[TMP1:%.*]] = xor i8 [[A]], [[B]]
-; CHECK-NEXT:    [[XOR2:%.*]] = xor i8 [[TMP1]], 33
-; CHECK-NEXT:    [[OR:%.*]] = or i8 [[XOR1]], [[XOR2]]
+; CHECK-NEXT:    [[NOT:%.*]] = xor i8 [[A]], 33
+; CHECK-NEXT:    [[XOR2:%.*]] = xor i8 [[NOT]], [[B]]
+; CHECK-NEXT:    [[OR:%.*]] = or i8 [[XOR1]], 33
 ; CHECK-NEXT:    [[RES:%.*]] = mul i8 [[OR]], [[XOR2]]
 ; CHECK-NEXT:    ret i8 [[RES]]
 ;
   %xor1 = xor i8 %B, %A
   %not = xor i8 %A, 33
   %xor2 = xor i8 %not, %B
   %or = or i8 %xor1, %xor2
   %res = mul i8 %or, %xor2 ; to increase the use count for the xor
   ret i8 %res
 }
 
 define i8 @test18(i8 %A, i8 %B) {
 ; CHECK-LABEL: @test18(
 ; CHECK-NEXT:    [[XOR1:%.*]] = xor i8 [[B:%.*]], [[A:%.*]]
-; CHECK-NEXT:    [[TMP1:%.*]] = xor i8 [[A]], [[B]]
-; CHECK-NEXT:    [[XOR2:%.*]] = xor i8 [[TMP1]], 33
-; CHECK-NEXT:    [[OR:%.*]] = or i8 [[XOR2]], [[XOR1]]
+; CHECK-NEXT:    [[NOT:%.*]] = xor i8 [[A]], 33
+; CHECK-NEXT:    [[XOR2:%.*]] = xor i8 [[NOT]], [[B]]
+; CHECK-NEXT:    [[OR:%.*]] = or i8 [[XOR1]], 33
 ; CHECK-NEXT:    [[RES:%.*]] = mul i8 [[OR]], [[XOR2]]
 ; CHECK-NEXT:    ret i8 [[RES]]
 ;
   %xor1 = xor i8 %B, %A
   %not = xor i8 %A, 33
   %xor2 = xor i8 %not, %B
   %or = or i8 %xor2, %xor1
   %res = mul i8 %or, %xor2 ; to increase the use count for the xor

llvm/test/Transforms/InstCombine/unfold-masked-merge-with-const-mask-scalar.ll

;
   %n0 = xor i4 %x, 14 ; %x
   %n1 = and i4 %n0, 1
   %r = xor i4 %n1, 14
   ret i4 %r
 }
 
 define i4 @in_constant_mone_vary(i4 %y, i4 %mask) {
 ; CHECK-LABEL: @in_constant_mone_vary(
-; CHECK-NEXT:    [[R1:%.*]] = or i4 [[Y:%.*]], 1
-; CHECK-NEXT:    ret i4 [[R1]]
+; CHECK-NEXT:    [[N0:%.*]] = and i4 [[Y:%.*]], 1
+; CHECK-NEXT:    [[N1:%.*]] = xor i4 [[N0]], 1
+; CHECK-NEXT:    [[R:%.*]] = xor i4 [[N1]], [[Y]]
+; CHECK-NEXT:    ret i4 [[R]]
 ;
   %n0 = xor i4 %y, -1 ; %x
   %n1 = and i4 %n0, 1
   %r = xor i4 %n1, %y
   ret i4 %r
 }
 
 define i4 @in_constant_14_vary(i4 %y, i4 %mask) {

llvm/test/Transforms/InstCombine/unfold-masked-merge-with-const-mask-vector.ll

;
   %n0 = xor <3 x i4> %x, <i4 14, i4 undef, i4 7> ; %x
   %n1 = and <3 x i4> %n0, <i4 1, i4 undef, i4 1>
   %r = xor <3 x i4> %n1, <i4 14, i4 undef, i4 7>
   ret <3 x i4> %r
 }
 
 define <2 x i4> @in_constant_mone_vary(<2 x i4> %y, <2 x i4> %mask) {
 ; CHECK-LABEL: @in_constant_mone_vary(
-; CHECK-NEXT:    [[R1:%.*]] = or <2 x i4> [[Y:%.*]], <i4 1, i4 1>
-; CHECK-NEXT:    ret <2 x i4> [[R1]]
+; CHECK-NEXT:    [[N0:%.*]] = and <2 x i4> [[Y:%.*]], <i4 1, i4 1>
+; CHECK-NEXT:    [[N1:%.*]] = xor <2 x i4> [[N0]], <i4 1, i4 1>
+; CHECK-NEXT:    [[R:%.*]] = xor <2 x i4> [[N1]], [[Y]]
+; CHECK-NEXT:    ret <2 x i4> [[R]]
 ;
   %n0 = xor <2 x i4> %y, <i4 -1, i4 -1> ; %x
   %n1 = and <2 x i4> %n0, <i4 1, i4 1>
   %r = xor <2 x i4> %n1, %y
   ret <2 x i4> %r
 }
 
 define <2 x i4> @in_constant_14_vary(<2 x i4> %y, <2 x i4> %mask) {

llvm/test/Transforms/InstCombine/vec_shuffle-inseltpoison.ll

;
   ret <3 x i32> %r
 }
 
 ; Negative test - widening splat
 
 define <5 x i32> @splat_assoc_xor(<4 x i32> %x, <5 x i32> %y) {
 ; CHECK-LABEL: @splat_assoc_xor(
 ; CHECK-NEXT:    [[SPLATX:%.*]] = shufflevector <4 x i32> [[X:%.*]], <4 x i32> undef, <5 x i32> zeroinitializer
-; CHECK-NEXT:    [[TMP1:%.*]] = xor <5 x i32> [[SPLATX]], [[Y:%.*]]
-; CHECK-NEXT:    [[R:%.*]] = xor <5 x i32> [[TMP1]], <i32 42, i32 42, i32 42, i32 42, i32 42>
+; CHECK-NEXT:    [[A:%.*]] = xor <5 x i32> [[Y:%.*]], <i32 42, i32 42, i32 42, i32 42, i32 42>
+; CHECK-NEXT:    [[R:%.*]] = xor <5 x i32> [[SPLATX]], [[A]]
 ; CHECK-NEXT:    ret <5 x i32> [[R]]
 ;
   %splatx = shufflevector <4 x i32> %x, <4 x i32> undef, <5 x i32> zeroinitializer
   %a = xor <5 x i32> %y, <i32 42, i32 42, i32 42, i32 42, i32 42>
   %r = xor <5 x i32> %splatx, %a
   ret <5 x i32> %r
 }
 

llvm/test/Transforms/InstCombine/vec_shuffle.ll

;
   ret <3 x i32> %r
 }
 
 ; Negative test - widening splat
 
 define <5 x i32> @splat_assoc_xor(<4 x i32> %x, <5 x i32> %y) {
 ; CHECK-LABEL: @splat_assoc_xor(
 ; CHECK-NEXT:    [[SPLATX:%.*]] = shufflevector <4 x i32> [[X:%.*]], <4 x i32> undef, <5 x i32> zeroinitializer
-; CHECK-NEXT:    [[TMP1:%.*]] = xor <5 x i32> [[SPLATX]], [[Y:%.*]]
-; CHECK-NEXT:    [[R:%.*]] = xor <5 x i32> [[TMP1]], <i32 42, i32 42, i32 42, i32 42, i32 42>
+; CHECK-NEXT:    [[A:%.*]] = xor <5 x i32> [[Y:%.*]], <i32 42, i32 42, i32 42, i32 42, i32 42>
+; CHECK-NEXT:    [[R:%.*]] = xor <5 x i32> [[SPLATX]], [[A]]
 ; CHECK-NEXT:    ret <5 x i32> [[R]]
 ;
   %splatx = shufflevector <4 x i32> %x, <4 x i32> undef, <5 x i32> zeroinitializer
   %a = xor <5 x i32> %y, <i32 42, i32 42, i32 42, i32 42, i32 42>
   %r = xor <5 x i32> %splatx, %a
   ret <5 x i32> %r
 }
 

llvm/test/Transforms/InstCombine/xor2.ll

;
   %xor = xor i32 %b, %c
   %and = and i32 %c, %b
   %xor2 = xor i32 %xor, %and
   ret i32 %xor2
 }
 
 define i32 @test11(i32 %A, i32 %B) {
 ; CHECK-LABEL: @test11(
-; CHECK-NEXT:    [[XOR1:%.*]] = xor i32 [[B:%.*]], [[A:%.*]]
-; CHECK-NEXT:    [[TMP1:%.*]] = xor i32 [[A]], [[B]]
-; CHECK-NEXT:    [[XOR2:%.*]] = xor i32 [[TMP1]], -1
-; CHECK-NEXT:    [[AND:%.*]] = and i32 [[XOR1]], [[XOR2]]
-; CHECK-NEXT:    ret i32 [[AND]]
+; CHECK-NEXT:    ret i32 0
 ;
   %xor1 = xor i32 %B, %A
   %not = xor i32 %A, -1
   %xor2 = xor i32 %not, %B
   %and = and i32 %xor1, %xor2
   ret i32 %and
 }
 
 define i32 @test11b(i32 %A, i32 %B) {
 ; CHECK-LABEL: @test11b(
-; CHECK-NEXT:    [[XOR1:%.*]] = xor i32 [[B:%.*]], [[A:%.*]]
-; CHECK-NEXT:    [[TMP1:%.*]] = xor i32 [[A]], [[B]]
-; CHECK-NEXT:    [[XOR2:%.*]] = xor i32 [[TMP1]], -1
-; CHECK-NEXT:    [[AND:%.*]] = and i32 [[XOR1]], [[XOR2]]
-; CHECK-NEXT:    ret i32 [[AND]]
+; CHECK-NEXT:    ret i32 0
 ;
   %xor1 = xor i32 %B, %A
   %not = xor i32 %A, -1
   %xor2 = xor i32 %not, %B
   %and = and i32 %xor2, %xor1
   ret i32 %and
 }
 
 define i32 @test11c(i32 %A, i32 %B) {
 ; CHECK-LABEL: @test11c(
 ; CHECK-NEXT:    [[XOR1:%.*]] = xor i32 [[A:%.*]], [[B:%.*]]
-; CHECK-NEXT:    [[TMP1:%.*]] = xor i32 [[A]], [[B]]
-; CHECK-NEXT:    [[XOR2:%.*]] = xor i32 [[TMP1]], -1
+; CHECK-NEXT:    [[NOT:%.*]] = xor i32 [[A]], -1
+; CHECK-NEXT:    [[XOR2:%.*]] = xor i32 [[NOT]], [[B]]
 ; CHECK-NEXT:    [[AND:%.*]] = and i32 [[XOR1]], [[XOR2]]
 ; CHECK-NEXT:    ret i32 [[AND]]
 ;
   %xor1 = xor i32 %A, %B
   %not = xor i32 %A, -1
   %xor2 = xor i32 %not, %B
   %and = and i32 %xor1, %xor2
   ret i32 %and
 }
 
 define i32 @test11d(i32 %A, i32 %B) {
 ; CHECK-LABEL: @test11d(
 ; CHECK-NEXT:    [[XOR1:%.*]] = xor i32 [[A:%.*]], [[B:%.*]]
-; CHECK-NEXT:    [[TMP1:%.*]] = xor i32 [[A]], [[B]]
-; CHECK-NEXT:    [[XOR2:%.*]] = xor i32 [[TMP1]], -1
-; CHECK-NEXT:    [[AND:%.*]] = and i32 [[XOR1]], [[XOR2]]
+; CHECK-NEXT:    [[NOT:%.*]] = xor i32 [[A]], -1
+; CHECK-NEXT:    [[XOR2:%.*]] = xor i32 [[NOT]], [[B]]
+; CHECK-NEXT:    [[AND:%.*]] = and i32 [[XOR2]], [[XOR1]]
 ; CHECK-NEXT:    ret i32 [[AND]]
 ;
   %xor1 = xor i32 %A, %B
   %not = xor i32 %A, -1
   %xor2 = xor i32 %not, %B
   %and = and i32 %xor2, %xor1
   ret i32 %and
 }
 
 define i32 @test11e(i32 %A, i32 %B, i32 %C) {
 ; CHECK-LABEL: @test11e(
 ; CHECK-NEXT:    [[FORCE:%.*]] = mul i32 [[B:%.*]], [[C:%.*]]
 ; CHECK-NEXT:    [[XOR1:%.*]] = xor i32 [[FORCE]], [[A:%.*]]
-; CHECK-NEXT:    [[TMP1:%.*]] = xor i32 [[FORCE]], [[A]]
-; CHECK-NEXT:    [[XOR2:%.*]] = xor i32 [[TMP1]], -1
+; CHECK-NEXT:    [[NOT:%.*]] = xor i32 [[A]], -1
+; CHECK-NEXT:    [[XOR2:%.*]] = xor i32 [[FORCE]], [[NOT]]
 ; CHECK-NEXT:    [[AND:%.*]] = and i32 [[XOR1]], [[XOR2]]
 ; CHECK-NEXT:    ret i32 [[AND]]
 ;
   %force = mul i32 %B, %C
   %xor1 = xor i32 %force, %A
   %not = xor i32 %A, -1
   %xor2 = xor i32 %force, %not
   %and = and i32 %xor1, %xor2
   ret i32 %and
 }
 
 define i32 @test11f(i32 %A, i32 %B, i32 %C) {
 ; CHECK-LABEL: @test11f(
 ; CHECK-NEXT:    [[FORCE:%.*]] = mul i32 [[B:%.*]], [[C:%.*]]
 ; CHECK-NEXT:    [[XOR1:%.*]] = xor i32 [[FORCE]], [[A:%.*]]
-; CHECK-NEXT:    [[TMP1:%.*]] = xor i32 [[FORCE]], [[A]]
-; CHECK-NEXT:    [[XOR2:%.*]] = xor i32 [[TMP1]], -1
-; CHECK-NEXT:    [[AND:%.*]] = and i32 [[XOR1]], [[XOR2]]
+; CHECK-NEXT:    [[NOT:%.*]] = xor i32 [[A]], -1
+; CHECK-NEXT:    [[XOR2:%.*]] = xor i32 [[FORCE]], [[NOT]]
+; CHECK-NEXT:    [[AND:%.*]] = and i32 [[XOR2]], [[XOR1]]
 ; CHECK-NEXT:    ret i32 [[AND]]
 ;
   %force = mul i32 %B, %C
   %xor1 = xor i32 %force, %A
   %not = xor i32 %A, -1
   %xor2 = xor i32 %force, %not
   %and = and i32 %xor2, %xor1
   ret i32 %and
;
   store i32 %ab, i32* %p2
   %r = xor i32 %ac, %ab
   ret i32 %r
 }
 
 define i8 @test15(i8 %A, i8 %B) {
 ; CHECK-LABEL: @test15(
 ; CHECK-NEXT:    [[XOR1:%.*]] = xor i8 [[B:%.*]], [[A:%.*]]
-; CHECK-NEXT:    [[TMP1:%.*]] = xor i8 [[A]], [[B]]
-; CHECK-NEXT:    [[XOR2:%.*]] = xor i8 [[TMP1]], 33
-; CHECK-NEXT:    [[AND:%.*]] = and i8 [[XOR1]], [[XOR2]]
+; CHECK-NEXT:    [[NOT:%.*]] = xor i8 [[A]], 33
+; CHECK-NEXT:    [[XOR2:%.*]] = xor i8 [[NOT]], [[B]]
+; CHECK-NEXT:    [[AND:%.*]] = and i8 [[XOR1]], -34
 ; CHECK-NEXT:    [[RES:%.*]] = mul i8 [[AND]], [[XOR2]]
 ; CHECK-NEXT:    ret i8 [[RES]]
 ;
   %xor1 = xor i8 %B, %A
   %not = xor i8 %A, 33
   %xor2 = xor i8 %not, %B
   %and = and i8 %xor1, %xor2
   %res = mul i8 %and, %xor2 ; to increase the use count for the xor
   ret i8 %res
 }
 
 define i8 @test16(i8 %A, i8 %B) {
 ; CHECK-LABEL: @test16(
 ; CHECK-NEXT:    [[XOR1:%.*]] = xor i8 [[B:%.*]], [[A:%.*]]
-; CHECK-NEXT:    [[TMP1:%.*]] = xor i8 [[A]], [[B]]
-; CHECK-NEXT:    [[XOR2:%.*]] = xor i8 [[TMP1]], 33
-; CHECK-NEXT:    [[AND:%.*]] = and i8 [[XOR2]], [[XOR1]]
+; CHECK-NEXT:    [[NOT:%.*]] = xor i8 [[A]], 33
+; CHECK-NEXT:    [[XOR2:%.*]] = xor i8 [[NOT]], [[B]]
+; CHECK-NEXT:    [[AND:%.*]] = and i8 [[XOR1]], -34
 ; CHECK-NEXT:    [[RES:%.*]] = mul i8 [[AND]], [[XOR2]]
 ; CHECK-NEXT:    ret i8 [[RES]]
 ;
   %xor1 = xor i8 %B, %A
   %not = xor i8 %A, 33
   %xor2 = xor i8 %not, %B
   %and = and i8 %xor2, %xor1
   %res = mul i8 %and, %xor2 ; to increase the use count for the xor
   ret i8 %res
 }