[wasm] Move all heap-allocated WASM structures into wasm-objects.h.

src/wasm/wasm-js.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/api-natives.h"
 #include "src/api.h"
 #include "src/asmjs/asm-js.h"
 #include "src/asmjs/asm-typer.h"
 #include "src/asmjs/asm-wasm-builder.h"
 #include "src/assert-scope.h"
 #include "src/ast/ast.h"
 #include "src/execution.h"
 #include "src/factory.h"
 #include "src/handles.h"
 #include "src/isolate.h"
 #include "src/objects.h"
 #include "src/parsing/parse-info.h"
 
 #include "src/wasm/module-decoder.h"
 #include "src/wasm/wasm-js.h"
 #include "src/wasm/wasm-module.h"
+#include "src/wasm/wasm-objects.h"
 #include "src/wasm/wasm-result.h"
 
 typedef uint8_t byte;
 
 using v8::internal::wasm::ErrorThrower;
 
 namespace v8 {
 
-static const int kWasmTableArrayFieldIndex = 0;
-static const int kWasmTableMaximumFieldIndex = 1;
-static const int kWasmTableDispatchTablesFieldIndex = 2;
-
 enum WasmMemoryObjectData {
   kWasmMemoryBuffer,
   kWasmMemoryMaximum,
   kWasmMemoryInstanceObject
 };
 
-enum WasmInternalFieldCountData {
-  kWasmTableInternalFieldCount = 3,
-  kWasmMemoryInternalFieldCount = 3
-};
-
 namespace {
 i::Handle<i::String> v8_str(i::Isolate* isolate, const char* str) {
   return isolate->factory()->NewStringFromAsciiChecked(str);
 }
 Local<String> v8_str(Isolate* isolate, const char* str) {
   return Utils::ToLocal(v8_str(reinterpret_cast<i::Isolate*>(isolate), str));
 }
 
 struct RawBuffer {
   const byte* start;
@@ skipping 31 matching lines @@
     if (start == nullptr || end == start) {
       thrower->TypeError("ArrayBuffer argument is empty");
     }
   } else {
     thrower->TypeError("Argument 0 must be an ArrayBuffer or Uint8Array");
   }
 
   return {start, end};
 }
 
-static i::MaybeHandle<i::JSObject> CreateModuleObject(
+static i::MaybeHandle<i::WasmModuleObject> CreateModuleObject(
     v8::Isolate* isolate, const v8::Local<v8::Value> source,
     ErrorThrower* thrower) {
   i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
   i::MaybeHandle<i::JSObject> nothing;
 
   RawBuffer buffer = GetRawBufferSource(source, thrower);
-  if (buffer.start == nullptr) return i::MaybeHandle<i::JSObject>();
+  if (buffer.start == nullptr) return i::MaybeHandle<i::WasmModuleObject>();
 
   DCHECK(source->IsArrayBuffer() || source->IsTypedArray());
   return i::wasm::CreateModuleObjectFromBytes(
       i_isolate, buffer.start, buffer.end, thrower, i::wasm::kWasmOrigin,
       i::Handle<i::Script>::null(), nullptr, nullptr);
 }
 
 static bool ValidateModule(v8::Isolate* isolate,
                            const v8::Local<v8::Value> source,
                            ErrorThrower* thrower) {
   i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
   i::MaybeHandle<i::JSObject> nothing;
 
   RawBuffer buffer = GetRawBufferSource(source, thrower);
   if (buffer.start == nullptr) return false;
 
   DCHECK(source->IsArrayBuffer() || source->IsTypedArray());
   return i::wasm::ValidateModuleBytes(i_isolate, buffer.start, buffer.end,
                                       thrower,
                                       i::wasm::ModuleOrigin::kWasmOrigin);
 }
 
-bool BrandCheck(Isolate* isolate, i::Handle<i::Object> value,
-                i::Handle<i::Symbol> sym, const char* msg) {
+static bool BrandCheck(Isolate* isolate, i::Handle<i::Object> value,
+                       i::Handle<i::Symbol> sym, const char* msg) {
   if (value->IsJSObject()) {
     i::Handle<i::JSObject> object = i::Handle<i::JSObject>::cast(value);
     Maybe<bool> has_brand = i::JSObject::HasOwnProperty(object, sym);
     if (has_brand.IsNothing()) return false;
     if (has_brand.ToChecked()) return true;
   }
   v8::Local<v8::Value> e = v8::Exception::TypeError(v8_str(isolate, msg));
   isolate->ThrowException(e);
   return false;
 }
@@ skipping 88 matching lines @@
   if (args.Length() > 1 && args[1]->IsObject()) {
     Local<Object> obj = Local<Object>::Cast(args[1]);
     ffi = i::Handle<i::JSReceiver>::cast(v8::Utils::OpenHandle(*obj));
   }
 
   i::Handle<i::JSArrayBuffer> memory = i::Handle<i::JSArrayBuffer>::null();
   if (args.Length() > 2 && args[2]->IsObject()) {
     Local<Object> obj = Local<Object>::Cast(args[2]);
     i::Handle<i::Object> mem_obj = v8::Utils::OpenHandle(*obj);
     if (i::WasmJs::IsWasmMemoryObject(i_isolate, mem_obj)) {
-      memory = i::WasmJs::GetWasmMemoryArrayBuffer(i_isolate, mem_obj);
+      memory = i::Handle<i::JSArrayBuffer>(
+          i::Handle<i::WasmMemoryObject>::cast(mem_obj)->get_buffer(),
+          i_isolate);
     } else {
       thrower.TypeError("Argument 2 must be a WebAssembly.Memory");
     }
   }
   i::MaybeHandle<i::JSObject> instance =
       i::wasm::WasmModule::Instantiate(i_isolate, &thrower, i_obj, ffi, memory);
   if (instance.is_null()) {
     if (!thrower.error()) thrower.RuntimeError("Could not instantiate module");
     return;
   }
@@ skipping 71 matching lines @@
 
   if (has_maximum.IsNothing()) {
     // There has been an exception, just return.
     return;
   }
   if (has_maximum.FromJust()) {
     if (!GetIntegerProperty(isolate, &thrower, context, descriptor, maximum_key,
                             &maximum, initial, max_table_size)) {
       return;
     }
+  } else {
+    maximum = static_cast<int>(i::wasm::WasmModule::kV8MaxTableSize);
   }
 
   i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
   i::Handle<i::FixedArray> fixed_array;
-  i::Handle<i::JSObject> table_obj = i::WasmJs::CreateWasmTableObject(
-      i_isolate, initial, has_maximum.FromJust(), maximum, &fixed_array);
+  i::Handle<i::JSObject> table_obj =
+      i::WasmTableObject::New(i_isolate, initial, maximum, &fixed_array);
   v8::ReturnValue<v8::Value> return_value = args.GetReturnValue();
   return_value.Set(Utils::ToLocal(table_obj));
 }
 
 void WebAssemblyMemory(const v8::FunctionCallbackInfo<v8::Value>& args) {
   v8::Isolate* isolate = args.GetIsolate();
   HandleScope scope(isolate);
   ErrorThrower thrower(reinterpret_cast<i::Isolate*>(isolate),
                        "WebAssembly.Module()");
   if (args.Length() < 1 || !args[0]->IsObject()) {
@@ skipping 23 matching lines @@
       return;
     }
   }
   i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
   i::Handle<i::JSArrayBuffer> buffer =
       i_isolate->factory()->NewJSArrayBuffer(i::SharedFlag::kNotShared);
   size_t size = static_cast<size_t>(i::wasm::WasmModule::kPageSize) *
                 static_cast<size_t>(initial);
   i::JSArrayBuffer::SetupAllocatingData(buffer, i_isolate, size);
 
-  i::Handle<i::JSObject> memory_obj = i::WasmJs::CreateWasmMemoryObject(
-      i_isolate, buffer, has_maximum.FromJust(), maximum);
-  v8::ReturnValue<v8::Value> return_value = args.GetReturnValue();
-  return_value.Set(Utils::ToLocal(memory_obj));
+  i::Handle<i::JSObject> memory_obj = i::WasmMemoryObject::New(
+      i_isolate, buffer, has_maximum.FromJust() ? maximum : -1);
+  args.GetReturnValue().Set(Utils::ToLocal(memory_obj));
 }
 
 void WebAssemblyTableGetLength(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   v8::Isolate* isolate = args.GetIsolate();
   Local<Context> context = isolate->GetCurrentContext();
   i::Handle<i::Context> i_context = Utils::OpenHandle(*context);
   if (!BrandCheck(isolate, Utils::OpenHandle(*args.This()),
                   i::Handle<i::Symbol>(i_context->wasm_table_sym()),
                   "Receiver is not a WebAssembly.Table")) {
     return;
   }
-  i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
-  i::Handle<i::JSObject> receiver =
-      i::Handle<i::JSObject>::cast(Utils::OpenHandle(*args.This()));
-  i::Handle<i::Object> array(
-      receiver->GetInternalField(kWasmTableArrayFieldIndex), i_isolate);
-  int length = i::Handle<i::FixedArray>::cast(array)->length();
-  v8::ReturnValue<v8::Value> return_value = args.GetReturnValue();
-  return_value.Set(v8::Number::New(isolate, length));
+  auto receiver =
+      i::Handle<i::WasmTableObject>::cast(Utils::OpenHandle(*args.This()));
+  args.GetReturnValue().Set(
+      v8::Number::New(isolate, receiver->current_length()));
 }
 
 void WebAssemblyTableGrow(const v8::FunctionCallbackInfo<v8::Value>& args) {
   v8::Isolate* isolate = args.GetIsolate();
   Local<Context> context = isolate->GetCurrentContext();
   i::Handle<i::Context> i_context = Utils::OpenHandle(*context);
   if (!BrandCheck(isolate, Utils::OpenHandle(*args.This()),
                   i::Handle<i::Symbol>(i_context->wasm_table_sym()),
                   "Receiver is not a WebAssembly.Table")) {
     return;
   }
 
   i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
-  i::Handle<i::JSObject> receiver =
-      i::Handle<i::JSObject>::cast(Utils::OpenHandle(*args.This()));
-  i::Handle<i::FixedArray> old_array(
-      i::FixedArray::cast(
-          receiver->GetInternalField(kWasmTableArrayFieldIndex)),
-      i_isolate);
+  auto receiver =
+      i::Handle<i::WasmTableObject>::cast(Utils::OpenHandle(*args.This()));
+  i::Handle<i::FixedArray> old_array(receiver->get_functions(), i_isolate);
   int old_size = old_array->length();
   int64_t new_size64 = 0;
   if (args.Length() > 0 && !args[0]->IntegerValue(context).To(&new_size64)) {
     return;
   }
   new_size64 += old_size;
 
-  i::Handle<i::Object> max_val(
-      receiver->GetInternalField(kWasmTableMaximumFieldIndex), i_isolate);
-  int max_size =
-      max_val->IsSmi() ? i::Smi::cast(*max_val)->value() : max_table_size;
-  if (new_size64 < old_size || new_size64 > max_size) {
+  if (new_size64 < old_size || new_size64 > receiver->maximum_length()) {
     v8::Local<v8::Value> e = v8::Exception::RangeError(
         v8_str(isolate, new_size64 < old_size ? "trying to shrink table"
                                               : "maximum table size exceeded"));
     isolate->ThrowException(e);
     return;
   }
   int new_size = static_cast<int>(new_size64);
 
   if (new_size != old_size) {
     i::Handle<i::FixedArray> new_array =
         i_isolate->factory()->NewFixedArray(new_size);
     for (int i = 0; i < old_size; ++i) new_array->set(i, old_array->get(i));
     i::Object* null = i_isolate->heap()->null_value();
     for (int i = old_size; i < new_size; ++i) new_array->set(i, null);
-    receiver->SetInternalField(kWasmTableArrayFieldIndex, *new_array);
+    receiver->set_functions(*new_array);
   }
 
   // TODO(titzer): update relevant instances.
 }
 
 void WebAssemblyTableGet(const v8::FunctionCallbackInfo<v8::Value>& args) {
   v8::Isolate* isolate = args.GetIsolate();
   Local<Context> context = isolate->GetCurrentContext();
   i::Handle<i::Context> i_context = Utils::OpenHandle(*context);
   if (!BrandCheck(isolate, Utils::OpenHandle(*args.This()),
                   i::Handle<i::Symbol>(i_context->wasm_table_sym()),
                   "Receiver is not a WebAssembly.Table")) {
     return;
   }
 
   i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
-  i::Handle<i::JSObject> receiver =
-      i::Handle<i::JSObject>::cast(Utils::OpenHandle(*args.This()));
-  i::Handle<i::Object> array(
-      receiver->GetInternalField(kWasmTableArrayFieldIndex), i_isolate);
+  auto receiver =
+      i::Handle<i::WasmTableObject>::cast(Utils::OpenHandle(*args.This()));
+  i::Handle<i::FixedArray> array(receiver->get_functions(), i_isolate);
   int i = 0;
   if (args.Length() > 0 && !args[0]->Int32Value(context).To(&i)) return;
   v8::ReturnValue<v8::Value> return_value = args.GetReturnValue();
-  if (i < 0 || i >= i::Handle<i::FixedArray>::cast(array)->length()) {
+  if (i < 0 || i >= array->length()) {
     v8::Local<v8::Value> e =
         v8::Exception::RangeError(v8_str(isolate, "index out of bounds"));
     isolate->ThrowException(e);
     return;
   }
 
-  i::Handle<i::Object> value(i::Handle<i::FixedArray>::cast(array)->get(i),
-                             i_isolate);
+  i::Handle<i::Object> value(array->get(i), i_isolate);
   return_value.Set(Utils::ToLocal(value));
 }
 
 void WebAssemblyTableSet(const v8::FunctionCallbackInfo<v8::Value>& args) {
   v8::Isolate* isolate = args.GetIsolate();
   i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
   Local<Context> context = isolate->GetCurrentContext();
   i::Handle<i::Context> i_context = Utils::OpenHandle(*context);
   if (!BrandCheck(isolate, Utils::OpenHandle(*args.This()),
                   i::Handle<i::Symbol>(i_context->wasm_table_sym()),
@@ skipping 10 matching lines @@
   if (!value->IsNull(i_isolate) &&
       (!value->IsJSFunction() ||
        i::Handle<i::JSFunction>::cast(value)->code()->kind() !=
            i::Code::JS_TO_WASM_FUNCTION)) {
     v8::Local<v8::Value> e = v8::Exception::TypeError(
         v8_str(isolate, "Argument 1 must be null or a WebAssembly function"));
     isolate->ThrowException(e);
     return;
   }
 
-  i::Handle<i::JSObject> receiver =
-      i::Handle<i::JSObject>::cast(Utils::OpenHandle(*args.This()));
-  i::Handle<i::Object> array(
-      receiver->GetInternalField(kWasmTableArrayFieldIndex), i_isolate);
+  auto receiver =
+      i::Handle<i::WasmTableObject>::cast(Utils::OpenHandle(*args.This()));
+  i::Handle<i::FixedArray> array(receiver->get_functions(), i_isolate);
   int i;
   if (!args[0]->Int32Value(context).To(&i)) return;
-  if (i < 0 || i >= i::Handle<i::FixedArray>::cast(array)->length()) {
+  if (i < 0 || i >= array->length()) {
     v8::Local<v8::Value> e =
         v8::Exception::RangeError(v8_str(isolate, "index out of bounds"));
     isolate->ThrowException(e);
     return;
   }
 
-  i::Handle<i::FixedArray> dispatch_tables(
-      i::FixedArray::cast(
-          receiver->GetInternalField(kWasmTableDispatchTablesFieldIndex)),
-      i_isolate);
+  i::Handle<i::FixedArray> dispatch_tables(receiver->get_dispatch_tables(),
+                                           i_isolate);
   if (value->IsNull(i_isolate)) {
     i::wasm::UpdateDispatchTables(i_isolate, dispatch_tables, i,
                                   i::Handle<i::JSFunction>::null());
   } else {
     i::wasm::UpdateDispatchTables(i_isolate, dispatch_tables, i,
                                   i::Handle<i::JSFunction>::cast(value));
   }
 
   i::Handle<i::FixedArray>::cast(array)->set(i, *value);
 }
@@ skipping 59 matching lines @@
   i::Handle<i::JSObject> receiver =
       i::Handle<i::JSObject>::cast(Utils::OpenHandle(*args.This()));
   i::Handle<i::Object> buffer(receiver->GetInternalField(kWasmMemoryBuffer),
                               i_isolate);
   DCHECK(buffer->IsJSArrayBuffer());
   v8::ReturnValue<v8::Value> return_value = args.GetReturnValue();
   return_value.Set(Utils::ToLocal(buffer));
 }
 }  // namespace
 
-i::Handle<i::JSObject> i::WasmJs::CreateWasmMemoryObject(
-    i::Isolate* i_isolate, i::Handle<i::JSArrayBuffer> buffer, bool has_maximum,
-    int maximum) {
-  i::Handle<i::JSFunction> memory_ctor(
-      i_isolate->native_context()->wasm_memory_constructor());
-  i::Handle<i::JSObject> memory_obj =
-      i_isolate->factory()->NewJSObject(memory_ctor);
-  memory_obj->SetInternalField(kWasmMemoryBuffer, *buffer);
-  memory_obj->SetInternalField(
-      kWasmMemoryMaximum,
-      has_maximum
-          ? static_cast<i::Object*>(i::Smi::FromInt(maximum))
-          : static_cast<i::Object*>(i_isolate->heap()->undefined_value()));
-  i::Handle<i::Symbol> memory_sym(
-      i_isolate->native_context()->wasm_memory_sym());
-  i::Object::SetProperty(memory_obj, memory_sym, memory_obj, i::STRICT).Check();
-  return memory_obj;
-}
-
-i::Handle<i::JSObject> i::WasmJs::CreateWasmTableObject(
-    i::Isolate* i_isolate, uint32_t initial, bool has_maximum, uint32_t maximum,
-    i::Handle<i::FixedArray>* js_functions) {
-  i::Handle<i::JSFunction> table_ctor(
-      i_isolate->native_context()->wasm_table_constructor());
-  i::Handle<i::JSObject> table_obj =
-      i_isolate->factory()->NewJSObject(table_ctor);
-  *js_functions = i_isolate->factory()->NewFixedArray(initial);
-  i::Object* null = i_isolate->heap()->null_value();
-  // TODO(titzer): consider moving FixedArray to size_t.
-  for (int i = 0; i < static_cast<int>(initial); ++i) {
-    (*js_functions)->set(i, null);
-  }
-  table_obj->SetInternalField(kWasmTableArrayFieldIndex, *(*js_functions));
-  table_obj->SetInternalField(
-      kWasmTableMaximumFieldIndex,
-      has_maximum
-          ? static_cast<i::Object*>(i::Smi::FromInt(maximum))
-          : static_cast<i::Object*>(i_isolate->heap()->undefined_value()));
-  Handle<FixedArray> dispatch_tables = i_isolate->factory()->NewFixedArray(0);
-  table_obj->SetInternalField(kWasmTableDispatchTablesFieldIndex,
-                              *dispatch_tables);
-  i::Handle<i::Symbol> table_sym(i_isolate->native_context()->wasm_table_sym());
-  i::Object::SetProperty(table_obj, table_sym, table_obj, i::STRICT).Check();
-  return table_obj;
-}
-
-i::Handle<i::FixedArray> i::WasmJs::AddWasmTableDispatchTable(
-    i::Isolate* i_isolate, i::Handle<i::JSObject> table_obj,
-    i::Handle<i::JSObject> instance, int table_index,
-    i::Handle<i::FixedArray> dispatch_table) {
-  DCHECK(IsWasmTableObject(i_isolate, table_obj));
-  i::Handle<i::FixedArray> dispatch_tables(
-      i::FixedArray::cast(
-          table_obj->GetInternalField(kWasmTableDispatchTablesFieldIndex)),
-      i_isolate);
-  DCHECK_EQ(0, dispatch_tables->length() % 3);
-
-  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 pair at the end.
-  i::Handle<i::FixedArray> new_dispatch_tables =
-      i_isolate->factory()->CopyFixedArrayAndGrow(dispatch_tables, 3);
-
-  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, *dispatch_table);
-
-  table_obj->SetInternalField(kWasmTableDispatchTablesFieldIndex,
-                              *new_dispatch_tables);
-
-  return new_dispatch_tables;
-}
-
 // TODO(titzer): we use the API to create the function template because the
 // internal guts are too ugly to replicate here.
 static i::Handle<i::FunctionTemplateInfo> NewTemplate(i::Isolate* i_isolate,
                                                       FunctionCallback func) {
   Isolate* isolate = reinterpret_cast<Isolate*>(i_isolate);
   Local<FunctionTemplate> local = FunctionTemplate::New(isolate, func);
   return v8::Utils::OpenHandle(*local);
 }
 
 namespace internal {
@@ skipping 68 matching lines @@
   // Setup compile
   InstallFunc(isolate, webassembly, "validate", WebAssemblyValidate);
 
   // Setup Module
   Handle<JSFunction> module_constructor =
       InstallFunc(isolate, webassembly, "Module", WebAssemblyModule);
   context->set_wasm_module_constructor(*module_constructor);
   Handle<JSObject> module_proto =
       factory->NewJSObject(module_constructor, TENURED);
   i::Handle<i::Map> map = isolate->factory()->NewMap(
-      i::JS_OBJECT_TYPE, i::JSObject::kHeaderSize + i::kPointerSize);
+      i::JS_OBJECT_TYPE, i::JSObject::kHeaderSize +
+                             WasmModuleObject::kFieldCount * i::kPointerSize);
   JSFunction::SetInitialMap(module_constructor, map, module_proto);
   JSObject::AddProperty(module_proto, isolate->factory()->constructor_string(),
                         module_constructor, DONT_ENUM);
 
   // Setup Instance
   Handle<JSFunction> instance_constructor =
       InstallFunc(isolate, webassembly, "Instance", WebAssemblyInstance);
   context->set_wasm_instance_constructor(*instance_constructor);
 
   // Setup Table
   Handle<JSFunction> table_constructor =
       InstallFunc(isolate, webassembly, "Table", WebAssemblyTable);
   context->set_wasm_table_constructor(*table_constructor);
   Handle<JSObject> table_proto =
       factory->NewJSObject(table_constructor, TENURED);
   map = isolate->factory()->NewMap(
       i::JS_OBJECT_TYPE, i::JSObject::kHeaderSize +
-                             kWasmTableInternalFieldCount * i::kPointerSize);
+                             WasmTableObject::kFieldCount * i::kPointerSize);
   JSFunction::SetInitialMap(table_constructor, map, table_proto);
   JSObject::AddProperty(table_proto, isolate->factory()->constructor_string(),
                         table_constructor, DONT_ENUM);
   InstallGetter(isolate, table_proto, "length", WebAssemblyTableGetLength);
   InstallFunc(isolate, table_proto, "grow", WebAssemblyTableGrow);
   InstallFunc(isolate, table_proto, "get", WebAssemblyTableGet);
   InstallFunc(isolate, table_proto, "set", WebAssemblyTableSet);
 
   // Setup Memory
   Handle<JSFunction> memory_constructor =
       InstallFunc(isolate, webassembly, "Memory", WebAssemblyMemory);
   context->set_wasm_memory_constructor(*memory_constructor);
   Handle<JSObject> memory_proto =
       factory->NewJSObject(memory_constructor, TENURED);
   map = isolate->factory()->NewMap(
       i::JS_OBJECT_TYPE, i::JSObject::kHeaderSize +
-                             kWasmMemoryInternalFieldCount * i::kPointerSize);
+                             WasmMemoryObject::kFieldCount * i::kPointerSize);
   JSFunction::SetInitialMap(memory_constructor, map, memory_proto);
   JSObject::AddProperty(memory_proto, isolate->factory()->constructor_string(),
                         memory_constructor, DONT_ENUM);
   InstallFunc(isolate, memory_proto, "grow", WebAssemblyMemoryGrow);
   InstallGetter(isolate, memory_proto, "buffer", WebAssemblyMemoryGetBuffer);
 
   // Setup errors
   attributes = static_cast<PropertyAttributes>(DONT_DELETE | READ_ONLY);
   Handle<JSFunction> compile_error(
       isolate->native_context()->wasm_compile_error_function());
@@ skipping 60 matching lines @@
 
 bool WasmJs::IsWasmMemoryObject(Isolate* isolate, Handle<Object> value) {
   i::Handle<i::Symbol> symbol(isolate->context()->wasm_memory_sym(), isolate);
   return HasBrand(value, symbol);
 }
 
 bool WasmJs::IsWasmTableObject(Isolate* isolate, Handle<Object> value) {
   i::Handle<i::Symbol> symbol(isolate->context()->wasm_table_sym(), isolate);
   return HasBrand(value, symbol);
 }
-
-Handle<FixedArray> WasmJs::GetWasmTableFunctions(Isolate* isolate,
-                                                 Handle<JSObject> value) {
-  DCHECK(IsWasmTableObject(isolate, value));
-  Handle<Object> arr(
-      JSObject::cast(*value)->GetInternalField(kWasmTableArrayFieldIndex),
-      isolate);
-  return Handle<FixedArray>::cast(arr);
-}
-
-Handle<JSArrayBuffer> WasmJs::GetWasmMemoryArrayBuffer(Isolate* isolate,
-                                                       Handle<Object> value) {
-  DCHECK(IsWasmMemoryObject(isolate, value));
-  Handle<Object> buf(
-      JSObject::cast(*value)->GetInternalField(kWasmMemoryBuffer), isolate);
-  return Handle<JSArrayBuffer>::cast(buf);
-}
-
-void WasmJs::SetWasmMemoryArrayBuffer(Isolate* isolate, Handle<Object> value,
-                                      Handle<JSArrayBuffer> buffer) {
-  DCHECK(IsWasmMemoryObject(isolate, value));
-  JSObject::cast(*value)->SetInternalField(kWasmMemoryBuffer, *buffer);
-}
-
-uint32_t WasmJs::GetWasmMemoryMaximumSize(Isolate* isolate,
-                                          Handle<Object> value) {
-  DCHECK(IsWasmMemoryObject(isolate, value));
-  Object* max_mem =
-      JSObject::cast(*value)->GetInternalField(kWasmMemoryMaximum);
-  if (max_mem->IsUndefined(isolate)) return 0;
-  uint32_t max_pages = Smi::cast(max_mem)->value();
-  return max_pages;
-}
-
-void WasmJs::SetWasmMemoryInstance(Isolate* isolate,
-                                   Handle<Object> memory_object,
-                                   Handle<JSObject> instance) {
-  if (!memory_object->IsUndefined(isolate)) {
-    DCHECK(IsWasmMemoryObject(isolate, memory_object));
-    // TODO(gdeepti): This should be a weak list of instance objects
-    // for instances that share memory.
-    JSObject::cast(*memory_object)
-        ->SetInternalField(kWasmMemoryInstanceObject, *instance);
-  }
-}
 }  // namespace internal
 }  // namespace v8