[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 39 matching lines @@
 
 // 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 {
   kModuleName,         // String
   kFunctionName,       // maybe String
   kOutputCount,        // Smi. an uint32_t
   kSignature,          // ByteArray. A copy of the data in FunctionSig
   kWasmImportDataSize  // Sentinel value.
 };
@@ skipping 908 matching lines @@
   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());
+  DCHECK(IsWasmObject(*wasm_object));
+  WasmCompiledModule* compiled_module = WasmCompiledModule::cast(
+      wasm_object->GetInternalField(kWasmCompiledModule));
+  return static_cast<uint32_t>(compiled_module->ptr_to_import_data()->length());

[titzer, 2016/10/06 15:55:09]

That won't work in my latest patch; the number of imported functions is stored
directly now.

[Clemens Hammacher, 2016/10/06 18:46:50]

Fixed as discussed.

 }
 
 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 332 matching lines @@
     for (int index = 0; index < num_imported_functions; index++) {
       Handle<Code> import_wrapper =
           CompileImportWrapper(isolate, ffi, index, import_data, thrower);
       if (thrower->error()) return nothing;
       code_table->set(index, *import_wrapper);
       RecordStats(isolate, *import_wrapper);
     }
   }
 
   //--------------------------------------------------------------------------
-  // 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 = isolate->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 =
           isolate->factory()->NewFixedArray(2, TENURED);
@@ skipping 237 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)) {
+    DCHECK(IsWasmObject(*wasm));
+    WasmCompiledModule* compiled_module = WasmCompiledModule::cast(
+        Handle<JSObject>::cast(wasm)->GetInternalField(kWasmCompiledModule));
     Handle<ByteArray> func_names_arr_obj(
-        ByteArray::cast(Handle<JSObject>::cast(wasm)->GetInternalField(
-            kWasmFunctionNamesArray)),
-        isolate);
+        compiled_module->ptr_to_function_names(), isolate);

[Mircea Trofin, 2016/10/06 15:43:21]

wouldn't compiled_module->function_names() give you the same thing?

[Clemens Hammacher, 2016/10/06 18:46:50]

Good catch, fixed.

     // 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)) {
       return name;
     }
   }
   return isolate->factory()->null_value();
 }
@@ skipping 13 matching lines @@
 
   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) {

[titzer, 2016/10/06 15:55:09]

Please return a handle instead of a raw pointer here.

[Clemens Hammacher, 2016/10/06 18:46:50]

Done.

-  return SeqOneByteString::cast(wasm->GetInternalField(kWasmModuleBytesString));
+  DCHECK(IsWasmObject(wasm));
+  WasmCompiledModule* compiled_module =
+      WasmCompiledModule::cast(wasm->GetInternalField(kWasmCompiledModule));
+  return compiled_module->ptr_to_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 59 matching lines @@
   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);
+  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 170 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