[InstCombine] try to fold the expression "(A & ~B) + B" to "A | B"

[spatel]

Summary

Summary

Since llvm will generate the following ir:

define i32 @and_to_xor1(i32 %0, i32 %1) local_unnamed_addr #0 {
   %3 = shl nsw i32 %0, 1
   %4 = mul nsw i32 %1, %0
   %5 = xor i32 %4, -1
   %6 = and i32 %3, %5
   %7 = add nsw i32 %6, %4
   ret i32 %7
 }

but InstCombine can not simplify this code shape.
So I use this patch to achieve this.

Test Plan:

check-llvm

[lebedev.ri]

The missing fold here is: https://alive2.llvm.org/ce/z/7uIb0B (i.e. it should go into haveNoCommonBitsSet())
And this will automagically fold to or, not xor: https://godbolt.org/z/6svT3vc44

[dongAxis1944]

In D105013#2843794, @lebedev.ri wrote:

The missing fold here is: https://alive2.llvm.org/ce/z/7uIb0B (i.e. it should go into haveNoCommonBitsSet())
And this will automagically fold to or, not xor: https://godbolt.org/z/6svT3vc44

Sorry for my mistake, I just missing the right expression.

[dongAxis1944]

modify code , the original code is wrong

[dongAxis1944]

fix wrong comment

[lebedev.ri]

This pattern (A & ~B) op B should be matched in llvm::haveNoCommonBitsSet() in ValueTracking.cpp.

[dongAxis1944]

add pattern in valuetrack

[spatel]

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

8 ↗

