Save 260k in InitValueNumStoreStatics

src/coreclr/jit/compiler.cpp

@@ -1329,9 +1329,6 @@ void Compiler::compStartup()
 
     emitter::emitInit();
 
-    // Static vars of ValueNumStore
-    ValueNumStore::InitValueNumStoreStatics();
-
     compDisplayStaticSizes(jitstdout);
 }
 

src/coreclr/jit/gentree.h

@@ -1020,7 +1020,7 @@ struct GenTree
 
     static const unsigned char gtOperKindTable[];
 
-    static unsigned OperKind(unsigned gtOper)
+    static constexpr unsigned OperKind(unsigned gtOper)
     {
         assert(gtOper < GT_COUNT);
 
@@ -1446,7 +1446,7 @@ struct GenTree
     }
 #endif // TARGET_XARCH
 
-    static bool OperIsUnary(genTreeOps gtOper)
+    static constexpr bool OperIsUnary(genTreeOps gtOper)
     {
         return (OperKind(gtOper) & GTK_UNOP) != 0;
     }
@@ -1508,7 +1508,7 @@ struct GenTree
     }
 #endif // FEATURE_HW_INTRINSICS
 
-    static bool OperIsCommutative(genTreeOps gtOper)
+    static constexpr bool OperIsCommutative(genTreeOps gtOper)
     {
         return (OperKind(gtOper) & GTK_COMMUTE) != 0;
     }

src/coreclr/jit/valuenum.cpp

@@ -8816,70 +8816,90 @@ void ValueNumStore::vnDumpZeroObj(Compiler* comp, VNFuncApp* zeroObj)
 #endif // DEBUG
 
 // Static fields, methods.
