JIT/EE interface cleanup

src/coreclr/src/ToolBox/superpmi/mcs/verbildump.cpp

@@ -905,7 +905,6 @@ char* DumpAttributeToConsoleBare(DWORD attribute)
     const char* s_static      = "static";
     const char* s_dontInline  = "$dontInline ";
     const char* s_constructor = "$constructor";
-    const char* s_cfnw        = "$noSecurityWrap";
 
 #define ifPrint(s, t)                                                                                                  \
     else if ((s & attribute) == s)                                                                                     \
@@ -917,7 +916,7 @@ char* DumpAttributeToConsoleBare(DWORD attribute)
     if (0)
         ;
     ifPrint(CORINFO_FLG_STATIC, s_static) ifPrint(CORINFO_FLG_DONT_INLINE, s_dontInline)
-        ifPrint(CORINFO_FLG_CONSTRUCTOR, s_constructor) ifPrint(CORINFO_FLG_NOSECURITYWRAP, s_cfnw) else
+        ifPrint(CORINFO_FLG_CONSTRUCTOR, s_constructor) else
     {
         LogError("unknown attribute %x", attribute);
         __debugbreak();

src/coreclr/src/ToolBox/superpmi/superpmi-shared/icorjitcompilerimpl.h

@@ -34,14 +34,6 @@ CorJitResult __stdcall compileMethod(ICorJitInfo*                comp,     /* IN
                                      ULONG* nativeSizeOfCode               /* OUT */
                                      );
 
-// Some JIT compilers (most notably Phoenix), cache information about EE structures from one invocation
-// of the compiler to the next. This can be a problem when appdomains are unloaded, as some of this
-// cached information becomes stale. The code:ICorJitCompiler.isCacheCleanupRequired is called by the EE
-// early first to see if jit needs these notifications, and if so, the EE will call ClearCache is called
-// whenever the compiler should abandon its cache (eg on appdomain unload)
-void clearCache();
-BOOL isCacheCleanupRequired();
-
 // Do any appropriate work at process shutdown.  Default impl is to do nothing.
 void ProcessShutdownWork(ICorStaticInfo* info); /* {}; */
 
@@ -57,12 +49,4 @@ void getVersionIdentifier(GUID* versionIdentifier /* OUT */
 // intrinsics, so the EE should use the default size (i.e. the size of the IL implementation).
 unsigned getMaxIntrinsicSIMDVectorLength(CORJIT_FLAGS cpuCompileFlags); /* { return 0; } */
 
-// IL obfuscators sometimes interpose on the EE-JIT interface. This function allows the VM to
-// tell the JIT to use a particular ICorJitCompiler to implement the methods of this interface,
-// and not to implement those methods itself. The JIT must not return this method when getJit()
-// is called. Instead, it must pass along all calls to this interface from within its own
-// ICorJitCompiler implementation. If 'realJitCompiler' is nullptr, then the JIT should resume
-// executing all the functions itself.
-void setRealJit(ICorJitCompiler* realJitCompiler); /* { } */
-
 #endif

src/coreclr/src/ToolBox/superpmi/superpmi-shared/icorjitinfoimpl.h

@@ -169,22 +169,6 @@ BOOL isCompatibleDelegate(CORINFO_CLASS_HANDLE  objCls,          /* type of the
                           BOOL*                 pfIsOpenDelegate /* is the delegate open */
                           );
 
-// Indicates if the method is an instance of the generic
-// method that passes (or has passed) verification
-CorInfoInstantiationVerification isInstantiationOfVerifiedGeneric(CORINFO_METHOD_HANDLE method /* IN  */
-                                                                  );
-
-// Loads the constraints on a typical method definition, detecting cycles;
-// for use in verification.
-void initConstraintsForVerification(CORINFO_METHOD_HANDLE method,                        /* IN */
-                                    BOOL*                 pfHasCircularClassConstraints, /* OUT */
-                                    BOOL*                 pfHasCircularMethodConstraint  /* OUT */
-                                    );
-
-// Returns enum whether the method does not require verification
-// Also see ICorModuleInfo::canSkipVerification
-CorInfoCanSkipVerificationResult canSkipMethodVerification(CORINFO_METHOD_HANDLE ftnHandle);
-
 // load and restore the method
 void methodMustBeLoadedBeforeCodeIsRun(CORINFO_METHOD_HANDLE method);
 
@@ -231,20 +215,6 @@ void findCallSiteSig(CORINFO_MODULE_HANDLE  module,  /* IN */
 
 CORINFO_CLASS_HANDLE getTokenTypeAsHandle(CORINFO_RESOLVED_TOKEN* pResolvedToken /* IN  */);
 
-// Returns true if the module does not require verification
-//
-// If fQuickCheckOnlyWithoutCommit=TRUE, the function only checks that the
-// module does not currently require verification in the current AppDomain.
-// This decision could change in the future, and so should not be cached.
-// If it is cached, it should only be used as a hint.
-// This is only used by ngen for calculating certain hints.
-//
-
-// Returns enum whether the module does not require verification
-// Also see ICorMethodInfo::canSkipMethodVerification();
-CorInfoCanSkipVerificationResult canSkipVerification(CORINFO_MODULE_HANDLE module /* IN  */
-                                                     );
-
 // Checks if the given metadata token is valid
 BOOL isValidToken(CORINFO_MODULE_HANDLE module, /* IN  */
                   unsigned              metaTOK /* IN  */
@@ -260,8 +230,6 @@ LPCWSTR getStringLiteral(CORINFO_MODULE_HANDLE module,  /* IN  */
                          int*                  length   /* OUT */
                          );
 
-BOOL shouldEnforceCallvirtRestriction(CORINFO_MODULE_HANDLE scope);
-
 /**********************************************************************************/
 //
 // ICorClassInfo
@@ -300,10 +268,6 @@ BOOL isValueClass(CORINFO_CLASS_HANDLE cls);
 //     GetTypeFromHandle(X) == GetTypeFromHandle(Y) (for CORINFO_INLINE_TYPECHECK_SOURCE_TOKEN)
 CorInfoInlineTypeCheck canInlineTypeCheck(CORINFO_CLASS_HANDLE cls, CorInfoInlineTypeCheckSource source);
 
-// If this method returns true, JIT will do optimization to inline the check for
-//     GetTypeFromHandle(handle) == obj.GetType()
-BOOL canInlineTypeCheckWithObjectVTable(CORINFO_CLASS_HANDLE cls);
-
 // return flags (defined above, CORINFO_FLG_PUBLIC ...)
 DWORD getClassAttribs(CORINFO_CLASS_HANDLE cls);
 
@@ -375,8 +339,6 @@ CorInfoHelpFunc getCastingHelper(CORINFO_RESOLVED_TOKEN* pResolvedToken, bool fT
 // returns helper to trigger static constructor
 CorInfoHelpFunc getSharedCCtorHelper(CORINFO_CLASS_HANDLE clsHnd);
 
-CorInfoHelpFunc getSecurityPrologHelper(CORINFO_METHOD_HANDLE ftn);
-
 // This is not pretty.  Boxing nullable<T> actually returns
 // a boxed<T> not a boxed Nullable<T>.  This call allows the verifier
 // to call back to the EE on the 'box' instruction and get the transformed
@@ -532,11 +494,6 @@ CorInfoType getFieldType(CORINFO_FIELD_HANDLE  field,
 // return the data member's instance offset
 unsigned getFieldOffset(CORINFO_FIELD_HANDLE field);
 
-// TODO: jit64 should be switched to the same plan as the i386 jits - use
-// getClassGClayout to figure out the need for writebarrier helper, and inline the copying.
-// The interpretted value class copy is slow. Once this happens, USE_WRITE_BARRIER_HELPERS
-bool isWriteBarrierHelperRequired(CORINFO_FIELD_HANDLE field);
-
 void getFieldInfo(CORINFO_RESOLVED_TOKEN* pResolvedToken,
                   CORINFO_METHOD_HANDLE   callerHandle,
                   CORINFO_ACCESS_FLAGS    flags,
@@ -609,7 +566,7 @@ void setVars(CORINFO_METHOD_HANDLE         ftn,   // [IN] method of interest
 // Used to allocate memory that needs to handed to the EE.
 // For eg, use this to allocated memory for reporting debug info,
 // which will be handed to the EE by setVars() and setBoundaries()
-void* allocateArray(ULONG cBytes);
+void* allocateArray(size_t cBytes);
 
 // JitCompiler will free arrays passed by the EE using this
 // For eg, The EE returns memory in getVars() and getBoundaries()
@@ -827,17 +784,7 @@ void embedGenericHandle(CORINFO_RESOLVED_TOKEN* pResolvedToken,
 //      CORINFO_LOOKUP_THISOBJ     use vtable pointer of 'this' param
 //      CORINFO_LOOKUP_CLASSPARAM  use vtable hidden param
 //      CORINFO_LOOKUP_METHODPARAM use enclosing type of method-desc hidden param
-CORINFO_LOOKUP_KIND getLocationOfThisType(CORINFO_METHOD_HANDLE context);
-
-// NOTE: the two methods below--getPInvokeUnmanagedTarget and getAddressOfPInvokeFixup--are
-//       deprecated. New code should instead use getAddressOfPInvokeTarget, which subsumes the
-//       functionality of these methods.
-
-// return the unmanaged target *if method has already been prelinked.*
-void* getPInvokeUnmanagedTarget(CORINFO_METHOD_HANDLE method, void** ppIndirection = NULL);
-
-// return address of fixup area for late-bound PInvoke calls.
-void* getAddressOfPInvokeFixup(CORINFO_METHOD_HANDLE method, void** ppIndirection = NULL);
+void getLocationOfThisType(CORINFO_METHOD_HANDLE context, CORINFO_LOOKUP_KIND* pLookupKind);
 
 // return the address of the PInvoke target. May be a fixup area in the
 // case of late-bound PInvoke calls.
@@ -929,9 +876,6 @@ void* getTailCallCopyArgsThunk(CORINFO_SIG_INFO* pSig, CorInfoHelperTailCallSpec
 
 bool convertPInvokeCalliToCall(CORINFO_RESOLVED_TOKEN * pResolvedToken, bool fMustConvert);
 
-// return memory manager that the JIT can use to allocate a regular memory
-IEEMemoryManager* getMemoryManager();
-
 // get a block of memory for the code, readonly data, and read-write data
 void allocMem(ULONG              hotCodeSize,   /* IN */
               ULONG              coldCodeSize,  /* IN */
@@ -992,8 +936,6 @@ void allocUnwindInfo(BYTE*          pHotCode,     /* IN */
 void* allocGCInfo(size_t size /* IN */
                   );
 
-void yieldExecution();
-
 // Indicate how many exception handler blocks are to be returned.
 // This is guaranteed to be called before any 'setEHinfo' call.
 // Note that allocMem must be called before this method can be called.
@@ -1060,13 +1002,6 @@ void recordRelocation(void* location,   /* IN  */
 
 WORD getRelocTypeHint(void* target);
 
-// A callback to identify the range of address known to point to
-// compiler-generated native entry points that call back into
-// MSIL.
-void getModuleNativeEntryPointRange(void** pStart, /* OUT */
-                                    void** pEnd    /* OUT */
-                                    );
-
 // For what machine does the VM expect the JIT to generate code? The VM
 // returns one of the IMAGE_FILE_MACHINE_* values. Note that if the VM
 // is cross-compiling (such as the case for crossgen), it will return a

src/coreclr/src/ToolBox/superpmi/superpmi-shared/lwmlist.h

@@ -28,8 +28,6 @@ LWM(CanGetCookieForPInvokeCalliSig, CanGetCookieForPInvokeCalliSigValue, DWORD)
 LWM(CanGetVarArgsHandle, CanGetVarArgsHandleValue, DWORD)
 LWM(CanInline, DLDL, Agnostic_CanInline)
 LWM(CanInlineTypeCheck, DLD, DWORD)
-LWM(CanInlineTypeCheckWithObjectVTable, DWORDLONG, DWORD)
-LWM(CanSkipMethodVerification, DLD, DWORD)
 LWM(CanTailCall, Agnostic_CanTailCall, DWORD)
 LWM(CheckMethodModifier, Agnostic_CheckMethodModifier, DWORD)
 LWM(CompareTypesForCast, DLDL, DWORD)
@@ -48,7 +46,6 @@ LWM(FilterException, DWORD, DWORD)
 LWM(FindCallSiteSig, Agnostic_FindCallSiteSig, Agnostic_CORINFO_SIG_INFO)
 LWM(FindNameOfToken, DLD, DLD)
 LWM(FindSig, Agnostic_FindSig, Agnostic_CORINFO_SIG_INFO)
-LWM(GetAddressOfPInvokeFixup, DWORDLONG, DLDL)
 LWM(GetAddressOfPInvokeTarget, DWORDLONG, DLD)
 LWM(GetAddrOfCaptureThreadGlobal, DWORD, DLDL)
 LWM(GetArgClass, GetArgClassValue, Agnostic_GetArgClass_Value)
@@ -116,12 +113,10 @@ LWM(GetMethodVTableOffset, DWORDLONG, DDD)
 LWM(GetNewArrHelper, DWORDLONG, DWORD)
 LWM(GetNewHelper, Agnostic_GetNewHelper, DD)
 LWM(GetParentType, DWORDLONG, DWORDLONG)
-LWM(GetPInvokeUnmanagedTarget, DWORDLONG, DLDL)
 LWM(GetProfilingHandle, DWORD, Agnostic_GetProfilingHandle)
 LWM(GetReadyToRunHelper, GetReadyToRunHelper_TOKENin, GetReadyToRunHelper_TOKENout)
 LWM(GetReadyToRunDelegateCtorHelper, GetReadyToRunDelegateCtorHelper_TOKENIn, Agnostic_CORINFO_LOOKUP)
 LWM(GetRelocTypeHint, DWORDLONG, DWORD)
-LWM(GetSecurityPrologHelper, DWORDLONG, DWORD)
 LWM(GetSharedCCtorHelper, DWORDLONG, DWORD)
 LWM(GetStringConfigValue, DWORD, DWORD)
 LWM(GetSystemVAmd64PassStructInRegisterDescriptor, DWORDLONG, Agnostic_GetSystemVAmd64PassStructInRegisterDescriptor)
@@ -138,19 +133,16 @@ LWM(GetVarArgsHandle, GetVarArgsHandleValue, DLDL)
 LWM(GetVars, DWORDLONG, Agnostic_GetVars)
 DENSELWM(HandleException, DWORD)
 LWM(InitClass, Agnostic_InitClass, DWORD)
-LWM(InitConstraintsForVerification, DWORDLONG, DD)
 LWM(IsCompatibleDelegate, Agnostic_IsCompatibleDelegate, DD)
 LWM(IsDelegateCreationAllowed, DLDL, DWORD)
 LWM(IsFieldStatic, DWORDLONG, DWORD)
 LWM(IsIntrinsicType, DWORDLONG, DWORD)
-LWM(IsInstantiationOfVerifiedGeneric, DWORDLONG, DWORD)
 LWM(IsSDArray, DWORDLONG, DWORD)
 LWM(IsStructRequiringStackAllocRetBuf, DWORDLONG, DWORD)
 LWM(IsValidStringRef, DLD, DWORD)
 LWM(GetStringLiteral, DLD, DD)
 LWM(IsValidToken, DLD, DWORD)
 LWM(IsValueClass, DWORDLONG, DWORD)
-LWM(IsWriteBarrierHelperRequired, DWORDLONG, DWORD)
 LWM(MergeClasses, DLDL, DWORDLONG)
 LWM(IsMoreSpecificType, DLDL, DWORD)
 LWM(PInvokeMarshalingRequired, PInvokeMarshalingRequiredValue, DWORD)
@@ -159,7 +151,6 @@ LWM(ResolveVirtualMethod, Agnostic_ResolveVirtualMethod, DWORDLONG)
 LWM(TryResolveToken, Agnostic_CORINFO_RESOLVED_TOKENin, TryResolveTokenValue)
 LWM(SatisfiesClassConstraints, DWORDLONG, DWORD)
 LWM(SatisfiesMethodConstraints, DLDL, DWORD)
-LWM(ShouldEnforceCallvirtRestriction, DWORDLONG, DWORD)
 
 #undef LWM
 #undef DENSELWM