ThunkInput.txt

; Licensed to the .NET Foundation under one or more agreements.
; The .NET Foundation licenses this file to you under the MIT license.
;
; Thunk generator input file for generating the thunks from the C++ version of the 
; jit interface to COM, into managed, and from COM to C++. 
;
; The format of this file is as follows. 
; There are NORMALTYPES, RETURNTYPES, and FUNCTIONS regions
;  In the NORMALTYPES/RETURNTYPES region, each type is described. If a type is 
;  described in the NORMALTYPES section, but isn't described in the RETURNTYPES section
;  then the NORMALTYPES description can be used for a return value.
;
; TYPES have three fields
; ThunkDescriptionType,ManagedType,NativeType
;   If either ManagedType or NativeType are missing, then that form is replaced with ThunkDescriptionType. 
;   This feature allows reduction in type for enums and other types where the same type can be used in managed an native
;
;  Specification of a custom native type is done to allow multiple translations of the same native type to managed.
;  i.e.
;  REFIntPointer,ref int *,int**
;  and
;  PointerToIntPointer,int**,int**
;
; Following the TYPES sections, there is the FUNCTIONS section
; Each function that is to be part of the interface is written here. The format is basically the C++ format 
; without support for inline comments or sal annotations.
;
; Also, note that an empty line is ignored, and a line that begins with a ; is ignored.
;
; If the boilerplate around the individual functions needs adjustment, edit the thunk generator source code, and 
;    rebuild with rebuildthunkgen.cmd in the the ThunkGenerator subdir, then rebuildthunks.cmd
; If this file is editted, rebuild with rebuildthunks.cmd -- DO NOT RUN from within a razzle window.
;
NORMALTYPES
void
LPVOID,void*,void*
void*
const void *,void*
HRESULT,,int
SIZE_T*,void*,size_t*
int
INT,int,int
INT32,int,int
UINT32,uint,unsigned int
ULONG32,uint,unsigned int
ULONG,uint,unsigned int
DWORD,uint,unsigned int
unsigned,uint
unsigned int, uint
size_t,UIntPtr
SIZE_T,UIntPtr,size_t
WORD,ushort,unsigned short
BOOL,[MarshalAs(UnmanagedType.Bool)]bool,int
bool,[MarshalAs(UnmanagedType.I1)]bool
const char *,byte*
mdMethodDef,mdToken,unsigned int
mdToken,,unsigned int
BYTE*,byte*,unsigned char*
GSCookie*,IntPtr*,void*
GSCookie**,IntPtr**,void**

BOOL*,[MarshalAs(UnmanagedType.Bool)] ref bool,int*
bool*,[MarshalAs(UnmanagedType.U1)] ref bool
BoolStar,byte*,bool*
UINT32*,ref uint,unsigned int*
ULONG*,ref uint,unsigned long*
void **,ref void*
VOIDSTARSTAR,void **,void **
ULONG32*,ref uint,unsigned int*
LONG*,int*,long*
char*,byte*
const char**,byte**
WCHAR**,char**,wchar_t**
LPCSTR,byte*,const char*
LPWSTR,char*,wchar_t*
LPCWSTR,char*,const wchar_t*
wchar_t*,char*
const wchar_t*,String

