[wasm] Add utilities to print out WASM ast directly from the bytes.

src/wasm/ast-decoder.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 "src/base/platform/elapsed-timer.h"
 #include "src/signature.h"
 
 #include "src/flags.h"
 #include "src/handles.h"
 #include "src/zone-containers.h"
@@ skipping 133 matching lines @@
       if (trees_.size() == 0) {
         if (function_env_->sig->return_count() > 0) {
           error(start_, "no trees created");
         }
       } else {
         tree = trees_[0];
       }
     }
 
     if (ok()) {
+      if (FLAG_trace_wasm_ast) {
+        PrintAst(function_env, pc, end);
+      }
       if (FLAG_trace_wasm_decode_time) {
         double ms = decode_timer.Elapsed().InMillisecondsF();
-        PrintF(" - decoding took %0.3f ms\n", ms);
+        PrintF("wasm-decode ok (%0.3f ms)\n\n", ms);
+      } else {
+        TRACE("wasm-decode ok\n\n");
       }
-      TRACE("wasm-decode ok\n\n");
     } else {
       TRACE("wasm-error module+%-6d func+%d: %s\n\n", baserel(error_pc_),
             startrel(error_pc_), error_msg_.get());
     }
+
     return toResult(tree);
   }
 
  private:
   static const size_t kErrorMsgSize = 128;
 
   Zone* zone_;
   TFBuilder* builder_;
   const byte* base_;
   TreeResult result_;
@@ skipping 1297 matching lines @@
   }
 }
 
 
 int OpcodeLength(const byte* pc) {
   switch (static_cast<WasmOpcode>(*pc)) {
 #define DECLARE_OPCODE_CASE(name, opcode, sig) case kExpr##name:
     FOREACH_LOAD_MEM_OPCODE(DECLARE_OPCODE_CASE)
     FOREACH_STORE_MEM_OPCODE(DECLARE_OPCODE_CASE)
 #undef DECLARE_OPCODE_CASE
-
+    {
+      // Loads and stores have an optional offset.
+      byte bitfield = pc[1];
+      if (MemoryAccess::OffsetField::decode(bitfield)) {
+        int length;
+        uint32_t result = 0;
+        ReadUnsignedLEB128Operand(pc + 2, pc + 7, &length, &result);
+        return 2 + length;
+      }
+      return 2;
+    }
     case kExprI8Const:
     case kExprBlock:
     case kExprLoop:
     case kExprBr:
     case kExprBrIf:
       return 2;
     case kExprI32Const:
     case kExprF32Const:
       return 5;
     case kExprI64Const:
@@ skipping 80 matching lines @@
 
       FOREACH_LOAD_MEM_OPCODE(DECLARE_OPCODE_CASE)
       FOREACH_STORE_MEM_OPCODE(DECLARE_OPCODE_CASE)
       FOREACH_MISC_MEM_OPCODE(DECLARE_OPCODE_CASE)
       FOREACH_SIMPLE_OPCODE(DECLARE_OPCODE_CASE)
 #undef DECLARE_OPCODE_CASE
   }
   UNREACHABLE();
   return 0;
 }
+
+
+void PrintAst(FunctionEnv* env, const byte* start, const byte* end) {
+  const byte* pc = start;
+  std::vector<int> arity_stack;
+  while (pc < end) {
+    int arity = OpcodeArity(env, pc);
+    size_t length = OpcodeLength(pc);
+
+    for (auto arity : arity_stack) {
+      printf("  ");
+      USE(arity);
+    }
+
+    WasmOpcode opcode = static_cast<WasmOpcode>(*pc);
+    printf("k%s,", WasmOpcodes::OpcodeName(opcode));
+
+    for (size_t i = 1; i < length; i++) {
+      printf(" 0x%02x,", pc[i]);
+    }
+    pc += length;
+    printf("\n");
+
+    arity_stack.push_back(arity);
+    while (arity_stack.back() == 0) {
+      arity_stack.pop_back();
+      if (arity_stack.empty()) break;
+      arity_stack.back()--;
+    }
+  }
+}
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8