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

// Copyright (C) Microsoft. All rights reserved.

// Licensed under the MIT license. See LICENSE.txt file in the project root for full license information.

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

#include "JsrtPch.h"

#include "JsrtInternal.h"

#include "JsrtExternalObject.h"

#include "JsrtExternalArrayBuffer.h"

#include "jsrtHelper.h"

#include "JsrtSourceHolder.h"

#include "ByteCode/ByteCodeSerializer.h"

#include "Common/ByteSwap.h"

#include "Library/DataView.h"

#include "Library/JavascriptExceptionMetadata.h"

#include "Library/JavascriptPromise.h"

#include "Base/ThreadContextTlsEntry.h"

#include "Codex/Utf8Helper.h"

// Parser Includes

#include "cmperr.h" // For ERRnoMemory

#include "screrror.h" // For CompileScriptException

#ifdef ENABLE_DEBUG_CONFIG_OPTIONS

#include "TestHooksRt.h"

#endif

struct CodexHeapAllocatorInterface

{

public:

static void* allocate(size_t size)

{

return HeapNewArray(char, size);

}

static void free(void* ptr, size_t count)

{

HeapDeleteArray(count, (char*) ptr);

}

};

JsErrorCode CheckContext(JsrtContext *currentContext, bool verifyRuntimeState,

bool allowInObjectBeforeCollectCallback)

{

if (currentContext == nullptr)

{

return JsErrorNoCurrentContext;

}

// We don't need parameter check if it's checked in previous wrapper.

if (verifyRuntimeState)

{

Js::ScriptContext *scriptContext = currentContext->GetScriptContext();

Assert(scriptContext != nullptr);

Recycler *recycler = scriptContext->GetRecycler();

ThreadContext *threadContext = scriptContext->GetThreadContext();

if (recycler && recycler->IsHeapEnumInProgress())

{

return JsErrorHeapEnumInProgress;

}

else if (!allowInObjectBeforeCollectCallback &&

recycler && recycler->IsInObjectBeforeCollectCallback())

{

return JsErrorInObjectBeforeCollectCallback;

}

else if (threadContext->IsExecutionDisabled())

{

return JsErrorInDisabledState;

}

else if (scriptContext->IsInProfileCallback())

{

return JsErrorInProfileCallback;

}

else if (threadContext->IsInThreadServiceCallback())

{

return JsErrorInThreadServiceCallback;

}

// Make sure we don't have an outstanding exception.

if (scriptContext->GetThreadContext()->GetRecordedException() != nullptr)

{

return JsErrorInExceptionState;

}

}

return JsNoError;

}

/////////////////////

#if ENABLE_TTD

void CALLBACK OnScriptLoad_TTDCallback(FinalizableObject* jsrtCtx, Js::FunctionBody* body, Js::Utf8SourceInfo* utf8SourceInfo, CompileScriptException* compileException, bool notify)

{

((JsrtContext*)jsrtCtx)->OnScriptLoad_TTDCallback(body, utf8SourceInfo, compileException, notify);

}

uint32 CALLBACK OnBPRegister_TTDCallback(void* runtimeRcvr, int64 bpID, Js::ScriptContext* scriptContext, Js::Utf8SourceInfo* utf8SourceInfo, uint32 line, uint32 column, BOOL* isNewBP)

{

return ((JsrtRuntime*)runtimeRcvr)->BPRegister_TTD(bpID, scriptContext, utf8SourceInfo, line, column, isNewBP);

}

void CALLBACK OnBPDelete_TTDCallback(void* runtimeRcvr, uint32 bpID)

{

((JsrtRuntime*)runtimeRcvr)->BPDelete_TTD(bpID);

}

void CALLBACK OnBPClearDocument_TTDCallback(void* runtimeRcvr)

{

((JsrtRuntime*)runtimeRcvr)->BPClearDocument_TTD();

}

#endif

//A create context function that we can funnel to for regular and record or debug aware creation

JsErrorCode CreateContextCore(_In_ JsRuntimeHandle runtimeHandle, _In_ TTDRecorder& _actionEntryPopper, _In_ bool inRecordMode, _In_ bool activelyRecording, _In_ bool inReplayMode, _Out_ JsContextRef *newContext)

