[wasm] Improve naming consistency for WASM instances.

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 807 matching lines @@
       os << "+" << pair.function_->func_index;
     }
   } else {
     os << "?";
   }
   return os;
 }
 
 Handle<JSFunction> wasm::WrapExportCodeAsJSFunction(
     Isolate* isolate, Handle<Code> export_code, Handle<String> name, int arity,
-    MaybeHandle<ByteArray> maybe_signature, Handle<JSObject> module_instance) {
+    MaybeHandle<ByteArray> maybe_signature, Handle<JSObject> instance) {
   Handle<SharedFunctionInfo> shared =
       isolate->factory()->NewSharedFunctionInfo(name, export_code, false);
   shared->set_length(arity);
   shared->set_internal_formal_parameter_count(arity);
   Handle<JSFunction> function = isolate->factory()->NewFunction(
       isolate->wasm_function_map(), name, export_code);
   function->set_shared(*shared);
 
-  function->SetInternalField(kInternalModuleInstance, *module_instance);
+  function->SetInternalField(kInternalModuleInstance, *instance);
   // add another Internal Field as the function arity
   function->SetInternalField(kInternalArity, Smi::FromInt(arity));
   // add another Internal Field as the signature of the foreign function
   Handle<ByteArray> signature;
   if (maybe_signature.ToHandle(&signature)) {
     function->SetInternalField(kInternalSignature, *signature);
   }
   return function;
 }
 
 Object* wasm::GetOwningWasmInstance(Code* code) {
   DCHECK(code->kind() == Code::WASM_FUNCTION);
   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();
 }
 
-int wasm::GetNumImportedFunctions(Handle<JSObject> wasm_object) {
+int wasm::GetNumImportedFunctions(Handle<JSObject> instance) {
   // TODO(wasm): Cache this number if it ever becomes a performance problem.
-  DCHECK(IsWasmObject(*wasm_object));
-  WasmCompiledModule* compiled_module = GetCompiledModule(*wasm_object);
+  DCHECK(IsWasmInstance(*instance));
+  WasmCompiledModule* compiled_module = GetCompiledModule(*instance);
   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;
@@ skipping 544 matching lines @@
         }
         module_object_->SetInternalField(0, *compiled_module_);
         instance->SetInternalField(kWasmCompiledModule, *compiled_module_);
         compiled_module_->set_weak_owning_instance(link_to_owning_instance);
         GlobalHandles::MakeWeak(global_handle.location(),
                                 global_handle.location(), &InstanceFinalizer,
                                 v8::WeakCallbackType::kFinalizer);
       }
     }
 
-    DCHECK(wasm::IsWasmObject(*instance));
+    DCHECK(wasm::IsWasmInstance(*instance));
     Handle<Object> memory_object(instance->GetInternalField(kWasmMemObject),
                                  isolate_);
     WasmJs::SetWasmMemoryInstance(isolate_, memory_object, instance);
 
     //--------------------------------------------------------------------------
     // Run the start function if one was specified.
     //--------------------------------------------------------------------------
     if (compiled_module_->has_startup_function()) {
       Handle<FixedArray> startup_data = compiled_module_->startup_function();
       HandleScope scope(isolate_);
@@ skipping 529 matching lines @@
         WasmCompiledModule::cast(current->ptr_to_weak_next_instance()->value());
   }
   PrintF("\n");
 #endif
 }
 
 Handle<Object> wasm::GetWasmFunctionNameOrNull(Isolate* isolate,
                                                Handle<Object> wasm,
                                                uint32_t func_index) {
   if (!wasm->IsUndefined(isolate)) {
-    DCHECK(IsWasmObject(*wasm));
+    DCHECK(IsWasmInstance(*wasm));
     WasmCompiledModule* compiled_module =
         GetCompiledModule(JSObject::cast(*wasm));
     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, func_index).ToHandle(&name)) {
       return name;
     }
   }
   return isolate->factory()->null_value();
 }
 
 Handle<String> wasm::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 wasm::IsWasmObject(Object* object) {
+bool wasm::IsWasmInstance(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()) ||
       !WasmCompiledModule::IsWasmCompiledModule(
           obj->GetInternalField(kWasmCompiledModule))) {
     return false;
   }
 
   // All checks passed.
   return true;
 }
 
 WasmCompiledModule* wasm::GetCompiledModule(JSObject* wasm) {
   return WasmCompiledModule::cast(wasm->GetInternalField(kWasmCompiledModule));
 }
 
 bool wasm::WasmIsAsmJs(Object* wasm, Isolate* isolate) {
   if (wasm->IsUndefined(isolate)) return false;
-  DCHECK(IsWasmObject(wasm));
+  DCHECK(IsWasmInstance(wasm));
   WasmCompiledModule* compiled_module = GetCompiledModule(JSObject::cast(wasm));
   return compiled_module->has_asm_js_script();
 }
 
 Handle<Script> wasm::GetAsmWasmScript(Handle<JSObject> wasm) {
-  DCHECK(IsWasmObject(*wasm));
+  DCHECK(IsWasmInstance(*wasm));
   WasmCompiledModule* compiled_module = GetCompiledModule(*wasm);
   return compiled_module->asm_js_script();
 }
 
 int wasm::GetAsmWasmSourcePosition(Handle<JSObject> wasm, int func_index,
                                    int byte_offset) {
   return WasmDebugInfo::GetAsmJsSourcePosition(GetDebugInfo(wasm), func_index,
                                                byte_offset);
 }
 
