ICorJitInfo_API_wrapper.hpp

// 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.

#defineAPI_ENTER(name) wrapComp->CLR_API_Enter(API_##name);
#defineAPI_LEAVE(name) wrapComp->CLR_API_Leave(API_##name);

/**********************************************************************************/
// clang-format off
/**********************************************************************************/
//
// ICorMethodInfo
//

DWORD WrapICorJitInfo::getMethodAttribs(CORINFO_METHOD_HANDLE ftn /* IN */)
{
API_ENTER(getMethodAttribs)
 DWORD temp = wrapHnd->getMethodAttribs(ftn);
API_LEAVE(getMethodAttribs)
return temp;
}

voidWrapICorJitInfo::setMethodAttribs(CORINFO_METHOD_HANDLE ftn,/* IN */
 CorInfoMethodRuntimeFlags attribs/* IN */)
{
API_ENTER(setMethodAttribs);
 wrapHnd->setMethodAttribs(ftn, attribs);
API_LEAVE(setMethodAttribs);
}

voidWrapICorJitInfo::getMethodSig(CORINFO_METHOD_HANDLE ftn, /* IN */
 CORINFO_SIG_INFO *sig, /* OUT */
 CORINFO_CLASS_HANDLE memberParent/* IN */)
{
API_ENTER(getMethodSig);
 wrapHnd->getMethodSig(ftn, sig, memberParent);
API_LEAVE(getMethodSig);
}

boolWrapICorJitInfo::getMethodInfo(
 CORINFO_METHOD_HANDLE ftn, /* IN */
 CORINFO_METHOD_INFO* info /* OUT */)
{
API_ENTER(getMethodInfo);
bool temp = wrapHnd->getMethodInfo(ftn, info);
API_LEAVE(getMethodInfo);
return temp;
}

CorInfoInline WrapICorJitInfo::canInline(
 CORINFO_METHOD_HANDLE callerHnd, /* IN */
 CORINFO_METHOD_HANDLE calleeHnd, /* IN */
 DWORD* pRestrictions /* OUT */)
{
API_ENTER(canInline);
 CorInfoInline temp = wrapHnd->canInline(callerHnd, calleeHnd, pRestrictions);
API_LEAVE(canInline);
return temp;
}

voidWrapICorJitInfo::reportInliningDecision(CORINFO_METHOD_HANDLE inlinerHnd,
 CORINFO_METHOD_HANDLE inlineeHnd,
 CorInfoInline inlineResult,
constchar * reason)
{
API_ENTER(reportInliningDecision);
 wrapHnd->reportInliningDecision(inlinerHnd, inlineeHnd, inlineResult, reason);
API_LEAVE(reportInliningDecision);
}

boolWrapICorJitInfo::canTailCall(
 CORINFO_METHOD_HANDLE callerHnd, /* IN */
 CORINFO_METHOD_HANDLE declaredCalleeHnd, /* IN */
 CORINFO_METHOD_HANDLE exactCalleeHnd, /* IN */
boolfIsTailPrefix/* IN */)
{
API_ENTER(canTailCall);
bool temp = wrapHnd->canTailCall(callerHnd, declaredCalleeHnd, exactCalleeHnd, fIsTailPrefix);
API_LEAVE(canTailCall);
return temp;
}

voidWrapICorJitInfo::reportTailCallDecision(CORINFO_METHOD_HANDLE callerHnd,
 CORINFO_METHOD_HANDLE calleeHnd,
boolfIsTailPrefix,
 CorInfoTailCall tailCallResult,
constchar * reason)
{
API_ENTER(reportTailCallDecision);
 wrapHnd->reportTailCallDecision(callerHnd, calleeHnd, fIsTailPrefix, tailCallResult, reason);
API_LEAVE(reportTailCallDecision);
}

voidWrapICorJitInfo::getEHinfo(
 CORINFO_METHOD_HANDLE ftn, /* IN */
unsigned EHnumber, /* IN */
 CORINFO_EH_CLAUSE* clause /* OUT */)
{
API_ENTER(getEHinfo);
 wrapHnd->getEHinfo(ftn, EHnumber, clause);
API_LEAVE(getEHinfo);
}

CORINFO_CLASS_HANDLE WrapICorJitInfo::getMethodClass(
 CORINFO_METHOD_HANDLE method)
{
API_ENTER(getMethodClass);
 CORINFO_CLASS_HANDLE temp = wrapHnd->getMethodClass(method);
API_LEAVE(getMethodClass);
return temp;
}

CORINFO_MODULE_HANDLE WrapICorJitInfo::getMethodModule(
 CORINFO_METHOD_HANDLE method)
{
API_ENTER(getMethodModule);
 CORINFO_MODULE_HANDLE temp = wrapHnd->getMethodModule(method);
API_LEAVE(getMethodModule);
return temp;
}

