[wasm] Add --trace-wasm-ast-start and --trace-wasm-ast-end options and improve tracing.

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/signature.h"
 
 #include "src/bit-vector.h"
 #include "src/flags.h"
 #include "src/handles.h"
 #include "src/zone-containers.h"
 
 #include "src/wasm/ast-decoder.h"
 #include "src/wasm/decoder.h"
 #include "src/wasm/wasm-module.h"
 #include "src/wasm/wasm-opcodes.h"
 
+#include "src/ostreams.h"
+
 #include "src/compiler/wasm-compiler.h"
 
 namespace v8 {
 namespace internal {
 namespace wasm {
 
 #if DEBUG
 #define TRACE(...)                                    \
   do {                                                \
     if (FLAG_trace_wasm_decoder) PrintF(__VA_ARGS__); \
@@ skipping 367 matching lines @@
       if (trees_.size() == 0) {
         if (sig_->return_count() > 0) {
           error(start_, "no trees created");
         }
       } else {
         tree = trees_[0];
       }
     }
 
     if (ok()) {
-      if (FLAG_trace_wasm_ast) {
-        FunctionBody body = {module_, sig_, base_, start_, end_};
-        PrintAst(body);
-      }
       TRACE("wasm-decode ok\n");
     } else {
       TRACE("wasm-error module+%-6d func+%d: %s\n\n", baserel(error_pc_),
             startrel(error_pc_), error_msg_.get());
     }
 
     return toResult(tree);
   }
 
   std::vector<LocalType>* DecodeLocalDeclsForTesting() {
@@ skipping 1264 matching lines @@
   return decoder.OpcodeLength(pc);
 }
 
 int OpcodeArity(ModuleEnv* module, FunctionSig* sig, const byte* pc,
                 const byte* end) {
   WasmDecoder decoder(module, sig, pc, end);
   return decoder.OpcodeArity(pc);
 }
 
 void PrintAst(FunctionBody& body) {
-  WasmDecoder decoder(body.module, body.sig, body.start, body.end);
-  const byte* pc = body.start;
+  Zone zone;
+  SR_WasmDecoder decoder(&zone, nullptr, body);
+
+  OFStream os(stdout);
+
+  // Print the function signature.
+  if (body.sig) {
+    os << "// signature: " << *body.sig << std::endl;
+  }
+
+  // Print the local declarations.
+  std::vector<LocalType>* decls = decoder.DecodeLocalDeclsForTesting();
+  const byte* pc = decoder.pc();
+  if (body.start != decoder.pc()) {
+    printf("// locals:");

[ahaas, 2016/03/15 14:24:55]

Why do you mix streams and printf here?

[titzer, 2016/03/15 17:18:04]

Meh, it's a mix because of some 0x%02x things below.

+    size_t pos = 0;
+    while (pos < decls->size()) {
+      LocalType type = decls->at(pos++);
+      size_t count = 1;
+      while (pos < decls->size() && decls->at(pos) == type) {
+        pos++;
+        count++;
+      }
+
+      os << " " << count << " " << WasmOpcodes::TypeName(type);
+    }
+    os << std::endl;
+
+    for (const byte* locals = body.start; locals < pc; locals++) {
+      printf(" 0x%02x,", *locals);
+    }
+    printf("\n");
+  }
+  delete decls;
+
+  printf("// body: \n");
   std::vector<int> arity_stack;
   while (pc < body.end) {
     int arity = decoder.OpcodeArity(pc);
     size_t length = decoder.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]);
     }
+
+    if (body.module) {
+      switch (opcode) {
+        case kExprCallIndirect: {
+          SignatureIndexOperand operand(&decoder, pc);
+          if (decoder.Validate(pc, operand)) {
+            os << " // sig #" << operand.index << ": " << *operand.sig;
+          }
+          break;
+        }
+        case kExprCallImport: {
+          ImportIndexOperand operand(&decoder, pc);
+          if (decoder.Validate(pc, operand)) {
+            os << " // import #" << operand.index << ": " << *operand.sig;
+          }
+          break;
+        }
+        case kExprCallFunction: {
+          FunctionIndexOperand operand(&decoder, pc);
+          if (decoder.Validate(pc, operand)) {
+            os << " // function #" << operand.index << ": " << *operand.sig;
+          }
+          break;
+        }
+        default:
+          break;
+      }
+    }
+
     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()--;
     }
   }
 }
 
 BitVector* AnalyzeLoopAssignmentForTesting(Zone* zone, size_t num_locals,
                                            const byte* start, const byte* end) {
   FunctionBody body = {nullptr, nullptr, nullptr, start, end};
   SR_WasmDecoder decoder(zone, nullptr, body);
   return decoder.AnalyzeLoopAssignmentForTesting(start, num_locals);
 }
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8