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

src/wasm/wasm-objects.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 "src/wasm/wasm-objects.h"
 #include "src/utils.h"
 
 #include "src/assembler-inl.h"
 #include "src/base/iterator.h"
 #include "src/compiler/wasm-compiler.h"
@@ skipping 11 matching lines @@
   } while (false)
 
 #define TRACE_CHAIN(instance)        \
   do {                               \
     instance->PrintInstancesChain(); \
   } while (false)
 
 using namespace v8::internal;
 using namespace v8::internal::wasm;
 
-#define DEFINE_GETTER0(getter, Container, name, field, type) \
-  type* Container::name() { return type::cast(getter(field)); }
-
-#define DEFINE_ACCESSORS0(getter, setter, Container, name, field, type) \
-  DEFINE_GETTER0(getter, Container, name, field, type)                  \
-  void Container::set_##name(type* value) { return setter(field, value); }
-
-#define DEFINE_OPTIONAL_ACCESSORS0(getter, setter, Container, name, field, \
-                                   type)                                   \
-  DEFINE_ACCESSORS0(getter, setter, Container, name, field, type)          \
-  bool Container::has_##name() {                                           \
-    return !getter(field)->IsUndefined(GetIsolate());                      \
-  }
-
-#define DEFINE_OPTIONAL_GETTER0(getter, Container, name, field, type) \
-  DEFINE_GETTER0(getter, Container, name, field, type)                \
-  bool Container::has_##name() {                                      \
-    return !getter(field)->IsUndefined(GetIsolate());                 \
-  }
-
-#define DEFINE_GETTER0(getter, Container, name, field, type) \
-  type* Container::name() { return type::cast(getter(field)); }
-
-#define DEFINE_OBJ_GETTER(Container, name, field, type) \
-  DEFINE_GETTER0(GetEmbedderField, Container, name, field, type)
-#define DEFINE_OBJ_ACCESSORS(Container, name, field, type)               \
-  DEFINE_ACCESSORS0(GetEmbedderField, SetEmbedderField, Container, name, \
-                    field, type)
-#define DEFINE_OPTIONAL_OBJ_ACCESSORS(Container, name, field, type)         \
-  DEFINE_OPTIONAL_ACCESSORS0(GetEmbedderField, SetEmbedderField, Container, \
-                             name, field, type)
-#define DEFINE_ARR_GETTER(Container, name, field, type) \
-  DEFINE_GETTER0(get, Container, name, field, type)
-#define DEFINE_ARR_ACCESSORS(Container, name, field, type) \
-  DEFINE_ACCESSORS0(get, set, Container, name, field, type)
-#define DEFINE_OPTIONAL_ARR_ACCESSORS(Container, name, field, type) \
-  DEFINE_OPTIONAL_ACCESSORS0(get, set, Container, name, field, type)
-#define DEFINE_OPTIONAL_ARR_GETTER(Container, name, field, type) \
-  DEFINE_OPTIONAL_GETTER0(get, Container, name, field, type)
-
 namespace {
 
 // An iterator that returns first the module itself, then all modules linked via
 // next, then all linked via prev.
 class CompiledModulesIterator
     : public v8::base::iterator<std::input_iterator_tag,
                                 Handle<WasmCompiledModule>> {
  public:
   CompiledModulesIterator(Isolate* isolate,
                           Handle<WasmCompiledModule> start_module, bool at_end)
@@ skipping 109 matching lines @@
     if (offset == static_cast<uint32_t>(offset_in_func)) return true;
   }
   return false;
 }
 #endif  // DEBUG
 
 }  // namespace
 
 Handle<WasmModuleObject> WasmModuleObject::New(
     Isolate* isolate, Handle<WasmCompiledModule> compiled_module) {
-  WasmModule* module = compiled_module->module();
-  Handle<JSObject> module_object;
-  if (module->is_wasm()) {
-    Handle<JSFunction> module_cons(
-        isolate->native_context()->wasm_module_constructor());
-    module_object = isolate->factory()->NewJSObject(module_cons);
-    Handle<Symbol> module_sym(isolate->native_context()->wasm_module_sym());
-    Object::SetProperty(module_object, module_sym, module_object, STRICT)
-        .Check();
-  } else {
-    DCHECK(module->is_asm_js());
-    Handle<Map> map = isolate->factory()->NewMap(
-        JS_OBJECT_TYPE,
-        JSObject::kHeaderSize + WasmModuleObject::kFieldCount * kPointerSize);
-    module_object = isolate->factory()->NewJSObjectFromMap(map, TENURED);
-  }
-  module_object->SetEmbedderField(WasmModuleObject::kCompiledModule,
-                                  *compiled_module);
+  Handle<JSFunction> module_cons(
+      isolate->native_context()->wasm_module_constructor());
+  auto module_object = Handle<WasmModuleObject>::cast(
+      isolate->factory()->NewJSObject(module_cons));
+  Handle<Symbol> module_sym(isolate->native_context()->wasm_module_sym());
+  Object::SetProperty(module_object, module_sym, module_object, STRICT).Check();
+  module_object->set_compiled_module(*compiled_module);
   Handle<WeakCell> link_to_module =
       isolate->factory()->NewWeakCell(module_object);
   compiled_module->set_weak_wasm_module(link_to_module);
-  return Handle<WasmModuleObject>::cast(module_object);
+  return module_object;
 }
 
