2017-09-01 12:57:34 +00:00
|
|
|
// Copyright 2017 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 "test/cctest/wasm/wasm-run-utils.h"
|
|
|
|
|
2017-09-11 11:40:20 +00:00
|
|
|
#include "src/api.h"
|
2017-09-13 10:56:20 +00:00
|
|
|
#include "src/assembler-inl.h"
|
2017-10-02 08:27:24 +00:00
|
|
|
#include "src/wasm/wasm-memory.h"
|
2017-09-08 08:39:19 +00:00
|
|
|
#include "src/wasm/wasm-objects-inl.h"
|
|
|
|
|
2017-09-01 12:57:34 +00:00
|
|
|
namespace v8 {
|
|
|
|
namespace internal {
|
|
|
|
namespace wasm {
|
|
|
|
|
2017-09-12 12:39:42 +00:00
|
|
|
TestingModuleBuilder::TestingModuleBuilder(
|
|
|
|
Zone* zone, WasmExecutionMode mode,
|
2018-01-05 08:43:05 +00:00
|
|
|
compiler::RuntimeExceptionSupport exception_support, LowerSimd lower_simd)
|
2017-09-01 12:57:34 +00:00
|
|
|
: test_module_ptr_(&test_module_),
|
|
|
|
isolate_(CcTest::InitIsolateOnce()),
|
|
|
|
global_offset(0),
|
|
|
|
mem_start_(nullptr),
|
|
|
|
mem_size_(0),
|
2017-09-12 12:39:42 +00:00
|
|
|
interpreter_(nullptr),
|
2017-10-25 12:46:43 +00:00
|
|
|
execution_mode_(mode),
|
2017-10-05 20:22:49 +00:00
|
|
|
runtime_exception_support_(exception_support),
|
2018-01-05 08:43:05 +00:00
|
|
|
lower_simd_(lower_simd) {
|
2017-09-04 12:15:18 +00:00
|
|
|
WasmJs::Install(isolate_, true);
|
2017-09-01 12:57:34 +00:00
|
|
|
test_module_.globals_size = kMaxGlobalsSize;
|
|
|
|
memset(globals_data_, 0, sizeof(globals_data_));
|
|
|
|
instance_object_ = InitInstanceObject();
|
2017-11-02 14:04:14 +00:00
|
|
|
if (mode == kExecuteInterpreter) {
|
2017-09-01 12:57:34 +00:00
|
|
|
interpreter_ = WasmDebugInfo::SetupForTesting(instance_object_);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
byte* TestingModuleBuilder::AddMemory(uint32_t size) {
|
|
|
|
CHECK(!test_module_.has_memory);
|
|
|
|
CHECK_NULL(mem_start_);
|
|
|
|
CHECK_EQ(0, mem_size_);
|
[wasm] Introduce the WasmContext
The WasmContext struct introduced in this CL is used to store the
mem_size and mem_start address of the wasm memory. These variables can
be accessed at C++ level at graph build time (e.g., initialized during
instance building). When the GrowMemory runtime is invoked, the context
variables can be changed in the WasmContext at C++ level so that the
generated code will load the correct values.
This requires to insert a relocatable pointer only in the
JSToWasmWrapper (and in the other wasm entry points), the value is then
passed from function to function as an automatically added additional
parameter. The WasmContext is then dropped when creating an Interpreter
Entry or when invoking a JavaScript function. This removes the need of
patching the generated code at runtime (i.e., when the memory grows)
with respect to WASM_MEMORY_REFERENCE and WASM_MEMORY_SIZE_REFERENCE.
However, we still need to patch the code at instance build time to patch
the JSToWasmWrappers; in fact the address of the WasmContext is not
known during compilation, but only when the instance is built.
The WasmContext address is passed as the first parameter. This has the
advantage of not having to move the WasmContext around if the function
does not use many registers. This CL also changes the wasm calling
convention so that the first parameter register is different from the
return value register. The WasmContext is attached to every
WasmMemoryObject, to share the same context with multiple instances
sharing the same memory. Moreover, the nodes representing the
WasmContext variables are cached in the SSA environment, similarly to
other local variables that might change during execution. The nodes are
created when initializing the SSA environment and refreshed every time a
grow_memory or a function call happens, so that we are sure that they
always represent the correct mem_size and mem_start variables.
This CL also removes the WasmMemorySize runtime (since it's now possible
to directly retrieve mem_size from the context) and simplifies the
GrowMemory runtime (since every instance now has a memory_object).
R=ahaas@chromium.org,clemensh@chromium.org
CC=gdeepti@chromium.org
Change-Id: I3f058e641284f5a1bbbfc35a64c88da6ff08e240
Reviewed-on: https://chromium-review.googlesource.com/671008
Commit-Queue: Enrico Bacis <enricobacis@google.com>
Reviewed-by: Clemens Hammacher <clemensh@chromium.org>
Reviewed-by: Andreas Haas <ahaas@chromium.org>
Cr-Commit-Position: refs/heads/master@{#48209}
2017-09-28 14:59:37 +00:00
|
|
|
DCHECK(!instance_object_->has_memory_object());
|
2017-09-01 12:57:34 +00:00
|
|
|
test_module_.has_memory = true;
|
2017-10-09 22:42:48 +00:00
|
|
|
const bool enable_guard_regions =
|
2017-12-05 23:09:14 +00:00
|
|
|
trap_handler::IsTrapHandlerEnabled() && test_module_.is_wasm();
|
2017-09-01 12:57:34 +00:00
|
|
|
uint32_t alloc_size =
|
2017-12-15 17:59:57 +00:00
|
|
|
enable_guard_regions ? RoundUp(size, CommitPageSize()) : size;
|
2017-09-01 12:57:34 +00:00
|
|
|
Handle<JSArrayBuffer> new_buffer =
|
|
|
|
wasm::NewArrayBuffer(isolate_, alloc_size, enable_guard_regions);
|
|
|
|
CHECK(!new_buffer.is_null());
|
|
|
|
mem_start_ = reinterpret_cast<byte*>(new_buffer->backing_store());
|
|
|
|
mem_size_ = size;
|
|
|
|
CHECK(size == 0 || mem_start_);
|
|
|
|
memset(mem_start_, 0, size);
|
|
|
|
|
[wasm] Introduce the WasmContext
The WasmContext struct introduced in this CL is used to store the
mem_size and mem_start address of the wasm memory. These variables can
be accessed at C++ level at graph build time (e.g., initialized during
instance building). When the GrowMemory runtime is invoked, the context
variables can be changed in the WasmContext at C++ level so that the
generated code will load the correct values.
This requires to insert a relocatable pointer only in the
JSToWasmWrapper (and in the other wasm entry points), the value is then
passed from function to function as an automatically added additional
parameter. The WasmContext is then dropped when creating an Interpreter
Entry or when invoking a JavaScript function. This removes the need of
patching the generated code at runtime (i.e., when the memory grows)
with respect to WASM_MEMORY_REFERENCE and WASM_MEMORY_SIZE_REFERENCE.
However, we still need to patch the code at instance build time to patch
the JSToWasmWrappers; in fact the address of the WasmContext is not
known during compilation, but only when the instance is built.
The WasmContext address is passed as the first parameter. This has the
advantage of not having to move the WasmContext around if the function
does not use many registers. This CL also changes the wasm calling
convention so that the first parameter register is different from the
return value register. The WasmContext is attached to every
WasmMemoryObject, to share the same context with multiple instances
sharing the same memory. Moreover, the nodes representing the
WasmContext variables are cached in the SSA environment, similarly to
other local variables that might change during execution. The nodes are
created when initializing the SSA environment and refreshed every time a
grow_memory or a function call happens, so that we are sure that they
always represent the correct mem_size and mem_start variables.
This CL also removes the WasmMemorySize runtime (since it's now possible
to directly retrieve mem_size from the context) and simplifies the
GrowMemory runtime (since every instance now has a memory_object).
R=ahaas@chromium.org,clemensh@chromium.org
CC=gdeepti@chromium.org
Change-Id: I3f058e641284f5a1bbbfc35a64c88da6ff08e240
Reviewed-on: https://chromium-review.googlesource.com/671008
Commit-Queue: Enrico Bacis <enricobacis@google.com>
Reviewed-by: Clemens Hammacher <clemensh@chromium.org>
Reviewed-by: Andreas Haas <ahaas@chromium.org>
Cr-Commit-Position: refs/heads/master@{#48209}
2017-09-28 14:59:37 +00:00
|
|
|
// Create the WasmMemoryObject.
|
|
|
|
Handle<WasmMemoryObject> memory_object = WasmMemoryObject::New(
|
|
|
|
isolate_, new_buffer,
|
|
|
|
(test_module_.maximum_pages != 0) ? test_module_.maximum_pages : -1);
|
|
|
|
instance_object_->set_memory_object(*memory_object);
|
|
|
|
WasmMemoryObject::AddInstance(isolate_, memory_object, instance_object_);
|
|
|
|
// TODO(wasm): Delete the following two lines when test-run-wasm will use a
|
|
|
|
// multiple of kPageSize as memory size. At the moment, the effect of these
|
|
|
|
// two lines is used to shrink the memory for testing purposes.
|
2017-12-15 19:47:29 +00:00
|
|
|
instance_object_->wasm_context()->get()->SetRawMemory(mem_start_, mem_size_);
|
2017-09-01 12:57:34 +00:00
|
|
|
return mem_start_;
|
|
|
|
}
|
|
|
|
|
2017-11-28 22:25:36 +00:00
|
|
|
uint32_t TestingModuleBuilder::AddFunction(FunctionSig* sig, const char* name) {
|
2017-09-01 12:57:34 +00:00
|
|
|
if (test_module_.functions.size() == 0) {
|
|
|
|
// TODO(titzer): Reserving space here to avoid the underlying WasmFunction
|
|
|
|
// structs from moving.
|
|
|
|
test_module_.functions.reserve(kMaxFunctions);
|
|
|
|
}
|
|
|
|
uint32_t index = static_cast<uint32_t>(test_module_.functions.size());
|
2017-11-28 22:25:36 +00:00
|
|
|
if (FLAG_wasm_jit_to_native) {
|
|
|
|
native_module_->ResizeCodeTableForTest(index);
|
|
|
|
}
|
2017-09-01 12:57:34 +00:00
|
|
|
test_module_.functions.push_back(
|
|
|
|
{sig, index, 0, {0, 0}, {0, 0}, false, false});
|
|
|
|
if (name) {
|
|
|
|
Vector<const byte> name_vec = Vector<const byte>::cast(CStrVector(name));
|
|
|
|
test_module_.functions.back().name = {
|
|
|
|
AddBytes(name_vec), static_cast<uint32_t>(name_vec.length())};
|
|
|
|
}
|
2017-11-28 22:25:36 +00:00
|
|
|
function_code_.push_back(Handle<Code>::null());
|
2017-09-01 12:57:34 +00:00
|
|
|
if (interpreter_) {
|
|
|
|
interpreter_->AddFunctionForTesting(&test_module_.functions.back());
|
|
|
|
}
|
|
|
|
DCHECK_LT(index, kMaxFunctions); // limited for testing.
|
|
|
|
return index;
|
|
|
|
}
|
|
|
|
|
2017-09-08 02:55:51 +00:00
|
|
|
uint32_t TestingModuleBuilder::AddJsFunction(
|
|
|
|
FunctionSig* sig, const char* source, Handle<FixedArray> js_imports_table) {
|
2017-09-01 12:57:34 +00:00
|
|
|
Handle<JSFunction> jsfunc = Handle<JSFunction>::cast(v8::Utils::OpenHandle(
|
|
|
|
*v8::Local<v8::Function>::Cast(CompileRun(source))));
|
2017-11-28 22:25:36 +00:00
|
|
|
uint32_t index = AddFunction(sig, nullptr);
|
2017-09-21 00:02:33 +00:00
|
|
|
js_imports_table->set(0, *isolate_->native_context());
|
2017-12-08 01:31:37 +00:00
|
|
|
// TODO(6792): No longer needed once WebAssembly code is off heap.
|
|
|
|
CodeSpaceMemoryModificationScope modification_scope(isolate_->heap());
|
|
|
|
Handle<Code> code = compiler::CompileWasmToJSWrapper(
|
|
|
|
isolate_, jsfunc, sig, index, test_module_.origin(),
|
|
|
|
trap_handler::IsTrapHandlerEnabled(), js_imports_table);
|
2017-11-28 22:25:36 +00:00
|
|
|
if (FLAG_wasm_jit_to_native) {
|
|
|
|
native_module_->ResizeCodeTableForTest(index);
|
2017-12-08 01:31:37 +00:00
|
|
|
native_module_->AddCodeCopy(code, wasm::WasmCode::kWasmToJsWrapper, index);
|
2017-11-28 22:25:36 +00:00
|
|
|
} else {
|
|
|
|
function_code_[index] = code;
|
|
|
|
}
|
2017-09-01 12:57:34 +00:00
|
|
|
return index;
|
|
|
|
}
|
|
|
|
|
|
|
|
Handle<JSFunction> TestingModuleBuilder::WrapCode(uint32_t index) {
|
|
|
|
// Wrap the code so it can be called as a JS function.
|
2017-11-28 22:25:36 +00:00
|
|
|
Link();
|
|
|
|
WasmCodeWrapper code = FLAG_wasm_jit_to_native
|
|
|
|
? WasmCodeWrapper(native_module_->GetCode(index))
|
|
|
|
: WasmCodeWrapper(function_code_[index]);
|
[wasm] Introduce the WasmContext
The WasmContext struct introduced in this CL is used to store the
mem_size and mem_start address of the wasm memory. These variables can
be accessed at C++ level at graph build time (e.g., initialized during
instance building). When the GrowMemory runtime is invoked, the context
variables can be changed in the WasmContext at C++ level so that the
generated code will load the correct values.
This requires to insert a relocatable pointer only in the
JSToWasmWrapper (and in the other wasm entry points), the value is then
passed from function to function as an automatically added additional
parameter. The WasmContext is then dropped when creating an Interpreter
Entry or when invoking a JavaScript function. This removes the need of
patching the generated code at runtime (i.e., when the memory grows)
with respect to WASM_MEMORY_REFERENCE and WASM_MEMORY_SIZE_REFERENCE.
However, we still need to patch the code at instance build time to patch
the JSToWasmWrappers; in fact the address of the WasmContext is not
known during compilation, but only when the instance is built.
The WasmContext address is passed as the first parameter. This has the
advantage of not having to move the WasmContext around if the function
does not use many registers. This CL also changes the wasm calling
convention so that the first parameter register is different from the
return value register. The WasmContext is attached to every
WasmMemoryObject, to share the same context with multiple instances
sharing the same memory. Moreover, the nodes representing the
WasmContext variables are cached in the SSA environment, similarly to
other local variables that might change during execution. The nodes are
created when initializing the SSA environment and refreshed every time a
grow_memory or a function call happens, so that we are sure that they
always represent the correct mem_size and mem_start variables.
This CL also removes the WasmMemorySize runtime (since it's now possible
to directly retrieve mem_size from the context) and simplifies the
GrowMemory runtime (since every instance now has a memory_object).
R=ahaas@chromium.org,clemensh@chromium.org
CC=gdeepti@chromium.org
Change-Id: I3f058e641284f5a1bbbfc35a64c88da6ff08e240
Reviewed-on: https://chromium-review.googlesource.com/671008
Commit-Queue: Enrico Bacis <enricobacis@google.com>
Reviewed-by: Clemens Hammacher <clemensh@chromium.org>
Reviewed-by: Andreas Haas <ahaas@chromium.org>
Cr-Commit-Position: refs/heads/master@{#48209}
2017-09-28 14:59:37 +00:00
|
|
|
byte* context_address =
|
|
|
|
test_module_.has_memory
|
2018-01-10 10:01:26 +00:00
|
|
|
? reinterpret_cast<byte*>(instance_object_->wasm_context()->get())
|
[wasm] Introduce the WasmContext
The WasmContext struct introduced in this CL is used to store the
mem_size and mem_start address of the wasm memory. These variables can
be accessed at C++ level at graph build time (e.g., initialized during
instance building). When the GrowMemory runtime is invoked, the context
variables can be changed in the WasmContext at C++ level so that the
generated code will load the correct values.
This requires to insert a relocatable pointer only in the
JSToWasmWrapper (and in the other wasm entry points), the value is then
passed from function to function as an automatically added additional
parameter. The WasmContext is then dropped when creating an Interpreter
Entry or when invoking a JavaScript function. This removes the need of
patching the generated code at runtime (i.e., when the memory grows)
with respect to WASM_MEMORY_REFERENCE and WASM_MEMORY_SIZE_REFERENCE.
However, we still need to patch the code at instance build time to patch
the JSToWasmWrappers; in fact the address of the WasmContext is not
known during compilation, but only when the instance is built.
The WasmContext address is passed as the first parameter. This has the
advantage of not having to move the WasmContext around if the function
does not use many registers. This CL also changes the wasm calling
convention so that the first parameter register is different from the
return value register. The WasmContext is attached to every
WasmMemoryObject, to share the same context with multiple instances
sharing the same memory. Moreover, the nodes representing the
WasmContext variables are cached in the SSA environment, similarly to
other local variables that might change during execution. The nodes are
created when initializing the SSA environment and refreshed every time a
grow_memory or a function call happens, so that we are sure that they
always represent the correct mem_size and mem_start variables.
This CL also removes the WasmMemorySize runtime (since it's now possible
to directly retrieve mem_size from the context) and simplifies the
GrowMemory runtime (since every instance now has a memory_object).
R=ahaas@chromium.org,clemensh@chromium.org
CC=gdeepti@chromium.org
Change-Id: I3f058e641284f5a1bbbfc35a64c88da6ff08e240
Reviewed-on: https://chromium-review.googlesource.com/671008
Commit-Queue: Enrico Bacis <enricobacis@google.com>
Reviewed-by: Clemens Hammacher <clemensh@chromium.org>
Reviewed-by: Andreas Haas <ahaas@chromium.org>
Cr-Commit-Position: refs/heads/master@{#48209}
2017-09-28 14:59:37 +00:00
|
|
|
: nullptr;
|
|
|
|
Handle<Code> ret_code = compiler::CompileJSToWasmWrapper(
|
2017-12-05 23:09:14 +00:00
|
|
|
isolate_, &test_module_, code, index, context_address,
|
|
|
|
trap_handler::IsTrapHandlerEnabled());
|
2017-09-01 12:57:34 +00:00
|
|
|
Handle<JSFunction> ret = WasmExportedFunction::New(
|
|
|
|
isolate_, instance_object(), MaybeHandle<String>(),
|
|
|
|
static_cast<int>(index),
|
|
|
|
static_cast<int>(test_module_.functions[index].sig->parameter_count()),
|
|
|
|
ret_code);
|
|
|
|
|
|
|
|
// Add weak reference to exported functions.
|
|
|
|
Handle<WasmCompiledModule> compiled_module(
|
|
|
|
instance_object()->compiled_module(), isolate_);
|
2017-12-18 14:08:14 +00:00
|
|
|
Handle<FixedArray> old_arr(compiled_module->weak_exported_functions(),
|
|
|
|
isolate_);
|
2017-09-01 12:57:34 +00:00
|
|
|
Handle<FixedArray> new_arr =
|
|
|
|
isolate_->factory()->NewFixedArray(old_arr->length() + 1);
|
|
|
|
old_arr->CopyTo(0, *new_arr, 0, old_arr->length());
|
|
|
|
Handle<WeakCell> weak_fn = isolate_->factory()->NewWeakCell(ret);
|
|
|
|
new_arr->set(old_arr->length(), *weak_fn);
|
2017-12-18 14:08:14 +00:00
|
|
|
compiled_module->set_weak_exported_functions(*new_arr);
|
2017-09-01 12:57:34 +00:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2018-01-16 12:25:31 +00:00
|
|
|
void TestingModuleBuilder::AddIndirectFunctionTable(
|
|
|
|
const uint16_t* function_indexes, uint32_t table_size) {
|
2017-09-01 12:57:34 +00:00
|
|
|
test_module_.function_tables.emplace_back();
|
|
|
|
WasmIndirectFunctionTable& table = test_module_.function_tables.back();
|
|
|
|
table.initial_size = table_size;
|
|
|
|
table.maximum_size = table_size;
|
|
|
|
table.has_maximum_size = true;
|
|
|
|
for (uint32_t i = 0; i < table_size; ++i) {
|
|
|
|
table.values.push_back(function_indexes[i]);
|
|
|
|
}
|
|
|
|
|
2018-01-16 12:25:31 +00:00
|
|
|
FixedArray* func_table = *isolate_->factory()->NewFixedArray(
|
|
|
|
table_size * compiler::kFunctionTableEntrySize);
|
2017-09-01 12:57:34 +00:00
|
|
|
function_tables_.push_back(
|
2018-01-16 12:25:31 +00:00
|
|
|
isolate_->global_handles()->Create(func_table).address());
|
2017-09-01 12:57:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void TestingModuleBuilder::PopulateIndirectFunctionTable() {
|
|
|
|
if (interpret()) return;
|
|
|
|
// Initialize the fixed arrays in instance->function_tables.
|
|
|
|
for (uint32_t i = 0; i < function_tables_.size(); i++) {
|
|
|
|
WasmIndirectFunctionTable& table = test_module_.function_tables[i];
|
|
|
|
Handle<FixedArray> function_table(
|
|
|
|
reinterpret_cast<FixedArray**>(function_tables_[i]));
|
|
|
|
int table_size = static_cast<int>(table.values.size());
|
|
|
|
for (int j = 0; j < table_size; j++) {
|
|
|
|
WasmFunction& function = test_module_.functions[table.values[j]];
|
2018-01-16 12:25:31 +00:00
|
|
|
function_table->set(
|
|
|
|
compiler::FunctionTableSigOffset(j),
|
|
|
|
Smi::FromInt(test_module_.signature_map.Find(function.sig)));
|
2017-11-28 22:25:36 +00:00
|
|
|
if (FLAG_wasm_jit_to_native) {
|
|
|
|
Handle<Foreign> foreign_holder = isolate_->factory()->NewForeign(
|
|
|
|
native_module_->GetCode(function.func_index)
|
|
|
|
->instructions()
|
|
|
|
.start(),
|
|
|
|
TENURED);
|
2018-01-16 12:25:31 +00:00
|
|
|
function_table->set(compiler::FunctionTableCodeOffset(j),
|
|
|
|
*foreign_holder);
|
2017-11-28 22:25:36 +00:00
|
|
|
} else {
|
2018-01-16 12:25:31 +00:00
|
|
|
function_table->set(compiler::FunctionTableCodeOffset(j),
|
|
|
|
*function_code_[function.func_index]);
|
2017-11-28 22:25:36 +00:00
|
|
|
}
|
2017-09-01 12:57:34 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
uint32_t TestingModuleBuilder::AddBytes(Vector<const byte> bytes) {
|
2017-12-18 14:08:14 +00:00
|
|
|
Handle<WasmSharedModuleData> shared(
|
|
|
|
instance_object_->compiled_module()->shared(), isolate_);
|
2017-12-17 19:10:22 +00:00
|
|
|
Handle<SeqOneByteString> old_bytes(shared->module_bytes(), isolate_);
|
2017-09-01 12:57:34 +00:00
|
|
|
uint32_t old_size = static_cast<uint32_t>(old_bytes->length());
|
|
|
|
// Avoid placing strings at offset 0, this might be interpreted as "not
|
|
|
|
// set", e.g. for function names.
|
|
|
|
uint32_t bytes_offset = old_size ? old_size : 1;
|
|
|
|
ScopedVector<byte> new_bytes(bytes_offset + bytes.length());
|
|
|
|
memcpy(new_bytes.start(), old_bytes->GetChars(), old_size);
|
|
|
|
memcpy(new_bytes.start() + bytes_offset, bytes.start(), bytes.length());
|
|
|
|
Handle<SeqOneByteString> new_bytes_str = Handle<SeqOneByteString>::cast(
|
|
|
|
isolate_->factory()->NewStringFromOneByte(new_bytes).ToHandleChecked());
|
2017-12-17 19:10:22 +00:00
|
|
|
shared->set_module_bytes(*new_bytes_str);
|
2017-09-01 12:57:34 +00:00
|
|
|
return bytes_offset;
|
|
|
|
}
|
|
|
|
|
|
|
|
compiler::ModuleEnv TestingModuleBuilder::CreateModuleEnv() {
|
2018-01-16 12:25:31 +00:00
|
|
|
return {&test_module_, function_tables_, function_code_, Handle<Code>::null(),
|
|
|
|
trap_handler::IsTrapHandlerEnabled()};
|
2017-09-01 12:57:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
const WasmGlobal* TestingModuleBuilder::AddGlobal(ValueType type) {
|
|
|
|
byte size = WasmOpcodes::MemSize(WasmOpcodes::MachineTypeFor(type));
|
|
|
|
global_offset = (global_offset + size - 1) & ~(size - 1); // align
|
|
|
|
test_module_.globals.push_back(
|
|
|
|
{type, true, WasmInitExpr(), global_offset, false, false});
|
|
|
|
global_offset += size;
|
|
|
|
// limit number of globals.
|
|
|
|
CHECK_LT(global_offset, kMaxGlobalsSize);
|
|
|
|
return &test_module_.globals.back();
|
|
|
|
}
|
|
|
|
|
|
|
|
Handle<WasmInstanceObject> TestingModuleBuilder::InitInstanceObject() {
|
|
|
|
Handle<SeqOneByteString> empty_string = Handle<SeqOneByteString>::cast(
|
|
|
|
isolate_->factory()->NewStringFromOneByte({}).ToHandleChecked());
|
|
|
|
// The lifetime of the wasm module is tied to this object's, and we cannot
|
|
|
|
// rely on the mechanics of Managed<T>.
|
|
|
|
Handle<Foreign> module_wrapper = isolate_->factory()->NewForeign(
|
|
|
|
reinterpret_cast<Address>(&test_module_ptr_));
|
|
|
|
Handle<Script> script =
|
|
|
|
isolate_->factory()->NewScript(isolate_->factory()->empty_string());
|
|
|
|
script->set_type(Script::TYPE_WASM);
|
|
|
|
Handle<WasmSharedModuleData> shared_module_data =
|
|
|
|
WasmSharedModuleData::New(isolate_, module_wrapper, empty_string, script,
|
|
|
|
Handle<ByteArray>::null());
|
|
|
|
Handle<FixedArray> code_table = isolate_->factory()->NewFixedArray(0);
|
|
|
|
Handle<FixedArray> export_wrappers = isolate_->factory()->NewFixedArray(0);
|
|
|
|
Handle<WasmCompiledModule> compiled_module = WasmCompiledModule::New(
|
2017-11-28 22:25:36 +00:00
|
|
|
isolate_, test_module_ptr_, code_table, export_wrappers, function_tables_,
|
2018-01-16 12:25:31 +00:00
|
|
|
trap_handler::IsTrapHandlerEnabled());
|
2017-11-28 22:25:36 +00:00
|
|
|
compiled_module->OnWasmModuleDecodingComplete(shared_module_data);
|
|
|
|
// This method is called when we initialize TestEnvironment. We don't
|
|
|
|
// have a memory yet, so we won't create it here. We'll update the
|
|
|
|
// interpreter when we get a memory. We do have globals, though.
|
|
|
|
native_module_ = compiled_module->GetNativeModule();
|
|
|
|
|
2017-09-01 12:57:34 +00:00
|
|
|
Handle<FixedArray> weak_exported = isolate_->factory()->NewFixedArray(0);
|
2017-12-18 14:08:14 +00:00
|
|
|
compiled_module->set_weak_exported_functions(*weak_exported);
|
2017-09-01 12:57:34 +00:00
|
|
|
DCHECK(WasmCompiledModule::IsWasmCompiledModule(*compiled_module));
|
|
|
|
script->set_wasm_compiled_module(*compiled_module);
|
2017-10-16 08:49:45 +00:00
|
|
|
auto instance = WasmInstanceObject::New(isolate_, compiled_module);
|
|
|
|
instance->wasm_context()->get()->globals_start = globals_data_;
|
2017-11-28 22:25:36 +00:00
|
|
|
Handle<WeakCell> weak_instance = isolate()->factory()->NewWeakCell(instance);
|
2017-12-18 14:08:14 +00:00
|
|
|
compiled_module->set_weak_owning_instance(*weak_instance);
|
2017-10-16 08:49:45 +00:00
|
|
|
return instance;
|
2017-09-01 12:57:34 +00:00
|
|
|
}
|
|
|
|
|
2017-12-05 23:09:14 +00:00
|
|
|
void TestBuildingGraphWithBuilder(compiler::WasmGraphBuilder* builder,
|
|
|
|
Zone* zone, FunctionSig* sig,
|
|
|
|
const byte* start, const byte* end) {
|
2017-09-01 12:57:34 +00:00
|
|
|
DecodeResult result =
|
2017-12-05 23:09:14 +00:00
|
|
|
BuildTFGraph(zone->allocator(), builder, sig, start, end);
|
2017-09-01 12:57:34 +00:00
|
|
|
if (result.failed()) {
|
2017-12-01 15:22:00 +00:00
|
|
|
#ifdef DEBUG
|
2017-09-01 12:57:34 +00:00
|
|
|
if (!FLAG_trace_wasm_decoder) {
|
|
|
|
// Retry the compilation with the tracing flag on, to help in debugging.
|
|
|
|
FLAG_trace_wasm_decoder = true;
|
2017-12-05 23:09:14 +00:00
|
|
|
result = BuildTFGraph(zone->allocator(), builder, sig, start, end);
|
2017-09-01 12:57:34 +00:00
|
|
|
}
|
2017-12-01 15:22:00 +00:00
|
|
|
#endif
|
2017-09-01 12:57:34 +00:00
|
|
|
|
|
|
|
uint32_t pc = result.error_offset();
|
2017-12-18 16:19:23 +00:00
|
|
|
FATAL("Verification failed; pc = +%x, msg = %s", pc,
|
|
|
|
result.error_msg().c_str());
|
2017-09-01 12:57:34 +00:00
|
|
|
}
|
2017-12-05 23:09:14 +00:00
|
|
|
builder->LowerInt64();
|
2017-09-01 12:57:34 +00:00
|
|
|
if (!CpuFeatures::SupportsWasmSimd128()) {
|
2017-12-05 23:09:14 +00:00
|
|
|
builder->SimdScalarLoweringForTesting();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void TestBuildingGraph(
|
|
|
|
Zone* zone, compiler::JSGraph* jsgraph, compiler::ModuleEnv* module,
|
|
|
|
FunctionSig* sig, compiler::SourcePositionTable* source_position_table,
|
|
|
|
const byte* start, const byte* end,
|
|
|
|
compiler::RuntimeExceptionSupport runtime_exception_support) {
|
|
|
|
if (module) {
|
|
|
|
compiler::WasmGraphBuilder builder(
|
|
|
|
module, zone, jsgraph, CEntryStub(jsgraph->isolate(), 1).GetCode(), sig,
|
|
|
|
source_position_table, runtime_exception_support);
|
|
|
|
TestBuildingGraphWithBuilder(&builder, zone, sig, start, end);
|
|
|
|
} else {
|
|
|
|
compiler::WasmGraphBuilder builder(
|
2017-12-09 00:20:10 +00:00
|
|
|
nullptr, zone, jsgraph, CEntryStub(jsgraph->isolate(), 1).GetCode(),
|
|
|
|
sig, source_position_table, runtime_exception_support);
|
2017-12-05 23:09:14 +00:00
|
|
|
TestBuildingGraphWithBuilder(&builder, zone, sig, start, end);
|
2017-09-01 12:57:34 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
WasmFunctionWrapper::WasmFunctionWrapper(Zone* zone, int num_params)
|
[wasm] Introduce the WasmContext
The WasmContext struct introduced in this CL is used to store the
mem_size and mem_start address of the wasm memory. These variables can
be accessed at C++ level at graph build time (e.g., initialized during
instance building). When the GrowMemory runtime is invoked, the context
variables can be changed in the WasmContext at C++ level so that the
generated code will load the correct values.
This requires to insert a relocatable pointer only in the
JSToWasmWrapper (and in the other wasm entry points), the value is then
passed from function to function as an automatically added additional
parameter. The WasmContext is then dropped when creating an Interpreter
Entry or when invoking a JavaScript function. This removes the need of
patching the generated code at runtime (i.e., when the memory grows)
with respect to WASM_MEMORY_REFERENCE and WASM_MEMORY_SIZE_REFERENCE.
However, we still need to patch the code at instance build time to patch
the JSToWasmWrappers; in fact the address of the WasmContext is not
known during compilation, but only when the instance is built.
The WasmContext address is passed as the first parameter. This has the
advantage of not having to move the WasmContext around if the function
does not use many registers. This CL also changes the wasm calling
convention so that the first parameter register is different from the
return value register. The WasmContext is attached to every
WasmMemoryObject, to share the same context with multiple instances
sharing the same memory. Moreover, the nodes representing the
WasmContext variables are cached in the SSA environment, similarly to
other local variables that might change during execution. The nodes are
created when initializing the SSA environment and refreshed every time a
grow_memory or a function call happens, so that we are sure that they
always represent the correct mem_size and mem_start variables.
This CL also removes the WasmMemorySize runtime (since it's now possible
to directly retrieve mem_size from the context) and simplifies the
GrowMemory runtime (since every instance now has a memory_object).
R=ahaas@chromium.org,clemensh@chromium.org
CC=gdeepti@chromium.org
Change-Id: I3f058e641284f5a1bbbfc35a64c88da6ff08e240
Reviewed-on: https://chromium-review.googlesource.com/671008
Commit-Queue: Enrico Bacis <enricobacis@google.com>
Reviewed-by: Clemens Hammacher <clemensh@chromium.org>
Reviewed-by: Andreas Haas <ahaas@chromium.org>
Cr-Commit-Position: refs/heads/master@{#48209}
2017-09-28 14:59:37 +00:00
|
|
|
: GraphAndBuilders(zone),
|
|
|
|
inner_code_node_(nullptr),
|
|
|
|
context_address_(nullptr),
|
|
|
|
signature_(nullptr) {
|
2017-09-01 12:57:34 +00:00
|
|
|
// One additional parameter for the pointer to the return value memory.
|
|
|
|
Signature<MachineType>::Builder sig_builder(zone, 1, num_params + 1);
|
|
|
|
|
|
|
|
sig_builder.AddReturn(MachineType::Int32());
|
|
|
|
for (int i = 0; i < num_params + 1; i++) {
|
|
|
|
sig_builder.AddParam(MachineType::Pointer());
|
|
|
|
}
|
|
|
|
signature_ = sig_builder.Build();
|
|
|
|
}
|
|
|
|
|
2018-02-09 19:19:25 +00:00
|
|
|
void WasmFunctionWrapper::Init(CallDescriptor* call_descriptor,
|
2017-09-01 12:57:34 +00:00
|
|
|
MachineType return_type,
|
|
|
|
Vector<MachineType> param_types) {
|
2018-02-09 19:19:25 +00:00
|
|
|
DCHECK_NOT_NULL(call_descriptor);
|
2017-09-01 12:57:34 +00:00
|
|
|
DCHECK_EQ(signature_->parameter_count(), param_types.length() + 1);
|
|
|
|
|
|
|
|
// Create the TF graph for the wrapper.
|
|
|
|
|
[wasm] Introduce the WasmContext
The WasmContext struct introduced in this CL is used to store the
mem_size and mem_start address of the wasm memory. These variables can
be accessed at C++ level at graph build time (e.g., initialized during
instance building). When the GrowMemory runtime is invoked, the context
variables can be changed in the WasmContext at C++ level so that the
generated code will load the correct values.
This requires to insert a relocatable pointer only in the
JSToWasmWrapper (and in the other wasm entry points), the value is then
passed from function to function as an automatically added additional
parameter. The WasmContext is then dropped when creating an Interpreter
Entry or when invoking a JavaScript function. This removes the need of
patching the generated code at runtime (i.e., when the memory grows)
with respect to WASM_MEMORY_REFERENCE and WASM_MEMORY_SIZE_REFERENCE.
However, we still need to patch the code at instance build time to patch
the JSToWasmWrappers; in fact the address of the WasmContext is not
known during compilation, but only when the instance is built.
The WasmContext address is passed as the first parameter. This has the
advantage of not having to move the WasmContext around if the function
does not use many registers. This CL also changes the wasm calling
convention so that the first parameter register is different from the
return value register. The WasmContext is attached to every
WasmMemoryObject, to share the same context with multiple instances
sharing the same memory. Moreover, the nodes representing the
WasmContext variables are cached in the SSA environment, similarly to
other local variables that might change during execution. The nodes are
created when initializing the SSA environment and refreshed every time a
grow_memory or a function call happens, so that we are sure that they
always represent the correct mem_size and mem_start variables.
This CL also removes the WasmMemorySize runtime (since it's now possible
to directly retrieve mem_size from the context) and simplifies the
GrowMemory runtime (since every instance now has a memory_object).
R=ahaas@chromium.org,clemensh@chromium.org
CC=gdeepti@chromium.org
Change-Id: I3f058e641284f5a1bbbfc35a64c88da6ff08e240
Reviewed-on: https://chromium-review.googlesource.com/671008
Commit-Queue: Enrico Bacis <enricobacis@google.com>
Reviewed-by: Clemens Hammacher <clemensh@chromium.org>
Reviewed-by: Andreas Haas <ahaas@chromium.org>
Cr-Commit-Position: refs/heads/master@{#48209}
2017-09-28 14:59:37 +00:00
|
|
|
// Function, context_address, effect, and control.
|
|
|
|
Node** parameters = zone()->NewArray<Node*>(param_types.length() + 4);
|
|
|
|
graph()->SetStart(graph()->NewNode(common()->Start(7)));
|
2017-09-01 12:57:34 +00:00
|
|
|
Node* effect = graph()->start();
|
|
|
|
int parameter_count = 0;
|
|
|
|
|
|
|
|
// Dummy node which gets replaced in SetInnerCode.
|
|
|
|
inner_code_node_ = graph()->NewNode(common()->Int32Constant(0));
|
|
|
|
parameters[parameter_count++] = inner_code_node_;
|
|
|
|
|
[wasm] Introduce the WasmContext
The WasmContext struct introduced in this CL is used to store the
mem_size and mem_start address of the wasm memory. These variables can
be accessed at C++ level at graph build time (e.g., initialized during
instance building). When the GrowMemory runtime is invoked, the context
variables can be changed in the WasmContext at C++ level so that the
generated code will load the correct values.
This requires to insert a relocatable pointer only in the
JSToWasmWrapper (and in the other wasm entry points), the value is then
passed from function to function as an automatically added additional
parameter. The WasmContext is then dropped when creating an Interpreter
Entry or when invoking a JavaScript function. This removes the need of
patching the generated code at runtime (i.e., when the memory grows)
with respect to WASM_MEMORY_REFERENCE and WASM_MEMORY_SIZE_REFERENCE.
However, we still need to patch the code at instance build time to patch
the JSToWasmWrappers; in fact the address of the WasmContext is not
known during compilation, but only when the instance is built.
The WasmContext address is passed as the first parameter. This has the
advantage of not having to move the WasmContext around if the function
does not use many registers. This CL also changes the wasm calling
convention so that the first parameter register is different from the
return value register. The WasmContext is attached to every
WasmMemoryObject, to share the same context with multiple instances
sharing the same memory. Moreover, the nodes representing the
WasmContext variables are cached in the SSA environment, similarly to
other local variables that might change during execution. The nodes are
created when initializing the SSA environment and refreshed every time a
grow_memory or a function call happens, so that we are sure that they
always represent the correct mem_size and mem_start variables.
This CL also removes the WasmMemorySize runtime (since it's now possible
to directly retrieve mem_size from the context) and simplifies the
GrowMemory runtime (since every instance now has a memory_object).
R=ahaas@chromium.org,clemensh@chromium.org
CC=gdeepti@chromium.org
Change-Id: I3f058e641284f5a1bbbfc35a64c88da6ff08e240
Reviewed-on: https://chromium-review.googlesource.com/671008
Commit-Queue: Enrico Bacis <enricobacis@google.com>
Reviewed-by: Clemens Hammacher <clemensh@chromium.org>
Reviewed-by: Andreas Haas <ahaas@chromium.org>
Cr-Commit-Position: refs/heads/master@{#48209}
2017-09-28 14:59:37 +00:00
|
|
|
// Dummy node that gets replaced in SetContextAddress.
|
|
|
|
context_address_ = graph()->NewNode(IntPtrConstant(0));
|
|
|
|
parameters[parameter_count++] = context_address_;
|
|
|
|
|
2017-09-01 12:57:34 +00:00
|
|
|
int param_idx = 0;
|
|
|
|
for (MachineType t : param_types) {
|
|
|
|
DCHECK_NE(MachineType::None(), t);
|
|
|
|
parameters[parameter_count] = graph()->NewNode(
|
|
|
|
machine()->Load(t),
|
|
|
|
graph()->NewNode(common()->Parameter(param_idx++), graph()->start()),
|
|
|
|
graph()->NewNode(common()->Int32Constant(0)), effect, graph()->start());
|
|
|
|
effect = parameters[parameter_count++];
|
|
|
|
}
|
|
|
|
|
|
|
|
parameters[parameter_count++] = effect;
|
|
|
|
parameters[parameter_count++] = graph()->start();
|
2018-02-09 19:19:25 +00:00
|
|
|
Node* call = graph()->NewNode(common()->Call(call_descriptor),
|
|
|
|
parameter_count, parameters);
|
2017-09-01 12:57:34 +00:00
|
|
|
|
|
|
|
if (!return_type.IsNone()) {
|
|
|
|
effect = graph()->NewNode(
|
|
|
|
machine()->Store(compiler::StoreRepresentation(
|
|
|
|
return_type.representation(), WriteBarrierKind::kNoWriteBarrier)),
|
|
|
|
graph()->NewNode(common()->Parameter(param_types.length()),
|
|
|
|
graph()->start()),
|
|
|
|
graph()->NewNode(common()->Int32Constant(0)), call, effect,
|
|
|
|
graph()->start());
|
|
|
|
}
|
|
|
|
Node* zero = graph()->NewNode(common()->Int32Constant(0));
|
|
|
|
Node* r = graph()->NewNode(
|
|
|
|
common()->Return(), zero,
|
|
|
|
graph()->NewNode(common()->Int32Constant(WASM_WRAPPER_RETURN_VALUE)),
|
|
|
|
effect, graph()->start());
|
|
|
|
graph()->SetEnd(graph()->NewNode(common()->End(1), r));
|
|
|
|
}
|
|
|
|
|
|
|
|
Handle<Code> WasmFunctionWrapper::GetWrapperCode() {
|
|
|
|
if (code_.is_null()) {
|
|
|
|
Isolate* isolate = CcTest::InitIsolateOnce();
|
|
|
|
|
2018-02-09 19:19:25 +00:00
|
|
|
auto call_descriptor =
|
2017-09-01 12:57:34 +00:00
|
|
|
compiler::Linkage::GetSimplifiedCDescriptor(zone(), signature_, true);
|
|
|
|
|
|
|
|
if (kPointerSize == 4) {
|
|
|
|
size_t num_params = signature_->parameter_count();
|
|
|
|
// One additional parameter for the pointer of the return value.
|
|
|
|
Signature<MachineRepresentation>::Builder rep_builder(zone(), 1,
|
|
|
|
num_params + 1);
|
|
|
|
|
|
|
|
rep_builder.AddReturn(MachineRepresentation::kWord32);
|
|
|
|
for (size_t i = 0; i < num_params + 1; i++) {
|
|
|
|
rep_builder.AddParam(MachineRepresentation::kWord32);
|
|
|
|
}
|
|
|
|
compiler::Int64Lowering r(graph(), machine(), common(), zone(),
|
|
|
|
rep_builder.Build());
|
|
|
|
r.LowerGraph();
|
|
|
|
}
|
|
|
|
|
2017-11-15 14:36:57 +00:00
|
|
|
CompilationInfo info(ArrayVector("testing"), graph()->zone(),
|
2017-10-24 18:06:56 +00:00
|
|
|
Code::C_WASM_ENTRY);
|
2017-11-15 14:36:57 +00:00
|
|
|
code_ = compiler::Pipeline::GenerateCodeForTesting(
|
2018-02-09 19:19:25 +00:00
|
|
|
&info, isolate, call_descriptor, graph(), nullptr);
|
2017-09-01 12:57:34 +00:00
|
|
|
CHECK(!code_.is_null());
|
|
|
|
#ifdef ENABLE_DISASSEMBLER
|
|
|
|
if (FLAG_print_opt_code) {
|
|
|
|
OFStream os(stdout);
|
|
|
|
code_->Disassemble("wasm wrapper", os);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
return code_;
|
|
|
|
}
|
|
|
|
|
|
|
|
void WasmFunctionCompiler::Build(const byte* start, const byte* end) {
|
|
|
|
size_t locals_size = local_decls.Size();
|
|
|
|
size_t total_size = end - start + locals_size + 1;
|
|
|
|
byte* buffer = static_cast<byte*>(zone()->New(total_size));
|
|
|
|
// Prepend the local decls to the code.
|
|
|
|
local_decls.Emit(buffer);
|
|
|
|
// Emit the code.
|
|
|
|
memcpy(buffer + locals_size, start, end - start);
|
|
|
|
// Append an extra end opcode.
|
|
|
|
buffer[total_size - 1] = kExprEnd;
|
|
|
|
|
|
|
|
start = buffer;
|
|
|
|
end = buffer + total_size;
|
|
|
|
|
|
|
|
CHECK_GE(kMaxInt, end - start);
|
|
|
|
int len = static_cast<int>(end - start);
|
|
|
|
function_->code = {builder_->AddBytes(Vector<const byte>(start, len)),
|
|
|
|
static_cast<uint32_t>(len)};
|
|
|
|
|
|
|
|
if (interpreter_) {
|
|
|
|
// Add the code to the interpreter.
|
|
|
|
interpreter_->SetFunctionCodeForTesting(function_, start, end);
|
|
|
|
}
|
|
|
|
|
2017-09-12 12:39:42 +00:00
|
|
|
Handle<WasmCompiledModule> compiled_module(
|
|
|
|
builder_->instance_object()->compiled_module(), isolate());
|
2017-11-28 22:25:36 +00:00
|
|
|
NativeModule* native_module = compiled_module->GetNativeModule();
|
|
|
|
if (FLAG_wasm_jit_to_native) {
|
|
|
|
native_module->ResizeCodeTableForTest(function_->func_index);
|
|
|
|
}
|
2017-12-17 19:10:22 +00:00
|
|
|
Handle<SeqOneByteString> wire_bytes(compiled_module->shared()->module_bytes(),
|
2017-09-12 12:39:42 +00:00
|
|
|
isolate());
|
|
|
|
|
2017-09-01 12:57:34 +00:00
|
|
|
compiler::ModuleEnv module_env = builder_->CreateModuleEnv();
|
2017-09-12 12:39:42 +00:00
|
|
|
ErrorThrower thrower(isolate(), "WasmFunctionCompiler::Build");
|
|
|
|
ScopedVector<uint8_t> func_wire_bytes(function_->code.length());
|
|
|
|
memcpy(func_wire_bytes.start(),
|
|
|
|
wire_bytes->GetChars() + function_->code.offset(),
|
|
|
|
func_wire_bytes.length());
|
|
|
|
ScopedVector<char> func_name(function_->name.length());
|
|
|
|
memcpy(func_name.start(), wire_bytes->GetChars() + function_->name.offset(),
|
|
|
|
func_name.length());
|
|
|
|
|
|
|
|
FunctionBody func_body{function_->sig, function_->code.offset(),
|
|
|
|
func_wire_bytes.start(), func_wire_bytes.end()};
|
2017-10-25 12:46:43 +00:00
|
|
|
compiler::WasmCompilationUnit::CompilationMode comp_mode =
|
|
|
|
builder_->execution_mode() == WasmExecutionMode::kExecuteLiftoff
|
|
|
|
? compiler::WasmCompilationUnit::CompilationMode::kLiftoff
|
|
|
|
: compiler::WasmCompilationUnit::CompilationMode::kTurbofan;
|
2017-09-12 12:39:42 +00:00
|
|
|
compiler::WasmCompilationUnit unit(
|
2017-11-28 22:25:36 +00:00
|
|
|
isolate(), &module_env, native_module, func_body, func_name,
|
|
|
|
function_->func_index, CEntryStub(isolate(), 1).GetCode(), comp_mode,
|
|
|
|
isolate()->counters(), builder_->runtime_exception_support(),
|
|
|
|
builder_->lower_simd());
|
2017-09-12 12:39:42 +00:00
|
|
|
unit.ExecuteCompilation();
|
2017-11-28 22:25:36 +00:00
|
|
|
WasmCodeWrapper code_wrapper = unit.FinishCompilation(&thrower);
|
2017-09-12 12:39:42 +00:00
|
|
|
CHECK(!thrower.error());
|
2017-11-28 22:25:36 +00:00
|
|
|
if (!FLAG_wasm_jit_to_native) {
|
|
|
|
Handle<Code> code = code_wrapper.GetCode();
|
|
|
|
// TODO(6792): No longer needed once WebAssembly code is off heap.
|
|
|
|
CodeSpaceMemoryModificationScope modification_scope(isolate()->heap());
|
|
|
|
|
|
|
|
// Manually add the deoptimization info that would otherwise be added
|
|
|
|
// during instantiation. Deopt data holds <WeakCell<wasm_instance>,
|
|
|
|
// func_index>.
|
|
|
|
DCHECK_EQ(0, code->deoptimization_data()->length());
|
|
|
|
Handle<FixedArray> deopt_data =
|
|
|
|
isolate()->factory()->NewFixedArray(2, TENURED);
|
|
|
|
Handle<Object> weak_instance =
|
|
|
|
isolate()->factory()->NewWeakCell(builder_->instance_object());
|
|
|
|
deopt_data->set(0, *weak_instance);
|
|
|
|
deopt_data->set(1, Smi::FromInt(static_cast<int>(function_index())));
|
|
|
|
code->set_deoptimization_data(*deopt_data);
|
|
|
|
|
|
|
|
// Build the TurboFan graph.
|
|
|
|
builder_->SetFunctionCode(function_index(), code);
|
|
|
|
|
|
|
|
// Add to code table.
|
2017-12-18 14:08:14 +00:00
|
|
|
Handle<FixedArray> code_table(compiled_module->code_table(), isolate());
|
2017-11-28 22:25:36 +00:00
|
|
|
if (static_cast<int>(function_index()) >= code_table->length()) {
|
|
|
|
Handle<FixedArray> new_arr = isolate()->factory()->NewFixedArray(
|
|
|
|
static_cast<int>(function_index()) + 1);
|
|
|
|
code_table->CopyTo(0, *new_arr, 0, code_table->length());
|
|
|
|
code_table = new_arr;
|
|
|
|
compiled_module->ReplaceCodeTableForTesting(code_table);
|
|
|
|
}
|
|
|
|
DCHECK(code_table->get(static_cast<int>(function_index()))
|
|
|
|
->IsUndefined(isolate()));
|
|
|
|
code_table->set(static_cast<int>(function_index()), *code);
|
2017-12-05 23:09:14 +00:00
|
|
|
if (trap_handler::IsTrapHandlerEnabled()) {
|
2017-11-28 22:25:36 +00:00
|
|
|
UnpackAndRegisterProtectedInstructionsGC(isolate(), code_table);
|
|
|
|
}
|
|
|
|
} else {
|
2017-12-05 23:09:14 +00:00
|
|
|
if (trap_handler::IsTrapHandlerEnabled()) {
|
2017-11-28 22:25:36 +00:00
|
|
|
UnpackAndRegisterProtectedInstructions(isolate(), native_module);
|
|
|
|
}
|
2017-09-01 12:57:34 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-09-12 12:39:42 +00:00
|
|
|
WasmFunctionCompiler::WasmFunctionCompiler(Zone* zone, FunctionSig* sig,
|
|
|
|
TestingModuleBuilder* builder,
|
|
|
|
const char* name)
|
2017-09-01 12:57:34 +00:00
|
|
|
: GraphAndBuilders(zone),
|
|
|
|
jsgraph(builder->isolate(), this->graph(), this->common(), nullptr,
|
|
|
|
nullptr, this->machine()),
|
|
|
|
sig(sig),
|
|
|
|
descriptor_(nullptr),
|
|
|
|
builder_(builder),
|
|
|
|
local_decls(zone, sig),
|
|
|
|
source_position_table_(this->graph()),
|
2017-09-12 12:39:42 +00:00
|
|
|
interpreter_(builder->interpreter()) {
|
2017-09-01 12:57:34 +00:00
|
|
|
// Get a new function from the testing module.
|
2017-11-28 22:25:36 +00:00
|
|
|
int index = builder->AddFunction(sig, name);
|
2017-09-01 12:57:34 +00:00
|
|
|
function_ = builder_->GetFunctionAt(index);
|
|
|
|
}
|
|
|
|
|
2017-09-25 16:13:13 +00:00
|
|
|
WasmFunctionCompiler::~WasmFunctionCompiler() {
|
2017-11-28 22:25:36 +00:00
|
|
|
if (!FLAG_wasm_jit_to_native) {
|
2017-12-05 23:09:14 +00:00
|
|
|
if (trap_handler::IsTrapHandlerEnabled() &&
|
2017-11-28 22:25:36 +00:00
|
|
|
!builder_->GetFunctionCode(function_index()).is_null()) {
|
|
|
|
const int handler_index = builder_->GetFunctionCode(function_index())
|
|
|
|
.GetCode()
|
|
|
|
->trap_handler_index()
|
|
|
|
->value();
|
|
|
|
trap_handler::ReleaseHandlerData(handler_index);
|
|
|
|
}
|
2017-09-25 16:13:13 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-09-01 12:57:34 +00:00
|
|
|
FunctionSig* WasmRunnerBase::CreateSig(MachineType return_type,
|
|
|
|
Vector<MachineType> param_types) {
|
|
|
|
int return_count = return_type.IsNone() ? 0 : 1;
|
|
|
|
int param_count = param_types.length();
|
|
|
|
|
|
|
|
// Allocate storage array in zone.
|
|
|
|
ValueType* sig_types = zone_.NewArray<ValueType>(return_count + param_count);
|
|
|
|
|
|
|
|
// Convert machine types to local types, and check that there are no
|
|
|
|
// MachineType::None()'s in the parameters.
|
|
|
|
int idx = 0;
|
|
|
|
if (return_count) sig_types[idx++] = WasmOpcodes::ValueTypeFor(return_type);
|
|
|
|
for (MachineType param : param_types) {
|
|
|
|
CHECK_NE(MachineType::None(), param);
|
|
|
|
sig_types[idx++] = WasmOpcodes::ValueTypeFor(param);
|
|
|
|
}
|
|
|
|
return new (&zone_) FunctionSig(return_count, param_count, sig_types);
|
|
|
|
}
|
|
|
|
|
|
|
|
// static
|
|
|
|
bool WasmRunnerBase::trap_happened;
|
|
|
|
|
|
|
|
} // namespace wasm
|
|
|
|
} // namespace internal
|
|
|
|
} // namespace v8
|