Remove verifier element type API and refactor enum/primitive category handling

docs/design/datacontracts/RuntimeTypeSystem.md

@@ -835,20 +835,16 @@ Contracts used:
         // if typedesc: check for CorElementType.ValueType
     }
 
-    // Enums have Category_PrimitiveValueType in their MethodTable flags and their
+    // Enums have Category_Enum in their MethodTable flags and their
     // InternalCorElementType is a primitive type (I1, U1, I2, U2, I4, U4, I8, U8),
-    // not ValueType. Regular primitive value types (IntPtr/UIntPtr) have Category_TruePrimitive.
+    // not ValueType. Regular primitive value types (Int32, etc.) have Category_TruePrimitive.
     public bool IsEnum(TypeHandle typeHandle)
     {
         if (!typeHandle.IsMethodTable())
             return false;
 
-        CorElementType sigType = GetSignatureCorElementType(typeHandle);
-        if (sigType != CorElementType.ValueType)
-            return false;
-
-        CorElementType internalType = (CorElementType)GetClassData(typeHandle).InternalCorElementType;
-        return internalType != CorElementType.ValueType;
+        MethodTable methodTable = _methodTables[typeHandle.Address];
+        return methodTable.Flags.GetFlag(WFLAGS_HIGH.Category_Mask) == WFLAGS_HIGH.Category_Enum;
     }
 
     // return true if the TypeHandle represents an array, and set the rank to either 0 (if the type is not an array), or the rank number if it is.

src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/RuntimeHelpers.CoreCLR.cs

@@ -850,8 +850,8 @@ internal unsafe struct MethodTable
         private const uint enum_flag_Category_ValueType = 0x00040000;
         private const uint enum_flag_Category_Nullable = 0x00050000;
         private const uint enum_flag_Category_IsPrimitiveMask = 0x000E0000;
-        private const uint enum_flag_Category_PrimitiveValueType = 0x00060000; // sub-category of ValueType, Enum or primitive value type
-        private const uint enum_flag_Category_TruePrimitive = 0x00070000; // sub-category of ValueType, Primitive (ELEMENT_TYPE_I, etc.)
+        private const uint enum_flag_Category_Enum = 0x00060000; // sub-category of ValueType
+        private const uint enum_flag_Category_TruePrimitive = 0x00070000; // sub-category of ValueType. (Int32, etc.)
         private const uint enum_flag_Category_Array = 0x00080000;
         private const uint enum_flag_Category_Array_Mask = 0x000C0000;
         private const uint enum_flag_Category_ValueType_Mask = 0x000C0000;
@@ -955,7 +955,7 @@ public int MultiDimensionalArrayRank
         public bool IsByRefLike => (Flags & (enum_flag_HasComponentSize | enum_flag_IsByRefLike)) == enum_flag_IsByRefLike;
 
         // Warning! UNLIKE the similarly named Reflection api, this method also returns "true" for Enums.
-        public bool IsPrimitive => (Flags & enum_flag_Category_IsPrimitiveMask) == enum_flag_Category_PrimitiveValueType;
+        public bool IsPrimitive => (Flags & enum_flag_Category_IsPrimitiveMask) == enum_flag_Category_Enum;
 
         public bool IsTruePrimitive => (Flags & enum_flag_Category_Mask) is enum_flag_Category_TruePrimitive;
 

src/coreclr/vm/arraynative.cpp

@@ -24,7 +24,7 @@ FCIMPL1(INT32, ArrayNative::GetCorElementTypeOfElementType, ArrayBase* arrayUNSA
 
     _ASSERTE(arrayUNSAFE != NULL);
 
-    return arrayUNSAFE->GetArrayElementTypeHandle().GetVerifierCorElementType();
+    return arrayUNSAFE->GetArrayElementTypeHandle().GetInternalCorElementType();
 }
 FCIMPLEND
 

src/coreclr/vm/callingconvention.h

