Revert of [wasm] Master CL for Binary 0xC changes.

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/zone-containers.h"
@@ skipping 18 matching lines @@
   } while (false)
 #else
 #define TRACE(...)
 #endif
 
 #define CHECK_PROTOTYPE_OPCODE(flag)                   \
   if (!FLAG_##flag) {                                  \
     error("Invalid opcode (enable with --" #flag ")"); \
     break;                                             \
   }
-// TODO(titzer): this is only for intermediate migration.
-#define IMPLICIT_FUNCTION_END 1
 
 // An SsaEnv environment carries the current local variable renaming
 // as well as the current effect and control dependency in the TF graph.
 // It maintains a control state that tracks whether the environment
 // is reachable, has reached a control end, or has been merged.
 struct SsaEnv {
   enum State { kControlEnd, kUnreachable, kReached, kMerged };
 
   State state;
   TFNode* control;
@@ skipping 14 matching lines @@
 
 // An entry on the value stack.
 struct Value {
   const byte* pc;
   TFNode* node;
   LocalType type;
 };
 
 struct Control;
 
-struct MergeValues {
-  uint32_t arity;
-  union {
-    Value* array;
-    Value first;
-  } vals;  // Either multiple values or a single value.
-
-  Value& first() {
-    DCHECK_GT(arity, 0u);
-    return arity == 1 ? vals.first : vals.array[0];
-  }
-};
-
-// IncomingBranch is used by exception handling code for managing finally's.
-struct IncomingBranch {
-  int32_t token_value;
-  Control* target;
-  MergeValues merge;
-};
-
-static Value* NO_VALUE = nullptr;
-
-enum ControlKind { kControlIf, kControlBlock, kControlLoop, kControlTry };
-
-// An entry on the control stack (i.e. if, block, loop).
+// An entry on the control stack (i.e. if, block, loop, try).
 struct Control {
   const byte* pc;
-  ControlKind kind;
   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).
+  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.
 
-  // Values merged into the end of this control construct.
-  MergeValues merge;
+  bool is_if() const { return *pc == kExprIf; }
 
-  inline bool is_if() const { return kind == kControlIf; }
-  inline bool is_block() const { return kind == kControlBlock; }
-  inline bool is_loop() const { return kind == kControlLoop; }
-  inline bool is_try() const { return kind == kControlTry; }
+  bool is_try() const { return *pc == kExprTry; }
 
   // Named constructors.
   static Control Block(const byte* pc, int stack_depth, SsaEnv* end_env) {
-    return {pc,      kControlBlock, stack_depth,    end_env,
-            nullptr, nullptr,       {0, {NO_VALUE}}};
+    return {pc,      stack_depth, end_env, nullptr,
+            nullptr, nullptr,     kAstEnd, false};
   }
 
   static Control If(const byte* pc, int stack_depth, SsaEnv* end_env,
                     SsaEnv* false_env) {
-    return {pc,        kControlIf, stack_depth,    end_env,
-            false_env, nullptr,    {0, {NO_VALUE}}};
+    return {pc,      stack_depth, end_env,  false_env,
+            nullptr, nullptr,     kAstStmt, false};
   }
 
   static Control Loop(const byte* pc, int stack_depth, SsaEnv* end_env) {
-    return {pc,      kControlLoop, stack_depth,    end_env,
-            nullptr, nullptr,      {0, {NO_VALUE}}};
+    return {pc, stack_depth, end_env, nullptr, nullptr, nullptr, kAstEnd, true};
   }
 
   static Control Try(const byte* pc, int stack_depth, SsaEnv* end_env,
                      SsaEnv* catch_env) {
-    return {pc,      kControlTry, stack_depth,    end_env,
-            nullptr, catch_env,   {0, {NO_VALUE}}};
+    return {pc,        stack_depth, end_env, nullptr,
+            catch_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 14 matching lines @@
 
   inline bool Validate(const byte* pc, LocalIndexOperand& operand) {
     if (operand.index < total_locals_) {
       if (local_types_) {
         operand.type = local_types_->at(operand.index);
       } else {
         operand.type = kAstStmt;
       }
       return true;
     }
-    error(pc, pc + 1, "invalid local index: %u", operand.index);
+    error(pc, pc + 1, "invalid local index");
     return false;
   }
 
   inline bool Validate(const byte* pc, GlobalIndexOperand& operand) {
     ModuleEnv* m = module_;
     if (m && m->module && operand.index < m->module->globals.size()) {
-      operand.global = &m->module->globals[operand.index];
-      operand.type = operand.global->type;
+      operand.type = m->module->globals[operand.index].type;
       return true;
     }
-    error(pc, pc + 1, "invalid global index: %u", operand.index);
+    error(pc, pc + 1, "invalid global index");
     return false;
   }
 
   inline bool Complete(const byte* pc, CallFunctionOperand& operand) {
     ModuleEnv* m = module_;
     if (m && m->module && operand.index < m->module->functions.size()) {
       operand.sig = m->module->functions[operand.index].sig;
       return true;
     }
     return false;
   }
 
   inline bool Validate(const byte* pc, CallFunctionOperand& operand) {
     if (Complete(pc, operand)) {
+      uint32_t expected = static_cast<uint32_t>(operand.sig->parameter_count());
+      if (operand.arity != expected) {
+        error(pc, pc + 1,
+              "arity mismatch in direct function call (expected %u, got %u)",
+              expected, operand.arity);
+        return false;
+      }
       return true;
     }
-    error(pc, pc + 1, "invalid function index: %u", operand.index);
+    error(pc, pc + 1, "invalid function index");
     return false;
   }
 
   inline bool Complete(const byte* pc, CallIndirectOperand& operand) {
     ModuleEnv* m = module_;
     if (m && m->module && operand.index < m->module->signatures.size()) {
       operand.sig = m->module->signatures[operand.index];
       return true;
     }
     return false;
   }
 
   inline bool Validate(const byte* pc, CallIndirectOperand& operand) {
     if (Complete(pc, operand)) {
+      uint32_t expected = static_cast<uint32_t>(operand.sig->parameter_count());
+      if (operand.arity != expected) {
+        error(pc, pc + 1,
+              "arity mismatch in indirect function call (expected %u, got %u)",
+              expected, operand.arity);
+        return false;
+      }
       return true;
     }
-    error(pc, pc + 1, "invalid signature index: #%u", operand.index);
+    error(pc, pc + 1, "invalid signature index");
+    return false;
+  }
+
+  inline bool Complete(const byte* pc, CallImportOperand& operand) {
+    ModuleEnv* m = module_;
+    if (m && m->module && operand.index < m->module->import_table.size()) {
+      operand.sig = m->module->import_table[operand.index].sig;
+      return true;
+    }
+    return false;
+  }
+
+  inline bool Validate(const byte* pc, CallImportOperand& operand) {
+    if (Complete(pc, operand)) {
+      uint32_t expected = static_cast<uint32_t>(operand.sig->parameter_count());
+      if (operand.arity != expected) {
+        error(pc, pc + 1, "arity mismatch in import call (expected %u, got %u)",
+              expected, operand.arity);
+        return false;
+      }
+      return true;
+    }
+    error(pc, pc + 1, "invalid signature index");
     return false;
   }
 
   inline bool Validate(const byte* pc, BreakDepthOperand& operand,
                        ZoneVector<Control>& control) {
+    if (operand.arity > 1) {
+      error(pc, pc + 1, "invalid arity for br or br_if");
+      return false;
+    }
     if (operand.depth < control.size()) {
       operand.target = &control[control.size() - operand.depth - 1];
       return true;
     }
-    error(pc, pc + 1, "invalid break depth: %u", operand.depth);
+    error(pc, pc + 1, "invalid break depth");
     return false;
   }
 
   bool Validate(const byte* pc, BranchTableOperand& operand,
                 size_t block_depth) {
-    // TODO(titzer): add extra redundant validation for br_table here?
+    if (operand.arity > 1) {
+      error(pc, pc + 1, "invalid arity for break");
+      return false;
+    }
+    // Verify table.
+    for (uint32_t i = 0; i < operand.table_count + 1; ++i) {
+      uint32_t target = operand.read_entry(this, i);
+      if (target >= block_depth) {
+        error(operand.table + i * 2, "improper branch in br_table");
+        return false;
+      }
+    }
     return true;
   }
 
+  unsigned OpcodeArity(const byte* pc) {
+#define DECLARE_ARITY(name, ...)                          \
+  static const LocalType kTypes_##name[] = {__VA_ARGS__}; \
+  static const int kArity_##name =                        \
+      static_cast<int>(arraysize(kTypes_##name) - 1);
+
+    FOREACH_SIGNATURE(DECLARE_ARITY);
+#undef DECLARE_ARITY
+
+    switch (static_cast<WasmOpcode>(*pc)) {
+      case kExprI8Const:
+      case kExprI32Const:
+      case kExprI64Const:
+      case kExprF64Const:
+      case kExprF32Const:
+      case kExprGetLocal:
+      case kExprGetGlobal:
+      case kExprNop:
+      case kExprUnreachable:
+      case kExprEnd:
+      case kExprBlock:
+      case kExprThrow:
+      case kExprTry:
+      case kExprLoop:
+        return 0;
+
+      case kExprSetGlobal:
+      case kExprSetLocal:
+      case kExprElse:
+      case kExprCatch:
+        return 1;
+
+      case kExprBr: {
+        BreakDepthOperand operand(this, pc);
+        return operand.arity;
+      }
+      case kExprBrIf: {
+        BreakDepthOperand operand(this, pc);
+        return 1 + operand.arity;
+      }
+      case kExprBrTable: {
+        BranchTableOperand operand(this, pc);
+        return 1 + operand.arity;
+      }
+
+      case kExprIf:
+        return 1;
+      case kExprSelect:
+        return 3;
+
+      case kExprCallFunction: {
+        CallFunctionOperand operand(this, pc);
+        return operand.arity;
+      }
+      case kExprCallIndirect: {
+        CallIndirectOperand operand(this, pc);
+        return 1 + operand.arity;
+      }
+      case kExprCallImport: {
+        CallImportOperand operand(this, pc);
+        return operand.arity;
+      }
+      case kExprReturn: {
+        ReturnArityOperand operand(this, pc);
+        return operand.arity;
+      }
+
+#define DECLARE_OPCODE_CASE(name, opcode, sig) \
+  case kExpr##name:                            \
+    return kArity_##sig;
+
+        FOREACH_LOAD_MEM_OPCODE(DECLARE_OPCODE_CASE)
+        FOREACH_STORE_MEM_OPCODE(DECLARE_OPCODE_CASE)
+        FOREACH_MISC_MEM_OPCODE(DECLARE_OPCODE_CASE)
+        FOREACH_SIMPLE_OPCODE(DECLARE_OPCODE_CASE)
+        FOREACH_SIMPLE_MEM_OPCODE(DECLARE_OPCODE_CASE)
+        FOREACH_ASMJS_COMPAT_OPCODE(DECLARE_OPCODE_CASE)
+        FOREACH_SIMD_0_OPERAND_OPCODE(DECLARE_OPCODE_CASE)
+#undef DECLARE_OPCODE_CASE
+#define DECLARE_OPCODE_CASE(name, opcode, sig) case kExpr##name:
+        FOREACH_SIMD_1_OPERAND_OPCODE(DECLARE_OPCODE_CASE)
+#undef DECLARE_OPCODE_CASE
+        return 1;
+      default:
+        UNREACHABLE();
+        return 0;
+    }
+  }
+
   unsigned 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, UINT32_MAX);
         return 1 + operand.length;
       }
       case kExprBr:
       case kExprBrIf: {
         BreakDepthOperand operand(this, pc);
         return 1 + operand.length;
       }
       case kExprSetGlobal:
       case kExprGetGlobal: {
         GlobalIndexOperand operand(this, pc);
         return 1 + operand.length;
       }
 
       case kExprCallFunction: {
         CallFunctionOperand operand(this, pc);
         return 1 + operand.length;
       }
       case kExprCallIndirect: {
         CallIndirectOperand operand(this, pc);
         return 1 + operand.length;
       }
-
-      case kExprTry:
-      case kExprIf:  // fall thru
-      case kExprLoop:
-      case kExprBlock: {
-        BlockTypeOperand operand(this, pc);
+      case kExprCallImport: {
+        CallImportOperand operand(this, pc);
         return 1 + operand.length;
       }
 
       case kExprSetLocal:
-      case kExprTeeLocal:
       case kExprGetLocal:
       case kExprCatch: {
         LocalIndexOperand operand(this, pc);
         return 1 + operand.length;
       }
       case kExprBrTable: {
         BranchTableOperand operand(this, pc);
-        BranchTableIterator iterator(this, operand);
-        return 1 + iterator.length();
+        return 1 + operand.length;
       }
       case kExprI32Const: {
         ImmI32Operand operand(this, pc);
         return 1 + operand.length;
       }
       case kExprI64Const: {
         ImmI64Operand operand(this, pc);
         return 1 + operand.length;
       }
       case kExprI8Const:
         return 2;
       case kExprF32Const:
         return 5;
       case kExprF64Const:
         return 9;
+      case kExprReturn: {
+        ReturnArityOperand operand(this, pc);
+        return 1 + operand.length;
+      }
+#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;
     }
   }
 };
 
 // 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),
-        last_end_found_(false) {
+        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();
 
     if (end_ < pc_) {
-      error("function body end < start");
+      error(pc_, "function body end < start");
       return false;
     }
 
     DecodeLocalDecls();
     InitSsaEnv();
     DecodeFunctionBody();
 
     if (failed()) return TraceFailed();
 
-#if IMPLICIT_FUNCTION_END
-    // With implicit end support (old style), the function block
-    // remains on the stack. Other control blocks are an error.
-    if (control_.size() > 1) {
-      error(pc_, control_.back().pc, "unterminated control structure");
-      return TraceFailed();
-    }
-
-    // Assume an implicit end to the function body block.
-    if (control_.size() == 1) {
-      Control* c = &control_.back();
-      if (ssa_env_->go()) {
-        FallThruTo(c);
-      }
-
-      if (c->end_env->go()) {
-        // Push the end values onto the stack.
-        stack_.resize(c->stack_depth);
-        if (c->merge.arity == 1) {
-          stack_.push_back(c->merge.vals.first);
-        } else {
-          for (unsigned i = 0; i < c->merge.arity; i++) {
-            stack_.push_back(c->merge.vals.array[i]);
-          }
-        }
-
-        TRACE("  @%-8d #xx:%-20s|", startrel(pc_), "ImplicitReturn");
-        SetEnv("function:end", c->end_env);
-        DoReturn();
-        TRACE("\n");
-      }
-    }
-#else
     if (!control_.empty()) {
       error(pc_, control_.back().pc, "unterminated control structure");
       return TraceFailed();
     }
 
-    if (!last_end_found_) {
-      error("function body must end with \"end\" opcode.");
-      return false;
+    if (ssa_env_->go()) {
+      TRACE("  @%-8d #xx:%-20s|", startrel(pc_), "ImplicitReturn");
+      DoReturn();
+      if (failed()) return TraceFailed();
+      TRACE("\n");
     }
-#endif
 
     if (FLAG_trace_wasm_decode_time) {
       double ms = decode_timer.Elapsed().InMillisecondsF();
-      PrintF("wasm-decode %s (%0.3f ms)\n\n", ok() ? "ok" : "failed", ms);
+      PrintF("wasm-decode ok (%0.3f ms)\n\n", ms);
     } else {
-      TRACE("wasm-decode %s\n\n", ok() ? "ok" : "failed");
+      TRACE("wasm-decode ok\n\n");
     }
 
     return true;
   }
 
   bool TraceFailed() {
     TRACE("wasm-error module+%-6d func+%d: %s\n\n", baserel(error_pc_),
           startrel(error_pc_), error_msg_.get());
     return false;
   }
@@ skipping 32 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.
-  bool last_end_found_;
 
   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 100 matching lines @@
     total_locals_ = local_type_vec_.size();
   }
 
   // Decodes the body of a function.
   void DecodeFunctionBody() {
     TRACE("wasm-decode %p...%p (module+%d, %d bytes) %s\n",
           reinterpret_cast<const void*>(start_),
           reinterpret_cast<const void*>(limit_), baserel(pc_),
           static_cast<int>(limit_ - start_), builder_ ? "graph building" : "");
 
-    {
-      // Set up initial function block.
-      SsaEnv* break_env = ssa_env_;
-      SetEnv("initial env", Steal(break_env));
-      PushBlock(break_env);
-      Control* c = &control_.back();
-      c->merge.arity = static_cast<uint32_t>(sig_->return_count());
-
-      if (c->merge.arity == 1) {
-        c->merge.vals.first = {pc_, nullptr, sig_->GetReturn(0)};
-      } else if (c->merge.arity > 1) {
-        c->merge.vals.array = zone_->NewArray<Value>(c->merge.arity);
-        for (unsigned i = 0; i < c->merge.arity; i++) {
-          c->merge.vals.array[i] = {pc_, nullptr, sig_->GetReturn(i)};
-        }
-      }
-    }
-
     if (pc_ >= limit_) return;  // Nothing to do.
 
     while (true) {  // decoding loop.
       unsigned len = 1;
       WasmOpcode opcode = static_cast<WasmOpcode>(*pc_);
       if (!WasmOpcodes::IsPrefixOpcode(opcode)) {
         TRACE("  @%-8d #%02x:%-20s|", startrel(pc_), opcode,
               WasmOpcodes::ShortOpcodeName(opcode));
       }
 
       FunctionSig* sig = WasmOpcodes::Signature(opcode);
       if (sig) {
         BuildSimpleOperator(opcode, sig);
       } else {
         // Complex bytecode.
         switch (opcode) {
           case kExprNop:
+            Push(kAstStmt, nullptr);
             break;
           case kExprBlock: {
             // The break environment is the outer environment.
-            BlockTypeOperand operand(this, pc_);
             SsaEnv* break_env = ssa_env_;
             PushBlock(break_env);
             SetEnv("block:start", Steal(break_env));
-            SetBlockType(&control_.back(), operand);
-            len = 1 + operand.length;
             break;
           }
           case kExprThrow: {
             CHECK_PROTOTYPE_OPCODE(wasm_eh_prototype);
             Value value = Pop(0, kAstI32);
             BUILD(Throw, value.node);
             break;
           }
           case kExprTry: {
             CHECK_PROTOTYPE_OPCODE(wasm_eh_prototype);
-            BlockTypeOperand operand(this, pc_);
             SsaEnv* outer_env = ssa_env_;
             SsaEnv* try_env = Steal(outer_env);
             SsaEnv* catch_env = Split(try_env);
             PushTry(outer_env, catch_env);
-            SetEnv("try_catch:start", try_env);
-            SetBlockType(&control_.back(), operand);
-            len = 1 + operand.length;
+            SetEnv("try:start", try_env);
             break;
           }
           case kExprCatch: {
             CHECK_PROTOTYPE_OPCODE(wasm_eh_prototype);
             LocalIndexOperand operand(this, pc_);
             len = 1 + operand.length;
 
             if (control_.empty()) {
-              error("catch does not match any try");
+              error(pc_, "catch does not match a any try");
               break;
             }
 
             Control* c = &control_.back();
             if (!c->is_try()) {
-              error("catch does not match any try");
+              error(pc_, "catch does not match a try");
               break;
             }
 
             if (c->catch_env == nullptr) {
-              error("catch already present for try with catch");
+              error(pc_, "catch already present for try with catch");
               break;
             }
 
             Goto(ssa_env_, c->end_env);
 
             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 kExprLoop: {
-            BlockTypeOperand operand(this, pc_);
-            SsaEnv* finish_try_env = Steal(ssa_env_);
+            // 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));
             ssa_env_->SetNotMerged();
             PushLoop(finish_try_env);
-            SetBlockType(&control_.back(), operand);
-            len = 1 + operand.length;
             break;
           }
           case kExprIf: {
             // Condition on top of stack. Split environments for branches.
-            BlockTypeOperand operand(this, pc_);
             Value cond = Pop(0, kAstI32);
             TFNode* if_true = nullptr;
             TFNode* if_false = nullptr;
             BUILD(Branch, cond.node, &if_true, &if_false);
             SsaEnv* end_env = ssa_env_;
             SsaEnv* false_env = Split(ssa_env_);
             false_env->control = if_false;
             SsaEnv* true_env = Steal(ssa_env_);
             true_env->control = if_true;
             PushIf(end_env, false_env);
             SetEnv("if:true", true_env);
-            SetBlockType(&control_.back(), operand);
-            len = 1 + operand.length;
             break;
           }
           case kExprElse: {
             if (control_.empty()) {
-              error("else does not match any if");
+              error(pc_, "else does not match any if");
               break;
             }
             Control* c = &control_.back();
             if (!c->is_if()) {
               error(pc_, c->pc, "else does not match an if");
               break;
             }
             if (c->false_env == nullptr) {
               error(pc_, c->pc, "else already present for if");
               break;
             }
-            FallThruTo(c);
+            Value val = PopUpTo(c->stack_depth);
+            MergeInto(c->end_env, &c->node, &c->type, val);
             // Switch to environment for false branch.
-            stack_.resize(c->stack_depth);
             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("end does not match any if, try, or block");
-              return;
+              error(pc_, "end does not match any if, try, or block");
+              break;
             }
             const char* name = "block:end";
             Control* c = &control_.back();
-            if (c->is_loop()) {
-              // A loop just leaves the values on the stack.
-              TypeCheckLoopFallThru(c);
+            Value val = PopUpTo(c->stack_depth);
+            if (c->is_loop) {
+              // Loops always push control in pairs.
               PopControl();
-              SetEnv("loop:end", ssa_env_);
-              break;
-            }
-            if (c->is_if()) {
+              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);
-                if (ssa_env_->go() && stack_.size() != c->stack_depth) {
-                  error("end of if expected empty stack");
-                  stack_.resize(c->stack_depth);
-                }
-                if (c->merge.arity > 0) {
-                  error("non-void one-armed if");
-                }
+                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";
 
               // validate that catch was seen.
               if (c->catch_env != nullptr) {
-                error("missing catch in try");
+                error(pc_, "missing catch in try");
                 break;
               }
             }
-            FallThruTo(c);
+
+            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);
-
-            // Push the end values onto the stack.
             stack_.resize(c->stack_depth);
-            if (c->merge.arity == 1) {
-              stack_.push_back(c->merge.vals.first);
-            } else {
-              for (unsigned i = 0; i < c->merge.arity; i++) {
-                stack_.push_back(c->merge.vals.array[i]);
-              }
-            }
-
+            Push(c->type, c->node);
             PopControl();
-
-            if (control_.empty()) {
-              // If the last (implicit) control was popped, check we are at end.
-              if (pc_ + 1 != end_) {
-                error(pc_, pc_ + 1, "trailing code after function end");
-              }
-              last_end_found_ = true;
-              if (ssa_env_->go()) {
-                // The result of the block is the return value.
-                TRACE("  @%-8d #xx:%-20s|", startrel(pc_), "ImplicitReturn");
-                DoReturn();
-                TRACE("\n");
-              }
-              return;
-            }
             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("type mismatch in select");
+                error(pc_, "type mismatch in select");
                 break;
               }
             }
             if (build()) {
               DCHECK(tval.type != kAstEnd);
               DCHECK(fval.type != kAstEnd);
               DCHECK(cond.type != kAstEnd);
               TFNode* controls[2];
               builder_->Branch(cond.node, &controls[0], &controls[1]);
               TFNode* merge = builder_->Merge(2, controls);
               TFNode* vals[2] = {tval.node, fval.node};
               TFNode* phi = builder_->Phi(tval.type, 2, vals, merge);
               Push(tval.type, phi);
               ssa_env_->control = merge;
             } 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.depth);
+              BreakTo(operand.target, val);
             }
             len = 1 + operand.length;
-            EndControl();
+            Push(kAstEnd, nullptr);
             break;
           }
           case kExprBrIf: {
             BreakDepthOperand operand(this, pc_);
-            Value cond = Pop(0, kAstI32);
+            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.depth);
+              BreakTo(operand.target, val);
               ssa_env_ = fenv;
             }
             len = 1 + operand.length;
