[wasm] Move asm.js offset table to compiled module

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 1915 matching lines @@
 
 bool wasm::IsWasmInstance(Object* object) {
   return WasmInstanceObject::IsWasmInstanceObject(object);
 }
 
 bool wasm::WasmIsAsmJs(Object* instance, Isolate* isolate) {
   if (instance->IsUndefined(isolate)) return false;
   DCHECK(IsWasmInstance(instance));
   WasmCompiledModule* compiled_module =
       WasmInstanceObject::cast(instance)->get_compiled_module();
-  DCHECK_EQ(compiled_module->has_asm_js_offset_tables(),
+  DCHECK_EQ(compiled_module->has_asm_js_offset_table(),
             compiled_module->script()->type() == Script::TYPE_NORMAL);
-  return compiled_module->has_asm_js_offset_tables();
+  return compiled_module->has_asm_js_offset_table();
 }
 
 Handle<Script> wasm::GetScript(Handle<JSObject> instance) {
   WasmCompiledModule* compiled_module =
       WasmInstanceObject::cast(*instance)->get_compiled_module();
   DCHECK(compiled_module->has_script());
   return compiled_module->script();
 }
 
 std::pair<std::string, std::vector<std::tuple<uint32_t, int, int>>>
 wasm::DisassembleFunction(Handle<WasmCompiledModule> compiled_module,
                           int func_index) {
   std::ostringstream disassembly_os;
   std::vector<std::tuple<uint32_t, int, int>> offset_table;
 
   Vector<const uint8_t> func_bytes =
       GetFunctionBytes(compiled_module, func_index);
   DisallowHeapAllocation no_gc;
   if (func_bytes.is_empty()) return {};
 
   AccountingAllocator allocator;
   bool ok = PrintAst(
       &allocator, FunctionBodyForTesting(func_bytes.start(), func_bytes.end()),
       disassembly_os, &offset_table);
   CHECK(ok);
 
   return {disassembly_os.str(), std::move(offset_table)};
 }
 
-int wasm::GetAsmWasmSourcePosition(Handle<JSObject> instance, int func_index,
-                                   int byte_offset) {
-  return WasmDebugInfo::GetAsmJsSourcePosition(GetDebugInfo(instance),
-                                               func_index, byte_offset);
-}
-
 Handle<WasmDebugInfo> wasm::GetDebugInfo(Handle<JSObject> object) {
   auto instance = Handle<WasmInstanceObject>::cast(object);
   if (instance->has_debug_info()) {
     Handle<WasmDebugInfo> info(instance->get_debug_info(),
                                instance->GetIsolate());
     return info;
   }
   Handle<WasmDebugInfo> new_info = WasmDebugInfo::New(instance);
   instance->set_debug_info(*new_info);
   return new_info;
 }
 
-int wasm::GetNumberOfFunctions(Handle<JSObject> object) {
-  return static_cast<int>(
-      Handle<WasmInstanceObject>::cast(object)->module()->functions.size());
-}
-
 // TODO(clemensh): origin can be inferred from asm_js_script; remove it.
 MaybeHandle<WasmModuleObject> 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<WasmModuleObject> nothing;
   ModuleResult result = DecodeWasmModule(isolate, start, end, false, origin);
   if (result.failed()) {
     if (result.val) delete result.val;
     thrower->CompileFailed("Wasm decoding failed", result);
     return nothing;
   }
   // The {module_wrapper} will take ownership of the {WasmModule} object,
   // and it will be destroyed when the GC reclaims the wrapper object.
   Handle<WasmModuleWrapper> module_wrapper =
       WasmModuleWrapper::New(isolate, const_cast<WasmModule*>(result.val));
 
   // Compile the functions of the module, producing a compiled module.
   MaybeHandle<WasmCompiledModule> maybe_compiled_module =
       result.val->CompileFunctions(isolate, module_wrapper, thrower);
 
   if (maybe_compiled_module.is_null()) return nothing;
 
   Handle<WasmCompiledModule> compiled_module =
       maybe_compiled_module.ToHandleChecked();
 
   DCHECK_EQ(origin == kAsmJsOrigin, !asm_js_script.is_null());
   DCHECK(!compiled_module->has_script());
-  DCHECK(!compiled_module->has_asm_js_offset_tables());
+  DCHECK(!compiled_module->has_asm_js_offset_table());
   if (origin == kAsmJsOrigin) {
     // Set script for the asm.js source, and the offset table mapping wasm byte
     // offsets to source positions.
     compiled_module->set_script(asm_js_script);
-    size_t offset_tables_len =
+    size_t offset_table_len =
         asm_js_offset_tables_end - asm_js_offset_tables_start;
-    DCHECK_GE(static_cast<size_t>(kMaxInt), offset_tables_len);
-    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);
+    DCHECK_GE(static_cast<size_t>(kMaxInt), offset_table_len);
+    Handle<ByteArray> offset_table =
+        isolate->factory()->NewByteArray(static_cast<int>(offset_table_len));
+    memcpy(offset_table->GetDataStartAddress(), asm_js_offset_tables_start,
+           offset_table_len);
+    compiled_module->set_asm_js_offset_table(offset_table);
   } else {
     // Create a new Script object representing this wasm module, store it in the
     // compiled wasm module, and register it at the debugger.
     Handle<Script> script =
         isolate->factory()->NewScript(isolate->factory()->empty_string());
     script->set_type(Script::TYPE_WASM);
 
     DCHECK_GE(kMaxInt, end - start);
     int hash = StringHasher::HashSequentialString(
         reinterpret_cast<const char*>(start), static_cast<int>(end - start),
@@ skipping 233 matching lines @@
 MaybeHandle<String> WasmCompiledModule::GetFunctionName(
     Handle<WasmCompiledModule> compiled_module, uint32_t func_index) {
   DCHECK_LT(func_index, compiled_module->module()->functions.size());
   WasmFunction& function = compiled_module->module()->functions[func_index];
   Isolate* isolate = compiled_module->GetIsolate();
   MaybeHandle<String> string = ExtractStringFromModuleBytes(
       isolate, compiled_module, function.name_offset, function.name_length);
   if (!string.is_null()) return string.ToHandleChecked();
   return {};
 }