voidWrapICorJitInfo::getMethodVTableOffset(
 CORINFO_METHOD_HANDLE method, /* IN */
unsigned* offsetOfIndirection, /* OUT */
unsigned* offsetAfterIndirection, /* OUT */
bool* isRelative /* OUT */)
{
API_ENTER(getMethodVTableOffset);
 wrapHnd->getMethodVTableOffset(method, offsetOfIndirection, offsetAfterIndirection, isRelative);
API_LEAVE(getMethodVTableOffset);
}

CorInfoIntrinsics WrapICorJitInfo::getIntrinsicID(
 CORINFO_METHOD_HANDLE method,
bool* pMustExpand /* OUT */)
{
API_ENTER(getIntrinsicID);
 CorInfoIntrinsics temp = wrapHnd->getIntrinsicID(method, pMustExpand);
API_LEAVE(getIntrinsicID);
return temp;
}

boolWrapICorJitInfo::isIntrinsicType(CORINFO_CLASS_HANDLE classHnd)
{
API_ENTER(isIntrinsicType);
bool temp = wrapHnd->isIntrinsicType(classHnd);
API_LEAVE(isIntrinsicType);
return temp;
}

CorInfoUnmanagedCallConv WrapICorJitInfo::getUnmanagedCallConv(
 CORINFO_METHOD_HANDLE method)
{
API_ENTER(getUnmanagedCallConv);
 CorInfoUnmanagedCallConv temp = wrapHnd->getUnmanagedCallConv(method);
API_LEAVE(getUnmanagedCallConv);
return temp;
}

BOOL WrapICorJitInfo::pInvokeMarshalingRequired(
 CORINFO_METHOD_HANDLE method,
 CORINFO_SIG_INFO* callSiteSig)
{
API_ENTER(pInvokeMarshalingRequired);
 BOOL temp = wrapHnd->pInvokeMarshalingRequired(method, callSiteSig);
API_LEAVE(pInvokeMarshalingRequired);
return temp;
}

BOOL WrapICorJitInfo::satisfiesMethodConstraints(
 CORINFO_CLASS_HANDLE parent, // the exact parent of the method
 CORINFO_METHOD_HANDLE method)
{
API_ENTER(satisfiesMethodConstraints);
 BOOL temp = wrapHnd->satisfiesMethodConstraints(parent, method);
API_LEAVE(satisfiesMethodConstraints);
return temp;
}

BOOL WrapICorJitInfo::isCompatibleDelegate(
 CORINFO_CLASS_HANDLE objCls,
 CORINFO_CLASS_HANDLE methodParentCls,
 CORINFO_METHOD_HANDLE method,
 CORINFO_CLASS_HANDLE delegateCls,
 BOOL *pfIsOpenDelegate)
{
API_ENTER(isCompatibleDelegate);
 BOOL temp = wrapHnd->isCompatibleDelegate(objCls, methodParentCls, method, delegateCls, pfIsOpenDelegate);
API_LEAVE(isCompatibleDelegate);
return temp;
}

CorInfoInstantiationVerification WrapICorJitInfo::isInstantiationOfVerifiedGeneric(
 CORINFO_METHOD_HANDLE method /* IN */)
{
API_ENTER(isInstantiationOfVerifiedGeneric);
 CorInfoInstantiationVerification temp = wrapHnd->isInstantiationOfVerifiedGeneric(method);
API_LEAVE(isInstantiationOfVerifiedGeneric);
return temp;
}

voidWrapICorJitInfo::initConstraintsForVerification(
 CORINFO_METHOD_HANDLE method, /* IN */
 BOOL *pfHasCircularClassConstraints, /* OUT */
 BOOL *pfHasCircularMethodConstraint /* OUT */)
{
API_ENTER(initConstraintsForVerification);
 wrapHnd->initConstraintsForVerification(method, pfHasCircularClassConstraints, pfHasCircularMethodConstraint);
API_LEAVE(initConstraintsForVerification);
}

CorInfoCanSkipVerificationResult WrapICorJitInfo::canSkipMethodVerification(
 CORINFO_METHOD_HANDLE ftnHandle)
{
API_ENTER(canSkipMethodVerification);
 CorInfoCanSkipVerificationResult temp = wrapHnd->canSkipMethodVerification(ftnHandle);
API_LEAVE(canSkipMethodVerification);
return temp;
}

voidWrapICorJitInfo::methodMustBeLoadedBeforeCodeIsRun(
 CORINFO_METHOD_HANDLE method)
{
API_ENTER(methodMustBeLoadedBeforeCodeIsRun);
 wrapHnd->methodMustBeLoadedBeforeCodeIsRun(method);
API_LEAVE(methodMustBeLoadedBeforeCodeIsRun);
}