-static UINT8      vnfOpAttribs[VNF_COUNT];
-static genTreeOps genTreeOpsIllegalAsVNFunc[] = {GT_IND, // When we do heap memory.
-                                                 GT_NULLCHECK, GT_QMARK, GT_COLON, GT_LOCKADD, GT_XADD, GT_XCHG,
-                                                 GT_CMPXCHG, GT_LCLHEAP, GT_BOX, GT_XORR, GT_XAND, GT_STORE_DYN_BLK,
-                                                 GT_STORE_LCL_VAR, GT_STORE_LCL_FLD, GT_STOREIND, GT_STORE_BLK,
-                                                 // These need special semantics:
-                                                 GT_COMMA, // == second argument (but with exception(s) from first).
-                                                 GT_ARR_ADDR, GT_BOUNDS_CHECK,
-                                                 GT_BLK,      // May reference heap memory.
-                                                 GT_INIT_VAL, // Not strictly a pass-through.
-                                                 GT_MDARR_LENGTH,
-                                                 GT_MDARR_LOWER_BOUND, // 'dim' value must be considered
-                                                 GT_BITCAST,           // Needs to encode the target type.
-
-                                                 // These control-flow operations need no values.
-                                                 GT_JTRUE, GT_RETURN, GT_SWITCH, GT_RETFILT, GT_CKFINITE};
-
-UINT8* ValueNumStore::s_vnfOpAttribs = nullptr;
-
-void ValueNumStore::InitValueNumStoreStatics()
+static const genTreeOps genTreeOpsIllegalAsVNFunc[] = {GT_IND, // When we do heap memory.
+                                                       GT_NULLCHECK, GT_QMARK, GT_COLON, GT_LOCKADD, GT_XADD, GT_XCHG,
+                                                       GT_CMPXCHG, GT_LCLHEAP, GT_BOX, GT_XORR, GT_XAND, GT_STORE_DYN_BLK,
+                                                       GT_STORE_LCL_VAR, GT_STORE_LCL_FLD, GT_STOREIND, GT_STORE_BLK,
+                                                       // These need special semantics:
+                                                       GT_COMMA, // == second argument (but with exception(s) from first).
+                                                       GT_ARR_ADDR, GT_BOUNDS_CHECK,
+                                                       GT_BLK,      // May reference heap memory.
+                                                       GT_INIT_VAL, // Not strictly a pass-through.
+                                                       GT_MDARR_LENGTH,
+                                                       GT_MDARR_LOWER_BOUND, // 'dim' value must be considered
+                                                       GT_BITCAST,           // Needs to encode the target type.
+
+                                                       // These control-flow operations need no values.
+                                                       GT_JTRUE, GT_RETURN, GT_SWITCH, GT_RETFILT, GT_CKFINITE};
+
+/* static */ const ValueNumStore::VnfOpAttribsType ValueNumStore::s_vnfOpAttribs = ValueNumStore::VnfOpAttribsType();
+
+/* static */ constexpr unsigned ValueNumStore::VnfOpAttribsType::GetArity(unsigned oper)
+{
+    genTreeOps gtOper = static_cast<genTreeOps>(oper);
+    unsigned   arity  = 0;
+    if (GenTree::OperIsUnary(gtOper))
+    {
+        arity = 1;
+    }
+    else if (GenTree::OperIsBinary(gtOper))
+    {
+        arity = 2;
+    }
+    else if (GenTree::StaticOperIs(gtOper, GT_SELECT))
+    {
+        arity = 3;
+    }
+
+    return (arity << VNFOA_ArityShift) & VNFOA_ArityMask;
+}
+
+/* static */ constexpr unsigned ValueNumStore::VnfOpAttribsType::GetCommutative(unsigned oper)
+{
+    genTreeOps gtOper = static_cast<genTreeOps>(oper);
+    return GenTree::OperIsCommutative(gtOper) ? VNFOA_Commutative : 0;
+}
+
+/* static */ constexpr unsigned ValueNumStore::VnfOpAttribsType::GetFunc(int arity, bool commute, bool knownNonNull, bool sharedStatic)
+{
+    unsigned value = 0;
+    if (commute)
+    {
+        value |= VNFOA_Commutative;
+    }
+    if (knownNonNull)
+    {
+        value |= VNFOA_KnownNonNull;
+    }
+    if (sharedStatic)
+    {
+        value |= VNFOA_SharedStatic;
+    }
+    if (arity > 0)
+    {
+        value |= ((arity << VNFOA_ArityShift) & VNFOA_ArityMask);
+    }
+    return value;
+}
+
+constexpr ValueNumStore::VnfOpAttribsType::VnfOpAttribsType() : m_arr()
 {
     // Make sure we have the constants right...
     assert(unsigned(VNFOA_Arity1) == (1 << VNFOA_ArityShift));
     assert(VNFOA_ArityMask == (VNFOA_MaxArity << VNFOA_ArityShift));
 
-    s_vnfOpAttribs = &vnfOpAttribs[0];
     for (unsigned i = 0; i < GT_COUNT; i++)
     {
-        genTreeOps gtOper = static_cast<genTreeOps>(i);
-        unsigned   arity  = 0;
-        if (GenTree::OperIsUnary(gtOper))
-        {
-            arity = 1;
-        }
-        else if (GenTree::OperIsBinary(gtOper))
-        {
-            arity = 2;
-        }
-        else if (GenTree::StaticOperIs(gtOper, GT_SELECT))
-        {
-            arity = 3;
-        }
-
-        vnfOpAttribs[i] |= ((arity << VNFOA_ArityShift) & VNFOA_ArityMask);
-
-        if (GenTree::OperIsCommutative(gtOper))
-        {
-            vnfOpAttribs[i] |= VNFOA_Commutative;
-        }
+        m_arr[i] |= GetArity(i);
+        m_arr[i] |= GetCommutative(i);
     }
 
     // I so wish this wasn't the best way to do this...
 
     int vnfNum = VNF_Boundary + 1; // The macro definition below will update this after using it.
 
 #define ValueNumFuncDef(vnf, arity, commute, knownNonNull, sharedStatic)                                               \
-    if (commute)                                                                                                       \
-        vnfOpAttribs[vnfNum] |= VNFOA_Commutative;                                                                     \
-    if (knownNonNull)                                                                                                  \
-        vnfOpAttribs[vnfNum] |= VNFOA_KnownNonNull;                                                                    \
-    if (sharedStatic)                                                                                                  \
-        vnfOpAttribs[vnfNum] |= VNFOA_SharedStatic;                                                                    \
-    if (arity > 0)                                                                                                     \
-        vnfOpAttribs[vnfNum] |= ((arity << VNFOA_ArityShift) & VNFOA_ArityMask);                                       \
+    m_arr[vnfNum] |= GetFunc(arity, commute, knownNonNull, sharedStatic);                                 \
     vnfNum++;
 
 #include "valuenumfuncs.h"
@@ -8888,8 +8908,8 @@ void ValueNumStore::InitValueNumStoreStatics()
     assert(vnfNum == VNF_COUNT);
 
 #define ValueNumFuncSetArity(vnfNum, arity)                                                                            \
-    vnfOpAttribs[vnfNum] &= ~VNFOA_ArityMask;                               /* clear old arity value   */              \
-    vnfOpAttribs[vnfNum] |= ((arity << VNFOA_ArityShift) & VNFOA_ArityMask) /* set the new arity value */
+    m_arr[vnfNum] &= ~VNFOA_ArityMask;                               /* clear old arity value   */                     \
+    m_arr[vnfNum] |= ((arity << VNFOA_ArityShift) & VNFOA_ArityMask) /* set the new arity value */
 
 #ifdef FEATURE_HW_INTRINSICS
 
@@ -8912,7 +8932,7 @@ void ValueNumStore::InitValueNumStoreStatics()
         if (HWIntrinsicInfo::IsCommutative(id))
         {
             VNFunc func = VNFunc(VNF_HWI_FIRST + (id - NI_HW_INTRINSIC_START - 1));
-            vnfOpAttribs[func] |= VNFOA_Commutative;
+            m_arr[func] |= VNFOA_Commutative;
         }
     }
 
