CORINFO_RESOLVED_TOKEN* pResolvedToken,

CORINFO_RESOLVED_TOKEN* pConstrainedResolvedToken,

GenTree* newobjThis,

int prefixFlags,

CORINFO_CALL_INFO* callInfo,

IL_OFFSET rawILOffset)

{

assert(opcode == CEE_CALL || opcode == CEE_CALLVIRT || opcode == CEE_NEWOBJ || opcode == CEE_CALLI);

// The current statement DI may not refer to the exact call, but for calls

// we wish to be able to attach the exact IL instruction to get "return

// value" support in the debugger, so create one with the exact IL offset.

DebugInfo di = impCreateDIWithCurrentStackInfo(rawILOffset, true);

var_types callRetTyp = TYP_COUNT;

CORINFO_SIG_INFO* sig = nullptr;

CORINFO_METHOD_HANDLE methHnd = nullptr;

CORINFO_CLASS_HANDLE clsHnd = nullptr;

unsigned clsFlags = 0;

unsigned mflags = 0;

GenTree* call = nullptr;

CORINFO_THIS_TRANSFORM constraintCallThisTransform = CORINFO_NO_THIS_TRANSFORM;

CORINFO_CONTEXT_HANDLE exactContextHnd = nullptr;

bool exactContextNeedsRuntimeLookup = false;

bool canTailCall = true;

const char* szCanTailCallFailReason = nullptr;

const int tailCallFlags = (prefixFlags & PREFIX_TAILCALL);

const bool isReadonlyCall = (prefixFlags & PREFIX_READONLY) != 0;

methodPointerInfo* ldftnInfo = nullptr;

// Synchronized methods need to call CORINFO_HELP_MON_EXIT at the end. We could

// do that before tailcalls, but that is probably not the intended

// semantic. So just disallow tailcalls from synchronized methods.

// Also, popping arguments in a varargs function is more work and NYI

// If we have a security object, we have to keep our frame around for callers

// to see any imperative security.

// Reverse P/Invokes need a call to CORINFO_HELP_JIT_REVERSE_PINVOKE_EXIT

// at the end, so tailcalls should be disabled.

// Async methods need to restore contexts, so tailcalls should be disabled.

if (info.compFlags & CORINFO_FLG_SYNCH)

{

canTailCall = false;

szCanTailCallFailReason = "Caller is synchronized";

}

else if (opts.IsReversePInvoke())

{

canTailCall = false;

szCanTailCallFailReason = "Caller is Reverse P/Invoke";

}

else if (compIsAsync())

{

canTailCall = false;

szCanTailCallFailReason = "Caller is async method";

}

#if !FEATURE_FIXED_OUT_ARGS

else if (info.compIsVarArgs)

{

canTailCall = false;

szCanTailCallFailReason = "Caller is varargs";

}

#endif // FEATURE_FIXED_OUT_ARGS

// We only need to cast the return value of pinvoke inlined calls that return small types

bool checkForSmallType = false;

bool bIntrinsicImported = false;

CORINFO_SIG_INFO calliSig;

GenTree* varArgsCookie = nullptr;

GenTree* instParam = nullptr;

GenTree* asyncContinuation = nullptr;

// Swift calls that might throw use a SwiftError* arg that requires additional IR to handle,

// so if we're importing a Swift call, look for this type in the signature

GenTree* swiftErrorNode = nullptr;

/*-------------------------------------------------------------------------

if (opcode == CEE_CALLI)

{

if (IsTargetAbi(CORINFO_NATIVEAOT_ABI))

{

if (info.compCompHnd->convertPInvokeCalliToCall(pResolvedToken, !impCanPInvokeInlineCallSite(compCurBB)))

{

eeGetCallInfo(pResolvedToken, nullptr, CORINFO_CALLINFO_ALLOWINSTPARAM, callInfo);

return impImportCall(CEE_CALL, pResolvedToken, nullptr, nullptr, prefixFlags, callInfo, rawILOffset);

}

}

/* Get the call site sig */

eeGetSig(pResolvedToken->token, pResolvedToken->tokenScope, pResolvedToken->tokenContext, &calliSig);

callRetTyp = JITtype2varType(calliSig.retType);

call = impImportIndirectCall(&calliSig, di);

// We don't know the target method, so we have to infer the flags, or

// assume the worst-case.

mflags = (calliSig.callConv & CORINFO_CALLCONV_HASTHIS) ? 0 : CORINFO_FLG_STATIC;

#ifdef DEBUG

if (verbose)

{

unsigned structSize = (callRetTyp == TYP_STRUCT) ? eeTryGetClassSize(calliSig.retTypeSigClass) : 0;

printf("\nIn Compiler::impImportCall: opcode is %s, kind=%d, callRetType is %s, structSize is %u\n",

opcodeNames[opcode], callInfo->kind, varTypeName(callRetTyp), structSize);

}

#endif

sig = &calliSig;

}