CORINFO_METHOD_HANDLE WrapICorJitInfo::mapMethodDeclToMethodImpl(
 CORINFO_METHOD_HANDLE method)
{
API_ENTER(mapMethodDeclToMethodImpl);
 CORINFO_METHOD_HANDLE temp = wrapHnd->mapMethodDeclToMethodImpl(method);
API_LEAVE(mapMethodDeclToMethodImpl);
return temp;
}

voidWrapICorJitInfo::getGSCookie(
 GSCookie * pCookieVal,
 GSCookie ** ppCookieVal )
{
API_ENTER(getGSCookie);
 wrapHnd->getGSCookie(pCookieVal, ppCookieVal);
API_LEAVE(getGSCookie);
}

/**********************************************************************************/
//
// ICorModuleInfo
//
/**********************************************************************************/

voidWrapICorJitInfo::resolveToken(/* IN, OUT */ CORINFO_RESOLVED_TOKEN * pResolvedToken)
{
API_ENTER(resolveToken);
 wrapHnd->resolveToken(pResolvedToken);
API_LEAVE(resolveToken);
}

boolWrapICorJitInfo::tryResolveToken(/* IN, OUT */ CORINFO_RESOLVED_TOKEN * pResolvedToken)
{
API_ENTER(tryResolveToken);
bool success = wrapHnd->tryResolveToken(pResolvedToken);
API_LEAVE(tryResolveToken);
return success;
}

voidWrapICorJitInfo::findSig(
 CORINFO_MODULE_HANDLE module,
unsigned sigTOK,
 CORINFO_CONTEXT_HANDLE context,
 CORINFO_SIG_INFO *sig )
{
API_ENTER(findSig);
 wrapHnd->findSig(module, sigTOK, context, sig);
API_LEAVE(findSig);
}

voidWrapICorJitInfo::findCallSiteSig(
 CORINFO_MODULE_HANDLE module, /* IN */
unsigned methTOK, /* IN */
 CORINFO_CONTEXT_HANDLE context, /* IN */
 CORINFO_SIG_INFO *sig /* OUT */)
{
API_ENTER(findCallSiteSig);
 wrapHnd->findCallSiteSig(module, methTOK, context, sig);
API_LEAVE(findCallSiteSig);
}

CORINFO_CLASS_HANDLE WrapICorJitInfo::getTokenTypeAsHandle(
 CORINFO_RESOLVED_TOKEN * pResolvedToken /* IN */)
{
API_ENTER(getTokenTypeAsHandle);
 CORINFO_CLASS_HANDLE temp = wrapHnd->getTokenTypeAsHandle(pResolvedToken);
API_LEAVE(getTokenTypeAsHandle);
return temp;
}

CorInfoCanSkipVerificationResult WrapICorJitInfo::canSkipVerification(
 CORINFO_MODULE_HANDLE module /* IN */)
{
API_ENTER(canSkipVerification);
 CorInfoCanSkipVerificationResult temp = wrapHnd->canSkipVerification(module);
API_LEAVE(canSkipVerification);
return temp;
}

BOOL WrapICorJitInfo::isValidToken(
 CORINFO_MODULE_HANDLE module, /* IN */
unsigned metaTOK /* IN */)
{
API_ENTER(isValidToken);
 BOOL result = wrapHnd->isValidToken(module, metaTOK);
API_LEAVE(isValidToken);
return result;
}

BOOL WrapICorJitInfo::isValidStringRef(
 CORINFO_MODULE_HANDLE module, /* IN */
unsigned metaTOK /* IN */)
{
API_ENTER(isValidStringRef);
 BOOL temp = wrapHnd->isValidStringRef(module, metaTOK);
API_LEAVE(isValidStringRef);
return temp;
}

BOOL WrapICorJitInfo::shouldEnforceCallvirtRestriction(
 CORINFO_MODULE_HANDLE scope)
{
API_ENTER(shouldEnforceCallvirtRestriction);
 BOOL temp = wrapHnd->shouldEnforceCallvirtRestriction(scope);
API_LEAVE(shouldEnforceCallvirtRestriction);
return temp;
}

/**********************************************************************************/
//
// ICorClassInfo
//
/**********************************************************************************/

CorInfoType WrapICorJitInfo::asCorInfoType(CORINFO_CLASS_HANDLE cls)
{
API_ENTER(asCorInfoType);
 CorInfoType temp = wrapHnd->asCorInfoType(cls);
API_LEAVE(asCorInfoType);
return temp;
}

constchar* WrapICorJitInfo::getClassName(CORINFO_CLASS_HANDLE cls)
{
API_ENTER(getClassName);
constchar* result = wrapHnd->getClassName(cls);
API_LEAVE(getClassName);
return result;
}