+            Push(kAstStmt, nullptr);
             break;
           }
           case kExprBrTable: {
             BranchTableOperand operand(this, pc_);
-            BranchTableIterator iterator(this, operand);
             if (Validate(pc_, operand, control_.size())) {
-              Value key = Pop(0, kAstI32);
+              Value key = Pop(operand.arity, kAstI32);
+              Value val = {pc_, nullptr, kAstStmt};
+              if (operand.arity == 1) val = Pop();
               if (failed()) break;
 
               SsaEnv* break_env = ssa_env_;
               if (operand.table_count > 0) {
                 // Build branches to the various blocks based on the table.
                 TFNode* sw = BUILD(Switch, operand.table_count + 1, key.node);
 
                 SsaEnv* copy = Steal(break_env);
                 ssa_env_ = copy;
-                while (iterator.has_next()) {
-                  uint32_t i = iterator.cur_index();
-                  const byte* pos = iterator.pc();
-                  uint32_t target = iterator.next();
-                  if (target >= control_.size()) {
-                    error(pos, "improper branch in br_table");
-                    break;
-                  }
+                for (uint32_t i = 0; i < operand.table_count + 1; ++i) {
+                  uint16_t target = operand.read_entry(this, i);
                   ssa_env_ = Split(copy);
                   ssa_env_->control = (i == operand.table_count)
                                           ? BUILD(IfDefault, sw)
                                           : BUILD(IfValue, i, sw);
-                  BreakTo(target);
+                  int depth = target;
+                  Control* c = &control_[control_.size() - depth - 1];
+                  MergeInto(c->end_env, &c->node, &c->type, val);
                 }
               } else {
                 // Only a default target. Do the equivalent of br.
-                const byte* pos = iterator.pc();
-                uint32_t target = iterator.next();
-                if (target >= control_.size()) {
-                  error(pos, "improper branch in br_table");
-                  break;
-                }
-                BreakTo(target);
+                uint16_t target = operand.read_entry(this, 0);
+                int depth = target;
+                Control* c = &control_[control_.size() - depth - 1];
+                MergeInto(c->end_env, &c->node, &c->type, val);
               }
               // br_table ends the control flow like br.
               ssa_env_ = break_env;
+              Push(kAstStmt, nullptr);
             }
-            len = 1 + iterator.length();
+            len = 1 + operand.length;
             break;
           }
           case kExprReturn: {
+            ReturnArityOperand operand(this, pc_);
+            if (operand.arity != sig_->return_count()) {
+              error(pc_, pc_ + 1, "arity mismatch in return");
+            }
             DoReturn();
+            len = 1 + operand.length;
             break;
           }
           case kExprUnreachable: {
-            BUILD(Unreachable, position());
-            EndControl();
+            Push(kAstEnd, BUILD(Unreachable, position()));
+            ssa_env_->Kill(SsaEnv::kControlEnd);
             break;
           }
           case kExprI8Const: {
             ImmI8Operand operand(this, pc_);
             Push(kAstI32, BUILD(Int32Constant, operand.value));
             len = 1 + operand.length;
             break;
           }
           case kExprI32Const: {
             ImmI32Operand operand(this, pc_);
@@ skipping 29 matching lines @@
               }
             }
             len = 1 + operand.length;
             break;
           }
           case kExprSetLocal: {
             LocalIndexOperand operand(this, pc_);
             if (Validate(pc_, operand)) {
               Value val = Pop(0, local_type_vec_[operand.index]);
               if (ssa_env_->locals) ssa_env_->locals[operand.index] = val.node;
-            }
-            len = 1 + operand.length;
-            break;
-          }
-          case kExprTeeLocal: {
-            LocalIndexOperand operand(this, pc_);
-            if (Validate(pc_, operand)) {
-              Value val = Pop(0, local_type_vec_[operand.index]);
-              if (ssa_env_->locals) ssa_env_->locals[operand.index] = val.node;
               Push(val.type, val.node);
             }
             len = 1 + operand.length;
             break;
           }
