diff options
Diffstat (limited to 'js/src/vm/Runtime.cpp')
| -rw-r--r-- | js/src/vm/Runtime.cpp | 968 |
1 files changed, 968 insertions, 0 deletions
diff --git a/js/src/vm/Runtime.cpp b/js/src/vm/Runtime.cpp new file mode 100644 index 000000000..646d48299 --- /dev/null +++ b/js/src/vm/Runtime.cpp @@ -0,0 +1,968 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * vim: set ts=8 sts=4 et sw=4 tw=99: + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "mozilla/ArrayUtils.h" +#include "mozilla/Atomics.h" +#include "mozilla/DebugOnly.h" +#include "mozilla/MemoryReporting.h" +#include "mozilla/ThreadLocal.h" +#include "mozilla/Unused.h" + +#if defined(XP_DARWIN) +#include <mach/mach.h> +#elif defined(XP_UNIX) +#include <sys/resource.h> +#elif defined(XP_WIN) +#include <processthreadsapi.h> +#include <windows.h> +#endif // defined(XP_DARWIN) || defined(XP_UNIX) || defined(XP_WIN) + +#include <locale.h> +#include <string.h> + +#ifdef JS_CAN_CHECK_THREADSAFE_ACCESSES +# include <sys/mman.h> +#endif + +#include "jsatom.h" +#include "jsdtoa.h" +#include "jsgc.h" +#include "jsmath.h" +#include "jsnativestack.h" +#include "jsobj.h" +#include "jsscript.h" +#include "jswatchpoint.h" +#include "jswin.h" +#include "jswrapper.h" + +#include "builtin/Promise.h" +#include "gc/GCInternals.h" +#include "jit/arm/Simulator-arm.h" +#include "jit/arm64/vixl/Simulator-vixl.h" +#include "jit/IonBuilder.h" +#include "jit/JitCompartment.h" +#include "jit/mips32/Simulator-mips32.h" +#include "jit/mips64/Simulator-mips64.h" +#include "jit/PcScriptCache.h" +#include "js/Date.h" +#include "js/MemoryMetrics.h" +#include "js/SliceBudget.h" +#include "vm/Debugger.h" +#include "wasm/WasmSignalHandlers.h" + +#include "jscntxtinlines.h" +#include "jsgcinlines.h" + +using namespace js; +using namespace js::gc; + +using mozilla::Atomic; +using mozilla::DebugOnly; +using mozilla::NegativeInfinity; +using mozilla::PodZero; +using mozilla::PodArrayZero; +using mozilla::PositiveInfinity; +using JS::GenericNaN; +using JS::DoubleNaNValue; + +/* static */ MOZ_THREAD_LOCAL(PerThreadData*) js::TlsPerThreadData; +/* static */ Atomic<size_t> JSRuntime::liveRuntimesCount; + +namespace js { + bool gCanUseExtraThreads = true; +} // namespace js + +void +js::DisableExtraThreads() +{ + gCanUseExtraThreads = false; +} + +const JSSecurityCallbacks js::NullSecurityCallbacks = { }; + +PerThreadData::PerThreadData(JSRuntime* runtime) + : runtime_(runtime) +#ifdef JS_TRACE_LOGGING + , traceLogger(nullptr) +#endif + , autoFlushICache_(nullptr) + , dtoaState(nullptr) + , suppressGC(0) +#ifdef DEBUG + , ionCompiling(false) + , ionCompilingSafeForMinorGC(false) + , performingGC(false) + , gcSweeping(false) +#endif +{} + +PerThreadData::~PerThreadData() +{ + if (dtoaState) + DestroyDtoaState(dtoaState); +} + +bool +PerThreadData::init() +{ + dtoaState = NewDtoaState(); + if (!dtoaState) + return false; + + return true; +} + +static const JSWrapObjectCallbacks DefaultWrapObjectCallbacks = { + TransparentObjectWrapper, + nullptr +}; + +static size_t +ReturnZeroSize(const void* p) +{ + return 0; +} + +JSRuntime::JSRuntime(JSRuntime* parentRuntime) + : mainThread(this), + jitTop(nullptr), + jitActivation(nullptr), + jitStackLimit_(0xbad), + jitStackLimitNoInterrupt_(0xbad), +#ifdef DEBUG + ionBailAfter_(0), +#endif + activation_(nullptr), + profilingActivation_(nullptr), + profilerSampleBufferGen_(0), + profilerSampleBufferLapCount_(1), + wasmActivationStack_(nullptr), + entryMonitor(nullptr), + noExecuteDebuggerTop(nullptr), + parentRuntime(parentRuntime), +#ifdef DEBUG + updateChildRuntimeCount(parentRuntime), +#endif + interrupt_(false), + telemetryCallback(nullptr), + handlingSegFault(false), + handlingJitInterrupt_(false), + interruptCallbackDisabled(false), + getIncumbentGlobalCallback(nullptr), + enqueuePromiseJobCallback(nullptr), + enqueuePromiseJobCallbackData(nullptr), + promiseRejectionTrackerCallback(nullptr), + promiseRejectionTrackerCallbackData(nullptr), + startAsyncTaskCallback(nullptr), + finishAsyncTaskCallback(nullptr), + promiseTasksToDestroy(mutexid::PromiseTaskPtrVector), + exclusiveAccessLock(mutexid::RuntimeExclusiveAccess), +#ifdef DEBUG + mainThreadHasExclusiveAccess(false), +#endif + numExclusiveThreads(0), + numCompartments(0), + localeCallbacks(nullptr), + defaultLocale(nullptr), + defaultVersion_(JSVERSION_DEFAULT), + ownerThread_(js::ThisThread::GetId()), + ownerThreadNative_(0), + tempLifoAlloc(TEMP_LIFO_ALLOC_PRIMARY_CHUNK_SIZE), + jitRuntime_(nullptr), + selfHostingGlobal_(nullptr), + nativeStackBase(GetNativeStackBase()), + destroyCompartmentCallback(nullptr), + sizeOfIncludingThisCompartmentCallback(nullptr), + destroyZoneCallback(nullptr), + sweepZoneCallback(nullptr), + compartmentNameCallback(nullptr), + activityCallback(nullptr), + activityCallbackArg(nullptr), + requestDepth(0), +#ifdef DEBUG + checkRequestDepth(0), +#endif + gc(thisFromCtor()), + gcInitialized(false), +#ifdef JS_SIMULATOR + simulator_(nullptr), +#endif + scriptAndCountsVector(nullptr), + lcovOutput(), + NaNValue(DoubleNaNValue()), + negativeInfinityValue(DoubleValue(NegativeInfinity<double>())), + positiveInfinityValue(DoubleValue(PositiveInfinity<double>())), + emptyString(nullptr), + spsProfiler(thisFromCtor()), + profilingScripts(false), + suppressProfilerSampling(false), + hadOutOfMemory(false), +#if defined(DEBUG) || defined(JS_OOM_BREAKPOINT) + runningOOMTest(false), +#endif + allowRelazificationForTesting(false), + defaultFreeOp_(nullptr), + debuggerMutations(0), + securityCallbacks(&NullSecurityCallbacks), + DOMcallbacks(nullptr), + destroyPrincipals(nullptr), + readPrincipals(nullptr), + warningReporter(nullptr), + buildIdOp(nullptr), + propertyRemovals(0), +#if !EXPOSE_INTL_API + thousandsSeparator(0), + decimalSeparator(0), + numGrouping(0), +#endif + keepAtoms_(0), + trustedPrincipals_(nullptr), + beingDestroyed_(false), + atoms_(nullptr), + atomsCompartment_(nullptr), + staticStrings(nullptr), + commonNames(nullptr), + permanentAtoms(nullptr), + wellKnownSymbols(nullptr), + wrapObjectCallbacks(&DefaultWrapObjectCallbacks), + preserveWrapperCallback(nullptr), + jitSupportsFloatingPoint(false), + jitSupportsUnalignedAccesses(false), + jitSupportsSimd(false), + ionPcScriptCache(nullptr), + scriptEnvironmentPreparer(nullptr), + ctypesActivityCallback(nullptr), + windowProxyClass_(nullptr), + offthreadIonCompilationEnabled_(true), + parallelParsingEnabled_(true), + autoWritableJitCodeActive_(false), +#ifdef DEBUG + enteredPolicy(nullptr), +#endif + largeAllocationFailureCallback(nullptr), + oomCallback(nullptr), + debuggerMallocSizeOf(ReturnZeroSize), + lastAnimationTime(0), + performanceMonitoring(thisFromCtor()), + ionLazyLinkListSize_(0), + stackFormat_(parentRuntime ? js::StackFormat::Default + : js::StackFormat::SpiderMonkey) +{ + setGCStoreBufferPtr(&gc.storeBuffer); + + liveRuntimesCount++; + + /* Initialize infallibly first, so we can goto bad and JS_DestroyRuntime. */ + JS_INIT_CLIST(&onNewGlobalObjectWatchers); + + PodArrayZero(nativeStackQuota); + PodZero(&asmJSCacheOps); + lcovOutput.init(); +} + +bool +JSRuntime::init(uint32_t maxbytes, uint32_t maxNurseryBytes) +{ + MOZ_ASSERT(ownerThread_ == js::ThisThread::GetId()); + + // Get a platform-native handle for the owner thread, used by + // js::InterruptRunningJitCode to halt the runtime's main thread. +#ifdef XP_WIN + size_t openFlags = THREAD_GET_CONTEXT | THREAD_SET_CONTEXT | THREAD_SUSPEND_RESUME | + THREAD_QUERY_INFORMATION; + HANDLE self = OpenThread(openFlags, false, GetCurrentThreadId()); + if (!self) + return false; + static_assert(sizeof(HANDLE) <= sizeof(ownerThreadNative_), "need bigger field"); + ownerThreadNative_ = (size_t)self; +#else + static_assert(sizeof(pthread_t) <= sizeof(ownerThreadNative_), "need bigger field"); + ownerThreadNative_ = (size_t)pthread_self(); +#endif + + if (!mainThread.init()) + return false; + + if (!regexpStack.init()) + return false; + + if (CanUseExtraThreads() && !EnsureHelperThreadsInitialized()) + return false; + + js::TlsPerThreadData.set(&mainThread); + + defaultFreeOp_ = js_new<js::FreeOp>(this); + if (!defaultFreeOp_) + return false; + + if (!gc.init(maxbytes, maxNurseryBytes)) + return false; + + ScopedJSDeletePtr<Zone> atomsZone(new_<Zone>(this)); + if (!atomsZone || !atomsZone->init(true)) + return false; + + JS::CompartmentOptions options; + ScopedJSDeletePtr<JSCompartment> atomsCompartment(new_<JSCompartment>(atomsZone.get(), options)); + if (!atomsCompartment || !atomsCompartment->init(nullptr)) + return false; + + if (!gc.zones.append(atomsZone.get())) + return false; + if (!atomsZone->compartments.append(atomsCompartment.get())) + return false; + + atomsCompartment->setIsSystem(true); + atomsCompartment->setIsAtomsCompartment(); + + atomsZone.forget(); + this->atomsCompartment_ = atomsCompartment.forget(); + + if (!symbolRegistry_.init()) + return false; + + if (!scriptDataTable_.init()) + return false; + + /* The garbage collector depends on everything before this point being initialized. */ + gcInitialized = true; + + if (!InitRuntimeNumberState(this)) + return false; + + JS::ResetTimeZone(); + +#ifdef JS_SIMULATOR + simulator_ = js::jit::Simulator::Create(contextFromMainThread()); + if (!simulator_) + return false; +#endif + + jitSupportsFloatingPoint = js::jit::JitSupportsFloatingPoint(); + jitSupportsUnalignedAccesses = js::jit::JitSupportsUnalignedAccesses(); + jitSupportsSimd = js::jit::JitSupportsSimd(); + + if (!wasm::EnsureSignalHandlers(this)) + return false; + + if (!spsProfiler.init()) + return false; + + if (!fx.initInstance()) + return false; + + if (!parentRuntime) { + sharedImmutableStrings_ = js::SharedImmutableStringsCache::Create(); + if (!sharedImmutableStrings_) + return false; + } + + return true; +} + +void +JSRuntime::destroyRuntime() +{ + MOZ_ASSERT(!isHeapBusy()); + MOZ_ASSERT(childRuntimeCount == 0); + + fx.destroyInstance(); + + sharedIntlData.destroyInstance(); + + if (gcInitialized) { + /* + * Finish any in-progress GCs first. This ensures the parseWaitingOnGC + * list is empty in CancelOffThreadParses. + */ + JSContext* cx = contextFromMainThread(); + if (JS::IsIncrementalGCInProgress(cx)) + FinishGC(cx); + + /* Free source hook early, as its destructor may want to delete roots. */ + sourceHook = nullptr; + + /* + * Cancel any pending, in progress or completed Ion compilations and + * parse tasks. Waiting for wasm and compression tasks is done + * synchronously (on the main thread or during parse tasks), so no + * explicit canceling is needed for these. + */ + CancelOffThreadIonCompile(this); + CancelOffThreadParses(this); + + /* Remove persistent GC roots. */ + gc.finishRoots(); + + /* + * Flag us as being destroyed. This allows the GC to free things like + * interned atoms and Ion trampolines. + */ + beingDestroyed_ = true; + + /* Allow the GC to release scripts that were being profiled. */ + profilingScripts = false; + + /* Set the profiler sampler buffer generation to invalid. */ + profilerSampleBufferGen_ = UINT32_MAX; + + JS::PrepareForFullGC(contextFromMainThread()); + gc.gc(GC_NORMAL, JS::gcreason::DESTROY_RUNTIME); + } + + MOZ_ASSERT(ionLazyLinkListSize_ == 0); + MOZ_ASSERT(ionLazyLinkList_.isEmpty()); + + MOZ_ASSERT(!numExclusiveThreads); + AutoLockForExclusiveAccess lock(this); + + /* + * Even though all objects in the compartment are dead, we may have keep + * some filenames around because of gcKeepAtoms. + */ + FreeScriptData(this, lock); + +#if !EXPOSE_INTL_API + FinishRuntimeNumberState(this); +#endif + + gc.finish(); + atomsCompartment_ = nullptr; + + js_delete(defaultFreeOp_); + + js_free(defaultLocale); + js_delete(jitRuntime_); + + js_delete(ionPcScriptCache); + + gc.storeBuffer.disable(); + gc.nursery.disable(); + +#ifdef JS_SIMULATOR + js::jit::Simulator::Destroy(simulator_); +#endif + + DebugOnly<size_t> oldCount = liveRuntimesCount--; + MOZ_ASSERT(oldCount > 0); + +#ifdef JS_TRACE_LOGGING + DestroyTraceLoggerMainThread(this); +#endif + + js::TlsPerThreadData.set(nullptr); + +#ifdef XP_WIN + if (ownerThreadNative_) + CloseHandle((HANDLE)ownerThreadNative_); +#endif +} + +void +JSRuntime::addTelemetry(int id, uint32_t sample, const char* key) +{ + if (telemetryCallback) + (*telemetryCallback)(id, sample, key); +} + +void +JSRuntime::setTelemetryCallback(JSRuntime* rt, JSAccumulateTelemetryDataCallback callback) +{ + rt->telemetryCallback = callback; +} + +void +JSRuntime::addSizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf, JS::RuntimeSizes* rtSizes) +{ + // Several tables in the runtime enumerated below can be used off thread. + AutoLockForExclusiveAccess lock(this); + + // For now, measure the size of the derived class (JSContext). + // TODO (bug 1281529): make memory reporting reflect the new + // JSContext/JSRuntime world better. + JSContext* cx = unsafeContextFromAnyThread(); + rtSizes->object += mallocSizeOf(cx); + + rtSizes->atomsTable += atoms(lock).sizeOfIncludingThis(mallocSizeOf); + + if (!parentRuntime) { + rtSizes->atomsTable += mallocSizeOf(staticStrings); + rtSizes->atomsTable += mallocSizeOf(commonNames); + rtSizes->atomsTable += permanentAtoms->sizeOfIncludingThis(mallocSizeOf); + } + + rtSizes->contexts += cx->sizeOfExcludingThis(mallocSizeOf); + + rtSizes->temporary += tempLifoAlloc.sizeOfExcludingThis(mallocSizeOf); + + rtSizes->interpreterStack += interpreterStack_.sizeOfExcludingThis(mallocSizeOf); + + if (MathCache* cache = cx->caches.maybeGetMathCache()) + rtSizes->mathCache += cache->sizeOfIncludingThis(mallocSizeOf); + + if (sharedImmutableStrings_) { + rtSizes->sharedImmutableStringsCache += + sharedImmutableStrings_->sizeOfExcludingThis(mallocSizeOf); + } + + rtSizes->sharedIntlData += sharedIntlData.sizeOfExcludingThis(mallocSizeOf); + + rtSizes->uncompressedSourceCache += + cx->caches.uncompressedSourceCache.sizeOfExcludingThis(mallocSizeOf); + + + rtSizes->scriptData += scriptDataTable(lock).sizeOfExcludingThis(mallocSizeOf); + for (ScriptDataTable::Range r = scriptDataTable(lock).all(); !r.empty(); r.popFront()) + rtSizes->scriptData += mallocSizeOf(r.front()); + + if (jitRuntime_) { + jitRuntime_->execAlloc().addSizeOfCode(&rtSizes->code); + jitRuntime_->backedgeExecAlloc().addSizeOfCode(&rtSizes->code); + } + + rtSizes->gc.marker += gc.marker.sizeOfExcludingThis(mallocSizeOf); + rtSizes->gc.nurseryCommitted += gc.nursery.sizeOfHeapCommitted(); + rtSizes->gc.nurseryMallocedBuffers += gc.nursery.sizeOfMallocedBuffers(mallocSizeOf); + gc.storeBuffer.addSizeOfExcludingThis(mallocSizeOf, &rtSizes->gc); +} + +static bool +InvokeInterruptCallback(JSContext* cx) +{ + MOZ_ASSERT(cx->runtime()->requestDepth >= 1); + + cx->runtime()->gc.gcIfRequested(); + + // A worker thread may have requested an interrupt after finishing an Ion + // compilation. + jit::AttachFinishedCompilations(cx); + + // Important: Additional callbacks can occur inside the callback handler + // if it re-enters the JS engine. The embedding must ensure that the + // callback is disconnected before attempting such re-entry. + if (cx->runtime()->interruptCallbackDisabled) + return true; + + bool stop = false; + for (JSInterruptCallback cb : cx->runtime()->interruptCallbacks) { + if (!cb(cx)) + stop = true; + } + + if (!stop) { + // Debugger treats invoking the interrupt callback as a "step", so + // invoke the onStep handler. + if (cx->compartment()->isDebuggee()) { + ScriptFrameIter iter(cx); + if (!iter.done() && + cx->compartment() == iter.compartment() && + iter.script()->stepModeEnabled()) + { + RootedValue rval(cx); + switch (Debugger::onSingleStep(cx, &rval)) { + case JSTRAP_ERROR: + return false; + case JSTRAP_CONTINUE: + return true; + case JSTRAP_RETURN: + // See note in Debugger::propagateForcedReturn. + Debugger::propagateForcedReturn(cx, iter.abstractFramePtr(), rval); + return false; + case JSTRAP_THROW: + cx->setPendingException(rval); + return false; + default:; + } + } + } + + return true; + } + + // No need to set aside any pending exception here: ComputeStackString + // already does that. + JSString* stack = ComputeStackString(cx); + JSFlatString* flat = stack ? stack->ensureFlat(cx) : nullptr; + + const char16_t* chars; + AutoStableStringChars stableChars(cx); + if (flat && stableChars.initTwoByte(cx, flat)) + chars = stableChars.twoByteRange().begin().get(); + else + chars = u"(stack not available)"; + JS_ReportErrorFlagsAndNumberUC(cx, JSREPORT_WARNING, GetErrorMessage, nullptr, + JSMSG_TERMINATED, chars); + + return false; +} + +void +JSRuntime::requestInterrupt(InterruptMode mode) +{ + interrupt_ = true; + jitStackLimit_ = UINTPTR_MAX; + + if (mode == JSRuntime::RequestInterruptUrgent) { + // If this interrupt is urgent (slow script dialog and garbage + // collection among others), take additional steps to + // interrupt corner cases where the above fields are not + // regularly polled. Wake both ilooping JIT code and + // Atomics.wait(). + fx.lock(); + if (fx.isWaiting()) + fx.wake(FutexRuntime::WakeForJSInterrupt); + fx.unlock(); + InterruptRunningJitCode(this); + } +} + +bool +JSRuntime::handleInterrupt(JSContext* cx) +{ + MOZ_ASSERT(CurrentThreadCanAccessRuntime(cx->runtime())); + if (interrupt_ || jitStackLimit_ == UINTPTR_MAX) { + interrupt_ = false; + cx->resetJitStackLimit(); + return InvokeInterruptCallback(cx); + } + return true; +} + +bool +JSRuntime::setDefaultLocale(const char* locale) +{ + if (!locale) + return false; + resetDefaultLocale(); + defaultLocale = JS_strdup(contextFromMainThread(), locale); + return defaultLocale != nullptr; +} + +void +JSRuntime::resetDefaultLocale() +{ + js_free(defaultLocale); + defaultLocale = nullptr; +} + +const char* +JSRuntime::getDefaultLocale() +{ + if (defaultLocale) + return defaultLocale; + + const char* locale; +#ifdef HAVE_SETLOCALE + locale = setlocale(LC_ALL, nullptr); +#else + locale = getenv("LANG"); +#endif + // convert to a well-formed BCP 47 language tag + if (!locale || !strcmp(locale, "C")) + locale = "und"; + + char* lang = JS_strdup(contextFromMainThread(), locale); + if (!lang) + return nullptr; + + char* p; + if ((p = strchr(lang, '.'))) + *p = '\0'; + while ((p = strchr(lang, '_'))) + *p = '-'; + + defaultLocale = lang; + return defaultLocale; +} + +void +JSRuntime::traceSharedIntlData(JSTracer* trc) +{ + sharedIntlData.trace(trc); +} + +void +JSRuntime::triggerActivityCallback(bool active) +{ + if (!activityCallback) + return; + + /* + * The activity callback must not trigger a GC: it would create a cirular + * dependency between entering a request and Rooted's requirement of being + * in a request. In practice this callback already cannot trigger GC. The + * suppression serves to inform the exact rooting hazard analysis of this + * property and ensures that it remains true in the future. + */ + AutoSuppressGC suppress(contextFromMainThread()); + + activityCallback(activityCallbackArg, active); +} + +FreeOp::FreeOp(JSRuntime* maybeRuntime) + : JSFreeOp(maybeRuntime) +{ + MOZ_ASSERT_IF(maybeRuntime, CurrentThreadCanAccessRuntime(maybeRuntime)); +} + +FreeOp::~FreeOp() +{ + for (size_t i = 0; i < freeLaterList.length(); i++) + free_(freeLaterList[i]); + + if (!jitPoisonRanges.empty()) + jit::ExecutableAllocator::poisonCode(runtime(), jitPoisonRanges); +} + +bool +FreeOp::isDefaultFreeOp() const +{ + return runtime_ && runtime_->defaultFreeOp() == this; +} + +JSObject* +JSRuntime::getIncumbentGlobal(JSContext* cx) +{ + MOZ_ASSERT(cx->runtime()->getIncumbentGlobalCallback, + "Must set a callback using JS_SetGetIncumbentGlobalCallback before using Promises"); + + return cx->runtime()->getIncumbentGlobalCallback(cx); +} + +bool +JSRuntime::enqueuePromiseJob(JSContext* cx, HandleFunction job, HandleObject promise, + HandleObject incumbentGlobal) +{ + MOZ_ASSERT(cx->runtime()->enqueuePromiseJobCallback, + "Must set a callback using JS_SetEnqeueuPromiseJobCallback before using Promises"); + MOZ_ASSERT_IF(incumbentGlobal, !IsWrapper(incumbentGlobal) && !IsWindowProxy(incumbentGlobal)); + + void* data = cx->runtime()->enqueuePromiseJobCallbackData; + RootedObject allocationSite(cx); + if (promise) { + RootedObject unwrappedPromise(cx, promise); + // While the job object is guaranteed to be unwrapped, the promise + // might be wrapped. See the comments in + // intrinsic_EnqueuePromiseReactionJob for details. + if (IsWrapper(promise)) + unwrappedPromise = UncheckedUnwrap(promise); + if (unwrappedPromise->is<PromiseObject>()) + allocationSite = JS::GetPromiseAllocationSite(unwrappedPromise); + } + return cx->runtime()->enqueuePromiseJobCallback(cx, job, allocationSite, incumbentGlobal, data); +} + +void +JSRuntime::addUnhandledRejectedPromise(JSContext* cx, js::HandleObject promise) +{ + MOZ_ASSERT(promise->is<PromiseObject>()); + if (!cx->runtime()->promiseRejectionTrackerCallback) + return; + + void* data = cx->runtime()->promiseRejectionTrackerCallbackData; + cx->runtime()->promiseRejectionTrackerCallback(cx, promise, + PromiseRejectionHandlingState::Unhandled, data); +} + +void +JSRuntime::removeUnhandledRejectedPromise(JSContext* cx, js::HandleObject promise) +{ + MOZ_ASSERT(promise->is<PromiseObject>()); + if (!cx->runtime()->promiseRejectionTrackerCallback) + return; + + void* data = cx->runtime()->promiseRejectionTrackerCallbackData; + cx->runtime()->promiseRejectionTrackerCallback(cx, promise, + PromiseRejectionHandlingState::Handled, data); +} + +mozilla::non_crypto::XorShift128PlusRNG& +JSRuntime::randomKeyGenerator() +{ + MOZ_ASSERT(CurrentThreadCanAccessRuntime(this)); + if (randomKeyGenerator_.isNothing()) { + mozilla::Array<uint64_t, 2> seed; + GenerateXorShift128PlusSeed(seed); + randomKeyGenerator_.emplace(seed[0], seed[1]); + } + return randomKeyGenerator_.ref(); +} + +mozilla::HashCodeScrambler +JSRuntime::randomHashCodeScrambler() +{ + auto& rng = randomKeyGenerator(); + return mozilla::HashCodeScrambler(rng.next(), rng.next()); +} + +mozilla::non_crypto::XorShift128PlusRNG +JSRuntime::forkRandomKeyGenerator() +{ + auto& rng = randomKeyGenerator(); + return mozilla::non_crypto::XorShift128PlusRNG(rng.next(), rng.next()); +} + +void +JSRuntime::updateMallocCounter(size_t nbytes) +{ + updateMallocCounter(nullptr, nbytes); +} + +void +JSRuntime::updateMallocCounter(JS::Zone* zone, size_t nbytes) +{ + gc.updateMallocCounter(zone, nbytes); +} + +JS_FRIEND_API(void*) +JSRuntime::onOutOfMemory(AllocFunction allocFunc, size_t nbytes, void* reallocPtr, + JSContext* maybecx) +{ + MOZ_ASSERT_IF(allocFunc != AllocFunction::Realloc, !reallocPtr); + MOZ_ASSERT(CurrentThreadCanAccessRuntime(this)); + + if (isHeapBusy()) + return nullptr; + + if (!oom::IsSimulatedOOMAllocation()) { + /* + * Retry when we are done with the background sweeping and have stopped + * all the allocations and released the empty GC chunks. + */ + gc.onOutOfMallocMemory(); + void* p; + switch (allocFunc) { + case AllocFunction::Malloc: + p = js_malloc(nbytes); + break; + case AllocFunction::Calloc: + p = js_calloc(nbytes); + break; + case AllocFunction::Realloc: + p = js_realloc(reallocPtr, nbytes); + break; + default: + MOZ_CRASH(); + } + if (p) + return p; + } + + if (maybecx) + ReportOutOfMemory(maybecx); + return nullptr; +} + +void* +JSRuntime::onOutOfMemoryCanGC(AllocFunction allocFunc, size_t bytes, void* reallocPtr) +{ + if (largeAllocationFailureCallback && bytes >= LARGE_ALLOCATION) + largeAllocationFailureCallback(largeAllocationFailureCallbackData); + return onOutOfMemory(allocFunc, bytes, reallocPtr); +} + +bool +JSRuntime::activeGCInAtomsZone() +{ + Zone* zone = atomsCompartment_->zone(); + return (zone->needsIncrementalBarrier() && !gc.isVerifyPreBarriersEnabled()) || + zone->wasGCStarted(); +} + +void +JSRuntime::setUsedByExclusiveThread(Zone* zone) +{ + MOZ_ASSERT(!zone->usedByExclusiveThread); + zone->usedByExclusiveThread = true; + numExclusiveThreads++; +} + +void +JSRuntime::clearUsedByExclusiveThread(Zone* zone) +{ + MOZ_ASSERT(zone->usedByExclusiveThread); + zone->usedByExclusiveThread = false; + numExclusiveThreads--; + if (gc.fullGCForAtomsRequested() && !keepAtoms()) + gc.triggerFullGCForAtoms(); +} + +bool +js::CurrentThreadCanAccessRuntime(const JSRuntime* rt) +{ + return rt->ownerThread_ == js::ThisThread::GetId(); +} + +bool +js::CurrentThreadCanAccessZone(Zone* zone) +{ + if (CurrentThreadCanAccessRuntime(zone->runtime_)) + return true; + + // Only zones in use by an exclusive thread can be used off the main thread. + // We don't keep track of which thread owns such zones though, so this check + // is imperfect. + return zone->usedByExclusiveThread; +} + +#ifdef DEBUG +bool +js::CurrentThreadIsPerformingGC() +{ + return TlsPerThreadData.get()->performingGC; +} +#endif + +JS_FRIEND_API(void) +JS::UpdateJSContextProfilerSampleBufferGen(JSContext* cx, uint32_t generation, + uint32_t lapCount) +{ + cx->setProfilerSampleBufferGen(generation); + cx->updateProfilerSampleBufferLapCount(lapCount); +} + +JS_FRIEND_API(bool) +JS::IsProfilingEnabledForContext(JSContext* cx) +{ + MOZ_ASSERT(cx); + return cx->spsProfiler.enabled(); +} + +JSRuntime::IonBuilderList& +JSRuntime::ionLazyLinkList() +{ + MOZ_ASSERT(TlsPerThreadData.get()->runtimeFromMainThread(), + "Should only be mutated by the main thread."); + return ionLazyLinkList_; +} + +void +JSRuntime::ionLazyLinkListRemove(jit::IonBuilder* builder) +{ + MOZ_ASSERT(TlsPerThreadData.get()->runtimeFromMainThread(), + "Should only be mutated by the main thread."); + MOZ_ASSERT(ionLazyLinkListSize_ > 0); + + builder->removeFrom(ionLazyLinkList()); + ionLazyLinkListSize_--; + + MOZ_ASSERT(ionLazyLinkList().isEmpty() == (ionLazyLinkListSize_ == 0)); +} + +void +JSRuntime::ionLazyLinkListAdd(jit::IonBuilder* builder) +{ + MOZ_ASSERT(TlsPerThreadData.get()->runtimeFromMainThread(), + "Should only be mutated by the main thread."); + ionLazyLinkList().insertFront(builder); + ionLazyLinkListSize_++; +} + +JSContext* +PerThreadData::contextFromMainThread() +{ + return runtime_->contextFromMainThread(); +} |