Hooking up asm-wasm conversion.

src/wasm/wasm-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/api-natives.h"
 #include "src/api.h"
 #include "src/assert-scope.h"
 #include "src/ast/ast.h"
 #include "src/ast/scopes.h"
 #include "src/execution.h"
@@ skipping 17 matching lines @@
 
 namespace v8 {
 
 namespace {
 struct RawBuffer {
   const byte* start;
   const byte* end;
   size_t size() { return static_cast<size_t>(end - start); }
 };
 
-RawBuffer GetRawBufferSource(
-    v8::Local<v8::Value> source, ErrorThrower* thrower) {
+RawBuffer GetRawBufferSource(v8::Local<v8::Value> source,
+                             ErrorThrower* thrower) {
   const byte* start = nullptr;
   const byte* end = nullptr;
 
   if (source->IsArrayBuffer()) {
     // A raw array buffer was passed.
     Local<ArrayBuffer> buffer = Local<ArrayBuffer>::Cast(source);
     ArrayBuffer::Contents contents = buffer->GetContents();
 
     start = reinterpret_cast<const byte*>(contents.Data());
     end = start + contents.ByteLength();
 
     if (start == nullptr || end == start) {
       thrower->Error("ArrayBuffer argument is empty");
     }
   } else if (source->IsTypedArray()) {
     // A TypedArray was passed.
     Local<TypedArray> array = Local<TypedArray>::Cast(source);
     Local<ArrayBuffer> buffer = array->Buffer();
 
     ArrayBuffer::Contents contents = buffer->GetContents();
 
     start =
         reinterpret_cast<const byte*>(contents.Data()) + array->ByteOffset();
     end = start + array->ByteLength();
 
     if (start == nullptr || end == start) {
       thrower->Error("ArrayBuffer argument is empty");
     }
   } else {
-    thrower->Error("Argument 0 must be an ArrayBuffer or Uint8Array");
+    thrower->Error("Source must be an ArrayBuffer or Uint8Array");

[Mircea Trofin, 2016/06/30 23:23:29]

Super-nit: would the caller (js programmer, I assume) know what "source" is?
Should we call it source data or something like that?

[bradn, 2016/07/01 01:06:08]

Reworded.

   }
 
   return {start, end};
 }
 
+i::Handle<i::JSArrayBuffer> GetMemoryArgument(
+    const v8::FunctionCallbackInfo<v8::Value>& args, int index) {
+  i::Handle<i::JSArrayBuffer> memory = i::Handle<i::JSArrayBuffer>::null();
+  if (args.Length() > index && args[index]->IsArrayBuffer()) {
+    Local<Object> obj = Local<Object>::Cast(args[index]);
+    i::Handle<i::Object> mem_obj = v8::Utils::OpenHandle(*obj);
+    memory = i::Handle<i::JSArrayBuffer>(i::JSArrayBuffer::cast(*mem_obj));
+  }
+  return memory;
+}
+
+i::Handle<i::JSObject> GetForeignArgument(
+    const v8::FunctionCallbackInfo<v8::Value>& args, int index) {
+  i::Handle<i::JSObject> foreign;
+  if (args.Length() > index && args[index]->IsObject()) {
+    Local<Object> local_foreign = Local<Object>::Cast(args[index]);
+    i::Handle<i::Object> foreign_obj = v8::Utils::OpenHandle(*local_foreign);
+    foreign = i::Handle<i::JSObject>(i::JSObject::cast(*foreign_obj));
+  }
+  return foreign;
+}
+
 void VerifyModule(const v8::FunctionCallbackInfo<v8::Value>& args) {
   HandleScope scope(args.GetIsolate());
   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(args.GetIsolate());
   ErrorThrower thrower(isolate, "Wasm.verifyModule()");
 
   if (args.Length() < 1) {
     thrower.Error("Argument 0 must be a buffer source");
     return;
   }
   RawBuffer buffer = GetRawBufferSource(args[0], &thrower);
@@ skipping 32 matching lines @@
                                                 buffer.start, buffer.end);
   }
 
   if (result.failed()) {
     thrower.Failed("", result);
   }
 
   if (result.val) delete result.val;
 }
 
-v8::internal::wasm::ZoneBuffer* TranslateAsmModule(
-    i::ParseInfo* info, ErrorThrower* thrower,
-    i::Handle<i::FixedArray>* foreign_args) {
+static bool ParseAsmModule(i::ParseInfo* info, ErrorThrower* thrower) {
   info->set_global();
   info->set_lazy(false);
   info->set_allow_lazy_parsing(false);
   info->set_toplevel(true);
 
   if (!i::Compiler::ParseAndAnalyze(info)) {
-    return nullptr;
+    return false;
   }
 
   if (info->scope()->declarations()->length() == 0) {
     thrower->Error("Asm.js validation failed: no declarations in scope");
-    return nullptr;
+    return false;
   }
 
   if (!info->scope()->declarations()->at(0)->IsFunctionDeclaration()) {
     thrower->Error("Asm.js validation failed: non-function declaration");
-    return nullptr;
+    return false;
   }
 
   info->set_literal(
       info->scope()->declarations()->at(0)->AsFunctionDeclaration()->fun());
-
-  v8::internal::AsmTyper typer(info->isolate(), info->zone(), *(info->script()),
-                               info->literal());
-  if (i::FLAG_enable_simd_asmjs) {
-    typer.set_allow_simd(true);
-  }
-  if (!typer.Validate()) {
-    thrower->Error("Asm.js validation failed: %s", typer.error_message());
-    return nullptr;
-  }
-
-  v8::internal::wasm::AsmWasmBuilder builder(info->isolate(), info->zone(),
-                                             info->literal(), &typer);
-
-  return builder.Run(foreign_args);
+  return true;
 }
 
-i::MaybeHandle<i::JSObject> InstantiateModuleCommon(
-    const v8::FunctionCallbackInfo<v8::Value>& args, const byte* start,
-    const byte* end, ErrorThrower* thrower,
+i::MaybeHandle<i::FixedArray> CompileModuleCommon(
+    i::Isolate* isolate, const byte* start, const byte* end,
+    ErrorThrower* thrower,
     internal::wasm::ModuleOrigin origin = i::wasm::kWasmOrigin) {
-  i::Isolate* isolate = reinterpret_cast<i::Isolate*>(args.GetIsolate());
-
   // Decode but avoid a redundant pass over function bodies for verification.
   // Verification will happen during compilation.
   i::Zone zone(isolate->allocator());
   internal::wasm::ModuleResult result = internal::wasm::DecodeWasmModule(
       isolate, &zone, start, end, false, origin);
 
-  i::MaybeHandle<i::JSObject> object;
+  i::MaybeHandle<i::FixedArray> compiled_module;
   if (result.failed() && origin == internal::wasm::kAsmJsOrigin) {
     thrower->Error("Asm.js converted module failed to decode");
   } else if (result.failed()) {
     thrower->Failed("", result);
   } else {
-    // Success. Instantiate the module and return the object.
-    i::Handle<i::JSReceiver> ffi = i::Handle<i::JSObject>::null();
-    if (args.Length() > 1 && args[1]->IsObject()) {
-      Local<Object> obj = Local<Object>::Cast(args[1]);
-      ffi = i::Handle<i::JSReceiver>::cast(v8::Utils::OpenHandle(*obj));
-    }
-
-    i::Handle<i::JSArrayBuffer> memory = i::Handle<i::JSArrayBuffer>::null();
-    if (args.Length() > 2 && args[2]->IsArrayBuffer()) {
-      Local<Object> obj = Local<Object>::Cast(args[2]);
-      i::Handle<i::Object> mem_obj = v8::Utils::OpenHandle(*obj);
-      memory = i::Handle<i::JSArrayBuffer>(i::JSArrayBuffer::cast(*mem_obj));
-    }
-
-    i::MaybeHandle<i::FixedArray> compiled_module =
-        result.val->CompileFunctions(isolate);
-    if (!compiled_module.is_null()) {
-      object = i::wasm::WasmModule::Instantiate(
-          isolate, compiled_module.ToHandleChecked(), ffi, memory);
-      if (!object.is_null()) {
-        args.GetReturnValue().Set(v8::Utils::ToLocal(object.ToHandleChecked()));
-      }
-    }
+    compiled_module = result.val->CompileFunctions(isolate);
   }
 
   if (result.val) delete result.val;
-  return object;
+  return compiled_module;
 }
 
 void InstantiateModuleFromAsm(const v8::FunctionCallbackInfo<v8::Value>& args) {
   HandleScope scope(args.GetIsolate());
   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(args.GetIsolate());
   ErrorThrower thrower(isolate, "Wasm.instantiateModuleFromAsm()");
 
   if (!args[0]->IsString()) {
     thrower.Error("Asm module text should be a string");
     return;
   }
 
   i::Factory* factory = isolate->factory();
   i::Zone zone(isolate->allocator());
   Local<String> source = Local<String>::Cast(args[0]);
   i::Handle<i::Script> script = factory->NewScript(Utils::OpenHandle(*source));
   i::ParseInfo info(&zone, script);
 
-  i::Handle<i::Object> foreign;
-  if (args.Length() > 1 && args[1]->IsObject()) {
-    Local<Object> local_foreign = Local<Object>::Cast(args[1]);
-    foreign = v8::Utils::OpenHandle(*local_foreign);
-  }
-
-  i::Handle<i::FixedArray> foreign_args;
-  auto module = TranslateAsmModule(&info, &thrower, &foreign_args);
-  if (module == nullptr) {
+  if (!ParseAsmModule(&info, &thrower)) {
     return;
   }
 
-  i::MaybeHandle<i::Object> maybe_module_object =
-      InstantiateModuleCommon(args, module->begin(), module->end(), &thrower,
-                              internal::wasm::kAsmJsOrigin);
-  if (maybe_module_object.is_null()) {
+  i::Handle<i::FixedArray> wasm_data;
+  if (!i::WasmJs::ConvertAsmToWasm(&info, false, &wasm_data)) {
+    thrower.Error("Asm.js failed to validate");
     return;
   }
 
-  i::Handle<i::Name> name =
-      factory->NewStringFromStaticChars("__foreign_init__");
+  i::Handle<i::JSObject> foreign = GetForeignArgument(args, 1);
+  i::Handle<i::JSArrayBuffer> memory = GetMemoryArgument(args, 2);
 
-  i::Handle<i::Object> module_object = maybe_module_object.ToHandleChecked();
-  i::MaybeHandle<i::Object> maybe_init =
-      i::Object::GetProperty(module_object, name);
-  DCHECK(!maybe_init.is_null());
+  i::Handle<i::Object> result;
+  if (!i::WasmJs::InstantiateAsmWasm(isolate, wasm_data, memory, foreign,
+                                     &result)) {
+    return;
+  }
 
-  i::Handle<i::Object> init = maybe_init.ToHandleChecked();
-  i::Handle<i::Object> undefined = isolate->factory()->undefined_value();
-  i::Handle<i::Object>* foreign_args_array =
-      new i::Handle<i::Object>[foreign_args->length()];
-  for (int j = 0; j < foreign_args->length(); j++) {
-    if (!foreign.is_null()) {
-      i::MaybeHandle<i::Name> name = i::Object::ToName(
-          isolate, i::Handle<i::Object>(foreign_args->get(j), isolate));
-      if (!name.is_null()) {
-        i::MaybeHandle<i::Object> val =
-            i::Object::GetProperty(foreign, name.ToHandleChecked());
-        if (!val.is_null()) {
-          foreign_args_array[j] = val.ToHandleChecked();
-          continue;
-        }
-      }
-    }
-    foreign_args_array[j] = undefined;
-  }
-  i::MaybeHandle<i::Object> retval = i::Execution::Call(
-      isolate, init, undefined, foreign_args->length(), foreign_args_array);
-  delete[] foreign_args_array;
-
-  if (retval.is_null()) {
-    thrower.Error(
-        "WASM.instantiateModuleFromAsm(): foreign init function failed");
+  if (!result.is_null()) {
+    args.GetReturnValue().Set(v8::Utils::ToLocal(result));
   }
 }
 
 void InstantiateModule(const v8::FunctionCallbackInfo<v8::Value>& args) {
   HandleScope scope(args.GetIsolate());
   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(args.GetIsolate());
   ErrorThrower thrower(isolate, "Wasm.instantiateModule()");
 
   if (args.Length() < 1) {
     thrower.Error("Argument 0 must be a buffer source");
     return;
   }
   RawBuffer buffer = GetRawBufferSource(args[0], &thrower);
   if (buffer.start == nullptr) return;
 
-  InstantiateModuleCommon(args, buffer.start, buffer.end, &thrower);
+  i::Handle<i::JSObject> foreign = GetForeignArgument(args, 1);
+  i::Handle<i::JSArrayBuffer> memory = GetMemoryArgument(args, 2);
+
+  i::MaybeHandle<i::FixedArray> compiled =
+      CompileModuleCommon(isolate, buffer.start, buffer.end, &thrower);
+  if (compiled.is_null()) {
+    return;
+  }
+  i::MaybeHandle<i::JSObject> result = i::wasm::WasmModule::Instantiate(
+      isolate, compiled.ToHandleChecked(), foreign, memory);
+
+  if (!result.is_null()) {
+    args.GetReturnValue().Set(v8::Utils::ToLocal(result.ToHandleChecked()));
+  }
 }
 
-
 static i::MaybeHandle<i::JSObject> CreateModuleObject(
     v8::Isolate* isolate, const v8::Local<v8::Value> source,
     ErrorThrower* thrower) {
   i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
 
   RawBuffer buffer = GetRawBufferSource(source, thrower);
   if (buffer.start == nullptr) return i::MaybeHandle<i::JSObject>();
 
   // TODO(rossberg): Once we can, do compilation here.
   DCHECK(source->IsArrayBuffer() || source->IsTypedArray());
@@ skipping 46 matching lines @@
       CreateModuleObject(isolate, args[0], &thrower);
   if (module_obj.is_null()) return;
 
   v8::ReturnValue<v8::Value> return_value = args.GetReturnValue();
   return_value.Set(Utils::ToLocal(module_obj.ToHandleChecked()));
 }
 
 void WebAssemblyInstance(const v8::FunctionCallbackInfo<v8::Value>& args) {
   HandleScope scope(args.GetIsolate());
   v8::Isolate* isolate = args.GetIsolate();
-  ErrorThrower thrower(reinterpret_cast<i::Isolate*>(isolate),
-                       "WebAssembly.Instance()");
+  i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
+  ErrorThrower thrower(i_isolate, "WebAssembly.Instance()");
 
   if (args.Length() < 1) {
     thrower.Error("Argument 0 must be a WebAssembly.Module");
     return;
   }
   Local<Context> context = isolate->GetCurrentContext();
   i::Handle<i::Context> i_context = Utils::OpenHandle(*context);
   i::Handle<i::Symbol> module_sym(i_context->wasm_module_sym());
   i::MaybeHandle<i::Object> source =
       i::Object::GetProperty(Utils::OpenHandle(*args[0]), module_sym);
   if (source.is_null()) return;
 
   RawBuffer buffer =
       GetRawBufferSource(Utils::ToLocal(source.ToHandleChecked()), &thrower);
   if (buffer.start == nullptr) return;
 
-  InstantiateModuleCommon(args, buffer.start, buffer.end, &thrower);
+  i::Handle<i::JSObject> foreign = GetForeignArgument(args, 1);
+  i::Handle<i::JSArrayBuffer> memory = GetMemoryArgument(args, 2);
+
+  i::MaybeHandle<i::FixedArray> compiled =
+      CompileModuleCommon(i_isolate, buffer.start, buffer.end, &thrower);
+  if (compiled.is_null()) {
+    return;
+  }
+  i::MaybeHandle<i::JSObject> result = i::wasm::WasmModule::Instantiate(
+      i_isolate, compiled.ToHandleChecked(), foreign, memory);
+
+  if (!result.is_null()) {
+    args.GetReturnValue().Set(v8::Utils::ToLocal(result.ToHandleChecked()));
+  }
 }
 }  // namespace
 
 // TODO(titzer): we use the API to create the function template because the
 // internal guts are too ugly to replicate here.
 static i::Handle<i::FunctionTemplateInfo> NewTemplate(i::Isolate* i_isolate,
                                                       FunctionCallback func) {
   Isolate* isolate = reinterpret_cast<Isolate*>(i_isolate);
   Local<FunctionTemplate> local = FunctionTemplate::New(isolate, func);
   return v8::Utils::OpenHandle(*local);
@@ skipping 10 matching lines @@
   Handle<FunctionTemplateInfo> temp = NewTemplate(isolate, func);
   Handle<JSFunction> function =
       ApiNatives::InstantiateFunction(temp).ToHandleChecked();
   PropertyAttributes attributes =
       static_cast<PropertyAttributes>(DONT_DELETE | READ_ONLY);
   JSObject::AddProperty(object, name, function, attributes);
   return function;
 }
 
 void WasmJs::Install(Isolate* isolate, Handle<JSGlobalObject> global) {
+  if (!FLAG_expose_wasm && !FLAG_validate_asm) {
+    return;
+  }

[titzer, 2016/07/01 11:12:15]

Why'd these flags go away? That accidentally shipped WASM by default. Fixing.

[Michael Starzinger, 2016/07/01 11:41:27]

+1. I also explicitly checked for these flags in my review and LGTMed the
version _with_ the flags in place.

[bradn, 2016/07/01 12:39:53]

AAAH. Drat.
Sorry about that.
When I moved stuff over to the asmjs dir, I forgot I'd changed how this gets
called, and reverted the whole file.

Thanks for fixing!

   Factory* factory = isolate->factory();
 
   // Setup wasm function map.
   Handle<Context> context(global->native_context(), isolate);
   InstallWasmFunctionMap(isolate, context);
 
+  if (!FLAG_expose_wasm) {
+    return;
+  }
+
   // Bind the experimental WASM object.
   // TODO(rossberg, titzer): remove once it's no longer needed.
   {
     Handle<String> name = v8_str(isolate, "Wasm");
     Handle<JSFunction> cons = factory->NewFunction(name);
     JSFunction::SetInstancePrototype(
         cons, Handle<Object>(context->initial_object_prototype(), isolate));
     cons->shared()->set_instance_class_name(*name);
     Handle<JSObject> wasm_object = factory->NewJSObject(cons, TENURED);
     PropertyAttributes attributes = static_cast<PropertyAttributes>(DONT_ENUM);
@@ skipping 61 matching lines @@
                                             &in_object_properties);
 
     int unused_property_fields = in_object_properties - pre_allocated;
     Handle<Map> map = Map::CopyInitialMap(
         prev_map, instance_size, in_object_properties, unused_property_fields);
 
     context->set_wasm_function_map(*map);
   }
 }
 
+bool WasmJs::ConvertAsmToWasm(ParseInfo* info, bool fixed_signature,

[titzer, 2016/06/30 09:56:03]

The logic is basically OK here, but I think we should split out the
asm.js-related stuff into another file. The original intention of the wasm-js.cc
file was that it would be the place where the JS API for WASM lived. The fact
that we pulled out InstantiateModuleCommon here shows that some common code
maybe needs to move into wasm-module.cc and be shared by this wasm-js.cc and
asm-js.cc.

[bradn, 2016/07/01 01:06:09]

Done.

+                              Handle<FixedArray>* wasm_data) {
+  ErrorThrower thrower(info->isolate(), "Asm.js -> WebAssembly conversion");
+  AsmTyper typer(info->isolate(), info->zone(), *(info->script()),
+                 info->literal());
+  typer.set_fixed_signature(fixed_signature);
+  if (i::FLAG_enable_simd_asmjs) {
+    typer.set_allow_simd(true);
+  }
+  if (!typer.Validate()) {
+    DCHECK(!info->isolate()->has_pending_exception());
+    PrintF("Validation of asm.js module failed: %s", typer.error_message());
+    return false;
+  }
+  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);
+  *wasm_data = info->isolate()->factory()->NewFixedArray(2);
+  (*wasm_data)->set(0, *buffer);
+  (*wasm_data)->set(1, *foreign_globals);

[Mircea Trofin, 2016/06/30 23:23:29]

you could return MaybeHandle<FixedArray>, and then avoid having a out parameter
for wasm_data.

[bradn, 2016/07/01 01:06:08]

Done.

+  return true;
+}
+
+bool WasmJs::InstantiateAsmWasm(i::Isolate* isolate,
+                                Handle<FixedArray> wasm_data,
+                                Handle<JSArrayBuffer> memory,
+                                Handle<JSObject> foreign,
+                                Handle<Object>* result) {
+  i::Handle<i::JSArrayBuffer> module_bytes(
+      i::JSArrayBuffer::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");
+  i::Factory* factory = isolate->factory();
+
+  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 =
+      CompileModuleCommon(isolate, module_start, module_end, &thrower,
+                          internal::wasm::kAsmJsOrigin);
+  if (compiled.is_null()) {
+    return false;
+  }
+  i::MaybeHandle<i::JSObject> maybe_module_object =
+      i::wasm::WasmModule::Instantiate(isolate, compiled.ToHandleChecked(),
+                                       foreign, memory);
+  if (maybe_module_object.is_null()) {
+    return false;
+  }
+
+  i::Handle<i::Name> name =
+      factory->NewStringFromStaticChars("__foreign_init__");

[Mircea Trofin, 2016/06/30 23:23:30]

Should you use one of the Internalize APIs, e.g. InternalizeOneByteString? I
think NewStringFromStaticChars will re-instantiate each time we hit here, so we
add GC pressure for no reason.

[bradn, 2016/07/01 01:06:09]

Done.

+
+  i::Handle<i::Object> module_object = maybe_module_object.ToHandleChecked();
+  i::MaybeHandle<i::Object> maybe_init =
+      i::Object::GetProperty(module_object, name);
+  DCHECK(!maybe_init.is_null());
+
+  i::Handle<i::Object> init = maybe_init.ToHandleChecked();
+  i::Handle<i::Object> undefined(isolate->heap()->undefined_value(), isolate);
+  i::Handle<i::Object>* foreign_args_array =
+      new i::Handle<i::Object>[foreign_globals->length()];
+  for (int j = 0; j < foreign_globals->length(); j++) {

[Mircea Trofin, 2016/06/30 23:23:29]

This is the asm.js initialization protocol? we could refactor (maybe in a
different CL) things a bit, I think, into decoding, instantiation, and
initialization. 

[bradn, 2016/07/01 01:06:08]

Yes needs refactor.

+    if (!foreign.is_null()) {
+      i::MaybeHandle<i::Name> name = i::Object::ToName(
+          isolate, i::Handle<i::Object>(foreign_globals->get(j), isolate));
+      if (!name.is_null()) {
+        i::MaybeHandle<i::Object> val =
+            i::Object::GetProperty(foreign, name.ToHandleChecked());
+        if (!val.is_null()) {
+          foreign_args_array[j] = val.ToHandleChecked();
+          continue;
+        }
+      }
+    }
+    foreign_args_array[j] = undefined;
+  }
+  i::MaybeHandle<i::Object> retval = i::Execution::Call(
+      isolate, init, undefined, foreign_globals->length(), foreign_args_array);
+  delete[] foreign_args_array;
+
+  if (retval.is_null()) {
+    thrower.Error(
+        "WASM.instantiateModuleFromAsm(): foreign init function failed");
+    return false;
+  } else {
+    *result = maybe_module_object.ToHandleChecked();

[Mircea Trofin, 2016/06/30 23:23:30]

same comment as above, maybe return MaybeHandle<Object>? It'd also be, I think,
more consistent, there are other APIs with this pattern. (if there are some bool
ones, perhaps we can agree on one way or the other, then progressively change? I
propose returning MaybeHandles wherever we produce JS heap objects in Wasm)

[bradn, 2016/07/01 01:06:08]

Done.

+  }
+
+  return true;
+}
+
 }  // namespace internal
 }  // namespace v8