[wasm] Remove the use of private symbols for branding.

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/assembler-inl.h"
 #include "src/base/iterator.h"
 #include "src/compiler/wasm-compiler.h"
@@ skipping 144 matching lines @@
 #endif  // DEBUG
 
 }  // namespace
 
 Handle<WasmModuleObject> WasmModuleObject::New(
     Isolate* isolate, Handle<WasmCompiledModule> compiled_module) {
   Handle<JSFunction> module_cons(
       isolate->native_context()->wasm_module_constructor());
   auto module_object = Handle<WasmModuleObject>::cast(
       isolate->factory()->NewJSObject(module_cons));
-  Handle<Symbol> module_sym(isolate->native_context()->wasm_module_sym());
-  Object::SetProperty(module_object, module_sym, module_object, STRICT).Check();
   module_object->set_compiled_module(*compiled_module);
   Handle<WeakCell> link_to_module =
       isolate->factory()->NewWeakCell(module_object);
   compiled_module->set_weak_wasm_module(link_to_module);
   return module_object;
 }
 
 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());
   auto table_obj = Handle<WasmTableObject>::cast(
       isolate->factory()->NewJSObject(table_ctor));
 
   *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->set_functions(**js_functions);
   DCHECK_EQ(maximum, static_cast<int>(maximum));
   table_obj->set_maximum_length(static_cast<int>(maximum));
 
   Handle<FixedArray> dispatch_tables = isolate->factory()->NewFixedArray(0);
   table_obj->set_dispatch_tables(*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);
 }
 
 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(table_obj->dispatch_tables());
   DCHECK_EQ(0, dispatch_tables->length() % 4);
 
@@ skipping 115 matching lines @@
       isolate->native_context()->wasm_memory_constructor());
   auto memory_obj = Handle<WasmMemoryObject>::cast(
       isolate->factory()->NewJSObject(memory_ctor, TENURED));
   if (buffer.is_null()) {
     const bool enable_guard_regions = EnableGuardRegions();
     buffer = SetupArrayBuffer(isolate, nullptr, 0, nullptr, 0, false,
                               enable_guard_regions);
   }
   memory_obj->set_array_buffer(*buffer);
   memory_obj->set_maximum_pages(maximum);
-  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);
 }
 
 uint32_t WasmMemoryObject::current_pages() {
   uint32_t byte_length;
   CHECK(array_buffer()->byte_length()->ToUint32(&byte_length));
   return byte_length / wasm::WasmModule::kPageSize;
 }
 
 void WasmMemoryObject::AddInstance(Isolate* isolate,
@@ skipping 87 matching lines @@
   return new_info;
 }
 
 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);
 
-  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->set_compiled_module(*compiled_module);
   Handle<WasmInstanceWrapper> instance_wrapper =
       WasmInstanceWrapper::New(isolate, instance);
   instance->set_instance_wrapper(*instance_wrapper);
   return instance;
 }
 
@@ skipping 968 matching lines @@
   if (!array->get(kWrapperInstanceObjectIndex)->IsWeakCell()) return false;
   Isolate* isolate = array->GetIsolate();
   if (!array->get(kNextInstanceWrapperIndex)->IsUndefined(isolate) &&
       !array->get(kNextInstanceWrapperIndex)->IsFixedArray())
     return false;
   if (!array->get(kPreviousInstanceWrapperIndex)->IsUndefined(isolate) &&
       !array->get(kPreviousInstanceWrapperIndex)->IsFixedArray())
     return false;
   return true;
 }