[SelectionDAG] Add static getMaxNumOperands function to SDNode.

[fhahn]

Summary

Use this helper to make sure we use the same value at various places.
This will likely be needed at more places were we currently crash
because we use more operands than possible.

Also makes it easier to change in the future.

[arsenm]

What's this for?

[fhahn]

Update places to use getMaxNumOperands, add more context to description.

[RKSimon]

In D56859#1361713, @arsenm wrote:

What's this for?

To remove magic numbers in D56739

[fhahn]

llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp

9269 ↗

(On Diff #182306)

typo sneaked in, 'll fix that.

[fhahn]

Fix typo.

[RKSimon]

LGTM - thanks

llvm/trunk/include/llvm/CodeGen/SelectionDAGNodes.h

public:
 
   /// Return true if all the users of N are contained in Nodes.
   /// NOTE: Requires at least one match, but doesn't require them all.
   static bool areOnlyUsersOf(ArrayRef<const SDNode *> Nodes, const SDNode *N);
 
   /// Return the number of values used by this operation.
   unsigned getNumOperands() const { return NumOperands; }
 
+  /// Return the maximum number of operands that a SDNode can hold.
+  static constexpr size_t getMaxNumOperands() {
+    return std::numeric_limits<decltype(SDNode::NumOperands)>::max();
+  }
+
   /// Helper method returns the integer value of a ConstantSDNode operand.
   inline uint64_t getConstantOperandVal(unsigned Num) const;
 
   const SDValue &getOperand(unsigned Num) const {
     assert(Num < NumOperands && "Invalid child # of SDNode!");
     return OperandList[Num];
   }
 

llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAG.cpp

SDNode *SelectionDAG::isConstantFPBuildVectorOrConstantFP(SDValue N) {
   if (ISD::isBuildVectorOfConstantFPSDNodes(N.getNode()))
     return N.getNode();
 
   return nullptr;
 }
 
 void SelectionDAG::createOperands(SDNode *Node, ArrayRef<SDValue> Vals) {
   assert(!Node->OperandList && "Node already has operands");
-  assert(std::numeric_limits<decltype(SDNode::NumOperands)>::max() >=
-             Vals.size() &&
+  assert(SDNode::getMaxNumOperands() >= Vals.size() &&
          "too many operands to fit into SDNode");
   SDUse *Ops = OperandRecycler.allocate(
       ArrayRecycler<SDUse>::Capacity::get(Vals.size()), OperandAllocator);
 
   bool IsDivergent = false;
   for (unsigned I = 0; I != Vals.size(); ++I) {
     Ops[I].setUser(Node);
     Ops[I].setInitial(Vals[I]);

llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

if (PendingLoads.size() == 1) {
     PendingLoads.clear();
     return Root;
   }
 
   // Otherwise, we have to make a token factor node.
   // If we have >= 2^16 loads then split across multiple token factors as
   // there's a 64k limit on the number of SDNode operands.
   SDValue Root;
-  size_t Limit = (1 << 16) - 1;
+  size_t Limit = SDNode::getMaxNumOperands();
   while (PendingLoads.size() > Limit) {
     unsigned SliceIdx = PendingLoads.size() - Limit;
     auto ExtractedTFs = ArrayRef<SDValue>(PendingLoads).slice(SliceIdx, Limit);
     SDValue NewTF =
         DAG.getNode(ISD::TokenFactor, getCurSDLoc(), MVT::Other, ExtractedTFs);
     PendingLoads.erase(PendingLoads.begin() + SliceIdx, PendingLoads.end());
     PendingLoads.emplace_back(NewTF);
   }