160 lines
4.7 KiB
C++
160 lines
4.7 KiB
C++
/* -*- 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.
|
|
*/
|
|
|
|
#ifndef wasm_ion_compile_h
|
|
#define wasm_ion_compile_h
|
|
|
|
#include "jit/MacroAssembler.h"
|
|
#include "wasm/WasmTypes.h"
|
|
|
|
namespace js {
|
|
namespace wasm {
|
|
|
|
struct ModuleGeneratorData;
|
|
|
|
typedef Vector<jit::MIRType, 8, SystemAllocPolicy> MIRTypeVector;
|
|
typedef jit::ABIArgIter<MIRTypeVector> ABIArgMIRTypeIter;
|
|
typedef jit::ABIArgIter<ValTypeVector> ABIArgValTypeIter;
|
|
|
|
// 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
|
|
{
|
|
Bytes bytes_;
|
|
uint32_t index_;
|
|
const SigWithId& sig_;
|
|
uint32_t lineOrBytecode_;
|
|
Uint32Vector callSiteLineNums_;
|
|
|
|
public:
|
|
FuncBytes(Bytes&& bytes,
|
|
uint32_t index,
|
|
const SigWithId& sig,
|
|
uint32_t lineOrBytecode,
|
|
Uint32Vector&& callSiteLineNums)
|
|
: bytes_(Move(bytes)),
|
|
index_(index),
|
|
sig_(sig),
|
|
lineOrBytecode_(lineOrBytecode),
|
|
callSiteLineNums_(Move(callSiteLineNums))
|
|
{}
|
|
|
|
Bytes& bytes() { return bytes_; }
|
|
const Bytes& bytes() const { return bytes_; }
|
|
uint32_t index() const { return index_; }
|
|
const SigWithId& sig() const { return sig_; }
|
|
uint32_t lineOrBytecode() const { return lineOrBytecode_; }
|
|
const Uint32Vector& callSiteLineNums() const { return callSiteLineNums_; }
|
|
};
|
|
|
|
typedef UniquePtr<FuncBytes> UniqueFuncBytes;
|
|
|
|
// The FuncCompileResults class contains the results of compiling a single
|
|
// function body, ready to be merged into the whole-module MacroAssembler.
|
|
|
|
class FuncCompileResults
|
|
{
|
|
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_; }
|
|
};
|
|
|
|
// An IonCompileTask represents the task of compiling a single function body. An
|
|
// IonCompileTask is filled with the wasm code to be compiled on the main
|
|
// validation thread, sent off to an Ion compilation helper thread which creates
|
|
// the FuncCompileResults, and finally sent back to the validation thread. To
|
|
// save time allocating and freeing memory, IonCompileTasks are reset() and
|
|
// reused.
|
|
|
|
class IonCompileTask
|
|
{
|
|
public:
|
|
enum class CompileMode { None, Baseline, Ion };
|
|
|
|
private:
|
|
const ModuleGeneratorData& mg_;
|
|
LifoAlloc lifo_;
|
|
UniqueFuncBytes func_;
|
|
CompileMode mode_;
|
|
Maybe<FuncCompileResults> results_;
|
|
|
|
IonCompileTask(const IonCompileTask&) = delete;
|
|
IonCompileTask& operator=(const IonCompileTask&) = delete;
|
|
|
|
public:
|
|
IonCompileTask(const ModuleGeneratorData& mg, size_t defaultChunkSize)
|
|
: mg_(mg), lifo_(defaultChunkSize), func_(nullptr), mode_(CompileMode::None)
|
|
{}
|
|
LifoAlloc& lifo() {
|
|
return lifo_;
|
|
}
|
|
const ModuleGeneratorData& mg() const {
|
|
return mg_;
|
|
}
|
|
void init(UniqueFuncBytes func, CompileMode mode) {
|
|
MOZ_ASSERT(!func_);
|
|
func_ = Move(func);
|
|
results_.emplace(lifo_);
|
|
mode_ = mode;
|
|
}
|
|
CompileMode mode() const {
|
|
return mode_;
|
|
}
|
|
const FuncBytes& func() const {
|
|
MOZ_ASSERT(func_);
|
|
return *func_;
|
|
}
|
|
FuncCompileResults& results() {
|
|
return *results_;
|
|
}
|
|
void reset(Bytes* recycled) {
|
|
if (func_)
|
|
*recycled = Move(func_->bytes());
|
|
func_.reset(nullptr);
|
|
results_.reset();
|
|
lifo_.releaseAll();
|
|
mode_ = CompileMode::None;
|
|
}
|
|
};
|
|
|
|
MOZ_MUST_USE bool
|
|
IonCompileFunction(IonCompileTask* task);
|
|
|
|
bool
|
|
CompileFunction(IonCompileTask* task);
|
|
|
|
} // namespace wasm
|
|
} // namespace js
|
|
|
|
#endif // wasm_ion_compile_h
|