constchar* WrapICorJitInfo::getClassNameFromMetadata(CORINFO_CLASS_HANDLE cls, constchar** namespaceName)
{
API_ENTER(getClassNameFromMetadata);
constchar* result = wrapHnd->getClassNameFromMetadata(cls, namespaceName);
API_LEAVE(getClassNameFromMetadata);
return result;
}

CORINFO_CLASS_HANDLE WrapICorJitInfo::getTypeInstantiationArgument(CORINFO_CLASS_HANDLE cls, unsigned index)
{
API_ENTER(getTypeInstantiationArgument);
 CORINFO_CLASS_HANDLE result = wrapHnd->getTypeInstantiationArgument(cls, index);
API_LEAVE(getTypeInstantiationArgument);
return result;
}

intWrapICorJitInfo::appendClassName(
__deref_inout_ecount(*pnBufLen) WCHAR** ppBuf,
 int* pnBufLen,
 CORINFO_CLASS_HANDLE cls,
 BOOL fNamespace,
 BOOL fFullInst,
 BOOL fAssembly)
{
API_ENTER(appendClassName);
 WCHAR* pBuf = *ppBuf;
int nLen = wrapHnd->appendClassName(ppBuf, pnBufLen, cls, fNamespace, fFullInst, fAssembly);
API_LEAVE(appendClassName);
return nLen;
}

BOOL WrapICorJitInfo::isValueClass(CORINFO_CLASS_HANDLE cls)
{
API_ENTER(isValueClass);
 BOOL temp = wrapHnd->isValueClass(cls);
API_LEAVE(isValueClass);
return temp;
}

CorInfoInlineTypeCheck canInlineTypeCheck(CORINFO_CLASS_HANDLE cls, CorInfoInlineTypeCheckSource source)
{
API_ENTER(canInlineTypeCheck);
 CorInfoInlineTypeCheck temp = wrapHnd->canInlineTypeCheck(cls, source);
API_LEAVE(canInlineTypeCheck);
return temp;
}

BOOL WrapICorJitInfo::canInlineTypeCheckWithObjectVTable(CORINFO_CLASS_HANDLE cls)
{
API_ENTER(canInlineTypeCheckWithObjectVTable);
 BOOL temp = wrapHnd->canInlineTypeCheckWithObjectVTable(cls);
API_LEAVE(canInlineTypeCheckWithObjectVTable);
return temp;
}

DWORD WrapICorJitInfo::getClassAttribs(
 CORINFO_CLASS_HANDLE cls)
{
API_ENTER(getClassAttribs);
 DWORD temp = wrapHnd->getClassAttribs(cls);
API_LEAVE(getClassAttribs);
return temp;
}

BOOL WrapICorJitInfo::isStructRequiringStackAllocRetBuf(CORINFO_CLASS_HANDLE cls)
{
API_ENTER(isStructRequiringStackAllocRetBuf);
 BOOL temp = wrapHnd->isStructRequiringStackAllocRetBuf(cls);
API_LEAVE(isStructRequiringStackAllocRetBuf);
return temp;
}

CORINFO_MODULE_HANDLE WrapICorJitInfo::getClassModule(
 CORINFO_CLASS_HANDLE cls)
{
API_ENTER(getClassModule);
 CORINFO_MODULE_HANDLE result = wrapHnd->getClassModule(cls);
API_LEAVE(getClassModule);
return result;
}

CORINFO_ASSEMBLY_HANDLE WrapICorJitInfo::getModuleAssembly(
 CORINFO_MODULE_HANDLE mod)
{
API_ENTER(getModuleAssembly);
 CORINFO_ASSEMBLY_HANDLE result = wrapHnd->getModuleAssembly(mod);
API_LEAVE(getModuleAssembly);
return result;
}

constchar* WrapICorJitInfo::getAssemblyName(
 CORINFO_ASSEMBLY_HANDLE assem)
{
API_ENTER(getAssemblyName);
constchar* result = wrapHnd->getAssemblyName(assem);
API_LEAVE(getAssemblyName);
return result;
}

void* WrapICorJitInfo::LongLifetimeMalloc(size_t sz)
{
API_ENTER(LongLifetimeMalloc);
void* result = wrapHnd->LongLifetimeMalloc(sz);
API_LEAVE(LongLifetimeMalloc);
return result;
}

voidWrapICorJitInfo::LongLifetimeFree(void* obj)
{
API_ENTER(LongLifetimeFree);
 wrapHnd->LongLifetimeFree(obj);
API_LEAVE(LongLifetimeFree);
}

size_tWrapICorJitInfo::getClassModuleIdForStatics(
 CORINFO_CLASS_HANDLE cls,
 CORINFO_MODULE_HANDLE *pModule,
void **ppIndirection)
{
API_ENTER(getClassModuleIdForStatics);
size_t temp = wrapHnd->getClassModuleIdForStatics(cls, pModule, ppIndirection);
API_LEAVE(getClassModuleIdForStatics);
return temp;
}