{

JsrtRuntime * runtime = JsrtRuntime::FromHandle(runtimeHandle);

ThreadContext * threadContext = runtime->GetThreadContext();

if(threadContext->GetRecycler() && threadContext->GetRecycler()->IsHeapEnumInProgress())

{

return JsErrorHeapEnumInProgress;

}

else if(threadContext->IsInThreadServiceCallback())

{

return JsErrorInThreadServiceCallback;

}

ThreadContextScope scope(threadContext);

if(!scope.IsValid())

{

return JsErrorWrongThread;

}

#if ENABLE_TTD

TTD::NSLogEvents::EventLogEntry* createEvent = nullptr;

if(activelyRecording)

{

createEvent = threadContext->TTDLog->RecordJsRTCreateScriptContext(_actionEntryPopper);

}

#endif

JsrtContext * context = JsrtContext::New(runtime);

#if ENABLE_TTD

if(inRecordMode | inReplayMode)

{

Js::ScriptContext* scriptContext = context->GetScriptContext();

HostScriptContextCallbackFunctor callbackFunctor((FinalizableObject*)context, (void*)runtime, &OnScriptLoad_TTDCallback, &OnBPRegister_TTDCallback, &OnBPDelete_TTDCallback, &OnBPClearDocument_TTDCallback);

#if ENABLE_TTD_DIAGNOSTICS_TRACING

bool noNative = true;

bool doDebug = true;

#else

bool noNative = TTD_FORCE_NOJIT_MODE || threadContext->TTDLog->IsDebugModeFlagSet();

bool doDebug = TTD_FORCE_DEBUG_MODE || threadContext->TTDLog->IsDebugModeFlagSet();

#endif

threadContext->TTDLog->PushMode(TTD::TTDMode::ExcludedExecutionTTAction);

if(inRecordMode)

{

threadContext->TTDContext->AddNewScriptContextRecord(context, scriptContext, callbackFunctor, noNative, doDebug);

}

else

{

threadContext->TTDContext->AddNewScriptContextReplay(context, scriptContext, callbackFunctor, noNative, doDebug);

}

threadContext->TTDLog->SetModeFlagsOnContext(scriptContext);

threadContext->TTDLog->PopMode(TTD::TTDMode::ExcludedExecutionTTAction);

}

#endif

#ifdef ENABLE_SCRIPT_DEBUGGING

JsrtDebugManager* jsrtDebugManager = runtime->GetJsrtDebugManager();

if(jsrtDebugManager != nullptr)

{

// JsDiagStartDebugging was called

threadContext->GetDebugManager()->SetLocalsDisplayFlags(Js::DebugManager::LocalsDisplayFlags::LocalsDisplayFlags_NoGroupMethods);

Js::ScriptContext* scriptContext = context->GetScriptContext();

Js::DebugContext* debugContext = scriptContext->GetDebugContext();

debugContext->SetHostDebugContext(jsrtDebugManager);

if (!jsrtDebugManager->IsDebugEventCallbackSet())

{

// JsDiagStopDebugging was called so we need to be in SourceRunDownMode

debugContext->SetDebuggerMode(Js::DebuggerMode::SourceRundown);

}

else

{

// Set Debugging mode

scriptContext->InitializeDebugging();

Js::ProbeContainer* probeContainer = debugContext->GetProbeContainer();

probeContainer->InitializeInlineBreakEngine(jsrtDebugManager);

probeContainer->InitializeDebuggerScriptOptionCallback(jsrtDebugManager);

}

}

#endif

#if ENABLE_TTD

if(activelyRecording)

{

threadContext->TTDLog->RecordJsRTCreateScriptContextResult(createEvent, context->GetScriptContext());

}

#endif

*newContext = (JsContextRef)context;

return JsNoError;

}

#if ENABLE_TTD

void CALLBACK CreateExternalObject_TTDCallback(Js::ScriptContext* ctx, Js::Var prototype, Js::Var* object)

{

TTDAssert(object != nullptr, "This should always be a valid location");

Js::RecyclableObject * prototypeObject = nullptr;

if (prototype != JS_INVALID_REFERENCE)

{

prototypeObject = Js::RecyclableObject::FromVar(prototype);

}

*object = JsrtExternalObject::Create(nullptr, nullptr, prototypeObject, ctx);

}

void CALLBACK TTDDummyPromiseContinuationCallback(JsValueRef task, void *callbackState)

{

TTDAssert(false, "This should never actually be invoked!!!");

}

void CALLBACK CreateJsRTContext_TTDCallback(void* runtimeHandle, Js::ScriptContext** result)

{

JsContextRef newContext = nullptr;

*result = nullptr;

TTDRecorder dummyActionEntryPopper;

JsErrorCode err = CreateContextCore(static_cast<JsRuntimeHandle>(runtimeHandle), dummyActionEntryPopper, false /*inRecordMode*/, false /*activelyRecording*/, true /*inReplayMode*/, &newContext);

TTDAssert(err == JsNoError, "Shouldn't fail on us!!!");

*result = static_cast<JsrtContext*>(newContext)->GetScriptContext();

(*result)->GetLibrary()->SetNativeHostPromiseContinuationFunction((Js::JavascriptLibrary::PromiseContinuationCallback)TTDDummyPromiseContinuationCallback, nullptr);

//To ensure we have a valid context active (when we next try and inflate into this context) set this as active by convention

JsrtContext::TrySetCurrent(static_cast<JsrtContext*>(newContext));

}