(On Diff #354895)

1. The tests should be minimized - only instructions in the most basic pattern need to be here, so something like:

https://alive2.llvm.org/ce/z/NrJRbF

2. Use llvm/utils/update_test_checks.py to auto-generate the CHECK lines.

3. You can probably add these tests in the same file where existing haveNoCommonBitSet patterns are tested (disable the existing transform and see which tests fail).

[dongAxis1944]

@spatel thanks, I update the case, and I prefer use the new file, because the old case might not be clear to find I think.

[spatel]

llvm/test/Analysis/ValueTracking/known-non-common-bits.ll

6

There are 4 commuted variations of this pattern, so we should have a test for each. Other transforms will try to normalize the code structure, so the tests will have to overcome that to provide full coverage.

Search for "thwart complexity-based canonicalization" in the test dir for examples.

You may vary the value types across those 4 tests for more coverage as well (try unusual widths or vectors).

6

Remove "dso_local" and mangling artifacts from the function name.

It's easier to read the tests if the values are named the same as in the code comment ("A" and "B" in this case).

[spatel]

llvm/test/Analysis/ValueTracking/known-non-common-bits.ll

17

If I'm seeing it correctly, this test does not change with this patch. Why is it included?

[dongAxis1944]

remove useless ut

[dongAxis1944]

llvm/test/Analysis/ValueTracking/known-non-common-bits.ll

6

thanks., I will update later

[dongAxis1944]

address the comment

[dongAxis1944]

format the patch

[dongAxis1944]

address comment

[dongAxis1944]

gentle ping @spatel @lebedev.ri

[spatel]

In D105013#2866272, @dongAxis1944 wrote:

gentle ping @spatel @lebedev.ri

I don't think you've accounted for commutation in the tests. Did you see the existing test examples that have the comment "thwart complexity-based canonicalization"?
Do you have commit access? If so, please commit the tests only without the code change (and so with baseline CHECK lines), so we can confirm.

llvm/test/Analysis/ValueTracking/known-non-common-bits.ll

4

Remove mangling artifacts (_Z11, 1ii) from all function names.

[lebedev.ri]

This review seems to be stuck/dead, consider abandoning if no longer relevant.

[spatel]

This is a subset of:
D124763 / 2171a896ed0059e3576fd9c36d0021a3d

llvm/lib/Analysis/ValueTracking.cpp

bool llvm::haveNoCommonBitsSet(const Value *LHS, const Value *RHS,
   // Look for an inverted mask: (X & ~M) op (Y & M).
   Value *M;
   if (match(LHS, m_c_And(m_Not(m_Value(M)), m_Value())) &&
       match(RHS, m_c_And(m_Specific(M), m_Value())))
     return true;
   if (match(RHS, m_c_And(m_Not(m_Value(M)), m_Value())) &&
       match(LHS, m_c_And(m_Specific(M), m_Value())))
     return true;
+
+  // Look for a pattern:(A & ~B) op B
+  if (match(LHS, m_c_And(m_Not(m_Specific(RHS)), m_Value())) ||
+      match(RHS, m_c_And(m_Not(m_Specific(LHS)), m_Value())))
+    return true;
+
   IntegerType *IT = cast<IntegerType>(LHS->getType()->getScalarType());
   KnownBits LHSKnown(IT->getBitWidth());
   KnownBits RHSKnown(IT->getBitWidth());
   computeKnownBits(LHS, LHSKnown, DL, 0, AC, CxtI, DT, nullptr, UseInstrInfo);
   computeKnownBits(RHS, RHSKnown, DL, 0, AC, CxtI, DT, nullptr, UseInstrInfo);
   return KnownBits::haveNoCommonBitsSet(LHSKnown, RHSKnown);
 }
 

llvm/test/Analysis/ValueTracking/known-non-common-bits.ll

+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
+; RUN: opt < %s -instcombine -S | FileCheck %s
+
+define i32 @_Z11and_to_xor1ii(i32 %A, i32 %B) {
+; CHECK-LABEL: @_Z11and_to_xor1ii(
+; CHECK-NEXT:    [[RET:%.*]] = or i32 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    ret i32 [[RET]]
+;
+  %NOT_B = xor i32 %B, -1            ; %NOT_B = ~B
+  %AND = and i32 %NOT_B, %A          ; %AND = ~B & A
+  %RET = add nsw i32 %AND, %B        ; (~B & A) + B
+  ret i32 %RET
+}
+
+define i32 @_Z11and_to_xor2ii(i32 %A, i32 %B) {
+; CHECK-LABEL: @_Z11and_to_xor2ii(
+; CHECK-NEXT:    [[RET:%.*]] = or i32 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    ret i32 [[RET]]
+;
+  %NOT_B = xor i32 %B, -1            ; %NOT_B = ~B
+  %AND = and i32 %NOT_B, %A          ; %AND = ~B & A
+  %RET = add nsw i32 %B, %AND        ; B + (~B & A)
+  ret i32 %RET
+}
+
+define i32 @_Z11and_to_xor3ii(i32 %A, i32 %B) {
+; CHECK-LABEL: @_Z11and_to_xor3ii(
+; CHECK-NEXT:    [[RET:%.*]] = or i32 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    ret i32 [[RET]]
+;
+  %NOT_B = xor i32 %B, -1            ; %NOT_B = ~B
+  %AND = and i32 %A, %NOT_B          ; %AND = A & ~B
+  %RET = add nsw i32 %AND, %B        ; (A & ~B) + B
+  ret i32 %RET
+}
+
+define i32 @_Z11and_to_xor4ii(i32 %A, i32 %B) {
+; CHECK-LABEL: @_Z11and_to_xor4ii(
+; CHECK-NEXT:    [[RET:%.*]] = or i32 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    ret i32 [[RET]]
+;
+  %NOT_B = xor i32 %B, -1            ; %NOT_B = ~B
+  %AND = and i32 %A, %NOT_B          ; %AND = A & ~B
+  %RET = add nsw i32 %B, %AND        ; B + (A & ~B)
+  ret i32 %RET
+}
+
+define <2 x i32> @_Z11and_to_xor1vv(<2 x i32> %A, <2 x i32> %B) {
+; CHECK-LABEL: @_Z11and_to_xor1vv(
+; CHECK-NEXT:    [[RET:%.*]] = or <2 x i32> [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    ret <2 x i32> [[RET]]
+;
+  %NOT_B = xor <2 x i32> %B, <i32 -1, i32 -1>            ; %NOT_B = ~B
+  %AND = and <2 x i32> %NOT_B, %A                        ; %AND = ~B & A
+  %RET = add nsw <2 x i32> %AND, %B                       ; (~B & A) + B
+  ret <2 x i32> %RET
+}
+
+define <2 x i32> @_Z11and_to_xor2vv(<2 x i32> %A, <2 x i32> %B) {
+; CHECK-LABEL: @_Z11and_to_xor2vv(
+; CHECK-NEXT:    [[RET:%.*]] = or <2 x i32> [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    ret <2 x i32> [[RET]]
+;
+  %NOT_B = xor <2 x i32> %B, <i32 -1, i32 -1>            ; %NOT_B = ~B
+  %AND = and <2 x i32> %NOT_B, %A                        ; %AND = ~B & A
+  %RET = add nsw <2 x i32> %B, %AND                      ; B + (~B & A)
+  ret <2 x i32> %RET
+}
+
+define <2 x i32> @_Z11and_to_xor3vv(<2 x i32> %A, <2 x i32> %B) {
+; CHECK-LABEL: @_Z11and_to_xor3vv(
+; CHECK-NEXT:    [[RET:%.*]] = or <2 x i32> [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    ret <2 x i32> [[RET]]
+;
+  %NOT_B = xor <2 x i32> %B, <i32 -1, i32 -1>            ; %NOT_B = ~B
+  %AND = and <2 x i32> %A, %NOT_B                        ; %AND = A & ~B
+  %RET = add nsw <2 x i32> %AND, %B                       ; (A & ~B) + B
+  ret <2 x i32> %RET
+}
+
+define <2 x i32> @_Z11and_to_xor4vv(<2 x i32> %A, <2 x i32> %B) {
+; CHECK-LABEL: @_Z11and_to_xor4vv(
+; CHECK-NEXT:    [[RET:%.*]] = or <2 x i32> [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    ret <2 x i32> [[RET]]
+;
+  %NOT_B = xor <2 x i32> %B, <i32 -1, i32 -1>            ; %NOT_B = ~B
+  %AND = and <2 x i32> %A, %NOT_B                        ; %AND = A & ~B
+  %RET = add nsw <2 x i32> %B, %AND                      ; B + (A & ~B)
+  ret <2 x i32> %RET
+}