else // (opcode != CEE_CALLI)

{

NamedIntrinsic ni = NI_Illegal;

// Passing CORINFO_CALLINFO_ALLOWINSTPARAM indicates that this JIT is prepared to

// supply the instantiation parameters necessary to make direct calls to underlying

// shared generic code, rather than calling through instantiating stubs. If the

// returned signature has CORINFO_CALLCONV_PARAMTYPE then this indicates that the JIT

// must indeed pass an instantiation parameter.

methHnd = callInfo->hMethod;

sig = &(callInfo->sig);

callRetTyp = JITtype2varType(sig->retType);

mflags = callInfo->methodFlags;

#ifdef DEBUG

if (verbose)

{

unsigned structSize = (callRetTyp == TYP_STRUCT) ? eeTryGetClassSize(sig->retTypeSigClass) : 0;

printf("\nIn Compiler::impImportCall: opcode is %s, kind=%d, callRetType is %s, structSize is %u\n",

opcodeNames[opcode], callInfo->kind, varTypeName(callRetTyp), structSize);

}

#endif

if (compIsForInlining())

{

/* Does the inlinee use StackCrawlMark */

if (mflags & CORINFO_FLG_DONT_INLINE_CALLER)

{

compInlineResult->NoteFatal(InlineObservation::CALLEE_STACK_CRAWL_MARK);

return TYP_UNDEF;

}

/* For now ignore varargs */

if ((sig->callConv & CORINFO_CALLCONV_MASK) == CORINFO_CALLCONV_NATIVEVARARG)

{

compInlineResult->NoteFatal(InlineObservation::CALLEE_HAS_NATIVE_VARARGS);

return TYP_UNDEF;

}

if ((sig->callConv & CORINFO_CALLCONV_MASK) == CORINFO_CALLCONV_VARARG)

{

compInlineResult->NoteFatal(InlineObservation::CALLEE_HAS_MANAGED_VARARGS);

return TYP_UNDEF;

}

}

clsHnd = pResolvedToken->hClass;

clsFlags = callInfo->classFlags;

#ifdef DEBUG

// If this is a call to JitTestLabel.Mark, do "early inlining", and record the test attribute.

// This recognition should really be done by knowing the methHnd of the relevant Mark method(s).

// These should be in corelib.h, and available through a JIT/EE interface call.

const char* namespaceName;

const char* className;

const char* methodName =

info.compCompHnd->getMethodNameFromMetadata(methHnd, &className, &namespaceName, nullptr, 0);

if ((namespaceName != nullptr) && (className != nullptr) && (methodName != nullptr) &&

(strcmp(namespaceName, "System.Runtime.CompilerServices") == 0) &&

(strcmp(className, "JitTestLabel") == 0) && (strcmp(methodName, "Mark") == 0))

{

return impImportJitTestLabelMark(sig->numArgs);

}

#endif // DEBUG

const bool isIntrinsic = (mflags & CORINFO_FLG_INTRINSIC) != 0;

// <NICE> Factor this into getCallInfo </NICE>

bool isSpecialIntrinsic = false;

if (isIntrinsic || (!info.compMatchedVM && !RunningSuperPmiReplay()))

{

// For mismatched VM (AltJit) we want to check all methods as intrinsic to ensure

// we get more accurate codegen. This particularly applies to HWIntrinsic usage.

// But don't do this under SuperPMI replay, because it's unlikely we'll have

// the right data in the MethodContext in that case.

const bool isTailCall = canTailCall && (tailCallFlags != 0);

#if defined(FEATURE_READYTORUN)

CORINFO_CONST_LOOKUP entryPoint;

if (IsAot() && (callInfo->kind == CORINFO_CALL))

{

entryPoint = callInfo->codePointerLookup.constLookup;

}

else

{

entryPoint.addr = nullptr;

entryPoint.accessType = IAT_VALUE;

}

#endif // FEATURE_READYTORUN

call = impIntrinsic(clsHnd, methHnd, sig, mflags, pResolvedToken, isReadonlyCall, isTailCall,

opcode == CEE_CALLVIRT, pConstrainedResolvedToken,

callInfo->thisTransform R2RARG(&entryPoint), &ni, &isSpecialIntrinsic);

if (compDonotInline())

{

return TYP_UNDEF;

}

if (call != nullptr)

{

bIntrinsicImported = true;

goto DONE_CALL;

}

}

if ((mflags & CORINFO_FLG_VIRTUAL) && (mflags & CORINFO_FLG_EnC) && (opcode == CEE_CALLVIRT))

{

NO_WAY("Virtual call to a function added via EnC is not supported");

}

if ((sig->callConv & CORINFO_CALLCONV_MASK) != CORINFO_CALLCONV_DEFAULT &&

(sig->callConv & CORINFO_CALLCONV_MASK) != CORINFO_CALLCONV_VARARG &&

(sig->callConv & CORINFO_CALLCONV_MASK) != CORINFO_CALLCONV_NATIVEVARARG)

{

BADCODE("Bad calling convention");

}

//-------------------------------------------------------------------------

// Construct the call node

//

// Work out what sort of call we're making.

// Dispense with virtual calls implemented via LDVIRTFTN immediately.

constraintCallThisTransform = callInfo->thisTransform;

exactContextHnd = callInfo->contextHandle;

exactContextNeedsRuntimeLookup = callInfo->exactContextNeedsRuntimeLookup;

switch (callInfo->kind)

{

case CORINFO_VIRTUALCALL_STUB:

{

assert(!(mflags & CORINFO_FLG_STATIC)); // can't call a static method

assert(!(clsFlags & CORINFO_FLG_VALUECLASS));

if (callInfo->stubLookup.lookupKind.needsRuntimeLookup)

{

if (callInfo->stubLookup.lookupKind.runtimeLookupKind == CORINFO_LOOKUP_NOT_SUPPORTED)

{

// Runtime does not support inlining of all shapes of runtime lookups

// Inlining has to be aborted in such a case

compInlineResult->NoteFatal(InlineObservation::CALLSITE_HAS_COMPLEX_HANDLE);

return TYP_UNDEF;

}

GenTree* stubAddr = impRuntimeLookupToTree(&callInfo->stubLookup, methHnd);

// stubAddr tree may require a new temp.

// If we're inlining, this may trigger the too many locals inline failure.

//

// If so, we need to bail out.

//

if (compDonotInline())

{

return TYP_UNDEF;

}

// This is the rough code to set up an indirect stub call

assert(stubAddr != nullptr);

// The stubAddr may be a

// complex expression. As it is evaluated after the args,

// it may cause registered args to be spilled. Simply spill it.

//

if (!stubAddr->OperIs(GT_LCL_VAR))

{

unsigned const lclNum = lvaGrabTemp(true DEBUGARG("VirtualCall with runtime lookup"));

if (compDonotInline())

{

return TYP_UNDEF;

}

impStoreToTemp(lclNum, stubAddr, CHECK_SPILL_NONE);

stubAddr = gtNewLclvNode(lclNum, TYP_I_IMPL);

}

// Create the actual call node

assert((sig->callConv & CORINFO_CALLCONV_MASK) != CORINFO_CALLCONV_VARARG &&

(sig->callConv & CORINFO_CALLCONV_MASK) != CORINFO_CALLCONV_NATIVEVARARG);

call = gtNewIndCallNode(stubAddr, callRetTyp, di);

call->gtFlags |= GTF_EXCEPT | (stubAddr->gtFlags & GTF_GLOB_EFFECT);

call->gtFlags |= GTF_CALL_VIRT_STUB;

#ifdef TARGET_X86

// No tailcalls allowed for these yet...

canTailCall = false;

szCanTailCallFailReason = "VirtualCall with runtime lookup";

#endif

}

else

{

// The stub address is known at compile time

call = gtNewCallNode(CT_USER_FUNC, callInfo->hMethod, callRetTyp, di);

call->AsCall()->gtStubCallStubAddr = callInfo->stubLookup.constLookup.addr;

call->gtFlags |= GTF_CALL_VIRT_STUB;

assert(callInfo->stubLookup.constLookup.accessType != IAT_PPVALUE &&

callInfo->stubLookup.constLookup.accessType != IAT_RELPVALUE);

if (callInfo->stubLookup.constLookup.accessType == IAT_PVALUE)

{

call->AsCall()->gtCallMoreFlags |= GTF_CALL_M_VIRTSTUB_REL_INDIRECT;

}

}

#ifdef FEATURE_READYTORUN

if (IsAot())

{

// Null check is sometimes needed for ready to run to handle

// non-virtual <-> virtual changes between versions

if (callInfo->nullInstanceCheck)

{

call->gtFlags |= GTF_CALL_NULLCHECK;

}

}

#endif

break;

}

case CORINFO_VIRTUALCALL_VTABLE:

{

assert(!(mflags & CORINFO_FLG_STATIC)); // can't call a static method

assert(!(clsFlags & CORINFO_FLG_VALUECLASS));

call = gtNewCallNode(CT_USER_FUNC, callInfo->hMethod, callRetTyp, di);

call->gtFlags |= GTF_CALL_VIRT_VTABLE;

if (opts.OptimizationEnabled())

{

// Mark this method to expand the virtual call target early in fgMorphCall

call->AsCall()->SetExpandedEarly();

}

break;

}

case CORINFO_VIRTUALCALL_LDVIRTFTN:

{

assert(!(mflags & CORINFO_FLG_STATIC)); // can't call a static method

assert(!(clsFlags & CORINFO_FLG_VALUECLASS));

const bool needsFatPointerHandling =

(sig->sigInst.methInstCount != 0) && IsTargetAbi(CORINFO_NATIVEAOT_ABI);

if (needsFatPointerHandling)

{

// NativeAOT generic virtual method: need to handle potential fat function pointers

// Spill any side-effecting arguments before we do the LDVIRTFTN

impSpillSideEffects(false, CHECK_SPILL_ALL DEBUGARG("fat pointer arg spill"));

}

// OK, We've been told to call via LDVIRTFTN, so just

// take the call now....

call = gtNewIndCallNode(nullptr, callRetTyp, di);

if (sig->isAsyncCall())

{

impSetupAsyncCall(call->AsCall(), opcode, prefixFlags, di);

if (compDonotInline())

{

return TYP_UNDEF;

}

}

impPopCallArgs(sig, call->AsCall());

if (call->AsCall()->IsAsync())

{

impInsertAsyncContinuationForLdvirtftnCall(call->AsCall());

}

GenTree* thisPtr = impPopStack().val;

thisPtr = impTransformThis(thisPtr, pConstrainedResolvedToken, callInfo->thisTransform);

assert(thisPtr != nullptr);

GenTree* origThisPtr = thisPtr;

// Clone the (possibly transformed) "this" pointer

GenTree* thisPtrCopy;

thisPtr =

impCloneExpr(thisPtr, &thisPtrCopy, CHECK_SPILL_ALL, nullptr DEBUGARG("LDVIRTFTN this pointer"));

// We cloned the "this" pointer, mark it as a single def and set the class for it

if (thisPtr->OperIsLocal() && thisPtr->TypeIs(TYP_REF) && (origThisPtr != thisPtr))

{

lvaGetDesc(thisPtr->AsLclVarCommon())->lvSingleDef = 1;

lvaSetClass(thisPtr->AsLclVarCommon()->GetLclNum(), origThisPtr);

}

GenTree* fptr = impImportLdvirtftn(thisPtr, pResolvedToken, callInfo);

assert(fptr != nullptr);

call->AsCall()

->gtArgs.PushFront(this, NewCallArg::Primitive(thisPtrCopy).WellKnown(WellKnownArg::ThisPointer));

// Now make an indirect call through the function pointer

call->AsCall()->gtControlExpr = fptr;

call->gtFlags |= GTF_EXCEPT | (fptr->gtFlags & GTF_GLOB_EFFECT);

if (needsFatPointerHandling)

{

const unsigned fptrLclNum = lvaGrabTemp(true DEBUGARG("fat pointer temp"));

impStoreToTemp(fptrLclNum, fptr, CHECK_SPILL_ALL);

call->AsCall()->gtControlExpr = gtNewLclvNode(fptrLclNum, genActualType(fptr->TypeGet()));

addFatPointerCandidate(call->AsCall());

}

#ifdef FEATURE_READYTORUN

if (IsAot())

{

// Null check is needed for ready to run to handle

// non-virtual <-> virtual changes between versions

call->gtFlags |= GTF_CALL_NULLCHECK;

}

#endif

// Since we are jumping over some code, check that its OK to skip that code

assert((sig->callConv & CORINFO_CALLCONV_MASK) != CORINFO_CALLCONV_VARARG &&

(sig->callConv & CORINFO_CALLCONV_MASK) != CORINFO_CALLCONV_NATIVEVARARG);

goto DEVIRT;

}

case CORINFO_CALL:

{

// This is for a non-virtual, non-interface etc. call

call = gtNewCallNode(CT_USER_FUNC, callInfo->hMethod, callRetTyp, di);

// We remove the nullcheck for the GetType call intrinsic.

// TODO-CQ: JIT64 does not introduce the null check for many more helper calls

// and intrinsics.

if (callInfo->nullInstanceCheck &&

!((mflags & CORINFO_FLG_INTRINSIC) != 0 && (ni == NI_System_Object_GetType)))

{

call->gtFlags |= GTF_CALL_NULLCHECK;

}

#ifdef FEATURE_READYTORUN

if (IsAot())

{

call->AsCall()->setEntryPoint(callInfo->codePointerLookup.constLookup);

}

#endif

break;

}

case CORINFO_CALL_CODE_POINTER:

{

// The EE has asked us to call by computing a code pointer and then doing an

// indirect call. This is because a runtime lookup is required to get the code entry point.

// These calls always follow a uniform calling convention, i.e. no extra hidden params

assert((sig->callConv & CORINFO_CALLCONV_PARAMTYPE) == 0);

assert((sig->callConv & CORINFO_CALLCONV_MASK) != CORINFO_CALLCONV_VARARG);

assert((sig->callConv & CORINFO_CALLCONV_MASK) != CORINFO_CALLCONV_NATIVEVARARG);

GenTree* fptr = impLookupToTree(&callInfo->codePointerLookup, GTF_ICON_FTN_ADDR, callInfo->hMethod);

if (compDonotInline())

{

return TYP_UNDEF;

}

// Now make an indirect call through the function pointer

unsigned lclNum = lvaGrabTemp(true DEBUGARG("Indirect call through function pointer"));

impStoreToTemp(lclNum, fptr, CHECK_SPILL_ALL);

fptr = gtNewLclvNode(lclNum, TYP_I_IMPL);

call = gtNewIndCallNode(fptr, callRetTyp, di);

call->gtFlags |= GTF_EXCEPT | (fptr->gtFlags & GTF_GLOB_EFFECT);

if (callInfo->nullInstanceCheck)

{

call->gtFlags |= GTF_CALL_NULLCHECK;

}

break;

}

default:

assert(!"unknown call kind");

break;

}

//-------------------------------------------------------------------------

// Set more flags

assert(call != nullptr);

if (mflags & CORINFO_FLG_NOGCCHECK)

{

call->AsCall()->gtCallMoreFlags |= GTF_CALL_M_NOGCCHECK;

}

// Mark call if it's one of the ones we will maybe treat as an intrinsic

if (isSpecialIntrinsic)

{

call->AsCall()->gtCallMoreFlags |= GTF_CALL_M_SPECIAL_INTRINSIC;

}

}

