Revert "[v8][wasm] Handles finally in try/finally blocks."

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 50 matching lines @@
   }
 };
 
 // An entry on the value stack.
 struct Value {
   const byte* pc;
   TFNode* node;
   LocalType type;
 };
 
-struct Control;
-
-// IncomingBranch is used by exception handling code for managing finally's.
-struct IncomingBranch {
-  int32_t token_value;
-  Control* target;
-  Value val;
-};
-
-// Auxiliary data for exception handling. Most scopes don't need any of this so
-// we group everything into a separate struct.
-struct TryInfo : public ZoneObject {
-  SsaEnv* catch_env;       // catch environment (only for try with catch).
-  SsaEnv* finish_try_env;  // the environment where a try with finally lives.
-  ZoneVector<IncomingBranch> incoming_branches;
-  TFNode* token;
-  bool has_handled_finally;
-
-  TryInfo(Zone* zone, SsaEnv* c, SsaEnv* f)
-      : catch_env(c),
-        finish_try_env(f),
-        incoming_branches(zone),
-        token(nullptr),
-        has_handled_finally(false) {}
-};
-
 // An entry on the control stack (i.e. if, block, loop).
 struct Control {
   const byte* pc;
-  int stack_depth;       // stack height at the beginning of the construct.
-  SsaEnv* end_env;       // end environment for the construct.
-  SsaEnv* false_env;     // false environment (only for if).
-  TryInfo* try_info;     // exception handling stuff. See TryInfo above.
-  int32_t prev_finally;  // previous control (on stack) that has a finally.
-  TFNode* node;          // result node for the construct.
-  LocalType type;        // result type for the construct.
-  bool is_loop;          // true if this is the inner label of a loop.
+  int stack_depth;         // stack height at the beginning of the construct.
+  SsaEnv* end_env;         // end environment for the construct.
+  SsaEnv* false_env;       // false environment (only for if).
+  SsaEnv* catch_env;       // catch environment (only for try with catch).
+  SsaEnv* finish_try_env;  // the environment where a try with finally lives.
+  TFNode* node;            // result node for the construct.
+  LocalType type;          // result type for the construct.
+  bool is_loop;            // true if this is the inner label of a loop.
 
   bool is_if() const { return *pc == kExprIf; }
 
   bool is_try() const {
     return *pc == kExprTryCatch || *pc == kExprTryCatchFinally ||
            *pc == kExprTryFinally;
   }
 
   bool has_catch() const {
     return *pc == kExprTryCatch || *pc == kExprTryCatchFinally;
   }
 
   bool has_finally() const {
     return *pc == kExprTryCatchFinally || *pc == kExprTryFinally;
   }
 
   // Named constructors.
-  static Control Block(const byte* pc, int stack_depth,
-                       int32_t most_recent_finally, SsaEnv* end_env) {
-    return {pc,      stack_depth, end_env,
-            nullptr, nullptr,     most_recent_finally,
-            nullptr, kAstEnd,     false};
+  static Control Block(const byte* pc, int stack_depth, SsaEnv* end_env) {
+    return {pc,      stack_depth, end_env, nullptr, nullptr,
+            nullptr, nullptr,     kAstEnd, false};
   }
 
-  static Control If(const byte* pc, int stack_depth,
-                    int32_t most_recent_finally, SsaEnv* end_env,
+  static Control If(const byte* pc, int stack_depth, SsaEnv* end_env,
                     SsaEnv* false_env) {
-    return {pc,        stack_depth, end_env,
-            false_env, nullptr,     most_recent_finally,
-            nullptr,   kAstStmt,    false};
+    return {pc,      stack_depth, end_env,  false_env, nullptr,
+            nullptr, nullptr,     kAstStmt, false};
   }
 
-  static Control Loop(const byte* pc, int stack_depth,
-                      int32_t most_recent_finally, SsaEnv* end_env) {
-    return {pc,      stack_depth, end_env,
-            nullptr, nullptr,     most_recent_finally,
-            nullptr, kAstEnd,     true};
+  static Control Loop(const byte* pc, int stack_depth, SsaEnv* end_env) {
+    return {pc,      stack_depth, end_env, nullptr, nullptr,
+            nullptr, nullptr,     kAstEnd, true};
   }
 
-  static Control Try(const byte* pc, int stack_depth,
-                     int32_t most_recent_finally, Zone* zone, SsaEnv* end_env,
+  static Control Try(const byte* pc, int stack_depth, SsaEnv* end_env,
                      SsaEnv* catch_env, SsaEnv* finish_try_env) {
-    return {pc,
-            stack_depth,
-            end_env,
-            nullptr,
-            new (zone) TryInfo(zone, catch_env, finish_try_env),
-            most_recent_finally,
-            nullptr,
-            kAstEnd,
-            false};
+    return {pc,      stack_depth, end_env, nullptr, catch_env, finish_try_env,
+            nullptr, kAstEnd,     false};
   }
 };
 
 // Macros that build nodes only if there is a graph and the current SSA
 // environment is reachable from start. This avoids problems with malformed
 // TF graphs when decoding inputs that have unreachable code.
 #define BUILD(func, ...) (build() ? builder_->func(__VA_ARGS__) : nullptr)
 #define BUILD0(func) (build() ? builder_->func() : nullptr)
 
 // Generic Wasm bytecode decoder with utilities for decoding operands,
@@ skipping 294 matching lines @@
 #define DECLARE_OPCODE_CASE(name, opcode, sig) case kExpr##name:
         FOREACH_SIMD_0_OPERAND_OPCODE(DECLARE_OPCODE_CASE) { return 2; }
         FOREACH_SIMD_1_OPERAND_OPCODE(DECLARE_OPCODE_CASE) { return 3; }
 #undef DECLARE_OPCODE_CASE
       default:
         return 1;
     }
   }
 };
 
-static const int32_t kFirstFinallyToken = 1;
-static const int32_t kFallthroughToken = 0;
-static const int32_t kNullFinallyToken = -1;
-
 // The full WASM decoder for bytecode. Both verifies bytecode and generates
 // a TurboFan IR graph.
 class WasmFullDecoder : public WasmDecoder {
  public:
   WasmFullDecoder(Zone* zone, TFBuilder* builder, const FunctionBody& body)
       : WasmDecoder(body.module, body.sig, body.start, body.end),
         zone_(zone),
         builder_(builder),
         base_(body.base),
         local_type_vec_(zone),
         stack_(zone),
-        control_(zone),
-        most_recent_finally_(-1),
-        finally_token_val_(kFirstFinallyToken) {
+        control_(zone) {
     local_types_ = &local_type_vec_;
   }
 
   bool Decode() {
     base::ElapsedTimer decode_timer;
     if (FLAG_trace_wasm_decode_time) {
       decode_timer.Start();
     }
     stack_.clear();
     control_.clear();
@@ skipping 72 matching lines @@
   Zone* zone_;
   TFBuilder* builder_;
   const byte* base_;
 
   SsaEnv* ssa_env_;
 
   ZoneVector<LocalType> local_type_vec_;  // types of local variables.
   ZoneVector<Value> stack_;               // stack of values.
   ZoneVector<Control> control_;           // stack of blocks, loops, and ifs.
 
-  int32_t most_recent_finally_;
-  int32_t finally_token_val_;
-
-  int32_t FallthroughTokenForFinally() {
-    // Any number < kFirstFinallyToken would work.
-    return kFallthroughToken;
-  }
-
-  int32_t NewTokenForFinally() { return finally_token_val_++; }
-
   inline bool build() { return builder_ && ssa_env_->go(); }
 
   void InitSsaEnv() {
     TFNode* start = nullptr;
     SsaEnv* ssa_env = reinterpret_cast<SsaEnv*>(zone_->New(sizeof(SsaEnv)));
     size_t size = sizeof(TFNode*) * EnvironmentCount();
     ssa_env->state = SsaEnv::kReached;
     ssa_env->locals =
         size > 0 ? reinterpret_cast<TFNode**>(zone_->New(size)) : nullptr;
 
@@ skipping 176 matching lines @@
               error(pc_, "catch does not match a any try");
               break;
             }
 
             Control* c = &control_.back();
             if (!c->has_catch()) {
               error(pc_, "catch does not match a try with catch");
               break;
             }
 
-            if (c->try_info->catch_env == nullptr) {
+            if (c->catch_env == nullptr) {
               error(pc_, "catch already present for try with catch");
               break;
             }
 
             Goto(ssa_env_, c->end_env);
 
-            SsaEnv* catch_env = c->try_info->catch_env;
-            c->try_info->catch_env = nullptr;
+            SsaEnv* catch_env = c->catch_env;
+            c->catch_env = nullptr;
             SetEnv("catch:begin", catch_env);
 
             if (Validate(pc_, operand)) {
               // TODO(jpp): figure out how thrown value is propagated. It is
               // unlikely to be a value on the stack.
               if (ssa_env_->locals) {
                 ssa_env_->locals[operand.index] = nullptr;
               }
             }
 
             PopUpTo(c->stack_depth);
 
             break;
           }
           case kExprFinally: {
             CHECK_PROTOTYPE_OPCODE(wasm_eh_prototype);
             if (control_.empty()) {
               error(pc_, "finally does not match a any try");
               break;
             }
 
             Control* c = &control_.back();
-            if (c->has_catch() && c->try_info->catch_env != nullptr) {
+            if (c->has_catch() && c->catch_env != nullptr) {
               error(pc_, "missing catch for try with catch and finally");
               break;
             }
 
             if (!c->has_finally()) {
               error(pc_, "finally does not match a try with finally");
               break;
             }
 
-            if (c->try_info->finish_try_env == nullptr) {
+            if (c->finish_try_env == nullptr) {
               error(pc_, "finally already present for try with finally");
               break;
             }
 
             // ssa_env_ is either the env for either the try or the catch, but
             // it does not matter: either way we need to direct the control flow
             // to the end_env, which is the env for the finally.
-            // c->try_info->finish_try_env is the the environment enclosing the
-            // try block.
-            const bool has_fallthrough = ssa_env_->go();
-            Value val = PopUpTo(c->stack_depth);
-            if (has_fallthrough) {
-              MergeInto(c->end_env, &c->node, &c->type, val);
-              MergeFinallyToken(ssa_env_, c, FallthroughTokenForFinally());
-            }
+            // c->finish_try_env is the the environment enclosing the try block.
+            Goto(ssa_env_, c->end_env);
+
+            PopUpTo(c->stack_depth);
 
             // The current environment becomes end_env, and finish_try_env
             // becomes the new end_env. This ensures that any control flow
             // leaving a try block up to now will do so by branching to the
             // finally block. Setting the end_env to be finish_try_env ensures
             // that kExprEnd below can handle the try block as it would any
             // other block construct.
             SsaEnv* finally_env = c->end_env;
-            c->end_env = c->try_info->finish_try_env;
+            c->end_env = c->finish_try_env;
             SetEnv("finally:begin", finally_env);
-            c->try_info->finish_try_env = nullptr;
+            c->finish_try_env = nullptr;
 
-            if (has_fallthrough) {
-              LocalType c_type = c->type;
-              if (c->node == nullptr) {
-                c_type = kAstStmt;
-              }
-              Push(c_type, c->node);
-            }
-
-            c->try_info->has_handled_finally = true;
-            // There's no more need to keep the current control scope in the
-            // finally chain as no more predecessors will be added to c.
-            most_recent_finally_ = c->prev_finally;
             break;
           }
           case kExprLoop: {
             // The break environment is the outer environment.
             SsaEnv* break_env = ssa_env_;
             PushBlock(break_env);
             SsaEnv* finish_try_env = Steal(break_env);
             // The continue environment is the inner environment.
             PrepareForLoop(pc_, finish_try_env);
             SetEnv("loop:start", Split(finish_try_env));
@@ skipping 32 matching lines @@
             }
             Value val = PopUpTo(c->stack_depth);
             MergeInto(c->end_env, &c->node, &c->type, val);
             // Switch to environment for false branch.
             SetEnv("if_else:false", c->false_env);
             c->false_env = nullptr;  // record that an else is already seen
             break;
           }
           case kExprEnd: {
             if (control_.empty()) {
-              error(pc_, "end does not match any if, try, or block");
+              error(pc_, "end does not match any if or block");
               break;
             }
             const char* name = "block:end";
             Control* c = &control_.back();
             Value val = PopUpTo(c->stack_depth);
             if (c->is_loop) {
               // Loops always push control in pairs.
-              PopControl();
+              control_.pop_back();
               c = &control_.back();
               name = "loop:end";
             } else if (c->is_if()) {
               if (c->false_env != nullptr) {
                 // End the true branch of a one-armed if.
                 Goto(c->false_env, c->end_env);
                 val = {val.pc, nullptr, kAstStmt};
                 name = "if:merge";
               } else {
                 // End the false branch of a two-armed if.
                 name = "if_else:merge";
               }
             } else if (c->is_try()) {
               name = "try:end";
 
+              // try blocks do not yield a value.
+              val = {val.pc, nullptr, kAstStmt};
+
               // validate that catch/finally were seen.
-              if (c->try_info->catch_env != nullptr) {
+              if (c->catch_env != nullptr) {
                 error(pc_, "missing catch in try with catch");
                 break;
               }
 
-              if (c->try_info->finish_try_env != nullptr) {
+              if (c->finish_try_env != nullptr) {
                 error(pc_, "missing finally in try with finally");
                 break;
               }
-
-              if (c->has_finally() && ssa_env_->go()) {
-                DispatchToTargets(c, val);
-              }
             }
 
             if (ssa_env_->go()) {
-              // Adds a fallthrough edge to the next control block.
               MergeInto(c->end_env, &c->node, &c->type, val);
             }
             SetEnv(name, c->end_env);
             stack_.resize(c->stack_depth);
             Push(c->type, c->node);
-            PopControl();
+            control_.pop_back();
             break;
           }
           case kExprSelect: {
             Value cond = Pop(2, kAstI32);
             Value fval = Pop();
             Value tval = Pop();
             if (tval.type == kAstStmt || tval.type != fval.type) {
               if (tval.type != kAstEnd && fval.type != kAstEnd) {
                 error(pc_, "type mismatch in select");
                 break;
@@ skipping 13 matching lines @@
             } else {
               Push(tval.type, nullptr);
             }
             break;
           }
           case kExprBr: {
             BreakDepthOperand operand(this, pc_);
             Value val = {pc_, nullptr, kAstStmt};
             if (operand.arity) val = Pop();
             if (Validate(pc_, operand, control_)) {
-              BreakTo(operand, val);
+              BreakTo(operand.target, val);
             }
             len = 1 + operand.length;
             Push(kAstEnd, nullptr);
             break;
           }
           case kExprBrIf: {
             BreakDepthOperand operand(this, pc_);
             Value cond = Pop(operand.arity, kAstI32);
             Value val = {pc_, nullptr, kAstStmt};
             if (operand.arity == 1) val = Pop();
             if (ok() && Validate(pc_, operand, control_)) {
               SsaEnv* fenv = ssa_env_;
               SsaEnv* tenv = Split(fenv);
               fenv->SetNotMerged();
               BUILD(Branch, cond.node, &tenv->control, &fenv->control);
               ssa_env_ = tenv;
-              BreakTo(operand, val);
+              BreakTo(operand.target, val);
               ssa_env_ = fenv;
             }
             len = 1 + operand.length;
             Push(kAstStmt, nullptr);
             break;
           }
           case kExprBrTable: {
             BranchTableOperand operand(this, pc_);
             if (Validate(pc_, operand, control_.size())) {
               Value key = Pop(operand.arity, kAstI32);
@@ skipping 316 matching lines @@
       return nullptr;
     }
   }
 
   LocalType GetReturnType(FunctionSig* sig) {
     return sig->return_count() == 0 ? kAstStmt : sig->GetReturn();
   }
 
   void PushBlock(SsaEnv* end_env) {
     const int stack_depth = static_cast<int>(stack_.size());
-    control_.emplace_back(
-        Control::Block(pc_, stack_depth, most_recent_finally_, end_env));
+    control_.emplace_back(Control::Block(pc_, stack_depth, end_env));
   }
 
   void PushLoop(SsaEnv* end_env) {
     const int stack_depth = static_cast<int>(stack_.size());
-    control_.emplace_back(
-        Control::Loop(pc_, stack_depth, most_recent_finally_, end_env));
+    control_.emplace_back(Control::Loop(pc_, stack_depth, end_env));
   }
 
   void PushIf(SsaEnv* end_env, SsaEnv* false_env) {
     const int stack_depth = static_cast<int>(stack_.size());
-    control_.emplace_back(Control::If(pc_, stack_depth, most_recent_finally_,
-                                      end_env, false_env));
+    control_.emplace_back(Control::If(pc_, stack_depth, end_env, false_env));
   }
 
   void PushTry(SsaEnv* end_env, SsaEnv* catch_env, SsaEnv* finish_try_env) {
     const int stack_depth = static_cast<int>(stack_.size());
-    control_.emplace_back(Control::Try(pc_, stack_depth, most_recent_finally_,
-                                       zone_, end_env, catch_env,
-                                       finish_try_env));
-    if (control_.back().has_finally()) {
-      most_recent_finally_ = static_cast<uint32_t>(control_.size() - 1);
-    }
-  }
-
-  void PopControl() {
-    const Control& c = control_.back();
-    most_recent_finally_ = c.prev_finally;
-    control_.pop_back();
-    // No more accesses to (danging pointer) c
+    control_.emplace_back(
+        Control::Try(pc_, stack_depth, end_env, catch_env, finish_try_env));
   }
 
   int DecodeLoadMem(LocalType type, MachineType mem_type) {
     MemoryAccessOperand operand(this, pc_,
                                 ElementSizeLog2Of(mem_type.representation()));
 
     Value index = Pop(0, kAstI32);
     TFNode* node = BUILD(LoadMem, type, mem_type, index.node, operand.offset,
                          operand.alignment, position());
     Push(type, node);
@@ skipping 36 matching lines @@
           TFNode* node = BUILD(SimdOp, opcode, inputs);
           Push(GetReturnType(sig), node);
         } else {
           error(pc_, pc_, "invalid simd opcode");
         }
       }
     }
     return len;
   }
 
-  void DispatchToTargets(Control* next_block, const Value& val) {
-    const ZoneVector<IncomingBranch>& incoming_branches =
-        next_block->try_info->incoming_branches;
-    // Counts how many successors are not current control block.
-    uint32_t targets = 0;
-    for (const auto& path_token : incoming_branches) {
-      if (path_token.target != next_block) ++targets;
-    }
-
-    if (targets == 0) {
-      // Nothing to do here: the control flow should just fall
-      // through to the next control block.
-      return;
-    }
-
-    TFNode* sw = BUILD(Switch, static_cast<uint32_t>(targets + 1),
-                       next_block->try_info->token);
-
-    SsaEnv* break_env = ssa_env_;
-    SsaEnv* copy = Steal(break_env);
-    for (uint32_t ii = 0; ii < incoming_branches.size(); ++ii) {
-      Control* t = incoming_branches[ii].target;
-      if (t != next_block) {
-        const int32_t token_value = incoming_branches[ii].token_value;
-        ssa_env_ = Split(copy);
-        ssa_env_->control = BUILD(IfValue, token_value, sw);
-        MergeInto(t->end_env, &t->node, &t->type, incoming_branches[ii].val);
-        // We only need to merge the finally token if t is both a
-        // try-with-finally and its finally hasn't yet been found
-        // in the instruction stream. Otherwise we just need to
-        // branch to t.
-        if (t->has_finally() && !t->try_info->has_handled_finally) {
-          MergeFinallyToken(ssa_env_, t, token_value);
-        }
-      }
-    }
-    ssa_env_ = Split(copy);
-    ssa_env_->control = BUILD(IfDefault, sw);
-    MergeInto(next_block->end_env, &next_block->node, &next_block->type, val);
-    // Not a finally env; no fallthrough token.
-
-    ssa_env_ = break_env;
-  }
-
   void DoReturn() {
     int count = static_cast<int>(sig_->return_count());
     TFNode** buffer = nullptr;
     if (build()) buffer = builder_->Buffer(count);
 
     // Pop return values off the stack in reverse order.
     for (int i = count - 1; i >= 0; i--) {
       Value val = Pop(i, sig_->GetReturn(i));
       if (buffer) buffer[i] = val.node;
     }
@@ skipping 46 matching lines @@
       return val;
     }
   }
 
   int baserel(const byte* ptr) {
     return base_ ? static_cast<int>(ptr - base_) : 0;
   }
 
   int startrel(const byte* ptr) { return static_cast<int>(ptr - start_); }
 
-  Control* BuildFinallyChain(const BreakDepthOperand& operand, const Value& val,
-                             int32_t* token) {
-    DCHECK_LE(operand.depth, control_.size());
-    const int32_t target_index =
-        static_cast<uint32_t>(control_.size() - operand.depth - 1);
-
-    if (most_recent_finally_ == kNullFinallyToken ||  // No finallies.
-        most_recent_finally_ < target_index) {  // Does not cross any finally.
-      *token = kNullFinallyToken;
-      return operand.target;
-    }
-
-    Control* previous_control = &control_[most_recent_finally_];
-    *token = NewTokenForFinally();
-
-    for (int32_t ii = previous_control->prev_finally; ii >= target_index;
-         ii = previous_control->prev_finally) {
-      Control* current_finally = &control_[ii];
-
-      DCHECK(!current_finally->try_info->has_handled_finally);
-      previous_control->try_info->incoming_branches.push_back(
-          {*token, current_finally, val});
-      previous_control = current_finally;
-    }
-
-    if (operand.target != previous_control) {
-      DCHECK_NOT_NULL(previous_control);
-      DCHECK(previous_control->has_finally());
-      DCHECK_NE(*token, kNullFinallyToken);
-      previous_control->try_info->incoming_branches.push_back(
-          {*token, operand.target, val});
-    }
-
-    return &control_[most_recent_finally_];
-  }
-
-  void BreakTo(const BreakDepthOperand& operand, const Value& val) {
-    int32_t finally_token;
-    Control* block = BuildFinallyChain(operand, val, &finally_token);
-
+  void BreakTo(Control* block, Value& val) {
     if (block->is_loop) {
       // This is the inner loop block, which does not have a value.
       Goto(ssa_env_, block->end_env);
     } else {
       // Merge the value into the production for the block.
       MergeInto(block->end_env, &block->node, &block->type, val);
     }
-
-    if (finally_token != kNullFinallyToken) {
-      MergeFinallyToken(ssa_env_, block, finally_token);
-    }
   }
 
-  void MergeInto(SsaEnv* target, TFNode** node, LocalType* type,
-                 const Value& val) {
+  void MergeInto(SsaEnv* target, TFNode** node, LocalType* type, Value& val) {
     if (!ssa_env_->go()) return;
     DCHECK_NE(kAstEnd, val.type);
 
     bool first = target->state == SsaEnv::kUnreachable;
     Goto(ssa_env_, target);
 
     if (first) {
       // first merge to this environment; set the type and the node.
       *type = val.type;
       *node = val.node;
@@ skipping 36 matching lines @@
       PrintF("\n");
     }
 #endif
     ssa_env_ = env;
     if (builder_) {
       builder_->set_control_ptr(&env->control);
       builder_->set_effect_ptr(&env->effect);
     }
   }
 
-  void MergeFinallyToken(SsaEnv*, Control* to, int32_t new_token) {
-    DCHECK(to->has_finally());
-    DCHECK(!to->try_info->has_handled_finally);
-    if (builder_ == nullptr) {
-      return;
-    }
-
-    switch (to->end_env->state) {
-      case SsaEnv::kReached:
-        DCHECK(to->try_info->token == nullptr);
-        to->try_info->token = builder_->Int32Constant(new_token);
-        break;
-      case SsaEnv::kMerged:
-        DCHECK_NOT_NULL(to->try_info->token);
-        to->try_info->token = CreateOrMergeIntoPhi(
-            kAstI32, to->end_env->control, to->try_info->token,
-            builder_->Int32Constant(new_token));
-        break;
-      case SsaEnv::kUnreachable:
-        UNREACHABLE();
-      // fallthrough intended.
-      default:
-        break;
-    }
-  }
-
   void Goto(SsaEnv* from, SsaEnv* to) {
     DCHECK_NOT_NULL(to);
     if (!from->go()) return;
     switch (to->state) {
       case SsaEnv::kUnreachable: {  // Overwrite destination.
         to->state = SsaEnv::kReached;
         to->locals = from->locals;
         to->control = from->control;
         to->effect = from->effect;
         break;
@@ skipping 419 matching lines @@
 BitVector* AnalyzeLoopAssignmentForTesting(Zone* zone, size_t num_locals,
                                            const byte* start, const byte* end) {
   FunctionBody body = {nullptr, nullptr, nullptr, start, end};
   WasmFullDecoder decoder(zone, nullptr, body);
   return decoder.AnalyzeLoopAssignmentForTesting(start, num_locals);
 }
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8