-          case kExprDrop: {
-            Pop();
-            break;
-          }
           case kExprGetGlobal: {
             GlobalIndexOperand operand(this, pc_);
             if (Validate(pc_, operand)) {
               Push(operand.type, BUILD(GetGlobal, operand.index));
             }
             len = 1 + operand.length;
             break;
           }
           case kExprSetGlobal: {
             GlobalIndexOperand operand(this, pc_);
             if (Validate(pc_, operand)) {
-              if (operand.global->mutability) {
-                Value val = Pop(0, operand.type);
-                BUILD(SetGlobal, operand.index, val.node);
-              } else {
-                error(pc_, pc_ + 1, "immutable global #%u cannot be assigned",
-                      operand.index);
-              }
+              Value val = Pop(0, operand.type);
+              BUILD(SetGlobal, operand.index, val.node);
+              Push(val.type, val.node);
             }
             len = 1 + operand.length;
             break;
           }
           case kExprI32LoadMem8S:
             len = DecodeLoadMem(kAstI32, MachineType::Int8());
             break;
           case kExprI32LoadMem8U:
             len = DecodeLoadMem(kAstI32, MachineType::Uint8());
             break;
           case kExprI32LoadMem16S:
             len = DecodeLoadMem(kAstI32, MachineType::Int16());
             break;
           case kExprI32LoadMem16U:
             len = DecodeLoadMem(kAstI32, MachineType::Uint16());
             break;
           case kExprI32LoadMem:
             len = DecodeLoadMem(kAstI32, MachineType::Int32());
             break;
