[wasm] Update WasmMemoryObject correctly when module memory is exported.

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/base/atomic-utils.h"
 #include "src/code-stubs.h"
 #include "src/compiler/wasm-compiler.h"
 #include "src/debug/interface-types.h"
@@ skipping 1201 matching lines @@
               ? static_cast<Address>(
                     compiled_module_->memory()->backing_store())
               : nullptr;
       RelocateMemoryReferencesInCode(code_table, old_mem_start, mem_start,
                                      old_mem_size, mem_size);
       compiled_module_->set_memory(memory_);
     } else {
       LoadDataSegments(nullptr, 0);
     }
 
-    DCHECK(wasm::IsWasmInstance(*instance));
-    if (instance->has_memory_object()) {
-      instance->get_memory_object()->AddInstance(isolate_, instance);
-    }
-
     //--------------------------------------------------------------------------
     // Set up the runtime support for the new instance.
     //--------------------------------------------------------------------------
     Handle<WeakCell> weak_link = factory->NewWeakCell(instance);
 
     for (int i = num_imported_functions + FLAG_skip_compiling_wasm_funcs;
          i < code_table->length(); ++i) {
       Handle<Code> code = code_table->GetValueChecked<Code>(isolate_, i);
       if (code->kind() == Code::WASM_FUNCTION) {
         Handle<FixedArray> deopt_data = factory->NewFixedArray(2, TENURED);
         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);
 
     //--------------------------------------------------------------------------
+    // Add instance to Memory object
+    //--------------------------------------------------------------------------
+    DCHECK(wasm::IsWasmInstance(*instance));
+    if (instance->has_memory_object()) {
+      instance->get_memory_object()->AddInstance(isolate_, instance);
+    }
+
+    //--------------------------------------------------------------------------
     // Set up the indirect function tables for the new instance.
     //--------------------------------------------------------------------------
     if (function_table_count > 0) InitializeTables(code_table, instance);
 
     if (num_imported_functions > 0 || !owner.is_null()) {
       // If the code was cloned, or new imports were compiled, patch.
       PatchDirectCalls(old_code_table, code_table, num_imported_functions);
     }
 
     FlushICache(isolate_, code_table);
@@ skipping 24 matching lines @@
               protected_instructions
                   ->GetValueChecked<Smi>(isolate_, i + Code::kTrapLandingOffset)
                   ->value();
           unpacked.emplace_back(data);
         }
         // TODO(eholk): Register the protected instruction information once the
         // trap handler is in place.
       }
     }
 
+    //--------------------------------------------------------------------------
     // Set up and link the new instance.
     //--------------------------------------------------------------------------
     {
       Handle<Object> global_handle =
           isolate_->global_handles()->Create(*instance);
       Handle<WeakCell> link_to_clone = factory->NewWeakCell(compiled_module_);
       Handle<WeakCell> link_to_owning_instance = factory->NewWeakCell(instance);
       MaybeHandle<WeakCell> link_to_original;
       MaybeHandle<WasmCompiledModule> original;
       if (!owner.is_null()) {
@@ skipping 1067 matching lines @@
 MaybeHandle<String> WasmCompiledModule::GetFunctionName(
     Handle<WasmCompiledModule> compiled_module, uint32_t func_index) {
   DCHECK_LT(func_index, compiled_module->module()->functions.size());
   WasmFunction& function = compiled_module->module()->functions[func_index];
   Isolate* isolate = compiled_module->GetIsolate();
   MaybeHandle<String> string = ExtractStringFromModuleBytes(
       isolate, compiled_module, function.name_offset, function.name_length);
   if (!string.is_null()) return string.ToHandleChecked();
   return {};
 }