diff options
author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-07 17:32:43 +0000 |
---|---|---|
committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-07 17:32:43 +0000 |
commit | 6bf0a5cb5034a7e684dcc3500e841785237ce2dd (patch) | |
tree | a68f146d7fa01f0134297619fbe7e33db084e0aa /js/src/jit/JitRealm.h | |
parent | Initial commit. (diff) | |
download | thunderbird-6bf0a5cb5034a7e684dcc3500e841785237ce2dd.tar.xz thunderbird-6bf0a5cb5034a7e684dcc3500e841785237ce2dd.zip |
Adding upstream version 1:115.7.0.upstream/1%115.7.0upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to '')
-rw-r--r-- | js/src/jit/JitRealm.h | 189 |
1 files changed, 189 insertions, 0 deletions
diff --git a/js/src/jit/JitRealm.h b/js/src/jit/JitRealm.h new file mode 100644 index 0000000000..a423d9a1c3 --- /dev/null +++ b/js/src/jit/JitRealm.h @@ -0,0 +1,189 @@ +/* -*- 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_JitRealm_h +#define jit_JitRealm_h + +#include "mozilla/Assertions.h" +#include "mozilla/Attributes.h" +#include "mozilla/EnumeratedArray.h" +#include "mozilla/MemoryReporting.h" + +#include <stddef.h> +#include <stdint.h> + +#include "gc/Barrier.h" +#include "gc/ZoneAllocator.h" +#include "js/GCHashTable.h" +#include "js/RootingAPI.h" +#include "js/TracingAPI.h" +#include "js/TypeDecls.h" + +namespace js { + +MOZ_COLD void ReportOutOfMemory(JSContext* cx); + +namespace jit { + +class JitCode; + +class JitRealm { + friend class JitActivation; + + // The JitRealm stores stubs to concatenate strings inline and perform RegExp + // calls inline. These bake in zone and realm specific pointers and can't be + // stored in JitRuntime. They also are dependent on the value of + // 'initialStringHeap' and must be flushed when its value changes. + // + // These are weak pointers, but they can by accessed during off-thread Ion + // compilation and therefore can't use the usual read barrier. Instead, we + // record which stubs have been read and perform the appropriate barriers in + // CodeGenerator::link(). + + enum StubIndex : uint32_t { + StringConcat = 0, + RegExpMatcher, + RegExpSearcher, + RegExpExecMatch, + RegExpExecTest, + Count + }; + + mozilla::EnumeratedArray<StubIndex, StubIndex::Count, WeakHeapPtr<JitCode*>> + stubs_; + + gc::Heap initialStringHeap; + + JitCode* generateStringConcatStub(JSContext* cx); + JitCode* generateRegExpMatcherStub(JSContext* cx); + JitCode* generateRegExpSearcherStub(JSContext* cx); + JitCode* generateRegExpExecMatchStub(JSContext* cx); + JitCode* generateRegExpExecTestStub(JSContext* cx); + + JitCode* getStubNoBarrier(StubIndex stub, + uint32_t* requiredBarriersOut) const { + MOZ_ASSERT(CurrentThreadIsIonCompiling()); + *requiredBarriersOut |= 1 << uint32_t(stub); + return stubs_[stub].unbarrieredGet(); + } + + public: + JitRealm(); + + void initialize(bool zoneHasNurseryStrings); + + // Initialize code stubs only used by Ion, not Baseline. + [[nodiscard]] bool ensureIonStubsExist(JSContext* cx) { + if (stubs_[StringConcat]) { + return true; + } + stubs_[StringConcat] = generateStringConcatStub(cx); + return stubs_[StringConcat]; + } + + void traceWeak(JSTracer* trc, JS::Realm* realm); + + void discardStubs() { + for (WeakHeapPtr<JitCode*>& stubRef : stubs_) { + stubRef = nullptr; + } + } + + bool hasStubs() const { + for (const WeakHeapPtr<JitCode*>& stubRef : stubs_) { + if (stubRef) { + return true; + } + } + return false; + } + + void setStringsCanBeInNursery(bool allow) { + MOZ_ASSERT(!hasStubs()); + initialStringHeap = allow ? gc::Heap::Default : gc::Heap::Tenured; + } + gc::Heap getInitialStringHeap() const { return initialStringHeap; } + + JitCode* stringConcatStubNoBarrier(uint32_t* requiredBarriersOut) const { + return getStubNoBarrier(StringConcat, requiredBarriersOut); + } + + JitCode* regExpMatcherStubNoBarrier(uint32_t* requiredBarriersOut) const { + return getStubNoBarrier(RegExpMatcher, requiredBarriersOut); + } + + [[nodiscard]] JitCode* ensureRegExpMatcherStubExists(JSContext* cx) { + if (JitCode* code = stubs_[RegExpMatcher]) { + return code; + } + stubs_[RegExpMatcher] = generateRegExpMatcherStub(cx); + return stubs_[RegExpMatcher]; + } + + JitCode* regExpSearcherStubNoBarrier(uint32_t* requiredBarriersOut) const { + return getStubNoBarrier(RegExpSearcher, requiredBarriersOut); + } + + [[nodiscard]] JitCode* ensureRegExpSearcherStubExists(JSContext* cx) { + if (JitCode* code = stubs_[RegExpSearcher]) { + return code; + } + stubs_[RegExpSearcher] = generateRegExpSearcherStub(cx); + return stubs_[RegExpSearcher]; + } + + JitCode* regExpExecMatchStubNoBarrier(uint32_t* requiredBarriersOut) const { + return getStubNoBarrier(RegExpExecMatch, requiredBarriersOut); + } + + [[nodiscard]] JitCode* ensureRegExpExecMatchStubExists(JSContext* cx) { + if (JitCode* code = stubs_[RegExpExecMatch]) { + return code; + } + stubs_[RegExpExecMatch] = generateRegExpExecMatchStub(cx); + return stubs_[RegExpExecMatch]; + } + + JitCode* regExpExecTestStubNoBarrier(uint32_t* requiredBarriersOut) const { + return getStubNoBarrier(RegExpExecTest, requiredBarriersOut); + } + + [[nodiscard]] JitCode* ensureRegExpExecTestStubExists(JSContext* cx) { + if (JitCode* code = stubs_[RegExpExecTest]) { + return code; + } + stubs_[RegExpExecTest] = generateRegExpExecTestStub(cx); + return stubs_[RegExpExecTest]; + } + + // Perform the necessary read barriers on stubs described by the bitmasks + // passed in. This function can only be called from the main thread. + // + // The stub pointers must still be valid by the time these methods are + // called. This is arranged by cancelling off-thread Ion compilation at the + // start of GC and at the start of sweeping. + void performStubReadBarriers(uint32_t stubsToBarrier) const; + + size_t sizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) const; + + static constexpr size_t offsetOfRegExpMatcherStub() { + return offsetof(JitRealm, stubs_) + RegExpMatcher * sizeof(uintptr_t); + } + static constexpr size_t offsetOfRegExpSearcherStub() { + return offsetof(JitRealm, stubs_) + RegExpSearcher * sizeof(uintptr_t); + } + static constexpr size_t offsetOfRegExpExecMatchStub() { + return offsetof(JitRealm, stubs_) + RegExpExecMatch * sizeof(uintptr_t); + } + static constexpr size_t offsetOfRegExpExecTestStub() { + return offsetof(JitRealm, stubs_) + RegExpExecTest * sizeof(uintptr_t); + } +}; + +} // namespace jit +} // namespace js + +#endif /* jit_JitRealm_h */ |