assert(sig);

assert(clsHnd || (opcode == CEE_CALLI)); // We're never verifying for CALLI, so this is not set.

/* Some sanity checks */

// CALL_VIRT and NEWOBJ must have a THIS pointer

assert((opcode != CEE_CALLVIRT && opcode != CEE_NEWOBJ) || (sig->callConv & CORINFO_CALLCONV_HASTHIS));

// static bit and hasThis are negations of one another

assert(((mflags & CORINFO_FLG_STATIC) != 0) == ((sig->callConv & CORINFO_CALLCONV_HASTHIS) == 0));

assert(call != nullptr);

/*-------------------------------------------------------------------------

/* Special case - Check if it is a call to Delegate.Invoke(). */

if (mflags & CORINFO_FLG_DELEGATE_INVOKE)

{

assert(!(mflags & CORINFO_FLG_STATIC)); // can't call a static method

assert(mflags & CORINFO_FLG_FINAL);

/* Set the delegate flag */

call->AsCall()->gtCallMoreFlags |= GTF_CALL_M_DELEGATE_INV;

if (callInfo->wrapperDelegateInvoke)

{

call->AsCall()->gtCallMoreFlags |= GTF_CALL_M_WRAPPER_DELEGATE_INV;

}

if (opcode == CEE_CALLVIRT)

{

assert(mflags & CORINFO_FLG_FINAL);

/* It should have the GTF_CALL_NULLCHECK flag set. Reset it */

assert(call->gtFlags & GTF_CALL_NULLCHECK);

call->gtFlags &= ~GTF_CALL_NULLCHECK;

}

}

