diff options
Diffstat (limited to 'js/src/vm/Runtime.h')
| -rw-r--r-- | js/src/vm/Runtime.h | 1175 |
1 files changed, 1175 insertions, 0 deletions
diff --git a/js/src/vm/Runtime.h b/js/src/vm/Runtime.h new file mode 100644 index 0000000000..934a534185 --- /dev/null +++ b/js/src/vm/Runtime.h @@ -0,0 +1,1175 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- + * vim: set ts=8 sts=2 et sw=2 tw=80: + * 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/. */ + +#ifndef vm_Runtime_h +#define vm_Runtime_h + +#include "mozilla/Assertions.h" // MOZ_ASSERT +#include "mozilla/Atomics.h" +#include "mozilla/Attributes.h" +#include "mozilla/DoublyLinkedList.h" +#include "mozilla/LinkedList.h" +#include "mozilla/Maybe.h" +#include "mozilla/MemoryReporting.h" +#include "mozilla/TimeStamp.h" +#include "mozilla/XorShift128PlusRNG.h" + +#include <algorithm> +#include <utility> + +#ifdef JS_HAS_INTL_API +# include "builtin/intl/SharedIntlData.h" +#endif +#include "frontend/ScriptIndex.h" +#include "gc/GCRuntime.h" +#include "js/AllocationRecording.h" +#include "js/BuildId.h" // JS::BuildIdOp +#include "js/Context.h" +#include "js/experimental/CTypes.h" // JS::CTypesActivityCallback +#include "js/friend/StackLimits.h" // js::ReportOverRecursed +#include "js/friend/UsageStatistics.h" // JSAccumulateTelemetryDataCallback +#include "js/GCVector.h" +#include "js/HashTable.h" +#include "js/Initialization.h" +#include "js/MemoryCallbacks.h" +#include "js/Modules.h" // JS::Module{DynamicImport,Metadata,Resolve}Hook +#include "js/ScriptPrivate.h" +#include "js/shadow/Zone.h" +#include "js/ShadowRealmCallbacks.h" +#include "js/Stack.h" +#include "js/StreamConsumer.h" +#include "js/Symbol.h" +#include "js/UniquePtr.h" +#include "js/Utility.h" +#include "js/WaitCallbacks.h" +#include "js/Warnings.h" // JS::WarningReporter +#include "js/Zone.h" +#include "vm/Caches.h" // js::RuntimeCaches +#include "vm/CodeCoverage.h" +#include "vm/GeckoProfiler.h" +#include "vm/InvalidatingFuse.h" +#include "vm/JSScript.h" +#include "vm/OffThreadPromiseRuntimeState.h" // js::OffThreadPromiseRuntimeState +#include "vm/SharedScriptDataTableHolder.h" // js::SharedScriptDataTableHolder +#include "vm/Stack.h" +#include "wasm/WasmTypeDecls.h" + +struct JSAtomState; +struct JSClass; +struct JSErrorInterceptor; +struct JSWrapObjectCallbacks; + +namespace js { + +class AutoAssertNoContentJS; +class Debugger; +class EnterDebuggeeNoExecute; +class FrontendContext; +class PlainObject; +class StaticStrings; + +} // namespace js + +struct DtoaState; +struct JSLocaleCallbacks; + +#ifdef JS_SIMULATOR_ARM64 +namespace vixl { +class Simulator; +} +#endif + +namespace js { + +extern MOZ_COLD void ReportOutOfMemory(JSContext* cx); +extern MOZ_COLD void ReportAllocationOverflow(JSContext* maybecx); +extern MOZ_COLD void ReportAllocationOverflow(FrontendContext* fc); +extern MOZ_COLD void ReportOversizedAllocation(JSContext* cx, + const unsigned errorNumber); + +class Activation; +class ActivationIterator; +class Shape; +class SourceHook; + +namespace jit { +class JitRuntime; +class JitActivation; +struct PcScriptCache; +class CompileRuntime; + +#ifdef JS_SIMULATOR_ARM64 +typedef vixl::Simulator Simulator; +#elif defined(JS_SIMULATOR) +class Simulator; +#endif +} // namespace jit + +namespace frontend { +struct CompilationInput; +struct CompilationStencil; +} // namespace frontend + +// [SMDOC] JS Engine Threading +// +// Threads interacting with a runtime are divided into two categories: +// +// - The main thread is capable of running JS. There's at most one main thread +// per runtime. +// +// - Helper threads do not run JS, and are controlled or triggered by activity +// on the main thread (or main threads, since all runtimes in a process share +// helper threads). Helper threads may have exclusive access to zones created +// for them, for parsing and similar tasks, but their activities do not cause +// observable changes in script behaviors. Activity on helper threads may be +// referred to as happening 'off thread' or on a background thread in some +// parts of the VM. + +} /* namespace js */ + +namespace JS { +struct RuntimeSizes; +} // namespace JS + +namespace js { + +/* + * Storage for well-known symbols. It's a separate struct from the Runtime so + * that it can be shared across multiple runtimes. As in JSAtomState, each + * field is a smart pointer that's immutable once initialized. + * `rt->wellKnownSymbols->iterator` is convertible to Handle<Symbol*>. + * + * Well-known symbols are never GC'd. The description() of each well-known + * symbol is a permanent atom. + */ +struct WellKnownSymbols { +#define DECLARE_SYMBOL(name) ImmutableTenuredPtr<JS::Symbol*> name; + JS_FOR_EACH_WELL_KNOWN_SYMBOL(DECLARE_SYMBOL) +#undef DECLARE_SYMBOL + + const ImmutableTenuredPtr<JS::Symbol*>& get(size_t u) const { + MOZ_ASSERT(u < JS::WellKnownSymbolLimit); + const ImmutableTenuredPtr<JS::Symbol*>* symbols = + reinterpret_cast<const ImmutableTenuredPtr<JS::Symbol*>*>(this); + return symbols[u]; + } + + const ImmutableTenuredPtr<JS::Symbol*>& get(JS::SymbolCode code) const { + return get(size_t(code)); + } + + WellKnownSymbols() = default; + WellKnownSymbols(const WellKnownSymbols&) = delete; + WellKnownSymbols& operator=(const WellKnownSymbols&) = delete; +}; + +// There are several coarse locks in the enum below. These may be either +// per-runtime or per-process. When acquiring more than one of these locks, +// the acquisition must be done in the order below to avoid deadlocks. +enum RuntimeLock { HelperThreadStateLock, GCLock }; + +inline bool CanUseExtraThreads() { + extern bool gCanUseExtraThreads; + return gCanUseExtraThreads; +} + +void DisableExtraThreads(); + +using ScriptAndCountsVector = GCVector<ScriptAndCounts, 0, SystemAllocPolicy>; + +class AutoLockScriptData; + +// Self-hosted lazy functions do not maintain a BaseScript as we can clone from +// the copy in the self-hosting zone. To allow these functions to be called by +// the JITs, we need a minimal script object. There is one instance per runtime. +struct SelfHostedLazyScript { + SelfHostedLazyScript() = default; + + // Pointer to interpreter trampoline. This field is stored at same location as + // in BaseScript::jitCodeRaw_. + uint8_t* jitCodeRaw_ = nullptr; + + // Warm-up count of zero. This field is stored at the same offset as + // BaseScript::warmUpData_. + ScriptWarmUpData warmUpData_ = {}; + + static constexpr size_t offsetOfJitCodeRaw() { + return offsetof(SelfHostedLazyScript, jitCodeRaw_); + } + static constexpr size_t offsetOfWarmUpData() { + return offsetof(SelfHostedLazyScript, warmUpData_); + } +}; + +// An interface for reporting telemetry from within SpiderMonkey. Reporting data +// to this interface will forward it to the embedding if a telemetry callback +// was registered. It is the embedding's responsibility to store and/or combine +// repeated samples for each metric. +class Metrics { + private: + JSRuntime* rt_; + + public: + explicit Metrics(JSRuntime* rt) : rt_(rt) {} + + // Records a TimeDuration metric. These are converted to integers when being + // recorded so choose an appropriate scale. In the future these will be Glean + // Timing Distribution metrics. + struct TimeDuration_S { + using SourceType = mozilla::TimeDuration; + static uint32_t convert(SourceType td) { return uint32_t(td.ToSeconds()); } + }; + struct TimeDuration_MS { + using SourceType = mozilla::TimeDuration; + static uint32_t convert(SourceType td) { + return uint32_t(td.ToMilliseconds()); + } + }; + struct TimeDuration_US { + using SourceType = mozilla::TimeDuration; + static uint32_t convert(SourceType td) { + return uint32_t(td.ToMicroseconds()); + } + }; + + // Record a metric in bytes. In the future these will be Glean Memory + // Distribution metrics. + struct MemoryDistribution { + using SourceType = size_t; + static uint32_t convert(SourceType sz) { + return static_cast<uint32_t>(std::min(sz, size_t(UINT32_MAX))); + } + }; + + // Record a metric for a quanity of items. This doesn't currently have a Glean + // analogue and we avoid using MemoryDistribution directly to avoid confusion + // about units. + using QuantityDistribution = MemoryDistribution; + + // Record the distribution of boolean values. In the future this will be a + // Glean Rate metric. + struct Boolean { + using SourceType = bool; + static uint32_t convert(SourceType sample) { + return static_cast<uint32_t>(sample); + } + }; + + // Record the distribution of an enumeration value. This records integer + // values so take care not to redefine the value of enum values. In the + // future, these should become Glean Labeled Counter metrics. + struct Enumeration { + using SourceType = unsigned int; + static uint32_t convert(SourceType sample) { + MOZ_ASSERT(sample <= 100); + return static_cast<uint32_t>(sample); + } + }; + + // Record a percentage distribution in the range 0 to 100. This takes a double + // and converts it to an integer. In the future, this will be a Glean Custom + // Distribution unless they add a better match. + struct Percentage { + using SourceType = double; + static uint32_t convert(SourceType sample) { + MOZ_ASSERT(sample >= 0.0 && sample <= 100.0); + return static_cast<uint32_t>(sample); + } + }; + + // Record an unsigned integer. + struct Integer { + using SourceType = uint32_t; + static uint32_t convert(SourceType sample) { return sample; } + }; + + inline void addTelemetry(JSMetric id, uint32_t sample); + +#define DECLARE_METRIC_HELPER(NAME, TY) \ + void NAME(TY::SourceType sample) { \ + addTelemetry(JSMetric::NAME, TY::convert(sample)); \ + } + FOR_EACH_JS_METRIC(DECLARE_METRIC_HELPER) +#undef DECLARE_METRIC_HELPER +}; + +class HasSeenObjectEmulateUndefinedFuse : public js::InvalidatingRuntimeFuse { + virtual const char* name() override { + return "HasSeenObjectEmulateUndefinedFuse"; + } + virtual bool checkInvariant(JSContext* cx) override { + // Without traversing the GC heap I don't think it's possible to assert + // this invariant directly. + return true; + } +}; + +} // namespace js + +struct JSRuntime { + private: + friend class js::Activation; + friend class js::ActivationIterator; + friend class js::jit::JitActivation; + friend class js::jit::CompileRuntime; + + /* Space for interpreter frames. */ + js::MainThreadData<js::InterpreterStack> interpreterStack_; + +#ifdef ENABLE_PORTABLE_BASELINE_INTERP + /* Space for portable baseline interpreter frames. */ + js::MainThreadData<js::PortableBaselineStack> portableBaselineStack_; +#endif + + public: + js::InterpreterStack& interpreterStack() { return interpreterStack_.ref(); } +#ifdef ENABLE_PORTABLE_BASELINE_INTERP + js::PortableBaselineStack& portableBaselineStack() { + return portableBaselineStack_.ref(); + } +#endif + + /* + * If non-null, another runtime guaranteed to outlive this one and whose + * permanent data may be used by this one where possible. + */ + JSRuntime* const parentRuntime; + + bool isMainRuntime() const { return !parentRuntime; } + +#ifdef DEBUG + /* The number of child runtimes that have this runtime as their parent. */ + mozilla::Atomic<size_t> childRuntimeCount; + + class AutoUpdateChildRuntimeCount { + JSRuntime* parent_; + + public: + explicit AutoUpdateChildRuntimeCount(JSRuntime* parent) : parent_(parent) { + if (parent_) { + parent_->childRuntimeCount++; + } + } + + ~AutoUpdateChildRuntimeCount() { + if (parent_) { + parent_->childRuntimeCount--; + } + } + }; + + AutoUpdateChildRuntimeCount updateChildRuntimeCount; +#endif + + private: +#ifdef DEBUG + js::WriteOnceData<bool> initialized_; +#endif + + // The JSContext* for the runtime's main thread. Immutable after this is set + // in JSRuntime::init. + JSContext* mainContext_; + + public: + JSContext* mainContextFromAnyThread() const { return mainContext_; } + const void* addressOfMainContext() { return &mainContext_; } + js::Fprinter parserWatcherFile; + + inline JSContext* mainContextFromOwnThread(); + + js::Metrics metrics() { return js::Metrics(this); } + + /* + * The start of the range stored in the profiler sample buffer, as measured + * after the most recent sample. + * All JitcodeGlobalTable entries referenced from a given sample are + * assigned the buffer position of the START of the sample. The buffer + * entries that reference the JitcodeGlobalTable entries will only ever be + * read from the buffer while the entire sample is still inside the buffer; + * if some buffer entries at the start of the sample have left the buffer, + * the entire sample will be considered inaccessible. + * This means that, once profilerSampleBufferRangeStart_ advances beyond + * the sample position that's stored on a JitcodeGlobalTable entry, the + * buffer entries that reference this JitcodeGlobalTable entry will be + * considered inaccessible, and those JitcodeGlobalTable entry can be + * disposed of. + */ + mozilla::Atomic<uint64_t, mozilla::ReleaseAcquire> + profilerSampleBufferRangeStart_; + + mozilla::Maybe<uint64_t> profilerSampleBufferRangeStart() { + if (beingDestroyed_ || !geckoProfiler().enabled()) { + return mozilla::Nothing(); + } + uint64_t rangeStart = profilerSampleBufferRangeStart_; + return mozilla::Some(rangeStart); + } + void setProfilerSampleBufferRangeStart(uint64_t rangeStart) { + profilerSampleBufferRangeStart_ = rangeStart; + } + + /* Call this to accumulate telemetry data. May be called from any thread; the + * embedder is responsible for locking. */ + JSAccumulateTelemetryDataCallback telemetryCallback; + + /* Call this to accumulate use counter data. */ + js::MainThreadData<JSSetUseCounterCallback> useCounterCallback; + + public: + // Accumulates data for Firefox telemetry. + void addTelemetry(JSMetric id, uint32_t sample); + + void setTelemetryCallback(JSRuntime* rt, + JSAccumulateTelemetryDataCallback callback); + + // Sets the use counter for a specific feature, measuring the presence or + // absence of usage of a feature on a specific web page and document which + // the passed JSObject belongs to. + void setUseCounter(JSObject* obj, JSUseCounter counter); + + void setUseCounterCallback(JSRuntime* rt, JSSetUseCounterCallback callback); + + public: + js::UnprotectedData<js::OffThreadPromiseRuntimeState> offThreadPromiseState; + js::UnprotectedData<JS::ConsumeStreamCallback> consumeStreamCallback; + js::UnprotectedData<JS::ReportStreamErrorCallback> reportStreamErrorCallback; + + js::GlobalObject* getIncumbentGlobal(JSContext* cx); + bool enqueuePromiseJob(JSContext* cx, js::HandleFunction job, + js::HandleObject promise, + js::Handle<js::GlobalObject*> incumbentGlobal); + void addUnhandledRejectedPromise(JSContext* cx, js::HandleObject promise); + void removeUnhandledRejectedPromise(JSContext* cx, js::HandleObject promise); + + /* Had an out-of-memory error which did not populate an exception. */ + mozilla::Atomic<bool, mozilla::SequentiallyConsistent> hadOutOfMemory; + + /* + * Allow relazifying functions in compartments that are active. This is + * only used by the relazifyFunctions() testing function. + */ + js::MainThreadData<bool> allowRelazificationForTesting; + + /* Zone destroy callback. */ + js::MainThreadData<JSDestroyZoneCallback> destroyZoneCallback; + + /* Compartment destroy callback. */ + js::MainThreadData<JSDestroyCompartmentCallback> destroyCompartmentCallback; + + /* Compartment memory reporting callback. */ + js::MainThreadData<JSSizeOfIncludingThisCompartmentCallback> + sizeOfIncludingThisCompartmentCallback; + + /* Callback for creating ubi::Nodes representing DOM node objects. Set by + * JS::ubi::SetConstructUbiNodeForDOMObjectCallback. Refer to + * js/public/UbiNode.h. + */ + void (*constructUbiNodeForDOMObjectCallback)(void*, JSObject*) = nullptr; + + /* Realm destroy callback. */ + js::MainThreadData<JS::DestroyRealmCallback> destroyRealmCallback; + + /* Call this to get the name of a realm. */ + js::MainThreadData<JS::RealmNameCallback> realmNameCallback; + + js::MainThreadData<mozilla::UniquePtr<js::SourceHook>> sourceHook; + + js::MainThreadData<const JSSecurityCallbacks*> securityCallbacks; + js::MainThreadData<const js::DOMCallbacks*> DOMcallbacks; + js::MainThreadData<JSDestroyPrincipalsOp> destroyPrincipals; + js::MainThreadData<JSReadPrincipalsOp> readPrincipals; + + js::MainThreadData<JS::EnsureCanAddPrivateElementOp> canAddPrivateElement; + + /* Optional warning reporter. */ + js::MainThreadData<JS::WarningReporter> warningReporter; + + // Lazy self-hosted functions use a shared SelfHostedLazyScript instance + // instead instead of a BaseScript. This contains the minimal pointers to + // trampolines for the scripts to support direct jitCodeRaw calls. + js::UnprotectedData<js::SelfHostedLazyScript> selfHostedLazyScript; + + private: + // The self-hosted JS code is compiled as a Stencil which is then attached to + // the Runtime. This is used to instantiate functions into realms on demand. + js::WriteOnceData<js::frontend::CompilationInput*> selfHostStencilInput_; + js::WriteOnceData<js::frontend::CompilationStencil*> selfHostStencil_; + + public: + // The self-hosted stencil is immutable once attached to the runtime, so + // worker runtimes directly use the stencil on the parent runtime. + js::frontend::CompilationInput& selfHostStencilInput() { + MOZ_ASSERT(hasSelfHostStencil()); + return *selfHostStencilInput_.ref(); + } + js::frontend::CompilationStencil& selfHostStencil() { + MOZ_ASSERT(hasSelfHostStencil()); + return *selfHostStencil_.ref(); + } + bool hasSelfHostStencil() const { return bool(selfHostStencil_.ref()); } + + // A mapping from the name of self-hosted function to a ScriptIndex range of + // the function and inner-functions within the self-hosted stencil. + js::MainThreadData< + JS::GCHashMap<js::PreBarriered<JSAtom*>, js::frontend::ScriptIndexRange, + js::DefaultHasher<JSAtom*>, js::SystemAllocPolicy>> + selfHostScriptMap; + + private: + /* Gecko profiling metadata */ + js::UnprotectedData<js::GeckoProfilerRuntime> geckoProfiler_; + + public: + js::GeckoProfilerRuntime& geckoProfiler() { return geckoProfiler_.ref(); } + + // Heap GC roots for PersistentRooted pointers. + js::MainThreadData< + mozilla::EnumeratedArray<JS::RootKind, JS::RootKind::Limit, + mozilla::LinkedList<js::PersistentRootedBase>>> + heapRoots; + + void tracePersistentRoots(JSTracer* trc); + void finishPersistentRoots(); + + void finishRoots(); + + private: + js::UnprotectedData<const JSPrincipals*> trustedPrincipals_; + + public: + void setTrustedPrincipals(const JSPrincipals* p) { trustedPrincipals_ = p; } + const JSPrincipals* trustedPrincipals() const { return trustedPrincipals_; } + + js::MainThreadData<const JSWrapObjectCallbacks*> wrapObjectCallbacks; + js::MainThreadData<js::PreserveWrapperCallback> preserveWrapperCallback; + js::MainThreadData<js::HasReleasedWrapperCallback> hasReleasedWrapperCallback; + + js::MainThreadData<js::ScriptEnvironmentPreparer*> scriptEnvironmentPreparer; + + js::MainThreadData<JS::CTypesActivityCallback> ctypesActivityCallback; + + private: + js::WriteOnceData<const JSClass*> windowProxyClass_; + + public: + const JSClass* maybeWindowProxyClass() const { return windowProxyClass_; } + void setWindowProxyClass(const JSClass* clasp) { windowProxyClass_ = clasp; } + + private: + // List of non-ephemeron weak containers to sweep during + // beginSweepingSweepGroup. + js::MainThreadData<mozilla::LinkedList<js::gc::WeakCacheBase>> weakCaches_; + + public: + mozilla::LinkedList<js::gc::WeakCacheBase>& weakCaches() { + return weakCaches_.ref(); + } + void registerWeakCache(js::gc::WeakCacheBase* cachep) { + weakCaches().insertBack(cachep); + } + + template <typename T> + struct GlobalObjectWatchersLinkAccess { + static mozilla::DoublyLinkedListElement<T>& Get(T* aThis) { + return aThis->onNewGlobalObjectWatchersLink; + } + }; + + template <typename T> + struct GarbageCollectionWatchersLinkAccess { + static mozilla::DoublyLinkedListElement<T>& Get(T* aThis) { + return aThis->onGarbageCollectionWatchersLink; + } + }; + + using OnNewGlobalWatchersList = + mozilla::DoublyLinkedList<js::Debugger, + GlobalObjectWatchersLinkAccess<js::Debugger>>; + using OnGarbageCollectionWatchersList = mozilla::DoublyLinkedList< + js::Debugger, GarbageCollectionWatchersLinkAccess<js::Debugger>>; + + private: + /* + * List of all enabled Debuggers that have onNewGlobalObject handler + * methods established. + */ + js::MainThreadData<OnNewGlobalWatchersList> onNewGlobalObjectWatchers_; + + /* + * List of all enabled Debuggers that have onGarbageCollection handler + * methods established. + */ + js::MainThreadData<OnGarbageCollectionWatchersList> + onGarbageCollectionWatchers_; + + public: + OnNewGlobalWatchersList& onNewGlobalObjectWatchers() { + return onNewGlobalObjectWatchers_.ref(); + } + + OnGarbageCollectionWatchersList& onGarbageCollectionWatchers() { + return onGarbageCollectionWatchers_.ref(); + } + + private: + /* Linked list of all Debugger objects in the runtime. */ + js::MainThreadData<mozilla::LinkedList<js::Debugger>> debuggerList_; + + public: + mozilla::LinkedList<js::Debugger>& debuggerList() { + return debuggerList_.ref(); + } + + public: + JS::HeapState heapState() const { return gc.heapState(); } + + // How many realms there are across all zones. This number includes + // off-thread context realms, so it isn't necessarily equal to the + // number of realms visited by RealmsIter. + js::MainThreadData<size_t> numRealms; + + // The Gecko Profiler may want to sample the allocations happening across the + // browser. This callback can be registered to record the allocation. + js::MainThreadData<JS::RecordAllocationsCallback> recordAllocationCallback; + js::MainThreadData<double> allocationSamplingProbability; + + private: + // Number of debuggee realms in the runtime. + js::MainThreadData<size_t> numDebuggeeRealms_; + + // Number of debuggee realms in the runtime observing code coverage. + js::MainThreadData<size_t> numDebuggeeRealmsObservingCoverage_; + + public: + void incrementNumDebuggeeRealms(); + void decrementNumDebuggeeRealms(); + + size_t numDebuggeeRealms() const { return numDebuggeeRealms_; } + + void incrementNumDebuggeeRealmsObservingCoverage(); + void decrementNumDebuggeeRealmsObservingCoverage(); + + void startRecordingAllocations(double probability, + JS::RecordAllocationsCallback callback); + void stopRecordingAllocations(); + void ensureRealmIsRecordingAllocations(JS::Handle<js::GlobalObject*> global); + + /* Locale-specific callbacks for string conversion. */ + js::MainThreadData<const JSLocaleCallbacks*> localeCallbacks; + + /* Default locale for Internationalization API */ + js::MainThreadData<js::UniqueChars> defaultLocale; + + /* If true, new scripts must be created with PC counter information. */ + js::MainThreadOrIonCompileData<bool> profilingScripts; + + /* Strong references on scripts held for PCCount profiling API. */ + js::MainThreadData<JS::PersistentRooted<js::ScriptAndCountsVector>*> + scriptAndCountsVector; + + using RootedPlainObjVec = JS::PersistentRooted< + JS::GCVector<js::PlainObject*, 0, js::SystemAllocPolicy>>; + js::MainThreadData<js::UniquePtr<RootedPlainObjVec>> watchtowerTestingLog; + + private: + /* Code coverage output. */ + js::UnprotectedData<js::coverage::LCovRuntime> lcovOutput_; + + /* Functions to call, together with data, when the runtime is being torn down. + */ + js::MainThreadData<mozilla::Vector<std::pair<void (*)(void*), void*>, 4>> + cleanupClosures; + + public: + js::coverage::LCovRuntime& lcovOutput() { return lcovOutput_.ref(); } + + /* Register a cleanup function to be called during runtime shutdown. Do not + * depend on the ordering of cleanup calls. */ + bool atExit(void (*function)(void*), void* data) { + return cleanupClosures.ref().append(std::pair(function, data)); + } + + private: + js::UnprotectedData<js::jit::JitRuntime*> jitRuntime_; + + public: + mozilla::Maybe<js::frontend::ScriptIndexRange> getSelfHostedScriptIndexRange( + js::PropertyName* name); + + [[nodiscard]] bool createJitRuntime(JSContext* cx); + js::jit::JitRuntime* jitRuntime() const { return jitRuntime_.ref(); } + bool hasJitRuntime() const { return !!jitRuntime_; } + + private: + // Used to generate random keys for hash tables. + mozilla::Maybe<mozilla::non_crypto::XorShift128PlusRNG> randomKeyGenerator_; + mozilla::non_crypto::XorShift128PlusRNG& randomKeyGenerator(); + + // Used to generate random hash codes for symbols. + mozilla::Maybe<mozilla::non_crypto::XorShift128PlusRNG> + randomHashCodeGenerator_; + + public: + mozilla::HashCodeScrambler randomHashCodeScrambler(); + mozilla::non_crypto::XorShift128PlusRNG forkRandomKeyGenerator(); + + js::HashNumber randomHashCode(); + + //------------------------------------------------------------------------- + // Self-hosting support + //------------------------------------------------------------------------- + + bool hasInitializedSelfHosting() const { return hasSelfHostStencil(); } + + bool initSelfHostingStencil(JSContext* cx, JS::SelfHostedCache xdrCache, + JS::SelfHostedWriter xdrWriter); + bool initSelfHostingFromStencil(JSContext* cx); + void finishSelfHosting(); + void traceSelfHostingStencil(JSTracer* trc); + js::GeneratorKind getSelfHostedFunctionGeneratorKind(js::PropertyName* name); + bool delazifySelfHostedFunction(JSContext* cx, + js::Handle<js::PropertyName*> name, + js::Handle<JSFunction*> targetFun); + bool getSelfHostedValue(JSContext* cx, js::Handle<js::PropertyName*> name, + js::MutableHandleValue vp); + void assertSelfHostedFunctionHasCanonicalName( + JS::Handle<js::PropertyName*> name); + + private: + void setSelfHostingStencil( + JS::MutableHandle<js::UniquePtr<js::frontend::CompilationInput>> input, + RefPtr<js::frontend::CompilationStencil>&& stencil); + + //------------------------------------------------------------------------- + // Locale information + //------------------------------------------------------------------------- + + public: + /* + * Set the default locale for the ECMAScript Internationalization API + * (Intl.Collator, Intl.NumberFormat, Intl.DateTimeFormat). + * Note that the Internationalization API encourages clients to + * specify their own locales. + * The locale string remains owned by the caller. + */ + bool setDefaultLocale(const char* locale); + + /* Reset the default locale to OS defaults. */ + void resetDefaultLocale(); + + /* Gets current default locale. String remains owned by context. */ + const char* getDefaultLocale(); + + /* Garbage collector state. */ + js::gc::GCRuntime gc; + + /* Garbage collector state has been successfully initialized. */ + + bool hasZealMode(js::gc::ZealMode mode) { return gc.hasZealMode(mode); } + + void lockGC() { gc.lockGC(); } + + void unlockGC() { gc.unlockGC(); } + + js::WriteOnceData<js::PropertyName*> emptyString; + + public: + JS::GCContext* gcContext() { return &gc.mainThreadContext.ref(); } + +#if !JS_HAS_INTL_API + /* Number localization, used by jsnum.cpp. */ + js::WriteOnceData<const char*> thousandsSeparator; + js::WriteOnceData<const char*> decimalSeparator; + js::WriteOnceData<const char*> numGrouping; +#endif + + private: + js::WriteOnceData<bool> beingDestroyed_; + + public: + bool isBeingDestroyed() const { return beingDestroyed_; } + + private: + bool allowContentJS_; + + public: + bool allowContentJS() const { return allowContentJS_; } + + friend class js::AutoAssertNoContentJS; + + private: + // Table of all atoms other than those in permanentAtoms and staticStrings. + js::WriteOnceData<js::AtomsTable*> atoms_; + + // Set of all live symbols produced by Symbol.for(). All such symbols are + // allocated in the atoms zone. Reading or writing the symbol registry + // can only be done from the main thread. + js::MainThreadOrGCTaskData<js::SymbolRegistry> symbolRegistry_; + + js::WriteOnceData<js::FrozenAtomSet*> permanentAtoms_; + + public: + bool initializeAtoms(JSContext* cx); + void finishAtoms(); + bool atomsAreFinished() const { return !atoms_; } + + js::AtomsTable* atomsForSweeping() { + MOZ_ASSERT(JS::RuntimeHeapIsCollecting()); + return atoms_; + } + + js::AtomsTable& atoms() { + MOZ_ASSERT(atoms_); + return *atoms_; + } + + JS::Zone* atomsZone() { + MOZ_ASSERT(js::CurrentThreadCanAccessRuntime(this)); + return unsafeAtomsZone(); + } + JS::Zone* unsafeAtomsZone() { return gc.atomsZone(); } + +#ifdef DEBUG + bool isAtomsZone(const JS::Zone* zone) const { + return JS::shadow::Zone::from(zone)->isAtomsZone(); + } +#endif + + bool activeGCInAtomsZone(); + + js::SymbolRegistry& symbolRegistry() { return symbolRegistry_.ref(); } + + // Permanent atoms are fixed during initialization of the runtime and are + // not modified or collected until the runtime is destroyed. These may be + // shared with another, longer living runtime through |parentRuntime| and + // can be freely accessed with no locking necessary. + + // Permanent atoms pre-allocated for general use. + js::WriteOnceData<js::StaticStrings*> staticStrings; + + // Cached pointers to various permanent property names. + js::WriteOnceData<JSAtomState*> commonNames; + + // All permanent atoms in the runtime, other than those in staticStrings. + // Access to this does not require a lock because it is frozen and thus + // read-only. + const js::FrozenAtomSet* permanentAtoms() const { + MOZ_ASSERT(permanentAtomsPopulated()); + return permanentAtoms_.ref(); + } + + // The permanent atoms table is populated during initialization. + bool permanentAtomsPopulated() const { return permanentAtoms_; } + + // Cached well-known symbols (ES6 rev 24 6.1.5.1). Like permanent atoms, + // these are shared with the parentRuntime, if any. + js::WriteOnceData<js::WellKnownSymbols*> wellKnownSymbols; + +#ifdef JS_HAS_INTL_API + /* Shared Intl data for this runtime. */ + js::MainThreadData<js::intl::SharedIntlData> sharedIntlData; + + void traceSharedIntlData(JSTracer* trc); +#endif + + private: + js::SharedScriptDataTableHolder scriptDataTableHolder_; + + public: + // Returns the runtime's local script data table holder. + js::SharedScriptDataTableHolder& scriptDataTableHolder(); + + private: + static mozilla::Atomic<size_t> liveRuntimesCount; + + public: + static bool hasLiveRuntimes() { return liveRuntimesCount > 0; } + static bool hasSingleLiveRuntime() { return liveRuntimesCount == 1; } + + explicit JSRuntime(JSRuntime* parentRuntime); + ~JSRuntime(); + + // destroyRuntime is used instead of a destructor, to ensure the downcast + // to JSContext remains valid. The final GC triggered here depends on this. + void destroyRuntime(); + + bool init(JSContext* cx, uint32_t maxbytes); + + JSRuntime* thisFromCtor() { return this; } + + private: + // Number of live SharedArrayBuffer objects, including those in Wasm shared + // memories. uint64_t to avoid any risk of overflow. + js::MainThreadData<uint64_t> liveSABs; + + public: + void incSABCount() { + MOZ_RELEASE_ASSERT(liveSABs != UINT64_MAX); + liveSABs++; + } + + void decSABCount() { + MOZ_RELEASE_ASSERT(liveSABs > 0); + liveSABs--; + } + + bool hasLiveSABs() const { return liveSABs > 0; } + + public: + js::MainThreadData<JS::BeforeWaitCallback> beforeWaitCallback; + js::MainThreadData<JS::AfterWaitCallback> afterWaitCallback; + + public: + void reportAllocationOverflow() { + js::ReportAllocationOverflow(static_cast<JSContext*>(nullptr)); + } + + /* + * This should be called after system malloc/calloc/realloc returns nullptr + * to try to recove some memory or to report an error. For realloc, the + * original pointer must be passed as reallocPtr. + * + * The function must be called outside the GC lock. + */ + JS_PUBLIC_API void* onOutOfMemory(js::AllocFunction allocator, + arena_id_t arena, size_t nbytes, + void* reallocPtr = nullptr, + JSContext* maybecx = nullptr); + + /* onOutOfMemory but can call OnLargeAllocationFailure. */ + JS_PUBLIC_API void* onOutOfMemoryCanGC(js::AllocFunction allocator, + arena_id_t arena, size_t nbytes, + void* reallocPtr = nullptr); + + static const unsigned LARGE_ALLOCATION = 25 * 1024 * 1024; + + void addSizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf, + JS::RuntimeSizes* rtSizes); + + private: + // Settings for how helper threads can be used. + mozilla::Atomic<bool, mozilla::SequentiallyConsistent> + offthreadIonCompilationEnabled_; + mozilla::Atomic<bool, mozilla::SequentiallyConsistent> + parallelParsingEnabled_; + + js::MainThreadData<bool> autoWritableJitCodeActive_; + + public: + // Note: these values may be toggled dynamically (in response to about:config + // prefs changing). + void setOffthreadIonCompilationEnabled(bool value) { + offthreadIonCompilationEnabled_ = value; + } + bool canUseOffthreadIonCompilation() const { + return offthreadIonCompilationEnabled_; + } + void setParallelParsingEnabled(bool value) { + parallelParsingEnabled_ = value; + } + bool canUseParallelParsing() const { return parallelParsingEnabled_; } + + void toggleAutoWritableJitCodeActive(bool b) { + MOZ_ASSERT(autoWritableJitCodeActive_ != b, + "AutoWritableJitCode should not be nested."); + autoWritableJitCodeActive_ = b; + } + + /* See comment for JS::SetOutOfMemoryCallback in js/MemoryCallbacks.h. */ + js::MainThreadData<JS::OutOfMemoryCallback> oomCallback; + js::MainThreadData<void*> oomCallbackData; + + /* + * Debugger.Memory functions like takeCensus use this embedding-provided + * function to assess the size of malloc'd blocks of memory. + */ + js::MainThreadData<mozilla::MallocSizeOf> debuggerMallocSizeOf; + + /* Last time at which an animation was played for this runtime. */ + js::MainThreadData<mozilla::TimeStamp> lastAnimationTime; + + private: + /* The stack format for the current runtime. Only valid on non-child + * runtimes. */ + mozilla::Atomic<js::StackFormat, mozilla::ReleaseAcquire> stackFormat_; + + public: + js::StackFormat stackFormat() const { + const JSRuntime* rt = this; + while (rt->parentRuntime) { + MOZ_ASSERT(rt->stackFormat_ == js::StackFormat::Default); + rt = rt->parentRuntime; + } + MOZ_ASSERT(rt->stackFormat_ != js::StackFormat::Default); + return rt->stackFormat_; + } + void setStackFormat(js::StackFormat format) { + MOZ_ASSERT(!parentRuntime); + MOZ_ASSERT(format != js::StackFormat::Default); + stackFormat_ = format; + } + + private: + // Warning: no data should be accessed in these caches from another thread, + // but Ion needs to be able to access addresses inside here, which should be + // safe, as the actual cache lookups will be performed on the main thread + // through jitted code. + js::MainThreadOrIonCompileData<js::RuntimeCaches> caches_; + + public: + js::RuntimeCaches& caches() { return caches_.ref(); } + + // List of all the live wasm::Instances in the runtime. Equal to the union + // of all instances registered in all JS::Realms. Accessed from watchdog + // threads for purposes of wasm::InterruptRunningCode(). + js::ExclusiveData<js::wasm::InstanceVector> wasmInstances; + + // A counter used when recording the order in which modules had their + // AsyncEvaluation field set to true. This is used to order queued + // evaluations. This is reset when the last module that was async evaluating + // is finished. + // + // See https://tc39.es/ecma262/#sec-async-module-execution-fulfilled step 10 + // for use. + js::MainThreadData<uint32_t> moduleAsyncEvaluatingPostOrder; + + // The implementation-defined abstract operation HostResolveImportedModule. + js::MainThreadData<JS::ModuleResolveHook> moduleResolveHook; + + // A hook that implements the abstract operations + // HostGetImportMetaProperties and HostFinalizeImportMeta. + js::MainThreadData<JS::ModuleMetadataHook> moduleMetadataHook; + + // A hook that implements the abstract operation + // HostImportModuleDynamically. This is also used to enable/disable dynamic + // module import and can accessed by off-thread parsing. + mozilla::Atomic<JS::ModuleDynamicImportHook> moduleDynamicImportHook; + + // Hooks called when script private references are created and destroyed. + js::MainThreadData<JS::ScriptPrivateReferenceHook> scriptPrivateAddRefHook; + js::MainThreadData<JS::ScriptPrivateReferenceHook> scriptPrivateReleaseHook; + + void addRefScriptPrivate(const JS::Value& value) { + if (!value.isUndefined() && scriptPrivateAddRefHook) { + scriptPrivateAddRefHook(value); + } + } + + void releaseScriptPrivate(const JS::Value& value) { + if (!value.isUndefined() && scriptPrivateReleaseHook) { + scriptPrivateReleaseHook(value); + } + } + + public: +#if defined(NIGHTLY_BUILD) + // Support for informing the embedding of any error thrown. + // This mechanism is designed to let the embedding + // log/report/fail in case certain errors are thrown + // (e.g. SyntaxError, ReferenceError or TypeError + // in critical code). + struct ErrorInterceptionSupport { + ErrorInterceptionSupport() : isExecuting(false), interceptor(nullptr) {} + + // true if the error interceptor is currently executing, + // false otherwise. Used to avoid infinite loops. + bool isExecuting; + + // if non-null, any call to `setPendingException` + // in this runtime will trigger the call to `interceptor` + JSErrorInterceptor* interceptor; + }; + ErrorInterceptionSupport errorInterception; +#endif // defined(NIGHTLY_BUILD) + + public: + JS::GlobalInitializeCallback getShadowRealmInitializeGlobalCallback() { + return shadowRealmInitializeGlobalCallback; + } + + JS::GlobalCreationCallback getShadowRealmGlobalCreationCallback() { + return shadowRealmGlobalCreationCallback; + } + + js::MainThreadData<JS::GlobalInitializeCallback> + shadowRealmInitializeGlobalCallback; + + js::MainThreadData<JS::GlobalCreationCallback> + shadowRealmGlobalCreationCallback; + + js::MainThreadData<js::HasSeenObjectEmulateUndefinedFuse> + hasSeenObjectEmulateUndefinedFuse; +}; + +namespace js { + +void Metrics::addTelemetry(JSMetric id, uint32_t sample) { + rt_->addTelemetry(id, sample); +} + +static MOZ_ALWAYS_INLINE void MakeRangeGCSafe(Value* vec, size_t len) { + // Don't PodZero here because JS::Value is non-trivial. + for (size_t i = 0; i < len; i++) { + vec[i].setDouble(+0.0); + } +} + +static MOZ_ALWAYS_INLINE void MakeRangeGCSafe(Value* beg, Value* end) { + MakeRangeGCSafe(beg, end - beg); +} + +static MOZ_ALWAYS_INLINE void MakeRangeGCSafe(jsid* beg, jsid* end) { + std::fill(beg, end, PropertyKey::Int(0)); +} + +static MOZ_ALWAYS_INLINE void MakeRangeGCSafe(jsid* vec, size_t len) { + MakeRangeGCSafe(vec, vec + len); +} + +static MOZ_ALWAYS_INLINE void MakeRangeGCSafe(Shape** beg, Shape** end) { + std::fill(beg, end, nullptr); +} + +static MOZ_ALWAYS_INLINE void MakeRangeGCSafe(Shape** vec, size_t len) { + MakeRangeGCSafe(vec, vec + len); +} + +static MOZ_ALWAYS_INLINE void SetValueRangeToUndefined(Value* beg, Value* end) { + for (Value* v = beg; v != end; ++v) { + v->setUndefined(); + } +} + +static MOZ_ALWAYS_INLINE void SetValueRangeToUndefined(Value* vec, size_t len) { + SetValueRangeToUndefined(vec, vec + len); +} + +static MOZ_ALWAYS_INLINE void SetValueRangeToNull(Value* beg, Value* end) { + for (Value* v = beg; v != end; ++v) { + v->setNull(); + } +} + +static MOZ_ALWAYS_INLINE void SetValueRangeToNull(Value* vec, size_t len) { + SetValueRangeToNull(vec, vec + len); +} + +extern const JSSecurityCallbacks NullSecurityCallbacks; + +// This callback is set by JS::SetProcessLargeAllocationFailureCallback +// and may be null. See comment in jsapi.h. +extern mozilla::Atomic<JS::LargeAllocationFailureCallback> + OnLargeAllocationFailure; + +// This callback is set by JS::SetBuildIdOp and may be null. See comment in +// jsapi.h. +extern mozilla::Atomic<JS::BuildIdOp> GetBuildId; + +extern JS::FilenameValidationCallback gFilenameValidationCallback; + +} /* namespace js */ + +#endif /* vm_Runtime_h */ |