+
           case kExprI64LoadMem8S:
             len = DecodeLoadMem(kAstI64, MachineType::Int8());
             break;
           case kExprI64LoadMem8U:
             len = DecodeLoadMem(kAstI64, MachineType::Uint8());
             break;
           case kExprI64LoadMem16S:
             len = DecodeLoadMem(kAstI64, MachineType::Int16());
             break;
           case kExprI64LoadMem16U:
@@ skipping 43 matching lines @@
             break;
           case kExprGrowMemory:
             if (module_->origin != kAsmJsOrigin) {
               Value val = Pop(0, kAstI32);
               Push(kAstI32, BUILD(GrowMemory, val.node));
             } else {
               error("grow_memory is not supported for asmjs modules");
             }
             break;
           case kExprMemorySize:
-            Push(kAstI32, BUILD(CurrentMemoryPages));
+            Push(kAstI32, BUILD(MemSize, 0));
             break;
           case kExprCallFunction: {
             CallFunctionOperand operand(this, pc_);
             if (Validate(pc_, operand)) {
               TFNode** buffer = PopArgs(operand.sig);
-              TFNode** rets =
+              TFNode* call =
                   BUILD(CallDirect, operand.index, buffer, position());
-              PushReturns(operand.sig, rets);
+              Push(GetReturnType(operand.sig), call);
             }
             len = 1 + operand.length;
             break;
           }
           case kExprCallIndirect: {
             CallIndirectOperand operand(this, pc_);
             if (Validate(pc_, operand)) {
+              TFNode** buffer = PopArgs(operand.sig);
               Value index = Pop(0, kAstI32);
-              TFNode** buffer = PopArgs(operand.sig);
               if (buffer) buffer[0] = index.node;
-              TFNode** rets =
+              TFNode* call =
                   BUILD(CallIndirect, operand.index, buffer, position());
-              PushReturns(operand.sig, rets);
+              Push(GetReturnType(operand.sig), call);
             }
             len = 1 + operand.length;
             break;
+          }
+          case kExprCallImport: {
+            CallImportOperand operand(this, pc_);
+            if (Validate(pc_, operand)) {
+              TFNode** buffer = PopArgs(operand.sig);
+              TFNode* call =
+                  BUILD(CallImport, operand.index, buffer, position());
+              Push(GetReturnType(operand.sig), call);
+            }
+            len = 1 + operand.length;
+            break;
           }
           case kSimdPrefix: {
             CHECK_PROTOTYPE_OPCODE(wasm_simd_prototype);
             len++;
             byte simd_index = *(pc_ + 1);
             opcode = static_cast<WasmOpcode>(opcode << 8 | simd_index);
             TRACE("  @%-4d #%02x #%02x:%-20s|", startrel(pc_), kSimdPrefix,
                   simd_index, WasmOpcodes::ShortOpcodeName(opcode));
             len += DecodeSimdOpcode(opcode);
             break;
           }