CORINFO_CLASS_HANDLE actualMethodRetTypeSigClass;

actualMethodRetTypeSigClass = sig->retTypeSigClass;

/* Check for varargs */

if (!compFeatureVarArg() && ((sig->callConv & CORINFO_CALLCONV_MASK) == CORINFO_CALLCONV_VARARG ||

(sig->callConv & CORINFO_CALLCONV_MASK) == CORINFO_CALLCONV_NATIVEVARARG))

{

BADCODE("Varargs not supported.");

}

if ((sig->callConv & CORINFO_CALLCONV_MASK) == CORINFO_CALLCONV_VARARG ||

(sig->callConv & CORINFO_CALLCONV_MASK) == CORINFO_CALLCONV_NATIVEVARARG)

{

/* Set the right flags */

call->gtFlags |= GTF_CALL_POP_ARGS;

call->AsCall()->gtArgs.SetIsVarArgs();

/* Can't allow tailcall for varargs as it is caller-pop. The caller

#ifdef TARGET_X86

if (canTailCall)

{

canTailCall = false;

szCanTailCallFailReason = "Callee is varargs";

}

#endif

/* Get the total number of arguments - this is already correct

if (opcode != CEE_CALLI)

{

#ifdef DEBUG

unsigned numArgsDef = sig->numArgs;

#endif

eeGetCallSiteSig(pResolvedToken->token, pResolvedToken->tokenScope, pResolvedToken->tokenContext, sig);

// For vararg calls we must be sure to load the return type of the

// method actually being called, as well as the return types of the

// specified in the vararg signature. With type equivalency, these types

// may not be the same.

if (sig->retTypeSigClass != actualMethodRetTypeSigClass)

{

if (actualMethodRetTypeSigClass != nullptr && sig->retType != CORINFO_TYPE_CLASS &&

sig->retType != CORINFO_TYPE_BYREF && sig->retType != CORINFO_TYPE_PTR &&

sig->retType != CORINFO_TYPE_VAR)

{

// Make sure that all valuetypes (including enums) that we push are loaded.

// This is to guarantee that if a GC is triggered from the prestub of this methods,

// all valuetypes in the method signature are already loaded.

// We need to be able to find the size of the valuetypes, but we cannot

// do a class-load from within GC.

info.compCompHnd->classMustBeLoadedBeforeCodeIsRun(actualMethodRetTypeSigClass);

}

}

assert(numArgsDef <= sig->numArgs);

}

/* We will have "cookie" as the last argument but we cannot push

}

//--------------------------- Inline PInvoke ------------------------------

// If this is a call to a PInvoke method, we may be able to inline the invocation frame.

//

impCheckForPInvokeCall(call->AsCall(), methHnd, sig, mflags, compCurBB);

#ifdef UNIX_X86_ABI

// On Unix x86 we use caller-cleaned convention.

if ((call->gtFlags & GTF_CALL_UNMANAGED) == 0)

call->gtFlags |= GTF_CALL_POP_ARGS;

#endif // UNIX_X86_ABI

if (call->gtFlags & GTF_CALL_UNMANAGED)

{

assert(call->IsCall());

// We set up the unmanaged call by linking the frame, disabling GC, etc

// This needs to be cleaned up on return.

// In addition, native calls have different normalization rules than managed code

// (managed calling convention always widens return values in the callee)

if (canTailCall)

{

canTailCall = false;

szCanTailCallFailReason = "Callee is native";

}

checkForSmallType = true;

impPopArgsForUnmanagedCall(call->AsCall(), sig, &swiftErrorNode);

goto DONE;

}

else if ((opcode == CEE_CALLI) && ((sig->callConv & CORINFO_CALLCONV_MASK) != CORINFO_CALLCONV_DEFAULT) &&

((sig->callConv & CORINFO_CALLCONV_MASK) != CORINFO_CALLCONV_VARARG))

{

void* pCookie;

void* cookie = info.compCompHnd->GetCookieForPInvokeCalliSig(sig, &pCookie);

CORINFO_CONST_LOOKUP cookieLookup = eeConvertToLookup(cookie, pCookie);

call->AsCall()->gtCallCookie = new (getAllocator(CMK_ASTNode)) CORINFO_CONST_LOOKUP(cookieLookup);

if (canTailCall)

{

canTailCall = false;

szCanTailCallFailReason = "PInvoke calli";

}

}

if (sig->isAsyncCall())

{

impSetupAsyncCall(call->AsCall(), opcode, prefixFlags, di);

if (compDonotInline())

{

return TYP_UNDEF;

}

if (lvaNextCallAsyncContinuation != BAD_VAR_NUM)

{

asyncContinuation = gtNewLclVarNode(lvaNextCallAsyncContinuation);

lvaNextCallAsyncContinuation = BAD_VAR_NUM;

}

else

{

asyncContinuation = gtNewNull();

}

}

// Now create the argument list.

//-------------------------------------------------------------------------

// Special case - for varargs we have an extra argument

if ((sig->callConv & CORINFO_CALLCONV_MASK) == CORINFO_CALLCONV_VARARG)

{

void *varCookie, *pVarCookie;

varCookie = info.compCompHnd->getVarArgsHandle(sig, methHnd, &pVarCookie);

assert((!varCookie) != (!pVarCookie));

varArgsCookie = gtNewIconEmbHndNode(varCookie, pVarCookie, GTF_ICON_VARG_HDL, sig);

}

//-------------------------------------------------------------------------

// Extra arg for shared generic code and array methods

//

// Extra argument containing instantiation information is passed in the

// following circumstances:

// (a) To the "Address" method on array classes; the extra parameter is

// the array's type handle (a TypeDesc)

// (b) To shared-code instance methods in generic structs; the extra parameter

// is the struct's type handle (a vtable ptr)

// (c) To shared-code per-instantiation non-generic static methods in generic

// classes and structs; the extra parameter is the type handle

// (d) To shared-code generic methods; the extra parameter is an

// exact-instantiation MethodDesc

//

// We also set the exact type context associated with the call so we can

// inline the call correctly later on.

if (sig->hasTypeArg())

{

if (lvaNextCallGenericContext != BAD_VAR_NUM)

{

instParam = gtNewLclVarNode(lvaNextCallGenericContext);

lvaNextCallGenericContext = BAD_VAR_NUM;

}

else

{

assert(call->AsCall()->gtCallType == CT_USER_FUNC);

if (clsHnd == nullptr)

{

NO_WAY("CALLI on parameterized type");

}

assert(opcode != CEE_CALLI);

bool runtimeLookup;

// Instantiated generic method

if (((SIZE_T)exactContextHnd & CORINFO_CONTEXTFLAGS_MASK) == CORINFO_CONTEXTFLAGS_METHOD)

{

assert(exactContextHnd != METHOD_BEING_COMPILED_CONTEXT());

CORINFO_METHOD_HANDLE exactMethodHandle =

(CORINFO_METHOD_HANDLE)((SIZE_T)exactContextHnd & ~CORINFO_CONTEXTFLAGS_MASK);

if (!exactContextNeedsRuntimeLookup)

{

#ifdef FEATURE_READYTORUN

if (IsAot())

{

instParam =

gtNewIconEmbHndNode(&callInfo->instParamLookup, GTF_ICON_METHOD_HDL, exactMethodHandle);

if (instParam == nullptr)

{

assert(compDonotInline());

return TYP_UNDEF;

}

}

else

#endif

{

instParam = gtNewIconEmbMethHndNode(exactMethodHandle);

info.compCompHnd->methodMustBeLoadedBeforeCodeIsRun(exactMethodHandle);

}

}

else

{

instParam = impTokenToHandle(pResolvedToken, &runtimeLookup, true /*mustRestoreHandle*/);

