[wasm] Enable wasm frame inspection for debugging

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,
   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 65 matching lines @@
 }
 
 bool WasmDebugInfo::IsDebugInfo(Object *object) {
   if (!object->IsFixedArray()) return false;
   FixedArray *arr = FixedArray::cast(object);
   Isolate *isolate = arr->GetIsolate();
   return arr->length() == kWasmDebugInfoNumEntries &&
          IsWasmObject(arr->get(kWasmDebugInfoWasmObj)) &&
          arr->get(kWasmDebugInfoWasmBytesHash)->IsNumber() &&
          (arr->get(kWasmDebugInfoFunctionByteOffsets)->IsUndefined(isolate) ||
-          arr->get(kWasmDebugInfoFunctionByteOffsets)->IsByteArray());
+          arr->get(kWasmDebugInfoFunctionByteOffsets)->IsByteArray()) &&
+         (arr->get(kWasmDebugInfoFunctionScripts)->IsUndefined(isolate) ||
+          arr->get(kWasmDebugInfoFunctionScripts)->IsFixedArray());
 }
 
 WasmDebugInfo *WasmDebugInfo::cast(Object *object) {
   DCHECK(IsDebugInfo(object));
   return reinterpret_cast<WasmDebugInfo *>(object);
 }
 
 JSObject *WasmDebugInfo::wasm_object() {
   return JSObject::cast(get(kWasmDebugInfoWasmObj));
 }
 
 bool WasmDebugInfo::SetBreakPoint(int byte_offset) {
   // TODO(clemensh): Implement this.
   return false;
 }
 
+Script *WasmDebugInfo::GetFunctionScript(Handle<WasmDebugInfo> debug_info,
+                                         int func_index) {
+  Isolate *isolate = debug_info->GetIsolate();
+  Object *scripts_obj = debug_info->get(kWasmDebugInfoFunctionScripts);
+  Handle<FixedArray> scripts;
+  if (scripts_obj->IsUndefined(isolate)) {
+    int num_functions = wasm::GetNumberOfFunctions(debug_info->wasm_object());
+    scripts = isolate->factory()->NewFixedArray(num_functions, TENURED);
+    debug_info->set(kWasmDebugInfoFunctionScripts, *scripts);
+  } else {
+    scripts = handle(FixedArray::cast(scripts_obj), isolate);
+  }
+
+  DCHECK(func_index >= 0 && func_index < scripts->length());
+  Object *script_or_undef = scripts->get(func_index);
+  if (!script_or_undef->IsUndefined(isolate)) {
+    return Script::cast(script_or_undef);
+  }
+
+  Handle<Script> script =
+      isolate->factory()->NewScript(isolate->factory()->empty_string());
+  scripts->set(func_index, *script);
+
+  script->set_type(Script::TYPE_WASM);
+
+  int func_bytes_len =
+      GetFunctionOffsetAndLength(debug_info, func_index).second;
+  Handle<FixedArray> line_ends = isolate->factory()->NewFixedArray(1, TENURED);
+  line_ends->set(0, Smi::FromInt(func_bytes_len));
+  line_ends->set_map(isolate->heap()->fixed_cow_array_map());
+  script->set_line_ends(*line_ends);
+
+  // TODO(clemensh): Register this new script at the debugger.
+
+  return *script;
+}
+
 Handle<String> WasmDebugInfo::DisassembleFunction(
     Handle<WasmDebugInfo> debug_info, int func_index) {
   std::ostringstream disassembly_os;
 
   {
     Vector<const uint8_t> bytes_vec = GetFunctionBytes(debug_info, func_index);
     DisallowHeapAllocation no_gc;
 
     base::AccountingAllocator allocator;
     bool ok = PrintAst(
@@ skipping 41 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;
 }