Google Git
Sign in
android / platform / external / v8 / 8b7e11b / . / src / wasm / wasm-module.cc
blob: c9a42797eb93b5781e5c5ed6c2151e680879efa9 [file] [log] [blame]
// Copyright 2015 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "src/base/atomic-utils.h"
#include "src/macro-assembler.h"
#include "src/objects.h"
#include "src/property-descriptor.h"
#include "src/v8.h"
#include "src/simulator.h"
#include "src/wasm/ast-decoder.h"
#include "src/wasm/module-decoder.h"
#include "src/wasm/wasm-function-name-table.h"
#include "src/wasm/wasm-module.h"
#include "src/wasm/wasm-result.h"
#include "src/compiler/wasm-compiler.h"
namespace v8 {
namespace internal {
namespace wasm {
static const char* wasmSections[] = {
#define F(enumerator, order, string) string,
FOR_EACH_WASM_SECTION_TYPE(F)
#undef F
"<unknown>" // entry for "Max"
};
static uint8_t wasmSectionsLengths[]{
#define F(enumerator, order, string) sizeof(string) - 1,
FOR_EACH_WASM_SECTION_TYPE(F)
#undef F
9 // entry for "Max"
};
static uint8_t wasmSectionsOrders[]{
#define F(enumerator, order, string) order,
FOR_EACH_WASM_SECTION_TYPE(F)
#undef F
0 // entry for "Max"
};
static_assert(sizeof(wasmSections) / sizeof(wasmSections[0]) ==
(size_t)WasmSection::Code::Max + 1,
"expected enum WasmSection::Code to be monotonic from 0");
WasmSection::Code WasmSection::begin() { return (WasmSection::Code)0; }
WasmSection::Code WasmSection::end() { return WasmSection::Code::Max; }
WasmSection::Code WasmSection::next(WasmSection::Code code) {
return (WasmSection::Code)(1 + (uint32_t)code);
}
const char* WasmSection::getName(WasmSection::Code code) {
return wasmSections[(size_t)code];
}
size_t WasmSection::getNameLength(WasmSection::Code code) {
return wasmSectionsLengths[(size_t)code];
}
int WasmSection::getOrder(WasmSection::Code code) {
return wasmSectionsOrders[(size_t)code];
}
WasmSection::Code WasmSection::lookup(const byte* string, uint32_t length) {
// TODO(jfb) Linear search, it may be better to do a common-prefix search.
for (Code i = begin(); i != end(); i = next(i)) {
if (getNameLength(i) == length && 0 == memcmp(getName(i), string, length)) {
return i;
}
}
return Code::Max;
}
std::ostream& operator<<(std::ostream& os, const WasmModule& module) {
os << "WASM module with ";
os << (module.min_mem_pages * module.kPageSize) << " min mem";
os << (module.max_mem_pages * module.kPageSize) << " max mem";
os << module.functions.size() << " functions";
os << module.functions.size() << " globals";
os << module.functions.size() << " data segments";
return os;
}
std::ostream& operator<<(std::ostream& os, const WasmFunction& function) {
os << "WASM function with signature " << *function.sig;
os << " code bytes: "
<< (function.code_end_offset - function.code_start_offset);
return os;
}
std::ostream& operator<<(std::ostream& os, const WasmFunctionName& pair) {
os << "#" << pair.function_->func_index << ":";
if (pair.function_->name_offset > 0) {
if (pair.module_) {
WasmName name = pair.module_->GetName(pair.function_->name_offset,
pair.function_->name_length);
os.write(name.start(), name.length());
} else {
os << "+" << pair.function_->func_index;
}
} else {
os << "?";
}
return os;
}
// A helper class for compiling multiple wasm functions that offers
// placeholder code objects for calling functions that are not yet compiled.
class WasmLinker {
public:
WasmLinker(Isolate* isolate, size_t size)
: isolate_(isolate), placeholder_code_(size), function_code_(size) {}
// Get the code object for a function, allocating a placeholder if it has
// not yet been compiled.
Handle<Code> GetFunctionCode(uint32_t index) {
DCHECK(index < function_code_.size());
if (function_code_[index].is_null()) {
// Create a placeholder code object and encode the corresponding index in
// the {constant_pool_offset} field of the code object.
// TODO(titzer): placeholder code objects are somewhat dangerous.
byte buffer[] = {0, 0, 0, 0, 0, 0, 0, 0}; // fake instructions.
CodeDesc desc = {buffer, 8, 8, 0, 0, nullptr};
Handle<Code> code = isolate_->factory()->NewCode(
desc, Code::KindField::encode(Code::WASM_FUNCTION),
Handle<Object>::null());
code->set_constant_pool_offset(index + kPlaceholderMarker);
placeholder_code_[index] = code;
function_code_[index] = code;
}
return function_code_[index];
}
void Finish(uint32_t index, Handle<Code> code) {
DCHECK(index < function_code_.size());
function_code_[index] = code;
}
void Link(Handle<FixedArray> function_table,
std::vector<uint16_t>& functions) {
for (size_t i = 0; i < function_code_.size(); i++) {
LinkFunction(function_code_[i]);
}
if (!function_table.is_null()) {
int table_size = static_cast<int>(functions.size());
DCHECK_EQ(function_table->length(), table_size * 2);
for (int i = 0; i < table_size; i++) {
function_table->set(i + table_size, *function_code_[functions[i]]);
}
}
}
private:
static const int kPlaceholderMarker = 1000000000;
Isolate* isolate_;
std::vector<Handle<Code>> placeholder_code_;
std::vector<Handle<Code>> function_code_;
void LinkFunction(Handle<Code> code) {
bool modified = false;
int mode_mask = RelocInfo::kCodeTargetMask;
AllowDeferredHandleDereference embedding_raw_address;
for (RelocIterator it(*code, mode_mask); !it.done(); it.next()) {
RelocInfo::Mode mode = it.rinfo()->rmode();
if (RelocInfo::IsCodeTarget(mode)) {
Code* target =
Code::GetCodeFromTargetAddress(it.rinfo()->target_address());
if (target->kind() == Code::WASM_FUNCTION &&
target->constant_pool_offset() >= kPlaceholderMarker) {
// Patch direct calls to placeholder code objects.
uint32_t index = target->constant_pool_offset() - kPlaceholderMarker;
CHECK(index < function_code_.size());
Handle<Code> new_target = function_code_[index];
if (target != *new_target) {
CHECK_EQ(*placeholder_code_[index], target);
it.rinfo()->set_target_address(new_target->instruction_start(),
SKIP_WRITE_BARRIER,
SKIP_ICACHE_FLUSH);
modified = true;
}
}
}
}
if (modified) {
Assembler::FlushICache(isolate_, code->instruction_start(),
code->instruction_size());
}
}
};
namespace {
// Internal constants for the layout of the module object.
const int kWasmModuleInternalFieldCount = 5;
const int kWasmModuleFunctionTable = 0;
const int kWasmModuleCodeTable = 1;
const int kWasmMemArrayBuffer = 2;
const int kWasmGlobalsArrayBuffer = 3;
const int kWasmFunctionNamesArray = 4;
size_t AllocateGlobalsOffsets(std::vector<WasmGlobal>& globals) {
uint32_t offset = 0;
if (globals.size() == 0) return 0;
for (WasmGlobal& global : globals) {
byte size = WasmOpcodes::MemSize(global.type);
offset = (offset + size - 1) & ~(size - 1); // align
global.offset = offset;
offset += size;
}
return offset;
}
void LoadDataSegments(WasmModule* module, byte* mem_addr, size_t mem_size) {
for (const WasmDataSegment& segment : module->data_segments) {
if (!segment.init) continue;
if (!segment.source_size) continue;
CHECK_LT(segment.dest_addr, mem_size);
CHECK_LE(segment.source_size, mem_size);
CHECK_LE(segment.dest_addr + segment.source_size, mem_size);
byte* addr = mem_addr + segment.dest_addr;
memcpy(addr, module->module_start + segment.source_offset,
segment.source_size);
}
}
Handle<FixedArray> BuildFunctionTable(Isolate* isolate, WasmModule* module) {
if (module->function_table.size() == 0) {
return Handle<FixedArray>::null();
}
int table_size = static_cast<int>(module->function_table.size());
Handle<FixedArray> fixed = isolate->factory()->NewFixedArray(2 * table_size);
for (int i = 0; i < table_size; i++) {
WasmFunction* function = &module->functions[module->function_table[i]];
fixed->set(i, Smi::FromInt(function->sig_index));
}
return fixed;
}
Handle<JSArrayBuffer> NewArrayBuffer(Isolate* isolate, size_t size,
byte** backing_store) {
if (size > (WasmModule::kMaxMemPages * WasmModule::kPageSize)) {
// TODO(titzer): lift restriction on maximum memory allocated here.
*backing_store = nullptr;
return Handle<JSArrayBuffer>::null();
}
void* memory =
isolate->array_buffer_allocator()->Allocate(static_cast<int>(size));
if (!memory) {
*backing_store = nullptr;
return Handle<JSArrayBuffer>::null();
}
*backing_store = reinterpret_cast<byte*>(memory);
#if DEBUG
// Double check the API allocator actually zero-initialized the memory.
byte* bytes = reinterpret_cast<byte*>(*backing_store);
for (size_t i = 0; i < size; i++) {
DCHECK_EQ(0, bytes[i]);
}
#endif
Handle<JSArrayBuffer> buffer = isolate->factory()->NewJSArrayBuffer();
JSArrayBuffer::Setup(buffer, isolate, false, memory, static_cast<int>(size));
buffer->set_is_neuterable(false);
return buffer;
}
// Set the memory for a module instance to be the {memory} array buffer.
void SetMemory(WasmModuleInstance* instance, Handle<JSArrayBuffer> memory) {
memory->set_is_neuterable(false);
instance->mem_start = reinterpret_cast<byte*>(memory->backing_store());
instance->mem_size = memory->byte_length()->Number();
instance->mem_buffer = memory;
}
// Allocate memory for a module instance as a new JSArrayBuffer.
bool AllocateMemory(ErrorThrower* thrower, Isolate* isolate,
WasmModuleInstance* instance) {
DCHECK(instance->module);
DCHECK(instance->mem_buffer.is_null());
if (instance->module->min_mem_pages > WasmModule::kMaxMemPages) {
thrower->Error("Out of memory: wasm memory too large");
return false;
}
instance->mem_size = WasmModule::kPageSize * instance->module->min_mem_pages;
instance->mem_buffer =
NewArrayBuffer(isolate, instance->mem_size, &instance->mem_start);
if (!instance->mem_start) {
thrower->Error("Out of memory: wasm memory");
instance->mem_size = 0;
return false;
}
return true;
}
bool AllocateGlobals(ErrorThrower* thrower, Isolate* isolate,
WasmModuleInstance* instance) {
instance->globals_size = AllocateGlobalsOffsets(instance->module->globals);
if (instance->globals_size > 0) {
instance->globals_buffer = NewArrayBuffer(isolate, instance->globals_size,
&instance->globals_start);
if (!instance->globals_start) {
// Not enough space for backing store of globals.
thrower->Error("Out of memory: wasm globals");
return false;
}
}
return true;
}
} // namespace
WasmModule::WasmModule()
: shared_isolate(nullptr),
module_start(nullptr),
module_end(nullptr),
min_mem_pages(0),
max_mem_pages(0),
mem_export(false),
mem_external(false),
start_function_index(-1),
origin(kWasmOrigin) {}
static MaybeHandle<JSFunction> ReportFFIError(ErrorThrower& thrower,
const char* error, uint32_t index,
wasm::WasmName module_name,
wasm::WasmName function_name) {
if (function_name.start()) {
thrower.Error("Import #%d module=\"%.*s\" function=\"%.*s\" error: %s",
index, module_name.length(), module_name.start(),
function_name.length(), function_name.start(), error);
} else {
thrower.Error("Import #%d module=\"%.*s\" error: %s", index,
module_name.length(), module_name.start(), error);
}
thrower.Error("Import ");
return MaybeHandle<JSFunction>();
}
static MaybeHandle<JSFunction> LookupFunction(
ErrorThrower& thrower, Factory* factory, Handle<JSReceiver> ffi,
uint32_t index, wasm::WasmName module_name, wasm::WasmName function_name) {
if (ffi.is_null()) {
return ReportFFIError(thrower, "FFI is not an object", index, module_name,
function_name);
}
// Look up the module first.
Handle<String> name = factory->InternalizeUtf8String(module_name);
MaybeHandle<Object> result = Object::GetProperty(ffi, name);
if (result.is_null()) {
return ReportFFIError(thrower, "module not found", index, module_name,
function_name);
}
Handle<Object> module = result.ToHandleChecked();
if (!module->IsJSReceiver()) {
return ReportFFIError(thrower, "module is not an object or function", index,
module_name, function_name);
}
Handle<Object> function;
if (function_name.start()) {
// Look up the function in the module.
Handle<String> name = factory->InternalizeUtf8String(function_name);
MaybeHandle<Object> result = Object::GetProperty(module, name);
if (result.is_null()) {
return ReportFFIError(thrower, "function not found", index, module_name,
function_name);
}
function = result.ToHandleChecked();
} else {
// No function specified. Use the "default export".
function = module;
}
if (!function->IsJSFunction()) {
return ReportFFIError(thrower, "not a function", index, module_name,
function_name);
}
return Handle<JSFunction>::cast(function);
}
namespace {
// Fetches the compilation unit of a wasm function and executes its parallel
// phase.
bool FetchAndExecuteCompilationUnit(
Isolate* isolate,
std::vector<compiler::WasmCompilationUnit*>* compilation_units,
std::queue<compiler::WasmCompilationUnit*>* executed_units,
base::Mutex* result_mutex, base::AtomicNumber<size_t>* next_unit) {
DisallowHeapAllocation no_allocation;
DisallowHandleAllocation no_handles;
DisallowHandleDereference no_deref;
DisallowCodeDependencyChange no_dependency_change;
// - 1 because AtomicIntrement returns the value after the atomic increment.
size_t index = next_unit->Increment(1) - 1;
if (index >= compilation_units->size()) {
return false;
}
compiler::WasmCompilationUnit* unit = compilation_units->at(index);
if (unit != nullptr) {
compiler::ExecuteCompilation(unit);
{
base::LockGuard<base::Mutex> guard(result_mutex);
executed_units->push(unit);
}
}
return true;
}
class WasmCompilationTask : public CancelableTask {
public:
WasmCompilationTask(
Isolate* isolate,
std::vector<compiler::WasmCompilationUnit*>* compilation_units,
std::queue<compiler::WasmCompilationUnit*>* executed_units,
base::Semaphore* on_finished, base::Mutex* result_mutex,
base::AtomicNumber<size_t>* next_unit)
: CancelableTask(isolate),
isolate_(isolate),
compilation_units_(compilation_units),
executed_units_(executed_units),
on_finished_(on_finished),
result_mutex_(result_mutex),
next_unit_(next_unit) {}
void RunInternal() override {
while (FetchAndExecuteCompilationUnit(isolate_, compilation_units_,
executed_units_, result_mutex_,
next_unit_)) {
}
on_finished_->Signal();
}
Isolate* isolate_;
std::vector<compiler::WasmCompilationUnit*>* compilation_units_;
std::queue<compiler::WasmCompilationUnit*>* executed_units_;
base::Semaphore* on_finished_;
base::Mutex* result_mutex_;
base::AtomicNumber<size_t>* next_unit_;
};
void record_code_size(uint32_t& total_code_size, Code* code) {
if (FLAG_print_wasm_code_size) {
total_code_size += code->body_size() + code->relocation_info()->length();
}
}
bool CompileWrappersToImportedFunctions(Isolate* isolate, WasmModule* module,
const Handle<JSReceiver> ffi,
WasmModuleInstance* instance,
ErrorThrower* thrower, Factory* factory,
ModuleEnv* module_env,
uint32_t& total_code_size) {
uint32_t index = 0;
if (module->import_table.size() > 0) {
instance->import_code.reserve(module->import_table.size());
for (const WasmImport& import : module->import_table) {
WasmName module_name = module->GetNameOrNull(import.module_name_offset,
import.module_name_length);
WasmName function_name = module->GetNameOrNull(
import.function_name_offset, import.function_name_length);
MaybeHandle<JSFunction> function = LookupFunction(
*thrower, factory, ffi, index, module_name, function_name);
if (function.is_null()) return false;
Handle<Code> code = compiler::CompileWasmToJSWrapper(
isolate, module_env, function.ToHandleChecked(), import.sig,
module_name, function_name);
instance->import_code.push_back(code);
record_code_size(total_code_size, *code);
index++;
}
}
return true;
}
void InitializeParallelCompilation(
Isolate* isolate, std::vector<WasmFunction>& functions,
std::vector<compiler::WasmCompilationUnit*>& compilation_units,
ModuleEnv& module_env, ErrorThrower& thrower) {
// Create a placeholder code object for all functions.
// TODO(ahaas): Maybe we could skip this for external functions.
for (uint32_t i = 0; i < functions.size(); i++) {
module_env.linker->GetFunctionCode(i);
}
for (uint32_t i = FLAG_skip_compiling_wasm_funcs; i < functions.size(); i++) {
compilation_units[i] = compiler::CreateWasmCompilationUnit(
&thrower, isolate, &module_env, &functions[i], i);
}
}
uint32_t* StartCompilationTasks(
Isolate* isolate,
std::vector<compiler::WasmCompilationUnit*>& compilation_units,
std::queue<compiler::WasmCompilationUnit*>& executed_units,
const base::SmartPointer<base::Semaphore>& pending_tasks,
base::Mutex& result_mutex, base::AtomicNumber<size_t>& next_unit) {
const size_t num_tasks =
Min(static_cast<size_t>(FLAG_wasm_num_compilation_tasks),
V8::GetCurrentPlatform()->NumberOfAvailableBackgroundThreads());
uint32_t* task_ids = new uint32_t[num_tasks];
for (size_t i = 0; i < num_tasks; i++) {
WasmCompilationTask* task =
new WasmCompilationTask(isolate, &compilation_units, &executed_units,
pending_tasks.get(), &result_mutex, &next_unit);
task_ids[i] = task->id();
V8::GetCurrentPlatform()->CallOnBackgroundThread(
task, v8::Platform::kShortRunningTask);
}
return task_ids;
}
void WaitForCompilationTasks(
Isolate* isolate, uint32_t* task_ids,
const base::SmartPointer<base::Semaphore>& pending_tasks) {
const size_t num_tasks =
Min(static_cast<size_t>(FLAG_wasm_num_compilation_tasks),
V8::GetCurrentPlatform()->NumberOfAvailableBackgroundThreads());
for (size_t i = 0; i < num_tasks; i++) {
// If the task has not started yet, then we abort it. Otherwise we wait for
// it to finish.
if (!isolate->cancelable_task_manager()->TryAbort(task_ids[i])) {
pending_tasks->Wait();
}
}
}
void FinishCompilationUnits(
WasmModule* module,
std::queue<compiler::WasmCompilationUnit*>& executed_units,
std::vector<Handle<Code>>& results, base::Mutex& result_mutex) {
while (true) {
compiler::WasmCompilationUnit* unit = nullptr;
{
base::LockGuard<base::Mutex> guard(&result_mutex);
if (executed_units.empty()) {
break;
}
unit = executed_units.front();
executed_units.pop();
}
int j = compiler::GetIndexOfWasmCompilationUnit(unit);
results[j] = compiler::FinishCompilation(unit);
}
}
bool FinishCompilation(Isolate* isolate, WasmModule* module,
const Handle<JSReceiver> ffi,
const std::vector<Handle<Code>>& results,
const WasmModuleInstance& instance,
const Handle<FixedArray>& code_table,
ErrorThrower& thrower, Factory* factory,
ModuleEnv& module_env, uint32_t& total_code_size,
PropertyDescriptor& desc) {
for (uint32_t i = FLAG_skip_compiling_wasm_funcs;
i < module->functions.size(); i++) {
const WasmFunction& func = module->functions[i];
if (thrower.error()) break;
DCHECK_EQ(i, func.func_index);
WasmName str = module->GetName(func.name_offset, func.name_length);
Handle<Code> code = Handle<Code>::null();
Handle<JSFunction> function = Handle<JSFunction>::null();
Handle<String> function_name = Handle<String>::null();
if (FLAG_wasm_num_compilation_tasks != 0) {
code = results[i];
} else {
// Compile the function.
code =
compiler::CompileWasmFunction(&thrower, isolate, &module_env, &func);
}
if (code.is_null()) {
thrower.Error("Compilation of #%d:%.*s failed.", i, str.length(),
str.start());
return false;
}
if (func.exported) {
function_name = factory->InternalizeUtf8String(str);
function = compiler::CompileJSToWasmWrapper(
isolate, &module_env, function_name, code, instance.js_object, i);
record_code_size(total_code_size, function->code());
}
if (!code.is_null()) {
// Install the code into the linker table.
module_env.linker->Finish(i, code);
code_table->set(i, *code);
record_code_size(total_code_size, *code);
}
if (func.exported) {
// Exported functions are installed as read-only properties on the
// module.
desc.set_value(function);
Maybe<bool> status = JSReceiver::DefineOwnProperty(
isolate, instance.js_object, function_name, &desc,
Object::THROW_ON_ERROR);
if (!status.IsJust())
thrower.Error("export of %.*s failed.", str.length(), str.start());
}
}
return true;
}
} // namespace
// Instantiates a wasm module as a JSObject.
// * allocates a backing store of {mem_size} bytes.
// * installs a named property "memory" for that buffer if exported
// * installs named properties on the object for exported functions
// * compiles wasm code to machine code
MaybeHandle<JSObject> WasmModule::Instantiate(Isolate* isolate,
Handle<JSReceiver> ffi,
Handle<JSArrayBuffer> memory) {
HistogramTimerScope wasm_instantiate_module_time_scope(
isolate->counters()->wasm_instantiate_module_time());
this->shared_isolate = isolate; // TODO(titzer): have a real shared isolate.
ErrorThrower thrower(isolate, "WasmModule::Instantiate()");
Factory* factory = isolate->factory();
PropertyDescriptor desc;
desc.set_writable(false);
// If FLAG_print_wasm_code_size is set, this aggregates the sum of all code
// objects created for this module.
// TODO(titzer): switch this to TRACE_EVENT
uint32_t total_code_size = 0;
//-------------------------------------------------------------------------
// Allocate the instance and its JS counterpart.
//-------------------------------------------------------------------------
Handle<Map> map = factory->NewMap(
JS_OBJECT_TYPE,
JSObject::kHeaderSize + kWasmModuleInternalFieldCount * kPointerSize);
WasmModuleInstance instance(this);
instance.context = isolate->native_context();
instance.js_object = factory->NewJSObjectFromMap(map, TENURED);
Handle<FixedArray> code_table =
factory->NewFixedArray(static_cast<int>(functions.size()), TENURED);
instance.js_object->SetInternalField(kWasmModuleCodeTable, *code_table);
//-------------------------------------------------------------------------
// Allocate and initialize the linear memory.
//-------------------------------------------------------------------------
isolate->counters()->wasm_min_mem_pages_count()->AddSample(
instance.module->min_mem_pages);
isolate->counters()->wasm_max_mem_pages_count()->AddSample(
instance.module->max_mem_pages);
if (memory.is_null()) {
if (!AllocateMemory(&thrower, isolate, &instance)) {
return MaybeHandle<JSObject>();
}
} else {
SetMemory(&instance, memory);
}
instance.js_object->SetInternalField(kWasmMemArrayBuffer,
*instance.mem_buffer);
LoadDataSegments(this, instance.mem_start, instance.mem_size);
//-------------------------------------------------------------------------
// Allocate the globals area if necessary.
//-------------------------------------------------------------------------
if (!AllocateGlobals(&thrower, isolate, &instance)) {
return MaybeHandle<JSObject>();
}
if (!instance.globals_buffer.is_null()) {
instance.js_object->SetInternalField(kWasmGlobalsArrayBuffer,
*instance.globals_buffer);
}
HistogramTimerScope wasm_compile_module_time_scope(
isolate->counters()->wasm_compile_module_time());
instance.function_table = BuildFunctionTable(isolate, this);
WasmLinker linker(isolate, functions.size());
ModuleEnv module_env;
module_env.module = this;
module_env.instance = &instance;
module_env.linker = &linker;
module_env.origin = origin;
//-------------------------------------------------------------------------
// Compile wrappers to imported functions.
//-------------------------------------------------------------------------
if (!CompileWrappersToImportedFunctions(isolate, this, ffi, &instance,
&thrower, factory, &module_env,
total_code_size)) {
return MaybeHandle<JSObject>();
}
//-------------------------------------------------------------------------
// Compile all functions in the module.
//-------------------------------------------------------------------------
{
isolate->counters()->wasm_functions_per_module()->AddSample(
static_cast<int>(functions.size()));
// Data structures for the parallel compilation.
std::vector<compiler::WasmCompilationUnit*> compilation_units(
functions.size());
std::queue<compiler::WasmCompilationUnit*> executed_units;
std::vector<Handle<Code>> results(functions.size());
if (FLAG_wasm_num_compilation_tasks != 0) {
//-----------------------------------------------------------------------
// For parallel compilation:
// 1) The main thread allocates a compilation unit for each wasm function
// and stores them in the vector {compilation_units}.
// 2) The main thread spawns {WasmCompilationTask} instances which run on
// the background threads.
// 3.a) The background threads and the main thread pick one compilation
// unit at a time and execute the parallel phase of the compilation
// unit. After finishing the execution of the parallel phase, the
// result is enqueued in {executed_units}.
// 3.b) If {executed_units} contains a compilation unit, the main thread
// dequeues it and finishes the compilation.
// 4) After the parallel phase of all compilation units has started, the
// main thread waits for all {WasmCompilationTask} instances to finish.
// 5) The main thread finishes the compilation.
// Turn on the {CanonicalHandleScope} so that the background threads can
// use the node cache.
CanonicalHandleScope canonical(isolate);
// 1) The main thread allocates a compilation unit for each wasm function
// and stores them in the vector {compilation_units}.
InitializeParallelCompilation(isolate, functions, compilation_units,
module_env, thrower);
// Objects for the synchronization with the background threads.
base::SmartPointer<base::Semaphore> pending_tasks(new base::Semaphore(0));
base::Mutex result_mutex;
base::AtomicNumber<size_t> next_unit(
static_cast<size_t>(FLAG_skip_compiling_wasm_funcs));
// 2) The main thread spawns {WasmCompilationTask} instances which run on
// the background threads.
base::SmartArrayPointer<uint32_t> task_ids(
StartCompilationTasks(isolate, compilation_units, executed_units,
pending_tasks, result_mutex, next_unit));
// 3.a) The background threads and the main thread pick one compilation
// unit at a time and execute the parallel phase of the compilation
// unit. After finishing the execution of the parallel phase, the
// result is enqueued in {executed_units}.
while (FetchAndExecuteCompilationUnit(isolate, &compilation_units,
&executed_units, &result_mutex,
&next_unit)) {
// 3.b) If {executed_units} contains a compilation unit, the main thread
// dequeues it and finishes the compilation unit. Compilation units
// are finished concurrently to the background threads to save
// memory.
FinishCompilationUnits(this, executed_units, results, result_mutex);
}
// 4) After the parallel phase of all compilation units has started, the
// main thread waits for all {WasmCompilationTask} instances to finish.
WaitForCompilationTasks(isolate, task_ids.get(), pending_tasks);
// Finish the compilation of the remaining compilation units.
FinishCompilationUnits(this, executed_units, results, result_mutex);
}
// 5) The main thread finishes the compilation.
if (!FinishCompilation(isolate, this, ffi, results, instance, code_table,
thrower, factory, module_env, total_code_size,
desc)) {
return MaybeHandle<JSObject>();
}
// Patch all direct call sites.
linker.Link(instance.function_table, this->function_table);
instance.js_object->SetInternalField(kWasmModuleFunctionTable,
Smi::FromInt(0));
//-------------------------------------------------------------------------
// Create and populate the exports object.
//-------------------------------------------------------------------------
if (export_table.size() > 0 || mem_export) {
// Create the "exports" object.
Handle<JSFunction> object_function = Handle<JSFunction>(
isolate->native_context()->object_function(), isolate);
Handle<JSObject> exports_object =
factory->NewJSObject(object_function, TENURED);
Handle<String> exports_name = factory->InternalizeUtf8String("exports");
JSObject::AddProperty(instance.js_object, exports_name, exports_object,
READ_ONLY);
// Compile wrappers and add them to the exports object.
for (const WasmExport& exp : export_table) {
if (thrower.error()) break;
WasmName str = GetName(exp.name_offset, exp.name_length);
Handle<String> name = factory->InternalizeUtf8String(str);
Handle<Code> code = linker.GetFunctionCode(exp.func_index);
Handle<JSFunction> function = compiler::CompileJSToWasmWrapper(
isolate, &module_env, name, code, instance.js_object,
exp.func_index);
record_code_size(total_code_size, function->code());
desc.set_value(function);
Maybe<bool> status = JSReceiver::DefineOwnProperty(
isolate, exports_object, name, &desc, Object::THROW_ON_ERROR);
if (!status.IsJust())
thrower.Error("export of %.*s failed.", str.length(), str.start());
}
if (mem_export) {
// Export the memory as a named property.
Handle<String> name = factory->InternalizeUtf8String("memory");
JSObject::AddProperty(exports_object, name, instance.mem_buffer,
READ_ONLY);
}
}
}
//-------------------------------------------------------------------------
// Attach an array with function names and an array with offsets into that
// first array.
//-------------------------------------------------------------------------
{
Handle<Object> arr = BuildFunctionNamesTable(isolate, module_env.module);
instance.js_object->SetInternalField(kWasmFunctionNamesArray, *arr);
}
if (FLAG_print_wasm_code_size)
printf("Total generated wasm code: %u bytes\n", total_code_size);
// Run the start function if one was specified.
if (this->start_function_index >= 0) {
HandleScope scope(isolate);
uint32_t index = static_cast<uint32_t>(this->start_function_index);
Handle<String> name = isolate->factory()->NewStringFromStaticChars("start");
Handle<Code> code = linker.GetFunctionCode(index);
Handle<JSFunction> jsfunc = compiler::CompileJSToWasmWrapper(
isolate, &module_env, name, code, instance.js_object, index);
// Call the JS function.
Handle<Object> undefined(isolate->heap()->undefined_value(), isolate);
MaybeHandle<Object> retval =
Execution::Call(isolate, jsfunc, undefined, 0, nullptr);
if (retval.is_null()) {
thrower.Error("WASM.instantiateModule(): start function failed");
}
}
return instance.js_object;
}
Handle<Code> ModuleEnv::GetFunctionCode(uint32_t index) {
DCHECK(IsValidFunction(index));
if (linker) return linker->GetFunctionCode(index);
return instance ? instance->function_code[index] : Handle<Code>::null();
}
Handle<Code> ModuleEnv::GetImportCode(uint32_t index) {
DCHECK(IsValidImport(index));
return instance ? instance->import_code[index] : Handle<Code>::null();
}
compiler::CallDescriptor* ModuleEnv::GetCallDescriptor(Zone* zone,
uint32_t index) {
DCHECK(IsValidFunction(index));
// Always make a direct call to whatever is in the table at that location.
// A wrapper will be generated for FFI calls.
WasmFunction* function = &module->functions[index];
return GetWasmCallDescriptor(zone, function->sig);
}
int32_t CompileAndRunWasmModule(Isolate* isolate, const byte* module_start,
const byte* module_end, bool asm_js) {
HandleScope scope(isolate);
Zone zone(isolate->allocator());
// Decode the module, but don't verify function bodies, since we'll
// be compiling them anyway.
ModuleResult result = DecodeWasmModule(isolate, &zone, module_start,
module_end, false, kWasmOrigin);
if (result.failed()) {
if (result.val) {
delete result.val;
}
// Module verification failed. throw.
std::ostringstream str;
str << "WASM.compileRun() failed: " << result;
isolate->Throw(
*isolate->factory()->NewStringFromAsciiChecked(str.str().c_str()));
return -1;
}
int32_t retval = CompileAndRunWasmModule(isolate, result.val);
delete result.val;
return retval;
}
int32_t CompileAndRunWasmModule(Isolate* isolate, WasmModule* module) {
ErrorThrower thrower(isolate, "CompileAndRunWasmModule");
WasmModuleInstance instance(module);
// Allocate and initialize the linear memory.
if (!AllocateMemory(&thrower, isolate, &instance)) {
return -1;
}
LoadDataSegments(module, instance.mem_start, instance.mem_size);
// Allocate the globals area if necessary.
if (!AllocateGlobals(&thrower, isolate, &instance)) {
return -1;
}
// Build the function table.
instance.function_table = BuildFunctionTable(isolate, module);
// Create module environment.
WasmLinker linker(isolate, module->functions.size());
ModuleEnv module_env;
module_env.module = module;
module_env.instance = &instance;
module_env.linker = &linker;
module_env.origin = module->origin;
// Compile all functions.
Handle<Code> main_code = Handle<Code>::null(); // record last code.
uint32_t index = 0;
int main_index = 0;
for (const WasmFunction& func : module->functions) {
DCHECK_EQ(index, func.func_index);
// Compile the function and install it in the code table.
Handle<Code> code =
compiler::CompileWasmFunction(&thrower, isolate, &module_env, &func);
if (!code.is_null()) {
if (func.exported) {
main_code = code;
main_index = index;
}
linker.Finish(index, code);
}
if (thrower.error()) return -1;
index++;
}
if (main_code.is_null()) {
thrower.Error("WASM.compileRun() failed: no main code found");
return -1;
}
linker.Link(instance.function_table, instance.module->function_table);
// Wrap the main code so it can be called as a JS function.
Handle<String> name = isolate->factory()->NewStringFromStaticChars("main");
Handle<JSObject> module_object = Handle<JSObject>(0, isolate);
Handle<JSFunction> jsfunc = compiler::CompileJSToWasmWrapper(
isolate, &module_env, name, main_code, module_object, main_index);
// Call the JS function.
Handle<Object> undefined(isolate->heap()->undefined_value(), isolate);
MaybeHandle<Object> retval =
Execution::Call(isolate, jsfunc, undefined, 0, nullptr);
// The result should be a number.
if (retval.is_null()) {
thrower.Error("WASM.compileRun() failed: Invocation was null");
return -1;
}
Handle<Object> result = retval.ToHandleChecked();
if (result->IsSmi()) {
return Smi::cast(*result)->value();
}
if (result->IsHeapNumber()) {
return static_cast<int32_t>(HeapNumber::cast(*result)->value());
}
thrower.Error("WASM.compileRun() failed: Return value should be number");
return -1;
}
Handle<Object> GetWasmFunctionName(Handle<JSObject> wasm, uint32_t func_index) {
Handle<Object> func_names_arr_obj = handle(
wasm->GetInternalField(kWasmFunctionNamesArray), wasm->GetIsolate());
if (func_names_arr_obj->IsUndefined())
return func_names_arr_obj; // Return undefined.
return GetWasmFunctionNameFromTable(
Handle<ByteArray>::cast(func_names_arr_obj), func_index);
}
} // namespace wasm
} // namespace internal
} // namespace v8