unsignedWrapICorJitInfo::getClassSize(CORINFO_CLASS_HANDLE cls)
{
API_ENTER(getClassSize);
unsigned temp = wrapHnd->getClassSize(cls);
API_LEAVE(getClassSize);
return temp;
}

unsignedWrapICorJitInfo::getHeapClassSize(CORINFO_CLASS_HANDLE cls)
{
API_ENTER(getHeapClassSize);
unsigned temp = wrapHnd->getHeapClassSize(cls);
API_LEAVE(getHeapClassSize);
return temp;
}

BOOL WrapICorJitInfo::canAllocateOnStack(CORINFO_CLASS_HANDLE cls)
{
API_ENTER(canAllocateOnStack);
 BOOL temp = wrapHnd->canAllocateOnStack(cls);
API_LEAVE(canAllocateOnStack);
return temp;
}

unsignedWrapICorJitInfo::getClassAlignmentRequirement(
 CORINFO_CLASS_HANDLE cls,
 BOOL fDoubleAlignHint)
{
API_ENTER(getClassAlignmentRequirement);
unsigned temp = wrapHnd->getClassAlignmentRequirement(cls, fDoubleAlignHint);
API_LEAVE(getClassAlignmentRequirement);
return temp;
}

unsignedWrapICorJitInfo::getClassGClayout(
 CORINFO_CLASS_HANDLE cls, /* IN */
 BYTE *gcPtrs /* OUT */)
{
API_ENTER(getClassGClayout);
unsigned temp = wrapHnd->getClassGClayout(cls, gcPtrs);
API_LEAVE(getClassGClayout);
return temp;
}

unsignedWrapICorJitInfo::getClassNumInstanceFields(
 CORINFO_CLASS_HANDLE cls /* IN */)
{
API_ENTER(getClassNumInstanceFields);
unsigned temp = wrapHnd->getClassNumInstanceFields(cls);
API_LEAVE(getClassNumInstanceFields);
return temp;
}

CORINFO_FIELD_HANDLE WrapICorJitInfo::getFieldInClass(
 CORINFO_CLASS_HANDLE clsHnd,
 INT num)
{
API_ENTER(getFieldInClass);
 CORINFO_FIELD_HANDLE temp = wrapHnd->getFieldInClass(clsHnd, num);
API_LEAVE(getFieldInClass);
return temp;
}

BOOL WrapICorJitInfo::checkMethodModifier(
 CORINFO_METHOD_HANDLE hMethod,
 LPCSTR modifier,
 BOOL fOptional)
{
API_ENTER(checkMethodModifier);
 BOOL result = wrapHnd->checkMethodModifier(hMethod, modifier, fOptional);
API_LEAVE(checkMethodModifier);
return result;
}

CorInfoHelpFunc WrapICorJitInfo::getNewHelper(
 CORINFO_RESOLVED_TOKEN * pResolvedToken,
 CORINFO_METHOD_HANDLE callerHandle,
bool * pHasSideEffects)
{
API_ENTER(getNewHelper);
 CorInfoHelpFunc temp = wrapHnd->getNewHelper(pResolvedToken, callerHandle, pHasSideEffects);
API_LEAVE(getNewHelper);
return temp;
}

CorInfoHelpFunc WrapICorJitInfo::getNewArrHelper(
 CORINFO_CLASS_HANDLE arrayCls)
{
API_ENTER(getNewArrHelper);
 CorInfoHelpFunc temp = wrapHnd->getNewArrHelper(arrayCls);
API_LEAVE(getNewArrHelper);
return temp;
}

CorInfoHelpFunc WrapICorJitInfo::getCastingHelper(
 CORINFO_RESOLVED_TOKEN * pResolvedToken,
boolfThrowing)
{
API_ENTER(getCastingHelper);
 CorInfoHelpFunc temp = wrapHnd->getCastingHelper(pResolvedToken, fThrowing);
API_LEAVE(getCastingHelper);
return temp;
}

CorInfoHelpFunc WrapICorJitInfo::getSharedCCtorHelper(
 CORINFO_CLASS_HANDLE clsHnd)
{
API_ENTER(getSharedCCtorHelper);
 CorInfoHelpFunc temp = wrapHnd->getSharedCCtorHelper(clsHnd);
API_LEAVE(getSharedCCtorHelper);
return temp;
}

CorInfoHelpFunc WrapICorJitInfo::getSecurityPrologHelper(
 CORINFO_METHOD_HANDLE ftn)
{
API_ENTER(getSecurityPrologHelper);
 CorInfoHelpFunc temp = wrapHnd->getSecurityPrologHelper(ftn);
API_LEAVE(getSecurityPrologHelper);
return temp;
}

