[X86] Teach computeKnownBitsForTargetNode about MUL_IMM

[kazu]

Summary

This patch teaches computeKnownBitsForTargetNode about MUL_IMM.

MUL_IMM comes up in certain select of constants. Specifically, it is
used to multiply the result of SETCC. Computing the known zero bits
of MUL_IMM allows matchAddressRecursively us to convert some OR into
ADD, which eventually becomes a part of LEA.

This patch fixes:

https://github.com/llvm/llvm-project/issues/61365

[kazu]

Guard against a potential integer overflow.

[craig.topper]

llvm/lib/Target/X86/X86ISelLowering.cpp

38108

Why can't we use KnownBits.mul?

[foad]

llvm/lib/Target/X86/X86ISelLowering.cpp

38105–38106

You can write this as ~Known2.Zero or Known2.getMaxValue(). But I agree with @craig.topper.

[kazu]

Switched to KnownBits::mul.

[kazu]

Please take a look. Thanks!

[RKSimon]

llvm/test/CodeGen/X86/select-constant-lea.ll

20

Please can you confirm what's caused us to use the ORLIke pattern?

[kazu]

llvm/test/CodeGen/X86/select-constant-lea.ll

20

combineSelectOfTwoConstants expands ISD::SELECT as:

// select Cond, TC, FC --> (zext(Cond) * (TC - FC)) + FC

with ISD::ADD. Then DAGCombiner::visitADD does:

// fold (a+b) -> (a|b) iff a and b share no bits.                                                 
if ((!LegalOperations || TLI.isOperationLegal(ISD::OR, VT)) &&
    DAG.haveNoCommonBitsSet(N0, N1))
  return DAG.getNode(ISD::OR, DL, VT, N0, N1);

This is where the ISD::OR comes from.

[RKSimon]

LGTM - cheers

llvm/lib/Target/X86/X86ISelLowering.cpp

LLVM_DEBUG(dbgs() << "PREALLOCATED_ARG arg index " << ArgIdx
                       << ", arg offset " << ArgOffset << "\n");
     // stack pointer + offset
     addRegOffset(
         BuildMI(*BB, MI, DL, TII->get(X86::LEA32r), MI.getOperand(0).getReg()),
         X86::ESP, false, ArgOffset);
     MI.eraseFromParent();
     return BB;
   }
   case X86::PTDPBSSD:
   case X86::PTDPBSUD:
   case X86::PTDPBUSD:
   case X86::PTDPBUUD:
   case X86::PTDPBF16PS:
   case X86::PTDPFP16PS: {
     unsigned Opc;
     switch (MI.getOpcode()) {
     default: llvm_unreachable("illegal opcode!");
     case X86::PTDPBSSD: Opc = X86::TDPBSSD; break;
     case X86::PTDPBSUD: Opc = X86::TDPBSUD; break;
     case X86::PTDPBUSD: Opc = X86::TDPBUSD; break;
assert((Opc >= ISD::BUILTIN_OP_END ||
           Opc == ISD::INTRINSIC_W_CHAIN ||
           Opc == ISD::INTRINSIC_VOID) &&
          "Should use MaskedValueIsZero if you don't know whether Op"
          " is a target node!");
 
   Known.resetAll();
   switch (Opc) {
   default: break;
+  case X86ISD::MUL_IMM: {
+    KnownBits Known2;
+    Known = DAG.computeKnownBits(Op.getOperand(1), DemandedElts, Depth + 1);
+    Known2 = DAG.computeKnownBits(Op.getOperand(0), DemandedElts, Depth + 1);
+    Known = KnownBits::mul(Known, Known2);
+    break;
+  }
   case X86ISD::SETCC:
     Known.Zero.setBitsFrom(1);
     break;
   case X86ISD::MOVMSK: {
     unsigned NumLoBits = Op.getOperand(0).getValueType().getVectorNumElements();
     Known.Zero.setBitsFrom(NumLoBits);
     break;
   }

llvm/test/CodeGen/X86/pr57402.ll

 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
 ; RUN: llc < %s -mtriple=x86_64-- | FileCheck %s
 
 define void @PR57402() {
 ; CHECK-LABEL: PR57402:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    notl %eax
 ; CHECK-NEXT:    andl $-2, %eax
-; CHECK-NEXT:    leal (%rax,%rax,2), %ecx
-; CHECK-NEXT:    orl $1, %ecx
+; CHECK-NEXT:    leal 1(%rax,%rax,2), %ecx
 ; CHECK-NEXT:    movswq %cx, %rsi
 ; CHECK-NEXT:    xorl %edi, %edi
 ; CHECK-NEXT:    movq $-1, %rax
 ; CHECK-NEXT:    xorl %edx, %edx
 ; CHECK-NEXT:    divq %rsi
 ; CHECK-NEXT:    testb %dil, %dil
 ; CHECK-NEXT:    jne .LBB0_4
 ; CHECK-NEXT:  # %bb.1: # %entry

llvm/test/CodeGen/X86/select-constant-lea.ll

 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
 ; RUN: llc < %s -mtriple=x86_64-unknown-unknown                      | FileCheck %s --check-prefix=BASE
 ; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mattr=slow-3ops-lea | FileCheck %s --check-prefix=SLOWLEA3
 
 define i32 @select_unsigned_lt_10_8_13j(i32 %0) {
 ; BASE-LABEL: select_unsigned_lt_10_8_13j:
 ; BASE:       # %bb.0:
 ; BASE-NEXT:    xorl %eax, %eax
 ; BASE-NEXT:    cmpl $10, %edi
 ; BASE-NEXT:    setae %al
-; BASE-NEXT:    leal (%rax,%rax,4), %eax
-; BASE-NEXT:    orl $8, %eax
+; BASE-NEXT:    leal 8(%rax,%rax,4), %eax
 ; BASE-NEXT:    retq
 ;
 ; SLOWLEA3-LABEL: select_unsigned_lt_10_8_13j:
 ; SLOWLEA3:       # %bb.0:
 ; SLOWLEA3-NEXT:    xorl %eax, %eax
 ; SLOWLEA3-NEXT:    cmpl $10, %edi
 ; SLOWLEA3-NEXT:    setae %al
 ; SLOWLEA3-NEXT:    leal (%rax,%rax,4), %eax
-; SLOWLEA3-NEXT:    orl $8, %eax
+; SLOWLEA3-NEXT:    addl $8, %eax
 ; SLOWLEA3-NEXT:    retq
   %2 = icmp ult i32 %0, 10
   %3 = select i1 %2, i32 8, i32 13
   ret i32 %3
 }