void CALLBACK ReleaseJsRTContext_TTDCallback(FinalizableObject* jsrtCtx)

{

static_cast<JsrtContext*>(jsrtCtx)->GetScriptContext()->GetThreadContext()->GetRecycler()->RootRelease(jsrtCtx);

JsrtContext::OnReplayDisposeContext_TTDCallback(jsrtCtx);

}

void CALLBACK SetActiveJsRTContext_TTDCallback(void* runtimeHandle, Js::ScriptContext* ctx)

{

JsrtRuntime * runtime = JsrtRuntime::FromHandle(static_cast<JsRuntimeHandle>(runtimeHandle));

ThreadContext * threadContext = runtime->GetThreadContext();

threadContext->TTDContext->SetActiveScriptContext(ctx);

JsrtContext* runtimeCtx = (JsrtContext*)threadContext->TTDContext->GetRuntimeContextForScriptContext(ctx);

JsrtContext::TrySetCurrent(runtimeCtx);

}

#endif

//A create runtime function that we can funnel to for regular and record or debug aware creation

JsErrorCode CreateRuntimeCore(_In_ JsRuntimeAttributes attributes,

_In_opt_ const char* optTTUri, size_t optTTUriCount, bool isRecord, bool isReplay, bool isDebug,

_In_ UINT32 snapInterval, _In_ UINT32 snapHistoryLength,

_In_opt_ TTDOpenResourceStreamCallback openResourceStream, _In_opt_ JsTTDReadBytesFromStreamCallback readBytesFromStream,

_In_opt_ JsTTDWriteBytesToStreamCallback writeBytesToStream, _In_opt_ JsTTDFlushAndCloseStreamCallback flushAndCloseStream,

_In_opt_ JsThreadServiceCallback threadService, _Out_ JsRuntimeHandle *runtimeHandle)

