[wasm] Clean up wasm module implementation

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"
 #include "src/objects.h"
 #include "src/property-descriptor.h"
 #include "src/simulator.h"
 #include "src/snapshot/snapshot.h"
 #include "src/v8.h"
 
 #include "src/wasm/ast-decoder.h"
 #include "src/wasm/module-decoder.h"
 #include "src/wasm/wasm-debug.h"
 #include "src/wasm/wasm-function-name-table.h"
 #include "src/wasm/wasm-js.h"
 #include "src/wasm/wasm-module.h"
 #include "src/wasm/wasm-result.h"
 
 #include "src/compiler/wasm-compiler.h"
 
-namespace v8 {
-namespace internal {
-namespace wasm {
+using namespace v8::internal;
+using namespace v8::internal::wasm;
+namespace base = v8::base;
 
 #define TRACE(...)                                      \
   do {                                                  \
     if (FLAG_trace_wasm_instances) PrintF(__VA_ARGS__); \
   } while (false)
 
 #define TRACE_CHAIN(instance)        \
   do {                               \
     instance->PrintInstancesChain(); \
   } while (false)
@@ skipping 709 matching lines @@
       Handle<Code> wasm_function =
           wasm_functions->GetValueChecked<Code>(isolate, fct_index);
       PatchFunctionTable(wasm_function, table_to_replace, cloned_table);
     }
   }
   return cloned_indirect_tables;
 }
 
 }  // namespace
 