@@ -2435,7 +2435,7 @@ inline BOOL HasRetBuffArgUnmanagedFixup(MetaSig * pSig)
 {
     WRAPPER_NO_CONTRACT;
     // We cannot just pSig->GetReturnType() here since it will return ELEMENT_TYPE_VALUETYPE for enums
-    CorElementType type = pSig->GetRetTypeHandleThrowing().GetVerifierCorElementType();
+    CorElementType type = pSig->GetRetTypeHandleThrowing().GetInternalCorElementType();
     return type == ELEMENT_TYPE_VALUETYPE;
 }
 #endif

src/coreclr/vm/class.cpp

@@ -1318,7 +1318,7 @@ void ClassLoader::LoadExactParents(MethodTable* pMT)
 /*static*/
 CorElementType ClassLoader::GetReducedTypeElementType(TypeHandle hType)
 {
-    CorElementType elemType = hType.GetVerifierCorElementType();
+    CorElementType elemType = hType.GetInternalCorElementType();
     switch (elemType)
     {
         case ELEMENT_TYPE_U1:

src/coreclr/vm/comdelegate.cpp

@@ -2511,7 +2511,7 @@ static bool IsLocationAssignable(TypeHandle fromHandle, TypeHandle toHandle, boo
     else
     {
         // they are not compatible yet enums can go into each other if their underlying element type is the same
-        if (toHandle.GetVerifierCorElementType() == fromHandle.GetVerifierCorElementType()
+        if (toHandle.GetInternalCorElementType() == fromHandle.GetInternalCorElementType()
             && (toHandle.IsEnum() || fromHandle.IsEnum()))
             return true;
 

src/coreclr/vm/customattribute.cpp

@@ -52,7 +52,7 @@ static HRESULT ParseCaType(
 
         if (!th.IsNull() && th.IsEnum())
         {
-            pCaType->enumType = (CorSerializationType)th.GetVerifierCorElementType();
+            pCaType->enumType = (CorSerializationType)th.GetInternalCorElementType();
 
             // The assembly qualified name of th might not equal pCaType->szEnumName.
             // e.g. th could be "MyEnum, MyAssembly, Version=4.0.0.0" while

src/coreclr/vm/invokeutil.cpp

@@ -135,7 +135,7 @@ void InvokeUtil::CopyArg(TypeHandle th, PVOID argRef, ArgDestination *argDest) {
     CONTRACTL_END;
 
     void *pArgDst = argDest->GetDestinationAddress();
-    CorElementType type = th.GetVerifierCorElementType();
+    CorElementType type = th.GetInternalCorElementType();
 
     switch (type) {
 #ifdef TARGET_RISCV64
@@ -500,7 +500,7 @@ void InvokeUtil::ValidField(TypeHandle th, OBJECTREF* value)
             if (th.IsEnum())
                 COMPlusThrow(kArgumentException,W("Arg_ObjObj"));
 
-            type = th.GetVerifierCorElementType();
+            type = th.GetInternalCorElementType();
             if (IsPrimitiveType(type))
             {
                 if (CanPrimitiveWiden(type, oType))

src/coreclr/vm/jitinterface.cpp

@@ -338,14 +338,7 @@ CorInfoType CEEInfo::asCorInfoType(CorElementType eeType,
         // Enums are exactly like primitives, even from a verification standpoint,
         // so we zap the type handle in this case.
         //
-        // However RuntimeTypeHandle etc. are reported as E_T_INT (or something like that)
-        // but don't count as primitives as far as verification is concerned...
-        //
-        // To make things stranger, TypedReference returns true for "IsTruePrimitive".
-        // However the JIT likes us to report the type handle in that case.
-        if (!typeHnd.IsTypeDesc() && (
-                (typeHnd.AsMethodTable()->IsTruePrimitive() && typeHnd != TypeHandle(g_TypedReferenceMT))
-                    || typeHnd.AsMethodTable()->IsEnum()) )
+        if (!typeHnd.IsTypeDesc() && typeHnd.AsMethodTable()->IsPrimitive())
         {
             typeHndUpdated = TypeHandle();
         }
@@ -4067,7 +4060,7 @@ CorInfoType CEEInfo::getTypeForPrimitiveValueClass(
     TypeHandle th(clsHnd);
     _ASSERTE (!th.IsGenericVariable());
 
-    CorElementType elementType = th.GetVerifierCorElementType();
+    CorElementType elementType = th.GetInternalCorElementType();
     if (CorIsPrimitiveType(elementType))
     {
         result = asCorInfoType(elementType);
@@ -4445,7 +4438,7 @@ static bool isExactTypeHelper(TypeHandle th)
         th = pMT->GetArrayElementTypeHandle();
 
         // Arrays of primitives are interchangeable with arrays of enums of the same underlying type.
-        if (CorTypeInfo::IsPrimitiveType(th.GetVerifierCorElementType()))
+        if (CorTypeInfo::IsPrimitiveType(th.GetInternalCorElementType()))
             return false;
     }
 
@@ -5052,7 +5045,7 @@ void CEEInfo::getCallInfo(
             if (pMD->GetSlot() == CoreLibBinder::GetMethod(METHOD__OBJECT__GET_HASH_CODE)->GetSlot())
             {
                 // Pretend this was a "constrained. UnderlyingType" instruction prefix
-                constrainedType = TypeHandle(CoreLibBinder::GetElementType(constrainedType.GetVerifierCorElementType()));
+                constrainedType = TypeHandle(CoreLibBinder::GetElementType(constrainedType.GetInternalCorElementType()));
 
                 constrainedResolvedTokenCopy = *pConstrainedResolvedToken;
                 pConstrainedResolvedToken = &constrainedResolvedTokenCopy;
@@ -7232,7 +7225,7 @@ static bool getILIntrinsicImplementationForInterlocked(MethodDesc * ftn,
     }
     else
     {
-        CorElementType elementType = typeHandle.GetVerifierCorElementType();
+        CorElementType elementType = typeHandle.GetInternalCorElementType();
         if (!CorTypeInfo::IsPrimitiveType(elementType) ||
             elementType == ELEMENT_TYPE_R4 ||
             elementType == ELEMENT_TYPE_R8)
@@ -7401,7 +7394,7 @@ static bool getILIntrinsicImplementationForRuntimeHelpers(
         Instantiation inst = ftn->GetMethodInstantiation();
 
         _ASSERTE(inst.GetNumArgs() == 1);
-        CorElementType et = inst[0].GetVerifierCorElementType();
+        CorElementType et = inst[0].GetInternalCorElementType();
         if (et == ELEMENT_TYPE_I4 ||
             et == ELEMENT_TYPE_U4 ||
             et == ELEMENT_TYPE_I2 ||
@@ -7430,7 +7423,7 @@ static bool getILIntrinsicImplementationForRuntimeHelpers(
         Instantiation inst = ftn->GetMethodInstantiation();
 
         _ASSERTE(inst.GetNumArgs() == 1);
-        CorElementType et = inst[0].GetVerifierCorElementType();
+        CorElementType et = inst[0].GetInternalCorElementType();
         if (et == ELEMENT_TYPE_I4 ||
             et == ELEMENT_TYPE_U4 ||
             et == ELEMENT_TYPE_I2 ||

src/coreclr/vm/marshalnative.cpp

@@ -110,7 +110,7 @@ extern "C" BOOL QCALLTYPE MarshalNative_HasLayout(QCall::TypeHandle t, BOOL* pIs
     {
         // Enums don't have native layout info, but they marshal identically
         // to their underlying primitive type.
-        th = CoreLibBinder::GetElementType(th.GetVerifierCorElementType());
+        th = CoreLibBinder::GetElementType(th.GetInternalCorElementType());
     }
 
     if (th.HasLayout())

src/coreclr/vm/methodtable.cpp

@@ -3087,7 +3087,7 @@ namespace
         STANDARD_VM_CONTRACT;
 
         PTR_MethodTable fieldType = pFieldDesc->GetFieldTypeHandleThrowing().GetMethodTable();
-        CorElementType corType = fieldType->GetVerifierCorElementType();
+        CorElementType corType = fieldType->GetInternalCorElementType();
 
         if (corType == ELEMENT_TYPE_VALUETYPE)
         {
@@ -4969,9 +4969,8 @@ CorElementType MethodTable::GetInternalCorElementType()
         ret = ELEMENT_TYPE_VALUETYPE;
         break;
 
-    case enum_flag_Category_PrimitiveValueType:
-        // This path should only be taken for the builtin CoreLib types
-        // and primitive valuetypes
+    case enum_flag_Category_Enum:
+        // enum_flag_Category_ElementTypeMask maps both Category_TruePrimitive and Category_Enum here.
         ret = GetClass()->GetInternalCorElementType();
         _ASSERTE((ret != ELEMENT_TYPE_CLASS) &&
                     (ret != ELEMENT_TYPE_VALUETYPE));
@@ -4994,48 +4993,6 @@ CorElementType MethodTable::GetInternalCorElementType()
     return ret;
 }
 
-//==========================================================================================
-CorElementType MethodTable::GetVerifierCorElementType()
-{
-    LIMITED_METHOD_CONTRACT;
-    SUPPORTS_DAC;
-
-    // This should not touch the EEClass, at least not in the
-    // common cases of ELEMENT_TYPE_CLASS and ELEMENT_TYPE_VALUETYPE.
-    CorElementType ret;
-
-    switch (GetFlag(enum_flag_Category_ElementTypeMask))
-    {
-    case enum_flag_Category_Array:
-        ret = ELEMENT_TYPE_ARRAY;
-        break;
-
-    case enum_flag_Category_Array | enum_flag_Category_IfArrayThenSzArray:
-        ret = ELEMENT_TYPE_SZARRAY;
-        break;
-
-    case enum_flag_Category_ValueType:
-        ret = ELEMENT_TYPE_VALUETYPE;
-        break;
-
-    case enum_flag_Category_PrimitiveValueType:
-        //
-        // This is the only difference from MethodTable::GetInternalCorElementType()
-        //
-        if (IsTruePrimitive() || IsEnum())
-            ret = GetClass()->GetInternalCorElementType();
-        else
-            ret = ELEMENT_TYPE_VALUETYPE;
-        break;
-
-    default:
-        ret = ELEMENT_TYPE_CLASS;
-        break;
-    }
-
-    return ret;
-}
-
 //==========================================================================================
 CorElementType MethodTable::GetSignatureCorElementType()
 {
@@ -5058,7 +5015,7 @@ CorElementType MethodTable::GetSignatureCorElementType()
 
     case enum_flag_Category_ValueType:
     case enum_flag_Category_Nullable:
-    case enum_flag_Category_PrimitiveValueType:
+    case enum_flag_Category_Enum:
         ret = ELEMENT_TYPE_VALUETYPE;
         break;
 
@@ -5077,28 +5034,26 @@ CorElementType MethodTable::GetSignatureCorElementType()
 #ifndef DACCESS_COMPILE
 
 //==========================================================================================
-void MethodTable::SetInternalCorElementType (CorElementType _NormType)
+void MethodTable::SetInternalCorElementType(CorElementType elemType, bool isTruePrimitive)
 {
     WRAPPER_NO_CONTRACT;
 
-    switch (_NormType)
+    switch (elemType)
     {
     case ELEMENT_TYPE_CLASS:
         _ASSERTE(!IsArray());
         // Nothing to do
         break;
     case ELEMENT_TYPE_VALUETYPE:
         SetFlag(enum_flag_Category_ValueType);
-        _ASSERTE(GetFlag(enum_flag_Category_Mask) == enum_flag_Category_ValueType);
         break;
     default:
-        SetFlag(enum_flag_Category_PrimitiveValueType);
-        _ASSERTE(GetFlag(enum_flag_Category_Mask) == enum_flag_Category_PrimitiveValueType);
+        SetFlag(isTruePrimitive ? enum_flag_Category_TruePrimitive : enum_flag_Category_Enum);
         break;
     }
 
-    GetClass()->SetInternalCorElementType(_NormType);
-    _ASSERTE(GetInternalCorElementType() == _NormType);
+    GetClass()->SetInternalCorElementType(elemType);
+    _ASSERTE(GetInternalCorElementType() == elemType);
 }
 
 #endif // !DACCESS_COMPILE

src/coreclr/vm/methodtable.h

@@ -2769,30 +2769,26 @@ class MethodTable
     //
     // #KindsOfElementTypes
     // GetInternalCorElementType() retrieves the internal representation of the type. It's not always
-    // appropriate to use this. For example, we treat enums as their underlying type or some structs are
-    // optimized to be ints. To get the signature type or the verifier type (same as signature except for
-    // enums are normalized to the primitive type that underlies them), use the APIs in Typehandle.h
+    // appropriate to use this. It treats enums as their underlying type. To get the signature
+    // type, use the APIs in Typehandle.h.
     //
     //   * code:TypeHandle.GetSignatureCorElementType()
-    //   * code:TypeHandle.GetVerifierCorElementType()
     //   * code:TypeHandle.GetInternalCorElementType()
     CorElementType GetInternalCorElementType();
-    void SetInternalCorElementType(CorElementType _NormType);
-
-    // See code:TypeHandle::GetVerifierCorElementType for description
-    CorElementType GetVerifierCorElementType();
+    void SetInternalCorElementType(CorElementType elemType, bool isTruePrimitive = false);
 
     // See code:TypeHandle::GetSignatureCorElementType for description
     CorElementType GetSignatureCorElementType();
 
-    // A true primitive is one who's GetVerifierCorElementType() ==
+    // A true primitive is one whose GetInternalCorElementType() ==
     //      ELEMENT_TYPE_I,
     //      ELEMENT_TYPE_I4,
     //      ELEMENT_TYPE_TYPEDBYREF etc.
-    // Note that GetIntenalCorElementType might return these same values for some additional
-    // types such as Enums and some structs.
-    BOOL IsTruePrimitive();
-    void SetIsTruePrimitive();
+    //  Note that IsTruePrimitive returns false for enum types.
+    bool IsTruePrimitive();
+
+    // Like IsTruePrimitive but also returns true for enum types.
+    bool IsPrimitive();
 
     // Is this delegate? Returns false for System.Delegate and System.MulticastDelegate.
     inline BOOL IsDelegate()
@@ -3793,8 +3789,8 @@ public :
         enum_flag_Category_ValueType        = 0x00040000, // [cDAC] [RuntimeTypeSystem]: Contract depends on this value
         enum_flag_Category_ValueType_Mask   = 0x000C0000,
         enum_flag_Category_Nullable         = 0x00050000, // sub-category of ValueType. [cDAC] [RuntimeTypeSystem]: Contract depends on this value
-        enum_flag_Category_PrimitiveValueType=0x00060000, // sub-category of ValueType, Enum or primitive value type. [cDAC] [RuntimeTypeSystem]: Contract depends on this value
-        enum_flag_Category_TruePrimitive    = 0x00070000, // sub-category of ValueType, Primitive (ELEMENT_TYPE_I, etc.). [cDAC] [RuntimeTypeSystem]: Contract depends on this value
+        enum_flag_Category_Enum             = 0x00060000, // sub-category of ValueType. [cDAC] [RuntimeTypeSystem]: Contract depends on this value
+        enum_flag_Category_TruePrimitive    = 0x00070000, // sub-category of ValueType. (Int32, etc.). [cDAC] [RuntimeTypeSystem]: Contract depends on this value
 
         enum_flag_Category_Array            = 0x00080000, // [cDAC] [RuntimeTypeSystem]: Contract depends on this value
         enum_flag_Category_Array_Mask       = 0x000C0000, // [cDAC] [RuntimeTypeSystem]: Contract depends on this value

src/coreclr/vm/methodtable.inl

@@ -324,17 +324,18 @@ inline DWORD MethodTable::GetRank()
 }
 
 //==========================================================================================
-inline BOOL MethodTable::IsTruePrimitive()
+inline bool MethodTable::IsTruePrimitive()
 {
     LIMITED_METHOD_DAC_CONTRACT;
     return GetFlag(enum_flag_Category_Mask) == enum_flag_Category_TruePrimitive;
 }
 
 //==========================================================================================
-inline void MethodTable::SetIsTruePrimitive()
+inline bool MethodTable::IsPrimitive()
 {
     LIMITED_METHOD_DAC_CONTRACT;
-    SetFlag(enum_flag_Category_TruePrimitive);
+    // enum_flag_Category_ElementTypeMask maps both Category_TruePrimitive and Category_Enum here.
+    return GetFlag(enum_flag_Category_ElementTypeMask) == enum_flag_Category_Enum;
 }
 
 //==========================================================================================