-          default: {
+          default:
             // Deal with special asmjs opcodes.
-            if (module_ && module_->origin == kAsmJsOrigin) {
+            if (module_->origin == kAsmJsOrigin) {
               sig = WasmOpcodes::AsmjsSignature(opcode);
               if (sig) {
                 BuildSimpleOperator(opcode, sig);
               }
             } else {
               error("Invalid opcode");
               return;
             }
-          }
         }
-      }
+      }  // end complex bytecode
 
 #if DEBUG
       if (FLAG_trace_wasm_decoder) {
         for (size_t i = 0; i < stack_.size(); ++i) {
           Value& val = stack_[i];
           WasmOpcode opcode = static_cast<WasmOpcode>(*val.pc);
           if (WasmOpcodes::IsPrefixOpcode(opcode)) {
             opcode = static_cast<WasmOpcode>(opcode << 8 | *(val.pc + 1));
           }
           PrintF(" %c@%d:%s", WasmOpcodes::ShortNameOf(val.type),
                  static_cast<int>(val.pc - start_),
                  WasmOpcodes::ShortOpcodeName(opcode));
           switch (opcode) {
             case kExprI32Const: {
               ImmI32Operand operand(this, val.pc);
               PrintF("[%d]", operand.value);
               break;
             }
             case kExprGetLocal: {
               LocalIndexOperand operand(this, val.pc);
               PrintF("[%u]", operand.index);
               break;
             }
-            case kExprSetLocal:  // fallthru
-            case kExprTeeLocal: {
+            case kExprSetLocal: {
               LocalIndexOperand operand(this, val.pc);
               PrintF("[%u]", operand.index);
               break;
             }
             default:
               break;
           }
         }
         PrintF("\n");
       }
 #endif
       pc_ += len;
       if (pc_ >= limit_) {
         // End of code reached or exceeded.
         if (pc_ > limit_ && ok()) error("Beyond end of code");
         return;
       }
     }  // end decode loop
