[wasm] Introduce instance types for WebAssembly.* objects.

test/cctest/wasm/test-run-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 <stdlib.h>
 #include <string.h>
 
 #include "src/objects-inl.h"
 #include "src/snapshot/code-serializer.h"
 #include "src/version.h"
@@ skipping 254 matching lines @@
   }
 
   void DeserializeAndRun() {
     ErrorThrower thrower(current_isolate(), "");
     v8::Local<v8::WasmCompiledModule> deserialized_module;
     CHECK(Deserialize().ToLocal(&deserialized_module));
     Handle<WasmModuleObject> module_object = Handle<WasmModuleObject>::cast(
         v8::Utils::OpenHandle(*deserialized_module));
     {
       DisallowHeapAllocation assume_no_gc;
-      Handle<WasmCompiledModule> compiled_part(
-          WasmCompiledModule::cast(module_object->GetEmbedderField(0)),
-          current_isolate());
+      Handle<WasmCompiledModule> compiled_part(module_object->compiled_module(),
+                                               current_isolate());
       CHECK_EQ(memcmp(compiled_part->module_bytes()->GetCharsAddress(),
                       wire_bytes().first, wire_bytes().second),
                0);
     }
     Handle<JSObject> instance =
         SyncInstantiate(current_isolate(), &thrower, module_object,
                         Handle<JSReceiver>::null(),
                         MaybeHandle<JSArrayBuffer>())
             .ToHandleChecked();
     Handle<Object> params[1] = {
@@ skipping 814 matching lines @@
     // Fake the Embedder flow by creating a memory object, externalize and grow.
     Handle<WasmMemoryObject> mem_obj =
         WasmMemoryObject::New(isolate, memory, 100);
 
     v8::Utils::ToLocal(memory)->Externalize();
 
     uint32_t result = WasmMemoryObject::Grow(isolate, mem_obj, 4);
     const bool free_memory = true;
     wasm::DetachWebAssemblyMemoryBuffer(isolate, memory, free_memory);
     CHECK_EQ(16, result);
-    memory = handle(mem_obj->buffer());
+    memory = handle(mem_obj->array_buffer());
     instance->set_memory_buffer(*memory);
     // Externalize should make no difference without the JS API as in this case
     // the buffer is not detached.
     v8::Utils::ToLocal(memory)->Externalize();
     result = testing::RunWasmModuleForTesting(isolate, instance, 0, nullptr);
     CHECK_EQ(kExpectedValue, result);
     // Free the buffer as the tracker does not know about it.
     const v8::ArrayBuffer::Allocator::AllocationMode allocation_mode =
         memory->allocation_mode();
     CHECK_NOT_NULL(memory->allocation_base());
@@ skipping 41 matching lines @@
     Handle<JSArrayBuffer> buffer = wasm::SetupArrayBuffer(
         isolate, backing_store, 16 * WasmModule::kPageSize, backing_store,
         16 * WasmModule::kPageSize, false, false);
     v8::Utils::ToLocal(buffer)->Externalize();
     wasm::DetachWebAssemblyMemoryBuffer(isolate, buffer, true);
     isolate->array_buffer_allocator()->Free(backing_store,
                                             16 * WasmModule::kPageSize);
   }
   Cleanup();
 }