[wasm] Remove three fields from wasm object

src/wasm/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 <memory>
 
 #include "src/base/atomic-utils.h"
 #include "src/code-stubs.h"
 
 #include "src/macro-assembler.h"
@@ skipping 37 matching lines @@
   kInternalSignature
 };
 
 // Internal constants for the layout of the module object.
 enum WasmInstanceObjectFields {
   kWasmCompiledModule = 0,
   kWasmModuleFunctionTable,
   kWasmModuleCodeTable,
   kWasmMemArrayBuffer,
   kWasmGlobalsArrayBuffer,
-  // TODO(clemensh): Remove function name array, extract names from module
-  // bytes.
-  kWasmFunctionNamesArray,
-  kWasmModuleBytesString,
   kWasmDebugInfo,
-  kWasmNumImportedFunctions,
   kWasmModuleInternalFieldCount
 };
 
 enum WasmImportData {
   kImportKind,         // Smi. an ExternalKind
   kImportGlobalType,   // Smi. Type for globals.
   kImportIndex,        // Smi. index for the import.
   kModuleName,         // String
   kFunctionName,       // maybe String
   kOutputCount,        // Smi. an uint32_t
@@ skipping 271 matching lines @@
   Address old_address = nullptr;
   Object* stored_value = owner->GetInternalField(kWasmGlobalsArrayBuffer);
   if (stored_value != undefined) {
     old_address = static_cast<Address>(
         JSArrayBuffer::cast(stored_value)->backing_store());
   }
   return old_address;
 }
 
 Handle<FixedArray> EncodeImports(Factory* factory, const WasmModule* module) {
+  // TODO(wasm): Encode this in one big FixedArray.
   Handle<FixedArray> ret = factory->NewFixedArray(
       static_cast<int>(module->import_table.size()), TENURED);
 
   for (size_t i = 0; i < module->import_table.size(); ++i) {
     const WasmImport& import = module->import_table[i];
     Handle<FixedArray> encoded_import =
         factory->NewFixedArray(kWasmImportDataSize, TENURED);
     encoded_import->set(kImportKind, Smi::FromInt(import.kind));
     encoded_import->set(kImportIndex, Smi::FromInt(import.index));
 
@@ skipping 480 matching lines @@
   DisallowHeapAllocation no_gc;
   FixedArray* deopt_data = code->deoptimization_data();
   DCHECK_NOT_NULL(deopt_data);
   DCHECK(deopt_data->length() == 2);
   Object* weak_link = deopt_data->get(0);
   if (!weak_link->IsWeakCell()) return nullptr;
   WeakCell* cell = WeakCell::cast(weak_link);
   return cell->value();
 }
 
-uint32_t GetNumImportedFunctions(Handle<JSObject> wasm_object) {
-  return static_cast<uint32_t>(
-      Smi::cast(wasm_object->GetInternalField(kWasmNumImportedFunctions))
-          ->value());
+int GetNumImportedFunctions(Handle<JSObject> wasm_object) {
+  // TODO(wasm): Cache this number if it ever becomes a performance problem.
+  DCHECK(IsWasmObject(*wasm_object));
+  Object* compiled_module = wasm_object->GetInternalField(kWasmCompiledModule);
+  Handle<FixedArray> imports =
+      WasmCompiledModule::cast(compiled_module)->imports();
+  int num_imports = imports->length();
+  int num_imported_functions = 0;
+  for (int i = 0; i < num_imports; ++i) {
+    FixedArray* encoded_import = FixedArray::cast(imports->get(i));
+    int kind = Smi::cast(encoded_import->get(kImportKind))->value();
+    if (kind == kExternalFunction) ++num_imported_functions;
+  }
+  return num_imported_functions;
 }
 
 WasmModule::WasmModule(byte* module_start)
     : module_start(module_start),
       module_end(nullptr),
       min_mem_pages(0),
       max_mem_pages(0),
       mem_export(false),
       start_function_index(-1),
       origin(kWasmOrigin),
@@ skipping 431 matching lines @@
     //--------------------------------------------------------------------------
     int num_imported_functions = ProcessImports(globals, code_table);
     if (num_imported_functions < 0) return nothing;
 
     //--------------------------------------------------------------------------
     // Process the initialization for the module's globals.
     //--------------------------------------------------------------------------
     ProcessInits(globals);
 
     //--------------------------------------------------------------------------
-    // Set up the debug support for the new instance.
-    //--------------------------------------------------------------------------
-    // TODO(clemensh): avoid referencing this stuff from the instance, use it
-    // off the compiled module instead. See the following 3 assignments:
-    if (compiled_module_->has_module_bytes()) {
-      instance->SetInternalField(kWasmModuleBytesString,
-                                 compiled_module_->ptr_to_module_bytes());
-    }
-
-    if (compiled_module_->has_function_names()) {
-      instance->SetInternalField(kWasmFunctionNamesArray,
-                                 compiled_module_->ptr_to_function_names());
-    }
-
-    {
-      Handle<Object> handle = factory->NewNumber(num_imported_functions);
-      instance->SetInternalField(kWasmNumImportedFunctions, *handle);
-    }
-
-    //--------------------------------------------------------------------------
     // Set up the runtime support for the new instance.
     //--------------------------------------------------------------------------
     Handle<WeakCell> weak_link = factory->NewWeakCell(instance);
 
     for (int i = num_imported_functions + FLAG_skip_compiling_wasm_funcs;
          i < code_table->length(); ++i) {
       Handle<Code> code = code_table->GetValueChecked<Code>(isolate_, i);
       if (code->kind() == Code::WASM_FUNCTION) {
         Handle<FixedArray> deopt_data = factory->NewFixedArray(2, TENURED);
         deopt_data->set(0, *weak_link);
@@ skipping 587 matching lines @@
     current =
         WasmCompiledModule::cast(current->ptr_to_weak_next_instance()->value());
   }
   PrintF("\n");
 #endif
 }
 
 Handle<Object> GetWasmFunctionNameOrNull(Isolate* isolate, Handle<Object> wasm,
                                          uint32_t func_index) {
   if (!wasm->IsUndefined(isolate)) {
-    Handle<ByteArray> func_names_arr_obj(
-        ByteArray::cast(Handle<JSObject>::cast(wasm)->GetInternalField(
-            kWasmFunctionNamesArray)),
-        isolate);
+    DCHECK(IsWasmObject(*wasm));
+    WasmCompiledModule* compiled_module = WasmCompiledModule::cast(
+        Handle<JSObject>::cast(wasm)->GetInternalField(kWasmCompiledModule));
+    Handle<ByteArray> func_names = compiled_module->function_names();
     // TODO(clemens): Extract this from the module bytes; skip whole function
     // name table.
     Handle<Object> name;
-    if (GetWasmFunctionNameFromTable(func_names_arr_obj, func_index)
-            .ToHandle(&name)) {
+    if (GetWasmFunctionNameFromTable(func_names, func_index).ToHandle(&name)) {
       return name;
     }
   }
   return isolate->factory()->null_value();
 }
 
 Handle<String> GetWasmFunctionName(Isolate* isolate, Handle<Object> wasm,
                                    uint32_t func_index) {
   Handle<Object> name_or_null =
       GetWasmFunctionNameOrNull(isolate, wasm, func_index);
   if (!name_or_null->IsNull(isolate)) {
     return Handle<String>::cast(name_or_null);
   }
   return isolate->factory()->NewStringFromStaticChars("<WASM UNNAMED>");
 }
 
 bool IsWasmObject(Object* object) {
   if (!object->IsJSObject()) return false;
 
   JSObject* obj = JSObject::cast(object);
   Isolate* isolate = obj->GetIsolate();
   if (obj->GetInternalFieldCount() != kWasmModuleInternalFieldCount) {
     return false;
   }
 
   Object* mem = obj->GetInternalField(kWasmMemArrayBuffer);
   if (!obj->GetInternalField(kWasmModuleCodeTable)->IsFixedArray() ||
       !(mem->IsUndefined(isolate) || mem->IsJSArrayBuffer()) ||
-      !obj->GetInternalField(kWasmFunctionNamesArray)->IsByteArray() ||
       !WasmCompiledModule::IsWasmCompiledModule(
           obj->GetInternalField(kWasmCompiledModule))) {
     return false;
   }
 
   // All checks passed.
   return true;
 }
 
-SeqOneByteString* GetWasmBytes(JSObject* wasm) {
-  return SeqOneByteString::cast(wasm->GetInternalField(kWasmModuleBytesString));
+Handle<SeqOneByteString> GetWasmBytes(Handle<JSObject> wasm) {
+  DCHECK(IsWasmObject(*wasm));
+  Object* compiled_module = wasm->GetInternalField(kWasmCompiledModule);
+  return WasmCompiledModule::cast(compiled_module)->module_bytes();
 }
 
 Handle<WasmDebugInfo> GetDebugInfo(Handle<JSObject> wasm) {
   Handle<Object> info(wasm->GetInternalField(kWasmDebugInfo),
                       wasm->GetIsolate());
   if (!info->IsUndefined(wasm->GetIsolate()))
     return Handle<WasmDebugInfo>::cast(info);
   Handle<WasmDebugInfo> new_info = WasmDebugInfo::New(wasm);
   wasm->SetInternalField(kWasmDebugInfo, *new_info);
   return new_info;
@@ skipping 58 matching lines @@
                            const std::vector<Handle<Code>>* code_table) {
   uint32_t max_size = table->length() / 2;
   for (uint32_t i = max_size; i < max_size + table_size; ++i) {
     int index = Smi::cast(table->get(static_cast<int>(i)))->value();
     DCHECK_GE(index, 0);
     DCHECK_LT(static_cast<size_t>(index), code_table->size());
     table->set(static_cast<int>(i), *(*code_table)[index]);
   }
 }
 
-int GetNumberOfFunctions(JSObject* wasm) {
-  Object* func_names_obj = wasm->GetInternalField(kWasmFunctionNamesArray);
+int GetNumberOfFunctions(Handle<JSObject> wasm) {
+  DCHECK(IsWasmObject(*wasm));
+  WasmCompiledModule* compiled_module =
+      WasmCompiledModule::cast(wasm->GetInternalField(kWasmCompiledModule));
+  ByteArray* func_names_arr = compiled_module->ptr_to_function_names();
   // TODO(clemensh): this looks inside an array constructed elsewhere. Refactor.
-  return ByteArray::cast(func_names_obj)->get_int(0);
+  return func_names_arr->get_int(0);
 }
 
 Handle<JSObject> CreateCompiledModuleObject(Isolate* isolate,
                                             Handle<FixedArray> compiled_module,
                                             ModuleOrigin origin) {
   Handle<JSObject> module_obj;
   if (origin == ModuleOrigin::kWasmOrigin) {
     Handle<JSFunction> module_cons(
         isolate->native_context()->wasm_module_constructor());
     module_obj = isolate->factory()->NewJSObject(module_cons);
@@ skipping 173 matching lines @@
   WasmCompiledModule* compiled_module =
       WasmCompiledModule::cast(instance->GetInternalField(kWasmCompiledModule));
   CHECK(compiled_module->has_weak_module_object());
   CHECK(compiled_module->ptr_to_weak_module_object()->cleared());
 }
 
 }  // namespace testing
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8