[X86] Enable promotion of i16 popcnt (PR52056)

[xbolva00]

Summary

Solves https://bugs.llvm.org/show_bug.cgi?id=52056

[craig.topper]

llvm/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp

2665

This should be isLegalOrPromoted

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

21

This is a pretty big regression. My other comment will fix it. But I don’t understand why you would submit a patch without mentioning these regressions in the description.

[xbolva00]

Use isOperationLegalOrPromote.

[xbolva00]

llvm/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp

2665

Yeah.

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

21

Sorry, I should have been more loud about this regression to be not overlooked.

[RKSimon]

llvm/lib/Target/X86/X86ISelLowering.cpp

434

Please add a comment explaining why we don't use popcntw

[xbolva00]

llvm/lib/Target/X86/X86ISelLowering.cpp

434

So something like for both i8/i16

"The 32-bit version is shorter to encode and the zext we emit for the promotion is likely going to be a 32-bit zero extend anyway." ?

[RKSimon]

llvm/lib/Target/X86/X86ISelLowering.cpp

434

Shouldn't it only refer to i16?

"The 32-bit version is shorter to encode than popcntw, ..."

[xbolva00]

llvm/lib/Target/X86/X86ISelLowering.cpp

434

Yeah right :)

[craig.topper]

llvm/lib/Target/X86/X86ISelLowering.cpp

434

popcntw also has a false dependency on the dest that popcntl hasn't had since Cannon Lake.

[xbolva00]

Added code comment.

[RKSimon]

LGTM - cheers

