Compile asm->wasm conversion at parse time.

src/asmjs/asm-js.cc

 // 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/asmjs/asm-js.h"
 
 #include "src/api-natives.h"
 #include "src/api.h"
 #include "src/asmjs/asm-wasm-builder.h"
 #include "src/asmjs/typing-asm.h"
@@ skipping 56 matching lines @@
   }
   if (!typer.Validate()) {
     DCHECK(!info->isolate()->has_pending_exception());
     PrintF("Validation of asm.js module failed: %s", typer.error_message());
     return MaybeHandle<FixedArray>();
   }
   v8::internal::wasm::AsmWasmBuilder builder(info->isolate(), info->zone(),
                                              info->literal(), &typer);
   i::Handle<i::FixedArray> foreign_globals;
   auto module = builder.Run(&foreign_globals);
-  size_t byte_length = module->end() - module->begin();
-  Handle<JSArrayBuffer> buffer = info->isolate()->factory()->NewJSArrayBuffer();
-  JSArrayBuffer::SetupAllocatingData(buffer, info->isolate(), byte_length,
-                                     false, SharedFlag::kNotShared);
-  uint8_t* module_bytes = reinterpret_cast<uint8_t*>(buffer->backing_store());
-  memcpy(module_bytes, module->begin(), byte_length);
+
+  i::MaybeHandle<i::FixedArray> compiled =
+      CompileModule(info->isolate(), module->begin(), module->end(), &thrower,

[Mircea Trofin, 2016/07/12 22:07:34]

To echo our chat - this change moves compiling at parse time instead
of runtime. Compile time is lengthy and may impact user experience. Would this
change surprise or block a developer in terms of their ability to mitigate
compile time? Do we need to pair it with guidance?

+                    internal::wasm::kAsmJsOrigin);
+  DCHECK(!compiled.is_null());
+
   Handle<FixedArray> result = info->isolate()->factory()->NewFixedArray(2);
-  result->set(0, *buffer);
+  result->set(0, *compiled.ToHandleChecked());
   result->set(1, *foreign_globals);
   return result;
 }
 
 MaybeHandle<Object> AsmJs::InstantiateAsmWasm(i::Isolate* isolate,
                                               Handle<FixedArray> wasm_data,
                                               Handle<JSArrayBuffer> memory,
                                               Handle<JSObject> foreign) {
-  i::Handle<i::JSArrayBuffer> module_bytes(
-      i::JSArrayBuffer::cast(wasm_data->get(0)));
+  i::Handle<i::FixedArray> compiled(i::FixedArray::cast(wasm_data->get(0)));
   i::Handle<i::FixedArray> foreign_globals(
       i::FixedArray::cast(wasm_data->get(1)));
 
   ErrorThrower thrower(isolate, "Asm.js -> WebAssembly instantiation");
 
-  const byte* module_start =
-      reinterpret_cast<const byte*>(module_bytes->backing_store());
-  size_t module_length =
-      static_cast<size_t>(module_bytes->byte_length()->Number());
-  const byte* module_end = module_start + module_length;
-  i::MaybeHandle<i::FixedArray> compiled =
-      CompileModule(isolate, module_start, module_end, &thrower,
-                    internal::wasm::kAsmJsOrigin);
-  if (compiled.is_null()) {
-    return MaybeHandle<Object>();
-  }
   i::MaybeHandle<i::JSObject> maybe_module_object =
-      i::wasm::WasmModule::Instantiate(isolate, compiled.ToHandleChecked(),
-                                       foreign, memory);
+      i::wasm::WasmModule::Instantiate(isolate, compiled, foreign, memory);
   if (maybe_module_object.is_null()) {
     return MaybeHandle<Object>();
   }
 
   i::Handle<i::Name> name(isolate->factory()->InternalizeOneByteString(
       STATIC_CHAR_VECTOR("__foreign_init__")));
 
   i::Handle<i::Object> module_object = maybe_module_object.ToHandleChecked();
   i::MaybeHandle<i::Object> maybe_init =
       i::Object::GetProperty(module_object, name);
@@ skipping 25 matching lines @@
   if (retval.is_null()) {
     thrower.Error(
         "WASM.instantiateModuleFromAsm(): foreign init function failed");
     return MaybeHandle<Object>();
   }
   return maybe_module_object;
 }
 
 }  // namespace internal
 }  // namespace v8