{

VALIDATE_ENTER_CURRENT_THREAD();

PARAM_NOT_NULL(runtimeHandle);

*runtimeHandle = nullptr;

JsErrorCode runtimeResult = GlobalAPIWrapper_NoRecord([&]() -> JsErrorCode {

const JsRuntimeAttributes JsRuntimeAttributesAll =

(JsRuntimeAttributes)(

JsRuntimeAttributeDisableBackgroundWork |

JsRuntimeAttributeAllowScriptInterrupt |

JsRuntimeAttributeEnableIdleProcessing |

JsRuntimeAttributeDisableEval |

JsRuntimeAttributeDisableNativeCodeGeneration |

JsRuntimeAttributeDisableExecutablePageAllocation |

JsRuntimeAttributeEnableExperimentalFeatures |

JsRuntimeAttributeDispatchSetExceptionsToDebugger |

JsRuntimeAttributeDisableFatalOnOOM

#ifdef ENABLE_DEBUG_CONFIG_OPTIONS

| JsRuntimeAttributeSerializeLibraryByteCode

#endif

);

Assert((attributes & ~JsRuntimeAttributesAll) == 0);

if ((attributes & ~JsRuntimeAttributesAll) != 0)

{

return JsErrorInvalidArgument;

}

CreateFileMapping(INVALID_HANDLE_VALUE, nullptr, PAGE_READWRITE, 0, 0, nullptr);

AllocationPolicyManager * policyManager = HeapNew(AllocationPolicyManager, (attributes & JsRuntimeAttributeDisableBackgroundWork) == 0);

bool enableExperimentalFeatures = (attributes & JsRuntimeAttributeEnableExperimentalFeatures) != 0;

ThreadContext * threadContext = HeapNew(ThreadContext, policyManager, threadService, enableExperimentalFeatures);

if (((attributes & JsRuntimeAttributeDisableBackgroundWork) != 0)

#ifdef ENABLE_DEBUG_CONFIG_OPTIONS

&& !Js::Configuration::Global.flags.ConcurrentRuntime

#endif

)

{

threadContext->OptimizeForManyInstances(true);

#if ENABLE_NATIVE_CODEGEN

threadContext->EnableBgJit(false);

#endif

}

if (!threadContext->IsRentalThreadingEnabledInJSRT()

#ifdef ENABLE_DEBUG_CONFIG_OPTIONS

|| Js::Configuration::Global.flags.DisableRentalThreading

#endif

)

{

threadContext->SetIsThreadBound();

}

if (attributes & JsRuntimeAttributeAllowScriptInterrupt)

{

threadContext->SetThreadContextFlag(ThreadContextFlagCanDisableExecution);

}

if (attributes & JsRuntimeAttributeDisableEval)

{

threadContext->SetThreadContextFlag(ThreadContextFlagEvalDisabled);

}

if (attributes & JsRuntimeAttributeDisableNativeCodeGeneration)

{

threadContext->SetThreadContextFlag(ThreadContextFlagNoJIT);

}

if (attributes & JsRuntimeAttributeDisableExecutablePageAllocation)

{

threadContext->SetThreadContextFlag(ThreadContextFlagNoJIT);

threadContext->SetThreadContextFlag(ThreadContextFlagNoDynamicThunks);

}

if (attributes & JsRuntimeAttributeDisableFatalOnOOM)

{

threadContext->SetThreadContextFlag(ThreadContextFlagDisableFatalOnOOM);

}

#ifdef ENABLE_DEBUG_CONFIG_OPTIONS

if (Js::Configuration::Global.flags.PrimeRecycler)

{

threadContext->EnsureRecycler()->Prime();

}

#endif

bool enableIdle = (attributes & JsRuntimeAttributeEnableIdleProcessing) == JsRuntimeAttributeEnableIdleProcessing;

bool dispatchExceptions = (attributes & JsRuntimeAttributeDispatchSetExceptionsToDebugger) == JsRuntimeAttributeDispatchSetExceptionsToDebugger;

JsrtRuntime * runtime = HeapNew(JsrtRuntime, threadContext, enableIdle, dispatchExceptions);

threadContext->SetCurrentThreadId(ThreadContext::NoThread);

*runtimeHandle = runtime->ToHandle();

#ifdef ENABLE_DEBUG_CONFIG_OPTIONS

runtime->SetSerializeByteCodeForLibrary((attributes & JsRuntimeAttributeSerializeLibraryByteCode) != 0);

#endif

return JsNoError;

});

#if ENABLE_TTD

if(runtimeResult != JsNoError)

{

return runtimeResult;

}

if(isRecord | isReplay | isDebug)

{

ThreadContext* threadContext = JsrtRuntime::FromHandle(*runtimeHandle)->GetThreadContext();

if(isRecord && isReplay)

{

return JsErrorInvalidArgument; //A runtime can only be in 1 mode

}

if(isReplay && optTTUri == nullptr)

{

return JsErrorInvalidArgument; //We must have a location to store data into

}

runtimeResult = GlobalAPIWrapper_NoRecord([&]() -> JsErrorCode {

//Make sure the thread context recycler is allocated before we do anything else

ThreadContextScope scope(threadContext);

threadContext->EnsureRecycler();

threadContext->InitTimeTravel(threadContext, *runtimeHandle, snapInterval, max<uint32>(2, snapHistoryLength));

threadContext->InitHostFunctionsAndTTData(isRecord, isReplay, isDebug, optTTUriCount, optTTUri,

openResourceStream, readBytesFromStream, writeBytesToStream, flushAndCloseStream,

&CreateExternalObject_TTDCallback, &CreateJsRTContext_TTDCallback, &ReleaseJsRTContext_TTDCallback, &SetActiveJsRTContext_TTDCallback);

return JsNoError;

});

}

#endif

return runtimeResult;

}

/////////////////////

CHAKRA_API JsCreateRuntime(_In_ JsRuntimeAttributes attributes, _In_opt_ JsThreadServiceCallback threadService, _Out_ JsRuntimeHandle *runtimeHandle)

{

return CreateRuntimeCore(attributes,

nullptr /*optRecordUri*/, 0 /*optRecordUriCount */, false /*isRecord*/, false /*isReplay*/, false /*isDebug*/,

UINT_MAX /*optSnapInterval*/, UINT_MAX /*optLogLength*/,

nullptr, nullptr, nullptr, nullptr, /*TTD IO handlers*/

threadService, runtimeHandle);

}

template <CollectionFlags flags>

JsErrorCode JsCollectGarbageCommon(JsRuntimeHandle runtimeHandle)

{

return GlobalAPIWrapper_NoRecord([&]() -> JsErrorCode {

VALIDATE_INCOMING_RUNTIME_HANDLE(runtimeHandle);

ThreadContext * threadContext = JsrtRuntime::FromHandle(runtimeHandle)->GetThreadContext();

if (threadContext->GetRecycler() && threadContext->GetRecycler()->IsHeapEnumInProgress())

{

return JsErrorHeapEnumInProgress;

}

else if (threadContext->IsInThreadServiceCallback())

{

return JsErrorInThreadServiceCallback;

}

ThreadContextScope scope(threadContext);

if (!scope.IsValid())

{

return JsErrorWrongThread;

}

Recycler* recycler = threadContext->EnsureRecycler();

#ifdef ENABLE_DEBUG_CONFIG_OPTIONS

if (flags & CollectOverride_SkipStack)

{

Recycler::AutoEnterExternalStackSkippingGCMode autoGC(recycler);

recycler->CollectNow<flags>();

}

else

#endif

{

recycler->CollectNow<flags>();

}

return JsNoError;

});

}

