This is an archive of the discontinued LLVM Phabricator instance.

Differential D116135

[InstCombine] ((~a & ~b & c) | ~(a | b | c) -> ~(a | b)
AbandonedPublic

Authored by rampitec on Dec 21 2021, 3:05 PM.

Details

Reviewers
spatel
Summary

This is a version of (~(a | b) & c) | ~(a | b | c) -> ~(a | b) which is
already handled. However, LHS needs demorganing for the transformation to
happen and it is not demorganed if there are multiple uses of the ~a or ~b.

----------------------------------------
define i4 @src(i4 %a, i4 %b, i4 %c) {
%0:
  %or1 = or i4 %b, %c
  %or2 = or i4 %or1, %a
  %not1 = xor i4 %or2, 15
  %nota = xor i4 %a, 15
  %notb = xor i4 %b, 15
  %and1 = and i4 %nota, %notb
  %and2 = and i4 %and1, %c
  %or4 = or i4 %and2, %not1
  ret i4 %or4
}
=>
define i4 @tgt(i4 %a, i4 %b, i4 %c) {
%0:
  %or = or i4 %a, %b
  %not = xor i4 %or, 15
  ret i4 %not
}
Transformation seems to be correct!

The inverted case: (~a | ~b | c) | ~(a & b & c) -> ~(a & b)

----------------------------------------
define i4 @src(i4 %a, i4 %b, i4 %c) {
%0:
  %and1 = and i4 %b, %c
  %and2 = and i4 %and1, %a
  %not1 = xor i4 %and2, 15
  %nota = xor i4 %a, 15
  %notb = xor i4 %b, 15
  %or1 = or i4 %nota, %notb
  %or2 = or i4 %or1, %c
  %and4 = and i4 %or2, %not1
  ret i4 %and4
}
=>
define i4 @tgt(i4 %a, i4 %b, i4 %c) {
%0:
  %and = and i4 %a, %b
  %not = xor i4 %and, 15
  ret i4 %not
}
Transformation seems to be correct!

Diff Detail

Event Timeline

rampitec created this revision.Dec 21 2021, 3:05 PM
Herald added a subscriber: hiraditya. · View Herald TranscriptDec 21 2021, 3:05 PM
rampitec requested review of this revision.Dec 21 2021, 3:05 PM
Herald added a project: Restricted Project. · View Herald TranscriptDec 21 2021, 3:05 PM
rampitec added a comment.Dec 21 2021, 3:08 PM

I will precommit tests if that is generally OK.

Handling of all the code in the previous block dealing with (~(A | B) & C) is possible, but will overcomplicate the patch a lot and not exactly trivial for the symmetrical case (~(A | B) & C) | (~(A | C) & B).

In general a lot of things would become easier after D114126 if accepted.

Harbormaster completed remote builds in B140311: Diff 395759.Dec 21 2021, 4:23 PM
rampitec updated this revision to Diff 396072.Dec 23 2021, 11:59 AM

Fixed formatting.
It will go under the same LHS as above after D116231 (plus it will need some more tests in this case).

Harbormaster completed remote builds in B140539: Diff 396072.Dec 23 2021, 12:57 PM
rampitec added a child revision: D116254: [InstCombine] (~(a | b) & c) | ~(a | b | c) -> ~(a | b).Dec 23 2021, 2:55 PM
rampitec added a comment.Jan 5 2022, 9:55 AM

ping

rampitec abandoned this revision.Feb 3 2022, 2:03 PM

Revision Contents

PathSize
llvm/
lib/
Transforms/
InstCombine/
29 lines
test/
Transforms/
InstCombine/
774 lines

Diff 395759

llvm/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp

Show First 20 Lines • Show All 1,789 Lines • ▼ Show 20 Lines if (Opcode == Instruction::Or && Op0->hasOneUse() &&
m_c_Xor(m_Specific(A), m_Specific(B)))))))) { m_c_Xor(m_Specific(A), m_Specific(B)))))))) {
// X = ~(A | B) // X = ~(A | B)
// Y = (C | (A ^ B) // Y = (C | (A ^ B)
Value *Or = cast<BinaryOperator>(X)->getOperand(0); Value *Or = cast<BinaryOperator>(X)->getOperand(0);
return BinaryOperator::CreateNot(Builder.CreateAnd(Or, Y)); return BinaryOperator::CreateNot(Builder.CreateAnd(Or, Y));
} }
} }
// Same version of the LHS which is not demorganed if any subexpressions are
// used multiple times, thus match it in this form:
// (~A & ~B & C) | ... --> ...
// (~A | ~B | C) | ... --> ...
// TODO: Generalize it to work with all patterns in the above block instead
// of a separate pattern here.
if (Op0->hasOneUse() &&
(match(Op0,
m_c_BinOp(FlippedOpcode,
m_c_BinOp(FlippedOpcode, m_Value(C), m_Not(m_Value(B))),
m_Not(m_Value(A)))) ||
match(Op0, m_c_BinOp(FlippedOpcode,
m_c_BinOp(FlippedOpcode, m_Not(m_Value(A)),
m_Not(m_Value(B))),
m_Value(C))))) {
// (~A & ~B & C) | ~(A | (B | C)) --> ~(A | B)
// (~A & ~B & C) | ~(B | (A | C)) --> ~(A | B)
// (~A | ~B | C) & ~(A & (B & C)) --> ~(A & B)
// (~A | ~B | C) & ~(B & (A & C)) --> ~(A & B)
if (match(Op1, m_Not(m_c_BinOp(
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-     if (match(Op1, m_Not(m_c_BinOp(
-                        Opcode, m_c_BinOp(Opcode, m_Specific(B), m_Specific(C)),
-                        m_Specific(A)))) ||
-         match(Op1, m_Not(m_c_BinOp(
-                        Opcode, m_c_BinOp(Opcode, m_Specific(A), m_Specific(C)),
+    if (match(Op1, m_Not(m_c_BinOp(
+                       Opcode, m_c_BinOp(Opcode, m_Specific(B), m_Specific(C)),
+                       m_Specific(A)))) ||
+        match(Op1, m_Not(m_c_BinOp(
+                       Opcode, m_c_BinOp(Opcode, m_Specific(A), m_Specific(C)),
Lint: Pre-merge checks: clang-format: please reformat the code ``` - if (match(Op1, m_Not(m_c_BinOp…
Opcode, m_c_BinOp(Opcode, m_Specific(B), m_Specific(C)),
m_Specific(A)))) ||
match(Op1, m_Not(m_c_BinOp(
Opcode, m_c_BinOp(Opcode, m_Specific(A), m_Specific(C)),
m_Specific(B)))))
return BinaryOperator::CreateNot(Builder.CreateBinOp(Opcode, A, B));
}
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-
Lint: Pre-merge checks: clang-format: please reformat the code ``` - ```
// (~A & B & C) | ... --> ... // (~A & B & C) | ... --> ...
// (~A | B | C) | ... --> ... // (~A | B | C) | ... --> ...
// TODO: One use checks are conservative. We just need to check that a total // TODO: One use checks are conservative. We just need to check that a total
// number of multiple used values does not exceed reduction // number of multiple used values does not exceed reduction
// in operations. // in operations.
if (match(Op0, if (match(Op0,
m_OneUse(m_c_BinOp(FlippedOpcode, m_OneUse(m_c_BinOp(FlippedOpcode,
m_BinOp(FlippedOpcode, m_Value(B), m_Value(C)), m_BinOp(FlippedOpcode, m_Value(B), m_Value(C)),
▲ Show 20 Lines • Show All 1,950 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 3,632 Lines • ▼ Show 20 Lines;
%not1 = xor i32 %and1, -1 %not1 = xor i32 %and1, -1
%not2 = xor i32 %a, -1 %not2 = xor i32 %a, -1
%or1 = or i32 %not2, %b %or1 = or i32 %not2, %b
%or2 = or i32 %or1, %c %or2 = or i32 %or1, %c
%and2 = and i32 %or2, %not1 %and2 = and i32 %or2, %not1
call void @use(i32 %or2) call void @use(i32 %or2)
ret i32 %and2 ret i32 %and2
} }
; (~a & ~b & c) | ~(a | (b | c)) -> ~(a | b)
; (~a & ~b & c) | ~(b | (a | c)) -> ~(a | b)
define i32 @not_and_not_and_or_not_or_or(i32 %a, i32 %b, i32 %c) {
; CHECK-LABEL: @not_and_not_and_or_not_or_or(
; CHECK-NEXT: [[NOTA:%.*]] = xor i32 [[A:%.*]], -1
; CHECK-NEXT: [[NOTB:%.*]] = xor i32 [[B:%.*]], -1
; CHECK-NEXT: [[TMP1:%.*]] = or i32 [[A]], [[B]]
; CHECK-NEXT: [[OR4:%.*]] = xor i32 [[TMP1]], -1
; CHECK-NEXT: call void @use(i32 [[NOTA]])
; CHECK-NEXT: call void @use(i32 [[NOTB]])
; CHECK-NEXT: ret i32 [[OR4]]
;
%or1 = or i32 %b, %c
%or2 = or i32 %or1, %a
%not1 = xor i32 %or2, -1
%nota = xor i32 %a, -1
%notb = xor i32 %b, -1
%and1 = and i32 %nota, %notb
%and2 = and i32 %and1, %c
%or4 = or i32 %and2, %not1
call void @use(i32 %nota)
call void @use(i32 %notb)
ret i32 %or4
}
define i32 @not_and_not_and_or_not_or_or_commute1(i32 %a, i32 %b, i32 %c) {
; CHECK-LABEL: @not_and_not_and_or_not_or_or_commute1(
; CHECK-NEXT: [[NOTA:%.*]] = xor i32 [[A:%.*]], -1
; CHECK-NEXT: [[NOTB:%.*]] = xor i32 [[B:%.*]], -1
; CHECK-NEXT: [[TMP1:%.*]] = or i32 [[A]], [[B]]
; CHECK-NEXT: [[OR4:%.*]] = xor i32 [[TMP1]], -1
; CHECK-NEXT: call void @use(i32 [[NOTA]])
; CHECK-NEXT: call void @use(i32 [[NOTB]])
; CHECK-NEXT: ret i32 [[OR4]]
;
%or1 = or i32 %a, %c
%or2 = or i32 %or1, %b
%not1 = xor i32 %or2, -1
%nota = xor i32 %a, -1
%notb = xor i32 %b, -1
%and1 = and i32 %nota, %notb
%and2 = and i32 %and1, %c
%or4 = or i32 %and2, %not1
call void @use(i32 %nota)
call void @use(i32 %notb)
ret i32 %or4
}
define i32 @not_and_not_and_or_not_or_or_commute2(i32 %a, i32 %b, i32 %c) {
; CHECK-LABEL: @not_and_not_and_or_not_or_or_commute2(
; CHECK-NEXT: [[NOTA:%.*]] = xor i32 [[A:%.*]], -1
; CHECK-NEXT: [[NOTB:%.*]] = xor i32 [[B:%.*]], -1
; CHECK-NEXT: [[TMP1:%.*]] = or i32 [[A]], [[B]]
; CHECK-NEXT: [[OR4:%.*]] = xor i32 [[TMP1]], -1
; CHECK-NEXT: call void @use(i32 [[NOTA]])
; CHECK-NEXT: call void @use(i32 [[NOTB]])
; CHECK-NEXT: ret i32 [[OR4]]
;
%or1 = or i32 %c, %b
%or2 = or i32 %or1, %a
%not1 = xor i32 %or2, -1
%nota = xor i32 %a, -1
%notb = xor i32 %b, -1
%and1 = and i32 %nota, %notb
%and2 = and i32 %and1, %c
%or4 = or i32 %and2, %not1
call void @use(i32 %nota)
call void @use(i32 %notb)
ret i32 %or4
}
define i32 @not_and_not_and_or_not_or_or_commute3(i32 %a0, i32 %b, i32 %c) {
; CHECK-LABEL: @not_and_not_and_or_not_or_or_commute3(
; CHECK-NEXT: [[A:%.*]] = sdiv i32 42, [[A0:%.*]]
; CHECK-NEXT: [[NOTA:%.*]] = xor i32 [[A]], -1
; CHECK-NEXT: [[NOTB:%.*]] = xor i32 [[B:%.*]], -1
; CHECK-NEXT: [[TMP1:%.*]] = or i32 [[A]], [[B]]
; CHECK-NEXT: [[OR4:%.*]] = xor i32 [[TMP1]], -1
; CHECK-NEXT: call void @use(i32 [[NOTA]])
; CHECK-NEXT: call void @use(i32 [[NOTB]])
; CHECK-NEXT: ret i32 [[OR4]]
;
%a = sdiv i32 42, %a0 ; thwart complexity-based canonicalization
%or1 = or i32 %b, %c
%or2 = or i32 %a, %or1
%not1 = xor i32 %or2, -1
%nota = xor i32 %a, -1
%notb = xor i32 %b, -1
%and1 = and i32 %nota, %notb
%and2 = and i32 %and1, %c
%or4 = or i32 %and2, %not1
call void @use(i32 %nota)
call void @use(i32 %notb)
ret i32 %or4
}
define i32 @not_and_not_and_or_not_or_or_commute4(i32 %a, i32 %b0, i32 %c) {
; CHECK-LABEL: @not_and_not_and_or_not_or_or_commute4(
; CHECK-NEXT: [[B:%.*]] = sdiv i32 42, [[B0:%.*]]
; CHECK-NEXT: [[NOTA:%.*]] = xor i32 [[A:%.*]], -1
; CHECK-NEXT: [[NOTB:%.*]] = xor i32 [[B]], -1
; CHECK-NEXT: [[TMP1:%.*]] = or i32 [[B]], [[A]]
; CHECK-NEXT: [[OR4:%.*]] = xor i32 [[TMP1]], -1
; CHECK-NEXT: call void @use(i32 [[NOTA]])
; CHECK-NEXT: call void @use(i32 [[NOTB]])
; CHECK-NEXT: ret i32 [[OR4]]
;
%b = sdiv i32 42, %b0 ; thwart complexity-based canonicalization
%or1 = or i32 %a, %c
%or2 = or i32 %b, %or1
%not1 = xor i32 %or2, -1
%nota = xor i32 %a, -1
%notb = xor i32 %b, -1
%and1 = and i32 %nota, %notb
%and2 = and i32 %and1, %c
%or4 = or i32 %and2, %not1
call void @use(i32 %nota)
call void @use(i32 %notb)
ret i32 %or4
}
define i32 @not_and_not_and_or_not_or_or_commute5(i32 %a, i32 %b, i32 %c0) {
; CHECK-LABEL: @not_and_not_and_or_not_or_or_commute5(
; CHECK-NEXT: [[NOTA:%.*]] = xor i32 [[A:%.*]], -1
; CHECK-NEXT: [[NOTB:%.*]] = xor i32 [[B:%.*]], -1
; CHECK-NEXT: [[TMP1:%.*]] = or i32 [[A]], [[B]]
; CHECK-NEXT: [[OR4:%.*]] = xor i32 [[TMP1]], -1
; CHECK-NEXT: call void @use(i32 [[NOTA]])
; CHECK-NEXT: call void @use(i32 [[NOTB]])
; CHECK-NEXT: ret i32 [[OR4]]
;
%c = sdiv i32 42, %c0 ; thwart complexity-based canonicalization
%or1 = or i32 %c, %a
%or2 = or i32 %or1, %b
%not1 = xor i32 %or2, -1
%nota = xor i32 %a, -1
%notb = xor i32 %b, -1
%and1 = and i32 %nota, %notb
%and2 = and i32 %and1, %c
%or4 = or i32 %and2, %not1
call void @use(i32 %nota)
call void @use(i32 %notb)
ret i32 %or4
}
define i32 @not_and_not_and_or_not_or_or_commute6(i32 %a, i32 %b, i32 %c) {
; CHECK-LABEL: @not_and_not_and_or_not_or_or_commute6(
; CHECK-NEXT: [[NOTA:%.*]] = xor i32 [[A:%.*]], -1
; CHECK-NEXT: [[NOTB:%.*]] = xor i32 [[B:%.*]], -1
; CHECK-NEXT: [[TMP1:%.*]] = or i32 [[B]], [[A]]
; CHECK-NEXT: [[OR4:%.*]] = xor i32 [[TMP1]], -1
; CHECK-NEXT: call void @use(i32 [[NOTA]])
; CHECK-NEXT: call void @use(i32 [[NOTB]])
; CHECK-NEXT: ret i32 [[OR4]]
;
%or1 = or i32 %b, %c
%or2 = or i32 %or1, %a
%not1 = xor i32 %or2, -1
%nota = xor i32 %a, -1
%notb = xor i32 %b, -1
%and1 = and i32 %notb, %nota
%and2 = and i32 %and1, %c
%or4 = or i32 %and2, %not1
call void @use(i32 %nota)
call void @use(i32 %notb)
ret i32 %or4
}
define i32 @not_and_not_and_or_not_or_or_commute7(i32 %a, i32 %b, i32 %c0) {
; CHECK-LABEL: @not_and_not_and_or_not_or_or_commute7(
; CHECK-NEXT: [[NOTA:%.*]] = xor i32 [[A:%.*]], -1
; CHECK-NEXT: [[NOTB:%.*]] = xor i32 [[B:%.*]], -1
; CHECK-NEXT: [[TMP1:%.*]] = or i32 [[A]], [[B]]
; CHECK-NEXT: [[OR4:%.*]] = xor i32 [[TMP1]], -1
; CHECK-NEXT: call void @use(i32 [[NOTA]])
; CHECK-NEXT: call void @use(i32 [[NOTB]])
; CHECK-NEXT: ret i32 [[OR4]]
;
%c = sdiv i32 42, %c0 ; thwart complexity-based canonicalization
%or1 = or i32 %b, %c
%or2 = or i32 %or1, %a
%not1 = xor i32 %or2, -1
%nota = xor i32 %a, -1
%notb = xor i32 %b, -1
%and1 = and i32 %nota, %notb
%and2 = and i32 %c, %and1
%or4 = or i32 %and2, %not1
call void @use(i32 %nota)
call void @use(i32 %notb)
ret i32 %or4
}
define i32 @not_and_not_and_or_not_or_or_commute8(i32 %a, i32 %b, i32 %c) {
; CHECK-LABEL: @not_and_not_and_or_not_or_or_commute8(
; CHECK-NEXT: [[OR1:%.*]] = or i32 [[B:%.*]], [[C:%.*]]
; CHECK-NEXT: [[OR2:%.*]] = or i32 [[OR1]], [[A:%.*]]
; CHECK-NEXT: [[NOT1:%.*]] = xor i32 [[OR2]], -1
; CHECK-NEXT: [[NOTA:%.*]] = xor i32 [[A]], -1
; CHECK-NEXT: [[NOTB:%.*]] = xor i32 [[B]], -1
; CHECK-NEXT: [[TMP1:%.*]] = or i32 [[A]], [[B]]
; CHECK-NEXT: [[TMP2:%.*]] = xor i32 [[TMP1]], -1
; CHECK-NEXT: [[AND2:%.*]] = and i32 [[TMP2]], [[C]]
; CHECK-NEXT: [[OR4:%.*]] = or i32 [[AND2]], [[NOT1]]
; CHECK-NEXT: call void @use(i32 [[NOTA]])
; CHECK-NEXT: call void @use(i32 [[NOTB]])
; CHECK-NEXT: ret i32 [[OR4]]
;
%or1 = or i32 %b, %c
%or2 = or i32 %or1, %a
%not1 = xor i32 %or2, -1
%nota = xor i32 %a, -1
%notb = xor i32 %b, -1
%and1 = and i32 %nota, %c
%and2 = and i32 %and1, %notb
%or4 = or i32 %and2, %not1
call void @use(i32 %nota)
call void @use(i32 %notb)
ret i32 %or4
}
define i32 @not_and_not_and_or_not_or_or_commute9(i32 %a, i32 %b, i32 %c) {
; CHECK-LABEL: @not_and_not_and_or_not_or_or_commute9(
; CHECK-NEXT: [[OR1:%.*]] = or i32 [[B:%.*]], [[C:%.*]]
; CHECK-NEXT: [[OR2:%.*]] = or i32 [[OR1]], [[A:%.*]]
; CHECK-NEXT: [[NOT1:%.*]] = xor i32 [[OR2]], -1
; CHECK-NEXT: [[NOTA:%.*]] = xor i32 [[A]], -1
; CHECK-NEXT: [[NOTB:%.*]] = xor i32 [[B]], -1
; CHECK-NEXT: [[TMP1:%.*]] = or i32 [[B]], [[A]]
; CHECK-NEXT: [[TMP2:%.*]] = xor i32 [[TMP1]], -1
; CHECK-NEXT: [[AND2:%.*]] = and i32 [[TMP2]], [[C]]
; CHECK-NEXT: [[OR4:%.*]] = or i32 [[AND2]], [[NOT1]]
; CHECK-NEXT: call void @use(i32 [[NOTA]])
; CHECK-NEXT: call void @use(i32 [[NOTB]])
; CHECK-NEXT: ret i32 [[OR4]]
;
%or1 = or i32 %b, %c
%or2 = or i32 %or1, %a
%not1 = xor i32 %or2, -1
%nota = xor i32 %a, -1
%notb = xor i32 %b, -1
%and1 = and i32 %notb, %c
%and2 = and i32 %and1, %nota
%or4 = or i32 %and2, %not1
call void @use(i32 %nota)
call void @use(i32 %notb)
ret i32 %or4
}
define i32 @not_and_not_and_or_not_or_or_use1(i32 %a, i32 %b, i32 %c) {
; CHECK-LABEL: @not_and_not_and_or_not_or_or_use1(
; CHECK-NEXT: [[OR1:%.*]] = or i32 [[B:%.*]], [[C:%.*]]
; CHECK-NEXT: [[OR2:%.*]] = or i32 [[OR1]], [[A:%.*]]
; CHECK-NEXT: [[NOT1:%.*]] = xor i32 [[OR2]], -1
; CHECK-NEXT: [[NOTA:%.*]] = xor i32 [[A]], -1
; CHECK-NEXT: [[NOTB:%.*]] = xor i32 [[B]], -1
; CHECK-NEXT: [[AND1:%.*]] = and i32 [[NOTA]], [[NOTB]]
; CHECK-NEXT: [[AND2:%.*]] = and i32 [[AND1]], [[C]]
; CHECK-NEXT: [[OR4:%.*]] = or i32 [[AND2]], [[NOT1]]
; CHECK-NEXT: call void @use(i32 [[NOTA]])
; CHECK-NEXT: call void @use(i32 [[NOTB]])
; CHECK-NEXT: call void @use(i32 [[OR1]])
; CHECK-NEXT: call void @use(i32 [[OR2]])
; CHECK-NEXT: call void @use(i32 [[NOT1]])
; CHECK-NEXT: call void @use(i32 [[AND1]])
; CHECK-NEXT: call void @use(i32 [[AND2]])
; CHECK-NEXT: ret i32 [[OR4]]
;
%or1 = or i32 %b, %c
%or2 = or i32 %or1, %a
%not1 = xor i32 %or2, -1
%nota = xor i32 %a, -1
%notb = xor i32 %b, -1
%and1 = and i32 %nota, %notb
%and2 = and i32 %and1, %c
%or4 = or i32 %and2, %not1
call void @use(i32 %nota)
call void @use(i32 %notb)
call void @use(i32 %or1)
call void @use(i32 %or2)
call void @use(i32 %not1)
call void @use(i32 %and1)
call void @use(i32 %and2)
ret i32 %or4
}
define i32 @not_and_not_and_or_not_or_or_use2(i32 %a, i32 %b, i32 %c) {
; CHECK-LABEL: @not_and_not_and_or_not_or_or_use2(
; CHECK-NEXT: [[OR1:%.*]] = or i32 [[B:%.*]], [[C:%.*]]
; CHECK-NEXT: [[OR2:%.*]] = or i32 [[OR1]], [[A:%.*]]
; CHECK-NEXT: [[NOT1:%.*]] = xor i32 [[OR2]], -1
; CHECK-NEXT: [[NOTA:%.*]] = xor i32 [[A]], -1
; CHECK-NEXT: [[NOTB:%.*]] = xor i32 [[B]], -1
; CHECK-NEXT: [[AND1:%.*]] = and i32 [[NOTA]], [[NOTB]]
; CHECK-NEXT: [[AND2:%.*]] = and i32 [[AND1]], [[C]]
; CHECK-NEXT: [[OR4:%.*]] = or i32 [[AND2]], [[NOT1]]
; CHECK-NEXT: call void @use(i32 [[NOTA]])
; CHECK-NEXT: call void @use(i32 [[NOTB]])
; CHECK-NEXT: call void @use(i32 [[OR2]])
; CHECK-NEXT: call void @use(i32 [[NOT1]])
; CHECK-NEXT: call void @use(i32 [[AND1]])
; CHECK-NEXT: call void @use(i32 [[AND2]])
; CHECK-NEXT: ret i32 [[OR4]]
;
%or1 = or i32 %b, %c
%or2 = or i32 %or1, %a
%not1 = xor i32 %or2, -1
%nota = xor i32 %a, -1
%notb = xor i32 %b, -1
%and1 = and i32 %nota, %notb
%and2 = and i32 %and1, %c
%or4 = or i32 %and2, %not1
call void @use(i32 %nota)
call void @use(i32 %notb)
call void @use(i32 %or2)
call void @use(i32 %not1)
call void @use(i32 %and1)
call void @use(i32 %and2)
ret i32 %or4
}
define i32 @not_and_not_and_or_not_or_or_use3(i32 %a, i32 %b, i32 %c) {
; CHECK-LABEL: @not_and_not_and_or_not_or_or_use3(
; CHECK-NEXT: [[OR1:%.*]] = or i32 [[B:%.*]], [[C:%.*]]
; CHECK-NEXT: [[OR2:%.*]] = or i32 [[OR1]], [[A:%.*]]
; CHECK-NEXT: [[NOT1:%.*]] = xor i32 [[OR2]], -1
; CHECK-NEXT: [[NOTA:%.*]] = xor i32 [[A]], -1
; CHECK-NEXT: [[NOTB:%.*]] = xor i32 [[B]], -1
; CHECK-NEXT: [[AND1:%.*]] = and i32 [[NOTA]], [[NOTB]]
; CHECK-NEXT: [[TMP1:%.*]] = or i32 [[A]], [[B]]
; CHECK-NEXT: [[OR4:%.*]] = xor i32 [[TMP1]], -1
; CHECK-NEXT: call void @use(i32 [[NOTA]])
; CHECK-NEXT: call void @use(i32 [[NOTB]])
; CHECK-NEXT: call void @use(i32 [[OR1]])
; CHECK-NEXT: call void @use(i32 [[OR2]])
; CHECK-NEXT: call void @use(i32 [[NOT1]])
; CHECK-NEXT: call void @use(i32 [[AND1]])
; CHECK-NEXT: ret i32 [[OR4]]
;
%or1 = or i32 %b, %c
%or2 = or i32 %or1, %a
%not1 = xor i32 %or2, -1
%nota = xor i32 %a, -1
%notb = xor i32 %b, -1
%and1 = and i32 %nota, %notb
%and2 = and i32 %and1, %c
%or4 = or i32 %and2, %not1
call void @use(i32 %nota)
call void @use(i32 %notb)
call void @use(i32 %or1)
call void @use(i32 %or2)
call void @use(i32 %not1)
call void @use(i32 %and1)
ret i32 %or4
}
define i32 @not_and_not_and_or_not_or_or_use4(i32 %a, i32 %b, i32 %c) {
; CHECK-LABEL: @not_and_not_and_or_not_or_or_use4(
; CHECK-NEXT: [[OR1:%.*]] = or i32 [[B:%.*]], [[C:%.*]]
; CHECK-NEXT: [[OR2:%.*]] = or i32 [[OR1]], [[A:%.*]]
; CHECK-NEXT: [[NOT1:%.*]] = xor i32 [[OR2]], -1
; CHECK-NEXT: [[NOTA:%.*]] = xor i32 [[A]], -1
; CHECK-NEXT: [[NOTB:%.*]] = xor i32 [[B]], -1
; CHECK-NEXT: [[TMP1:%.*]] = or i32 [[A]], [[B]]
; CHECK-NEXT: [[OR4:%.*]] = xor i32 [[TMP1]], -1
; CHECK-NEXT: call void @use(i32 [[NOTA]])
; CHECK-NEXT: call void @use(i32 [[NOTB]])
; CHECK-NEXT: call void @use(i32 [[OR1]])
; CHECK-NEXT: call void @use(i32 [[OR2]])
; CHECK-NEXT: call void @use(i32 [[NOT1]])
; CHECK-NEXT: ret i32 [[OR4]]
;
%or1 = or i32 %b, %c
%or2 = or i32 %or1, %a
%not1 = xor i32 %or2, -1
%nota = xor i32 %a, -1
%notb = xor i32 %b, -1
%and1 = and i32 %nota, %notb
%and2 = and i32 %and1, %c
%or4 = or i32 %and2, %not1
call void @use(i32 %nota)
call void @use(i32 %notb)
call void @use(i32 %or1)
call void @use(i32 %or2)
call void @use(i32 %not1)
ret i32 %or4
}
; (~a | ~b | c) | ~(a & (b & c)) -> ~(a & b)
; (~a | ~b | c) | ~(b & (a & c)) -> ~(a & b)
define i32 @not_or_not_or_and_not_and_and(i32 %a, i32 %b, i32 %c) {
; CHECK-LABEL: @not_or_not_or_and_not_and_and(
; CHECK-NEXT: [[NOTA:%.*]] = xor i32 [[A:%.*]], -1
; CHECK-NEXT: [[NOTB:%.*]] = xor i32 [[B:%.*]], -1
; CHECK-NEXT: [[TMP1:%.*]] = and i32 [[A]], [[B]]
; CHECK-NEXT: [[AND4:%.*]] = xor i32 [[TMP1]], -1
; CHECK-NEXT: call void @use(i32 [[NOTA]])
; CHECK-NEXT: call void @use(i32 [[NOTB]])
; CHECK-NEXT: ret i32 [[AND4]]
;
%and1 = and i32 %b, %c
%and2 = and i32 %and1, %a
%not1 = xor i32 %and2, -1
%nota = xor i32 %a, -1
%notb = xor i32 %b, -1
%or1 = or i32 %nota, %notb
%or2 = or i32 %or1, %c
%and4 = and i32 %or2, %not1
call void @use(i32 %nota)
call void @use(i32 %notb)
ret i32 %and4
}
define i32 @not_or_not_or_and_not_and_and_commute1(i32 %a, i32 %b, i32 %c) {
; CHECK-LABEL: @not_or_not_or_and_not_and_and_commute1(
; CHECK-NEXT: [[NOTA:%.*]] = xor i32 [[A:%.*]], -1
; CHECK-NEXT: [[NOTB:%.*]] = xor i32 [[B:%.*]], -1
; CHECK-NEXT: [[TMP1:%.*]] = and i32 [[A]], [[B]]
; CHECK-NEXT: [[AND4:%.*]] = xor i32 [[TMP1]], -1
; CHECK-NEXT: call void @use(i32 [[NOTA]])
; CHECK-NEXT: call void @use(i32 [[NOTB]])
; CHECK-NEXT: ret i32 [[AND4]]
;
%and1 = and i32 %a, %c
%and2 = and i32 %and1, %b
%not1 = xor i32 %and2, -1
%nota = xor i32 %a, -1
%notb = xor i32 %b, -1
%or1 = or i32 %nota, %notb
%or2 = or i32 %or1, %c
%and4 = and i32 %or2, %not1
call void @use(i32 %nota)
call void @use(i32 %notb)
ret i32 %and4
}
define i32 @not_or_not_or_and_not_and_and_commute2(i32 %a, i32 %b, i32 %c) {
; CHECK-LABEL: @not_or_not_or_and_not_and_and_commute2(
; CHECK-NEXT: [[NOTA:%.*]] = xor i32 [[A:%.*]], -1
; CHECK-NEXT: [[NOTB:%.*]] = xor i32 [[B:%.*]], -1
; CHECK-NEXT: [[TMP1:%.*]] = and i32 [[A]], [[B]]
; CHECK-NEXT: [[AND4:%.*]] = xor i32 [[TMP1]], -1
; CHECK-NEXT: call void @use(i32 [[NOTA]])
; CHECK-NEXT: call void @use(i32 [[NOTB]])
; CHECK-NEXT: ret i32 [[AND4]]
;
%and1 = and i32 %c, %b
%and2 = and i32 %and1, %a
%not1 = xor i32 %and2, -1
%nota = xor i32 %a, -1
%notb = xor i32 %b, -1
%or1 = or i32 %nota, %notb
%or2 = or i32 %or1, %c
%and4 = and i32 %or2, %not1
call void @use(i32 %nota)
call void @use(i32 %notb)
ret i32 %and4
}
define i32 @not_or_not_or_and_not_and_and_commute3(i32 %a0, i32 %b, i32 %c) {
; CHECK-LABEL: @not_or_not_or_and_not_and_and_commute3(
; CHECK-NEXT: [[A:%.*]] = sdiv i32 42, [[A0:%.*]]
; CHECK-NEXT: [[NOTA:%.*]] = xor i32 [[A]], -1
; CHECK-NEXT: [[NOTB:%.*]] = xor i32 [[B:%.*]], -1
; CHECK-NEXT: [[TMP1:%.*]] = and i32 [[A]], [[B]]
; CHECK-NEXT: [[AND4:%.*]] = xor i32 [[TMP1]], -1
; CHECK-NEXT: call void @use(i32 [[NOTA]])
; CHECK-NEXT: call void @use(i32 [[NOTB]])
; CHECK-NEXT: ret i32 [[AND4]]
;
%a = sdiv i32 42, %a0 ; thwart complexity-based canonicalization
%and1 = and i32 %b, %c
%and2 = and i32 %a, %and1
%not1 = xor i32 %and2, -1
%nota = xor i32 %a, -1
%notb = xor i32 %b, -1
%or1 = or i32 %nota, %notb
%or2 = or i32 %or1, %c
%and4 = and i32 %or2, %not1
call void @use(i32 %nota)
call void @use(i32 %notb)
ret i32 %and4
}
define i32 @not_or_not_or_and_not_and_and_commute4(i32 %a, i32 %b0, i32 %c) {
; CHECK-LABEL: @not_or_not_or_and_not_and_and_commute4(
; CHECK-NEXT: [[B:%.*]] = sdiv i32 42, [[B0:%.*]]
; CHECK-NEXT: [[NOTA:%.*]] = xor i32 [[A:%.*]], -1
; CHECK-NEXT: [[NOTB:%.*]] = xor i32 [[B]], -1
; CHECK-NEXT: [[TMP1:%.*]] = and i32 [[B]], [[A]]
; CHECK-NEXT: [[AND4:%.*]] = xor i32 [[TMP1]], -1
; CHECK-NEXT: call void @use(i32 [[NOTA]])
; CHECK-NEXT: call void @use(i32 [[NOTB]])
; CHECK-NEXT: ret i32 [[AND4]]
;
%b = sdiv i32 42, %b0 ; thwart complexity-based canonicalization
%and1 = and i32 %a, %c
%and2 = and i32 %b, %and1
%not1 = xor i32 %and2, -1
%nota = xor i32 %a, -1
%notb = xor i32 %b, -1
%or1 = or i32 %nota, %notb
%or2 = or i32 %or1, %c
%and4 = and i32 %or2, %not1
call void @use(i32 %nota)
call void @use(i32 %notb)
ret i32 %and4
}
define i32 @not_or_not_or_and_not_and_and_commute5(i32 %a, i32 %b, i32 %c0) {
; CHECK-LABEL: @not_or_not_or_and_not_and_and_commute5(
; CHECK-NEXT: [[NOTA:%.*]] = xor i32 [[A:%.*]], -1
; CHECK-NEXT: [[NOTB:%.*]] = xor i32 [[B:%.*]], -1
; CHECK-NEXT: [[TMP1:%.*]] = and i32 [[A]], [[B]]
; CHECK-NEXT: [[AND4:%.*]] = xor i32 [[TMP1]], -1
; CHECK-NEXT: call void @use(i32 [[NOTA]])
; CHECK-NEXT: call void @use(i32 [[NOTB]])
; CHECK-NEXT: ret i32 [[AND4]]
;
%c = sdiv i32 42, %c0 ; thwart complexity-based canonicalization
%and1 = and i32 %c, %a
%and2 = and i32 %and1, %b
%not1 = xor i32 %and2, -1
%nota = xor i32 %a, -1
%notb = xor i32 %b, -1
%or1 = or i32 %nota, %notb
%or2 = or i32 %or1, %c
%and4 = and i32 %or2, %not1
call void @use(i32 %nota)
call void @use(i32 %notb)
ret i32 %and4
}
define i32 @not_or_not_or_and_not_and_and_commute6(i32 %a, i32 %b, i32 %c) {
; CHECK-LABEL: @not_or_not_or_and_not_and_and_commute6(
; CHECK-NEXT: [[NOTA:%.*]] = xor i32 [[A:%.*]], -1
; CHECK-NEXT: [[NOTB:%.*]] = xor i32 [[B:%.*]], -1
; CHECK-NEXT: [[TMP1:%.*]] = and i32 [[B]], [[A]]
; CHECK-NEXT: [[AND4:%.*]] = xor i32 [[TMP1]], -1
; CHECK-NEXT: call void @use(i32 [[NOTA]])
; CHECK-NEXT: call void @use(i32 [[NOTB]])
; CHECK-NEXT: ret i32 [[AND4]]
;
%and1 = and i32 %b, %c
%and2 = and i32 %and1, %a
%not1 = xor i32 %and2, -1
%nota = xor i32 %a, -1
%notb = xor i32 %b, -1
%or1 = or i32 %notb, %nota
%or2 = or i32 %or1, %c
%and4 = and i32 %or2, %not1
call void @use(i32 %nota)
call void @use(i32 %notb)
ret i32 %and4
}
define i32 @not_or_not_or_and_not_and_and_commute7(i32 %a, i32 %b, i32 %c0) {
; CHECK-LABEL: @not_or_not_or_and_not_and_and_commute7(
; CHECK-NEXT: [[NOTA:%.*]] = xor i32 [[A:%.*]], -1
; CHECK-NEXT: [[NOTB:%.*]] = xor i32 [[B:%.*]], -1
; CHECK-NEXT: [[TMP1:%.*]] = and i32 [[A]], [[B]]
; CHECK-NEXT: [[AND4:%.*]] = xor i32 [[TMP1]], -1
; CHECK-NEXT: call void @use(i32 [[NOTA]])
; CHECK-NEXT: call void @use(i32 [[NOTB]])
; CHECK-NEXT: ret i32 [[AND4]]
;
%c = sdiv i32 42, %c0 ; thwart complexity-based canonicalization
%and1 = and i32 %b, %c
%and2 = and i32 %and1, %a
%not1 = xor i32 %and2, -1
%nota = xor i32 %a, -1
%notb = xor i32 %b, -1
%or1 = or i32 %nota, %notb
%or2 = or i32 %c, %or1
%and4 = and i32 %or2, %not1
call void @use(i32 %nota)
call void @use(i32 %notb)
ret i32 %and4
}
define i32 @not_or_not_or_and_not_and_and_commute8(i32 %a, i32 %b, i32 %c) {
; CHECK-LABEL: @not_or_not_or_and_not_and_and_commute8(
; CHECK-NEXT: [[AND1:%.*]] = and i32 [[B:%.*]], [[C:%.*]]
; CHECK-NEXT: [[AND2:%.*]] = and i32 [[AND1]], [[A:%.*]]
; CHECK-NEXT: [[NOTA:%.*]] = xor i32 [[A]], -1
; CHECK-NEXT: [[NOTB:%.*]] = xor i32 [[B]], -1
; CHECK-NEXT: [[TMP1:%.*]] = and i32 [[A]], [[B]]
; CHECK-NEXT: [[TMP2:%.*]] = xor i32 [[TMP1]], -1
; CHECK-NEXT: [[OR2:%.*]] = or i32 [[TMP2]], [[C]]
; CHECK-NEXT: [[AND4:%.*]] = xor i32 [[AND2]], [[OR2]]
; CHECK-NEXT: call void @use(i32 [[NOTA]])
; CHECK-NEXT: call void @use(i32 [[NOTB]])
; CHECK-NEXT: ret i32 [[AND4]]
;
%and1 = and i32 %b, %c
%and2 = and i32 %and1, %a
%not1 = xor i32 %and2, -1
%nota = xor i32 %a, -1
%notb = xor i32 %b, -1
%or1 = or i32 %nota, %c
%or2 = or i32 %or1, %notb
%and4 = and i32 %or2, %not1
call void @use(i32 %nota)
call void @use(i32 %notb)
ret i32 %and4
}
define i32 @not_or_not_or_and_not_and_and_commute9(i32 %a, i32 %b, i32 %c) {
; CHECK-LABEL: @not_or_not_or_and_not_and_and_commute9(
; CHECK-NEXT: [[AND1:%.*]] = and i32 [[B:%.*]], [[C:%.*]]
; CHECK-NEXT: [[AND2:%.*]] = and i32 [[AND1]], [[A:%.*]]
; CHECK-NEXT: [[NOTA:%.*]] = xor i32 [[A]], -1
; CHECK-NEXT: [[NOTB:%.*]] = xor i32 [[B]], -1
; CHECK-NEXT: [[TMP1:%.*]] = and i32 [[B]], [[A]]
; CHECK-NEXT: [[TMP2:%.*]] = xor i32 [[TMP1]], -1
; CHECK-NEXT: [[OR2:%.*]] = or i32 [[TMP2]], [[C]]
; CHECK-NEXT: [[AND4:%.*]] = xor i32 [[AND2]], [[OR2]]
; CHECK-NEXT: call void @use(i32 [[NOTA]])
; CHECK-NEXT: call void @use(i32 [[NOTB]])
; CHECK-NEXT: ret i32 [[AND4]]
;
%and1 = and i32 %b, %c
%and2 = and i32 %and1, %a
%not1 = xor i32 %and2, -1
%nota = xor i32 %a, -1
%notb = xor i32 %b, -1
%or1 = or i32 %notb, %c
%or2 = or i32 %or1, %nota
%and4 = and i32 %or2, %not1
call void @use(i32 %nota)
call void @use(i32 %notb)
ret i32 %and4
}
define i32 @not_or_not_or_and_not_and_and_use1(i32 %a, i32 %b, i32 %c) {
; CHECK-LABEL: @not_or_not_or_and_not_and_and_use1(
; CHECK-NEXT: [[AND1:%.*]] = and i32 [[B:%.*]], [[C:%.*]]
; CHECK-NEXT: [[AND2:%.*]] = and i32 [[AND1]], [[A:%.*]]
; CHECK-NEXT: [[NOT1:%.*]] = xor i32 [[AND2]], -1
; CHECK-NEXT: [[NOTA:%.*]] = xor i32 [[A]], -1
; CHECK-NEXT: [[NOTB:%.*]] = xor i32 [[B]], -1
; CHECK-NEXT: [[OR1:%.*]] = or i32 [[NOTA]], [[NOTB]]
; CHECK-NEXT: [[OR2:%.*]] = or i32 [[OR1]], [[C]]
; CHECK-NEXT: [[AND4:%.*]] = xor i32 [[AND2]], [[OR2]]
; CHECK-NEXT: call void @use(i32 [[NOTA]])
; CHECK-NEXT: call void @use(i32 [[NOTB]])
; CHECK-NEXT: call void @use(i32 [[AND1]])
; CHECK-NEXT: call void @use(i32 [[AND2]])
; CHECK-NEXT: call void @use(i32 [[NOT1]])
; CHECK-NEXT: call void @use(i32 [[OR1]])
; CHECK-NEXT: call void @use(i32 [[OR2]])
; CHECK-NEXT: ret i32 [[AND4]]
;
%and1 = and i32 %b, %c
%and2 = and i32 %and1, %a
%not1 = xor i32 %and2, -1
%nota = xor i32 %a, -1
%notb = xor i32 %b, -1
%or1 = or i32 %nota, %notb
%or2 = or i32 %or1, %c
%and4 = and i32 %or2, %not1
call void @use(i32 %nota)
call void @use(i32 %notb)
call void @use(i32 %and1)
call void @use(i32 %and2)
call void @use(i32 %not1)
call void @use(i32 %or1)
call void @use(i32 %or2)
ret i32 %and4
}
define i32 @not_or_not_or_and_not_and_and_use2(i32 %a, i32 %b, i32 %c) {
; CHECK-LABEL: @not_or_not_or_and_not_and_and_use2(
; CHECK-NEXT: [[AND1:%.*]] = and i32 [[B:%.*]], [[C:%.*]]
; CHECK-NEXT: [[AND2:%.*]] = and i32 [[AND1]], [[A:%.*]]
; CHECK-NEXT: [[NOT1:%.*]] = xor i32 [[AND2]], -1
; CHECK-NEXT: [[NOTA:%.*]] = xor i32 [[A]], -1
; CHECK-NEXT: [[NOTB:%.*]] = xor i32 [[B]], -1
; CHECK-NEXT: [[OR1:%.*]] = or i32 [[NOTA]], [[NOTB]]
; CHECK-NEXT: [[OR2:%.*]] = or i32 [[OR1]], [[C]]
; CHECK-NEXT: [[AND4:%.*]] = xor i32 [[AND2]], [[OR2]]
; CHECK-NEXT: call void @use(i32 [[NOTA]])
; CHECK-NEXT: call void @use(i32 [[NOTB]])
; CHECK-NEXT: call void @use(i32 [[AND2]])
; CHECK-NEXT: call void @use(i32 [[NOT1]])
; CHECK-NEXT: call void @use(i32 [[OR1]])
; CHECK-NEXT: call void @use(i32 [[OR2]])
; CHECK-NEXT: ret i32 [[AND4]]
;
%and1 = and i32 %b, %c
%and2 = and i32 %and1, %a
%not1 = xor i32 %and2, -1
%nota = xor i32 %a, -1
%notb = xor i32 %b, -1
%or1 = or i32 %nota, %notb
%or2 = or i32 %or1, %c
%and4 = and i32 %or2, %not1
call void @use(i32 %nota)
call void @use(i32 %notb)
call void @use(i32 %and2)
call void @use(i32 %not1)
call void @use(i32 %or1)
call void @use(i32 %or2)
ret i32 %and4
}
define i32 @not_or_not_or_and_not_and_and_use3(i32 %a, i32 %b, i32 %c) {
; CHECK-LABEL: @not_or_not_or_and_not_and_and_use3(
; CHECK-NEXT: [[AND1:%.*]] = and i32 [[B:%.*]], [[C:%.*]]
; CHECK-NEXT: [[AND2:%.*]] = and i32 [[AND1]], [[A:%.*]]
; CHECK-NEXT: [[NOT1:%.*]] = xor i32 [[AND2]], -1
; CHECK-NEXT: [[NOTA:%.*]] = xor i32 [[A]], -1
; CHECK-NEXT: [[NOTB:%.*]] = xor i32 [[B]], -1
; CHECK-NEXT: [[OR1:%.*]] = or i32 [[NOTA]], [[NOTB]]
; CHECK-NEXT: [[TMP1:%.*]] = and i32 [[A]], [[B]]
; CHECK-NEXT: [[AND4:%.*]] = xor i32 [[TMP1]], -1
; CHECK-NEXT: call void @use(i32 [[NOTA]])
; CHECK-NEXT: call void @use(i32 [[NOTB]])
; CHECK-NEXT: call void @use(i32 [[AND1]])
; CHECK-NEXT: call void @use(i32 [[AND2]])
; CHECK-NEXT: call void @use(i32 [[NOT1]])
; CHECK-NEXT: call void @use(i32 [[OR1]])
; CHECK-NEXT: ret i32 [[AND4]]
;
%and1 = and i32 %b, %c
%and2 = and i32 %and1, %a
%not1 = xor i32 %and2, -1
%nota = xor i32 %a, -1
%notb = xor i32 %b, -1
%or1 = or i32 %nota, %notb
%or2 = or i32 %or1, %c
%and4 = and i32 %or2, %not1
call void @use(i32 %nota)
call void @use(i32 %notb)
call void @use(i32 %and1)
call void @use(i32 %and2)
call void @use(i32 %not1)
call void @use(i32 %or1)
ret i32 %and4
}
define i32 @not_or_not_or_and_not_and_and_use4(i32 %a, i32 %b, i32 %c) {
; CHECK-LABEL: @not_or_not_or_and_not_and_and_use4(
; CHECK-NEXT: [[AND1:%.*]] = and i32 [[B:%.*]], [[C:%.*]]
; CHECK-NEXT: [[AND2:%.*]] = and i32 [[AND1]], [[A:%.*]]
; CHECK-NEXT: [[NOT1:%.*]] = xor i32 [[AND2]], -1
; CHECK-NEXT: [[NOTA:%.*]] = xor i32 [[A]], -1
; CHECK-NEXT: [[NOTB:%.*]] = xor i32 [[B]], -1
; CHECK-NEXT: [[TMP1:%.*]] = and i32 [[A]], [[B]]
; CHECK-NEXT: [[AND4:%.*]] = xor i32 [[TMP1]], -1
; CHECK-NEXT: call void @use(i32 [[NOTA]])
; CHECK-NEXT: call void @use(i32 [[NOTB]])
; CHECK-NEXT: call void @use(i32 [[AND1]])
; CHECK-NEXT: call void @use(i32 [[AND2]])
; CHECK-NEXT: call void @use(i32 [[NOT1]])
; CHECK-NEXT: ret i32 [[AND4]]
;
%and1 = and i32 %b, %c
%and2 = and i32 %and1, %a
%not1 = xor i32 %and2, -1
%nota = xor i32 %a, -1
%notb = xor i32 %b, -1
%or1 = or i32 %nota, %notb
%or2 = or i32 %or1, %c
%and4 = and i32 %or2, %not1
call void @use(i32 %nota)
call void @use(i32 %notb)
call void @use(i32 %and1)
call void @use(i32 %and2)
call void @use(i32 %not1)
ret i32 %and4
}