[wasm][asm.js] Make asm.js->wasm return a regular object.

src/wasm/wasm-module.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 <memory>
 
 #include "src/assembler-inl.h"
 #include "src/base/adapters.h"
 #include "src/base/atomic-utils.h"
 #include "src/code-stubs.h"
@@ skipping 1124 matching lines @@
   }
 }
 
 // A helper class to simplify instantiating a module from a compiled module.
 // It closes over the {Isolate}, the {ErrorThrower}, the {WasmCompiledModule},
 // etc.
 class WasmInstanceBuilder {
  public:
   WasmInstanceBuilder(Isolate* isolate, ErrorThrower* thrower,
                       Handle<WasmModuleObject> module_object,
-                      Handle<JSReceiver> ffi, Handle<JSArrayBuffer> memory)
+                      Handle<JSReceiver> ffi, Handle<JSArrayBuffer> memory,
+                      Handle<JSObject> export_to)
       : isolate_(isolate),
         module_(module_object->compiled_module()->module()),
         thrower_(thrower),
         module_object_(module_object),
         ffi_(ffi),
-        memory_(memory) {}
+        memory_(memory),
+        export_to_(export_to) {}
 
   // Build an instance, in all of its glory.
   MaybeHandle<WasmInstanceObject> Build() {
     MaybeHandle<WasmInstanceObject> nothing;
 
     // Check that an imports argument was provided, if the module requires it.
     // No point in continuing otherwise.
     if (!module_->import_table.empty() && ffi_.is_null()) {
       thrower_->TypeError(
           "Imports argument must be present and must be an object");
@@ skipping 213 matching lines @@
         deopt_data->set(0, *weak_link);
         deopt_data->set(1, Smi::FromInt(static_cast<int>(i)));
         deopt_data->set_length(2);
         code->set_deoptimization_data(*deopt_data);
       }
     }
 
     //--------------------------------------------------------------------------
     // Set up the exports object for the new instance.
     //--------------------------------------------------------------------------
-    ProcessExports(code_table, instance, compiled_module_);
+    ProcessExports(code_table, instance, export_to_, compiled_module_);
 
     //--------------------------------------------------------------------------
     // Add instance to Memory object
     //--------------------------------------------------------------------------
     DCHECK(wasm::IsWasmInstance(*instance));
     if (instance->has_memory_object()) {
       instance->memory_object()->AddInstance(isolate_, instance);
     }
 
     //--------------------------------------------------------------------------
@@ skipping 128 matching lines @@
     Handle<FixedArray> function_table;       // internal code array
     Handle<FixedArray> signature_table;      // internal sig array
   };
 
   Isolate* isolate_;
   WasmModule* const module_;
   ErrorThrower* thrower_;
   Handle<WasmModuleObject> module_object_;
   Handle<JSReceiver> ffi_;
   Handle<JSArrayBuffer> memory_;
+  Handle<JSObject> export_to_;
   Handle<JSArrayBuffer> globals_;
   Handle<WasmCompiledModule> compiled_module_;
   std::vector<TableInstance> table_instances_;
   std::vector<Handle<JSFunction>> js_wrappers_;
 
   // Helper routines to print out errors with imports.
   void ReportLinkError(const char* error, uint32_t index,
                        Handle<String> module_name, Handle<String> import_name) {
     thrower_->LinkError(
         "Import #%d module=\"%.*s\" function=\"%.*s\" error: %s", index,
@@ skipping 360 matching lines @@
     for (auto table : module_->function_tables) {
       if (table.exported) return true;
     }
     return false;
   }
 
   // Process the exports, creating wrappers for functions, tables, memories,
   // and globals.
   void ProcessExports(Handle<FixedArray> code_table,
                       Handle<WasmInstanceObject> instance,
+                      Handle<JSObject> exports,
                       Handle<WasmCompiledModule> compiled_module) {
     if (NeedsWrappers()) {
       // Fill the table to cache the exported JSFunction wrappers.
       js_wrappers_.insert(js_wrappers_.begin(), module_->functions.size(),
                           Handle<JSFunction>::null());
     }
 
-    Handle<JSObject> exports_object = instance;
+    Handle<JSObject> exports_object = exports;
     if (module_->origin == kWasmOrigin) {
       // Create the "exports" object.
       exports_object = isolate_->factory()->NewJSObjectWithNullProto();
       Handle<String> exports_name =
           isolate_->factory()->InternalizeUtf8String("exports");
       JSObject::AddProperty(instance, exports_name, exports_object, NONE);
     }
 
     PropertyDescriptor desc;
-    desc.set_writable(false);
+    desc.set_writable(module_->origin == kAsmJsOrigin);
     desc.set_enumerable(true);
 
     // Count up export indexes.
     int export_index = 0;
     for (auto exp : module_->export_table) {
       if (exp.kind == kExternalFunction) {
         ++export_index;
       }
     }
 
@@ skipping 274 matching lines @@
       }
     }
   }
 };
 
 // Instantiates a WASM module, creating a WebAssembly.Instance from a
 // WebAssembly.Module.
 MaybeHandle<WasmInstanceObject> WasmModule::Instantiate(
     Isolate* isolate, ErrorThrower* thrower,
     Handle<WasmModuleObject> wasm_module, Handle<JSReceiver> ffi,
-    Handle<JSArrayBuffer> memory) {
-  WasmInstanceBuilder builder(isolate, thrower, wasm_module, ffi, memory);
+    Handle<JSArrayBuffer> memory, Handle<JSObject> export_to) {
+  WasmInstanceBuilder builder(isolate, thrower, wasm_module, ffi, memory,
+                              export_to);
   return builder.Build();
 }
 
 bool wasm::IsWasmInstance(Object* object) {
   return WasmInstanceObject::IsWasmInstanceObject(object);
 }
 
 Handle<Script> wasm::GetScript(Handle<JSObject> instance) {
   WasmCompiledModule* compiled_module =
       WasmInstanceObject::cast(*instance)->compiled_module();
@@ skipping 555 matching lines @@
   Handle<FixedArray> storage = factory->NewFixedArray(num_custom_sections);
   JSArray::SetContent(array_object, storage);
   array_object->set_length(Smi::FromInt(num_custom_sections));
 
   for (int i = 0; i < num_custom_sections; i++) {
     storage->set(i, *matching_sections[i]);
   }
 
   return array_object;
 }