CHAKRA_API JsCollectGarbage(_In_ JsRuntimeHandle runtimeHandle)

{

return JsCollectGarbageCommon<CollectNowExhaustive>(runtimeHandle);

}

#ifdef ENABLE_DEBUG_CONFIG_OPTIONS

CHAKRA_API JsPrivateCollectGarbageSkipStack(_In_ JsRuntimeHandle runtimeHandle)

{

return JsCollectGarbageCommon<CollectNowExhaustiveSkipStack>(runtimeHandle);

}

CHAKRA_API JsPrivateDetachArrayBuffer(_In_ JsValueRef ref, _Out_ void** detachedState)

{

return GlobalAPIWrapper_NoRecord([&]() -> JsErrorCode

{

VALIDATE_JSREF(ref);

*detachedState = Js::JavascriptOperators::DetachVarAndGetState(ref);

return JsNoError;

});

}

CHAKRA_API JsPrivateFreeDetachedArrayBuffer(_In_ void* detachedState)

{

return GlobalAPIWrapper_NoRecord([&]() -> JsErrorCode

{

auto state = reinterpret_cast<Js::ArrayBufferDetachedStateBase*>(detachedState);

state->CleanUp();

return JsNoError;

});

}

#endif

CHAKRA_API JsDisposeRuntime(_In_ JsRuntimeHandle runtimeHandle)

{

return GlobalAPIWrapper_NoRecord([&] () -> JsErrorCode {

VALIDATE_INCOMING_RUNTIME_HANDLE(runtimeHandle);

JsrtRuntime * runtime = JsrtRuntime::FromHandle(runtimeHandle);

ThreadContext * threadContext = runtime->GetThreadContext();

ThreadContextScope scope(threadContext);

// We should not dispose if the runtime is being used.

if (!scope.IsValid() ||

scope.WasInUse() ||

(threadContext->GetRecycler() && threadContext->GetRecycler()->IsHeapEnumInProgress()))

{

return JsErrorRuntimeInUse;

}

else if (threadContext->IsInThreadServiceCallback())

{

return JsErrorInThreadServiceCallback;

}

// Invoke and clear the callbacks while the contexts and runtime are still available

{

Recycler* recycler = threadContext->GetRecycler();

if (recycler != nullptr)

{

recycler->ClearObjectBeforeCollectCallbacks();

}

}

#ifdef ENABLE_SCRIPT_DEBUGGING

if (runtime->GetJsrtDebugManager() != nullptr)

{

runtime->GetJsrtDebugManager()->ClearDebuggerObjects();

}

#endif

Js::ScriptContext *scriptContext;

for (scriptContext = threadContext->GetScriptContextList(); scriptContext; scriptContext = scriptContext->next)

{

#ifdef ENABLE_SCRIPT_DEBUGGING

if (runtime->GetJsrtDebugManager() != nullptr)

{

runtime->GetJsrtDebugManager()->ClearDebugDocument(scriptContext);

}

#endif

scriptContext->MarkForClose();

}

// Close any open Contexts.

// We need to do this before recycler shutdown, because ScriptEngine->Close won't work then.

runtime->CloseContexts();

#ifdef ENABLE_SCRIPT_DEBUGGING

runtime->DeleteJsrtDebugManager();

#endif

#if defined(CHECK_MEMORY_LEAK) || defined(LEAK_REPORT)

bool doFinalGC = false;

#if defined(LEAK_REPORT)

if (Js::Configuration::Global.flags.IsEnabled(Js::LeakReportFlag))

{

doFinalGC = true;

}

#endif

#if defined(CHECK_MEMORY_LEAK)

if (Js::Configuration::Global.flags.CheckMemoryLeak)

{

doFinalGC = true;

}

#endif

if (doFinalGC)

{

Recycler *recycler = threadContext->GetRecycler();

if (recycler)

{

recycler->EnsureNotCollecting();

recycler->CollectNow<CollectNowFinalGC>();

Assert(!recycler->CollectionInProgress());

}

}

#endif

runtime->SetBeforeCollectCallback(nullptr, nullptr);

threadContext->CloseForJSRT();

HeapDelete(threadContext);

HeapDelete(runtime);

scope.Invalidate();

return JsNoError;

});

}

CHAKRA_API JsAddRef(_In_ JsRef ref, _Out_opt_ unsigned int *count)