-Handle<SeqOneByteString> wasm::GetWasmBytes(Handle<JSObject> wasm) {
-  DCHECK(IsWasmObject(*wasm));
-  WasmCompiledModule* compiled_module = GetCompiledModule(*wasm);
+Handle<SeqOneByteString> wasm::GetWasmBytes(Handle<JSObject> instance) {
+  DCHECK(IsWasmInstance(*instance));
+  WasmCompiledModule* compiled_module = GetCompiledModule(*instance);
   return compiled_module->module_bytes();
 }
 
-Handle<WasmDebugInfo> wasm::GetDebugInfo(Handle<JSObject> wasm) {
-  Handle<Object> info(wasm->GetInternalField(kWasmDebugInfo),
-                      wasm->GetIsolate());
-  if (!info->IsUndefined(wasm->GetIsolate()))
+Handle<WasmDebugInfo> wasm::GetDebugInfo(Handle<JSObject> instance) {
+  Handle<Object> info(instance->GetInternalField(kWasmDebugInfo),
+                      instance->GetIsolate());
+  if (!info->IsUndefined(instance->GetIsolate()))
     return Handle<WasmDebugInfo>::cast(info);
-  Handle<WasmDebugInfo> new_info = WasmDebugInfo::New(wasm);
-  wasm->SetInternalField(kWasmDebugInfo, *new_info);
+  Handle<WasmDebugInfo> new_info = WasmDebugInfo::New(instance);
+  instance->SetInternalField(kWasmDebugInfo, *new_info);
   return new_info;
 }
 
 Handle<FixedArray> wasm::BuildFunctionTable(Isolate* isolate, uint32_t index,
                                             const WasmModule* module) {
   const WasmIndirectFunctionTable* table = &module->function_tables[index];
   DCHECK_EQ(table->size, table->values.size());
   DCHECK_GE(table->max_size, table->size);
   Handle<FixedArray> values =
       isolate->factory()->NewFixedArray(2 * table->max_size, TENURED);
@@ skipping 19 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 wasm::GetNumberOfFunctions(Handle<JSObject> wasm) {
-  DCHECK(IsWasmObject(*wasm));
-  WasmCompiledModule* compiled_module = GetCompiledModule(*wasm);
+int wasm::GetNumberOfFunctions(Handle<JSObject> instance) {
+  DCHECK(IsWasmInstance(*instance));
+  WasmCompiledModule* compiled_module = GetCompiledModule(*instance);
   ByteArray* func_names_arr = compiled_module->ptr_to_function_names();
   // TODO(clemensh): this looks inside an array constructed elsewhere. Refactor.
   return func_names_arr->get_int(0);
 }
 
 Handle<JSObject> wasm::CreateCompiledModuleObject(
     Isolate* isolate, Handle<WasmCompiledModule> compiled_module,
     ModuleOrigin origin) {
   Handle<JSObject> module_obj;
   if (origin == ModuleOrigin::kWasmOrigin) {
@@ skipping 65 matching lines @@
     DCHECK_NOT_NULL(result.val);
     delete result.val;
     return true;
   }
   return false;
 }
 
 MaybeHandle<JSArrayBuffer> wasm::GetInstanceMemory(Isolate* isolate,
                                                    Handle<JSObject> instance) {
   Object* mem = instance->GetInternalField(kWasmMemArrayBuffer);
-  DCHECK(IsWasmObject(*instance));
+  DCHECK(IsWasmInstance(*instance));
   if (mem->IsUndefined(isolate)) return MaybeHandle<JSArrayBuffer>();
   return Handle<JSArrayBuffer>(JSArrayBuffer::cast(mem));
 }
 
 void SetInstanceMemory(Handle<JSObject> instance, JSArrayBuffer* buffer) {
   DisallowHeapAllocation no_gc;
-  DCHECK(IsWasmObject(*instance));
+  DCHECK(IsWasmInstance(*instance));
   instance->SetInternalField(kWasmMemArrayBuffer, buffer);
   WasmCompiledModule* compiled_module = GetCompiledModule(*instance);
   compiled_module->set_ptr_to_heap(buffer);
 }
 
 int32_t wasm::GetInstanceMemorySize(Isolate* isolate,
                                     Handle<JSObject> instance) {
   MaybeHandle<JSArrayBuffer> maybe_mem_buffer =
       GetInstanceMemory(isolate, instance);
   Handle<JSArrayBuffer> buffer;
   if (!maybe_mem_buffer.ToHandle(&buffer)) {
     return 0;
   } else {
     return buffer->byte_length()->Number() / WasmModule::kPageSize;
   }
 }
 
 uint32_t GetMaxInstanceMemorySize(Isolate* isolate, Handle<JSObject> instance) {
   uint32_t max_pages = WasmModule::kMaxMemPages;
   Handle<Object> memory_object(instance->GetInternalField(kWasmMemObject),
                                isolate);
   if (memory_object->IsUndefined(isolate)) return max_pages;
   return WasmJs::GetWasmMemoryMaximumSize(isolate, memory_object);
 }
 
 int32_t wasm::GrowInstanceMemory(Isolate* isolate, Handle<JSObject> instance,
                                  uint32_t pages) {
-  if (!IsWasmObject(*instance)) return -1;
+  if (!IsWasmInstance(*instance)) return -1;
   if (pages == 0) return GetInstanceMemorySize(isolate, instance);
   uint32_t max_pages = GetMaxInstanceMemorySize(isolate, instance);
   if (WasmModule::kMaxMemPages < max_pages) return -1;
 
   Address old_mem_start = nullptr;
   uint32_t old_size = 0, new_size = 0;
 
   MaybeHandle<JSArrayBuffer> maybe_mem_buffer =
       GetInstanceMemory(isolate, instance);
   Handle<JSArrayBuffer> old_buffer;
@@ skipping 41 matching lines @@
       JSObject::cast(compiled_module->ptr_to_weak_module_object()->value()),
       *module_obj);
   Object* prev = nullptr;
   int found_instances = compiled_module->has_weak_owning_instance() ? 1 : 0;
   WasmCompiledModule* current_instance = compiled_module;
   while (current_instance->has_weak_next_instance()) {
     CHECK((prev == nullptr && !current_instance->has_weak_prev_instance()) ||
           current_instance->ptr_to_weak_prev_instance()->value() == prev);
     CHECK_EQ(current_instance->ptr_to_weak_module_object()->value(),
              *module_obj);
-    CHECK(
-        IsWasmObject(current_instance->ptr_to_weak_owning_instance()->value()));
+    CHECK(IsWasmInstance(
+        current_instance->ptr_to_weak_owning_instance()->value()));
     prev = current_instance;
     current_instance = WasmCompiledModule::cast(
         current_instance->ptr_to_weak_next_instance()->value());
     ++found_instances;
     CHECK_LE(found_instances, instance_count);
   }
   CHECK_EQ(found_instances, instance_count);
 }
 
 void testing::ValidateModuleState(Isolate* isolate,
                                   Handle<JSObject> module_obj) {
   DisallowHeapAllocation no_gc;
   WasmCompiledModule* compiled_module =
       WasmCompiledModule::cast(module_obj->GetInternalField(0));
   CHECK(compiled_module->has_weak_module_object());
   CHECK_EQ(compiled_module->ptr_to_weak_module_object()->value(), *module_obj);
   CHECK(!compiled_module->has_weak_prev_instance());
   CHECK(!compiled_module->has_weak_next_instance());
   CHECK(!compiled_module->has_weak_owning_instance());
 }
 
 void testing::ValidateOrphanedInstance(Isolate* isolate,
                                        Handle<JSObject> instance) {
   DisallowHeapAllocation no_gc;
-  CHECK(IsWasmObject(*instance));
+  CHECK(IsWasmInstance(*instance));
   WasmCompiledModule* compiled_module = GetCompiledModule(*instance);
   CHECK(compiled_module->has_weak_module_object());
   CHECK(compiled_module->ptr_to_weak_module_object()->cleared());
 }