mozilla
/
gecko-dev
зеркало из https://github.com/mozilla/gecko-dev.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

Bug 1320374: Batch function compilations; r=luke 

MozReview-Commit-ID: BmFx1UuesSL

--HG--
extra : rebase_source : c43ae49d7cb048ec06b0c592894b8361758d7543
This commit is contained in:
Benjamin Bouvier 2016-12-27 15:48:46 +01:00
Родитель 8a763f40ff
Коммит ec79f44e1f
9 изменённых файлов: 273 добавлений и 199 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

2
js/src/jit/JitAllocPolicy.h
Просмотреть файл

@ -173,7 +173,7 @@ struct TempObject
"Placement new argument type must inherit from TempObject");
MOZ_ASSERT(pos);
return pos;
}
}
};
template <typename T>

10
js/src/jit/JitOptions.cpp
Просмотреть файл

@ -237,6 +237,16 @@ DefaultJitOptions::DefaultJitOptions()
// included in the bounds check.
SET_DEFAULT(wasmFoldOffsets, true);
// Until which wasm bytecode size should we accumulate functions, in order
// to compile efficiently on helper threads (see also bug 1320374).
SET_DEFAULT(wasmBatchThreshold, 10000);
// In order to have different batching thresholds for Ion and the wasm
// baseline, and since a same batch can contain both Ion and baseline
// compiled functions, we make Ion functions weight more by using a scaling
// factor.
SET_DEFAULT(wasmBatchIonScaleFactor, 9);
// Determines whether we suppress using signal handlers
// for interrupting jit-ed code. This is used only for testing.
SET_DEFAULT(ionInterruptWithoutSignals, false);

2
js/src/jit/JitOptions.h
Просмотреть файл

@ -87,6 +87,8 @@ struct DefaultJitOptions
uint32_t branchPruningBlockSpanFactor;
uint32_t branchPruningEffectfulInstFactor;
uint32_t branchPruningThreshold;
uint32_t wasmBatchThreshold;
uint32_t wasmBatchIonScaleFactor;
mozilla::Maybe<uint32_t> forcedDefaultIonWarmUpThreshold;
mozilla::Maybe<uint32_t> forcedDefaultIonSmallFunctionWarmUpThreshold;
mozilla::Maybe<IonRegisterAllocator> forcedRegisterAllocator;

39
js/src/wasm/WasmBaselineCompile.cpp
Просмотреть файл

