/* 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_BaselineCompileTask_h
#define jit_BaselineCompileTask_h
#include "mozilla/LinkedList.h"
#include "mozilla/Maybe.h"
#include "jit/BaselineCodeGen.h"
#include "jit/JitScript.h"
#include "jit/OffthreadSnapshot.h"
#include "vm/HelperThreadTask.h"
namespace js::jit {
class BaselineSnapshot {
OffthreadGCPtr<JSScript*> script_;
OffthreadGCPtr<GlobalLexicalEnvironmentObject*> globalLexical_;
OffthreadGCPtr<JSObject*> globalThis_;
OffthreadGCPtr<CallObject*> callObjectTemplate_;
OffthreadGCPtr<NamedLambdaObject*> namedLambdaTemplate_;
size_t nargs_;
uint32_t baseWarmUpThreshold_;
bool isIonCompileable_;
bool compileDebugInstrumentation_;
public:
BaselineSnapshot(JSScript* script,
GlobalLexicalEnvironmentObject* globalLexical,
JSObject* globalThis, uint32_t baseWarmUpThreshold,
bool isIonCompileable,
bool compileDebugInstrumentation)
: script_(script),
globalLexical_(globalLexical),
globalThis_(globalThis),
callObjectTemplate_(nullptr),
namedLambdaTemplate_(nullptr),
nargs_(script->function() ? script->function()->nargs() :
0),
baseWarmUpThreshold_(baseWarmUpThreshold),
isIonCompileable_(isIonCompileable),
compileDebugInstrumentation_(compileDebugInstrumentation) {
if (script->needsFunctionEnvironmentObjects()) {
auto [callObjectTemplate, namedLambdaTemplate] =
script->jitScript()->functionEnvironmentTemplates(script->function());
callObjectTemplate_.init(callObjectTemplate);
namedLambdaTemplate_.init(namedLambdaTemplate);
}
}
JSScript* script()
const {
return script_; }
GlobalLexicalEnvironmentObject* globalLexical()
const {
return globalLexical_;
}
JSObject* globalThis()
const {
return globalThis_; }
CallObject* callObjectTemplate()
const {
return callObjectTemplate_; }
NamedLambdaObject* namedLambdaTemplate()
const {
return namedLambdaTemplate_;
}
size_t nargs()
const {
return nargs_; }
uint32_t baseWarmUpThreshold()
const {
return baseWarmUpThreshold_; }
bool isIonCompileable()
const {
return isIonCompileable_; }
bool compileDebugInstrumentation()
const {
return compileDebugInstrumentation_;
}
void trace(JSTracer* trc);
};
class OffThreadBaselineSnapshot
:
public BaselineSnapshot,
public mozilla::LinkedListElement<OffThreadBaselineSnapshot> {
public:
OffThreadBaselineSnapshot(JSScript* script,
GlobalLexicalEnvironmentObject* globalLexical,
JSObject* globalThis, uint32_t baseWarmUpThreshold,
bool isIonCompileable,
bool compileDebugInstrumentation)
: BaselineSnapshot(script, globalLexical, globalThis, baseWarmUpThreshold,
isIonCompileable, compileDebugInstrumentation) {}
explicit OffThreadBaselineSnapshot(BaselineSnapshot other)
: BaselineSnapshot(other) {}
bool compileOffThread(TempAllocator& temp, CompileRealm* realm);
private:
mozilla::Maybe<OffThreadMacroAssembler> masm_;
mozilla::Maybe<BaselineCompiler> compiler_;
friend class BaselineCompileTask;
};
using BaselineSnapshotList = mozilla::LinkedList<OffThreadBaselineSnapshot>;
class BaselineCompileTask final :
public HelperThreadTask {
public:
BaselineCompileTask(CompileRealm* realm, LifoAlloc* alloc,
BaselineSnapshotList&& snapshots)
: realm_(realm), alloc_(alloc), snapshots_(std::move(snapshots)) {
#ifdef DEBUG
for (
auto* snapshot : snapshots_) {
MOZ_ASSERT(CompileRealm::get(snapshot->script()->realm()) == realm);
}
#endif
}
static bool OffThreadBaselineCompilationAvailable(JSContext* cx,
JSScript* script,
bool isEager =
false);
ThreadType threadType() override {
return THREAD_TYPE_BASELINE; }
void runTask();
void runHelperThreadTask(AutoLockHelperThreadState& locked) override;
void markScriptsAsCompiling();
void finishOnMainThread(JSContext* cx);
JSRuntime* runtimeFromAnyThread()
const {
return firstScript()->runtimeFromAnyThread();
}
Zone* zoneFromAnyThread()
const {
return firstScript()->zoneFromAnyThread(); }
bool scriptMatches(JSScript* script) {
for (
auto* snapshot : snapshots_) {
if (snapshot->script() == script) {
return true;
}
}
return false;
}
const char* getName() override {
return "BaselineCompileTask"; }
void trace(JSTracer* trc);
static void FinishOffThreadTask(BaselineCompileTask* task);
bool failed()
const {
return failed_; }
private:
// All scripts are in the same realm, so we can use an arbitrary script
// to access the realm/zone/runtime.
JSScript* firstScript()
const {
return snapshots_.getFirst()->script(); }
CompileRealm* realm_;
LifoAlloc* alloc_;
BaselineSnapshotList snapshots_;
bool failed_ =
false;
};
}
// namespace js::jit
#endif /* jit_BaselineCompileTask_h */
