summaryrefslogtreecommitdiffstats
path: root/js/src/jit/CompileWrappers.cpp
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 00:47:55 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 00:47:55 +0000
commit26a029d407be480d791972afb5975cf62c9360a6 (patch)
treef435a8308119effd964b339f76abb83a57c29483 /js/src/jit/CompileWrappers.cpp
parentInitial commit. (diff)
downloadfirefox-26a029d407be480d791972afb5975cf62c9360a6.tar.xz
firefox-26a029d407be480d791972afb5975cf62c9360a6.zip
Adding upstream version 124.0.1.upstream/124.0.1
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'js/src/jit/CompileWrappers.cpp')
-rw-r--r--js/src/jit/CompileWrappers.cpp235
1 files changed, 235 insertions, 0 deletions
diff --git a/js/src/jit/CompileWrappers.cpp b/js/src/jit/CompileWrappers.cpp
new file mode 100644
index 0000000000..a2c53e8052
--- /dev/null
+++ b/js/src/jit/CompileWrappers.cpp
@@ -0,0 +1,235 @@
+/* -*- 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/. */
+
+#include "jit/CompileWrappers.h"
+
+#include "gc/Heap.h"
+#include "gc/Zone.h"
+#include "jit/Ion.h"
+#include "jit/JitRuntime.h"
+#include "vm/Realm.h"
+
+using namespace js;
+using namespace js::jit;
+
+JSRuntime* CompileRuntime::runtime() {
+ return reinterpret_cast<JSRuntime*>(this);
+}
+
+/* static */
+CompileRuntime* CompileRuntime::get(JSRuntime* rt) {
+ return reinterpret_cast<CompileRuntime*>(rt);
+}
+
+#ifdef JS_GC_ZEAL
+const uint32_t* CompileRuntime::addressOfGCZealModeBits() {
+ return runtime()->gc.addressOfZealModeBits();
+}
+#endif
+
+const JitRuntime* CompileRuntime::jitRuntime() {
+ return runtime()->jitRuntime();
+}
+
+GeckoProfilerRuntime& CompileRuntime::geckoProfiler() {
+ return runtime()->geckoProfiler();
+}
+
+bool CompileRuntime::hadOutOfMemory() { return runtime()->hadOutOfMemory; }
+
+bool CompileRuntime::profilingScripts() { return runtime()->profilingScripts; }
+
+const JSAtomState& CompileRuntime::names() { return *runtime()->commonNames; }
+
+const PropertyName* CompileRuntime::emptyString() {
+ return runtime()->emptyString;
+}
+
+const StaticStrings& CompileRuntime::staticStrings() {
+ return *runtime()->staticStrings;
+}
+
+const WellKnownSymbols& CompileRuntime::wellKnownSymbols() {
+ return *runtime()->wellKnownSymbols;
+}
+
+const JSClass* CompileRuntime::maybeWindowProxyClass() {
+ return runtime()->maybeWindowProxyClass();
+}
+
+const void* CompileRuntime::mainContextPtr() {
+ return runtime()->mainContextFromAnyThread();
+}
+
+const void* CompileRuntime::addressOfJitStackLimit() {
+ return runtime()->mainContextFromAnyThread()->addressOfJitStackLimit();
+}
+
+const void* CompileRuntime::addressOfInterruptBits() {
+ return runtime()->mainContextFromAnyThread()->addressOfInterruptBits();
+}
+
+const void* CompileRuntime::addressOfZone() {
+ return runtime()->mainContextFromAnyThread()->addressOfZone();
+}
+
+const void* CompileRuntime::addressOfMegamorphicCache() {
+ return &runtime()->caches().megamorphicCache;
+}
+
+const void* CompileRuntime::addressOfMegamorphicSetPropCache() {
+ return runtime()->caches().megamorphicSetPropCache.get();
+}
+
+const void* CompileRuntime::addressOfStringToAtomCache() {
+ return &runtime()->caches().stringToAtomCache;
+}
+
+const void* CompileRuntime::addressOfLastBufferedWholeCell() {
+ return runtime()->gc.addressOfLastBufferedWholeCell();
+}
+
+const void* CompileRuntime::addressOfHasSeenObjectEmulateUndefinedFuse() {
+ // We're merely accessing the address of the fuse here, and so we don't need
+ // the MainThreadData check here.
+ return runtime()->hasSeenObjectEmulateUndefinedFuse.refNoCheck().fuseRef();
+}
+
+bool CompileRuntime::hasSeenObjectEmulateUndefinedFuseIntact() {
+ // Note: This accesses the bit; this would be unsafe off-thread, however
+ // this should only be accessed by CompileInfo in its constructor on main
+ // thread and so should be safe.
+ //
+ // (This value is also checked by ref() rather than skipped like the address
+ // call above.)
+ return runtime()->hasSeenObjectEmulateUndefinedFuse.ref().intact();
+}
+
+const DOMCallbacks* CompileRuntime::DOMcallbacks() {
+ return runtime()->DOMcallbacks;
+}
+
+bool CompileRuntime::runtimeMatches(JSRuntime* rt) { return rt == runtime(); }
+
+Zone* CompileZone::zone() { return reinterpret_cast<Zone*>(this); }
+
+/* static */
+CompileZone* CompileZone::get(Zone* zone) {
+ return reinterpret_cast<CompileZone*>(zone);
+}
+
+CompileRuntime* CompileZone::runtime() {
+ return CompileRuntime::get(zone()->runtimeFromAnyThread());
+}
+
+bool CompileZone::isAtomsZone() { return zone()->isAtomsZone(); }
+
+#ifdef DEBUG
+const void* CompileRuntime::addressOfIonBailAfterCounter() {
+ return runtime()->jitRuntime()->addressOfIonBailAfterCounter();
+}
+#endif
+
+const uint32_t* CompileZone::addressOfNeedsIncrementalBarrier() {
+ // Cast away relaxed atomic wrapper for JIT access to barrier state.
+ const mozilla::Atomic<uint32_t, mozilla::Relaxed>* ptr =
+ zone()->addressOfNeedsIncrementalBarrier();
+ return reinterpret_cast<const uint32_t*>(ptr);
+}
+
+uint32_t* CompileZone::addressOfTenuredAllocCount() {
+ return zone()->addressOfTenuredAllocCount();
+}
+
+gc::FreeSpan** CompileZone::addressOfFreeList(gc::AllocKind allocKind) {
+ return zone()->arenas.addressOfFreeList(allocKind);
+}
+
+bool CompileZone::allocNurseryObjects() {
+ return zone()->allocNurseryObjects();
+}
+
+bool CompileZone::allocNurseryStrings() {
+ return zone()->allocNurseryStrings();
+}
+
+bool CompileZone::allocNurseryBigInts() {
+ return zone()->allocNurseryBigInts();
+}
+
+void* CompileZone::addressOfNurseryPosition() {
+ return zone()->runtimeFromAnyThread()->gc.addressOfNurseryPosition();
+}
+
+void* CompileZone::addressOfNurseryAllocatedSites() {
+ JSRuntime* rt = zone()->runtimeFromAnyThread();
+ return rt->gc.nursery().addressOfNurseryAllocatedSites();
+}
+
+bool CompileZone::canNurseryAllocateStrings() {
+ return zone()->allocNurseryStrings();
+}
+
+bool CompileZone::canNurseryAllocateBigInts() {
+ return zone()->allocNurseryBigInts();
+}
+
+gc::AllocSite* CompileZone::catchAllAllocSite(JS::TraceKind traceKind,
+ gc::CatchAllAllocSite siteKind) {
+ if (siteKind == gc::CatchAllAllocSite::Optimized) {
+ return zone()->optimizedAllocSite();
+ }
+ return zone()->unknownAllocSite(traceKind);
+}
+
+JS::Realm* CompileRealm::realm() { return reinterpret_cast<JS::Realm*>(this); }
+
+/* static */
+CompileRealm* CompileRealm::get(JS::Realm* realm) {
+ return reinterpret_cast<CompileRealm*>(realm);
+}
+
+CompileZone* CompileRealm::zone() { return CompileZone::get(realm()->zone()); }
+
+CompileRuntime* CompileRealm::runtime() {
+ return CompileRuntime::get(realm()->runtimeFromAnyThread());
+}
+
+const mozilla::non_crypto::XorShift128PlusRNG*
+CompileRealm::addressOfRandomNumberGenerator() {
+ return realm()->addressOfRandomNumberGenerator();
+}
+
+const JitZone* CompileZone::jitZone() { return zone()->jitZone(); }
+
+const GlobalObject* CompileRealm::maybeGlobal() {
+ // This uses unsafeUnbarrieredMaybeGlobal() so as not to trigger the read
+ // barrier on the global from off thread. This is safe because we
+ // abort Ion compilation when we GC.
+ return realm()->unsafeUnbarrieredMaybeGlobal();
+}
+
+const uint32_t* CompileRealm::addressOfGlobalWriteBarriered() {
+ return &realm()->globalWriteBarriered;
+}
+
+bool CompileZone::hasRealmWithAllocMetadataBuilder() {
+ return zone()->hasRealmWithAllocMetadataBuilder();
+}
+
+JitCompileOptions::JitCompileOptions()
+ : profilerSlowAssertionsEnabled_(false),
+ offThreadCompilationAvailable_(false) {}
+
+JitCompileOptions::JitCompileOptions(JSContext* cx) {
+ profilerSlowAssertionsEnabled_ =
+ cx->runtime()->geckoProfiler().enabled() &&
+ cx->runtime()->geckoProfiler().slowAssertionsEnabled();
+ offThreadCompilationAvailable_ = OffThreadCompilationAvailable(cx);
+#ifdef DEBUG
+ ionBailAfterEnabled_ = cx->runtime()->jitRuntime()->ionBailAfterEnabled();
+#endif
+}