[DAGCombiner][TLI] SimplifySetCC(): `(X&1) != 0`-->`extortrunc(X&1)` (PR51312)

[lebedev.ri]

Summary

If we take and produce non-i1 type, and the input has only the 0'th bit,
and we are only checking whether the input is not empty,
then just use the casted operand, iff the boolean type does not require sign-extension.

[lebedev.ri]

Actually, let's not.

llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp

if (N0.getOpcode() == ISD::UREM && N1C->isNullValue() &&
       KnownBits YKnown = DAG.computeKnownBits(N0.getOperand(1));
       if (XKnown.countMaxPopulation() == 1 && YKnown.countMinPopulation() >= 2)
         return DAG.getSetCC(dl, VT, N0.getOperand(0), N1, Cond);
     }
 
     if (SDValue V =
             optimizeSetCCOfSignedTruncationCheck(VT, N0, N1, Cond, DCI, dl))
       return V;
+
+    // If we take and produce non-i1 type, and the input has only the 0'th bit,
+    // and we are only checking whether the input is not empty,
+    // then just use the casted operand.
+    if (OpVT.getScalarSizeInBits() > 1 && VT.getScalarSizeInBits() > 1 &&
+        Cond == ISD::SETNE && C1.isNullValue() &&
+        (getBooleanContents(OpVT) == UndefinedBooleanContent ||
+         getBooleanContents(OpVT) == ZeroOrOneBooleanContent)) {
+      KnownBits N0Known = DAG.computeKnownBits(N0);
+      if (N0Known.getMaxValue().isOneValue())
+        return DAG.getBoolExtOrTrunc(N0, dl, VT, OpVT);
+    }
   }
 
   // These simplifications apply to splat vectors as well.
   // TODO: Handle more splat vector cases.
   if (auto *N1C = isConstOrConstSplat(N1)) {
     const APInt &C1 = N1C->getAPIntValue();
 
     APInt MinVal, MaxVal;

llvm/test/CodeGen/X86/lzcnt-cmp.ll

 ; X86-BSR-NEXT:    xorl %eax, %eax
 ; X86-BSR-NEXT:    cmpl $0, {{[0-9]+}}(%esp)
 ; X86-BSR-NEXT:    jne .LBB1_2
 ; X86-BSR-NEXT:  # %bb.1:
 ; X86-BSR-NEXT:    bsrl {{[0-9]+}}(%esp), %eax
 ; X86-BSR-NEXT:    xorl $31, %eax
 ; X86-BSR-NEXT:    addl $32, %eax
 ; X86-BSR-NEXT:  .LBB1_2:
-; X86-BSR-NEXT:    testl $-64, %eax
-; X86-BSR-NEXT:    setne %al
+; X86-BSR-NEXT:    shrl $6, %eax
+; X86-BSR-NEXT:    # kill: def $al killed $al killed $eax
 ; X86-BSR-NEXT:    retl
 ;
 ; X86-LZCNT-LABEL: lshr_ctlz_undef_cmpeq_one_i64:
 ; X86-LZCNT:       # %bb.0:
 ; X86-LZCNT-NEXT:    xorl %eax, %eax
 ; X86-LZCNT-NEXT:    cmpl $0, {{[0-9]+}}(%esp)
 ; X86-LZCNT-NEXT:    jne .LBB1_2
 ; X86-LZCNT-NEXT:  # %bb.1:
 ; X86-LZCNT-NEXT:    lzcntl {{[0-9]+}}(%esp), %eax
 ; X86-LZCNT-NEXT:    addl $32, %eax
 ; X86-LZCNT-NEXT:  .LBB1_2:
-; X86-LZCNT-NEXT:    testb $64, %al
-; X86-LZCNT-NEXT:    setne %al
+; X86-LZCNT-NEXT:    shrl $6, %eax
+; X86-LZCNT-NEXT:    # kill: def $al killed $al killed $eax
 ; X86-LZCNT-NEXT:    retl
 ;
 ; X64-BSR-LABEL: lshr_ctlz_undef_cmpeq_one_i64:
 ; X64-BSR:       # %bb.0:
 ; X64-BSR-NEXT:    bsrq %rdi, %rax
 ; X64-BSR-NEXT:    shrq $6, %rax
 ; X64-BSR-NEXT:    cmpl $1, %eax
 ; X64-BSR-NEXT:    sete %al

 ; X86-BSR-NEXT:    xorl %eax, %eax
 ; X86-BSR-NEXT:    cmpl $0, {{[0-9]+}}(%esp)
 ; X86-BSR-NEXT:    jne .LBB3_2
 ; X86-BSR-NEXT:  # %bb.1:
 ; X86-BSR-NEXT:    bsrl {{[0-9]+}}(%esp), %eax
 ; X86-BSR-NEXT:    xorl $31, %eax
 ; X86-BSR-NEXT:    addl $32, %eax
 ; X86-BSR-NEXT:  .LBB3_2:
-; X86-BSR-NEXT:    testl $-64, %eax
-; X86-BSR-NEXT:    setne %al
+; X86-BSR-NEXT:    shrl $6, %eax
+; X86-BSR-NEXT:    # kill: def $al killed $al killed $eax
 ; X86-BSR-NEXT:    retl
 ;
 ; X86-LZCNT-LABEL: lshr_ctlz_undef_cmpne_zero_i64:
 ; X86-LZCNT:       # %bb.0:
 ; X86-LZCNT-NEXT:    xorl %eax, %eax
 ; X86-LZCNT-NEXT:    cmpl $0, {{[0-9]+}}(%esp)
 ; X86-LZCNT-NEXT:    jne .LBB3_2
 ; X86-LZCNT-NEXT:  # %bb.1:
 ; X86-LZCNT-NEXT:    lzcntl {{[0-9]+}}(%esp), %eax
 ; X86-LZCNT-NEXT:    addl $32, %eax
 ; X86-LZCNT-NEXT:  .LBB3_2:
-; X86-LZCNT-NEXT:    testb $64, %al
-; X86-LZCNT-NEXT:    setne %al
+; X86-LZCNT-NEXT:    shrl $6, %eax
+; X86-LZCNT-NEXT:    # kill: def $al killed $al killed $eax
 ; X86-LZCNT-NEXT:    retl
 ;
 ; X64-BSR-LABEL: lshr_ctlz_undef_cmpne_zero_i64:
 ; X64-BSR:       # %bb.0:
 ; X64-BSR-NEXT:    bsrq %rdi, %rax
-; X64-BSR-NEXT:    testq $-64, %rax
-; X64-BSR-NEXT:    setne %al
+; X64-BSR-NEXT:    shrq $6, %rax
+; X64-BSR-NEXT:    # kill: def $al killed $al killed $rax
 ; X64-BSR-NEXT:    retq
 ;
 ; X64-LZCNT-LABEL: lshr_ctlz_undef_cmpne_zero_i64:
 ; X64-LZCNT:       # %bb.0:
 ; X64-LZCNT-NEXT:    lzcntq %rdi, %rax
-; X64-LZCNT-NEXT:    testb $64, %al
-; X64-LZCNT-NEXT:    setne %al
+; X64-LZCNT-NEXT:    shrq $6, %rax
+; X64-LZCNT-NEXT:    # kill: def $al killed $al killed $rax
 ; X64-LZCNT-NEXT:    retq
   %ctlz = call i64 @llvm.ctlz.i64(i64 %in, i1 -1)
   %lshr = lshr i64 %ctlz, 6
   %icmp = icmp ne i64 %lshr, 0
   ret i1 %icmp
 }
 
 define <2 x i64> @lshr_ctlz_cmpeq_zero_v2i64(<2 x i64> %in) nounwind {

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

; CHECK-NEXT:    retq
   ret i1 %r
 }
 define i1 @canonical_parity(<16 x i1> %x) {
 ; CHECK-LABEL: canonical_parity:
 ; CHECK:       # %bb.0:
 ; CHECK-NEXT:    psllw $7, %xmm0
 ; CHECK-NEXT:    pmovmskb %xmm0, %eax
 ; CHECK-NEXT:    popcntw %ax, %ax
-; CHECK-NEXT:    testb $1, %al
-; CHECK-NEXT:    setne %al
+; CHECK-NEXT:    andl $1, %eax
+; CHECK-NEXT:    # kill: def $al killed $al killed $eax
 ; CHECK-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) {

llvm/test/CodeGen/X86/umul_fix_sat.ll

 ; X86-LABEL: func8:
 ; X86:       # %bb.0:
 ; X86-NEXT:    pushl %ebp
 ; X86-NEXT:    pushl %ebx
 ; X86-NEXT:    pushl %edi
 ; X86-NEXT:    pushl %esi
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %ecx
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %esi
+; X86-NEXT:    movl {{[0-9]+}}(%esp), %ebp
 ; X86-NEXT:    movl %ecx, %eax
-; X86-NEXT:    mull %esi
+; X86-NEXT:    mull %ebp
 ; X86-NEXT:    movl %edx, %edi
 ; X86-NEXT:    movl %eax, %ebx
 ; X86-NEXT:    movl %ecx, %eax
-; X86-NEXT:    mull {{[0-9]+}}(%esp)
-; X86-NEXT:    movl %edx, %ebp
-; X86-NEXT:    addl %ebx, %ebp
+; X86-NEXT:    mull %esi
+; X86-NEXT:    addl %edx, %ebx
 ; X86-NEXT:    adcl $0, %edi
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT:    mull %esi
+; X86-NEXT:    mull %ebp
 ; X86-NEXT:    movl %edx, %ecx
-; X86-NEXT:    movl %eax, %ebx
+; X86-NEXT:    movl %eax, %ebp
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT:    mull {{[0-9]+}}(%esp)
-; X86-NEXT:    addl %ebp, %eax
+; X86-NEXT:    mull %esi
+; X86-NEXT:    addl %ebx, %eax
 ; X86-NEXT:    adcl %edi, %edx
 ; X86-NEXT:    adcl $0, %ecx
-; X86-NEXT:    addl %ebx, %edx
+; X86-NEXT:    addl %ebp, %edx
 ; X86-NEXT:    adcl $0, %ecx
-; X86-NEXT:    shrdl $31, %edx, %eax
-; X86-NEXT:    movl %edx, %esi
-; X86-NEXT:    shrl $31, %esi
-; X86-NEXT:    xorl %edi, %edi
-; X86-NEXT:    cmpl $1, %esi
-; X86-NEXT:    sbbl %edi, %edi
-; X86-NEXT:    notl %edi
-; X86-NEXT:    orl %edi, %eax
 ; X86-NEXT:    shldl $1, %edx, %ecx
-; X86-NEXT:    orl %edi, %ecx
+; X86-NEXT:    shrdl $31, %edx, %eax
+; X86-NEXT:    testl $-2147483648, %edx # imm = 0x80000000
+; X86-NEXT:    movl $-1, %edx
+; X86-NEXT:    cmovnel %edx, %eax
+; X86-NEXT:    cmovnel %edx, %ecx
 ; X86-NEXT:    movl %ecx, %edx
 ; X86-NEXT:    popl %esi
 ; X86-NEXT:    popl %edi
 ; X86-NEXT:    popl %ebx
 ; X86-NEXT:    popl %ebp
 ; X86-NEXT:    retl
   %tmp = call i64 @llvm.umul.fix.sat.i64(i64 %x, i64 %y, i32 63)
   ret i64 %tmp
 }