void WrapICorJitInfo::setMethodAttribs(CORINFO_METHOD_HANDLE ftn,/* IN */
CorInfoMethodRuntimeFlags attribs/* IN */)
{
API_ENTER(setMethodAttribs);
wrapHnd->setMethodAttribs(ftn, attribs);
API_LEAVE(setMethodAttribs);
}
bool WrapICorJitInfo::tryResolveToken(/* IN, OUT */ CORINFO_RESOLVED_TOKEN * pResolvedToken)
{
API_ENTER(tryResolveToken);
bool success = wrapHnd->tryResolveToken(pResolvedToken);
API_LEAVE(tryResolveToken);
return success;
}
void WrapICorJitInfo::methodMustBeLoadedBeforeCodeIsRun(
CORINFO_METHOD_HANDLE method)
{
API_ENTER(methodMustBeLoadedBeforeCodeIsRun);
wrapHnd->methodMustBeLoadedBeforeCodeIsRun(method);
API_LEAVE(methodMustBeLoadedBeforeCodeIsRun);
}
bool WrapICorJitInfo::isInSIMDModule(CORINFO_CLASS_HANDLE classHnd)
{
API_ENTER(isInSIMDModule);
bool temp = wrapHnd->isInSIMDModule(classHnd);
API_LEAVE(isInSIMDModule);
return temp;
}
DWORD WrapICorJitInfo::getMethodAttribs(CORINFO_METHOD_HANDLE ftn /* IN */)
{
API_ENTER(getMethodAttribs)
DWORD temp = wrapHnd->getMethodAttribs(ftn);
API_LEAVE(getMethodAttribs)
return temp;
}
CorInfoType WrapICorJitInfo::asCorInfoType(CORINFO_CLASS_HANDLE cls)
{
API_ENTER(asCorInfoType);
CorInfoType temp = wrapHnd->asCorInfoType(cls);
API_LEAVE(asCorInfoType);
return temp;
}
const char* WrapICorJitInfo::getClassName(CORINFO_CLASS_HANDLE cls)
{
API_ENTER(getClassName);
const char* result = wrapHnd->getClassName(cls);
API_LEAVE(getClassName);
return result;
}
CorInfoUnmanagedCallConv WrapICorJitInfo::getUnmanagedCallConv(
CORINFO_METHOD_HANDLE method)
{
API_ENTER(getUnmanagedCallConv);
CorInfoUnmanagedCallConv temp = wrapHnd->getUnmanagedCallConv(method);
API_LEAVE(getUnmanagedCallConv);
return temp;
}
CorInfoInstantiationVerification WrapICorJitInfo::isInstantiationOfVerifiedGeneric(
CORINFO_METHOD_HANDLE method /* IN */)
{
API_ENTER(isInstantiationOfVerifiedGeneric);
CorInfoInstantiationVerification temp = wrapHnd->isInstantiationOfVerifiedGeneric(method);
API_LEAVE(isInstantiationOfVerifiedGeneric);
return temp;
}
CORINFO_METHOD_HANDLE WrapICorJitInfo::mapMethodDeclToMethodImpl(
CORINFO_METHOD_HANDLE method)
{
API_ENTER(mapMethodDeclToMethodImpl);
CORINFO_METHOD_HANDLE temp = wrapHnd->mapMethodDeclToMethodImpl(method);
API_LEAVE(mapMethodDeclToMethodImpl);
return temp;
}
CORINFO_CLASS_HANDLE WrapICorJitInfo::getMethodClass(
CORINFO_METHOD_HANDLE method)
{
API_ENTER(getMethodClass);
CORINFO_CLASS_HANDLE temp = wrapHnd->getMethodClass(method);
API_LEAVE(getMethodClass);
return temp;
}
CorInfoCanSkipVerificationResult WrapICorJitInfo::canSkipMethodVerification(
CORINFO_METHOD_HANDLE ftnHandle)
{
API_ENTER(canSkipMethodVerification);
CorInfoCanSkipVerificationResult temp = wrapHnd->canSkipMethodVerification(ftnHandle);
API_LEAVE(canSkipMethodVerification);
return temp;
}
void WrapICorJitInfo::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);
}
CorInfoCanSkipVerificationResult WrapICorJitInfo::canSkipVerification(
CORINFO_MODULE_HANDLE module /* IN */)
{
API_ENTER(canSkipVerification);
CorInfoCanSkipVerificationResult temp = wrapHnd->canSkipVerification(module);
API_LEAVE(canSkipVerification);
return temp;
}
BOOL WrapICorJitInfo::shouldEnforceCallvirtRestriction(
CORINFO_MODULE_HANDLE scope)
{
API_ENTER(shouldEnforceCallvirtRestriction);
BOOL temp = wrapHnd->shouldEnforceCallvirtRestriction(scope);
API_LEAVE(shouldEnforceCallvirtRestriction);
return temp;
}
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;
}
void WrapICorJitInfo::getGSCookie(
GSCookie * pCookieVal,
GSCookie ** ppCookieVal )
{
API_ENTER(getGSCookie);
wrapHnd->getGSCookie(pCookieVal, ppCookieVal);
API_LEAVE(getGSCookie);
}
CORINFO_MODULE_HANDLE WrapICorJitInfo::getMethodModule(
CORINFO_METHOD_HANDLE method)
{
API_ENTER(getMethodModule);
CORINFO_MODULE_HANDLE temp = wrapHnd->getMethodModule(method);
API_LEAVE(getMethodModule);
return temp;
}
void WrapICorJitInfo::reportInliningDecision(CORINFO_METHOD_HANDLE inlinerHnd,
CORINFO_METHOD_HANDLE inlineeHnd,
CorInfoInline inlineResult,
const char * reason)
{
API_ENTER(reportInliningDecision);
wrapHnd->reportInliningDecision(inlinerHnd, inlineeHnd, inlineResult, reason);
API_LEAVE(reportInliningDecision);
}
bool WrapICorJitInfo::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;
}
void WrapICorJitInfo::getMethodVTableOffset(
CORINFO_METHOD_HANDLE method, /* IN */
unsigned* offsetOfIndirection, /* OUT */
unsigned* offsetAfterIndirection /* OUT */)
{
API_ENTER(getMethodVTableOffset);
wrapHnd->getMethodVTableOffset(method, offsetOfIndirection, offsetAfterIndirection);
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;
}
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::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::isDelegateCreationAllowed(
CORINFO_CLASS_HANDLE delegateHnd,
CORINFO_METHOD_HANDLE calleeHnd)
{
API_ENTER(isDelegateCreationAllowed);
BOOL temp = wrapHnd->isDelegateCreationAllowed(delegateHnd, calleeHnd);
API_LEAVE(isDelegateCreationAllowed);
return temp;
}
void WrapICorJitInfo::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);
}
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;
}
void WrapICorJitInfo::initConstraintsForVerification(
CORINFO_METHOD_HANDLE method, /* IN */
BOOL *pfHasCircularClassConstraints, /* OUT */
BOOL *pfHasCircularMethodConstraint /* OUT */)
{
API_ENTER(initConstraintsForVerification);
wrapHnd->initConstraintsForVerification(method, pfHasCircularClassConstraints, pfHasCircularMethodConstraint);
API_LEAVE(initConstraintsForVerification);
}
int HPSSFSAL_MkdirHandle(ns_ObjHandle_t * ObjHandle, /* IN - handle of parent directory */
char *Path, /* IN - path of directory */
mode_t Mode, /* IN - perm bits for new directory */
TYPE_CRED_HPSS * Ucred, /* IN - user credentials */
ns_ObjHandle_t * HandleOut, /* OUT - returned object handle */
hpss_Attrs_t * AttrsOut) /* OUT - returned attributes */
{
long error = 0;
apithrdstate_t *threadcontext;
TYPE_CRED_HPSS *ucred_ptr;
API_ENTER("hpss_MkdirHandle");
/*
* Initialize the thread if not already initialized.
* Get a pointer back to the thread specific context.
*/
error = API_ClientAPIInit(&threadcontext);
if(error != 0)
API_RETURN(error);
/*
* Check that the object handle is not NULL.
*/
if(ObjHandle == (ns_ObjHandle_t *) NULL)
API_RETURN(-EINVAL);
/*
* Check that there is a name for the new object
*/
if(Path == NULL)
API_RETURN(-EFAULT);
if(*Path == '\0')
API_RETURN(-ENOENT);
/*
* If user credentials were not passed, use the ones in the
* current thread context.
*/
if(Ucred == (TYPE_CRED_HPSS *) NULL)
ucred_ptr = &threadcontext->UserCred;
else
ucred_ptr = Ucred;
error = HPSSFSAL_Common_Mkdir(threadcontext,
ObjHandle,
Path,
API_NULL_CWD_STACK, Mode, ucred_ptr, HandleOut, AttrsOut);
API_RETURN(error);
}