CORINFO_CLASS_HANDLE WrapICorJitInfo::getTypeForBox(
 CORINFO_CLASS_HANDLE cls)
{
API_ENTER(getTypeForBox);
 CORINFO_CLASS_HANDLE temp = wrapHnd->getTypeForBox(cls);
API_LEAVE(getTypeForBox);
return temp;
}

CorInfoHelpFunc WrapICorJitInfo::getBoxHelper(
 CORINFO_CLASS_HANDLE cls)
{
API_ENTER(getBoxHelper);
 CorInfoHelpFunc temp = wrapHnd->getBoxHelper(cls);
API_LEAVE(getBoxHelper);
return temp;
}

CorInfoHelpFunc WrapICorJitInfo::getUnBoxHelper(
 CORINFO_CLASS_HANDLE cls)
{
API_ENTER(getUnBoxHelper);
 CorInfoHelpFunc temp = wrapHnd->getUnBoxHelper(cls);
API_LEAVE(getUnBoxHelper);
return temp;
}

boolWrapICorJitInfo::getReadyToRunHelper(
 CORINFO_RESOLVED_TOKEN * pResolvedToken,
 CORINFO_LOOKUP_KIND * pGenericLookupKind,
 CorInfoHelpFunc id,
 CORINFO_CONST_LOOKUP * pLookup)
{
API_ENTER(getReadyToRunHelper);
bool result = wrapHnd->getReadyToRunHelper(pResolvedToken, pGenericLookupKind, id, pLookup);
API_LEAVE(getReadyToRunHelper);
return result;
}

voidWrapICorJitInfo::getReadyToRunDelegateCtorHelper(
 CORINFO_RESOLVED_TOKEN * pTargetMethod,
 CORINFO_CLASS_HANDLE delegateType,
 CORINFO_LOOKUP * pLookup)
{
API_ENTER(getReadyToRunDelegateCtorHelper);
 wrapHnd->getReadyToRunDelegateCtorHelper(pTargetMethod, delegateType, pLookup);
API_LEAVE(getReadyToRunDelegateCtorHelper);
}

constchar* WrapICorJitInfo::getHelperName(
 CorInfoHelpFunc funcNum)
{
API_ENTER(getHelperName);
constchar* temp = wrapHnd->getHelperName(funcNum);
API_LEAVE(getHelperName);
return temp;
}

CorInfoInitClassResult WrapICorJitInfo::initClass(
 CORINFO_FIELD_HANDLE field,

 CORINFO_METHOD_HANDLE method,
 CORINFO_CONTEXT_HANDLE context,
 BOOL speculative)
{
API_ENTER(initClass);
 CorInfoInitClassResult temp = wrapHnd->initClass(field, method, context, speculative);
API_LEAVE(initClass);
return temp;
}

voidWrapICorJitInfo::classMustBeLoadedBeforeCodeIsRun(
 CORINFO_CLASS_HANDLE cls)
{
API_ENTER(classMustBeLoadedBeforeCodeIsRun);
 wrapHnd->classMustBeLoadedBeforeCodeIsRun(cls);
API_LEAVE(classMustBeLoadedBeforeCodeIsRun);
}

CORINFO_CLASS_HANDLE WrapICorJitInfo::getBuiltinClass(
 CorInfoClassId classId)
{
API_ENTER(getBuiltinClass);
 CORINFO_CLASS_HANDLE temp = wrapHnd->getBuiltinClass(classId);
API_LEAVE(getBuiltinClass);
return temp;
}

CorInfoType WrapICorJitInfo::getTypeForPrimitiveValueClass(
 CORINFO_CLASS_HANDLE cls)
{
API_ENTER(getTypeForPrimitiveValueClass);
 CorInfoType temp = wrapHnd->getTypeForPrimitiveValueClass(cls);
API_LEAVE(getTypeForPrimitiveValueClass);
return temp;
}

CorInfoType WrapICorJitInfo::getTypeForPrimitiveNumericClass(
 CORINFO_CLASS_HANDLE cls)
{
API_ENTER(getTypeForPrimitiveNumericClass);
 CorInfoType temp = wrapHnd->getTypeForPrimitiveNumericClass(cls);
API_LEAVE(getTypeForPrimitiveNumericClass);
return temp;
}

BOOL WrapICorJitInfo::canCast(
 CORINFO_CLASS_HANDLE child,
 CORINFO_CLASS_HANDLE parent )
{
API_ENTER(canCast);
 BOOL temp = wrapHnd->canCast(child, parent);
API_LEAVE(canCast);
return temp;
}