DWORD**,ref uint*,unsigned int**
unsigned*,ref uint
DWORD*,ref uint,unsigned int*
CORJIT_FLAGS*,ref CORJIT_FLAGS,void*
CORINFO_CONST_LOOKUP*,ref CORINFO_CONST_LOOKUP,void*
CORINFO_LOOKUP*,ref CORINFO_LOOKUP,void*
CORINFO_LOOKUP_KIND*,ref CORINFO_LOOKUP_KIND,void*
CORINFO_EH_CLAUSE*,ref CORINFO_EH_CLAUSE,void*
const CORINFO_EH_CLAUSE*,ref CORINFO_EH_CLAUSE,void*
CORINFO_SIG_INFO*,,void*
CORINFO_RESOLVED_TOKEN*,ref CORINFO_RESOLVED_TOKEN,void*
CORINFO_RESOLVED_TOKEN_PTR,CORINFO_RESOLVED_TOKEN*,void*
CORINFO_EE_INFO*,ref CORINFO_EE_INFO,void*
CORINFO_TAILCALL_HELPERS*,ref CORINFO_TAILCALL_HELPERS,void*
CORINFO_GENERICHANDLE_RESULT*,ref CORINFO_GENERICHANDLE_RESULT,void*
CORINFO_METHOD_INFO*,CORINFO_METHOD_INFO*,void*
CORINFO_FIELD_INFO*,CORINFO_FIELD_INFO*,void*
CORINFO_CALL_INFO*,CORINFO_CALL_INFO*,void*
PatchpointInfo*,PatchpointInfo*,void*
DelegateCtorArgs*,ref DelegateCtorArgs,void*
ICorDynamicInfo*,IntPtr,void*
va_list,IntPtr
CORINFO_HELPER_DESC*,ref CORINFO_HELPER_DESC,void*
const CORINFO_HELPER_DESC*,ref CORINFO_HELPER_DESC,const void*
int*,ref int
unsigned int*,ref uint

CORINFO_JUST_MY_CODE_HANDLE**,ref CORINFO_JUST_MY_CODE_HANDLE_*,void**

ICorJitInfo::BlockCounts**,ref BlockCounts*,void**

; Enums
CorInfoClassId,,int
CorInfoHelpFunc,,int
CorInfoInitClassResult,,int
CorInfoInlineTypeCheck,,int
CorInfoInlineTypeCheckSource,,int
CorInfoInline,,int
CorInfoIntrinsics,,int
CorInfoIsAccessAllowedResult,,int
CorInfoMethodRuntimeFlags,,int
CorInfoTailCall,,int
CorInfoType,,int
CorInfoHFAElemType,,int
CorInfoTypeWithMod,,int
CorInfoUnmanagedCallConv,,int
InfoAccessType,,int
CORINFO_LOOKUP_KIND
CORINFO_ACCESS_FLAGS,,int
CORINFO_CALLINFO_FLAGS,,int
CORINFO_GET_TAILCALL_HELPERS_FLAGS,,int
CorJitAllocMemFlag,,int
CorJitFuncKind,,int
CorJitResult,,int
TypeCompareState,,int
CORINFO_InstructionSet,InstructionSet,int

; Handle types
CORINFO_MODULE_HANDLE,CORINFO_MODULE_STRUCT_*,void*
CORINFO_METHOD_HANDLE,CORINFO_METHOD_STRUCT_*,void*
CORINFO_FIELD_HANDLE,CORINFO_FIELD_STRUCT_*,void*
CORINFO_CLASS_HANDLE,CORINFO_CLASS_STRUCT_*,void*
CORINFO_ASSEMBLY_HANDLE,CORINFO_ASSEMBLY_STRUCT_*,void*
CORINFO_JUST_MY_CODE_HANDLE,CORINFO_JUST_MY_CODE_HANDLE_*,void*
CORINFO_MODULE_HANDLE*,CORINFO_MODULE_STRUCT_**,void*
CORINFO_CLASS_HANDLE*,CORINFO_CLASS_STRUCT_**,void*
CORINFO_ARG_LIST_HANDLE,CORINFO_ARG_LIST_STRUCT_*,void*
CORINFO_VARARGS_HANDLE,IntPtr,void*
CORINFO_CONTEXT_HANDLE,CORINFO_CONTEXT_STRUCT*,void*
SYSTEMV_AMD64_CORINFO_STRUCT_REG_PASSING_DESCRIPTOR*,SYSTEMV_AMD64_CORINFO_STRUCT_REG_PASSING_DESCRIPTOR*,void*