if (instParam == nullptr)

{

assert(compDonotInline());

return TYP_UNDEF;

}

}

}

// otherwise must be an instance method in a generic struct,

// a static method in a generic type, or a runtime-generated array method

else

{

assert(((SIZE_T)exactContextHnd & CORINFO_CONTEXTFLAGS_MASK) == CORINFO_CONTEXTFLAGS_CLASS);

CORINFO_CLASS_HANDLE exactClassHandle = eeGetClassFromContext(exactContextHnd);

if (compIsForInlining() && (clsFlags & CORINFO_FLG_ARRAY) != 0)

{

compInlineResult->NoteFatal(InlineObservation::CALLEE_IS_ARRAY_METHOD);

return TYP_UNDEF;

}

if ((clsFlags & CORINFO_FLG_ARRAY) && isReadonlyCall)

{

// We indicate "readonly" to the Address operation by using a null

// instParam.

instParam = gtNewIconNode(0, TYP_REF);

}

else if (!exactContextNeedsRuntimeLookup)

{

#ifdef FEATURE_READYTORUN

if (IsAot())

{

instParam =

gtNewIconEmbHndNode(&callInfo->instParamLookup, GTF_ICON_CLASS_HDL, exactClassHandle);

if (instParam == nullptr)

{

assert(compDonotInline());

return TYP_UNDEF;

}

}

else

#endif

{

instParam = gtNewIconEmbClsHndNode(exactClassHandle);

info.compCompHnd->classMustBeLoadedBeforeCodeIsRun(exactClassHandle);

}

}

else

{

instParam = impParentClassTokenToHandle(pResolvedToken, &runtimeLookup, true /*mustRestoreHandle*/);

if (instParam == nullptr)

{

assert(compDonotInline());

return TYP_UNDEF;

}

}

}

}

}

