diff --git a/test/unittests/wasm/ast-decoder-unittest.cc b/test/unittests/wasm/ast-decoder-unittest.cc
index 0b1b79e..fe10115 100644
--- a/test/unittests/wasm/ast-decoder-unittest.cc
+++ b/test/unittests/wasm/ast-decoder-unittest.cc
@@ -18,9 +18,13 @@
 namespace internal {
 namespace wasm {
 
+#define B1(a) kExprBlock, a, kExprEnd
+#define B2(a, b) kExprBlock, a, b, kExprEnd
+#define B3(a, b, c) kExprBlock, a, b, c, kExprEnd
+
 static const byte kCodeGetLocal0[] = {kExprGetLocal, 0};
 static const byte kCodeGetLocal1[] = {kExprGetLocal, 1};
-static const byte kCodeSetLocal0[] = {kExprSetLocal, 0, kExprI8Const, 0};
+static const byte kCodeSetLocal0[] = {WASM_SET_LOCAL(0, WASM_ZERO)};
 
 static const LocalType kLocalTypes[] = {kAstI32, kAstI64, kAstF32, kAstF64};
 static const MachineType machineTypes[] = {
@@ -36,7 +40,7 @@
     kExprI32LeS,  kExprI32LtU,  kExprI32LeU};
 
 #define WASM_BRV_IF_ZERO(depth, val) \
-  kExprBrIf, static_cast<byte>(depth), val, WASM_ZERO
+  val, WASM_ZERO, kExprBrIf, ARITY_1, static_cast<byte>(depth)
 
 #define EXPECT_VERIFIES(env, x) Verify(kSuccess, env, x, x + arraysize(x))
 
@@ -48,7 +52,6 @@
     Verify(kSuccess, env, code, code + arraysize(code)); \
   } while (false)
 
-
 #define EXPECT_FAILURE_INLINE(env, ...)                \
   do {                                                 \
     static byte code[] = {__VA_ARGS__};                \
@@ -65,7 +68,8 @@
  public:
   typedef std::pair<uint32_t, LocalType> LocalsDecl;
 
-  AstDecoderTest() : module(nullptr) {}
+  AstDecoderTest() : module(nullptr), local_decls(zone()) {}
+
   TestSignatures sigs;
   ModuleEnv* module;
   LocalDeclEncoder local_decls;
@@ -74,7 +78,7 @@
     local_decls.AddLocals(count, type);
   }
 
-  // Preprends local variable declarations and renders nice error messages for
+  // Prepends local variable declarations and renders nice error messages for
   // verification failures.
   void Verify(ErrorCode expected, FunctionSig* sig, const byte* start,
               const byte* end) {
@@ -107,8 +111,7 @@
 
   void TestBinop(WasmOpcode opcode, FunctionSig* success) {
     // op(local[0], local[1])
-    byte code[] = {static_cast<byte>(opcode), kExprGetLocal, 0, kExprGetLocal,
-                   1};
+    byte code[] = {WASM_BINOP(opcode, WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))};
     EXPECT_VERIFIES(success, code);
 
     // Try all combinations of return and parameter types.
@@ -134,7 +137,7 @@
 
   void TestUnop(WasmOpcode opcode, LocalType ret_type, LocalType param_type) {
     // Return(op(local[0]))
-    byte code[] = {static_cast<byte>(opcode), kExprGetLocal, 0};
+    byte code[] = {WASM_UNOP(opcode, WASM_GET_LOCAL(0))};
     {
       LocalType types[] = {ret_type, param_type};
       FunctionSig sig(1, 1, types);
@@ -155,7 +158,6 @@
   }
 };
 
-
 TEST_F(AstDecoderTest, Int8Const) {
   byte code[] = {kExprI8Const, 0};
   for (int i = -128; i < 128; i++) {
@@ -176,12 +178,6 @@
   EXPECT_FAILURE(sigs.i_i(), code);
 }
 
-TEST_F(AstDecoderTest, IncompleteIf2) {
-  byte code[] = {kExprIf, kExprI8Const, 0};
-  EXPECT_FAILURE(sigs.v_v(), code);
-  EXPECT_FAILURE(sigs.i_i(), code);
-}
-
 TEST_F(AstDecoderTest, Int8Const_fallthru) {
   byte code[] = {kExprI8Const, 0, kExprI8Const, 1};
   EXPECT_VERIFIES(sigs.i_i(), code);
@@ -303,199 +299,294 @@
     EXPECT_FAILURE(sigs.i_i(), code1);
   }
 
-  byte code3[] = {0, kExprGetLocal, 0};  // [opcode] [expr]
+  byte code3[] = {kExprGetLocal, 0, 0};  // [expr] [opcode]
   for (size_t i = 0; i < arraysize(kInt32BinopOpcodes); i++) {
-    code3[0] = kInt32BinopOpcodes[i];
+    code3[2] = kInt32BinopOpcodes[i];
     EXPECT_FAILURE(sigs.i_i(), code3);
   }
 
-  byte code4[] = {0, kExprGetLocal, 0, 0};  // [opcode] [expr] [opcode]
+  byte code4[] = {kExprGetLocal, 0, 0, 0};  // [expr] [opcode] [opcode]
   for (size_t i = 0; i < arraysize(kInt32BinopOpcodes); i++) {
-    code4[0] = kInt32BinopOpcodes[i];
+    code4[2] = kInt32BinopOpcodes[i];
     code4[3] = kInt32BinopOpcodes[i];
     EXPECT_FAILURE(sigs.i_i(), code4);
   }
 }
 
+TEST_F(AstDecoderTest, BinopsAcrossBlock1) {
+  static const byte code[] = {WASM_ZERO, kExprBlock, WASM_ZERO, kExprI32Add,
+                              kExprEnd};
+  EXPECT_FAILURE(sigs.i_i(), code);
+}
 
-//===================================================================
-//== Statements
-//===================================================================
+TEST_F(AstDecoderTest, BinopsAcrossBlock2) {
+  static const byte code[] = {WASM_ZERO, WASM_ZERO, kExprBlock, kExprI32Add,
+                              kExprEnd};
+  EXPECT_FAILURE(sigs.i_i(), code);
+}
+
+TEST_F(AstDecoderTest, BinopsAcrossBlock3) {
+  static const byte code[] = {WASM_ZERO, WASM_ZERO,   kExprIf, kExprI32Add,
+                              kExprElse, kExprI32Add, kExprEnd};
+  EXPECT_FAILURE(sigs.i_i(), code);
+}
+
 TEST_F(AstDecoderTest, Nop) {
   static const byte code[] = {kExprNop};
   EXPECT_VERIFIES(sigs.v_v(), code);
 }
 
 TEST_F(AstDecoderTest, SetLocal0_param) {
-  static const byte code[] = {kExprSetLocal, 0, kExprI8Const, 0};
-  EXPECT_VERIFIES(sigs.i_i(), code);
+  EXPECT_VERIFIES(sigs.i_i(), kCodeSetLocal0);
+  EXPECT_FAILURE(sigs.f_ff(), kCodeSetLocal0);
+  EXPECT_FAILURE(sigs.d_dd(), kCodeSetLocal0);
 }
 
 TEST_F(AstDecoderTest, SetLocal0_local) {
-  byte code[] = {kExprSetLocal, 0, kExprI8Const, 0};
+  EXPECT_FAILURE(sigs.i_v(), kCodeSetLocal0);
   AddLocals(kAstI32, 1);
-  EXPECT_VERIFIES(sigs.i_v(), code);
+  EXPECT_VERIFIES(sigs.i_v(), kCodeSetLocal0);
 }
 
 TEST_F(AstDecoderTest, SetLocalN_local) {
   for (byte i = 1; i < 8; i++) {
     AddLocals(kAstI32, 1);
     for (byte j = 0; j < i; j++) {
-      byte code[] = {kExprSetLocal, j, kExprI8Const, i};
-      EXPECT_VERIFIES(sigs.v_v(), code);
+      EXPECT_VERIFIES_INLINE(sigs.v_v(), WASM_SET_LOCAL(j, WASM_I8(i)));
     }
   }
 }
 
+TEST_F(AstDecoderTest, BlockN) {
+  const int kMaxSize = 200;
+  byte buffer[kMaxSize + 2];
+
+  for (int i = 0; i <= kMaxSize; i++) {
+    memset(buffer, kExprNop, sizeof(buffer));
+    buffer[0] = kExprBlock;
+    buffer[i + 1] = kExprEnd;
+    Verify(kSuccess, sigs.v_i(), buffer, buffer + i + 2);
+  }
+}
+
 TEST_F(AstDecoderTest, Block0) {
-  static const byte code[] = {kExprBlock, 0};
+  static const byte code[] = {kExprBlock, kExprEnd};
   EXPECT_VERIFIES(sigs.v_v(), code);
+  EXPECT_FAILURE(sigs.i_i(), code);
 }
 
 TEST_F(AstDecoderTest, Block0_fallthru1) {
-  static const byte code[] = {kExprBlock, 0, kExprBlock, 0};
+  static const byte code[] = {kExprBlock, kExprBlock, kExprEnd, kExprEnd};
   EXPECT_VERIFIES(sigs.v_v(), code);
+  EXPECT_FAILURE(sigs.i_i(), code);
+}
+
+TEST_F(AstDecoderTest, Block0Block0) {
+  static const byte code[] = {kExprBlock, kExprEnd, kExprBlock, kExprEnd};
+  EXPECT_VERIFIES(sigs.v_v(), code);
+  EXPECT_FAILURE(sigs.i_i(), code);
+}
+
+TEST_F(AstDecoderTest, Block0_end_end) {
+  static const byte code[] = {kExprBlock, kExprEnd, kExprEnd};
+  EXPECT_FAILURE(sigs.v_v(), code);
 }
 
 TEST_F(AstDecoderTest, Block1) {
-  static const byte code[] = {kExprBlock, 1, kExprSetLocal, 0, kExprI8Const, 0};
+  byte code[] = {B1(WASM_SET_LOCAL(0, WASM_ZERO))};
   EXPECT_VERIFIES(sigs.i_i(), code);
+  EXPECT_VERIFIES(sigs.v_i(), code);
+  EXPECT_FAILURE(sigs.d_dd(), code);
 }
 
-TEST_F(AstDecoderTest, Block0_fallthru2) {
-  static const byte code[] = {kExprBlock, 0, kExprSetLocal, 0, kExprI8Const, 0};
+TEST_F(AstDecoderTest, Block1_i) {
+  byte code[] = {B1(WASM_ZERO)};
   EXPECT_VERIFIES(sigs.i_i(), code);
+  EXPECT_FAILURE(sigs.f_ff(), code);
+  EXPECT_FAILURE(sigs.d_dd(), code);
+  EXPECT_FAILURE(sigs.l_ll(), code);
 }
 
-TEST_F(AstDecoderTest, Block2) {
-  static const byte code[] = {kExprBlock,    2,                    // --
-                              kExprSetLocal, 0, kExprI8Const, 0,   // --
-                              kExprSetLocal, 0, kExprI8Const, 0};  // --
-  EXPECT_VERIFIES(sigs.i_i(), code);
-}
-
-TEST_F(AstDecoderTest, Block2_fallthru) {
-  static const byte code[] = {kExprBlock,    2,                   // --
-                              kExprSetLocal, 0, kExprI8Const, 0,  // --
-                              kExprSetLocal, 0, kExprI8Const, 0,  // --
-                              kExprI8Const,  11};                 // --
-  EXPECT_VERIFIES(sigs.i_i(), code);
-}
-
-TEST_F(AstDecoderTest, BlockN) {
-  byte block[] = {kExprBlock, 2};
-
-  for (size_t i = 0; i < 10; i++) {
-    size_t total = sizeof(block) + sizeof(kCodeSetLocal0) * i;
-    byte* code = reinterpret_cast<byte*>(malloc(total));
-    memcpy(code, block, sizeof(block));
-    code[1] = static_cast<byte>(i);
-    for (size_t j = 0; j < i; j++) {
-      memcpy(code + sizeof(block) + j * sizeof(kCodeSetLocal0), kCodeSetLocal0,
-             sizeof(kCodeSetLocal0));
-    }
-    Verify(kSuccess, sigs.v_i(), code, code + total);
-    free(code);
-  }
-}
-
-TEST_F(AstDecoderTest, BlockN_off_end) {
-  for (byte i = 2; i < 10; i++) {
-    byte code[] = {kExprBlock, i, kExprNop};
-    EXPECT_FAILURE(sigs.v_v(), code);
-  }
-}
-
-TEST_F(AstDecoderTest, Block1_break) {
-  static const byte code[] = {kExprBlock, 1, kExprBr, 0, kExprNop};
-  EXPECT_VERIFIES(sigs.v_v(), code);
-}
-
-TEST_F(AstDecoderTest, Block2_break) {
-  static const byte code[] = {kExprBlock, 2, kExprNop, kExprBr, 0, kExprNop};
-  EXPECT_VERIFIES(sigs.v_v(), code);
+TEST_F(AstDecoderTest, Block1_f) {
+  byte code[] = {B1(WASM_F32(0))};
+  EXPECT_FAILURE(sigs.i_i(), code);
+  EXPECT_VERIFIES(sigs.f_ff(), code);
+  EXPECT_FAILURE(sigs.d_dd(), code);
+  EXPECT_FAILURE(sigs.l_ll(), code);
 }
 
 TEST_F(AstDecoderTest, Block1_continue) {
-  static const byte code[] = {kExprBlock, 1, kExprBr, 1, kExprNop};
-  EXPECT_FAILURE(sigs.v_v(), code);
+  EXPECT_VERIFIES_INLINE(sigs.v_v(), B1(WASM_BR(0)));
+  EXPECT_FAILURE_INLINE(sigs.v_v(), B1(WASM_BR(1)));
+  EXPECT_FAILURE_INLINE(sigs.v_v(), B1(WASM_BR(2)));
+  EXPECT_FAILURE_INLINE(sigs.v_v(), B1(WASM_BR(3)));
 }
 
-TEST_F(AstDecoderTest, Block2_continue) {
-  static const byte code[] = {kExprBlock, 2, kExprNop, kExprBr, 1, kExprNop};
-  EXPECT_FAILURE(sigs.v_v(), code);
+TEST_F(AstDecoderTest, Block1_br) {
+  EXPECT_FAILURE_INLINE(sigs.v_v(), kExprBlock, kExprBr, ARITY_1, DEPTH_0,
+                        kExprEnd);
+  EXPECT_VERIFIES_INLINE(sigs.v_v(), kExprBlock, kExprBr, ARITY_0, DEPTH_0,
+                         kExprEnd);
 }
 
-TEST_F(AstDecoderTest, ExprBlock0) {
-  static const byte code[] = {kExprBlock, 0};
-  EXPECT_VERIFIES(sigs.v_v(), code);
+TEST_F(AstDecoderTest, Block2_br) {
+  EXPECT_VERIFIES_INLINE(sigs.v_v(), B2(WASM_NOP, WASM_BR(0)));
+  EXPECT_VERIFIES_INLINE(sigs.v_v(), B2(WASM_BR(0), WASM_NOP));
+  EXPECT_VERIFIES_INLINE(sigs.v_v(), B2(WASM_BR(0), WASM_BR(0)));
 }
 
-TEST_F(AstDecoderTest, ExprBlock1a) {
-  static const byte code[] = {kExprBlock, 1, kExprI8Const, 0};
+TEST_F(AstDecoderTest, Block2) {
+  EXPECT_VERIFIES_INLINE(sigs.i_i(),
+                         B2(WASM_NOP, WASM_SET_LOCAL(0, WASM_ZERO)));
+  EXPECT_FAILURE_INLINE(sigs.i_i(), B2(WASM_SET_LOCAL(0, WASM_ZERO), WASM_NOP));
+  EXPECT_VERIFIES_INLINE(sigs.i_i(), B2(WASM_SET_LOCAL(0, WASM_ZERO),
+                                        WASM_SET_LOCAL(0, WASM_ZERO)));
+}
+
+TEST_F(AstDecoderTest, Block2b) {
+  byte code[] = {B2(WASM_SET_LOCAL(0, WASM_ZERO), WASM_ZERO)};
   EXPECT_VERIFIES(sigs.i_i(), code);
-}
-
-TEST_F(AstDecoderTest, ExprBlock1b) {
-  static const byte code[] = {kExprBlock, 1, kExprI8Const, 0};
+  EXPECT_FAILURE(sigs.v_v(), code);
   EXPECT_FAILURE(sigs.f_ff(), code);
 }
 
-TEST_F(AstDecoderTest, ExprBlock1c) {
-  static const byte code[] = {kExprBlock, 1, kExprF32Const, 0, 0, 0, 0};
+TEST_F(AstDecoderTest, Block2_fallthru) {
+  EXPECT_VERIFIES_INLINE(sigs.i_i(), B2(WASM_SET_LOCAL(0, WASM_ZERO),
+                                        WASM_SET_LOCAL(0, WASM_ZERO)),
+                         WASM_I8(23));
+}
+
+TEST_F(AstDecoderTest, Block3) {
+  EXPECT_VERIFIES_INLINE(
+      sigs.i_i(), B3(WASM_SET_LOCAL(0, WASM_ZERO), WASM_SET_LOCAL(0, WASM_ZERO),
+                     WASM_I8(11)));
+}
+
+TEST_F(AstDecoderTest, Block5) {
+  EXPECT_VERIFIES_INLINE(sigs.v_i(), B1(WASM_GET_LOCAL(0)));
+
+  EXPECT_VERIFIES_INLINE(sigs.v_i(), B2(WASM_GET_LOCAL(0), WASM_GET_LOCAL(0)));
+
+  EXPECT_VERIFIES_INLINE(
+      sigs.v_i(), B3(WASM_GET_LOCAL(0), WASM_GET_LOCAL(0), WASM_GET_LOCAL(0)));
+
+  EXPECT_VERIFIES_INLINE(sigs.v_i(),
+                         WASM_BLOCK(4, WASM_GET_LOCAL(0), WASM_GET_LOCAL(0),
+                                    WASM_GET_LOCAL(0), WASM_GET_LOCAL(0)));
+
+  EXPECT_VERIFIES_INLINE(
+      sigs.v_i(),
+      WASM_BLOCK(5, WASM_GET_LOCAL(0), WASM_GET_LOCAL(0), WASM_GET_LOCAL(0),
+                 WASM_GET_LOCAL(0), WASM_GET_LOCAL(0)));
+}
+
+TEST_F(AstDecoderTest, BlockF32) {
+  static const byte code[] = {kExprBlock, kExprF32Const, 0, 0, 0, 0, kExprEnd};
   EXPECT_VERIFIES(sigs.f_ff(), code);
+  EXPECT_FAILURE(sigs.i_i(), code);
+  EXPECT_FAILURE(sigs.d_dd(), code);
+}
+
+TEST_F(AstDecoderTest, BlockN_off_end) {
+  byte code[] = {kExprBlock, kExprNop, kExprNop, kExprNop, kExprNop, kExprEnd};
+  EXPECT_VERIFIES(sigs.v_v(), code);
+  for (size_t i = 1; i < arraysize(code); i++) {
+    Verify(kError, sigs.v_v(), code, code + i);
+  }
+}
+
+TEST_F(AstDecoderTest, Block2_continue) {
+  static const byte code[] = {kExprBlock, kExprBr,  ARITY_0,
+                              DEPTH_1,    kExprNop, kExprEnd};
+  EXPECT_FAILURE(sigs.v_v(), code);
+}
+
+TEST_F(AstDecoderTest, NestedBlock_return) {
+  EXPECT_VERIFIES_INLINE(sigs.i_i(), B1(B1(WASM_RETURN1(WASM_ZERO))));
+}
+
+TEST_F(AstDecoderTest, BlockBinop) {
+  EXPECT_VERIFIES_INLINE(sigs.i_i(), WASM_I32_AND(B1(WASM_I8(1)), WASM_I8(2)));
+}
+
+TEST_F(AstDecoderTest, BlockBrBinop) {
+  EXPECT_VERIFIES_INLINE(sigs.i_i(),
+                         WASM_I32_AND(B1(WASM_BRV(0, WASM_I8(1))), WASM_I8(2)));
+}
+
+TEST_F(AstDecoderTest, If_empty1) {
+  EXPECT_VERIFIES_INLINE(sigs.v_v(), WASM_ZERO, kExprIf, kExprEnd);
+}
+
+TEST_F(AstDecoderTest, If_empty2) {
+  EXPECT_VERIFIES_INLINE(sigs.v_v(), WASM_ZERO, kExprIf, kExprElse, kExprEnd);
+}
+
+TEST_F(AstDecoderTest, If_empty3) {
+  EXPECT_VERIFIES_INLINE(sigs.v_v(), WASM_ZERO, kExprIf, WASM_ZERO, kExprElse,
+                         kExprEnd);
+}
+
+TEST_F(AstDecoderTest, If_empty4) {
+  EXPECT_VERIFIES_INLINE(sigs.v_v(), WASM_ZERO, kExprIf, kExprElse, WASM_ZERO,
+                         kExprEnd);
+}
+
+TEST_F(AstDecoderTest, If_empty_stack) {
+  byte code[] = {kExprIf};
+  EXPECT_FAILURE(sigs.v_v(), code);
+  EXPECT_FAILURE(sigs.i_i(), code);
+}
+
+TEST_F(AstDecoderTest, If_incomplete1) {
+  byte code[] = {kExprI8Const, 0, kExprIf};
+  EXPECT_FAILURE(sigs.v_v(), code);
+  EXPECT_FAILURE(sigs.i_i(), code);
+}
+
+TEST_F(AstDecoderTest, If_incomplete2) {
+  byte code[] = {kExprI8Const, 0, kExprIf, kExprNop};
+  EXPECT_FAILURE(sigs.v_v(), code);
+  EXPECT_FAILURE(sigs.i_i(), code);
+}
+
+TEST_F(AstDecoderTest, If_else_else) {
+  byte code[] = {kExprI8Const, 0, kExprIf, kExprElse, kExprElse, kExprEnd};
+  EXPECT_FAILURE(sigs.v_v(), code);
+  EXPECT_FAILURE(sigs.i_i(), code);
 }
 
 TEST_F(AstDecoderTest, IfEmpty) {
-  static const byte code[] = {kExprIf, kExprGetLocal, 0, kExprNop};
-  EXPECT_VERIFIES(sigs.v_i(), code);
+  EXPECT_VERIFIES_INLINE(sigs.v_i(), kExprGetLocal, 0, kExprIf, kExprEnd);
 }
 
 TEST_F(AstDecoderTest, IfSet) {
-  static const byte code[] = {kExprIfElse, kExprGetLocal, 0, kExprSetLocal,
-                              0,           kExprI8Const,  0, kExprNop};
-  EXPECT_VERIFIES(sigs.v_i(), code);
-}
-
-TEST_F(AstDecoderTest, IfBlock1) {
-  static const byte code[] = {kExprIfElse, kExprGetLocal, 0, kExprBlock,
-                              1,           kExprSetLocal, 0, kExprI8Const,
-                              0,           kExprNop};
-  EXPECT_VERIFIES(sigs.v_i(), code);
-}
-
-TEST_F(AstDecoderTest, IfBlock2) {
-  static const byte code[] = {kExprIf, kExprGetLocal, 0, kExprBlock,
-                              2,       kExprSetLocal, 0, kExprI8Const,
-                              0,       kExprSetLocal, 0, kExprI8Const,
-                              0};
-  EXPECT_VERIFIES(sigs.v_i(), code);
+  EXPECT_VERIFIES_INLINE(
+      sigs.v_i(), WASM_IF(WASM_GET_LOCAL(0), WASM_SET_LOCAL(0, WASM_ZERO)));
+  EXPECT_VERIFIES_INLINE(
+      sigs.v_i(),
+      WASM_IF_ELSE(WASM_GET_LOCAL(0), WASM_SET_LOCAL(0, WASM_ZERO), WASM_NOP));
 }
 
 TEST_F(AstDecoderTest, IfElseEmpty) {
-  static const byte code[] = {kExprIfElse, kExprGetLocal, 0, kExprNop,
-                              kExprNop};
-  EXPECT_VERIFIES(sigs.v_i(), code);
+  EXPECT_VERIFIES_INLINE(sigs.v_i(), WASM_GET_LOCAL(0), kExprIf, kExprElse,
+                         kExprEnd);
+  EXPECT_VERIFIES_INLINE(sigs.v_i(),
+                         WASM_IF_ELSE(WASM_GET_LOCAL(0), WASM_NOP, WASM_NOP));
 }
 
-TEST_F(AstDecoderTest, IfElseSet) {
-  static const byte code[] = {kExprIfElse,
-                              kExprGetLocal,
-                              0,  // --
-                              kExprSetLocal,
-                              0,
-                              kExprI8Const,
-                              0,  // --
-                              kExprSetLocal,
-                              0,
-                              kExprI8Const,
-                              1};  // --
-  EXPECT_VERIFIES(sigs.v_i(), code);
+TEST_F(AstDecoderTest, IfElseUnreachable1) {
+  EXPECT_VERIFIES_INLINE(
+      sigs.i_i(),
+      WASM_IF_ELSE(WASM_GET_LOCAL(0), WASM_UNREACHABLE, WASM_GET_LOCAL(0)));
+  EXPECT_VERIFIES_INLINE(
+      sigs.i_i(),
+      WASM_IF_ELSE(WASM_GET_LOCAL(0), WASM_GET_LOCAL(0), WASM_UNREACHABLE));
 }
 
-TEST_F(AstDecoderTest, IfElseUnreachable) {
-  static const byte code[] = {kExprIfElse,      kExprI8Const,  0,
-                              kExprUnreachable, kExprGetLocal, 0};
+TEST_F(AstDecoderTest, IfElseUnreachable2) {
+  static const byte code[] = {
+      WASM_IF_ELSE(WASM_GET_LOCAL(0), WASM_UNREACHABLE, WASM_GET_LOCAL(0))};
 
   for (size_t i = 0; i < arraysize(kLocalTypes); i++) {
     LocalType types[] = {kAstI32, kLocalTypes[i]};
@@ -509,66 +600,136 @@
   }
 }
 
+TEST_F(AstDecoderTest, IfBreak) {
+  EXPECT_VERIFIES_INLINE(sigs.v_i(), WASM_IF(WASM_GET_LOCAL(0), WASM_BR(0)));
+  EXPECT_FAILURE_INLINE(sigs.v_i(), WASM_IF(WASM_GET_LOCAL(0), WASM_BR(1)));
+}
+
+TEST_F(AstDecoderTest, IfElseBreak) {
+  EXPECT_VERIFIES_INLINE(sigs.v_i(),
+                         WASM_IF_ELSE(WASM_GET_LOCAL(0), WASM_NOP, WASM_BR(0)));
+  EXPECT_FAILURE_INLINE(sigs.v_i(),
+                        WASM_IF_ELSE(WASM_GET_LOCAL(0), WASM_NOP, WASM_BR(1)));
+}
+
+TEST_F(AstDecoderTest, Block_else) {
+  byte code[] = {kExprI8Const, 0, kExprBlock, kExprElse, kExprEnd};
+  EXPECT_FAILURE(sigs.v_v(), code);
+  EXPECT_FAILURE(sigs.i_i(), code);
+}
+
+TEST_F(AstDecoderTest, IfNop) {
+  EXPECT_VERIFIES_INLINE(sigs.v_i(), WASM_IF(WASM_GET_LOCAL(0), WASM_NOP));
+}
+
+TEST_F(AstDecoderTest, IfNopElseNop) {
+  EXPECT_VERIFIES_INLINE(sigs.v_i(),
+                         WASM_IF_ELSE(WASM_GET_LOCAL(0), WASM_NOP, WASM_NOP));
+}
+
+TEST_F(AstDecoderTest, If_end_end) {
+  static const byte code[] = {kExprGetLocal, 0, kExprIf, kExprEnd, kExprEnd};
+  EXPECT_FAILURE(sigs.v_i(), code);
+}
+
+TEST_F(AstDecoderTest, If_falloff) {
+  static const byte code[] = {kExprGetLocal, 0, kExprIf};
+  EXPECT_FAILURE(sigs.v_i(), code);
+}
+
+TEST_F(AstDecoderTest, IfElse_falloff) {
+  static const byte code[] = {kExprGetLocal, 0, kExprIf, kExprNop, kExprElse};
+  EXPECT_FAILURE(sigs.v_i(), code);
+}
+
+TEST_F(AstDecoderTest, IfElseNop) {
+  EXPECT_VERIFIES_INLINE(
+      sigs.v_i(),
+      WASM_IF_ELSE(WASM_GET_LOCAL(0), WASM_SET_LOCAL(0, WASM_ZERO), WASM_NOP));
+}
+
+TEST_F(AstDecoderTest, IfBlock1) {
+  EXPECT_VERIFIES_INLINE(
+      sigs.v_i(), WASM_IF_ELSE(WASM_GET_LOCAL(0),
+                               B1(WASM_SET_LOCAL(0, WASM_ZERO)), WASM_NOP));
+}
+
+TEST_F(AstDecoderTest, IfBlock1b) {
+  EXPECT_VERIFIES_INLINE(
+      sigs.v_i(), WASM_IF(WASM_GET_LOCAL(0), B1(WASM_SET_LOCAL(0, WASM_ZERO))));
+}
+
+TEST_F(AstDecoderTest, IfBlock2a) {
+  EXPECT_VERIFIES_INLINE(
+      sigs.v_i(), WASM_IF(WASM_GET_LOCAL(0), B2(WASM_SET_LOCAL(0, WASM_ZERO),
+                                                WASM_SET_LOCAL(0, WASM_ZERO))));
+}
+
+TEST_F(AstDecoderTest, IfBlock2b) {
+  EXPECT_VERIFIES_INLINE(
+      sigs.v_i(),
+      WASM_IF_ELSE(WASM_GET_LOCAL(0), B2(WASM_SET_LOCAL(0, WASM_ZERO),
+                                         WASM_SET_LOCAL(0, WASM_ZERO)),
+                   WASM_NOP));
+}
+
+TEST_F(AstDecoderTest, IfElseSet) {
+  EXPECT_VERIFIES_INLINE(
+      sigs.v_i(), WASM_IF_ELSE(WASM_GET_LOCAL(0), WASM_SET_LOCAL(0, WASM_ZERO),
+                               WASM_SET_LOCAL(0, WASM_I8(1))));
+}
+
 TEST_F(AstDecoderTest, Loop0) {
-  static const byte code[] = {kExprLoop, 0};
+  static const byte code[] = {kExprLoop, kExprEnd};
   EXPECT_VERIFIES(sigs.v_v(), code);
 }
 
 TEST_F(AstDecoderTest, Loop1) {
-  static const byte code[] = {kExprLoop, 1, kExprSetLocal, 0, kExprI8Const, 0};
+  static const byte code[] = {WASM_LOOP(1, WASM_SET_LOCAL(0, WASM_ZERO))};
   EXPECT_VERIFIES(sigs.v_i(), code);
+  EXPECT_FAILURE(sigs.v_v(), code);
+  EXPECT_FAILURE(sigs.f_ff(), code);
 }
 
 TEST_F(AstDecoderTest, Loop2) {
-  static const byte code[] = {kExprLoop,     2,                    // --
-                              kExprSetLocal, 0, kExprI8Const, 0,   // --
-                              kExprSetLocal, 0, kExprI8Const, 0};  // --
-  EXPECT_VERIFIES(sigs.v_i(), code);
+  EXPECT_VERIFIES_INLINE(sigs.v_i(), WASM_LOOP(2, WASM_SET_LOCAL(0, WASM_ZERO),
+                                               WASM_SET_LOCAL(0, WASM_ZERO)));
 }
 
 TEST_F(AstDecoderTest, Loop1_continue) {
-  static const byte code[] = {kExprLoop, 1, kExprBr, 0, kExprNop};
-  EXPECT_VERIFIES(sigs.v_v(), code);
+  EXPECT_VERIFIES_INLINE(sigs.v_v(), WASM_LOOP(1, WASM_BR(0)));
 }
 
 TEST_F(AstDecoderTest, Loop1_break) {
-  static const byte code[] = {kExprLoop, 1, kExprBr, 1, kExprNop};
-  EXPECT_VERIFIES(sigs.v_v(), code);
+  EXPECT_VERIFIES_INLINE(sigs.v_v(), WASM_LOOP(1, WASM_BR(1)));
 }
 
 TEST_F(AstDecoderTest, Loop2_continue) {
-  static const byte code[] = {kExprLoop,     2,                   // --
-                              kExprSetLocal, 0, kExprI8Const, 0,  // --
-                              kExprBr,       0, kExprNop};        // --
-  EXPECT_VERIFIES(sigs.v_i(), code);
+  EXPECT_VERIFIES_INLINE(
+      sigs.v_i(), WASM_LOOP(2, WASM_SET_LOCAL(0, WASM_ZERO), WASM_BR(0)));
 }
 
 TEST_F(AstDecoderTest, Loop2_break) {
-  static const byte code[] = {kExprLoop,     2,                   // --
-                              kExprSetLocal, 0, kExprI8Const, 0,  // --
-                              kExprBr,       1, kExprNop};        // --
-  EXPECT_VERIFIES(sigs.v_i(), code);
+  EXPECT_VERIFIES_INLINE(
+      sigs.v_i(), WASM_LOOP(2, WASM_SET_LOCAL(0, WASM_ZERO), WASM_BR(1)));
 }
 
 TEST_F(AstDecoderTest, ExprLoop0) {
-  static const byte code[] = {kExprLoop, 0};
+  static const byte code[] = {kExprLoop, kExprEnd};
   EXPECT_VERIFIES(sigs.v_v(), code);
 }
 
 TEST_F(AstDecoderTest, ExprLoop1a) {
-  static const byte code[] = {kExprLoop, 1, kExprBr, 0, kExprI8Const, 0};
-  EXPECT_VERIFIES(sigs.i_i(), code);
+  EXPECT_VERIFIES_INLINE(sigs.i_i(), WASM_LOOP(1, WASM_BRV(0, WASM_ZERO)));
 }
 
 TEST_F(AstDecoderTest, ExprLoop1b) {
-  static const byte code[] = {kExprLoop, 1, kExprBr, 0, kExprI8Const, 0};
-  EXPECT_VERIFIES(sigs.i_i(), code);
+  EXPECT_VERIFIES_INLINE(sigs.i_i(), WASM_LOOP(1, WASM_BRV(1, WASM_ZERO)));
+  EXPECT_FAILURE_INLINE(sigs.f_ff(), WASM_LOOP(1, WASM_BRV(1, WASM_ZERO)));
 }
 
 TEST_F(AstDecoderTest, ExprLoop2_unreachable) {
-  static const byte code[] = {kExprLoop,    2, kExprBr, 0,
-                              kExprI8Const, 0, kExprNop};
-  EXPECT_VERIFIES(sigs.i_i(), code);
+  EXPECT_VERIFIES_INLINE(sigs.i_i(), WASM_LOOP(2, WASM_BR(0), WASM_NOP));
 }
 
 TEST_F(AstDecoderTest, ReturnVoid1) {
@@ -579,7 +740,7 @@
 }
 
 TEST_F(AstDecoderTest, ReturnVoid2) {
-  static const byte code[] = {kExprBlock, 1, kExprBr, 0, kExprNop};
+  static const byte code[] = {kExprBlock, kExprBr, ARITY_0, DEPTH_0, kExprEnd};
   EXPECT_VERIFIES(sigs.v_v(), code);
   EXPECT_FAILURE(sigs.i_i(), code);
   EXPECT_FAILURE(sigs.i_f(), code);
@@ -598,67 +759,85 @@
 TEST_F(AstDecoderTest, Unreachable1) {
   EXPECT_VERIFIES_INLINE(sigs.v_v(), kExprUnreachable);
   EXPECT_VERIFIES_INLINE(sigs.v_v(), kExprUnreachable, kExprUnreachable);
-  EXPECT_VERIFIES_INLINE(sigs.v_v(),
-                         WASM_BLOCK(2, WASM_UNREACHABLE, WASM_ZERO));
-  EXPECT_VERIFIES_INLINE(sigs.v_v(), WASM_BLOCK(2, WASM_BR(0), WASM_ZERO));
+  EXPECT_VERIFIES_INLINE(sigs.v_v(), B2(WASM_UNREACHABLE, WASM_ZERO));
+  EXPECT_VERIFIES_INLINE(sigs.v_v(), B2(WASM_BR(0), WASM_ZERO));
   EXPECT_VERIFIES_INLINE(sigs.v_v(), WASM_LOOP(2, WASM_UNREACHABLE, WASM_ZERO));
   EXPECT_VERIFIES_INLINE(sigs.v_v(), WASM_LOOP(2, WASM_BR(0), WASM_ZERO));
 }
 
-TEST_F(AstDecoderTest, Codeiness) {
-  VERIFY(kExprLoop, 2,                       // --
-         kExprSetLocal, 0, kExprI8Const, 0,  // --
-         kExprBr, 0, kExprNop);              // --
+TEST_F(AstDecoderTest, Unreachable_binop) {
+  EXPECT_VERIFIES_INLINE(sigs.i_i(), WASM_I32_AND(WASM_ZERO, WASM_UNREACHABLE));
+  EXPECT_VERIFIES_INLINE(sigs.i_i(), WASM_I32_AND(WASM_UNREACHABLE, WASM_ZERO));
 }
 
-TEST_F(AstDecoderTest, ExprIf1) {
-  VERIFY(kExprIf, kExprGetLocal, 0, kExprI8Const, 0, kExprI8Const, 1);
-  VERIFY(kExprIf, kExprGetLocal, 0, kExprGetLocal, 0, kExprGetLocal, 0);
-  VERIFY(kExprIf, kExprGetLocal, 0, kExprI32Add, kExprGetLocal, 0,
-         kExprGetLocal, 0, kExprI8Const, 1);
+TEST_F(AstDecoderTest, Unreachable_select) {
+  EXPECT_VERIFIES_INLINE(sigs.i_i(),
+                         WASM_SELECT(WASM_UNREACHABLE, WASM_ZERO, WASM_ZERO));
+  EXPECT_VERIFIES_INLINE(sigs.i_i(),
+                         WASM_SELECT(WASM_ZERO, WASM_UNREACHABLE, WASM_ZERO));
+  EXPECT_VERIFIES_INLINE(sigs.i_i(),
+                         WASM_SELECT(WASM_ZERO, WASM_ZERO, WASM_UNREACHABLE));
 }
 
-TEST_F(AstDecoderTest, ExprIf_off_end) {
-  static const byte kCode[] = {kExprIf, kExprGetLocal, 0, kExprGetLocal,
-                               0,       kExprGetLocal, 0};
-  for (size_t len = 1; len < arraysize(kCode); len++) {
+TEST_F(AstDecoderTest, If1) {
+  EXPECT_VERIFIES_INLINE(
+      sigs.i_i(), WASM_IF_ELSE(WASM_GET_LOCAL(0), WASM_I8(9), WASM_I8(8)));
+  EXPECT_VERIFIES_INLINE(sigs.i_i(), WASM_IF_ELSE(WASM_GET_LOCAL(0), WASM_I8(9),
+                                                  WASM_GET_LOCAL(0)));
+  EXPECT_VERIFIES_INLINE(
+      sigs.i_i(),
+      WASM_IF_ELSE(WASM_GET_LOCAL(0), WASM_GET_LOCAL(0), WASM_I8(8)));
+}
+
+TEST_F(AstDecoderTest, If_off_end) {
+  static const byte kCode[] = {
+      WASM_IF_ELSE(WASM_GET_LOCAL(0), WASM_GET_LOCAL(0), WASM_GET_LOCAL(0))};
+  for (size_t len = 3; len < arraysize(kCode); len++) {
     Verify(kError, sigs.i_i(), kCode, kCode + len);
   }
 }
 
-TEST_F(AstDecoderTest, ExprIf_type) {
-  {
-    // float|double ? 1 : 2
-    static const byte kCode[] = {kExprIfElse, kExprGetLocal, 0, kExprI8Const,
-                                 1,           kExprI8Const,  2};
-    EXPECT_FAILURE(sigs.i_f(), kCode);
-    EXPECT_FAILURE(sigs.i_d(), kCode);
-  }
-  {
-    // 1 ? float|double : 2
-    static const byte kCode[] = {kExprIfElse, kExprI8Const, 1, kExprGetLocal,
-                                 0,           kExprI8Const, 2};
-    EXPECT_FAILURE(sigs.i_f(), kCode);
-    EXPECT_FAILURE(sigs.i_d(), kCode);
-  }
-  {
-    // stmt ? 0 : 1
-    static const byte kCode[] = {kExprIfElse, kExprNop,     kExprI8Const,
-                                 0,           kExprI8Const, 1};
-    EXPECT_FAILURE(sigs.i_i(), kCode);
-  }
-  {
-    // 0 ? stmt : 1
-    static const byte kCode[] = {kExprIfElse, kExprI8Const, 0,
-                                 kExprNop,    kExprI8Const, 1};
-    EXPECT_FAILURE(sigs.i_i(), kCode);
-  }
-  {
-    // 0 ? 1 : stmt
-    static const byte kCode[] = {kExprIfElse, kExprI8Const, 0, kExprI8Const, 1,
-                                 0,           kExprBlock};
-    EXPECT_FAILURE(sigs.i_i(), kCode);
-  }
+TEST_F(AstDecoderTest, If_type1) {
+  // float|double ? 1 : 2
+  static const byte kCode[] = {
+      WASM_IF_ELSE(WASM_GET_LOCAL(0), WASM_I8(0), WASM_I8(2))};
+  EXPECT_VERIFIES(sigs.i_i(), kCode);
+  EXPECT_FAILURE(sigs.i_f(), kCode);
+  EXPECT_FAILURE(sigs.i_d(), kCode);
+}
+
+TEST_F(AstDecoderTest, If_type2) {
+  // 1 ? float|double : 2
+  static const byte kCode[] = {
+      WASM_IF_ELSE(WASM_I8(1), WASM_GET_LOCAL(0), WASM_I8(1))};
+  EXPECT_VERIFIES(sigs.i_i(), kCode);
+  EXPECT_FAILURE(sigs.i_f(), kCode);
+  EXPECT_FAILURE(sigs.i_d(), kCode);
+}
+
+TEST_F(AstDecoderTest, If_type3) {
+  // stmt ? 0 : 1
+  static const byte kCode[] = {WASM_IF_ELSE(WASM_NOP, WASM_I8(0), WASM_I8(1))};
+  EXPECT_FAILURE(sigs.i_i(), kCode);
+  EXPECT_FAILURE(sigs.i_f(), kCode);
+  EXPECT_FAILURE(sigs.i_d(), kCode);
+}
+
+TEST_F(AstDecoderTest, If_type4) {
+  // 0 ? stmt : 1
+  static const byte kCode[] = {
+      WASM_IF_ELSE(WASM_GET_LOCAL(0), WASM_NOP, WASM_I8(1))};
+  EXPECT_FAILURE(sigs.i_i(), kCode);
+  EXPECT_FAILURE(sigs.i_f(), kCode);
+  EXPECT_FAILURE(sigs.i_d(), kCode);
+}
+
+TEST_F(AstDecoderTest, If_type5) {
+  // 0 ? 1 : stmt
+  static const byte kCode[] = {WASM_IF_ELSE(WASM_ZERO, WASM_I8(1), WASM_NOP)};
+  EXPECT_FAILURE(sigs.i_i(), kCode);
+  EXPECT_FAILURE(sigs.i_f(), kCode);
+  EXPECT_FAILURE(sigs.i_d(), kCode);
 }
 
 TEST_F(AstDecoderTest, Int64Local_param) {
@@ -669,8 +848,7 @@
   for (byte i = 1; i < 8; i++) {
     AddLocals(kAstI64, 1);
     for (byte j = 0; j < i; j++) {
-      byte code[] = {kExprGetLocal, j};
-      EXPECT_VERIFIES(sigs.l_v(), code);
+      EXPECT_VERIFIES_INLINE(sigs.l_v(), WASM_GET_LOCAL(j));
     }
   }
 }
@@ -737,7 +915,7 @@
   VERIFY(WASM_IF(WASM_GET_LOCAL(0), WASM_NOP));
   VERIFY(WASM_IF_ELSE(WASM_GET_LOCAL(0), WASM_NOP, WASM_NOP));
   VERIFY(WASM_NOP);
-  VERIFY(WASM_BLOCK(1, WASM_NOP));
+  VERIFY(B1(WASM_NOP));
   VERIFY(WASM_LOOP(1, WASM_NOP));
   VERIFY(WASM_LOOP(1, WASM_BREAK(0)));
   VERIFY(WASM_LOOP(1, WASM_CONTINUE(0)));
@@ -760,30 +938,30 @@
 }
 
 TEST_F(AstDecoderTest, MacrosVariadic) {
-  VERIFY(WASM_BLOCK(2, WASM_NOP, WASM_NOP));
-  VERIFY(WASM_BLOCK(3, WASM_NOP, WASM_NOP, WASM_NOP));
+  VERIFY(B2(WASM_NOP, WASM_NOP));
+  VERIFY(B3(WASM_NOP, WASM_NOP, WASM_NOP));
   VERIFY(WASM_LOOP(2, WASM_NOP, WASM_NOP));
   VERIFY(WASM_LOOP(3, WASM_NOP, WASM_NOP, WASM_NOP));
 }
 
 TEST_F(AstDecoderTest, MacrosNestedBlocks) {
-  VERIFY(WASM_BLOCK(2, WASM_NOP, WASM_BLOCK(2, WASM_NOP, WASM_NOP)));
-  VERIFY(WASM_BLOCK(3, WASM_NOP,                          // --
-                    WASM_BLOCK(2, WASM_NOP, WASM_NOP),    // --
-                    WASM_BLOCK(2, WASM_NOP, WASM_NOP)));  // --
-  VERIFY(WASM_BLOCK(1, WASM_BLOCK(1, WASM_BLOCK(2, WASM_NOP, WASM_NOP))));
+  VERIFY(B2(WASM_NOP, B2(WASM_NOP, WASM_NOP)));
+  VERIFY(B3(WASM_NOP,                  // --
+            B2(WASM_NOP, WASM_NOP),    // --
+            B2(WASM_NOP, WASM_NOP)));  // --
+  VERIFY(B1(B1(B2(WASM_NOP, WASM_NOP))));
 }
 
 TEST_F(AstDecoderTest, MultipleReturn) {
   static LocalType kIntTypes5[] = {kAstI32, kAstI32, kAstI32, kAstI32, kAstI32};
   FunctionSig sig_ii_v(2, 0, kIntTypes5);
-  EXPECT_VERIFIES_INLINE(&sig_ii_v, WASM_RETURN(WASM_ZERO, WASM_ONE));
-  EXPECT_FAILURE_INLINE(&sig_ii_v, WASM_RETURN(WASM_ZERO));
+  EXPECT_VERIFIES_INLINE(&sig_ii_v, WASM_RETURNN(2, WASM_ZERO, WASM_ONE));
+  EXPECT_FAILURE_INLINE(&sig_ii_v, WASM_RETURNN(1, WASM_ZERO));
 
   FunctionSig sig_iii_v(3, 0, kIntTypes5);
   EXPECT_VERIFIES_INLINE(&sig_iii_v,
-                         WASM_RETURN(WASM_ZERO, WASM_ONE, WASM_I8(44)));
-  EXPECT_FAILURE_INLINE(&sig_iii_v, WASM_RETURN(WASM_ZERO, WASM_ONE));
+                         WASM_RETURNN(3, WASM_ZERO, WASM_ONE, WASM_I8(44)));
+  EXPECT_FAILURE_INLINE(&sig_iii_v, WASM_RETURNN(2, WASM_ZERO, WASM_ONE));
 }
 
 TEST_F(AstDecoderTest, MultipleReturn_fallthru) {
@@ -887,78 +1065,57 @@
 }
 
 TEST_F(AstDecoderTest, GrowMemory) {
-  byte code[] = {kExprGrowMemory, kExprGetLocal, 0};
+  byte code[] = {WASM_UNOP(kExprGrowMemory, WASM_GET_LOCAL(0))};
   EXPECT_VERIFIES(sigs.i_i(), code);
   EXPECT_FAILURE(sigs.i_d(), code);
 }
 
 TEST_F(AstDecoderTest, LoadMemOffset) {
   for (int offset = 0; offset < 128; offset += 7) {
-    byte code[] = {kExprI32LoadMem, ZERO_ALIGNMENT, static_cast<byte>(offset),
-                   kExprI8Const, 0};
+    byte code[] = {kExprI8Const, 0, kExprI32LoadMem, ZERO_ALIGNMENT,
+                   static_cast<byte>(offset)};
     EXPECT_VERIFIES(sigs.i_i(), code);
   }
 }
 
 TEST_F(AstDecoderTest, StoreMemOffset) {
   for (int offset = 0; offset < 128; offset += 7) {
-    byte code[] = {
-        kExprI32StoreMem, 0, static_cast<byte>(offset), kExprI8Const, 0,
-        kExprI8Const,     0};
+    byte code[] = {WASM_STORE_MEM_OFFSET(MachineType::Int32(), offset,
+                                         WASM_ZERO, WASM_ZERO)};
     EXPECT_VERIFIES(sigs.i_i(), code);
   }
 }
 
-TEST_F(AstDecoderTest, LoadMemOffset_varint) {
-  byte code1[] = {kExprI32LoadMem, ZERO_ALIGNMENT, ZERO_OFFSET, kExprI8Const,
-                  0};
-  byte code2[] = {kExprI32LoadMem, ZERO_ALIGNMENT, 0x80, 1, kExprI8Const, 0};
-  byte code3[] = {
-      kExprI32LoadMem, ZERO_ALIGNMENT, 0x81, 0x82, 5, kExprI8Const, 0};
-  byte code4[] = {
-      kExprI32LoadMem, ZERO_ALIGNMENT, 0x83, 0x84, 0x85, 7, kExprI8Const, 0};
+#define BYTE0(x) ((x)&0x7F)
+#define BYTE1(x) ((x >> 7) & 0x7F)
+#define BYTE2(x) ((x >> 14) & 0x7F)
+#define BYTE3(x) ((x >> 21) & 0x7F)
 
-  EXPECT_VERIFIES(sigs.i_i(), code1);
-  EXPECT_VERIFIES(sigs.i_i(), code2);
-  EXPECT_VERIFIES(sigs.i_i(), code3);
-  EXPECT_VERIFIES(sigs.i_i(), code4);
+#define VARINT1(x) BYTE0(x)
+#define VARINT2(x) BYTE0(x) | 0x80, BYTE1(x)
+#define VARINT3(x) BYTE0(x) | 0x80, BYTE1(x) | 0x80, BYTE2(x)
+#define VARINT4(x) BYTE0(x) | 0x80, BYTE1(x) | 0x80, BYTE2(x) | 0x80, BYTE3(x)
+
+TEST_F(AstDecoderTest, LoadMemOffset_varint) {
+  EXPECT_VERIFIES_INLINE(sigs.i_i(), WASM_ZERO, kExprI32LoadMem, ZERO_ALIGNMENT,
+                         VARINT1(0x45));
+  EXPECT_VERIFIES_INLINE(sigs.i_i(), WASM_ZERO, kExprI32LoadMem, ZERO_ALIGNMENT,
+                         VARINT2(0x3999));
+  EXPECT_VERIFIES_INLINE(sigs.i_i(), WASM_ZERO, kExprI32LoadMem, ZERO_ALIGNMENT,
+                         VARINT3(0x344445));
+  EXPECT_VERIFIES_INLINE(sigs.i_i(), WASM_ZERO, kExprI32LoadMem, ZERO_ALIGNMENT,
+                         VARINT4(0x36666667));
 }
 
 TEST_F(AstDecoderTest, StoreMemOffset_varint) {
-  byte code1[] = {
-      kExprI32StoreMem, ZERO_ALIGNMENT, 0, kExprI8Const, 0, kExprI8Const, 0};
-  byte code2[] = {kExprI32StoreMem,
-                  ZERO_ALIGNMENT,
-                  0x80,
-                  1,
-                  kExprI8Const,
-                  0,
-                  kExprI8Const,
-                  0};
-  byte code3[] = {kExprI32StoreMem,
-                  ZERO_ALIGNMENT,
-                  0x81,
-                  0x82,
-                  5,
-                  kExprI8Const,
-                  0,
-                  kExprI8Const,
-                  0};
-  byte code4[] = {kExprI32StoreMem,
-                  ZERO_ALIGNMENT,
-                  0x83,
-                  0x84,
-                  0x85,
-                  7,
-                  kExprI8Const,
-                  0,
-                  kExprI8Const,
-                  0};
-
-  EXPECT_VERIFIES(sigs.i_i(), code1);
-  EXPECT_VERIFIES(sigs.i_i(), code2);
-  EXPECT_VERIFIES(sigs.i_i(), code3);
-  EXPECT_VERIFIES(sigs.i_i(), code4);
+  EXPECT_VERIFIES_INLINE(sigs.i_i(), WASM_ZERO, WASM_ZERO, kExprI32StoreMem,
+                         ZERO_ALIGNMENT, VARINT1(0x33));
+  EXPECT_VERIFIES_INLINE(sigs.i_i(), WASM_ZERO, WASM_ZERO, kExprI32StoreMem,
+                         ZERO_ALIGNMENT, VARINT2(0x1111));
+  EXPECT_VERIFIES_INLINE(sigs.i_i(), WASM_ZERO, WASM_ZERO, kExprI32StoreMem,
+                         ZERO_ALIGNMENT, VARINT3(0x222222));
+  EXPECT_VERIFIES_INLINE(sigs.i_i(), WASM_ZERO, WASM_ZERO, kExprI32StoreMem,
+                         ZERO_ALIGNMENT, VARINT4(0x44444444));
 }
 
 TEST_F(AstDecoderTest, AllLoadMemCombinations) {
@@ -966,9 +1123,7 @@
     LocalType local_type = kLocalTypes[i];
     for (size_t j = 0; j < arraysize(machineTypes); j++) {
       MachineType mem_type = machineTypes[j];
-      byte code[] = {
-          static_cast<byte>(WasmOpcodes::LoadStoreOpcodeOf(mem_type, false)),
-          ZERO_ALIGNMENT, ZERO_OFFSET, kExprI8Const, 0};
+      byte code[] = {WASM_LOAD_MEM(mem_type, WASM_ZERO)};
       FunctionSig sig(1, 0, &local_type);
       if (local_type == WasmOpcodes::LocalTypeFor(mem_type)) {
         EXPECT_VERIFIES(&sig, code);
@@ -984,14 +1139,7 @@
     LocalType local_type = kLocalTypes[i];
     for (size_t j = 0; j < arraysize(machineTypes); j++) {
       MachineType mem_type = machineTypes[j];
-      byte code[] = {
-          static_cast<byte>(WasmOpcodes::LoadStoreOpcodeOf(mem_type, true)),
-          ZERO_ALIGNMENT,
-          ZERO_OFFSET,
-          kExprI8Const,
-          0,
-          kExprGetLocal,
-          0};
+      byte code[] = {WASM_STORE_MEM(mem_type, WASM_ZERO, WASM_GET_LOCAL(0))};
       FunctionSig sig(0, 1, &local_type);
       if (local_type == WasmOpcodes::LocalTypeFor(mem_type)) {
         EXPECT_VERIFIES(&sig, code);
@@ -1002,7 +1150,6 @@
   }
 }
 
-
 namespace {
 // A helper for tests that require a module environment for functions and
 // globals.
@@ -1024,12 +1171,24 @@
     return static_cast<byte>(mod.signatures.size() - 1);
   }
   byte AddFunction(FunctionSig* sig) {
-    mod.functions.push_back({sig, 0, 0, 0, 0, 0, 0, 0, false, false});
+    mod.functions.push_back({sig,      // sig
+                             0,        // func_index
+                             0,        // sig_index
+                             0,        // name_offset
+                             0,        // name_length
+                             0,        // code_start_offset
+                             0,        // code_end_offset
+                             false});  // exported
     CHECK(mod.functions.size() <= 127);
     return static_cast<byte>(mod.functions.size() - 1);
   }
   byte AddImport(FunctionSig* sig) {
-    mod.import_table.push_back({sig, 0, 0});
+    mod.import_table.push_back({sig,  // sig
+                                0,    // sig_index
+                                0,    // module_name_offset
+                                0,    // module_name_length
+                                0,    // function_name_offset
+                                0});  // function_name_length
     CHECK(mod.import_table.size() <= 127);
     return static_cast<byte>(mod.import_table.size() - 1);
   }
@@ -1048,9 +1207,9 @@
   module_env.AddFunction(sigs.i_i());
   module_env.AddFunction(sigs.i_ii());
 
-  EXPECT_VERIFIES_INLINE(sig, WASM_CALL_FUNCTION(0));
-  EXPECT_VERIFIES_INLINE(sig, WASM_CALL_FUNCTION(1, WASM_I8(27)));
-  EXPECT_VERIFIES_INLINE(sig, WASM_CALL_FUNCTION(2, WASM_I8(37), WASM_I8(77)));
+  EXPECT_VERIFIES_INLINE(sig, WASM_CALL_FUNCTION0(0));
+  EXPECT_VERIFIES_INLINE(sig, WASM_CALL_FUNCTION1(1, WASM_I8(27)));
+  EXPECT_VERIFIES_INLINE(sig, WASM_CALL_FUNCTION2(2, WASM_I8(37), WASM_I8(77)));
 }
 
 TEST_F(AstDecoderTest, CallsWithTooFewArguments) {
@@ -1063,35 +1222,8 @@
   module_env.AddFunction(sigs.f_ff());
 
   EXPECT_FAILURE_INLINE(sig, WASM_CALL_FUNCTION0(0));
-  EXPECT_FAILURE_INLINE(sig, WASM_CALL_FUNCTION(1, WASM_ZERO));
-  EXPECT_FAILURE_INLINE(sig, WASM_CALL_FUNCTION(2, WASM_GET_LOCAL(0)));
-}
-
-TEST_F(AstDecoderTest, CallsWithSpilloverArgs) {
-  static LocalType a_i_ff[] = {kAstI32, kAstF32, kAstF32};
-  FunctionSig sig_i_ff(1, 2, a_i_ff);
-
-  TestModuleEnv module_env;
-  module = &module_env;
-
-  module_env.AddFunction(&sig_i_ff);
-
-  EXPECT_VERIFIES_INLINE(sigs.i_i(),
-                         WASM_CALL_FUNCTION(0, WASM_F32(0.1), WASM_F32(0.1)));
-
-  EXPECT_VERIFIES_INLINE(sigs.i_ff(),
-                         WASM_CALL_FUNCTION(0, WASM_F32(0.1), WASM_F32(0.1)));
-
-  EXPECT_FAILURE_INLINE(sigs.f_ff(),
-                        WASM_CALL_FUNCTION(0, WASM_F32(0.1), WASM_F32(0.1)));
-
-  EXPECT_FAILURE_INLINE(
-      sigs.i_i(),
-      WASM_CALL_FUNCTION(0, WASM_F32(0.1), WASM_F32(0.1), WASM_F32(0.2)));
-
-  EXPECT_VERIFIES_INLINE(
-      sigs.f_ff(),
-      WASM_CALL_FUNCTION(0, WASM_F32(0.1), WASM_F32(0.1), WASM_F32(11)));
+  EXPECT_FAILURE_INLINE(sig, WASM_CALL_FUNCTION1(1, WASM_ZERO));
+  EXPECT_FAILURE_INLINE(sig, WASM_CALL_FUNCTION1(2, WASM_GET_LOCAL(0)));
 }
 
 TEST_F(AstDecoderTest, CallsWithMismatchedSigs2) {
@@ -1101,9 +1233,9 @@
 
   module_env.AddFunction(sigs.i_i());
 
-  EXPECT_FAILURE_INLINE(sig, WASM_CALL_FUNCTION(0, WASM_I64V_1(17)));
-  EXPECT_FAILURE_INLINE(sig, WASM_CALL_FUNCTION(0, WASM_F32(17.1)));
-  EXPECT_FAILURE_INLINE(sig, WASM_CALL_FUNCTION(0, WASM_F64(17.1)));
+  EXPECT_FAILURE_INLINE(sig, WASM_CALL_FUNCTION1(0, WASM_I64V_1(17)));
+  EXPECT_FAILURE_INLINE(sig, WASM_CALL_FUNCTION1(0, WASM_F32(17.1)));
+  EXPECT_FAILURE_INLINE(sig, WASM_CALL_FUNCTION1(0, WASM_F64(17.1)));
 }
 
 TEST_F(AstDecoderTest, CallsWithMismatchedSigs3) {
@@ -1113,15 +1245,15 @@
 
   module_env.AddFunction(sigs.i_f());
 
-  EXPECT_FAILURE_INLINE(sig, WASM_CALL_FUNCTION(0, WASM_I8(17)));
-  EXPECT_FAILURE_INLINE(sig, WASM_CALL_FUNCTION(0, WASM_I64V_1(27)));
-  EXPECT_FAILURE_INLINE(sig, WASM_CALL_FUNCTION(0, WASM_F64(37.2)));
+  EXPECT_FAILURE_INLINE(sig, WASM_CALL_FUNCTION1(0, WASM_I8(17)));
+  EXPECT_FAILURE_INLINE(sig, WASM_CALL_FUNCTION1(0, WASM_I64V_1(27)));
+  EXPECT_FAILURE_INLINE(sig, WASM_CALL_FUNCTION1(0, WASM_F64(37.2)));
 
   module_env.AddFunction(sigs.i_d());
 
-  EXPECT_FAILURE_INLINE(sig, WASM_CALL_FUNCTION(1, WASM_I8(16)));
-  EXPECT_FAILURE_INLINE(sig, WASM_CALL_FUNCTION(1, WASM_I64V_1(16)));
-  EXPECT_FAILURE_INLINE(sig, WASM_CALL_FUNCTION(1, WASM_F32(17.6)));
+  EXPECT_FAILURE_INLINE(sig, WASM_CALL_FUNCTION1(1, WASM_I8(16)));
+  EXPECT_FAILURE_INLINE(sig, WASM_CALL_FUNCTION1(1, WASM_I64V_1(16)));
+  EXPECT_FAILURE_INLINE(sig, WASM_CALL_FUNCTION1(1, WASM_F32(17.6)));
 }
 
 TEST_F(AstDecoderTest, SimpleIndirectCalls) {
@@ -1134,9 +1266,9 @@
   byte f2 = module_env.AddSignature(sigs.i_ii());
 
   EXPECT_VERIFIES_INLINE(sig, WASM_CALL_INDIRECT0(f0, WASM_ZERO));
-  EXPECT_VERIFIES_INLINE(sig, WASM_CALL_INDIRECT(f1, WASM_ZERO, WASM_I8(22)));
+  EXPECT_VERIFIES_INLINE(sig, WASM_CALL_INDIRECT1(f1, WASM_ZERO, WASM_I8(22)));
   EXPECT_VERIFIES_INLINE(
-      sig, WASM_CALL_INDIRECT(f2, WASM_ZERO, WASM_I8(32), WASM_I8(72)));
+      sig, WASM_CALL_INDIRECT2(f2, WASM_ZERO, WASM_I8(32), WASM_I8(72)));
 }
 
 TEST_F(AstDecoderTest, IndirectCallsOutOfBounds) {
@@ -1148,11 +1280,11 @@
   module_env.AddSignature(sigs.i_v());
   EXPECT_VERIFIES_INLINE(sig, WASM_CALL_INDIRECT0(0, WASM_ZERO));
 
-  EXPECT_FAILURE_INLINE(sig, WASM_CALL_INDIRECT(1, WASM_ZERO, WASM_I8(22)));
+  EXPECT_FAILURE_INLINE(sig, WASM_CALL_INDIRECT1(1, WASM_ZERO, WASM_I8(22)));
   module_env.AddSignature(sigs.i_i());
-  EXPECT_VERIFIES_INLINE(sig, WASM_CALL_INDIRECT(1, WASM_ZERO, WASM_I8(27)));
+  EXPECT_VERIFIES_INLINE(sig, WASM_CALL_INDIRECT1(1, WASM_ZERO, WASM_I8(27)));
 
-  EXPECT_FAILURE_INLINE(sig, WASM_CALL_INDIRECT(2, WASM_ZERO, WASM_I8(27)));
+  EXPECT_FAILURE_INLINE(sig, WASM_CALL_INDIRECT1(2, WASM_ZERO, WASM_I8(27)));
 }
 
 TEST_F(AstDecoderTest, IndirectCallsWithMismatchedSigs3) {
@@ -1162,10 +1294,11 @@
 
   byte f0 = module_env.AddFunction(sigs.i_f());
 
-  EXPECT_FAILURE_INLINE(sig, WASM_CALL_INDIRECT(f0, WASM_ZERO, WASM_I8(17)));
+  EXPECT_FAILURE_INLINE(sig, WASM_CALL_INDIRECT1(f0, WASM_ZERO, WASM_I8(17)));
   EXPECT_FAILURE_INLINE(sig,
-                        WASM_CALL_INDIRECT(f0, WASM_ZERO, WASM_I64V_1(27)));
-  EXPECT_FAILURE_INLINE(sig, WASM_CALL_INDIRECT(f0, WASM_ZERO, WASM_F64(37.2)));
+                        WASM_CALL_INDIRECT1(f0, WASM_ZERO, WASM_I64V_1(27)));
+  EXPECT_FAILURE_INLINE(sig,
+                        WASM_CALL_INDIRECT1(f0, WASM_ZERO, WASM_F64(37.2)));
 
   EXPECT_FAILURE_INLINE(sig, WASM_CALL_INDIRECT0(f0, WASM_I8(17)));
   EXPECT_FAILURE_INLINE(sig, WASM_CALL_INDIRECT0(f0, WASM_I64V_1(27)));
@@ -1173,10 +1306,11 @@
 
   byte f1 = module_env.AddFunction(sigs.i_d());
 
-  EXPECT_FAILURE_INLINE(sig, WASM_CALL_INDIRECT(f1, WASM_ZERO, WASM_I8(16)));
+  EXPECT_FAILURE_INLINE(sig, WASM_CALL_INDIRECT1(f1, WASM_ZERO, WASM_I8(16)));
   EXPECT_FAILURE_INLINE(sig,
-                        WASM_CALL_INDIRECT(f1, WASM_ZERO, WASM_I64V_1(16)));
-  EXPECT_FAILURE_INLINE(sig, WASM_CALL_INDIRECT(f1, WASM_ZERO, WASM_F32(17.6)));
+                        WASM_CALL_INDIRECT1(f1, WASM_ZERO, WASM_I64V_1(16)));
+  EXPECT_FAILURE_INLINE(sig,
+                        WASM_CALL_INDIRECT1(f1, WASM_ZERO, WASM_F32(17.6)));
 }
 
 TEST_F(AstDecoderTest, SimpleImportCalls) {
@@ -1189,8 +1323,8 @@
   byte f2 = module_env.AddImport(sigs.i_ii());
 
   EXPECT_VERIFIES_INLINE(sig, WASM_CALL_IMPORT0(f0));
-  EXPECT_VERIFIES_INLINE(sig, WASM_CALL_IMPORT(f1, WASM_I8(22)));
-  EXPECT_VERIFIES_INLINE(sig, WASM_CALL_IMPORT(f2, WASM_I8(32), WASM_I8(72)));
+  EXPECT_VERIFIES_INLINE(sig, WASM_CALL_IMPORT1(f1, WASM_I8(22)));
+  EXPECT_VERIFIES_INLINE(sig, WASM_CALL_IMPORT2(f2, WASM_I8(32), WASM_I8(72)));
 }
 
 TEST_F(AstDecoderTest, ImportCallsWithMismatchedSigs3) {
@@ -1201,16 +1335,16 @@
   byte f0 = module_env.AddImport(sigs.i_f());
 
   EXPECT_FAILURE_INLINE(sig, WASM_CALL_IMPORT0(f0));
-  EXPECT_FAILURE_INLINE(sig, WASM_CALL_IMPORT(f0, WASM_I8(17)));
-  EXPECT_FAILURE_INLINE(sig, WASM_CALL_IMPORT(f0, WASM_I64V_1(27)));
-  EXPECT_FAILURE_INLINE(sig, WASM_CALL_IMPORT(f0, WASM_F64(37.2)));
+  EXPECT_FAILURE_INLINE(sig, WASM_CALL_IMPORT1(f0, WASM_I8(17)));
+  EXPECT_FAILURE_INLINE(sig, WASM_CALL_IMPORT1(f0, WASM_I64V_1(27)));
+  EXPECT_FAILURE_INLINE(sig, WASM_CALL_IMPORT1(f0, WASM_F64(37.2)));
 
   byte f1 = module_env.AddImport(sigs.i_d());
 
   EXPECT_FAILURE_INLINE(sig, WASM_CALL_IMPORT0(f1));
-  EXPECT_FAILURE_INLINE(sig, WASM_CALL_IMPORT(f1, WASM_I8(16)));
-  EXPECT_FAILURE_INLINE(sig, WASM_CALL_IMPORT(f1, WASM_I64V_1(16)));
-  EXPECT_FAILURE_INLINE(sig, WASM_CALL_IMPORT(f1, WASM_F32(17.6)));
+  EXPECT_FAILURE_INLINE(sig, WASM_CALL_IMPORT1(f1, WASM_I8(16)));
+  EXPECT_FAILURE_INLINE(sig, WASM_CALL_IMPORT1(f1, WASM_I64V_1(16)));
+  EXPECT_FAILURE_INLINE(sig, WASM_CALL_IMPORT1(f1, WASM_F32(17.6)));
 }
 
 TEST_F(AstDecoderTest, Int32Globals) {
@@ -1334,11 +1468,29 @@
   }
 }
 
+TEST_F(AstDecoderTest, BreakEnd) {
+  EXPECT_VERIFIES_INLINE(sigs.i_i(),
+                         B1(WASM_I32_ADD(WASM_BRV(0, WASM_ZERO), WASM_ZERO)));
+  EXPECT_VERIFIES_INLINE(sigs.i_i(),
+                         B1(WASM_I32_ADD(WASM_ZERO, WASM_BRV(0, WASM_ZERO))));
+}
+
+TEST_F(AstDecoderTest, BreakIfBinop) {
+  EXPECT_FAILURE_INLINE(
+      sigs.i_i(),
+      WASM_BLOCK(
+          1, WASM_I32_ADD(WASM_BRV_IF(0, WASM_ZERO, WASM_ZERO), WASM_ZERO)));
+  EXPECT_FAILURE_INLINE(
+      sigs.i_i(),
+      WASM_BLOCK(
+          1, WASM_I32_ADD(WASM_ZERO, WASM_BRV_IF(0, WASM_ZERO, WASM_ZERO))));
+}
+
 TEST_F(AstDecoderTest, BreakNesting1) {
   for (int i = 0; i < 5; i++) {
     // (block[2] (loop[2] (if (get p) break[N]) (set p 1)) p)
     byte code[] = {WASM_BLOCK(
-        2, WASM_LOOP(2, WASM_IF(WASM_GET_LOCAL(0), WASM_BRV(i, WASM_ZERO)),
+        2, WASM_LOOP(2, WASM_IF(WASM_GET_LOCAL(0), WASM_BRV(i + 1, WASM_ZERO)),
                      WASM_SET_LOCAL(0, WASM_I8(1))),
         WASM_GET_LOCAL(0))};
     if (i < 3) {
@@ -1353,8 +1505,8 @@
   AddLocals(kAstI32, 1);
   for (int i = 0; i < 5; i++) {
     // (block[2] (loop[2] (if 0 break[N]) (set p 1)) (return p)) (11)
-    byte code[] = {WASM_BLOCK(1, WASM_LOOP(2, WASM_IF(WASM_ZERO, WASM_BREAK(i)),
-                                           WASM_SET_LOCAL(0, WASM_I8(1)))),
+    byte code[] = {B1(WASM_LOOP(2, WASM_IF(WASM_ZERO, WASM_BREAK(i + 1)),
+                                WASM_SET_LOCAL(0, WASM_I8(1)))),
                    WASM_I8(11)};
     if (i < 2) {
       EXPECT_VERIFIES(sigs.v_v(), code);
@@ -1367,8 +1519,8 @@
 TEST_F(AstDecoderTest, BreakNesting3) {
   for (int i = 0; i < 5; i++) {
     // (block[1] (loop[1] (block[1] (if 0 break[N])
-    byte code[] = {WASM_BLOCK(
-        1, WASM_LOOP(1, WASM_BLOCK(1, WASM_IF(WASM_ZERO, WASM_BREAK(i)))))};
+    byte code[] = {
+        WASM_BLOCK(1, WASM_LOOP(1, B1(WASM_IF(WASM_ZERO, WASM_BREAK(i + 1)))))};
     if (i < 3) {
       EXPECT_VERIFIES(sigs.v_v(), code);
     } else {
@@ -1378,41 +1530,42 @@
 }
 
 TEST_F(AstDecoderTest, BreaksWithMultipleTypes) {
-  EXPECT_FAILURE_INLINE(
-      sigs.i_i(),
-      WASM_BLOCK(2, WASM_BRV_IF_ZERO(0, WASM_I8(7)), WASM_F32(7.7)));
+  EXPECT_FAILURE_INLINE(sigs.i_i(),
+                        B2(WASM_BRV_IF_ZERO(0, WASM_I8(7)), WASM_F32(7.7)));
 
-  EXPECT_FAILURE_INLINE(sigs.i_i(),
-                        WASM_BLOCK(2, WASM_BRV_IF_ZERO(0, WASM_I8(7)),
-                                   WASM_BRV_IF_ZERO(0, WASM_F32(7.7))));
-  EXPECT_FAILURE_INLINE(sigs.i_i(),
-                        WASM_BLOCK(3, WASM_BRV_IF_ZERO(0, WASM_I8(8)),
-                                   WASM_BRV_IF_ZERO(0, WASM_I8(0)),
-                                   WASM_BRV_IF_ZERO(0, WASM_F32(7.7))));
-  EXPECT_FAILURE_INLINE(sigs.i_i(),
-                        WASM_BLOCK(3, WASM_BRV_IF_ZERO(0, WASM_I8(9)),
-                                   WASM_BRV_IF_ZERO(0, WASM_F32(7.7)),
-                                   WASM_BRV_IF_ZERO(0, WASM_I8(11))));
+  EXPECT_FAILURE_INLINE(sigs.i_i(), B2(WASM_BRV_IF_ZERO(0, WASM_I8(7)),
+                                       WASM_BRV_IF_ZERO(0, WASM_F32(7.7))));
+  EXPECT_FAILURE_INLINE(sigs.i_i(), B3(WASM_BRV_IF_ZERO(0, WASM_I8(8)),
+                                       WASM_BRV_IF_ZERO(0, WASM_I8(0)),
+                                       WASM_BRV_IF_ZERO(0, WASM_F32(7.7))));
+  EXPECT_FAILURE_INLINE(sigs.i_i(), B3(WASM_BRV_IF_ZERO(0, WASM_I8(9)),
+                                       WASM_BRV_IF_ZERO(0, WASM_F32(7.7)),
+                                       WASM_BRV_IF_ZERO(0, WASM_I8(11))));
 }
 
 TEST_F(AstDecoderTest, BreakNesting_6_levels) {
   for (int mask = 0; mask < 64; mask++) {
     for (int i = 0; i < 14; i++) {
       byte code[] = {
-          kExprBlock, 1,  // --
-          kExprBlock, 1,  // --
-          kExprBlock, 1,  // --
-          kExprBlock, 1,  // --
-          kExprBlock, 1,  // --
-          kExprBlock, 1,  // --
-          kExprBr,    static_cast<byte>(i),
-          kExprNop  // --
+          kExprBlock,                                 // --
+          kExprBlock,                                 // --
+          kExprBlock,                                 // --
+          kExprBlock,                                 // --
+          kExprBlock,                                 // --
+          kExprBlock,                                 // --
+          kExprBr,    ARITY_0, static_cast<byte>(i),  // --
+          kExprEnd,                                   // --
+          kExprEnd,                                   // --
+          kExprEnd,                                   // --
+          kExprEnd,                                   // --
+          kExprEnd,                                   // --
+          kExprEnd                                    // --
       };
 
       int depth = 6;
       for (int l = 0; l < 6; l++) {
         if (mask & (1 << l)) {
-          code[l * 2] = kExprLoop;
+          code[l] = kExprLoop;
           depth++;
         }
       }
@@ -1432,29 +1585,27 @@
     FunctionSig* sig = sigarray[i];
     // unify X and X => OK
     EXPECT_VERIFIES_INLINE(
-        sig, WASM_BLOCK(2, WASM_IF(WASM_ZERO, WASM_BRV(0, WASM_GET_LOCAL(0))),
-                        WASM_GET_LOCAL(0)));
+        sig, B2(WASM_IF(WASM_ZERO, WASM_BRV(0, WASM_GET_LOCAL(0))),
+                WASM_GET_LOCAL(0)));
   }
 
   // unify i32 and f32 => fail
   EXPECT_FAILURE_INLINE(
       sigs.i_i(),
-      WASM_BLOCK(2, WASM_IF(WASM_ZERO, WASM_BRV(0, WASM_ZERO)), WASM_F32(1.2)));
+      B2(WASM_IF(WASM_ZERO, WASM_BRV(0, WASM_ZERO)), WASM_F32(1.2)));
 
   // unify f64 and f64 => OK
   EXPECT_VERIFIES_INLINE(
       sigs.d_dd(),
-      WASM_BLOCK(2, WASM_IF(WASM_ZERO, WASM_BRV(0, WASM_GET_LOCAL(0))),
-                 WASM_F64(1.2)));
+      B2(WASM_IF(WASM_ZERO, WASM_BRV(0, WASM_GET_LOCAL(0))), WASM_F64(1.2)));
 }
 
 TEST_F(AstDecoderTest, ExprBreak_TypeCheckAll) {
   byte code1[] = {WASM_BLOCK(2,
                              WASM_IF(WASM_ZERO, WASM_BRV(0, WASM_GET_LOCAL(0))),
                              WASM_GET_LOCAL(1))};
-  byte code2[] = {
-      WASM_BLOCK(2, WASM_IF(WASM_ZERO, WASM_BRV_IF_ZERO(0, WASM_GET_LOCAL(0))),
-                 WASM_GET_LOCAL(1))};
+  byte code2[] = {B2(WASM_IF(WASM_ZERO, WASM_BRV_IF_ZERO(0, WASM_GET_LOCAL(0))),
+                     WASM_GET_LOCAL(1))};
 
   for (size_t i = 0; i < arraysize(kLocalTypes); i++) {
     for (size_t j = 0; j < arraysize(kLocalTypes); j++) {
@@ -1479,14 +1630,12 @@
       LocalType storage[] = {kAstI32, kAstI32, type};
       FunctionSig sig(1, 2, storage);
 
-      byte code1[] = {
-          WASM_BLOCK(2, WASM_IF(WASM_ZERO, WASM_BRV(0, WASM_GET_LOCAL(which))),
-                     WASM_GET_LOCAL(which ^ 1))};
+      byte code1[] = {B2(WASM_IF(WASM_ZERO, WASM_BRV(1, WASM_GET_LOCAL(which))),
+                         WASM_GET_LOCAL(which ^ 1))};
       byte code2[] = {
-          WASM_LOOP(2, WASM_IF(WASM_ZERO, WASM_BRV(1, WASM_GET_LOCAL(which))),
+          WASM_LOOP(2, WASM_IF(WASM_ZERO, WASM_BRV(2, WASM_GET_LOCAL(which))),
                     WASM_GET_LOCAL(which ^ 1))};
 
-
       if (type == kAstI32) {
         EXPECT_VERIFIES(&sig, code1);
         EXPECT_VERIFIES(&sig, code2);
@@ -1499,8 +1648,7 @@
 }
 
 TEST_F(AstDecoderTest, ExprBrIf_cond_type) {
-  byte code[] = {
-      WASM_BLOCK(1, WASM_BRV_IF(0, WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)))};
+  byte code[] = {B1(WASM_BRV_IF(0, WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)))};
   for (size_t i = 0; i < arraysize(kLocalTypes); i++) {
     for (size_t j = 0; j < arraysize(kLocalTypes); j++) {
       LocalType types[] = {kLocalTypes[i], kLocalTypes[j]};
@@ -1516,9 +1664,8 @@
 }
 
 TEST_F(AstDecoderTest, ExprBrIf_val_type) {
-  byte code[] = {
-      WASM_BLOCK(2, WASM_BRV_IF(0, WASM_GET_LOCAL(1), WASM_GET_LOCAL(2)),
-                 WASM_GET_LOCAL(0))};
+  byte code[] = {B2(WASM_BRV_IF(0, WASM_GET_LOCAL(1), WASM_GET_LOCAL(2)),
+                    WASM_GET_LOCAL(0))};
   for (size_t i = 0; i < arraysize(kLocalTypes); i++) {
     for (size_t j = 0; j < arraysize(kLocalTypes); j++) {
       LocalType types[] = {kLocalTypes[i], kLocalTypes[i], kLocalTypes[j],
@@ -1541,8 +1688,8 @@
       LocalType storage[] = {kAstI32, kAstI32, type};
       FunctionSig sig(1, 2, storage);
 
-      byte code1[] = {WASM_BLOCK(2, WASM_BRV_IF_ZERO(0, WASM_GET_LOCAL(which)),
-                                 WASM_GET_LOCAL(which ^ 1))};
+      byte code1[] = {B2(WASM_BRV_IF_ZERO(0, WASM_GET_LOCAL(which)),
+                         WASM_GET_LOCAL(which ^ 1))};
       byte code2[] = {WASM_LOOP(2, WASM_BRV_IF_ZERO(1, WASM_GET_LOCAL(which)),
                                 WASM_GET_LOCAL(which ^ 1))};
 
@@ -1558,31 +1705,29 @@
 }
 
 TEST_F(AstDecoderTest, BrTable0) {
-  static byte code[] = {kExprBrTable, 0, 0};
+  static byte code[] = {kExprNop, kExprBrTable, 0, 0};
   EXPECT_FAILURE(sigs.v_v(), code);
 }
 
 TEST_F(AstDecoderTest, BrTable0b) {
-  static byte code[] = {kExprBrTable, 0, 0, kExprI32Const, 11};
+  static byte code[] = {kExprNop, kExprI32Const, 11, kExprBrTable, 0, 0};
   EXPECT_FAILURE(sigs.v_v(), code);
   EXPECT_FAILURE(sigs.i_i(), code);
 }
 
 TEST_F(AstDecoderTest, BrTable0c) {
-  static byte code[] = {kExprBrTable, 0, 1, 0, 0, kExprI32Const, 11};
+  static byte code[] = {kExprNop, kExprI32Const, 11, kExprBrTable, 0, 1, 0, 0};
   EXPECT_FAILURE(sigs.v_v(), code);
   EXPECT_FAILURE(sigs.i_i(), code);
 }
 
 TEST_F(AstDecoderTest, BrTable1a) {
-  static byte code[] = {
-      WASM_BLOCK(1, WASM_BR_TABLE(WASM_I8(67), 0, BR_TARGET(0)))};
+  static byte code[] = {B1(WASM_BR_TABLE(WASM_I8(67), 0, BR_TARGET(0)))};
   EXPECT_VERIFIES(sigs.v_v(), code);
 }
 
 TEST_F(AstDecoderTest, BrTable1b) {
-  static byte code[] = {
-      WASM_BLOCK(1, WASM_BR_TABLE(WASM_ZERO, 0, BR_TARGET(0)))};
+  static byte code[] = {B1(WASM_BR_TABLE(WASM_ZERO, 0, BR_TARGET(0)))};
   EXPECT_VERIFIES(sigs.v_v(), code);
   EXPECT_FAILURE(sigs.i_i(), code);
   EXPECT_FAILURE(sigs.f_ff(), code);
@@ -1591,7 +1736,7 @@
 
 TEST_F(AstDecoderTest, BrTable2a) {
   static byte code[] = {
-      WASM_BLOCK(1, WASM_BR_TABLE(WASM_I8(67), 1, BR_TARGET(0), BR_TARGET(0)))};
+      B1(WASM_BR_TABLE(WASM_I8(67), 1, BR_TARGET(0), BR_TARGET(0)))};
   EXPECT_VERIFIES(sigs.v_v(), code);
 }
 
@@ -1603,8 +1748,7 @@
 }
 
 TEST_F(AstDecoderTest, BrTable_off_end) {
-  static byte code[] = {
-      WASM_BLOCK(1, WASM_BR_TABLE(WASM_GET_LOCAL(0), 0, BR_TARGET(0)))};
+  static byte code[] = {B1(WASM_BR_TABLE(WASM_GET_LOCAL(0), 0, BR_TARGET(0)))};
   for (size_t len = 1; len < sizeof(code); len++) {
     Verify(kError, sigs.i_i(), code, code + len);
   }
@@ -1612,8 +1756,7 @@
 
 TEST_F(AstDecoderTest, BrTable_invalid_br1) {
   for (int depth = 0; depth < 4; depth++) {
-    byte code[] = {
-        WASM_BLOCK(1, WASM_BR_TABLE(WASM_GET_LOCAL(0), 0, BR_TARGET(depth)))};
+    byte code[] = {B1(WASM_BR_TABLE(WASM_GET_LOCAL(0), 0, BR_TARGET(depth)))};
     if (depth == 0) {
       EXPECT_VERIFIES(sigs.v_i(), code);
     } else {
@@ -1635,11 +1778,10 @@
 }
 
 TEST_F(AstDecoderTest, ExprBreakNesting1) {
-  EXPECT_VERIFIES_INLINE(sigs.v_v(), WASM_BLOCK(1, WASM_BRV(0, WASM_ZERO)));
-  EXPECT_VERIFIES_INLINE(sigs.v_v(), WASM_BLOCK(1, WASM_BR(0)));
-  EXPECT_VERIFIES_INLINE(sigs.v_v(),
-                         WASM_BLOCK(1, WASM_BRV_IF(0, WASM_ZERO, WASM_ZERO)));
-  EXPECT_VERIFIES_INLINE(sigs.v_v(), WASM_BLOCK(1, WASM_BR_IF(0, WASM_ZERO)));
+  EXPECT_VERIFIES_INLINE(sigs.v_v(), B1(WASM_BRV(0, WASM_ZERO)));
+  EXPECT_VERIFIES_INLINE(sigs.v_v(), B1(WASM_BR(0)));
+  EXPECT_VERIFIES_INLINE(sigs.v_v(), B1(WASM_BRV_IF(0, WASM_ZERO, WASM_ZERO)));
+  EXPECT_VERIFIES_INLINE(sigs.v_v(), B1(WASM_BR_IF(0, WASM_ZERO)));
 
   EXPECT_VERIFIES_INLINE(sigs.v_v(), WASM_LOOP(1, WASM_BRV(0, WASM_ZERO)));
   EXPECT_VERIFIES_INLINE(sigs.v_v(), WASM_LOOP(1, WASM_BR(0)));
@@ -1714,7 +1856,6 @@
       WASM_SELECT(WASM_F32(9.9), WASM_GET_LOCAL(0), WASM_I64V_1(0)));
 }
 
-
 class WasmOpcodeLengthTest : public TestWithZone {
  public:
   WasmOpcodeLengthTest() : TestWithZone() {}
@@ -1734,16 +1875,16 @@
 
 TEST_F(WasmOpcodeLengthTest, Statements) {
   EXPECT_LENGTH(1, kExprNop);
-  EXPECT_LENGTH(2, kExprBlock);
-  EXPECT_LENGTH(2, kExprLoop);
+  EXPECT_LENGTH(1, kExprBlock);
+  EXPECT_LENGTH(1, kExprLoop);
   EXPECT_LENGTH(1, kExprIf);
-  EXPECT_LENGTH(1, kExprIfElse);
+  EXPECT_LENGTH(1, kExprElse);
+  EXPECT_LENGTH(1, kExprEnd);
   EXPECT_LENGTH(1, kExprSelect);
-  EXPECT_LENGTH(2, kExprBr);
-  EXPECT_LENGTH(2, kExprBrIf);
+  EXPECT_LENGTH(3, kExprBr);
+  EXPECT_LENGTH(3, kExprBrIf);
 }
 
-
 TEST_F(WasmOpcodeLengthTest, MiscExpressions) {
   EXPECT_LENGTH(2, kExprI8Const);
   EXPECT_LENGTH(5, kExprF32Const);
@@ -1752,15 +1893,14 @@
   EXPECT_LENGTH(2, kExprSetLocal);
   EXPECT_LENGTH(2, kExprLoadGlobal);
   EXPECT_LENGTH(2, kExprStoreGlobal);
-  EXPECT_LENGTH(2, kExprCallFunction);
-  EXPECT_LENGTH(2, kExprCallImport);
-  EXPECT_LENGTH(2, kExprCallIndirect);
+  EXPECT_LENGTH(3, kExprCallFunction);
+  EXPECT_LENGTH(3, kExprCallImport);
+  EXPECT_LENGTH(3, kExprCallIndirect);
   EXPECT_LENGTH(1, kExprIf);
-  EXPECT_LENGTH(1, kExprIfElse);
-  EXPECT_LENGTH(2, kExprBlock);
-  EXPECT_LENGTH(2, kExprLoop);
-  EXPECT_LENGTH(2, kExprBr);
-  EXPECT_LENGTH(2, kExprBrIf);
+  EXPECT_LENGTH(1, kExprBlock);
+  EXPECT_LENGTH(1, kExprLoop);
+  EXPECT_LENGTH(3, kExprBr);
+  EXPECT_LENGTH(3, kExprBrIf);
 }
 
 TEST_F(WasmOpcodeLengthTest, I32Const) {
@@ -1818,13 +1958,11 @@
   EXPECT_LENGTH(3, kExprF64StoreMem);
 }
 
-
 TEST_F(WasmOpcodeLengthTest, MiscMemExpressions) {
   EXPECT_LENGTH(1, kExprMemorySize);
   EXPECT_LENGTH(1, kExprGrowMemory);
 }
 
-
 TEST_F(WasmOpcodeLengthTest, SimpleExpressions) {
   EXPECT_LENGTH(1, kExprI32Add);
   EXPECT_LENGTH(1, kExprI32Sub);
@@ -1946,54 +2084,49 @@
   EXPECT_LENGTH(1, kExprI64ReinterpretF64);
 }
 
-
 class WasmOpcodeArityTest : public TestWithZone {
  public:
   WasmOpcodeArityTest() : TestWithZone() {}
-  TestModuleEnv module;
-  TestSignatures sigs;
 };
 
-#define EXPECT_ARITY(expected, ...)                                            \
-  {                                                                            \
-    static const byte code[] = {__VA_ARGS__};                                  \
-    EXPECT_EQ(expected, OpcodeArity(&module, sig, code, code + sizeof(code))); \
+#define EXPECT_ARITY(expected, ...)                              \
+  {                                                              \
+    static const byte code[] = {__VA_ARGS__};                    \
+    EXPECT_EQ(expected, OpcodeArity(code, code + sizeof(code))); \
   }
 
 TEST_F(WasmOpcodeArityTest, Control) {
-  FunctionSig* sig = sigs.v_v();
   EXPECT_ARITY(0, kExprNop);
 
   EXPECT_ARITY(0, kExprBlock, 0);
-  EXPECT_ARITY(1, kExprBlock, 1);
-  EXPECT_ARITY(2, kExprBlock, 2);
-  EXPECT_ARITY(5, kExprBlock, 5);
-  EXPECT_ARITY(10, kExprBlock, 10);
+  EXPECT_ARITY(0, kExprBlock, 1);
+  EXPECT_ARITY(0, kExprBlock, 2);
+  EXPECT_ARITY(0, kExprBlock, 5);
+  EXPECT_ARITY(0, kExprBlock, 10);
 
   EXPECT_ARITY(0, kExprLoop, 0);
-  EXPECT_ARITY(1, kExprLoop, 1);
-  EXPECT_ARITY(2, kExprLoop, 2);
-  EXPECT_ARITY(7, kExprLoop, 7);
-  EXPECT_ARITY(11, kExprLoop, 11);
+  EXPECT_ARITY(0, kExprLoop, 1);
+  EXPECT_ARITY(0, kExprLoop, 2);
+  EXPECT_ARITY(0, kExprLoop, 7);
+  EXPECT_ARITY(0, kExprLoop, 11);
 
-  EXPECT_ARITY(2, kExprIf);
-  EXPECT_ARITY(3, kExprIfElse);
   EXPECT_ARITY(3, kExprSelect);
 
-  EXPECT_ARITY(1, kExprBr);
-  EXPECT_ARITY(2, kExprBrIf);
+  EXPECT_ARITY(0, kExprBr);
+  EXPECT_ARITY(1, kExprBrIf);
+  EXPECT_ARITY(1, kExprBrTable);
+
+  EXPECT_ARITY(1, kExprBr, ARITY_1);
+  EXPECT_ARITY(2, kExprBrIf, ARITY_1);
+  EXPECT_ARITY(2, kExprBrTable, ARITY_1);
 
   {
-    sig = sigs.v_v();
-    EXPECT_ARITY(0, kExprReturn);
-    sig = sigs.i_i();
-    EXPECT_ARITY(1, kExprReturn);
+    EXPECT_ARITY(0, kExprReturn, ARITY_0);
+    EXPECT_ARITY(1, kExprReturn, ARITY_1);
   }
 }
 
-
 TEST_F(WasmOpcodeArityTest, Misc) {
-  FunctionSig* sig = sigs.v_v();
   EXPECT_ARITY(0, kExprI8Const);
   EXPECT_ARITY(0, kExprI32Const);
   EXPECT_ARITY(0, kExprF32Const);
@@ -2005,41 +2138,37 @@
   EXPECT_ARITY(1, kExprStoreGlobal);
 }
 
-
 TEST_F(WasmOpcodeArityTest, Calls) {
-  module.AddFunction(sigs.i_ii());
-  module.AddFunction(sigs.i_i());
-
-  module.AddSignature(sigs.f_ff());
-  module.AddSignature(sigs.i_d());
-
-  module.AddImport(sigs.f_ff());
-  module.AddImport(sigs.i_d());
-
   {
-    FunctionSig* sig = sigs.i_ii();
+    EXPECT_ARITY(2, kExprCallFunction, 2, 0);
+    EXPECT_ARITY(2, kExprCallImport, 2, 0);
+    EXPECT_ARITY(3, kExprCallIndirect, 2, 0);
 
-    EXPECT_ARITY(2, kExprCallFunction, 0);
-    EXPECT_ARITY(2, kExprCallImport, 0);
-    EXPECT_ARITY(3, kExprCallIndirect, 0);
-    EXPECT_ARITY(1, kExprBr);
-    EXPECT_ARITY(2, kExprBrIf);
+    EXPECT_ARITY(1, kExprBr, ARITY_1);
+    EXPECT_ARITY(2, kExprBrIf, ARITY_1);
+    EXPECT_ARITY(2, kExprBrTable, ARITY_1);
+
+    EXPECT_ARITY(0, kExprBr, ARITY_0);
+    EXPECT_ARITY(1, kExprBrIf, ARITY_0);
+    EXPECT_ARITY(1, kExprBrTable, ARITY_0);
   }
 
   {
-    FunctionSig* sig = sigs.v_v();
+    EXPECT_ARITY(1, kExprCallFunction, ARITY_1, 1);
+    EXPECT_ARITY(1, kExprCallImport, ARITY_1, 1);
+    EXPECT_ARITY(2, kExprCallIndirect, ARITY_1, 1);
 
-    EXPECT_ARITY(1, kExprCallFunction, 1);
-    EXPECT_ARITY(1, kExprCallImport, 1);
-    EXPECT_ARITY(2, kExprCallIndirect, 1);
-    EXPECT_ARITY(1, kExprBr);
-    EXPECT_ARITY(2, kExprBrIf);
+    EXPECT_ARITY(1, kExprBr, ARITY_1);
+    EXPECT_ARITY(2, kExprBrIf, ARITY_1);
+    EXPECT_ARITY(2, kExprBrTable, ARITY_1);
+
+    EXPECT_ARITY(0, kExprBr, ARITY_0);
+    EXPECT_ARITY(1, kExprBrIf, ARITY_0);
+    EXPECT_ARITY(1, kExprBrTable, ARITY_0);
   }
 }
 
-
 TEST_F(WasmOpcodeArityTest, LoadsAndStores) {
-  FunctionSig* sig = sigs.v_v();
   EXPECT_ARITY(1, kExprI32LoadMem8S);
   EXPECT_ARITY(1, kExprI32LoadMem8U);
   EXPECT_ARITY(1, kExprI32LoadMem16S);
@@ -2067,16 +2196,12 @@
   EXPECT_ARITY(2, kExprF64StoreMem);
 }
 
-
 TEST_F(WasmOpcodeArityTest, MiscMemExpressions) {
-  FunctionSig* sig = sigs.v_v();
   EXPECT_ARITY(0, kExprMemorySize);
   EXPECT_ARITY(1, kExprGrowMemory);
 }
 
-
 TEST_F(WasmOpcodeArityTest, SimpleExpressions) {
-  FunctionSig* sig = sigs.v_v();
   EXPECT_ARITY(2, kExprI32Add);
   EXPECT_ARITY(2, kExprI32Sub);
   EXPECT_ARITY(2, kExprI32Mul);
@@ -2246,7 +2371,7 @@
 
     LocalTypeMap map = Expand(decls);
     EXPECT_EQ(1, map.size());
-    EXPECT_EQ(type, map.at(0));
+    EXPECT_EQ(type, map[0]);
   }
 }
 
@@ -2297,7 +2422,7 @@
 TEST_F(LocalDeclDecoderTest, UseEncoder) {
   const byte* data = nullptr;
   const byte* end = nullptr;
-  LocalDeclEncoder local_decls;
+  LocalDeclEncoder local_decls(zone());
 
   local_decls.AddLocals(5, kAstF32);
   local_decls.AddLocals(1337, kAstI32);
diff --git a/test/unittests/wasm/encoder-unittest.cc b/test/unittests/wasm/encoder-unittest.cc
index 740c054..47885e6 100644
--- a/test/unittests/wasm/encoder-unittest.cc
+++ b/test/unittests/wasm/encoder-unittest.cc
@@ -9,6 +9,8 @@
 #include "src/wasm/ast-decoder.h"
 #include "src/wasm/encoder.h"
 
+#include "test/cctest/wasm/test-signatures.h"
+
 namespace v8 {
 namespace internal {
 namespace wasm {
@@ -17,202 +19,10 @@
  protected:
   void AddLocal(WasmFunctionBuilder* f, LocalType type) {
     uint16_t index = f->AddLocal(type);
-    const std::vector<uint8_t>& out_index = UnsignedLEB128From(index);
-    std::vector<uint8_t> code;
-    code.push_back(kExprGetLocal);
-    for (size_t i = 0; i < out_index.size(); i++) {
-      code.push_back(out_index.at(i));
-    }
-    uint32_t local_indices[] = {1};
-    f->EmitCode(&code[0], static_cast<uint32_t>(code.size()), local_indices, 1);
-  }
-
-  void CheckReadValue(uint8_t* leb_value, uint32_t expected_result,
-                      int expected_length,
-                      ReadUnsignedLEB128ErrorCode expected_error_code) {
-    int length;
-    uint32_t result;
-    ReadUnsignedLEB128ErrorCode error_code =
-        ReadUnsignedLEB128Operand(leb_value, leb_value + 5, &length, &result);
-    CHECK_EQ(error_code, expected_error_code);
-    if (error_code == 0) {
-      CHECK_EQ(result, expected_result);
-      CHECK_EQ(length, expected_length);
-    }
-  }
-
-  void CheckWriteValue(uint32_t input, int length, uint8_t* vals) {
-    const std::vector<uint8_t> result = UnsignedLEB128From(input);
-    CHECK_EQ(result.size(), length);
-    for (int i = 0; i < length; i++) {
-      CHECK_EQ(result.at(i), vals[i]);
-    }
+    f->EmitGetLocal(index);
   }
 };
 
-
-TEST_F(EncoderTest, Function_Builder_Variable_Indexing) {
-  base::AccountingAllocator allocator;
-  Zone zone(&allocator);
-  WasmModuleBuilder* builder = new (&zone) WasmModuleBuilder(&zone);
-  uint16_t f_index = builder->AddFunction();
-  WasmFunctionBuilder* function = builder->FunctionAt(f_index);
-  uint16_t local_f32 = function->AddLocal(kAstF32);
-  uint16_t param_float32 = function->AddParam(kAstF32);
-  uint16_t local_i32 = function->AddLocal(kAstI32);
-  uint16_t local_f64 = function->AddLocal(kAstF64);
-  uint16_t local_i64 = function->AddLocal(kAstI64);
-  uint16_t param_int32 = function->AddParam(kAstI32);
-  uint16_t local_i32_2 = function->AddLocal(kAstI32);
-
-  byte code[] = {kExprGetLocal, static_cast<uint8_t>(param_float32)};
-  uint32_t local_indices[] = {1};
-  function->EmitCode(code, sizeof(code), local_indices, 1);
-  code[1] = static_cast<uint8_t>(param_int32);
-  function->EmitCode(code, sizeof(code), local_indices, 1);
-  code[1] = static_cast<uint8_t>(local_i32);
-  function->EmitCode(code, sizeof(code), local_indices, 1);
-  code[1] = static_cast<uint8_t>(local_i32_2);
-  function->EmitCode(code, sizeof(code), local_indices, 1);
-  code[1] = static_cast<uint8_t>(local_i64);
-  function->EmitCode(code, sizeof(code), local_indices, 1);
-  code[1] = static_cast<uint8_t>(local_f32);
-  function->EmitCode(code, sizeof(code), local_indices, 1);
-  code[1] = static_cast<uint8_t>(local_f64);
-  function->EmitCode(code, sizeof(code), local_indices, 1);
-
-  WasmFunctionEncoder* f = function->Build(&zone, builder);
-  ZoneVector<uint8_t> buffer_vector(f->HeaderSize() + f->BodySize(), &zone);
-  byte* buffer = &buffer_vector[0];
-  byte* header = buffer;
-  byte* body = buffer + f->HeaderSize();
-  f->Serialize(buffer, &header, &body);
-}
-
-
-TEST_F(EncoderTest, Function_Builder_Indexing_Variable_Width) {
-  base::AccountingAllocator allocator;
-  Zone zone(&allocator);
-  WasmModuleBuilder* builder = new (&zone) WasmModuleBuilder(&zone);
-  uint16_t f_index = builder->AddFunction();
-  WasmFunctionBuilder* function = builder->FunctionAt(f_index);
-  for (size_t i = 0; i < 128; i++) {
-    AddLocal(function, kAstF32);
-  }
-  AddLocal(function, kAstI32);
-
-  WasmFunctionEncoder* f = function->Build(&zone, builder);
-  ZoneVector<uint8_t> buffer_vector(f->HeaderSize() + f->BodySize(), &zone);
-  byte* buffer = &buffer_vector[0];
-  byte* header = buffer;
-  byte* body = buffer + f->HeaderSize();
-  f->Serialize(buffer, &header, &body);
-  body = buffer + f->HeaderSize();
-}
-
-TEST_F(EncoderTest, Function_Builder_Block_Variable_Width) {
-  base::AccountingAllocator allocator;
-  Zone zone(&allocator);
-  WasmModuleBuilder* builder = new (&zone) WasmModuleBuilder(&zone);
-  uint16_t f_index = builder->AddFunction();
-  WasmFunctionBuilder* function = builder->FunctionAt(f_index);
-  function->EmitWithVarInt(kExprBlock, 200);
-  for (int i = 0; i < 200; ++i) {
-    function->Emit(kExprNop);
-  }
-
-  WasmFunctionEncoder* f = function->Build(&zone, builder);
-  CHECK_EQ(f->BodySize(), 204);
-}
-
-TEST_F(EncoderTest, Function_Builder_EmitEditableVarIntImmediate) {
-  base::AccountingAllocator allocator;
-  Zone zone(&allocator);
-  WasmModuleBuilder* builder = new (&zone) WasmModuleBuilder(&zone);
-  uint16_t f_index = builder->AddFunction();
-  WasmFunctionBuilder* function = builder->FunctionAt(f_index);
-  function->Emit(kExprLoop);
-  uint32_t offset = function->EmitEditableVarIntImmediate();
-  for (int i = 0; i < 200; ++i) {
-    function->Emit(kExprNop);
-  }
-  function->EditVarIntImmediate(offset, 200);
-
-  WasmFunctionEncoder* f = function->Build(&zone, builder);
-  CHECK_EQ(f->BodySize(), 204);
-}
-
-TEST_F(EncoderTest, Function_Builder_EmitEditableVarIntImmediate_Locals) {
-  base::AccountingAllocator allocator;
-  Zone zone(&allocator);
-  WasmModuleBuilder* builder = new (&zone) WasmModuleBuilder(&zone);
-  uint16_t f_index = builder->AddFunction();
-  WasmFunctionBuilder* function = builder->FunctionAt(f_index);
-  function->Emit(kExprBlock);
-  uint32_t offset = function->EmitEditableVarIntImmediate();
-  for (int i = 0; i < 200; ++i) {
-    AddLocal(function, kAstI32);
-  }
-  function->EditVarIntImmediate(offset, 200);
-
-  WasmFunctionEncoder* f = function->Build(&zone, builder);
-  ZoneVector<uint8_t> buffer_vector(f->HeaderSize() + f->BodySize(), &zone);
-  byte* buffer = &buffer_vector[0];
-  byte* header = buffer;
-  byte* body = buffer + f->HeaderSize();
-  f->Serialize(buffer, &header, &body);
-  body = buffer + f->HeaderSize();
-
-  CHECK_EQ(f->BodySize(), 479);
-  const uint8_t varint200_low = (200 & 0x7f) | 0x80;
-  const uint8_t varint200_high = (200 >> 7) & 0x7f;
-  offset = 0;
-  CHECK_EQ(body[offset++], 1);  // Local decl count.
-  CHECK_EQ(body[offset++], varint200_low);
-  CHECK_EQ(body[offset++], varint200_high);
-  CHECK_EQ(body[offset++], kLocalI32);
-  CHECK_EQ(body[offset++], kExprBlock);
-  CHECK_EQ(body[offset++], varint200_low);
-  CHECK_EQ(body[offset++], varint200_high);
-  // GetLocal with one-byte indices.
-  for (int i = 0; i <= 127; ++i) {
-    CHECK_EQ(body[offset++], kExprGetLocal);
-    CHECK_EQ(body[offset++], i);
-  }
-  // GetLocal with two-byte indices.
-  for (int i = 128; i < 200; ++i) {
-    CHECK_EQ(body[offset++], kExprGetLocal);
-    CHECK_EQ(body[offset++], (i & 0x7f) | 0x80);
-    CHECK_EQ(body[offset++], (i >> 7) & 0x7f);
-  }
-  CHECK_EQ(offset, 479);
-}
-
-TEST_F(EncoderTest, LEB_Functions) {
-  byte leb_value[5] = {0, 0, 0, 0, 0};
-  CheckReadValue(leb_value, 0, 1, kNoError);
-  CheckWriteValue(0, 1, leb_value);
-  leb_value[0] = 23;
-  CheckReadValue(leb_value, 23, 1, kNoError);
-  CheckWriteValue(23, 1, leb_value);
-  leb_value[0] = 0x80;
-  leb_value[1] = 0x01;
-  CheckReadValue(leb_value, 128, 2, kNoError);
-  CheckWriteValue(128, 2, leb_value);
-  leb_value[0] = 0x80;
-  leb_value[1] = 0x80;
-  leb_value[2] = 0x80;
-  leb_value[3] = 0x80;
-  leb_value[4] = 0x01;
-  CheckReadValue(leb_value, 0x10000000, 5, kNoError);
-  CheckWriteValue(0x10000000, 5, leb_value);
-  leb_value[0] = 0x80;
-  leb_value[1] = 0x80;
-  leb_value[2] = 0x80;
-  leb_value[3] = 0x80;
-  leb_value[4] = 0x80;
-  CheckReadValue(leb_value, -1, -1, kInvalidLEB128);
-}
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8
diff --git a/test/unittests/wasm/leb-helper-unittest.cc b/test/unittests/wasm/leb-helper-unittest.cc
new file mode 100644
index 0000000..ed9f0a3
--- /dev/null
+++ b/test/unittests/wasm/leb-helper-unittest.cc
@@ -0,0 +1,190 @@
+// Copyright 2016 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 "test/unittests/test-utils.h"
+
+#include "src/wasm/decoder.h"
+#include "src/wasm/leb-helper.h"
+
+namespace v8 {
+namespace internal {
+namespace wasm {
+
+class LEBHelperTest : public TestWithZone {};
+
+TEST_F(LEBHelperTest, sizeof_u32v) {
+  EXPECT_EQ(1, LEBHelper::sizeof_u32v(0));
+  EXPECT_EQ(1, LEBHelper::sizeof_u32v(1));
+  EXPECT_EQ(1, LEBHelper::sizeof_u32v(3));
+
+  for (uint32_t i = 4; i < 128; i++) {
+    EXPECT_EQ(1, LEBHelper::sizeof_u32v(i));
+  }
+
+  for (uint32_t i = (1 << 7); i < (1 << 9); i++) {
+    EXPECT_EQ(2, LEBHelper::sizeof_u32v(i));
+  }
+
+  for (uint32_t i = (1 << 14); i < (1 << 16); i += 33) {
+    EXPECT_EQ(3, LEBHelper::sizeof_u32v(i));
+  }
+
+  for (uint32_t i = (1 << 21); i < (1 << 24); i += 33999) {
+    EXPECT_EQ(4, LEBHelper::sizeof_u32v(i));
+  }
+
+  for (uint32_t i = (1 << 28); i < (1 << 31); i += 33997779) {
+    EXPECT_EQ(5, LEBHelper::sizeof_u32v(i));
+  }
+
+  EXPECT_EQ(5, LEBHelper::sizeof_u32v(0xFFFFFFFF));
+}
+
+TEST_F(LEBHelperTest, sizeof_i32v) {
+  EXPECT_EQ(1, LEBHelper::sizeof_i32v(0));
+  EXPECT_EQ(1, LEBHelper::sizeof_i32v(1));
+  EXPECT_EQ(1, LEBHelper::sizeof_i32v(3));
+
+  for (int32_t i = 0; i < (1 << 6); i++) {
+    EXPECT_EQ(1, LEBHelper::sizeof_i32v(i));
+  }
+
+  for (int32_t i = (1 << 6); i < (1 << 8); i++) {
+    EXPECT_EQ(2, LEBHelper::sizeof_i32v(i));
+  }
+
+  for (int32_t i = (1 << 13); i < (1 << 15); i += 31) {
+    EXPECT_EQ(3, LEBHelper::sizeof_i32v(i));
+  }
+
+  for (int32_t i = (1 << 20); i < (1 << 22); i += 31991) {
+    EXPECT_EQ(4, LEBHelper::sizeof_i32v(i));
+  }
+
+  for (int32_t i = (1 << 27); i < (1 << 29); i += 3199893) {
+    EXPECT_EQ(5, LEBHelper::sizeof_i32v(i));
+  }
+
+  for (int32_t i = -(1 << 6); i <= 0; i++) {
+    EXPECT_EQ(1, LEBHelper::sizeof_i32v(i));
+  }
+
+  for (int32_t i = -(1 << 13); i < -(1 << 6); i++) {
+    EXPECT_EQ(2, LEBHelper::sizeof_i32v(i));
+  }
+
+  for (int32_t i = -(1 << 20); i < -(1 << 18); i += 11) {
+    EXPECT_EQ(3, LEBHelper::sizeof_i32v(i));
+  }
+
+  for (int32_t i = -(1 << 27); i < -(1 << 25); i += 11999) {
+    EXPECT_EQ(4, LEBHelper::sizeof_i32v(i));
+  }
+
+  for (int32_t i = -(1 << 30); i < -(1 << 28); i += 1199999) {
+    EXPECT_EQ(5, LEBHelper::sizeof_i32v(i));
+  }
+}
+
+#define DECLARE_ENCODE_DECODE_CHECKER(ctype, name)                         \
+  static void CheckEncodeDecode_##name(ctype val) {                        \
+    static const int kSize = 16;                                           \
+    static byte buffer[kSize];                                             \
+    byte *ptr = buffer;                                                    \
+    LEBHelper::write_##name(&ptr, val);                                    \
+    EXPECT_EQ(LEBHelper::sizeof_##name(val),                               \
+              static_cast<size_t>(ptr - buffer));                          \
+    Decoder decoder(buffer, buffer + kSize);                               \
+    int length = 0;                                                        \
+    ctype result = decoder.checked_read_##name(buffer, 0, &length);        \
+    EXPECT_EQ(val, result);                                                \
+    EXPECT_EQ(LEBHelper::sizeof_##name(val), static_cast<size_t>(length)); \
+  }
+
+DECLARE_ENCODE_DECODE_CHECKER(int32_t, i32v)
+DECLARE_ENCODE_DECODE_CHECKER(uint32_t, u32v)
+DECLARE_ENCODE_DECODE_CHECKER(int64_t, i64v)
+DECLARE_ENCODE_DECODE_CHECKER(uint64_t, u64v)
+
+TEST_F(LEBHelperTest, WriteAndDecode_u32v) {
+  CheckEncodeDecode_u32v(0);
+  CheckEncodeDecode_u32v(1);
+  CheckEncodeDecode_u32v(5);
+  CheckEncodeDecode_u32v(99);
+  CheckEncodeDecode_u32v(298);
+  CheckEncodeDecode_u32v(87348723);
+  CheckEncodeDecode_u32v(77777);
+
+  for (uint32_t val = 0x3a; val != 0; val = val << 1) {
+    CheckEncodeDecode_u32v(val);
+  }
+}
+
+TEST_F(LEBHelperTest, WriteAndDecode_i32v) {
+  CheckEncodeDecode_i32v(0);
+  CheckEncodeDecode_i32v(1);
+  CheckEncodeDecode_i32v(5);
+  CheckEncodeDecode_i32v(99);
+  CheckEncodeDecode_i32v(298);
+  CheckEncodeDecode_i32v(87348723);
+  CheckEncodeDecode_i32v(77777);
+
+  CheckEncodeDecode_i32v(-2);
+  CheckEncodeDecode_i32v(-4);
+  CheckEncodeDecode_i32v(-59);
+  CheckEncodeDecode_i32v(-288);
+  CheckEncodeDecode_i32v(-12608);
+  CheckEncodeDecode_i32v(-87328723);
+  CheckEncodeDecode_i32v(-77377);
+
+  for (uint32_t val = 0x3a; val != 0; val = val << 1) {
+    CheckEncodeDecode_i32v(bit_cast<int32_t>(val));
+  }
+
+  for (uint32_t val = 0xFFFFFF3B; val != 0; val = val << 1) {
+    CheckEncodeDecode_i32v(bit_cast<int32_t>(val));
+  }
+}
+
+TEST_F(LEBHelperTest, WriteAndDecode_u64v) {
+  CheckEncodeDecode_u64v(0);
+  CheckEncodeDecode_u64v(1);
+  CheckEncodeDecode_u64v(5);
+  CheckEncodeDecode_u64v(99);
+  CheckEncodeDecode_u64v(298);
+  CheckEncodeDecode_u64v(87348723);
+  CheckEncodeDecode_u64v(77777);
+
+  for (uint64_t val = 0x3a; val != 0; val = val << 1) {
+    CheckEncodeDecode_u64v(val);
+  }
+}
+
+TEST_F(LEBHelperTest, WriteAndDecode_i64v) {
+  CheckEncodeDecode_i64v(0);
+  CheckEncodeDecode_i64v(1);
+  CheckEncodeDecode_i64v(5);
+  CheckEncodeDecode_i64v(99);
+  CheckEncodeDecode_i64v(298);
+  CheckEncodeDecode_i64v(87348723);
+  CheckEncodeDecode_i64v(77777);
+
+  CheckEncodeDecode_i64v(-2);
+  CheckEncodeDecode_i64v(-4);
+  CheckEncodeDecode_i64v(-59);
+  CheckEncodeDecode_i64v(-288);
+  CheckEncodeDecode_i64v(-87648723);
+  CheckEncodeDecode_i64v(-77377);
+
+  for (uint64_t val = 0x3a; val != 0; val = val << 1) {
+    CheckEncodeDecode_i64v(bit_cast<int64_t>(val));
+  }
+
+  for (uint64_t val = 0xFFFFFFFFFFFFFF3B; val != 0; val = val << 1) {
+    CheckEncodeDecode_i64v(bit_cast<int64_t>(val));
+  }
+}
+}  // namespace wasm
+}  // namespace internal
+}  // namespace v8
diff --git a/test/unittests/wasm/loop-assignment-analysis-unittest.cc b/test/unittests/wasm/loop-assignment-analysis-unittest.cc
index e77c1cf..7d97c50 100644
--- a/test/unittests/wasm/loop-assignment-analysis-unittest.cc
+++ b/test/unittests/wasm/loop-assignment-analysis-unittest.cc
@@ -32,14 +32,12 @@
   }
 };
 
-
 TEST_F(WasmLoopAssignmentAnalyzerTest, Empty0) {
   byte code[] = { 0 };
   BitVector* assigned = Analyze(code, code);
   CHECK_NULL(assigned);
 }
 
-
 TEST_F(WasmLoopAssignmentAnalyzerTest, Empty1) {
   byte code[] = {kExprLoop, 0};
   for (int i = 0; i < 5; i++) {
@@ -51,7 +49,6 @@
   }
 }
 
-
 TEST_F(WasmLoopAssignmentAnalyzerTest, One) {
   num_locals = 5;
   for (int i = 0; i < 5; i++) {
@@ -63,7 +60,6 @@
   }
 }
 
-
 TEST_F(WasmLoopAssignmentAnalyzerTest, OneBeyond) {
   num_locals = 5;
   for (int i = 0; i < 5; i++) {
@@ -75,7 +71,6 @@
   }
 }
 
-
 TEST_F(WasmLoopAssignmentAnalyzerTest, Two) {
   num_locals = 5;
   for (int i = 0; i < 5; i++) {
@@ -90,7 +85,6 @@
   }
 }
 
-
 TEST_F(WasmLoopAssignmentAnalyzerTest, NestedIf) {
   num_locals = 5;
   for (int i = 0; i < 5; i++) {
@@ -104,14 +98,12 @@
   }
 }
 
-
 static byte LEBByte(uint32_t val, byte which) {
   byte b = (val >> (which * 7)) & 0x7F;
   if (val >> ((which + 1) * 7)) b |= 0x80;
   return b;
 }
 
-
 TEST_F(WasmLoopAssignmentAnalyzerTest, BigLocal) {
   num_locals = 65000;
   for (int i = 13; i < 65000; i = static_cast<int>(i * 1.5)) {
@@ -133,7 +125,6 @@
   }
 }
 
-
 TEST_F(WasmLoopAssignmentAnalyzerTest, Break) {
   num_locals = 3;
   byte code[] = {
@@ -147,7 +138,6 @@
   }
 }
 
-
 TEST_F(WasmLoopAssignmentAnalyzerTest, Loop1) {
   num_locals = 5;
   byte code[] = {
@@ -164,7 +154,6 @@
   }
 }
 
-
 TEST_F(WasmLoopAssignmentAnalyzerTest, Loop2) {
   num_locals = 6;
   const byte kIter = 0;
@@ -184,14 +173,13 @@
       WASM_STORE_MEM(MachineType::Float32(), WASM_ZERO, WASM_GET_LOCAL(kSum)),
       WASM_GET_LOCAL(kIter))};
 
-  BitVector* assigned = Analyze(code + 2, code + arraysize(code));
+  BitVector* assigned = Analyze(code + 1, code + arraysize(code));
   for (int j = 0; j < assigned->length(); j++) {
     bool expected = j == kIter || j == kSum;
     CHECK_EQ(expected, assigned->Contains(j));
   }
 }
 
-
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8
diff --git a/test/unittests/wasm/module-decoder-unittest.cc b/test/unittests/wasm/module-decoder-unittest.cc
index 44e7865..7090c1f 100644
--- a/test/unittests/wasm/module-decoder-unittest.cc
+++ b/test/unittests/wasm/module-decoder-unittest.cc
@@ -13,18 +13,34 @@
 namespace wasm {
 
 #define EMPTY_FUNCTION(sig_index) 0, SIG_INDEX(sig_index), U16_LE(0)
-#define EMPTY_FUNCTION_SIZE ((size_t)5)
+#define SIZEOF_EMPTY_FUNCTION ((size_t)5)
 #define EMPTY_BODY 0
-#define EMPTY_BODY_SIZE ((size_t)1)
+#define SIZEOF_EMPTY_BODY ((size_t)1)
 #define NOP_BODY 2, 0, kExprNop
-#define NOP_BODY_SIZE ((size_t)3)
-#define VOID_VOID_SIG 0, kLocalVoid
-#define VOID_VOID_SIG_SIZE ((size_t)2)
-#define INT_INT_SIG 1, kLocalI32, kLocalI32
-#define INT_INT_SIG_SIZE ((size_t)3)
+#define SIZEOF_NOP_BODY ((size_t)3)
 
-#define SECTION(NAME, EXTRA_SIZE) \
-  U32V_1(WASM_SECTION_##NAME##_SIZE + (EXTRA_SIZE)), WASM_SECTION_##NAME
+#define SIG_ENTRY_i_i SIG_ENTRY_x_x(kLocalI32, kLocalI32)
+
+#define UNKNOWN_EMPTY_SECTION_NAME 1, '\0'
+#define UNKNOWN_SECTION_NAME 4, 'l', 'u', 'l', 'z'
+
+#define SECTION(NAME, EXTRA_SIZE) WASM_SECTION_##NAME, U32V_1(EXTRA_SIZE)
+
+#define SIGNATURES_SECTION(count, ...) \
+  SECTION(SIGNATURES, 1 + 3 * (count)), U32V_1(count), __VA_ARGS__
+#define FUNCTION_SIGNATURES_SECTION(count, ...) \
+  SECTION(FUNCTION_SIGNATURES, 1 + (count)), U32V_1(count), __VA_ARGS__
+
+#define FOO_STRING 3, 'f', 'o', 'o'
+#define NO_LOCAL_NAMES 0
+
+#define EMPTY_SIGNATURES_SECTION SECTION(SIGNATURES, 1), 0
+#define EMPTY_FUNCTION_SIGNATURES_SECTION SECTION(FUNCTION_SIGNATURES, 1), 0
+#define EMPTY_FUNCTION_BODIES_SECTION SECTION(FUNCTION_BODIES, 1), 0
+#define EMPTY_NAMES_SECTION SECTION(NAMES, 1), 0
+
+#define SIGNATURES_SECTION_VOID_VOID \
+  SECTION(SIGNATURES, 1 + SIZEOF_SIG_ENTRY_v_v), 1, SIG_ENTRY_v_v
 
 #define EXPECT_VERIFIES(data)                                         \
   do {                                                                \
@@ -49,6 +65,15 @@
     }                                                   \
   } while (false)
 
+#define EXPECT_OK(result)                \
+  do {                                   \
+    EXPECT_TRUE(result.ok());            \
+    if (!result.ok()) {                  \
+      if (result.val) delete result.val; \
+      return;                            \
+    }                                    \
+  } while (false)
+
 static size_t SizeOfVarInt(size_t value) {
   size_t size = 0;
   do {
@@ -66,7 +91,7 @@
                    {kLocalF32, kAstF32},
                    {kLocalF64, kAstF64}};
 
-class WasmModuleVerifyTest : public TestWithZone {
+class WasmModuleVerifyTest : public TestWithIsolateAndZone {
  public:
   ModuleResult DecodeModule(const byte* module_start, const byte* module_end) {
     // Add the WASM magic and version number automatically.
@@ -76,14 +101,14 @@
     auto temp = new byte[total];
     memcpy(temp, header, sizeof(header));
     memcpy(temp + sizeof(header), module_start, size);
-    ModuleResult result = DecodeWasmModule(nullptr, zone(), temp, temp + total,
-                                           false, kWasmOrigin);
+    ModuleResult result = DecodeWasmModule(isolate(), zone(), temp,
+                                           temp + total, false, kWasmOrigin);
     delete[] temp;
     return result;
   }
   ModuleResult DecodeModuleNoHeader(const byte* module_start,
                                     const byte* module_end) {
-    return DecodeWasmModule(nullptr, zone(), module_start, module_end, false,
+    return DecodeWasmModule(isolate(), zone(), module_start, module_end, false,
                             kWasmOrigin);
   }
 };
@@ -115,7 +140,7 @@
 
 TEST_F(WasmModuleVerifyTest, OneGlobal) {
   static const byte data[] = {
-      SECTION(GLOBALS, 7),  // --
+      SECTION(GLOBALS, 5),  // --
       1,
       NAME_LENGTH(1),
       'g',      // name
@@ -126,7 +151,7 @@
   {
     // Should decode to exactly one global.
     ModuleResult result = DecodeModule(data, data + arraysize(data));
-    EXPECT_TRUE(result.ok());
+    EXPECT_OK(result);
     EXPECT_EQ(1, result.val->globals.size());
     EXPECT_EQ(0, result.val->functions.size());
     EXPECT_EQ(0, result.val->data_segments.size());
@@ -144,18 +169,16 @@
   EXPECT_OFF_END_FAILURE(data, 1, sizeof(data));
 }
 
-
 TEST_F(WasmModuleVerifyTest, ZeroGlobals) {
   static const byte data[] = {
       SECTION(GLOBALS, 1),  // --
       0,                    // declare 0 globals
   };
   ModuleResult result = DecodeModule(data, data + arraysize(data));
-  EXPECT_TRUE(result.ok());
+  EXPECT_OK(result);
   if (result.val) delete result.val;
 }
 
-
 static void AppendUint32v(std::vector<byte>& buffer, uint32_t val) {
   while (true) {
     uint32_t next = val >> 7;
@@ -170,7 +193,6 @@
   }
 }
 
-
 TEST_F(WasmModuleVerifyTest, NGlobals) {
   static const byte data[] = {
       NO_NAME,  // name length
@@ -180,9 +202,8 @@
 
   for (uint32_t i = 0; i < 1000000; i = i * 13 + 1) {
     std::vector<byte> buffer;
-    size_t size =
-        WASM_SECTION_GLOBALS_SIZE + SizeOfVarInt(i) + i * sizeof(data);
-    const byte globals[] = {U32V_5(size), WASM_SECTION_GLOBALS};
+    size_t size = SizeOfVarInt(i) + i * sizeof(data);
+    const byte globals[] = {WASM_SECTION_GLOBALS, U32V_5(size)};
     for (size_t g = 0; g != sizeof(globals); ++g) {
       buffer.push_back(globals[g]);
     }
@@ -192,7 +213,7 @@
     }
 
     ModuleResult result = DecodeModule(&buffer[0], &buffer[0] + buffer.size());
-    EXPECT_TRUE(result.ok());
+    EXPECT_OK(result);
     if (result.val) delete result.val;
   }
 }
@@ -221,10 +242,9 @@
   EXPECT_FAILURE(data);
 }
 
-
 TEST_F(WasmModuleVerifyTest, TwoGlobals) {
   static const byte data[] = {
-      SECTION(GLOBALS, 13),
+      SECTION(GLOBALS, 7),
       2,
       NO_NAME,  // #0: name length
       kMemF32,  // memory type
@@ -237,7 +257,7 @@
   {
     // Should decode to exactly two globals.
     ModuleResult result = DecodeModule(data, data + arraysize(data));
-    EXPECT_TRUE(result.ok());
+    EXPECT_OK(result);
     EXPECT_EQ(2, result.val->globals.size());
     EXPECT_EQ(0, result.val->functions.size());
     EXPECT_EQ(0, result.val->data_segments.size());
@@ -261,39 +281,31 @@
   EXPECT_OFF_END_FAILURE(data, 1, sizeof(data));
 }
 
-
 TEST_F(WasmModuleVerifyTest, OneSignature) {
   {
-    static const byte data[] = {SECTION(SIGNATURES, 1 + VOID_VOID_SIG_SIZE), 1,
-                                VOID_VOID_SIG};
+    static const byte data[] = {SIGNATURES_SECTION_VOID_VOID};
     EXPECT_VERIFIES(data);
   }
 
   {
-    static const byte data[] = {SECTION(SIGNATURES, 1 + INT_INT_SIG_SIZE), 1,
-                                INT_INT_SIG};
+    static const byte data[] = {SECTION(SIGNATURES, 1 + SIZEOF_SIG_ENTRY_x_x),
+                                1, SIG_ENTRY_i_i};
     EXPECT_VERIFIES(data);
   }
 }
 
-
 TEST_F(WasmModuleVerifyTest, MultipleSignatures) {
   static const byte data[] = {
-      SECTION(SIGNATURES, 10),
-      3,
-      0,
-      kLocalVoid,  // void -> void
-      1,
-      kLocalI32,
-      kLocalF32,  // f32 -> i32
-      2,
-      kLocalI32,
-      kLocalF64,
-      kLocalF64,  // (f64,f64) -> i32
+      SECTION(SIGNATURES, 1 + SIZEOF_SIG_ENTRY_v_v + SIZEOF_SIG_ENTRY_x_x +
+                              SIZEOF_SIG_ENTRY_x_xx),   // --
+      3,                                                // --
+      SIG_ENTRY_v_v,                                    // void -> void
+      SIG_ENTRY_x_x(kLocalI32, kLocalF32),              // f32 -> i32
+      SIG_ENTRY_x_xx(kLocalI32, kLocalF64, kLocalF64),  // f64,f64 -> i32
   };
 
   ModuleResult result = DecodeModule(data, data + arraysize(data));
-  EXPECT_TRUE(result.ok());
+  EXPECT_OK(result);
   EXPECT_EQ(3, result.val->signatures.size());
   if (result.val->signatures.size() == 3) {
     EXPECT_EQ(0, result.val->signatures[0]->return_count());
@@ -309,10 +321,9 @@
   EXPECT_OFF_END_FAILURE(data, 1, sizeof(data));
 }
 
-
 TEST_F(WasmModuleVerifyTest, FunctionWithoutSig) {
   static const byte data[] = {
-      SECTION(FUNCTIONS, 25), 1,
+      SECTION(OLD_FUNCTIONS, 25), 1,
       // func#0 ------------------------------------------------------
       SIG_INDEX(0),  // signature index
       NO_NAME,       // name length
@@ -323,7 +334,7 @@
       U16_LE(699),   // local float32 count
       U16_LE(599),   // local float64 count
       0,             // exported
-      1              // external
+      0              // external
   };
 
   ModuleResult result = DecodeModule(data, data + arraysize(data));
@@ -331,24 +342,17 @@
   if (result.val) delete result.val;
 }
 
-
 TEST_F(WasmModuleVerifyTest, OneEmptyVoidVoidFunction) {
-  const int kCodeStartOffset = 51;
+  const int kCodeStartOffset = 41;
   const int kCodeEndOffset = kCodeStartOffset + 1;
 
   static const byte data[] = {
-      SECTION(SIGNATURES, 1 + VOID_VOID_SIG_SIZE), 1,
-      // sig#0 -------------------------------------------------------
-      VOID_VOID_SIG,
+      // signatures
+      SIGNATURES_SECTION_VOID_VOID,
       // func#0 ------------------------------------------------------
-      SECTION(FUNCTIONS, 19), 1,
-      kDeclFunctionLocals | kDeclFunctionExport | kDeclFunctionName,
+      SECTION(OLD_FUNCTIONS, 10), 1, kDeclFunctionExport | kDeclFunctionName,
       SIG_INDEX(0),              // signature index
       NAME_LENGTH(2), 'h', 'i',  // name
-      U16_LE(1466),              // local int32 count
-      U16_LE(1355),              // local int64 count
-      U16_LE(1244),              // local float32 count
-      U16_LE(1133),              // local float64 count
       1, 0,                      // size
       kExprNop,
   };
@@ -356,7 +360,7 @@
   {
     // Should decode to exactly one function.
     ModuleResult result = DecodeModule(data, data + arraysize(data));
-    EXPECT_TRUE(result.ok());
+    EXPECT_OK(result);
     EXPECT_EQ(0, result.val->globals.size());
     EXPECT_EQ(1, result.val->signatures.size());
     EXPECT_EQ(1, result.val->functions.size());
@@ -365,18 +369,12 @@
 
     WasmFunction* function = &result.val->functions.back();
 
-    EXPECT_EQ(39, function->name_offset);
+    EXPECT_EQ(37, function->name_offset);
     EXPECT_EQ(2, function->name_length);
     EXPECT_EQ(kCodeStartOffset, function->code_start_offset);
     EXPECT_EQ(kCodeEndOffset, function->code_end_offset);
 
-    EXPECT_EQ(1466, function->local_i32_count);
-    EXPECT_EQ(1355, function->local_i64_count);
-    EXPECT_EQ(1244, function->local_f32_count);
-    EXPECT_EQ(1133, function->local_f64_count);
-
     EXPECT_TRUE(function->exported);
-    EXPECT_FALSE(function->external);
 
     if (result.val) delete result.val;
   }
@@ -384,46 +382,13 @@
   EXPECT_OFF_END_FAILURE(data, 16, sizeof(data));
 }
 
-
-TEST_F(WasmModuleVerifyTest, OneFunctionImported) {
-  static const byte data[] = {
-      SECTION(SIGNATURES, VOID_VOID_SIG_SIZE), 1,
-      // sig#0 -------------------------------------------------------
-      VOID_VOID_SIG, SECTION(FUNCTIONS, 6), 1,
-      // func#0 ------------------------------------------------------
-      kDeclFunctionImport,  // no name, no locals, imported
-      SIG_INDEX(0),
-  };
-
-  ModuleResult result = DecodeModule(data, data + arraysize(data));
-  EXPECT_TRUE(result.ok());
-  EXPECT_EQ(1, result.val->functions.size());
-  WasmFunction* function = &result.val->functions.back();
-
-  EXPECT_EQ(0, function->name_length);
-  EXPECT_EQ(0, function->code_start_offset);
-  EXPECT_EQ(0, function->code_end_offset);
-
-  EXPECT_EQ(0, function->local_i32_count);
-  EXPECT_EQ(0, function->local_i64_count);
-  EXPECT_EQ(0, function->local_f32_count);
-  EXPECT_EQ(0, function->local_f64_count);
-
-  EXPECT_FALSE(function->exported);
-  EXPECT_TRUE(function->external);
-
-  if (result.val) delete result.val;
-}
-
 TEST_F(WasmModuleVerifyTest, OneFunctionWithNopBody) {
-  static const byte kCodeStartOffset = 40;
+  static const byte kCodeStartOffset = 38;
   static const byte kCodeEndOffset = kCodeStartOffset + 1;
 
   static const byte data[] = {
-      SECTION(SIGNATURES, 3), 1,
-      // sig#0 -------------------------------------------------------
-      0, 0,  // void -> void
-      SECTION(FUNCTIONS, 7), 1,
+      SIGNATURES_SECTION_VOID_VOID,  // --
+      SECTION(OLD_FUNCTIONS, 7), 1,
       // func#0 ------------------------------------------------------
       0,        // no name, no locals
       0, 0,     // signature index
@@ -432,7 +397,7 @@
   };
 
   ModuleResult result = DecodeModule(data, data + arraysize(data));
-  EXPECT_TRUE(result.ok());
+  EXPECT_OK(result);
   EXPECT_EQ(1, result.val->functions.size());
   WasmFunction* function = &result.val->functions.back();
 
@@ -440,86 +405,38 @@
   EXPECT_EQ(kCodeStartOffset, function->code_start_offset);
   EXPECT_EQ(kCodeEndOffset, function->code_end_offset);
 
-  EXPECT_EQ(0, function->local_i32_count);
-  EXPECT_EQ(0, function->local_i64_count);
-  EXPECT_EQ(0, function->local_f32_count);
-  EXPECT_EQ(0, function->local_f64_count);
-
   EXPECT_FALSE(function->exported);
-  EXPECT_FALSE(function->external);
 
   if (result.val) delete result.val;
 }
 
-
-TEST_F(WasmModuleVerifyTest, OneFunctionWithNopBody_WithLocals) {
-  static const byte kCodeStartOffset = 48;
-  static const byte kCodeEndOffset = kCodeStartOffset + 1;
-
-  static const byte data[] = {
-      SECTION(SIGNATURES, 3), 1,
-      // sig#0 -------------------------------------------------------
-      0, 0,  // void -> void
-      SECTION(FUNCTIONS, 15), 1,
-      // func#0 ------------------------------------------------------
-      kDeclFunctionLocals, 0, 0,  // signature index
-      1, 2,                       // local int32 count
-      3, 4,                       // local int64 count
-      5, 6,                       // local float32 count
-      7, 8,                       // local float64 count
-      1, 0,                       // body size
-      kExprNop                    // body
-  };
-
-  ModuleResult result = DecodeModule(data, data + arraysize(data));
-  EXPECT_TRUE(result.ok());
-  EXPECT_EQ(1, result.val->functions.size());
-  WasmFunction* function = &result.val->functions.back();
-
-  EXPECT_EQ(0, function->name_length);
-  EXPECT_EQ(kCodeStartOffset, function->code_start_offset);
-  EXPECT_EQ(kCodeEndOffset, function->code_end_offset);
-
-  EXPECT_EQ(513, function->local_i32_count);
-  EXPECT_EQ(1027, function->local_i64_count);
-  EXPECT_EQ(1541, function->local_f32_count);
-  EXPECT_EQ(2055, function->local_f64_count);
-
-  EXPECT_FALSE(function->exported);
-  EXPECT_FALSE(function->external);
-
-  if (result.val) delete result.val;
-}
-
-
 TEST_F(WasmModuleVerifyTest, OneGlobalOneFunctionWithNopBodyOneDataSegment) {
-  static const byte kCodeStartOffset = 75;
+  static const byte kNameOffset = 49;
+  static const byte kCodeStartOffset = 53;
   static const byte kCodeEndOffset = kCodeStartOffset + 3;
-  static const byte kDataSegmentSourceOffset = kCodeEndOffset + 20;
+  static const byte kDataSegmentSourceOffset = kCodeEndOffset + 22;
 
   static const byte data[] = {
-      SECTION(MEMORY, 3), 28, 28, 1,
       // global#0 --------------------------------------------------
-      SECTION(GLOBALS, 7), 1,
+      SECTION(GLOBALS, 4), 1,
       0,       // name length
       kMemU8,  // memory type
       0,       // exported
       // sig#0 -----------------------------------------------------
-      SECTION(SIGNATURES, 3), 1, 0, 0,  // void -> void
+      SIGNATURES_SECTION_VOID_VOID,
       // func#0 ----------------------------------------------------
-      SECTION(FUNCTIONS, 20), 1, kDeclFunctionLocals | kDeclFunctionName, 0,
-      0,            // signature index
-      2, 'h', 'i',  // name
-      1, 2,         // local int32 count
-      3, 4,         // local int64 count
-      5, 6,         // local float32 count
-      7, 8,         // local float64 count
-      3, 0,         // body size
-      kExprNop,     // func#0 body
-      kExprNop,     // func#0 body
-      kExprNop,     // func#0 body
+      SECTION(OLD_FUNCTIONS, 12), 1,
+      kDeclFunctionName,  // --
+      SIG_INDEX(0),       // signature index
+      2, 'h', 'i',        // name
+      3, 0,               // body size
+      kExprNop,           // func#0 body
+      kExprNop,           // func#0 body
+      kExprNop,           // func#0 body
+      // memory section --------------------------------------------
+      SECTION(MEMORY, 3), 28, 28, 1,
       // segment#0 -------------------------------------------------
-      SECTION(DATA_SEGMENTS, 14), 1,
+      SECTION(DATA_SEGMENTS, 10), 1,
       U32V_3(0x8b3ae),  // dest addr
       U32V_1(5),        // source size
       0, 1, 2, 3, 4,    // data bytes
@@ -529,7 +446,7 @@
 
   {
     ModuleResult result = DecodeModule(data, data + arraysize(data));
-    EXPECT_TRUE(result.ok());
+    EXPECT_OK(result);
     EXPECT_EQ(1, result.val->globals.size());
     EXPECT_EQ(1, result.val->functions.size());
     EXPECT_EQ(1, result.val->data_segments.size());
@@ -543,13 +460,12 @@
 
     WasmFunction* function = &result.val->functions.back();
 
-    EXPECT_EQ(63, function->name_offset);
+    EXPECT_EQ(kNameOffset, function->name_offset);
     EXPECT_EQ(2, function->name_length);
     EXPECT_EQ(kCodeStartOffset, function->code_start_offset);
     EXPECT_EQ(kCodeEndOffset, function->code_end_offset);
 
     EXPECT_FALSE(function->exported);
-    EXPECT_FALSE(function->external);
 
     WasmDataSegment* segment = &result.val->data_segments.back();
 
@@ -562,9 +478,8 @@
   }
 }
 
-
 TEST_F(WasmModuleVerifyTest, OneDataSegment) {
-  const byte kDataSegmentSourceOffset = 39;
+  const byte kDataSegmentSourceOffset = 30;
   const byte data[] = {
       SECTION(MEMORY, 3),
       28,
@@ -582,7 +497,7 @@
   {
     EXPECT_VERIFIES(data);
     ModuleResult result = DecodeModule(data, data + arraysize(data));
-    EXPECT_TRUE(result.ok());
+    EXPECT_OK(result);
     EXPECT_EQ(0, result.val->globals.size());
     EXPECT_EQ(0, result.val->functions.size());
     EXPECT_EQ(1, result.val->data_segments.size());
@@ -600,17 +515,16 @@
   EXPECT_OFF_END_FAILURE(data, 13, sizeof(data));
 }
 
-
 TEST_F(WasmModuleVerifyTest, TwoDataSegments) {
-  const byte kDataSegment0SourceOffset = 39;
-  const byte kDataSegment1SourceOffset = 39 + 8;
+  const byte kDataSegment0SourceOffset = 30;
+  const byte kDataSegment1SourceOffset = 30 + 8;
 
   const byte data[] = {
       SECTION(MEMORY, 3),
       28,
       28,
       1,
-      SECTION(DATA_SEGMENTS, 31),
+      SECTION(DATA_SEGMENTS, 23),
       2,                // segment count
       U32V_3(0x7ffee),  // #0: dest addr
       U32V_1(4),        // source size
@@ -634,7 +548,7 @@
 
   {
     ModuleResult result = DecodeModule(data, data + arraysize(data));
-    EXPECT_TRUE(result.ok());
+    EXPECT_OK(result);
     EXPECT_EQ(0, result.val->globals.size());
     EXPECT_EQ(0, result.val->functions.size());
     EXPECT_EQ(2, result.val->data_segments.size());
@@ -670,7 +584,7 @@
                      mem_pages,
                      mem_pages,
                      1,
-                     SECTION(DATA_SEGMENTS, 14),
+                     SECTION(DATA_SEGMENTS, 8),
                      1,
                      U32V_3(dest_addr),
                      U32V_1(source_size),
@@ -687,21 +601,18 @@
   }
 }
 
-
-// To make below tests for indirect calls much shorter.
-#define FUNCTION(sig_index, external) kDeclFunctionImport, SIG_INDEX(sig_index)
-
 TEST_F(WasmModuleVerifyTest, OneIndirectFunction) {
   static const byte data[] = {
       // sig#0 -------------------------------------------------------
-      SECTION(SIGNATURES, 3), 1, 0, 0,  // void -> void
+      SIGNATURES_SECTION_VOID_VOID,
       // func#0 ------------------------------------------------------
-      SECTION(FUNCTIONS, 4), 1, FUNCTION(0, 0),
+      SECTION(OLD_FUNCTIONS, 1 + SIZEOF_EMPTY_FUNCTION), 1,  // --
+      EMPTY_FUNCTION(0),
       // indirect table ----------------------------------------------
       SECTION(FUNCTION_TABLE, 2), 1, U32V_1(0)};
 
   ModuleResult result = DecodeModule(data, data + arraysize(data));
-  EXPECT_TRUE(result.ok());
+  EXPECT_OK(result);
   if (result.ok()) {
     EXPECT_EQ(1, result.val->signatures.size());
     EXPECT_EQ(1, result.val->functions.size());
@@ -711,17 +622,19 @@
   if (result.val) delete result.val;
 }
 
-
 TEST_F(WasmModuleVerifyTest, MultipleIndirectFunctions) {
   static const byte data[] = {
       // sig#0 -------------------------------------------------------
-      SECTION(SIGNATURES, 5), 2, 0, 0,  // void -> void
-      0, kLocalI32,                     // void -> i32
+      SECTION(SIGNATURES, 1 + SIZEOF_SIG_ENTRY_v_v + SIZEOF_SIG_ENTRY_v_x),
+      2,                         // --
+      SIG_ENTRY_v_v,             // void -> void
+      SIG_ENTRY_v_x(kLocalI32),  // void -> i32
       // func#0 ------------------------------------------------------
-      SECTION(FUNCTIONS, 13), 4, FUNCTION(0, 1),  // --
-      FUNCTION(1, 1),                             // --
-      FUNCTION(0, 1),                             // --
-      FUNCTION(1, 1),                             // --
+      SECTION(OLD_FUNCTIONS, 1 + 4 * SIZEOF_EMPTY_FUNCTION), 4,  // --
+      EMPTY_FUNCTION(0),                                         // --
+      EMPTY_FUNCTION(1),                                         // --
+      EMPTY_FUNCTION(0),                                         // --
+      EMPTY_FUNCTION(1),                                         // --
       // indirect table ----------------------------------------------
       SECTION(FUNCTION_TABLE, 9), 8,
       U32V_1(0),  // --
@@ -735,7 +648,7 @@
   };
 
   ModuleResult result = DecodeModule(data, data + arraysize(data));
-  EXPECT_TRUE(result.ok());
+  EXPECT_OK(result);
   if (result.ok()) {
     EXPECT_EQ(2, result.val->signatures.size());
     EXPECT_EQ(4, result.val->functions.size());
@@ -747,11 +660,10 @@
   if (result.val) delete result.val;
 }
 
-
 TEST_F(WasmModuleVerifyTest, IndirectFunctionNoFunctions) {
   static const byte data[] = {
       // sig#0 -------------------------------------------------------
-      SECTION(SIGNATURES, 3), 1, 0, 0,  // void -> void
+      SIGNATURES_SECTION_VOID_VOID,
       // indirect table ----------------------------------------------
       SECTION(FUNCTION_TABLE, 3), 1, 0, 0,
   };
@@ -759,13 +671,13 @@
   EXPECT_FAILURE(data);
 }
 
-
 TEST_F(WasmModuleVerifyTest, IndirectFunctionInvalidIndex) {
   static const byte data[] = {
       // sig#0 -------------------------------------------------------
-      SECTION(SIGNATURES, 3), 1, 0, 0,  // void -> void
+      SIGNATURES_SECTION_VOID_VOID,
       // functions ---------------------------------------------------
-      SECTION(FUNCTIONS, 4), 1, FUNCTION(0, 1),
+      SECTION(OLD_FUNCTIONS, 1 + SIZEOF_EMPTY_FUNCTION), 1,  // --
+      EMPTY_FUNCTION(0),
       // indirect table ----------------------------------------------
       SECTION(FUNCTION_TABLE, 3), 1, 1, 0,
   };
@@ -773,12 +685,10 @@
   EXPECT_FAILURE(data);
 }
 
-
 class WasmSignatureDecodeTest : public TestWithZone {};
 
-
 TEST_F(WasmSignatureDecodeTest, Ok_v_v) {
-  static const byte data[] = {0, 0};
+  static const byte data[] = {SIG_ENTRY_v_v};
   base::AccountingAllocator allocator;
   Zone zone(&allocator);
   FunctionSig* sig =
@@ -789,11 +699,10 @@
   EXPECT_EQ(0, sig->return_count());
 }
 
-
 TEST_F(WasmSignatureDecodeTest, Ok_t_v) {
   for (size_t i = 0; i < arraysize(kLocalTypes); i++) {
     LocalTypePair ret_type = kLocalTypes[i];
-    const byte data[] = {0, ret_type.code};
+    const byte data[] = {SIG_ENTRY_x(ret_type.code)};
     FunctionSig* sig =
         DecodeWasmSignatureForTesting(zone(), data, data + arraysize(data));
 
@@ -804,11 +713,10 @@
   }
 }
 
-
 TEST_F(WasmSignatureDecodeTest, Ok_v_t) {
   for (size_t i = 0; i < arraysize(kLocalTypes); i++) {
     LocalTypePair param_type = kLocalTypes[i];
-    const byte data[] = {1, 0, param_type.code};
+    const byte data[] = {SIG_ENTRY_v_x(param_type.code)};
     FunctionSig* sig =
         DecodeWasmSignatureForTesting(zone(), data, data + arraysize(data));
 
@@ -819,15 +727,12 @@
   }
 }
 
-
 TEST_F(WasmSignatureDecodeTest, Ok_t_t) {
   for (size_t i = 0; i < arraysize(kLocalTypes); i++) {
     LocalTypePair ret_type = kLocalTypes[i];
     for (size_t j = 0; j < arraysize(kLocalTypes); j++) {
       LocalTypePair param_type = kLocalTypes[j];
-      const byte data[] = {1,                 // param count
-                           ret_type.code,     // ret
-                           param_type.code};  // param
+      const byte data[] = {SIG_ENTRY_x_x(ret_type.code, param_type.code)};
       FunctionSig* sig =
           DecodeWasmSignatureForTesting(zone(), data, data + arraysize(data));
 
@@ -840,16 +745,13 @@
   }
 }
 
-
 TEST_F(WasmSignatureDecodeTest, Ok_i_tt) {
   for (size_t i = 0; i < arraysize(kLocalTypes); i++) {
     LocalTypePair p0_type = kLocalTypes[i];
     for (size_t j = 0; j < arraysize(kLocalTypes); j++) {
       LocalTypePair p1_type = kLocalTypes[j];
-      const byte data[] = {2,              // param count
-                           kLocalI32,      // ret
-                           p0_type.code,   // p0
-                           p1_type.code};  // p1
+      const byte data[] = {
+          SIG_ENTRY_x_xx(kLocalI32, p0_type.code, p1_type.code)};
       FunctionSig* sig =
           DecodeWasmSignatureForTesting(zone(), data, data + arraysize(data));
 
@@ -862,7 +764,6 @@
   }
 }
 
-
 TEST_F(WasmSignatureDecodeTest, Fail_off_end) {
   byte data[256];
   for (int p = 0; p <= 255; p = p + 1 + p * 3) {
@@ -877,11 +778,10 @@
   }
 }
 
-
 TEST_F(WasmSignatureDecodeTest, Fail_invalid_type) {
   byte kInvalidType = 76;
-  for (int i = 1; i < 3; i++) {
-    byte data[] = {2, kLocalI32, kLocalI32, kLocalI32};
+  for (size_t i = 0; i < SIZEOF_SIG_ENTRY_x_xx; i++) {
+    byte data[] = {SIG_ENTRY_x_xx(kLocalI32, kLocalI32, kLocalI32)};
     data[i] = kInvalidType;
     FunctionSig* sig =
         DecodeWasmSignatureForTesting(zone(), data, data + arraysize(data));
@@ -889,46 +789,56 @@
   }
 }
 
-
-TEST_F(WasmSignatureDecodeTest, Fail_invalid_param_type) {
-  static const int kParamCount = 3;
-  for (int i = 0; i < kParamCount; i++) {
-    byte data[] = {kParamCount, kLocalI32, kLocalI32, kLocalI32, kLocalI32};
-    data[i + 2] = kLocalVoid;
-    FunctionSig* sig =
-        DecodeWasmSignatureForTesting(zone(), data, data + arraysize(data));
-    EXPECT_EQ(nullptr, sig);
-  }
+TEST_F(WasmSignatureDecodeTest, Fail_invalid_ret_type1) {
+  static const byte data[] = {SIG_ENTRY_x_x(kLocalVoid, kLocalI32)};
+  FunctionSig* sig =
+      DecodeWasmSignatureForTesting(zone(), data, data + arraysize(data));
+  EXPECT_EQ(nullptr, sig);
 }
 
+TEST_F(WasmSignatureDecodeTest, Fail_invalid_param_type1) {
+  static const byte data[] = {SIG_ENTRY_x_x(kLocalI32, kLocalVoid)};
+  FunctionSig* sig =
+      DecodeWasmSignatureForTesting(zone(), data, data + arraysize(data));
+  EXPECT_EQ(nullptr, sig);
+}
 
-class WasmFunctionVerifyTest : public TestWithZone {};
+TEST_F(WasmSignatureDecodeTest, Fail_invalid_param_type2) {
+  static const byte data[] = {SIG_ENTRY_x_xx(kLocalI32, kLocalI32, kLocalVoid)};
+  FunctionSig* sig =
+      DecodeWasmSignatureForTesting(zone(), data, data + arraysize(data));
+  EXPECT_EQ(nullptr, sig);
+}
 
+class WasmFunctionVerifyTest : public TestWithIsolateAndZone {};
 
 TEST_F(WasmFunctionVerifyTest, Ok_v_v_empty) {
   static const byte data[] = {
-      0,       kLocalVoid,  // signature
-      4,                    // locals
-      3,       kLocalI32,   // --
-      4,       kLocalI64,   // --
-      5,       kLocalF32,   // --
-      6,       kLocalF64,   // --
-      kExprNop              // body
+      SIG_ENTRY_v_v,  // signature entry
+      4,              // locals
+      3,
+      kLocalI32,  // --
+      4,
+      kLocalI64,  // --
+      5,
+      kLocalF32,  // --
+      6,
+      kLocalF64,  // --
+      kExprNop    // body
   };
 
-  FunctionResult result = DecodeWasmFunction(nullptr, zone(), nullptr, data,
+  FunctionResult result = DecodeWasmFunction(isolate(), zone(), nullptr, data,
                                              data + arraysize(data));
-  EXPECT_TRUE(result.ok());
+  EXPECT_OK(result);
 
   if (result.val && result.ok()) {
     WasmFunction* function = result.val;
     EXPECT_EQ(0, function->sig->parameter_count());
     EXPECT_EQ(0, function->sig->return_count());
     EXPECT_EQ(0, function->name_offset);
-    EXPECT_EQ(2, function->code_start_offset);
+    EXPECT_EQ(SIZEOF_SIG_ENTRY_v_v, function->code_start_offset);
     EXPECT_EQ(arraysize(data), function->code_end_offset);
     // TODO(titzer): verify encoding of local declarations
-    EXPECT_FALSE(function->external);
     EXPECT_FALSE(function->exported);
   }
 
@@ -942,47 +852,51 @@
 
 TEST_F(WasmModuleVerifyTest, TheLoneliestOfValidModulesTheTrulyEmptyOne) {
   const byte data[] = {
-      1,  // Section size.
       0,  // Empty section name.
           // No section name, no content, nothing but sadness.
+      0,  // No section content.
   };
   EXPECT_VERIFIES(data);
 }
 
 TEST_F(WasmModuleVerifyTest, OnlyUnknownSectionEmpty) {
   const byte data[] = {
-      5,                      // Section size.
-      4, 'l', 'u', 'l', 'z',  // unknown section.
+      UNKNOWN_SECTION_NAME, 0,
   };
   EXPECT_VERIFIES(data);
 }
 
 TEST_F(WasmModuleVerifyTest, OnlyUnknownSectionNonEmpty) {
   const byte data[] = {
-      10,                     // Section size.
-      4, 'l', 'u', 'l', 'z',  // unknown section.
-      // Section content:
-      0xff, 0xff, 0xff, 0xff, 0xff,
+      UNKNOWN_SECTION_NAME,
+      5,  // section size
+      0xff,
+      0xff,
+      0xff,
+      0xff,
+      0xff,  // section data
   };
   EXPECT_VERIFIES(data);
 }
 
 TEST_F(WasmModuleVerifyTest, SignatureFollowedByEmptyUnknownSection) {
   const byte data[] = {
-      SECTION(SIGNATURES, 1 + VOID_VOID_SIG_SIZE), 1, VOID_VOID_SIG,
+      // signatures
+      SIGNATURES_SECTION_VOID_VOID,
       // -----------------------------------------------------------
-      5,                      // Section size.
-      4, 'l', 'u', 'l', 'z',  // unknown section.
+      UNKNOWN_SECTION_NAME,
+      0  // empty section
   };
   EXPECT_VERIFIES(data);
 }
 
 TEST_F(WasmModuleVerifyTest, SignatureFollowedByUnknownSection) {
   const byte data[] = {
-      SECTION(SIGNATURES, 1 + VOID_VOID_SIG_SIZE), 1, VOID_VOID_SIG,
+      // signatures
+      SIGNATURES_SECTION_VOID_VOID,
       // -----------------------------------------------------------
-      10,                     // Section size.
-      4, 'l', 'u', 'l', 'z',  // unknown section.
+      UNKNOWN_SECTION_NAME,
+      5,  // section size
       0xff, 0xff, 0xff, 0xff, 0xff,
   };
   EXPECT_VERIFIES(data);
@@ -990,29 +904,46 @@
 
 TEST_F(WasmModuleVerifyTest, SignatureFollowedByUnknownSectionWithLongLEB) {
   const byte data[] = {
-      SECTION(SIGNATURES, 1 + VOID_VOID_SIG_SIZE), 1, VOID_VOID_SIG,
+      // signatures
+      SIGNATURES_SECTION_VOID_VOID,
       // -----------------------------------------------------------
-      0x85, 0x80, 0x80, 0x80, 0x00,  // Section size: 1 but in a 5-byte LEB.
-      4, 'l', 'u', 'l', 'z',         // unknown section.
+      UNKNOWN_SECTION_NAME, 0x81, 0x80, 0x80, 0x80,
+      0x00,  // section size: 1 but in a 5-byte LEB
+      0,
   };
   EXPECT_VERIFIES(data);
 }
 
 TEST_F(WasmModuleVerifyTest, UnknownSectionOverflow) {
   static const byte data[] = {
-      13,                                // Section size.
-      1,                                 // Section name length.
-      '\0',                              // Section name.
-      1,    2, 3, 4, 5, 6, 7, 8, 9, 10,  // 10 byte section
+      UNKNOWN_EMPTY_SECTION_NAME,
+      9,  // section size
+      1,
+      2,
+      3,
+      4,
+      5,
+      6,
+      7,
+      8,
+      9,
+      10,  // 10 byte section
   };
   EXPECT_FAILURE(data);
 }
 
 TEST_F(WasmModuleVerifyTest, UnknownSectionUnderflow) {
   static const byte data[] = {
-      0xff, 0xff, 0xff, 0xff, 0x0f,  // Section size LEB128 0xffffffff
-      1,    '\0',                    // Section name and name length.
-      1,    2,    3,    4,           // 4 byte section
+      UNKNOWN_EMPTY_SECTION_NAME,
+      0xff,
+      0xff,
+      0xff,
+      0xff,
+      0x0f,  // Section size LEB128 0xffffffff
+      1,
+      2,
+      3,
+      4,  // 4 byte section
   };
   EXPECT_FAILURE(data);
 }
@@ -1020,27 +951,33 @@
 TEST_F(WasmModuleVerifyTest, UnknownSectionLoop) {
   // Would infinite loop decoding if wrapping and allowed.
   static const byte data[] = {
-      0xfa, 0xff, 0xff, 0xff, 0x0f,  // Section size LEB128 0xfffffffa
-      1,    '\0',                    // Section name and name length.
-      1,    2,    3,    4,           // 4 byte section
+      UNKNOWN_EMPTY_SECTION_NAME,
+      1,
+      2,
+      3,
+      4,  // 4 byte section
+      0xfa,
+      0xff,
+      0xff,
+      0xff,
+      0x0f,  // Section size LEB128 0xfffffffa
   };
   EXPECT_FAILURE(data);
 }
 
 TEST_F(WasmModuleVerifyTest, UnknownSectionSkipped) {
   static const byte data[] = {
-      3,  // Section size.
-      1,
-      '\0',  // Section name: LEB128 1, string '\0'
-      0,     // one byte section
-      SECTION(GLOBALS, 7),
+      UNKNOWN_EMPTY_SECTION_NAME,
+      1,  // section size
+      0,  // one byte section
+      SECTION(GLOBALS, 4),
       1,
       0,        // name length
       kMemI32,  // memory type
       0,        // exported
   };
   ModuleResult result = DecodeModule(data, data + arraysize(data));
-  EXPECT_TRUE(result.ok());
+  EXPECT_OK(result);
 
   EXPECT_EQ(1, result.val->globals.size());
   EXPECT_EQ(0, result.val->functions.size());
@@ -1062,26 +999,36 @@
   EXPECT_VERIFIES(data);
 }
 
-TEST_F(WasmModuleVerifyTest, ImportTable_nosigs) {
+TEST_F(WasmModuleVerifyTest, ImportTable_nosigs1) {
   static const byte data[] = {SECTION(IMPORT_TABLE, 1), 0};
+  EXPECT_VERIFIES(data);
+}
+
+TEST_F(WasmModuleVerifyTest, ImportTable_nosigs2) {
+  static const byte data[] = {
+      SECTION(IMPORT_TABLE, 6), 1,    // sig table
+      IMPORT_SIG_INDEX(0),            // sig index
+      NAME_LENGTH(1),           'm',  // module name
+      NAME_LENGTH(1),           'f',  // function name
+  };
   EXPECT_FAILURE(data);
 }
 
 TEST_F(WasmModuleVerifyTest, ImportTable_invalid_sig) {
   static const byte data[] = {
-      SECTION(SIGNATURES, 1), 0,   SECTION(IMPORT_TABLE, 6), 1,
-      IMPORT_SIG_INDEX(0),          // sig index
-      NAME_LENGTH(1),         'm',  // module name
-      NAME_LENGTH(1),         'f',  // function name
+      SECTION(SIGNATURES, 1),   0,    // --
+      SECTION(IMPORT_TABLE, 6), 1,    // --
+      IMPORT_SIG_INDEX(0),            // sig index
+      NAME_LENGTH(1),           'm',  // module name
+      NAME_LENGTH(1),           'f',  // function name
   };
   EXPECT_FAILURE(data);
 }
 
 TEST_F(WasmModuleVerifyTest, ImportTable_one_sig) {
   static const byte data[] = {
-      SECTION(SIGNATURES, 1 + VOID_VOID_SIG_SIZE),
-      1,
-      VOID_VOID_SIG,
+      // signatures
+      SIGNATURES_SECTION_VOID_VOID,
       SECTION(IMPORT_TABLE, 6),
       1,                    // --
       IMPORT_SIG_INDEX(0),  // sig index
@@ -1095,9 +1042,8 @@
 
 TEST_F(WasmModuleVerifyTest, ImportTable_invalid_module) {
   static const byte data[] = {
-      SECTION(SIGNATURES, 1 + VOID_VOID_SIG_SIZE),
-      1,
-      VOID_VOID_SIG,
+      // signatures
+      SIGNATURES_SECTION_VOID_VOID,
       SECTION(IMPORT_TABLE, 6),
       1,                    // --
       IMPORT_SIG_INDEX(0),  // sig index
@@ -1110,9 +1056,8 @@
 
 TEST_F(WasmModuleVerifyTest, ImportTable_off_end) {
   static const byte data[] = {
-      SECTION(SIGNATURES, 1 + VOID_VOID_SIG_SIZE),
-      1,
-      VOID_VOID_SIG,
+      // signatures
+      SIGNATURES_SECTION_VOID_VOID,
       SECTION(IMPORT_TABLE, 6),
       1,
       IMPORT_SIG_INDEX(0),  // sig index
@@ -1126,28 +1071,31 @@
 }
 
 TEST_F(WasmModuleVerifyTest, ExportTable_empty1) {
-  static const byte data[] = {SECTION(SIGNATURES, 1 + VOID_VOID_SIG_SIZE),
-                              1,
-                              VOID_VOID_SIG,
-                              SECTION(FUNCTIONS, 1 + EMPTY_FUNCTION_SIZE),
-                              1,
-                              EMPTY_FUNCTION(0),
-                              SECTION(EXPORT_TABLE, 1),
-                              0};
+  static const byte data[] = {
+      // signatures
+      SIGNATURES_SECTION_VOID_VOID,
+      SECTION(OLD_FUNCTIONS, 1 + SIZEOF_EMPTY_FUNCTION),
+      1,
+      EMPTY_FUNCTION(0),
+      SECTION(EXPORT_TABLE, 1),
+      0  // --
+  };
   EXPECT_VERIFIES(data);
 }
 
 TEST_F(WasmModuleVerifyTest, ExportTable_empty2) {
-  static const byte data[] = {SECTION(SIGNATURES, 1),   0,
-                              SECTION(FUNCTIONS, 1),    0,
-                              SECTION(EXPORT_TABLE, 1), 0};
+  static const byte data[] = {
+      SECTION(SIGNATURES, 1),   0, SECTION(OLD_FUNCTIONS, 1), 0,
+      SECTION(EXPORT_TABLE, 1), 0  // --
+  };
   // TODO(titzer): current behavior treats empty functions section as missing.
   EXPECT_FAILURE(data);
 }
 
 TEST_F(WasmModuleVerifyTest, ExportTable_NoFunctions1) {
-  static const byte data[] = {SECTION(SIGNATURES, 1), 0,
-                              SECTION(EXPORT_TABLE, 1), 0};
+  static const byte data[] = {
+      SECTION(SIGNATURES, 1), 0, SECTION(EXPORT_TABLE, 1), 0  // --
+  };
   EXPECT_FAILURE(data);
 }
 
@@ -1158,13 +1106,12 @@
 
 TEST_F(WasmModuleVerifyTest, ExportTableOne) {
   static const byte data[] = {
-      SECTION(SIGNATURES, 1 + VOID_VOID_SIG_SIZE),
-      1,              // sigs
-      VOID_VOID_SIG,  // --
-      SECTION(FUNCTIONS, 1 + EMPTY_FUNCTION_SIZE),
+      // signatures
+      SIGNATURES_SECTION_VOID_VOID,
+      SECTION(OLD_FUNCTIONS, 1 + SIZEOF_EMPTY_FUNCTION),
       1,                  // functions
       EMPTY_FUNCTION(0),  // --
-      SECTION(EXPORT_TABLE, 7),
+      SECTION(EXPORT_TABLE, 3),
       1,              // exports
       FUNC_INDEX(0),  // --
       NO_NAME         // --
@@ -1174,10 +1121,9 @@
 
 TEST_F(WasmModuleVerifyTest, ExportTableTwo) {
   static const byte data[] = {
-      SECTION(SIGNATURES, 1 + VOID_VOID_SIG_SIZE),
-      1,              // sigs
-      VOID_VOID_SIG,  // --
-      SECTION(FUNCTIONS, 1 + EMPTY_FUNCTION_SIZE),
+      // signatures
+      SIGNATURES_SECTION_VOID_VOID,
+      SECTION(OLD_FUNCTIONS, 1 + SIZEOF_EMPTY_FUNCTION),
       1,                  // functions
       EMPTY_FUNCTION(0),  // --
       SECTION(EXPORT_TABLE, 12),
@@ -1199,10 +1145,9 @@
 
 TEST_F(WasmModuleVerifyTest, ExportTableThree) {
   static const byte data[] = {
-      SECTION(SIGNATURES, 1 + VOID_VOID_SIG_SIZE),
-      1,              // sigs
-      VOID_VOID_SIG,  // --
-      SECTION(FUNCTIONS, 1 + 3 * EMPTY_FUNCTION_SIZE),
+      // signatures
+      SIGNATURES_SECTION_VOID_VOID,
+      SECTION(OLD_FUNCTIONS, 1 + 3 * SIZEOF_EMPTY_FUNCTION),
       3,                  // functions
       EMPTY_FUNCTION(0),  // --
       EMPTY_FUNCTION(0),  // --
@@ -1225,10 +1170,9 @@
 TEST_F(WasmModuleVerifyTest, ExportTableThreeOne) {
   for (int i = 0; i < 6; i++) {
     const byte data[] = {
-        SECTION(SIGNATURES, 1 + VOID_VOID_SIG_SIZE),
-        1,              // sigs
-        VOID_VOID_SIG,  // --
-        SECTION(FUNCTIONS, 1 + 3 * EMPTY_FUNCTION_SIZE),
+        // signatures
+        SIGNATURES_SECTION_VOID_VOID,
+        SECTION(OLD_FUNCTIONS, 1 + 3 * SIZEOF_EMPTY_FUNCTION),
         3,                  // functions
         EMPTY_FUNCTION(0),  // --
         EMPTY_FUNCTION(0),  // --
@@ -1251,10 +1195,9 @@
 
 TEST_F(WasmModuleVerifyTest, ExportTableOne_off_end) {
   static const byte data[] = {
-      SECTION(SIGNATURES, 1 + VOID_VOID_SIG_SIZE),
-      1,              // sigs
-      VOID_VOID_SIG,  // --
-      SECTION(FUNCTIONS, 1 + EMPTY_FUNCTION_SIZE),
+      // signatures
+      SIGNATURES_SECTION_VOID_VOID,
+      SECTION(OLD_FUNCTIONS, 1 + SIZEOF_EMPTY_FUNCTION),
       1,                  // functions
       EMPTY_FUNCTION(0),  // --
       SECTION(EXPORT_TABLE, 1 + 6),
@@ -1270,67 +1213,68 @@
   }
 }
 
-#define SIGNATURES_SECTION(count, ...) \
-  SECTION(SIGNATURES, 1 + 3 * (count)), U32V_1(count), __VA_ARGS__
-#define FUNCTION_SIGNATURES_SECTION(count, ...) \
-  SECTION(FUNCTION_SIGNATURES, 1 + (count)), U32V_1(count), __VA_ARGS__
-
-#define FOO_STRING 3, 'f', 'o', 'o'
-#define NO_LOCAL_NAMES 0
-
-#define EMPTY_SIGNATURES_SECTION SECTION(SIGNATURES, 1), 0
-#define EMPTY_FUNCTION_SIGNATURES_SECTION SECTION(FUNCTION_SIGNATURES, 1), 0
-#define EMPTY_FUNCTION_BODIES_SECTION SECTION(FUNCTION_BODIES, 1), 0
-#define EMPTY_NAMES_SECTION SECTION(NAMES, 1), 0
-
 TEST_F(WasmModuleVerifyTest, FunctionSignatures_empty) {
-  static const byte data[] = {SECTION(SIGNATURES, 1), 0,
-                              SECTION(FUNCTION_SIGNATURES, 1), 0};
+  static const byte data[] = {
+      SECTION(SIGNATURES, 1), 0,          // --
+      SECTION(FUNCTION_SIGNATURES, 1), 0  // --
+  };                                      // --
   EXPECT_VERIFIES(data);
 }
 
 TEST_F(WasmModuleVerifyTest, FunctionSignatures_one) {
-  static const byte data[] = {SIGNATURES_SECTION(1, VOID_VOID_SIG),
-                              FUNCTION_SIGNATURES_SECTION(1, 0)};
+  static const byte data[] = {
+      SIGNATURES_SECTION(1, SIG_ENTRY_v_v),  // --
+      FUNCTION_SIGNATURES_SECTION(1, 0)      // --
+  };
   EXPECT_VERIFIES(data);
 }
 
 TEST_F(WasmModuleVerifyTest, FunctionBodies_empty) {
-  static const byte data[] = {EMPTY_SIGNATURES_SECTION,
-                              EMPTY_FUNCTION_SIGNATURES_SECTION,
-                              EMPTY_FUNCTION_BODIES_SECTION};
+  static const byte data[] = {
+      EMPTY_SIGNATURES_SECTION,           // --
+      EMPTY_FUNCTION_SIGNATURES_SECTION,  // --
+      EMPTY_FUNCTION_BODIES_SECTION       // --
+  };
   EXPECT_VERIFIES(data);
 }
 
 TEST_F(WasmModuleVerifyTest, FunctionBodies_one_empty) {
   static const byte data[] = {
-      SIGNATURES_SECTION(1, VOID_VOID_SIG), FUNCTION_SIGNATURES_SECTION(1, 0),
-      SECTION(FUNCTION_BODIES, 1 + EMPTY_BODY_SIZE), 1, EMPTY_BODY};
+      SIGNATURES_SECTION(1, SIG_ENTRY_v_v),                           // --
+      FUNCTION_SIGNATURES_SECTION(1, 0),                              // --
+      SECTION(FUNCTION_BODIES, 1 + SIZEOF_EMPTY_BODY), 1, EMPTY_BODY  // --
+  };
   EXPECT_VERIFIES(data);
 }
 
 TEST_F(WasmModuleVerifyTest, FunctionBodies_one_nop) {
   static const byte data[] = {
-      SIGNATURES_SECTION(1, VOID_VOID_SIG), FUNCTION_SIGNATURES_SECTION(1, 0),
-      SECTION(FUNCTION_BODIES, 1 + NOP_BODY_SIZE), 1, NOP_BODY};
+      SIGNATURES_SECTION(1, SIG_ENTRY_v_v),                       // --
+      FUNCTION_SIGNATURES_SECTION(1, 0),                          // --
+      SECTION(FUNCTION_BODIES, 1 + SIZEOF_NOP_BODY), 1, NOP_BODY  // --
+  };
   EXPECT_VERIFIES(data);
 }
 
 TEST_F(WasmModuleVerifyTest, FunctionBodies_count_mismatch1) {
-  static const byte data[] = {SIGNATURES_SECTION(1, VOID_VOID_SIG),
-                              FUNCTION_SIGNATURES_SECTION(2, 0, 0),
-                              SECTION(FUNCTION_BODIES, 1 + EMPTY_BODY_SIZE), 1,
-                              EMPTY_BODY};
+  static const byte data[] = {
+      SIGNATURES_SECTION(1, SIG_ENTRY_v_v),                // --
+      FUNCTION_SIGNATURES_SECTION(2, 0, 0),                // --
+      SECTION(FUNCTION_BODIES, 1 + SIZEOF_EMPTY_BODY), 1,  // --
+      EMPTY_BODY                                           // --
+  };
   EXPECT_FAILURE(data);
 }
 
 TEST_F(WasmModuleVerifyTest, FunctionBodies_count_mismatch2) {
-  static const byte data[] = {SIGNATURES_SECTION(1, VOID_VOID_SIG),
-                              FUNCTION_SIGNATURES_SECTION(1, 0),
-                              SECTION(FUNCTION_BODIES, 1 + 2 * NOP_BODY_SIZE),
-                              2,
-                              NOP_BODY,
-                              NOP_BODY};
+  static const byte data[] = {
+      SIGNATURES_SECTION(1, SIG_ENTRY_v_v),               // --
+      FUNCTION_SIGNATURES_SECTION(1, 0),                  // --
+      SECTION(FUNCTION_BODIES, 1 + 2 * SIZEOF_NOP_BODY),  // --
+      2,                                                  // --
+      NOP_BODY,                                           // --
+      NOP_BODY                                            // --
+  };
   EXPECT_FAILURE(data);
 }
 
@@ -1343,9 +1287,9 @@
 
 TEST_F(WasmModuleVerifyTest, Names_one_empty) {
   static const byte data[] = {
-      SIGNATURES_SECTION(1, VOID_VOID_SIG),  // --
+      SIGNATURES_SECTION(1, SIG_ENTRY_v_v),  // --
       FUNCTION_SIGNATURES_SECTION(1, 0),     // --
-      SECTION(FUNCTION_BODIES, 1 + EMPTY_BODY_SIZE),
+      SECTION(FUNCTION_BODIES, 1 + SIZEOF_EMPTY_BODY),
       1,
       EMPTY_BODY,  // --
       SECTION(NAMES, 1 + 5),
@@ -1358,9 +1302,9 @@
 
 TEST_F(WasmModuleVerifyTest, Names_two_empty) {
   static const byte data[] = {
-      SIGNATURES_SECTION(1, VOID_VOID_SIG),               // --
-      FUNCTION_SIGNATURES_SECTION(2, 0, 0),               // --
-      SECTION(FUNCTION_BODIES, 1 + 2 * EMPTY_BODY_SIZE),  // --
+      SIGNATURES_SECTION(1, SIG_ENTRY_v_v),                 // --
+      FUNCTION_SIGNATURES_SECTION(2, 0, 0),                 // --
+      SECTION(FUNCTION_BODIES, 1 + 2 * SIZEOF_EMPTY_BODY),  // --
       2,
       EMPTY_BODY,
       EMPTY_BODY,  // --
diff --git a/test/unittests/wasm/switch-logic-unittest.cc b/test/unittests/wasm/switch-logic-unittest.cc
new file mode 100644
index 0000000..be587c2
--- /dev/null
+++ b/test/unittests/wasm/switch-logic-unittest.cc
@@ -0,0 +1,89 @@
+// Copyright 2016 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/wasm/switch-logic.h"
+#include "test/unittests/test-utils.h"
+
+namespace v8 {
+namespace internal {
+namespace wasm {
+class SwitchLogicTest : public TestWithZone {};
+
+void CheckNodeValues(CaseNode* node, int begin, int end) {
+  CHECK_EQ(node->begin, begin);
+  CHECK_EQ(node->end, end);
+}
+
+TEST_F(SwitchLogicTest, Single_Table_Test) {
+  ZoneVector<int> values(zone());
+  values.push_back(14);
+  values.push_back(12);
+  values.push_back(15);
+  values.push_back(19);
+  values.push_back(18);
+  values.push_back(16);
+  CaseNode* root = OrderCases(&values, zone());
+  CHECK_NULL(root->left);
+  CHECK_NULL(root->right);
+  CheckNodeValues(root, 12, 19);
+}
+
+TEST_F(SwitchLogicTest, Balanced_Tree_Test) {
+  ZoneVector<int> values(zone());
+  values.push_back(5);
+  values.push_back(1);
+  values.push_back(6);
+  values.push_back(9);
+  values.push_back(-4);
+  CaseNode* root = OrderCases(&values, zone());
+  CheckNodeValues(root, 5, 5);
+  CheckNodeValues(root->left, -4, -4);
+  CHECK_NULL(root->left->left);
+  CheckNodeValues(root->left->right, 1, 1);
+  CHECK_NULL(root->left->right->left);
+  CHECK_NULL(root->left->right->right);
+  CheckNodeValues(root->right, 6, 6);
+  CHECK_NULL(root->right->left);
+  CheckNodeValues(root->right->right, 9, 9);
+  CHECK_NULL(root->right->right->left);
+  CHECK_NULL(root->right->right->right);
+}
+
+TEST_F(SwitchLogicTest, Hybrid_Test) {
+  ZoneVector<int> values(zone());
+  values.push_back(1);
+  values.push_back(2);
+  values.push_back(3);
+  values.push_back(4);
+  values.push_back(7);
+  values.push_back(10);
+  values.push_back(11);
+  values.push_back(12);
+  values.push_back(13);
+  values.push_back(16);
+  CaseNode* root = OrderCases(&values, zone());
+  CheckNodeValues(root, 7, 7);
+  CheckNodeValues(root->left, 1, 4);
+  CheckNodeValues(root->right, 10, 13);
+  CheckNodeValues(root->right->right, 16, 16);
+}
+
+TEST_F(SwitchLogicTest, Single_Case) {
+  ZoneVector<int> values(zone());
+  values.push_back(3);
+  CaseNode* root = OrderCases(&values, zone());
+  CheckNodeValues(root, 3, 3);
+  CHECK_NULL(root->left);
+  CHECK_NULL(root->right);
+}
+
+TEST_F(SwitchLogicTest, Empty_Case) {
+  ZoneVector<int> values(zone());
+  CaseNode* root = OrderCases(&values, zone());
+  CHECK_NULL(root);
+}
+
+}  // namespace wasm
+}  // namespace internal
+}  // namespace v8
diff --git a/test/unittests/wasm/wasm-macro-gen-unittest.cc b/test/unittests/wasm/wasm-macro-gen-unittest.cc
index ec188c0..1058993 100644
--- a/test/unittests/wasm/wasm-macro-gen-unittest.cc
+++ b/test/unittests/wasm/wasm-macro-gen-unittest.cc
@@ -18,7 +18,6 @@
     EXPECT_EQ(size, sizeof(code)); \
   } while (false)
 
-
 TEST_F(WasmMacroGenTest, Constants) {
   EXPECT_SIZE(2, WASM_ONE);
   EXPECT_SIZE(2, WASM_ZERO);
@@ -48,7 +47,6 @@
   EXPECT_SIZE(9, WASM_F64(-9818934.0));
 }
 
-
 TEST_F(WasmMacroGenTest, Statements) {
   EXPECT_SIZE(1, WASM_NOP);
 
@@ -58,9 +56,9 @@
 
   EXPECT_SIZE(7, WASM_STORE_MEM(MachineType::Int32(), WASM_ZERO, WASM_ZERO));
 
-  EXPECT_SIZE(4, WASM_IF(WASM_ZERO, WASM_NOP));
+  EXPECT_SIZE(5, WASM_IF(WASM_ZERO, WASM_NOP));
 
-  EXPECT_SIZE(5, WASM_IF_ELSE(WASM_ZERO, WASM_NOP, WASM_NOP));
+  EXPECT_SIZE(7, WASM_IF_ELSE(WASM_ZERO, WASM_NOP, WASM_NOP));
 
   EXPECT_SIZE(5, WASM_SELECT(WASM_ZERO, WASM_NOP, WASM_NOP));
 
@@ -79,16 +77,14 @@
   EXPECT_SIZE(5, WASM_LOOP(1, WASM_BR(0)));
   EXPECT_SIZE(7, WASM_LOOP(1, WASM_BR_IF(0, WASM_ZERO)));
 
-  EXPECT_SIZE(1, WASM_RETURN0);
-  EXPECT_SIZE(3, WASM_RETURN(WASM_ZERO));
-  EXPECT_SIZE(5, WASM_RETURN(WASM_ZERO, WASM_ZERO));
+  EXPECT_SIZE(2, WASM_RETURN0);
+  EXPECT_SIZE(4, WASM_RETURN1(WASM_ZERO));
 
   EXPECT_SIZE(1, WASM_UNREACHABLE);
 }
 
-
 TEST_F(WasmMacroGenTest, MacroStatements) {
-  EXPECT_SIZE(8, WASM_WHILE(WASM_I8(0), WASM_NOP));
+  EXPECT_SIZE(10, WASM_WHILE(WASM_I8(0), WASM_NOP));
   EXPECT_SIZE(7, WASM_INC_LOCAL(0));
   EXPECT_SIZE(7, WASM_INC_LOCAL_BY(0, 3));
 
@@ -97,10 +93,10 @@
 }
 
 TEST_F(WasmMacroGenTest, BrTable) {
-  EXPECT_SIZE(8, WASM_BR_TABLE(WASM_ZERO, 1, BR_TARGET(1)));
+  EXPECT_SIZE(9, WASM_BR_TABLE(WASM_ZERO, 1, BR_TARGET(1)));
+  EXPECT_SIZE(11, WASM_BR_TABLEV(WASM_ZERO, WASM_ZERO, 1, BR_TARGET(1)));
 }
 
-
 TEST_F(WasmMacroGenTest, Expressions) {
   EXPECT_SIZE(2, WASM_GET_LOCAL(0));
   EXPECT_SIZE(2, WASM_GET_LOCAL(1));
@@ -114,8 +110,8 @@
 
   EXPECT_SIZE(3, WASM_NOT(WASM_ZERO));
 
-  EXPECT_SIZE(4, WASM_BRV(1, WASM_ZERO));
-  EXPECT_SIZE(6, WASM_BRV_IF(1, WASM_ZERO, WASM_ZERO));
+  EXPECT_SIZE(5, WASM_BRV(1, WASM_ZERO));
+  EXPECT_SIZE(7, WASM_BRV_IF(1, WASM_ZERO, WASM_ZERO));
 
   EXPECT_SIZE(4, WASM_BLOCK(1, WASM_ZERO));
   EXPECT_SIZE(5, WASM_BLOCK(2, WASM_NOP, WASM_ZERO));
@@ -127,33 +123,32 @@
 }
 
 TEST_F(WasmMacroGenTest, CallFunction) {
-  EXPECT_SIZE(2, WASM_CALL_FUNCTION0(0));
-  EXPECT_SIZE(2, WASM_CALL_FUNCTION0(1));
-  EXPECT_SIZE(2, WASM_CALL_FUNCTION0(11));
+  EXPECT_SIZE(3, WASM_CALL_FUNCTION0(0));
+  EXPECT_SIZE(3, WASM_CALL_FUNCTION0(1));
+  EXPECT_SIZE(3, WASM_CALL_FUNCTION0(11));
 
-  EXPECT_SIZE(4, WASM_CALL_FUNCTION(0, WASM_ZERO));
-  EXPECT_SIZE(6, WASM_CALL_FUNCTION(1, WASM_ZERO, WASM_ZERO));
+  EXPECT_SIZE(5, WASM_CALL_FUNCTION1(0, WASM_ZERO));
+  EXPECT_SIZE(7, WASM_CALL_FUNCTION2(1, WASM_ZERO, WASM_ZERO));
 }
 
 TEST_F(WasmMacroGenTest, CallImport) {
-  EXPECT_SIZE(2, WASM_CALL_IMPORT0(0));
-  EXPECT_SIZE(2, WASM_CALL_IMPORT0(1));
-  EXPECT_SIZE(2, WASM_CALL_IMPORT0(11));
+  EXPECT_SIZE(3, WASM_CALL_IMPORT0(0));
+  EXPECT_SIZE(3, WASM_CALL_IMPORT0(1));
+  EXPECT_SIZE(3, WASM_CALL_IMPORT0(11));
 
-  EXPECT_SIZE(4, WASM_CALL_IMPORT(0, WASM_ZERO));
-  EXPECT_SIZE(6, WASM_CALL_IMPORT(1, WASM_ZERO, WASM_ZERO));
+  EXPECT_SIZE(5, WASM_CALL_IMPORT1(0, WASM_ZERO));
+  EXPECT_SIZE(7, WASM_CALL_IMPORT2(1, WASM_ZERO, WASM_ZERO));
 }
 
 TEST_F(WasmMacroGenTest, CallIndirect) {
-  EXPECT_SIZE(4, WASM_CALL_INDIRECT0(0, WASM_ZERO));
-  EXPECT_SIZE(4, WASM_CALL_INDIRECT0(1, WASM_ZERO));
-  EXPECT_SIZE(4, WASM_CALL_INDIRECT0(11, WASM_ZERO));
+  EXPECT_SIZE(5, WASM_CALL_INDIRECT0(0, WASM_ZERO));
+  EXPECT_SIZE(5, WASM_CALL_INDIRECT0(1, WASM_ZERO));
+  EXPECT_SIZE(5, WASM_CALL_INDIRECT0(11, WASM_ZERO));
 
-  EXPECT_SIZE(6, WASM_CALL_INDIRECT(0, WASM_ZERO, WASM_ZERO));
-  EXPECT_SIZE(8, WASM_CALL_INDIRECT(1, WASM_ZERO, WASM_ZERO, WASM_ZERO));
+  EXPECT_SIZE(7, WASM_CALL_INDIRECT1(0, WASM_ZERO, WASM_ZERO));
+  EXPECT_SIZE(9, WASM_CALL_INDIRECT2(1, WASM_ZERO, WASM_ZERO, WASM_ZERO));
 }
 
-
 TEST_F(WasmMacroGenTest, Int32Ops) {
   EXPECT_SIZE(5, WASM_I32_ADD(WASM_ZERO, WASM_ZERO));
   EXPECT_SIZE(5, WASM_I32_SUB(WASM_ZERO, WASM_ZERO));
@@ -189,7 +184,6 @@
   EXPECT_SIZE(3, WASM_I32_EQZ(WASM_ZERO));
 }
 
-
 TEST_F(WasmMacroGenTest, Int64Ops) {
   EXPECT_SIZE(5, WASM_I64_ADD(WASM_ZERO, WASM_ZERO));
   EXPECT_SIZE(5, WASM_I64_SUB(WASM_ZERO, WASM_ZERO));
@@ -225,7 +219,6 @@
   EXPECT_SIZE(3, WASM_I64_EQZ(WASM_ZERO));
 }
 
-
 TEST_F(WasmMacroGenTest, Float32Ops) {
   EXPECT_SIZE(5, WASM_F32_ADD(WASM_ZERO, WASM_ZERO));
   EXPECT_SIZE(5, WASM_F32_SUB(WASM_ZERO, WASM_ZERO));
@@ -250,7 +243,6 @@
   EXPECT_SIZE(5, WASM_F32_GE(WASM_ZERO, WASM_ZERO));
 }
 
-
 TEST_F(WasmMacroGenTest, Float64Ops) {
   EXPECT_SIZE(5, WASM_F64_ADD(WASM_ZERO, WASM_ZERO));
   EXPECT_SIZE(5, WASM_F64_SUB(WASM_ZERO, WASM_ZERO));
@@ -275,7 +267,6 @@
   EXPECT_SIZE(5, WASM_F64_GE(WASM_ZERO, WASM_ZERO));
 }
 
-
 TEST_F(WasmMacroGenTest, Conversions) {
   EXPECT_SIZE(3, WASM_I32_SCONVERT_F32(WASM_ZERO));
   EXPECT_SIZE(3, WASM_I32_SCONVERT_F64(WASM_ZERO));
@@ -317,7 +308,6 @@
   }
 }
 
-
 TEST_F(WasmMacroGenTest, LoadsAndStoresWithOffset) {
   for (size_t i = 0; i < arraysize(kMemTypes); i++) {
     EXPECT_SIZE(5, WASM_LOAD_MEM_OFFSET(kMemTypes[i], 11, WASM_ZERO));