[DAG] Fold (X & Y) != 0 --> zextOrTrunc(X & Y) iff everything but LSB is known zero (PR51312)

[RKSimon]

Summary

Fixes parity codegen issue where we know all but the lowest bit is zero, we can replace the ICMPNE with 0 comparison with a zext/trunc

[lebedev.ri]

I think you are missing

if (TLI.getBooleanContents(VT) == TargetLowering::UndefinedBooleanContent ||
    TLI.getBooleanContents(VT) == TargetLowering::ZeroOrOneBooleanContent)

[RKSimon]

In D117983#3264453, @lebedev.ri wrote:

I think you are missing

if (TLI.getBooleanContents(VT) == TargetLowering::UndefinedBooleanContent ||
    TLI.getBooleanContents(VT) == TargetLowering::ZeroOrOneBooleanContent)

Nice catch!

[RKSimon]

address feedback

[RKSimon]

rebase

[lebedev.ri]

LG, thanks.

llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp

3273–3274

?

[RKSimon]

llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp

3273–3274

SGTM - cheers

llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp

bool TargetLowering::isExtendedTrueVal(const ConstantSDNode *N, EVT VT,
   llvm_unreachable("Unexpected enumeration.");
 }
 
 /// This helper function of SimplifySetCC tries to optimize the comparison when
 /// either operand of the SetCC node is a bitwise-and instruction.
 SDValue TargetLowering::foldSetCCWithAnd(EVT VT, SDValue N0, SDValue N1,
                                          ISD::CondCode Cond, const SDLoc &DL,
                                          DAGCombinerInfo &DCI) const {
-  // Match these patterns in any of their permutations:
-  // (X & Y) == Y
-  // (X & Y) != Y
   if (N1.getOpcode() == ISD::AND && N0.getOpcode() != ISD::AND)
     std::swap(N0, N1);
 
+  SelectionDAG &DAG = DCI.DAG;
   EVT OpVT = N0.getValueType();
   if (N0.getOpcode() != ISD::AND || !OpVT.isInteger() ||
       (Cond != ISD::SETEQ && Cond != ISD::SETNE))
     return SDValue();
 
+  // (X & Y) != 0 --> zextOrTrunc(X & Y)
+  // iff everything but LSB is known zero:
+  if (Cond == ISD::SETNE && isNullConstant(N1) &&
+      (getBooleanContents(VT) == TargetLowering::UndefinedBooleanContent ||
+       getBooleanContents(VT) == TargetLowering::ZeroOrOneBooleanContent)) {
+    unsigned NumEltBits = OpVT.getScalarSizeInBits();
+    APInt UpperBits = APInt::getHighBitsSet(NumEltBits, NumEltBits - 1);
+    if (DAG.MaskedValueIsZero(N0, UpperBits))
+      return DAG.getBoolExtOrTrunc(N0, DL, VT, OpVT);
+  }
+
+  // Match these patterns in any of their permutations:
+  // (X & Y) == Y
+  // (X & Y) != Y
   SDValue X, Y;
   if (N0.getOperand(0) == N1) {
     X = N0.getOperand(1);
     Y = N0.getOperand(0);
   } else if (N0.getOperand(1) == N1) {
     X = N0.getOperand(0);
     Y = N0.getOperand(1);
   } else {
     return SDValue();
   }
 
-  SelectionDAG &DAG = DCI.DAG;
   SDValue Zero = DAG.getConstant(0, DL, OpVT);
   if (DAG.isKnownToBeAPowerOfTwo(Y)) {
     // Simplify X & Y == Y to X & Y != 0 if Y has exactly one bit set.
     // Note that where Y is variable and is known to have at most one bit set
     // (for example, if it is Z & 1) we cannot do this; the expressions are not
     // equivalent when Y == 0.
     assert(OpVT.isInteger());
     Cond = ISD::getSetCCInverse(Cond, OpVT);

llvm/test/CodeGen/X86/parity-vec.ll

 ; NOPOPCNT-NEXT:    setnp %al
 ; NOPOPCNT-NEXT:    retq
 ;
 ; POPCNT-LABEL: canonical_parity:
 ; POPCNT:       # %bb.0:
 ; POPCNT-NEXT:    psllw $7, %xmm0
 ; POPCNT-NEXT:    pmovmskb %xmm0, %eax
 ; POPCNT-NEXT:    popcntl %eax, %eax
-; POPCNT-NEXT:    testb $1, %al
-; POPCNT-NEXT:    setne %al
+; POPCNT-NEXT:    andl $1, %eax
+; POPCNT-NEXT:    # kill: def $al killed $al killed $eax
 ; POPCNT-NEXT:    retq
   %i1 = bitcast <16 x i1> %x to i16
   %i2 = call i16 @llvm.ctpop.i16(i16 %i1)
   %i3 = and i16 %i2, 1
   %i4 = icmp ne i16 %i3, 0
   ret i1 %i4
 }
 define i1 @canonical_parity_noncanonical_pred(<16 x i1> %x) {