-  }
-
-  void EndControl() { ssa_env_->Kill(SsaEnv::kControlEnd); }
-
-  void SetBlockType(Control* c, BlockTypeOperand& operand) {
-    c->merge.arity = operand.arity;
-    if (c->merge.arity == 1) {
-      c->merge.vals.first = {pc_, nullptr, operand.read_entry(0)};
-    } else if (c->merge.arity > 1) {
-      c->merge.vals.array = zone_->NewArray<Value>(c->merge.arity);
-      for (unsigned i = 0; i < c->merge.arity; i++) {
-        c->merge.vals.array[i] = {pc_, nullptr, operand.read_entry(i)};
-      }
-    }
-  }
+  }    // end DecodeFunctionBody()
 
   TFNode** PopArgs(FunctionSig* sig) {
     if (build()) {
       int count = static_cast<int>(sig->parameter_count());
       TFNode** buffer = builder_->Buffer(count + 1);
       buffer[0] = nullptr;  // reserved for code object or function index.
       for (int i = count - 1; i >= 0; i--) {
         buffer[i + 1] = Pop(i, sig->GetParam(i)).node;
       }
       return buffer;
@@ skipping 43 matching lines @@
     return 1 + operand.length;
   }
 
   int DecodeStoreMem(LocalType type, MachineType mem_type) {
     MemoryAccessOperand operand(this, pc_,
                                 ElementSizeLog2Of(mem_type.representation()));
     Value val = Pop(1, type);
     Value index = Pop(0, kAstI32);
     BUILD(StoreMem, mem_type, index.node, operand.offset, operand.alignment,
           val.node, position());
+    Push(type, val.node);
     return 1 + operand.length;
   }
 
   unsigned DecodeSimdOpcode(WasmOpcode opcode) {
     unsigned len = 0;
     switch (opcode) {
       case kExprI32x4ExtractLane: {
         uint8_t lane = this->checked_read_u8(pc_, 2, "lane number");
         if (lane < 0 || lane > 3) {
           error(pc_, pc_ + 2, "invalid extract lane value");
         }
         TFNode* input = Pop(0, LocalType::kSimd128).node;
         TFNode* node = BUILD(SimdExtractLane, opcode, lane, input);
         Push(LocalType::kWord32, node);
         len++;
         break;
       }
       default: {
         FunctionSig* sig = WasmOpcodes::Signature(opcode);
         if (sig != nullptr) {
           compiler::NodeVector inputs(sig->parameter_count(), zone_);
           for (size_t i = sig->parameter_count(); i > 0; i--) {
             Value val = Pop(static_cast<int>(i - 1), sig->GetParam(i - 1));
             inputs[i - 1] = val.node;
           }
           TFNode* node = BUILD(SimdOp, opcode, inputs);
           Push(GetReturnType(sig), node);
         } else {
-          error("invalid simd opcode");
+          error(pc_, pc_, "invalid simd opcode");
         }
       }
     }
     return len;
   }
 
   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;
     }
 
