[inspector] Introduce translation of wasm frames

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 579 matching lines @@
   WasmModule* module = compiled_module->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)};
 }
 
+Vector<const uint8_t> GetFunctionBytes(
+    Handle<WasmCompiledModule> compiled_module, int func_index) {
+  int offset, length;
+  std::tie(offset, length) =
+      GetFunctionOffsetAndLength(compiled_module, func_index);
+  return Vector<const uint8_t>(
+      compiled_module->module_bytes()->GetChars() + offset, length);
+}
+
 }  // namespace
 
 const char* wasm::SectionName(WasmSectionCode code) {
   switch (code) {
     case kUnknownSectionCode:
       return "Unknown";
     case kTypeSectionCode:
       return "Type";
     case kImportSectionCode:
       return "Import";
@@ skipping 1264 matching lines @@
   return compiled_module->has_asm_js_offset_tables();
 }
 
 Handle<Script> wasm::GetScript(Handle<JSObject> instance) {
   DCHECK(IsWasmInstance(*instance));
   WasmCompiledModule* compiled_module = GetCompiledModule(*instance);
   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);
+  DCHECK(ok);

[titzer, 2016/11/16 14:23:59]

Bah, just make it a CHECK() so you don't need the USE() below. That does mean we
will crash in production, though.

[Clemens Hammacher, 2016/11/16 15:21:19]

Done.
We only call it for already compiled functions, so it should never crash anyway.
But I guess the runtime overhead for a CHECK is acceptable ;)

+  USE(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<SeqOneByteString> wasm::GetWasmBytes(Handle<JSObject> object) {
   return Handle<WasmInstanceObject>::cast(object)
       ->get_compiled_module()
       ->module_bytes();
@@ skipping 285 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 {};
 }