-WasmModuleObject* WasmModuleObject::cast(Object* object) {
-  DCHECK(object->IsJSObject());
-  // TODO(titzer): brand check for WasmModuleObject.
-  return reinterpret_cast<WasmModuleObject*>(object);
-}
-
-bool WasmModuleObject::IsWasmModuleObject(Object* object) {
-  return object->IsJSObject() &&
-         JSObject::cast(object)->GetEmbedderFieldCount() == kFieldCount;
-}
-
-DEFINE_OBJ_GETTER(WasmModuleObject, compiled_module, kCompiledModule,
-                  WasmCompiledModule)
-
 Handle<WasmTableObject> WasmTableObject::New(Isolate* isolate, uint32_t initial,
                                              int64_t maximum,
                                              Handle<FixedArray>* js_functions) {
   Handle<JSFunction> table_ctor(
       isolate->native_context()->wasm_table_constructor());
-  Handle<JSObject> table_obj = isolate->factory()->NewJSObject(table_ctor);
-  table_obj->SetEmbedderField(kWrapperTracerHeader, Smi::kZero);
+  auto table_obj = Handle<WasmTableObject>::cast(
+      isolate->factory()->NewJSObject(table_ctor));
 
   *js_functions = isolate->factory()->NewFixedArray(initial);
   Object* null = isolate->heap()->null_value();
   for (int i = 0; i < static_cast<int>(initial); ++i) {
     (*js_functions)->set(i, null);
   }
-  table_obj->SetEmbedderField(kFunctions, *(*js_functions));
-  Handle<Object> max = isolate->factory()->NewNumber(maximum);
-  table_obj->SetEmbedderField(kMaximum, *max);
+  table_obj->set_functions(**js_functions);
+  DCHECK_EQ(maximum, static_cast<int>(maximum));
+  table_obj->set_maximum_length(static_cast<int>(maximum));
 
   Handle<FixedArray> dispatch_tables = isolate->factory()->NewFixedArray(0);
-  table_obj->SetEmbedderField(kDispatchTables, *dispatch_tables);
+  table_obj->set_dispatch_tables(*dispatch_tables);
   Handle<Symbol> table_sym(isolate->native_context()->wasm_table_sym());
   Object::SetProperty(table_obj, table_sym, table_obj, STRICT).Check();
   return Handle<WasmTableObject>::cast(table_obj);
 }
 
 Handle<FixedArray> WasmTableObject::AddDispatchTable(
     Isolate* isolate, Handle<WasmTableObject> table_obj,
     Handle<WasmInstanceObject> instance, int table_index,
     Handle<FixedArray> function_table, Handle<FixedArray> signature_table) {
-  Handle<FixedArray> dispatch_tables(
-      FixedArray::cast(table_obj->GetEmbedderField(kDispatchTables)), isolate);
+  Handle<FixedArray> dispatch_tables(table_obj->dispatch_tables());
   DCHECK_EQ(0, dispatch_tables->length() % 4);
 
   if (instance.is_null()) return dispatch_tables;
   // TODO(titzer): use weak cells here to avoid leaking instances.
 
   // Grow the dispatch table and add a new entry at the end.
   Handle<FixedArray> new_dispatch_tables =
       isolate->factory()->CopyFixedArrayAndGrow(dispatch_tables, 4);
 
   new_dispatch_tables->set(dispatch_tables->length() + 0, *instance);
   new_dispatch_tables->set(dispatch_tables->length() + 1,
                            Smi::FromInt(table_index));
   new_dispatch_tables->set(dispatch_tables->length() + 2, *function_table);
   new_dispatch_tables->set(dispatch_tables->length() + 3, *signature_table);
 
-  table_obj->SetEmbedderField(WasmTableObject::kDispatchTables,
-                              *new_dispatch_tables);
+  table_obj->set_dispatch_tables(*new_dispatch_tables);
 
   return new_dispatch_tables;
 }
 