{

VALIDATE_JSREF(ref);

if (count != nullptr)

{

*count = 0;

}

if (Js::TaggedNumber::Is(ref))

{

// The count is always one because these are never collected

if (count)

{

*count = 1;

}

return JsNoError;

}

if (JsrtContext::Is(ref))

{

return GlobalAPIWrapper_NoRecord([&] () -> JsErrorCode

{

Recycler * recycler = static_cast<JsrtContext *>(ref)->GetRuntime()->GetThreadContext()->GetRecycler();

recycler->RootAddRef(ref, count);

return JsNoError;

});

}

else

{

ThreadContext* threadContext = ThreadContext::GetContextForCurrentThread();

if (threadContext == nullptr)

{

return JsErrorNoCurrentContext;

}

Recycler * recycler = threadContext->GetRecycler();

return GlobalAPIWrapper([&] (TTDRecorder& _actionEntryPopper) -> JsErrorCode

{

// Note, some references may live in arena-allocated memory, so we need to do this check

if (!recycler->IsValidObject(ref))

{

return JsNoError;

}

#if ENABLE_TTD

unsigned int lCount = 0;

recycler->RootAddRef(ref, &lCount);

if (count != nullptr)

{

*count = lCount;

}

if((lCount == 1) && (threadContext->IsRuntimeInTTDMode()) && (!threadContext->TTDLog->IsPropertyRecordRef(ref)))

{

Js::RecyclableObject* obj = Js::RecyclableObject::FromVar(ref);

if(obj->GetScriptContext()->IsTTDRecordModeEnabled())

{

if(obj->GetScriptContext()->ShouldPerformRecordAction())

{

threadContext->TTDLog->RecordJsRTAddRootRef(_actionEntryPopper, (Js::Var)ref);

}

threadContext->TTDContext->AddRootRef_Record(TTD_CONVERT_OBJ_TO_LOG_PTR_ID(obj), obj);

}

}

#else

recycler->RootAddRef(ref, count);

#endif

return JsNoError;

});

}

}

CHAKRA_API JsRelease(_In_ JsRef ref, _Out_opt_ unsigned int *count)

{

VALIDATE_JSREF(ref);

if (count != nullptr)

{

*count = 0;

}

if (Js::TaggedNumber::Is(ref))

{

// The count is always one because these are never collected

if (count)

{

*count = 1;

}

return JsNoError;

}

if (JsrtContext::Is(ref))

{

return GlobalAPIWrapper_NoRecord([&] () -> JsErrorCode

{

Recycler * recycler = static_cast<JsrtContext *>(ref)->GetRuntime()->GetThreadContext()->GetRecycler();

recycler->RootRelease(ref, count);

return JsNoError;

});

}

else

{

ThreadContext* threadContext = ThreadContext::GetContextForCurrentThread();

if (threadContext == nullptr)

{

return JsErrorNoCurrentContext;

}

Recycler * recycler = threadContext->GetRecycler();

return GlobalAPIWrapper([&](TTDRecorder& _actionEntryPopper) -> JsErrorCode

{

// Note, some references may live in arena-allocated memory, so we need to do this check

if (!recycler->IsValidObject(ref))

{

return JsNoError;

}

recycler->RootRelease(ref, count);

return JsNoError;

});

}

}

CHAKRA_API JsSetObjectBeforeCollectCallback(_In_ JsRef ref, _In_opt_ void *callbackState, _In_ JsObjectBeforeCollectCallback objectBeforeCollectCallback)

{

VALIDATE_JSREF(ref);

if (Js::TaggedNumber::Is(ref))

{

return JsErrorInvalidArgument;

}

if (JsrtContext::Is(ref))

{

return GlobalAPIWrapper_NoRecord([&]() -> JsErrorCode

{

ThreadContext* threadContext = static_cast<JsrtContext *>(ref)->GetRuntime()->GetThreadContext();

Recycler * recycler = threadContext->GetRecycler();

recycler->SetObjectBeforeCollectCallback(ref, reinterpret_cast<Recycler::ObjectBeforeCollectCallback>(objectBeforeCollectCallback), callbackState,

reinterpret_cast<Recycler::ObjectBeforeCollectCallbackWrapper>(JsrtCallbackState::ObjectBeforeCallectCallbackWrapper), threadContext);

return JsNoError;

});

}

else

{

ThreadContext* threadContext = ThreadContext::GetContextForCurrentThread();

if (threadContext == nullptr)

{

return JsErrorNoCurrentContext;

}

Recycler * recycler = threadContext->GetRecycler();

return GlobalAPIWrapper_NoRecord([&]() -> JsErrorCode

{

if (!recycler->IsValidObject(ref))

{

return JsErrorInvalidArgument;

}

recycler->SetObjectBeforeCollectCallback(ref, reinterpret_cast<Recycler::ObjectBeforeCollectCallback>(objectBeforeCollectCallback), callbackState,

reinterpret_cast<Recycler::ObjectBeforeCollectCallbackWrapper>(JsrtCallbackState::ObjectBeforeCallectCallbackWrapper), threadContext);

return JsNoError;

});

}

}

