[rename] Rename internal field to embedder field.

src/wasm/wasm-objects.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/wasm/wasm-objects.h"
 #include "src/utils.h"
 
 #include "src/base/iterator.h"
 #include "src/debug/debug-interface.h"
 #include "src/objects-inl.h"
@@ skipping 31 matching lines @@
 #define DEFINE_OPTIONAL_GETTER0(getter, Container, name, field, type) \
   DEFINE_GETTER0(getter, Container, name, field, type)                \
   bool Container::has_##name() {                                      \
     return !getter(field)->IsUndefined(GetIsolate());                 \
   }
 
 #define DEFINE_GETTER0(getter, Container, name, field, type) \
   type* Container::name() { return type::cast(getter(field)); }
 
 #define DEFINE_OBJ_GETTER(Container, name, field, type) \
-  DEFINE_GETTER0(GetInternalField, Container, name, field, type)
+  DEFINE_GETTER0(GetEmbedderField, Container, name, field, type)
 #define DEFINE_OBJ_ACCESSORS(Container, name, field, type)               \
-  DEFINE_ACCESSORS0(GetInternalField, SetInternalField, Container, name, \
+  DEFINE_ACCESSORS0(GetEmbedderField, SetEmbedderField, Container, name, \
                     field, type)
 #define DEFINE_OPTIONAL_OBJ_ACCESSORS(Container, name, field, type)         \
-  DEFINE_OPTIONAL_ACCESSORS0(GetInternalField, SetInternalField, Container, \
+  DEFINE_OPTIONAL_ACCESSORS0(GetEmbedderField, SetEmbedderField, Container, \
                              name, field, type)
 #define DEFINE_ARR_GETTER(Container, name, field, type) \
   DEFINE_GETTER0(get, Container, name, field, type)
 #define DEFINE_ARR_ACCESSORS(Container, name, field, type) \
   DEFINE_ACCESSORS0(get, set, Container, name, field, type)
 #define DEFINE_OPTIONAL_ARR_ACCESSORS(Container, name, field, type) \
   DEFINE_OPTIONAL_ACCESSORS0(get, set, Container, name, field, type)
 #define DEFINE_OPTIONAL_ARR_GETTER(Container, name, field, type) \
   DEFINE_OPTIONAL_GETTER0(get, Container, name, field, type)
 
@@ skipping 160 matching lines @@
     Handle<Symbol> module_sym(isolate->native_context()->wasm_module_sym());
     Object::SetProperty(module_object, module_sym, module_object, STRICT)
         .Check();
   } else {
     DCHECK(origin == ModuleOrigin::kAsmJsOrigin);
     Handle<Map> map = isolate->factory()->NewMap(
         JS_OBJECT_TYPE,
         JSObject::kHeaderSize + WasmModuleObject::kFieldCount * kPointerSize);
     module_object = isolate->factory()->NewJSObjectFromMap(map, TENURED);
   }
-  module_object->SetInternalField(WasmModuleObject::kCompiledModule,
+  module_object->SetEmbedderField(WasmModuleObject::kCompiledModule,
                                   *compiled_module);
   Handle<WeakCell> link_to_module =
       isolate->factory()->NewWeakCell(module_object);
   compiled_module->set_weak_wasm_module(link_to_module);
   return Handle<WasmModuleObject>::cast(module_object);
 }
 
 WasmModuleObject* WasmModuleObject::cast(Object* object) {
   DCHECK(object->IsJSObject());
   // TODO(titzer): brand check for WasmModuleObject.
   return reinterpret_cast<WasmModuleObject*>(object);
 }
 
 bool WasmModuleObject::IsWasmModuleObject(Object* object) {
   return object->IsJSObject() &&
-         JSObject::cast(object)->GetInternalFieldCount() == kFieldCount;
+         JSObject::cast(object)->GetEmbedderFieldCount() == kFieldCount;
 }
 
 DEFINE_OBJ_GETTER(WasmModuleObject, compiled_module, kCompiledModule,
                   WasmCompiledModule)
 
 Handle<WasmTableObject> WasmTableObject::New(Isolate* isolate, uint32_t initial,
                                              int64_t maximum,
                                              Handle<FixedArray>* js_functions) {
   Handle<JSFunction> table_ctor(
       isolate->native_context()->wasm_table_constructor());
   Handle<JSObject> table_obj = isolate->factory()->NewJSObject(table_ctor);
-  table_obj->SetInternalField(kWrapperTracerHeader, Smi::kZero);
+  table_obj->SetEmbedderField(kWrapperTracerHeader, Smi::kZero);
 
   *js_functions = isolate->factory()->NewFixedArray(initial);
   Object* null = isolate->heap()->null_value();
   for (int i = 0; i < static_cast<int>(initial); ++i) {
     (*js_functions)->set(i, null);
   }
-  table_obj->SetInternalField(kFunctions, *(*js_functions));
+  table_obj->SetEmbedderField(kFunctions, *(*js_functions));
   Handle<Object> max = isolate->factory()->NewNumber(maximum);
-  table_obj->SetInternalField(kMaximum, *max);
+  table_obj->SetEmbedderField(kMaximum, *max);
 
   Handle<FixedArray> dispatch_tables = isolate->factory()->NewFixedArray(0);
-  table_obj->SetInternalField(kDispatchTables, *dispatch_tables);
+  table_obj->SetEmbedderField(kDispatchTables, *dispatch_tables);
   Handle<Symbol> table_sym(isolate->native_context()->wasm_table_sym());
   Object::SetProperty(table_obj, table_sym, table_obj, STRICT).Check();
   return Handle<WasmTableObject>::cast(table_obj);
 }
 
 DEFINE_OBJ_GETTER(WasmTableObject, dispatch_tables, kDispatchTables, FixedArray)
 
 Handle<FixedArray> WasmTableObject::AddDispatchTable(
     Isolate* isolate, Handle<WasmTableObject> table_obj,
     Handle<WasmInstanceObject> instance, int table_index,
     Handle<FixedArray> function_table, Handle<FixedArray> signature_table) {
   Handle<FixedArray> dispatch_tables(
-      FixedArray::cast(table_obj->GetInternalField(kDispatchTables)), isolate);
+      FixedArray::cast(table_obj->GetEmbedderField(kDispatchTables)), isolate);
   DCHECK_EQ(0, dispatch_tables->length() % 4);
 
   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 triple at the end.
   Handle<FixedArray> new_dispatch_tables =
       isolate->factory()->CopyFixedArrayAndGrow(dispatch_tables, 4);
 
   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, *function_table);
   new_dispatch_tables->set(dispatch_tables->length() + 3, *signature_table);
 