ICorDebugInfo::OffsetMapping*,OffsetMapping*,void*
ICorDebugInfo::ILVarInfo**,ILVarInfo**,void*
ICorDebugInfo::NativeVarInfo*,NativeVarInfo*,void*
ICorDebugInfo::BoundaryTypes*,BoundaryTypes*,void*

struct _EXCEPTION_POINTERS*,_EXCEPTION_POINTERS*,void*

RETURNTYPES
BOOL,[return: MarshalAs(UnmanagedType.Bool)]bool,int
bool,[return: MarshalAs(UnmanagedType.I1)]bool
; NOTE in managed SIZE_T is an enum that is 64bits in size, and returning one of those causing mcg to do the wrong thing.
size_t,byte*,size_t

FUNCTIONS
    DWORD getMethodAttribs(        CORINFO_METHOD_HANDLE       ftn        );
    void setMethodAttribs(        CORINFO_METHOD_HANDLE       ftn,        CorInfoMethodRuntimeFlags   attribs        );
    void getMethodSig(        CORINFO_METHOD_HANDLE      ftn,        CORINFO_SIG_INFO          *sig,        CORINFO_CLASS_HANDLE      memberParent         );
    bool getMethodInfo(        CORINFO_METHOD_HANDLE   ftn,        CORINFO_METHOD_INFO*    info        );
    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);
    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);
    void getEHinfo(        CORINFO_METHOD_HANDLE ftn,        unsigned          EHnumber,        CORINFO_EH_CLAUSE* clause        );
    CORINFO_CLASS_HANDLE getMethodClass(        CORINFO_METHOD_HANDLE       method        );
    CORINFO_MODULE_HANDLE getMethodModule(        CORINFO_METHOD_HANDLE       method        );
    void getMethodVTableOffset(        CORINFO_METHOD_HANDLE       method,        unsigned*                   offsetOfIndirection,        unsigned*                   offsetAfterIndirection, bool*                       isRelative);
    CORINFO_METHOD_HANDLE resolveVirtualMethod(            CORINFO_METHOD_HANDLE       virtualMethod,          CORINFO_CLASS_HANDLE        implementingClass,            CORINFO_CONTEXT_HANDLE      ownerType);
    CORINFO_METHOD_HANDLE getUnboxedEntry(CORINFO_METHOD_HANDLE ftn, BoolStar requiresInstMethodTableArg);
    CORINFO_CLASS_HANDLE getDefaultEqualityComparerClass(CORINFO_CLASS_HANDLE elemType);
    void expandRawHandleIntrinsic(CORINFO_RESOLVED_TOKEN *        pResolvedToken, CORINFO_GENERICHANDLE_RESULT *  pResult);
    CorInfoIntrinsics getIntrinsicID(        CORINFO_METHOD_HANDLE       method        , BoolStar pMustExpand);
    bool isIntrinsicType(           CORINFO_CLASS_HANDLE        classHnd );
    CorInfoUnmanagedCallConv getUnmanagedCallConv(        CORINFO_METHOD_HANDLE       method        );
    BOOL pInvokeMarshalingRequired(        CORINFO_METHOD_HANDLE       method,        CORINFO_SIG_INFO*           callSiteSig        );
    BOOL satisfiesMethodConstraints(        CORINFO_CLASS_HANDLE        parent,        CORINFO_METHOD_HANDLE       method        );
    BOOL isCompatibleDelegate(        CORINFO_CLASS_HANDLE        objCls,        CORINFO_CLASS_HANDLE        methodParentCls,        CORINFO_METHOD_HANDLE       method,        CORINFO_CLASS_HANDLE        delegateCls,        BOOL                        *pfIsOpenDelegate        );
    void methodMustBeLoadedBeforeCodeIsRun(        CORINFO_METHOD_HANDLE       method        );
    CORINFO_METHOD_HANDLE mapMethodDeclToMethodImpl(        CORINFO_METHOD_HANDLE       method        );
    void getGSCookie(        GSCookie * pCookieVal,        GSCookie ** ppCookieVal        );
    void setPatchpointInfo(PatchpointInfo* patchpointInfo);
    PatchpointInfo* getOSRInfo(unsigned * ilOffset);
    void resolveToken(CORINFO_RESOLVED_TOKEN * pResolvedToken);
    void tryResolveToken(CORINFO_RESOLVED_TOKEN * pResolvedToken);
    void findSig(        CORINFO_MODULE_HANDLE       module,        unsigned                    sigTOK,        CORINFO_CONTEXT_HANDLE      context,        CORINFO_SIG_INFO           *sig        );
    void findCallSiteSig(        CORINFO_MODULE_HANDLE       module,unsigned                    methTOK,        CORINFO_CONTEXT_HANDLE      context,        CORINFO_SIG_INFO   *sig)
    CORINFO_CLASS_HANDLE getTokenTypeAsHandle(CORINFO_RESOLVED_TOKEN* pResolvedToken)
    BOOL isValidToken(CORINFO_MODULE_HANDLE module, unsigned metaTOK)
    BOOL isValidStringRef(CORINFO_MODULE_HANDLE module, unsigned metaTOK)
    LPCWSTR getStringLiteral(CORINFO_MODULE_HANDLE module, unsigned metaTOK, int* length)
    CorInfoType asCorInfoType(CORINFO_CLASS_HANDLE cls)
    const char* getClassName(CORINFO_CLASS_HANDLE cls)
    const char* getClassNameFromMetadata(CORINFO_CLASS_HANDLE cls, const char **namespaceName)
    CORINFO_CLASS_HANDLE getTypeInstantiationArgument(CORINFO_CLASS_HANDLE cls, unsigned index)
    int appendClassName(WCHAR** ppBuf, int* pnBufLen, CORINFO_CLASS_HANDLE cls, BOOL fNamespace, BOOL fFullInst, BOOL fAssembly)
    BOOL isValueClass(CORINFO_CLASS_HANDLE cls)
    CorInfoInlineTypeCheck canInlineTypeCheck(CORINFO_CLASS_HANDLE cls, CorInfoInlineTypeCheckSource source)
    DWORD getClassAttribs(CORINFO_CLASS_HANDLE cls)
    BOOL isStructRequiringStackAllocRetBuf(CORINFO_CLASS_HANDLE cls)
    CORINFO_MODULE_HANDLE getClassModule(CORINFO_CLASS_HANDLE cls)
    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 cls, CORINFO_MODULE_HANDLE* pModule, VOIDSTARSTAR ppIndirection)
    unsigned getClassSize(CORINFO_CLASS_HANDLE cls)
    unsigned getHeapClassSize(CORINFO_CLASS_HANDLE        cls)
    BOOL canAllocateOnStack(CORINFO_CLASS_HANDLE cls)
    unsigned getClassAlignmentRequirement(CORINFO_CLASS_HANDLE cls, BOOL fDoubleAlignHint)
    unsigned getClassGClayout(CORINFO_CLASS_HANDLE cls, BYTE* gcPtrs)
    unsigned getClassNumInstanceFields(CORINFO_CLASS_HANDLE cls)
    CORINFO_FIELD_HANDLE getFieldInClass(CORINFO_CLASS_HANDLE clsHnd, INT num)
    BOOL checkMethodModifier(CORINFO_METHOD_HANDLE hMethod, LPCSTR modifier, BOOL fOptional)
    CorInfoHelpFunc getNewHelper(CORINFO_RESOLVED_TOKEN* pResolvedToken, CORINFO_METHOD_HANDLE callerHandle, BoolStar pHasSideEffects)
    CorInfoHelpFunc getNewArrHelper(CORINFO_CLASS_HANDLE arrayCls)
    CorInfoHelpFunc getCastingHelper(CORINFO_RESOLVED_TOKEN* pResolvedToken, bool fThrowing)
    CorInfoHelpFunc getSharedCCtorHelper(CORINFO_CLASS_HANDLE clsHnd)
    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_LOOKUP *pLookup)
    const char* getHelperName(CorInfoHelpFunc helpFunc)
    CorInfoInitClassResult initClass(CORINFO_FIELD_HANDLE field, CORINFO_METHOD_HANDLE method, CORINFO_CONTEXT_HANDLE context)
    void classMustBeLoadedBeforeCodeIsRun(CORINFO_CLASS_HANDLE cls)
    CORINFO_CLASS_HANDLE getBuiltinClass(CorInfoClassId classId)
    CorInfoType getTypeForPrimitiveValueClass(CORINFO_CLASS_HANDLE cls)
    CorInfoType getTypeForPrimitiveNumericClass(CORINFO_CLASS_HANDLE cls)
    BOOL canCast(CORINFO_CLASS_HANDLE child, CORINFO_CLASS_HANDLE parent)
    BOOL areTypesEquivalent(CORINFO_CLASS_HANDLE cls1, CORINFO_CLASS_HANDLE cls2)
    TypeCompareState compareTypesForCast(CORINFO_CLASS_HANDLE fromClass, CORINFO_CLASS_HANDLE toClass)
    TypeCompareState compareTypesForEquality(CORINFO_CLASS_HANDLE cls1, CORINFO_CLASS_HANDLE cls2)
    CORINFO_CLASS_HANDLE mergeClasses(CORINFO_CLASS_HANDLE cls1, CORINFO_CLASS_HANDLE cls2)
    BOOL isMoreSpecificType(CORINFO_CLASS_HANDLE        cls1, CORINFO_CLASS_HANDLE        cls2)
    CORINFO_CLASS_HANDLE getParentType(CORINFO_CLASS_HANDLE cls)
    CorInfoType getChildType(CORINFO_CLASS_HANDLE clsHnd, CORINFO_CLASS_HANDLE* clsRet)
    BOOL satisfiesClassConstraints(CORINFO_CLASS_HANDLE cls)
    BOOL isSDArray(CORINFO_CLASS_HANDLE cls)
    unsigned getArrayRank(CORINFO_CLASS_HANDLE cls)
    void* getArrayInitializationData(CORINFO_FIELD_HANDLE field, DWORD size)
    CorInfoIsAccessAllowedResult canAccessClass(CORINFO_RESOLVED_TOKEN* pResolvedToken, CORINFO_METHOD_HANDLE callerHandle, CORINFO_HELPER_DESC* pAccessHelper)
    const char* getFieldName(CORINFO_FIELD_HANDLE ftn, const char** moduleName)
    CORINFO_CLASS_HANDLE getFieldClass(CORINFO_FIELD_HANDLE field)
    CorInfoType getFieldType(CORINFO_FIELD_HANDLE field, CORINFO_CLASS_HANDLE* structType, CORINFO_CLASS_HANDLE memberParent)
    unsigned getFieldOffset(CORINFO_FIELD_HANDLE field)
    void getFieldInfo(CORINFO_RESOLVED_TOKEN* pResolvedToken, CORINFO_METHOD_HANDLE callerHandle, CORINFO_ACCESS_FLAGS flags, CORINFO_FIELD_INFO* pResult)
    bool isFieldStatic(CORINFO_FIELD_HANDLE fldHnd)
    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)
    void*allocateArray(size_t cBytes);
    void freeArray(void*array);
    CORINFO_ARG_LIST_HANDLE getArgNext(CORINFO_ARG_LIST_HANDLE args);
    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);
    CorInfoHFAElemType getHFAType(CORINFO_CLASS_HANDLE hClass);
    HRESULT GetErrorHRESULT(struct _EXCEPTION_POINTERS *pExceptionPointers);
    ULONG GetErrorMessage(LPWSTR buffer, ULONG bufferLength);
    [ManualNativeWrapper] int FilterException(struct _EXCEPTION_POINTERS* pExceptionPointers);
    [ManualNativeWrapper] void HandleException(struct _EXCEPTION_POINTERS* pExceptionPointers);
    void ThrowExceptionForJitResult(HRESULT result);
    void ThrowExceptionForHelper(const CORINFO_HELPER_DESC* throwHelper);
    [ManualNativeWrapper] bool runWithErrorTrap(void* function, void* parameter);
    void getEEInfo(CORINFO_EE_INFO* pEEInfoOut);
    LPCWSTR getJitTimeLogFilename();
    mdMethodDef getMethodDefFromMethod(CORINFO_METHOD_HANDLE hMethod);
    const char* getMethodName(CORINFO_METHOD_HANDLE ftn, const char **moduleName);
    const char* getMethodNameFromMetadata(CORINFO_METHOD_HANDLE ftn, const char **className, const char **namespaceName, const char **enclosingClassName);
    unsigned getMethodHash(CORINFO_METHOD_HANDLE       ftn);
    size_t findNameOfToken(CORINFO_MODULE_HANDLE       moduleHandle,mdToken                     token, char * szFQName,size_t FQNameCapacity);
    bool getSystemVAmd64PassStructInRegisterDescriptor(CORINFO_CLASS_HANDLE  structHnd, SYSTEMV_AMD64_CORINFO_STRUCT_REG_PASSING_DESCRIPTOR* structPassInRegDescPtr);
    DWORD getThreadTLSIndex(void                  **ppIndirection);
    const void * getInlinedCallFrameVptr(void **ppIndirection);
    LONG * getAddrOfCaptureThreadGlobal(void                  **ppIndirection);
    void* getHelperFtn (CorInfoHelpFunc         ftnNum, void                  **ppIndirection);
    void getFunctionEntryPoint(CORINFO_METHOD_HANDLE   ftn, CORINFO_CONST_LOOKUP *  pResult, CORINFO_ACCESS_FLAGS accessFlags);
    void getFunctionFixedEntryPoint(CORINFO_METHOD_HANDLE   ftn, CORINFO_CONST_LOOKUP *  pResult);
    void* getMethodSync(CORINFO_METHOD_HANDLE               ftn, void                  **ppIndirection);
    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_METHOD_HANDLE embedMethodHandle(CORINFO_METHOD_HANDLE   handle, void                  **ppIndirection);
    CORINFO_FIELD_HANDLE embedFieldHandle(CORINFO_FIELD_HANDLE    handle, void                  **ppIndirection);
    void embedGenericHandle(CORINFO_RESOLVED_TOKEN *        pResolvedToken, BOOL fEmbedParent, CORINFO_GENERICHANDLE_RESULT *  pResult);
    void getLocationOfThisType(CORINFO_METHOD_HANDLE context, CORINFO_LOOKUP_KIND* pLookupKind);
    void getAddressOfPInvokeTarget(CORINFO_METHOD_HANDLE   method, CORINFO_CONST_LOOKUP *pLookup);
    LPVOID GetCookieForPInvokeCalliSig(CORINFO_SIG_INFO* szMetaSig, void           ** ppIndirection);
    bool canGetCookieForPInvokeCalliSig(CORINFO_SIG_INFO* szMetaSig);
    CORINFO_JUST_MY_CODE_HANDLE getJustMyCodeHandle(CORINFO_METHOD_HANDLE       method, CORINFO_JUST_MY_CODE_HANDLE**ppIndirection);
    void GetProfilingHandle(BOOL *pbHookFunction, void **pProfilerHandle, BOOL *pbIndirectedHandles);
    void getCallInfo(CORINFO_RESOLVED_TOKEN * pResolvedToken, CORINFO_RESOLVED_TOKEN_PTR pConstrainedResolvedToken, CORINFO_METHOD_HANDLE   callerHandle, CORINFO_CALLINFO_FLAGS  flags, CORINFO_CALL_INFO       *pResult);
    BOOL canAccessFamily(CORINFO_METHOD_HANDLE hCaller, CORINFO_CLASS_HANDLE hInstanceType);
    BOOL isRIDClassDomainID(CORINFO_CLASS_HANDLE cls);
    unsigned getClassDomainID (CORINFO_CLASS_HANDLE    cls, void                  **ppIndirection);
    void* getFieldAddress(CORINFO_FIELD_HANDLE    field, VOIDSTARSTAR ppIndirection);
    CORINFO_CLASS_HANDLE getStaticFieldCurrentClass(CORINFO_FIELD_HANDLE    field,  BoolStar pIsSpeculative);
    CORINFO_VARARGS_HANDLE getVarArgsHandle(CORINFO_SIG_INFO       *pSig, void                  **ppIndirection);
    bool canGetVarArgsHandle(CORINFO_SIG_INFO       *pSig);
    InfoAccessType constructStringLiteral(CORINFO_MODULE_HANDLE   module, mdToken                 metaTok, void                  **ppValue);
    InfoAccessType emptyStringLiteral(void                  **ppValue);
    DWORD getFieldThreadLocalStoreID (CORINFO_FIELD_HANDLE    field, void                  **ppIndirection);
    void setOverride(ICorDynamicInfo             *pOverride, CORINFO_METHOD_HANDLE       currentMethod);
    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);
    bool getTailCallHelpers(CORINFO_RESOLVED_TOKEN* callToken, CORINFO_SIG_INFO* sig, CORINFO_GET_TAILCALL_HELPERS_FLAGS flags, CORINFO_TAILCALL_HELPERS* pResult);
    bool convertPInvokeCalliToCall(CORINFO_RESOLVED_TOKEN * pResolvedToken, bool mustConvert);
    void notifyInstructionSetUsage(CORINFO_InstructionSet instructionSet,bool supportEnabled);
    void allocMem(        ULONG               hotCodeSize,    ULONG               coldCodeSize,     ULONG               roDataSize,             ULONG               xcptnsCount,            CorJitAllocMemFlag  flag,        void**             hotCodeBlock,           void**             coldCodeBlock,          void**             roDataBlock             );
    void reserveUnwindInfo(BOOL isFunclet, BOOL isColdCode, ULONG unwindSize)
    void allocUnwindInfo(BYTE* pHotCode, BYTE* pColdCode, ULONG startOffset, ULONG endOffset, ULONG unwindSize, BYTE* pUnwindBlock, CorJitFuncKind funcKind)
    void* allocGCInfo(size_t size)
    void setEHcount(unsigned cEH)
    void setEHinfo(unsigned EHnumber, const CORINFO_EH_CLAUSE* clause)
    BOOL logMsg(unsigned level, const char* fmt, va_list args)
    int doAssert(const char* szFile, int iLine, const char* szExpr)
    void reportFatalError(CorJitResult result)
    HRESULT allocMethodBlockCounts(UINT32 count, ICorJitInfo::BlockCounts** pBlockCounts)
    HRESULT getMethodBlockCounts(CORINFO_METHOD_HANDLE ftnHnd, UINT32* pCount, ICorJitInfo::BlockCounts** pBlockCounts, UINT32* pNumRuns)
    void recordCallSite(ULONG instrOffset, CORINFO_SIG_INFO* callSig, CORINFO_METHOD_HANDLE methodHandle)
    void recordRelocation(void* location, void* target, WORD fRelocType, WORD slotNum, INT32 addlDelta)
    WORD getRelocTypeHint(void* target)
    DWORD getExpectedTargetArchitecture()
    DWORD getJitFlags(CORJIT_FLAGS* flags, DWORD  sizeInBytes)