From f5c77e58b6e037e282cedb5f8db684b5128800c1 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Thu, 18 Jan 2024 14:44:16 +0100 Subject: [PATCH 01/23] Add getTypeDefinition definition --- src/coreclr/inc/corinfo.h | 15 +++++++++++++++ src/coreclr/inc/icorjitinfoimpl_generated.h | 3 +++ src/coreclr/jit/ICorJitInfo_names_generated.h | 1 + src/coreclr/jit/ICorJitInfo_wrapper_generated.hpp | 9 +++++++++ .../JitInterface/ThunkGenerator/ThunkInput.txt | 1 + .../aot/jitinterface/jitinterface_generated.h | 10 ++++++++++ .../icorjitinfo_generated.cpp | 7 +++++++ .../icorjitinfo_generated.cpp | 6 ++++++ 8 files changed, 52 insertions(+) diff --git a/src/coreclr/inc/corinfo.h b/src/coreclr/inc/corinfo.h index e273ca5f2698bc..213d2601b93793 100644 --- a/src/coreclr/inc/corinfo.h +++ b/src/coreclr/inc/corinfo.h @@ -2082,6 +2082,21 @@ class ICorStaticInfo CORINFO_METHOD_HANDLE meth1Hnd, CORINFO_METHOD_HANDLE meth2Hnd) = 0; + //------------------------------------------------------------------------------ + // getTypeDefinition: Get the (unconstructed) type definition from a given type handle. + // + // Arguments: + // type - The input type handle + // + // Return Value: + // The type handle for the (unconstructed) type definition from type. + // + // Remarks: + // This is equivalent of Type.GetGenericTypeDefinition(). Given a generic type handle, it will + // return the original type definition (eg. for Foo it will return Foo<>). If the input + // type handle represents a type that is not generic, it will just return the same type. + virtual CORINFO_CLASS_HANDLE getTypeDefinition(CORINFO_CLASS_HANDLE type) = 0; + // Decides if you have any limitations for inlining. If everything's OK, it will return // INLINE_PASS. // diff --git a/src/coreclr/inc/icorjitinfoimpl_generated.h b/src/coreclr/inc/icorjitinfoimpl_generated.h index f396963d68ba95..fc415320cad835 100644 --- a/src/coreclr/inc/icorjitinfoimpl_generated.h +++ b/src/coreclr/inc/icorjitinfoimpl_generated.h @@ -48,6 +48,9 @@ bool haveSameMethodDefinition( CORINFO_METHOD_HANDLE meth1Hnd, CORINFO_METHOD_HANDLE meth2Hnd) override; +CORINFO_CLASS_HANDLE getTypeDefinition( + CORINFO_CLASS_HANDLE type) override; + CorInfoInline canInline( CORINFO_METHOD_HANDLE callerHnd, CORINFO_METHOD_HANDLE calleeHnd) override; diff --git a/src/coreclr/jit/ICorJitInfo_names_generated.h b/src/coreclr/jit/ICorJitInfo_names_generated.h index f7c218d90d0293..d6526b94ee9ee2 100644 --- a/src/coreclr/jit/ICorJitInfo_names_generated.h +++ b/src/coreclr/jit/ICorJitInfo_names_generated.h @@ -11,6 +11,7 @@ DEF_CLR_API(setMethodAttribs) DEF_CLR_API(getMethodSig) DEF_CLR_API(getMethodInfo) DEF_CLR_API(haveSameMethodDefinition) +DEF_CLR_API(getTypeDefinition) DEF_CLR_API(canInline) DEF_CLR_API(beginInlining) DEF_CLR_API(reportInliningDecision) diff --git a/src/coreclr/jit/ICorJitInfo_wrapper_generated.hpp b/src/coreclr/jit/ICorJitInfo_wrapper_generated.hpp index 5b044f211e8dc9..3410d97d1fc565 100644 --- a/src/coreclr/jit/ICorJitInfo_wrapper_generated.hpp +++ b/src/coreclr/jit/ICorJitInfo_wrapper_generated.hpp @@ -79,6 +79,15 @@ bool WrapICorJitInfo::haveSameMethodDefinition( return temp; } +CORINFO_CLASS_HANDLE WrapICorJitInfo::getTypeDefinition( + CORINFO_CLASS_HANDLE type) +{ + API_ENTER(getTypeDefinition); + CORINFO_CLASS_HANDLE temp = wrapHnd->getTypeDefinition(type); + API_LEAVE(getTypeDefinition); + return temp; +} + CorInfoInline WrapICorJitInfo::canInline( CORINFO_METHOD_HANDLE callerHnd, CORINFO_METHOD_HANDLE calleeHnd) diff --git a/src/coreclr/tools/Common/JitInterface/ThunkGenerator/ThunkInput.txt b/src/coreclr/tools/Common/JitInterface/ThunkGenerator/ThunkInput.txt index ae10f997204ca0..1ddf962175b026 100644 --- a/src/coreclr/tools/Common/JitInterface/ThunkGenerator/ThunkInput.txt +++ b/src/coreclr/tools/Common/JitInterface/ThunkGenerator/ThunkInput.txt @@ -170,6 +170,7 @@ FUNCTIONS void getMethodSig( CORINFO_METHOD_HANDLE ftn, CORINFO_SIG_INFO *sig, CORINFO_CLASS_HANDLE memberParent ); bool getMethodInfo(CORINFO_METHOD_HANDLE ftn, CORINFO_METHOD_INFO* info, CORINFO_CONTEXT_HANDLE context); bool haveSameMethodDefinition(CORINFO_METHOD_HANDLE meth1Hnd, CORINFO_METHOD_HANDLE meth2Hnd); + CORINFO_CLASS_HANDLE getTypeDefinition(CORINFO_CLASS_HANDLE type); CorInfoInline canInline( CORINFO_METHOD_HANDLE callerHnd, CORINFO_METHOD_HANDLE calleeHnd); void beginInlining(CORINFO_METHOD_HANDLE inlinerHnd, CORINFO_METHOD_HANDLE inlineeHnd); void reportInliningDecision(CORINFO_METHOD_HANDLE inlinerHnd, CORINFO_METHOD_HANDLE inlineeHnd, CorInfoInline inlineResult, const char * reason); diff --git a/src/coreclr/tools/aot/jitinterface/jitinterface_generated.h b/src/coreclr/tools/aot/jitinterface/jitinterface_generated.h index 8c9a4786ea3d50..74f884b3afa9e9 100644 --- a/src/coreclr/tools/aot/jitinterface/jitinterface_generated.h +++ b/src/coreclr/tools/aot/jitinterface/jitinterface_generated.h @@ -18,6 +18,7 @@ struct JitInterfaceCallbacks void (* getMethodSig)(void * thisHandle, CorInfoExceptionClass** ppException, CORINFO_METHOD_HANDLE ftn, CORINFO_SIG_INFO* sig, CORINFO_CLASS_HANDLE memberParent); bool (* getMethodInfo)(void * thisHandle, CorInfoExceptionClass** ppException, CORINFO_METHOD_HANDLE ftn, CORINFO_METHOD_INFO* info, CORINFO_CONTEXT_HANDLE context); bool (* haveSameMethodDefinition)(void * thisHandle, CorInfoExceptionClass** ppException, CORINFO_METHOD_HANDLE meth1Hnd, CORINFO_METHOD_HANDLE meth2Hnd); + CORINFO_CLASS_HANDLE (* getTypeDefinition)(void * thisHandle, CorInfoExceptionClass** ppException, CORINFO_CLASS_HANDLE type); CorInfoInline (* canInline)(void * thisHandle, CorInfoExceptionClass** ppException, CORINFO_METHOD_HANDLE callerHnd, CORINFO_METHOD_HANDLE calleeHnd); void (* beginInlining)(void * thisHandle, CorInfoExceptionClass** ppException, CORINFO_METHOD_HANDLE inlinerHnd, CORINFO_METHOD_HANDLE inlineeHnd); void (* reportInliningDecision)(void * thisHandle, CorInfoExceptionClass** ppException, CORINFO_METHOD_HANDLE inlinerHnd, CORINFO_METHOD_HANDLE inlineeHnd, CorInfoInline inlineResult, const char* reason); @@ -269,6 +270,15 @@ class JitInterfaceWrapper : public ICorJitInfo return temp; } + virtual CORINFO_CLASS_HANDLE getTypeDefinition( + CORINFO_CLASS_HANDLE type) +{ + CorInfoExceptionClass* pException = nullptr; + CORINFO_CLASS_HANDLE temp = _callbacks->getTypeDefinition(_thisHandle, &pException, type); + if (pException != nullptr) throw pException; + return temp; +} + virtual CorInfoInline canInline( CORINFO_METHOD_HANDLE callerHnd, CORINFO_METHOD_HANDLE calleeHnd) diff --git a/src/coreclr/tools/superpmi/superpmi-shim-counter/icorjitinfo_generated.cpp b/src/coreclr/tools/superpmi/superpmi-shim-counter/icorjitinfo_generated.cpp index 61b210ca3c09a2..332c9d13d0a635 100644 --- a/src/coreclr/tools/superpmi/superpmi-shim-counter/icorjitinfo_generated.cpp +++ b/src/coreclr/tools/superpmi/superpmi-shim-counter/icorjitinfo_generated.cpp @@ -67,6 +67,13 @@ bool interceptor_ICJI::haveSameMethodDefinition( return original_ICorJitInfo->haveSameMethodDefinition(meth1Hnd, meth2Hnd); } +CORINFO_CLASS_HANDLE interceptor_ICJI::getTypeDefinition( + CORINFO_CLASS_HANDLE type) +{ + mcs->AddCall("getTypeDefinition"); + return original_ICorJitInfo->getTypeDefinition(type); +} + CorInfoInline interceptor_ICJI::canInline( CORINFO_METHOD_HANDLE callerHnd, CORINFO_METHOD_HANDLE calleeHnd) diff --git a/src/coreclr/tools/superpmi/superpmi-shim-simple/icorjitinfo_generated.cpp b/src/coreclr/tools/superpmi/superpmi-shim-simple/icorjitinfo_generated.cpp index 840291e26701a6..989c587d47d892 100644 --- a/src/coreclr/tools/superpmi/superpmi-shim-simple/icorjitinfo_generated.cpp +++ b/src/coreclr/tools/superpmi/superpmi-shim-simple/icorjitinfo_generated.cpp @@ -60,6 +60,12 @@ bool interceptor_ICJI::haveSameMethodDefinition( return original_ICorJitInfo->haveSameMethodDefinition(meth1Hnd, meth2Hnd); } +CORINFO_CLASS_HANDLE interceptor_ICJI::getTypeDefinition( + CORINFO_CLASS_HANDLE type) +{ + return original_ICorJitInfo->getTypeDefinition(type); +} + CorInfoInline interceptor_ICJI::canInline( CORINFO_METHOD_HANDLE callerHnd, CORINFO_METHOD_HANDLE calleeHnd) From 7b27bb2da1d5ba3bf441bc0c28688d1c6e6c452e Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Thu, 18 Jan 2024 15:12:41 +0100 Subject: [PATCH 02/23] Implement CEEInfo::getTypeDefinition --- src/coreclr/vm/jitinterface.cpp | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+) diff --git a/src/coreclr/vm/jitinterface.cpp b/src/coreclr/vm/jitinterface.cpp index 3b8c32e20fcd57..5192cd703635a0 100644 --- a/src/coreclr/vm/jitinterface.cpp +++ b/src/coreclr/vm/jitinterface.cpp @@ -7820,6 +7820,32 @@ bool CEEInfo::haveSameMethodDefinition( return result; } +CORINFO_CLASS_HANDLE CEEInfo::getTypeDefinition(CORINFO_CLASS_HANDLE type) +{ + CONTRACTL { + THROWS; + GC_TRIGGERS; + MODE_PREEMPTIVE; + } CONTRACTL_END; + + CORINFO_CLASS_HANDLE result = NULL; + + JIT_TO_EE_TRANSITION(); + + TypeHandle constructedHandle(type); + TypeHandle definitionHandle = ClassLoader::LoadTypeDefThrowing( + constructedHandle.GetModule(), + constructedHandle.GetMethodTable()->GetCl(), + ClassLoader::ThrowIfNotFound, + ClassLoader::PermitUninstDefOrRef); + + result = CORINFO_CLASS_HANDLE(definitionHandle.AsPtr()); + + EE_TO_JIT_TRANSITION(); + + return result; +} + /************************************************************* * Check if the caller and calle are in the same assembly * i.e. do not inline across assemblies From f7e895123a4b1b6e05d49fecd0c64de8eedb5aee Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Thu, 18 Jan 2024 16:22:39 +0100 Subject: [PATCH 03/23] Tweak CEEInfo::getTypeDefinition --- src/coreclr/vm/jitinterface.cpp | 16 +++++++++++----- 1 file changed, 11 insertions(+), 5 deletions(-) diff --git a/src/coreclr/vm/jitinterface.cpp b/src/coreclr/vm/jitinterface.cpp index 5192cd703635a0..f8c94bce355a15 100644 --- a/src/coreclr/vm/jitinterface.cpp +++ b/src/coreclr/vm/jitinterface.cpp @@ -7823,25 +7823,31 @@ bool CEEInfo::haveSameMethodDefinition( CORINFO_CLASS_HANDLE CEEInfo::getTypeDefinition(CORINFO_CLASS_HANDLE type) { CONTRACTL { - THROWS; + NOTHROW; GC_TRIGGERS; MODE_PREEMPTIVE; } CONTRACTL_END; CORINFO_CLASS_HANDLE result = NULL; - JIT_TO_EE_TRANSITION(); + JIT_TO_EE_TRANSITION_LEAF(); TypeHandle constructedHandle(type); TypeHandle definitionHandle = ClassLoader::LoadTypeDefThrowing( constructedHandle.GetModule(), constructedHandle.GetMethodTable()->GetCl(), - ClassLoader::ThrowIfNotFound, - ClassLoader::PermitUninstDefOrRef); + ClassLoader::ReturnNullIfNotFound, + ClassLoader::PermitUninstDefOrRef, + /* tokenNotToLoad */ tdAllTypes); result = CORINFO_CLASS_HANDLE(definitionHandle.AsPtr()); - EE_TO_JIT_TRANSITION(); + JIT_TO_EE_TRANSITION_LEAF(); + + // We forbid loading new types here, and we expect the resulting types to + // always be available. That is because if we are trying to get the type + // definition of some 'Foo' type, then 'Foo<>' must also be loaded. + _ASSERTE(result != NULL); return result; } From 9d6ec4897b24a3cc26dcdf164fee708cda18c109 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Thu, 18 Jan 2024 16:23:45 +0100 Subject: [PATCH 04/23] Make Type.GetGenericTypeDefinition() an intrinsic --- src/coreclr/jit/compiler.h | 1 + src/coreclr/jit/fgbasic.cpp | 1 + src/coreclr/jit/importer.cpp | 21 +++++++++++++++++++ src/coreclr/jit/importercalls.cpp | 15 +++++++++++++ src/coreclr/jit/namedintrinsiclist.h | 1 + .../System.Private.CoreLib/src/System/Type.cs | 1 + 6 files changed, 40 insertions(+) diff --git a/src/coreclr/jit/compiler.h b/src/coreclr/jit/compiler.h index 7013184028a878..ce8cfe9f57f0d6 100644 --- a/src/coreclr/jit/compiler.h +++ b/src/coreclr/jit/compiler.h @@ -4589,6 +4589,7 @@ class Compiler #endif void impResetLeaveBlock(BasicBlock* block, unsigned jmpAddr); GenTree* impTypeIsAssignable(GenTree* typeTo, GenTree* typeFrom); + GenTree* impGetGenericTypeDefinition(GenTree* type); // Mirrors StringComparison.cs enum StringComparison diff --git a/src/coreclr/jit/fgbasic.cpp b/src/coreclr/jit/fgbasic.cpp index f2c0f458c10505..a2ef25e6a5f97c 100644 --- a/src/coreclr/jit/fgbasic.cpp +++ b/src/coreclr/jit/fgbasic.cpp @@ -1387,6 +1387,7 @@ void Compiler::fgFindJumpTargets(const BYTE* codeAddr, IL_OFFSET codeSize, Fixed case NI_System_Type_get_IsByRefLike: case NI_System_Type_get_IsGenericType: case NI_System_Type_GetTypeFromHandle: + case NI_System_Type_GetGenericTypeDefinition: case NI_System_String_get_Length: case NI_System_Buffers_Binary_BinaryPrimitives_ReverseEndianness: #if defined(FEATURE_HW_INTRINSICS) diff --git a/src/coreclr/jit/importer.cpp b/src/coreclr/jit/importer.cpp index ad0c4d2b902813..2f0c9bcf911d4d 100644 --- a/src/coreclr/jit/importer.cpp +++ b/src/coreclr/jit/importer.cpp @@ -2490,6 +2490,27 @@ GenTree* Compiler::impTypeIsAssignable(GenTree* typeTo, GenTree* typeFrom) return nullptr; } + +GenTree* Compiler::impGetGenericTypeDefinition(GenTree* type) +{ + // this intrinsic requires the first arg to be some `typeof()` expression, + // ie. it applies to cases such as `typeof(...).GetGenericTypeDefinition()`. + CORINFO_CLASS_HANDLE hClassType = NO_CLASS_HANDLE; + if (gtIsTypeof(type, &hClassType)) + { + CORINFO_CLASS_HANDLE hClassResult = info.compCompHnd->getTypeDefinition(hClassType); + + GenTree* retNode = gtNewIconEmbClsHndNode(hClassResult); + + // Drop the typeof(T) node + impPopStack(); + + return retNode; + } + + return nullptr; +} + /***************************************************************************** * 'logMsg' is true if a log message needs to be logged. false if the caller has * already logged it (presumably in a more detailed fashion than done here) diff --git a/src/coreclr/jit/importercalls.cpp b/src/coreclr/jit/importercalls.cpp index 322ce25ca96f8e..e8de998ebed2c4 100644 --- a/src/coreclr/jit/importercalls.cpp +++ b/src/coreclr/jit/importercalls.cpp @@ -3321,6 +3321,9 @@ GenTree* Compiler::impIntrinsic(CORINFO_CLASS_HANDLE clsHnd, case NI_System_Type_op_Equality: case NI_System_Type_op_Inequality: + // This allows folding "typeof(...).GetGenericTypeDefinition() == typeof(...)" + case NI_System_Type_GetGenericTypeDefinition: + // These may lead to early dead code elimination case NI_System_Type_get_IsValueType: case NI_System_Type_get_IsPrimitive: @@ -3856,6 +3859,14 @@ GenTree* Compiler::impIntrinsic(CORINFO_CLASS_HANDLE clsHnd, break; } + case NI_System_Type_GetGenericTypeDefinition: + { + GenTree* type = impStackTop(0).val; + + retNode = impGetGenericTypeDefinition(type); + break; + } + case NI_System_Type_op_Equality: case NI_System_Type_op_Inequality: { @@ -10220,6 +10231,10 @@ NamedIntrinsic Compiler::lookupNamedIntrinsic(CORINFO_METHOD_HANDLE method) { result = NI_System_Type_GetTypeFromHandle; } + else if (strcmp(methodName, "GetGenericTypeDefinition") == 0) + { + result = NI_System_Type_GetGenericTypeDefinition; + } else if (strcmp(methodName, "IsAssignableFrom") == 0) { result = NI_System_Type_IsAssignableFrom; diff --git a/src/coreclr/jit/namedintrinsiclist.h b/src/coreclr/jit/namedintrinsiclist.h index 93e4ce7893f98b..c4e8ceeee4d5ab 100644 --- a/src/coreclr/jit/namedintrinsiclist.h +++ b/src/coreclr/jit/namedintrinsiclist.h @@ -89,6 +89,7 @@ enum NamedIntrinsic : unsigned short NI_System_Type_op_Equality, NI_System_Type_op_Inequality, NI_System_Type_GetTypeFromHandle, + NI_System_Type_GetGenericTypeDefinition, NI_System_Array_Clone, NI_System_Array_GetLength, NI_System_Array_GetLowerBound, diff --git a/src/libraries/System.Private.CoreLib/src/System/Type.cs b/src/libraries/System.Private.CoreLib/src/System/Type.cs index 6c9185193dabf5..3437d8f377bd44 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Type.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Type.cs @@ -74,6 +74,7 @@ public bool IsInterface public virtual int GetArrayRank() => throw new NotSupportedException(SR.NotSupported_SubclassOverride); + [Intrinsic] public virtual Type GetGenericTypeDefinition() => throw new NotSupportedException(SR.NotSupported_SubclassOverride); public virtual Type[] GenericTypeArguments => (IsGenericType && !IsGenericTypeDefinition) ? GetGenericArguments() : EmptyTypes; public virtual Type[] GetGenericArguments() => throw new NotSupportedException(SR.NotSupported_SubclassOverride); From b5375052a32f18984f7f75b2f0f97fdff86f6781 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Thu, 18 Jan 2024 16:31:09 +0100 Subject: [PATCH 05/23] Add GetGenericTypeDefinition() intrinsic tests --- src/tests/JIT/Intrinsics/TypeIntrinsics.cs | 35 ++++++++++++++++++++++ 1 file changed, 35 insertions(+) diff --git a/src/tests/JIT/Intrinsics/TypeIntrinsics.cs b/src/tests/JIT/Intrinsics/TypeIntrinsics.cs index 3821f74bf18761..1376d8b020d416 100644 --- a/src/tests/JIT/Intrinsics/TypeIntrinsics.cs +++ b/src/tests/JIT/Intrinsics/TypeIntrinsics.cs @@ -134,6 +134,7 @@ public static int TestEntryPoint() IsPrimitiveTests(); IsGenericTypeTests(); + GetGenericTypeDefinitionTests(); return 100 + _errors; } @@ -276,6 +277,30 @@ private static void IsGenericTypeTests() IsTrue(new ClassUsingIsGenericTypeOnT().IsGenericTypeFromOtherGenericType()); } + private static void GetGenericTypeDefinitionTests() + { + AreEqual(typeof(GenericEnumClass).GetGenericTypeDefinition(), typeof(GenericEnumClass<>)); + AreEqual(typeof(GenericEnumClass<>).GetGenericTypeDefinition(), typeof(GenericEnumClass<>)); + AreEqual(typeof(IGenericInterface).GetGenericTypeDefinition(), typeof(IGenericInterface<>)); + AreEqual(typeof(IGenericInterface<>).GetGenericTypeDefinition(), typeof(IGenericInterface<>)); + AreEqual(typeof(GenericStruct).GetGenericTypeDefinition(), typeof(GenericStruct<>)); + AreEqual(typeof(GenericStruct<>).GetGenericTypeDefinition(), typeof(GenericStruct<>)); + AreEqual(typeof(SimpleEnum?).GetGenericTypeDefinition(), typeof(Nullable<>)); + AreEqual(typeof(int?).GetGenericTypeDefinition(), typeof(Nullable<>)); + AreEqual(typeof(IntPtr?).GetGenericTypeDefinition(), typeof(Nullable<>)); + AreEqual(typeof(Nullable<>).GetGenericTypeDefinition(), typeof(Nullable<>)); + AreEqual(typeof(KeyValuePair).GetGenericTypeDefinition(), typeof(KeyValuePair<,>)); + AreEqual(typeof(KeyValuePair<,>).GetGenericTypeDefinition(), typeof(KeyValuePair<,>)); + AreEqual(typeof(Dictionary).GetGenericTypeDefinition(), typeof(Dictionary<,>)); + AreEqual(typeof(Dictionary<,>).GetGenericTypeDefinition(), typeof(Dictionary<,>)); + AreEqual(typeof(List).GetGenericTypeDefinition(), typeof(List<>)); + AreEqual(typeof(List<>).GetGenericTypeDefinition(), typeof(List<>)); + AreEqual(typeof(Action<>).GetGenericTypeDefinition(), typeof(Action<>)); + AreEqual(typeof(Action).GetGenericTypeDefinition(), typeof(Action<>)); + AreEqual(typeof(Func).GetGenericTypeDefinition(), typeof(Func<,>)); + AreEqual(typeof(Func<,>).GetGenericTypeDefinition(), typeof(Func<,>)); + } + private static int _varInt = 42; private static int? _varNullableInt = 42; private static decimal _varDecimal = 42M; @@ -329,6 +354,16 @@ static void IsFalse(bool expression, [CallerLineNumber] int line = 0, [CallerFil } } + [MethodImpl(MethodImplOptions.NoInlining)] + static void AreEqual(Type left, Type right, [CallerLineNumber] int line = 0, [CallerFilePath] string file = "") + { + if (left != right) + { + Console.WriteLine($"{file}:L{line} test failed (expected: '{left}' to be equal to '{right}')."); + _errors++; + } + } + static void ThrowsNRE(Action action, [CallerLineNumber] int line = 0, [CallerFilePath] string file = "") { try From a02c9a1381fe01ab3a6ef41cdddf0f55714a0cfb Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Thu, 18 Jan 2024 19:01:05 +0100 Subject: [PATCH 06/23] Only expand intrinsic for generic types --- src/coreclr/inc/corinfo.h | 4 ++-- src/coreclr/jit/importer.cpp | 18 ++++++++++++------ 2 files changed, 14 insertions(+), 8 deletions(-) diff --git a/src/coreclr/inc/corinfo.h b/src/coreclr/inc/corinfo.h index 213d2601b93793..17891090e4c811 100644 --- a/src/coreclr/inc/corinfo.h +++ b/src/coreclr/inc/corinfo.h @@ -2093,8 +2093,8 @@ class ICorStaticInfo // // Remarks: // This is equivalent of Type.GetGenericTypeDefinition(). Given a generic type handle, it will - // return the original type definition (eg. for Foo it will return Foo<>). If the input - // type handle represents a type that is not generic, it will just return the same type. + // return the original type definition (eg. for Foo it will return Foo<>). This method + // should only be called when the input type is in fact a generic type. virtual CORINFO_CLASS_HANDLE getTypeDefinition(CORINFO_CLASS_HANDLE type) = 0; // Decides if you have any limitations for inlining. If everything's OK, it will return diff --git a/src/coreclr/jit/importer.cpp b/src/coreclr/jit/importer.cpp index 2f0c9bcf911d4d..62ac1abffce0cf 100644 --- a/src/coreclr/jit/importer.cpp +++ b/src/coreclr/jit/importer.cpp @@ -2493,19 +2493,25 @@ GenTree* Compiler::impTypeIsAssignable(GenTree* typeTo, GenTree* typeFrom) GenTree* Compiler::impGetGenericTypeDefinition(GenTree* type) { - // this intrinsic requires the first arg to be some `typeof()` expression, + // This intrinsic requires the first arg to be some `typeof()` expression, // ie. it applies to cases such as `typeof(...).GetGenericTypeDefinition()`. CORINFO_CLASS_HANDLE hClassType = NO_CLASS_HANDLE; if (gtIsTypeof(type, &hClassType)) { - CORINFO_CLASS_HANDLE hClassResult = info.compCompHnd->getTypeDefinition(hClassType); + // Check that the 'typeof()' expression is being used on a type that is in fact generic. + // If that is not the case, we don't expand the intrinsic. This will end up using + // the usual Type.GetGenericTypeDefinition() at runtime, which will throw in this case. + if (info.compCompHnd->getTypeInstantiationArgument(hClassType, 0) != NO_CLASS_HANDLE) + { + CORINFO_CLASS_HANDLE hClassResult = info.compCompHnd->getTypeDefinition(hClassType); - GenTree* retNode = gtNewIconEmbClsHndNode(hClassResult); + GenTree* retNode = gtNewIconEmbClsHndNode(hClassResult); - // Drop the typeof(T) node - impPopStack(); + // Drop the typeof(T) node + impPopStack(); - return retNode; + return retNode; + } } return nullptr; From 23f8ebccbca7c35ec2a21b73c6e75b22220044bd Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Thu, 18 Jan 2024 19:04:04 +0100 Subject: [PATCH 07/23] Use normal JIT_TO_EE transition --- src/coreclr/vm/jitinterface.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/coreclr/vm/jitinterface.cpp b/src/coreclr/vm/jitinterface.cpp index f8c94bce355a15..e79bba81aadc4a 100644 --- a/src/coreclr/vm/jitinterface.cpp +++ b/src/coreclr/vm/jitinterface.cpp @@ -7830,7 +7830,7 @@ CORINFO_CLASS_HANDLE CEEInfo::getTypeDefinition(CORINFO_CLASS_HANDLE type) CORINFO_CLASS_HANDLE result = NULL; - JIT_TO_EE_TRANSITION_LEAF(); + JIT_TO_EE_TRANSITION(); TypeHandle constructedHandle(type); TypeHandle definitionHandle = ClassLoader::LoadTypeDefThrowing( @@ -7842,7 +7842,7 @@ CORINFO_CLASS_HANDLE CEEInfo::getTypeDefinition(CORINFO_CLASS_HANDLE type) result = CORINFO_CLASS_HANDLE(definitionHandle.AsPtr()); - JIT_TO_EE_TRANSITION_LEAF(); + JIT_TO_EE_TRANSITION(); // We forbid loading new types here, and we expect the resulting types to // always be available. That is because if we are trying to get the type From d6a925d36ac71b230164154ae22fb94dc0267c94 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Thu, 18 Jan 2024 20:01:47 +0100 Subject: [PATCH 08/23] Apply review suggestions for CEEInfo::getTypeDefinition --- src/coreclr/vm/jitinterface.cpp | 13 ++++++------- 1 file changed, 6 insertions(+), 7 deletions(-) diff --git a/src/coreclr/vm/jitinterface.cpp b/src/coreclr/vm/jitinterface.cpp index e79bba81aadc4a..e1ab5d2362002c 100644 --- a/src/coreclr/vm/jitinterface.cpp +++ b/src/coreclr/vm/jitinterface.cpp @@ -7823,7 +7823,7 @@ bool CEEInfo::haveSameMethodDefinition( CORINFO_CLASS_HANDLE CEEInfo::getTypeDefinition(CORINFO_CLASS_HANDLE type) { CONTRACTL { - NOTHROW; + THROWS; GC_TRIGGERS; MODE_PREEMPTIVE; } CONTRACTL_END; @@ -7833,20 +7833,19 @@ CORINFO_CLASS_HANDLE CEEInfo::getTypeDefinition(CORINFO_CLASS_HANDLE type) JIT_TO_EE_TRANSITION(); TypeHandle constructedHandle(type); + + _ASSERTE(constructedHandle.HasInstantiation()); + TypeHandle definitionHandle = ClassLoader::LoadTypeDefThrowing( constructedHandle.GetModule(), constructedHandle.GetMethodTable()->GetCl(), - ClassLoader::ReturnNullIfNotFound, - ClassLoader::PermitUninstDefOrRef, - /* tokenNotToLoad */ tdAllTypes); + ClassLoader::ThrowIfNotFound, + ClassLoader::PermitUninstDefOrRef); result = CORINFO_CLASS_HANDLE(definitionHandle.AsPtr()); JIT_TO_EE_TRANSITION(); - // We forbid loading new types here, and we expect the resulting types to - // always be available. That is because if we are trying to get the type - // definition of some 'Foo' type, then 'Foo<>' must also be loaded. _ASSERTE(result != NULL); return result; From cf937db45f9fad3ac33b5f9e5e9264d6222f7138 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Thu, 18 Jan 2024 20:29:02 +0100 Subject: [PATCH 09/23] Implement managed version of getTypeDefinition --- src/coreclr/tools/Common/JitInterface/CorInfoImpl.cs | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/coreclr/tools/Common/JitInterface/CorInfoImpl.cs b/src/coreclr/tools/Common/JitInterface/CorInfoImpl.cs index 27a55a64149101..0033a758669307 100644 --- a/src/coreclr/tools/Common/JitInterface/CorInfoImpl.cs +++ b/src/coreclr/tools/Common/JitInterface/CorInfoImpl.cs @@ -1248,6 +1248,11 @@ private bool haveSameMethodDefinition(CORINFO_METHOD_STRUCT_* methHnd1, CORINFO_ return meth1.GetTypicalMethodDefinition() == meth2.GetTypicalMethodDefinition(); } + private CORINFO_CLASS_STRUCT_* getTypeDefinition(CORINFO_CLASS_STRUCT_* type) + { + return ObjectToHandle(HandleToObject(type).GetTypeDefinition()); + } + private CorInfoInline canInline(CORINFO_METHOD_STRUCT_* callerHnd, CORINFO_METHOD_STRUCT_* calleeHnd) { MethodDesc callerMethod = HandleToObject(callerHnd); From 98952fcf1328cbfae13948dd7e617b5029bd6187 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Thu, 18 Jan 2024 20:52:31 +0100 Subject: [PATCH 10/23] Fix EE_TO_JIT transition --- src/coreclr/vm/jitinterface.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/coreclr/vm/jitinterface.cpp b/src/coreclr/vm/jitinterface.cpp index e1ab5d2362002c..de70b4ed21628e 100644 --- a/src/coreclr/vm/jitinterface.cpp +++ b/src/coreclr/vm/jitinterface.cpp @@ -7844,7 +7844,7 @@ CORINFO_CLASS_HANDLE CEEInfo::getTypeDefinition(CORINFO_CLASS_HANDLE type) result = CORINFO_CLASS_HANDLE(definitionHandle.AsPtr()); - JIT_TO_EE_TRANSITION(); + EE_TO_JIT_TRANSITION(); _ASSERTE(result != NULL); From f65d626a96b51044884213f87f11d729c867b698 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Mon, 11 Mar 2024 15:12:04 -0700 Subject: [PATCH 11/23] Implement missing superPMI methods --- .../tools/superpmi/superpmi-shared/lwmlist.h | 1 + .../superpmi-shared/methodcontext.cpp | 23 +++++++++++++++++++ .../superpmi/superpmi-shared/methodcontext.h | 5 ++++ .../superpmi-shim-collector/icorjitinfo.cpp | 9 ++++++++ .../tools/superpmi/superpmi/icorjitinfo.cpp | 8 +++++++ 5 files changed, 46 insertions(+) diff --git a/src/coreclr/tools/superpmi/superpmi-shared/lwmlist.h b/src/coreclr/tools/superpmi/superpmi-shared/lwmlist.h index eb4968fbb44880..236bb4181ce5c3 100644 --- a/src/coreclr/tools/superpmi/superpmi-shared/lwmlist.h +++ b/src/coreclr/tools/superpmi/superpmi-shared/lwmlist.h @@ -110,6 +110,7 @@ LWM(GetMethodDefFromMethod, DWORDLONG, DWORD) LWM(GetMethodHash, DWORDLONG, DWORD) LWM(GetMethodInfo, DLDL, Agnostic_GetMethodInfo) LWM(HaveSameMethodDefinition, DLDL, DWORD) +LWM(GetTypeDefinition, DWORDLONG, DWORDLONG) LWM(GetMethodNameFromMetadata, Agnostic_CORINFO_METHODNAME_TOKENin, Agnostic_CORINFO_METHODNAME_TOKENout) LWM(GetMethodSig, DLDL, Agnostic_CORINFO_SIG_INFO) LWM(GetMethodSync, DWORDLONG, DLDL) diff --git a/src/coreclr/tools/superpmi/superpmi-shared/methodcontext.cpp b/src/coreclr/tools/superpmi/superpmi-shared/methodcontext.cpp index e818afbac539c9..066a6fac585bb6 100644 --- a/src/coreclr/tools/superpmi/superpmi-shared/methodcontext.cpp +++ b/src/coreclr/tools/superpmi/superpmi-shared/methodcontext.cpp @@ -3094,6 +3094,29 @@ bool MethodContext::repHaveSameMethodDefinition(CORINFO_METHOD_HANDLE methHnd1, return value != 0; } +void MethodContext::recGetTypeDefinition(CORINFO_CLASS_HANDLE cls, CORINFO_CLASS_HANDLE result) +{ + if (GetTypeDefinition == nullptr) + GetTypeDefinition = new LightWeightMap(); + + DWORDLONG key = CastHandle(cls); + DWORDLONG value = CastHandle(result); + GetTypeDefinition->Add(key, value); + DEBUG_REC(dmpGetTypeDefinition(key, value)); +} +void MethodContext::dmpGetTypeDefinition(DWORDLONG key, DWORDLONG value) +{ + printf("GetTypeDefinition key cls-%016" PRIX64 ", value cls-%016" PRIX64 "", key, value); +} +CORINFO_CLASS_HANDLE MethodContext::repGetTypeDefinition(CORINFO_CLASS_HANDLE cls) +{ + DWORDLONG key = CastHandle(cls); + DWORDLONG value = LookupByKeyOrMiss(GetTypeDefinition, key, ": key %016" PRIX64 "", key); + DEBUG_REP(dmpGetTypeDefinition(key, value)); + CORINFO_CLASS_HANDLE result = (CORINFO_CLASS_HANDLE)value; + return result; +} + void MethodContext::recGetNewHelper(CORINFO_CLASS_HANDLE classHandle, bool hasSideEffects, CorInfoHelpFunc result, diff --git a/src/coreclr/tools/superpmi/superpmi-shared/methodcontext.h b/src/coreclr/tools/superpmi/superpmi-shared/methodcontext.h index 669455c729939f..408203e64c9106 100644 --- a/src/coreclr/tools/superpmi/superpmi-shared/methodcontext.h +++ b/src/coreclr/tools/superpmi/superpmi-shared/methodcontext.h @@ -422,6 +422,10 @@ class MethodContext void dmpHaveSameMethodDefinition(const DLDL& key, DWORD value); bool repHaveSameMethodDefinition(CORINFO_METHOD_HANDLE methHnd1, CORINFO_METHOD_HANDLE methHnd2); + void recGetTypeDefinition(CORINFO_CLASS_HANDLE type, CORINFO_CLASS_HANDLE result); + void dmpGetTypeDefinition(DWORDLONG key, DWORDLONG value); + CORINFO_CLASS_HANDLE repGetTypeDefinition(CORINFO_CLASS_HANDLE type); + void recGetNewHelper(CORINFO_CLASS_HANDLE classHandle, bool hasSideEffects, CorInfoHelpFunc result, @@ -1185,6 +1189,7 @@ enum mcPackets Packet_GetClassThreadStaticDynamicInfo = 219, Packet_IsGenericType = 220, Packet_GetTypeForBoxOnStack = 221, + Packet_GetTypeDefinition = 222, }; void SetDebugDumpVariables(); diff --git a/src/coreclr/tools/superpmi/superpmi-shim-collector/icorjitinfo.cpp b/src/coreclr/tools/superpmi/superpmi-shim-collector/icorjitinfo.cpp index 77def3e6276ae5..24495dbaa17346 100644 --- a/src/coreclr/tools/superpmi/superpmi-shim-collector/icorjitinfo.cpp +++ b/src/coreclr/tools/superpmi/superpmi-shim-collector/icorjitinfo.cpp @@ -107,6 +107,15 @@ bool interceptor_ICJI::haveSameMethodDefinition( return result; } +CORINFO_CLASS_HANDLE interceptor_ICJI::getTypeDefinition( + CORINFO_CLASS_HANDLE type) +{ + CORINFO_CLASS_HANDLE result = original_ICorJitInfo->getTypeDefinition(type); + mc->recGetTypeDefinition(type, result); + + return result; +} + // Decides if you have any limitations for inlining. If everything's OK, it will return // INLINE_PASS. // diff --git a/src/coreclr/tools/superpmi/superpmi/icorjitinfo.cpp b/src/coreclr/tools/superpmi/superpmi/icorjitinfo.cpp index 1ec06bedca508e..370d99ecad912a 100644 --- a/src/coreclr/tools/superpmi/superpmi/icorjitinfo.cpp +++ b/src/coreclr/tools/superpmi/superpmi/icorjitinfo.cpp @@ -96,6 +96,14 @@ bool MyICJI::haveSameMethodDefinition( return value; } +CORINFO_CLASS_HANDLE MyICJI::getTypeDefinition( + CORINFO_CLASS_HANDLE type) +{ + jitInstance->mc->cr->AddCall("getTypeDefinition"); + CORINFO_CLASS_HANDLE value = jitInstance->mc->repGetTypeDefinition(type); + return value; +} + // Decides if you have any limitations for inlining. If everything's OK, it will return // INLINE_PASS. // From cfad15d453e51dfa6320ba6e69a01908621b7b67 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Sun, 16 Jun 2024 12:32:54 -0700 Subject: [PATCH 12/23] Remove extra blank line --- src/coreclr/jit/importer.cpp | 1 - 1 file changed, 1 deletion(-) diff --git a/src/coreclr/jit/importer.cpp b/src/coreclr/jit/importer.cpp index 62ac1abffce0cf..e35bdcb8029f2b 100644 --- a/src/coreclr/jit/importer.cpp +++ b/src/coreclr/jit/importer.cpp @@ -2490,7 +2490,6 @@ GenTree* Compiler::impTypeIsAssignable(GenTree* typeTo, GenTree* typeFrom) return nullptr; } - GenTree* Compiler::impGetGenericTypeDefinition(GenTree* type) { // This intrinsic requires the first arg to be some `typeof()` expression, From f3b54026312ea3ca239e5bae22973805cbf8603d Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Sun, 16 Jun 2024 13:52:56 -0700 Subject: [PATCH 13/23] Add missing handle -> 'Type' conversion --- src/coreclr/jit/importer.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/coreclr/jit/importer.cpp b/src/coreclr/jit/importer.cpp index e35bdcb8029f2b..def691cc4e850e 100644 --- a/src/coreclr/jit/importer.cpp +++ b/src/coreclr/jit/importer.cpp @@ -2504,7 +2504,8 @@ GenTree* Compiler::impGetGenericTypeDefinition(GenTree* type) { CORINFO_CLASS_HANDLE hClassResult = info.compCompHnd->getTypeDefinition(hClassType); - GenTree* retNode = gtNewIconEmbClsHndNode(hClassResult); + GenTree* handle = gtNewIconEmbClsHndNode(hClassResult); + GenTree* retNode = gtNewHelperCallNode(CORINFO_HELP_TYPEHANDLE_TO_RUNTIMETYPE, TYP_REF, handle); // Drop the typeof(T) node impPopStack(); From b44805d395e2e5bb85551179798646fef60e6595 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Sun, 16 Jun 2024 19:37:36 -0700 Subject: [PATCH 14/23] Add '__Canon' tests as well --- src/tests/JIT/Intrinsics/TypeIntrinsics.cs | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/src/tests/JIT/Intrinsics/TypeIntrinsics.cs b/src/tests/JIT/Intrinsics/TypeIntrinsics.cs index 1376d8b020d416..9f58aa356b44ad 100644 --- a/src/tests/JIT/Intrinsics/TypeIntrinsics.cs +++ b/src/tests/JIT/Intrinsics/TypeIntrinsics.cs @@ -299,6 +299,15 @@ private static void GetGenericTypeDefinitionTests() AreEqual(typeof(Action).GetGenericTypeDefinition(), typeof(Action<>)); AreEqual(typeof(Func).GetGenericTypeDefinition(), typeof(Func<,>)); AreEqual(typeof(Func<,>).GetGenericTypeDefinition(), typeof(Func<,>)); + + // Test for __Canon + AreEqual(GetGenericTypeDefinition>(), typeof(GenericEnumClass<>)); + AreEqual(GetGenericTypeDefinition>(), typeof(IGenericInterface<>)); + AreEqual(GetGenericTypeDefinition>(), typeof(GenericStruct<>)); + AreEqual(GetGenericTypeDefinition>(), typeof(Dictionary<,>)); + AreEqual(GetGenericTypeDefinition>(), typeof(List<>)); + AreEqual(GetGenericTypeDefinition>(), typeof(Action<>)); + AreEqual(GetGenericTypeDefinition>(), typeof(Func<,>)); } private static int _varInt = 42; @@ -334,6 +343,9 @@ private static void GetGenericTypeDefinitionTests() [MethodImpl(MethodImplOptions.NoInlining)] private static dynamic CreateDynamic2() => new { Name = "Test" }; + [MethodImpl(MethodImplOptions.NoInlining)] + private static Type GetGenericTypeDefinition() => typeof(T).GetGenericTypeDefinition(); + [MethodImpl(MethodImplOptions.NoInlining)] static void IsTrue(bool expression, [CallerLineNumber] int line = 0, [CallerFilePath] string file = "") { From 447f949d1516a8a508b30927e2f6532616720767 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Sun, 16 Jun 2024 19:41:03 -0700 Subject: [PATCH 15/23] Add tests for failure cases as well --- src/tests/JIT/Intrinsics/TypeIntrinsics.cs | 26 ++++++++++++++++++++++ 1 file changed, 26 insertions(+) diff --git a/src/tests/JIT/Intrinsics/TypeIntrinsics.cs b/src/tests/JIT/Intrinsics/TypeIntrinsics.cs index 9f58aa356b44ad..1418f7328e1b20 100644 --- a/src/tests/JIT/Intrinsics/TypeIntrinsics.cs +++ b/src/tests/JIT/Intrinsics/TypeIntrinsics.cs @@ -308,6 +308,11 @@ private static void GetGenericTypeDefinitionTests() AreEqual(GetGenericTypeDefinition>(), typeof(List<>)); AreEqual(GetGenericTypeDefinition>(), typeof(Action<>)); AreEqual(GetGenericTypeDefinition>(), typeof(Func<,>)); + + // Test for failures + GetGenericTypeDefinitionThrows(); + GetGenericTypeDefinitionThrows(); + GetGenericTypeDefinitionThrows