[wasm] Remove {WasmCompiledModule} object type.

R=clemensh@chromium.org

Change-Id: I01b0b4948973ebbe0386ae8ae08e722ad16bcab8
Reviewed-on: https://chromium-review.googlesource.com/1114616Reviewed-by: Clemens Hammacher <clemensh@chromium.org>
Commit-Queue: Michael Starzinger <mstarzinger@chromium.org>
Cr-Commit-Position: refs/heads/master@{#54058}

src/compiler/types.cc

@@ -316,7 +316,6 @@ Type::bitset BitsetType::Lub(HeapObjectType const& type) {
     case INTERPRETER_DATA_TYPE:
     case TUPLE2_TYPE:
     case TUPLE3_TYPE:
-    case WASM_COMPILED_MODULE_TYPE:
     case WASM_DEBUG_INFO_TYPE:
     case WASM_EXPORTED_FUNCTION_DATA_TYPE:
     case LOAD_HANDLER_TYPE:

src/objects-body-descriptors-inl.h

@@ -548,7 +548,7 @@ class WasmInstanceObject::BodyDescriptor final : public BodyDescriptorBase {
  public:
   static bool IsValidSlot(Map* map, HeapObject* obj, int offset) {
     if (offset < kMemoryStartOffset) return true;
-    if (offset < kCompiledModuleOffset) return false;
+    if (offset < kModuleObjectOffset) return false;
     return IsValidSlotImpl(map, obj, offset);
   }
 

src/objects-debug.cc

@@ -1540,13 +1540,6 @@ void Tuple3::Tuple3Verify(Isolate* isolate) {
   VerifyObjectField(kValue3Offset);
 }
 
-void WasmCompiledModule::WasmCompiledModuleVerify(Isolate* isolate) {
-  CHECK(IsWasmCompiledModule());
-  VerifyObjectField(kNextInstanceOffset);
-  VerifyObjectField(kPrevInstanceOffset);
-  VerifyObjectField(kOwningInstanceOffset);
-}
-
 void WasmDebugInfo::WasmDebugInfoVerify(Isolate* isolate) {
   CHECK(IsWasmDebugInfo());
   VerifyObjectField(kInstanceOffset);
@@ -1586,7 +1579,6 @@ void WasmExportedFunctionData::WasmExportedFunctionDataVerify(
 void WasmModuleObject::WasmModuleObjectVerify(Isolate* isolate) {
   CHECK(IsWasmModuleObject());
   VerifyObjectField(kNativeModuleOffset);
-  VerifyObjectField(kCompiledModuleOffset);
   VerifyObjectField(kExportWrappersOffset);
   VerifyObjectField(kManagedModuleOffset);
   CHECK(managed_module()->IsForeign());

src/objects-printer.cc

@@ -1672,11 +1672,6 @@ void Tuple3::Tuple3Print(std::ostream& os) {  // NOLINT
   os << "\n";
 }
 
-void WasmCompiledModule::WasmCompiledModulePrint(std::ostream& os) {  // NOLINT
-  HeapObject::PrintHeader(os, "WasmCompiledModule");
-  os << "\n";
-}
-
 void WasmDebugInfo::WasmDebugInfoPrint(std::ostream& os) {  // NOLINT
   HeapObject::PrintHeader(os, "WasmDebugInfo");
   os << "\n - wasm_instance: " << Brief(wasm_instance());
@@ -1685,7 +1680,6 @@ void WasmDebugInfo::WasmDebugInfoPrint(std::ostream& os) {  // NOLINT
 
 void WasmInstanceObject::WasmInstanceObjectPrint(std::ostream& os) {  // NOLINT
   HeapObject::PrintHeader(os, "WasmInstanceObject");
-  os << "\n - compiled_module: " << Brief(compiled_module());
   os << "\n - module_object: " << Brief(module_object());
   os << "\n - exports_object: " << Brief(exports_object());
   os << "\n - native_context: " << Brief(native_context());

src/objects.h

@@ -103,7 +103,6 @@
 //         - ModuleInfo
 //         - ScriptContextTable
 //         - FixedArrayOfWeakCells
-//         - WasmCompiledModule
 //       - FixedDoubleArray
 //     - Name
 //       - String
@@ -400,7 +399,6 @@ const int kStubMinorKeyBits = kSmiValueSize - kStubMajorKeyBits - 1;
   V(STACK_FRAME_INFO_TYPE)                                      \
   V(TUPLE2_TYPE)                                                \
   V(TUPLE3_TYPE)                                                \
-  V(WASM_COMPILED_MODULE_TYPE)                                  \
   V(WASM_DEBUG_INFO_TYPE)                                       \
   V(WASM_EXPORTED_FUNCTION_DATA_TYPE)                           \
                                                                 \
@@ -587,7 +585,6 @@ const int kStubMinorKeyBits = kSmiValueSize - kStubMajorKeyBits - 1;
   V(STACK_FRAME_INFO, StackFrameInfo, stack_frame_info)                      \
   V(TUPLE2, Tuple2, tuple2)                                                  \
   V(TUPLE3, Tuple3, tuple3)                                                  \
-  V(WASM_COMPILED_MODULE, WasmCompiledModule, wasm_compiled_module)          \
   V(WASM_DEBUG_INFO, WasmDebugInfo, wasm_debug_info)                         \
   V(WASM_EXPORTED_FUNCTION_DATA, WasmExportedFunctionData,                   \
     wasm_exported_function_data)                                             \
@@ -786,7 +783,6 @@ enum InstanceType : uint16_t {
   STACK_FRAME_INFO_TYPE,
   TUPLE2_TYPE,
   TUPLE3_TYPE,
-  WASM_COMPILED_MODULE_TYPE,
   WASM_DEBUG_INFO_TYPE,
   WASM_EXPORTED_FUNCTION_DATA_TYPE,
 

src/runtime/runtime-test.cc

@@ -959,24 +959,6 @@ RUNTIME_FUNCTION(Runtime_DeserializeWasmModule) {
   return *module_object;
 }
 
-RUNTIME_FUNCTION(Runtime_ValidateWasmInstancesChain) {
-  HandleScope shs(isolate);
-  DCHECK_EQ(2, args.length());
-  CONVERT_ARG_HANDLE_CHECKED(WasmModuleObject, module_obj, 0);
-  CONVERT_ARG_HANDLE_CHECKED(Smi, instance_count, 1);
-  WasmInstanceObject::ValidateInstancesChainForTesting(isolate, module_obj,
-                                                       instance_count->value());
-  return isolate->heap()->ToBoolean(true);
-}
-
-RUNTIME_FUNCTION(Runtime_ValidateWasmModuleState) {
-  HandleScope shs(isolate);
-  DCHECK_EQ(1, args.length());
-  CONVERT_ARG_HANDLE_CHECKED(WasmModuleObject, module_obj, 0);
-  WasmModuleObject::ValidateStateForTesting(isolate, module_obj);
-  return isolate->heap()->ToBoolean(true);
-}
-
 RUNTIME_FUNCTION(Runtime_HeapObjectVerify) {
   HandleScope shs(isolate);
   DCHECK_EQ(1, args.length());
@@ -994,6 +976,18 @@ RUNTIME_FUNCTION(Runtime_HeapObjectVerify) {
   return isolate->heap()->ToBoolean(true);
 }
 
+RUNTIME_FUNCTION(Runtime_WasmGetNumberOfInstances) {
+  SealHandleScope shs(isolate);
+  DCHECK_EQ(1, args.length());
+  CONVERT_ARG_HANDLE_CHECKED(WasmModuleObject, module_obj, 0);
+  int instance_count = 0;
+  WeakArrayList* weak_instance_list = module_obj->weak_instance_list();
+  for (int i = 0; i < weak_instance_list->length(); ++i) {
+    if (weak_instance_list->Get(i)->IsWeakHeapObject()) instance_count++;
+  }
+  return Smi::FromInt(instance_count);
+}
+
 RUNTIME_FUNCTION(Runtime_WasmNumInterpretedCalls) {
   DCHECK_EQ(1, args.length());
   HandleScope scope(isolate);

src/runtime/runtime.h

@@ -556,8 +556,7 @@ namespace internal {
   F(TraceEnter, 0, 1)                         \
   F(TraceExit, 1, 1)                          \
   F(UnblockConcurrentRecompilation, 0, 1)     \
-  F(ValidateWasmInstancesChain, 2, 1)         \
-  F(ValidateWasmModuleState, 1, 1)            \
+  F(WasmGetNumberOfInstances, 1, 1)           \
   F(WasmNumInterpretedCalls, 1, 1)            \
   F(WasmTraceMemory, 1, 1)                    \
   F(WasmMemoryHasFullGuardRegion, 1, 1)

src/wasm/module-compiler.cc

@@ -229,9 +229,8 @@ class JSToWasmWrapperCache {
   std::vector<Handle<Code>> code_cache_;
 };
 
-// A helper class to simplify instantiating a module from a compiled module.
-// It closes over the {Isolate}, the {ErrorThrower}, the {WasmCompiledModule},
-// etc.
+// A helper class to simplify instantiating a module from a module object.
+// It closes over the {Isolate}, the {ErrorThrower}, etc.
 class InstanceBuilder {
  public:
   InstanceBuilder(Isolate* isolate, ErrorThrower* thrower,
@@ -1046,7 +1045,6 @@ MaybeHandle<WasmInstanceObject> InstanceBuilder::Build() {
   // Record build time into correct bucket, then build instance.
   TimedHistogramScope wasm_instantiate_module_time_scope(SELECT_WASM_COUNTER(
       counters(), module_->origin, wasm_instantiate, module_time));
-  Factory* factory = isolate_->factory();
 
   //--------------------------------------------------------------------------
   // Allocate the memory array buffer.
@@ -1082,6 +1080,7 @@ MaybeHandle<WasmInstanceObject> InstanceBuilder::Build() {
     memory_ = AllocateMemory(initial_pages);
     if (memory_.is_null()) return {};  // failed to allocate memory
   }
+
   //--------------------------------------------------------------------------
   // Recompile module if using trap handlers but could not get guarded memory
   //--------------------------------------------------------------------------
@@ -1113,42 +1112,14 @@ MaybeHandle<WasmInstanceObject> InstanceBuilder::Build() {
     }
   }
 
-  //--------------------------------------------------------------------------
-  // Reuse the compiled module (if no owner), otherwise clone.
-  //--------------------------------------------------------------------------
-  wasm::NativeModule* native_module = module_object_->native_module();
-  // Root the old instance, if any, in case later allocation causes GC,
-  // to prevent the finalizer running for the old instance.
-  MaybeHandle<WasmInstanceObject> old_instance;
-
-  TRACE("Starting new module instantiation\n");
-  Handle<WasmCompiledModule> new_compiled_module;
-  {
-    Handle<WasmCompiledModule> original =
-        handle(module_object_->compiled_module(), isolate_);
-    if (original->has_instance()) {
-      old_instance = handle(original->owning_instance(), isolate_);
-      // Clone, but don't insert yet the clone in the instances chain.
-      // We do that last. Since we are holding on to the old instance,
-      // the owner + original state used for cloning and patching
-      // won't be mutated by possible finalizer runs.
-      TRACE("Cloning from %zu\n", native_module->instance_id);
-      new_compiled_module = WasmCompiledModule::Clone(isolate_, original);
-      RecordStats(module_object_->native_module(), counters());
-    } else {
-      // No instance owned the original compiled module.
-      new_compiled_module = original;
-      TRACE("Reusing existing instance %zu\n", native_module->instance_id);
-    }
-  }
-  wasm::NativeModuleModificationScope native_modification_scope(native_module);
-
   //--------------------------------------------------------------------------
   // Create the WebAssembly.Instance object.
   //--------------------------------------------------------------------------
+  wasm::NativeModule* native_module = module_object_->native_module();
+  TRACE("New module instantiation for %zu\n", native_module->instance_id);
   Handle<WasmInstanceObject> instance =
-      WasmInstanceObject::New(isolate_, module_object_, new_compiled_module);
-  Handle<WeakCell> weak_instance = factory->NewWeakCell(instance);
+      WasmInstanceObject::New(isolate_, module_object_);
+  wasm::NativeModuleModificationScope native_modification_scope(native_module);
 
   //--------------------------------------------------------------------------
   // Set up the globals for the new instance.
@@ -1294,18 +1265,9 @@ MaybeHandle<WasmInstanceObject> InstanceBuilder::Build() {
   FlushICache(native_module);
 
   //--------------------------------------------------------------------------
-  // Insert the compiled module into the weak list of compiled modules.
+  // Install a finalizer on the new instance object.
   //--------------------------------------------------------------------------
-  {
-    if (!old_instance.is_null()) {
-      // Publish the new instance to the instances chain.
-      DisallowHeapAllocation no_gc;
-      new_compiled_module->InsertInChain(*module_object_);
-    }
-    module_object_->set_compiled_module(*new_compiled_module);
-    new_compiled_module->set_weak_owning_instance(*weak_instance);
-    WasmInstanceObject::InstallFinalizer(isolate_, instance);
-  }
+  WasmInstanceObject::InstallFinalizer(isolate_, instance);
 
   //--------------------------------------------------------------------------
   // Debugging support.

src/wasm/wasm-code-manager.cc

@@ -290,11 +290,6 @@ const char* GetWasmCodeKindAsString(WasmCode::Kind kind) {
 }
 
 WasmCode::~WasmCode() {
-  // Depending on finalizer order, the WasmCompiledModule finalizer may be
-  // called first, case in which we release here. If the InstanceFinalizer is
-  // called first, the handlers will be cleared in Reset, as-if the NativeModule
-  // may be later used again (which would be the case if the WasmCompiledModule
-  // were still held by a WasmModuleObject)
   if (HasTrapHandlerIndex()) {
     CHECK_LT(trap_handler_index(),
              static_cast<size_t>(std::numeric_limits<int>::max()));

src/wasm/wasm-objects-inl.h

@@ -20,7 +20,6 @@
 namespace v8 {
 namespace internal {
 
-CAST_ACCESSOR(WasmCompiledModule)
 CAST_ACCESSOR(WasmDebugInfo)
 CAST_ACCESSOR(WasmExportedFunctionData)
 CAST_ACCESSOR(WasmGlobalObject)
@@ -52,12 +51,12 @@ CAST_ACCESSOR(WasmTableObject)
 // WasmModuleObject
 ACCESSORS(WasmModuleObject, managed_native_module, Managed<wasm::NativeModule>,
           kNativeModuleOffset)
-ACCESSORS(WasmModuleObject, compiled_module, WasmCompiledModule,
-          kCompiledModuleOffset)
 ACCESSORS(WasmModuleObject, export_wrappers, FixedArray, kExportWrappersOffset)
 ACCESSORS(WasmModuleObject, managed_module, Managed<wasm::WasmModule>,
           kManagedModuleOffset)
 ACCESSORS(WasmModuleObject, script, Script, kScriptOffset)
+ACCESSORS(WasmModuleObject, weak_instance_list, WeakArrayList,
+          kWeakInstanceListOffset)
 OPTIONAL_ACCESSORS(WasmModuleObject, asm_js_offset_table, ByteArray,
                    kAsmJsOffsetTableOffset)
 OPTIONAL_ACCESSORS(WasmModuleObject, breakpoint_infos, FixedArray,
@@ -156,8 +155,6 @@ PRIMITIVE_ACCESSORS(WasmInstanceObject, indirect_function_table_sig_ids,
 PRIMITIVE_ACCESSORS(WasmInstanceObject, indirect_function_table_targets,
                     Address*, kIndirectFunctionTableTargetsOffset)
 
-ACCESSORS(WasmInstanceObject, compiled_module, WasmCompiledModule,
-          kCompiledModuleOffset)
 ACCESSORS(WasmInstanceObject, module_object, WasmModuleObject,
           kModuleObjectOffset)
 ACCESSORS(WasmInstanceObject, exports_object, JSObject, kExportsObjectOffset)
@@ -220,40 +217,6 @@ OPTIONAL_ACCESSORS(WasmDebugInfo, c_wasm_entry_map, Managed<wasm::SignatureMap>,
                    kCWasmEntryMapOffset)
 
 #undef OPTIONAL_ACCESSORS
-
-#define WCM_OBJECT_OR_WEAK(TYPE, NAME, OFFSET, TYPE_CHECK)   \
-  bool WasmCompiledModule::has_##NAME() const {              \
-    Object* value = READ_FIELD(this, OFFSET);                \
-    return TYPE_CHECK;                                       \
-  }                                                          \
-                                                             \
-  void WasmCompiledModule::reset_##NAME() {                  \
-    WRITE_FIELD(this, OFFSET, GetHeap()->undefined_value()); \
-  }                                                          \
-                                                             \
-  ACCESSORS_CHECKED2(WasmCompiledModule, NAME, TYPE, OFFSET, TYPE_CHECK, true)
-
-#define WCM_OBJECT(TYPE, NAME, OFFSET) \
-  WCM_OBJECT_OR_WEAK(TYPE, NAME, OFFSET, value->Is##TYPE())
-
-#define WCM_WEAK_LINK(TYPE, NAME, OFFSET)                                \
-  WCM_OBJECT_OR_WEAK(WeakCell, weak_##NAME, OFFSET, value->IsWeakCell()) \
-                                                                         \
-  TYPE* WasmCompiledModule::NAME() const {                               \
-    DCHECK(!weak_##NAME()->cleared());                                   \
-    return TYPE::cast(weak_##NAME()->value());                           \
-  }
-
-// WasmCompiledModule
-WCM_OBJECT(WasmCompiledModule, next_instance, kNextInstanceOffset)
-WCM_OBJECT(WasmCompiledModule, prev_instance, kPrevInstanceOffset)
-WCM_WEAK_LINK(WasmInstanceObject, owning_instance, kOwningInstanceOffset)
-ACCESSORS(WasmCompiledModule, raw_next_instance, Object, kNextInstanceOffset);
-ACCESSORS(WasmCompiledModule, raw_prev_instance, Object, kPrevInstanceOffset);
-
-#undef WCM_OBJECT_OR_WEAK
-#undef WCM_OBJECT
-#undef WCM_WEAK_LINK
 #undef READ_PRIMITIVE_FIELD
 #undef WRITE_PRIMITIVE_FIELD
 #undef PRIMITIVE_ACCESSORS
@@ -262,10 +225,6 @@ uint32_t WasmTableObject::current_length() { return functions()->length(); }
 
 bool WasmMemoryObject::has_maximum_pages() { return maximum_pages() >= 0; }
 
-inline bool WasmCompiledModule::has_instance() const {
-  return !weak_owning_instance()->cleared();
-}
-
 #include "src/objects/object-macros-undef.h"
 
 }  // namespace internal

src/wasm/wasm-objects.h

@@ -36,7 +36,6 @@ class BreakPoint;
 class JSArrayBuffer;
 class FixedArrayOfWeakCells;
 class SeqOneByteString;
-class WasmCompiledModule;
 class WasmDebugInfo;
 class WasmInstanceObject;
 
@@ -107,11 +106,11 @@ class WasmModuleObject : public JSObject {
 
   DECL_ACCESSORS(managed_native_module, Managed<wasm::NativeModule>)
   inline wasm::NativeModule* native_module();
-  DECL_ACCESSORS(compiled_module, WasmCompiledModule)
   DECL_ACCESSORS(export_wrappers, FixedArray)
   DECL_ACCESSORS(managed_module, Managed<wasm::WasmModule>)
   inline wasm::WasmModule* module() const;
   DECL_ACCESSORS(script, Script)
+  DECL_ACCESSORS(weak_instance_list, WeakArrayList)
   DECL_OPTIONAL_ACCESSORS(asm_js_offset_table, ByteArray)
   DECL_OPTIONAL_ACCESSORS(breakpoint_infos, FixedArray)
   inline void reset_breakpoint_infos();
@@ -123,10 +122,10 @@ class WasmModuleObject : public JSObject {
 // Layout description.
 #define WASM_MODULE_OBJECT_FIELDS(V)       \
   V(kNativeModuleOffset, kPointerSize)     \
-  V(kCompiledModuleOffset, kPointerSize)   \
   V(kExportWrappersOffset, kPointerSize)   \
   V(kManagedModuleOffset, kPointerSize)    \
   V(kScriptOffset, kPointerSize)           \
+  V(kWeakInstanceListOffset, kPointerSize) \
   V(kAsmJsOffsetTableOffset, kPointerSize) \
   V(kBreakPointInfosOffset, kPointerSize)  \
   V(kSize, 0)
@@ -150,9 +149,6 @@ class WasmModuleObject : public JSObject {
   static bool SetBreakPoint(Handle<WasmModuleObject>, int* position,
                             Handle<BreakPoint> break_point);
 
-  static void ValidateStateForTesting(Isolate* isolate,
-                                      Handle<WasmModuleObject> module);
-
   // Check whether this module was generated from asm.js source.
   inline bool is_asm_js();
 
@@ -374,7 +370,6 @@ class WasmInstanceObject : public JSObject {
  public:
   DECL_CAST(WasmInstanceObject)
 
-  DECL_ACCESSORS(compiled_module, WasmCompiledModule)
   DECL_ACCESSORS(module_object, WasmModuleObject)
   DECL_ACCESSORS(exports_object, JSObject)
   DECL_ACCESSORS(native_context, Context)
@@ -408,7 +403,6 @@ class WasmInstanceObject : public JSObject {
 
 // Layout description.
 #define WASM_INSTANCE_OBJECT_FIELDS(V)                                  \
-  V(kCompiledModuleOffset, kPointerSize)                                \
   V(kModuleObjectOffset, kPointerSize)                                  \
   V(kExportsObjectOffset, kPointerSize)                                 \
   V(kNativeContextOffset, kPointerSize)                                 \
@@ -456,12 +450,7 @@ class WasmInstanceObject : public JSObject {
   // If no debug info exists yet, it is created automatically.
   static Handle<WasmDebugInfo> GetOrCreateDebugInfo(Handle<WasmInstanceObject>);
 
-  static Handle<WasmInstanceObject> New(Isolate*, Handle<WasmModuleObject>,
-                                        Handle<WasmCompiledModule>);
-
-  static void ValidateInstancesChainForTesting(
-      Isolate* isolate, Handle<WasmModuleObject> module_obj,
-      int instance_count);
+  static Handle<WasmInstanceObject> New(Isolate*, Handle<WasmModuleObject>);
 
   static void InstallFinalizer(Isolate* isolate,
                                Handle<WasmInstanceObject> instance);
@@ -519,73 +508,6 @@ class WasmExportedFunctionData : public Struct {
 #undef WASM_EXPORTED_FUNCTION_DATA_FIELDS
 };
 
-// This represents the set of wasm compiled functions, together
-// with all the information necessary for re-specializing them.
-class WasmCompiledModule : public Struct {
- public:
-  DECL_CAST(WasmCompiledModule)
-
-  // Dispatched behavior.
-  DECL_PRINTER(WasmCompiledModule)
-  DECL_VERIFIER(WasmCompiledModule)
-
-// Layout description.
-#define WASM_COMPILED_MODULE_FIELDS(V)          \
-  V(kNextInstanceOffset, kPointerSize)          \
-  V(kPrevInstanceOffset, kPointerSize)          \
-  V(kOwningInstanceOffset, kPointerSize)        \
-  V(kSize, 0)
-
-  DEFINE_FIELD_OFFSET_CONSTANTS(HeapObject::kHeaderSize,
-                                WASM_COMPILED_MODULE_FIELDS)
-#undef WASM_COMPILED_MODULE_FIELDS
-
-#define WCM_OBJECT_OR_WEAK(TYPE, NAME, SETTER_MODIFIER) \
- public:                                                \
-  inline TYPE* NAME() const;                            \
-  inline bool has_##NAME() const;                       \
-  inline void reset_##NAME();                           \
-                                                        \
-  SETTER_MODIFIER:                                      \
-  inline void set_##NAME(TYPE* value,                   \
-                         WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
-
-#define WCM_OBJECT(TYPE, NAME) WCM_OBJECT_OR_WEAK(TYPE, NAME, public)
-
-#define WCM_CONST_OBJECT(TYPE, NAME) WCM_OBJECT_OR_WEAK(TYPE, NAME, private)
-
-#define WCM_WEAK_LINK(TYPE, NAME)                   \
-  WCM_OBJECT_OR_WEAK(WeakCell, weak_##NAME, public) \
-                                                    \
- public:                                            \
-  inline TYPE* NAME() const;
-
-  // Add values here if they are required for creating new instances or
-  // for deserialization, and if they are serializable.
-  // By default, instance values go to WasmInstanceObject, however, if
-  // we embed the generated code with a value, then we track that value here.
-  WCM_CONST_OBJECT(WasmCompiledModule, next_instance)
-  WCM_CONST_OBJECT(WasmCompiledModule, prev_instance)
-  WCM_WEAK_LINK(WasmInstanceObject, owning_instance)
-
- public:
-  static Handle<WasmCompiledModule> New(Isolate* isolate);
-
-  static Handle<WasmCompiledModule> Clone(Isolate* isolate,
-                                          Handle<WasmCompiledModule> module);
-
-  bool has_instance() const;
-
-  void InsertInChain(WasmModuleObject*);
-  void RemoveFromChain(Isolate* isolate);
-
-  DECL_ACCESSORS(raw_next_instance, Object);
-  DECL_ACCESSORS(raw_prev_instance, Object);
-
- private:
-  DISALLOW_IMPLICIT_CONSTRUCTORS(WasmCompiledModule);
-};
-
 class WasmDebugInfo : public Struct {
  public:
   DECL_ACCESSORS(wasm_instance, WasmInstanceObject)
@@ -681,11 +603,6 @@ class WasmDebugInfo : public Struct {
 };
 
 #undef DECL_OPTIONAL_ACCESSORS
-#undef WCM_CONST_OBJECT
-#undef WCM_LARGE_NUMBER
-#undef WCM_OBJECT
-#undef WCM_OBJECT_OR_WEAK
-#undef WCM_WEAK_LINK
 
 }  // namespace internal
 }  // namespace v8

test/cctest/wasm/test-wasm-breakpoints.cc

@@ -120,8 +120,6 @@ void SetBreakpoint(WasmRunnerBase& runner, int function_index, int byte_offset,
   int code_offset = func_offset + byte_offset;
   if (expected_set_byte_offset == -1) expected_set_byte_offset = byte_offset;
   Handle<WasmInstanceObject> instance = runner.builder().instance_object();
-  Handle<WasmCompiledModule> compiled_module(instance->compiled_module(),
-                                             runner.main_isolate());
   Handle<WasmModuleObject> module_object(instance->module_object(),
                                          runner.main_isolate());
   static int break_index = 0;

test/cctest/wasm/test-wasm-serialization.cc

@@ -154,10 +154,6 @@ class WasmSerializationTest {
       Handle<WasmModuleObject> module_object =
           maybe_module_object.ToHandleChecked();
 
-      Handle<WasmCompiledModule> compiled_module(
-          module_object->compiled_module(), serialization_isolate);
-      Handle<FixedArray> export_wrappers(module_object->export_wrappers(),
-                                         serialization_isolate);
       v8::Local<v8::Object> v8_module_obj =
           v8::Utils::ToLocal(Handle<JSObject>::cast(module_object));
       CHECK(v8_module_obj->IsWebAssemblyCompiledModule());

test/cctest/wasm/wasm-run-utils.cc

@@ -224,20 +224,14 @@ Handle<WasmInstanceObject> TestingModuleBuilder::InitInstanceObject() {
   Handle<WasmModuleObject> module_object =
       WasmModuleObject::New(isolate_, export_wrappers, test_module_, env,
                             nullptr, 0, script, Handle<ByteArray>::null());
-  Handle<WasmCompiledModule> compiled_module(module_object->compiled_module(),
-                                             isolate_);
   // This method is called when we initialize TestEnvironment. We don't
   // have a memory yet, so we won't create it here. We'll update the
   // interpreter when we get a memory. We do have globals, though.
   native_module_ = module_object->native_module();
   native_module_->ReserveCodeTableForTesting(kMaxFunctions);
 
-  DCHECK(compiled_module->IsWasmCompiledModule());
-  auto instance =
-      WasmInstanceObject::New(isolate_, module_object, compiled_module);
+  auto instance = WasmInstanceObject::New(isolate_, module_object);
   instance->set_globals_start(globals_data_);
-  Handle<WeakCell> weak_instance = isolate()->factory()->NewWeakCell(instance);
-  compiled_module->set_weak_owning_instance(*weak_instance);
   return instance;
 }
 

test/cctest/wasm/wasm-run-utils.h

@@ -86,7 +86,7 @@ struct ManuallyImportedJSFunction {
 
 // A  Wasm module builder. Globals are pre-set, however, memory and code may be
 // progressively added by a test. In turn, we piecemeal update the runtime
-// objects, i.e. {WasmInstanceObject}, {WasmCompiledModule} and, if necessary,
+// objects, i.e. {WasmInstanceObject}, {WasmModuleObject} and, if necessary,
 // the interpreter.
 class TestingModuleBuilder {
  public:

test/mjsunit/wasm/compiled-module-management.js

@@ -27,23 +27,21 @@ var instance4;
     ]).exportFunc();
 
   module = new WebAssembly.Module(builder.toBuffer());
-  print("Initial module");
-  %ValidateWasmModuleState(module);
 
   print("Initial instances=0");
-  %ValidateWasmInstancesChain(module, 0);
+  assertEquals(0, %WasmGetNumberOfInstances(module));
   instance1 = new WebAssembly.Instance(module, {"": {getValue: () => 1}});
 
   print("Initial instances=1");
-  %ValidateWasmInstancesChain(module, 1);
+  assertEquals(1, %WasmGetNumberOfInstances(module));
   instance2 = new WebAssembly.Instance(module, {"": {getValue: () => 2}});
 
   print("Initial instances=2");
-  %ValidateWasmInstancesChain(module, 2);
+  assertEquals(2, %WasmGetNumberOfInstances(module));
   instance3 = new WebAssembly.Instance(module, {"": {getValue: () => 3}});
 
   print("Initial instances=3");
-  %ValidateWasmInstancesChain(module, 3);
+  assertEquals(3, %WasmGetNumberOfInstances(module));
 })();
 
 (function CompiledModuleInstancesClear1() {
@@ -51,30 +49,33 @@ var instance4;
   instance1 = null;
 })();
 
+// Note that two GC's are required because weak slots clearing is deferred.
+gc();
 gc();
 print("After gc instances=2");
-%ValidateWasmInstancesChain(module, 2);
+assertEquals(2, %WasmGetNumberOfInstances(module));
 
 (function CompiledModuleInstancesClear3() {
   assertEquals(3, instance3.exports.f());
   instance3 = null;
 })();
 
+// Note that two GC's are required because weak slots clearing is deferred.
+gc();
 gc();
 print("After gc instances=1");
-%ValidateWasmInstancesChain(module, 1);
+assertEquals(1, %WasmGetNumberOfInstances(module));
 
 (function CompiledModuleInstancesClear2() {
   assertEquals(2, instance2.exports.f());
   instance2 = null;
 })();
 
-// Note that two GC's are required because weak cells are not cleared
-// in the same cycle that the instance finalizer is run.
+// Note that two GC's are required because weak slots clearing is deferred.
 gc();
 gc();
-print("After gc module state");
-%ValidateWasmModuleState(module);
+print("After gc instances=0");
+assertEquals(0, %WasmGetNumberOfInstances(module));
 
 (function CompiledModuleInstancesInitialize4AndClearModule() {
   instance4 = new WebAssembly.Instance(module, {"": {getValue: () => 4}});
@@ -82,6 +83,6 @@ print("After gc module state");
   module = null;
 })();
 
-// Note that the first GC will clear the module, the second the instance.
+// Note that two GC's are required because weak slots clearing is deferred.
 gc();
 gc();