-    BUILD(Return, count, buffer);
-    EndControl();
+    Push(kAstEnd, BUILD(Return, count, buffer));
+    ssa_env_->Kill(SsaEnv::kControlEnd);
   }
 
   void Push(LocalType type, TFNode* node) {
-    if (type != kAstStmt && type != kAstEnd) {
-      stack_.push_back({pc_, node, type});
-    }
-  }
-
-  void PushReturns(FunctionSig* sig, TFNode** rets) {
-    for (size_t i = 0; i < sig->return_count(); i++) {
-      // When verifying only, then {rets} will be null, so push null.
-      Push(sig->GetReturn(i), rets ? rets[i] : nullptr);
-    }
+    stack_.push_back({pc_, node, type});
   }
 
   const char* SafeOpcodeNameAt(const byte* pc) {
     if (pc >= end_) return "<end>";
     return WasmOpcodes::ShortOpcodeName(static_cast<WasmOpcode>(*pc));
   }
 
   Value Pop(int index, LocalType expected) {
-    if (!ssa_env_->go()) {
-      // Unreachable code is essentially not typechecked.
-      return {pc_, nullptr, expected};
-    }
     Value val = Pop();
     if (val.type != expected) {
       if (val.type != kAstEnd) {
         error(pc_, val.pc, "%s[%d] expected type %s, found %s of type %s",
               SafeOpcodeNameAt(pc_), index, WasmOpcodes::TypeName(expected),
               SafeOpcodeNameAt(val.pc), WasmOpcodes::TypeName(val.type));
       }
     }
     return val;
   }
 
   Value Pop() {
-    if (!ssa_env_->go()) {
-      // Unreachable code is essentially not typechecked.
-      return {pc_, nullptr, kAstEnd};
-    }
     size_t limit = control_.empty() ? 0 : control_.back().stack_depth;
     if (stack_.size() <= limit) {
       Value val = {pc_, nullptr, kAstStmt};
       error(pc_, pc_, "%s found empty stack", SafeOpcodeNameAt(pc_));
       return val;
     }
     Value val = stack_.back();
     stack_.pop_back();
     return val;
   }
 
   Value PopUpTo(int stack_depth) {
-    if (!ssa_env_->go()) {
-      // Unreachable code is essentially not typechecked.
-      return {pc_, nullptr, kAstEnd};
-    }
     if (stack_depth == stack_.size()) {
       Value val = {pc_, nullptr, kAstStmt};
       return val;
     } else {
       DCHECK_LE(stack_depth, static_cast<int>(stack_.size()));
       Value val = Pop();
       stack_.resize(stack_depth);
       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_); }
 