-DEFINE_OBJ_ACCESSORS(WasmTableObject, functions, kFunctions, FixedArray)
-
-DEFINE_OBJ_GETTER(WasmTableObject, dispatch_tables, kDispatchTables, FixedArray)
-
-uint32_t WasmTableObject::current_length() { return functions()->length(); }
-
-bool WasmTableObject::has_maximum_length() {
-  return GetEmbedderField(kMaximum)->Number() >= 0;
-}
-
-int64_t WasmTableObject::maximum_length() {
-  return static_cast<int64_t>(GetEmbedderField(kMaximum)->Number());
-}
-
-WasmTableObject* WasmTableObject::cast(Object* object) {
-  DCHECK(object && object->IsJSObject());
-  // TODO(titzer): brand check for WasmTableObject.
-  return reinterpret_cast<WasmTableObject*>(object);
-}
-
 void WasmTableObject::grow(Isolate* isolate, uint32_t count) {
-  Handle<FixedArray> dispatch_tables(
-      FixedArray::cast(GetEmbedderField(kDispatchTables)));
+  Handle<FixedArray> dispatch_tables(this->dispatch_tables());
   DCHECK_EQ(0, dispatch_tables->length() % 4);
   uint32_t old_size = functions()->length();
 
   Zone specialization_zone(isolate->allocator(), ZONE_NAME);
   for (int i = 0; i < dispatch_tables->length(); i += 4) {
     Handle<FixedArray> old_function_table(
         FixedArray::cast(dispatch_tables->get(i + 2)));
     Handle<FixedArray> old_signature_table(
         FixedArray::cast(dispatch_tables->get(i + 3)));
     Handle<FixedArray> new_function_table =
@@ skipping 76 matching lines @@
   code_specialization.ApplyToWholeInstance(*instance);
 }
 
 }  // namespace
 
 Handle<WasmMemoryObject> WasmMemoryObject::New(Isolate* isolate,
                                                Handle<JSArrayBuffer> buffer,
                                                int32_t maximum) {
   Handle<JSFunction> memory_ctor(
       isolate->native_context()->wasm_memory_constructor());
-  Handle<JSObject> memory_obj =
-      isolate->factory()->NewJSObject(memory_ctor, TENURED);
-  memory_obj->SetEmbedderField(kWrapperTracerHeader, Smi::kZero);
+  auto memory_obj = Handle<WasmMemoryObject>::cast(
+      isolate->factory()->NewJSObject(memory_ctor, TENURED));
   if (buffer.is_null()) {
     const bool enable_guard_regions = EnableGuardRegions();
     buffer = SetupArrayBuffer(isolate, nullptr, 0, nullptr, 0, false,
                               enable_guard_regions);
   }
-  memory_obj->SetEmbedderField(kArrayBuffer, *buffer);
-  Handle<Object> max = isolate->factory()->NewNumber(maximum);
-  memory_obj->SetEmbedderField(kMaximum, *max);
+  memory_obj->set_array_buffer(*buffer);
+  memory_obj->set_maximum_pages(maximum);
   Handle<Symbol> memory_sym(isolate->native_context()->wasm_memory_sym());
   Object::SetProperty(memory_obj, memory_sym, memory_obj, STRICT).Check();
   return Handle<WasmMemoryObject>::cast(memory_obj);
 }
 
-DEFINE_OBJ_ACCESSORS(WasmMemoryObject, buffer, kArrayBuffer, JSArrayBuffer)
-DEFINE_OPTIONAL_OBJ_ACCESSORS(WasmMemoryObject, instances_link, kInstancesLink,
-                              WasmInstanceWrapper)
-
 uint32_t WasmMemoryObject::current_pages() {
   uint32_t byte_length;
-  CHECK(buffer()->byte_length()->ToUint32(&byte_length));
+  CHECK(array_buffer()->byte_length()->ToUint32(&byte_length));
   return byte_length / wasm::WasmModule::kPageSize;
 }
 
-bool WasmMemoryObject::has_maximum_pages() {
-  return GetEmbedderField(kMaximum)->Number() >= 0;
-}
-
-int32_t WasmMemoryObject::maximum_pages() {
-  return static_cast<int32_t>(GetEmbedderField(kMaximum)->Number());
-}
-
-WasmMemoryObject* WasmMemoryObject::cast(Object* object) {
-  DCHECK(object && object->IsJSObject());
-  // TODO(titzer): brand check for WasmMemoryObject.
-  return reinterpret_cast<WasmMemoryObject*>(object);
-}
-
 void WasmMemoryObject::AddInstance(Isolate* isolate,
                                    Handle<WasmInstanceObject> instance) {
   Handle<WasmInstanceWrapper> instance_wrapper =
       handle(instance->instance_wrapper());
   if (has_instances_link()) {
     Handle<WasmInstanceWrapper> current_wrapper(instances_link());
     DCHECK(WasmInstanceWrapper::IsWasmInstanceWrapper(*current_wrapper));
     DCHECK(!current_wrapper->has_previous());
     instance_wrapper->set_next_wrapper(*current_wrapper);
     current_wrapper->set_previous_wrapper(*instance_wrapper);
   }
   set_instances_link(*instance_wrapper);
 }
 
