Source code

Revision control

Copy as Markdown

Other Tools

/* -*- 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 */
#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();
static CompileRuntime* get(JSRuntime* rt);
#ifdef JS_GC_ZEAL
const uint32_t* addressOfGCZealModeBits();
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();
// 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();
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();
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*
const GlobalObject* maybeGlobal();
const uint32_t* addressOfGlobalWriteBarriered();
class JitCompileOptions {
explicit JitCompileOptions(JSContext* cx);
bool profilerSlowAssertionsEnabled() const {
return profilerSlowAssertionsEnabled_;
bool offThreadCompilationAvailable() const {
return offThreadCompilationAvailable_;
#ifdef DEBUG
bool ionBailAfterEnabled() const { return ionBailAfterEnabled_; }
bool profilerSlowAssertionsEnabled_;
bool offThreadCompilationAvailable_;
#ifdef DEBUG
bool ionBailAfterEnabled_ = false;
} // namespace jit
} // namespace js
#endif // jit_CompileWrappers_h