[wasm] Allocate a single script per wasm 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 611 matching lines @@
     }
     TRACE("chain after {\n");
     TRACE_CHAIN(WasmCompiledModule::cast(wasm_module->GetInternalField(0)));
     TRACE("}\n");
   }
   compiled_module->reset_weak_owning_instance();
   GlobalHandles::Destroy(reinterpret_cast<Object**>(p));
   TRACE("}\n");
 }
 
+std::pair<int, int> GetFunctionOffsetAndLength(
+    Handle<WasmCompiledModule> compiled_module, int func_index) {
+  WasmModule* module = compiled_module->cpp_module();
+  if (func_index < 0 ||
+      static_cast<size_t>(func_index) > module->functions.size()) {
+    return {0, 0};
+  }
+  WasmFunction& func = module->functions[func_index];
+  return {static_cast<int>(func.code_start_offset),
+          static_cast<int>(func.code_end_offset - func.code_start_offset)};
+}
+
 }  // namespace
 
 const char* wasm::SectionName(WasmSectionCode code) {
   switch (code) {
     case kUnknownSectionCode:
       return "Unknown";
     case kTypeSectionCode:
       return "Type";
     case kImportSectionCode:
       return "Import";
@@ skipping 80 matching lines @@
   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();
 }
 
 WasmModule* GetCppModule(Handle<JSObject> instance) {
   DCHECK(IsWasmInstance(*instance));
-  return reinterpret_cast<WasmModuleWrapper*>(
-             *GetCompiledModule(*instance)->module_wrapper())
+  return Handle<WasmModuleWrapper>::cast(
+             GetCompiledModule(*instance)->module_wrapper())
       ->get();
 }
 
-int wasm::GetNumImportedFunctions(Handle<JSObject> instance) {
-  return static_cast<int>(GetCppModule(instance)->num_imported_functions);
+int wasm::GetFunctionCodeOffset(Handle<WasmCompiledModule> compiled_module,
+                                int func_index) {
+  return GetFunctionOffsetAndLength(compiled_module, func_index).first;
+}
+
+bool wasm::GetPositionInfo(Handle<WasmCompiledModule> compiled_module,
+                           uint32_t position, Script::PositionInfo* info) {
+  WasmModule* module = compiled_module->cpp_module();
+
+  // Binary search for a function containing the given position.
+  int left = 0;                                            // inclusive
+  int right = static_cast<int>(module->functions.size());  // exclusive
+  if (right == 0) return false;
+  while (right - left > 1) {
+    int mid = left + (right - left) / 2;
+    if (module->functions[mid].code_start_offset <= position) {
+      left = mid;
+    } else {
+      right = mid;
+    }
+  }
+  // If the found entry does not contains the given position, return false.

[Yang, 2016/11/15 07:42:26]

Can this actually happen, if we check upfront that position is less or equal the
last functions end offset? I'd rather do that and change this code to an
assertion.

[Clemens Hammacher, 2016/11/15 15:04:06]

There is a slight gap between functions, precisely the bytes used to encode the
length of the function code. For details:
https://github.com/WebAssembly/design/blob/master/BinaryEncoding.md#function-...

+  WasmFunction& func = module->functions[left];
+  if (position < func.code_start_offset || position >= func.code_end_offset) {
+    return false;
+  }
+
+  info->line = left;
+  info->column = position - func.code_start_offset;
+  info->line_start = func.code_start_offset;
+  info->line_end = func.code_end_offset;
+  return true;
 }
 
 WasmModule::WasmModule(Zone* owned, const byte* module_start)
     : owned_zone(owned),
       module_start(module_start),
       pending_tasks(new base::Semaphore(0)) {}
 
 MaybeHandle<WasmCompiledModule> WasmModule::CompileFunctions(
     Isolate* isolate, Handle<WasmModuleWrapper> module_wrapper,
     ErrorThrower* thrower) const {
@@ skipping 1164 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> wasm::GetWasmFunctionNameOrNull(Isolate* isolate,
-                                               Handle<Object> instance,
-                                               uint32_t func_index) {
-  if (!instance->IsUndefined(isolate)) {
-    DCHECK(IsWasmInstance(*instance));
-    WasmModule* module = GetCppModule(Handle<JSObject>::cast(instance));
-    WasmFunction& function = module->functions[func_index];
-    Handle<WasmCompiledModule> compiled_module(GetCompiledModule(*instance),
-                                               isolate);
-    MaybeHandle<String> string = ExtractStringFromModuleBytes(
-        isolate, compiled_module, function.name_offset, function.name_length);
-    if (!string.is_null()) return string.ToHandleChecked();
-  }
+Handle<Object> wasm::GetWasmFunctionNameOrNull(
+    Isolate* isolate, Handle<WasmCompiledModule> compiled_module,
+    uint32_t func_index) {
+  WasmModule* module =
+      Handle<WasmModuleWrapper>::cast(compiled_module->module_wrapper())->get();
+  DCHECK_LT(func_index, module->functions.size());
+  WasmFunction& function = module->functions[func_index];
+  MaybeHandle<String> string = ExtractStringFromModuleBytes(
+      isolate, compiled_module, function.name_offset, function.name_length);
+  if (!string.is_null()) return string.ToHandleChecked();
   return isolate->factory()->null_value();
 }
 
-Handle<String> wasm::GetWasmFunctionName(Isolate* isolate,
-                                         Handle<Object> instance,
-                                         uint32_t func_index) {
-  Handle<Object> name_or_null =
-      GetWasmFunctionNameOrNull(isolate, instance, func_index);
-  if (!name_or_null->IsNull(isolate)) {
-    return Handle<String>::cast(name_or_null);
+Handle<String> wasm::GetWasmFunctionName(
+    Isolate* isolate, Handle<Object> compiled_module_or_undef,
+    uint32_t func_index) {
+  if (!compiled_module_or_undef->IsUndefined(isolate)) {
+    Handle<Object> name_or_null = GetWasmFunctionNameOrNull(
+        isolate, Handle<WasmCompiledModule>::cast(compiled_module_or_undef),
+        func_index);
+    if (!name_or_null->IsNull(isolate)) {
+      return Handle<String>::cast(name_or_null);
+    }
   }
   return isolate->factory()->NewStringFromStaticChars("<WASM UNNAMED>");
 }
 
 bool wasm::IsWasmInstance(Object* object) {
   if (!object->IsJSObject()) return false;
 
   JSObject* obj = JSObject::cast(object);
   Isolate* isolate = obj->GetIsolate();
   if (obj->GetInternalFieldCount() != kWasmInstanceInternalFieldCount) {
@@ skipping 11 matching lines @@
   return true;
 }
 
 WasmCompiledModule* wasm::GetCompiledModule(Object* instance) {
   DCHECK(IsWasmInstance(instance));
   return WasmCompiledModule::cast(
       JSObject::cast(instance)->GetInternalField(kWasmCompiledModule));
 }
 
 bool wasm::WasmIsAsmJs(Object* instance, Isolate* isolate) {
-  return IsWasmInstance(instance) &&
-         GetCompiledModule(JSObject::cast(instance))->has_asm_js_script();
+  if (instance->IsUndefined(isolate)) return false;
+  DCHECK(IsWasmInstance(instance));
+  WasmCompiledModule* compiled_module =
+      GetCompiledModule(JSObject::cast(instance));
+  DCHECK_EQ(compiled_module->has_asm_js_offset_tables(),
+            compiled_module->script()->type() == Script::TYPE_NORMAL);
+  return compiled_module->has_asm_js_offset_tables();
 }
 
-Handle<Script> wasm::GetAsmWasmScript(Handle<JSObject> instance) {
+Handle<Script> wasm::GetScript(Handle<JSObject> instance) {
   DCHECK(IsWasmInstance(*instance));
   WasmCompiledModule* compiled_module = GetCompiledModule(*instance);
-  return compiled_module->asm_js_script();
+  DCHECK(compiled_module->has_script());
+  return compiled_module->script();
 }
 
 int wasm::GetAsmWasmSourcePosition(Handle<JSObject> instance, int func_index,
                                    int byte_offset) {
   return WasmDebugInfo::GetAsmJsSourcePosition(GetDebugInfo(instance),
                                                func_index, byte_offset);
 }
 
 Handle<SeqOneByteString> wasm::GetWasmBytes(Handle<JSObject> instance) {
   DCHECK(IsWasmInstance(*instance));
@@ skipping 61 matching lines @@
   // 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_asm_js_script());
+  DCHECK(!compiled_module->has_script());
   DCHECK(!compiled_module->has_asm_js_offset_tables());
   if (origin == kAsmJsOrigin) {
-    compiled_module->set_asm_js_script(asm_js_script);
+    // 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 =
         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);
+  } 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),
+        kZeroHashSeed);
+
+    char buffer[50];
+    int url_chars = SNPrintF(ArrayVector(buffer), "wasm://wasm/%08x", hash);
+    DCHECK(url_chars >= 0 && url_chars < arraysize(buffer));
+    MaybeHandle<String> url_str = isolate->factory()->NewStringFromOneByte(
+        Vector<const uint8_t>(reinterpret_cast<uint8_t*>(buffer), url_chars),
+        TENURED);
+    script->set_source_url(*url_str.ToHandleChecked());
+
+    int name_chars = SNPrintF(ArrayVector(buffer), "wasm-%08x", hash);
+    DCHECK(name_chars >= 0 && name_chars < arraysize(buffer));
+    MaybeHandle<String> name_str = isolate->factory()->NewStringFromOneByte(
+        Vector<const uint8_t>(reinterpret_cast<uint8_t*>(buffer), name_chars),
+        TENURED);
+    script->set_name(*name_str.ToHandleChecked());
+
+    script->set_wasm_compiled_module(*compiled_module);
+    compiled_module->set_script(script);
+    isolate->debug()->OnAfterCompile(script);
   }
 
   return CreateWasmModuleObject(isolate, compiled_module, origin);
 }
 
 bool wasm::ValidateModuleBytes(Isolate* isolate, const byte* start,
                                const byte* end, ErrorThrower* thrower,
                                ModuleOrigin origin) {
   ModuleResult result = DecodeWasmModule(isolate, start, end, false, origin);
   if (result.val) {
@@ skipping 171 matching lines @@
     CHECK_NOT_NULL(result.val);
     module = const_cast<WasmModule*>(result.val);
   }
 
   Handle<WasmModuleWrapper> module_wrapper =
       WasmModuleWrapper::New(isolate, module);
 
   compiled_module->set_module_wrapper(module_wrapper);
   DCHECK(WasmCompiledModule::IsWasmCompiledModule(*compiled_module));
 }