-const char* SectionName(WasmSectionCode code) {
+const char* wasm::SectionName(WasmSectionCode code) {
   switch (code) {
     case kUnknownSectionCode:
       return "Unknown";
     case kTypeSectionCode:
       return "Type";
     case kImportSectionCode:
       return "Import";
     case kFunctionSectionCode:
       return "Function";
     case kTableSectionCode:
@@ skipping 12 matching lines @@
       return "Element";
     case kDataSectionCode:
       return "Data";
     case kNameSectionCode:
       return "Name";
     default:
       return "<unknown>";
   }
 }
 
-std::ostream& operator<<(std::ostream& os, const WasmModule& module) {
+std::ostream& wasm::operator<<(std::ostream& os, const WasmModule& module) {
   os << "WASM module with ";
   os << (module.min_mem_pages * module.kPageSize) << " min mem";
   os << (module.max_mem_pages * module.kPageSize) << " max mem";
   os << module.functions.size() << " functions";
   os << module.functions.size() << " globals";
   os << module.functions.size() << " data segments";
   return os;
 }
 
-std::ostream& operator<<(std::ostream& os, const WasmFunction& function) {
+std::ostream& wasm::operator<<(std::ostream& os, const WasmFunction& function) {
   os << "WASM function with signature " << *function.sig;
 
   os << " code bytes: "
      << (function.code_end_offset - function.code_start_offset);
   return os;
 }
 
-std::ostream& operator<<(std::ostream& os, const WasmFunctionName& pair) {
+std::ostream& wasm::operator<<(std::ostream& os, const WasmFunctionName& pair) {
   os << "#" << pair.function_->func_index << ":";
   if (pair.function_->name_offset > 0) {
     if (pair.module_) {
       WasmName name = pair.module_->GetName(pair.function_->name_offset,
                                             pair.function_->name_length);
       os.write(name.start(), name.length());
     } else {
       os << "+" << pair.function_->func_index;
     }
   } else {
     os << "?";
   }
   return os;
 }
 
-Handle<JSFunction> WrapExportCodeAsJSFunction(
+Handle<JSFunction> wasm::WrapExportCodeAsJSFunction(
     Isolate* isolate, Handle<Code> export_code, Handle<String> name, int arity,
     MaybeHandle<ByteArray> maybe_signature, Handle<JSObject> module_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);
   // 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* GetOwningWasmInstance(Code* code) {
+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 GetNumImportedFunctions(Handle<JSObject> wasm_object) {
+int wasm::GetNumImportedFunctions(Handle<JSObject> wasm_object) {
   // TODO(wasm): Cache this number if it ever becomes a performance problem.
   DCHECK(IsWasmObject(*wasm_object));
   WasmCompiledModule* compiled_module = GetCompiledModule(*wasm_object);
   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),
       globals_size(0),
       num_imported_functions(0),
       num_declared_functions(0),
       num_exported_functions(0),
       pending_tasks(new base::Semaphore(0)) {}
 
+namespace {
+
 void EncodeInit(const WasmModule* module, Factory* factory,
                 Handle<FixedArray> entry, int kind_index, int value_index,
                 const WasmInitExpr& expr) {
   entry->set(kind_index, Smi::kZero);
 
   Handle<Object> value;
   switch (expr.kind) {
     case WasmInitExpr::kGlobalIndex: {
       TRACE("  kind = 1, global index %u\n", expr.val.global_index);
       entry->set(kind_index, Smi::FromInt(1));
@@ skipping 16 matching lines @@
     case WasmInitExpr::kF64Const:
       TRACE("  kind = 0, f64 = %lf\n", expr.val.f64_const);
       value = factory->NewNumber(expr.val.f64_const);
       break;
     default:
       UNREACHABLE();
   }
   entry->set(value_index, *value);
 }
 
+}  // namespace
+
 MaybeHandle<WasmCompiledModule> WasmModule::CompileFunctions(
     Isolate* isolate, ErrorThrower* thrower) const {
   Factory* factory = isolate->factory();
 
   MaybeHandle<WasmCompiledModule> nothing;
 
   WasmModuleInstance temp_instance(this);
   temp_instance.context = isolate->native_context();
   temp_instance.mem_size = GetMinModuleMemSize(this);
   temp_instance.mem_start = nullptr;
@@ skipping 921 matching lines @@
               UNREACHABLE();
           }
           desc.set_value(isolate_->factory()->NewNumber(num));
           break;
         }
         default:
           UNREACHABLE();
           break;
       }
 
-      Maybe<bool> status = JSReceiver::DefineOwnProperty(
+      v8::Maybe<bool> status = JSReceiver::DefineOwnProperty(
           isolate_, exports_object, name, &desc, Object::THROW_ON_ERROR);
       if (!status.IsJust()) {
         thrower_->Error("export of %.*s failed.", name->length(),
                         name->ToCString().get());
         return;
       }
     }
   }
 };
 
@@ skipping 67 matching lines @@
     PrintF("->%d", current->instance_id());
     if (current->ptr_to_weak_next_instance() == nullptr) break;
     CHECK(!current->ptr_to_weak_next_instance()->cleared());
     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) {
+Handle<Object> wasm::GetWasmFunctionNameOrNull(Isolate* isolate,
+                                               Handle<Object> wasm,
+                                               uint32_t func_index) {
   if (!wasm->IsUndefined(isolate)) {
     DCHECK(IsWasmObject(*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> GetWasmFunctionName(Isolate* isolate, Handle<Object> wasm,
-                                   uint32_t func_index) {
+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 IsWasmObject(Object* object) {
+bool wasm::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()) ||
       !WasmCompiledModule::IsWasmCompiledModule(
           obj->GetInternalField(kWasmCompiledModule))) {
     return false;
   }
 
   // All checks passed.
   return true;
 }
 
-WasmCompiledModule* GetCompiledModule(JSObject* wasm) {
+WasmCompiledModule* wasm::GetCompiledModule(JSObject* wasm) {
   return WasmCompiledModule::cast(wasm->GetInternalField(kWasmCompiledModule));
 }
 
-bool WasmIsAsmJs(Object* wasm, Isolate* isolate) {
+bool wasm::WasmIsAsmJs(Object* wasm, Isolate* isolate) {
   if (wasm->IsUndefined(isolate)) return false;
   DCHECK(IsWasmObject(wasm));
   WasmCompiledModule* compiled_module = GetCompiledModule(JSObject::cast(wasm));
   return compiled_module->has_asm_js_script();
 }
 
-Handle<Script> GetAsmWasmScript(Handle<JSObject> wasm) {
+Handle<Script> wasm::GetAsmWasmScript(Handle<JSObject> wasm) {
   DCHECK(IsWasmObject(*wasm));
   WasmCompiledModule* compiled_module = GetCompiledModule(*wasm);
   return compiled_module->asm_js_script();
 }
 
-int GetAsmWasmSourcePosition(Handle<JSObject> wasm, int func_index,
-                             int byte_offset) {
+int wasm::GetAsmWasmSourcePosition(Handle<JSObject> wasm, int func_index,
+                                   int byte_offset) {
   return WasmDebugInfo::GetAsmJsSourcePosition(GetDebugInfo(wasm), func_index,
                                                byte_offset);
 }
 
-Handle<SeqOneByteString> GetWasmBytes(Handle<JSObject> wasm) {
+Handle<SeqOneByteString> wasm::GetWasmBytes(Handle<JSObject> wasm) {
   DCHECK(IsWasmObject(*wasm));
   WasmCompiledModule* compiled_module = GetCompiledModule(*wasm);
   return compiled_module->module_bytes();
 }
 
-Handle<WasmDebugInfo> GetDebugInfo(Handle<JSObject> wasm) {
+Handle<WasmDebugInfo> wasm::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;
 }
 
-bool UpdateWasmModuleMemory(Handle<JSObject> object, Address old_start,
-                            Address new_start, uint32_t old_size,
-                            uint32_t new_size) {
+bool wasm::UpdateWasmModuleMemory(Handle<JSObject> object, Address old_start,
+                                  Address new_start, uint32_t old_size,
+                                  uint32_t new_size) {
   DisallowHeapAllocation no_allocation;
   if (!IsWasmObject(*object)) {
     return false;
   }
 
   // Get code table associated with the module js_object
   Object* obj = object->GetInternalField(kWasmModuleCodeTable);
   Handle<FixedArray> code_table(FixedArray::cast(obj));
 
   // Iterate through the code objects in the code table and update relocation
   // information
   for (int i = 0; i < code_table->length(); ++i) {
     obj = code_table->get(i);
     Handle<Code> code(Code::cast(obj));
 
     int mode_mask = RelocInfo::ModeMask(RelocInfo::WASM_MEMORY_REFERENCE) |
                     RelocInfo::ModeMask(RelocInfo::WASM_MEMORY_SIZE_REFERENCE);
     for (RelocIterator it(*code, mode_mask); !it.done(); it.next()) {
       RelocInfo::Mode mode = it.rinfo()->rmode();
       if (RelocInfo::IsWasmMemoryReference(mode) ||
           RelocInfo::IsWasmMemorySizeReference(mode)) {
         it.rinfo()->update_wasm_memory_reference(old_start, new_start, old_size,
                                                  new_size);
       }
     }
   }
   return true;
 }
 
-Handle<FixedArray> BuildFunctionTable(Isolate* isolate, uint32_t index,
-                                      const WasmModule* module) {
+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);
   for (uint32_t i = 0; i < table->size; ++i) {
     const WasmFunction* function = &module->functions[table->values[i]];
     int32_t index = table->map.Find(function->sig);
     DCHECK_GE(index, 0);
     values->set(i, Smi::FromInt(index));
     values->set(i + table->max_size, Smi::FromInt(table->values[i]));
   }
   // Set the remaining elements to -1 (instead of "undefined"). These
   // elements are accessed directly as SMIs (without a check). On 64-bit
   // platforms, it is possible to have the top bits of "undefined" take
   // small integer values (or zero), which are more likely to be equal to
   // the signature index we check against.
   for (uint32_t i = table->size; i < table->max_size; ++i) {
     values->set(i, Smi::FromInt(-1));
   }
   return values;
 }
 
-void PopulateFunctionTable(Handle<FixedArray> table, uint32_t table_size,
-                           const std::vector<Handle<Code>>* code_table) {
+void wasm::PopulateFunctionTable(Handle<FixedArray> table, uint32_t table_size,
+                                 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(Handle<JSObject> wasm) {
+int wasm::GetNumberOfFunctions(Handle<JSObject> wasm) {
   DCHECK(IsWasmObject(*wasm));
   WasmCompiledModule* compiled_module = GetCompiledModule(*wasm);
   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> CreateCompiledModuleObject(
+Handle<JSObject> wasm::CreateCompiledModuleObject(
     Isolate* isolate, Handle<WasmCompiledModule> 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);
   } else {
     DCHECK(origin == ModuleOrigin::kAsmJsOrigin);
     Handle<Map> map = isolate->factory()->NewMap(
         JS_OBJECT_TYPE, JSObject::kHeaderSize + kPointerSize);
     module_obj = isolate->factory()->NewJSObjectFromMap(map, TENURED);
   }
   module_obj->SetInternalField(0, *compiled_module);
   if (origin == ModuleOrigin::kWasmOrigin) {
     Handle<Symbol> module_sym(isolate->native_context()->wasm_module_sym());
     Object::SetProperty(module_obj, module_sym, module_obj, STRICT).Check();
   }
   Handle<WeakCell> link_to_module = isolate->factory()->NewWeakCell(module_obj);
   compiled_module->set_weak_module_object(link_to_module);
   return module_obj;
 }
 
 // TODO(clemensh): origin can be inferred from asm_js_script; remove it.
-MaybeHandle<JSObject> CreateModuleObjectFromBytes(
+MaybeHandle<JSObject> wasm::CreateModuleObjectFromBytes(
     Isolate* isolate, const byte* start, const byte* end, ErrorThrower* thrower,
     ModuleOrigin origin, Handle<Script> asm_js_script,
     const byte* asm_js_offset_tables_start,
     const byte* asm_js_offset_tables_end) {
   MaybeHandle<JSObject> nothing;
   Zone zone(isolate->allocator());
   ModuleResult result =
       DecodeWasmModule(isolate, &zone, start, end, false, origin);
   std::unique_ptr<const WasmModule> decoded_module(result.val);
   if (result.failed()) {
@@ skipping 17 matching lines @@
     Handle<ByteArray> offset_tables =
         isolate->factory()->NewByteArray(static_cast<int>(offset_tables_len));
     memcpy(offset_tables->GetDataStartAddress(), asm_js_offset_tables_start,
            offset_tables_len);
     compiled_module->set_asm_js_offset_tables(offset_tables);
   }
 
   return CreateCompiledModuleObject(isolate, compiled_module, origin);
 }
 
-bool ValidateModuleBytes(Isolate* isolate, const byte* start, const byte* end,
-                         ErrorThrower* thrower, ModuleOrigin origin) {
+bool wasm::ValidateModuleBytes(Isolate* isolate, const byte* start,
+                               const byte* end, ErrorThrower* thrower,
+                               ModuleOrigin origin) {
   Zone zone(isolate->allocator());
   ModuleResult result =
       DecodeWasmModule(isolate, &zone, start, end, false, origin);
   if (result.ok()) {
     DCHECK_NOT_NULL(result.val);
     delete result.val;
     return true;
   }
   return false;
 }
 
+namespace {
+
 MaybeHandle<JSArrayBuffer> GetInstanceMemory(Isolate* isolate,
                                              Handle<JSObject> instance) {
   Object* mem = instance->GetInternalField(kWasmMemArrayBuffer);
   DCHECK(IsWasmObject(*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));
   instance->SetInternalField(kWasmMemArrayBuffer, buffer);
   WasmCompiledModule* compiled_module = GetCompiledModule(*instance);
   compiled_module->set_ptr_to_heap(buffer);
 }
 
-int32_t GetInstanceMemorySize(Isolate* isolate, Handle<JSObject> instance) {
+}  // namespace
+
+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;
   }
 }
 
-int32_t GrowInstanceMemory(Isolate* isolate, Handle<JSObject> instance,
-                           uint32_t pages) {
+int32_t wasm::GrowInstanceMemory(Isolate* isolate, Handle<JSObject> instance,
+                                 uint32_t pages) {
   if (pages == 0) {
     return GetInstanceMemorySize(isolate, instance);
   }
   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;
   if (!maybe_mem_buffer.ToHandle(&old_buffer)) {
@@ skipping 27 matching lines @@
   }
   SetInstanceMemory(instance, *buffer);
   if (!UpdateWasmModuleMemory(instance, old_mem_start, new_mem_start, old_size,
                               new_size)) {
     return -1;
   }
   DCHECK(old_size % WasmModule::kPageSize == 0);
   return (old_size / WasmModule::kPageSize);
 }
 
-namespace testing {
-
-void ValidateInstancesChain(Isolate* isolate, Handle<JSObject> module_obj,
-                            int instance_count) {
+void testing::ValidateInstancesChain(Isolate* isolate,
+                                     Handle<JSObject> module_obj,
+                                     int instance_count) {
   CHECK_GE(instance_count, 0);
   DisallowHeapAllocation no_gc;
   WasmCompiledModule* compiled_module =
       WasmCompiledModule::cast(module_obj->GetInternalField(0));
   CHECK_EQ(
       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()));
     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 ValidateModuleState(Isolate* isolate, Handle<JSObject> module_obj) {
+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 ValidateOrphanedInstance(Isolate* isolate, Handle<JSObject> instance) {
+void testing::ValidateOrphanedInstance(Isolate* isolate,
+                                       Handle<JSObject> instance) {
   DisallowHeapAllocation no_gc;
   CHECK(IsWasmObject(*instance));
   WasmCompiledModule* compiled_module = GetCompiledModule(*instance);
   CHECK(compiled_module->has_weak_module_object());
   CHECK(compiled_module->ptr_to_weak_module_object()->cleared());
 }
-
-}  // namespace testing
-}  // namespace wasm
-}  // namespace internal
-}  // namespace v8