Var JavascriptExternalFunction::ExternalFunctionThunk(RecyclableObject* function, CallInfo callInfo, ...)
{
RUNTIME_ARGUMENTS(args, callInfo);
JavascriptExternalFunction* externalFunction = static_cast<JavascriptExternalFunction*>(function);
// Deferred constructors which are not callable fall back to using the RecyclableObject::DefaultEntryPoint. In order to call
// this function we have to be inside script so all this and return before doing any of the external call preparation.
if (externalFunction->nativeMethod == Js::RecyclableObject::DefaultExternalEntryPoint)
{
return Js::RecyclableObject::DefaultExternalEntryPoint(function, callInfo, args.Values);
}
ScriptContext * scriptContext = externalFunction->type->GetScriptContext();
#ifdef ENABLE_DIRECTCALL_TELEMETRY
DirectCallTelemetry::AutoLogger logger(scriptContext, externalFunction, &args);
#endif
externalFunction->PrepareExternalCall(&args);
Var result = nullptr;
BEGIN_LEAVE_SCRIPT_WITH_EXCEPTION(scriptContext)
{
// Don't do stack probe since BEGIN_LEAVE_SCRIPT_WITH_EXCEPTION does that for us already
result = externalFunction->nativeMethod(function, callInfo, args.Values);
}
END_LEAVE_SCRIPT_WITH_EXCEPTION(scriptContext);
return externalFunction->FinishExternalCall(result);
}
Var CrossSite::CrossSiteProxyCallTrap(RecyclableObject* function, CallInfo callInfo, ...)
{
RUNTIME_ARGUMENTS(args, callInfo);
Assert(JavascriptProxy::Is(function));
return CrossSite::CommonThunk(function, JavascriptProxy::FunctionCallTrap, args);
}
Var JavascriptExternalFunction::StdCallExternalFunctionThunk(RecyclableObject* function, CallInfo callInfo, ...)
{
RUNTIME_ARGUMENTS(args, callInfo);
JavascriptExternalFunction* externalFunction = static_cast<JavascriptExternalFunction*>(function);
externalFunction->PrepareExternalCall(&args);
ScriptContext * scriptContext = externalFunction->type->GetScriptContext();
AnalysisAssert(scriptContext);
Var result = NULL;
BEGIN_LEAVE_SCRIPT(scriptContext)
{
result = externalFunction->stdCallNativeMethod(function, ((callInfo.Flags & CallFlags_New) != 0), args.Values, args.Info.Count, externalFunction->callbackState);
}
END_LEAVE_SCRIPT(scriptContext);
if (result != nullptr && !Js::TaggedNumber::Is(result))
{
if (!Js::RecyclableObject::Is(result))
{
Js::Throw::InternalError();
}
Js::RecyclableObject * obj = Js::RecyclableObject::FromVar(result);
// For JSRT, we could get result marshalled in different context.
bool isJSRT = !(scriptContext->GetThreadContext()->GetIsThreadBound());
if (!isJSRT && obj->GetScriptContext() != scriptContext)
{
Js::Throw::InternalError();
}
}
if (scriptContext->HasRecordedException())
{
bool considerPassingToDebugger = false;
JavascriptExceptionObject* recordedException = scriptContext->GetAndClearRecordedException(&considerPassingToDebugger);
if (recordedException != nullptr)
{
// If this is script termination, then throw ScriptAbortExceptio, else throw normal Exception object.
if (recordedException == scriptContext->GetThreadContext()->GetPendingTerminatedErrorObject())
{
throw Js::ScriptAbortException();
}
else
{
JavascriptExceptionOperators::RethrowExceptionObject(recordedException, scriptContext, considerPassingToDebugger);
}
}
}
return externalFunction->FinishExternalCall(result);
}
Var CrossSite::ProfileThunk(RecyclableObject* callable, CallInfo callInfo, ...)
{
JavascriptFunction* function = JavascriptFunction::FromVar(callable);
Assert(function->GetTypeId() == TypeIds_Function);
Assert(function->GetEntryPoint() == CrossSite::ProfileThunk);
RUNTIME_ARGUMENTS(args, callInfo);
ScriptContext * scriptContext = function->GetScriptContext();
// It is not safe to access the function body if the script context is not alive.
scriptContext->VerifyAliveWithHostContext(!function->IsExternal(),
scriptContext->GetThreadContext()->GetPreviousHostScriptContext());
JavascriptMethod entryPoint;
FunctionInfo *funcInfo = function->GetFunctionInfo();
TTD_XSITE_LOG(callable->GetScriptContext(), "DefaultOrProfileThunk", callable);
#ifdef ENABLE_WASM
if (WasmScriptFunction::Is(function))
{
AsmJsFunctionInfo* asmInfo = funcInfo->GetFunctionBody()->GetAsmJsFunctionInfo();
Assert(asmInfo);
if (asmInfo->IsWasmDeferredParse())
{
entryPoint = WasmLibrary::WasmDeferredParseExternalThunk;
}
else
{
entryPoint = Js::AsmJsExternalEntryPoint;
}
} else
#endif
if (funcInfo->HasBody())
{
#if ENABLE_DEBUG_CONFIG_OPTIONS
char16 debugStringBuffer[MAX_FUNCTION_BODY_DEBUG_STRING_SIZE];
#endif
entryPoint = ScriptFunction::FromVar(function)->GetEntryPointInfo()->jsMethod;
if (funcInfo->IsDeferred() && scriptContext->IsProfiling())
{
// if the current entrypoint is deferred parse we need to update it appropriately for the profiler mode.
entryPoint = Js::ScriptContext::GetProfileModeThunk(entryPoint);
}
OUTPUT_TRACE(Js::ScriptProfilerPhase, _u("CrossSite::ProfileThunk FunctionNumber : %s, Entrypoint : 0x%08X\n"), funcInfo->GetFunctionProxy()->GetDebugNumberSet(debugStringBuffer), entryPoint);
}
else
{
entryPoint = ProfileEntryThunk;
}
return CommonThunk(function, entryPoint, args);
}
Var JavascriptExternalFunction::WrappedFunctionThunk(RecyclableObject* function, CallInfo callInfo, ...)
{
RUNTIME_ARGUMENTS(args, callInfo);
JavascriptExternalFunction* externalFunction = static_cast<JavascriptExternalFunction*>(function);
ScriptContext* scriptContext = externalFunction->type->GetScriptContext();
Assert(!scriptContext->GetThreadContext()->IsDisableImplicitException());
scriptContext->VerifyAlive();
Assert(scriptContext->GetThreadContext()->IsScriptActive());
// Make sure the callee knows we are a wrapped function thunk
args.Info.Flags = (Js::CallFlags) (((long) args.Info.Flags) | CallFlags_Wrapped);
// don't need to leave script here, ExternalFunctionThunk will
Assert(externalFunction->wrappedMethod->GetFunctionInfo()->GetOriginalEntryPoint() == JavascriptExternalFunction::ExternalFunctionThunk);
return JavascriptFunction::CallFunction<true>(externalFunction->wrappedMethod, externalFunction->wrappedMethod->GetEntryPoint(), args);
}
Var CrossSite::DefaultThunk(RecyclableObject* callable, CallInfo callInfo, ...)
{
JavascriptFunction* function = JavascriptFunction::FromVar(callable);
Assert(function->GetTypeId() == TypeIds_Function);
Assert(function->GetEntryPoint() == CrossSite::DefaultThunk);
RUNTIME_ARGUMENTS(args, callInfo);
// It is not safe to access the function body if the script context is not alive.
function->GetScriptContext()->VerifyAliveWithHostContext(!function->IsExternal(),
ThreadContext::GetContextForCurrentThread()->GetPreviousHostScriptContext());
JavascriptMethod entryPoint;
FunctionInfo *funcInfo = function->GetFunctionInfo();
TTD_XSITE_LOG(callable->GetScriptContext(), "DefaultOrProfileThunk", callable);
if (funcInfo->HasBody())
{
#ifdef ASMJS_PLAT
if (funcInfo->GetFunctionProxy()->IsFunctionBody() &&
funcInfo->GetFunctionBody()->GetIsAsmJsFunction())
{
#ifdef ENABLE_WASM
AsmJsFunctionInfo* asmInfo = funcInfo->GetFunctionBody()->GetAsmJsFunctionInfo();
if (asmInfo && asmInfo->IsWasmDeferredParse())
{
entryPoint = WasmLibrary::WasmDeferredParseExternalThunk;
}
else
#endif
{
entryPoint = Js::AsmJsExternalEntryPoint;
}
}
else
#endif
{
entryPoint = ScriptFunction::FromVar(function)->GetEntryPointInfo()->jsMethod;
}
}
else
{
entryPoint = funcInfo->GetOriginalEntryPoint();
}
return CommonThunk(function, entryPoint, args);
}
Var BoundFunction::NewInstance(RecyclableObject* function, CallInfo callInfo, ...)
{
RUNTIME_ARGUMENTS(args, callInfo);
ScriptContext* scriptContext = function->GetScriptContext();
if (args.Info.Count == 0)
{
JavascriptError::ThrowTypeError(scriptContext, JSERR_NeedFunction /* TODO-ERROR: get arg name - args[0] */);
}
BoundFunction *boundFunction = (BoundFunction *) function;
Var targetFunction = boundFunction->targetFunction;
//
// var o = new boundFunction()
// a new object should be created using the actual function object
//
Var newVarInstance = nullptr;
if (callInfo.Flags & CallFlags_New)
{
if (JavascriptProxy::Is(targetFunction))
{
JavascriptProxy* proxy = JavascriptProxy::FromVar(targetFunction);
Arguments proxyArgs(CallInfo(CallFlags_New, 1), &targetFunction);
args.Values[0] = newVarInstance = proxy->ConstructorTrap(proxyArgs, scriptContext, 0);
}
else
{
args.Values[0] = newVarInstance = JavascriptOperators::NewScObjectNoCtor(targetFunction, scriptContext);
}
}
Js::Arguments actualArgs = args;
if (boundFunction->count > 0)
{
BOOL isCrossSiteObject = boundFunction->IsCrossSiteObject();
// OACR thinks that this can change between here and the check in the for loop below
const unsigned int argCount = args.Info.Count;
if ((boundFunction->count + argCount) > CallInfo::kMaxCountArgs)
{
JavascriptError::ThrowRangeError(scriptContext, JSERR_ArgListTooLarge);
}
Var *newValues = RecyclerNewArray(scriptContext->GetRecycler(), Var, boundFunction->count + argCount);
uint index = 0;
//
// For [[Construct]] use the newly created var instance
// For [[Call]] use the "this" to which bind bound it.
//
if (callInfo.Flags & CallFlags_New)
{
newValues[index++] = args[0];
}
else
{
newValues[index++] = boundFunction->boundThis;
}
// Copy the bound args
if (!isCrossSiteObject)
{
for (uint i = 0; i < boundFunction->count; i++)
{
newValues[index++] = boundFunction->boundArgs[i];
}
}
else
{
// it is possible that the bound arguments are not marshalled yet.
for (uint i = 0; i < boundFunction->count; i++)
{
newValues[index++] = CrossSite::MarshalVar(scriptContext, boundFunction->boundArgs[i]);
}
}
// Copy the extra args
for (uint i=1; i<argCount; i++)
{
newValues[index++] = args[i];
}
actualArgs = Arguments(args.Info, newValues);
actualArgs.Info.Count = boundFunction->count + argCount;
}
else
{
if (!(callInfo.Flags & CallFlags_New))
{
actualArgs.Values[0] = boundFunction->boundThis;
}
}
RecyclableObject* actualFunction = RecyclableObject::FromVar(targetFunction);
Var aReturnValue = JavascriptFunction::CallFunction<true>(actualFunction, actualFunction->GetEntryPoint(), actualArgs);
//
// [[Construct]] and call returned a non-object
// return the newly created var instance
//
if ((callInfo.Flags & CallFlags_New) && !JavascriptOperators::IsObject(aReturnValue))
{
aReturnValue = newVarInstance;
}
return aReturnValue;
}