if ((opcode == CEE_NEWOBJ) && ((clsFlags & CORINFO_FLG_DELEGATE) != 0))

{

// Only verifiable cases are supported.

// dup; ldvirtftn; newobj; or ldftn; newobj.

// IL test could contain unverifiable sequence, in this case optimization should not be done.

if (impStackHeight() > 0)

{

typeInfo delegateTypeInfo = impStackTop().seTypeInfo;

if (delegateTypeInfo.IsMethod())

{

ldftnInfo = delegateTypeInfo.GetMethodPointerInfo();

}

}

}

//-------------------------------------------------------------------------

// The main group of arguments, and the this pointer.

// 'this' is pushed on the IL stack before all call args, but if this is a

// constrained call 'this' is a byref that may need to be dereferenced.

// That dereference should happen _after_ all args, so we need to spill

// them if they can interfere.

bool hasThis;

hasThis = ((mflags & CORINFO_FLG_STATIC) == 0) && ((sig->callConv & CORINFO_CALLCONV_EXPLICITTHIS) == 0) &&

((opcode != CEE_NEWOBJ) || (newobjThis != nullptr));

if (hasThis && (constraintCallThisTransform == CORINFO_DEREF_THIS))

{

impSpillSideEffects(false, CHECK_SPILL_ALL DEBUGARG(

"constrained call requires dereference for 'this' right before call"));

}

