From 36d22d82aa202bb199967e9512281e9a53db42c9 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 21:33:14 +0200 Subject: Adding upstream version 115.7.0esr. Signed-off-by: Daniel Baumann --- js/src/jit/JitZone.h | 208 +++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 208 insertions(+) create mode 100644 js/src/jit/JitZone.h (limited to 'js/src/jit/JitZone.h') diff --git a/js/src/jit/JitZone.h b/js/src/jit/JitZone.h new file mode 100644 index 0000000000..7489eca256 --- /dev/null +++ b/js/src/jit/JitZone.h @@ -0,0 +1,208 @@ +/* -*- 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_JitZone_h +#define jit_JitZone_h + +#include "mozilla/Assertions.h" +#include "mozilla/HashFunctions.h" +#include "mozilla/Maybe.h" +#include "mozilla/MemoryReporting.h" + +#include +#include +#include + +#include "gc/Barrier.h" +#include "jit/ExecutableAllocator.h" +#include "jit/ICStubSpace.h" +#include "jit/Invalidation.h" +#include "js/AllocPolicy.h" +#include "js/GCHashTable.h" +#include "js/HashTable.h" +#include "js/TracingAPI.h" +#include "js/TypeDecls.h" +#include "js/UniquePtr.h" +#include "js/Utility.h" +#include "threading/ProtectedData.h" + +namespace JS { +struct CodeSizes; +} + +namespace js { +namespace jit { + +enum class CacheKind : uint8_t; +class CacheIRStubInfo; +class JitCode; + +enum class ICStubEngine : uint8_t { + // Baseline IC, see BaselineIC.h. + Baseline = 0, + + // Ion IC, see IonIC.h. + IonIC +}; + +struct CacheIRStubKey : public DefaultHasher { + struct Lookup { + CacheKind kind; + ICStubEngine engine; + const uint8_t* code; + uint32_t length; + + Lookup(CacheKind kind, ICStubEngine engine, const uint8_t* code, + uint32_t length) + : kind(kind), engine(engine), code(code), length(length) {} + }; + + static HashNumber hash(const Lookup& l); + static bool match(const CacheIRStubKey& entry, const Lookup& l); + + UniquePtr stubInfo; + + explicit CacheIRStubKey(CacheIRStubInfo* info) : stubInfo(info) {} + CacheIRStubKey(CacheIRStubKey&& other) + : stubInfo(std::move(other.stubInfo)) {} + + void operator=(CacheIRStubKey&& other) { + stubInfo = std::move(other.stubInfo); + } +}; + +struct BaselineCacheIRStubCodeMapGCPolicy { + static bool traceWeak(JSTracer* trc, CacheIRStubKey*, + WeakHeapPtr* value) { + return TraceWeakEdge(trc, value, "traceWeak"); + } +}; + +class JitZone { + // Allocated space for optimized baseline stubs. + OptimizedICStubSpace optimizedStubSpace_; + + // Set of CacheIRStubInfo instances used by Ion stubs in this Zone. + using IonCacheIRStubInfoSet = + HashSet; + IonCacheIRStubInfoSet ionCacheIRStubInfoSet_; + + // Map CacheIRStubKey to shared JitCode objects. + using BaselineCacheIRStubCodeMap = + GCHashMap, CacheIRStubKey, + SystemAllocPolicy, BaselineCacheIRStubCodeMapGCPolicy>; + BaselineCacheIRStubCodeMap baselineCacheIRStubCodes_; + + // Executable allocator for all code except wasm code. + MainThreadData execAlloc_; + + // HashMap that maps scripts to compilations inlining those scripts. + using InlinedScriptMap = + GCHashMap, RecompileInfoVector, + StableCellHasher>, SystemAllocPolicy>; + InlinedScriptMap inlinedCompilations_; + + // The following two fields are a pair of associated scripts. If they are + // non-null, the child has been inlined into the parent, and we have bailed + // out due to a MonomorphicInlinedStubFolding bailout. If it wasn't + // trial-inlined, we need to track for the parent if we attach a new case to + // the corresponding folded stub which belongs to the child. + WeakHeapPtr lastStubFoldingBailoutChild_; + WeakHeapPtr lastStubFoldingBailoutParent_; + + mozilla::Maybe currentCompilationId_; + bool keepJitScripts_ = false; + + public: + ~JitZone() { MOZ_ASSERT(!keepJitScripts_); } + + void traceWeak(JSTracer* trc); + + void addSizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf, + JS::CodeSizes* code, size_t* jitZone, + size_t* baselineStubsOptimized) const; + + OptimizedICStubSpace* optimizedStubSpace() { return &optimizedStubSpace_; } + + JitCode* getBaselineCacheIRStubCode(const CacheIRStubKey::Lookup& key, + CacheIRStubInfo** stubInfo) { + auto p = baselineCacheIRStubCodes_.lookup(key); + if (p) { + *stubInfo = p->key().stubInfo.get(); + return p->value(); + } + *stubInfo = nullptr; + return nullptr; + } + [[nodiscard]] bool putBaselineCacheIRStubCode( + const CacheIRStubKey::Lookup& lookup, CacheIRStubKey& key, + JitCode* stubCode) { + auto p = baselineCacheIRStubCodes_.lookupForAdd(lookup); + MOZ_ASSERT(!p); + return baselineCacheIRStubCodes_.add(p, std::move(key), stubCode); + } + + CacheIRStubInfo* getIonCacheIRStubInfo(const CacheIRStubKey::Lookup& key) { + IonCacheIRStubInfoSet::Ptr p = ionCacheIRStubInfoSet_.lookup(key); + return p ? p->stubInfo.get() : nullptr; + } + [[nodiscard]] bool putIonCacheIRStubInfo(const CacheIRStubKey::Lookup& lookup, + CacheIRStubKey& key) { + IonCacheIRStubInfoSet::AddPtr p = + ionCacheIRStubInfoSet_.lookupForAdd(lookup); + MOZ_ASSERT(!p); + return ionCacheIRStubInfoSet_.add(p, std::move(key)); + } + void purgeIonCacheIRStubInfo() { ionCacheIRStubInfoSet_.clearAndCompact(); } + + ExecutableAllocator& execAlloc() { return execAlloc_.ref(); } + const ExecutableAllocator& execAlloc() const { return execAlloc_.ref(); } + + [[nodiscard]] bool addInlinedCompilation(const RecompileInfo& info, + JSScript* inlined); + + RecompileInfoVector* maybeInlinedCompilations(JSScript* inlined) { + auto p = inlinedCompilations_.lookup(inlined); + return p ? &p->value() : nullptr; + } + + void removeInlinedCompilations(JSScript* inlined) { + inlinedCompilations_.remove(inlined); + } + + void noteStubFoldingBailout(JSScript* child, JSScript* parent) { + lastStubFoldingBailoutChild_ = child; + lastStubFoldingBailoutParent_ = parent; + } + bool hasStubFoldingBailoutData(JSScript* child) const { + return lastStubFoldingBailoutChild_ && + lastStubFoldingBailoutChild_.get() == child && + lastStubFoldingBailoutParent_; + } + JSScript* stubFoldingBailoutParent() const { + MOZ_ASSERT(lastStubFoldingBailoutChild_); + return lastStubFoldingBailoutParent_.get(); + } + void clearStubFoldingBailoutData() { + lastStubFoldingBailoutChild_ = nullptr; + lastStubFoldingBailoutParent_ = nullptr; + } + + bool keepJitScripts() const { return keepJitScripts_; } + void setKeepJitScripts(bool keep) { keepJitScripts_ = keep; } + + mozilla::Maybe currentCompilationId() const { + return currentCompilationId_; + } + mozilla::Maybe& currentCompilationIdRef() { + return currentCompilationId_; + } +}; + +} // namespace jit +} // namespace js + +#endif /* jit_JitZone_h */ -- cgit v1.2.3