[wasm] Further simplify WasmCompiledModule.

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 590 matching lines @@
 
     Handle<WasmSharedModuleData> shared = WasmSharedModuleData::New(
         isolate_, module_wrapper, Handle<SeqOneByteString>::cast(module_bytes),
         script, asm_js_offset_table);
     if (lazy_compile) WasmSharedModuleData::PrepareForLazyCompilation(shared);
 
     // Create the compiled module object, and populate with compiled functions
     // and information needed at instantiation time. This object needs to be
     // serializable. Instantiation may occur off a deserialized version of this
     // object.
-    Handle<WasmCompiledModule> compiled_module =
-        WasmCompiledModule::New(isolate_, shared);
-    compiled_module->set_num_imported_functions(
-        module_->num_imported_functions);
-    compiled_module->set_code_table(code_table);
-    compiled_module->set_min_mem_pages(module_->min_mem_pages);
-    compiled_module->set_max_mem_pages(module_->max_mem_pages);
+    Handle<WasmCompiledModule> compiled_module = WasmCompiledModule::New(
+        isolate_, shared, code_table, function_tables, signature_tables);
     if (function_table_count > 0) {
       compiled_module->set_function_tables(function_tables);
-      compiled_module->set_signature_tables(signature_tables);
-      compiled_module->set_empty_function_tables(function_tables);
     }
 
     // If we created a wasm script, finish it now and make it public to the
     // debugger.
     if (asm_js_script.is_null()) {
       script->set_wasm_compiled_module(*compiled_module);
       isolate_->debug()->OnAfterCompile(script);
     }
 
     // Compile JS->WASM wrappers for exported functions.
@@ skipping 459 matching lines @@
     HistogramTimerScope wasm_instantiate_module_time_scope(
         module_->is_wasm()
             ? isolate_->counters()->wasm_instantiate_wasm_module_time()
             : isolate_->counters()->wasm_instantiate_asm_module_time());
     Factory* factory = isolate_->factory();
 
     //--------------------------------------------------------------------------
     // Reuse the compiled module (if no owner), otherwise clone.
     //--------------------------------------------------------------------------
     Handle<FixedArray> code_table;
+    // We keep around a copy of the old code table, because we'll be replacing
+    // imports for the new instance, and then we need the old imports to be
+    // able to relocate.
     Handle<FixedArray> old_code_table;
     MaybeHandle<WasmInstanceObject> owner;
 
     TRACE("Starting new module instantiation\n");
     {
       // Root the owner, if any, before doing any allocations, which
       // may trigger GC.
       // Both owner and original template need to be in sync. Even
       // after we lose the original template handle, the code
       // objects we copied from it have data relative to the
       // instance - such as globals addresses.
       Handle<WasmCompiledModule> original;
       {
         DisallowHeapAllocation no_gc;
         original = handle(module_object_->compiled_module());
         if (original->has_weak_owning_instance()) {
           owner = handle(WasmInstanceObject::cast(
               original->weak_owning_instance()->value()));
         }
       }
       DCHECK(!original.is_null());
-      // Always make a new copy of the code_table, since the old_code_table
-      // may still have placeholders for imports.
-      old_code_table = original->code_table();
-      code_table = factory->CopyFixedArray(old_code_table);
-
       if (original->has_weak_owning_instance()) {
         // Clone, but don't insert yet the clone in the instances chain.
         // We do that last. Since we are holding on to the owner instance,
         // the owner + original state used for cloning and patching
         // won't be mutated by possible finalizer runs.
         DCHECK(!owner.is_null());
         TRACE("Cloning from %d\n", original->instance_id());
+        old_code_table = original->code_table();
         compiled_module_ = WasmCompiledModule::Clone(isolate_, original);
+        code_table = compiled_module_->code_table();
         // Avoid creating too many handles in the outer scope.
         HandleScope scope(isolate_);
 
         // Clone the code for WASM functions and exports.
         for (int i = 0; i < code_table->length(); ++i) {
           Handle<Code> orig_code(Code::cast(code_table->get(i)), isolate_);
           switch (orig_code->kind()) {
             case Code::WASM_TO_JS_FUNCTION:
               // Imports will be overwritten with newly compiled wrappers.
               break;
@@ skipping 17 matching lines @@
               break;
             }
             default:
               UNREACHABLE();
           }
         }
         RecordStats(isolate_, code_table);
       } else {
         // There was no owner, so we can reuse the original.
         compiled_module_ = original;
+        old_code_table =
+            factory->CopyFixedArray(compiled_module_->code_table());
+        code_table = compiled_module_->code_table();
         TRACE("Reusing existing instance %d\n",
               compiled_module_->instance_id());
       }
-      compiled_module_->set_code_table(code_table);
       compiled_module_->set_native_context(isolate_->native_context());
     }
 
     //--------------------------------------------------------------------------
     // Allocate the instance object.
     //--------------------------------------------------------------------------
     Zone instantiation_zone(isolate_->allocator(), ZONE_NAME);
     CodeSpecialization code_specialization(isolate_, &instantiation_zone);
     Handle<WasmInstanceObject> instance =
         WasmInstanceObject::New(isolate_, compiled_module_);
@@ skipping 1757 matching lines @@
                                      callee_compiled->instruction_start());
     }
     DCHECK_EQ(non_compiled_functions.size(), idx);
   }
 
   Code* ret =
       Code::cast(compiled_module->code_table()->get(func_to_return_idx));
   DCHECK_EQ(Code::WASM_FUNCTION, ret->kind());
   return handle(ret, isolate);
 }