-  table_obj->SetInternalField(WasmTableObject::kDispatchTables,
+  table_obj->SetEmbedderField(WasmTableObject::kDispatchTables,
                               *new_dispatch_tables);
 
   return new_dispatch_tables;
 }
 
 DEFINE_OBJ_ACCESSORS(WasmTableObject, functions, kFunctions, FixedArray)
 
 uint32_t WasmTableObject::current_length() { return functions()->length(); }
 
 bool WasmTableObject::has_maximum_length() {
-  return GetInternalField(kMaximum)->Number() >= 0;
+  return GetEmbedderField(kMaximum)->Number() >= 0;
 }
 
 int64_t WasmTableObject::maximum_length() {
-  return static_cast<int64_t>(GetInternalField(kMaximum)->Number());
+  return static_cast<int64_t>(GetEmbedderField(kMaximum)->Number());
 }
 
 WasmTableObject* WasmTableObject::cast(Object* object) {
   DCHECK(object && object->IsJSObject());
   // TODO(titzer): brand check for WasmTableObject.
   return reinterpret_cast<WasmTableObject*>(object);
 }
 
 void WasmTableObject::Grow(Isolate* isolate, Handle<WasmTableObject> table,
                            uint32_t count) {
   Handle<FixedArray> dispatch_tables(table->dispatch_tables());
   wasm::GrowDispatchTables(isolate, dispatch_tables,
                            table->functions()->length(), count);
 }
 
 Handle<WasmMemoryObject> WasmMemoryObject::New(Isolate* isolate,
                                                Handle<JSArrayBuffer> buffer,
                                                int32_t maximum) {
   Handle<JSFunction> memory_ctor(
       isolate->native_context()->wasm_memory_constructor());
   Handle<JSObject> memory_obj =
       isolate->factory()->NewJSObject(memory_ctor, TENURED);
-  memory_obj->SetInternalField(kWrapperTracerHeader, Smi::kZero);
+  memory_obj->SetEmbedderField(kWrapperTracerHeader, Smi::kZero);
 
-  memory_obj->SetInternalField(kArrayBuffer, *buffer);
+  memory_obj->SetEmbedderField(kArrayBuffer, *buffer);
   Handle<Object> max = isolate->factory()->NewNumber(maximum);
-  memory_obj->SetInternalField(kMaximum, *max);
+  memory_obj->SetEmbedderField(kMaximum, *max);
   Handle<Symbol> memory_sym(isolate->native_context()->wasm_memory_sym());
   Object::SetProperty(memory_obj, memory_sym, memory_obj, STRICT).Check();
   return Handle<WasmMemoryObject>::cast(memory_obj);
 }
 
 DEFINE_OBJ_ACCESSORS(WasmMemoryObject, buffer, kArrayBuffer, JSArrayBuffer)
 DEFINE_OPTIONAL_OBJ_ACCESSORS(WasmMemoryObject, instances_link, kInstancesLink,
                               WasmInstanceWrapper)
 
 uint32_t WasmMemoryObject::current_pages() {
   return SafeUint32(buffer()->byte_length()) / wasm::WasmModule::kPageSize;
 }
 
 bool WasmMemoryObject::has_maximum_pages() {
-  return GetInternalField(kMaximum)->Number() >= 0;
+  return GetEmbedderField(kMaximum)->Number() >= 0;
 }
 
 int32_t WasmMemoryObject::maximum_pages() {
-  return static_cast<int32_t>(GetInternalField(kMaximum)->Number());
+  return static_cast<int32_t>(GetEmbedderField(kMaximum)->Number());
 }
 
 WasmMemoryObject* WasmMemoryObject::cast(Object* object) {
   DCHECK(object && object->IsJSObject());
   // TODO(titzer): brand check for WasmMemoryObject.
   return reinterpret_cast<WasmMemoryObject*>(object);
 }
 
 void WasmMemoryObject::AddInstance(Isolate* isolate,
                                    Handle<WasmInstanceObject> instance) {
   Handle<WasmInstanceWrapper> instance_wrapper =
       handle(instance->instance_wrapper());
   if (has_instances_link()) {
     Handle<WasmInstanceWrapper> current_wrapper(instances_link());
     DCHECK(WasmInstanceWrapper::IsWasmInstanceWrapper(*current_wrapper));
     DCHECK(!current_wrapper->has_previous());
     instance_wrapper->set_next_wrapper(*current_wrapper);
     current_wrapper->set_previous_wrapper(*instance_wrapper);
   }
   set_instances_link(*instance_wrapper);
 }
 
 void WasmMemoryObject::ResetInstancesLink(Isolate* isolate) {
   Handle<Object> undefined = isolate->factory()->undefined_value();
-  SetInternalField(kInstancesLink, *undefined);
+  SetEmbedderField(kInstancesLink, *undefined);
 }
 
 DEFINE_OBJ_ACCESSORS(WasmInstanceObject, compiled_module, kCompiledModule,
                      WasmCompiledModule)
 DEFINE_OPTIONAL_OBJ_ACCESSORS(WasmInstanceObject, globals_buffer,
                               kGlobalsArrayBuffer, JSArrayBuffer)
 DEFINE_OPTIONAL_OBJ_ACCESSORS(WasmInstanceObject, memory_buffer,
                               kMemoryArrayBuffer, JSArrayBuffer)
 DEFINE_OPTIONAL_OBJ_ACCESSORS(WasmInstanceObject, memory_object, kMemoryObject,
                               WasmMemoryObject)
