adjust for wasm-demo

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/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/compiler/wasm-compiler.h"
 
 namespace v8 {
 namespace internal {
 namespace wasm {
 
-#if DEBUG
 #define TRACE(...)                                    \
   do {                                                \
     if (FLAG_trace_wasm_decoder) PrintF(__VA_ARGS__); \
   } while (false)
-#else
-#define TRACE(...)
-#endif
 
 // The root of a decoded tree.
 struct Tree {
   LocalType type;     // tree type.
   uint32_t count;     // number of children.
   const byte* pc;     // start of the syntax tree.
   TFNode* node;       // node in the TurboFan graph.
   Tree* children[1];  // pointers to children.
 
   WasmOpcode opcode() const { return static_cast<WasmOpcode>(*pc); }
@@ skipping 194 matching lines @@
       case kExprSetLocal:
         return 1;
 
       case kExprIf:
       case kExprBrIf:
         return 2;
       case kExprIfElse:
       case kExprSelect:
         return 3;
 
-      case kExprBlock:
+      case kExprBlock: {
+        BlockCountOperand operand(this, pc);
+        return operand.count;
+      }
       case kExprLoop: {
-        BlockCountOperand operand(this, pc);
+        LoopCountOperand operand(this, pc);
         return operand.count;
       }
 
       case kExprCallFunction: {
         FunctionIndexOperand operand(this, pc);
         return static_cast<int>(
             function_env_->module->GetFunctionSignature(operand.index)
                 ->parameter_count());
       }
       case kExprCallIndirect: {
@@ skipping 27 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
       {
         MemoryAccessOperand operand(this, pc);
         return 1 + operand.length;
       }
-      case kExprBlock:
+      case kExprBlock: {
+        BlockCountOperand operand(this, pc);
+        return 1 + operand.length;
+      }
       case kExprLoop: {
-        BlockCountOperand operand(this, pc);
+        LoopCountOperand operand(this, pc);
         return 1 + operand.length;
       }
       case kExprBr:
       case kExprBrIf: {
         BreakDepthOperand operand(this, pc);
         return 1 + operand.length;
       }
       case kExprStoreGlobal:
       case kExprLoadGlobal: {
         GlobalIndexOperand operand(this, pc);
@@ skipping 275 matching lines @@
             Shift(kAstEnd, operand.count);
             // The break environment is the outer environment.
             SsaEnv* break_env = ssa_env_;
             PushBlock(break_env);
             SetEnv("block:start", Steal(break_env));
           }
           len = 1 + operand.length;
           break;
         }
         case kExprLoop: {
-          BlockCountOperand operand(this, pc_);
+          LoopCountOperand operand(this, pc_);
           if (operand.count < 1) {
             Leaf(kAstStmt);
           } else {
             Shift(kAstEnd, operand.count);
             // The break environment is the outer environment.
             SsaEnv* break_env = ssa_env_;
             PushBlock(break_env);
             SsaEnv* cont_env = Steal(break_env);
             // The continue environment is the inner environment.
             PrepareForLoop(cont_env);
@@ skipping 1049 matching lines @@
 
 BitVector* AnalyzeLoopAssignmentForTesting(Zone* zone, FunctionEnv* env,
                                            const byte* start, const byte* end) {
   LoopAssignmentAnalyzer analyzer(zone, env);
   return analyzer.Analyze(start, end);
 }
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8