Make Type.IsEnum and Type.GetEnumUnderlyingType intrinsics (#71685)

* Make Type.GetTypeCode an intrinsic

Makes Type.GetTypeCode a JIT intrinsic for primitive types,
enums and strings.

Makes Type.IsEnum use intrinsics instead of IsSubclassOf

Makes Enum.GetUnderlyingType use Type.GetTypeCode

Moves the legacy FCall to InternalGetUnderlyingTypeImpl,
so that the non-intrinsic GetTypeCode can use it.

Introduces JIT tests checking the generated codegen.

* Change IsEnum to an intrinsic

* Fallback to the FCall for nint/nuint enums

* Fix compilation

* Add missing Intrinsic

* Add typeof support to IsKnownConstant

* Use gtIsTypeHandleToRuntimeTypeHelper

* Add __reftype tests

* Make more places use gtIsTypeof

* Update EnumTests.cs

* Add impTypeGetTypeCode to the header

* Update EnumGetUnderlyingTypeEnums.il

* Make the IsActualEnum helper an intrinsic

* Remove GetTypeCode intrinsics

* Create a new JIT-EE api, add GetEnumUnderlyingType back

* Optimize GetTypeCode with IsKnownConstant

* Change the code to make the inliner happy

* Handle all types in GetTypeCode

* Check for custom types

* Fix build, do suggested changes

Co-authored-by: Andy Ayers <andya@microsoft.com>
Co-authored-by: Jan Kotas <jkotas@microsoft.com>

Author: 3 people

src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CoreCLR.cs

@@ -3397,6 +3397,7 @@ public override unsafe bool IsEnum
         // This returns true for actual enum types only.
         internal unsafe bool IsActualEnum
         {
+            [Intrinsic]
             get
             {
                 TypeHandle th = GetNativeTypeHandle();

src/coreclr/inc/corinfo.h

@@ -2270,7 +2270,7 @@ class ICorStaticInfo
 
     //------------------------------------------------------------------------------
     // printObjectDescription: Prints a (possibly truncated) textual UTF8 representation of the given
-    //    object to a preallocated buffer. It's intended to be used only for debug/diagnostic 
+    //    object to a preallocated buffer. It's intended to be used only for debug/diagnostic
     //    purposes such as JitDisasm. The buffer is null-terminated (even if truncated).
     //
     // Arguments:
@@ -2635,6 +2635,16 @@ class ICorStaticInfo
             CORINFO_CLASS_HANDLE        cls2
             ) = 0;
 
+    // Returns TypeCompareState::Must if cls is known to be an enum.
+    // For enums with known exact type returns the underlying
+    // type in underlyingType when the provided pointer is
+    // non-NULL.
+    // Returns TypeCompareState::May when a runtime check is required.
+    virtual TypeCompareState isEnum(
+            CORINFO_CLASS_HANDLE        cls,
+            CORINFO_CLASS_HANDLE*       underlyingType
+            ) = 0;
+
     // Given a class handle, returns the Parent type.
     // For COMObjectType, it returns Class Handle of System.Object.
     // Returns 0 if System.Object is passed in.
@@ -2849,7 +2859,7 @@ class ICorStaticInfo
             CORINFO_CLASS_HANDLE       *vcTypeRet       /* OUT */
             ) = 0;
 
-    // Obtains a list of exact classes for a given base type. Returns 0 if the number of 
+    // Obtains a list of exact classes for a given base type. Returns 0 if the number of
     // the exact classes is greater than maxExactClasses or if more types might be loaded
     // in future.
     virtual int getExactClasses(

src/coreclr/inc/icorjitinfoimpl_generated.h

@@ -352,6 +352,10 @@ bool isMoreSpecificType(
           CORINFO_CLASS_HANDLE cls1,
           CORINFO_CLASS_HANDLE cls2) override;
 
+TypeCompareState isEnum(
+          CORINFO_CLASS_HANDLE cls,
+          CORINFO_CLASS_HANDLE* underlyingType) override;
+
 CORINFO_CLASS_HANDLE getParentType(
           CORINFO_CLASS_HANDLE cls) override;
 

src/coreclr/inc/jiteeversionguid.h

@@ -43,11 +43,11 @@ typedef const GUID *LPCGUID;
 #define GUID_DEFINED
 #endif // !GUID_DEFINED
 
-constexpr GUID JITEEVersionIdentifier = { /* 77b6df16-d27f-4118-9dfd-d8073ff20fb6 */
-    0x77b6df16,
-    0xd27f,
-    0x4118,
-    {0x9d, 0xfd, 0xd8, 0x7, 0x3f, 0xf2, 0xf, 0xb6}
+constexpr GUID JITEEVersionIdentifier = { /* e452af1d-0a1a-44a8-a5b3-ef6074b8ab4a */
+    0xe452af1d,
+    0x0a1a,
+    0x44a8,
+    {0xa5, 0xb3, 0xef, 0x60, 0x74, 0xb8, 0xab, 0x4a}
   };
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////

src/coreclr/jit/ICorJitInfo_names_generated.h

@@ -88,6 +88,7 @@ DEF_CLR_API(compareTypesForCast)
 DEF_CLR_API(compareTypesForEquality)
 DEF_CLR_API(mergeClasses)
 DEF_CLR_API(isMoreSpecificType)
+DEF_CLR_API(isEnum)
 DEF_CLR_API(getParentType)
 DEF_CLR_API(getChildType)
 DEF_CLR_API(satisfiesClassConstraints)

src/coreclr/jit/ICorJitInfo_wrapper_generated.hpp

@@ -830,6 +830,16 @@ bool WrapICorJitInfo::isMoreSpecificType(
     return temp;
 }
 
+TypeCompareState WrapICorJitInfo::isEnum(
+          CORINFO_CLASS_HANDLE cls,
+          CORINFO_CLASS_HANDLE* underlyingType)
+{
+    API_ENTER(isEnum);
+    TypeCompareState temp = wrapHnd->isEnum(cls, underlyingType);
+    API_LEAVE(isEnum);
+    return temp;
+}
+
 CORINFO_CLASS_HANDLE WrapICorJitInfo::getParentType(
           CORINFO_CLASS_HANDLE cls)
 {

src/coreclr/jit/compiler.h

@@ -2878,6 +2878,8 @@ class Compiler
     CORINFO_CLASS_HANDLE gtGetHelperArgClassHandle(GenTree* array);
     // Get the class handle for a field
     CORINFO_CLASS_HANDLE gtGetFieldClassHandle(CORINFO_FIELD_HANDLE fieldHnd, bool* pIsExact, bool* pIsNonNull);
+    // Check if this tree is a typeof()
+    bool gtIsTypeof(GenTree* tree, CORINFO_CLASS_HANDLE* handle = nullptr);
 
     GenTree* gtCallGetDefinedRetBufLclAddr(GenTreeCall* call);
 

src/coreclr/jit/fgbasic.cpp

@@ -1163,6 +1163,8 @@ void Compiler::fgFindJumpTargets(const BYTE* codeAddr, IL_OFFSET codeSize, Fixed
                                 break;
 
                             // These are foldable if the first argument is a constant
+                            case NI_System_Type_get_IsEnum:
+                            case NI_System_Type_GetEnumUnderlyingType:
                             case NI_System_Type_get_IsValueType:
                             case NI_System_Type_get_IsByRefLike:
                             case NI_System_Type_GetTypeFromHandle:

src/coreclr/jit/gentree.cpp

@@ -18335,6 +18335,42 @@ CORINFO_CLASS_HANDLE Compiler::gtGetFieldClassHandle(CORINFO_FIELD_HANDLE fieldH
     return fieldClass;
 }
 
+//------------------------------------------------------------------------
+// gtIsTypeof: Checks if the tree is a typeof()
+//
+// Arguments:
+//    tree   - the tree that is checked
+//    handle - (optional, default nullptr) - if non-null is set to the type
+//
+// Return Value:
+//    Is the tree typeof()
+//
+bool Compiler::gtIsTypeof(GenTree* tree, CORINFO_CLASS_HANDLE* handle)
+{
+    if (tree->IsCall())
+    {
+        GenTreeCall* call = tree->AsCall();
+        if (gtIsTypeHandleToRuntimeTypeHelper(call))
+        {
+            assert(call->gtArgs.CountArgs() == 1);
+            CORINFO_CLASS_HANDLE hClass = gtGetHelperArgClassHandle(call->gtArgs.GetArgByIndex(0)->GetEarlyNode());
+            if (hClass != NO_CLASS_HANDLE)
+            {
+                if (handle != nullptr)
+                {
+                    *handle = hClass;
+                }
+                return true;
+            }
+        }
+    }
+    if (handle != nullptr)
+    {
+        *handle = NO_CLASS_HANDLE;
+    }
+    return false;
+}
+
 //------------------------------------------------------------------------
 // gtCallGetDefinedRetBufLclAddr:
 //   Get the tree corresponding to the address of the retbuf that this call defines.

src/coreclr/jit/importer.cpp

@@ -2932,37 +2932,24 @@ GenTree* Compiler::impTypeIsAssignable(GenTree* typeTo, GenTree* typeFrom)
     //
     // to true/false
 
-    if (typeTo->IsCall() && typeFrom->IsCall())
+    // make sure both arguments are `typeof()`
+    CORINFO_CLASS_HANDLE hClassTo   = NO_CLASS_HANDLE;
+    CORINFO_CLASS_HANDLE hClassFrom = NO_CLASS_HANDLE;
+    if (gtIsTypeof(typeTo, &hClassTo) && gtIsTypeof(typeFrom, &hClassFrom))
     {
-        // make sure both arguments are `typeof()`
-        CORINFO_METHOD_HANDLE hTypeof = eeFindHelper(CORINFO_HELP_TYPEHANDLE_TO_RUNTIMETYPE);
-        if ((typeTo->AsCall()->gtCallMethHnd == hTypeof) && (typeFrom->AsCall()->gtCallMethHnd == hTypeof))
+        TypeCompareState castResult = info.compCompHnd->compareTypesForCast(hClassFrom, hClassTo);
+        if (castResult == TypeCompareState::May)
         {
-            assert((typeTo->AsCall()->gtArgs.CountArgs() == 1) && (typeFrom->AsCall()->gtArgs.CountArgs() == 1));
-            CORINFO_CLASS_HANDLE hClassTo =
-                gtGetHelperArgClassHandle(typeTo->AsCall()->gtArgs.GetArgByIndex(0)->GetEarlyNode());
-            CORINFO_CLASS_HANDLE hClassFrom =
-                gtGetHelperArgClassHandle(typeFrom->AsCall()->gtArgs.GetArgByIndex(0)->GetEarlyNode());
-
-            if (hClassTo == NO_CLASS_HANDLE || hClassFrom == NO_CLASS_HANDLE)
-            {
-                return nullptr;
-            }
-
-            TypeCompareState castResult = info.compCompHnd->compareTypesForCast(hClassFrom, hClassTo);
-            if (castResult == TypeCompareState::May)
-            {
-                // requires runtime check
-                // e.g. __Canon, COMObjects, Nullable
-                return nullptr;
-            }
+            // requires runtime check
+            // e.g. __Canon, COMObjects, Nullable
+            return nullptr;
+        }
 
-            GenTreeIntCon* retNode = gtNewIconNode((castResult == TypeCompareState::Must) ? 1 : 0);
-            impPopStack(); // drop both CORINFO_HELP_TYPEHANDLE_TO_RUNTIMETYPE calls
-            impPopStack();
+        GenTreeIntCon* retNode = gtNewIconNode((castResult == TypeCompareState::Must) ? 1 : 0);
+        impPopStack(); // drop both CORINFO_HELP_TYPEHANDLE_TO_RUNTIMETYPE calls
+        impPopStack();
 
-            return retNode;
-        }
+        return retNode;
     }
 
     return nullptr;
@@ -13391,15 +13378,10 @@ void Compiler::impInlineRecordArgInfo(InlineInfo*   pInlineInfo,
             return;
         }
     }
-    else
+    else if (gtIsTypeof(curArgVal))
     {
-        if (curArgVal->IsHelperCall() && gtIsTypeHandleToRuntimeTypeHelper(curArgVal->AsCall()) &&
-            (gtGetHelperArgClassHandle(curArgVal->AsCall()->gtArgs.GetArgByIndex(0)->GetEarlyNode()) !=
-             NO_CLASS_HANDLE))
-        {
-            inlCurArgInfo->argIsInvariant = true;
-            inlCurArgInfo->argHasSideEff  = false;
-        }
+        inlCurArgInfo->argIsInvariant = true;
+        inlCurArgInfo->argHasSideEff  = false;
     }
 
     bool isExact              = false;