BOOL WrapICorJitInfo::areTypesEquivalent(
 CORINFO_CLASS_HANDLE cls1,
 CORINFO_CLASS_HANDLE cls2)
{
API_ENTER(areTypesEquivalent);
 BOOL temp = wrapHnd->areTypesEquivalent(cls1, cls2);
API_LEAVE(areTypesEquivalent);
return temp;
}

CORINFO_CLASS_HANDLE WrapICorJitInfo::mergeClasses(
 CORINFO_CLASS_HANDLE cls1,
 CORINFO_CLASS_HANDLE cls2)
{
API_ENTER(mergeClasses);
 CORINFO_CLASS_HANDLE temp = wrapHnd->mergeClasses(cls1, cls2);
API_LEAVE(mergeClasses);
return temp;
}

CORINFO_CLASS_HANDLE WrapICorJitInfo::getParentType(
 CORINFO_CLASS_HANDLE cls)
{
API_ENTER(getParentType);
 CORINFO_CLASS_HANDLE temp = wrapHnd->getParentType(cls);
API_LEAVE(getParentType);
return temp;
}

CorInfoType WrapICorJitInfo::getChildType(
 CORINFO_CLASS_HANDLE clsHnd,
 CORINFO_CLASS_HANDLE *clsRet)
{
API_ENTER(getChildType);
 CorInfoType temp = wrapHnd->getChildType(clsHnd, clsRet);
API_LEAVE(getChildType);
return temp;
}

BOOL WrapICorJitInfo::satisfiesClassConstraints(
 CORINFO_CLASS_HANDLE cls)
{
API_ENTER(satisfiesClassConstraints);
 BOOL temp = wrapHnd->satisfiesClassConstraints(cls);
API_LEAVE(satisfiesClassConstraints);
return temp;

}

BOOL WrapICorJitInfo::isSDArray(
 CORINFO_CLASS_HANDLE cls)
{
API_ENTER(isSDArray);
 BOOL temp = wrapHnd->isSDArray(cls);
API_LEAVE(isSDArray);
return temp;
}

unsignedWrapICorJitInfo::getArrayRank(
 CORINFO_CLASS_HANDLE cls)
{
API_ENTER(getArrayRank);
unsigned result = wrapHnd->getArrayRank(cls);
API_LEAVE(getArrayRank);
return result;
}

void * WrapICorJitInfo::getArrayInitializationData(
 CORINFO_FIELD_HANDLE field,
 DWORD size)
{
API_ENTER(getArrayInitializationData);
void *temp = wrapHnd->getArrayInitializationData(field, size);
API_LEAVE(getArrayInitializationData);
return temp;
}

CorInfoIsAccessAllowedResult WrapICorJitInfo::canAccessClass(
 CORINFO_RESOLVED_TOKEN * pResolvedToken,
 CORINFO_METHOD_HANDLE callerHandle,
 CORINFO_HELPER_DESC *pAccessHelper)
{
API_ENTER(canAccessClass);
 CorInfoIsAccessAllowedResult temp = wrapHnd->canAccessClass(pResolvedToken, callerHandle, pAccessHelper);
API_LEAVE(canAccessClass);
return temp;
}

/**********************************************************************************/
//
// ICorFieldInfo
//
/**********************************************************************************/

constchar* WrapICorJitInfo::getFieldName(
 CORINFO_FIELD_HANDLE ftn, /* IN */
constchar **moduleName /* OUT */)
{
API_ENTER(getFieldName);
constchar* temp = wrapHnd->getFieldName(ftn, moduleName);
API_LEAVE(getFieldName);
return temp;
}

CORINFO_CLASS_HANDLE WrapICorJitInfo::getFieldClass(
 CORINFO_FIELD_HANDLE field)
{
API_ENTER(getFieldClass);
 CORINFO_CLASS_HANDLE temp = wrapHnd->getFieldClass(field);
API_LEAVE(getFieldClass);
return temp;
}

CorInfoType WrapICorJitInfo::getFieldType(
 CORINFO_FIELD_HANDLE field,
 CORINFO_CLASS_HANDLE *structType,
 CORINFO_CLASS_HANDLE memberParent/* IN */)
{
API_ENTER(getFieldType);
 CorInfoType temp = wrapHnd->getFieldType(field, structType, memberParent);
API_LEAVE(getFieldType);
return temp;
}

unsignedWrapICorJitInfo::getFieldOffset(
 CORINFO_FIELD_HANDLE field)
{
API_ENTER(getFieldOffset);
unsigned temp = wrapHnd->getFieldOffset(field);
API_LEAVE(getFieldOffset);
return temp;
}

boolWrapICorJitInfo::isWriteBarrierHelperRequired(
 CORINFO_FIELD_HANDLE field)
{
API_ENTER(isWriteBarrierHelperRequired);
bool result = wrapHnd->isWriteBarrierHelperRequired(field);
API_LEAVE(isWriteBarrierHelperRequired);
return result;
}