impPopCallArgs(sig, call->AsCall());

// Extra args

if ((instParam != nullptr) || (asyncContinuation != nullptr) || (varArgsCookie != nullptr))

{

if (Target::g_tgtArgOrder == Target::ARG_ORDER_R2L)

{

if (varArgsCookie != nullptr)

{

call->AsCall()->gtArgs.PushFront(this, NewCallArg::Primitive(varArgsCookie)

.WellKnown(WellKnownArg::VarArgsCookie));

}

if (asyncContinuation != nullptr)

{

call->AsCall()->gtArgs.PushFront(this, NewCallArg::Primitive(asyncContinuation)

.WellKnown(WellKnownArg::AsyncContinuation));

}

if (instParam != nullptr)

{

call->AsCall()->gtArgs.PushFront(this,

NewCallArg::Primitive(instParam).WellKnown(WellKnownArg::InstParam));

}

}

else

{

if (asyncContinuation != nullptr)

{

call->AsCall()->gtArgs.PushBack(this, NewCallArg::Primitive(asyncContinuation)

.WellKnown(WellKnownArg::AsyncContinuation));

}

if (instParam != nullptr)

{

call->AsCall()->gtArgs.PushBack(this,

NewCallArg::Primitive(instParam).WellKnown(WellKnownArg::InstParam));

}

if (varArgsCookie != nullptr)

{

call->AsCall()->gtArgs.PushBack(this, NewCallArg::Primitive(varArgsCookie)

.WellKnown(WellKnownArg::VarArgsCookie));

}

}

}

