[wasm] Fix OpcodeLength() calculation.

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"
@@ skipping 317 matching lines @@
 
       case kExprSetLocal:
       case kExprGetLocal: {
         LocalIndexOperand operand(this, pc);
         return 1 + operand.length;
       }
       case kExprBrTable: {
         BranchTableOperand operand(this, pc);
         return 1 + operand.length;
       }
+      case kExprI32Const: {

[binji, 2016/03/11 18:10:03]

oops, sorry about this. Didn't notice!

+        ImmI32Operand operand(this, pc);
+        return 1 + operand.length;
+      }
+      case kExprI64Const: {
+        ImmI64Operand operand(this, pc);
+        return 1 + operand.length;
+      }
       case kExprI8Const:
         return 2;
-      case kExprI32Const:
       case kExprF32Const:
         return 5;
-      case kExprI64Const:
       case kExprF64Const:
         return 9;
 
       default:
         return 1;
     }
   }
 };
 
 
@@ skipping 303 matching lines @@
           BlockCountOperand 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);
+            PrepareForLoop(pc_, cont_env);
             SetEnv("loop:start", Split(cont_env));
             if (ssa_env_->go()) ssa_env_->state = SsaEnv::kReached;
             PushBlock(cont_env);
             blocks_.back().stack_depth = -1;  // no production for inner block.
           }
           len = 1 + operand.length;
           break;
         }
         case kExprIf:
           Shift(kAstStmt, 2);
@@ skipping 778 matching lines @@
     } else if (tnode != fnode) {
       uint32_t count = builder_->InputCount(merge);
       TFNode** vals = builder_->Buffer(count);
       for (uint32_t j = 0; j < count - 1; j++) vals[j] = tnode;
       vals[count - 1] = fnode;
       return builder_->Phi(type, count, vals, merge);
     }
     return tnode;
   }
 
-  void BuildInfiniteLoop() {
-    if (ssa_env_->go()) {
-      PrepareForLoop(ssa_env_);
-      SsaEnv* cont_env = ssa_env_;
-      ssa_env_ = Split(ssa_env_);
-      ssa_env_->state = SsaEnv::kReached;
-      Goto(ssa_env_, cont_env);
+  void PrepareForLoop(const byte* pc, SsaEnv* env) {

[Mircea Trofin, 2016/03/11 17:15:41]

Looks like the change below is aesthetic only. What do we need pc for? 

[titzer, 2016/03/11 17:17:35]

Ah, an artifact of splitting this CL off. The next CL uses pc.

+    if (!env->go()) return;
+    env->state = SsaEnv::kMerged;
+    if (!builder_) return;
+
+    env->control = builder_->Loop(env->control);
+    env->effect = builder_->EffectPhi(1, &env->effect, env->control);
+    builder_->Terminate(env->effect, env->control);
+    // Conservatively introduce phis for all local variables.
+    for (int i = EnvironmentCount() - 1; i >= 0; i--) {
+      env->locals[i] =
+          builder_->Phi(local_type_vec_[i], 1, &env->locals[i], env->control);
     }
   }
 
-  void PrepareForLoop(SsaEnv* env) {
-    if (env->go()) {
-      env->state = SsaEnv::kMerged;
-      if (builder_) {
-        env->control = builder_->Loop(env->control);
-        env->effect = builder_->EffectPhi(1, &env->effect, env->control);
-        builder_->Terminate(env->effect, env->control);
-        for (int i = EnvironmentCount() - 1; i >= 0; i--) {
-          env->locals[i] = builder_->Phi(local_type_vec_[i], 1, &env->locals[i],
-                                         env->control);
-        }
-      }
-    }
-  }
-
   // Create a complete copy of the {from}.
   SsaEnv* Split(SsaEnv* from) {
     DCHECK_NOT_NULL(from);
     SsaEnv* result = reinterpret_cast<SsaEnv*>(zone_->New(sizeof(SsaEnv)));
     size_t size = sizeof(TFNode*) * EnvironmentCount();
     result->control = from->control;
     result->effect = from->effect;
     result->state = from->state == SsaEnv::kUnreachable ? SsaEnv::kUnreachable
                                                         : SsaEnv::kReached;
 
@@ skipping 95 matching lines @@
           // Unverified code might have an out-of-bounds index.
           assigned->Add(operand.index);
         }
         arity = 1;
         length = 1 + operand.length;
       } else {
         arity = OpcodeArity(pc);
         length = OpcodeLength(pc);
       }
 
+      TRACE("loop-assign module+%-6d %s func+%d: 0x%02x %s (len=%d)\n",
+            baserel(pc), indentation(), startrel(pc), opcode,
+            WasmOpcodes::OpcodeName(opcode), length);
       pc += length;
       arity_stack.push_back(arity);
       while (arity_stack.back() == 0) {
         arity_stack.pop_back();
         if (arity_stack.empty()) return assigned;  // reached end of loop
         arity_stack.back()--;
       }
     }
     return assigned;
   }
@@ skipping 93 matching lines @@
 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