From 557f4ce0c3d2a9221ebd12897e6faf8e206bd2cc Mon Sep 17 00:00:00 2001 From: Stanislav Mekhanoshin Date: Wed, 10 Nov 2021 13:12:25 -0800 Subject: [PATCH] [InstCombine] Precommit updated and-xor-or.ll tests. NFC. Tests for: ``` (a | ~(b & c)) & ~(a & (b ^ c)) --> ~(a | b) | (a ^ b ^ 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 ^ c) (~a | b | c) & ~(a & b) -> (c & ~b) | ~a ``` --- .../test/Transforms/InstCombine/and-xor-or.ll | 1038 +++++++++++++++++ 1 file changed, 1038 insertions(+) diff --git a/llvm/test/Transforms/InstCombine/and-xor-or.ll b/llvm/test/Transforms/InstCombine/and-xor-or.ll index 5c89c10002ef..5b5517c4acf4 100644 --- a/llvm/test/Transforms/InstCombine/and-xor-or.ll +++ b/llvm/test/Transforms/InstCombine/and-xor-or.ll @@ -2353,6 +2353,265 @@ define i32 @and_not_or_or_not_or_xor_use6(i32 %a, i32 %b, i32 %c) { ret i32 %or3 } +; (a | ~(b & c)) & ~(a & (b ^ c)) --> ~(a | b) | (a ^ b ^ c) + +define i32 @or_not_and_and_not_and_xor(i32 %a, i32 %b, i32 %c) { +; CHECK-LABEL: @or_not_and_and_not_and_xor( +; CHECK-NEXT: [[AND1:%.*]] = and i32 [[B:%.*]], [[C:%.*]] +; CHECK-NEXT: [[NOT1:%.*]] = xor i32 [[AND1]], -1 +; CHECK-NEXT: [[OR1:%.*]] = or i32 [[NOT1]], [[A:%.*]] +; CHECK-NEXT: [[XOR1:%.*]] = xor i32 [[B]], [[C]] +; CHECK-NEXT: [[AND2:%.*]] = and i32 [[XOR1]], [[A]] +; CHECK-NEXT: [[AND3:%.*]] = xor i32 [[AND2]], [[OR1]] +; CHECK-NEXT: ret i32 [[AND3]] +; + %and1 = and i32 %b, %c + %not1 = xor i32 %and1, -1 + %or1 = or i32 %not1, %a + %xor1 = xor i32 %b, %c + %and2 = and i32 %xor1, %a + %not2 = xor i32 %and2, -1 + %and3 = and i32 %or1, %not2 + ret i32 %and3 +} + +define i32 @or_not_and_and_not_and_xor_commute1(i32 %a, i32 %b, i32 %c) { +; CHECK-LABEL: @or_not_and_and_not_and_xor_commute1( +; CHECK-NEXT: [[AND1:%.*]] = and i32 [[C:%.*]], [[B:%.*]] +; CHECK-NEXT: [[NOT1:%.*]] = xor i32 [[AND1]], -1 +; CHECK-NEXT: [[OR1:%.*]] = or i32 [[NOT1]], [[A:%.*]] +; CHECK-NEXT: [[XOR1:%.*]] = xor i32 [[B]], [[C]] +; CHECK-NEXT: [[AND2:%.*]] = and i32 [[XOR1]], [[A]] +; CHECK-NEXT: [[AND3:%.*]] = xor i32 [[AND2]], [[OR1]] +; CHECK-NEXT: ret i32 [[AND3]] +; + %and1 = and i32 %c, %b + %not1 = xor i32 %and1, -1 + %or1 = or i32 %not1, %a + %xor1 = xor i32 %b, %c + %and2 = and i32 %xor1, %a + %not2 = xor i32 %and2, -1 + %and3 = and i32 %or1, %not2 + ret i32 %and3 +} + +define i32 @or_not_and_and_not_and_xor_commute2(i32 %a0, i32 %b, i32 %c) { +; CHECK-LABEL: @or_not_and_and_not_and_xor_commute2( +; CHECK-NEXT: [[A:%.*]] = sdiv i32 42, [[A0:%.*]] +; CHECK-NEXT: [[AND1:%.*]] = and i32 [[B:%.*]], [[C:%.*]] +; CHECK-NEXT: [[NOT1:%.*]] = xor i32 [[AND1]], -1 +; CHECK-NEXT: [[OR1:%.*]] = or i32 [[A]], [[NOT1]] +; CHECK-NEXT: [[XOR1:%.*]] = xor i32 [[B]], [[C]] +; CHECK-NEXT: [[AND2:%.*]] = and i32 [[XOR1]], [[A]] +; CHECK-NEXT: [[AND3:%.*]] = xor i32 [[AND2]], [[OR1]] +; CHECK-NEXT: ret i32 [[AND3]] +; + %a = sdiv i32 42, %a0 ; thwart complexity-based canonicalization + %and1 = and i32 %b, %c + %not1 = xor i32 %and1, -1 + %or1 = or i32 %a, %not1 + %xor1 = xor i32 %b, %c + %and2 = and i32 %xor1, %a + %not2 = xor i32 %and2, -1 + %and3 = and i32 %or1, %not2 + ret i32 %and3 +} + +define i32 @or_not_and_and_not_and_xor_commute3(i32 %a, i32 %b, i32 %c) { +; CHECK-LABEL: @or_not_and_and_not_and_xor_commute3( +; CHECK-NEXT: [[AND1:%.*]] = and i32 [[B:%.*]], [[C:%.*]] +; CHECK-NEXT: [[NOT1:%.*]] = xor i32 [[AND1]], -1 +; CHECK-NEXT: [[OR1:%.*]] = or i32 [[NOT1]], [[A:%.*]] +; CHECK-NEXT: [[XOR1:%.*]] = xor i32 [[C]], [[B]] +; CHECK-NEXT: [[AND2:%.*]] = and i32 [[XOR1]], [[A]] +; CHECK-NEXT: [[AND3:%.*]] = xor i32 [[AND2]], [[OR1]] +; CHECK-NEXT: ret i32 [[AND3]] +; + %and1 = and i32 %b, %c + %not1 = xor i32 %and1, -1 + %or1 = or i32 %not1, %a + %xor1 = xor i32 %c, %b + %and2 = and i32 %xor1, %a + %not2 = xor i32 %and2, -1 + %and3 = and i32 %or1, %not2 + ret i32 %and3 +} + +define i32 @or_not_and_and_not_and_xor_commute4(i32 %a0, i32 %b, i32 %c) { +; CHECK-LABEL: @or_not_and_and_not_and_xor_commute4( +; CHECK-NEXT: [[A:%.*]] = sdiv i32 42, [[A0:%.*]] +; CHECK-NEXT: [[AND1:%.*]] = and i32 [[B:%.*]], [[C:%.*]] +; CHECK-NEXT: [[NOT1:%.*]] = xor i32 [[AND1]], -1 +; CHECK-NEXT: [[OR1:%.*]] = or i32 [[A]], [[NOT1]] +; CHECK-NEXT: [[XOR1:%.*]] = xor i32 [[B]], [[C]] +; CHECK-NEXT: [[AND2:%.*]] = and i32 [[A]], [[XOR1]] +; CHECK-NEXT: [[AND3:%.*]] = xor i32 [[AND2]], [[OR1]] +; CHECK-NEXT: ret i32 [[AND3]] +; + %a = sdiv i32 42, %a0 ; thwart complexity-based canonicalization + %and1 = and i32 %b, %c + %not1 = xor i32 %and1, -1 + %or1 = or i32 %a, %not1 + %xor1 = xor i32 %b, %c + %and2 = and i32 %a, %xor1 + %not2 = xor i32 %and2, -1 + %and3 = and i32 %or1, %not2 + ret i32 %and3 +} + +define i32 @or_not_and_and_not_and_xor_commute5(i32 %a, i32 %b, i32 %c) { +; CHECK-LABEL: @or_not_and_and_not_and_xor_commute5( +; CHECK-NEXT: [[AND1:%.*]] = and i32 [[B:%.*]], [[C:%.*]] +; CHECK-NEXT: [[NOT1:%.*]] = xor i32 [[AND1]], -1 +; CHECK-NEXT: [[OR1:%.*]] = or i32 [[NOT1]], [[A:%.*]] +; CHECK-NEXT: [[XOR1:%.*]] = xor i32 [[B]], [[C]] +; CHECK-NEXT: [[AND2:%.*]] = and i32 [[XOR1]], [[A]] +; CHECK-NEXT: [[AND3:%.*]] = xor i32 [[AND2]], [[OR1]] +; CHECK-NEXT: ret i32 [[AND3]] +; + %and1 = and i32 %b, %c + %not1 = xor i32 %and1, -1 + %or1 = or i32 %not1, %a + %xor1 = xor i32 %b, %c + %and2 = and i32 %xor1, %a + %not2 = xor i32 %and2, -1 + %and3 = and i32 %not2, %or1 + ret i32 %and3 +} + +define i32 @or_not_and_and_not_and_xor_use1(i32 %a, i32 %b, i32 %c) { +; CHECK-LABEL: @or_not_and_and_not_and_xor_use1( +; CHECK-NEXT: [[AND1:%.*]] = and i32 [[B:%.*]], [[C:%.*]] +; CHECK-NEXT: [[NOT1:%.*]] = xor i32 [[AND1]], -1 +; CHECK-NEXT: [[OR1:%.*]] = or i32 [[NOT1]], [[A:%.*]] +; CHECK-NEXT: [[XOR1:%.*]] = xor i32 [[B]], [[C]] +; CHECK-NEXT: [[AND2:%.*]] = and i32 [[XOR1]], [[A]] +; CHECK-NEXT: [[AND3:%.*]] = xor i32 [[AND2]], [[OR1]] +; CHECK-NEXT: call void @use(i32 [[AND1]]) +; CHECK-NEXT: ret i32 [[AND3]] +; + %and1 = and i32 %b, %c + %not1 = xor i32 %and1, -1 + %or1 = or i32 %not1, %a + %xor1 = xor i32 %b, %c + %and2 = and i32 %xor1, %a + %not2 = xor i32 %and2, -1 + %and3 = and i32 %or1, %not2 + call void @use(i32 %and1) + ret i32 %and3 +} + +define i32 @or_not_and_and_not_and_xor_use2(i32 %a, i32 %b, i32 %c) { +; CHECK-LABEL: @or_not_and_and_not_and_xor_use2( +; CHECK-NEXT: [[AND1:%.*]] = and i32 [[B:%.*]], [[C:%.*]] +; CHECK-NEXT: [[NOT1:%.*]] = xor i32 [[AND1]], -1 +; CHECK-NEXT: [[OR1:%.*]] = or i32 [[NOT1]], [[A:%.*]] +; CHECK-NEXT: [[XOR1:%.*]] = xor i32 [[B]], [[C]] +; CHECK-NEXT: [[AND2:%.*]] = and i32 [[XOR1]], [[A]] +; CHECK-NEXT: [[AND3:%.*]] = xor i32 [[AND2]], [[OR1]] +; CHECK-NEXT: call void @use(i32 [[NOT1]]) +; CHECK-NEXT: ret i32 [[AND3]] +; + %and1 = and i32 %b, %c + %not1 = xor i32 %and1, -1 + %or1 = or i32 %not1, %a + %xor1 = xor i32 %b, %c + %and2 = and i32 %xor1, %a + %not2 = xor i32 %and2, -1 + %and3 = and i32 %or1, %not2 + call void @use(i32 %not1) + ret i32 %and3 +} + +define i32 @or_not_and_and_not_and_xor_use3(i32 %a, i32 %b, i32 %c) { +; CHECK-LABEL: @or_not_and_and_not_and_xor_use3( +; CHECK-NEXT: [[AND1:%.*]] = and i32 [[B:%.*]], [[C:%.*]] +; CHECK-NEXT: [[NOT1:%.*]] = xor i32 [[AND1]], -1 +; CHECK-NEXT: [[OR1:%.*]] = or i32 [[NOT1]], [[A:%.*]] +; CHECK-NEXT: [[XOR1:%.*]] = xor i32 [[B]], [[C]] +; CHECK-NEXT: [[AND2:%.*]] = and i32 [[XOR1]], [[A]] +; CHECK-NEXT: [[AND3:%.*]] = xor i32 [[AND2]], [[OR1]] +; CHECK-NEXT: call void @use(i32 [[OR1]]) +; CHECK-NEXT: ret i32 [[AND3]] +; + %and1 = and i32 %b, %c + %not1 = xor i32 %and1, -1 + %or1 = or i32 %not1, %a + %xor1 = xor i32 %b, %c + %and2 = and i32 %xor1, %a + %not2 = xor i32 %and2, -1 + %and3 = and i32 %or1, %not2 + call void @use(i32 %or1) + ret i32 %and3 +} + +define i32 @or_not_and_and_not_and_xor_use4(i32 %a, i32 %b, i32 %c) { +; CHECK-LABEL: @or_not_and_and_not_and_xor_use4( +; CHECK-NEXT: [[AND1:%.*]] = and i32 [[B:%.*]], [[C:%.*]] +; CHECK-NEXT: [[NOT1:%.*]] = xor i32 [[AND1]], -1 +; CHECK-NEXT: [[OR1:%.*]] = or i32 [[NOT1]], [[A:%.*]] +; CHECK-NEXT: [[XOR1:%.*]] = xor i32 [[B]], [[C]] +; CHECK-NEXT: [[AND2:%.*]] = and i32 [[XOR1]], [[A]] +; CHECK-NEXT: [[AND3:%.*]] = xor i32 [[AND2]], [[OR1]] +; CHECK-NEXT: call void @use(i32 [[XOR1]]) +; CHECK-NEXT: ret i32 [[AND3]] +; + %and1 = and i32 %b, %c + %not1 = xor i32 %and1, -1 + %or1 = or i32 %not1, %a + %xor1 = xor i32 %b, %c + %and2 = and i32 %xor1, %a + %not2 = xor i32 %and2, -1 + %and3 = and i32 %or1, %not2 + call void @use(i32 %xor1) + ret i32 %and3 +} + +define i32 @or_not_and_and_not_and_xor_use5(i32 %a, i32 %b, i32 %c) { +; CHECK-LABEL: @or_not_and_and_not_and_xor_use5( +; CHECK-NEXT: [[AND1:%.*]] = and i32 [[B:%.*]], [[C:%.*]] +; CHECK-NEXT: [[NOT1:%.*]] = xor i32 [[AND1]], -1 +; CHECK-NEXT: [[OR1:%.*]] = or i32 [[NOT1]], [[A:%.*]] +; CHECK-NEXT: [[XOR1:%.*]] = xor i32 [[B]], [[C]] +; CHECK-NEXT: [[AND2:%.*]] = and i32 [[XOR1]], [[A]] +; CHECK-NEXT: [[AND3:%.*]] = xor i32 [[AND2]], [[OR1]] +; CHECK-NEXT: call void @use(i32 [[AND2]]) +; CHECK-NEXT: ret i32 [[AND3]] +; + %and1 = and i32 %b, %c + %not1 = xor i32 %and1, -1 + %or1 = or i32 %not1, %a + %xor1 = xor i32 %b, %c + %and2 = and i32 %xor1, %a + %not2 = xor i32 %and2, -1 + %and3 = and i32 %or1, %not2 + call void @use(i32 %and2) + ret i32 %and3 +} + +define i32 @or_not_and_and_not_and_xor_use6(i32 %a, i32 %b, i32 %c) { +; CHECK-LABEL: @or_not_and_and_not_and_xor_use6( +; CHECK-NEXT: [[AND1:%.*]] = and i32 [[B:%.*]], [[C:%.*]] +; CHECK-NEXT: [[NOT1:%.*]] = xor i32 [[AND1]], -1 +; CHECK-NEXT: [[OR1:%.*]] = or i32 [[NOT1]], [[A:%.*]] +; CHECK-NEXT: [[XOR1:%.*]] = xor i32 [[B]], [[C]] +; CHECK-NEXT: [[AND2:%.*]] = and i32 [[XOR1]], [[A]] +; CHECK-NEXT: [[NOT2:%.*]] = xor i32 [[AND2]], -1 +; CHECK-NEXT: [[AND3:%.*]] = xor i32 [[AND2]], [[OR1]] +; CHECK-NEXT: call void @use(i32 [[NOT2]]) +; CHECK-NEXT: ret i32 [[AND3]] +; + %and1 = and i32 %b, %c + %not1 = xor i32 %and1, -1 + %or1 = or i32 %not1, %a + %xor1 = xor i32 %b, %c + %and2 = and i32 %xor1, %a + %not2 = xor i32 %and2, -1 + %and3 = and i32 %or1, %not2 + call void @use(i32 %not2) + ret i32 %and3 +} + ; (~a & b & c) | ~(a | b | c) -> ~(a | (b ^ c)) define i32 @not_and_and_or_not_or_or(i32 %a, i32 %b, i32 %c) { @@ -2688,6 +2947,327 @@ define i32 @not_and_and_or_not_or_or_use6(i32 %a, i32 %b, i32 %c) { ret i32 %or3 } +; (~a | b | c) & ~(a & b & c) -> ~a | (b ^ c) + +define i32 @not_or_or_and_not_and_and(i32 %a, i32 %b, i32 %c) { +; CHECK-LABEL: @not_or_or_and_not_and_and( +; CHECK-NEXT: [[AND1:%.*]] = and i32 [[B:%.*]], [[A:%.*]] +; CHECK-NEXT: [[AND2:%.*]] = and i32 [[AND1]], [[C:%.*]] +; CHECK-NEXT: [[NOT2:%.*]] = xor i32 [[A]], -1 +; CHECK-NEXT: [[OR1:%.*]] = or i32 [[NOT2]], [[B]] +; CHECK-NEXT: [[OR2:%.*]] = or i32 [[OR1]], [[C]] +; CHECK-NEXT: [[AND3:%.*]] = xor i32 [[AND2]], [[OR2]] +; CHECK-NEXT: ret i32 [[AND3]] +; + %and1 = and i32 %b, %a + %and2 = and i32 %and1, %c + %not1 = xor i32 %and2, -1 + %not2 = xor i32 %a, -1 + %or1 = or i32 %not2, %b + %or2 = or i32 %or1, %c + %and3 = and i32 %or2, %not1 + ret i32 %and3 +} + +define i32 @not_or_or_and_not_and_and_commute1_and(i32 %a, i32 %b, i32 %c) { +; CHECK-LABEL: @not_or_or_and_not_and_and_commute1_and( +; CHECK-NEXT: [[AND1:%.*]] = and i32 [[C:%.*]], [[A:%.*]] +; CHECK-NEXT: [[AND2:%.*]] = and i32 [[AND1]], [[B:%.*]] +; CHECK-NEXT: [[NOT2:%.*]] = xor i32 [[A]], -1 +; CHECK-NEXT: [[OR1:%.*]] = or i32 [[NOT2]], [[B]] +; CHECK-NEXT: [[OR2:%.*]] = or i32 [[OR1]], [[C]] +; CHECK-NEXT: [[AND3:%.*]] = xor i32 [[AND2]], [[OR2]] +; CHECK-NEXT: ret i32 [[AND3]] +; + %and1 = and i32 %c, %a + %and2 = and i32 %and1, %b + %not1 = xor i32 %and2, -1 + %not2 = xor i32 %a, -1 + %or1 = or i32 %not2, %b + %or2 = or i32 %or1, %c + %and3 = and i32 %or2, %not1 + ret i32 %and3 +} + +define i32 @not_or_or_and_not_and_and_commute2_and(i32 %a, i32 %b, i32 %c) { +; CHECK-LABEL: @not_or_or_and_not_and_and_commute2_and( +; CHECK-NEXT: [[AND1:%.*]] = and i32 [[B:%.*]], [[C:%.*]] +; CHECK-NEXT: [[AND2:%.*]] = and i32 [[AND1]], [[A:%.*]] +; CHECK-NEXT: [[NOT2:%.*]] = xor i32 [[A]], -1 +; CHECK-NEXT: [[OR1:%.*]] = or i32 [[NOT2]], [[B]] +; CHECK-NEXT: [[OR2:%.*]] = or i32 [[OR1]], [[C]] +; CHECK-NEXT: [[AND3:%.*]] = xor i32 [[AND2]], [[OR2]] +; CHECK-NEXT: ret i32 [[AND3]] +; + %and1 = and i32 %b, %c + %and2 = and i32 %and1, %a + %not1 = xor i32 %and2, -1 + %not2 = xor i32 %a, -1 + %or1 = or i32 %not2, %b + %or2 = or i32 %or1, %c + %and3 = and i32 %or2, %not1 + ret i32 %and3 +} + +define i32 @not_or_or_and_not_and_and_commute1_or(i32 %a, i32 %b, i32 %c) { +; CHECK-LABEL: @not_or_or_and_not_and_and_commute1_or( +; CHECK-NEXT: [[AND1:%.*]] = and i32 [[B:%.*]], [[A:%.*]] +; CHECK-NEXT: [[AND2:%.*]] = and i32 [[AND1]], [[C:%.*]] +; CHECK-NEXT: [[NOT2:%.*]] = xor i32 [[A]], -1 +; CHECK-NEXT: [[OR1:%.*]] = or i32 [[NOT2]], [[C]] +; CHECK-NEXT: [[OR2:%.*]] = or i32 [[OR1]], [[B]] +; CHECK-NEXT: [[AND3:%.*]] = xor i32 [[AND2]], [[OR2]] +; CHECK-NEXT: ret i32 [[AND3]] +; + %and1 = and i32 %b, %a + %and2 = and i32 %and1, %c + %not1 = xor i32 %and2, -1 + %not2 = xor i32 %a, -1 + %or1 = or i32 %not2, %c + %or2 = or i32 %or1, %b + %and3 = and i32 %or2, %not1 + ret i32 %and3 +} + +define i32 @not_or_or_and_not_and_and_commute2_or(i32 %a, i32 %b, i32 %c) { +; CHECK-LABEL: @not_or_or_and_not_and_and_commute2_or( +; CHECK-NEXT: [[AND1:%.*]] = and i32 [[B:%.*]], [[A:%.*]] +; CHECK-NEXT: [[AND2:%.*]] = and i32 [[AND1]], [[C:%.*]] +; CHECK-NEXT: [[NOT2:%.*]] = xor i32 [[A]], -1 +; CHECK-NEXT: [[OR1:%.*]] = or i32 [[B]], [[C]] +; CHECK-NEXT: [[OR2:%.*]] = or i32 [[OR1]], [[NOT2]] +; CHECK-NEXT: [[AND3:%.*]] = xor i32 [[AND2]], [[OR2]] +; CHECK-NEXT: ret i32 [[AND3]] +; + %and1 = and i32 %b, %a + %and2 = and i32 %and1, %c + %not1 = xor i32 %and2, -1 + %not2 = xor i32 %a, -1 + %or1 = or i32 %b, %c + %or2 = or i32 %or1, %not2 + %and3 = and i32 %or2, %not1 + ret i32 %and3 +} + +define i32 @not_or_or_and_not_and_and_commute1(i32 %a, i32 %b, i32 %c) { +; CHECK-LABEL: @not_or_or_and_not_and_and_commute1( +; CHECK-NEXT: [[AND1:%.*]] = and i32 [[A:%.*]], [[B:%.*]] +; CHECK-NEXT: [[AND2:%.*]] = and i32 [[AND1]], [[C:%.*]] +; CHECK-NEXT: [[NOT2:%.*]] = xor i32 [[A]], -1 +; CHECK-NEXT: [[OR1:%.*]] = or i32 [[NOT2]], [[B]] +; CHECK-NEXT: [[OR2:%.*]] = or i32 [[OR1]], [[C]] +; CHECK-NEXT: [[AND3:%.*]] = xor i32 [[AND2]], [[OR2]] +; CHECK-NEXT: ret i32 [[AND3]] +; + %and1 = and i32 %a, %b + %and2 = and i32 %and1, %c + %not1 = xor i32 %and2, -1 + %not2 = xor i32 %a, -1 + %or1 = or i32 %not2, %b + %or2 = or i32 %or1, %c + %and3 = and i32 %or2, %not1 + ret i32 %and3 +} + +define i32 @not_or_or_and_not_and_and_commute2(i32 %a, i32 %b, i32 %c0) { +; CHECK-LABEL: @not_or_or_and_not_and_and_commute2( +; CHECK-NEXT: [[C:%.*]] = sdiv i32 42, [[C0:%.*]] +; CHECK-NEXT: [[AND1:%.*]] = and i32 [[B:%.*]], [[A:%.*]] +; CHECK-NEXT: [[AND2:%.*]] = and i32 [[C]], [[AND1]] +; CHECK-NEXT: [[NOT2:%.*]] = xor i32 [[A]], -1 +; CHECK-NEXT: [[OR1:%.*]] = or i32 [[NOT2]], [[B]] +; CHECK-NEXT: [[OR2:%.*]] = or i32 [[OR1]], [[C]] +; CHECK-NEXT: [[AND3:%.*]] = xor i32 [[AND2]], [[OR2]] +; CHECK-NEXT: ret i32 [[AND3]] +; + %c = sdiv i32 42, %c0 ; thwart complexity-based canonicalization + %and1 = and i32 %b, %a + %and2 = and i32 %c, %and1 + %not1 = xor i32 %and2, -1 + %not2 = xor i32 %a, -1 + %or1 = or i32 %not2, %b + %or2 = or i32 %or1, %c + %and3 = and i32 %or2, %not1 + ret i32 %and3 +} + +define i32 @not_or_or_and_not_and_and_commute3(i32 %a, i32 %b0, i32 %c) { +; CHECK-LABEL: @not_or_or_and_not_and_and_commute3( +; CHECK-NEXT: [[B:%.*]] = sdiv i32 42, [[B0:%.*]] +; CHECK-NEXT: [[AND1:%.*]] = and i32 [[B]], [[A:%.*]] +; CHECK-NEXT: [[AND2:%.*]] = and i32 [[AND1]], [[C:%.*]] +; CHECK-NEXT: [[NOT2:%.*]] = xor i32 [[A]], -1 +; CHECK-NEXT: [[OR1:%.*]] = or i32 [[B]], [[NOT2]] +; CHECK-NEXT: [[OR2:%.*]] = or i32 [[OR1]], [[C]] +; CHECK-NEXT: [[AND3:%.*]] = xor i32 [[AND2]], [[OR2]] +; CHECK-NEXT: ret i32 [[AND3]] +; + %b = sdiv i32 42, %b0 ; thwart complexity-based canonicalization + %and1 = and i32 %b, %a + %and2 = and i32 %and1, %c + %not1 = xor i32 %and2, -1 + %not2 = xor i32 %a, -1 + %or1 = or i32 %b, %not2 + %or2 = or i32 %or1, %c + %and3 = and i32 %or2, %not1 + ret i32 %and3 +} + +define i32 @not_or_or_and_not_and_and_commute4(i32 %a, i32 %b, i32 %c0) { +; CHECK-LABEL: @not_or_or_and_not_and_and_commute4( +; CHECK-NEXT: [[C:%.*]] = sdiv i32 42, [[C0:%.*]] +; CHECK-NEXT: [[AND1:%.*]] = and i32 [[B:%.*]], [[A:%.*]] +; CHECK-NEXT: [[AND2:%.*]] = and i32 [[AND1]], [[C]] +; CHECK-NEXT: [[NOT2:%.*]] = xor i32 [[A]], -1 +; CHECK-NEXT: [[OR1:%.*]] = or i32 [[NOT2]], [[B]] +; CHECK-NEXT: [[OR2:%.*]] = or i32 [[C]], [[OR1]] +; CHECK-NEXT: [[AND3:%.*]] = xor i32 [[AND2]], [[OR2]] +; CHECK-NEXT: ret i32 [[AND3]] +; + %c = sdiv i32 42, %c0 ; thwart complexity-based canonicalization + %and1 = and i32 %b, %a + %and2 = and i32 %and1, %c + %not1 = xor i32 %and2, -1 + %not2 = xor i32 %a, -1 + %or1 = or i32 %not2, %b + %or2 = or i32 %c, %or1 + %and3 = and i32 %or2, %not1 + ret i32 %and3 +} + +define i32 @not_or_or_and_not_and_and_use1(i32 %a, i32 %b, i32 %c) { +; CHECK-LABEL: @not_or_or_and_not_and_and_use1( +; CHECK-NEXT: [[AND1:%.*]] = and i32 [[B:%.*]], [[A:%.*]] +; CHECK-NEXT: [[AND2:%.*]] = and i32 [[AND1]], [[C:%.*]] +; CHECK-NEXT: [[NOT2:%.*]] = xor i32 [[A]], -1 +; CHECK-NEXT: [[OR1:%.*]] = or i32 [[NOT2]], [[B]] +; CHECK-NEXT: [[OR2:%.*]] = or i32 [[OR1]], [[C]] +; CHECK-NEXT: [[AND3:%.*]] = xor i32 [[AND2]], [[OR2]] +; CHECK-NEXT: call void @use(i32 [[AND1]]) +; CHECK-NEXT: ret i32 [[AND3]] +; + %and1 = and i32 %b, %a + %and2 = and i32 %and1, %c + %not1 = xor i32 %and2, -1 + %not2 = xor i32 %a, -1 + %or1 = or i32 %not2, %b + %or2 = or i32 %or1, %c + %and3 = and i32 %or2, %not1 + call void @use(i32 %and1) + ret i32 %and3 +} + +define i32 @not_or_or_and_not_and_and_use2(i32 %a, i32 %b, i32 %c) { +; CHECK-LABEL: @not_or_or_and_not_and_and_use2( +; CHECK-NEXT: [[AND1:%.*]] = and i32 [[B:%.*]], [[A:%.*]] +; CHECK-NEXT: [[AND2:%.*]] = and i32 [[AND1]], [[C:%.*]] +; CHECK-NEXT: [[NOT2:%.*]] = xor i32 [[A]], -1 +; CHECK-NEXT: [[OR1:%.*]] = or i32 [[NOT2]], [[B]] +; CHECK-NEXT: [[OR2:%.*]] = or i32 [[OR1]], [[C]] +; CHECK-NEXT: [[AND3:%.*]] = xor i32 [[AND2]], [[OR2]] +; CHECK-NEXT: call void @use(i32 [[AND2]]) +; CHECK-NEXT: ret i32 [[AND3]] +; + %and1 = and i32 %b, %a + %and2 = and i32 %and1, %c + %not1 = xor i32 %and2, -1 + %not2 = xor i32 %a, -1 + %or1 = or i32 %not2, %b + %or2 = or i32 %or1, %c + %and3 = and i32 %or2, %not1 + call void @use(i32 %and2) + ret i32 %and3 +} + +define i32 @not_or_or_and_not_and_and_use3(i32 %a, i32 %b, i32 %c) { +; CHECK-LABEL: @not_or_or_and_not_and_and_use3( +; CHECK-NEXT: [[AND1:%.*]] = and i32 [[B:%.*]], [[A:%.*]] +; CHECK-NEXT: [[AND2:%.*]] = and i32 [[AND1]], [[C:%.*]] +; CHECK-NEXT: [[NOT1:%.*]] = xor i32 [[AND2]], -1 +; CHECK-NEXT: [[NOT2:%.*]] = xor i32 [[A]], -1 +; CHECK-NEXT: [[OR1:%.*]] = or i32 [[NOT2]], [[B]] +; CHECK-NEXT: [[OR2:%.*]] = or i32 [[OR1]], [[C]] +; CHECK-NEXT: [[AND3:%.*]] = xor i32 [[AND2]], [[OR2]] +; CHECK-NEXT: call void @use(i32 [[NOT1]]) +; CHECK-NEXT: ret i32 [[AND3]] +; + %and1 = and i32 %b, %a + %and2 = and i32 %and1, %c + %not1 = xor i32 %and2, -1 + %not2 = xor i32 %a, -1 + %or1 = or i32 %not2, %b + %or2 = or i32 %or1, %c + %and3 = and i32 %or2, %not1 + call void @use(i32 %not1) + ret i32 %and3 +} + +define i32 @not_or_or_and_not_and_and_use4(i32 %a, i32 %b, i32 %c) { +; CHECK-LABEL: @not_or_or_and_not_and_and_use4( +; CHECK-NEXT: [[AND1:%.*]] = and i32 [[B:%.*]], [[A:%.*]] +; CHECK-NEXT: [[AND2:%.*]] = and i32 [[AND1]], [[C:%.*]] +; CHECK-NEXT: [[NOT2:%.*]] = xor i32 [[A]], -1 +; CHECK-NEXT: [[OR1:%.*]] = or i32 [[NOT2]], [[B]] +; CHECK-NEXT: [[OR2:%.*]] = or i32 [[OR1]], [[C]] +; CHECK-NEXT: [[AND3:%.*]] = xor i32 [[AND2]], [[OR2]] +; CHECK-NEXT: call void @use(i32 [[NOT2]]) +; CHECK-NEXT: ret i32 [[AND3]] +; + %and1 = and i32 %b, %a + %and2 = and i32 %and1, %c + %not1 = xor i32 %and2, -1 + %not2 = xor i32 %a, -1 + %or1 = or i32 %not2, %b + %or2 = or i32 %or1, %c + %and3 = and i32 %or2, %not1 + call void @use(i32 %not2) + ret i32 %and3 +} + +define i32 @not_or_or_and_not_and_and_use5(i32 %a, i32 %b, i32 %c) { +; CHECK-LABEL: @not_or_or_and_not_and_and_use5( +; CHECK-NEXT: [[AND1:%.*]] = and i32 [[B:%.*]], [[A:%.*]] +; CHECK-NEXT: [[AND2:%.*]] = and i32 [[AND1]], [[C:%.*]] +; CHECK-NEXT: [[NOT2:%.*]] = xor i32 [[A]], -1 +; CHECK-NEXT: [[OR1:%.*]] = or i32 [[NOT2]], [[B]] +; CHECK-NEXT: [[OR2:%.*]] = or i32 [[OR1]], [[C]] +; CHECK-NEXT: [[AND3:%.*]] = xor i32 [[AND2]], [[OR2]] +; CHECK-NEXT: call void @use(i32 [[OR1]]) +; CHECK-NEXT: ret i32 [[AND3]] +; + %and1 = and i32 %b, %a + %and2 = and i32 %and1, %c + %not1 = xor i32 %and2, -1 + %not2 = xor i32 %a, -1 + %or1 = or i32 %not2, %b + %or2 = or i32 %or1, %c + %and3 = and i32 %or2, %not1 + call void @use(i32 %or1) + ret i32 %and3 +} + +define i32 @not_or_or_and_not_and_and_use6(i32 %a, i32 %b, i32 %c) { +; CHECK-LABEL: @not_or_or_and_not_and_and_use6( +; CHECK-NEXT: [[AND1:%.*]] = and i32 [[B:%.*]], [[A:%.*]] +; CHECK-NEXT: [[AND2:%.*]] = and i32 [[AND1]], [[C:%.*]] +; CHECK-NEXT: [[NOT2:%.*]] = xor i32 [[A]], -1 +; CHECK-NEXT: [[OR1:%.*]] = or i32 [[NOT2]], [[B]] +; CHECK-NEXT: [[OR2:%.*]] = or i32 [[OR1]], [[C]] +; CHECK-NEXT: [[AND3:%.*]] = xor i32 [[AND2]], [[OR2]] +; CHECK-NEXT: call void @use(i32 [[OR2]]) +; CHECK-NEXT: ret i32 [[AND3]] +; + %and1 = and i32 %b, %a + %and2 = and i32 %and1, %c + %not1 = xor i32 %and2, -1 + %not2 = xor i32 %a, -1 + %or1 = or i32 %not2, %b + %or2 = or i32 %or1, %c + %and3 = and i32 %or2, %not1 + call void @use(i32 %or2) + ret i32 %and3 +} + ; (~a & b & c) | ~(a | b) -> (c | ~b) & ~a define i32 @not_and_and_or_no_or(i32 %a, i32 %b, i32 %c) { @@ -2976,6 +3556,289 @@ define i32 @not_and_and_or_no_or_use8(i32 %a, i32 %b, i32 %c) { ret i32 %or2 } +; (~a | b | c) & ~(a & b) -> (c & ~b) | ~a + +define i32 @not_or_or_and_no_and(i32 %a, i32 %b, i32 %c) { +; CHECK-LABEL: @not_or_or_and_no_and( +; CHECK-NEXT: [[AND1:%.*]] = and i32 [[B:%.*]], [[A:%.*]] +; CHECK-NEXT: [[NOT1:%.*]] = xor i32 [[AND1]], -1 +; CHECK-NEXT: [[NOT2:%.*]] = xor i32 [[A]], -1 +; CHECK-NEXT: [[OR1:%.*]] = or i32 [[NOT2]], [[B]] +; CHECK-NEXT: [[OR2:%.*]] = or i32 [[OR1]], [[C:%.*]] +; CHECK-NEXT: [[AND2:%.*]] = and i32 [[OR2]], [[NOT1]] +; CHECK-NEXT: ret i32 [[AND2]] +; + %and1 = and i32 %b, %a + %not1 = xor i32 %and1, -1 + %not2 = xor i32 %a, -1 + %or1 = or i32 %not2, %b + %or2 = or i32 %or1, %c + %and2 = and i32 %or2, %not1 + ret i32 %and2 +} + +define i32 @not_or_or_and_no_and_commute1_or(i32 %a, i32 %b, i32 %c) { +; CHECK-LABEL: @not_or_or_and_no_and_commute1_or( +; CHECK-NEXT: [[AND1:%.*]] = and i32 [[B:%.*]], [[A:%.*]] +; CHECK-NEXT: [[NOT2:%.*]] = xor i32 [[A]], -1 +; CHECK-NEXT: [[OR1:%.*]] = or i32 [[C:%.*]], [[B]] +; CHECK-NEXT: [[OR2:%.*]] = or i32 [[OR1]], [[NOT2]] +; CHECK-NEXT: [[AND2:%.*]] = xor i32 [[AND1]], [[OR2]] +; CHECK-NEXT: ret i32 [[AND2]] +; + %and1 = and i32 %b, %a + %not1 = xor i32 %and1, -1 + %not2 = xor i32 %a, -1 + %or1 = or i32 %c, %b + %or2 = or i32 %or1, %not2 + %and2 = and i32 %or2, %not1 + ret i32 %and2 +} + +define i32 @not_or_or_and_no_and_commute2_or(i32 %a, i32 %b, i32 %c) { +; CHECK-LABEL: @not_or_or_and_no_and_commute2_or( +; CHECK-NEXT: [[AND1:%.*]] = and i32 [[B:%.*]], [[A:%.*]] +; CHECK-NEXT: [[NOT2:%.*]] = xor i32 [[A]], -1 +; CHECK-NEXT: [[OR1:%.*]] = or i32 [[NOT2]], [[C:%.*]] +; CHECK-NEXT: [[OR2:%.*]] = or i32 [[OR1]], [[B]] +; CHECK-NEXT: [[AND2:%.*]] = xor i32 [[AND1]], [[OR2]] +; CHECK-NEXT: ret i32 [[AND2]] +; + %and1 = and i32 %b, %a + %not1 = xor i32 %and1, -1 + %not2 = xor i32 %a, -1 + %or1 = or i32 %not2, %c + %or2 = or i32 %or1, %b + %and2 = and i32 %or2, %not1 + ret i32 %and2 +} + +define i32 @not_or_or_and_no_and_commute1(i32 %a, i32 %b, i32 %c) { +; CHECK-LABEL: @not_or_or_and_no_and_commute1( +; CHECK-NEXT: [[AND1:%.*]] = and i32 [[A:%.*]], [[B:%.*]] +; CHECK-NEXT: [[NOT1:%.*]] = xor i32 [[AND1]], -1 +; CHECK-NEXT: [[NOT2:%.*]] = xor i32 [[A]], -1 +; CHECK-NEXT: [[OR1:%.*]] = or i32 [[NOT2]], [[B]] +; CHECK-NEXT: [[OR2:%.*]] = or i32 [[OR1]], [[C:%.*]] +; CHECK-NEXT: [[AND2:%.*]] = and i32 [[OR2]], [[NOT1]] +; CHECK-NEXT: ret i32 [[AND2]] +; + %and1 = and i32 %a, %b + %not1 = xor i32 %and1, -1 + %not2 = xor i32 %a, -1 + %or1 = or i32 %not2, %b + %or2 = or i32 %or1, %c + %and2 = and i32 %or2, %not1 + ret i32 %and2 +} + +define i32 @not_or_or_and_no_and_commute2(i32 %a, i32 %b0, i32 %c) { +; CHECK-LABEL: @not_or_or_and_no_and_commute2( +; CHECK-NEXT: [[B:%.*]] = sdiv i32 42, [[B0:%.*]] +; CHECK-NEXT: [[AND1:%.*]] = and i32 [[B]], [[A:%.*]] +; CHECK-NEXT: [[NOT1:%.*]] = xor i32 [[AND1]], -1 +; CHECK-NEXT: [[NOT2:%.*]] = xor i32 [[A]], -1 +; CHECK-NEXT: [[OR1:%.*]] = or i32 [[B]], [[NOT2]] +; CHECK-NEXT: [[OR2:%.*]] = or i32 [[OR1]], [[C:%.*]] +; CHECK-NEXT: [[AND2:%.*]] = and i32 [[OR2]], [[NOT1]] +; CHECK-NEXT: ret i32 [[AND2]] +; + %b = sdiv i32 42, %b0 ; thwart complexity-based canonicalization + %and1 = and i32 %b, %a + %not1 = xor i32 %and1, -1 + %not2 = xor i32 %a, -1 + %or1 = or i32 %b, %not2 + %or2 = or i32 %or1, %c + %and2 = and i32 %or2, %not1 + ret i32 %and2 +} + +define i32 @not_or_or_and_no_and_commute3(i32 %a, i32 %b, i32 %c0) { +; CHECK-LABEL: @not_or_or_and_no_and_commute3( +; CHECK-NEXT: [[C:%.*]] = sdiv i32 42, [[C0:%.*]] +; CHECK-NEXT: [[AND1:%.*]] = and i32 [[B:%.*]], [[A:%.*]] +; CHECK-NEXT: [[NOT1:%.*]] = xor i32 [[AND1]], -1 +; CHECK-NEXT: [[NOT2:%.*]] = xor i32 [[A]], -1 +; CHECK-NEXT: [[OR1:%.*]] = or i32 [[NOT2]], [[B]] +; CHECK-NEXT: [[OR2:%.*]] = or i32 [[C]], [[OR1]] +; CHECK-NEXT: [[AND2:%.*]] = and i32 [[OR2]], [[NOT1]] +; CHECK-NEXT: ret i32 [[AND2]] +; + %c = sdiv i32 42, %c0 ; thwart complexity-based canonicalization + %and1 = and i32 %b, %a + %not1 = xor i32 %and1, -1 + %not2 = xor i32 %a, -1 + %or1 = or i32 %not2, %b + %or2 = or i32 %c, %or1 + %and2 = and i32 %or2, %not1 + ret i32 %and2 +} + +define i32 @not_or_or_and_no_and_use1(i32 %a, i32 %b, i32 %c) { +; CHECK-LABEL: @not_or_or_and_no_and_use1( +; CHECK-NEXT: [[AND1:%.*]] = and i32 [[B:%.*]], [[A:%.*]] +; CHECK-NEXT: [[NOT1:%.*]] = xor i32 [[AND1]], -1 +; CHECK-NEXT: [[NOT2:%.*]] = xor i32 [[A]], -1 +; CHECK-NEXT: [[OR1:%.*]] = or i32 [[NOT2]], [[B]] +; CHECK-NEXT: [[OR2:%.*]] = or i32 [[OR1]], [[C:%.*]] +; CHECK-NEXT: [[AND2:%.*]] = and i32 [[OR2]], [[NOT1]] +; CHECK-NEXT: call void @use(i32 [[NOT2]]) +; CHECK-NEXT: ret i32 [[AND2]] +; + %and1 = and i32 %b, %a + %not1 = xor i32 %and1, -1 + %not2 = xor i32 %a, -1 + %or1 = or i32 %not2, %b + %or2 = or i32 %or1, %c + %and2 = and i32 %or2, %not1 + call void @use(i32 %not2) + ret i32 %and2 +} + +define i32 @not_or_or_and_no_and_use2(i32 %a, i32 %b, i32 %c) { +; CHECK-LABEL: @not_or_or_and_no_and_use2( +; CHECK-NEXT: [[AND1:%.*]] = and i32 [[B:%.*]], [[A:%.*]] +; CHECK-NEXT: [[NOT2:%.*]] = xor i32 [[A]], -1 +; CHECK-NEXT: [[OR1:%.*]] = or i32 [[B]], [[C:%.*]] +; CHECK-NEXT: [[OR2:%.*]] = or i32 [[OR1]], [[NOT2]] +; CHECK-NEXT: [[AND2:%.*]] = xor i32 [[AND1]], [[OR2]] +; CHECK-NEXT: call void @use(i32 [[NOT2]]) +; CHECK-NEXT: ret i32 [[AND2]] +; + %and1 = and i32 %b, %a + %not1 = xor i32 %and1, -1 + %not2 = xor i32 %a, -1 + %or1 = or i32 %b, %c + %or2 = or i32 %or1, %not2 + %and2 = and i32 %or2, %not1 + call void @use(i32 %not2) + ret i32 %and2 +} + +define i32 @not_or_or_and_no_and_use3(i32 %a, i32 %b, i32 %c) { +; CHECK-LABEL: @not_or_or_and_no_and_use3( +; CHECK-NEXT: [[AND1:%.*]] = and i32 [[B:%.*]], [[A:%.*]] +; CHECK-NEXT: [[NOT2:%.*]] = xor i32 [[A]], -1 +; CHECK-NEXT: [[OR1:%.*]] = or i32 [[NOT2]], [[C:%.*]] +; CHECK-NEXT: [[OR2:%.*]] = or i32 [[OR1]], [[B]] +; CHECK-NEXT: [[AND2:%.*]] = xor i32 [[AND1]], [[OR2]] +; CHECK-NEXT: call void @use(i32 [[NOT2]]) +; CHECK-NEXT: ret i32 [[AND2]] +; + %and1 = and i32 %b, %a + %not1 = xor i32 %and1, -1 + %not2 = xor i32 %a, -1 + %or1 = or i32 %not2, %c + %or2 = or i32 %or1, %b + %and2 = and i32 %or2, %not1 + call void @use(i32 %not2) + ret i32 %and2 +} + +define i32 @not_or_or_and_no_and_use4(i32 %a, i32 %b, i32 %c) { +; CHECK-LABEL: @not_or_or_and_no_and_use4( +; CHECK-NEXT: [[AND1:%.*]] = and i32 [[B:%.*]], [[A:%.*]] +; CHECK-NEXT: [[NOT2:%.*]] = xor i32 [[A]], -1 +; CHECK-NEXT: [[OR1:%.*]] = or i32 [[NOT2]], [[C:%.*]] +; CHECK-NEXT: [[OR2:%.*]] = or i32 [[OR1]], [[B]] +; CHECK-NEXT: [[AND2:%.*]] = xor i32 [[AND1]], [[OR2]] +; CHECK-NEXT: call void @use(i32 [[NOT2]]) +; CHECK-NEXT: ret i32 [[AND2]] +; + %and1 = and i32 %b, %a + %not1 = xor i32 %and1, -1 + %not2 = xor i32 %a, -1 + %or1 = or i32 %not2, %c + %or2 = or i32 %or1, %b + %and2 = and i32 %or2, %not1 + call void @use(i32 %not2) + ret i32 %and2 +} + +define i32 @not_or_or_and_no_and_use5(i32 %a, i32 %b, i32 %c) { +; CHECK-LABEL: @not_or_or_and_no_and_use5( +; CHECK-NEXT: [[AND1:%.*]] = and i32 [[B:%.*]], [[A:%.*]] +; CHECK-NEXT: [[NOT1:%.*]] = xor i32 [[AND1]], -1 +; CHECK-NEXT: [[NOT2:%.*]] = xor i32 [[A]], -1 +; CHECK-NEXT: [[OR1:%.*]] = or i32 [[NOT2]], [[B]] +; CHECK-NEXT: [[OR2:%.*]] = or i32 [[OR1]], [[C:%.*]] +; CHECK-NEXT: [[AND2:%.*]] = and i32 [[OR2]], [[NOT1]] +; CHECK-NEXT: call void @use(i32 [[AND1]]) +; CHECK-NEXT: ret i32 [[AND2]] +; + %and1 = and i32 %b, %a + %not1 = xor i32 %and1, -1 + %not2 = xor i32 %a, -1 + %or1 = or i32 %not2, %b + %or2 = or i32 %or1, %c + %and2 = and i32 %or2, %not1 + call void @use(i32 %and1) + ret i32 %and2 +} + +define i32 @not_or_or_and_no_and_use6(i32 %a, i32 %b, i32 %c) { +; CHECK-LABEL: @not_or_or_and_no_and_use6( +; CHECK-NEXT: [[AND1:%.*]] = and i32 [[B:%.*]], [[A:%.*]] +; CHECK-NEXT: [[NOT1:%.*]] = xor i32 [[AND1]], -1 +; CHECK-NEXT: [[NOT2:%.*]] = xor i32 [[A]], -1 +; CHECK-NEXT: [[OR1:%.*]] = or i32 [[NOT2]], [[B]] +; CHECK-NEXT: [[OR2:%.*]] = or i32 [[OR1]], [[C:%.*]] +; CHECK-NEXT: [[AND2:%.*]] = and i32 [[OR2]], [[NOT1]] +; CHECK-NEXT: call void @use(i32 [[NOT1]]) +; CHECK-NEXT: ret i32 [[AND2]] +; + %and1 = and i32 %b, %a + %not1 = xor i32 %and1, -1 + %not2 = xor i32 %a, -1 + %or1 = or i32 %not2, %b + %or2 = or i32 %or1, %c + %and2 = and i32 %or2, %not1 + call void @use(i32 %not1) + ret i32 %and2 +} + +define i32 @not_or_or_and_no_and_use7(i32 %a, i32 %b, i32 %c) { +; CHECK-LABEL: @not_or_or_and_no_and_use7( +; CHECK-NEXT: [[AND1:%.*]] = and i32 [[B:%.*]], [[A:%.*]] +; CHECK-NEXT: [[NOT1:%.*]] = xor i32 [[AND1]], -1 +; CHECK-NEXT: [[NOT2:%.*]] = xor i32 [[A]], -1 +; CHECK-NEXT: [[OR1:%.*]] = or i32 [[NOT2]], [[B]] +; CHECK-NEXT: [[OR2:%.*]] = or i32 [[OR1]], [[C:%.*]] +; CHECK-NEXT: [[AND2:%.*]] = and i32 [[OR2]], [[NOT1]] +; CHECK-NEXT: call void @use(i32 [[OR1]]) +; CHECK-NEXT: ret i32 [[AND2]] +; + %and1 = and i32 %b, %a + %not1 = xor i32 %and1, -1 + %not2 = xor i32 %a, -1 + %or1 = or i32 %not2, %b + %or2 = or i32 %or1, %c + %and2 = and i32 %or2, %not1 + call void @use(i32 %or1) + ret i32 %and2 +} + +define i32 @not_or_or_and_no_and_use8(i32 %a, i32 %b, i32 %c) { +; CHECK-LABEL: @not_or_or_and_no_and_use8( +; CHECK-NEXT: [[AND1:%.*]] = and i32 [[B:%.*]], [[A:%.*]] +; CHECK-NEXT: [[NOT1:%.*]] = xor i32 [[AND1]], -1 +; CHECK-NEXT: [[NOT2:%.*]] = xor i32 [[A]], -1 +; CHECK-NEXT: [[OR1:%.*]] = or i32 [[NOT2]], [[B]] +; CHECK-NEXT: [[OR2:%.*]] = or i32 [[OR1]], [[C:%.*]] +; CHECK-NEXT: [[AND2:%.*]] = and i32 [[OR2]], [[NOT1]] +; CHECK-NEXT: call void @use(i32 [[OR2]]) +; CHECK-NEXT: ret i32 [[AND2]] +; + %and1 = and i32 %b, %a + %not1 = xor i32 %and1, -1 + %not2 = xor i32 %a, -1 + %or1 = or i32 %not2, %b + %or2 = or i32 %or1, %c + %and2 = and i32 %or2, %not1 + call void @use(i32 %or2) + ret i32 %and2 +} + ; (~(a | b) & c) | ~(a | (b | c)) -> ~(a | b) ; (~(a | b) & c) | ~(b | (a | c)) -> ~(a | b) @@ -3156,3 +4019,178 @@ define i32 @not_or_and_or_not_or_or_use2(i32 %a, i32 %b, i32 %c) { 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_and_or_and_not_and_and(i32 %a, i32 %b, i32 %c) { +; CHECK-LABEL: @not_and_or_and_not_and_and( +; CHECK-NEXT: [[AND1:%.*]] = and i32 [[B:%.*]], [[C:%.*]] +; CHECK-NEXT: [[AND2:%.*]] = and i32 [[AND1]], [[A:%.*]] +; CHECK-NEXT: [[AND3:%.*]] = and i32 [[B]], [[A]] +; CHECK-NEXT: [[NOT2:%.*]] = xor i32 [[AND3]], -1 +; CHECK-NEXT: [[OR2:%.*]] = or i32 [[NOT2]], [[C]] +; CHECK-NEXT: [[AND4:%.*]] = xor i32 [[AND2]], [[OR2]] +; CHECK-NEXT: ret i32 [[AND4]] +; + %and1 = and i32 %b, %c + %and2 = and i32 %and1, %a + %not1 = xor i32 %and2, -1 + %and3 = and i32 %b, %a + %not2 = xor i32 %and3, -1 + %or2 = or i32 %not2, %c + %and4 = and i32 %or2, %not1 + ret i32 %and4 +} + +define i32 @not_and_or_and_not_and_and_commute1(i32 %a, i32 %b, i32 %c) { +; CHECK-LABEL: @not_and_or_and_not_and_and_commute1( +; CHECK-NEXT: [[AND1:%.*]] = and i32 [[A:%.*]], [[C:%.*]] +; CHECK-NEXT: [[AND2:%.*]] = and i32 [[AND1]], [[B:%.*]] +; CHECK-NEXT: [[AND3:%.*]] = and i32 [[B]], [[A]] +; CHECK-NEXT: [[NOT2:%.*]] = xor i32 [[AND3]], -1 +; CHECK-NEXT: [[OR2:%.*]] = or i32 [[NOT2]], [[C]] +; CHECK-NEXT: [[AND4:%.*]] = xor i32 [[AND2]], [[OR2]] +; CHECK-NEXT: ret i32 [[AND4]] +; + %and1 = and i32 %a, %c + %and2 = and i32 %and1, %b + %not1 = xor i32 %and2, -1 + %and3 = and i32 %b, %a + %not2 = xor i32 %and3, -1 + %or2 = or i32 %not2, %c + %and4 = and i32 %or2, %not1 + ret i32 %and4 +} + +define i32 @not_and_or_and_not_and_and_commute2(i32 %a, i32 %b, i32 %c) { +; CHECK-LABEL: @not_and_or_and_not_and_and_commute2( +; CHECK-NEXT: [[AND1:%.*]] = and i32 [[C:%.*]], [[B:%.*]] +; CHECK-NEXT: [[AND2:%.*]] = and i32 [[AND1]], [[A:%.*]] +; CHECK-NEXT: [[AND3:%.*]] = and i32 [[B]], [[A]] +; CHECK-NEXT: [[NOT2:%.*]] = xor i32 [[AND3]], -1 +; CHECK-NEXT: [[OR2:%.*]] = or i32 [[NOT2]], [[C]] +; CHECK-NEXT: [[AND4:%.*]] = xor i32 [[AND2]], [[OR2]] +; CHECK-NEXT: ret i32 [[AND4]] +; + %and1 = and i32 %c, %b + %and2 = and i32 %and1, %a + %not1 = xor i32 %and2, -1 + %and3 = and i32 %b, %a + %not2 = xor i32 %and3, -1 + %or2 = or i32 %not2, %c + %and4 = and i32 %or2, %not1 + ret i32 %and4 +} + +define i32 @not_and_or_and_not_and_and_commute3(i32 %a0, i32 %b, i32 %c) { +; CHECK-LABEL: @not_and_or_and_not_and_and_commute3( +; CHECK-NEXT: [[A:%.*]] = sdiv i32 42, [[A0:%.*]] +; CHECK-NEXT: [[AND1:%.*]] = and i32 [[B:%.*]], [[C:%.*]] +; CHECK-NEXT: [[AND2:%.*]] = and i32 [[A]], [[AND1]] +; CHECK-NEXT: [[AND3:%.*]] = and i32 [[A]], [[B]] +; CHECK-NEXT: [[NOT2:%.*]] = xor i32 [[AND3]], -1 +; CHECK-NEXT: [[OR2:%.*]] = or i32 [[NOT2]], [[C]] +; CHECK-NEXT: [[AND4:%.*]] = xor i32 [[AND2]], [[OR2]] +; 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 + %and3 = and i32 %a, %b + %not2 = xor i32 %and3, -1 + %or2 = or i32 %not2, %c + %and4 = and i32 %or2, %not1 + ret i32 %and4 +} + +define i32 @not_and_or_and_not_and_and_commute4(i32 %a, i32 %b0, i32 %c) { +; CHECK-LABEL: @not_and_or_and_not_and_and_commute4( +; CHECK-NEXT: [[B:%.*]] = sdiv i32 42, [[B0:%.*]] +; CHECK-NEXT: [[AND1:%.*]] = and i32 [[A:%.*]], [[C:%.*]] +; CHECK-NEXT: [[AND2:%.*]] = and i32 [[B]], [[AND1]] +; CHECK-NEXT: [[AND3:%.*]] = and i32 [[B]], [[A]] +; CHECK-NEXT: [[NOT2:%.*]] = xor i32 [[AND3]], -1 +; CHECK-NEXT: [[OR2:%.*]] = or i32 [[NOT2]], [[C]] +; CHECK-NEXT: [[AND4:%.*]] = xor i32 [[AND2]], [[OR2]] +; 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 + %and3 = and i32 %b, %a + %not2 = xor i32 %and3, -1 + %or2 = or i32 %not2, %c + %and4 = and i32 %or2, %not1 + ret i32 %and4 +} + +define i32 @not_and_or_and_not_and_and_commute5(i32 %a, i32 %b, i32 %c0) { +; CHECK-LABEL: @not_and_or_and_not_and_and_commute5( +; CHECK-NEXT: [[C:%.*]] = sdiv i32 42, [[C0:%.*]] +; CHECK-NEXT: [[AND1:%.*]] = and i32 [[C]], [[A:%.*]] +; CHECK-NEXT: [[AND2:%.*]] = and i32 [[AND1]], [[B:%.*]] +; CHECK-NEXT: [[AND3:%.*]] = and i32 [[B]], [[A]] +; CHECK-NEXT: [[NOT2:%.*]] = xor i32 [[AND3]], -1 +; CHECK-NEXT: [[OR2:%.*]] = or i32 [[C]], [[NOT2]] +; CHECK-NEXT: [[AND4:%.*]] = xor i32 [[AND2]], [[OR2]] +; 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 + %and3 = and i32 %b, %a + %not2 = xor i32 %and3, -1 + %or2 = or i32 %c, %not2 + %and4 = and i32 %or2, %not1 + ret i32 %and4 +} + +define i32 @not_and_or_and_not_and_and_use1(i32 %a, i32 %b, i32 %c) { +; CHECK-LABEL: @not_and_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: [[AND3:%.*]] = and i32 [[B]], [[A]] +; CHECK-NEXT: [[NOT2:%.*]] = xor i32 [[AND3]], -1 +; CHECK-NEXT: [[OR2:%.*]] = or i32 [[NOT2]], [[C]] +; CHECK-NEXT: [[AND4:%.*]] = xor i32 [[AND2]], [[OR2]] +; 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 + %and3 = and i32 %b, %a + %not2 = xor i32 %and3, -1 + %or2 = or i32 %not2, %c + %and4 = and i32 %or2, %not1 + call void @use(i32 %not1) + ret i32 %and4 +} + +define i32 @not_and_or_and_not_and_and_use2(i32 %a, i32 %b, i32 %c) { +; CHECK-LABEL: @not_and_or_and_not_and_and_use2( +; CHECK-NEXT: [[AND1:%.*]] = and i32 [[A:%.*]], [[C:%.*]] +; CHECK-NEXT: [[AND2:%.*]] = and i32 [[AND1]], [[B:%.*]] +; CHECK-NEXT: [[NOT1:%.*]] = xor i32 [[AND2]], -1 +; CHECK-NEXT: [[AND3:%.*]] = and i32 [[B]], [[A]] +; CHECK-NEXT: [[NOT2:%.*]] = xor i32 [[AND3]], -1 +; CHECK-NEXT: [[OR2:%.*]] = or i32 [[NOT2]], [[C]] +; CHECK-NEXT: [[AND4:%.*]] = xor i32 [[AND2]], [[OR2]] +; CHECK-NEXT: call void @use(i32 [[NOT1]]) +; CHECK-NEXT: ret i32 [[AND4]] +; + %and1 = and i32 %a, %c + %and2 = and i32 %and1, %b + %not1 = xor i32 %and2, -1 + %and3 = and i32 %b, %a + %not2 = xor i32 %and3, -1 + %or2 = or i32 %not2, %c + %and4 = and i32 %or2, %not1 + call void @use(i32 %not1) + ret i32 %and4 +}