-  void BreakTo(unsigned depth) {
-    if (!ssa_env_->go()) return;
-    Control* c = &control_[control_.size() - depth - 1];
-    if (c->is_loop()) {
+  void BreakTo(Control* block, const Value& val) {
+    if (block->is_loop) {
       // This is the inner loop block, which does not have a value.
-      Goto(ssa_env_, c->end_env);
+      Goto(ssa_env_, block->end_env);
     } else {
-      // Merge the value(s) into the end of the block.
-      if (static_cast<size_t>(c->stack_depth + c->merge.arity) >
-          stack_.size()) {
-        error(
-            pc_, pc_,
-            "expected at least %d values on the stack for br to @%d, found %d",
-            c->merge.arity, startrel(c->pc),
-            static_cast<int>(stack_.size() - c->stack_depth));
-        return;
-      }
-      MergeValuesInto(c);
+      // Merge the value into the production for the block.
+      MergeInto(block->end_env, &block->node, &block->type, val);
     }
   }
 
-  void FallThruTo(Control* c) {
+  void MergeInto(SsaEnv* target, TFNode** node, LocalType* type,
+                 const Value& val) {
     if (!ssa_env_->go()) return;
-    // Merge the value(s) into the end of the block.
-    int arity = static_cast<int>(c->merge.arity);
-    if (c->stack_depth + arity != stack_.size()) {
-      error(pc_, pc_, "expected %d elements on the stack for fallthru to @%d",
-            arity, startrel(c->pc));
-      return;
-    }
-    MergeValuesInto(c);
-  }
+    DCHECK_NE(kAstEnd, val.type);
 
-  inline Value& GetMergeValueFromStack(Control* c, int i) {
-    return stack_[stack_.size() - c->merge.arity + i];
-  }
+    bool first = target->state == SsaEnv::kUnreachable;
+    Goto(ssa_env_, target);
 
-  void TypeCheckLoopFallThru(Control* c) {
-    if (!ssa_env_->go()) return;
-    // Fallthru must match arity exactly.
-    int arity = static_cast<int>(c->merge.arity);
-    if (c->stack_depth + arity != stack_.size()) {
-      error(pc_, pc_, "expected %d elements on the stack for fallthru to @%d",
-            arity, startrel(c->pc));
-      return;
-    }
-    // Typecheck the values left on the stack.
-    for (unsigned i = 0; i < c->merge.arity; i++) {
-      Value& val = GetMergeValueFromStack(c, i);
-      Value& old =
-          c->merge.arity == 1 ? c->merge.vals.first : c->merge.vals.array[i];
-      if (val.type != old.type) {
-        error(pc_, pc_, "type error in merge[%d] (expected %s, got %s)", i,
-              WasmOpcodes::TypeName(old.type), WasmOpcodes::TypeName(val.type));
-        return;
-      }
+    if (first) {
+      // first merge to this environment; set the type and the node.
+      *type = val.type;
+      *node = val.node;
+    } else if (val.type == *type && val.type != kAstStmt) {
+      // merge with the existing value for this block.
+      *node = CreateOrMergeIntoPhi(*type, target->control, *node, val.node);
+    } else {
+      // types don't match, or block is already a stmt.
+      *type = kAstStmt;
+      *node = nullptr;
     }
   }
 
-  void MergeValuesInto(Control* c) {
-    SsaEnv* target = c->end_env;
-    bool first = target->state == SsaEnv::kUnreachable;
-    Goto(ssa_env_, target);
-
-    for (unsigned i = 0; i < c->merge.arity; i++) {
-      Value& val = GetMergeValueFromStack(c, i);
-      Value& old =
-          c->merge.arity == 1 ? c->merge.vals.first : c->merge.vals.array[i];
-      if (val.type != old.type) {
-        error(pc_, pc_, "type error in merge[%d] (expected %s, got %s)", i,
-              WasmOpcodes::TypeName(old.type), WasmOpcodes::TypeName(val.type));
-        return;
-      }
-      old.node =
-          first ? val.node : CreateOrMergeIntoPhi(old.type, target->control,
-                                                  old.node, val.node);
-    }
-  }
-
   void SetEnv(const char* reason, SsaEnv* env) {
 #if DEBUG
     if (FLAG_trace_wasm_decoder) {
       char state = 'X';
       if (env) {
         switch (env->state) {
           case SsaEnv::kReached:
             state = 'R';
             break;
           case SsaEnv::kUnreachable:
@@ skipping 205 matching lines @@
     int depth = 0;
     // Iteratively process all AST nodes nested inside the loop.
     while (pc < limit_ && ok()) {
       WasmOpcode opcode = static_cast<WasmOpcode>(*pc);
       unsigned length = 1;
       switch (opcode) {
         case kExprLoop:
         case kExprIf:
         case kExprBlock:
         case kExprTry:
-          length = OpcodeLength(pc);
           depth++;
+          DCHECK_EQ(1, OpcodeLength(pc));
           break;
-        case kExprSetLocal:  // fallthru
-        case kExprTeeLocal: {
+        case kExprSetLocal: {
           LocalIndexOperand operand(this, pc);
           if (assigned->length() > 0 &&
               operand.index < static_cast<uint32_t>(assigned->length())) {
             // Unverified code might have an out-of-bounds index.
             assigned->Add(operand.index);
           }
           length = 1 + operand.length;
           break;
         }
         case kExprEnd:
@@ skipping 72 matching lines @@
   WasmFullDecoder decoder(&zone, builder, body);
   decoder.Decode();
   return decoder.toResult<DecodeStruct*>(nullptr);
 }
 
 unsigned OpcodeLength(const byte* pc, const byte* end) {
   WasmDecoder decoder(nullptr, nullptr, pc, end);
   return decoder.OpcodeLength(pc);
 }
 
+unsigned OpcodeArity(const byte* pc, const byte* end) {
+  WasmDecoder decoder(nullptr, nullptr, pc, end);
+  return decoder.OpcodeArity(pc);
+}
+
 void PrintAstForDebugging(const byte* start, const byte* end) {
   AccountingAllocator allocator;
   OFStream os(stdout);
   PrintAst(&allocator, FunctionBodyForTesting(start, end), os, nullptr);
 }
 
 bool PrintAst(AccountingAllocator* allocator, const FunctionBody& body,
               std::ostream& os,
               std::vector<std::tuple<uint32_t, int, int>>* offset_table) {
   Zone zone(allocator);
@@ skipping 45 matching lines @@
     const char* padding =
         "                                                                ";
     os.write(padding, num_whitespaces);
     os << "k" << WasmOpcodes::OpcodeName(opcode) << ",";
 
     for (size_t j = 1; j < length; ++j) {
       os << " " << AsHex(i.pc()[j], 2) << ",";
     }
 
     switch (opcode) {
+      case kExprIf:
       case kExprElse:
+      case kExprLoop:
+      case kExprBlock:
+      case kExprTry:
         os << "   // @" << i.pc_offset();
         control_depth++;
         break;
-      case kExprLoop:
-      case kExprIf:
-      case kExprBlock:
-      case kExprTry: {
-        BlockTypeOperand operand(&i, i.pc());
-        os << "   // @" << i.pc_offset();
-        for (unsigned i = 0; i < operand.arity; i++) {
-          os << " " << WasmOpcodes::TypeName(operand.read_entry(i));
-        }
-        control_depth++;
-        break;
-      }
       case kExprEnd:
         os << "   // @" << i.pc_offset();
         control_depth--;
         break;
       case kExprBr: {
         BreakDepthOperand operand(&i, i.pc());
-        os << "   // depth=" << operand.depth;
+        os << "   // arity=" << operand.arity << " depth=" << operand.depth;
         break;
       }
       case kExprBrIf: {
         BreakDepthOperand operand(&i, i.pc());
-        os << "   // depth=" << operand.depth;
+        os << "   // arity=" << operand.arity << " depth" << operand.depth;
         break;
       }
       case kExprBrTable: {
         BranchTableOperand operand(&i, i.pc());
-        os << " // entries=" << operand.table_count;
+        os << "   // arity=" << operand.arity
+           << " entries=" << operand.table_count;
         break;
       }
       case kExprCallIndirect: {
         CallIndirectOperand operand(&i, i.pc());
-        os << "   // sig #" << operand.index;
         if (decoder.Complete(i.pc(), operand)) {
-          os << ": " << *operand.sig;
+          os << "   // sig #" << operand.index << ": " << *operand.sig;
+        } else {
+          os << " // arity=" << operand.arity << " sig #" << operand.index;
+        }
+        break;
+      }
+      case kExprCallImport: {
+        CallImportOperand operand(&i, i.pc());
+        if (decoder.Complete(i.pc(), operand)) {
+          os << "   // import #" << operand.index << ": " << *operand.sig;
+        } else {
+          os << " // arity=" << operand.arity << " import #" << operand.index;
         }
         break;
       }
       case kExprCallFunction: {
         CallFunctionOperand operand(&i, i.pc());
-        os << " // function #" << operand.index;
         if (decoder.Complete(i.pc(), operand)) {
-          os << ": " << *operand.sig;
+          os << "   // function #" << operand.index << ": " << *operand.sig;
+        } else {
+          os << " // arity=" << operand.arity << " function #" << operand.index;
         }
         break;
       }
+      case kExprReturn: {
+        ReturnArityOperand operand(&i, i.pc());
+        os << "   // arity=" << operand.arity;
+        break;
+      }
       default:
         break;
       }
     os << std::endl;
     ++line_nr;
   }
 
   return decoder.ok();
 }
 
 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