[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;
@@ skipping 54 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 75 matching lines @@
   }
   if (has_maximum.FromJust()) {
     if (!GetIntegerProperty(isolate, &thrower, context, descriptor, maximum_key,
                             &maximum, initial, max_table_size)) {
       return;
     }
   }
 
   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::Handle<i::JSObject> table_obj = i::WasmTableObject::New(
       i_isolate, initial, has_maximum.FromJust(), 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()");
@@ skipping 24 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);
+  i::Handle<i::JSObject> memory_obj = i::WasmMemoryObject::New(
+      i_isolate, buffer, has_maximum.FromJust() ? maximum : -1);
   v8::ReturnValue<v8::Value> return_value = args.GetReturnValue();
   return_value.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()),
@@ skipping 206 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 70 matching lines @@
 
 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