CHAKRA_API JsCreateContext(_In_ JsRuntimeHandle runtimeHandle, _Out_ JsContextRef *newContext)

{

return GlobalAPIWrapper([&](TTDRecorder& _actionEntryPopper) -> JsErrorCode {

PARAM_NOT_NULL(newContext);

VALIDATE_INCOMING_RUNTIME_HANDLE(runtimeHandle);

bool inRecord = false;

bool activelyRecording = false;

bool inReplay = false;

#if ENABLE_TTD

JsrtRuntime * runtime = JsrtRuntime::FromHandle(runtimeHandle);

ThreadContext * threadContext = runtime->GetThreadContext();

if(threadContext->IsRuntimeInTTDMode() && threadContext->TTDContext->GetActiveScriptContext() != nullptr)

{

Js::ScriptContext* currentCtx = threadContext->TTDContext->GetActiveScriptContext();

inRecord = currentCtx->IsTTDRecordModeEnabled();

activelyRecording = currentCtx->ShouldPerformRecordAction();

inReplay = currentCtx->IsTTDReplayModeEnabled();

}

#endif

return CreateContextCore(runtimeHandle, _actionEntryPopper, inRecord, activelyRecording, inReplay, newContext);

});

}

CHAKRA_API JsGetCurrentContext(_Out_ JsContextRef *currentContext)

{

PARAM_NOT_NULL(currentContext);

BEGIN_JSRT_NO_EXCEPTION

{

*currentContext = (JsContextRef)JsrtContext::GetCurrent();

}

END_JSRT_NO_EXCEPTION

}

CHAKRA_API JsSetCurrentContext(_In_ JsContextRef newContext)

{

VALIDATE_ENTER_CURRENT_THREAD();

return GlobalAPIWrapper([&] (TTDRecorder& _actionEntryPopper) -> JsErrorCode {

JsrtContext *currentContext = JsrtContext::GetCurrent();

Recycler* recycler = currentContext != nullptr ? currentContext->GetScriptContext()->GetRecycler() : nullptr;

#if ENABLE_TTD

Js::ScriptContext* newScriptContext = newContext != nullptr ? static_cast<JsrtContext*>(newContext)->GetScriptContext() : nullptr;

Js::ScriptContext* oldScriptContext = currentContext != nullptr ? static_cast<JsrtContext*>(currentContext)->GetScriptContext() : nullptr;

if(newScriptContext == nullptr)

{

if(oldScriptContext == nullptr)

{

; //if newScriptContext and oldScriptContext are null then we don't worry about doing anything

}

else

{

if(oldScriptContext->IsTTDRecordModeEnabled())

{

//already know newScriptContext != oldScriptContext so don't check again

if(oldScriptContext->ShouldPerformRecordAction())

{

oldScriptContext->GetThreadContext()->TTDLog->RecordJsRTSetCurrentContext(_actionEntryPopper, nullptr);

}

oldScriptContext->GetThreadContext()->TTDContext->SetActiveScriptContext(nullptr);

}

}

}

else

{

if(newScriptContext->IsTTDRecordModeEnabled())

{

if(newScriptContext != oldScriptContext && newScriptContext->ShouldPerformRecordAction())

{

newScriptContext->GetThreadContext()->TTDLog->RecordJsRTSetCurrentContext(_actionEntryPopper, newScriptContext->GetGlobalObject());

}

newScriptContext->GetThreadContext()->TTDContext->SetActiveScriptContext(newScriptContext);

}

}

#endif

if (currentContext && recycler->IsHeapEnumInProgress())

{

return JsErrorHeapEnumInProgress;

}

else if (currentContext && currentContext->GetRuntime()->GetThreadContext()->IsInThreadServiceCallback())

{

return JsErrorInThreadServiceCallback;

}

if (!JsrtContext::TrySetCurrent((JsrtContext *)newContext))

{

return JsErrorWrongThread;

}

return JsNoError;

});

}

CHAKRA_API JsGetContextOfObject(_In_ JsValueRef object, _Out_ JsContextRef *context)

{

VALIDATE_JSREF(object);

PARAM_NOT_NULL(context);

BEGIN_JSRT_NO_EXCEPTION

{

if (!Js::RecyclableObject::Is(object))

{

RETURN_NO_EXCEPTION(JsErrorArgumentNotObject);

}

Js::RecyclableObject* obj = Js::RecyclableObject::FromVar(object);

*context = (JsContextRef)obj->GetScriptContext()->GetLibrary()->GetJsrtContext();

}

END_JSRT_NO_EXCEPTION

}

