[SelectionDAG] Add check for BUILD_VECTOR in isKnownNeverNaN

[Petar.Avramovic]

Summary

This includes handling of constants with vector type in isKnownNeverNaN.

[foad]

llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp

4685–4686

It looks like you're adding new functionality, so update the comment in SelectionDAG.h to explain that this function now handles vectors and what the behaviour is?

4784

for (const SDValue &Opnd : Op->ops()) ?

[Petar.Avramovic]

Patch also affects constants with vector type. Effectively, during legalization, fcanonicalize will not be inserted when input was vector constant.

define amdgpu_kernel void @maxnum_v2f16_imm_b(<2 x half> addrspace(1)* %r, <2 x half> addrspace(1)* %a) {
entry:
  %a.val = load <2 x half>, <2 x half> addrspace(1)* %a
  %add = fadd <2 x half> %a.val, <half 9.0, half 8.0>
  %r.val = call <2 x half> @llvm.maxnum.v2f16(<2 x half> %add, <2 x half> <half 4.0, half 3.0>) ;<half 4.0, half 3.0> will not get fcanonicalized during legalization after this patch
  store <2 x half> %r.val, <2 x half> addrspace(1)* %r
  ret void
}

This won't be visible in end result since there is fcanonicalize + build_vector combine in SITargetLowering::performFCanonicalizeCombine. Test changes were for non-constant build_vectors.
Add comment to indicate vector constants are handled bellow.

[foad]

@ecnelises did you really mean to add yourself as a "blocking reviewer" rather than a normal reviewer?

[foad]

LGTM apart from the nitpick about comments.

llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp

4685–4686

s/bellow/below/, or you could just delete this comment.

I meant something in SelectionDAG.h like:

/// Test whether the given SDValue **(or all elements of it, if it is a vector)** are known to never be NaN. If \p SNaN is
/// true, returns if \p Op is known to never be a signaling NaN (it may still
/// be a qNaN).
bool isKnownNeverNaN(SDValue Op, bool SNaN = false, unsigned Depth = 0) const;

Just to say explicitly what the expected behaviour is for a vector.

[ecnelises]

In D88573#2311275, @foad wrote:

@ecnelises did you really mean to add yourself as a "blocking reviewer" rather than a normal reviewer?

Oh, sorry! I meant to add myself as subscriber..

[arsenm]

LGTM

[arsenm]

Reverse ping

llvm/include/llvm/CodeGen/SelectionDAG.h

public:
 
   /// Return true if the specified operand is an ISD::ADD with a ConstantSDNode
   /// on the right-hand side, or if it is an ISD::OR with a ConstantSDNode that
   /// is guaranteed to have the same semantics as an ADD. This handles the
   /// equivalence:
   ///     X|Cst == X+Cst iff X&Cst = 0.
   bool isBaseWithConstantOffset(SDValue Op) const;
 
-  /// Test whether the given SDValue is known to never be NaN. If \p SNaN is
-  /// true, returns if \p Op is known to never be a signaling NaN (it may still
-  /// be a qNaN).
+  /// Test whether the given SDValue (or all elements of it, if it is a
+  /// vector) is known to never be NaN. If \p SNaN is true, returns if \p Op is
+  /// known to never be a signaling NaN (it may still be a qNaN).
   bool isKnownNeverNaN(SDValue Op, bool SNaN = false, unsigned Depth = 0) const;
 
   /// \returns true if \p Op is known to never be a signaling NaN.
   bool isKnownNeverSNaN(SDValue Op, unsigned Depth = 0) const {
     return isKnownNeverNaN(Op, true, Depth);
   }
 
   /// Test whether the given floating point SDValue is known to never be

llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp

 
 bool SelectionDAG::isKnownNeverNaN(SDValue Op, bool SNaN, unsigned Depth) const {
   // If we're told that NaNs won't happen, assume they won't.
   if (getTarget().Options.NoNaNsFPMath || Op->getFlags().hasNoNaNs())
     return true;
 
   if (Depth >= MaxRecursionDepth)
     return false; // Limit search depth.
 
-  // TODO: Handle vectors.
   // If the value is a constant, we can obviously see if it is a NaN or not.
   if (const ConstantFPSDNode *C = dyn_cast<ConstantFPSDNode>(Op)) {
     return !C->getValueAPF().isNaN() ||
            (SNaN && !C->getValueAPF().isSignaling());
   }
 
   unsigned Opcode = Op.getOpcode();
   switch (Opcode) {
   case ISD::FADD:
bool SelectionDAG::isKnownNeverNaN(SDValue Op, bool SNaN, unsigned Depth) const {
   case ISD::FMAXIMUM: {
     // TODO: Does this quiet or return the origina NaN as-is?
     return isKnownNeverNaN(Op.getOperand(0), SNaN, Depth + 1) &&
            isKnownNeverNaN(Op.getOperand(1), SNaN, Depth + 1);
   }
   case ISD::EXTRACT_VECTOR_ELT: {
     return isKnownNeverNaN(Op.getOperand(0), SNaN, Depth + 1);
   }
+  case ISD::BUILD_VECTOR: {
+    for (const SDValue &Opnd : Op->ops())
+      if (!isKnownNeverNaN(Opnd, SNaN, Depth + 1))
+        return false;
+    return true;
+  }
   default:
     if (Opcode >= ISD::BUILTIN_OP_END ||
         Opcode == ISD::INTRINSIC_WO_CHAIN ||
         Opcode == ISD::INTRINSIC_W_CHAIN ||
         Opcode == ISD::INTRINSIC_VOID) {
       return TLI->isKnownNeverNaNForTargetNode(Op, *this, SNaN, Depth);
     }