-void WasmMemoryObject::ResetInstancesLink(Isolate* isolate) {
-  Handle<Object> undefined = isolate->factory()->undefined_value();
-  SetEmbedderField(kInstancesLink, *undefined);
-}
-
 // static
 int32_t WasmMemoryObject::Grow(Isolate* isolate,
                                Handle<WasmMemoryObject> memory_object,
                                uint32_t pages) {
-  Handle<JSArrayBuffer> old_buffer(memory_object->buffer());
+  Handle<JSArrayBuffer> old_buffer(memory_object->array_buffer());
   uint32_t old_size = 0;
   CHECK(old_buffer->byte_length()->ToUint32(&old_size));
   Handle<JSArrayBuffer> new_buffer;
   // Return current size if grow by 0.
   if (pages == 0) {
     // Even for pages == 0, we need to attach a new JSArrayBuffer with the same
     // backing store and neuter the old one to be spec compliant.
     if (old_size != 0) {
       new_buffer = SetupArrayBuffer(
           isolate, old_buffer->allocation_base(),
           old_buffer->allocation_length(), old_buffer->backing_store(),
           old_size, old_buffer->is_external(), old_buffer->has_guard_region());
-      memory_object->set_buffer(*new_buffer);
+      memory_object->set_array_buffer(*new_buffer);
     }
     DCHECK_EQ(0, old_size % WasmModule::kPageSize);
     return old_size / WasmModule::kPageSize;
   }
   if (!memory_object->has_instances_link()) {
     // Memory object does not have an instance associated with it, just grow
     uint32_t max_pages;
     if (memory_object->has_maximum_pages()) {
       max_pages = static_cast<uint32_t>(memory_object->maximum_pages());
       if (FLAG_wasm_max_mem_pages < max_pages) return -1;
     } else {
       max_pages = FLAG_wasm_max_mem_pages;
     }
     new_buffer = GrowMemoryBuffer(isolate, old_buffer, pages, max_pages);
     if (new_buffer.is_null()) return -1;
   } else {
     Handle<WasmInstanceWrapper> instance_wrapper(
         memory_object->instances_link());
     DCHECK(WasmInstanceWrapper::IsWasmInstanceWrapper(*instance_wrapper));
     DCHECK(instance_wrapper->has_instance());
     Handle<WasmInstanceObject> instance = instance_wrapper->instance_object();
-    DCHECK(IsWasmInstance(*instance));
+    DCHECK(instance->IsWasmInstanceObject());
     uint32_t max_pages = instance->GetMaxMemoryPages();
 
     // Grow memory object buffer and update instances associated with it.
     new_buffer = GrowMemoryBuffer(isolate, old_buffer, pages, max_pages);
     if (new_buffer.is_null()) return -1;
     DCHECK(!instance_wrapper->has_previous());
     SetInstanceMemory(isolate, instance, new_buffer);
     Address old_mem_start = static_cast<Address>(old_buffer->backing_store());
     UncheckedUpdateInstanceMemory(isolate, instance, old_mem_start, old_size);
     while (instance_wrapper->has_next()) {
       instance_wrapper = instance_wrapper->next_wrapper();
       DCHECK(WasmInstanceWrapper::IsWasmInstanceWrapper(*instance_wrapper));
       Handle<WasmInstanceObject> instance = instance_wrapper->instance_object();
-      DCHECK(IsWasmInstance(*instance));
+      DCHECK(instance->IsWasmInstanceObject());
       SetInstanceMemory(isolate, instance, new_buffer);
       UncheckedUpdateInstanceMemory(isolate, instance, old_mem_start, old_size);
     }
   }
-  memory_object->set_buffer(*new_buffer);
+  memory_object->set_array_buffer(*new_buffer);
   DCHECK_EQ(0, old_size % WasmModule::kPageSize);
   return old_size / WasmModule::kPageSize;
 }
 
-DEFINE_OBJ_ACCESSORS(WasmInstanceObject, compiled_module, kCompiledModule,
-                     WasmCompiledModule)
-DEFINE_OPTIONAL_OBJ_ACCESSORS(WasmInstanceObject, globals_buffer,
-                              kGlobalsArrayBuffer, JSArrayBuffer)
-DEFINE_OPTIONAL_OBJ_ACCESSORS(WasmInstanceObject, memory_buffer,
-                              kMemoryArrayBuffer, JSArrayBuffer)
-DEFINE_OPTIONAL_OBJ_ACCESSORS(WasmInstanceObject, memory_object, kMemoryObject,
-                              WasmMemoryObject)
-DEFINE_OPTIONAL_OBJ_ACCESSORS(WasmInstanceObject, debug_info, kDebugInfo,
-                              WasmDebugInfo)
-DEFINE_OPTIONAL_OBJ_ACCESSORS(WasmInstanceObject, instance_wrapper,
-                              kWasmMemInstanceWrapper, WasmInstanceWrapper)
-DEFINE_OPTIONAL_OBJ_ACCESSORS(WasmInstanceObject, directly_called_instances,
-                              kDirectlyCalledInstances, FixedArray)
-
 WasmModuleObject* WasmInstanceObject::module_object() {
   return *compiled_module()->wasm_module();
 }
 
 WasmModule* WasmInstanceObject::module() { return compiled_module()->module(); }
 
 Handle<WasmDebugInfo> WasmInstanceObject::GetOrCreateDebugInfo(
     Handle<WasmInstanceObject> instance) {
   if (instance->has_debug_info()) return handle(instance->debug_info());
   Handle<WasmDebugInfo> new_info = WasmDebugInfo::New(instance);
   DCHECK(instance->has_debug_info());
   return new_info;
 }
 