llvm/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp

 /// Open code the operations for PARITY of the specified operation.
 SDValue SelectionDAGLegalize::ExpandPARITY(SDValue Op, const SDLoc &dl) {
   EVT VT = Op.getValueType();
   EVT ShVT = TLI.getShiftAmountTy(VT, DAG.getDataLayout());
   unsigned Sz = VT.getScalarSizeInBits();
 
   // If CTPOP is legal, use it. Otherwise use shifts and xor.
   SDValue Result;
-  if (TLI.isOperationLegal(ISD::CTPOP, VT)) {
+  if (TLI.isOperationLegalOrPromote(ISD::CTPOP, VT)) {
     Result = DAG.getNode(ISD::CTPOP, dl, VT, Op);
   } else {
     Result = Op;
     for (unsigned i = Log2_32_Ceil(Sz); i != 0;) {
       SDValue Shift = DAG.getNode(ISD::SRL, dl, VT, Result,
                                   DAG.getConstant(1ULL << (--i), dl, ShVT));
       Result = DAG.getNode(ISD::XOR, dl, VT, Result, Shift);
     }

llvm/lib/Target/X86/X86ISelLowering.cpp

X86TargetLowering::X86TargetLowering(const X86TargetMachine &TM,
 
   setOperationAction(ISD::PARITY, MVT::i8, Custom);
   setOperationAction(ISD::PARITY, MVT::i16, Custom);
   setOperationAction(ISD::PARITY, MVT::i32, Custom);
   if (Subtarget.is64Bit())
     setOperationAction(ISD::PARITY, MVT::i64, Custom);
   if (Subtarget.hasPOPCNT()) {
     setOperationPromotedToType(ISD::CTPOP, MVT::i8, MVT::i32);
+    // popcntw is longer to encode than popcntl and also has a false dependency
+    // on the dest that popcntl hasn't had since Cannon Lake.
+    setOperationPromotedToType(ISD::CTPOP, MVT::i16, MVT::i32);
   } else {
     setOperationAction(ISD::CTPOP          , MVT::i8   , Expand);
     setOperationAction(ISD::CTPOP          , MVT::i16  , Expand);
     setOperationAction(ISD::CTPOP          , MVT::i32  , Expand);
     if (Subtarget.is64Bit())
       setOperationAction(ISD::CTPOP        , MVT::i64  , Expand);
     else
       setOperationAction(ISD::CTPOP        , MVT::i64  , Custom);

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

; CHECK-NEXT:    retq
   %r = call i1 @llvm.vector.reduce.xor.v16i1(<16 x i1> %x)
   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:    popcntl %eax, %eax
 ; CHECK-NEXT:    testb $1, %al
 ; CHECK-NEXT:    setne %al
 ; 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) {
 ; CHECK-LABEL: canonical_parity_noncanonical_pred:
 ; CHECK:       # %bb.0:
 ; CHECK-NEXT:    psllw $7, %xmm0
 ; CHECK-NEXT:    pmovmskb %xmm0, %eax
-; CHECK-NEXT:    popcntw %ax, %ax
-; CHECK-NEXT:    # kill: def $al killed $al killed $ax
+; CHECK-NEXT:    popcntl %eax, %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 eq i16 %i3, 1
   ret i1 %i4
 }
 
; CHECK-NEXT:    retq
   %r = xor i1 %r.inv, -1
   ret i1 %r
 }
 define i1 @canonical_nonparity(<16 x i1> %x) {
 ; CHECK-LABEL: canonical_nonparity:
 ; CHECK:       # %bb.0:
 ; CHECK-NEXT:    psllw $7, %xmm0
 ; CHECK-NEXT:    pmovmskb %xmm0, %eax
-; CHECK-NEXT:    popcntw %ax, %ax
+; CHECK-NEXT:    popcntl %eax, %eax
 ; CHECK-NEXT:    testb $1, %al
 ; CHECK-NEXT:    sete %al
 ; 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 eq i16 %i3, 0
   ret i1 %i4
 }
 define i1 @canonical_nonparity_noncanonical_pred(<16 x i1> %x) {
 ; CHECK-LABEL: canonical_nonparity_noncanonical_pred:
 ; CHECK:       # %bb.0:
 ; CHECK-NEXT:    psllw $7, %xmm0
 ; CHECK-NEXT:    pmovmskb %xmm0, %eax
-; CHECK-NEXT:    popcntw %ax, %ax
+; CHECK-NEXT:    popcntl %eax, %eax
 ; CHECK-NEXT:    andl $1, %eax
 ; CHECK-NEXT:    xorb $1, %al
 ; 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, 1
   ret i1 %i4
 }
 
 declare i1 @llvm.vector.reduce.xor.v16i1(<16 x i1>)
 declare i16 @llvm.ctpop.i16(i16)

llvm/test/CodeGen/X86/parity.ll

 ; X64-NOPOPCNT-NEXT:    xorl %eax, %eax
 ; X64-NOPOPCNT-NEXT:    xorb %ch, %cl
 ; X64-NOPOPCNT-NEXT:    setnp %al
 ; X64-NOPOPCNT-NEXT:    # kill: def $ax killed $ax killed $eax
 ; X64-NOPOPCNT-NEXT:    retq
 ;
 ; X86-POPCNT-LABEL: parity_16:
 ; X86-POPCNT:       # %bb.0:
-; X86-POPCNT-NEXT:    popcntw {{[0-9]+}}(%esp), %ax
+; X86-POPCNT-NEXT:    movzwl {{[0-9]+}}(%esp), %eax
+; X86-POPCNT-NEXT:    popcntl %eax, %eax
 ; X86-POPCNT-NEXT:    andl $1, %eax
 ; X86-POPCNT-NEXT:    # kill: def $ax killed $ax killed $eax
 ; X86-POPCNT-NEXT:    retl
 ;
 ; X64-POPCNT-LABEL: parity_16:
 ; X64-POPCNT:       # %bb.0:
-; X64-POPCNT-NEXT:    popcntw %di, %ax
+; X64-POPCNT-NEXT:    movzwl %di, %eax
+; X64-POPCNT-NEXT:    popcntl %eax, %eax
 ; X64-POPCNT-NEXT:    andl $1, %eax
 ; X64-POPCNT-NEXT:    # kill: def $ax killed $ax killed $eax
 ; X64-POPCNT-NEXT:    retq
   %1 = tail call i16 @llvm.ctpop.i16(i16 %x)
   %2 = and i16 %1, 1
   ret i16 %2
 }
 

 ; X64-NOPOPCNT-NEXT:    xorb %ch, %cl
 ; X64-NOPOPCNT-NEXT:    setnp %al
 ; X64-NOPOPCNT-NEXT:    # kill: def $ax killed $ax killed $eax
 ; X64-NOPOPCNT-NEXT:    retq
 ;
 ; X86-POPCNT-LABEL: parity_16_load:
 ; X86-POPCNT:       # %bb.0:
 ; X86-POPCNT-NEXT:    movl {{[0-9]+}}(%esp), %eax
-; X86-POPCNT-NEXT:    popcntw (%eax), %ax
+; X86-POPCNT-NEXT:    movzwl (%eax), %eax
+; X86-POPCNT-NEXT:    popcntl %eax, %eax
 ; X86-POPCNT-NEXT:    andl $1, %eax
 ; X86-POPCNT-NEXT:    # kill: def $ax killed $ax killed $eax
 ; X86-POPCNT-NEXT:    retl
 ;
 ; X64-POPCNT-LABEL: parity_16_load:
 ; X64-POPCNT:       # %bb.0:
-; X64-POPCNT-NEXT:    popcntw (%rdi), %ax
+; X64-POPCNT-NEXT:    movzwl (%rdi), %eax
+; X64-POPCNT-NEXT:    popcntl %eax, %eax
 ; X64-POPCNT-NEXT:    andl $1, %eax
 ; X64-POPCNT-NEXT:    # kill: def $ax killed $ax killed $eax
 ; X64-POPCNT-NEXT:    retq
   %1 = load i16, i16* %x
   %2 = tail call i16 @llvm.ctpop.i16(i16 %1)
   %3 = and i16 %2, 1
   ret i16 %3
 }

 ; X64-NOPOPCNT-NEXT:    xorb %ch, %cl
 ; X64-NOPOPCNT-NEXT:    setnp %al
 ; X64-NOPOPCNT-NEXT:    addl %eax, %eax
 ; X64-NOPOPCNT-NEXT:    # kill: def $ax killed $ax killed $eax
 ; X64-NOPOPCNT-NEXT:    retq
 ;
 ; X86-POPCNT-LABEL: parity_16_shift:
 ; X86-POPCNT:       # %bb.0:
-; X86-POPCNT-NEXT:    popcntw {{[0-9]+}}(%esp), %ax
+; X86-POPCNT-NEXT:    movzwl {{[0-9]+}}(%esp), %eax
+; X86-POPCNT-NEXT:    popcntl %eax, %eax
 ; X86-POPCNT-NEXT:    andl $1, %eax
 ; X86-POPCNT-NEXT:    addl %eax, %eax
 ; X86-POPCNT-NEXT:    # kill: def $ax killed $ax killed $eax
 ; X86-POPCNT-NEXT:    retl
 ;
 ; X64-POPCNT-LABEL: parity_16_shift:
 ; X64-POPCNT:       # %bb.0:
-; X64-POPCNT-NEXT:    popcntw %di, %ax
+; X64-POPCNT-NEXT:    movzwl %di, %eax
+; X64-POPCNT-NEXT:    popcntl %eax, %eax
 ; X64-POPCNT-NEXT:    andl $1, %eax
 ; X64-POPCNT-NEXT:    addl %eax, %eax
 ; X64-POPCNT-NEXT:    # kill: def $ax killed $ax killed $eax
 ; X64-POPCNT-NEXT:    retq
   %2 = tail call i16 @llvm.ctpop.i16(i16 %0)
   %3 = shl nuw nsw i16 %2, 1
   %4 = and i16 %3, 2
   ret i16 %4

llvm/test/CodeGen/X86/popcnt.ll

 ; X64-NEXT:    shll $8, %ecx
 ; X64-NEXT:    addl %eax, %ecx
 ; X64-NEXT:    movzbl %ch, %eax
 ; X64-NEXT:    # kill: def $ax killed $ax killed $eax
 ; X64-NEXT:    retq
 ;
 ; X86-POPCNT-LABEL: cnt16:
 ; X86-POPCNT:       # %bb.0:
-; X86-POPCNT-NEXT:    popcntw {{[0-9]+}}(%esp), %ax
+; X86-POPCNT-NEXT:    movzwl {{[0-9]+}}(%esp), %eax
+; X86-POPCNT-NEXT:    popcntl %eax, %eax
+; X86-POPCNT-NEXT:    # kill: def $ax killed $ax killed $eax
 ; X86-POPCNT-NEXT:    retl
 ;
 ; X64-POPCNT-LABEL: cnt16:
 ; X64-POPCNT:       # %bb.0:
-; X64-POPCNT-NEXT:    popcntw %di, %ax
+; X64-POPCNT-NEXT:    movzwl %di, %eax
+; X64-POPCNT-NEXT:    popcntl %eax, %eax
+; X64-POPCNT-NEXT:    # kill: def $ax killed $ax killed $eax
 ; X64-POPCNT-NEXT:    retq
   %cnt = tail call i16 @llvm.ctpop.i16(i16 %x)
   ret i16 %cnt
 }
 
 define i32 @cnt32(i32 %x) nounwind readnone {
 ; X86-LABEL: cnt32:
 ; X86:       # %bb.0:

 ; X64-NEXT:    movl %eax, %ecx
 ; X64-NEXT:    shll $8, %ecx
 ; X64-NEXT:    addl %eax, %ecx
 ; X64-NEXT:    movzbl %ch, %eax
 ; X64-NEXT:    retq
 ;
 ; X86-POPCNT-LABEL: popcount_i16_zext:
 ; X86-POPCNT:       # %bb.0:
-; X86-POPCNT-NEXT:    popcntw {{[0-9]+}}(%esp), %ax
-; X86-POPCNT-NEXT:    movzwl %ax, %eax
+; X86-POPCNT-NEXT:    movzwl {{[0-9]+}}(%esp), %eax
+; X86-POPCNT-NEXT:    popcntl %eax, %eax
 ; X86-POPCNT-NEXT:    retl
 ;
 ; X64-POPCNT-LABEL: popcount_i16_zext:
 ; X64-POPCNT:       # %bb.0:
-; X64-POPCNT-NEXT:    popcntw %di, %ax
-; X64-POPCNT-NEXT:    movzwl %ax, %eax
+; X64-POPCNT-NEXT:    popcntl %edi, %eax
 ; X64-POPCNT-NEXT:    retq
   %cnt = tail call i16 @llvm.ctpop.i16(i16 %x)
   %z = zext i16 %cnt to i32
   ret i32 %z
 }
 
 declare i8 @llvm.ctpop.i8(i8) nounwind readnone
 declare i16 @llvm.ctpop.i16(i16) nounwind readnone