voidWrapICorJitInfo::getFieldInfo(CORINFO_RESOLVED_TOKEN * pResolvedToken,
 CORINFO_METHOD_HANDLE callerHandle,
 CORINFO_ACCESS_FLAGS flags,
 CORINFO_FIELD_INFO *pResult)
{
API_ENTER(getFieldInfo);
 wrapHnd->getFieldInfo(pResolvedToken, callerHandle, flags, pResult);
API_LEAVE(getFieldInfo);
}

boolWrapICorJitInfo::isFieldStatic(CORINFO_FIELD_HANDLE fldHnd)
{
API_ENTER(isFieldStatic);
bool result = wrapHnd->isFieldStatic(fldHnd);
API_LEAVE(isFieldStatic);
return result;
}

/*********************************************************************************/
//
// ICorDebugInfo
//
/*********************************************************************************/

voidWrapICorJitInfo::getBoundaries(
 CORINFO_METHOD_HANDLE ftn,
unsignedint *cILOffsets,
 DWORD **pILOffsets,

 ICorDebugInfo::BoundaryTypes *implictBoundaries)
{
API_ENTER(getBoundaries);
 wrapHnd->getBoundaries(ftn, cILOffsets, pILOffsets, implictBoundaries);
API_LEAVE(getBoundaries);
}

voidWrapICorJitInfo::setBoundaries(
 CORINFO_METHOD_HANDLE ftn,
 ULONG32 cMap,
 ICorDebugInfo::OffsetMapping *pMap)
{
API_ENTER(setBoundaries);
 wrapHnd->setBoundaries(ftn, cMap, pMap);
API_LEAVE(setBoundaries);
}

voidWrapICorJitInfo::getVars(
 CORINFO_METHOD_HANDLE ftn,
 ULONG32 *cVars,
 ICorDebugInfo::ILVarInfo **vars,
bool *extendOthers)

{
API_ENTER(getVars);
 wrapHnd->getVars(ftn, cVars, vars, extendOthers);
API_LEAVE(getVars);
}

voidWrapICorJitInfo::setVars(
 CORINFO_METHOD_HANDLE ftn,
 ULONG32 cVars,
 ICorDebugInfo::NativeVarInfo *vars)

{
API_ENTER(setVars);
 wrapHnd->setVars(ftn, cVars, vars);
API_LEAVE(setVars);
}

void * WrapICorJitInfo::allocateArray(
 ULONG cBytes)
{
API_ENTER(allocateArray);
void *temp = wrapHnd->allocateArray(cBytes);
API_LEAVE(allocateArray);
return temp;
}

voidWrapICorJitInfo::freeArray(
void *array)
{
API_ENTER(freeArray);
 wrapHnd->freeArray(array);
API_LEAVE(freeArray);
}

/*********************************************************************************/
//
// ICorArgInfo
//
/*********************************************************************************/

CORINFO_ARG_LIST_HANDLE WrapICorJitInfo::getArgNext(
 CORINFO_ARG_LIST_HANDLE args /* IN */)
{
API_ENTER(getArgNext);
 CORINFO_ARG_LIST_HANDLE temp = wrapHnd->getArgNext(args);
API_LEAVE(getArgNext);
return temp;
}

CorInfoTypeWithMod WrapICorJitInfo::getArgType(
 CORINFO_SIG_INFO* sig, /* IN */
 CORINFO_ARG_LIST_HANDLE args, /* IN */
 CORINFO_CLASS_HANDLE *vcTypeRet /* OUT */)
{
API_ENTER(getArgType);
 CorInfoTypeWithMod temp = wrapHnd->getArgType(sig, args, vcTypeRet);
API_LEAVE(getArgType);
return temp;
}

CORINFO_CLASS_HANDLE WrapICorJitInfo::getArgClass(
 CORINFO_SIG_INFO* sig, /* IN */
 CORINFO_ARG_LIST_HANDLE args /* IN */)
{
API_ENTER(getArgClass);
 CORINFO_CLASS_HANDLE temp = wrapHnd->getArgClass(sig, args);
API_LEAVE(getArgClass);
return temp;
}

CorInfoType WrapICorJitInfo::getHFAType(
 CORINFO_CLASS_HANDLE hClass)
{
API_ENTER(getHFAType);
 CorInfoType temp = wrapHnd->getHFAType(hClass);
API_LEAVE(getHFAType);
return temp;
}

HRESULT WrapICorJitInfo::GetErrorHRESULT(
struct_EXCEPTION_POINTERS *pExceptionPointers)
{
API_ENTER(GetErrorHRESULT);
 HRESULT temp = wrapHnd->GetErrorHRESULT(pExceptionPointers);
API_LEAVE(GetErrorHRESULT);