This is an archive of the discontinued LLVM Phabricator instance.

Paths

Table of Contentst

-
llvm/
-
lib/Transforms/InstCombine/
-
Transforms/
-
InstCombine/
-
InstCombineAndOrXor.cpp
-
test/Transforms/InstCombine/
-
Transforms/
-
InstCombine/
-
and-xor-or.ll

Differential D116135

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

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

Download Raw Diff

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

Unit TestsFailed

	Time	Test
	50 ms	x64 debian > LLVM.Bindings/Go::go.test

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

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

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

ping

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

Revision Contents

Path

Size

llvm/

lib/

Transforms/

InstCombine/

InstCombineAndOrXor.cpp

28 lines

test/

Transforms/

InstCombine/

and-xor-or.ll

774 lines

Diff 396072

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(
		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));
		}

// (~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
		}