@@ -8922,7 +8942,7 @@ void ValueNumStore::InitValueNumStoreStatics()
 
     for (unsigned i = 0; i < ArrLen(genTreeOpsIllegalAsVNFunc); i++)
     {
-        vnfOpAttribs[genTreeOpsIllegalAsVNFunc[i]] |= VNFOA_IllegalGenTreeOp;
+        m_arr[genTreeOpsIllegalAsVNFunc[i]] |= VNFOA_IllegalGenTreeOp;
     }
 }
 

src/coreclr/jit/valuenum.h

@@ -294,7 +294,7 @@ class ValueNumStore
     };
 
     // An array of length GT_COUNT, mapping genTreeOp values to their VNFOpAttrib.
-    static UINT8* s_vnfOpAttribs;
+    //static const UINT8* s_vnfOpAttribs;
 
     // Returns "true" iff gtOper is a legal value number function.
     // (Requires InitValueNumStoreStatics to have been run.)
@@ -359,6 +359,22 @@ class ValueNumStore
 #endif // FEATURE_SIMD
 
 private:
+    // This struct mainly exists to give a place to put the constexpr code for creating
+    // the OpAttribs table. It also gives a scope for the helpers functions used during
+    // initialization.
+    struct VnfOpAttribsType
+    {
+    public:
+        constexpr VnfOpAttribsType();
+        const UINT8& operator[](size_t idx) const { return m_arr[idx]; }
+    private:
+        static constexpr unsigned GetArity(unsigned oper);
+        static constexpr unsigned GetCommutative(unsigned oper);
+        static constexpr unsigned GetFunc(int arity, bool commute, bool knownNonNull, bool sharedStatic);
+
+        UINT8 m_arr[VNF_COUNT];
+    } static const s_vnfOpAttribs;
+
     // Assumes that all the ValueNum arguments of each of these functions have been shown to represent constants.
     // Assumes that "vnf" is a operator of the appropriate arity (unary for the first, binary for the second).
     // Assume that "CanEvalForConstantArgs(vnf)" is true.
@@ -387,9 +403,6 @@ class ValueNumStore
     GenTreeFlags GetFoldedArithOpResultHandleFlags(ValueNum vn);
 
 public:
-    // Initializes any static variables of ValueNumStore.
-    static void InitValueNumStoreStatics();
-
     // Initialize an empty ValueNumStore.
     ValueNumStore(Compiler* comp, CompAllocator allocator);