-// Licensed to the .NET Foundation under one or more agreements.\r
-// The .NET Foundation licenses this file to you under the MIT license.\r
-// See the LICENSE file in the project root for more information.\r
-// ===========================================================================\r
-// File: JITinterface.H\r
-//\r
-\r
-// ===========================================================================\r
-\r
-\r
-#ifndef JITINTERFACE_H\r
-#define JITINTERFACE_H\r
-\r
-#include "corjit.h"\r
-#ifdef FEATURE_PREJIT\r
-#include "corcompile.h"\r
-#endif // FEATURE_PREJIT\r
-\r
-#ifndef FEATURE_PAL\r
-#define MAX_UNCHECKED_OFFSET_FOR_NULL_OBJECT ((32*1024)-1) // when generating JIT code\r
-#else // !FEATURE_PAL\r
-#define MAX_UNCHECKED_OFFSET_FOR_NULL_OBJECT ((OS_PAGE_SIZE / 2) - 1)\r
-#endif // !FEATURE_PAL\r
-\r
-class Stub;\r
-class MethodDesc;\r
-class FieldDesc;\r
-enum RuntimeExceptionKind;\r
-class AwareLock;\r
-class PtrArray;\r
-\r
-#include "genericdict.h"\r
-\r
-inline FieldDesc* GetField(CORINFO_FIELD_HANDLE fieldHandle)\r
-{\r
- LIMITED_METHOD_CONTRACT;\r
- return (FieldDesc*) fieldHandle;\r
-}\r
-\r
-inline\r
-bool SigInfoFlagsAreValid (CORINFO_SIG_INFO *sig)\r
-{\r
- LIMITED_METHOD_CONTRACT;\r
- return !(sig->flags & ~( CORINFO_SIGFLAG_IS_LOCAL_SIG\r
- | CORINFO_SIGFLAG_IL_STUB\r
- ));\r
-}\r
-\r
-\r
-void InitJITHelpers1();\r
-void InitJITHelpers2();\r
-\r
-PCODE UnsafeJitFunction(MethodDesc* ftn, COR_ILMETHOD_DECODER* header,\r
- DWORD flags, DWORD flags2, ULONG* sizeOfCode = NULL);\r
-\r
-void getMethodInfoHelper(MethodDesc * ftn,\r
- CORINFO_METHOD_HANDLE ftnHnd,\r
- COR_ILMETHOD_DECODER * header,\r
- CORINFO_METHOD_INFO * methInfo);\r
-\r
-void getMethodInfoILMethodHeaderHelper(\r
- COR_ILMETHOD_DECODER* header,\r
- CORINFO_METHOD_INFO* methInfo\r
- );\r
-\r
-\r
-#ifdef FEATURE_PREJIT\r
-BOOL LoadDynamicInfoEntry(Module *currentModule,\r
- RVA fixupRva,\r
- SIZE_T *entry);\r
-#endif // FEATURE_PREJIT\r
-\r
-//\r
-// The legacy x86 monitor helpers do not need a state argument\r
-//\r
-#if !defined(_TARGET_X86_)\r
-\r
-#define FCDECL_MONHELPER(funcname, arg) FCDECL2(void, funcname, arg, BYTE* pbLockTaken)\r
-#define HCIMPL_MONHELPER(funcname, arg) HCIMPL2(void, funcname, arg, BYTE* pbLockTaken)\r
-#define MONHELPER_STATE(x) x\r
-#define MONHELPER_ARG pbLockTaken\r
-\r
-#else\r
-\r
-#define FCDECL_MONHELPER(funcname, arg) FCDECL1(void, funcname, arg)\r
-#define HCIMPL_MONHELPER(funcname, arg) HCIMPL1(void, funcname, arg)\r
-#define MONHELPER_STATE(x)\r
-#define MONHELPER_ARG NULL\r
-\r
-#endif // _TARGET_X86_\r
-\r
-\r
-//\r
-// JIT HELPER ALIASING FOR PORTABILITY.\r
-//\r
-// The portable helper is used if the platform does not provide optimized implementation.\r
-//\r
-\r
-#ifndef JIT_MonEnter\r
-#define JIT_MonEnter JIT_MonEnter_Portable\r
-#endif\r
-EXTERN_C FCDECL1(void, JIT_MonEnter, Object *obj);\r
-EXTERN_C FCDECL1(void, JIT_MonEnter_Portable, Object *obj);\r
-\r
-#ifndef JIT_MonEnterWorker\r
-#define JIT_MonEnterWorker JIT_MonEnterWorker_Portable\r
-#endif\r
-EXTERN_C FCDECL_MONHELPER(JIT_MonEnterWorker, Object *obj);\r
-EXTERN_C FCDECL_MONHELPER(JIT_MonEnterWorker_Portable, Object *obj);\r
-\r
-#ifndef JIT_MonReliableEnter\r
-#define JIT_MonReliableEnter JIT_MonReliableEnter_Portable\r
-#endif\r
-EXTERN_C FCDECL2(void, JIT_MonReliableEnter, Object* obj, BYTE *tookLock);\r
-EXTERN_C FCDECL2(void, JIT_MonReliableEnter_Portable, Object* obj, BYTE *tookLock);\r
-\r
-#ifndef JIT_MonTryEnter\r
-#define JIT_MonTryEnter JIT_MonTryEnter_Portable\r
-#endif\r
-EXTERN_C FCDECL3(void, JIT_MonTryEnter, Object *obj, INT32 timeout, BYTE* pbLockTaken);\r
-EXTERN_C FCDECL3(void, JIT_MonTryEnter_Portable, Object *obj, INT32 timeout, BYTE* pbLockTaken);\r
-\r
-#ifndef JIT_MonExit\r
-#define JIT_MonExit JIT_MonExit_Portable\r
-#endif\r
-EXTERN_C FCDECL1(void, JIT_MonExit, Object *obj);\r
-EXTERN_C FCDECL1(void, JIT_MonExit_Portable, Object *obj);\r
-\r
-#ifndef JIT_MonExitWorker\r
-#define JIT_MonExitWorker JIT_MonExitWorker_Portable\r
-#endif\r
-EXTERN_C FCDECL_MONHELPER(JIT_MonExitWorker, Object *obj);\r
-EXTERN_C FCDECL_MONHELPER(JIT_MonExitWorker_Portable, Object *obj);\r
-\r
-#ifndef JIT_MonEnterStatic\r
-#define JIT_MonEnterStatic JIT_MonEnterStatic_Portable \r
-#endif\r
-EXTERN_C FCDECL_MONHELPER(JIT_MonEnterStatic, AwareLock *lock);\r
-EXTERN_C FCDECL_MONHELPER(JIT_MonEnterStatic_Portable, AwareLock *lock);\r
-\r
-#ifndef JIT_MonExitStatic\r
-#define JIT_MonExitStatic JIT_MonExitStatic_Portable\r
-#endif\r
-EXTERN_C FCDECL_MONHELPER(JIT_MonExitStatic, AwareLock *lock);\r
-EXTERN_C FCDECL_MONHELPER(JIT_MonExitStatic_Portable, AwareLock *lock);\r
-\r
-\r
-#ifndef JIT_GetSharedGCStaticBase\r
-#define JIT_GetSharedGCStaticBase JIT_GetSharedGCStaticBase_Portable\r
-#endif\r
-EXTERN_C FCDECL2(void*, JIT_GetSharedGCStaticBase, SIZE_T moduleDomainID, DWORD dwModuleClassID);\r
-EXTERN_C FCDECL2(void*, JIT_GetSharedGCStaticBase_Portable, SIZE_T moduleDomainID, DWORD dwModuleClassID);\r
-\r
-#ifndef JIT_GetSharedNonGCStaticBase\r
-#define JIT_GetSharedNonGCStaticBase JIT_GetSharedNonGCStaticBase_Portable\r
-#endif\r
-EXTERN_C FCDECL2(void*, JIT_GetSharedNonGCStaticBase, SIZE_T moduleDomainID, DWORD dwModuleClassID);\r
-EXTERN_C FCDECL2(void*, JIT_GetSharedNonGCStaticBase_Portable, SIZE_T moduleDomainID, DWORD dwModuleClassID);\r
-\r
-#ifndef JIT_GetSharedGCStaticBaseNoCtor\r
-#define JIT_GetSharedGCStaticBaseNoCtor JIT_GetSharedGCStaticBaseNoCtor_Portable\r
-#endif\r
-EXTERN_C FCDECL1(void*, JIT_GetSharedGCStaticBaseNoCtor, SIZE_T moduleDomainID);\r
-EXTERN_C FCDECL1(void*, JIT_GetSharedGCStaticBaseNoCtor_Portable, SIZE_T moduleDomainID);\r
-\r
-#ifndef JIT_GetSharedNonGCStaticBaseNoCtor\r
-#define JIT_GetSharedNonGCStaticBaseNoCtor JIT_GetSharedNonGCStaticBaseNoCtor_Portable\r
-#endif\r
-EXTERN_C FCDECL1(void*, JIT_GetSharedNonGCStaticBaseNoCtor, SIZE_T moduleDomainID);\r
-EXTERN_C FCDECL1(void*, JIT_GetSharedNonGCStaticBaseNoCtor_Portable, SIZE_T moduleDomainID);\r
-\r
-#ifndef JIT_ChkCastClass\r
-#define JIT_ChkCastClass JIT_ChkCastClass_Portable\r
-#endif\r
-EXTERN_C FCDECL2(Object*, JIT_ChkCastClass, MethodTable* pMT, Object* pObject);\r
-EXTERN_C FCDECL2(Object*, JIT_ChkCastClass_Portable, MethodTable* pMT, Object* pObject);\r
-\r
-#ifndef JIT_ChkCastClassSpecial\r
-#define JIT_ChkCastClassSpecial JIT_ChkCastClassSpecial_Portable\r
-#endif\r
-EXTERN_C FCDECL2(Object*, JIT_ChkCastClassSpecial, MethodTable* pMT, Object* pObject);\r
-EXTERN_C FCDECL2(Object*, JIT_ChkCastClassSpecial_Portable, MethodTable* pMT, Object* pObject);\r
-\r
-#ifndef JIT_IsInstanceOfClass\r
-#define JIT_IsInstanceOfClass JIT_IsInstanceOfClass_Portable\r
-#endif\r
-EXTERN_C FCDECL2(Object*, JIT_IsInstanceOfClass, MethodTable* pMT, Object* pObject);\r
-EXTERN_C FCDECL2(Object*, JIT_IsInstanceOfClass_Portable, MethodTable* pMT, Object* pObject);\r
-\r
-#ifndef JIT_ChkCastInterface\r
-#define JIT_ChkCastInterface JIT_ChkCastInterface_Portable\r
-#endif\r
-EXTERN_C FCDECL2(Object*, JIT_ChkCastInterface, MethodTable* pMT, Object* pObject);\r
-EXTERN_C FCDECL2(Object*, JIT_ChkCastInterface_Portable, MethodTable* pMT, Object* pObject);\r
-\r
-#ifndef JIT_IsInstanceOfInterface\r
-#define JIT_IsInstanceOfInterface JIT_IsInstanceOfInterface_Portable\r
-#endif\r
-EXTERN_C FCDECL2(Object*, JIT_IsInstanceOfInterface, MethodTable* pMT, Object* pObject);\r
-EXTERN_C FCDECL2(Object*, JIT_IsInstanceOfInterface_Portable, MethodTable* pMT, Object* pObject);\r
-\r
-extern FCDECL1(Object*, JIT_NewS_MP_FastPortable, CORINFO_CLASS_HANDLE typeHnd_);\r
-extern FCDECL1(Object*, JIT_New, CORINFO_CLASS_HANDLE typeHnd_);\r
-\r
-#ifndef JIT_NewCrossContext\r
-#define JIT_NewCrossContext JIT_NewCrossContext_Portable\r
-#endif\r
-EXTERN_C FCDECL1(Object*, JIT_NewCrossContext, CORINFO_CLASS_HANDLE typeHnd_);\r
-EXTERN_C FCDECL1(Object*, JIT_NewCrossContext_Portable, CORINFO_CLASS_HANDLE typeHnd_);\r
-\r
-extern FCDECL1(StringObject*, AllocateString_MP_FastPortable, DWORD stringLength);\r
-extern FCDECL1(StringObject*, UnframedAllocateString, DWORD stringLength);\r
-extern FCDECL1(StringObject*, FramedAllocateString, DWORD stringLength);\r
-\r
-extern FCDECL2(Object*, JIT_NewArr1VC_MP_FastPortable, CORINFO_CLASS_HANDLE typeHnd_, INT_PTR size);\r
-extern FCDECL2(Object*, JIT_NewArr1OBJ_MP_FastPortable, CORINFO_CLASS_HANDLE typeHnd_, INT_PTR size);\r
-extern FCDECL2(Object*, JIT_NewArr1, CORINFO_CLASS_HANDLE typeHnd_, INT_PTR size);\r
-\r
-#ifndef JIT_Stelem_Ref\r
-#define JIT_Stelem_Ref JIT_Stelem_Ref_Portable\r
-#endif\r
-EXTERN_C FCDECL3(void, JIT_Stelem_Ref, PtrArray* array, unsigned idx, Object* val);\r
-EXTERN_C FCDECL3(void, JIT_Stelem_Ref_Portable, PtrArray* array, unsigned idx, Object* val);\r
-\r
-EXTERN_C FCDECL_MONHELPER(JITutil_MonEnterWorker, Object* obj);\r
-EXTERN_C FCDECL2(void, JITutil_MonReliableEnter, Object* obj, BYTE* pbLockTaken);\r
-EXTERN_C FCDECL3(void, JITutil_MonTryEnter, Object* obj, INT32 timeOut, BYTE* pbLockTaken);\r
-EXTERN_C FCDECL_MONHELPER(JITutil_MonExitWorker, Object* obj);\r
-EXTERN_C FCDECL_MONHELPER(JITutil_MonSignal, AwareLock* lock);\r
-EXTERN_C FCDECL_MONHELPER(JITutil_MonContention, AwareLock* awarelock);\r
-EXTERN_C FCDECL2(void, JITutil_MonReliableContention, AwareLock* awarelock, BYTE* pbLockTaken);\r
-\r
-// Slow versions to tail call if the fast version fails\r
-EXTERN_C FCDECL2(void*, JIT_GetSharedNonGCStaticBase_Helper, DomainLocalModule *pLocalModule, DWORD dwClassDomainID);\r
-EXTERN_C FCDECL2(void*, JIT_GetSharedGCStaticBase_Helper, DomainLocalModule *pLocalModule, DWORD dwClassDomainID);\r
-\r
-EXTERN_C void DoJITFailFast ();\r
-EXTERN_C FCDECL0(void, JIT_FailFast);\r
-extern FCDECL3(void, JIT_ThrowAccessException, RuntimeExceptionKind, CORINFO_METHOD_HANDLE caller, void * callee);\r
-\r
-FCDECL1(void*, JIT_SafeReturnableByref, void* byref);\r
-\r
-#if !defined(FEATURE_USE_ASM_GC_WRITE_BARRIERS) && defined(FEATURE_COUNT_GC_WRITE_BARRIERS)\r
-// Extra argument for the classification of the checked barriers.\r
-extern "C" FCDECL3(VOID, JIT_CheckedWriteBarrier, Object **dst, Object *ref, CheckedWriteBarrierKinds kind);\r
-#else\r
-// Regular checked write barrier.\r
-extern "C" FCDECL2(VOID, JIT_CheckedWriteBarrier, Object **dst, Object *ref);\r
-#endif\r
-\r
-extern "C" FCDECL2(VOID, JIT_WriteBarrier, Object **dst, Object *ref);\r
-\r
-extern "C" FCDECL2(VOID, JIT_WriteBarrierEnsureNonHeapTarget, Object **dst, Object *ref);\r
-\r
-extern "C" FCDECL2(Object*, JIT_ChkCastAny, CORINFO_CLASS_HANDLE type, Object *pObject); // JITInterfaceX86.cpp, etc.\r
-extern "C" FCDECL2(Object*, JIT_IsInstanceOfAny, CORINFO_CLASS_HANDLE type, Object *pObject);\r
-\r
-extern "C" FCDECL2(Object*, JITutil_ChkCastInterface, MethodTable *pInterfaceMT, Object *obj);\r
-extern "C" FCDECL2(Object*, JITutil_IsInstanceOfInterface, MethodTable *pInterfaceMT, Object *obj);\r
-extern "C" FCDECL2(Object*, JITutil_ChkCastAny, CORINFO_CLASS_HANDLE type, Object *obj);\r
-extern "C" FCDECL2(Object*, JITutil_IsInstanceOfAny, CORINFO_CLASS_HANDLE type, Object *obj);\r
-\r
-extern "C" FCDECL1(void, JIT_InternalThrow, unsigned exceptNum);\r
-extern "C" FCDECL1(void*, JIT_InternalThrowFromHelper, unsigned exceptNum);\r
-\r
-#ifdef _TARGET_AMD64_\r
-\r
-\r
-class WriteBarrierManager\r
-{\r
-public:\r
- enum WriteBarrierType\r
- {\r
- WRITE_BARRIER_UNINITIALIZED,\r
- WRITE_BARRIER_PREGROW64,\r
- WRITE_BARRIER_POSTGROW64,\r
-#ifdef FEATURE_SVR_GC\r
- WRITE_BARRIER_SVR64,\r
-#endif // FEATURE_SVR_GC\r
-#ifdef FEATURE_USE_SOFTWARE_WRITE_WATCH_FOR_GC_HEAP\r
- WRITE_BARRIER_WRITE_WATCH_PREGROW64,\r
- WRITE_BARRIER_WRITE_WATCH_POSTGROW64,\r
-#ifdef FEATURE_SVR_GC\r
- WRITE_BARRIER_WRITE_WATCH_SVR64,\r
-#endif // FEATURE_SVR_GC\r
-#endif // FEATURE_USE_SOFTWARE_WRITE_WATCH_FOR_GC_HEAP\r
- WRITE_BARRIER_BUFFER\r
- };\r
-\r
- WriteBarrierManager();\r
- void Initialize();\r
- \r
- void UpdateEphemeralBounds(bool isRuntimeSuspended);\r
- void UpdateWriteWatchAndCardTableLocations(bool isRuntimeSuspended, bool bReqUpperBoundsCheck);\r
-\r
-#ifdef FEATURE_USE_SOFTWARE_WRITE_WATCH_FOR_GC_HEAP\r
- void SwitchToWriteWatchBarrier(bool isRuntimeSuspended);\r
- void SwitchToNonWriteWatchBarrier(bool isRuntimeSuspended);\r
-#endif // FEATURE_USE_SOFTWARE_WRITE_WATCH_FOR_GC_HEAP\r
-\r
-protected:\r
- size_t GetCurrentWriteBarrierSize();\r
- size_t GetSpecificWriteBarrierSize(WriteBarrierType writeBarrier);\r
- PBYTE CalculatePatchLocation(LPVOID base, LPVOID label, int offset);\r
- PCODE GetCurrentWriteBarrierCode();\r
- void ChangeWriteBarrierTo(WriteBarrierType newWriteBarrier, bool isRuntimeSuspended);\r
- bool NeedDifferentWriteBarrier(bool bReqUpperBoundsCheck, WriteBarrierType* pNewWriteBarrierType);\r
-\r
-private: \r
- void Validate();\r
- \r
- WriteBarrierType m_currentWriteBarrier;\r
-\r
- PBYTE m_pWriteWatchTableImmediate; // PREGROW | POSTGROW | SVR | WRITE_WATCH |\r
- PBYTE m_pLowerBoundImmediate; // PREGROW | POSTGROW | | WRITE_WATCH |\r
- PBYTE m_pCardTableImmediate; // PREGROW | POSTGROW | SVR | WRITE_WATCH |\r
- PBYTE m_pUpperBoundImmediate; // | POSTGROW | | WRITE_WATCH |\r
-};\r
-\r
-#endif // _TARGET_AMD64_\r
-\r
-#ifdef _WIN64\r
-EXTERN_C FCDECL1(Object*, JIT_TrialAllocSFastMP_InlineGetThread, CORINFO_CLASS_HANDLE typeHnd_);\r
-EXTERN_C FCDECL2(Object*, JIT_BoxFastMP_InlineGetThread, CORINFO_CLASS_HANDLE type, void* data);\r
-EXTERN_C FCDECL2(Object*, JIT_NewArr1VC_MP_InlineGetThread, CORINFO_CLASS_HANDLE typeHnd_, INT_PTR size);\r
-EXTERN_C FCDECL2(Object*, JIT_NewArr1OBJ_MP_InlineGetThread, CORINFO_CLASS_HANDLE typeHnd_, INT_PTR size);\r
-\r
-#endif // _WIN64\r
-\r
-EXTERN_C FCDECL2_VV(INT64, JIT_LMul, INT64 val1, INT64 val2);\r
-\r
-EXTERN_C FCDECL1_V(INT64, JIT_Dbl2Lng, double val);\r
-EXTERN_C FCDECL1_V(INT64, JIT_Dbl2IntSSE2, double val);\r
-EXTERN_C FCDECL1_V(INT64, JIT_Dbl2LngP4x87, double val);\r
-EXTERN_C FCDECL1_V(INT64, JIT_Dbl2LngSSE3, double val);\r
-EXTERN_C FCDECL1_V(INT64, JIT_Dbl2LngOvf, double val);\r
-\r
-EXTERN_C FCDECL1_V(INT32, JIT_Dbl2IntOvf, double val);\r
-\r
-EXTERN_C FCDECL2_VV(float, JIT_FltRem, float dividend, float divisor);\r
-EXTERN_C FCDECL2_VV(double, JIT_DblRem, double dividend, double divisor);\r
-\r
-#if !defined(_WIN64) && !defined(_TARGET_X86_)\r
-EXTERN_C FCDECL2_VV(UINT64, JIT_LLsh, UINT64 num, int shift);\r
-EXTERN_C FCDECL2_VV(INT64, JIT_LRsh, INT64 num, int shift);\r
-EXTERN_C FCDECL2_VV(UINT64, JIT_LRsz, UINT64 num, int shift);\r
-#endif\r
-\r
-#ifdef _TARGET_X86_\r
-\r
-extern "C"\r
-{\r
- void STDCALL JIT_LLsh(); // JIThelp.asm\r
- void STDCALL JIT_LRsh(); // JIThelp.asm\r
- void STDCALL JIT_LRsz(); // JIThelp.asm\r
-\r
- void STDCALL JIT_CheckedWriteBarrierEAX(); // JIThelp.asm/JIThelp.s\r
- void STDCALL JIT_CheckedWriteBarrierEBX(); // JIThelp.asm/JIThelp.s\r
- void STDCALL JIT_CheckedWriteBarrierECX(); // JIThelp.asm/JIThelp.s\r
- void STDCALL JIT_CheckedWriteBarrierESI(); // JIThelp.asm/JIThelp.s\r
- void STDCALL JIT_CheckedWriteBarrierEDI(); // JIThelp.asm/JIThelp.s\r
- void STDCALL JIT_CheckedWriteBarrierEBP(); // JIThelp.asm/JIThelp.s\r
-\r
- void STDCALL JIT_DebugWriteBarrierEAX(); // JIThelp.asm/JIThelp.s\r
- void STDCALL JIT_DebugWriteBarrierEBX(); // JIThelp.asm/JIThelp.s\r
- void STDCALL JIT_DebugWriteBarrierECX(); // JIThelp.asm/JIThelp.s\r
- void STDCALL JIT_DebugWriteBarrierESI(); // JIThelp.asm/JIThelp.s\r
- void STDCALL JIT_DebugWriteBarrierEDI(); // JIThelp.asm/JIThelp.s\r
- void STDCALL JIT_DebugWriteBarrierEBP(); // JIThelp.asm/JIThelp.s\r
-\r
- void STDCALL JIT_WriteBarrierEAX(); // JIThelp.asm/JIThelp.s\r
- void STDCALL JIT_WriteBarrierEBX(); // JIThelp.asm/JIThelp.s\r
- void STDCALL JIT_WriteBarrierECX(); // JIThelp.asm/JIThelp.s\r
- void STDCALL JIT_WriteBarrierESI(); // JIThelp.asm/JIThelp.s\r
- void STDCALL JIT_WriteBarrierEDI(); // JIThelp.asm/JIThelp.s\r
- void STDCALL JIT_WriteBarrierEBP(); // JIThelp.asm/JIThelp.s\r
-\r
- void STDCALL JIT_WriteBarrierStart();\r
- void STDCALL JIT_WriteBarrierLast();\r
-\r
- void STDCALL JIT_PatchedWriteBarrierStart();\r
- void STDCALL JIT_PatchedWriteBarrierLast();\r
-}\r
-\r
-void ValidateWriteBarrierHelpers();\r
-\r
-#endif //_TARGET_X86_\r
-\r
-extern "C"\r
-{\r
- void STDCALL JIT_EndCatch(); // JIThelp.asm/JIThelp.s\r
-\r
- void STDCALL JIT_ByRefWriteBarrier(); // JIThelp.asm/JIThelp.s\r
-\r
-#if defined(_TARGET_AMD64_) || defined(_TARGET_ARM_)\r
-\r
- FCDECL2VA(void, JIT_TailCall, PCODE copyArgs, PCODE target);\r
-\r
-#else // _TARGET_AMD64_ || _TARGET_ARM_\r
-\r
- void STDCALL JIT_TailCall(); // JIThelp.asm\r
-\r
-#endif // _TARGET_AMD64_ || _TARGET_ARM_\r
-\r
- void STDCALL JIT_MemSet(void *dest, int c, SIZE_T count);\r
- void STDCALL JIT_MemCpy(void *dest, const void *src, SIZE_T count);\r
-\r
- void STDCALL JIT_ProfilerEnterLeaveTailcallStub(UINT_PTR ProfilerHandle);\r
-};\r
-\r
-#ifndef FEATURE_CORECLR\r
-//\r
-// Obfluscators that are hacking into the JIT expect certain methods to exist in certain places of CEEInfo vtable. Add artifical slots \r
-// to the vtable to avoid breaking apps by .NET 4.5 in-place update.\r
-//\r
-\r
-class ICorMethodInfo_Hack\r
-{\r
-public:\r
- virtual const char* __stdcall ICorMethodInfo_Hack_getMethodName (CORINFO_METHOD_HANDLE ftnHnd, const char** scopeName) = 0;\r
-};\r
-\r
-class ICorModuleInfo_Hack\r
-{\r
-public:\r
- virtual void ICorModuleInfo_Hack_dummy() { LIMITED_METHOD_CONTRACT; UNREACHABLE(); };\r
-};\r
-\r
-class ICorClassInfo_Hack\r
-{\r
-public:\r
- virtual void ICorClassInfo_Hack_dummy1() { LIMITED_METHOD_CONTRACT; UNREACHABLE(); };\r
- virtual void ICorClassInfo_Hack_dummy2() { LIMITED_METHOD_CONTRACT; UNREACHABLE(); };\r
- virtual void ICorClassInfo_Hack_dummy3() { LIMITED_METHOD_CONTRACT; UNREACHABLE(); };\r
- virtual void ICorClassInfo_Hack_dummy4() { LIMITED_METHOD_CONTRACT; UNREACHABLE(); };\r
- virtual void ICorClassInfo_Hack_dummy5() { LIMITED_METHOD_CONTRACT; UNREACHABLE(); };\r
- virtual void ICorClassInfo_Hack_dummy6() { LIMITED_METHOD_CONTRACT; UNREACHABLE(); };\r
- virtual void ICorClassInfo_Hack_dummy7() { LIMITED_METHOD_CONTRACT; UNREACHABLE(); };\r
- virtual void ICorClassInfo_Hack_dummy8() { LIMITED_METHOD_CONTRACT; UNREACHABLE(); };\r
- virtual void ICorClassInfo_Hack_dummy9() { LIMITED_METHOD_CONTRACT; UNREACHABLE(); };\r
- virtual void ICorClassInfo_Hack_dummy10() { LIMITED_METHOD_CONTRACT; UNREACHABLE(); };\r
- virtual void ICorClassInfo_Hack_dummy11() { LIMITED_METHOD_CONTRACT; UNREACHABLE(); };\r
- virtual void ICorClassInfo_Hack_dummy12() { LIMITED_METHOD_CONTRACT; UNREACHABLE(); };\r
- virtual void ICorClassInfo_Hack_dummy13() { LIMITED_METHOD_CONTRACT; UNREACHABLE(); };\r
- virtual void ICorClassInfo_Hack_dummy14() { LIMITED_METHOD_CONTRACT; UNREACHABLE(); };\r
-\r
- virtual mdMethodDef __stdcall ICorClassInfo_Hack_getMethodDefFromMethod(CORINFO_METHOD_HANDLE hMethod) = 0;\r
-};\r
-\r
-class ICorStaticInfo_Hack : public virtual ICorMethodInfo_Hack, public virtual ICorModuleInfo_Hack, public virtual ICorClassInfo_Hack\r
-{\r
- virtual void ICorStaticInfo_Hack_dummy() { LIMITED_METHOD_CONTRACT; UNREACHABLE(); };\r
-};\r
-\r
-#endif // FEATURE_CORECLR\r
-\r
-\r
-/*********************************************************************/\r
-/*********************************************************************/\r
-class CEEInfo : public ICorJitInfo\r
-#ifndef FEATURE_CORECLR\r
- , public virtual ICorStaticInfo_Hack\r
-#endif\r
-{\r
- friend class CEEDynamicCodeInfo;\r
- \r
- const char * __stdcall ICorMethodInfo_Hack_getMethodName(CORINFO_METHOD_HANDLE ftnHnd, const char** scopeName)\r
- {\r
- WRAPPER_NO_CONTRACT;\r
- return getMethodName(ftnHnd, scopeName);\r
- }\r
-\r
- mdMethodDef __stdcall ICorClassInfo_Hack_getMethodDefFromMethod(CORINFO_METHOD_HANDLE hMethod)\r
- {\r
- WRAPPER_NO_CONTRACT;\r
- return getMethodDefFromMethod(hMethod);\r
- }\r
- \r
-public:\r
- // ICorClassInfo stuff\r
- CorInfoType asCorInfoType (CORINFO_CLASS_HANDLE cls);\r
- // This normalizes EE type information into the form expected by the JIT.\r
- //\r
- // If typeHnd contains exact type information, then *clsRet will contain\r
- // the normalized CORINFO_CLASS_HANDLE information on return.\r
- static CorInfoType asCorInfoType (CorElementType cet, \r
- TypeHandle typeHnd = TypeHandle() /* optional in */,\r
- CORINFO_CLASS_HANDLE *clsRet = NULL /* optional out */ );\r
-\r
- CORINFO_MODULE_HANDLE getClassModule(CORINFO_CLASS_HANDLE clsHnd);\r
- CORINFO_ASSEMBLY_HANDLE getModuleAssembly(CORINFO_MODULE_HANDLE mod);\r
- const char* getAssemblyName(CORINFO_ASSEMBLY_HANDLE assem);\r
- void* LongLifetimeMalloc(size_t sz);\r
- void LongLifetimeFree(void* obj);\r
- size_t getClassModuleIdForStatics(CORINFO_CLASS_HANDLE clsHnd, CORINFO_MODULE_HANDLE *pModuleHandle, void **ppIndirection);\r
- const char* getClassName (CORINFO_CLASS_HANDLE cls);\r
- const char* getHelperName(CorInfoHelpFunc ftnNum);\r
- int appendClassName(__deref_inout_ecount(*pnBufLen) WCHAR** ppBuf,\r
- int* pnBufLen,\r
- CORINFO_CLASS_HANDLE cls,\r
- BOOL fNamespace,\r
- BOOL fFullInst,\r
- BOOL fAssembly);\r
- BOOL isValueClass (CORINFO_CLASS_HANDLE cls);\r
- BOOL canInlineTypeCheckWithObjectVTable (CORINFO_CLASS_HANDLE cls);\r
-\r
- DWORD getClassAttribs (CORINFO_CLASS_HANDLE cls);\r
-\r
- // Internal version without JIT-EE transition\r
- DWORD getClassAttribsInternal (CORINFO_CLASS_HANDLE cls);\r
-\r
- BOOL isStructRequiringStackAllocRetBuf(CORINFO_CLASS_HANDLE cls);\r
-\r
- unsigned getClassSize (CORINFO_CLASS_HANDLE cls);\r
- unsigned getClassAlignmentRequirement(CORINFO_CLASS_HANDLE cls, BOOL fDoubleAlignHint);\r
- static unsigned getClassAlignmentRequirementStatic(TypeHandle clsHnd);\r
-\r
- // Used for HFA's on IA64...and later for type based disambiguation\r
- CORINFO_FIELD_HANDLE getFieldInClass(CORINFO_CLASS_HANDLE clsHnd, INT num);\r
-\r
- mdMethodDef getMethodDefFromMethod(CORINFO_METHOD_HANDLE hMethod);\r
- BOOL checkMethodModifier(CORINFO_METHOD_HANDLE hMethod, LPCSTR modifier, BOOL fOptional);\r
-\r
- unsigned getClassGClayout (CORINFO_CLASS_HANDLE cls, BYTE* gcPtrs); /* really GCType* gcPtrs */\r
- unsigned getClassNumInstanceFields(CORINFO_CLASS_HANDLE cls);\r
-\r
- // returns the enregister info for a struct based on type of fields, alignment, etc.\r
- bool getSystemVAmd64PassStructInRegisterDescriptor(\r
- /*IN*/ CORINFO_CLASS_HANDLE _structHnd,\r
- /*OUT*/ SYSTEMV_AMD64_CORINFO_STRUCT_REG_PASSING_DESCRIPTOR* structPassInRegDescPtr);\r
-\r
- // Check Visibility rules.\r
- // For Protected (family access) members, type of the instance is also\r
- // considered when checking visibility rules.\r
- \r
-\r
- CorInfoHelpFunc getNewHelper(CORINFO_RESOLVED_TOKEN * pResolvedToken, CORINFO_METHOD_HANDLE callerHandle);\r
- static CorInfoHelpFunc getNewHelperStatic(MethodTable * pMT);\r
-\r
- CorInfoHelpFunc getNewArrHelper(CORINFO_CLASS_HANDLE arrayCls);\r
- static CorInfoHelpFunc getNewArrHelperStatic(TypeHandle clsHnd);\r
-\r
- CorInfoHelpFunc getCastingHelper(CORINFO_RESOLVED_TOKEN * pResolvedToken, bool fThrowing);\r
- static CorInfoHelpFunc getCastingHelperStatic(TypeHandle clsHnd, bool fThrowing, bool * pfClassMustBeRestored);\r
-\r
- CorInfoHelpFunc getSharedCCtorHelper(CORINFO_CLASS_HANDLE clsHnd);\r
- CorInfoHelpFunc getSecurityPrologHelper(CORINFO_METHOD_HANDLE ftn);\r
- CORINFO_CLASS_HANDLE getTypeForBox(CORINFO_CLASS_HANDLE cls); \r
- CorInfoHelpFunc getBoxHelper(CORINFO_CLASS_HANDLE cls);\r
- CorInfoHelpFunc getUnBoxHelper(CORINFO_CLASS_HANDLE cls);\r
-\r
- bool getReadyToRunHelper(\r
- CORINFO_RESOLVED_TOKEN * pResolvedToken,\r
- CORINFO_LOOKUP_KIND * pGenericLookupKind,\r
- CorInfoHelpFunc id,\r
- CORINFO_CONST_LOOKUP * pLookup\r
- );\r
-\r
- void getReadyToRunDelegateCtorHelper(\r
- CORINFO_RESOLVED_TOKEN * pTargetMethod,\r
- CORINFO_CLASS_HANDLE delegateType,\r
- CORINFO_CONST_LOOKUP * pLookup\r
- );\r
-\r
- CorInfoInitClassResult initClass(\r
- CORINFO_FIELD_HANDLE field,\r
- CORINFO_METHOD_HANDLE method,\r
- CORINFO_CONTEXT_HANDLE context,\r
- BOOL speculative = FALSE);\r
-\r
- void classMustBeLoadedBeforeCodeIsRun (CORINFO_CLASS_HANDLE cls);\r
- void methodMustBeLoadedBeforeCodeIsRun (CORINFO_METHOD_HANDLE meth);\r
- CORINFO_METHOD_HANDLE mapMethodDeclToMethodImpl(CORINFO_METHOD_HANDLE methHnd);\r
- CORINFO_CLASS_HANDLE getBuiltinClass(CorInfoClassId classId);\r
- void getGSCookie(GSCookie * pCookieVal, GSCookie ** ppCookieVal);\r
-\r
- // "System.Int32" ==> CORINFO_TYPE_INT..\r
- CorInfoType getTypeForPrimitiveValueClass(\r
- CORINFO_CLASS_HANDLE cls\r
- );\r
-\r
- // TRUE if child is a subtype of parent\r
- // if parent is an interface, then does child implement / extend parent\r
- BOOL canCast(\r
- CORINFO_CLASS_HANDLE child,\r
- CORINFO_CLASS_HANDLE parent\r
- );\r
-\r
- // TRUE if cls1 and cls2 are considered equivalent types.\r
- BOOL areTypesEquivalent(\r
- CORINFO_CLASS_HANDLE cls1,\r
- CORINFO_CLASS_HANDLE cls2\r
- );\r
-\r
- // returns is the intersection of cls1 and cls2.\r
- CORINFO_CLASS_HANDLE mergeClasses(\r
- CORINFO_CLASS_HANDLE cls1,\r
- CORINFO_CLASS_HANDLE cls2\r
- );\r
-\r
- // Given a class handle, returns the Parent type.\r
- // For COMObjectType, it returns Class Handle of System.Object.\r
- // Returns 0 if System.Object is passed in.\r
- CORINFO_CLASS_HANDLE getParentType (\r
- CORINFO_CLASS_HANDLE cls\r
- );\r
-\r
- // Returns the CorInfoType of the "child type". If the child type is\r
- // not a primitive type, *clsRet will be set.\r
- // Given an Array of Type Foo, returns Foo.\r
- // Given BYREF Foo, returns Foo\r
- CorInfoType getChildType (\r
- CORINFO_CLASS_HANDLE clsHnd,\r
- CORINFO_CLASS_HANDLE *clsRet\r
- );\r
-\r
- // Check constraints on type arguments of this class and parent classes\r
- BOOL satisfiesClassConstraints(\r
- CORINFO_CLASS_HANDLE cls\r
- );\r
-\r
- // Check if this is a single dimensional array type\r
- BOOL isSDArray(\r
- CORINFO_CLASS_HANDLE cls\r
- );\r
-\r
- // Get the number of dimensions in an array \r
- unsigned getArrayRank(\r
- CORINFO_CLASS_HANDLE cls\r
- );\r
-\r
- // Get static field data for an array\r
- void * getArrayInitializationData(\r
- CORINFO_FIELD_HANDLE field,\r
- DWORD size\r
- );\r
-\r
- // Check Visibility rules.\r
- CorInfoIsAccessAllowedResult canAccessClass(\r
- CORINFO_RESOLVED_TOKEN * pResolvedToken,\r
- CORINFO_METHOD_HANDLE callerHandle,\r
- CORINFO_HELPER_DESC *pAccessHelper /* If canAccessClass returns something other\r
- than ALLOWED, then this is filled in. */\r
- );\r
-\r
- // Returns that compilation flags that are shared between JIT and NGen\r
- static DWORD GetBaseCompileFlags(MethodDesc * ftn);\r
-\r
- // Resolve metadata token into runtime method handles.\r
- void resolveToken(/* IN, OUT */ CORINFO_RESOLVED_TOKEN * pResolvedToken);\r
-\r
- // Attempt to resolve a metadata token into a runtime method handle. Returns true\r
- // if resolution succeeded and false otherwise.\r
- bool tryResolveToken(/* IN, OUT */ CORINFO_RESOLVED_TOKEN * pResolvedToken);\r
-\r
- void getFieldInfo (CORINFO_RESOLVED_TOKEN * pResolvedToken,\r
- CORINFO_METHOD_HANDLE callerHandle,\r
- CORINFO_ACCESS_FLAGS flags,\r
- CORINFO_FIELD_INFO *pResult\r
- );\r
- static CorInfoHelpFunc getSharedStaticsHelper(FieldDesc * pField, MethodTable * pFieldMT);\r
-\r
- bool isFieldStatic(CORINFO_FIELD_HANDLE fldHnd);\r
-\r
- // Given a signature token sigTOK, use class/method instantiation in context to instantiate any type variables in the signature and return a new signature\r
- void findSig(CORINFO_MODULE_HANDLE scopeHnd, unsigned sigTOK, CORINFO_CONTEXT_HANDLE context, CORINFO_SIG_INFO* sig);\r
- void findCallSiteSig(CORINFO_MODULE_HANDLE scopeHnd, unsigned methTOK, CORINFO_CONTEXT_HANDLE context, CORINFO_SIG_INFO* sig);\r
- CORINFO_CLASS_HANDLE getTokenTypeAsHandle(CORINFO_RESOLVED_TOKEN * pResolvedToken);\r
-\r
- size_t findNameOfToken (CORINFO_MODULE_HANDLE module, mdToken metaTOK,\r
- __out_ecount (FQNameCapacity) char * szFQName, size_t FQNameCapacity);\r
-\r
- CorInfoCanSkipVerificationResult canSkipVerification(CORINFO_MODULE_HANDLE moduleHnd);\r
-\r
- // Checks if the given metadata token is valid\r
- BOOL isValidToken (\r
- CORINFO_MODULE_HANDLE module,\r
- mdToken metaTOK);\r
-\r
- // Checks if the given metadata token is valid StringRef\r
- BOOL isValidStringRef (\r
- CORINFO_MODULE_HANDLE module,\r
- mdToken metaTOK);\r
-\r
- static size_t findNameOfToken (Module* module, mdToken metaTOK, \r
- __out_ecount (FQNameCapacity) char * szFQName, size_t FQNameCapacity);\r
-\r
- // ICorMethodInfo stuff\r
- const char* getMethodName (CORINFO_METHOD_HANDLE ftnHnd, const char** scopeName);\r
- unsigned getMethodHash (CORINFO_METHOD_HANDLE ftnHnd);\r
-\r
- DWORD getMethodAttribs (CORINFO_METHOD_HANDLE ftnHnd);\r
- // Internal version without JIT-EE transition\r
- DWORD getMethodAttribsInternal (CORINFO_METHOD_HANDLE ftnHnd);\r
-\r
- void setMethodAttribs (CORINFO_METHOD_HANDLE ftnHnd, CorInfoMethodRuntimeFlags attribs);\r
-\r
- bool getMethodInfo (\r
- CORINFO_METHOD_HANDLE ftnHnd,\r
- CORINFO_METHOD_INFO* methInfo);\r
-\r
- CorInfoInline canInline (\r
- CORINFO_METHOD_HANDLE callerHnd,\r
- CORINFO_METHOD_HANDLE calleeHnd,\r
- DWORD* pRestrictions);\r
-\r
- void reportInliningDecision (CORINFO_METHOD_HANDLE inlinerHnd,\r
- CORINFO_METHOD_HANDLE inlineeHnd,\r
- CorInfoInline inlineResult,\r
- const char * reason);\r
-\r
- // Used by ngen\r
- CORINFO_METHOD_HANDLE instantiateMethodAtObject(CORINFO_METHOD_HANDLE method);\r
-\r
- // Loads the constraints on a typical method definition, detecting cycles;\r
- // used by verifiers.\r
- void initConstraintsForVerification(\r
- CORINFO_METHOD_HANDLE method,\r
- BOOL *pfHasCircularClassConstraints,\r
- BOOL *pfHasCircularMethodConstraints\r
- );\r
-\r
- CorInfoInstantiationVerification isInstantiationOfVerifiedGeneric (\r
- CORINFO_METHOD_HANDLE methodHnd);\r
-\r
-\r
- bool canTailCall (\r
- CORINFO_METHOD_HANDLE callerHnd,\r
- CORINFO_METHOD_HANDLE declaredCalleeHnd,\r
- CORINFO_METHOD_HANDLE exactCalleeHnd,\r
- bool fIsTailPrefix);\r
-\r
- void reportTailCallDecision (CORINFO_METHOD_HANDLE callerHnd,\r
- CORINFO_METHOD_HANDLE calleeHnd,\r
- bool fIsTailPrefix,\r
- CorInfoTailCall tailCallResult,\r
- const char * reason);\r
-\r
- CorInfoCanSkipVerificationResult canSkipMethodVerification(\r
- CORINFO_METHOD_HANDLE ftnHnd);\r
- \r
- // Given a method descriptor ftnHnd, extract signature information into sigInfo\r
- // Obtain (representative) instantiation information from ftnHnd's owner class\r
- //@GENERICSVER: added explicit owner parameter\r
- void getMethodSig (\r
- CORINFO_METHOD_HANDLE ftnHnd,\r
- CORINFO_SIG_INFO* sigInfo,\r
- CORINFO_CLASS_HANDLE owner = NULL\r
- );\r
- // Internal version without JIT-EE transition\r
- void getMethodSigInternal (\r
- CORINFO_METHOD_HANDLE ftnHnd,\r
- CORINFO_SIG_INFO* sigInfo,\r
- CORINFO_CLASS_HANDLE owner = NULL\r
- );\r
-\r
- void getEHinfo(\r
- CORINFO_METHOD_HANDLE ftn,\r
- unsigned EHnumber,\r
- CORINFO_EH_CLAUSE* clause);\r
-\r
- CORINFO_CLASS_HANDLE getMethodClass (CORINFO_METHOD_HANDLE methodHnd);\r
- CORINFO_MODULE_HANDLE getMethodModule (CORINFO_METHOD_HANDLE methodHnd);\r
-\r
- void getMethodVTableOffset (\r
- CORINFO_METHOD_HANDLE methodHnd,\r
- unsigned * pOffsetOfIndirection,\r
- unsigned * pOffsetAfterIndirection\r
- );\r
-\r
- CorInfoIntrinsics getIntrinsicID(CORINFO_METHOD_HANDLE method,\r
- bool * pMustExpand = NULL);\r
-\r
- bool isInSIMDModule(CORINFO_CLASS_HANDLE classHnd);\r
-\r
- CorInfoUnmanagedCallConv getUnmanagedCallConv(CORINFO_METHOD_HANDLE method);\r
- BOOL pInvokeMarshalingRequired(CORINFO_METHOD_HANDLE method, CORINFO_SIG_INFO* callSiteSig);\r
-\r
- // Generate a cookie based on the signature that would needs to be passed\r
- // to the above generic stub\r
- LPVOID GetCookieForPInvokeCalliSig(CORINFO_SIG_INFO* szMetaSig, void ** ppIndirection);\r
- bool canGetCookieForPInvokeCalliSig(CORINFO_SIG_INFO* szMetaSig);\r
- \r
- // Check Visibility rules.\r
-\r
- // should we enforce the new (for whidbey) restrictions on calling virtual methods?\r
- BOOL shouldEnforceCallvirtRestriction(\r
- CORINFO_MODULE_HANDLE scope);\r
-\r
- // Check constraints on method type arguments (only).\r
- // The parent class should be checked separately using satisfiesClassConstraints(parent).\r
- BOOL satisfiesMethodConstraints(\r
- CORINFO_CLASS_HANDLE parent, // the exact parent of the method\r
- CORINFO_METHOD_HANDLE method\r
- );\r
-\r
- // Given a Delegate type and a method, check if the method signature\r
- // is Compatible with the Invoke method of the delegate.\r
- //@GENERICSVER: new (suitable for generics)\r
- BOOL isCompatibleDelegate(\r
- CORINFO_CLASS_HANDLE objCls,\r
- CORINFO_CLASS_HANDLE methodParentCls,\r
- CORINFO_METHOD_HANDLE method,\r
- CORINFO_CLASS_HANDLE delegateCls,\r
- BOOL* pfIsOpenDelegate);\r
-\r
- // Determines whether the delegate creation obeys security transparency rules\r
- BOOL isDelegateCreationAllowed (\r
- CORINFO_CLASS_HANDLE delegateHnd,\r
- CORINFO_METHOD_HANDLE calleeHnd);\r
-\r
- // ICorFieldInfo stuff\r
- const char* getFieldName (CORINFO_FIELD_HANDLE field,\r
- const char** scopeName);\r
-\r
- CORINFO_CLASS_HANDLE getFieldClass (CORINFO_FIELD_HANDLE field);\r
-\r
- //@GENERICSVER: added owner parameter\r
- CorInfoType getFieldType (CORINFO_FIELD_HANDLE field, CORINFO_CLASS_HANDLE* structType,CORINFO_CLASS_HANDLE owner = NULL);\r
- // Internal version without JIT-EE transition\r
- CorInfoType getFieldTypeInternal (CORINFO_FIELD_HANDLE field, CORINFO_CLASS_HANDLE* structType,CORINFO_CLASS_HANDLE owner = NULL);\r
-\r
- unsigned getFieldOffset (CORINFO_FIELD_HANDLE field);\r
-\r
- bool isWriteBarrierHelperRequired(CORINFO_FIELD_HANDLE field);\r
-\r
- void* getFieldAddress(CORINFO_FIELD_HANDLE field, void **ppIndirection);\r
-\r
- // ICorDebugInfo stuff\r
- void * allocateArray(ULONG cBytes);\r
- void freeArray(void *array);\r
- void getBoundaries(CORINFO_METHOD_HANDLE ftn,\r
- unsigned int *cILOffsets, DWORD **pILOffsets,\r
- ICorDebugInfo::BoundaryTypes *implictBoundaries);\r
- void setBoundaries(CORINFO_METHOD_HANDLE ftn,\r
- ULONG32 cMap, ICorDebugInfo::OffsetMapping *pMap);\r
- void getVars(CORINFO_METHOD_HANDLE ftn, ULONG32 *cVars,\r
- ICorDebugInfo::ILVarInfo **vars, bool *extendOthers);\r
- void setVars(CORINFO_METHOD_HANDLE ftn, ULONG32 cVars,\r
- ICorDebugInfo::NativeVarInfo *vars);\r
-\r
- // ICorArgInfo stuff\r
-\r
- CorInfoTypeWithMod getArgType (\r
- CORINFO_SIG_INFO* sig,\r
- CORINFO_ARG_LIST_HANDLE args,\r
- CORINFO_CLASS_HANDLE *vcTypeRet\r
- );\r
-\r
- CORINFO_CLASS_HANDLE getArgClass (\r
- CORINFO_SIG_INFO* sig,\r
- CORINFO_ARG_LIST_HANDLE args\r
- );\r
-\r
- CorInfoType getHFAType (\r
- CORINFO_CLASS_HANDLE hClass\r
- );\r
-\r
- CORINFO_ARG_LIST_HANDLE getArgNext (\r
- CORINFO_ARG_LIST_HANDLE args\r
- );\r
-\r
- // ICorErrorInfo stuff\r
-\r
- HRESULT GetErrorHRESULT(struct _EXCEPTION_POINTERS *pExceptionPointers);\r
- ULONG GetErrorMessage(__out_ecount(bufferLength) LPWSTR buffer,\r
- ULONG bufferLength);\r
- int FilterException(struct _EXCEPTION_POINTERS *pExceptionPointers);\r
- void HandleException(struct _EXCEPTION_POINTERS *pExceptionPointers);\r
- void ThrowExceptionForJitResult(HRESULT result);\r
- void ThrowExceptionForHelper(const CORINFO_HELPER_DESC * throwHelper);\r
-\r
- // ICorStaticInfo stuff\r
- void getEEInfo(CORINFO_EE_INFO *pEEInfoOut);\r
-\r
- LPCWSTR getJitTimeLogFilename();\r
-\r
- //ICorDynamicInfo stuff\r
- DWORD getFieldThreadLocalStoreID (CORINFO_FIELD_HANDLE field, void **ppIndirection);\r
-\r
- // Stub dispatch stuff\r
- void getCallInfo(\r
- CORINFO_RESOLVED_TOKEN * pResolvedToken,\r
- CORINFO_RESOLVED_TOKEN * pConstrainedResolvedToken,\r
- CORINFO_METHOD_HANDLE callerHandle,\r
- CORINFO_CALLINFO_FLAGS flags,\r
- CORINFO_CALL_INFO *pResult /*out */);\r
- BOOL canAccessFamily(CORINFO_METHOD_HANDLE hCaller,\r
- CORINFO_CLASS_HANDLE hInstanceType);\r
-\r
-protected:\r
-\r
- static void getEHinfoHelper(\r
- CORINFO_METHOD_HANDLE ftnHnd,\r
- unsigned EHnumber,\r
- CORINFO_EH_CLAUSE* clause,\r
- COR_ILMETHOD_DECODER* pILHeader);\r
-\r
- bool isVerifyOnly()\r
- {\r
- return m_fVerifyOnly;\r
- }\r
-\r
-public:\r
-\r
- BOOL isRIDClassDomainID(CORINFO_CLASS_HANDLE cls);\r
- unsigned getClassDomainID (CORINFO_CLASS_HANDLE cls, void **ppIndirection);\r
- CORINFO_VARARGS_HANDLE getVarArgsHandle(CORINFO_SIG_INFO *sig, void **ppIndirection);\r
- bool canGetVarArgsHandle(CORINFO_SIG_INFO *sig);\r
- void* getPInvokeUnmanagedTarget(CORINFO_METHOD_HANDLE method, void **ppIndirection);\r
- void* getAddressOfPInvokeFixup(CORINFO_METHOD_HANDLE method, void **ppIndirection);\r
- void getAddressOfPInvokeTarget(CORINFO_METHOD_HANDLE method, CORINFO_CONST_LOOKUP *pLookup);\r
- CORINFO_JUST_MY_CODE_HANDLE getJustMyCodeHandle(CORINFO_METHOD_HANDLE method, CORINFO_JUST_MY_CODE_HANDLE **ppIndirection);\r
-\r
- void GetProfilingHandle(\r
- BOOL *pbHookFunction,\r
- void **pProfilerHandle,\r
- BOOL *pbIndirectedHandles\r
- );\r
-\r
- InfoAccessType constructStringLiteral(CORINFO_MODULE_HANDLE scopeHnd, mdToken metaTok, void **ppValue);\r
- InfoAccessType emptyStringLiteral(void ** ppValue);\r
- void* getMethodSync(CORINFO_METHOD_HANDLE ftnHnd, void **ppIndirection);\r
-\r
- DWORD getThreadTLSIndex(void **ppIndirection);\r
- const void * getInlinedCallFrameVptr(void **ppIndirection);\r
-\r
- // Returns the address of the domain neutral module id. This only makes sense for domain neutral (shared)\r
- // modules\r
- SIZE_T* getAddrModuleDomainID(CORINFO_MODULE_HANDLE module);\r
-\r
- LONG * getAddrOfCaptureThreadGlobal(void **ppIndirection);\r
- void* getHelperFtn(CorInfoHelpFunc ftnNum, /* IN */\r
- void ** ppIndirection); /* OUT */\r
-\r
- void* getTailCallCopyArgsThunk(CORINFO_SIG_INFO *pSig,\r
- CorInfoHelperTailCallSpecialHandling flags);\r
-\r
- void getFunctionEntryPoint(CORINFO_METHOD_HANDLE ftn, /* IN */\r
- CORINFO_CONST_LOOKUP * pResult, /* OUT */\r
- CORINFO_ACCESS_FLAGS accessFlags = CORINFO_ACCESS_ANY);\r
-\r
- void getFunctionFixedEntryPoint(CORINFO_METHOD_HANDLE ftn,\r
- CORINFO_CONST_LOOKUP * pResult);\r
-\r
- // get slow lazy string literal helper to use (CORINFO_HELP_STRCNS*). \r
- // Returns CORINFO_HELP_UNDEF if lazy string literal helper cannot be used.\r
- CorInfoHelpFunc getLazyStringLiteralHelper(CORINFO_MODULE_HANDLE handle);\r
-\r
- CORINFO_MODULE_HANDLE embedModuleHandle(CORINFO_MODULE_HANDLE handle,\r
- void **ppIndirection);\r
- CORINFO_CLASS_HANDLE embedClassHandle(CORINFO_CLASS_HANDLE handle,\r
- void **ppIndirection);\r
- CORINFO_FIELD_HANDLE embedFieldHandle(CORINFO_FIELD_HANDLE handle,\r
- void **ppIndirection);\r
- CORINFO_METHOD_HANDLE embedMethodHandle(CORINFO_METHOD_HANDLE handle,\r
- void **ppIndirection);\r
-\r
- void embedGenericHandle(CORINFO_RESOLVED_TOKEN * pResolvedToken,\r\r
- BOOL fEmbedParent,\r\r
- CORINFO_GENERICHANDLE_RESULT *pResult);\r
-\r
- CORINFO_LOOKUP_KIND getLocationOfThisType(CORINFO_METHOD_HANDLE context);\r
-\r
-\r
- void setOverride(ICorDynamicInfo *pOverride, CORINFO_METHOD_HANDLE currentMethod)\r
- {\r
- LIMITED_METHOD_CONTRACT;\r
- m_pOverride = pOverride;\r
- m_pMethodBeingCompiled = (MethodDesc *)currentMethod; // method being compiled\r
-\r
- m_hMethodForSecurity_Key = NULL;\r
- m_pMethodForSecurity_Value = NULL;\r
- }\r
-\r
- // Returns whether we are generating code for NGen image.\r
- BOOL IsCompilingForNGen()\r
- {\r
- LIMITED_METHOD_CONTRACT;\r
- // NGen is the only place where we set the override\r
- return this != m_pOverride;\r
- }\r
-\r
- void addActiveDependency(CORINFO_MODULE_HANDLE moduleFrom, CORINFO_MODULE_HANDLE moduleTo);\r
- CORINFO_METHOD_HANDLE GetDelegateCtor(\r
- CORINFO_METHOD_HANDLE methHnd,\r
- CORINFO_CLASS_HANDLE clsHnd,\r
- CORINFO_METHOD_HANDLE targetMethodHnd,\r
- DelegateCtorArgs * pCtorData);\r
-\r
- void MethodCompileComplete(\r
- CORINFO_METHOD_HANDLE methHnd);\r
-\r
- //\r
- // ICorJitInfo stuff - none of this should be called on this class\r
- //\r
-\r
- IEEMemoryManager* getMemoryManager();\r
-\r
- void allocMem (\r
- ULONG hotCodeSize, /* IN */\r
- ULONG coldCodeSize, /* IN */\r
- ULONG roDataSize, /* IN */\r
- ULONG xcptnsCount, /* IN */\r
- CorJitAllocMemFlag flag, /* IN */\r
- void ** hotCodeBlock, /* OUT */\r
- void ** coldCodeBlock, /* OUT */\r
- void ** roDataBlock /* OUT */\r
- );\r
-\r
- void reserveUnwindInfo (\r
- BOOL isFunclet, /* IN */\r
- BOOL isColdCode, /* IN */\r
- ULONG unwindSize /* IN */\r
- );\r
-\r
- void allocUnwindInfo (\r
- BYTE * pHotCode, /* IN */\r
- BYTE * pColdCode, /* IN */\r
- ULONG startOffset, /* IN */\r
- ULONG endOffset, /* IN */\r
- ULONG unwindSize, /* IN */\r
- BYTE * pUnwindBlock, /* IN */\r
- CorJitFuncKind funcKind /* IN */\r
- );\r
-\r
- void * allocGCInfo (\r
- size_t size /* IN */\r
- );\r
-\r
- void yieldExecution();\r
-\r
- void setEHcount (\r
- unsigned cEH /* IN */\r
- );\r
-\r
- void setEHinfo (\r
- unsigned EHnumber, /* IN */\r
- const CORINFO_EH_CLAUSE *clause /* IN */\r
- );\r
-\r
- BOOL logMsg(unsigned level, const char* fmt, va_list args);\r
-\r
- int doAssert(const char* szFile, int iLine, const char* szExpr);\r
- \r
- void reportFatalError(CorJitResult result);\r
-\r
- void logSQMLongJitEvent(unsigned mcycles, unsigned msec, unsigned ilSize, unsigned numBasicBlocks, bool minOpts, \r
- CORINFO_METHOD_HANDLE methodHnd);\r
-\r
- HRESULT allocBBProfileBuffer (\r
- ULONG count, // The number of basic blocks that we have\r
- ProfileBuffer ** profileBuffer\r
- );\r
-\r
- HRESULT getBBProfileData(\r
- CORINFO_METHOD_HANDLE ftnHnd,\r
- ULONG * count, // The number of basic blocks that we have\r
- ProfileBuffer ** profileBuffer,\r
- ULONG * numRuns\r
- );\r
-\r
- void recordCallSite(\r
- ULONG instrOffset, /* IN */\r
- CORINFO_SIG_INFO * callSig, /* IN */\r
- CORINFO_METHOD_HANDLE methodHandle /* IN */\r
- );\r
-\r
- void recordRelocation(\r
- void * location, /* IN */\r
- void * target, /* IN */\r
- WORD fRelocType, /* IN */\r
- WORD slotNum = 0, /* IN */\r
- INT32 addlDelta = 0 /* IN */\r
- );\r
-\r
- WORD getRelocTypeHint(void * target);\r
-\r
- void getModuleNativeEntryPointRange(\r
- void ** pStart, /* OUT */\r
- void ** pEnd /* OUT */\r
- );\r
-\r
- DWORD getExpectedTargetArchitecture();\r
-\r
- CEEInfo(MethodDesc * fd = NULL, bool fVerifyOnly = false) :\r
- m_pOverride(NULL),\r
- m_pMethodBeingCompiled(fd),\r
- m_fVerifyOnly(fVerifyOnly),\r
- m_pThread(GetThread()),\r
- m_hMethodForSecurity_Key(NULL),\r
- m_pMethodForSecurity_Value(NULL)\r
- {\r
- LIMITED_METHOD_CONTRACT;\r
- }\r
-\r
- virtual ~CEEInfo()\r
- {\r
- LIMITED_METHOD_CONTRACT;\r
- }\r
-\r
- // Performs any work JIT-related work that should be performed at process shutdown.\r
- void JitProcessShutdownWork();\r
-\r
- void setJitFlags(const CORJIT_FLAGS& jitFlags);\r
-\r
- DWORD getJitFlags(CORJIT_FLAGS* jitFlags, DWORD sizeInBytes);\r
-\r
- bool runWithErrorTrap(void (*function)(void*), void* param);\r
-\r
-private:\r
- // Shrinking these buffers drastically reduces the amount of stack space\r
- // required for each instance of the interpreter, and thereby reduces SOs.\r
-#ifdef FEATURE_INTERPRETER\r
-#define CLS_STRING_SIZE 8 // force heap allocation\r
-#define CLS_BUFFER_SIZE SBUFFER_PADDED_SIZE(8)\r
-#else\r
-#define CLS_STRING_SIZE MAX_CLASSNAME_LENGTH\r
-#define CLS_BUFFER_SIZE MAX_CLASSNAME_LENGTH\r
-#endif\r
-\r
-#ifdef _DEBUG\r
- InlineSString<MAX_CLASSNAME_LENGTH> ssClsNameBuff;\r
- ScratchBuffer<MAX_CLASSNAME_LENGTH> ssClsNameBuffScratch;\r
-#endif\r
-\r
-public:\r
-\r
- //@GENERICS:\r
- // The method handle is used to instantiate method and class type parameters\r
- // It's also used to determine whether an extra dictionary parameter is required\r
- static \r
- void \r
- ConvToJitSig(\r
- PCCOR_SIGNATURE pSig, \r
- DWORD cbSig, \r
- CORINFO_MODULE_HANDLE scopeHnd, \r
- mdToken token, \r
- CORINFO_SIG_INFO * sigRet, \r
- MethodDesc * context, \r
- bool localSig, \r
- TypeHandle owner = TypeHandle());\r
-\r
- MethodDesc * GetMethodForSecurity(CORINFO_METHOD_HANDLE callerHandle);\r
-\r
- // Prepare the information about how to do a runtime lookup of the handle with shared\r\r
- // generic variables.\r\r
- void ComputeRuntimeLookupForSharedGenericToken(DictionaryEntryKind entryKind,\r\r
- CORINFO_RESOLVED_TOKEN * pResolvedToken,\r\r
- CORINFO_RESOLVED_TOKEN * pConstrainedResolvedToken /* for ConstrainedMethodEntrySlot */,\r\r
- MethodDesc * pTemplateMD /* for method-based slots */,\r\r
- CORINFO_LOOKUP *pResultLookup);\r\r
-\r\r
- static void ComputeRuntimeLookupForSharedGenericTokenStatic(DictionaryEntryKind entryKind,\r\r
- CORINFO_RESOLVED_TOKEN * pResolvedToken,\r\r
- CORINFO_RESOLVED_TOKEN * pConstrainedResolvedToken /* for ConstrainedMethodEntrySlot */,\r\r
- MethodDesc * pTemplateMD /* for method-based slots */,\r\r
- LoaderAllocator* pAllocator,\r\r
- DWORD numGenericArgs,\r\r
- DictionaryLayout* pDictionaryLayout,\r\r
- DWORD typeDictionaryIndex,\r\r
- CORINFO_LOOKUP *pResultLookup,\r\r
- BOOL fEnableTypeHandleLookupOptimization,\r\r
- BOOL fInstrument);\r\r
-\r
-protected:\r
- // NGen provides its own modifications to EE-JIT interface. From technical reason it cannot simply inherit \r
- // from code:CEEInfo class (because it has dependencies on VM that NGen does not want).\r
- // Therefore the "normal" EE-JIT interface has code:m_pOverride hook that is set either to \r
- // * 'this' (code:CEEInfo) at runtime, or to \r
- // * code:ZapInfo - the NGen specific implementation of the interface.\r
- ICorDynamicInfo * m_pOverride;\r
- \r
- MethodDesc* m_pMethodBeingCompiled; // Top-level method being compiled\r
- bool m_fVerifyOnly;\r
- Thread * m_pThread; // Cached current thread for faster JIT-EE transitions\r
- CORJIT_FLAGS m_jitFlags;\r
-\r
- CORINFO_METHOD_HANDLE getMethodBeingCompiled()\r
- {\r
- LIMITED_METHOD_CONTRACT;\r
- return (CORINFO_METHOD_HANDLE)m_pMethodBeingCompiled;\r
- }\r
-\r
- // Cache of last GetMethodForSecurity() lookup\r
- CORINFO_METHOD_HANDLE m_hMethodForSecurity_Key;\r
- MethodDesc * m_pMethodForSecurity_Value;\r
-\r
- // Tracking of module activation dependencies. We have two flavors: \r
- // - Fast one that gathers generic arguments from EE handles, but does not work inside generic context.\r
- // - Slow one that operates on typespec and methodspecs from metadata.\r
- void ScanForModuleDependencies(Module* pModule, SigPointer psig);\r
- void ScanMethodSpec(Module * pModule, PCCOR_SIGNATURE pMethodSpec, ULONG cbMethodSpec);\r
- // Returns true if it is ok to proceed with scan of parent chain\r
- BOOL ScanTypeSpec(Module * pModule, PCCOR_SIGNATURE pTypeSpec, ULONG cbTypeSpec);\r
- void ScanInstantiation(Module * pModule, Instantiation inst);\r
-\r
- // The main entrypoints for module activation tracking\r
- void ScanToken(Module * pModule, CORINFO_RESOLVED_TOKEN * pResolvedToken, TypeHandle th, MethodDesc * pMD = NULL);\r
- void ScanTokenForDynamicScope(CORINFO_RESOLVED_TOKEN * pResolvedToken, TypeHandle th, MethodDesc * pMD = NULL);\r
-};\r
-\r
-\r
-/*********************************************************************/\r
-\r
-class EEJitManager;\r
-struct _hpCodeHdr;\r
-typedef struct _hpCodeHdr CodeHeader;\r
-\r
-#ifndef CROSSGEN_COMPILE\r
-// CEEJitInfo is the concrete implementation of callbacks that the EE must provide for the JIT to do its\r
-// work. See code:ICorJitInfo#JitToEEInterface for more on this interface. \r
-class CEEJitInfo : public CEEInfo\r
-{\r
-public:\r
- // ICorJitInfo stuff\r
-\r
- void allocMem (\r
- ULONG hotCodeSize, /* IN */\r
- ULONG coldCodeSize, /* IN */\r
- ULONG roDataSize, /* IN */\r
- ULONG xcptnsCount, /* IN */\r
- CorJitAllocMemFlag flag, /* IN */\r
- void ** hotCodeBlock, /* OUT */\r
- void ** coldCodeBlock, /* OUT */\r
- void ** roDataBlock /* OUT */\r
- );\r
-\r
- void reserveUnwindInfo(BOOL isFunclet, BOOL isColdCode, ULONG unwindSize);\r
-\r
- void allocUnwindInfo (\r
- BYTE * pHotCode, /* IN */\r
- BYTE * pColdCode, /* IN */\r
- ULONG startOffset, /* IN */\r
- ULONG endOffset, /* IN */\r
- ULONG unwindSize, /* IN */\r
- BYTE * pUnwindBlock, /* IN */\r
- CorJitFuncKind funcKind /* IN */\r
- );\r
-\r
- void * allocGCInfo (size_t size);\r
-\r
- void setEHcount (unsigned cEH);\r
-\r
- void setEHinfo (\r
- unsigned EHnumber,\r
- const CORINFO_EH_CLAUSE* clause);\r
-\r
- void getEHinfo(\r
- CORINFO_METHOD_HANDLE ftn, /* IN */\r
- unsigned EHnumber, /* IN */\r
- CORINFO_EH_CLAUSE* clause /* OUT */\r
- );\r
-\r
-\r
- HRESULT allocBBProfileBuffer (\r
- ULONG count, // The number of basic blocks that we have\r
- ICorJitInfo::ProfileBuffer ** profileBuffer\r
- );\r
-\r
- HRESULT getBBProfileData (\r
- CORINFO_METHOD_HANDLE ftnHnd,\r
- ULONG * count, // The number of basic blocks that we have\r
- ICorJitInfo::ProfileBuffer ** profileBuffer,\r
- ULONG * numRuns\r
- );\r
-\r
- void recordCallSite(\r
- ULONG instrOffset, /* IN */\r
- CORINFO_SIG_INFO * callSig, /* IN */\r
- CORINFO_METHOD_HANDLE methodHandle /* IN */\r
- );\r
-\r
- void recordRelocation(\r
- void *location,\r
- void *target,\r
- WORD fRelocType,\r
- WORD slot,\r
- INT32 addlDelta);\r
-\r
- WORD getRelocTypeHint(void * target);\r
-\r
- void getModuleNativeEntryPointRange(\r
- void** pStart,\r
- void** pEnd);\r
-\r
- DWORD getExpectedTargetArchitecture();\r
-\r
- CodeHeader* GetCodeHeader()\r
- {\r
- LIMITED_METHOD_CONTRACT;\r
- return m_CodeHeader;\r
- }\r
-\r
- void SetCodeHeader(CodeHeader* pValue)\r
- {\r
- LIMITED_METHOD_CONTRACT;\r
- m_CodeHeader = pValue;\r
- }\r
-\r
- void ResetForJitRetry()\r
- {\r
- CONTRACTL {\r
- SO_TOLERANT;\r
- NOTHROW;\r
- GC_NOTRIGGER;\r
- } CONTRACTL_END;\r
-\r
- m_CodeHeader = NULL;\r
-\r
- if (m_pOffsetMapping != NULL)\r
- delete [] ((BYTE*) m_pOffsetMapping);\r
-\r
- if (m_pNativeVarInfo != NULL)\r
- delete [] ((BYTE*) m_pNativeVarInfo);\r
-\r
- m_iOffsetMapping = 0;\r
- m_pOffsetMapping = NULL;\r
- m_iNativeVarInfo = 0;\r
- m_pNativeVarInfo = NULL;\r
-\r
-#ifdef WIN64EXCEPTIONS\r
- m_moduleBase = NULL;\r
- m_totalUnwindSize = 0;\r
- m_usedUnwindSize = 0;\r
- m_theUnwindBlock = NULL;\r
- m_totalUnwindInfos = 0;\r
- m_usedUnwindInfos = 0;\r
-#endif // WIN64EXCEPTIONS\r
- }\r
-\r
-#ifdef _TARGET_AMD64_\r
- void SetAllowRel32(BOOL fAllowRel32)\r
- {\r
- LIMITED_METHOD_CONTRACT;\r
- m_fAllowRel32 = fAllowRel32;\r
- }\r
-\r
- void SetRel32Overflow(BOOL fRel32Overflow)\r
- {\r
- LIMITED_METHOD_CONTRACT;\r
- m_fRel32Overflow = fRel32Overflow;\r
- }\r
-\r
- BOOL IsRel32Overflow()\r
- {\r
- LIMITED_METHOD_CONTRACT;\r
- return m_fRel32Overflow;\r
- }\r
-\r
- BOOL JitAgain()\r
- {\r
- LIMITED_METHOD_CONTRACT;\r
- return m_fRel32Overflow;\r
- }\r
-#else\r
- BOOL JitAgain()\r
- {\r
- LIMITED_METHOD_CONTRACT;\r
- return FALSE;\r
- }\r
-#endif\r
-\r
- CEEJitInfo(MethodDesc* fd, COR_ILMETHOD_DECODER* header, \r
- EEJitManager* jm, bool fVerifyOnly)\r
- : CEEInfo(fd, fVerifyOnly),\r
- m_jitManager(jm),\r
- m_CodeHeader(NULL),\r
- m_ILHeader(header),\r
-#ifdef WIN64EXCEPTIONS\r
- m_moduleBase(NULL),\r
- m_totalUnwindSize(0),\r
- m_usedUnwindSize(0),\r
- m_theUnwindBlock(NULL),\r
- m_totalUnwindInfos(0),\r
- m_usedUnwindInfos(0),\r
-#endif\r
-#ifdef _TARGET_AMD64_\r
- m_fAllowRel32(FALSE),\r
- m_fRel32Overflow(FALSE),\r
-#endif\r
- m_GCinfo_len(0),\r
- m_EHinfo_len(0),\r
- m_iOffsetMapping(0),\r
- m_pOffsetMapping(NULL),\r
- m_iNativeVarInfo(0),\r
- m_pNativeVarInfo(NULL),\r
- m_gphCache()\r
- {\r
- CONTRACTL\r
- {\r
- NOTHROW;\r
- GC_NOTRIGGER;\r
- MODE_ANY;\r
- } CONTRACTL_END;\r
-\r
- m_pOverride = this;\r
- }\r
-\r
- ~CEEJitInfo()\r
- {\r
- CONTRACTL\r
- {\r
- NOTHROW;\r
- GC_NOTRIGGER;\r
- MODE_ANY;\r
- } CONTRACTL_END;\r
-\r
- if (m_pOffsetMapping != NULL)\r
- delete [] ((BYTE*) m_pOffsetMapping);\r
-\r
- if (m_pNativeVarInfo != NULL)\r
- delete [] ((BYTE*) m_pNativeVarInfo);\r
- }\r
-\r
- // ICorDebugInfo stuff.\r
- void setBoundaries(CORINFO_METHOD_HANDLE ftn,\r
- ULONG32 cMap, ICorDebugInfo::OffsetMapping *pMap);\r
- void setVars(CORINFO_METHOD_HANDLE ftn, ULONG32 cVars,\r
- ICorDebugInfo::NativeVarInfo *vars);\r
- void CompressDebugInfo();\r
-\r
- void* getHelperFtn(CorInfoHelpFunc ftnNum, /* IN */\r
- void ** ppIndirection); /* OUT */\r
- static PCODE getHelperFtnStatic(CorInfoHelpFunc ftnNum);\r
-\r
- // Override active dependency to talk to loader\r
- void addActiveDependency(CORINFO_MODULE_HANDLE moduleFrom, CORINFO_MODULE_HANDLE moduleTo);\r
-\r
- // Override of CEEInfo::GetProfilingHandle. The first time this is called for a\r
- // method desc, it calls through to CEEInfo::GetProfilingHandle and caches the\r
- // result in CEEJitInfo::GetProfilingHandleCache. Thereafter, this wrapper regurgitates the cached values\r
- // rather than calling into CEEInfo::GetProfilingHandle each time. This avoids\r
- // making duplicate calls into the profiler's FunctionIDMapper callback.\r
- void GetProfilingHandle(\r
- BOOL *pbHookFunction,\r
- void **pProfilerHandle,\r
- BOOL *pbIndirectedHandles\r
- );\r
-\r
- InfoAccessType constructStringLiteral(CORINFO_MODULE_HANDLE scopeHnd, mdToken metaTok, void **ppValue);\r
- InfoAccessType emptyStringLiteral(void ** ppValue);\r
- void* getFieldAddress(CORINFO_FIELD_HANDLE field, void **ppIndirection);\r
- void* getMethodSync(CORINFO_METHOD_HANDLE ftnHnd, void **ppIndirection);\r
-\r
- void BackoutJitData(EEJitManager * jitMgr);\r
-\r
-protected :\r
- EEJitManager* m_jitManager; // responsible for allocating memory\r
- CodeHeader* m_CodeHeader; // descriptor for JITTED code\r
- COR_ILMETHOD_DECODER * m_ILHeader; // the code header as exist in the file\r
-#ifdef WIN64EXCEPTIONS\r
- TADDR m_moduleBase; // Base for unwind Infos\r
- ULONG m_totalUnwindSize; // Total reserved unwind space\r
- ULONG m_usedUnwindSize; // used space in m_theUnwindBlock\r
- BYTE * m_theUnwindBlock; // start of the unwind memory block\r
- ULONG m_totalUnwindInfos; // Number of RUNTIME_FUNCTION needed\r
- ULONG m_usedUnwindInfos;\r
-#endif\r
-\r
-#ifdef _TARGET_AMD64_\r
- BOOL m_fAllowRel32; // Use 32-bit PC relative address modes\r
- BOOL m_fRel32Overflow; // Overflow while trying to use encode 32-bit PC relative address. \r
- // The code will need to be regenerated with m_fRel32Allowed == FALSE.\r
-#endif\r
-\r
-#if defined(_DEBUG)\r
- ULONG m_codeSize; // Code size requested via allocMem\r
-#endif\r
-\r
- size_t m_GCinfo_len; // Cached copy of GCinfo_len so we can backout in BackoutJitData()\r
- size_t m_EHinfo_len; // Cached copy of EHinfo_len so we can backout in BackoutJitData()\r
-\r
- ULONG32 m_iOffsetMapping;\r
- ICorDebugInfo::OffsetMapping * m_pOffsetMapping;\r
-\r
- ULONG32 m_iNativeVarInfo;\r
- ICorDebugInfo::NativeVarInfo * m_pNativeVarInfo;\r
-\r
- // The first time a call is made to CEEJitInfo::GetProfilingHandle() from this thread\r
- // for this method, these values are filled in. Thereafter, these values are used\r
- // in lieu of calling into the base CEEInfo::GetProfilingHandle() again. This protects the\r
- // profiler from duplicate calls to its FunctionIDMapper() callback.\r
- struct GetProfilingHandleCache\r
- {\r
- GetProfilingHandleCache() :\r
- m_bGphIsCacheValid(false),\r
- m_bGphHookFunction(false),\r
- m_pvGphProfilerHandle(NULL)\r
- {\r
- LIMITED_METHOD_CONTRACT;\r
- }\r
- \r
- bool m_bGphIsCacheValid : 1; // Tells us whether below values are valid\r
- bool m_bGphHookFunction : 1;\r
- void* m_pvGphProfilerHandle;\r
- } m_gphCache;\r
-\r
-\r
-};\r
-#endif // CROSSGEN_COMPILE\r
-\r
-/*********************************************************************/\r
-/*********************************************************************/\r
-\r
-typedef struct {\r
- void * pfnHelper;\r
-#ifdef _DEBUG\r
- const char* name;\r
-#endif\r
-} VMHELPDEF;\r
-\r
-#if defined(DACCESS_COMPILE)\r
-\r
-GARY_DECL(VMHELPDEF, hlpFuncTable, CORINFO_HELP_COUNT);\r
-\r
-#else\r
-\r
-extern "C" const VMHELPDEF hlpFuncTable[CORINFO_HELP_COUNT];\r
-\r
-#endif\r
-\r
-#if defined(_DEBUG) && (defined(_TARGET_AMD64_) || defined(_TARGET_X86_)) && !defined(FEATURE_PAL)\r
-typedef struct {\r
- void* pfnRealHelper;\r
- const char* helperName;\r
- LONG count;\r
- LONG helperSize;\r
-} VMHELPCOUNTDEF;\r
-\r
-extern "C" VMHELPCOUNTDEF hlpFuncCountTable[CORINFO_HELP_COUNT+1];\r
-\r
-void InitJitHelperLogging();\r
-void WriteJitHelperCountToSTRESSLOG();\r
-#else\r
-inline void InitJitHelperLogging() { }\r
-inline void WriteJitHelperCountToSTRESSLOG() { }\r
-#endif\r
-\r
-// enum for dynamically assigned helper calls\r
-enum DynamicCorInfoHelpFunc {\r
-#define JITHELPER(code, pfnHelper, sig)\r
-#define DYNAMICJITHELPER(code, pfnHelper, sig) DYNAMIC_##code,\r
-#include "jithelpers.h"\r
- DYNAMIC_CORINFO_HELP_COUNT\r
-};\r
-\r
-#ifdef _MSC_VER\r
-// GCC complains about duplicate "extern". And it is not needed for the GCC build\r
-extern "C"\r
-#endif\r
-GARY_DECL(VMHELPDEF, hlpDynamicFuncTable, DYNAMIC_CORINFO_HELP_COUNT);\r
-\r
-#define SetJitHelperFunction(ftnNum, pFunc) _SetJitHelperFunction(DYNAMIC_##ftnNum, (void*)(pFunc))\r
-void _SetJitHelperFunction(DynamicCorInfoHelpFunc ftnNum, void * pFunc);\r
-#ifdef ENABLE_FAST_GCPOLL_HELPER\r
-//These should only be called from ThreadStore::TrapReturningThreads!\r
-\r
-//Called when the VM wants to suspend one or more threads.\r
-void EnableJitGCPoll();\r
-//Called when there are no threads to suspend.\r
-void DisableJitGCPoll();\r
-#endif\r
-\r
-// Helper for RtlVirtualUnwind-based tail calls\r
-#if defined(_TARGET_AMD64_) || defined(_TARGET_ARM_)\r
-\r
-// The Stub-linker generated assembly routine to copy arguments from the va_list\r
-// into the CONTEXT and the stack.\r
-//\r
-typedef size_t (*pfnCopyArgs)(va_list, _CONTEXT *, DWORD_PTR *, size_t);\r
-\r
-// Forward declaration from Frames.h\r
-class TailCallFrame;\r
-\r
-// The shared stub return location\r
-EXTERN_C void JIT_TailCallHelperStub_ReturnAddress();\r
-\r
-#endif // _TARGET_AMD64_ || _TARGET_ARM_\r
-\r
-\r
-#ifdef _TARGET_X86_\r
-\r
-class JIT_TrialAlloc\r
-{\r
-public:\r
- enum Flags\r
- {\r
- NORMAL = 0x0,\r
- MP_ALLOCATOR = 0x1,\r
- SIZE_IN_EAX = 0x2,\r
- OBJ_ARRAY = 0x4,\r
- ALIGN8 = 0x8, // insert a dummy object to insure 8 byte alignment (until the next GC)\r
- ALIGN8OBJ = 0x10,\r
- NO_FRAME = 0x20, // call is from unmanaged code - don't try to put up a frame\r
- };\r
-\r
- static void *GenAllocSFast(Flags flags);\r
- static void *GenBox(Flags flags);\r
- static void *GenAllocArray(Flags flags);\r
- static void *GenAllocString(Flags flags);\r
-\r
-private:\r
- static void EmitAlignmentRoundup(CPUSTUBLINKER *psl,X86Reg regTestAlign, X86Reg regToAdj, Flags flags);\r
- static void EmitDummyObject(CPUSTUBLINKER *psl, X86Reg regTestAlign, Flags flags);\r
- static void EmitCore(CPUSTUBLINKER *psl, CodeLabel *noLock, CodeLabel *noAlloc, Flags flags);\r
- static void EmitNoAllocCode(CPUSTUBLINKER *psl, Flags flags);\r
-\r
-#if CHECK_APP_DOMAIN_LEAKS\r
- static void EmitSetAppDomain(CPUSTUBLINKER *psl);\r
- static void EmitCheckRestore(CPUSTUBLINKER *psl);\r
-#endif\r
-};\r
-#endif // _TARGET_X86_\r
-\r
-void *GenFastGetSharedStaticBase(bool bCheckCCtor);\r
-\r
-#ifdef HAVE_GCCOVER\r
-void SetupGcCoverage(MethodDesc* pMD, BYTE* nativeCode);\r
-void SetupGcCoverageForNativeImage(Module* module);\r
-bool IsGcCoverageInterrupt(LPVOID ip);\r
-BOOL OnGcCoverageInterrupt(PT_CONTEXT regs);\r
-void DoGcStress (PT_CONTEXT regs, MethodDesc *pMD);\r
-#endif //HAVE_GCCOVER\r
-\r
-EXTERN_C FCDECL2(LPVOID, ArrayStoreCheck, Object** pElement, PtrArray** pArray);\r
-\r
-OBJECTHANDLE ConstructStringLiteral(CORINFO_MODULE_HANDLE scopeHnd, mdToken metaTok);\r
-\r
-FCDECL2(Object*, JIT_Box, CORINFO_CLASS_HANDLE type, void* data);\r
-FCDECL0(VOID, JIT_PollGC);\r
-#ifdef ENABLE_FAST_GCPOLL_HELPER\r
-EXTERN_C FCDECL0(VOID, JIT_PollGC_Nop);\r
-#endif\r
-\r
-BOOL ObjIsInstanceOf(Object *pObject, TypeHandle toTypeHnd, BOOL throwCastException = FALSE);\r
-EXTERN_C TypeHandle::CastResult STDCALL ObjIsInstanceOfNoGC(Object *pObject, TypeHandle toTypeHnd);\r
-\r
-#ifdef _WIN64\r
-class InlinedCallFrame;\r
-Thread * __stdcall JIT_InitPInvokeFrame(InlinedCallFrame *pFrame, PTR_VOID StubSecretArg);\r
-#endif\r
-\r
-#ifdef _DEBUG\r
-extern LONG g_JitCount;\r
-#endif\r
-\r
-struct VirtualFunctionPointerArgs\r
-{\r
- CORINFO_CLASS_HANDLE classHnd;\r
- CORINFO_METHOD_HANDLE methodHnd;\r
-};\r
-\r
-FCDECL2(CORINFO_MethodPtr, JIT_VirtualFunctionPointer_Dynamic, Object * objectUNSAFE, VirtualFunctionPointerArgs * pArgs);\r
-\r
-typedef TADDR (F_CALL_CONV * FnStaticBaseHelper)(TADDR arg0, TADDR arg1);\r
-\r
-struct StaticFieldAddressArgs\r
-{\r
- FnStaticBaseHelper staticBaseHelper;\r
- TADDR arg0;\r
- TADDR arg1;\r
- SIZE_T offset;\r
-};\r
-\r
-FCDECL1(TADDR, JIT_StaticFieldAddress_Dynamic, StaticFieldAddressArgs * pArgs);\r
-FCDECL1(TADDR, JIT_StaticFieldAddressUnbox_Dynamic, StaticFieldAddressArgs * pArgs);\r
-\r
-CORINFO_GENERIC_HANDLE JIT_GenericHandleWorker(MethodDesc *pMD,\r
- MethodTable *pMT,\r
- LPVOID signature);\r
-\r
-void ClearJitGenericHandleCache(AppDomain *pDomain);\r
-\r
-class JitHelpers {\r
-public:\r
- static FCDECL3(void, UnsafeSetArrayElement, PtrArray* pPtrArray, INT32 index, Object* object);\r
-};\r
-\r
-DWORD GetDebuggerCompileFlags(Module* pModule, DWORD flags);\r
-\r
-bool TrackAllocationsEnabled();\r
-\r
-#endif // JITINTERFACE_H\r\r
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+// ===========================================================================
+// File: JITinterface.H
+//
+
+// ===========================================================================
+
+
+#ifndef JITINTERFACE_H
+#define JITINTERFACE_H
+
+#include "corjit.h"
+#ifdef FEATURE_PREJIT
+#include "corcompile.h"
+#endif // FEATURE_PREJIT
+
+#ifndef FEATURE_PAL
+#define MAX_UNCHECKED_OFFSET_FOR_NULL_OBJECT ((32*1024)-1) // when generating JIT code
+#else // !FEATURE_PAL
+#define MAX_UNCHECKED_OFFSET_FOR_NULL_OBJECT ((OS_PAGE_SIZE / 2) - 1)
+#endif // !FEATURE_PAL
+
+class Stub;
+class MethodDesc;
+class FieldDesc;
+enum RuntimeExceptionKind;
+class AwareLock;
+class PtrArray;
+
+#include "genericdict.h"
+
+inline FieldDesc* GetField(CORINFO_FIELD_HANDLE fieldHandle)
+{
+ LIMITED_METHOD_CONTRACT;
+ return (FieldDesc*) fieldHandle;
+}
+
+inline
+bool SigInfoFlagsAreValid (CORINFO_SIG_INFO *sig)
+{
+ LIMITED_METHOD_CONTRACT;
+ return !(sig->flags & ~( CORINFO_SIGFLAG_IS_LOCAL_SIG
+ | CORINFO_SIGFLAG_IL_STUB
+ ));
+}
+
+
+void InitJITHelpers1();
+void InitJITHelpers2();
+
+PCODE UnsafeJitFunction(MethodDesc* ftn, COR_ILMETHOD_DECODER* header,
+ DWORD flags, DWORD flags2, ULONG* sizeOfCode = NULL);
+
+void getMethodInfoHelper(MethodDesc * ftn,
+ CORINFO_METHOD_HANDLE ftnHnd,
+ COR_ILMETHOD_DECODER * header,
+ CORINFO_METHOD_INFO * methInfo);
+
+void getMethodInfoILMethodHeaderHelper(
+ COR_ILMETHOD_DECODER* header,
+ CORINFO_METHOD_INFO* methInfo
+ );
+
+
+#ifdef FEATURE_PREJIT
+BOOL LoadDynamicInfoEntry(Module *currentModule,
+ RVA fixupRva,
+ SIZE_T *entry);
+#endif // FEATURE_PREJIT
+
+//
+// The legacy x86 monitor helpers do not need a state argument
+//
+#if !defined(_TARGET_X86_)
+
+#define FCDECL_MONHELPER(funcname, arg) FCDECL2(void, funcname, arg, BYTE* pbLockTaken)
+#define HCIMPL_MONHELPER(funcname, arg) HCIMPL2(void, funcname, arg, BYTE* pbLockTaken)
+#define MONHELPER_STATE(x) x
+#define MONHELPER_ARG pbLockTaken
+
+#else
+
+#define FCDECL_MONHELPER(funcname, arg) FCDECL1(void, funcname, arg)
+#define HCIMPL_MONHELPER(funcname, arg) HCIMPL1(void, funcname, arg)
+#define MONHELPER_STATE(x)
+#define MONHELPER_ARG NULL
+
+#endif // _TARGET_X86_
+
+
+//
+// JIT HELPER ALIASING FOR PORTABILITY.
+//
+// The portable helper is used if the platform does not provide optimized implementation.
+//
+
+#ifndef JIT_MonEnter
+#define JIT_MonEnter JIT_MonEnter_Portable
+#endif
+EXTERN_C FCDECL1(void, JIT_MonEnter, Object *obj);
+EXTERN_C FCDECL1(void, JIT_MonEnter_Portable, Object *obj);
+
+#ifndef JIT_MonEnterWorker
+#define JIT_MonEnterWorker JIT_MonEnterWorker_Portable
+#endif
+EXTERN_C FCDECL_MONHELPER(JIT_MonEnterWorker, Object *obj);
+EXTERN_C FCDECL_MONHELPER(JIT_MonEnterWorker_Portable, Object *obj);
+
+#ifndef JIT_MonReliableEnter
+#define JIT_MonReliableEnter JIT_MonReliableEnter_Portable
+#endif
+EXTERN_C FCDECL2(void, JIT_MonReliableEnter, Object* obj, BYTE *tookLock);
+EXTERN_C FCDECL2(void, JIT_MonReliableEnter_Portable, Object* obj, BYTE *tookLock);
+
+#ifndef JIT_MonTryEnter
+#define JIT_MonTryEnter JIT_MonTryEnter_Portable
+#endif
+EXTERN_C FCDECL3(void, JIT_MonTryEnter, Object *obj, INT32 timeout, BYTE* pbLockTaken);
+EXTERN_C FCDECL3(void, JIT_MonTryEnter_Portable, Object *obj, INT32 timeout, BYTE* pbLockTaken);
+
+#ifndef JIT_MonExit
+#define JIT_MonExit JIT_MonExit_Portable
+#endif
+EXTERN_C FCDECL1(void, JIT_MonExit, Object *obj);
+EXTERN_C FCDECL1(void, JIT_MonExit_Portable, Object *obj);
+
+#ifndef JIT_MonExitWorker
+#define JIT_MonExitWorker JIT_MonExitWorker_Portable
+#endif
+EXTERN_C FCDECL_MONHELPER(JIT_MonExitWorker, Object *obj);
+EXTERN_C FCDECL_MONHELPER(JIT_MonExitWorker_Portable, Object *obj);
+
+#ifndef JIT_MonEnterStatic
+#define JIT_MonEnterStatic JIT_MonEnterStatic_Portable
+#endif
+EXTERN_C FCDECL_MONHELPER(JIT_MonEnterStatic, AwareLock *lock);
+EXTERN_C FCDECL_MONHELPER(JIT_MonEnterStatic_Portable, AwareLock *lock);
+
+#ifndef JIT_MonExitStatic
+#define JIT_MonExitStatic JIT_MonExitStatic_Portable
+#endif
+EXTERN_C FCDECL_MONHELPER(JIT_MonExitStatic, AwareLock *lock);
+EXTERN_C FCDECL_MONHELPER(JIT_MonExitStatic_Portable, AwareLock *lock);
+
+
+#ifndef JIT_GetSharedGCStaticBase
+#define JIT_GetSharedGCStaticBase JIT_GetSharedGCStaticBase_Portable
+#endif
+EXTERN_C FCDECL2(void*, JIT_GetSharedGCStaticBase, SIZE_T moduleDomainID, DWORD dwModuleClassID);
+EXTERN_C FCDECL2(void*, JIT_GetSharedGCStaticBase_Portable, SIZE_T moduleDomainID, DWORD dwModuleClassID);
+
+#ifndef JIT_GetSharedNonGCStaticBase
+#define JIT_GetSharedNonGCStaticBase JIT_GetSharedNonGCStaticBase_Portable
+#endif
+EXTERN_C FCDECL2(void*, JIT_GetSharedNonGCStaticBase, SIZE_T moduleDomainID, DWORD dwModuleClassID);
+EXTERN_C FCDECL2(void*, JIT_GetSharedNonGCStaticBase_Portable, SIZE_T moduleDomainID, DWORD dwModuleClassID);
+
+#ifndef JIT_GetSharedGCStaticBaseNoCtor
+#define JIT_GetSharedGCStaticBaseNoCtor JIT_GetSharedGCStaticBaseNoCtor_Portable
+#endif
+EXTERN_C FCDECL1(void*, JIT_GetSharedGCStaticBaseNoCtor, SIZE_T moduleDomainID);
+EXTERN_C FCDECL1(void*, JIT_GetSharedGCStaticBaseNoCtor_Portable, SIZE_T moduleDomainID);
+
+#ifndef JIT_GetSharedNonGCStaticBaseNoCtor
+#define JIT_GetSharedNonGCStaticBaseNoCtor JIT_GetSharedNonGCStaticBaseNoCtor_Portable
+#endif
+EXTERN_C FCDECL1(void*, JIT_GetSharedNonGCStaticBaseNoCtor, SIZE_T moduleDomainID);
+EXTERN_C FCDECL1(void*, JIT_GetSharedNonGCStaticBaseNoCtor_Portable, SIZE_T moduleDomainID);
+
+#ifndef JIT_ChkCastClass
+#define JIT_ChkCastClass JIT_ChkCastClass_Portable
+#endif
+EXTERN_C FCDECL2(Object*, JIT_ChkCastClass, MethodTable* pMT, Object* pObject);
+EXTERN_C FCDECL2(Object*, JIT_ChkCastClass_Portable, MethodTable* pMT, Object* pObject);
+
+#ifndef JIT_ChkCastClassSpecial
+#define JIT_ChkCastClassSpecial JIT_ChkCastClassSpecial_Portable
+#endif
+EXTERN_C FCDECL2(Object*, JIT_ChkCastClassSpecial, MethodTable* pMT, Object* pObject);
+EXTERN_C FCDECL2(Object*, JIT_ChkCastClassSpecial_Portable, MethodTable* pMT, Object* pObject);
+
+#ifndef JIT_IsInstanceOfClass
+#define JIT_IsInstanceOfClass JIT_IsInstanceOfClass_Portable
+#endif
+EXTERN_C FCDECL2(Object*, JIT_IsInstanceOfClass, MethodTable* pMT, Object* pObject);
+EXTERN_C FCDECL2(Object*, JIT_IsInstanceOfClass_Portable, MethodTable* pMT, Object* pObject);
+
+#ifndef JIT_ChkCastInterface
+#define JIT_ChkCastInterface JIT_ChkCastInterface_Portable
+#endif
+EXTERN_C FCDECL2(Object*, JIT_ChkCastInterface, MethodTable* pMT, Object* pObject);
+EXTERN_C FCDECL2(Object*, JIT_ChkCastInterface_Portable, MethodTable* pMT, Object* pObject);
+
+#ifndef JIT_IsInstanceOfInterface
+#define JIT_IsInstanceOfInterface JIT_IsInstanceOfInterface_Portable
+#endif
+EXTERN_C FCDECL2(Object*, JIT_IsInstanceOfInterface, MethodTable* pMT, Object* pObject);
+EXTERN_C FCDECL2(Object*, JIT_IsInstanceOfInterface_Portable, MethodTable* pMT, Object* pObject);
+
+extern FCDECL1(Object*, JIT_NewS_MP_FastPortable, CORINFO_CLASS_HANDLE typeHnd_);
+extern FCDECL1(Object*, JIT_New, CORINFO_CLASS_HANDLE typeHnd_);
+
+#ifndef JIT_NewCrossContext
+#define JIT_NewCrossContext JIT_NewCrossContext_Portable
+#endif
+EXTERN_C FCDECL1(Object*, JIT_NewCrossContext, CORINFO_CLASS_HANDLE typeHnd_);
+EXTERN_C FCDECL1(Object*, JIT_NewCrossContext_Portable, CORINFO_CLASS_HANDLE typeHnd_);
+
+extern FCDECL1(StringObject*, AllocateString_MP_FastPortable, DWORD stringLength);
+extern FCDECL1(StringObject*, UnframedAllocateString, DWORD stringLength);
+extern FCDECL1(StringObject*, FramedAllocateString, DWORD stringLength);
+
+extern FCDECL2(Object*, JIT_NewArr1VC_MP_FastPortable, CORINFO_CLASS_HANDLE typeHnd_, INT_PTR size);
+extern FCDECL2(Object*, JIT_NewArr1OBJ_MP_FastPortable, CORINFO_CLASS_HANDLE typeHnd_, INT_PTR size);
+extern FCDECL2(Object*, JIT_NewArr1, CORINFO_CLASS_HANDLE typeHnd_, INT_PTR size);
+
+#ifndef JIT_Stelem_Ref
+#define JIT_Stelem_Ref JIT_Stelem_Ref_Portable
+#endif
+EXTERN_C FCDECL3(void, JIT_Stelem_Ref, PtrArray* array, unsigned idx, Object* val);
+EXTERN_C FCDECL3(void, JIT_Stelem_Ref_Portable, PtrArray* array, unsigned idx, Object* val);
+
+EXTERN_C FCDECL_MONHELPER(JITutil_MonEnterWorker, Object* obj);
+EXTERN_C FCDECL2(void, JITutil_MonReliableEnter, Object* obj, BYTE* pbLockTaken);
+EXTERN_C FCDECL3(void, JITutil_MonTryEnter, Object* obj, INT32 timeOut, BYTE* pbLockTaken);
+EXTERN_C FCDECL_MONHELPER(JITutil_MonExitWorker, Object* obj);
+EXTERN_C FCDECL_MONHELPER(JITutil_MonSignal, AwareLock* lock);
+EXTERN_C FCDECL_MONHELPER(JITutil_MonContention, AwareLock* awarelock);
+EXTERN_C FCDECL2(void, JITutil_MonReliableContention, AwareLock* awarelock, BYTE* pbLockTaken);
+
+// Slow versions to tail call if the fast version fails
+EXTERN_C FCDECL2(void*, JIT_GetSharedNonGCStaticBase_Helper, DomainLocalModule *pLocalModule, DWORD dwClassDomainID);
+EXTERN_C FCDECL2(void*, JIT_GetSharedGCStaticBase_Helper, DomainLocalModule *pLocalModule, DWORD dwClassDomainID);
+
+EXTERN_C void DoJITFailFast ();
+EXTERN_C FCDECL0(void, JIT_FailFast);
+extern FCDECL3(void, JIT_ThrowAccessException, RuntimeExceptionKind, CORINFO_METHOD_HANDLE caller, void * callee);
+
+FCDECL1(void*, JIT_SafeReturnableByref, void* byref);
+
+#if !defined(FEATURE_USE_ASM_GC_WRITE_BARRIERS) && defined(FEATURE_COUNT_GC_WRITE_BARRIERS)
+// Extra argument for the classification of the checked barriers.
+extern "C" FCDECL3(VOID, JIT_CheckedWriteBarrier, Object **dst, Object *ref, CheckedWriteBarrierKinds kind);
+#else
+// Regular checked write barrier.
+extern "C" FCDECL2(VOID, JIT_CheckedWriteBarrier, Object **dst, Object *ref);
+#endif
+
+extern "C" FCDECL2(VOID, JIT_WriteBarrier, Object **dst, Object *ref);
+
+extern "C" FCDECL2(VOID, JIT_WriteBarrierEnsureNonHeapTarget, Object **dst, Object *ref);
+
+extern "C" FCDECL2(Object*, JIT_ChkCastAny, CORINFO_CLASS_HANDLE type, Object *pObject); // JITInterfaceX86.cpp, etc.
+extern "C" FCDECL2(Object*, JIT_IsInstanceOfAny, CORINFO_CLASS_HANDLE type, Object *pObject);
+
+extern "C" FCDECL2(Object*, JITutil_ChkCastInterface, MethodTable *pInterfaceMT, Object *obj);
+extern "C" FCDECL2(Object*, JITutil_IsInstanceOfInterface, MethodTable *pInterfaceMT, Object *obj);
+extern "C" FCDECL2(Object*, JITutil_ChkCastAny, CORINFO_CLASS_HANDLE type, Object *obj);
+extern "C" FCDECL2(Object*, JITutil_IsInstanceOfAny, CORINFO_CLASS_HANDLE type, Object *obj);
+
+extern "C" FCDECL1(void, JIT_InternalThrow, unsigned exceptNum);
+extern "C" FCDECL1(void*, JIT_InternalThrowFromHelper, unsigned exceptNum);
+
+#ifdef _TARGET_AMD64_
+
+
+class WriteBarrierManager
+{
+public:
+ enum WriteBarrierType
+ {
+ WRITE_BARRIER_UNINITIALIZED,
+ WRITE_BARRIER_PREGROW64,
+ WRITE_BARRIER_POSTGROW64,
+#ifdef FEATURE_SVR_GC
+ WRITE_BARRIER_SVR64,
+#endif // FEATURE_SVR_GC
+#ifdef FEATURE_USE_SOFTWARE_WRITE_WATCH_FOR_GC_HEAP
+ WRITE_BARRIER_WRITE_WATCH_PREGROW64,
+ WRITE_BARRIER_WRITE_WATCH_POSTGROW64,
+#ifdef FEATURE_SVR_GC
+ WRITE_BARRIER_WRITE_WATCH_SVR64,
+#endif // FEATURE_SVR_GC
+#endif // FEATURE_USE_SOFTWARE_WRITE_WATCH_FOR_GC_HEAP
+ WRITE_BARRIER_BUFFER
+ };
+
+ WriteBarrierManager();
+ void Initialize();
+
+ void UpdateEphemeralBounds(bool isRuntimeSuspended);
+ void UpdateWriteWatchAndCardTableLocations(bool isRuntimeSuspended, bool bReqUpperBoundsCheck);
+
+#ifdef FEATURE_USE_SOFTWARE_WRITE_WATCH_FOR_GC_HEAP
+ void SwitchToWriteWatchBarrier(bool isRuntimeSuspended);
+ void SwitchToNonWriteWatchBarrier(bool isRuntimeSuspended);
+#endif // FEATURE_USE_SOFTWARE_WRITE_WATCH_FOR_GC_HEAP
+
+protected:
+ size_t GetCurrentWriteBarrierSize();
+ size_t GetSpecificWriteBarrierSize(WriteBarrierType writeBarrier);
+ PBYTE CalculatePatchLocation(LPVOID base, LPVOID label, int offset);
+ PCODE GetCurrentWriteBarrierCode();
+ void ChangeWriteBarrierTo(WriteBarrierType newWriteBarrier, bool isRuntimeSuspended);
+ bool NeedDifferentWriteBarrier(bool bReqUpperBoundsCheck, WriteBarrierType* pNewWriteBarrierType);
+
+private:
+ void Validate();
+
+ WriteBarrierType m_currentWriteBarrier;
+
+ PBYTE m_pWriteWatchTableImmediate; // PREGROW | POSTGROW | SVR | WRITE_WATCH |
+ PBYTE m_pLowerBoundImmediate; // PREGROW | POSTGROW | | WRITE_WATCH |
+ PBYTE m_pCardTableImmediate; // PREGROW | POSTGROW | SVR | WRITE_WATCH |
+ PBYTE m_pUpperBoundImmediate; // | POSTGROW | | WRITE_WATCH |
+};
+
+#endif // _TARGET_AMD64_
+
+#ifdef _WIN64
+EXTERN_C FCDECL1(Object*, JIT_TrialAllocSFastMP_InlineGetThread, CORINFO_CLASS_HANDLE typeHnd_);
+EXTERN_C FCDECL2(Object*, JIT_BoxFastMP_InlineGetThread, CORINFO_CLASS_HANDLE type, void* data);
+EXTERN_C FCDECL2(Object*, JIT_NewArr1VC_MP_InlineGetThread, CORINFO_CLASS_HANDLE typeHnd_, INT_PTR size);
+EXTERN_C FCDECL2(Object*, JIT_NewArr1OBJ_MP_InlineGetThread, CORINFO_CLASS_HANDLE typeHnd_, INT_PTR size);
+
+#endif // _WIN64
+
+EXTERN_C FCDECL2_VV(INT64, JIT_LMul, INT64 val1, INT64 val2);
+
+EXTERN_C FCDECL1_V(INT64, JIT_Dbl2Lng, double val);
+EXTERN_C FCDECL1_V(INT64, JIT_Dbl2IntSSE2, double val);
+EXTERN_C FCDECL1_V(INT64, JIT_Dbl2LngP4x87, double val);
+EXTERN_C FCDECL1_V(INT64, JIT_Dbl2LngSSE3, double val);
+EXTERN_C FCDECL1_V(INT64, JIT_Dbl2LngOvf, double val);
+
+EXTERN_C FCDECL1_V(INT32, JIT_Dbl2IntOvf, double val);
+
+EXTERN_C FCDECL2_VV(float, JIT_FltRem, float dividend, float divisor);
+EXTERN_C FCDECL2_VV(double, JIT_DblRem, double dividend, double divisor);
+
+#if !defined(_WIN64) && !defined(_TARGET_X86_)
+EXTERN_C FCDECL2_VV(UINT64, JIT_LLsh, UINT64 num, int shift);
+EXTERN_C FCDECL2_VV(INT64, JIT_LRsh, INT64 num, int shift);
+EXTERN_C FCDECL2_VV(UINT64, JIT_LRsz, UINT64 num, int shift);
+#endif
+
+#ifdef _TARGET_X86_
+
+extern "C"
+{
+ void STDCALL JIT_LLsh(); // JIThelp.asm
+ void STDCALL JIT_LRsh(); // JIThelp.asm
+ void STDCALL JIT_LRsz(); // JIThelp.asm
+
+ void STDCALL JIT_CheckedWriteBarrierEAX(); // JIThelp.asm/JIThelp.s
+ void STDCALL JIT_CheckedWriteBarrierEBX(); // JIThelp.asm/JIThelp.s
+ void STDCALL JIT_CheckedWriteBarrierECX(); // JIThelp.asm/JIThelp.s
+ void STDCALL JIT_CheckedWriteBarrierESI(); // JIThelp.asm/JIThelp.s
+ void STDCALL JIT_CheckedWriteBarrierEDI(); // JIThelp.asm/JIThelp.s
+ void STDCALL JIT_CheckedWriteBarrierEBP(); // JIThelp.asm/JIThelp.s
+
+ void STDCALL JIT_DebugWriteBarrierEAX(); // JIThelp.asm/JIThelp.s
+ void STDCALL JIT_DebugWriteBarrierEBX(); // JIThelp.asm/JIThelp.s
+ void STDCALL JIT_DebugWriteBarrierECX(); // JIThelp.asm/JIThelp.s
+ void STDCALL JIT_DebugWriteBarrierESI(); // JIThelp.asm/JIThelp.s
+ void STDCALL JIT_DebugWriteBarrierEDI(); // JIThelp.asm/JIThelp.s
+ void STDCALL JIT_DebugWriteBarrierEBP(); // JIThelp.asm/JIThelp.s
+
+ void STDCALL JIT_WriteBarrierEAX(); // JIThelp.asm/JIThelp.s
+ void STDCALL JIT_WriteBarrierEBX(); // JIThelp.asm/JIThelp.s
+ void STDCALL JIT_WriteBarrierECX(); // JIThelp.asm/JIThelp.s
+ void STDCALL JIT_WriteBarrierESI(); // JIThelp.asm/JIThelp.s
+ void STDCALL JIT_WriteBarrierEDI(); // JIThelp.asm/JIThelp.s
+ void STDCALL JIT_WriteBarrierEBP(); // JIThelp.asm/JIThelp.s
+
+ void STDCALL JIT_WriteBarrierStart();
+ void STDCALL JIT_WriteBarrierLast();
+
+ void STDCALL JIT_PatchedWriteBarrierStart();
+ void STDCALL JIT_PatchedWriteBarrierLast();
+}
+
+void ValidateWriteBarrierHelpers();
+
+#endif //_TARGET_X86_
+
+extern "C"
+{
+ void STDCALL JIT_EndCatch(); // JIThelp.asm/JIThelp.s
+
+ void STDCALL JIT_ByRefWriteBarrier(); // JIThelp.asm/JIThelp.s
+
+#if defined(_TARGET_AMD64_) || defined(_TARGET_ARM_)
+
+ FCDECL2VA(void, JIT_TailCall, PCODE copyArgs, PCODE target);
+
+#else // _TARGET_AMD64_ || _TARGET_ARM_
+
+ void STDCALL JIT_TailCall(); // JIThelp.asm
+
+#endif // _TARGET_AMD64_ || _TARGET_ARM_
+
+ void STDCALL JIT_MemSet(void *dest, int c, SIZE_T count);
+ void STDCALL JIT_MemCpy(void *dest, const void *src, SIZE_T count);
+
+ void STDCALL JIT_ProfilerEnterLeaveTailcallStub(UINT_PTR ProfilerHandle);
+};
+
+#ifndef FEATURE_CORECLR
+//
+// Obfluscators that are hacking into the JIT expect certain methods to exist in certain places of CEEInfo vtable. Add artifical slots
+// to the vtable to avoid breaking apps by .NET 4.5 in-place update.
+//
+
+class ICorMethodInfo_Hack
+{
+public:
+ virtual const char* __stdcall ICorMethodInfo_Hack_getMethodName (CORINFO_METHOD_HANDLE ftnHnd, const char** scopeName) = 0;
+};
+
+class ICorModuleInfo_Hack
+{
+public:
+ virtual void ICorModuleInfo_Hack_dummy() { LIMITED_METHOD_CONTRACT; UNREACHABLE(); };
+};
+
+class ICorClassInfo_Hack
+{
+public:
+ virtual void ICorClassInfo_Hack_dummy1() { LIMITED_METHOD_CONTRACT; UNREACHABLE(); };
+ virtual void ICorClassInfo_Hack_dummy2() { LIMITED_METHOD_CONTRACT; UNREACHABLE(); };
+ virtual void ICorClassInfo_Hack_dummy3() { LIMITED_METHOD_CONTRACT; UNREACHABLE(); };
+ virtual void ICorClassInfo_Hack_dummy4() { LIMITED_METHOD_CONTRACT; UNREACHABLE(); };
+ virtual void ICorClassInfo_Hack_dummy5() { LIMITED_METHOD_CONTRACT; UNREACHABLE(); };
+ virtual void ICorClassInfo_Hack_dummy6() { LIMITED_METHOD_CONTRACT; UNREACHABLE(); };
+ virtual void ICorClassInfo_Hack_dummy7() { LIMITED_METHOD_CONTRACT; UNREACHABLE(); };
+ virtual void ICorClassInfo_Hack_dummy8() { LIMITED_METHOD_CONTRACT; UNREACHABLE(); };
+ virtual void ICorClassInfo_Hack_dummy9() { LIMITED_METHOD_CONTRACT; UNREACHABLE(); };
+ virtual void ICorClassInfo_Hack_dummy10() { LIMITED_METHOD_CONTRACT; UNREACHABLE(); };
+ virtual void ICorClassInfo_Hack_dummy11() { LIMITED_METHOD_CONTRACT; UNREACHABLE(); };
+ virtual void ICorClassInfo_Hack_dummy12() { LIMITED_METHOD_CONTRACT; UNREACHABLE(); };
+ virtual void ICorClassInfo_Hack_dummy13() { LIMITED_METHOD_CONTRACT; UNREACHABLE(); };
+ virtual void ICorClassInfo_Hack_dummy14() { LIMITED_METHOD_CONTRACT; UNREACHABLE(); };
+
+ virtual mdMethodDef __stdcall ICorClassInfo_Hack_getMethodDefFromMethod(CORINFO_METHOD_HANDLE hMethod) = 0;
+};
+
+class ICorStaticInfo_Hack : public virtual ICorMethodInfo_Hack, public virtual ICorModuleInfo_Hack, public virtual ICorClassInfo_Hack
+{
+ virtual void ICorStaticInfo_Hack_dummy() { LIMITED_METHOD_CONTRACT; UNREACHABLE(); };
+};
+
+#endif // FEATURE_CORECLR
+
+
+/*********************************************************************/
+/*********************************************************************/
+class CEEInfo : public ICorJitInfo
+#ifndef FEATURE_CORECLR
+ , public virtual ICorStaticInfo_Hack
+#endif
+{
+ friend class CEEDynamicCodeInfo;
+
+ const char * __stdcall ICorMethodInfo_Hack_getMethodName(CORINFO_METHOD_HANDLE ftnHnd, const char** scopeName)
+ {
+ WRAPPER_NO_CONTRACT;
+ return getMethodName(ftnHnd, scopeName);
+ }
+
+ mdMethodDef __stdcall ICorClassInfo_Hack_getMethodDefFromMethod(CORINFO_METHOD_HANDLE hMethod)
+ {
+ WRAPPER_NO_CONTRACT;
+ return getMethodDefFromMethod(hMethod);
+ }
+
+public:
+ // ICorClassInfo stuff
+ CorInfoType asCorInfoType (CORINFO_CLASS_HANDLE cls);
+ // This normalizes EE type information into the form expected by the JIT.
+ //
+ // If typeHnd contains exact type information, then *clsRet will contain
+ // the normalized CORINFO_CLASS_HANDLE information on return.
+ static CorInfoType asCorInfoType (CorElementType cet,
+ TypeHandle typeHnd = TypeHandle() /* optional in */,
+ CORINFO_CLASS_HANDLE *clsRet = NULL /* optional out */ );
+
+ CORINFO_MODULE_HANDLE getClassModule(CORINFO_CLASS_HANDLE clsHnd);
+ CORINFO_ASSEMBLY_HANDLE getModuleAssembly(CORINFO_MODULE_HANDLE mod);
+ const char* getAssemblyName(CORINFO_ASSEMBLY_HANDLE assem);
+ void* LongLifetimeMalloc(size_t sz);
+ void LongLifetimeFree(void* obj);
+ size_t getClassModuleIdForStatics(CORINFO_CLASS_HANDLE clsHnd, CORINFO_MODULE_HANDLE *pModuleHandle, void **ppIndirection);
+ const char* getClassName (CORINFO_CLASS_HANDLE cls);
+ const char* getHelperName(CorInfoHelpFunc ftnNum);
+ int appendClassName(__deref_inout_ecount(*pnBufLen) WCHAR** ppBuf,
+ int* pnBufLen,
+ CORINFO_CLASS_HANDLE cls,
+ BOOL fNamespace,
+ BOOL fFullInst,
+ BOOL fAssembly);
+ BOOL isValueClass (CORINFO_CLASS_HANDLE cls);
+ BOOL canInlineTypeCheckWithObjectVTable (CORINFO_CLASS_HANDLE cls);
+
+ DWORD getClassAttribs (CORINFO_CLASS_HANDLE cls);
+
+ // Internal version without JIT-EE transition
+ DWORD getClassAttribsInternal (CORINFO_CLASS_HANDLE cls);
+
+ BOOL isStructRequiringStackAllocRetBuf(CORINFO_CLASS_HANDLE cls);
+
+ unsigned getClassSize (CORINFO_CLASS_HANDLE cls);
+ unsigned getClassAlignmentRequirement(CORINFO_CLASS_HANDLE cls, BOOL fDoubleAlignHint);
+ static unsigned getClassAlignmentRequirementStatic(TypeHandle clsHnd);
+
+ // Used for HFA's on IA64...and later for type based disambiguation
+ CORINFO_FIELD_HANDLE getFieldInClass(CORINFO_CLASS_HANDLE clsHnd, INT num);
+
+ mdMethodDef getMethodDefFromMethod(CORINFO_METHOD_HANDLE hMethod);
+ BOOL checkMethodModifier(CORINFO_METHOD_HANDLE hMethod, LPCSTR modifier, BOOL fOptional);
+
+ unsigned getClassGClayout (CORINFO_CLASS_HANDLE cls, BYTE* gcPtrs); /* really GCType* gcPtrs */
+ unsigned getClassNumInstanceFields(CORINFO_CLASS_HANDLE cls);
+
+ // returns the enregister info for a struct based on type of fields, alignment, etc.
+ bool getSystemVAmd64PassStructInRegisterDescriptor(
+ /*IN*/ CORINFO_CLASS_HANDLE _structHnd,
+ /*OUT*/ SYSTEMV_AMD64_CORINFO_STRUCT_REG_PASSING_DESCRIPTOR* structPassInRegDescPtr);
+
+ // Check Visibility rules.
+ // For Protected (family access) members, type of the instance is also
+ // considered when checking visibility rules.
+
+
+ CorInfoHelpFunc getNewHelper(CORINFO_RESOLVED_TOKEN * pResolvedToken, CORINFO_METHOD_HANDLE callerHandle);
+ static CorInfoHelpFunc getNewHelperStatic(MethodTable * pMT);
+
+ CorInfoHelpFunc getNewArrHelper(CORINFO_CLASS_HANDLE arrayCls);
+ static CorInfoHelpFunc getNewArrHelperStatic(TypeHandle clsHnd);
+
+ CorInfoHelpFunc getCastingHelper(CORINFO_RESOLVED_TOKEN * pResolvedToken, bool fThrowing);
+ static CorInfoHelpFunc getCastingHelperStatic(TypeHandle clsHnd, bool fThrowing, bool * pfClassMustBeRestored);
+
+ CorInfoHelpFunc getSharedCCtorHelper(CORINFO_CLASS_HANDLE clsHnd);
+ CorInfoHelpFunc getSecurityPrologHelper(CORINFO_METHOD_HANDLE ftn);
+ CORINFO_CLASS_HANDLE getTypeForBox(CORINFO_CLASS_HANDLE cls);
+ CorInfoHelpFunc getBoxHelper(CORINFO_CLASS_HANDLE cls);
+ CorInfoHelpFunc getUnBoxHelper(CORINFO_CLASS_HANDLE cls);
+
+ bool getReadyToRunHelper(
+ CORINFO_RESOLVED_TOKEN * pResolvedToken,
+ CORINFO_LOOKUP_KIND * pGenericLookupKind,
+ CorInfoHelpFunc id,
+ CORINFO_CONST_LOOKUP * pLookup
+ );
+
+ void getReadyToRunDelegateCtorHelper(
+ CORINFO_RESOLVED_TOKEN * pTargetMethod,
+ CORINFO_CLASS_HANDLE delegateType,
+ CORINFO_CONST_LOOKUP * pLookup
+ );
+
+ CorInfoInitClassResult initClass(
+ CORINFO_FIELD_HANDLE field,
+ CORINFO_METHOD_HANDLE method,
+ CORINFO_CONTEXT_HANDLE context,
+ BOOL speculative = FALSE);
+
+ void classMustBeLoadedBeforeCodeIsRun (CORINFO_CLASS_HANDLE cls);
+ void methodMustBeLoadedBeforeCodeIsRun (CORINFO_METHOD_HANDLE meth);
+ CORINFO_METHOD_HANDLE mapMethodDeclToMethodImpl(CORINFO_METHOD_HANDLE methHnd);
+ CORINFO_CLASS_HANDLE getBuiltinClass(CorInfoClassId classId);
+ void getGSCookie(GSCookie * pCookieVal, GSCookie ** ppCookieVal);
+
+ // "System.Int32" ==> CORINFO_TYPE_INT..
+ CorInfoType getTypeForPrimitiveValueClass(
+ CORINFO_CLASS_HANDLE cls
+ );
+
+ // TRUE if child is a subtype of parent
+ // if parent is an interface, then does child implement / extend parent
+ BOOL canCast(
+ CORINFO_CLASS_HANDLE child,
+ CORINFO_CLASS_HANDLE parent
+ );
+
+ // TRUE if cls1 and cls2 are considered equivalent types.
+ BOOL areTypesEquivalent(
+ CORINFO_CLASS_HANDLE cls1,
+ CORINFO_CLASS_HANDLE cls2
+ );
+
+ // returns is the intersection of cls1 and cls2.
+ CORINFO_CLASS_HANDLE mergeClasses(
+ CORINFO_CLASS_HANDLE cls1,
+ CORINFO_CLASS_HANDLE cls2
+ );
+
+ // 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.
+ CORINFO_CLASS_HANDLE getParentType (
+ CORINFO_CLASS_HANDLE cls
+ );
+
+ // Returns the CorInfoType of the "child type". If the child type is
+ // not a primitive type, *clsRet will be set.
+ // Given an Array of Type Foo, returns Foo.
+ // Given BYREF Foo, returns Foo
+ CorInfoType getChildType (
+ CORINFO_CLASS_HANDLE clsHnd,
+ CORINFO_CLASS_HANDLE *clsRet
+ );
+
+ // Check constraints on type arguments of this class and parent classes
+ BOOL satisfiesClassConstraints(
+ CORINFO_CLASS_HANDLE cls
+ );
+
+ // Check if this is a single dimensional array type
+ BOOL isSDArray(
+ CORINFO_CLASS_HANDLE cls
+ );
+
+ // Get the number of dimensions in an array
+ unsigned getArrayRank(
+ CORINFO_CLASS_HANDLE cls
+ );
+
+ // Get static field data for an array
+ void * getArrayInitializationData(
+ CORINFO_FIELD_HANDLE field,
+ DWORD size
+ );
+
+ // Check Visibility rules.
+ CorInfoIsAccessAllowedResult canAccessClass(
+ CORINFO_RESOLVED_TOKEN * pResolvedToken,
+ CORINFO_METHOD_HANDLE callerHandle,
+ CORINFO_HELPER_DESC *pAccessHelper /* If canAccessClass returns something other
+ than ALLOWED, then this is filled in. */
+ );
+
+ // Returns that compilation flags that are shared between JIT and NGen
+ static DWORD GetBaseCompileFlags(MethodDesc * ftn);
+
+ // Resolve metadata token into runtime method handles.
+ void resolveToken(/* IN, OUT */ CORINFO_RESOLVED_TOKEN * pResolvedToken);
+
+ // Attempt to resolve a metadata token into a runtime method handle. Returns true
+ // if resolution succeeded and false otherwise.
+ bool tryResolveToken(/* IN, OUT */ CORINFO_RESOLVED_TOKEN * pResolvedToken);
+
+ void getFieldInfo (CORINFO_RESOLVED_TOKEN * pResolvedToken,
+ CORINFO_METHOD_HANDLE callerHandle,
+ CORINFO_ACCESS_FLAGS flags,
+ CORINFO_FIELD_INFO *pResult
+ );
+ static CorInfoHelpFunc getSharedStaticsHelper(FieldDesc * pField, MethodTable * pFieldMT);
+
+ bool isFieldStatic(CORINFO_FIELD_HANDLE fldHnd);
+
+ // Given a signature token sigTOK, use class/method instantiation in context to instantiate any type variables in the signature and return a new signature
+ void findSig(CORINFO_MODULE_HANDLE scopeHnd, unsigned sigTOK, CORINFO_CONTEXT_HANDLE context, CORINFO_SIG_INFO* sig);
+ void findCallSiteSig(CORINFO_MODULE_HANDLE scopeHnd, unsigned methTOK, CORINFO_CONTEXT_HANDLE context, CORINFO_SIG_INFO* sig);
+ CORINFO_CLASS_HANDLE getTokenTypeAsHandle(CORINFO_RESOLVED_TOKEN * pResolvedToken);
+
+ size_t findNameOfToken (CORINFO_MODULE_HANDLE module, mdToken metaTOK,
+ __out_ecount (FQNameCapacity) char * szFQName, size_t FQNameCapacity);
+
+ CorInfoCanSkipVerificationResult canSkipVerification(CORINFO_MODULE_HANDLE moduleHnd);
+
+ // Checks if the given metadata token is valid
+ BOOL isValidToken (
+ CORINFO_MODULE_HANDLE module,
+ mdToken metaTOK);
+
+ // Checks if the given metadata token is valid StringRef
+ BOOL isValidStringRef (
+ CORINFO_MODULE_HANDLE module,
+ mdToken metaTOK);
+
+ static size_t findNameOfToken (Module* module, mdToken metaTOK,
+ __out_ecount (FQNameCapacity) char * szFQName, size_t FQNameCapacity);
+
+ // ICorMethodInfo stuff
+ const char* getMethodName (CORINFO_METHOD_HANDLE ftnHnd, const char** scopeName);
+ unsigned getMethodHash (CORINFO_METHOD_HANDLE ftnHnd);
+
+ DWORD getMethodAttribs (CORINFO_METHOD_HANDLE ftnHnd);
+ // Internal version without JIT-EE transition
+ DWORD getMethodAttribsInternal (CORINFO_METHOD_HANDLE ftnHnd);
+
+ void setMethodAttribs (CORINFO_METHOD_HANDLE ftnHnd, CorInfoMethodRuntimeFlags attribs);
+
+ bool getMethodInfo (
+ CORINFO_METHOD_HANDLE ftnHnd,
+ CORINFO_METHOD_INFO* methInfo);
+
+ CorInfoInline canInline (
+ CORINFO_METHOD_HANDLE callerHnd,
+ CORINFO_METHOD_HANDLE calleeHnd,
+ DWORD* pRestrictions);
+
+ void reportInliningDecision (CORINFO_METHOD_HANDLE inlinerHnd,
+ CORINFO_METHOD_HANDLE inlineeHnd,
+ CorInfoInline inlineResult,
+ const char * reason);
+
+ // Used by ngen
+ CORINFO_METHOD_HANDLE instantiateMethodAtObject(CORINFO_METHOD_HANDLE method);
+
+ // Loads the constraints on a typical method definition, detecting cycles;
+ // used by verifiers.
+ void initConstraintsForVerification(
+ CORINFO_METHOD_HANDLE method,
+ BOOL *pfHasCircularClassConstraints,
+ BOOL *pfHasCircularMethodConstraints
+ );
+
+ CorInfoInstantiationVerification isInstantiationOfVerifiedGeneric (
+ CORINFO_METHOD_HANDLE methodHnd);
+
+
+ bool canTailCall (
+ CORINFO_METHOD_HANDLE callerHnd,
+ CORINFO_METHOD_HANDLE declaredCalleeHnd,
+ CORINFO_METHOD_HANDLE exactCalleeHnd,
+ bool fIsTailPrefix);
+
+ void reportTailCallDecision (CORINFO_METHOD_HANDLE callerHnd,
+ CORINFO_METHOD_HANDLE calleeHnd,
+ bool fIsTailPrefix,
+ CorInfoTailCall tailCallResult,
+ const char * reason);
+
+ CorInfoCanSkipVerificationResult canSkipMethodVerification(
+ CORINFO_METHOD_HANDLE ftnHnd);
+
+ // Given a method descriptor ftnHnd, extract signature information into sigInfo
+ // Obtain (representative) instantiation information from ftnHnd's owner class
+ //@GENERICSVER: added explicit owner parameter
+ void getMethodSig (
+ CORINFO_METHOD_HANDLE ftnHnd,
+ CORINFO_SIG_INFO* sigInfo,
+ CORINFO_CLASS_HANDLE owner = NULL
+ );
+ // Internal version without JIT-EE transition
+ void getMethodSigInternal (
+ CORINFO_METHOD_HANDLE ftnHnd,
+ CORINFO_SIG_INFO* sigInfo,
+ CORINFO_CLASS_HANDLE owner = NULL
+ );
+
+ void getEHinfo(
+ CORINFO_METHOD_HANDLE ftn,
+ unsigned EHnumber,
+ CORINFO_EH_CLAUSE* clause);
+
+ CORINFO_CLASS_HANDLE getMethodClass (CORINFO_METHOD_HANDLE methodHnd);
+ CORINFO_MODULE_HANDLE getMethodModule (CORINFO_METHOD_HANDLE methodHnd);
+
+ void getMethodVTableOffset (
+ CORINFO_METHOD_HANDLE methodHnd,
+ unsigned * pOffsetOfIndirection,
+ unsigned * pOffsetAfterIndirection
+ );
+
+ CorInfoIntrinsics getIntrinsicID(CORINFO_METHOD_HANDLE method,
+ bool * pMustExpand = NULL);
+
+ bool isInSIMDModule(CORINFO_CLASS_HANDLE classHnd);
+
+ CorInfoUnmanagedCallConv getUnmanagedCallConv(CORINFO_METHOD_HANDLE method);
+ BOOL pInvokeMarshalingRequired(CORINFO_METHOD_HANDLE method, CORINFO_SIG_INFO* callSiteSig);
+
+ // Generate a cookie based on the signature that would needs to be passed
+ // to the above generic stub
+ LPVOID GetCookieForPInvokeCalliSig(CORINFO_SIG_INFO* szMetaSig, void ** ppIndirection);
+ bool canGetCookieForPInvokeCalliSig(CORINFO_SIG_INFO* szMetaSig);
+
+ // Check Visibility rules.
+
+ // should we enforce the new (for whidbey) restrictions on calling virtual methods?
+ BOOL shouldEnforceCallvirtRestriction(
+ CORINFO_MODULE_HANDLE scope);
+
+ // Check constraints on method type arguments (only).
+ // The parent class should be checked separately using satisfiesClassConstraints(parent).
+ BOOL satisfiesMethodConstraints(
+ CORINFO_CLASS_HANDLE parent, // the exact parent of the method
+ CORINFO_METHOD_HANDLE method
+ );
+
+ // Given a Delegate type and a method, check if the method signature
+ // is Compatible with the Invoke method of the delegate.
+ //@GENERICSVER: new (suitable for generics)
+ BOOL isCompatibleDelegate(
+ CORINFO_CLASS_HANDLE objCls,
+ CORINFO_CLASS_HANDLE methodParentCls,
+ CORINFO_METHOD_HANDLE method,
+ CORINFO_CLASS_HANDLE delegateCls,
+ BOOL* pfIsOpenDelegate);
+
+ // Determines whether the delegate creation obeys security transparency rules
+ BOOL isDelegateCreationAllowed (
+ CORINFO_CLASS_HANDLE delegateHnd,
+ CORINFO_METHOD_HANDLE calleeHnd);
+
+ // ICorFieldInfo stuff
+ const char* getFieldName (CORINFO_FIELD_HANDLE field,
+ const char** scopeName);
+
+ CORINFO_CLASS_HANDLE getFieldClass (CORINFO_FIELD_HANDLE field);
+
+ //@GENERICSVER: added owner parameter
+ CorInfoType getFieldType (CORINFO_FIELD_HANDLE field, CORINFO_CLASS_HANDLE* structType,CORINFO_CLASS_HANDLE owner = NULL);
+ // Internal version without JIT-EE transition
+ CorInfoType getFieldTypeInternal (CORINFO_FIELD_HANDLE field, CORINFO_CLASS_HANDLE* structType,CORINFO_CLASS_HANDLE owner = NULL);
+
+ unsigned getFieldOffset (CORINFO_FIELD_HANDLE field);
+
+ bool isWriteBarrierHelperRequired(CORINFO_FIELD_HANDLE field);
+
+ void* getFieldAddress(CORINFO_FIELD_HANDLE field, void **ppIndirection);
+
+ // ICorDebugInfo stuff
+ void * allocateArray(ULONG cBytes);
+ void freeArray(void *array);
+ void getBoundaries(CORINFO_METHOD_HANDLE ftn,
+ unsigned int *cILOffsets, DWORD **pILOffsets,
+ ICorDebugInfo::BoundaryTypes *implictBoundaries);
+ void setBoundaries(CORINFO_METHOD_HANDLE ftn,
+ ULONG32 cMap, ICorDebugInfo::OffsetMapping *pMap);
+ void getVars(CORINFO_METHOD_HANDLE ftn, ULONG32 *cVars,
+ ICorDebugInfo::ILVarInfo **vars, bool *extendOthers);
+ void setVars(CORINFO_METHOD_HANDLE ftn, ULONG32 cVars,
+ ICorDebugInfo::NativeVarInfo *vars);
+
+ // ICorArgInfo stuff
+
+ CorInfoTypeWithMod getArgType (
+ CORINFO_SIG_INFO* sig,
+ CORINFO_ARG_LIST_HANDLE args,
+ CORINFO_CLASS_HANDLE *vcTypeRet
+ );
+
+ CORINFO_CLASS_HANDLE getArgClass (
+ CORINFO_SIG_INFO* sig,
+ CORINFO_ARG_LIST_HANDLE args
+ );
+
+ CorInfoType getHFAType (
+ CORINFO_CLASS_HANDLE hClass
+ );
+
+ CORINFO_ARG_LIST_HANDLE getArgNext (
+ CORINFO_ARG_LIST_HANDLE args
+ );
+
+ // ICorErrorInfo stuff
+
+ HRESULT GetErrorHRESULT(struct _EXCEPTION_POINTERS *pExceptionPointers);
+ ULONG GetErrorMessage(__out_ecount(bufferLength) LPWSTR buffer,
+ ULONG bufferLength);
+ int FilterException(struct _EXCEPTION_POINTERS *pExceptionPointers);
+ void HandleException(struct _EXCEPTION_POINTERS *pExceptionPointers);
+ void ThrowExceptionForJitResult(HRESULT result);
+ void ThrowExceptionForHelper(const CORINFO_HELPER_DESC * throwHelper);
+
+ // ICorStaticInfo stuff
+ void getEEInfo(CORINFO_EE_INFO *pEEInfoOut);
+
+ LPCWSTR getJitTimeLogFilename();
+
+ //ICorDynamicInfo stuff
+ DWORD getFieldThreadLocalStoreID (CORINFO_FIELD_HANDLE field, void **ppIndirection);
+
+ // Stub dispatch stuff
+ void getCallInfo(
+ CORINFO_RESOLVED_TOKEN * pResolvedToken,
+ CORINFO_RESOLVED_TOKEN * pConstrainedResolvedToken,
+ CORINFO_METHOD_HANDLE callerHandle,
+ CORINFO_CALLINFO_FLAGS flags,
+ CORINFO_CALL_INFO *pResult /*out */);
+ BOOL canAccessFamily(CORINFO_METHOD_HANDLE hCaller,
+ CORINFO_CLASS_HANDLE hInstanceType);
+
+protected:
+
+ static void getEHinfoHelper(
+ CORINFO_METHOD_HANDLE ftnHnd,
+ unsigned EHnumber,
+ CORINFO_EH_CLAUSE* clause,
+ COR_ILMETHOD_DECODER* pILHeader);
+
+ bool isVerifyOnly()
+ {
+ return m_fVerifyOnly;
+ }
+
+public:
+
+ BOOL isRIDClassDomainID(CORINFO_CLASS_HANDLE cls);
+ unsigned getClassDomainID (CORINFO_CLASS_HANDLE cls, void **ppIndirection);
+ CORINFO_VARARGS_HANDLE getVarArgsHandle(CORINFO_SIG_INFO *sig, void **ppIndirection);
+ bool canGetVarArgsHandle(CORINFO_SIG_INFO *sig);
+ void* getPInvokeUnmanagedTarget(CORINFO_METHOD_HANDLE method, void **ppIndirection);
+ void* getAddressOfPInvokeFixup(CORINFO_METHOD_HANDLE method, void **ppIndirection);
+ void getAddressOfPInvokeTarget(CORINFO_METHOD_HANDLE method, CORINFO_CONST_LOOKUP *pLookup);
+ CORINFO_JUST_MY_CODE_HANDLE getJustMyCodeHandle(CORINFO_METHOD_HANDLE method, CORINFO_JUST_MY_CODE_HANDLE **ppIndirection);
+
+ void GetProfilingHandle(
+ BOOL *pbHookFunction,
+ void **pProfilerHandle,
+ BOOL *pbIndirectedHandles
+ );
+
+ InfoAccessType constructStringLiteral(CORINFO_MODULE_HANDLE scopeHnd, mdToken metaTok, void **ppValue);
+ InfoAccessType emptyStringLiteral(void ** ppValue);
+ void* getMethodSync(CORINFO_METHOD_HANDLE ftnHnd, void **ppIndirection);
+
+ DWORD getThreadTLSIndex(void **ppIndirection);
+ const void * getInlinedCallFrameVptr(void **ppIndirection);
+
+ // Returns the address of the domain neutral module id. This only makes sense for domain neutral (shared)
+ // modules
+ SIZE_T* getAddrModuleDomainID(CORINFO_MODULE_HANDLE module);
+
+ LONG * getAddrOfCaptureThreadGlobal(void **ppIndirection);
+ void* getHelperFtn(CorInfoHelpFunc ftnNum, /* IN */
+ void ** ppIndirection); /* OUT */
+
+ void* getTailCallCopyArgsThunk(CORINFO_SIG_INFO *pSig,
+ CorInfoHelperTailCallSpecialHandling flags);
+
+ void getFunctionEntryPoint(CORINFO_METHOD_HANDLE ftn, /* IN */
+ CORINFO_CONST_LOOKUP * pResult, /* OUT */
+ CORINFO_ACCESS_FLAGS accessFlags = CORINFO_ACCESS_ANY);
+
+ void getFunctionFixedEntryPoint(CORINFO_METHOD_HANDLE ftn,
+ CORINFO_CONST_LOOKUP * pResult);
+
+ // get slow lazy string literal helper to use (CORINFO_HELP_STRCNS*).
+ // Returns CORINFO_HELP_UNDEF if lazy string literal helper cannot be used.
+ CorInfoHelpFunc getLazyStringLiteralHelper(CORINFO_MODULE_HANDLE handle);
+
+ CORINFO_MODULE_HANDLE embedModuleHandle(CORINFO_MODULE_HANDLE handle,
+ void **ppIndirection);
+ CORINFO_CLASS_HANDLE embedClassHandle(CORINFO_CLASS_HANDLE handle,
+ void **ppIndirection);
+ CORINFO_FIELD_HANDLE embedFieldHandle(CORINFO_FIELD_HANDLE handle,
+ void **ppIndirection);
+ CORINFO_METHOD_HANDLE embedMethodHandle(CORINFO_METHOD_HANDLE handle,
+ void **ppIndirection);
+
+ void embedGenericHandle(CORINFO_RESOLVED_TOKEN * pResolvedToken,
+ BOOL fEmbedParent,
+ CORINFO_GENERICHANDLE_RESULT *pResult);
+
+ CORINFO_LOOKUP_KIND getLocationOfThisType(CORINFO_METHOD_HANDLE context);
+
+
+ void setOverride(ICorDynamicInfo *pOverride, CORINFO_METHOD_HANDLE currentMethod)
+ {
+ LIMITED_METHOD_CONTRACT;
+ m_pOverride = pOverride;
+ m_pMethodBeingCompiled = (MethodDesc *)currentMethod; // method being compiled
+
+ m_hMethodForSecurity_Key = NULL;
+ m_pMethodForSecurity_Value = NULL;
+ }
+
+ // Returns whether we are generating code for NGen image.
+ BOOL IsCompilingForNGen()
+ {
+ LIMITED_METHOD_CONTRACT;
+ // NGen is the only place where we set the override
+ return this != m_pOverride;
+ }
+
+ void addActiveDependency(CORINFO_MODULE_HANDLE moduleFrom, CORINFO_MODULE_HANDLE moduleTo);
+ CORINFO_METHOD_HANDLE GetDelegateCtor(
+ CORINFO_METHOD_HANDLE methHnd,
+ CORINFO_CLASS_HANDLE clsHnd,
+ CORINFO_METHOD_HANDLE targetMethodHnd,
+ DelegateCtorArgs * pCtorData);
+
+ void MethodCompileComplete(
+ CORINFO_METHOD_HANDLE methHnd);
+
+ //
+ // ICorJitInfo stuff - none of this should be called on this class
+ //
+
+ IEEMemoryManager* getMemoryManager();
+
+ void allocMem (
+ ULONG hotCodeSize, /* IN */
+ ULONG coldCodeSize, /* IN */
+ ULONG roDataSize, /* IN */
+ ULONG xcptnsCount, /* IN */
+ CorJitAllocMemFlag flag, /* IN */
+ void ** hotCodeBlock, /* OUT */
+ void ** coldCodeBlock, /* OUT */
+ void ** roDataBlock /* OUT */
+ );
+
+ void reserveUnwindInfo (
+ BOOL isFunclet, /* IN */
+ BOOL isColdCode, /* IN */
+ ULONG unwindSize /* IN */
+ );
+
+ void allocUnwindInfo (
+ BYTE * pHotCode, /* IN */
+ BYTE * pColdCode, /* IN */
+ ULONG startOffset, /* IN */
+ ULONG endOffset, /* IN */
+ ULONG unwindSize, /* IN */
+ BYTE * pUnwindBlock, /* IN */
+ CorJitFuncKind funcKind /* IN */
+ );
+
+ void * allocGCInfo (
+ size_t size /* IN */
+ );
+
+ void yieldExecution();
+
+ void setEHcount (
+ unsigned cEH /* IN */
+ );
+
+ void setEHinfo (
+ unsigned EHnumber, /* IN */
+ const CORINFO_EH_CLAUSE *clause /* IN */
+ );
+
+ BOOL logMsg(unsigned level, const char* fmt, va_list args);
+
+ int doAssert(const char* szFile, int iLine, const char* szExpr);
+
+ void reportFatalError(CorJitResult result);
+
+ void logSQMLongJitEvent(unsigned mcycles, unsigned msec, unsigned ilSize, unsigned numBasicBlocks, bool minOpts,
+ CORINFO_METHOD_HANDLE methodHnd);
+
+ HRESULT allocBBProfileBuffer (
+ ULONG count, // The number of basic blocks that we have
+ ProfileBuffer ** profileBuffer
+ );
+
+ HRESULT getBBProfileData(
+ CORINFO_METHOD_HANDLE ftnHnd,
+ ULONG * count, // The number of basic blocks that we have
+ ProfileBuffer ** profileBuffer,
+ ULONG * numRuns
+ );
+
+ void recordCallSite(
+ ULONG instrOffset, /* IN */
+ CORINFO_SIG_INFO * callSig, /* IN */
+ CORINFO_METHOD_HANDLE methodHandle /* IN */
+ );
+
+ void recordRelocation(
+ void * location, /* IN */
+ void * target, /* IN */
+ WORD fRelocType, /* IN */
+ WORD slotNum = 0, /* IN */
+ INT32 addlDelta = 0 /* IN */
+ );
+
+ WORD getRelocTypeHint(void * target);
+
+ void getModuleNativeEntryPointRange(
+ void ** pStart, /* OUT */
+ void ** pEnd /* OUT */
+ );
+
+ DWORD getExpectedTargetArchitecture();
+
+ CEEInfo(MethodDesc * fd = NULL, bool fVerifyOnly = false) :
+ m_pOverride(NULL),
+ m_pMethodBeingCompiled(fd),
+ m_fVerifyOnly(fVerifyOnly),
+ m_pThread(GetThread()),
+ m_hMethodForSecurity_Key(NULL),
+ m_pMethodForSecurity_Value(NULL)
+ {
+ LIMITED_METHOD_CONTRACT;
+ }
+
+ virtual ~CEEInfo()
+ {
+ LIMITED_METHOD_CONTRACT;
+ }
+
+ // Performs any work JIT-related work that should be performed at process shutdown.
+ void JitProcessShutdownWork();
+
+ void setJitFlags(const CORJIT_FLAGS& jitFlags);
+
+ DWORD getJitFlags(CORJIT_FLAGS* jitFlags, DWORD sizeInBytes);
+
+ bool runWithErrorTrap(void (*function)(void*), void* param);
+
+private:
+ // Shrinking these buffers drastically reduces the amount of stack space
+ // required for each instance of the interpreter, and thereby reduces SOs.
+#ifdef FEATURE_INTERPRETER
+#define CLS_STRING_SIZE 8 // force heap allocation
+#define CLS_BUFFER_SIZE SBUFFER_PADDED_SIZE(8)
+#else
+#define CLS_STRING_SIZE MAX_CLASSNAME_LENGTH
+#define CLS_BUFFER_SIZE MAX_CLASSNAME_LENGTH
+#endif
+
+#ifdef _DEBUG
+ InlineSString<MAX_CLASSNAME_LENGTH> ssClsNameBuff;
+ ScratchBuffer<MAX_CLASSNAME_LENGTH> ssClsNameBuffScratch;
+#endif
+
+public:
+
+ //@GENERICS:
+ // The method handle is used to instantiate method and class type parameters
+ // It's also used to determine whether an extra dictionary parameter is required
+ static
+ void
+ ConvToJitSig(
+ PCCOR_SIGNATURE pSig,
+ DWORD cbSig,
+ CORINFO_MODULE_HANDLE scopeHnd,
+ mdToken token,
+ CORINFO_SIG_INFO * sigRet,
+ MethodDesc * context,
+ bool localSig,
+ TypeHandle owner = TypeHandle());
+
+ MethodDesc * GetMethodForSecurity(CORINFO_METHOD_HANDLE callerHandle);
+
+ // Prepare the information about how to do a runtime lookup of the handle with shared
+ // generic variables.
+ void ComputeRuntimeLookupForSharedGenericToken(DictionaryEntryKind entryKind,
+ CORINFO_RESOLVED_TOKEN * pResolvedToken,
+ CORINFO_RESOLVED_TOKEN * pConstrainedResolvedToken /* for ConstrainedMethodEntrySlot */,
+ MethodDesc * pTemplateMD /* for method-based slots */,
+ CORINFO_LOOKUP *pResultLookup);
+
+ static void ComputeRuntimeLookupForSharedGenericTokenStatic(DictionaryEntryKind entryKind,
+ CORINFO_RESOLVED_TOKEN * pResolvedToken,
+ CORINFO_RESOLVED_TOKEN * pConstrainedResolvedToken /* for ConstrainedMethodEntrySlot */,
+ MethodDesc * pTemplateMD /* for method-based slots */,
+ LoaderAllocator* pAllocator,
+ DWORD numGenericArgs,
+ DictionaryLayout* pDictionaryLayout,
+ DWORD typeDictionaryIndex,
+ CORINFO_LOOKUP *pResultLookup,
+ BOOL fEnableTypeHandleLookupOptimization,
+ BOOL fInstrument);
+
+protected:
+ // NGen provides its own modifications to EE-JIT interface. From technical reason it cannot simply inherit
+ // from code:CEEInfo class (because it has dependencies on VM that NGen does not want).
+ // Therefore the "normal" EE-JIT interface has code:m_pOverride hook that is set either to
+ // * 'this' (code:CEEInfo) at runtime, or to
+ // * code:ZapInfo - the NGen specific implementation of the interface.
+ ICorDynamicInfo * m_pOverride;
+
+ MethodDesc* m_pMethodBeingCompiled; // Top-level method being compiled
+ bool m_fVerifyOnly;
+ Thread * m_pThread; // Cached current thread for faster JIT-EE transitions
+ CORJIT_FLAGS m_jitFlags;
+
+ CORINFO_METHOD_HANDLE getMethodBeingCompiled()
+ {
+ LIMITED_METHOD_CONTRACT;
+ return (CORINFO_METHOD_HANDLE)m_pMethodBeingCompiled;
+ }
+
+ // Cache of last GetMethodForSecurity() lookup
+ CORINFO_METHOD_HANDLE m_hMethodForSecurity_Key;
+ MethodDesc * m_pMethodForSecurity_Value;
+
+ // Tracking of module activation dependencies. We have two flavors:
+ // - Fast one that gathers generic arguments from EE handles, but does not work inside generic context.
+ // - Slow one that operates on typespec and methodspecs from metadata.
+ void ScanForModuleDependencies(Module* pModule, SigPointer psig);
+ void ScanMethodSpec(Module * pModule, PCCOR_SIGNATURE pMethodSpec, ULONG cbMethodSpec);
+ // Returns true if it is ok to proceed with scan of parent chain
+ BOOL ScanTypeSpec(Module * pModule, PCCOR_SIGNATURE pTypeSpec, ULONG cbTypeSpec);
+ void ScanInstantiation(Module * pModule, Instantiation inst);
+
+ // The main entrypoints for module activation tracking
+ void ScanToken(Module * pModule, CORINFO_RESOLVED_TOKEN * pResolvedToken, TypeHandle th, MethodDesc * pMD = NULL);
+ void ScanTokenForDynamicScope(CORINFO_RESOLVED_TOKEN * pResolvedToken, TypeHandle th, MethodDesc * pMD = NULL);
+};
+
+
+/*********************************************************************/
+
+class EEJitManager;
+struct _hpCodeHdr;
+typedef struct _hpCodeHdr CodeHeader;
+
+#ifndef CROSSGEN_COMPILE
+// CEEJitInfo is the concrete implementation of callbacks that the EE must provide for the JIT to do its
+// work. See code:ICorJitInfo#JitToEEInterface for more on this interface.
+class CEEJitInfo : public CEEInfo
+{
+public:
+ // ICorJitInfo stuff
+
+ void allocMem (
+ ULONG hotCodeSize, /* IN */
+ ULONG coldCodeSize, /* IN */
+ ULONG roDataSize, /* IN */
+ ULONG xcptnsCount, /* IN */
+ CorJitAllocMemFlag flag, /* IN */
+ void ** hotCodeBlock, /* OUT */
+ void ** coldCodeBlock, /* OUT */
+ void ** roDataBlock /* OUT */
+ );
+
+ void reserveUnwindInfo(BOOL isFunclet, BOOL isColdCode, ULONG unwindSize);
+
+ void allocUnwindInfo (
+ BYTE * pHotCode, /* IN */
+ BYTE * pColdCode, /* IN */
+ ULONG startOffset, /* IN */
+ ULONG endOffset, /* IN */
+ ULONG unwindSize, /* IN */
+ BYTE * pUnwindBlock, /* IN */
+ CorJitFuncKind funcKind /* IN */
+ );
+
+ void * allocGCInfo (size_t size);
+
+ void setEHcount (unsigned cEH);
+
+ void setEHinfo (
+ unsigned EHnumber,
+ const CORINFO_EH_CLAUSE* clause);
+
+ void getEHinfo(
+ CORINFO_METHOD_HANDLE ftn, /* IN */
+ unsigned EHnumber, /* IN */
+ CORINFO_EH_CLAUSE* clause /* OUT */
+ );
+
+
+ HRESULT allocBBProfileBuffer (
+ ULONG count, // The number of basic blocks that we have
+ ICorJitInfo::ProfileBuffer ** profileBuffer
+ );
+
+ HRESULT getBBProfileData (
+ CORINFO_METHOD_HANDLE ftnHnd,
+ ULONG * count, // The number of basic blocks that we have
+ ICorJitInfo::ProfileBuffer ** profileBuffer,
+ ULONG * numRuns
+ );
+
+ void recordCallSite(
+ ULONG instrOffset, /* IN */
+ CORINFO_SIG_INFO * callSig, /* IN */
+ CORINFO_METHOD_HANDLE methodHandle /* IN */
+ );
+
+ void recordRelocation(
+ void *location,
+ void *target,
+ WORD fRelocType,
+ WORD slot,
+ INT32 addlDelta);
+
+ WORD getRelocTypeHint(void * target);
+
+ void getModuleNativeEntryPointRange(
+ void** pStart,
+ void** pEnd);
+
+ DWORD getExpectedTargetArchitecture();
+
+ CodeHeader* GetCodeHeader()
+ {
+ LIMITED_METHOD_CONTRACT;
+ return m_CodeHeader;
+ }
+
+ void SetCodeHeader(CodeHeader* pValue)
+ {
+ LIMITED_METHOD_CONTRACT;
+ m_CodeHeader = pValue;
+ }
+
+ void ResetForJitRetry()
+ {
+ CONTRACTL {
+ SO_TOLERANT;
+ NOTHROW;
+ GC_NOTRIGGER;
+ } CONTRACTL_END;
+
+ m_CodeHeader = NULL;
+
+ if (m_pOffsetMapping != NULL)
+ delete [] ((BYTE*) m_pOffsetMapping);
+
+ if (m_pNativeVarInfo != NULL)
+ delete [] ((BYTE*) m_pNativeVarInfo);
+
+ m_iOffsetMapping = 0;
+ m_pOffsetMapping = NULL;
+ m_iNativeVarInfo = 0;
+ m_pNativeVarInfo = NULL;
+
+#ifdef WIN64EXCEPTIONS
+ m_moduleBase = NULL;
+ m_totalUnwindSize = 0;
+ m_usedUnwindSize = 0;
+ m_theUnwindBlock = NULL;
+ m_totalUnwindInfos = 0;
+ m_usedUnwindInfos = 0;
+#endif // WIN64EXCEPTIONS
+ }
+
+#ifdef _TARGET_AMD64_
+ void SetAllowRel32(BOOL fAllowRel32)
+ {
+ LIMITED_METHOD_CONTRACT;
+ m_fAllowRel32 = fAllowRel32;
+ }
+
+ void SetRel32Overflow(BOOL fRel32Overflow)
+ {
+ LIMITED_METHOD_CONTRACT;
+ m_fRel32Overflow = fRel32Overflow;
+ }
+
+ BOOL IsRel32Overflow()
+ {
+ LIMITED_METHOD_CONTRACT;
+ return m_fRel32Overflow;
+ }
+
+ BOOL JitAgain()
+ {
+ LIMITED_METHOD_CONTRACT;
+ return m_fRel32Overflow;
+ }
+#else
+ BOOL JitAgain()
+ {
+ LIMITED_METHOD_CONTRACT;
+ return FALSE;
+ }
+#endif
+
+ CEEJitInfo(MethodDesc* fd, COR_ILMETHOD_DECODER* header,
+ EEJitManager* jm, bool fVerifyOnly)
+ : CEEInfo(fd, fVerifyOnly),
+ m_jitManager(jm),
+ m_CodeHeader(NULL),
+ m_ILHeader(header),
+#ifdef WIN64EXCEPTIONS
+ m_moduleBase(NULL),
+ m_totalUnwindSize(0),
+ m_usedUnwindSize(0),
+ m_theUnwindBlock(NULL),
+ m_totalUnwindInfos(0),
+ m_usedUnwindInfos(0),
+#endif
+#ifdef _TARGET_AMD64_
+ m_fAllowRel32(FALSE),
+ m_fRel32Overflow(FALSE),
+#endif
+ m_GCinfo_len(0),
+ m_EHinfo_len(0),
+ m_iOffsetMapping(0),
+ m_pOffsetMapping(NULL),
+ m_iNativeVarInfo(0),
+ m_pNativeVarInfo(NULL),
+ m_gphCache()
+ {
+ CONTRACTL
+ {
+ NOTHROW;
+ GC_NOTRIGGER;
+ MODE_ANY;
+ } CONTRACTL_END;
+
+ m_pOverride = this;
+ }
+
+ ~CEEJitInfo()
+ {
+ CONTRACTL
+ {
+ NOTHROW;
+ GC_NOTRIGGER;
+ MODE_ANY;
+ } CONTRACTL_END;
+
+ if (m_pOffsetMapping != NULL)
+ delete [] ((BYTE*) m_pOffsetMapping);
+
+ if (m_pNativeVarInfo != NULL)
+ delete [] ((BYTE*) m_pNativeVarInfo);
+ }
+
+ // ICorDebugInfo stuff.
+ void setBoundaries(CORINFO_METHOD_HANDLE ftn,
+ ULONG32 cMap, ICorDebugInfo::OffsetMapping *pMap);
+ void setVars(CORINFO_METHOD_HANDLE ftn, ULONG32 cVars,
+ ICorDebugInfo::NativeVarInfo *vars);
+ void CompressDebugInfo();
+
+ void* getHelperFtn(CorInfoHelpFunc ftnNum, /* IN */
+ void ** ppIndirection); /* OUT */
+ static PCODE getHelperFtnStatic(CorInfoHelpFunc ftnNum);
+
+ // Override active dependency to talk to loader
+ void addActiveDependency(CORINFO_MODULE_HANDLE moduleFrom, CORINFO_MODULE_HANDLE moduleTo);
+
+ // Override of CEEInfo::GetProfilingHandle. The first time this is called for a
+ // method desc, it calls through to CEEInfo::GetProfilingHandle and caches the
+ // result in CEEJitInfo::GetProfilingHandleCache. Thereafter, this wrapper regurgitates the cached values
+ // rather than calling into CEEInfo::GetProfilingHandle each time. This avoids
+ // making duplicate calls into the profiler's FunctionIDMapper callback.
+ void GetProfilingHandle(
+ BOOL *pbHookFunction,
+ void **pProfilerHandle,
+ BOOL *pbIndirectedHandles
+ );
+
+ InfoAccessType constructStringLiteral(CORINFO_MODULE_HANDLE scopeHnd, mdToken metaTok, void **ppValue);
+ InfoAccessType emptyStringLiteral(void ** ppValue);
+ void* getFieldAddress(CORINFO_FIELD_HANDLE field, void **ppIndirection);
+ void* getMethodSync(CORINFO_METHOD_HANDLE ftnHnd, void **ppIndirection);
+
+ void BackoutJitData(EEJitManager * jitMgr);
+
+protected :
+ EEJitManager* m_jitManager; // responsible for allocating memory
+ CodeHeader* m_CodeHeader; // descriptor for JITTED code
+ COR_ILMETHOD_DECODER * m_ILHeader; // the code header as exist in the file
+#ifdef WIN64EXCEPTIONS
+ TADDR m_moduleBase; // Base for unwind Infos
+ ULONG m_totalUnwindSize; // Total reserved unwind space
+ ULONG m_usedUnwindSize; // used space in m_theUnwindBlock
+ BYTE * m_theUnwindBlock; // start of the unwind memory block
+ ULONG m_totalUnwindInfos; // Number of RUNTIME_FUNCTION needed
+ ULONG m_usedUnwindInfos;
+#endif
+
+#ifdef _TARGET_AMD64_
+ BOOL m_fAllowRel32; // Use 32-bit PC relative address modes
+ BOOL m_fRel32Overflow; // Overflow while trying to use encode 32-bit PC relative address.
+ // The code will need to be regenerated with m_fRel32Allowed == FALSE.
+#endif
+
+#if defined(_DEBUG)
+ ULONG m_codeSize; // Code size requested via allocMem
+#endif
+
+ size_t m_GCinfo_len; // Cached copy of GCinfo_len so we can backout in BackoutJitData()
+ size_t m_EHinfo_len; // Cached copy of EHinfo_len so we can backout in BackoutJitData()
+
+ ULONG32 m_iOffsetMapping;
+ ICorDebugInfo::OffsetMapping * m_pOffsetMapping;
+
+ ULONG32 m_iNativeVarInfo;
+ ICorDebugInfo::NativeVarInfo * m_pNativeVarInfo;
+
+ // The first time a call is made to CEEJitInfo::GetProfilingHandle() from this thread
+ // for this method, these values are filled in. Thereafter, these values are used
+ // in lieu of calling into the base CEEInfo::GetProfilingHandle() again. This protects the
+ // profiler from duplicate calls to its FunctionIDMapper() callback.
+ struct GetProfilingHandleCache
+ {
+ GetProfilingHandleCache() :
+ m_bGphIsCacheValid(false),
+ m_bGphHookFunction(false),
+ m_pvGphProfilerHandle(NULL)
+ {
+ LIMITED_METHOD_CONTRACT;
+ }
+
+ bool m_bGphIsCacheValid : 1; // Tells us whether below values are valid
+ bool m_bGphHookFunction : 1;
+ void* m_pvGphProfilerHandle;
+ } m_gphCache;
+
+
+};
+#endif // CROSSGEN_COMPILE
+
+/*********************************************************************/
+/*********************************************************************/
+
+typedef struct {
+ void * pfnHelper;
+#ifdef _DEBUG
+ const char* name;
+#endif
+} VMHELPDEF;
+
+#if defined(DACCESS_COMPILE)
+
+GARY_DECL(VMHELPDEF, hlpFuncTable, CORINFO_HELP_COUNT);
+
+#else
+
+extern "C" const VMHELPDEF hlpFuncTable[CORINFO_HELP_COUNT];
+
+#endif
+
+#if defined(_DEBUG) && (defined(_TARGET_AMD64_) || defined(_TARGET_X86_)) && !defined(FEATURE_PAL)
+typedef struct {
+ void* pfnRealHelper;
+ const char* helperName;
+ LONG count;
+ LONG helperSize;
+} VMHELPCOUNTDEF;
+
+extern "C" VMHELPCOUNTDEF hlpFuncCountTable[CORINFO_HELP_COUNT+1];
+
+void InitJitHelperLogging();
+void WriteJitHelperCountToSTRESSLOG();
+#else
+inline void InitJitHelperLogging() { }
+inline void WriteJitHelperCountToSTRESSLOG() { }
+#endif
+
+// enum for dynamically assigned helper calls
+enum DynamicCorInfoHelpFunc {
+#define JITHELPER(code, pfnHelper, sig)
+#define DYNAMICJITHELPER(code, pfnHelper, sig) DYNAMIC_##code,
+#include "jithelpers.h"
+ DYNAMIC_CORINFO_HELP_COUNT
+};
+
+#ifdef _MSC_VER
+// GCC complains about duplicate "extern". And it is not needed for the GCC build
+extern "C"
+#endif
+GARY_DECL(VMHELPDEF, hlpDynamicFuncTable, DYNAMIC_CORINFO_HELP_COUNT);
+
+#define SetJitHelperFunction(ftnNum, pFunc) _SetJitHelperFunction(DYNAMIC_##ftnNum, (void*)(pFunc))
+void _SetJitHelperFunction(DynamicCorInfoHelpFunc ftnNum, void * pFunc);
+#ifdef ENABLE_FAST_GCPOLL_HELPER
+//These should only be called from ThreadStore::TrapReturningThreads!
+
+//Called when the VM wants to suspend one or more threads.
+void EnableJitGCPoll();
+//Called when there are no threads to suspend.
+void DisableJitGCPoll();
+#endif
+
+// Helper for RtlVirtualUnwind-based tail calls
+#if defined(_TARGET_AMD64_) || defined(_TARGET_ARM_)
+
+// The Stub-linker generated assembly routine to copy arguments from the va_list
+// into the CONTEXT and the stack.
+//
+typedef size_t (*pfnCopyArgs)(va_list, _CONTEXT *, DWORD_PTR *, size_t);
+
+// Forward declaration from Frames.h
+class TailCallFrame;
+
+// The shared stub return location
+EXTERN_C void JIT_TailCallHelperStub_ReturnAddress();
+
+#endif // _TARGET_AMD64_ || _TARGET_ARM_
+
+
+#ifdef _TARGET_X86_
+
+class JIT_TrialAlloc
+{
+public:
+ enum Flags
+ {
+ NORMAL = 0x0,
+ MP_ALLOCATOR = 0x1,
+ SIZE_IN_EAX = 0x2,
+ OBJ_ARRAY = 0x4,
+ ALIGN8 = 0x8, // insert a dummy object to insure 8 byte alignment (until the next GC)
+ ALIGN8OBJ = 0x10,
+ NO_FRAME = 0x20, // call is from unmanaged code - don't try to put up a frame
+ };
+
+ static void *GenAllocSFast(Flags flags);
+ static void *GenBox(Flags flags);
+ static void *GenAllocArray(Flags flags);
+ static void *GenAllocString(Flags flags);
+
+private:
+ static void EmitAlignmentRoundup(CPUSTUBLINKER *psl,X86Reg regTestAlign, X86Reg regToAdj, Flags flags);
+ static void EmitDummyObject(CPUSTUBLINKER *psl, X86Reg regTestAlign, Flags flags);
+ static void EmitCore(CPUSTUBLINKER *psl, CodeLabel *noLock, CodeLabel *noAlloc, Flags flags);
+ static void EmitNoAllocCode(CPUSTUBLINKER *psl, Flags flags);
+
+#if CHECK_APP_DOMAIN_LEAKS
+ static void EmitSetAppDomain(CPUSTUBLINKER *psl);
+ static void EmitCheckRestore(CPUSTUBLINKER *psl);
+#endif
+};
+#endif // _TARGET_X86_
+
+void *GenFastGetSharedStaticBase(bool bCheckCCtor);
+
+#ifdef HAVE_GCCOVER
+void SetupGcCoverage(MethodDesc* pMD, BYTE* nativeCode);
+void SetupGcCoverageForNativeImage(Module* module);
+bool IsGcCoverageInterrupt(LPVOID ip);
+BOOL OnGcCoverageInterrupt(PT_CONTEXT regs);
+void DoGcStress (PT_CONTEXT regs, MethodDesc *pMD);
+#endif //HAVE_GCCOVER
+
+EXTERN_C FCDECL2(LPVOID, ArrayStoreCheck, Object** pElement, PtrArray** pArray);
+
+OBJECTHANDLE ConstructStringLiteral(CORINFO_MODULE_HANDLE scopeHnd, mdToken metaTok);
+
+FCDECL2(Object*, JIT_Box, CORINFO_CLASS_HANDLE type, void* data);
+FCDECL0(VOID, JIT_PollGC);
+#ifdef ENABLE_FAST_GCPOLL_HELPER
+EXTERN_C FCDECL0(VOID, JIT_PollGC_Nop);
+#endif
+
+BOOL ObjIsInstanceOf(Object *pObject, TypeHandle toTypeHnd, BOOL throwCastException = FALSE);
+EXTERN_C TypeHandle::CastResult STDCALL ObjIsInstanceOfNoGC(Object *pObject, TypeHandle toTypeHnd);
+
+#ifdef _WIN64
+class InlinedCallFrame;
+Thread * __stdcall JIT_InitPInvokeFrame(InlinedCallFrame *pFrame, PTR_VOID StubSecretArg);
+#endif
+
+#ifdef _DEBUG
+extern LONG g_JitCount;
+#endif
+
+struct VirtualFunctionPointerArgs
+{
+ CORINFO_CLASS_HANDLE classHnd;
+ CORINFO_METHOD_HANDLE methodHnd;
+};
+
+FCDECL2(CORINFO_MethodPtr, JIT_VirtualFunctionPointer_Dynamic, Object * objectUNSAFE, VirtualFunctionPointerArgs * pArgs);
+
+typedef TADDR (F_CALL_CONV * FnStaticBaseHelper)(TADDR arg0, TADDR arg1);
+
+struct StaticFieldAddressArgs
+{
+ FnStaticBaseHelper staticBaseHelper;
+ TADDR arg0;
+ TADDR arg1;
+ SIZE_T offset;
+};
+
+FCDECL1(TADDR, JIT_StaticFieldAddress_Dynamic, StaticFieldAddressArgs * pArgs);
+FCDECL1(TADDR, JIT_StaticFieldAddressUnbox_Dynamic, StaticFieldAddressArgs * pArgs);
+
+CORINFO_GENERIC_HANDLE JIT_GenericHandleWorker(MethodDesc *pMD,
+ MethodTable *pMT,
+ LPVOID signature);
+
+void ClearJitGenericHandleCache(AppDomain *pDomain);
+
+class JitHelpers {
+public:
+ static FCDECL3(void, UnsafeSetArrayElement, PtrArray* pPtrArray, INT32 index, Object* object);
+};
+
+DWORD GetDebuggerCompileFlags(Module* pModule, DWORD flags);
+
+bool TrackAllocationsEnabled();
+
+#endif // JITINTERFACE_H
projects / platform / upstream / dotnet / runtime.git / commitdiff