[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 195 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) {
+  Object *offset_tables = debug_info->get(kWasmDebugInfoAsmJsOffsets);
+  Isolate *isolate = debug_info->GetIsolate();
+  if (offset_tables->IsUndefined(isolate)) {

[titzer, 2016/10/12 08:03:05]

Can you extract a helper method to materialize the offset tables?

[Clemens Hammacher, 2016/10/12 08:17:46]

Done.

+    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);
+    }
+    offset_tables = *all_tables;
+  }
+
+  FixedArray *offset_tables_arr = FixedArray::cast(offset_tables);
+  DCHECK_LT(func_index, offset_tables_arr->length());
+  ByteArray *offset_table = ByteArray::cast(offset_tables_arr->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);
+}