@ -512,7 +512,7 @@ class BaseCompiler
Assembler::Condition latentIntCmp_; // Comparison operator, if latentOp_ == Compare, int types
Assembler::DoubleCondition latentDoubleCmp_;// Comparison operator, if latentOp_ == Compare, float types
FuncCompileResults& compileResults_;
FuncOffsets offsets_;
MacroAssembler& masm; // No '_' suffix - too tedious...
AllocatableGeneralRegisterSet availGPR_;
@ -567,11 +567,12 @@ class BaseCompiler
Decoder& decoder,
const FuncBytes& func,
const ValTypeVector& locals,
FuncCompileResults& compileResults);
TempAllocator* alloc,
MacroAssembler* masm);
MOZ_MUST_USE bool init();
void finish();
FuncOffsets finish();
MOZ_MUST_USE bool emitFunction();
@ -2053,7 +2054,7 @@ class BaseCompiler
JitSpew(JitSpew_Codegen, "# Emitting wasm baseline code");
SigIdDesc sigId = env_.funcSigs[func_.index()]->id;
GenerateFunctionPrologue(masm, localSize_, sigId, &compileResults_.offsets());
GenerateFunctionPrologue(masm, localSize_, sigId, &offsets_);
MOZ_ASSERT(masm.framePushed() == uint32_t(localSize_));
@ -2148,7 +2149,7 @@ class BaseCompiler
// Restore the TLS register in case it was overwritten by the function.
loadFromFramePtr(WasmTlsReg, frameOffsetFromSlot(tlsSlot_, MIRType::Pointer));
GenerateFunctionEpilogue(masm, localSize_, &compileResults_.offsets());
GenerateFunctionEpilogue(masm, localSize_, &offsets_);
#if defined(JS_ION_PERF)
// FIXME - profiling code missing. Bug 1286948.
@ -2162,7 +2163,7 @@ class BaseCompiler
masm.wasmEmitTrapOutOfLineCode();
compileResults_.offsets().end = masm.currentOffset();
offsets_.end = masm.currentOffset();
// A frame greater than 256KB is implausible, probably an attack,
// so fail the compilation.
@ -7540,12 +7541,13 @@ BaseCompiler::BaseCompiler(const ModuleEnvironment& env,
Decoder& decoder,
const FuncBytes& func,
const ValTypeVector& locals,
FuncCompileResults& compileResults)
TempAllocator* alloc,
MacroAssembler* masm)
: env_(env),
iter_(decoder, func.lineOrBytecode()),
func_(func),
lastReadCallSite_(0),
alloc_(compileResults.alloc()),
alloc_(*alloc),
locals_(locals),
localSize_(0),
varLow_(0),
@ -7558,8 +7560,7 @@ BaseCompiler::BaseCompiler(const ModuleEnvironment& env,
latentType_(ValType::I32),
latentIntCmp_(Assembler::Equal),
latentDoubleCmp_(Assembler::DoubleEqual),
compileResults_(compileResults),
masm(compileResults_.masm()),
masm(*masm),
availGPR_(GeneralRegisterSet::All()),
availFPU_(FloatRegisterSet::All()),
#ifdef DEBUG
@ -7702,13 +7703,15 @@ BaseCompiler::init()
return true;
}
void
FuncOffsets
BaseCompiler::finish()
{
MOZ_ASSERT(done(), "all bytes must be consumed");
MOZ_ASSERT(func_.callSiteLineNums().length() == lastReadCallSite_);
masm.flushBuffer();
return offsets_;
}
static LiveRegisterSet
@ -7756,12 +7759,11 @@ js::wasm::BaselineCanCompile(const FunctionGenerator* fg)
}
bool
js::wasm::BaselineCompileFunction(CompileTask* task)
js::wasm::BaselineCompileFunction(CompileTask* task, FuncCompileUnit* unit)
{
MOZ_ASSERT(task->mode() == CompileTask::CompileMode::Baseline);
MOZ_ASSERT(unit->mode() == CompileMode::Baseline);
const FuncBytes& func = task->func();
FuncCompileResults& results = task->results();
const FuncBytes& func = unit->func();
Decoder d(func.bytes());
@ -7775,19 +7777,18 @@ js::wasm::BaselineCompileFunction(CompileTask* task)
// The MacroAssembler will sometimes access the jitContext.
JitContext jitContext(&results.alloc());
JitContext jitContext(&task->alloc());
// One-pass baseline compilation.
BaseCompiler f(task->env(), d, func, locals, results);
BaseCompiler f(task->env(), d, func, locals, &task->alloc(), &task->masm());
if (!f.init())
return false;
if (!f.emitFunction())
return false;
f.finish();
unit->finish(f.finish());
return true;
}

3
js/src/wasm/WasmBaselineCompile.h
Просмотреть файл

@ -24,6 +24,7 @@ namespace wasm {
class FunctionGenerator;
class CompileTask;
class FuncCompileUnit;
// Return true if BaselineCompileFunction can generate code for the
// function held in the FunctionGenerator. If false is returned a
@ -39,7 +40,7 @@ BaselineCanCompile(const FunctionGenerator* fg);
// Generate adequate code quickly.
bool
BaselineCompileFunction(CompileTask* task);
BaselineCompileFunction(CompileTask* task, FuncCompileUnit* unit);
} // namespace wasm
} // namespace js

158
js/src/wasm/WasmGenerator.cpp
Просмотреть файл

