| /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- |
| * vim: set ts=8 sts=4 et sw=4 tw=99: |
| * |
| * Copyright 2015 Mozilla Foundation |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #include "asmjs/WasmGenerator.h" |
| |
| #include "asmjs/AsmJSModule.h" |
| #include "asmjs/WasmStubs.h" |
| #ifdef MOZ_VTUNE |
| # include "vtune/VTuneWrapper.h" |
| #endif |
| |
| using namespace js; |
| using namespace js::jit; |
| using namespace js::wasm; |
| |
| static bool |
| ParallelCompilationEnabled(ExclusiveContext* cx) |
| { |
| // Since there are a fixed number of helper threads and one is already being |
| // consumed by this parsing task, ensure that there another free thread to |
| // avoid deadlock. (Note: there is at most one thread used for parsing so we |
| // don't have to worry about general dining philosophers.) |
| if (HelperThreadState().threadCount <= 1 || !CanUseExtraThreads()) |
| return false; |
| |
| // If 'cx' isn't a JSContext, then we are already off the main thread so |
| // off-thread compilation must be enabled. |
| return !cx->isJSContext() || cx->asJSContext()->runtime()->canUseOffthreadIonCompilation(); |
| } |
| |
| // **************************************************************************** |
| // ModuleGenerator |
| |
| static const unsigned GENERATOR_LIFO_DEFAULT_CHUNK_SIZE = 4 * 1024; |
| static const unsigned COMPILATION_LIFO_DEFAULT_CHUNK_SIZE = 64 * 1024; |
| |
| ModuleGenerator::ModuleGenerator(ExclusiveContext* cx) |
| : cx_(cx), |
| lifo_(GENERATOR_LIFO_DEFAULT_CHUNK_SIZE), |
| alloc_(&lifo_), |
| masm_(MacroAssembler::AsmJSToken(), &alloc_), |
| sigs_(cx), |
| parallel_(false), |
| outstanding_(0), |
| tasks_(cx), |
| freeTasks_(cx), |
| funcEntryOffsets_(cx), |
| funcPtrTables_(cx), |
| slowFuncs_(cx), |
| active_(nullptr) |
| {} |
| |
| ModuleGenerator::~ModuleGenerator() |
| { |
| if (parallel_) { |
| // Wait for any outstanding jobs to fail or complete. |
| if (outstanding_) { |
| AutoLockHelperThreadState lock; |
| while (true) { |
| CompileTaskVector& worklist = HelperThreadState().wasmWorklist(); |
| MOZ_ASSERT(outstanding_ >= worklist.length()); |
| outstanding_ -= worklist.length(); |
| worklist.clear(); |
| |
| CompileTaskVector& finished = HelperThreadState().wasmFinishedList(); |
| MOZ_ASSERT(outstanding_ >= finished.length()); |
| outstanding_ -= finished.length(); |
| finished.clear(); |
| |
| uint32_t numFailed = HelperThreadState().harvestFailedWasmJobs(); |
| MOZ_ASSERT(outstanding_ >= numFailed); |
| outstanding_ -= numFailed; |
| |
| if (!outstanding_) |
| break; |
| |
| HelperThreadState().wait(GlobalHelperThreadState::CONSUMER); |
| } |
| } |
| |
| MOZ_ASSERT(HelperThreadState().wasmCompilationInProgress); |
| HelperThreadState().wasmCompilationInProgress = false; |
| } else { |
| MOZ_ASSERT(!outstanding_); |
| } |
| } |
| |
| bool |
| ModuleGenerator::init(ScriptSource* ss, uint32_t srcStart, uint32_t srcBodyStart, bool strict) |
| { |
| if (!sigs_.init()) |
| return false; |
| |
| module_ = cx_->new_<AsmJSModule>(ss, srcStart, srcBodyStart, strict, cx_->canUseSignalHandlers()); |
| if (!module_) |
| return false; |
| |
| uint32_t numTasks; |
| if (ParallelCompilationEnabled(cx_) && |
| HelperThreadState().wasmCompilationInProgress.compareExchange(false, true)) |
| { |
| #ifdef DEBUG |
| { |
| AutoLockHelperThreadState lock; |
| MOZ_ASSERT(!HelperThreadState().wasmFailed()); |
| MOZ_ASSERT(HelperThreadState().wasmWorklist().empty()); |
| MOZ_ASSERT(HelperThreadState().wasmFinishedList().empty()); |
| } |
| #endif |
| |
| parallel_ = true; |
| numTasks = HelperThreadState().maxWasmCompilationThreads(); |
| } else { |
| numTasks = 1; |
| } |
| |
| if (!tasks_.initCapacity(numTasks)) |
| return false; |
| for (size_t i = 0; i < numTasks; i++) |
| tasks_.infallibleEmplaceBack(COMPILATION_LIFO_DEFAULT_CHUNK_SIZE, args()); |
| |
| if (!freeTasks_.reserve(numTasks)) |
| return false; |
| for (size_t i = 0; i < numTasks; i++) |
| freeTasks_.infallibleAppend(&tasks_[i]); |
| |
| return true; |
| } |
| |
| bool |
| ModuleGenerator::startFunc(PropertyName* name, unsigned line, unsigned column, |
| FunctionGenerator* fg) |
| { |
| MOZ_ASSERT(!active_); |
| |
| if (freeTasks_.empty() && !finishOutstandingTask()) |
| return false; |
| |
| CompileTask* task = freeTasks_.popCopy(); |
| FuncIR* func = task->lifo().new_<FuncIR>(task->lifo(), name, line, column); |
| if (!func) |
| return false; |
| |
| task->init(*func); |
| fg->m_ = this; |
| fg->task_ = task; |
| fg->func_ = func; |
| active_ = fg; |
| return true; |
| } |
| |
| bool |
| ModuleGenerator::finishFunc(uint32_t funcIndex, const LifoSig& sig, unsigned generateTime, |
| FunctionGenerator* fg) |
| { |
| MOZ_ASSERT(active_ == fg); |
| |
| fg->func_->finish(funcIndex, sig, generateTime); |
| |
| if (parallel_) { |
| if (!StartOffThreadWasmCompile(cx_, fg->task_)) |
| return false; |
| outstanding_++; |
| } else { |
| if (!CompileFunction(fg->task_)) |
| return false; |
| if (!finishTask(fg->task_)) |
| return false; |
| } |
| |
| fg->m_ = nullptr; |
| fg->task_ = nullptr; |
| fg->func_ = nullptr; |
| active_ = nullptr; |
| return true; |
| } |
| |
| bool |
| ModuleGenerator::finish(frontend::TokenStream& ts, ScopedJSDeletePtr<AsmJSModule>* module, |
| SlowFunctionVector* slowFuncs) |
| { |
| MOZ_ASSERT(!active_); |
| |
| while (outstanding_ > 0) { |
| if (!finishOutstandingTask()) |
| return false; |
| } |
| |
| module_->setFunctionBytes(masm_.size()); |
| |
| JitContext jitContext(CompileRuntime::get(args().runtime)); |
| |
| // Now that all function definitions have been compiled and their function- |
| // entry offsets are all known, patch inter-function calls and fill in the |
| // function-pointer table offsets. |
| |
| if (!GenerateStubs(masm_, *module_, funcEntryOffsets_)) |
| return false; |
| |
| for (auto& cs : masm_.callSites()) { |
| if (!cs.isInternal()) |
| continue; |
| MOZ_ASSERT(cs.kind() == CallSiteDesc::Relative); |
| uint32_t callerOffset = cs.returnAddressOffset(); |
| uint32_t calleeOffset = funcEntryOffsets_[cs.targetIndex()]; |
| masm_.patchCall(callerOffset, calleeOffset); |
| } |
| |
| for (unsigned tableIndex = 0; tableIndex < funcPtrTables_.length(); tableIndex++) { |
| FuncPtrTable& table = funcPtrTables_[tableIndex]; |
| AsmJSModule::OffsetVector entryOffsets; |
| for (uint32_t funcIndex : table.elems) |
| entryOffsets.append(funcEntryOffsets_[funcIndex]); |
| module_->funcPtrTable(tableIndex).define(Move(entryOffsets)); |
| } |
| |
| masm_.finish(); |
| if (masm_.oom()) |
| return false; |
| |
| if (!module_->finish(cx_, ts, masm_)) |
| return false; |
| |
| *module = module_.forget(); |
| *slowFuncs = Move(slowFuncs_); |
| return true; |
| } |
| |
| bool |
| ModuleGenerator::finishOutstandingTask() |
| { |
| MOZ_ASSERT(parallel_); |
| |
| CompileTask* task = nullptr; |
| { |
| AutoLockHelperThreadState lock; |
| while (true) { |
| MOZ_ASSERT(outstanding_ > 0); |
| |
| if (HelperThreadState().wasmFailed()) |
| return false; |
| |
| if (!HelperThreadState().wasmFinishedList().empty()) { |
| outstanding_--; |
| task = HelperThreadState().wasmFinishedList().popCopy(); |
| break; |
| } |
| |
| HelperThreadState().wait(GlobalHelperThreadState::CONSUMER); |
| } |
| } |
| |
| return finishTask(task); |
| } |
| |
| bool |
| ModuleGenerator::finishTask(CompileTask* task) |
| { |
| const FuncIR& func = task->func(); |
| FunctionCompileResults& results = task->results(); |
| |
| // Merge the compiled results into the whole-module masm. |
| size_t offset = masm_.size(); |
| if (!masm_.asmMergeWith(results.masm())) |
| return false; |
| |
| // Create the code range now that we know offset of results in whole masm. |
| AsmJSModule::CodeRange codeRange(func.line(), results.offsets()); |
| codeRange.functionOffsetBy(offset); |
| if (!module_->addFunctionCodeRange(func.name(), codeRange)) |
| return false; |
| |
| // Compilation may complete out of order, so cannot simply append(). |
| if (func.index() >= funcEntryOffsets_.length()) { |
| if (!funcEntryOffsets_.resize(func.index() + 1)) |
| return false; |
| } |
| funcEntryOffsets_[func.index()] = codeRange.entry(); |
| |
| // Keep a record of slow functions for printing in the final console message. |
| unsigned totalTime = func.generateTime() + results.compileTime(); |
| if (totalTime >= SlowFunction::msThreshold) { |
| if (!slowFuncs_.append(SlowFunction(func.name(), totalTime, func.line(), func.column()))) |
| return false; |
| } |
| |
| #if defined(MOZ_VTUNE) || defined(JS_ION_PERF) |
| AsmJSModule::ProfiledFunction pf(func.name(), codeRange.entry(), codeRange.end(), |
| func.line(), func.column()); |
| if (!module().addProfiledFunction(pf)) |
| return false; |
| #endif |
| |
| task->reset(); |
| freeTasks_.infallibleAppend(task); |
| return true; |
| } |
| |
| CompileArgs |
| ModuleGenerator::args() const |
| { |
| return CompileArgs(cx_->compartment()->runtimeFromAnyThread(), |
| module().usesSignalHandlersForOOB()); |
| } |
| |
| const LifoSig* |
| ModuleGenerator::newLifoSig(const MallocSig& sig) |
| { |
| SigSet::AddPtr p = sigs_.lookupForAdd(sig); |
| if (p) |
| return *p; |
| |
| LifoSig* lifoSig = LifoSig::new_(lifo_, sig); |
| if (!lifoSig || !sigs_.add(p, lifoSig)) |
| return nullptr; |
| |
| return lifoSig; |
| } |
| |
| bool |
| ModuleGenerator::declareFuncPtrTable(uint32_t numElems, uint32_t* funcPtrTableIndex) |
| { |
| // Here just add an uninitialized FuncPtrTable and claim space in the global |
| // data section. Later, 'defineFuncPtrTable' will be called with function |
| // indices for all the elements of the table. |
| |
| // Avoid easy way to OOM the process. |
| if (numElems > 1024 * 1024) |
| return false; |
| |
| if (!module_->declareFuncPtrTable(numElems, funcPtrTableIndex)) |
| return false; |
| |
| MOZ_ASSERT(*funcPtrTableIndex == funcPtrTables_.length()); |
| return funcPtrTables_.emplaceBack(numElems); |
| } |
| |
| bool |
| ModuleGenerator::defineFuncPtrTable(uint32_t funcPtrTableIndex, FuncIndexVector&& elems) |
| { |
| // The AsmJSModule needs to know the offsets in the code section which won't |
| // be known until 'finish'. So just remember the function indices for now |
| // and wait until 'finish' to hand over the offsets to the AsmJSModule. |
| |
| FuncPtrTable& table = funcPtrTables_[funcPtrTableIndex]; |
| if (table.numDeclared != elems.length() || !table.elems.empty()) |
| return false; |
| |
| table.elems = Move(elems); |
| return true; |
| } |
| |