//-------------------------------------------------------------------------

// The "this" pointer

if (hasThis)

{

GenTree* obj;

if (opcode == CEE_NEWOBJ)

{

obj = newobjThis;

}

else

{

obj = impPopStack().val;

obj = impTransformThis(obj, pConstrainedResolvedToken, constraintCallThisTransform);

if (compDonotInline())

{

return TYP_UNDEF;

}

}

// Store the "this" value in the call

call->gtFlags |= obj->gtFlags & GTF_GLOB_EFFECT;

call->AsCall()->gtArgs.PushFront(this, NewCallArg::Primitive(obj).WellKnown(WellKnownArg::ThisPointer));

if (impIsThis(obj))

{

call->AsCall()->gtCallMoreFlags |= GTF_CALL_M_NONVIRT_SAME_THIS;

}

}

DEVIRT:

bool probing;

probing = impConsiderCallProbe(call->AsCall(), rawILOffset);

// See if we can devirt if we aren't probing.

if (!probing && opts.OptimizationEnabled())

{

if (call->AsCall()->IsDevirtualizationCandidate(this))

{

// only true object pointers can be virtual

assert(call->AsCall()->gtArgs.HasThisPointer() &&

call->AsCall()->gtArgs.GetThisArg()->GetNode()->TypeIs(TYP_REF));

// See if we can devirtualize.

const bool isExplicitTailCall = (tailCallFlags & PREFIX_TAILCALL_EXPLICIT) != 0;

const bool isLateDevirtualization = false;

impDevirtualizeCall(call->AsCall(), pResolvedToken, &callInfo->hMethod, &callInfo->methodFlags,

&callInfo->contextHandle, &exactContextHnd, isLateDevirtualization, isExplicitTailCall,

// Take care to pass raw IL offset here as the 'debug info' might be different for

// inlinees.

rawILOffset);

const bool wasDevirtualized = !call->AsCall()->IsDevirtualizationCandidate(this);