-WasmInstanceObject* WasmInstanceObject::cast(Object* object) {
-  DCHECK(IsWasmInstanceObject(object));
-  return reinterpret_cast<WasmInstanceObject*>(object);
-}
-
-bool WasmInstanceObject::IsWasmInstanceObject(Object* object) {
-  if (!object->IsJSObject()) return false;
-
-  JSObject* obj = JSObject::cast(object);
-  Isolate* isolate = obj->GetIsolate();
-  if (obj->GetEmbedderFieldCount() != kFieldCount) {
-    return false;
-  }
-
-  Object* mem = obj->GetEmbedderField(kMemoryArrayBuffer);
-  if (!(mem->IsUndefined(isolate) || mem->IsJSArrayBuffer()) ||
-      !WasmCompiledModule::IsWasmCompiledModule(
-          obj->GetEmbedderField(kCompiledModule))) {
-    return false;
-  }
-
-  // All checks passed.
-  return true;
-}
-
 Handle<WasmInstanceObject> WasmInstanceObject::New(
     Isolate* isolate, Handle<WasmCompiledModule> compiled_module) {
   Handle<JSFunction> instance_cons(
       isolate->native_context()->wasm_instance_constructor());
   Handle<JSObject> instance_object =
       isolate->factory()->NewJSObject(instance_cons, TENURED);
-  instance_object->SetEmbedderField(kWrapperTracerHeader, Smi::kZero);
 
   Handle<Symbol> instance_sym(isolate->native_context()->wasm_instance_sym());
   Object::SetProperty(instance_object, instance_sym, instance_object, STRICT)
       .Check();
   Handle<WasmInstanceObject> instance(
       reinterpret_cast<WasmInstanceObject*>(*instance_object), isolate);
 
-  instance->SetEmbedderField(kCompiledModule, *compiled_module);
-  instance->SetEmbedderField(kMemoryObject, isolate->heap()->undefined_value());
+  instance->set_compiled_module(*compiled_module);
   Handle<WasmInstanceWrapper> instance_wrapper =
       WasmInstanceWrapper::New(isolate, instance);
-  instance->SetEmbedderField(kWasmMemInstanceWrapper, *instance_wrapper);
+  instance->set_instance_wrapper(*instance_wrapper);
   return instance;
 }
 
 int32_t WasmInstanceObject::GetMemorySize() {
   if (!has_memory_buffer()) return 0;
   uint32_t bytes = memory_buffer()->byte_length()->Number();
   DCHECK_EQ(0, bytes % WasmModule::kPageSize);
   return bytes / WasmModule::kPageSize;
 }
 
@@ skipping 35 matching lines @@
   }
   uint32_t compiled_max_pages = compiled_module()->module()->max_mem_pages;
   Isolate* isolate = GetIsolate();
   assert(compiled_module()->module()->is_wasm());
   isolate->counters()->wasm_wasm_max_mem_pages_count()->AddSample(
       compiled_max_pages);
   if (compiled_max_pages != 0) return compiled_max_pages;
   return FLAG_wasm_max_mem_pages;
 }
 
