[wasm] Provide better stack traces for asm.js code

src/wasm/wasm-debug.cc

 // Copyright 2016 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-debug.h"
 
 #include "src/assert-scope.h"
 #include "src/debug/debug.h"
 #include "src/factory.h"
 #include "src/isolate.h"
 #include "src/wasm/module-decoder.h"
 #include "src/wasm/wasm-module.h"
 
 using namespace v8::internal;
 using namespace v8::internal::wasm;
 
 namespace {
 
 enum {
   kWasmDebugInfoWasmObj,
   kWasmDebugInfoWasmBytesHash,
   kWasmDebugInfoFunctionByteOffsets,
   kWasmDebugInfoFunctionScripts,
+  kWasmDebugInfoAsmJsOffsets,
   kWasmDebugInfoNumEntries
 };
 
 ByteArray *GetOrCreateFunctionOffsetTable(Handle<WasmDebugInfo> debug_info) {
   Object *offset_table = debug_info->get(kWasmDebugInfoFunctionByteOffsets);
   Isolate *isolate = debug_info->GetIsolate();
   if (!offset_table->IsUndefined(isolate)) return ByteArray::cast(offset_table);
 
   FunctionOffsetsResult function_offsets;
   {
@@ skipping 39 matching lines @@
                                        int func_index) {
   Handle<JSObject> wasm_object(debug_info->wasm_object());
   Handle<SeqOneByteString> module_bytes = wasm::GetWasmBytes(wasm_object);
   std::pair<int, int> offset_and_length =
       GetFunctionOffsetAndLength(debug_info, func_index);
   return Vector<const uint8_t>(
       module_bytes->GetChars() + offset_and_length.first,
       offset_and_length.second);
 }
 
+FixedArray *GetOffsetTables(Handle<WasmDebugInfo> debug_info,
+                            Isolate *isolate) {
+  Object *offset_tables = debug_info->get(kWasmDebugInfoAsmJsOffsets);
+  if (!offset_tables->IsUndefined(isolate)) {
+    return FixedArray::cast(offset_tables);
+  }
+
+  AsmJsOffsetsResult asm_offsets;
+  {
+    Handle<JSObject> wasm_object(debug_info->wasm_object(), isolate);
+    Handle<WasmCompiledModule> compiled_module =
+        handle(GetCompiledModule(*wasm_object), isolate);
+    DCHECK(compiled_module->has_asm_js_offset_tables());
+    Handle<ByteArray> asm_offset_tables =
+        compiled_module->asm_js_offset_tables();
+    uint32_t num_imported_functions =
+        static_cast<uint32_t>(wasm::GetNumImportedFunctions(wasm_object));
+    DisallowHeapAllocation no_gc;
+    const byte *bytes_start = asm_offset_tables->GetDataStartAddress();
+    const byte *bytes_end = bytes_start + asm_offset_tables->length();
+    asm_offsets = wasm::DecodeAsmJsOffsets(bytes_start, bytes_end,
+                                           num_imported_functions);
+  }
+  // Wasm bytes must be valid and must contain asm.js offset table.
+  DCHECK(asm_offsets.ok());
+  DCHECK_GE(static_cast<size_t>(kMaxInt), asm_offsets.val.size());
+  int num_functions = static_cast<int>(asm_offsets.val.size());
+  DCHECK_EQ(wasm::GetNumberOfFunctions(handle(debug_info->wasm_object())),
+            num_functions);
+  Handle<FixedArray> all_tables =
+      isolate->factory()->NewFixedArray(num_functions);
+  debug_info->set(kWasmDebugInfoAsmJsOffsets, *all_tables);
+  for (int func = 0; func < num_functions; ++func) {
+    std::vector<std::pair<int, int>> &func_asm_offsets = asm_offsets.val[func];
+    if (func_asm_offsets.empty()) continue;
+    size_t array_size = 2 * kIntSize * func_asm_offsets.size();
+    CHECK_LE(array_size, static_cast<size_t>(kMaxInt));
+    ByteArray *arr =
+        *isolate->factory()->NewByteArray(static_cast<int>(array_size));
+    all_tables->set(func, arr);
+    int idx = 0;
+    for (std::pair<int, int> p : func_asm_offsets) {
+      // Byte offsets must be strictly monotonously increasing:
+      DCHECK(idx == 0 || p.first > arr->get_int(idx - 2));
+      arr->set_int(idx++, p.first);
+      arr->set_int(idx++, p.second);
+    }
+    DCHECK_EQ(arr->length(), idx * kIntSize);
+  }
+  return *all_tables;
+}
 }  // namespace
 
 Handle<WasmDebugInfo> WasmDebugInfo::New(Handle<JSObject> wasm) {
   Isolate *isolate = wasm->GetIsolate();
   Factory *factory = isolate->factory();
   Handle<FixedArray> arr =
       factory->NewFixedArray(kWasmDebugInfoNumEntries, TENURED);
   arr->set(kWasmDebugInfoWasmObj, *wasm);
   int hash = 0;
   Handle<SeqOneByteString> wasm_bytes = GetWasmBytes(wasm);
@@ skipping 136 matching lines @@
   int idx = 0;
   for (std::tuple<uint32_t, int, int> elem : offset_table_vec) {
     offset_table->set(idx++, Smi::FromInt(std::get<0>(elem)));
     offset_table->set(idx++, Smi::FromInt(std::get<1>(elem)));
     offset_table->set(idx++, Smi::FromInt(std::get<2>(elem)));
   }
   DCHECK_EQ(idx, offset_table->length());
 
   return offset_table;
 }
+
+int WasmDebugInfo::GetAsmJsSourcePosition(Handle<WasmDebugInfo> debug_info,
+                                          int func_index, int byte_offset) {
+  Isolate *isolate = debug_info->GetIsolate();
+  FixedArray *offset_tables = GetOffsetTables(debug_info, isolate);
+
+  DCHECK_LT(func_index, offset_tables->length());
+  ByteArray *offset_table = ByteArray::cast(offset_tables->get(func_index));
+
+  // Binary search for the current byte offset.
+  int left = 0;                                       // inclusive
+  int right = offset_table->length() / kIntSize / 2;  // exclusive
+  DCHECK_LT(left, right);
+  while (right - left > 1) {
+    int mid = left + (right - left) / 2;
+    if (offset_table->get_int(2 * mid) < byte_offset) {
+      left = mid;
+    } else {
+      right = mid;
+    }
+  }
+  // There should be an entry for each position that could show up on the stack
+  // trace:
+  DCHECK_EQ(byte_offset, offset_table->get_int(2 * left));
+  return offset_table->get_int(2 * left + 1);
+}