[wasm] Implement official wasm text format

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"
 #include "src/objects.h"
 #include "src/property-descriptor.h"
 #include "src/simulator.h"
 #include "src/snapshot/snapshot.h"
 #include "src/v8.h"
 
 #include "src/wasm/ast-decoder.h"
 #include "src/wasm/module-decoder.h"
 #include "src/wasm/wasm-js.h"
 #include "src/wasm/wasm-module.h"
 #include "src/wasm/wasm-objects.h"
 #include "src/wasm/wasm-result.h"
+#include "src/wasm/wasm-text.h"
 
 #include "src/compiler/wasm-compiler.h"
 
 using namespace v8::internal;
 using namespace v8::internal::wasm;
 namespace base = v8::base;
 
 #define TRACE(...)                                      \
   do {                                                  \
     if (FLAG_trace_wasm_instances) PrintF(__VA_ARGS__); \
@@ skipping 594 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
 
 Handle<JSArrayBuffer> wasm::NewArrayBuffer(Isolate* isolate, size_t size,
                                            bool enable_guard_regions) {
   if (size > (WasmModule::kV8MaxPages * WasmModule::kPageSize)) {
     // TODO(titzer): lift restriction on maximum memory allocated here.
     return Handle<JSArrayBuffer>::null();
   }
 
   enable_guard_regions = enable_guard_regions && kGuardRegionsSupported;
@@ skipping 1314 matching lines @@
 Handle<Script> wasm::GetScript(Handle<JSObject> instance) {
   WasmCompiledModule* compiled_module =
       WasmInstanceObject::cast(*instance)->get_compiled_module();
   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) {
+  if (func_index < 0 ||
+      static_cast<uint32_t>(func_index) >=
+          compiled_module->module()->functions.size())
+    return {};
+
   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);
-  CHECK(ok);
+  PrintWasmText(compiled_module->module(), static_cast<uint32_t>(func_index),
+                disassembly_os, &offset_table);
 
   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);
 }
 
@@ skipping 20 matching lines @@
     ModuleOrigin origin, Handle<Script> asm_js_script,
     const byte* asm_js_offset_tables_start,
     const byte* asm_js_offset_tables_end) {
   MaybeHandle<WasmModuleObject> nothing;
   ModuleResult result = DecodeWasmModule(isolate, start, end, false, origin);
   if (result.failed()) {
     if (result.val) delete result.val;
     thrower->CompileFailed("Wasm decoding failed", result);
     return nothing;
   }
+
   // The {module_wrapper} will take ownership of the {WasmModule} object,
   // and it will be destroyed when the GC reclaims the wrapper object.
   Handle<WasmModuleWrapper> module_wrapper =
       WasmModuleWrapper::New(isolate, const_cast<WasmModule*>(result.val));
 
   // 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;
@@ skipping 262 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 {};
 }