diff --git a/llvm/test/Transforms/InstCombine/and-xor-or.ll b/llvm/test/Transforms/InstCombine/and-xor-or.ll
index 26ced92fc8d37..af3e9c373fb13 100644
--- a/llvm/test/Transforms/InstCombine/and-xor-or.ll
+++ b/llvm/test/Transforms/InstCombine/and-xor-or.ll
@@ -1065,6 +1065,418 @@ define i32 @or_not_and_wrong_b(i32 %a, i32 %b, i32 %c, i32 %d) {
   ret i32 %or3
 }
 
+; (c | ~(a & b)) & (b | ~(a & c)) --> ~(a & (b ^ c))
+
+define i32 @and_not_or(i32 %a, i32 %b, i32 %c) {
+; CHECK-LABEL: @and_not_or(
+; CHECK-NEXT:    [[AND1:%.*]] = and i32 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[NOT1:%.*]] = xor i32 [[AND1]], -1
+; CHECK-NEXT:    [[OR1:%.*]] = or i32 [[NOT1]], [[C:%.*]]
+; CHECK-NEXT:    [[AND2:%.*]] = and i32 [[A]], [[C]]
+; CHECK-NEXT:    [[NOT2:%.*]] = xor i32 [[AND2]], -1
+; CHECK-NEXT:    [[OR2:%.*]] = or i32 [[NOT2]], [[B]]
+; CHECK-NEXT:    [[AND3:%.*]] = and i32 [[OR1]], [[OR2]]
+; CHECK-NEXT:    ret i32 [[AND3]]
+;
+  %and1 = and i32 %a, %b
+  %not1 = xor i32 %and1, -1
+  %or1 = or i32 %not1, %c
+  %and2 = and i32 %a, %c
+  %not2 = xor i32 %and2, -1
+  %or2 = or i32 %not2, %b
+  %and3 = and i32 %or1, %or2
+  ret i32 %and3
+}
+
+define i32 @and_not_or_commute1(i32 %a, i32 %b0, i32 %c) {
+; CHECK-LABEL: @and_not_or_commute1(
+; CHECK-NEXT:    [[B:%.*]] = sdiv i32 42, [[B0:%.*]]
+; CHECK-NEXT:    [[AND1:%.*]] = and i32 [[B]], [[A:%.*]]
+; CHECK-NEXT:    [[NOT1:%.*]] = xor i32 [[AND1]], -1
+; CHECK-NEXT:    [[OR1:%.*]] = or i32 [[NOT1]], [[C:%.*]]
+; CHECK-NEXT:    [[AND2:%.*]] = and i32 [[A]], [[C]]
+; CHECK-NEXT:    [[NOT2:%.*]] = xor i32 [[AND2]], -1
+; CHECK-NEXT:    [[OR2:%.*]] = or i32 [[B]], [[NOT2]]
+; CHECK-NEXT:    [[AND3:%.*]] = and i32 [[OR1]], [[OR2]]
+; CHECK-NEXT:    ret i32 [[AND3]]
+;
+  %b = sdiv i32 42, %b0 ; thwart complexity-based canonicalization
+  %and1 = and i32 %a, %b
+  %not1 = xor i32 %and1, -1
+  %or1 = or i32 %not1, %c
+  %and2 = and i32 %a, %c
+  %not2 = xor i32 %and2, -1
+  %or2 = or i32 %b, %not2
+  %and3 = and i32 %or1, %or2
+  ret i32 %and3
+}
+
+define i32 @and_not_or_commute2(i32 %a, i32 %b0, i32 %c) {
+; CHECK-LABEL: @and_not_or_commute2(
+; CHECK-NEXT:    [[B:%.*]] = sdiv i32 42, [[B0:%.*]]
+; CHECK-NEXT:    [[AND1:%.*]] = and i32 [[B]], [[A:%.*]]
+; CHECK-NEXT:    [[NOT1:%.*]] = xor i32 [[AND1]], -1
+; CHECK-NEXT:    [[OR1:%.*]] = or i32 [[NOT1]], [[C:%.*]]
+; CHECK-NEXT:    [[AND2:%.*]] = and i32 [[A]], [[C]]
+; CHECK-NEXT:    [[NOT2:%.*]] = xor i32 [[AND2]], -1
+; CHECK-NEXT:    [[OR2:%.*]] = or i32 [[B]], [[NOT2]]
+; CHECK-NEXT:    [[AND3:%.*]] = and i32 [[OR2]], [[OR1]]
+; CHECK-NEXT:    ret i32 [[AND3]]
+;
+  %b = sdiv i32 42, %b0 ; thwart complexity-based canonicalization
+  %and1 = and i32 %a, %b
+  %not1 = xor i32 %and1, -1
+  %or1 = or i32 %not1, %c
+  %and2 = and i32 %a, %c
+  %not2 = xor i32 %and2, -1
+  %or2 = or i32 %b, %not2
+  %and3 = and i32 %or2, %or1
+  ret i32 %and3
+}
+
+define i32 @and_not_or_commute3(i32 %a, i32 %b, i32 %c) {
+; CHECK-LABEL: @and_not_or_commute3(
+; CHECK-NEXT:    [[AND1:%.*]] = and i32 [[B:%.*]], [[A:%.*]]
+; CHECK-NEXT:    [[NOT1:%.*]] = xor i32 [[AND1]], -1
+; CHECK-NEXT:    [[OR1:%.*]] = or i32 [[NOT1]], [[C:%.*]]
+; CHECK-NEXT:    [[AND2:%.*]] = and i32 [[C]], [[A]]
+; CHECK-NEXT:    [[NOT2:%.*]] = xor i32 [[AND2]], -1
+; CHECK-NEXT:    [[OR2:%.*]] = or i32 [[NOT2]], [[B]]
+; CHECK-NEXT:    [[AND3:%.*]] = and i32 [[OR1]], [[OR2]]
+; CHECK-NEXT:    ret i32 [[AND3]]
+;
+  %and1 = and i32 %b, %a
+  %not1 = xor i32 %and1, -1
+  %or1 = or i32 %not1, %c
+  %and2 = and i32 %c, %a
+  %not2 = xor i32 %and2, -1
+  %or2 = or i32 %not2, %b
+  %and3 = and i32 %or1, %or2
+  ret i32 %and3
+}
+
+define i32 @and_not_or_commute4(i32 %a, i32 %b, i32 %c0) {
+; CHECK-LABEL: @and_not_or_commute4(
+; CHECK-NEXT:    [[C:%.*]] = sdiv i32 42, [[C0:%.*]]
+; CHECK-NEXT:    [[AND1:%.*]] = and i32 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[NOT1:%.*]] = xor i32 [[AND1]], -1
+; CHECK-NEXT:    [[OR1:%.*]] = or i32 [[C]], [[NOT1]]
+; CHECK-NEXT:    [[AND2:%.*]] = and i32 [[C]], [[A]]
+; CHECK-NEXT:    [[NOT2:%.*]] = xor i32 [[AND2]], -1
+; CHECK-NEXT:    [[OR2:%.*]] = or i32 [[NOT2]], [[B]]
+; CHECK-NEXT:    [[AND3:%.*]] = and i32 [[OR1]], [[OR2]]
+; CHECK-NEXT:    ret i32 [[AND3]]
+;
+  %c = sdiv i32 42, %c0 ; thwart complexity-based canonicalization
+  %and1 = and i32 %a, %b
+  %not1 = xor i32 %and1, -1
+  %or1 = or i32 %c, %not1
+  %and2 = and i32 %a, %c
+  %not2 = xor i32 %and2, -1
+  %or2 = or i32 %not2, %b
+  %and3 = and i32 %or1, %or2
+  ret i32 %and3
+}
+
+define i32 @and_not_or_commute5(i32 %a0, i32 %b, i32 %c0) {
+; CHECK-LABEL: @and_not_or_commute5(
+; CHECK-NEXT:    [[A:%.*]] = sdiv i32 42, [[A0:%.*]]
+; CHECK-NEXT:    [[C:%.*]] = sdiv i32 42, [[C0:%.*]]
+; CHECK-NEXT:    [[AND1:%.*]] = and i32 [[A]], [[B:%.*]]
+; CHECK-NEXT:    [[NOT1:%.*]] = xor i32 [[AND1]], -1
+; CHECK-NEXT:    [[OR1:%.*]] = or i32 [[C]], [[NOT1]]
+; CHECK-NEXT:    [[AND2:%.*]] = and i32 [[A]], [[C]]
+; CHECK-NEXT:    [[NOT2:%.*]] = xor i32 [[AND2]], -1
+; CHECK-NEXT:    [[OR2:%.*]] = or i32 [[NOT2]], [[B]]
+; CHECK-NEXT:    [[AND3:%.*]] = and i32 [[OR1]], [[OR2]]
+; CHECK-NEXT:    ret i32 [[AND3]]
+;
+  %a = sdiv i32 42, %a0 ; thwart complexity-based canonicalization
+  %c = sdiv i32 42, %c0 ; thwart complexity-based canonicalization
+  %and1 = and i32 %a, %b
+  %not1 = xor i32 %and1, -1
+  %or1 = or i32 %c, %not1
+  %and2 = and i32 %a, %c
+  %not2 = xor i32 %and2, -1
+  %or2 = or i32 %not2, %b
+  %and3 = and i32 %or1, %or2
+  ret i32 %and3
+}
+
+define i32 @and_not_or_commute6(i32 %a, i32 %b, i32 %c) {
+; CHECK-LABEL: @and_not_or_commute6(
+; CHECK-NEXT:    [[AND1:%.*]] = and i32 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[NOT1:%.*]] = xor i32 [[AND1]], -1
+; CHECK-NEXT:    [[OR1:%.*]] = or i32 [[NOT1]], [[C:%.*]]
+; CHECK-NEXT:    [[AND2:%.*]] = and i32 [[C]], [[A]]
+; CHECK-NEXT:    [[NOT2:%.*]] = xor i32 [[AND2]], -1
+; CHECK-NEXT:    [[OR2:%.*]] = or i32 [[NOT2]], [[B]]
+; CHECK-NEXT:    [[AND3:%.*]] = and i32 [[OR1]], [[OR2]]
+; CHECK-NEXT:    ret i32 [[AND3]]
+;
+  %and1 = and i32 %a, %b
+  %not1 = xor i32 %and1, -1
+  %or1 = or i32 %not1, %c
+  %and2 = and i32 %c, %a
+  %not2 = xor i32 %and2, -1
+  %or2 = or i32 %not2, %b
+  %and3 = and i32 %or1, %or2
+  ret i32 %and3
+}
+
+define i32 @and_not_or_commute7(i32 %a, i32 %b, i32 %c) {
+; CHECK-LABEL: @and_not_or_commute7(
+; CHECK-NEXT:    [[AND1:%.*]] = and i32 [[B:%.*]], [[A:%.*]]
+; CHECK-NEXT:    [[NOT1:%.*]] = xor i32 [[AND1]], -1
+; CHECK-NEXT:    [[OR1:%.*]] = or i32 [[NOT1]], [[C:%.*]]
+; CHECK-NEXT:    [[AND2:%.*]] = and i32 [[A]], [[C]]
+; CHECK-NEXT:    [[NOT2:%.*]] = xor i32 [[AND2]], -1
+; CHECK-NEXT:    [[OR2:%.*]] = or i32 [[NOT2]], [[B]]
+; CHECK-NEXT:    [[AND3:%.*]] = and i32 [[OR1]], [[OR2]]
+; CHECK-NEXT:    ret i32 [[AND3]]
+;
+  %and1 = and i32 %b, %a
+  %not1 = xor i32 %and1, -1
+  %or1 = or i32 %not1, %c
+  %and2 = and i32 %a, %c
+  %not2 = xor i32 %and2, -1
+  %or2 = or i32 %not2, %b
+  %and3 = and i32 %or1, %or2
+  ret i32 %and3
+}
+
+define i32 @and_not_or_commute8(i32 %a0, i32 %b0, i32 %c) {
+; CHECK-LABEL: @and_not_or_commute8(
+; CHECK-NEXT:    [[A:%.*]] = sdiv i32 42, [[A0:%.*]]
+; CHECK-NEXT:    [[B:%.*]] = sdiv i32 42, [[B0:%.*]]
+; CHECK-NEXT:    [[AND1:%.*]] = and i32 [[A]], [[B]]
+; CHECK-NEXT:    [[NOT1:%.*]] = xor i32 [[AND1]], -1
+; CHECK-NEXT:    [[OR1:%.*]] = or i32 [[NOT1]], [[C:%.*]]
+; CHECK-NEXT:    [[AND2:%.*]] = and i32 [[A]], [[C]]
+; CHECK-NEXT:    [[NOT2:%.*]] = xor i32 [[AND2]], -1
+; CHECK-NEXT:    [[OR2:%.*]] = or i32 [[B]], [[NOT2]]
+; CHECK-NEXT:    [[AND3:%.*]] = and i32 [[OR1]], [[OR2]]
+; CHECK-NEXT:    ret i32 [[AND3]]
+;
+  %a = sdiv i32 42, %a0 ; thwart complexity-based canonicalization
+  %b = sdiv i32 42, %b0 ; thwart complexity-based canonicalization
+  %and1 = and i32 %a, %b
+  %not1 = xor i32 %and1, -1
+  %or1 = or i32 %not1, %c
+  %and2 = and i32 %c, %a
+  %not2 = xor i32 %and2, -1
+  %or2 = or i32 %b, %not2
+  %and3 = and i32 %or1, %or2
+  ret i32 %and3
+}
+
+define i32 @and_not_or_commute9(i32 %a0, i32 %b0, i32 %c0) {
+; CHECK-LABEL: @and_not_or_commute9(
+; CHECK-NEXT:    [[A:%.*]] = sdiv i32 42, [[A0:%.*]]
+; CHECK-NEXT:    [[B:%.*]] = sdiv i32 42, [[B0:%.*]]
+; CHECK-NEXT:    [[C:%.*]] = sdiv i32 42, [[C0:%.*]]
+; CHECK-NEXT:    [[AND1:%.*]] = and i32 [[A]], [[B]]
+; CHECK-NEXT:    [[NOT1:%.*]] = xor i32 [[AND1]], -1
+; CHECK-NEXT:    [[OR1:%.*]] = or i32 [[C]], [[NOT1]]
+; CHECK-NEXT:    [[AND2:%.*]] = and i32 [[A]], [[C]]
+; CHECK-NEXT:    [[NOT2:%.*]] = xor i32 [[AND2]], -1
+; CHECK-NEXT:    [[OR2:%.*]] = or i32 [[B]], [[NOT2]]
+; CHECK-NEXT:    [[AND3:%.*]] = and i32 [[OR1]], [[OR2]]
+; CHECK-NEXT:    ret i32 [[AND3]]
+;
+  %a = sdiv i32 42, %a0 ; thwart complexity-based canonicalization
+  %b = sdiv i32 42, %b0 ; thwart complexity-based canonicalization
+  %c = sdiv i32 42, %c0 ; thwart complexity-based canonicalization
+  %and1 = and i32 %a, %b
+  %not1 = xor i32 %and1, -1
+  %or1 = or i32 %not1, %c
+  %and2 = and i32 %a, %c
+  %not2 = xor i32 %and2, -1
+  %or2 = or i32 %b, %not2
+  %and3 = and i32 %or1, %or2
+  ret i32 %and3
+}
+
+define i32 @and_not_or_extra_not_use1(i32 %a, i32 %b, i32 %c) {
+; CHECK-LABEL: @and_not_or_extra_not_use1(
+; CHECK-NEXT:    [[AND1:%.*]] = and i32 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[NOT1:%.*]] = xor i32 [[AND1]], -1
+; CHECK-NEXT:    [[OR1:%.*]] = or i32 [[NOT1]], [[C:%.*]]
+; CHECK-NEXT:    [[AND2:%.*]] = and i32 [[A]], [[C]]
+; CHECK-NEXT:    [[NOT2:%.*]] = xor i32 [[AND2]], -1
+; CHECK-NEXT:    [[OR2:%.*]] = or i32 [[NOT2]], [[B]]
+; CHECK-NEXT:    [[AND3:%.*]] = and i32 [[OR1]], [[OR2]]
+; CHECK-NEXT:    call void @use(i32 [[NOT1]])
+; CHECK-NEXT:    ret i32 [[AND3]]
+;
+  %and1 = and i32 %a, %b
+  %not1 = xor i32 %and1, -1
+  %or1 = or i32 %not1, %c
+  %and2 = and i32 %a, %c
+  %not2 = xor i32 %and2, -1
+  %or2 = or i32 %not2, %b
+  %and3 = and i32 %or1, %or2
+  call void @use(i32 %not1)
+  ret i32 %and3
+}
+
+define i32 @and_not_or_extra_not_use2(i32 %a, i32 %b, i32 %c) {
+; CHECK-LABEL: @and_not_or_extra_not_use2(
+; CHECK-NEXT:    [[AND1:%.*]] = and i32 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[NOT1:%.*]] = xor i32 [[AND1]], -1
+; CHECK-NEXT:    [[OR1:%.*]] = or i32 [[NOT1]], [[C:%.*]]
+; CHECK-NEXT:    [[AND2:%.*]] = and i32 [[A]], [[C]]
+; CHECK-NEXT:    [[NOT2:%.*]] = xor i32 [[AND2]], -1
+; CHECK-NEXT:    [[OR2:%.*]] = or i32 [[NOT2]], [[B]]
+; CHECK-NEXT:    [[AND3:%.*]] = and i32 [[OR1]], [[OR2]]
+; CHECK-NEXT:    call void @use(i32 [[NOT2]])
+; CHECK-NEXT:    ret i32 [[AND3]]
+;
+  %and1 = and i32 %a, %b
+  %not1 = xor i32 %and1, -1
+  %or1 = or i32 %not1, %c
+  %and2 = and i32 %a, %c
+  %not2 = xor i32 %and2, -1
+  %or2 = or i32 %not2, %b
+  %and3 = and i32 %or1, %or2
+  call void @use(i32 %not2)
+  ret i32 %and3
+}
+
+define i32 @and_not_or_extra_and_use1(i32 %a, i32 %b, i32 %c) {
+; CHECK-LABEL: @and_not_or_extra_and_use1(
+; CHECK-NEXT:    [[AND1:%.*]] = and i32 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[NOT1:%.*]] = xor i32 [[AND1]], -1
+; CHECK-NEXT:    [[OR1:%.*]] = or i32 [[NOT1]], [[C:%.*]]
+; CHECK-NEXT:    [[AND2:%.*]] = and i32 [[A]], [[C]]
+; CHECK-NEXT:    [[NOT2:%.*]] = xor i32 [[AND2]], -1
+; CHECK-NEXT:    [[OR2:%.*]] = or i32 [[NOT2]], [[B]]
+; CHECK-NEXT:    [[AND3:%.*]] = and i32 [[OR1]], [[OR2]]
+; CHECK-NEXT:    call void @use(i32 [[OR1]])
+; CHECK-NEXT:    ret i32 [[AND3]]
+;
+  %and1 = and i32 %a, %b
+  %not1 = xor i32 %and1, -1
+  %or1 = or i32 %not1, %c
+  %and2 = and i32 %a, %c
+  %not2 = xor i32 %and2, -1
+  %or2 = or i32 %not2, %b
+  %and3 = and i32 %or1, %or2
+  call void @use(i32 %or1)
+  ret i32 %and3
+}
+
+define i32 @and_not_or_extra_and_use2(i32 %a, i32 %b, i32 %c) {
+; CHECK-LABEL: @and_not_or_extra_and_use2(
+; CHECK-NEXT:    [[AND1:%.*]] = and i32 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[NOT1:%.*]] = xor i32 [[AND1]], -1
+; CHECK-NEXT:    [[OR1:%.*]] = or i32 [[NOT1]], [[C:%.*]]
+; CHECK-NEXT:    [[AND2:%.*]] = and i32 [[A]], [[C]]
+; CHECK-NEXT:    [[NOT2:%.*]] = xor i32 [[AND2]], -1
+; CHECK-NEXT:    [[OR2:%.*]] = or i32 [[NOT2]], [[B]]
+; CHECK-NEXT:    [[AND3:%.*]] = and i32 [[OR1]], [[OR2]]
+; CHECK-NEXT:    call void @use(i32 [[OR2]])
+; CHECK-NEXT:    ret i32 [[AND3]]
+;
+  %and1 = and i32 %a, %b
+  %not1 = xor i32 %and1, -1
+  %or1 = or i32 %not1, %c
+  %and2 = and i32 %a, %c
+  %not2 = xor i32 %and2, -1
+  %or2 = or i32 %not2, %b
+  %and3 = and i32 %or1, %or2
+  call void @use(i32 %or2)
+  ret i32 %and3
+}
+
+define i32 @and_not_or_extra_or_use1(i32 %a, i32 %b, i32 %c) {
+; CHECK-LABEL: @and_not_or_extra_or_use1(
+; CHECK-NEXT:    [[AND1:%.*]] = and i32 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[NOT1:%.*]] = xor i32 [[AND1]], -1
+; CHECK-NEXT:    [[OR1:%.*]] = or i32 [[NOT1]], [[C:%.*]]
+; CHECK-NEXT:    [[AND2:%.*]] = and i32 [[A]], [[C]]
+; CHECK-NEXT:    [[NOT2:%.*]] = xor i32 [[AND2]], -1
+; CHECK-NEXT:    [[OR2:%.*]] = or i32 [[NOT2]], [[B]]
+; CHECK-NEXT:    [[AND3:%.*]] = and i32 [[OR1]], [[OR2]]
+; CHECK-NEXT:    call void @use(i32 [[AND1]])
+; CHECK-NEXT:    ret i32 [[AND3]]
+;
+  %and1 = and i32 %a, %b
+  %not1 = xor i32 %and1, -1
+  %or1 = or i32 %not1, %c
+  %and2 = and i32 %a, %c
+  %not2 = xor i32 %and2, -1
+  %or2 = or i32 %not2, %b
+  %and3 = and i32 %or1, %or2
+  call void @use(i32 %and1)
+  ret i32 %and3
+}
+
+define i32 @and_not_or_extra_or_use2(i32 %a, i32 %b, i32 %c) {
+; CHECK-LABEL: @and_not_or_extra_or_use2(
+; CHECK-NEXT:    [[AND1:%.*]] = and i32 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[NOT1:%.*]] = xor i32 [[AND1]], -1
+; CHECK-NEXT:    [[OR1:%.*]] = or i32 [[NOT1]], [[C:%.*]]
+; CHECK-NEXT:    [[AND2:%.*]] = and i32 [[A]], [[C]]
+; CHECK-NEXT:    [[NOT2:%.*]] = xor i32 [[AND2]], -1
+; CHECK-NEXT:    [[OR2:%.*]] = or i32 [[NOT2]], [[B]]
+; CHECK-NEXT:    [[AND3:%.*]] = and i32 [[OR1]], [[OR2]]
+; CHECK-NEXT:    call void @use(i32 [[AND2]])
+; CHECK-NEXT:    ret i32 [[AND3]]
+;
+  %and1 = and i32 %a, %b
+  %not1 = xor i32 %and1, -1
+  %or1 = or i32 %not1, %c
+  %and2 = and i32 %a, %c
+  %not2 = xor i32 %and2, -1
+  %or2 = or i32 %not2, %b
+  %and3 = and i32 %or1, %or2
+  call void @use(i32 %and2)
+  ret i32 %and3
+}
+
+define i32 @and_not_or_wrong_c(i32 %a, i32 %b, i32 %c, i32 %d) {
+; CHECK-LABEL: @and_not_or_wrong_c(
+; CHECK-NEXT:    [[AND1:%.*]] = and i32 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[NOT1:%.*]] = xor i32 [[AND1]], -1
+; CHECK-NEXT:    [[OR1:%.*]] = or i32 [[NOT1]], [[C:%.*]]
+; CHECK-NEXT:    [[AND2:%.*]] = and i32 [[A]], [[D:%.*]]
+; CHECK-NEXT:    [[NOT2:%.*]] = xor i32 [[AND2]], -1
+; CHECK-NEXT:    [[OR2:%.*]] = or i32 [[NOT2]], [[B]]
+; CHECK-NEXT:    [[AND3:%.*]] = and i32 [[OR1]], [[OR2]]
+; CHECK-NEXT:    ret i32 [[AND3]]
+;
+  %and1 = and i32 %a, %b
+  %not1 = xor i32 %and1, -1
+  %or1 = or i32 %not1, %c
+  %and2 = and i32 %a, %d
+  %not2 = xor i32 %and2, -1
+  %or2 = or i32 %not2, %b
+  %and3 = and i32 %or1, %or2
+  ret i32 %and3
+}
+
+define i32 @and_not_or_wrong_b(i32 %a, i32 %b, i32 %c, i32 %d) {
+; CHECK-LABEL: @and_not_or_wrong_b(
+; CHECK-NEXT:    [[AND1:%.*]] = and i32 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[NOT1:%.*]] = xor i32 [[AND1]], -1
+; CHECK-NEXT:    [[OR1:%.*]] = or i32 [[NOT1]], [[C:%.*]]
+; CHECK-NEXT:    [[AND2:%.*]] = and i32 [[A]], [[C]]
+; CHECK-NEXT:    [[NOT2:%.*]] = xor i32 [[AND2]], -1
+; CHECK-NEXT:    [[OR2:%.*]] = or i32 [[NOT2]], [[D:%.*]]
+; CHECK-NEXT:    [[AND3:%.*]] = and i32 [[OR1]], [[OR2]]
+; CHECK-NEXT:    ret i32 [[AND3]]
+;
+  %and1 = and i32 %a, %b
+  %not1 = xor i32 %and1, -1
+  %or1 = or i32 %not1, %c
+  %and2 = and i32 %a, %c
+  %not2 = xor i32 %and2, -1
+  %or2 = or i32 %not2, %d
+  %and3 = and i32 %or1, %or2
+  ret i32 %and3
+}
+
 ; (b & ~(a | c)) | ~(a | b) --> ~((b & c) | a)
 
 define i32 @or_and_not_not(i32 %a, i32 %b, i32 %c) {
@@ -1299,6 +1711,29 @@ define i32 @or_and_not_not_extra_or_use2(i32 %a, i32 %b, i32 %c) {
   ret i32 %or3
 }
 
+define i32 @or_and_not_not_2_extra_uses(i32 %a, i32 %b, i32 %c) {
+; CHECK-LABEL: @or_and_not_not_2_extra_uses(
+; CHECK-NEXT:    [[OR1:%.*]] = or i32 [[B:%.*]], [[A:%.*]]
+; CHECK-NEXT:    call void @use(i32 [[OR1]])
+; CHECK-NEXT:    [[NOT1:%.*]] = xor i32 [[OR1]], -1
+; CHECK-NEXT:    [[OR2:%.*]] = or i32 [[A]], [[C:%.*]]
+; CHECK-NEXT:    [[NOT2:%.*]] = xor i32 [[OR2]], -1
+; CHECK-NEXT:    [[AND:%.*]] = and i32 [[NOT2]], [[B]]
+; CHECK-NEXT:    call void @use(i32 [[AND]])
+; CHECK-NEXT:    [[OR3:%.*]] = or i32 [[AND]], [[NOT1]]
+; CHECK-NEXT:    ret i32 [[OR3]]
+;
+  %or1 = or i32 %b, %a
+  call void @use(i32 %or1)
+  %not1 = xor i32 %or1, -1
+  %or2 = or i32 %a, %c
+  %not2 = xor i32 %or2, -1
+  %and = and i32 %not2, %b
+  call void @use(i32 %and)
+  %or3 = or i32 %not1, %and
+  ret i32 %or3
+}
+
 define i32 @or_and_not_not_wrong_a(i32 %a, i32 %b, i32 %c, i32 %d) {
 ; CHECK-LABEL: @or_and_not_not_wrong_a(
 ; CHECK-NEXT:    [[OR1:%.*]] = or i32 [[B:%.*]], [[D:%.*]]
@@ -1337,6 +1772,316 @@ define i32 @or_and_not_not_wrong_b(i32 %a, i32 %b, i32 %c, i32 %d) {
   ret i32 %or3
 }
 
+; (b | ~(a & c)) & ~(a & b) --> ~((b | c) & a)
+
+define i32 @and_or_not_not(i32 %a, i32 %b, i32 %c) {
+; CHECK-LABEL: @and_or_not_not(
+; CHECK-NEXT:    [[AND1:%.*]] = and i32 [[B:%.*]], [[A:%.*]]
+; CHECK-NEXT:    [[AND2:%.*]] = and i32 [[A]], [[C:%.*]]
+; CHECK-NEXT:    [[NOT2:%.*]] = xor i32 [[AND2]], -1
+; CHECK-NEXT:    [[OR:%.*]] = or i32 [[NOT2]], [[B]]
+; CHECK-NEXT:    [[AND3:%.*]] = xor i32 [[AND1]], [[OR]]
+; CHECK-NEXT:    ret i32 [[AND3]]
+;
+  %and1 = and i32 %b, %a
+  %not1 = xor i32 %and1, -1
+  %and2 = and i32 %a, %c
+  %not2 = xor i32 %and2, -1
+  %or = or i32 %not2, %b
+  %and3 = and i32 %or, %not1
+  ret i32 %and3
+}
+
+define i32 @and_or_not_not_commute1(i32 %a, i32 %b0, i32 %c) {
+; CHECK-LABEL: @and_or_not_not_commute1(
+; CHECK-NEXT:    [[B:%.*]] = sdiv i32 42, [[B0:%.*]]
+; CHECK-NEXT:    [[AND1:%.*]] = and i32 [[B]], [[A:%.*]]
+; CHECK-NEXT:    [[AND2:%.*]] = and i32 [[A]], [[C:%.*]]
+; CHECK-NEXT:    [[NOT2:%.*]] = xor i32 [[AND2]], -1
+; CHECK-NEXT:    [[OR:%.*]] = or i32 [[B]], [[NOT2]]
+; CHECK-NEXT:    [[AND3:%.*]] = xor i32 [[AND1]], [[OR]]
+; CHECK-NEXT:    ret i32 [[AND3]]
+;
+  %b = sdiv i32 42, %b0 ; thwart complexity-based canonicalization
+  %and1 = and i32 %b, %a
+  %not1 = xor i32 %and1, -1
+  %and2 = and i32 %a, %c
+  %not2 = xor i32 %and2, -1
+  %or = or i32 %b, %not2
+  %and3 = and i32 %or, %not1
+  ret i32 %and3
+}
+
+define i32 @and_or_not_not_commute2(i32 %a, i32 %b, i32 %c) {
+; CHECK-LABEL: @and_or_not_not_commute2(
+; CHECK-NEXT:    [[AND1:%.*]] = and i32 [[B:%.*]], [[A:%.*]]
+; CHECK-NEXT:    [[AND2:%.*]] = and i32 [[A]], [[C:%.*]]
+; CHECK-NEXT:    [[NOT2:%.*]] = xor i32 [[AND2]], -1
+; CHECK-NEXT:    [[OR:%.*]] = or i32 [[NOT2]], [[B]]
+; CHECK-NEXT:    [[AND3:%.*]] = xor i32 [[AND1]], [[OR]]
+; CHECK-NEXT:    ret i32 [[AND3]]
+;
+  %and1 = and i32 %b, %a
+  %not1 = xor i32 %and1, -1
+  %and2 = and i32 %a, %c
+  %not2 = xor i32 %and2, -1
+  %or = or i32 %not2, %b
+  %and3 = and i32 %or, %not1
+  ret i32 %and3
+}
+
+define i32 @and_or_not_not_commute3(i32 %a, i32 %b, i32 %c) {
+; CHECK-LABEL: @and_or_not_not_commute3(
+; CHECK-NEXT:    [[AND1:%.*]] = and i32 [[B:%.*]], [[A:%.*]]
+; CHECK-NEXT:    [[AND2:%.*]] = and i32 [[C:%.*]], [[A]]
+; CHECK-NEXT:    [[NOT2:%.*]] = xor i32 [[AND2]], -1
+; CHECK-NEXT:    [[OR:%.*]] = or i32 [[NOT2]], [[B]]
+; CHECK-NEXT:    [[AND3:%.*]] = xor i32 [[AND1]], [[OR]]
+; CHECK-NEXT:    ret i32 [[AND3]]
+;
+  %and1 = and i32 %b, %a
+  %not1 = xor i32 %and1, -1
+  %and2 = and i32 %c, %a
+  %not2 = xor i32 %and2, -1
+  %or = or i32 %not2, %b
+  %and3 = and i32 %or, %not1
+  ret i32 %and3
+}
+
+define i32 @and_or_not_not_commute4(i32 %a, i32 %b, i32 %c) {
+; CHECK-LABEL: @and_or_not_not_commute4(
+; CHECK-NEXT:    [[AND1:%.*]] = and i32 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[AND2:%.*]] = and i32 [[A]], [[C:%.*]]
+; CHECK-NEXT:    [[NOT2:%.*]] = xor i32 [[AND2]], -1
+; CHECK-NEXT:    [[OR:%.*]] = or i32 [[NOT2]], [[B]]
+; CHECK-NEXT:    [[AND3:%.*]] = xor i32 [[AND1]], [[OR]]
+; CHECK-NEXT:    ret i32 [[AND3]]
+;
+  %and1 = and i32 %a, %b
+  %not1 = xor i32 %and1, -1
+  %and2 = and i32 %a, %c
+  %not2 = xor i32 %and2, -1
+  %or = or i32 %not2, %b
+  %and3 = and i32 %or, %not1
+  ret i32 %and3
+}
+
+define i32 @and_or_not_not_commute5(i32 %a, i32 %b, i32 %c) {
+; CHECK-LABEL: @and_or_not_not_commute5(
+; CHECK-NEXT:    [[AND1:%.*]] = and i32 [[B:%.*]], [[A:%.*]]
+; CHECK-NEXT:    [[AND2:%.*]] = and i32 [[A]], [[C:%.*]]
+; CHECK-NEXT:    [[NOT2:%.*]] = xor i32 [[AND2]], -1
+; CHECK-NEXT:    [[OR:%.*]] = or i32 [[NOT2]], [[B]]
+; CHECK-NEXT:    [[AND3:%.*]] = xor i32 [[AND1]], [[OR]]
+; CHECK-NEXT:    ret i32 [[AND3]]
+;
+  %and1 = and i32 %b, %a
+  %not1 = xor i32 %and1, -1
+  %and2 = and i32 %a, %c
+  %not2 = xor i32 %and2, -1
+  %or = or i32 %not2, %b
+  %and3 = and i32 %not1, %or
+  ret i32 %and3
+}
+
+define i32 @and_or_not_not_commute6(i32 %a, i32 %b0, i32 %c) {
+; CHECK-LABEL: @and_or_not_not_commute6(
+; CHECK-NEXT:    [[B:%.*]] = sdiv i32 42, [[B0:%.*]]
+; CHECK-NEXT:    [[AND1:%.*]] = and i32 [[B]], [[A:%.*]]
+; CHECK-NEXT:    [[AND2:%.*]] = and i32 [[C:%.*]], [[A]]
+; CHECK-NEXT:    [[NOT2:%.*]] = xor i32 [[AND2]], -1
+; CHECK-NEXT:    [[OR:%.*]] = or i32 [[B]], [[NOT2]]
+; CHECK-NEXT:    [[AND3:%.*]] = xor i32 [[AND1]], [[OR]]
+; CHECK-NEXT:    ret i32 [[AND3]]
+;
+  %b = sdiv i32 42, %b0 ; thwart complexity-based canonicalization
+  %and1 = and i32 %b, %a
+  %not1 = xor i32 %and1, -1
+  %and2 = and i32 %c, %a
+  %not2 = xor i32 %and2, -1
+  %or = or i32 %b, %not2
+  %and3 = and i32 %or, %not1
+  ret i32 %and3
+}
+
+define i32 @and_or_not_not_commute7(i32 %a, i32 %b, i32 %c) {
+; CHECK-LABEL: @and_or_not_not_commute7(
+; CHECK-NEXT:    [[AND1:%.*]] = and i32 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[AND2:%.*]] = and i32 [[C:%.*]], [[A]]
+; CHECK-NEXT:    [[NOT2:%.*]] = xor i32 [[AND2]], -1
+; CHECK-NEXT:    [[OR:%.*]] = or i32 [[NOT2]], [[B]]
+; CHECK-NEXT:    [[AND3:%.*]] = xor i32 [[AND1]], [[OR]]
+; CHECK-NEXT:    ret i32 [[AND3]]
+;
+  %and1 = and i32 %a, %b
+  %not1 = xor i32 %and1, -1
+  %and2 = and i32 %c, %a
+  %not2 = xor i32 %and2, -1
+  %or = or i32 %not2, %b
+  %and3 = and i32 %or, %not1
+  ret i32 %and3
+}
+
+define i32 @and_or_not_not_extra_not_use1(i32 %a, i32 %b, i32 %c) {
+; CHECK-LABEL: @and_or_not_not_extra_not_use1(
+; CHECK-NEXT:    [[AND1:%.*]] = and i32 [[B:%.*]], [[A:%.*]]
+; CHECK-NEXT:    [[NOT1:%.*]] = xor i32 [[AND1]], -1
+; CHECK-NEXT:    [[AND2:%.*]] = and i32 [[A]], [[C:%.*]]
+; CHECK-NEXT:    [[NOT2:%.*]] = xor i32 [[AND2]], -1
+; CHECK-NEXT:    [[OR:%.*]] = or i32 [[NOT2]], [[B]]
+; CHECK-NEXT:    [[AND3:%.*]] = xor i32 [[AND1]], [[OR]]
+; CHECK-NEXT:    call void @use(i32 [[NOT1]])
+; CHECK-NEXT:    ret i32 [[AND3]]
+;
+  %and1 = and i32 %b, %a
+  %not1 = xor i32 %and1, -1
+  %and2 = and i32 %a, %c
+  %not2 = xor i32 %and2, -1
+  %or = or i32 %not2, %b
+  %and3 = and i32 %or, %not1
+  call void @use(i32 %not1)
+  ret i32 %and3
+}
+
+define i32 @and_or_not_not_extra_not_use2(i32 %a, i32 %b, i32 %c) {
+; CHECK-LABEL: @and_or_not_not_extra_not_use2(
+; CHECK-NEXT:    [[AND1:%.*]] = and i32 [[B:%.*]], [[A:%.*]]
+; CHECK-NEXT:    [[AND2:%.*]] = and i32 [[A]], [[C:%.*]]
+; CHECK-NEXT:    [[NOT2:%.*]] = xor i32 [[AND2]], -1
+; CHECK-NEXT:    [[OR:%.*]] = or i32 [[NOT2]], [[B]]
+; CHECK-NEXT:    [[AND3:%.*]] = xor i32 [[AND1]], [[OR]]
+; CHECK-NEXT:    call void @use(i32 [[NOT2]])
+; CHECK-NEXT:    ret i32 [[AND3]]
+;
+  %and1 = and i32 %b, %a
+  %not1 = xor i32 %and1, -1
+  %and2 = and i32 %a, %c
+  %not2 = xor i32 %and2, -1
+  %or = or i32 %not2, %b
+  %and3 = and i32 %or, %not1
+  call void @use(i32 %not2)
+  ret i32 %and3
+}
+
+define i32 @and_or_not_not_extra_and_use(i32 %a, i32 %b, i32 %c) {
+; CHECK-LABEL: @and_or_not_not_extra_and_use(
+; CHECK-NEXT:    [[AND1:%.*]] = and i32 [[B:%.*]], [[A:%.*]]
+; CHECK-NEXT:    [[AND2:%.*]] = and i32 [[A]], [[C:%.*]]
+; CHECK-NEXT:    [[NOT2:%.*]] = xor i32 [[AND2]], -1
+; CHECK-NEXT:    [[OR:%.*]] = or i32 [[NOT2]], [[B]]
+; CHECK-NEXT:    [[AND3:%.*]] = xor i32 [[AND1]], [[OR]]
+; CHECK-NEXT:    call void @use(i32 [[OR]])
+; CHECK-NEXT:    ret i32 [[AND3]]
+;
+  %and1 = and i32 %b, %a
+  %not1 = xor i32 %and1, -1
+  %and2 = and i32 %a, %c
+  %not2 = xor i32 %and2, -1
+  %or = or i32 %not2, %b
+  %and3 = and i32 %or, %not1
+  call void @use(i32 %or)
+  ret i32 %and3
+}
+
+define i32 @and_or_not_not_extra_or_use1(i32 %a, i32 %b, i32 %c) {
+; CHECK-LABEL: @and_or_not_not_extra_or_use1(
+; CHECK-NEXT:    [[AND1:%.*]] = and i32 [[B:%.*]], [[A:%.*]]
+; CHECK-NEXT:    [[AND2:%.*]] = and i32 [[A]], [[C:%.*]]
+; CHECK-NEXT:    [[NOT2:%.*]] = xor i32 [[AND2]], -1
+; CHECK-NEXT:    [[OR:%.*]] = or i32 [[NOT2]], [[B]]
+; CHECK-NEXT:    [[AND3:%.*]] = xor i32 [[AND1]], [[OR]]
+; CHECK-NEXT:    call void @use(i32 [[AND1]])
+; CHECK-NEXT:    ret i32 [[AND3]]
+;
+  %and1 = and i32 %b, %a
+  %not1 = xor i32 %and1, -1
+  %and2 = and i32 %a, %c
+  %not2 = xor i32 %and2, -1
+  %or = or i32 %not2, %b
+  %and3 = and i32 %or, %not1
+  call void @use(i32 %and1)
+  ret i32 %and3
+}
+
+define i32 @and_or_not_not_extra_or_use2(i32 %a, i32 %b, i32 %c) {
+; CHECK-LABEL: @and_or_not_not_extra_or_use2(
+; CHECK-NEXT:    [[AND1:%.*]] = and i32 [[B:%.*]], [[A:%.*]]
+; CHECK-NEXT:    [[AND2:%.*]] = and i32 [[A]], [[C:%.*]]
+; CHECK-NEXT:    [[NOT2:%.*]] = xor i32 [[AND2]], -1
+; CHECK-NEXT:    [[OR:%.*]] = or i32 [[NOT2]], [[B]]
+; CHECK-NEXT:    [[AND3:%.*]] = xor i32 [[AND1]], [[OR]]
+; CHECK-NEXT:    call void @use(i32 [[AND2]])
+; CHECK-NEXT:    ret i32 [[AND3]]
+;
+  %and1 = and i32 %b, %a
+  %not1 = xor i32 %and1, -1
+  %and2 = and i32 %a, %c
+  %not2 = xor i32 %and2, -1
+  %or = or i32 %not2, %b
+  %and3 = and i32 %or, %not1
+  call void @use(i32 %and2)
+  ret i32 %and3
+}
+
+define i32 @and_or_not_not_2_extra_uses(i32 %a, i32 %b, i32 %c) {
+; CHECK-LABEL: @and_or_not_not_2_extra_uses(
+; CHECK-NEXT:    [[AND1:%.*]] = and i32 [[B:%.*]], [[A:%.*]]
+; CHECK-NEXT:    call void @use(i32 [[AND1]])
+; CHECK-NEXT:    [[AND2:%.*]] = and i32 [[A]], [[C:%.*]]
+; CHECK-NEXT:    [[NOT2:%.*]] = xor i32 [[AND2]], -1
+; CHECK-NEXT:    [[OR:%.*]] = or i32 [[NOT2]], [[B]]
+; CHECK-NEXT:    call void @use(i32 [[OR]])
+; CHECK-NEXT:    [[AND3:%.*]] = xor i32 [[AND1]], [[OR]]
+; CHECK-NEXT:    ret i32 [[AND3]]
+;
+  %and1 = and i32 %b, %a
+  call void @use(i32 %and1)
+  %not1 = xor i32 %and1, -1
+  %and2 = and i32 %a, %c
+  %not2 = xor i32 %and2, -1
+  %or = or i32 %not2, %b
+  call void @use(i32 %or)
+  %and3 = and i32 %not1, %or
+  ret i32 %and3
+}
+
+define i32 @and_or_not_not_wrong_a(i32 %a, i32 %b, i32 %c, i32 %d) {
+; CHECK-LABEL: @and_or_not_not_wrong_a(
+; CHECK-NEXT:    [[AND1:%.*]] = and i32 [[B:%.*]], [[D:%.*]]
+; CHECK-NEXT:    [[AND2:%.*]] = and i32 [[A:%.*]], [[C:%.*]]
+; CHECK-NEXT:    [[NOT2:%.*]] = xor i32 [[AND2]], -1
+; CHECK-NEXT:    [[OR:%.*]] = or i32 [[NOT2]], [[B]]
+; CHECK-NEXT:    [[AND3:%.*]] = xor i32 [[AND1]], [[OR]]
+; CHECK-NEXT:    ret i32 [[AND3]]
+;
+  %and1 = and i32 %b, %d
+  %not1 = xor i32 %and1, -1
+  %and2 = and i32 %a, %c
+  %not2 = xor i32 %and2, -1
+  %or = or i32 %not2, %b
+  %and3 = and i32 %or, %not1
+  ret i32 %and3
+}
+
+define i32 @and_or_not_not_wrong_b(i32 %a, i32 %b, i32 %c, i32 %d) {
+; CHECK-LABEL: @and_or_not_not_wrong_b(
+; CHECK-NEXT:    [[AND1:%.*]] = and i32 [[D:%.*]], [[A:%.*]]
+; CHECK-NEXT:    [[NOT1:%.*]] = xor i32 [[AND1]], -1
+; CHECK-NEXT:    [[AND2:%.*]] = and i32 [[A]], [[C:%.*]]
+; CHECK-NEXT:    [[NOT2:%.*]] = xor i32 [[AND2]], -1
+; CHECK-NEXT:    [[OR:%.*]] = or i32 [[NOT2]], [[B:%.*]]
+; CHECK-NEXT:    [[AND3:%.*]] = and i32 [[OR]], [[NOT1]]
+; CHECK-NEXT:    ret i32 [[AND3]]
+;
+  %and1 = and i32 %d, %a
+  %not1 = xor i32 %and1, -1
+  %and2 = and i32 %a, %c
+  %not2 = xor i32 %and2, -1
+  %or = or i32 %not2, %b
+  %and3 = and i32 %or, %not1
+  ret i32 %and3
+}
+
 ; (a & ~(b | c)) | ~(a | (b ^ c)) --> (~a & b & c) | ~(b | c)
 
 define i32 @and_not_or_or_not_or_xor(i32 %a, i32 %b, i32 %c) {