CHAKRA_API JsGetContextData(_In_ JsContextRef context, _Out_ void **data)

{

VALIDATE_JSREF(context);

PARAM_NOT_NULL(data);

BEGIN_JSRT_NO_EXCEPTION

{

if (!JsrtContext::Is(context))

{

RETURN_NO_EXCEPTION(JsErrorInvalidArgument);

}

*data = static_cast<JsrtContext *>(context)->GetExternalData();

}

END_JSRT_NO_EXCEPTION

}

CHAKRA_API JsSetContextData(_In_ JsContextRef context, _In_ void *data)

{

VALIDATE_JSREF(context);

BEGIN_JSRT_NO_EXCEPTION

{

if (!JsrtContext::Is(context))

{

RETURN_NO_EXCEPTION(JsErrorInvalidArgument);

}

static_cast<JsrtContext *>(context)->SetExternalData(data);

}

END_JSRT_NO_EXCEPTION

}

void HandleScriptCompileError(Js::ScriptContext * scriptContext, CompileScriptException * se, const WCHAR * sourceUrl)

{

HRESULT hr = se->ei.scode;

if (hr == E_OUTOFMEMORY || hr == VBSERR_OutOfMemory || hr == ERRnoMemory)

{

Js::Throw::OutOfMemory();

}

else if (hr == E_ABORT)

{

Js::JavascriptOperators::ScriptAbort();

}

Js::JavascriptError* error = Js::JavascriptError::CreateFromCompileScriptException(scriptContext, se, sourceUrl);

Js::JavascriptExceptionObject * exceptionObject = RecyclerNew(scriptContext->GetRecycler(),

Js::JavascriptExceptionObject, error, scriptContext, nullptr);

scriptContext->GetThreadContext()->SetRecordedException(exceptionObject);

}

CHAKRA_API JsGetUndefinedValue(_Out_ JsValueRef *undefinedValue)

{

return ContextAPINoScriptWrapper_NoRecord([&] (Js::ScriptContext *scriptContext) -> JsErrorCode {

PARAM_NOT_NULL(undefinedValue);

*undefinedValue = scriptContext->GetLibrary()->GetUndefined();

return JsNoError;

},

/*allowInObjectBeforeCollectCallback*/true);

}

CHAKRA_API JsGetNullValue(_Out_ JsValueRef *nullValue)

{

return ContextAPINoScriptWrapper_NoRecord([&] (Js::ScriptContext *scriptContext) -> JsErrorCode {

PARAM_NOT_NULL(nullValue);

*nullValue = scriptContext->GetLibrary()->GetNull();

return JsNoError;

},

/*allowInObjectBeforeCollectCallback*/true);

}

CHAKRA_API JsGetTrueValue(_Out_ JsValueRef *trueValue)

{

return ContextAPINoScriptWrapper_NoRecord([&] (Js::ScriptContext *scriptContext) -> JsErrorCode {

PARAM_NOT_NULL(trueValue);

*trueValue = scriptContext->GetLibrary()->GetTrue();

return JsNoError;

},

/*allowInObjectBeforeCollectCallback*/true);

}

CHAKRA_API JsGetFalseValue(_Out_ JsValueRef *falseValue)

{

return ContextAPINoScriptWrapper_NoRecord([&] (Js::ScriptContext *scriptContext) -> JsErrorCode {

PARAM_NOT_NULL(falseValue);

*falseValue = scriptContext->GetLibrary()->GetFalse();

return JsNoError;

},

/*allowInObjectBeforeCollectCallback*/true);

}

CHAKRA_API JsBoolToBoolean(_In_ bool value, _Out_ JsValueRef *booleanValue)

{

return ContextAPINoScriptWrapper([&] (Js::ScriptContext *scriptContext, TTDRecorder& _actionEntryPopper) -> JsErrorCode {

PERFORM_JSRT_TTD_RECORD_ACTION(scriptContext, RecordJsRTCreateBoolean, value);

PARAM_NOT_NULL(booleanValue);

*booleanValue = value ? scriptContext->GetLibrary()->GetTrue() : scriptContext->GetLibrary()->GetFalse();

PERFORM_JSRT_TTD_RECORD_ACTION_RESULT(scriptContext, booleanValue);

return JsNoError;

},

/*allowInObjectBeforeCollectCallback*/true);

}

CHAKRA_API JsBooleanToBool(_In_ JsValueRef value, _Out_ bool *boolValue)

{

VALIDATE_JSREF(value);

PARAM_NOT_NULL(boolValue);

BEGIN_JSRT_NO_EXCEPTION

{

if (!Js::JavascriptBoolean::Is(value))

{

RETURN_NO_EXCEPTION(JsErrorInvalidArgument);