AuroraMiddleware/v8
1
0
Fork 0
Code Issues 2 Pull Requests Releases Wiki Activity

[wasm] Hide code copying from Wasm compiler interface.

Browse Source 
This refactoring hides the fact that some wrappers are first generated
in the GC'ed heap and then copied into the native module. It is a first
step towards avoiding the redundant copy.

R=clemensh@chromium.org

Change-Id: I531fa42e8b4c210948d306624007348a39b981e0
Reviewed-on: https://chromium-review.googlesource.com/c/1333673
Commit-Queue: Michael Starzinger <mstarzinger@chromium.org>
Reviewed-by: Clemens Hammacher <clemensh@chromium.org>
Cr-Commit-Position: refs/heads/master@{#57477}
This commit is contained in:
Michael Starzinger 2018-11-13 15:24:27 +01:00 committed by Commit Bot
parent 1ed5214c8c
commit d75e327d0f
6 changed files with 42 additions and 35 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

37
src/compiler/wasm-compiler.cc
View File

@ -5031,10 +5031,11 @@ WasmImportCallKind GetWasmImportCallKind(Handle<JSReceiver> target,
return WasmImportCallKind::kUseCallBuiltin;
}
MaybeHandle<Code> CompileWasmImportCallWrapper(Isolate* isolate,
WasmImportCallKind kind,
wasm::FunctionSig* sig,
bool source_positions) {
wasm::WasmCode* CompileWasmImportCallWrapper(Isolate* isolate,
wasm::NativeModule* native_module,
WasmImportCallKind kind,
wasm::FunctionSig* sig,
bool source_positions) {
DCHECK_NE(WasmImportCallKind::kLinkError, kind);
DCHECK_NE(WasmImportCallKind::kWasmToWasm, kind);
@ -5080,10 +5081,7 @@ MaybeHandle<Code> CompileWasmImportCallWrapper(Isolate* isolate,
MaybeHandle<Code> maybe_code = Pipeline::GenerateCodeForWasmStub(
isolate, incoming, &graph, Code::WASM_TO_JS_FUNCTION, func_name,
AssemblerOptions::Default(isolate), source_position_table);
Handle<Code> code;
if (!maybe_code.ToHandle(&code)) {
return maybe_code;
}
Handle<Code> code = maybe_code.ToHandleChecked();
#ifdef ENABLE_DISASSEMBLER
if (FLAG_print_opt_code) {
CodeTracer::Scope tracing_scope(isolate->GetCodeTracer());
@ -5097,12 +5095,16 @@ MaybeHandle<Code> CompileWasmImportCallWrapper(Isolate* isolate,
func_name);
}
return code;
// TODO(wasm): No need to compile the code onto the heap and copy back.
wasm::WasmCode* wasm_code = native_module->AddImportCallWrapper(code);
return wasm_code;
}
MaybeHandle<Code> CompileWasmInterpreterEntry(Isolate* isolate,
uint32_t func_index,
wasm::FunctionSig* sig) {
wasm::WasmCode* CompileWasmInterpreterEntry(Isolate* isolate,
wasm::NativeModule* native_module,
uint32_t func_index,
wasm::FunctionSig* sig) {
//----------------------------------------------------------------------------
// Create the Graph
//----------------------------------------------------------------------------
@ -5137,10 +5139,7 @@ MaybeHandle<Code> CompileWasmInterpreterEntry(Isolate* isolate,
MaybeHandle<Code> maybe_code = Pipeline::GenerateCodeForWasmStub(
isolate, incoming, &graph, Code::WASM_INTERPRETER_ENTRY,
func_name.start(), AssemblerOptions::Default(isolate));
Handle<Code> code;
if (!maybe_code.ToHandle(&code)) {
return maybe_code;
}
Handle<Code> code = maybe_code.ToHandleChecked();
#ifdef ENABLE_DISASSEMBLER
if (FLAG_print_opt_code) {
CodeTracer::Scope tracing_scope(isolate->GetCodeTracer());
@ -5154,7 +5153,11 @@ MaybeHandle<Code> CompileWasmInterpreterEntry(Isolate* isolate,
"%.*s", func_name.length(), func_name.start());
}
return maybe_code;
// TODO(wasm): No need to compile the code onto the heap and copy back.
wasm::WasmCode* wasm_code =
native_module->AddInterpreterEntry(code, func_index);
return wasm_code;
}
MaybeHandle<Code> CompileCWasmEntry(Isolate* isolate, wasm::FunctionSig* sig) {

12
src/compiler/wasm-compiler.h
View File

@ -84,9 +84,10 @@ WasmImportCallKind GetWasmImportCallKind(Handle<JSReceiver> callable,
wasm::FunctionSig* sig);
// Compiles an import call wrapper, which allows WASM to call imports.
MaybeHandle<Code> CompileWasmImportCallWrapper(Isolate*, WasmImportCallKind,
wasm::FunctionSig*,
bool source_positions);
wasm::WasmCode* CompileWasmImportCallWrapper(Isolate*, wasm::NativeModule*,
WasmImportCallKind,
wasm::FunctionSig*,
bool source_positions);
// Creates a code object calling a wasm function with the given signature,
// callable from JS.
@ -96,8 +97,9 @@ V8_EXPORT_PRIVATE MaybeHandle<Code> CompileJSToWasmWrapper(Isolate*,
// Compiles a stub that redirects a call to a wasm function to the wasm
// interpreter. It's ABI compatible with the compiled wasm function.
MaybeHandle<Code> CompileWasmInterpreterEntry(Isolate*, uint32_t func_index,
wasm::FunctionSig*);
wasm::WasmCode* CompileWasmInterpreterEntry(Isolate*, wasm::NativeModule*,
uint32_t func_index,
wasm::FunctionSig*);
enum CWasmEntryParameters {
kCodeEntry,

5
src/wasm/wasm-code-manager.cc
View File

@ -440,6 +440,11 @@ WasmCode* NativeModule::AddInterpreterEntry(Handle<Code> code,
return ret;
}
WasmCode* NativeModule::AddImportCallWrapper(Handle<Code> code) {
WasmCode* ret = AddAnonymousCode(code, WasmCode::kWasmToJsWrapper);
return ret;
}
WasmCode* NativeModule::AddCodeForTesting(Handle<Code> code) {
WasmCode* ret = AddAnonymousCode(code, WasmCode::kFunction);
return ret;

4
src/wasm/wasm-code-manager.h
View File

@ -238,6 +238,9 @@ class V8_EXPORT_PRIVATE NativeModule final {
// self-identify as the {index} function.
WasmCode* AddInterpreterEntry(Handle<Code> code, uint32_t index);
// Add an import wrapper for a JS-to-Wasm call.
WasmCode* AddImportCallWrapper(Handle<Code> code);
// Adds anonymous code for testing purposes.
WasmCode* AddCodeForTesting(Handle<Code> code);
@ -348,7 +351,6 @@ class V8_EXPORT_PRIVATE NativeModule final {
friend class WasmCode;
friend class WasmCodeManager;
friend class NativeModuleModificationScope;
friend class WasmImportWrapperCache;
NativeModule(Isolate* isolate, const WasmFeatures& enabled_features,
bool can_request_more, VirtualMemory code_space,

6
src/wasm/wasm-debug.cc
View File

@ -628,10 +628,8 @@ void WasmDebugInfo::RedirectToInterpreter(Handle<WasmDebugInfo> debug_info,
DCHECK_GT(module->functions.size(), func_index);
if (!interpreted_functions->get(func_index)->IsUndefined(isolate)) continue;
MaybeHandle<Code> new_code = compiler::CompileWasmInterpreterEntry(
isolate, func_index, module->functions[func_index].sig);
const wasm::WasmCode* wasm_new_code = native_module->AddInterpreterEntry(
new_code.ToHandleChecked(), func_index);
const wasm::WasmCode* wasm_new_code = compiler::CompileWasmInterpreterEntry(
isolate, native_module, func_index, module->functions[func_index].sig);
Handle<Foreign> foreign_holder = isolate->factory()->NewForeign(
wasm_new_code->instruction_start(), TENURED);
interpreted_functions->set(func_index, *foreign_holder);

13
src/wasm/wasm-import-wrapper-cache-inl.h
View File

@ -27,17 +27,14 @@ class WasmImportWrapperCache {
WasmCode*& cached = entry_map_[key];
if (cached == nullptr) {
// TODO(wasm): no need to hold the lock while compiling an import wrapper.
// TODO(wasm): no need to compile the code onto the heap and copy back.
HandleScope scope(isolate);
bool source_positions = native_module_->module()->origin == kAsmJsOrigin;
Handle<Code> code = compiler::CompileWasmImportCallWrapper(
isolate, kind, sig, source_positions)
.ToHandleChecked();
cached = compiler::CompileWasmImportCallWrapper(
isolate, native_module_, kind, sig, source_positions);
auto counters = isolate->counters();
counters->wasm_generated_code_size()->Increment(code->body_size());
counters->wasm_reloc_size()->Increment(code->relocation_info()->length());
cached =
native_module_->AddAnonymousCode(code, WasmCode::kWasmToJsWrapper);
counters->wasm_generated_code_size()->Increment(
cached->instructions().length());
counters->wasm_reloc_size()->Increment(cached->reloc_info().length());
}
return cached;
}