-WasmInstanceObject* WasmExportedFunction::instance() {
-  return WasmInstanceObject::cast(GetEmbedderField(kInstance));
-}
-
-int WasmExportedFunction::function_index() {
-  int32_t func_index;
-  CHECK(GetEmbedderField(kIndex)->ToInt32(&func_index));
-  return func_index;
-}
-
 WasmExportedFunction* WasmExportedFunction::cast(Object* object) {
   DCHECK(object && object->IsJSFunction());
   DCHECK_EQ(Code::JS_TO_WASM_FUNCTION,
             JSFunction::cast(object)->code()->kind());
   // TODO(titzer): brand check for WasmExportedFunction.
   return reinterpret_cast<WasmExportedFunction*>(object);
 }
 
 Handle<WasmExportedFunction> WasmExportedFunction::New(
     Isolate* isolate, Handle<WasmInstanceObject> instance,
     MaybeHandle<String> maybe_name, int func_index, int arity,
     Handle<Code> export_wrapper) {
   Handle<String> name;
   if (maybe_name.is_null()) {
     EmbeddedVector<char, 16> buffer;
     int length = SNPrintF(buffer, "%d", func_index);
     name = isolate->factory()
                ->NewStringFromOneByte(
                    Vector<uint8_t>::cast(buffer.SubVector(0, length)))
                .ToHandleChecked();
   } else {
     name = maybe_name.ToHandleChecked();
   }
   DCHECK_EQ(Code::JS_TO_WASM_FUNCTION, export_wrapper->kind());
   Handle<SharedFunctionInfo> shared =
       isolate->factory()->NewSharedFunctionInfo(name, export_wrapper, false);
   shared->set_length(arity);
   shared->set_internal_formal_parameter_count(arity);
-  Handle<JSFunction> function = isolate->factory()->NewFunction(
+  Handle<JSFunction> js_function = isolate->factory()->NewFunction(
       isolate->wasm_function_map(), name, export_wrapper);
-  function->SetEmbedderField(kWrapperTracerHeader, Smi::kZero);
+
+  Handle<WasmExportedFunction> function(
+      reinterpret_cast<WasmExportedFunction*>(*js_function), isolate);
 
   function->set_shared(*shared);
+  function->set_instance(*instance);
+  function->set_function_index(func_index);
 
-  function->SetEmbedderField(kInstance, *instance);
-  function->SetEmbedderField(kIndex, Smi::FromInt(func_index));
   return Handle<WasmExportedFunction>::cast(function);
 }
 
 bool WasmSharedModuleData::IsWasmSharedModuleData(Object* object) {
   if (!object->IsFixedArray()) return false;
   FixedArray* arr = FixedArray::cast(object);
   if (arr->length() != kFieldCount) return false;
   Isolate* isolate = arr->GetIsolate();
-  if (!arr->get(kModuleWrapper)->IsForeign()) return false;
-  if (!arr->get(kModuleBytes)->IsUndefined(isolate) &&
-      !arr->get(kModuleBytes)->IsSeqOneByteString())
+  if (!arr->get(kModuleWrapperIndex)->IsForeign()) return false;
+  if (!arr->get(kModuleBytesIndex)->IsUndefined(isolate) &&
+      !arr->get(kModuleBytesIndex)->IsSeqOneByteString())
     return false;
-  if (!arr->get(kScript)->IsScript()) return false;
-  if (!arr->get(kAsmJsOffsetTable)->IsUndefined(isolate) &&
-      !arr->get(kAsmJsOffsetTable)->IsByteArray())
+  if (!arr->get(kScriptIndex)->IsScript()) return false;
+  if (!arr->get(kAsmJsOffsetTableIndex)->IsUndefined(isolate) &&
+      !arr->get(kAsmJsOffsetTableIndex)->IsByteArray())
     return false;
-  if (!arr->get(kBreakPointInfos)->IsUndefined(isolate) &&
-      !arr->get(kBreakPointInfos)->IsFixedArray())
+  if (!arr->get(kBreakPointInfosIndex)->IsUndefined(isolate) &&
+      !arr->get(kBreakPointInfosIndex)->IsFixedArray())
     return false;
   return true;
 }
 
 WasmSharedModuleData* WasmSharedModuleData::cast(Object* object) {
   DCHECK(IsWasmSharedModuleData(object));
   return reinterpret_cast<WasmSharedModuleData*>(object);
 }
 
 wasm::WasmModule* WasmSharedModuleData::module() {
   // We populate the kModuleWrapper field with a Foreign holding the
   // address to the address of a WasmModule. This is because we can
   // handle both cases when the WasmModule's lifetime is managed through
   // a Managed<WasmModule> object, as well as cases when it's managed
   // by the embedder. CcTests fall into the latter case.
   return *(reinterpret_cast<wasm::WasmModule**>(
-      Foreign::cast(get(kModuleWrapper))->foreign_address()));
+      Foreign::cast(get(kModuleWrapperIndex))->foreign_address()));
 }
 
-DEFINE_OPTIONAL_ARR_ACCESSORS(WasmSharedModuleData, module_bytes, kModuleBytes,
-                              SeqOneByteString);
-DEFINE_ARR_GETTER(WasmSharedModuleData, script, kScript, Script);
-DEFINE_OPTIONAL_ARR_ACCESSORS(WasmSharedModuleData, asm_js_offset_table,
-                              kAsmJsOffsetTable, ByteArray);
-DEFINE_OPTIONAL_ARR_GETTER(WasmSharedModuleData, breakpoint_infos,
-                           kBreakPointInfos, FixedArray);
-DEFINE_OPTIONAL_ARR_GETTER(WasmSharedModuleData, lazy_compilation_orchestrator,
-                           kLazyCompilationOrchestrator, Foreign);
-
 Handle<WasmSharedModuleData> WasmSharedModuleData::New(
     Isolate* isolate, Handle<Foreign> module_wrapper,
     Handle<SeqOneByteString> module_bytes, Handle<Script> script,
     Handle<ByteArray> asm_js_offset_table) {
   Handle<FixedArray> arr =
       isolate->factory()->NewFixedArray(kFieldCount, TENURED);
-  arr->set(kWrapperTracerHeader, Smi::kZero);
-  arr->set(kModuleWrapper, *module_wrapper);
+  arr->set(kModuleWrapperIndex, *module_wrapper);
   if (!module_bytes.is_null()) {
-    arr->set(kModuleBytes, *module_bytes);
+    arr->set(kModuleBytesIndex, *module_bytes);
   }
   if (!script.is_null()) {
-    arr->set(kScript, *script);
+    arr->set(kScriptIndex, *script);
   }
   if (!asm_js_offset_table.is_null()) {
-    arr->set(kAsmJsOffsetTable, *asm_js_offset_table);
+    arr->set(kAsmJsOffsetTableIndex, *asm_js_offset_table);
   }
 
   DCHECK(WasmSharedModuleData::IsWasmSharedModuleData(*arr));
   return Handle<WasmSharedModuleData>::cast(arr);
 }
 
