[wasm] Attach loop assignment analysis behind a flag.

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"
@@ skipping 1336 matching lines @@
       error(p->pc(), p->last()->pc,
             "%s[%d] expected type %s, found %s of type %s",
             WasmOpcodes::OpcodeName(p->opcode()), p->index - 1,
             WasmOpcodes::TypeName(expected),
             WasmOpcodes::OpcodeName(p->last()->opcode()),
             WasmOpcodes::TypeName(p->last()->type));
     }
   }
 
   void SetEnv(const char* reason, SsaEnv* env) {
+#if DEBUG
     TRACE("  env = %p, block depth = %d, reason = %s", static_cast<void*>(env),
           static_cast<int>(blocks_.size()), reason);
     if (FLAG_trace_wasm_decoder && env && env->control) {
       TRACE(", control = ");
       compiler::WasmGraphBuilder::PrintDebugName(env->control);
     }
     TRACE("\n");
+#endif
     ssa_env_ = env;
     if (builder_) {
       builder_->set_control_ptr(&env->control);
       builder_->set_effect_ptr(&env->effect);
     }
   }
 
   void Goto(SsaEnv* from, SsaEnv* to) {
     DCHECK_NOT_NULL(to);
     if (!from->go()) return;
@@ skipping 85 matching lines @@
   }
 
   void PrepareForLoop(const byte* pc, SsaEnv* env) {
     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);
+    if (FLAG_wasm_loop_assignment_analysis) {
+      BitVector* assigned = AnalyzeLoopAssignment(pc);
+      if (assigned != nullptr) {
+        // Only introduce phis for variables assigned in this loop.
+        for (int i = EnvironmentCount() - 1; i >= 0; i--) {
+          if (!assigned->Contains(i)) continue;
+          env->locals[i] = builder_->Phi(local_type_vec_[i], 1, &env->locals[i],
+                                         env->control);
+        }
+        return;
+      }
+    }
+
     // 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);
     }
   }
 
   // Create a complete copy of the {from}.
   SsaEnv* Split(SsaEnv* from) {
     DCHECK_NOT_NULL(from);
@@ skipping 88 matching lines @@
     // Keep a stack to model the nesting of expressions.
     std::vector<int> arity_stack;
     arity_stack.push_back(OpcodeArity(pc));
     pc += OpcodeLength(pc);
 
     // Iteratively process all AST nodes nested inside the loop.
     while (pc < limit_) {
       WasmOpcode opcode = static_cast<WasmOpcode>(*pc);
       int arity = 0;
       int length = 1;
+      int assigned_index = -1;
       if (opcode == kExprSetLocal) {
         LocalIndexOperand operand(this, pc);
         if (assigned->length() > 0 &&
             static_cast<int>(operand.index) < assigned->length()) {
           // Unverified code might have an out-of-bounds index.
+          // Ignore out-of-bounds indices, as the main verification will fail.
           assigned->Add(operand.index);
+          assigned_index = 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);
+      TRACE("loop-assign module+%-6d %s func+%d: 0x%02x %s", baserel(pc),
+            indentation(), startrel(pc), opcode,
+            WasmOpcodes::OpcodeName(opcode));
+
+      if (assigned_index >= 0) {
+        TRACE(" (assigned local #%d)\n", assigned_index);
+      } else {
+        TRACE("\n");
+      }
+
       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