@@ skipping 19 matching lines @@
 WasmInstanceObject* WasmInstanceObject::cast(Object* object) {
   DCHECK(IsWasmInstanceObject(object));
   return reinterpret_cast<WasmInstanceObject*>(object);
 }
 
 bool WasmInstanceObject::IsWasmInstanceObject(Object* object) {
   if (!object->IsJSObject()) return false;
 
   JSObject* obj = JSObject::cast(object);
   Isolate* isolate = obj->GetIsolate();
-  if (obj->GetInternalFieldCount() != kFieldCount) {
+  if (obj->GetEmbedderFieldCount() != kFieldCount) {
     return false;
   }
 
-  Object* mem = obj->GetInternalField(kMemoryArrayBuffer);
+  Object* mem = obj->GetEmbedderField(kMemoryArrayBuffer);
   if (!(mem->IsUndefined(isolate) || mem->IsJSArrayBuffer()) ||
       !WasmCompiledModule::IsWasmCompiledModule(
-          obj->GetInternalField(kCompiledModule))) {
+          obj->GetEmbedderField(kCompiledModule))) {
     return false;
   }
 
   // All checks passed.
   return true;
 }
 
 Handle<WasmInstanceObject> WasmInstanceObject::New(
     Isolate* isolate, Handle<WasmCompiledModule> compiled_module) {
   Handle<JSFunction> instance_cons(
       isolate->native_context()->wasm_instance_constructor());
   Handle<JSObject> instance_object =
       isolate->factory()->NewJSObject(instance_cons, TENURED);
-  instance_object->SetInternalField(kWrapperTracerHeader, Smi::kZero);
+  instance_object->SetEmbedderField(kWrapperTracerHeader, Smi::kZero);
 
   Handle<Symbol> instance_sym(isolate->native_context()->wasm_instance_sym());
   Object::SetProperty(instance_object, instance_sym, instance_object, STRICT)
       .Check();
   Handle<WasmInstanceObject> instance(
       reinterpret_cast<WasmInstanceObject*>(*instance_object), isolate);
 
-  instance->SetInternalField(kCompiledModule, *compiled_module);
-  instance->SetInternalField(kMemoryObject, isolate->heap()->undefined_value());
+  instance->SetEmbedderField(kCompiledModule, *compiled_module);
+  instance->SetEmbedderField(kMemoryObject, isolate->heap()->undefined_value());
   Handle<WasmInstanceWrapper> instance_wrapper =
       WasmInstanceWrapper::New(isolate, instance);
-  instance->SetInternalField(kWasmMemInstanceWrapper, *instance_wrapper);
+  instance->SetEmbedderField(kWasmMemInstanceWrapper, *instance_wrapper);
   return instance;
 }
 
 WasmInstanceObject* WasmExportedFunction::instance() {
-  return WasmInstanceObject::cast(GetInternalField(kInstance));
+  return WasmInstanceObject::cast(GetEmbedderField(kInstance));
 }
 
 int WasmExportedFunction::function_index() {
-  return SafeInt32(GetInternalField(kIndex));
+  return SafeInt32(GetEmbedderField(kIndex));
 }
 
 WasmExportedFunction* WasmExportedFunction::cast(Object* object) {
   DCHECK(object && object->IsJSFunction());
   DCHECK_EQ(Code::JS_TO_WASM_FUNCTION,
             JSFunction::cast(object)->code()->kind());
   // TODO(titzer): brand check for WasmExportedFunction.
   return reinterpret_cast<WasmExportedFunction*>(object);
 }
 
