Turn on wasm flags all the time, add a reference from wasm functions to the module.

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.h"
 #include "src/api-natives.h"
 #include "src/assert-scope.h"
 #include "src/ast/ast.h"
 #include "src/ast/scopes.h"
 #include "src/factory.h"
@@ skipping 24 matching lines @@
 };
 
 
 RawBuffer GetRawBufferArgument(
     ErrorThrower& thrower, const v8::FunctionCallbackInfo<v8::Value>& args) {
   if (args.Length() < 1 || !args[0]->IsArrayBuffer()) {
     thrower.Error("Argument 0 must be an array buffer");
     return {nullptr, nullptr};
   }
   Local<ArrayBuffer> buffer = Local<ArrayBuffer>::Cast(args[0]);
-  ArrayBuffer::Contents contents =
-      buffer->IsExternal() ? buffer->GetContents() : buffer->Externalize();
+  ArrayBuffer::Contents contents = buffer->GetContents();
 
   // TODO(titzer): allow offsets into buffers, views, etc.
 
   const byte* start = reinterpret_cast<const byte*>(contents.Data());
   const byte* end = start + contents.ByteLength();
 
   if (start == nullptr) {
     thrower.Error("ArrayBuffer argument is empty");
   }
   return {start, end};
@@ skipping 18 matching lines @@
 
   if (result.val) delete result.val;
 }
 
 
 void VerifyFunction(const v8::FunctionCallbackInfo<v8::Value>& args) {
   HandleScope scope(args.GetIsolate());
   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(args.GetIsolate());
   ErrorThrower thrower(isolate, "WASM.verifyFunction()");
 
-  // TODO(titzer): no need to externalize to get the bytes for verification.
   RawBuffer buffer = GetRawBufferArgument(thrower, args);
   if (thrower.error()) return;
 
   internal::wasm::FunctionResult result;
   {
     // Verification of a single function shouldn't allocate.
     i::DisallowHeapAllocation no_allocation;
     i::Zone zone;
     result = internal::wasm::DecodeWasmFunction(isolate, &zone, nullptr,
                                                 buffer.start, buffer.end);
@@ skipping 142 matching lines @@
   ErrorThrower thrower(isolate, "WASM.instantiateModule()");
 
   RawBuffer buffer = GetRawBufferArgument(thrower, args);
   if (buffer.start == nullptr) return;
 
   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::Isolate* isolate = memory->GetIsolate();
-    memory->set_is_external(true);
-    isolate->heap()->UnregisterArrayBuffer(*memory);
   }
 
   // Decode but avoid a redundant pass over function bodies for verification.
   // Verification will happen during compilation.
   i::Zone zone;
   internal::wasm::ModuleResult result = internal::wasm::DecodeWasmModule(
       isolate, &zone, buffer.start, buffer.end, false, false);
 
   if (result.failed()) {
     thrower.Failed("", result);
@@ skipping 40 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);
 }
 
 
 void WasmJs::Install(Isolate* isolate, Handle<JSGlobalObject> global) {
+  // Setup wasm function map.
+  Handle<Map> wasm_function_map = isolate->factory()->NewMap(
+      JS_FUNCTION_TYPE, JSFunction::kSize + kPointerSize);
+  wasm_function_map->set_is_callable();
+  global->native_context()->set_wasm_function_map(*wasm_function_map);
+
   // Bind the WASM object.
   Factory* factory = isolate->factory();
   Handle<String> name = v8_str(isolate, "WASM");
   Handle<JSFunction> cons = factory->NewFunction(name);
   JSFunction::SetInstancePrototype(
       cons, Handle<Object>(global->native_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);
   JSObject::AddProperty(global, name, wasm_object, attributes);
 
   // Install functions on the WASM object.
   InstallFunc(isolate, wasm_object, "instantiateModule", InstantiateModule);
   InstallFunc(isolate, wasm_object, "verifyModule", VerifyModule);
   InstallFunc(isolate, wasm_object, "verifyFunction", VerifyFunction);
   InstallFunc(isolate, wasm_object, "compileRun", CompileRun);
   InstallFunc(isolate, wasm_object, "asmCompileRun", AsmCompileRun);
   InstallFunc(isolate, wasm_object, "instantiateModuleFromAsm",
               InstantiateModuleFromAsm);
 }
 }  // namespace internal
 }  // namespace v8