Remove Helper Method Frames (HMF) from Reflection (#110627)

AaronRobinsonMSFT · web-flow · commit e78ee77456c9 · 2024-12-16T19:09:35.000-08:00
Convert Signature.GetSignature() to QCall.
Rename Signature.GetSignature() to Signature.Init().
Remove HMF from Signature.GetTypeParameterOffset().
Remove HMF from Signature.GetCallingConventionFromFunctionPointerAtOffset().
Convert Signature.GetCustomModifiersAtOffset() to QCall.
Convert RuntimeTypeHandle.GetDeclaringMethodForGenericParameter() to QCall.
Rename RuntimeTypeHandle.GetDeclaringMethod() to RuntimeTypeHandle.GetDeclaringMethodForGenericParameter().
Convert RuntimeTypeHandle.CanCastTo() to slow/fast paths using FCall/QCall.
Remove HMF from RuntimeMethodHandle::GetMethodDef().
Convert RuntimeMethodHandle.GetStubIfNeeded() to fast/slow paths using FCall/QCall.
Convert RuntimeTypeHandle.SatisfiesConstraints() to QCall.
Convert RuntimeMethodHandle.GetMethodBody() to QCall.
diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/CastHelpers.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/CastHelpers.cs
@@ -539,7 +539,7 @@ private static bool AreTypesEquivalent(MethodTable* pMTa, MethodTable* pMTb)
 
         [DebuggerHidden]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static bool IsNullableForType(MethodTable* typeMT, MethodTable* boxedMT)
+        internal static bool IsNullableForType(MethodTable* typeMT, MethodTable* boxedMT)
         {
             if (!typeMT->IsNullable)
             {
diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/RuntimeHelpers.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/RuntimeHelpers.CoreCLR.cs
@@ -1098,28 +1098,64 @@ public static TypeHandle TypeHandleOf<T>()
 
         public static bool AreSameType(TypeHandle left, TypeHandle right) => left.m_asTAddr == right.m_asTAddr;
 
+        public int GetCorElementType() => GetCorElementType(m_asTAddr);
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public bool CanCastTo(TypeHandle destTH)
         {
-            if (m_asTAddr == destTH.m_asTAddr)
-                return true;
+            return TryCanCastTo(this, destTH) switch
+            {
+                CastResult.CanCast => true,
+                CastResult.CannotCast => false,
 
-            if (!IsTypeDesc && destTH.IsTypeDesc)
-                return false;
+                // Regular casting does not allow T to be cast to Nullable<T>.
+                // See TypeHandle::CanCastTo()
+                _ => CanCastToWorker(this, destTH, nullableCast: false)
+            };
+        }
 
-            CastResult result = CastCache.TryGet(CastHelpers.s_table!, (nuint)m_asTAddr, (nuint)destTH.m_asTAddr);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool CanCastToForReflection(TypeHandle srcTH, TypeHandle destTH)
+        {
+            return TryCanCastTo(srcTH, destTH) switch
+            {
+                CastResult.CanCast => true,
+                CastResult.CannotCast => false,
 
-            if (result != CastResult.MaybeCast)
-                return result == CastResult.CanCast;
+                 // Reflection allows T to be cast to Nullable<T>.
+                 // See ObjIsInstanceOfCore()
+                _ => CanCastToWorker(srcTH, destTH, nullableCast: true)
+            };
+        }
 
-            return CanCastTo_NoCacheLookup(m_asTAddr, destTH.m_asTAddr);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static CastResult TryCanCastTo(TypeHandle srcTH, TypeHandle destTH)
+        {
+            // See TypeHandle::CanCastToCached() for duplicate quick checks.
+            if (srcTH.m_asTAddr == destTH.m_asTAddr)
+                return CastResult.CanCast;
+
+            if (!srcTH.IsTypeDesc && destTH.IsTypeDesc)
+                return CastResult.CannotCast;
+
+            return CastCache.TryGet(CastHelpers.s_table!, (nuint)srcTH.m_asTAddr, (nuint)destTH.m_asTAddr);
         }
 
-        public int GetCorElementType() => GetCorElementType(m_asTAddr);
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        private static bool CanCastToWorker(TypeHandle srcTH, TypeHandle destTH, bool nullableCast)
+        {
+            if (!srcTH.IsTypeDesc
+                && !destTH.IsTypeDesc
+                && CastHelpers.IsNullableForType(destTH.AsMethodTable(), srcTH.AsMethodTable()))
+            {
+                return nullableCast;
+            }
+
+            return CanCastTo_NoCacheLookup(srcTH.m_asTAddr, destTH.m_asTAddr) != Interop.BOOL.FALSE;
+        }
 
         [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeHandle_CanCastTo_NoCacheLookup")]
-        [return: MarshalAs(UnmanagedType.Bool)]
-        private static partial bool CanCastTo_NoCacheLookup(void* fromTypeHnd, void* toTypeHnd);
+        private static partial Interop.BOOL CanCastTo_NoCacheLookup(void* fromTypeHnd, void* toTypeHnd);
 
         [SuppressGCTransition]
         [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeHandle_GetCorElementType")]
diff --git a/src/coreclr/System.Private.CoreLib/src/System/RuntimeHandles.cs b/src/coreclr/System.Private.CoreLib/src/System/RuntimeHandles.cs
diff --git a/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CoreCLR.cs
@@ -2011,29 +2011,23 @@ private static RuntimePropertyInfo GetPropertyInfo(RuntimeType reflectedType, in
 
         internal static void ValidateGenericArguments(MemberInfo definition, RuntimeType[] genericArguments, Exception? e)
         {
-            RuntimeType[]? typeContext = null;
-            RuntimeType[]? methodContext = null;
+            RuntimeType? typeContext;
+            RuntimeMethodInfo? methodContext = null;
             RuntimeType[] genericParameters;
 
             if (definition is Type)
             {
-                RuntimeType genericTypeDefinition = (RuntimeType)definition;
-                genericParameters = genericTypeDefinition.GetGenericArgumentsInternal();
-                typeContext = genericArguments;
+                typeContext = (RuntimeType)definition;
+                genericParameters = typeContext.GetGenericArgumentsInternal();
             }
             else
             {
-                RuntimeMethodInfo genericMethodDefinition = (RuntimeMethodInfo)definition;
-                genericParameters = genericMethodDefinition.GetGenericArgumentsInternal();
-                methodContext = genericArguments;
-
-                RuntimeType? declaringType = (RuntimeType?)genericMethodDefinition.DeclaringType;
-                if (declaringType != null)
-                {
-                    typeContext = declaringType.TypeHandle.GetInstantiationInternal();
-                }
+                methodContext = (RuntimeMethodInfo)definition;
+                typeContext = (RuntimeType?)methodContext.DeclaringType;
+                genericParameters = methodContext.GetGenericArgumentsInternal();
             }
 
+            Debug.Assert(genericArguments.Length == genericParameters.Length);
             for (int i = 0; i < genericArguments.Length; i++)
             {
                 Type genericArgument = genericArguments[i];
@@ -3276,8 +3270,7 @@ public override MethodBase? DeclaringMethod
                 if (!IsGenericParameter)
                     throw new InvalidOperationException(SR.Arg_NotGenericParameter);
 
-                IRuntimeMethodInfo declaringMethod = RuntimeTypeHandle.GetDeclaringMethod(this);
-
+                IRuntimeMethodInfo? declaringMethod = RuntimeTypeHandle.GetDeclaringMethodForGenericParameter(this);
                 if (declaringMethod == null)
                     return null;
 
diff --git a/src/coreclr/vm/assemblynative.cpp b/src/coreclr/vm/assemblynative.cpp
@@ -1089,7 +1089,7 @@ extern "C" void QCALLTYPE AssemblyNative_GetEntryPoint(QCall::AssemblyHandle pAs
     if (pMeth != NULL)
     {
         GCX_COOP();
-        retMethod.Set(pMeth->GetStubMethodInfo());
+        retMethod.Set(pMeth->AllocateStubMethodInfo());
     }
 
     END_QCALL;
diff --git a/src/coreclr/vm/comdelegate.cpp b/src/coreclr/vm/comdelegate.cpp
@@ -2127,7 +2127,7 @@ extern "C" void QCALLTYPE Delegate_FindMethodHandle(QCall::ObjectHandleOnStack d
 
     MethodDesc* pMD = COMDelegate::GetMethodDesc(d.Get());
     pMD = MethodDesc::FindOrCreateAssociatedMethodDescForReflection(pMD, TypeHandle(pMD->GetMethodTable()), pMD->GetMethodInstantiation());
-    retMethodInfo.Set(pMD->GetStubMethodInfo());
+    retMethodInfo.Set(pMD->AllocateStubMethodInfo());
 
     END_QCALL;
 }
diff --git a/src/coreclr/vm/comutilnative.cpp b/src/coreclr/vm/comutilnative.cpp
@@ -445,7 +445,7 @@ extern "C" void QCALLTYPE ExceptionNative_GetMethodFromStackTrace(QCall::ObjectH
     // The managed stack trace classes always return typical method definition,
     // so we don't need to bother providing exact instantiation.
     MethodDesc* pMDTypical = pMD->LoadTypicalMethodDefinition();
-    retMethodInfo.Set(pMDTypical->GetStubMethodInfo());
+    retMethodInfo.Set(pMDTypical->AllocateStubMethodInfo());
     _ASSERTE(pMDTypical->IsRuntimeMethodHandle());
 
     END_QCALL;
@@ -1861,11 +1861,6 @@ extern "C" BOOL QCALLTYPE TypeHandle_CanCastTo_NoCacheLookup(void* fromTypeHnd,
     {
         ret = fromTH.AsTypeDesc()->CanCastTo(toTH, NULL);
     }
-    else if (Nullable::IsNullableForType(toTH, fromTH.AsMethodTable()))
-    {
-        // do not allow type T to be cast to Nullable<T>
-        ret = FALSE;
-    }
     else
     {
         ret = fromTH.AsMethodTable()->CanCastTo(toTH.AsMethodTable(), NULL);
diff --git a/src/coreclr/vm/corelib.h b/src/coreclr/vm/corelib.h
@@ -137,6 +137,7 @@ DEFINE_METHOD(ASSEMBLY,             CTOR,                   .ctor,
 DEFINE_CLASS(ASYNCCALLBACK,         System,                 AsyncCallback)
 DEFINE_CLASS(ATTRIBUTE,             System,                 Attribute)
 
+DEFINE_CLASS_U(System,              Signature,          SignatureNative)
 
 DEFINE_CLASS(BINDER,                Reflection,             Binder)
 
@@ -182,7 +183,7 @@ DEFINE_METHOD(COM_OBJECT,           RELEASE_ALL_DATA,       ReleaseAllData,
 DEFINE_METHOD(COM_OBJECT,           GET_EVENT_PROVIDER,     GetEventProvider,           IM_Class_RetObj)
 #ifdef FOR_ILLINK
 DEFINE_METHOD(COM_OBJECT,           CTOR,                   .ctor,                      IM_RetVoid)
-#endif
+#endif // FOR_ILLINK
 
 DEFINE_CLASS(LICENSE_INTEROP_PROXY,  InternalInteropServices, LicenseInteropProxy)
 DEFINE_METHOD(LICENSE_INTEROP_PROXY, CREATE,                  Create,                  SM_RetObj)
@@ -358,9 +359,9 @@ DEFINE_FIELD(RT_FIELD_INFO,         HANDLE,                 m_fieldHandle)
 DEFINE_CLASS_U(System,              RuntimeFieldInfoStub,   ReflectFieldObject)
 DEFINE_FIELD_U(m_fieldHandle,       ReflectFieldObject,     m_pFD)
 DEFINE_CLASS(STUBFIELDINFO,         System,                 RuntimeFieldInfoStub)
-#if FOR_ILLINK
+#ifdef FOR_ILLINK
 DEFINE_METHOD(STUBFIELDINFO,        CTOR,                   .ctor,                      IM_RetVoid)
-#endif
+#endif // FOR_ILLINK
 
 DEFINE_CLASS(FIELD,                 Reflection,             RuntimeFieldInfo)
 
@@ -497,18 +498,18 @@ DEFINE_FIELD_U(_handlerLength,         RuntimeExceptionHandlingClause,        _h
 DEFINE_FIELD_U(_catchMetadataToken,    RuntimeExceptionHandlingClause,        _catchToken)
 DEFINE_FIELD_U(_filterOffset,          RuntimeExceptionHandlingClause,        _filterOffset)
 DEFINE_CLASS(RUNTIME_EH_CLAUSE,             Reflection,             RuntimeExceptionHandlingClause)
-#if FOR_ILLINK
+#ifdef FOR_ILLINK
 DEFINE_METHOD(RUNTIME_EH_CLAUSE,            CTOR,                   .ctor,              IM_RetVoid)
-#endif
+#endif // FOR_ILLINK
 
 DEFINE_CLASS_U(Reflection,             RuntimeLocalVariableInfo,        RuntimeLocalVariableInfo)
 DEFINE_FIELD_U(_type,                  RuntimeLocalVariableInfo,        _type)
 DEFINE_FIELD_U(_localIndex,            RuntimeLocalVariableInfo,        _localIndex)
 DEFINE_FIELD_U(_isPinned,              RuntimeLocalVariableInfo,        _isPinned)
 DEFINE_CLASS(RUNTIME_LOCAL_VARIABLE_INFO,   Reflection,             RuntimeLocalVariableInfo)
-#if FOR_ILLINK
+#ifdef FOR_ILLINK
 DEFINE_METHOD(RUNTIME_LOCAL_VARIABLE_INFO,  CTOR,                   .ctor,              IM_RetVoid)
-#endif
+#endif // FOR_ILLINK
 
 DEFINE_CLASS_U(Reflection,             RuntimeMethodBody,           RuntimeMethodBody)
 DEFINE_FIELD_U(_IL,                    RuntimeMethodBody,         _IL)
@@ -518,7 +519,11 @@ DEFINE_FIELD_U(_methodBase,               RuntimeMethodBody,         _methodBase
 DEFINE_FIELD_U(_localSignatureMetadataToken, RuntimeMethodBody,      _localVarSigToken)
 DEFINE_FIELD_U(_maxStackSize,             RuntimeMethodBody,         _maxStackSize)
 DEFINE_FIELD_U(_initLocals,               RuntimeMethodBody,         _initLocals)
-DEFINE_CLASS(RUNTIME_METHOD_BODY,           Reflection,             RuntimeMethodBody)
+
+DEFINE_CLASS(RUNTIME_METHOD_BODY,   Reflection, RuntimeMethodBody)
+#ifdef FOR_ILLINK
+DEFINE_METHOD(RUNTIME_METHOD_BODY,  CTOR,   .ctor,  IM_RetVoid)
+#endif // FOR_ILLINK
 
 DEFINE_CLASS(METHOD_INFO,           Reflection,             MethodInfo)
 
diff --git a/src/coreclr/vm/ecalllist.h b/src/coreclr/vm/ecalllist.h
@@ -82,7 +82,6 @@ FCFuncStart(gExceptionFuncs)
 FCFuncEnd()
 
 FCFuncStart(gCOMTypeHandleFuncs)
-    FCFuncElement("GetDeclaringMethod", RuntimeTypeHandle::GetDeclaringMethod)
     FCFuncElement("GetFirstIntroducedMethod", RuntimeTypeHandle::GetFirstIntroducedMethod)
     FCFuncElement("GetNextIntroducedMethod", RuntimeTypeHandle::GetNextIntroducedMethod)
     FCFuncElement("GetAssemblyIfExists", RuntimeTypeHandle::GetAssemblyIfExists)
@@ -93,11 +92,9 @@ FCFuncStart(gCOMTypeHandleFuncs)
     FCFuncElement("GetUtf8NameInternal", RuntimeTypeHandle::GetUtf8Name)
     FCFuncElement("GetAttributes", RuntimeTypeHandle::GetAttributes)
     FCFuncElement("GetNumVirtuals", RuntimeTypeHandle::GetNumVirtuals)
-    FCFuncElement("CanCastTo", RuntimeTypeHandle::CanCastTo)
     FCFuncElement("GetGenericVariableIndex", RuntimeTypeHandle::GetGenericVariableIndex)
     FCFuncElement("IsGenericVariable", RuntimeTypeHandle::IsGenericVariable)
     FCFuncElement("ContainsGenericVariables", RuntimeTypeHandle::ContainsGenericVariables)
-    FCFuncElement("SatisfiesConstraints", RuntimeTypeHandle::SatisfiesConstraints)
     FCFuncElement("IsUnmanagedFunctionPointer", RuntimeTypeHandle::IsUnmanagedFunctionPointer)
     FCFuncElement("CompareCanonicalHandles", RuntimeTypeHandle::CompareCanonicalHandles)
     FCFuncElement("GetRuntimeTypeFromHandleIfExists", RuntimeTypeHandle::GetRuntimeTypeFromHandleIfExists)
@@ -132,11 +129,9 @@ FCFuncStart(gMetaDataImport)
 FCFuncEnd()
 
 FCFuncStart(gSignatureNative)
-    FCFuncElement("GetSignature", SignatureNative::GetSignature)
     FCFuncElement("GetParameterOffsetInternal", SignatureNative::GetParameterOffsetInternal)
-    FCFuncElement("GetTypeParameterOffset", SignatureNative::GetTypeParameterOffset)
-    FCFuncElement("GetCustomModifiersAtOffset", SignatureNative::GetCustomModifiersAtOffset)
-    FCFuncElement("GetCallingConventionFromFunctionPointerAtOffset", SignatureNative::GetCallingConventionFromFunctionPointerAtOffset)
+    FCFuncElement("GetTypeParameterOffsetInternal", SignatureNative::GetTypeParameterOffsetInternal)
+    FCFuncElement("GetCallingConventionFromFunctionPointerAtOffsetInternal", SignatureNative::GetCallingConventionFromFunctionPointerAtOffsetInternal)
 FCFuncEnd()
 
 FCFuncStart(gRuntimeMethodHandle)
@@ -150,10 +145,9 @@ FCFuncStart(gRuntimeMethodHandle)
     FCFuncElement("IsGenericMethodDefinition", RuntimeMethodHandle::IsGenericMethodDefinition)
     FCFuncElement("GetGenericParameterCount", RuntimeMethodHandle::GetGenericParameterCount)
     FCFuncElement("IsTypicalMethodDefinition", RuntimeMethodHandle::IsTypicalMethodDefinition)
-    FCFuncElement("GetStubIfNeeded", RuntimeMethodHandle::GetStubIfNeeded)
+    FCFuncElement("GetStubIfNeededInternal", RuntimeMethodHandle::GetStubIfNeededInternal)
     FCFuncElement("GetMethodFromCanonical", RuntimeMethodHandle::GetMethodFromCanonical)
     FCFuncElement("IsDynamicMethod", RuntimeMethodHandle::IsDynamicMethod)
-    FCFuncElement("GetMethodBody", RuntimeMethodHandle::GetMethodBody)
     FCFuncElement("IsConstructor", RuntimeMethodHandle::IsConstructor)
     FCFuncElement("GetResolver", RuntimeMethodHandle::GetResolver)
     FCFuncElement("GetLoaderAllocatorInternal", RuntimeMethodHandle::GetLoaderAllocatorInternal)
diff --git a/src/coreclr/vm/interoplibinterface_objc.cpp b/src/coreclr/vm/interoplibinterface_objc.cpp
@@ -336,7 +336,7 @@ void* ObjCMarshalNative::GetPropagatingExceptionCallback(
         if (CallAvailableUnhandledExceptionPropagation())
         {
             gc.throwableRef = ObjectFromHandle(throwable);
-            gc.methodRef = method->GetStubMethodInfo();
+            gc.methodRef = method->AllocateStubMethodInfo();
 
             callback = CallInvokeUnhandledExceptionPropagation(
                 &gc.throwableRef,
diff --git a/src/coreclr/vm/interpreter.cpp b/src/coreclr/vm/interpreter.cpp
@@ -6536,7 +6536,7 @@ void Interpreter::LdToken()
     if (tok.hMethod != NULL)
     {
         MethodDesc* pMethod = (MethodDesc*)tok.hMethod;
-        Object* objPtr = OBJECTREFToObject((OBJECTREF)pMethod->GetStubMethodInfo());
+        Object* objPtr = OBJECTREFToObject((OBJECTREF)pMethod->AllocateStubMethodInfo());
         OpStackSet<Object*>(m_curStackHt, objPtr);
     }
     else if (tok.hField != NULL)
diff --git a/src/coreclr/vm/jithelpers.cpp b/src/coreclr/vm/jithelpers.cpp
@@ -701,7 +701,7 @@ HCIMPLEND_RAW
 //
 //========================================================================
 
-BOOL ObjIsInstanceOfCore(Object *pObject, TypeHandle toTypeHnd, BOOL throwCastException)
+static BOOL ObjIsInstanceOfCore(Object *pObject, TypeHandle toTypeHnd, BOOL throwCastException)
 {
     CONTRACTL {
         THROWS;
@@ -1625,7 +1625,7 @@ HCIMPL1(Object*, JIT_GetRuntimeMethodStub, CORINFO_METHOD_HANDLE method)
     HELPER_METHOD_FRAME_BEGIN_RET_0();    // Set up a frame
 
     MethodDesc *pMethod = (MethodDesc *)method;
-    stubRuntimeMethod = (OBJECTREF)pMethod->GetStubMethodInfo();
+    stubRuntimeMethod = (OBJECTREF)pMethod->AllocateStubMethodInfo();
 
     HELPER_METHOD_FRAME_END();
 
@@ -4049,7 +4049,7 @@ bool IndirectionAllowedForJitHelper(CorInfoHelpFunc ftnNum)
     {
         return false;
     }
-    
+
     return true;
 }
 
diff --git a/src/coreclr/vm/jitinterface.h b/src/coreclr/vm/jitinterface.h
@@ -1045,7 +1045,6 @@ FCDECL2(Object*, JIT_Box, CORINFO_CLASS_HANDLE type, void* data);
 FCDECL0(VOID, JIT_PollGC);
 
 BOOL ObjIsInstanceOf(Object *pObject, TypeHandle toTypeHnd, BOOL throwCastException = FALSE);
-BOOL ObjIsInstanceOfCore(Object* pObject, TypeHandle toTypeHnd, BOOL throwCastException = FALSE);
 
 #ifdef HOST_64BIT
 class InlinedCallFrame;
diff --git a/src/coreclr/vm/method.cpp b/src/coreclr/vm/method.cpp
@@ -3724,7 +3724,7 @@ PTR_LoaderAllocator MethodDesc::GetLoaderAllocator()
 }
 
 #if !defined(DACCESS_COMPILE)
-REFLECTMETHODREF MethodDesc::GetStubMethodInfo()
+REFLECTMETHODREF MethodDesc::AllocateStubMethodInfo()
 {
     CONTRACTL
     {
diff --git a/src/coreclr/vm/method.hpp b/src/coreclr/vm/method.hpp
@@ -1861,8 +1861,8 @@ class MethodDesc
 public:
     MethodDesc *GetInterfaceMD();
 
-// StubMethodInfo for use in creating RuntimeMethodHandles
-    REFLECTMETHODREF GetStubMethodInfo();
+    // StubMethodInfo for use in creating RuntimeMethodHandles
+    REFLECTMETHODREF AllocateStubMethodInfo();
 
     PrecodeType GetPrecodeType();
 
diff --git a/src/coreclr/vm/qcallentrypoints.cpp b/src/coreclr/vm/qcallentrypoints.cpp
@@ -127,11 +127,13 @@ static const Entry s_QCall[] =
     DllImportEntry(RuntimeTypeHandle_GetFields)
     DllImportEntry(RuntimeTypeHandle_VerifyInterfaceIsImplemented)
     DllImportEntry(RuntimeTypeHandle_GetInterfaceMethodImplementation)
+    DllImportEntry(RuntimeTypeHandle_GetDeclaringMethodForGenericParameter)
     DllImportEntry(RuntimeTypeHandle_GetDeclaringTypeHandleForGenericVariable)
     DllImportEntry(RuntimeTypeHandle_GetDeclaringTypeHandle)
     DllImportEntry(RuntimeTypeHandle_IsVisible)
     DllImportEntry(RuntimeTypeHandle_ConstructName)
     DllImportEntry(RuntimeTypeHandle_GetInterfaces)
+    DllImportEntry(RuntimeTypeHandle_SatisfiesConstraints)
     DllImportEntry(RuntimeTypeHandle_GetInstantiation)
     DllImportEntry(RuntimeTypeHandle_Instantiate)
     DllImportEntry(RuntimeTypeHandle_GetGenericTypeDefinition)
@@ -158,6 +160,8 @@ static const Entry s_QCall[] =
     DllImportEntry(RuntimeMethodHandle_StripMethodInstantiation)
     DllImportEntry(RuntimeMethodHandle_IsCAVisibleFromDecoratedType)
     DllImportEntry(RuntimeMethodHandle_Destroy)
+    DllImportEntry(RuntimeMethodHandle_GetStubIfNeededSlow)
+    DllImportEntry(RuntimeMethodHandle_GetMethodBody)
     DllImportEntry(RuntimeModule_GetScopeName)
     DllImportEntry(RuntimeModule_GetFullyQualifiedName)
     DllImportEntry(RuntimeModule_GetTypes)
@@ -187,7 +191,9 @@ static const Entry s_QCall[] =
     DllImportEntry(ModuleHandle_GetPEKind)
     DllImportEntry(ModuleHandle_GetDynamicMethod)
     DllImportEntry(AssemblyHandle_GetManifestModuleSlow)
+    DllImportEntry(Signature_Init)
     DllImportEntry(Signature_AreEqual)
+    DllImportEntry(Signature_GetCustomModifiersAtOffset)
     DllImportEntry(TypeBuilder_DefineGenericParam)
     DllImportEntry(TypeBuilder_DefineType)
     DllImportEntry(TypeBuilder_SetParentType)
diff --git a/src/coreclr/vm/runtimehandles.cpp b/src/coreclr/vm/runtimehandles.cpp
diff --git a/src/coreclr/vm/runtimehandles.h b/src/coreclr/vm/runtimehandles.h
diff --git a/src/coreclr/vm/typehandle.h b/src/coreclr/vm/typehandle.h
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/CompilerServices/CastCache.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/CompilerServices/CastCache.cs
diff --git a/src/libraries/System.Private.CoreLib/src/System/RuntimeType.cs b/src/libraries/System.Private.CoreLib/src/System/RuntimeType.cs

Original file line number	Diff line number	Diff line change
`@@ -539,7 +539,7 @@ private static bool AreTypesEquivalent(MethodTable* pMTa, MethodTable* pMTb)`
`539`	`539`
`540`	`540`	`[DebuggerHidden]`
`541`	`541`	`[MethodImpl(MethodImplOptions.AggressiveInlining)]`
`542`		`- private static bool IsNullableForType(MethodTable* typeMT, MethodTable* boxedMT)`
	`542`	`+ internal static bool IsNullableForType(MethodTable* typeMT, MethodTable* boxedMT)`
`543`	`543`	`{`
`544`	`544`	`if (!typeMT->IsNullable)`
`545`	`545`	`{`
Original file line number	Diff line number	Diff line change
`@@ -1089,7 +1089,7 @@ extern "C" void QCALLTYPE AssemblyNative_GetEntryPoint(QCall::AssemblyHandle pAs`
`1089`	`1089`	`if (pMeth != NULL)`
`1090`	`1090`	`{`
`1091`	`1091`	`GCX_COOP();`
`1092`		`- retMethod.Set(pMeth->GetStubMethodInfo());`
	`1092`	`+ retMethod.Set(pMeth->AllocateStubMethodInfo());`
`1093`	`1093`	`}`
`1094`	`1094`
`1095`	`1095`	`END_QCALL;`
Original file line number	Diff line number	Diff line change
`@@ -2127,7 +2127,7 @@ extern "C" void QCALLTYPE Delegate_FindMethodHandle(QCall::ObjectHandleOnStack d`
`2127`	`2127`
`2128`	`2128`	`MethodDesc* pMD = COMDelegate::GetMethodDesc(d.Get());`
`2129`	`2129`	`pMD = MethodDesc::FindOrCreateAssociatedMethodDescForReflection(pMD, TypeHandle(pMD->GetMethodTable()), pMD->GetMethodInstantiation());`
`2130`		`- retMethodInfo.Set(pMD->GetStubMethodInfo());`
	`2130`	`+ retMethodInfo.Set(pMD->AllocateStubMethodInfo());`
`2131`	`2131`
`2132`	`2132`	`END_QCALL;`
`2133`	`2133`	`}`
Original file line number	Diff line number	Diff line change
`@@ -445,7 +445,7 @@ extern "C" void QCALLTYPE ExceptionNative_GetMethodFromStackTrace(QCall::ObjectH`
`445`	`445`	`// The managed stack trace classes always return typical method definition,`
`446`	`446`	`// so we don't need to bother providing exact instantiation.`
`447`	`447`	`MethodDesc* pMDTypical = pMD->LoadTypicalMethodDefinition();`
`448`		`- retMethodInfo.Set(pMDTypical->GetStubMethodInfo());`
	`448`	`+ retMethodInfo.Set(pMDTypical->AllocateStubMethodInfo());`
`449`	`449`	`_ASSERTE(pMDTypical->IsRuntimeMethodHandle());`
`450`	`450`
`451`	`451`	`END_QCALL;`
`@@ -1861,11 +1861,6 @@ extern "C" BOOL QCALLTYPE TypeHandle_CanCastTo_NoCacheLookup(void* fromTypeHnd,`
`1861`	`1861`	`{`
`1862`	`1862`	`ret = fromTH.AsTypeDesc()->CanCastTo(toTH, NULL);`
`1863`	`1863`	`}`
`1864`		`- else if (Nullable::IsNullableForType(toTH, fromTH.AsMethodTable()))`
`1865`		`- {`
`1866`		`- // do not allow type T to be cast to Nullable<T>`
`1867`		`- ret = FALSE;`
`1868`		`- }`
`1869`	`1864`	`else`
`1870`	`1865`	`{`
`1871`	`1866`	`ret = fromTH.AsMethodTable()->CanCastTo(toTH.AsMethodTable(), NULL);`
Original file line number	Diff line number	Diff line change
`@@ -336,7 +336,7 @@ void* ObjCMarshalNative::GetPropagatingExceptionCallback(`
`336`	`336`	`if (CallAvailableUnhandledExceptionPropagation())`
`337`	`337`	`{`
`338`	`338`	`gc.throwableRef = ObjectFromHandle(throwable);`
`339`		`- gc.methodRef = method->GetStubMethodInfo();`
	`339`	`+ gc.methodRef = method->AllocateStubMethodInfo();`
`340`	`340`
`341`	`341`	`callback = CallInvokeUnhandledExceptionPropagation(`
`342`	`342`	`&gc.throwableRef,`