summaryrefslogtreecommitdiffstats
path: root/js/src/jit/CompileWrappers.h
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.h
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.h')
-rw-r--r--js/src/jit/CompileWrappers.h183
1 files changed, 183 insertions, 0 deletions
diff --git a/js/src/jit/CompileWrappers.h b/js/src/jit/CompileWrappers.h
new file mode 100644
index 0000000000..de23af7106
--- /dev/null
+++ b/js/src/jit/CompileWrappers.h
@@ -0,0 +1,183 @@
+/* -*- 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 jit_CompileWrappers_h
+#define jit_CompileWrappers_h
+
+#include <stdint.h>
+
+#include "gc/Pretenuring.h"
+#include "js/TypeDecls.h"
+#include "vm/Realm.h"
+#include "vm/RealmFuses.h"
+
+struct JSAtomState;
+
+namespace mozilla::non_crypto {
+class XorShift128PlusRNG;
+}
+
+namespace JS {
+enum class TraceKind;
+}
+
+namespace js {
+
+class GeckoProfilerRuntime;
+class GlobalObject;
+struct JSDOMCallbacks;
+class PropertyName;
+class StaticStrings;
+struct WellKnownSymbols;
+
+using DOMCallbacks = struct JSDOMCallbacks;
+
+namespace gc {
+
+enum class AllocKind : uint8_t;
+
+class FreeSpan;
+
+} // namespace gc
+
+namespace jit {
+
+class JitRuntime;
+
+// During Ion compilation we need access to various bits of the current
+// compartment, runtime and so forth. However, since compilation can run off
+// thread while the main thread is mutating the VM, this access needs
+// to be restricted. The classes below give the compiler an interface to access
+// all necessary information in a threadsafe fashion.
+
+class CompileRuntime {
+ JSRuntime* runtime();
+
+ public:
+ static CompileRuntime* get(JSRuntime* rt);
+
+#ifdef JS_GC_ZEAL
+ const uint32_t* addressOfGCZealModeBits();
+#endif
+
+ const JitRuntime* jitRuntime();
+
+ // Compilation does not occur off thread when the Gecko Profiler is enabled.
+ GeckoProfilerRuntime& geckoProfiler();
+
+ bool hadOutOfMemory();
+ bool profilingScripts();
+
+ const JSAtomState& names();
+ const PropertyName* emptyString();
+ const StaticStrings& staticStrings();
+ const WellKnownSymbols& wellKnownSymbols();
+ const JSClass* maybeWindowProxyClass();
+
+ const void* mainContextPtr();
+ const void* addressOfJitStackLimit();
+ const void* addressOfInterruptBits();
+ const void* addressOfZone();
+ const void* addressOfMegamorphicCache();
+ const void* addressOfMegamorphicSetPropCache();
+ const void* addressOfStringToAtomCache();
+ const void* addressOfLastBufferedWholeCell();
+
+ bool hasSeenObjectEmulateUndefinedFuseIntact();
+ const void* addressOfHasSeenObjectEmulateUndefinedFuse();
+
+#ifdef DEBUG
+ const void* addressOfIonBailAfterCounter();
+#endif
+
+ // DOM callbacks must be threadsafe (and will hopefully be removed soon).
+ const DOMCallbacks* DOMcallbacks();
+
+ bool runtimeMatches(JSRuntime* rt);
+};
+
+class JitZone;
+
+class CompileZone {
+ friend class MacroAssembler;
+ JS::Zone* zone();
+
+ public:
+ static CompileZone* get(JS::Zone* zone);
+
+ const JitZone* jitZone();
+
+ CompileRuntime* runtime();
+ bool isAtomsZone();
+
+ const uint32_t* addressOfNeedsIncrementalBarrier();
+ uint32_t* addressOfTenuredAllocCount();
+ gc::FreeSpan** addressOfFreeList(gc::AllocKind allocKind);
+ bool allocNurseryObjects();
+ bool allocNurseryStrings();
+ bool allocNurseryBigInts();
+ void* addressOfNurseryPosition();
+
+ void* addressOfNurseryAllocatedSites();
+
+ bool canNurseryAllocateStrings();
+ bool canNurseryAllocateBigInts();
+
+ gc::AllocSite* catchAllAllocSite(JS::TraceKind traceKind,
+ gc::CatchAllAllocSite siteKind);
+
+ bool hasRealmWithAllocMetadataBuilder();
+};
+
+class CompileRealm {
+ JS::Realm* realm();
+
+ public:
+ static CompileRealm* get(JS::Realm* realm);
+
+ CompileZone* zone();
+ CompileRuntime* runtime();
+
+ const void* realmPtr() { return realm(); }
+
+ RealmFuses& realmFuses() { return realm()->realmFuses; }
+
+ const mozilla::non_crypto::XorShift128PlusRNG*
+ addressOfRandomNumberGenerator();
+
+ const GlobalObject* maybeGlobal();
+ const uint32_t* addressOfGlobalWriteBarriered();
+};
+
+class JitCompileOptions {
+ public:
+ JitCompileOptions();
+ explicit JitCompileOptions(JSContext* cx);
+
+ bool profilerSlowAssertionsEnabled() const {
+ return profilerSlowAssertionsEnabled_;
+ }
+
+ bool offThreadCompilationAvailable() const {
+ return offThreadCompilationAvailable_;
+ }
+
+#ifdef DEBUG
+ bool ionBailAfterEnabled() const { return ionBailAfterEnabled_; }
+#endif
+
+ private:
+ bool profilerSlowAssertionsEnabled_;
+ bool offThreadCompilationAvailable_;
+#ifdef DEBUG
+ bool ionBailAfterEnabled_ = false;
+#endif
+};
+
+} // namespace jit
+} // namespace js
+
+#endif // jit_CompileWrappers_h