@@ skipping 12 matching lines @@
   } else {
     name = maybe_name.ToHandleChecked();
   }
   DCHECK_EQ(Code::JS_TO_WASM_FUNCTION, export_wrapper->kind());
   Handle<SharedFunctionInfo> shared =
       isolate->factory()->NewSharedFunctionInfo(name, export_wrapper, false);
   shared->set_length(arity);
   shared->set_internal_formal_parameter_count(arity);
   Handle<JSFunction> function = isolate->factory()->NewFunction(
       isolate->wasm_function_map(), name, export_wrapper);
-  function->SetInternalField(kWrapperTracerHeader, Smi::kZero);
+  function->SetEmbedderField(kWrapperTracerHeader, Smi::kZero);
 
   function->set_shared(*shared);
 
-  function->SetInternalField(kInstance, *instance);
-  function->SetInternalField(kIndex, Smi::FromInt(func_index));
+  function->SetEmbedderField(kInstance, *instance);
+  function->SetEmbedderField(kIndex, Smi::FromInt(func_index));
   return Handle<WasmExportedFunction>::cast(function);
 }
 
 bool WasmSharedModuleData::IsWasmSharedModuleData(Object* object) {
   if (!object->IsFixedArray()) return false;
   FixedArray* arr = FixedArray::cast(object);
   if (arr->length() != kFieldCount) return false;
   Isolate* isolate = arr->GetIsolate();
   if (!arr->get(kModuleWrapper)->IsForeign()) return false;
   if (!arr->get(kModuleBytes)->IsUndefined(isolate) &&
@@ skipping 664 matching lines @@
   if (!array->get(kWrapperInstanceObject)->IsWeakCell()) return false;
   Isolate* isolate = array->GetIsolate();
   if (!array->get(kNextInstanceWrapper)->IsUndefined(isolate) &&
       !array->get(kNextInstanceWrapper)->IsFixedArray())
     return false;
   if (!array->get(kPreviousInstanceWrapper)->IsUndefined(isolate) &&
       !array->get(kPreviousInstanceWrapper)->IsFixedArray())
     return false;
   return true;
 }