@ -55,6 +55,8 @@ ModuleGenerator::ModuleGenerator()
startOfUnpatchedCallsites_(0),
parallel_(false),
outstanding_(0),
currentTask_(nullptr),
batchedBytecode_(0),
activeFuncDef_(nullptr),
startedFuncDefs_(false),
finishedFuncDefs_(false),
@ -96,6 +98,8 @@ ModuleGenerator::~ModuleGenerator()
} else {
MOZ_ASSERT(!outstanding_);
}
MOZ_ASSERT_IF(finishedFuncDefs_, !batchedBytecode_);
MOZ_ASSERT_IF(finishedFuncDefs_, !currentTask_);
}
bool
@ -391,42 +395,45 @@ ModuleGenerator::patchFarJumps(const TrapExitOffsetArray& trapExits)
bool
ModuleGenerator::finishTask(CompileTask* task)
{
const FuncBytes& func = task->func();
FuncCompileResults& results = task->results();
masm_.haltingAlign(CodeAlignment);
// Before merging in the new function's code, if calls in a prior function
// body might go out of range, insert far jumps to extend the range.
if ((masm_.size() - startOfUnpatchedCallsites_) + results.masm().size() > JumpRange()) {
if ((masm_.size() - startOfUnpatchedCallsites_) + task->masm().size() > JumpRange()) {
startOfUnpatchedCallsites_ = masm_.size();
if (!patchCallSites())
return false;
}
// Offset the recorded FuncOffsets by the offset of the function in the
// whole module's code segment.
uint32_t offsetInWhole = masm_.size();
results.offsets().offsetBy(offsetInWhole);
for (const FuncCompileUnit& unit : task->units()) {
const FuncBytes& func = unit.func();
// Add the CodeRange for this function.
uint32_t funcCodeRangeIndex = metadata_->codeRanges.length();
if (!metadata_->codeRanges.emplaceBack(func.index(), func.lineOrBytecode(), results.offsets()))
return false;
// Offset the recorded FuncOffsets by the offset of the function in the
// whole module's code segment.
FuncOffsets offsets = unit.offsets();
offsets.offsetBy(offsetInWhole);
MOZ_ASSERT(!funcIsCompiled(func.index()));
funcToCodeRange_[func.index()] = funcCodeRangeIndex;
// Add the CodeRange for this function.
uint32_t funcCodeRangeIndex = metadata_->codeRanges.length();
if (!metadata_->codeRanges.emplaceBack(func.index(), func.lineOrBytecode(), offsets))
return false;
MOZ_ASSERT(!funcIsCompiled(func.index()));
funcToCodeRange_[func.index()] = funcCodeRangeIndex;
}
// Merge the compiled results into the whole-module masm.
mozilla::DebugOnly<size_t> sizeBefore = masm_.size();
if (!masm_.asmMergeWith(results.masm()))
if (!masm_.asmMergeWith(task->masm()))
return false;
MOZ_ASSERT(masm_.size() == offsetInWhole + task->masm().size());
if (!task->reset(&freeFuncBytes_))
return false;
MOZ_ASSERT(masm_.size() == offsetInWhole + results.masm().size());
UniqueBytes recycled;
task->reset(&recycled);
freeTasks_.infallibleAppend(task);
return freeBytes_.emplaceBack(Move(recycled));
return true;
}
bool
@ -864,15 +871,6 @@ ModuleGenerator::startFuncDefs()
for (size_t i = 0; i < numTasks; i++)
freeTasks_.infallibleAppend(&tasks_[i]);
if (!freeBytes_.reserve(numTasks))
return false;
for (size_t i = 0; i < numTasks; i++) {
auto bytes = js::MakeUnique<Bytes>();
if (!bytes)
return false;
freeBytes_.infallibleAppend(Move(bytes));
}
startedFuncDefs_ = true;
MOZ_ASSERT(!finishedFuncDefs_);
return true;
@ -885,58 +883,81 @@ ModuleGenerator::startFuncDef(uint32_t lineOrBytecode, FunctionGenerator* fg)
MOZ_ASSERT(!activeFuncDef_);
MOZ_ASSERT(!finishedFuncDefs_);
if (!freeBytes_.empty()) {
fg->bytes_ = Move(freeBytes_.back());
freeBytes_.popBack();
if (!freeFuncBytes_.empty()) {
fg->funcBytes_ = Move(freeFuncBytes_.back());
freeFuncBytes_.popBack();
} else {
fg->bytes_ = js::MakeUnique<Bytes>();
if (!fg->bytes_)
fg->funcBytes_ = js::MakeUnique<FuncBytes>();
if (!fg->funcBytes_)
return false;
}
fg->lineOrBytecode_ = lineOrBytecode;
if (!currentTask_) {
if (freeTasks_.empty() && !finishOutstandingTask())
return false;
currentTask_ = freeTasks_.popCopy();
}
fg->funcBytes_->setLineOrBytecode(lineOrBytecode);
fg->m_ = this;
activeFuncDef_ = fg;
return true;
}
bool
ModuleGenerator::launchBatchCompile()
{
MOZ_ASSERT(currentTask_);
size_t numBatchedFuncs = currentTask_->units().length();
MOZ_ASSERT(numBatchedFuncs);
if (parallel_) {
if (!StartOffThreadWasmCompile(currentTask_))
return false;
outstanding_++;
} else {
if (!CompileFunction(currentTask_))
return false;
if (!finishTask(currentTask_))
return false;
}
currentTask_ = nullptr;
batchedBytecode_ = 0;
numFinishedFuncDefs_ += numBatchedFuncs;
return true;
}
bool
ModuleGenerator::finishFuncDef(uint32_t funcIndex, FunctionGenerator* fg)
{
MOZ_ASSERT(activeFuncDef_ == fg);
auto func = js::MakeUnique<FuncBytes>(Move(fg->bytes_),
funcIndex,
funcSig(funcIndex),
fg->lineOrBytecode_,
Move(fg->callSiteLineNums_));
if (!func)
return false;
UniqueFuncBytes func = Move(fg->funcBytes_);
func->setFunc(funcIndex, &funcSig(funcIndex));
auto mode = alwaysBaseline_ && BaselineCanCompile(fg)
? CompileTask::CompileMode::Baseline
: CompileTask::CompileMode::Ion;
? CompileMode::Baseline
: CompileMode::Ion;
if (freeTasks_.empty() && !finishOutstandingTask())
CheckedInt<uint32_t> newBatched = func->bytes().length();
if (mode == CompileMode::Ion)
newBatched *= JitOptions.wasmBatchIonScaleFactor;
newBatched += batchedBytecode_;
if (!currentTask_->units().emplaceBack(Move(func), mode))
return false;
CompileTask* task = freeTasks_.popCopy();
task->init(Move(func), mode);
if (parallel_) {
if (!StartOffThreadWasmCompile(task))
return false;
outstanding_++;
} else {
if (!CompileFunction(task))
return false;
if (!finishTask(task))
return false;
}
if (newBatched.isValid() && newBatched.value() < JitOptions.wasmBatchThreshold)
batchedBytecode_ = newBatched.value();
else if (!launchBatchCompile())
return false;
fg->m_ = nullptr;
activeFuncDef_ = nullptr;
numFinishedFuncDefs_++;
return true;
}
@ -947,6 +968,9 @@ ModuleGenerator::finishFuncDefs()
MOZ_ASSERT(!activeFuncDef_);
MOZ_ASSERT(!finishedFuncDefs_);
if (currentTask_ && !launchBatchCompile())
return false;
while (outstanding_ > 0) {
if (!finishOutstandingTask())
return false;
@ -1146,14 +1170,18 @@ wasm::CompileFunction(CompileTask* task)
TraceLoggerThread* logger = TraceLoggerForCurrentThread();
AutoTraceLog logCompile(logger, TraceLogger_WasmCompilation);
switch (task->mode()) {
case wasm::CompileTask::CompileMode::Ion:
return wasm::IonCompileFunction(task);
case wasm::CompileTask::CompileMode::Baseline:
return wasm::BaselineCompileFunction(task);
case wasm::CompileTask::CompileMode::None:
break;
for (FuncCompileUnit& unit : task->units()) {
switch (unit.mode()) {
case CompileMode::Ion:
if (!IonCompileFunction(task, &unit))
return false;
break;
case CompileMode::Baseline:
if (!BaselineCompileFunction(task, &unit))
return false;
break;
}
}
MOZ_CRASH("Uninitialized task");
return true;
}

218
js/src/wasm/WasmGenerator.h
Просмотреть файл

@ -36,124 +36,158 @@ struct CompileArgs;
class FunctionGenerator;
typedef Vector<UniqueBytes, 0, SystemAllocPolicy> UniqueBytesVector;
// The FuncBytes class represents a single, concurrently-compilable function.
// A FuncBytes object is composed of the wasm function body bytes along with the
// ambient metadata describing the function necessary to compile it.
class FuncBytes
{
UniqueBytes bytes_;
Bytes bytes_;
uint32_t index_;
const SigWithId& sig_;
const SigWithId* sig_;
uint32_t lineOrBytecode_;
Uint32Vector callSiteLineNums_;
public:
FuncBytes(UniqueBytes bytes,
uint32_t index,
const SigWithId& sig,
uint32_t lineOrBytecode,
Uint32Vector&& callSiteLineNums)
: bytes_(Move(bytes)),
index_(index),
sig_(sig),
lineOrBytecode_(lineOrBytecode),
callSiteLineNums_(Move(callSiteLineNums))
FuncBytes()
: index_(UINT32_MAX),
sig_(nullptr),
lineOrBytecode_(UINT32_MAX)
{}
Bytes& bytes() { return *bytes_; }
const Bytes& bytes() const { return *bytes_; }
UniqueBytes recycle() { return Move(bytes_); }
Bytes& bytes() {
return bytes_;
}
MOZ_MUST_USE bool addCallSiteLineNum(uint32_t lineno) {
return callSiteLineNums_.append(lineno);
}
void setLineOrBytecode(uint32_t lineOrBytecode) {
MOZ_ASSERT(lineOrBytecode_ == UINT32_MAX);
lineOrBytecode_ = lineOrBytecode;
}
void setFunc(uint32_t index, const SigWithId* sig) {
MOZ_ASSERT(index_ == UINT32_MAX);
MOZ_ASSERT(sig_ == nullptr);
index_ = index;
sig_ = sig;
}
void reset() {
bytes_.clear();
index_ = UINT32_MAX;
sig_ = nullptr;
lineOrBytecode_ = UINT32_MAX;
callSiteLineNums_.clear();
}
const Bytes& bytes() const { return bytes_; }
uint32_t index() const { return index_; }
const SigWithId& sig() const { return sig_; }
const SigWithId& sig() const { return *sig_; }
uint32_t lineOrBytecode() const { return lineOrBytecode_; }
const Uint32Vector& callSiteLineNums() const { return callSiteLineNums_; }
};
typedef UniquePtr<FuncBytes> UniqueFuncBytes;
typedef Vector<UniqueFuncBytes, 8, SystemAllocPolicy> UniqueFuncBytesVector;
// The FuncCompileResults class contains the results of compiling a single
// function body, ready to be merged into the whole-module MacroAssembler.
class FuncCompileResults
enum class CompileMode
{
jit::TempAllocator alloc_;
jit::MacroAssembler masm_;
FuncOffsets offsets_;
FuncCompileResults(const FuncCompileResults&) = delete;
FuncCompileResults& operator=(const FuncCompileResults&) = delete;
public:
explicit FuncCompileResults(LifoAlloc& lifo)
: alloc_(&lifo),
masm_(jit::MacroAssembler::WasmToken(), alloc_)
{}
jit::TempAllocator& alloc() { return alloc_; }
jit::MacroAssembler& masm() { return masm_; }
FuncOffsets& offsets() { return offsets_; }
Baseline,
Ion
};
// A CompileTask represents the task of compiling a single function body. An
// CompileTask is filled with the wasm code to be compiled on the main
// validation thread, sent off to a compilation helper thread which creates
// the FuncCompileResults, and finally sent back to the validation thread. To
// save time allocating and freeing memory, CompileTasks are reset() and
// reused.
// FuncCompileUnit contains all the data necessary to produce and store the
// results of a single function's compilation.
class FuncCompileUnit
{
UniqueFuncBytes func_;
CompileMode mode_;
FuncOffsets offsets_;
DebugOnly<bool> finished_;
public:
FuncCompileUnit(UniqueFuncBytes func, CompileMode mode)
: func_(Move(func)),
mode_(mode),
finished_(false)
{}
const FuncBytes& func() const { return *func_; }
CompileMode mode() const { return mode_; }
FuncOffsets offsets() const { MOZ_ASSERT(finished_); return offsets_; }
void finish(FuncOffsets offsets) {
MOZ_ASSERT(!finished_);
offsets_ = offsets;
finished_ = true;
}
UniqueFuncBytes recycle() {
MOZ_ASSERT(finished_);
func_->reset();
return Move(func_);
}
};
typedef Vector<FuncCompileUnit, 8, SystemAllocPolicy> FuncCompileUnitVector;
// A CompileTask represents the task of compiling a batch of functions. It is
// filled with a certain number of function's bodies that are sent off to a
// compilation helper thread, which fills in the resulting code offsets, and
// finally sent back to the validation thread. To save time allocating and
// freeing memory, CompileTasks are reset() and reused.
class CompileTask
{
public:
enum class CompileMode { None, Baseline, Ion };
private:
const ModuleEnvironment& env_;
LifoAlloc lifo_;
UniqueFuncBytes func_;
CompileMode mode_;
Maybe<FuncCompileResults> results_;
const ModuleEnvironment& env_;
LifoAlloc lifo_;
Maybe<jit::TempAllocator> alloc_;
Maybe<jit::MacroAssembler> masm_;
FuncCompileUnitVector units_;
CompileTask(const CompileTask&) = delete;
CompileTask& operator=(const CompileTask&) = delete;
void init() {
alloc_.emplace(&lifo_);
masm_.emplace(jit::MacroAssembler::WasmToken(), *alloc_);
}
public:
CompileTask(const ModuleEnvironment& env, size_t defaultChunkSize)
: env_(env), lifo_(defaultChunkSize), func_(nullptr), mode_(CompileMode::None)
{}
: env_(env),
lifo_(defaultChunkSize)
{
init();
}
LifoAlloc& lifo() {
return lifo_;
}
jit::TempAllocator& alloc() {
return *alloc_;
}
const ModuleEnvironment& env() const {
return env_;
}
void init(UniqueFuncBytes func, CompileMode mode) {
MOZ_ASSERT(!func_);
func_ = Move(func);
results_.emplace(lifo_);
mode_ = mode;
jit::MacroAssembler& masm() {
return *masm_;
}
CompileMode mode() const {
return mode_;
FuncCompileUnitVector& units() {
return units_;
}
const FuncBytes& func() const {
MOZ_ASSERT(func_);
return *func_;
}
FuncCompileResults& results() {
return *results_;
}
void reset(UniqueBytes* recycled) {
if (func_) {
*recycled = Move(func_->recycle());
(*recycled)->clear();
bool reset(UniqueFuncBytesVector* freeFuncBytes) {
for (FuncCompileUnit& unit : units_) {
if (!freeFuncBytes->emplaceBack(Move(unit.recycle())))
return false;
}
func_.reset(nullptr);
results_.reset();
units_.clear();
masm_.reset();
alloc_.reset();
lifo_.releaseAll();
mode_ = CompileMode::None;
init();
return true;
}
};
@ -196,7 +230,9 @@ class MOZ_STACK_CLASS ModuleGenerator
uint32_t outstanding_;
CompileTaskVector tasks_;
CompileTaskPtrVector freeTasks_;
UniqueBytesVector freeBytes_;
UniqueFuncBytesVector freeFuncBytes_;
CompileTask* currentTask_;
uint32_t batchedBytecode_;
// Assertions
DebugOnly<FunctionGenerator*> activeFuncDef_;
@ -206,6 +242,7 @@ class MOZ_STACK_CLASS ModuleGenerator
bool funcIsCompiled(uint32_t funcIndex) const;
const CodeRange& funcCodeRange(uint32_t funcIndex) const;
uint32_t numFuncImports() const;
MOZ_MUST_USE bool patchCallSites(TrapExitOffsetArray* maybeTrapExits = nullptr);
MOZ_MUST_USE bool patchFarJumps(const TrapExitOffsetArray& trapExits);
MOZ_MUST_USE bool finishTask(CompileTask* task);
@ -217,12 +254,11 @@ class MOZ_STACK_CLASS ModuleGenerator
MOZ_MUST_USE bool allocateGlobalBytes(uint32_t bytes, uint32_t align, uint32_t* globalDataOff);
MOZ_MUST_USE bool allocateGlobal(GlobalDesc* global);
MOZ_MUST_USE bool launchBatchCompile();
MOZ_MUST_USE bool initAsmJS(Metadata* asmJSMetadata);
MOZ_MUST_USE bool initWasm();
// Functions declarations:
uint32_t numFuncImports() const;
public:
explicit ModuleGenerator();
~ModuleGenerator();
@ -275,10 +311,11 @@ class MOZ_STACK_CLASS ModuleGenerator
};
// A FunctionGenerator encapsulates the generation of a single function body.
// ModuleGenerator::startFunc must be called after construction and before doing
// anything else. After the body is complete, ModuleGenerator::finishFunc must
// be called before the FunctionGenerator is destroyed and the next function is
// started.
// ModuleGenerator::startFuncDef must be called after construction and before
// doing anything else.
//
// After the body is complete, ModuleGenerator::finishFuncDef must be called
// before the FunctionGenerator is destroyed and the next function is started.
class MOZ_STACK_CLASS FunctionGenerator
{
@ -288,16 +325,11 @@ class MOZ_STACK_CLASS FunctionGenerator
bool usesSimd_;
bool usesAtomics_;
// Data created during function generation, then handed over to the
// FuncBytes in ModuleGenerator::finishFunc().
UniqueBytes bytes_;
Uint32Vector callSiteLineNums_;
uint32_t lineOrBytecode_;
UniqueFuncBytes funcBytes_;
public:
FunctionGenerator()
: m_(nullptr), usesSimd_(false), usesAtomics_(false), bytes_(nullptr), lineOrBytecode_(0)
: m_(nullptr), usesSimd_(false), usesAtomics_(false), funcBytes_(nullptr)
{}
bool usesSimd() const {
@ -315,10 +347,10 @@ class MOZ_STACK_CLASS FunctionGenerator
}
Bytes& bytes() {
return *bytes_;
return funcBytes_->bytes();
}
MOZ_MUST_USE bool addCallSiteLineNum(uint32_t lineno) {
return callSiteLineNums_.append(lineno);
return funcBytes_->addCallSiteLineNum(lineno);
}
};

37
js/src/wasm/WasmIonCompile.cpp
Просмотреть файл

@ -168,8 +168,6 @@ class FunctionCompiler
uint32_t blockDepth_;
ControlFlowPatchsVector blockPatches_;
FuncCompileResults& compileResults_;
// TLS pointer argument to the current function.
MWasmParameter* tlsPointer_;
@ -178,8 +176,7 @@ class FunctionCompiler
Decoder& decoder,
const FuncBytes& func,
const ValTypeVector& locals,
MIRGenerator& mirGen,
FuncCompileResults& compileResults)
MIRGenerator& mirGen)
: env_(env),
iter_(decoder, func.lineOrBytecode()),
func_(func),
@ -194,14 +191,12 @@ class FunctionCompiler
maxStackArgBytes_(0),
loopDepth_(0),
blockDepth_(0),
compileResults_(compileResults),
tlsPointer_(nullptr)
{}
const ModuleEnvironment& env() const { return env_; }
IonOpIter& iter() { return iter_; }
TempAllocator& alloc() const { return alloc_; }
MacroAssembler& masm() const { return compileResults_.masm(); }
const Sig& sig() const { return func_.sig(); }
TrapOffset trapOffset() const {
@ -3697,12 +3692,12 @@ EmitExpr(FunctionCompiler& f)
}
bool
wasm::IonCompileFunction(CompileTask* task)
wasm::IonCompileFunction(CompileTask* task, FuncCompileUnit* unit)
{
MOZ_ASSERT(task->mode() == CompileTask::CompileMode::Ion);
MOZ_ASSERT(unit->mode() == CompileMode::Ion);
const FuncBytes& func = task->func();
FuncCompileResults& results = task->results();
const FuncBytes& func = unit->func();
const ModuleEnvironment& env = task->env();
Decoder d(func.bytes());
@ -3711,18 +3706,18 @@ wasm::IonCompileFunction(CompileTask* task)
ValTypeVector locals;
if (!locals.appendAll(func.sig().args()))
return false;
if (!DecodeLocalEntries(d, task->env().kind, &locals))
if (!DecodeLocalEntries(d, env.kind, &locals))
return false;
// Set up for Ion compilation.
JitContext jitContext(&results.alloc());
JitContext jitContext(&task->alloc());
const JitCompileOptions options;
MIRGraph graph(&results.alloc());
MIRGraph graph(&task->alloc());
CompileInfo compileInfo(locals.length());
MIRGenerator mir(nullptr, options, &results.alloc(), &graph, &compileInfo,
MIRGenerator mir(nullptr, options, &task->alloc(), &graph, &compileInfo,
IonOptimizations.get(OptimizationLevel::Wasm));
mir.initMinWasmHeapLength(task->env().minMemoryLength);
mir.initMinWasmHeapLength(env.minMemoryLength);
// Capture the prologue's trap site before decoding the function.
@ -3730,7 +3725,7 @@ wasm::IonCompileFunction(CompileTask* task)
// Build MIR graph
{
FunctionCompiler f(task->env(), d, func, locals, mir, results);
FunctionCompiler f(env, d, func, locals, mir);
if (!f.init())
return false;
@ -3770,11 +3765,15 @@ wasm::IonCompileFunction(CompileTask* task)
if (!lir)
return false;
SigIdDesc sigId = task->env().funcSigs[func.index()]->id;
SigIdDesc sigId = env.funcSigs[func.index()]->id;
CodeGenerator codegen(&mir, lir, &results.masm());
if (!codegen.generateWasm(sigId, prologueTrapOffset, &results.offsets()))
CodeGenerator codegen(&mir, lir, &task->masm());
FuncOffsets offsets;
if (!codegen.generateWasm(sigId, prologueTrapOffset, &offsets))
return false;
unit->finish(offsets);
}
return true;

3
js/src/wasm/WasmIonCompile.h
Просмотреть файл

@ -25,10 +25,11 @@ namespace js {
namespace wasm {
class CompileTask;
class FuncCompileUnit;
// Generates very fast code at the expense of compilation time.
MOZ_MUST_USE bool
IonCompileFunction(CompileTask* task);
IonCompileFunction(CompileTask* task, FuncCompileUnit* unit);
} // namespace wasm
} // namespace js