[wasm] Binary 0xD: update encoding of opcodes, types, and add immediates.

test/unittests/wasm/ast-decoder-unittest.cc

 // Copyright 2015 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "test/unittests/test-utils.h"
 
 #include "src/v8.h"
 
 #include "test/common/wasm/test-signatures.h"
 
@@ skipping 1131 matching lines @@
       TestBinop(kExpr##name, sig);                          \
     }                                                       \
   }
 
   FOREACH_SIMPLE_OPCODE(DECODE_TEST);
 
 #undef DECODE_TEST
 }
 
 TEST_F(AstDecoderTest, MemorySize) {
-  byte code[] = {kExprMemorySize};
+  byte code[] = {kExprMemorySize, 0};
   EXPECT_VERIFIES_C(i_i, code);
   EXPECT_FAILURE_C(f_ff, code);
 }
 
 TEST_F(AstDecoderTest, LoadMemOffset) {
   for (int offset = 0; offset < 128; offset += 7) {
     byte code[] = {kExprI8Const, 0, kExprI32LoadMem, ZERO_ALIGNMENT,
                    static_cast<byte>(offset)};
     EXPECT_VERIFIES_C(i_i, code);
   }
@@ skipping 462 matching lines @@
       }
     }
   }
 }
 
 TEST_F(AstDecoderTest, WasmGrowMemory) {
   TestModuleEnv module_env;
   module = &module_env;
   module->origin = kWasmOrigin;
 
-  byte code[] = {WASM_UNOP(kExprGrowMemory, WASM_GET_LOCAL(0))};
+  byte code[] = {WASM_GET_LOCAL(0), kExprGrowMemory, 0};
   EXPECT_VERIFIES_C(i_i, code);
   EXPECT_FAILURE_C(i_d, code);
 }
 
 TEST_F(AstDecoderTest, AsmJsGrowMemory) {
   TestModuleEnv module_env;
   module = &module_env;
   module->origin = kAsmJsOrigin;
 
-  byte code[] = {WASM_UNOP(kExprGrowMemory, WASM_GET_LOCAL(0))};
+  byte code[] = {WASM_GET_LOCAL(0), kExprGrowMemory, 0};
   EXPECT_FAILURE_C(i_i, code);
 }
 
 TEST_F(AstDecoderTest, AsmJsBinOpsCheckOrigin) {
   LocalType float32int32float32[] = {kAstF32, kAstI32, kAstF32};
   FunctionSig sig_f_if(1, 2, float32int32float32);
   LocalType float64int32float64[] = {kAstF64, kAstI32, kAstF64};
   FunctionSig sig_d_id(1, 2, float64int32float64);
   struct {
     WasmOpcode op;
@@ skipping 653 matching lines @@
 
 TEST_F(WasmOpcodeLengthTest, MiscExpressions) {
   EXPECT_LENGTH(2, kExprI8Const);
   EXPECT_LENGTH(5, kExprF32Const);
   EXPECT_LENGTH(9, kExprF64Const);
   EXPECT_LENGTH(2, kExprGetLocal);
   EXPECT_LENGTH(2, kExprSetLocal);
   EXPECT_LENGTH(2, kExprGetGlobal);
   EXPECT_LENGTH(2, kExprSetGlobal);
   EXPECT_LENGTH(2, kExprCallFunction);
-  EXPECT_LENGTH(2, kExprCallIndirect);
+  EXPECT_LENGTH(3, kExprCallIndirect);
 }
 
 TEST_F(WasmOpcodeLengthTest, I32Const) {
   EXPECT_LENGTH_N(2, kExprI32Const, U32V_1(1));
   EXPECT_LENGTH_N(3, kExprI32Const, U32V_2(999));
   EXPECT_LENGTH_N(4, kExprI32Const, U32V_3(9999));
   EXPECT_LENGTH_N(5, kExprI32Const, U32V_4(999999));
   EXPECT_LENGTH_N(6, kExprI32Const, U32V_5(99999999));
 }
 
@@ skipping 38 matching lines @@
   EXPECT_LENGTH(3, kExprI32StoreMem);
   EXPECT_LENGTH(3, kExprI64StoreMem8);
   EXPECT_LENGTH(3, kExprI64StoreMem16);
   EXPECT_LENGTH(3, kExprI64StoreMem32);
   EXPECT_LENGTH(3, kExprI64StoreMem);
   EXPECT_LENGTH(3, kExprF32StoreMem);
   EXPECT_LENGTH(3, kExprF64StoreMem);
 }
 
 TEST_F(WasmOpcodeLengthTest, MiscMemExpressions) {
-  EXPECT_LENGTH(1, kExprMemorySize);
-  EXPECT_LENGTH(1, kExprGrowMemory);
+  EXPECT_LENGTH(2, kExprMemorySize);
+  EXPECT_LENGTH(2, kExprGrowMemory);
 }
 
 TEST_F(WasmOpcodeLengthTest, SimpleExpressions) {
   EXPECT_LENGTH(1, kExprI32Add);
   EXPECT_LENGTH(1, kExprI32Sub);
   EXPECT_LENGTH(1, kExprI32Mul);
   EXPECT_LENGTH(1, kExprI32DivS);
   EXPECT_LENGTH(1, kExprI32DivU);
   EXPECT_LENGTH(1, kExprI32RemS);
   EXPECT_LENGTH(1, kExprI32RemU);
@@ skipping 279 matching lines @@
   iter.next();
   EXPECT_TRUE(iter.has_next());
   EXPECT_EQ(kExprI8Const, iter.current());
   iter.next();
   EXPECT_FALSE(iter.has_next());
 }
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8