[SelectionDAG] Add helper function to check whether a SDValue is neutral element. NFC.

[fakepaper56]

Summary

Using this helper makes work about neutral elements more easier. Although I only
find one case now, I think it will have more chance to be used since so many
combine works are related to neutral elements.

[RKSimon]

Please can you look at whether this is compatible with something similar we already have in foldSelectWithIdentityConstant in DAGCombiner.cpp?

[fakepaper56]

I am not sure what is the compatibility issue. I think foldSelectWithIdentityConstant could be also used for operations which not have communicative property (e.g. div).

[RKSimon]

In D133866#3791129, @fakepaper56 wrote:

I am not sure what is the compatibility issue. I think foldSelectWithIdentityConstant could be also used for operations which not have communicative property (e.g. div).

I#m sorry - compatibility was a poor word to use - my hope is that we can remove the 'isIdentityConstantForOpcode' lambda inside foldSelectWithIdentityConstant and use isNeutralConstant instead - either as part of this patch or a future patch.

llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp

10738

Can you add a OperandNo argument as well? It can default to 0 if necessary. This will allow us to handle sub/fsub, div/fdiv and shifts in future patches.

llvm::isNeutralConstant(unsigned Opcode, SDNodeFlags Flags, SDValue V, unsigned OperandNo = 0)

[fakepaper56]

Rebase and address RKSimon's comment. I do not replace foldSelectWithIdentityConstant
since it makes some axv512 test fails.

[RKSimon]

llvm/include/llvm/CodeGen/SelectionDAGNodes.h

1696

OperandNo

llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp

10771

Missing OperandNo == 1 check

[fakepaper56]

Address RKSimon's comment.

[fakepaper56]

llvm/include/llvm/CodeGen/SelectionDAGNodes.h

1696

Done.

llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp

10771

Done.

[RKSimon]

Cheers - would it be possible to add additional riscv test coverage now that you're handling a lot more than just fadd?

[fakepaper56]

Actually, there is no any new functional change in RISC-V. Those new opcodes are filtered out by BinOpToRVVReduce.

[RKSimon]

OK - LGTM

llvm/include/llvm/CodeGen/SelectionDAGNodes.h

 bool isAllOnesConstant(SDValue V);
 
 /// Returns true if \p V is a constant integer one.
 bool isOneConstant(SDValue V);
 
 /// Returns true if \p V is a constant min signed integer value.
 bool isMinSignedConstant(SDValue V);
 
+/// Returns true if \p V is a neutral element of Opc with Flags.
+bool isNeutralConstant(unsigned Opc, SDNodeFlags Flags, SDValue V);
+
 /// Return the non-bitcasted source operand of \p V if it exists.
 /// If \p V is not a bitcasted value, it is returned as-is.
 SDValue peekThroughBitcasts(SDValue V);
 
 /// Return the non-bitcasted and one-use source operand of \p V if it exists.
 /// If \p V is not a bitcasted one-use value, it is returned as-is.
 SDValue peekThroughOneUseBitcasts(SDValue V);
 
 /// Return the non-extracted vector source operand of \p V if it exists.
 /// If \p V is not an extracted subvector, it is returned as-is.

llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp

 //===- SelectionDAG.cpp - Implement the SelectionDAG data structures ------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This implements the SelectionDAG class.
bool llvm::isOneConstant(SDValue V) {
   return Const != nullptr && Const->isOne();
 }
 
 bool llvm::isMinSignedConstant(SDValue V) {
   ConstantSDNode *Const = dyn_cast<ConstantSDNode>(V);
   return Const != nullptr && Const->isMinSignedValue();
 }
 
+bool llvm::isNeutralConstant(unsigned Opcode, SDNodeFlags Flags, SDValue V) {
+  if (auto *Const = dyn_cast<ConstantSDNode>(V)) {
+    switch (Opcode) {
+    case ISD::ADD:
+    case ISD::OR:
+    case ISD::XOR:
+    case ISD::UMAX:
+      return Const->isZero();
+    case ISD::MUL:
+      return Const->isOne();
+    case ISD::AND:
+    case ISD::UMIN:
+      return Const->isAllOnes();
+    case ISD::SMAX:
+      return Const->isMinSignedValue();
+    case ISD::SMIN:
+      return Const->isMaxSignedValue();
+    }
+  } else if (auto *ConstFP = dyn_cast<ConstantFPSDNode>(V)) {
+    switch (Opcode) {
+    case ISD::FADD:
+      if (Flags.hasNoSignedZeros())
+        return ConstFP->isZero();
+      return ConstFP->isExactlyValue(-0.0);
+    case ISD::FMUL:
+      return ConstFP->isExactlyValue(1.0);
+    case ISD::FMINNUM:
+    case ISD::FMAXNUM: {
+      // Neutral element for fminnum is NaN, Inf or FLT_MAX, depending on FMF.
+      EVT VT = V.getValueType();
+      const fltSemantics &Semantics = SelectionDAG::EVTToAPFloatSemantics(VT);
+      APFloat NeutralAF = !Flags.hasNoNaNs()   ? APFloat::getQNaN(Semantics)
+                          : !Flags.hasNoInfs() ? APFloat::getInf(Semantics)
+                                               : APFloat::getLargest(Semantics);
+      if (Opcode == ISD::FMAXNUM)
+        NeutralAF.changeSign();
+
+      return ConstFP->isExactlyValue(NeutralAF);
+    }
+    }
+  }
+  return false;
+}
+
 SDValue llvm::peekThroughBitcasts(SDValue V) {
   while (V.getOpcode() == ISD::BITCAST)
     V = V.getOperand(0);
   return V;
 }
 
 SDValue llvm::peekThroughOneUseBitcasts(SDValue V) {
   while (V.getOpcode() == ISD::BITCAST && V.getOperand(0).hasOneUse())

llvm/lib/Target/RISCV/RISCVISelLowering.cpp

static SDValue combineBinOpToReduce(SDNode *N, SelectionDAG &DAG) {
   if (ScalarV.getOpcode() != RISCVISD::VFMV_S_F_VL &&
       ScalarV.getOpcode() != RISCVISD::VMV_S_X_VL &&
       ScalarV.getOpcode() != RISCVISD::VMV_V_X_VL)
     return SDValue();
 
   if (!isOneConstant(ScalarV.getOperand(2)))
     return SDValue();
 
-  // TODO: Deal with value other than neutral element.
-  auto IsRVVNeutralElement = [Opc, &DAG](SDNode *N, SDValue V) {
-    if (Opc == ISD::FADD && N->getFlags().hasNoSignedZeros() &&
-        isNullFPConstant(V))
-      return true;
-    return DAG.getNeutralElement(Opc, SDLoc(V), V.getSimpleValueType(),
-                                 N->getFlags()) == V;
-  };
-
   // Check the scalar of ScalarV is neutral element
-  if (!IsRVVNeutralElement(N, ScalarV.getOperand(1)))
+  // TODO: Deal with value other than neutral element.
+  if (!isNeutralConstant(N->getOpcode(), N->getFlags(), ScalarV.getOperand(1)))
     return SDValue();
 
   if (!ScalarV.hasOneUse())
     return SDValue();
 
   EVT SplatVT = ScalarV.getValueType();
   SDValue NewStart = N->getOperand(1 - ReduceIdx);
   unsigned SplatOpc = RISCVISD::VFMV_S_F_VL;