+Foreign* WasmSharedModuleData::lazy_compilation_orchestrator() {
+  return Foreign::cast(get(kLazyCompilationOrchestratorIndex));
+}
+
 bool WasmSharedModuleData::is_asm_js() {
   bool asm_js = module()->is_asm_js();
   DCHECK_EQ(asm_js, script()->IsUserJavaScript());
   DCHECK_EQ(asm_js, has_asm_js_offset_table());
   return asm_js;
 }
 
 void WasmSharedModuleData::ReinitializeAfterDeserialization(
     Isolate* isolate, Handle<WasmSharedModuleData> shared) {
-  DCHECK(shared->get(kModuleWrapper)->IsUndefined(isolate));
+  DCHECK(shared->get(kModuleWrapperIndex)->IsUndefined(isolate));
 #ifdef DEBUG
   // No BreakpointInfo objects should survive deserialization.
   if (shared->has_breakpoint_infos()) {
     for (int i = 0, e = shared->breakpoint_infos()->length(); i < e; ++i) {
       DCHECK(shared->breakpoint_infos()->get(i)->IsUndefined(isolate));
     }
   }
 #endif
 
-  shared->set(kBreakPointInfos, isolate->heap()->undefined_value());
+  shared->set(kBreakPointInfosIndex, isolate->heap()->undefined_value());
 
   WasmModule* module = nullptr;
   {
     // We parse the module again directly from the module bytes, so
     // the underlying storage must not be moved meanwhile.
     DisallowHeapAllocation no_allocation;
     SeqOneByteString* module_bytes = shared->module_bytes();
     const byte* start =
         reinterpret_cast<const byte*>(module_bytes->GetCharsAddress());
     const byte* end = start + module_bytes->length();
     // TODO(titzer): remember the module origin in the compiled_module
     // For now, we assume serialized modules did not originate from asm.js.
     ModuleResult result =
         SyncDecodeWasmModule(isolate, start, end, false, kWasmOrigin);
     CHECK(result.ok());
     CHECK_NOT_NULL(result.val);
     // Take ownership of the WasmModule and immediately transfer it to the
     // WasmModuleWrapper below.
     module = result.val.release();
   }
 
   Handle<WasmModuleWrapper> module_wrapper =
       WasmModuleWrapper::New(isolate, module);
 
-  shared->set(kModuleWrapper, *module_wrapper);
+  shared->set(kModuleWrapperIndex, *module_wrapper);
   DCHECK(WasmSharedModuleData::IsWasmSharedModuleData(*shared));
 }
 
 namespace {
 
 int GetBreakpointPos(Isolate* isolate, Object* break_point_info_or_undef) {
   if (break_point_info_or_undef->IsUndefined(isolate)) return kMaxInt;
   return BreakPointInfo::cast(break_point_info_or_undef)->source_position();
 }
 
@@ skipping 24 matching lines @@
 
 void WasmSharedModuleData::AddBreakpoint(Handle<WasmSharedModuleData> shared,
                                          int position,
                                          Handle<Object> break_point_object) {
   Isolate* isolate = shared->GetIsolate();
   Handle<FixedArray> breakpoint_infos;
   if (shared->has_breakpoint_infos()) {
     breakpoint_infos = handle(shared->breakpoint_infos(), isolate);
   } else {
     breakpoint_infos = isolate->factory()->NewFixedArray(4, TENURED);
-    shared->set(kBreakPointInfos, *breakpoint_infos);
+    shared->set(kBreakPointInfosIndex, *breakpoint_infos);
   }
 
   int insert_pos =
       FindBreakpointInfoInsertPos(isolate, breakpoint_infos, position);
 
   // If a BreakPointInfo object already exists for this position, add the new
   // breakpoint object and return.
   if (insert_pos < breakpoint_infos->length() &&
       GetBreakpointPos(isolate, breakpoint_infos->get(insert_pos)) ==
           position) {
     Handle<BreakPointInfo> old_info(
         BreakPointInfo::cast(breakpoint_infos->get(insert_pos)), isolate);
     BreakPointInfo::SetBreakPoint(old_info, break_point_object);
     return;
   }
 
   // Enlarge break positions array if necessary.
   bool need_realloc = !breakpoint_infos->get(breakpoint_infos->length() - 1)
                            ->IsUndefined(isolate);
   Handle<FixedArray> new_breakpoint_infos = breakpoint_infos;
   if (need_realloc) {
     new_breakpoint_infos = isolate->factory()->NewFixedArray(
         2 * breakpoint_infos->length(), TENURED);
-    shared->set(kBreakPointInfos, *new_breakpoint_infos);
+    shared->set(kBreakPointInfosIndex, *new_breakpoint_infos);
     // Copy over the entries [0, insert_pos).
     for (int i = 0; i < insert_pos; ++i)
       new_breakpoint_infos->set(i, breakpoint_infos->get(i));
   }
 
   // Move elements [insert_pos+1, ...] up by one.
   for (int i = insert_pos + 1; i < breakpoint_infos->length(); ++i) {
     Object* entry = breakpoint_infos->get(i);
     if (entry->IsUndefined(isolate)) break;
     new_breakpoint_infos->set(i + 1, entry);
@@ skipping 41 matching lines @@
   }
 }
 
 void WasmSharedModuleData::PrepareForLazyCompilation(
     Handle<WasmSharedModuleData> shared) {
   if (shared->has_lazy_compilation_orchestrator()) return;
   Isolate* isolate = shared->GetIsolate();
   LazyCompilationOrchestrator* orch = new LazyCompilationOrchestrator();
   Handle<Managed<LazyCompilationOrchestrator>> orch_handle =
       Managed<LazyCompilationOrchestrator>::New(isolate, orch);
-  shared->set(WasmSharedModuleData::kLazyCompilationOrchestrator, *orch_handle);
+  shared->set(kLazyCompilationOrchestratorIndex, *orch_handle);
 }
 
 Handle<WasmCompiledModule> WasmCompiledModule::New(
     Isolate* isolate, Handle<WasmSharedModuleData> shared,
     Handle<FixedArray> code_table,
     MaybeHandle<FixedArray> maybe_empty_function_tables,
     MaybeHandle<FixedArray> maybe_signature_tables) {
   Handle<FixedArray> ret =
       isolate->factory()->NewFixedArray(PropertyIndices::Count, TENURED);
   // WasmCompiledModule::cast would fail since fields are not set yet.
@@ skipping 608 matching lines @@
       instance->compiled_module()->shared()->lazy_compilation_orchestrator();
   LazyCompilationOrchestrator* orch =
       Managed<LazyCompilationOrchestrator>::cast(orch_obj)->get();
   return orch->CompileLazy(isolate, instance, caller, offset, func_index,
                            patch_caller);
 }
 
 Handle<WasmInstanceWrapper> WasmInstanceWrapper::New(
     Isolate* isolate, Handle<WasmInstanceObject> instance) {
   Handle<FixedArray> array =
-      isolate->factory()->NewFixedArray(kWrapperPropertyCount, TENURED);
+      isolate->factory()->NewFixedArray(kFieldCount, TENURED);
   Handle<WasmInstanceWrapper> instance_wrapper(
       reinterpret_cast<WasmInstanceWrapper*>(*array), isolate);
   Handle<WeakCell> cell = isolate->factory()->NewWeakCell(instance);
-  instance_wrapper->set(kWrapperInstanceObject, *cell);
+  instance_wrapper->set(kWrapperInstanceObjectIndex, *cell);
   return instance_wrapper;
 }
 
 bool WasmInstanceWrapper::IsWasmInstanceWrapper(Object* obj) {
   if (!obj->IsFixedArray()) return false;
   Handle<FixedArray> array = handle(FixedArray::cast(obj));
-  if (array->length() != kWrapperPropertyCount) return false;
-  if (!array->get(kWrapperInstanceObject)->IsWeakCell()) return false;
+  if (array->length() != kFieldCount) return false;
+  if (!array->get(kWrapperInstanceObjectIndex)->IsWeakCell()) return false;
   Isolate* isolate = array->GetIsolate();
-  if (!array->get(kNextInstanceWrapper)->IsUndefined(isolate) &&
-      !array->get(kNextInstanceWrapper)->IsFixedArray())
+  if (!array->get(kNextInstanceWrapperIndex)->IsUndefined(isolate) &&
+      !array->get(kNextInstanceWrapperIndex)->IsFixedArray())
     return false;
-  if (!array->get(kPreviousInstanceWrapper)->IsUndefined(isolate) &&
-      !array->get(kPreviousInstanceWrapper)->IsFixedArray())
+  if (!array->get(kPreviousInstanceWrapperIndex)->IsUndefined(isolate) &&
+      !array->get(kPreviousInstanceWrapperIndex)->IsFixedArray())
     return false;
   return true;
 }
-
-DEFINE_OPTIONAL_ARR_ACCESSORS(WasmDebugInfo, locals_names, kLocalsNames,
-                              FixedArray)