[SelectionDAG] Widen SDValue::NumValues/NumOperands type

[fzhinkin]

Summary

Changed SDValue::NumValues and SDValue::NumOperands type from
unsigned short to unsigned to match the type of SDVTList::NumVTs
and allow creation of nodes with larger values count.

Fields were reordered to preserve SDValue size on 64-bit platforms.

Related issue: https://github.com/llvm/llvm-project/issues/55737

llvm/include/llvm/CodeGen/SelectionDAGNodes.h

#undef END_TWO_BYTE_PACK
   static_assert(sizeof(LoadSDNodeBitfields) <= 2, "field too wide");
   static_assert(sizeof(StoreSDNodeBitfields) <= 2, "field too wide");
 
 private:
   friend class SelectionDAG;
   // TODO: unfriend HandleSDNode once we fix its operand handling.
   friend class HandleSDNode;
 
-  /// Unique id per SDNode in the DAG.
-  int NodeId = -1;
+  /// The number of entries in the Operand/Value list.
+  unsigned NumOperands = 0;
+  unsigned NumValues;
 
   /// The values that are used by this operation.
   SDUse *OperandList = nullptr;
 
   /// The types of the values this node defines.  SDNode's may
   /// define multiple values simultaneously.
   const EVT *ValueList;
 
   /// List of uses for this SDNode.
   SDUse *UseList = nullptr;
 
-  /// The number of entries in the Operand/Value list.
-  unsigned short NumOperands = 0;
-  unsigned short NumValues;
+  /// Unique id per SDNode in the DAG.
+  int NodeId = -1;
 
   // The ordering of the SDNodes. It roughly corresponds to the ordering of the
   // original LLVM instructions.
   // This is used for turning off scheduling, because we'll forgo
   // the normal scheduling algorithms and output the instructions according to
   // this ordering.
   unsigned IROrder;
 
static SDVTList getSDVTList(EVT VT) {
     return Ret;
   }
 
   /// Create an SDNode.
   ///
   /// SDNodes are created without any operands, and never own the operand
   /// storage. To add operands, see SelectionDAG::createOperands.
   SDNode(unsigned Opc, unsigned Order, DebugLoc dl, SDVTList VTs)
-      : NodeType(Opc), ValueList(VTs.VTs), NumValues(VTs.NumVTs),
+      : NodeType(Opc), NumValues(VTs.NumVTs), ValueList(VTs.VTs),
         IROrder(Order), debugLoc(std::move(dl)) {
     memset(&RawSDNodeBits, 0, sizeof(RawSDNodeBits));
     assert(debugLoc.hasTrivialDestructor() && "Expected trivial destructor");
     assert(NumValues == VTs.NumVTs &&
            "NumValues wasn't wide enough for its operands!");
   }
 
   /// Release the operands and set this node to have zero operands.

llvm/test/CodeGen/Generic/large-array-load.ll

+; RUN: llc < %s
+
+@arr_32 = external global [70000 x i32]
+
+define void @load() {
+  %i11 = load [70000 x i32], ptr @arr_32, align 4
+  ret void
+}
 No newline at end of file