[wasm] Remove non-standard kExprI8Const bytecode

test/cctest/wasm/test-run-wasm.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 <stdint.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include "src/base/platform/elapsed-timer.h"
 #include "src/utils.h"
 #include "src/wasm/wasm-macro-gen.h"
 
 #include "test/cctest/cctest.h"
 #include "test/cctest/compiler/value-helper.h"
 #include "test/cctest/wasm/wasm-run-utils.h"
 #include "test/common/wasm/test-signatures.h"
 
 using namespace v8::base;
 using namespace v8::internal;
 using namespace v8::internal::compiler;
 using namespace v8::internal::wasm;
 
 // for even shorter tests.
 #define B1(a) WASM_BLOCK(a)
 #define B2(a, b) WASM_BLOCK(a, b)
 #define B3(a, b, c) WASM_BLOCK(a, b, c)
 #define RET(x) x, kExprReturn
-#define RET_I8(x) kExprI8Const, x, kExprReturn
-
-WASM_EXEC_TEST(Int8Const) {
-  WasmRunner<int32_t> r(execution_mode);
-  const byte kExpectedValue = 121;
-  // return(kExpectedValue)
-  BUILD(r, WASM_I8(kExpectedValue));
-  CHECK_EQ(kExpectedValue, r.Call());
-}
-
-WASM_EXEC_TEST(Int8Const_end) {
-  WasmRunner<int32_t> r(execution_mode);
-  const byte kExpectedValue = 121;
-  // return(kExpectedValue)
-  BUILD(r, WASM_I8(kExpectedValue), kExprEnd);
-  CHECK_EQ(kExpectedValue, r.Call());
-}
-
-WASM_EXEC_TEST(Int8Const_fallthru2) {
-  WasmRunner<int32_t> r(execution_mode);
-  const byte kExpectedValue = 123;
-  // -99 kExpectedValue
-  BUILD(r, WASM_I8(-99), WASM_DROP, WASM_I8(kExpectedValue));
-  CHECK_EQ(kExpectedValue, r.Call());
-}
-
-WASM_EXEC_TEST(Int8Const_all) {
-  for (int value = -128; value <= 127; ++value) {
-    WasmRunner<int32_t> r(execution_mode);
-    // return(value)
-    BUILD(r, WASM_I8(value));
-    int32_t result = r.Call();
-    CHECK_EQ(value, result);
-  }
-}
+#define RET_I8(x) WASM_I32V_2(x), kExprReturn
 
 WASM_EXEC_TEST(Int32Const) {
   WasmRunner<int32_t> r(execution_mode);
   const int32_t kExpectedValue = 0x11223344;
   // return(kExpectedValue)
   BUILD(r, WASM_I32V_5(kExpectedValue));
   CHECK_EQ(kExpectedValue, r.Call());
 }
 
 WASM_EXEC_TEST(Int32Const_many) {
@@ skipping 31 matching lines @@
 WASM_EXEC_TEST(Int32Param1) {
   WasmRunner<int32_t, int32_t, int32_t> r(execution_mode);
   // local[1]
   BUILD(r, WASM_GET_LOCAL(1));
   FOR_INT32_INPUTS(i) { CHECK_EQ(*i, r.Call(-111, *i)); }
 }
 
 WASM_EXEC_TEST(Int32Add) {
   WasmRunner<int32_t> r(execution_mode);
   // 11 + 44
-  BUILD(r, WASM_I32_ADD(WASM_I8(11), WASM_I8(44)));
+  BUILD(r, WASM_I32_ADD(WASM_I32V_1(11), WASM_I32V_1(44)));
   CHECK_EQ(55, r.Call());
 }
 
 WASM_EXEC_TEST(Int32Add_P) {
   WasmRunner<int32_t, int32_t> r(execution_mode);
   // p0 + 13
-  BUILD(r, WASM_I32_ADD(WASM_I8(13), WASM_GET_LOCAL(0)));
+  BUILD(r, WASM_I32_ADD(WASM_I32V_1(13), WASM_GET_LOCAL(0)));
   FOR_INT32_INPUTS(i) { CHECK_EQ(*i + 13, r.Call(*i)); }
 }
 
 WASM_EXEC_TEST(Int32Add_P_fallthru) {
   WasmRunner<int32_t, int32_t> r(execution_mode);
   // p0 + 13
-  BUILD(r, WASM_I32_ADD(WASM_I8(13), WASM_GET_LOCAL(0)));
+  BUILD(r, WASM_I32_ADD(WASM_I32V_1(13), WASM_GET_LOCAL(0)));
   FOR_INT32_INPUTS(i) { CHECK_EQ(*i + 13, r.Call(*i)); }
 }
 
 static void RunInt32AddTest(WasmExecutionMode execution_mode, const byte* code,
                             size_t size) {
   WasmRunner<int32_t, int32_t, int32_t> r(execution_mode);
   r.Build(code, code + size);
   FOR_INT32_INPUTS(i) {
     FOR_INT32_INPUTS(j) {
       int32_t expected = static_cast<int32_t>(static_cast<uint32_t>(*i) +
@@ skipping 281 matching lines @@
   const int32_t kMin = std::numeric_limits<int32_t>::min();
   CHECK_TRAP(r.Call(100, 0));
   CHECK_TRAP(r.Call(-1001, 0));
   CHECK_TRAP(r.Call(kMin, 0));
   CHECK_EQ(kMin, r.Call(kMin, -1));
 }
 
 WASM_EXEC_TEST_WITH_TRAP(Int32DivS_byzero_const) {
   for (int8_t denom = -2; denom < 8; ++denom) {
     WasmRunner<int32_t, int32_t> r(execution_mode);
-    BUILD(r, WASM_I32_DIVS(WASM_GET_LOCAL(0), WASM_I8(denom)));
+    BUILD(r, WASM_I32_DIVS(WASM_GET_LOCAL(0), WASM_I32V_1(denom)));
     for (int32_t val = -7; val < 8; ++val) {
       if (denom == 0) {
         CHECK_TRAP(r.Call(val));
       } else {
         CHECK_EQ(val / denom, r.Call(val));
       }
     }
   }
 }
 
 WASM_EXEC_TEST(Int32AsmjsDivS_byzero_const) {
   for (int8_t denom = -2; denom < 8; ++denom) {
     WasmRunner<int32_t, int32_t> r(execution_mode);
     r.module().ChangeOriginToAsmjs();
-    BUILD(r, WASM_I32_ASMJS_DIVS(WASM_GET_LOCAL(0), WASM_I8(denom)));
+    BUILD(r, WASM_I32_ASMJS_DIVS(WASM_GET_LOCAL(0), WASM_I32V_1(denom)));
     FOR_INT32_INPUTS(i) {
       if (denom == 0) {
         CHECK_EQ(0, r.Call(*i));
       } else if (denom == -1 && *i == std::numeric_limits<int32_t>::min()) {
         CHECK_EQ(std::numeric_limits<int32_t>::min(), r.Call(*i));
       } else {
         CHECK_EQ(*i / denom, r.Call(*i));
       }
     }
   }
 }
 
 WASM_EXEC_TEST(Int32AsmjsRemS_byzero_const) {
   for (int8_t denom = -2; denom < 8; ++denom) {
     WasmRunner<int32_t, int32_t> r(execution_mode);
     r.module().ChangeOriginToAsmjs();
-    BUILD(r, WASM_I32_ASMJS_REMS(WASM_GET_LOCAL(0), WASM_I8(denom)));
+    BUILD(r, WASM_I32_ASMJS_REMS(WASM_GET_LOCAL(0), WASM_I32V_1(denom)));
     FOR_INT32_INPUTS(i) {
       if (denom == 0) {
         CHECK_EQ(0, r.Call(*i));
       } else if (denom == -1 && *i == std::numeric_limits<int32_t>::min()) {
         CHECK_EQ(0, r.Call(*i));
       } else {
         CHECK_EQ(*i % denom, r.Call(*i));
       }
     }
   }
@@ skipping 197 matching lines @@
   FOR_FLOAT64_INPUTS(i) {
     CHECK_EQ(0x8000000000000000,
              bit_cast<uint64_t>(*i) ^ bit_cast<uint64_t>(r.Call(*i)));
   }
 }
 
 WASM_EXEC_TEST(IfElse_P) {
   WasmRunner<int32_t, int32_t> r(execution_mode);
   // if (p0) return 11; else return 22;
   BUILD(r, WASM_IF_ELSE_I(WASM_GET_LOCAL(0),  // --
-                          WASM_I8(11),        // --
-                          WASM_I8(22)));      // --
+                          WASM_I32V_1(11),    // --
+                          WASM_I32V_1(22)));  // --
   FOR_INT32_INPUTS(i) {
     int32_t expected = *i ? 11 : 22;
     CHECK_EQ(expected, r.Call(*i));
   }
 }
 #define EMPTY
 
 WASM_EXEC_TEST(If_empty1) {
   WasmRunner<uint32_t, uint32_t, uint32_t> r(execution_mode);
   BUILD(r, WASM_GET_LOCAL(0), kExprIf, kLocalVoid, kExprEnd, WASM_GET_LOCAL(1));
@@ skipping 18 matching lines @@
   WasmRunner<uint32_t, uint32_t, uint32_t> r(execution_mode);
   BUILD(r, WASM_GET_LOCAL(0), kExprIf, kLocalVoid, kExprElse, WASM_NOP,
         kExprEnd, WASM_GET_LOCAL(1));
   FOR_UINT32_INPUTS(i) { CHECK_EQ(*i, r.Call(*i - 6, *i)); }
 }
 
 WASM_EXEC_TEST(If_chain1) {
   WasmRunner<int32_t, int32_t> r(execution_mode);
   // if (p0) 13; if (p0) 14; 15
   BUILD(r, WASM_IF(WASM_GET_LOCAL(0), WASM_NOP),
-        WASM_IF(WASM_GET_LOCAL(0), WASM_NOP), WASM_I8(15));
+        WASM_IF(WASM_GET_LOCAL(0), WASM_NOP), WASM_I32V_1(15));
   FOR_INT32_INPUTS(i) { CHECK_EQ(15, r.Call(*i)); }
 }
 
 WASM_EXEC_TEST(If_chain_set) {
   WasmRunner<int32_t, int32_t, int32_t> r(execution_mode);
   // if (p0) p1 = 73; if (p0) p1 = 74; p1
-  BUILD(r, WASM_IF(WASM_GET_LOCAL(0), WASM_SET_LOCAL(1, WASM_I8(73))),
-        WASM_IF(WASM_GET_LOCAL(0), WASM_SET_LOCAL(1, WASM_I8(74))),
+  BUILD(r, WASM_IF(WASM_GET_LOCAL(0), WASM_SET_LOCAL(1, WASM_I32V_2(73))),
+        WASM_IF(WASM_GET_LOCAL(0), WASM_SET_LOCAL(1, WASM_I32V_2(74))),
         WASM_GET_LOCAL(1));
   FOR_INT32_INPUTS(i) {
     int32_t expected = *i ? 74 : *i;
     CHECK_EQ(expected, r.Call(*i, *i));
   }
 }
 
 WASM_EXEC_TEST(IfElse_Unreachable1) {
   WasmRunner<int32_t> r(execution_mode);
   // 0 ? unreachable : 27
-  BUILD(r, WASM_IF_ELSE_I(WASM_ZERO,         // --
-                          WASM_UNREACHABLE,  // --
-                          WASM_I8(27)));     // --
+  BUILD(r, WASM_IF_ELSE_I(WASM_ZERO,          // --
+                          WASM_UNREACHABLE,   // --
+                          WASM_I32V_1(27)));  // --
   CHECK_EQ(27, r.Call());
 }
 
 WASM_EXEC_TEST(IfElse_Unreachable2) {
   WasmRunner<int32_t> r(execution_mode);
   // 1 ? 28 : unreachable
-  BUILD(r, WASM_IF_ELSE_I(WASM_I8(1),          // --
-                          WASM_I8(28),         // --
+  BUILD(r, WASM_IF_ELSE_I(WASM_I32V_1(1),      // --
+                          WASM_I32V_1(28),     // --
                           WASM_UNREACHABLE));  // --
   CHECK_EQ(28, r.Call());
 }
 
 WASM_EXEC_TEST(Return12) {
   WasmRunner<int32_t> r(execution_mode);
 
   BUILD(r, RET_I8(12));
   CHECK_EQ(12, r.Call());
 }
@@ skipping 49 matching lines @@
   WasmRunner<float, float, float, int32_t> r(execution_mode);
   // return select(11, 22, a);
   BUILD(r,
         WASM_SELECT(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1), WASM_GET_LOCAL(2)));
   CHECK_FLOAT_EQ(2.0f, r.Call(2.0f, 1.0f, 1));
 }
 
 WASM_EXEC_TEST(Select) {
   WasmRunner<int32_t, int32_t> r(execution_mode);
   // return select(11, 22, a);
-  BUILD(r, WASM_SELECT(WASM_I8(11), WASM_I8(22), WASM_GET_LOCAL(0)));
+  BUILD(r, WASM_SELECT(WASM_I32V_1(11), WASM_I32V_1(22), WASM_GET_LOCAL(0)));
   FOR_INT32_INPUTS(i) {
     int32_t expected = *i ? 11 : 22;
     CHECK_EQ(expected, r.Call(*i));
   }
 }
 
 WASM_EXEC_TEST(Select_strict1) {
   WasmRunner<int32_t, int32_t> r(execution_mode);
   // select(a=0, a=1, a=2); return a
-  BUILD(r, WASM_SELECT(WASM_TEE_LOCAL(0, WASM_I8(0)),
-                       WASM_TEE_LOCAL(0, WASM_I8(1)),
-                       WASM_TEE_LOCAL(0, WASM_I8(2))),
+  BUILD(r, WASM_SELECT(WASM_TEE_LOCAL(0, WASM_ZERO),
+                       WASM_TEE_LOCAL(0, WASM_I32V_1(1)),
+                       WASM_TEE_LOCAL(0, WASM_I32V_1(2))),
         WASM_DROP, WASM_GET_LOCAL(0));
   FOR_INT32_INPUTS(i) { CHECK_EQ(2, r.Call(*i)); }
 }
 
 WASM_EXEC_TEST(Select_strict2) {
   WasmRunner<int32_t, int32_t> r(execution_mode);
   r.AllocateLocal(kWasmI32);
   r.AllocateLocal(kWasmI32);
   // select(b=5, c=6, a)
-  BUILD(r, WASM_SELECT(WASM_TEE_LOCAL(1, WASM_I8(5)),
-                       WASM_TEE_LOCAL(2, WASM_I8(6)), WASM_GET_LOCAL(0)));
+  BUILD(r, WASM_SELECT(WASM_TEE_LOCAL(1, WASM_I32V_1(5)),
+                       WASM_TEE_LOCAL(2, WASM_I32V_1(6)), WASM_GET_LOCAL(0)));
   FOR_INT32_INPUTS(i) {
     int32_t expected = *i ? 5 : 6;
     CHECK_EQ(expected, r.Call(*i));
   }
 }
 
 WASM_EXEC_TEST(Select_strict3) {
   WasmRunner<int32_t, int32_t> r(execution_mode);
   r.AllocateLocal(kWasmI32);
   r.AllocateLocal(kWasmI32);
   // select(b=5, c=6, a=b)
-  BUILD(r, WASM_SELECT(WASM_TEE_LOCAL(1, WASM_I8(5)),
-                       WASM_TEE_LOCAL(2, WASM_I8(6)),
+  BUILD(r, WASM_SELECT(WASM_TEE_LOCAL(1, WASM_I32V_1(5)),
+                       WASM_TEE_LOCAL(2, WASM_I32V_1(6)),
                        WASM_TEE_LOCAL(0, WASM_GET_LOCAL(1))));
   FOR_INT32_INPUTS(i) {
     int32_t expected = 5;
     CHECK_EQ(expected, r.Call(*i));
   }
 }
 
 WASM_EXEC_TEST(BrIf_strict) {
   WasmRunner<int32_t, int32_t> r(execution_mode);
   BUILD(r, WASM_BLOCK_I(WASM_BRV_IF(0, WASM_GET_LOCAL(0),
-                                    WASM_TEE_LOCAL(0, WASM_I8(99)))));
+                                    WASM_TEE_LOCAL(0, WASM_I32V_2(99)))));
 
   FOR_INT32_INPUTS(i) { CHECK_EQ(*i, r.Call(*i)); }
 }
 
 WASM_EXEC_TEST(Br_height) {
   WasmRunner<int32_t, int32_t> r(execution_mode);
-  BUILD(r,
-        WASM_BLOCK_I(
-            WASM_BLOCK_I(WASM_BRV_IFD(0, WASM_GET_LOCAL(0), WASM_GET_LOCAL(0)),
-                         WASM_RETURN1(WASM_I8(9)), WASM_I8(7), WASM_I8(7)),
-            WASM_BRV(0, WASM_I8(8))));
+  BUILD(r, WASM_BLOCK_I(WASM_BLOCK_I(WASM_BRV_IFD(0, WASM_GET_LOCAL(0),
+                                                  WASM_GET_LOCAL(0)),
+                                     WASM_RETURN1(WASM_I32V_1(9)),
+                                     WASM_I32V_1(7), WASM_I32V_1(7)),
+                        WASM_BRV(0, WASM_I32V_1(8))));
 
   for (int32_t i = 0; i < 5; i++) {
     int32_t expected = i != 0 ? 8 : 9;
     CHECK_EQ(expected, r.Call(i));
   }
 }
 
 WASM_EXEC_TEST(Regression_660262) {
   WasmRunner<int32_t> r(execution_mode);
   r.module().AddMemoryElems<int32_t>(8);
-  BUILD(r, kExprI8Const, 0x00, kExprI8Const, 0x00, kExprI32LoadMem, 0x00, 0x0f,
-        kExprBrTable, 0x00, 0x80, 0x00);  // entries=0
+  BUILD(r, kExprI32Const, 0x00, kExprI32Const, 0x00, kExprI32LoadMem, 0x00,
+        0x0f, kExprBrTable, 0x00, 0x80, 0x00);  // entries=0
   r.Call();
 }
 
 WASM_EXEC_TEST(BrTable0a) {
   WasmRunner<int32_t, int32_t> r(execution_mode);
   BUILD(r, B1(B1(WASM_BR_TABLE(WASM_GET_LOCAL(0), 0, BR_TARGET(0)))),
-        WASM_I8(91));
+        WASM_I32V_2(91));
   FOR_INT32_INPUTS(i) { CHECK_EQ(91, r.Call(*i)); }
 }
 
 WASM_EXEC_TEST(BrTable0b) {
   WasmRunner<int32_t, int32_t> r(execution_mode);
   BUILD(r,
         B1(B1(WASM_BR_TABLE(WASM_GET_LOCAL(0), 1, BR_TARGET(0), BR_TARGET(0)))),
-        WASM_I8(92));
+        WASM_I32V_2(92));
   FOR_INT32_INPUTS(i) { CHECK_EQ(92, r.Call(*i)); }
 }
 
 WASM_EXEC_TEST(BrTable0c) {
   WasmRunner<int32_t, int32_t> r(execution_mode);
   BUILD(
       r,
       B1(B2(B1(WASM_BR_TABLE(WASM_GET_LOCAL(0), 1, BR_TARGET(0), BR_TARGET(1))),
             RET_I8(76))),
-      WASM_I8(77));
+      WASM_I32V_2(77));
   FOR_INT32_INPUTS(i) {
     int32_t expected = *i == 0 ? 76 : 77;
     CHECK_EQ(expected, r.Call(*i));
   }
 }
 
 WASM_EXEC_TEST(BrTable1) {
   WasmRunner<int32_t, int32_t> r(execution_mode);
   BUILD(r, B1(WASM_BR_TABLE(WASM_GET_LOCAL(0), 0, BR_TARGET(0))), RET_I8(93));
   FOR_INT32_INPUTS(i) { CHECK_EQ(93, r.Call(*i)); }
 }
 
 WASM_EXEC_TEST(BrTable_loop) {
   WasmRunner<int32_t, int32_t> r(execution_mode);
   BUILD(r,
         B2(B1(WASM_LOOP(WASM_BR_TABLE(WASM_INC_LOCAL_BYV(0, 1), 2, BR_TARGET(2),
                                       BR_TARGET(1), BR_TARGET(0)))),
            RET_I8(99)),
-        WASM_I8(98));
+        WASM_I32V_2(98));
   CHECK_EQ(99, r.Call(0));
   CHECK_EQ(98, r.Call(-1));
   CHECK_EQ(98, r.Call(-2));
   CHECK_EQ(98, r.Call(-3));
   CHECK_EQ(98, r.Call(-100));
 }
 
 WASM_EXEC_TEST(BrTable_br) {
   WasmRunner<int32_t, int32_t> r(execution_mode);
   BUILD(r,
         B2(B1(WASM_BR_TABLE(WASM_GET_LOCAL(0), 1, BR_TARGET(1), BR_TARGET(0))),
            RET_I8(91)),
-        WASM_I8(99));
+        WASM_I32V_2(99));
   CHECK_EQ(99, r.Call(0));
   CHECK_EQ(91, r.Call(1));
   CHECK_EQ(91, r.Call(2));
   CHECK_EQ(91, r.Call(3));
 }
 
 WASM_EXEC_TEST(BrTable_br2) {
   WasmRunner<int32_t, int32_t> r(execution_mode);
 
   BUILD(r, B2(B2(B2(B1(WASM_BR_TABLE(WASM_GET_LOCAL(0), 3, BR_TARGET(1),
                                      BR_TARGET(2), BR_TARGET(3), BR_TARGET(0))),
                     RET_I8(85)),
                  RET_I8(86)),
               RET_I8(87)),
-        WASM_I8(88));
+        WASM_I32V_2(88));
   CHECK_EQ(86, r.Call(0));
   CHECK_EQ(87, r.Call(1));
   CHECK_EQ(88, r.Call(2));
   CHECK_EQ(85, r.Call(3));
   CHECK_EQ(85, r.Call(4));
   CHECK_EQ(85, r.Call(5));
 }
 
 WASM_EXEC_TEST(BrTable4) {
   for (int i = 0; i < 4; ++i) {
     for (int t = 0; t < 4; ++t) {
       uint32_t cases[] = {0, 1, 2, 3};
       cases[i] = t;
       byte code[] = {B2(B2(B2(B2(B1(WASM_BR_TABLE(
                                      WASM_GET_LOCAL(0), 3, BR_TARGET(cases[0]),
                                      BR_TARGET(cases[1]), BR_TARGET(cases[2]),
                                      BR_TARGET(cases[3]))),
                                  RET_I8(70)),
                               RET_I8(71)),
                            RET_I8(72)),
                         RET_I8(73)),
-                     WASM_I8(75)};
+                     WASM_I32V_2(75)};
 
       WasmRunner<int32_t, int32_t> r(execution_mode);
       r.Build(code, code + arraysize(code));
 
       for (int x = -3; x < 50; ++x) {
         int index = (x > 3 || x < 0) ? 3 : x;
         int32_t expected = 70 + cases[index];
         CHECK_EQ(expected, r.Call(x));
       }
     }
   }
 }
 
 WASM_EXEC_TEST(BrTable4x4) {
   for (byte a = 0; a < 4; ++a) {
     for (byte b = 0; b < 4; ++b) {
       for (byte c = 0; c < 4; ++c) {
         for (byte d = 0; d < 4; ++d) {
           for (int i = 0; i < 4; ++i) {
             uint32_t cases[] = {a, b, c, d};
             byte code[] = {
                 B2(B2(B2(B2(B1(WASM_BR_TABLE(
                                 WASM_GET_LOCAL(0), 3, BR_TARGET(cases[0]),
                                 BR_TARGET(cases[1]), BR_TARGET(cases[2]),
                                 BR_TARGET(cases[3]))),
                             RET_I8(50)),
                          RET_I8(51)),
                       RET_I8(52)),
                    RET_I8(53)),
-                WASM_I8(55)};
+                WASM_I32V_2(55)};
 
             WasmRunner<int32_t, int32_t> r(execution_mode);
             r.Build(code, code + arraysize(code));
 
             for (int x = -6; x < 47; ++x) {
               int index = (x > 3 || x < 0) ? 3 : x;
               int32_t expected = 50 + cases[index];
               CHECK_EQ(expected, r.Call(x));
             }
           }
@@ skipping 42 matching lines @@
     CHECK_EQ(expected, r.Call());
   }
 }
 
 WASM_EXEC_TEST(I32ReinterpretF32) {
   WasmRunner<int32_t, int32_t> r(execution_mode);
   int32_t* memory = r.module().AddMemoryElems<int32_t>(8);
 
   BUILD(r, WASM_STORE_MEM(MachineType::Float32(), WASM_ZERO,
                           WASM_F32_REINTERPRET_I32(WASM_GET_LOCAL(0))),
-        WASM_I8(107));
+        WASM_I32V_2(107));
 
   FOR_INT32_INPUTS(i) {
     int32_t expected = *i;
     CHECK_EQ(107, r.Call(expected));
     CHECK_EQ(expected, r.module().ReadMemory(&memory[0]));
   }
 }
 
 WASM_EXEC_TEST_WITH_TRAP(LoadMaxUint32Offset) {
   WasmRunner<int32_t> r(execution_mode);
   r.module().AddMemoryElems<int32_t>(8);
 
-  BUILD(r, kExprI8Const, 0,  // index
+  BUILD(r, kExprI32Const, 0,  // index
         static_cast<byte>(v8::internal::wasm::WasmOpcodes::LoadStoreOpcodeOf(
             MachineType::Int32(), false)),  // --
         0,                                  // alignment
         U32V_5(0xffffffff));                // offset
 
   CHECK_TRAP32(r.Call());
 }
 
 WASM_EXEC_TEST(LoadStoreLoad) {
   WasmRunner<int32_t> r(execution_mode);
@@ skipping 100 matching lines @@
 
 WASM_EXEC_TEST(Block_br2) {
   WasmRunner<int32_t, int32_t> r(execution_mode);
   BUILD(r, WASM_BLOCK_I(WASM_BRV(0, WASM_GET_LOCAL(0))));
   FOR_UINT32_INPUTS(i) { CHECK_EQ(*i, static_cast<uint32_t>(r.Call(*i))); }
 }
 
 WASM_EXEC_TEST(Block_If_P) {
   WasmRunner<int32_t, int32_t> r(execution_mode);
   // block { if (p0) break 51; 52; }
-  BUILD(r, WASM_BLOCK_I(                           // --
-               WASM_IF(WASM_GET_LOCAL(0),          // --
-                       WASM_BRV(1, WASM_I8(51))),  // --
-               WASM_I8(52)));                      // --
+  BUILD(r, WASM_BLOCK_I(                               // --
+               WASM_IF(WASM_GET_LOCAL(0),              // --
+                       WASM_BRV(1, WASM_I32V_1(51))),  // --
+               WASM_I32V_1(52)));                      // --
   FOR_INT32_INPUTS(i) {
     int32_t expected = *i ? 51 : 52;
     CHECK_EQ(expected, r.Call(*i));
   }
 }
 
 WASM_EXEC_TEST(Loop_empty) {
   WasmRunner<int32_t, int32_t> r(execution_mode);
   BUILD(r, kExprLoop, kLocalVoid, kExprEnd, WASM_GET_LOCAL(0));
   FOR_INT32_INPUTS(i) { CHECK_EQ(*i, r.Call(*i)); }
@@ skipping 42 matching lines @@
   FOR_UINT32_INPUTS(i) {
     FOR_UINT32_INPUTS(j) {
       CHECK_EQ(*i, r.Call(0, *i, *j));
       CHECK_EQ(*j, r.Call(1, *i, *j));
     }
   }
 }
 
 WASM_EXEC_TEST(Block_BrIf_P) {
   WasmRunner<int32_t, int32_t> r(execution_mode);
-  BUILD(r, WASM_BLOCK_I(WASM_BRV_IFD(0, WASM_I8(51), WASM_GET_LOCAL(0)),
-                        WASM_I8(52)));
+  BUILD(r, WASM_BLOCK_I(WASM_BRV_IFD(0, WASM_I32V_1(51), WASM_GET_LOCAL(0)),
+                        WASM_I32V_1(52)));
   FOR_INT32_INPUTS(i) {
     int32_t expected = *i ? 51 : 52;
     CHECK_EQ(expected, r.Call(*i));
   }
 }
 
 WASM_EXEC_TEST(Block_IfElse_P_assign) {
   WasmRunner<int32_t, int32_t> r(execution_mode);
   // { if (p0) p0 = 71; else p0 = 72; return p0; }
-  BUILD(r,                                             // --
-        WASM_IF_ELSE(WASM_GET_LOCAL(0),                // --
-                     WASM_SET_LOCAL(0, WASM_I8(71)),   // --
-                     WASM_SET_LOCAL(0, WASM_I8(72))),  // --
+  BUILD(r,                                                 // --
+        WASM_IF_ELSE(WASM_GET_LOCAL(0),                    // --
+                     WASM_SET_LOCAL(0, WASM_I32V_2(71)),   // --
+                     WASM_SET_LOCAL(0, WASM_I32V_2(72))),  // --
         WASM_GET_LOCAL(0));
   FOR_INT32_INPUTS(i) {
     int32_t expected = *i ? 71 : 72;
     CHECK_EQ(expected, r.Call(*i));
   }
 }
 
 WASM_EXEC_TEST(Block_IfElse_P_return) {
   WasmRunner<int32_t, int32_t> r(execution_mode);
   // if (p0) return 81; else return 82;
   BUILD(r,                               // --
         WASM_IF_ELSE(WASM_GET_LOCAL(0),  // --
                      RET_I8(81),         // --
                      RET_I8(82)));       // --
   FOR_INT32_INPUTS(i) {
     int32_t expected = *i ? 81 : 82;
     CHECK_EQ(expected, r.Call(*i));
   }
 }
 
 WASM_EXEC_TEST(Block_If_P_assign) {
   WasmRunner<int32_t, int32_t> r(execution_mode);
   // { if (p0) p0 = 61; p0; }
-  BUILD(r, WASM_IF(WASM_GET_LOCAL(0), WASM_SET_LOCAL(0, WASM_I8(61))),
+  BUILD(r, WASM_IF(WASM_GET_LOCAL(0), WASM_SET_LOCAL(0, WASM_I32V_1(61))),
         WASM_GET_LOCAL(0));
   FOR_INT32_INPUTS(i) {
     int32_t expected = *i ? 61 : *i;
     CHECK_EQ(expected, r.Call(*i));
   }
 }
 
 WASM_EXEC_TEST(DanglingAssign) {
   WasmRunner<int32_t, int32_t> r(execution_mode);
   // { return 0; p0 = 0; }
   BUILD(r, B2(RET_I8(99), WASM_SET_LOCAL(0, WASM_ZERO)));
   CHECK_EQ(99, r.Call(1));
 }
 
 WASM_EXEC_TEST(ExprIf_P) {
   WasmRunner<int32_t, int32_t> r(execution_mode);
   // p0 ? 11 : 22;
   BUILD(r, WASM_IF_ELSE_I(WASM_GET_LOCAL(0),  // --
-                          WASM_I8(11),        // --
-                          WASM_I8(22)));      // --
+                          WASM_I32V_1(11),    // --
+                          WASM_I32V_1(22)));  // --
   FOR_INT32_INPUTS(i) {
     int32_t expected = *i ? 11 : 22;
     CHECK_EQ(expected, r.Call(*i));
   }
 }
 
 WASM_EXEC_TEST(CountDown) {
   WasmRunner<int32_t, int32_t> r(execution_mode);
-  BUILD(r, WASM_LOOP(WASM_IFB(
-               WASM_GET_LOCAL(0),
-               WASM_SET_LOCAL(0, WASM_I32_SUB(WASM_GET_LOCAL(0), WASM_I8(1))),
-               WASM_BR(1))),
+  BUILD(r, WASM_LOOP(WASM_IFB(WASM_GET_LOCAL(0),
+                              WASM_SET_LOCAL(0, WASM_I32_SUB(WASM_GET_LOCAL(0),
+                                                             WASM_I32V_1(1))),
+                              WASM_BR(1))),
         WASM_GET_LOCAL(0));
   CHECK_EQ(0, r.Call(1));
   CHECK_EQ(0, r.Call(10));
   CHECK_EQ(0, r.Call(100));
 }
 
 WASM_EXEC_TEST(CountDown_fallthru) {
   WasmRunner<int32_t, int32_t> r(execution_mode);
-  BUILD(r, WASM_LOOP(
-               WASM_IF(WASM_NOT(WASM_GET_LOCAL(0)),
-                       WASM_BRV(2, WASM_GET_LOCAL(0))),
-               WASM_SET_LOCAL(0, WASM_I32_SUB(WASM_GET_LOCAL(0), WASM_I8(1))),
-               WASM_CONTINUE(0)),
-        WASM_GET_LOCAL(0));
+  BUILD(
+      r,
+      WASM_LOOP(
+          WASM_IF(WASM_NOT(WASM_GET_LOCAL(0)), WASM_BRV(2, WASM_GET_LOCAL(0))),
+          WASM_SET_LOCAL(0, WASM_I32_SUB(WASM_GET_LOCAL(0), WASM_I32V_1(1))),
+          WASM_CONTINUE(0)),
+      WASM_GET_LOCAL(0));
   CHECK_EQ(0, r.Call(1));
   CHECK_EQ(0, r.Call(10));
   CHECK_EQ(0, r.Call(100));
 }
 
 WASM_EXEC_TEST(WhileCountDown) {
   WasmRunner<int32_t, int32_t> r(execution_mode);
-  BUILD(r, WASM_WHILE(
-               WASM_GET_LOCAL(0),
-               WASM_SET_LOCAL(0, WASM_I32_SUB(WASM_GET_LOCAL(0), WASM_I8(1)))),
+  BUILD(r, WASM_WHILE(WASM_GET_LOCAL(0),
+                      WASM_SET_LOCAL(
+                          0, WASM_I32_SUB(WASM_GET_LOCAL(0), WASM_I32V_1(1)))),
         WASM_GET_LOCAL(0));
   CHECK_EQ(0, r.Call(1));
   CHECK_EQ(0, r.Call(10));
   CHECK_EQ(0, r.Call(100));
 }
 
 WASM_EXEC_TEST(Loop_if_break1) {
   WasmRunner<int32_t, int32_t, int32_t> r(execution_mode);
   BUILD(r, WASM_LOOP(WASM_IF(WASM_GET_LOCAL(0), WASM_BRV(2, WASM_GET_LOCAL(1))),
-                     WASM_SET_LOCAL(0, WASM_I8(99))),
+                     WASM_SET_LOCAL(0, WASM_I32V_2(99))),
         WASM_GET_LOCAL(0));
   CHECK_EQ(99, r.Call(0, 11));
   CHECK_EQ(65, r.Call(3, 65));
   CHECK_EQ(10001, r.Call(10000, 10001));
   CHECK_EQ(-29, r.Call(-28, -29));
 }
 
 WASM_EXEC_TEST(Loop_if_break2) {
   WasmRunner<int32_t, int32_t, int32_t> r(execution_mode);
   BUILD(r, WASM_LOOP(WASM_BRV_IF(1, WASM_GET_LOCAL(1), WASM_GET_LOCAL(0)),
-                     WASM_DROP, WASM_SET_LOCAL(0, WASM_I8(99))),
+                     WASM_DROP, WASM_SET_LOCAL(0, WASM_I32V_2(99))),
         WASM_GET_LOCAL(0));
   CHECK_EQ(99, r.Call(0, 33));
   CHECK_EQ(3, r.Call(1, 3));
   CHECK_EQ(10000, r.Call(99, 10000));
   CHECK_EQ(-29, r.Call(-11, -29));
 }
 
 WASM_EXEC_TEST(Loop_if_break_fallthru) {
   WasmRunner<int32_t, int32_t> r(execution_mode);
   BUILD(r, B1(WASM_LOOP(WASM_IF(WASM_GET_LOCAL(0), WASM_BR(2)),
-                        WASM_SET_LOCAL(0, WASM_I8(93)))),
+                        WASM_SET_LOCAL(0, WASM_I32V_2(93)))),
         WASM_GET_LOCAL(0));
   CHECK_EQ(93, r.Call(0));
   CHECK_EQ(3, r.Call(3));
   CHECK_EQ(10001, r.Call(10001));
   CHECK_EQ(-22, r.Call(-22));
 }
 
 WASM_EXEC_TEST(Loop_if_break_fallthru2) {
   WasmRunner<int32_t, int32_t> r(execution_mode);
   BUILD(r, B1(B1(WASM_LOOP(WASM_IF(WASM_GET_LOCAL(0), WASM_BR(2)),
-                           WASM_SET_LOCAL(0, WASM_I8(93))))),
+                           WASM_SET_LOCAL(0, WASM_I32V_2(93))))),
         WASM_GET_LOCAL(0));
   CHECK_EQ(93, r.Call(0));
   CHECK_EQ(3, r.Call(3));
   CHECK_EQ(10001, r.Call(10001));
   CHECK_EQ(-22, r.Call(-22));
 }
 
 WASM_EXEC_TEST(IfBreak1) {
   WasmRunner<int32_t, int32_t> r(execution_mode);
   BUILD(r, WASM_IF(WASM_GET_LOCAL(0), WASM_SEQ(WASM_BR(0), WASM_UNREACHABLE)),
-        WASM_I8(91));
+        WASM_I32V_2(91));
   CHECK_EQ(91, r.Call(0));
   CHECK_EQ(91, r.Call(1));
   CHECK_EQ(91, r.Call(-8734));
 }
 
 WASM_EXEC_TEST(IfBreak2) {
   WasmRunner<int32_t, int32_t> r(execution_mode);
   BUILD(r, WASM_IF(WASM_GET_LOCAL(0), WASM_SEQ(WASM_BR(0), RET_I8(77))),
-        WASM_I8(81));
+        WASM_I32V_2(81));
   CHECK_EQ(81, r.Call(0));
   CHECK_EQ(81, r.Call(1));
   CHECK_EQ(81, r.Call(-8734));
 }
 
 WASM_EXEC_TEST(LoadMemI32) {
   WasmRunner<int32_t, int32_t> r(execution_mode);
   int32_t* memory = r.module().AddMemoryElems<int32_t>(8);
   r.module().RandomizeMemory(1111);
 
-  BUILD(r, WASM_LOAD_MEM(MachineType::Int32(), WASM_I8(0)));
+  BUILD(r, WASM_LOAD_MEM(MachineType::Int32(), WASM_ZERO));
 
   r.module().WriteMemory(&memory[0], 99999999);
   CHECK_EQ(99999999, r.Call(0));
 
   r.module().WriteMemory(&memory[0], 88888888);
   CHECK_EQ(88888888, r.Call(0));
 
   r.module().WriteMemory(&memory[0], 77777777);
   CHECK_EQ(77777777, r.Call(0));
 }
 
 WASM_EXEC_TEST(LoadMemI32_alignment) {
   for (byte alignment = 0; alignment <= 2; ++alignment) {
     WasmRunner<int32_t, int32_t> r(execution_mode);
     int32_t* memory = r.module().AddMemoryElems<int32_t>(8);
     r.module().RandomizeMemory(1111);
 
     BUILD(r,
-          WASM_LOAD_MEM_ALIGNMENT(MachineType::Int32(), WASM_I8(0), alignment));
+          WASM_LOAD_MEM_ALIGNMENT(MachineType::Int32(), WASM_ZERO, alignment));
 
     r.module().WriteMemory(&memory[0], 0x1a2b3c4d);
     CHECK_EQ(0x1a2b3c4d, r.Call(0));
 
     r.module().WriteMemory(&memory[0], 0x5e6f7a8b);
     CHECK_EQ(0x5e6f7a8b, r.Call(0));
 
     r.module().WriteMemory(&memory[0], 0x7ca0b1c2);
     CHECK_EQ(0x7ca0b1c2, r.Call(0));
   }
@@ skipping 68 matching lines @@
 
 WASM_EXEC_TEST_WITH_TRAP(LoadMemI32_const_oob_misaligned) {
   const int kMemSize = 12;
   // TODO(titzer): Fix misaligned accesses on MIPS and re-enable.
   for (int offset = 0; offset < kMemSize + 5; ++offset) {
     for (int index = 0; index < kMemSize + 5; ++index) {
       WasmRunner<int32_t> r(execution_mode);
       r.module().AddMemoryElems<byte>(kMemSize);
       r.module().RandomizeMemory();
 
-      BUILD(r,
-            WASM_LOAD_MEM_OFFSET(MachineType::Int32(), offset, WASM_I8(index)));
+      BUILD(r, WASM_LOAD_MEM_OFFSET(MachineType::Int32(), offset,
+                                    WASM_I32V_2(index)));
 
       if ((offset + index) <= static_cast<int>((kMemSize - sizeof(int32_t)))) {
         CHECK_EQ(r.module().raw_val_at<int32_t>(offset + index), r.Call());
       } else {
         CHECK_TRAP(r.Call());
       }
     }
   }
 }
 
 WASM_EXEC_TEST_WITH_TRAP(LoadMemI32_const_oob) {
   const int kMemSize = 24;
   for (int offset = 0; offset < kMemSize + 5; offset += 4) {
     for (int index = 0; index < kMemSize + 5; index += 4) {
       WasmRunner<int32_t> r(execution_mode);
       r.module().AddMemoryElems<byte>(kMemSize);
       r.module().RandomizeMemory();
 
-      BUILD(r,
-            WASM_LOAD_MEM_OFFSET(MachineType::Int32(), offset, WASM_I8(index)));
+      BUILD(r, WASM_LOAD_MEM_OFFSET(MachineType::Int32(), offset,
+                                    WASM_I32V_2(index)));
 
       if ((offset + index) <= static_cast<int>((kMemSize - sizeof(int32_t)))) {
         CHECK_EQ(r.module().raw_val_at<int32_t>(offset + index), r.Call());
       } else {
         CHECK_TRAP(r.Call());
       }
     }
   }
 }
 
@@ skipping 77 matching lines @@
     CHECK_EQ(r.module().ReadMemory(&memory[i]), r.Call(i * 4));
   }
 }
 
 WASM_EXEC_TEST(MemI32_Sum) {
   const int kNumElems = 20;
   WasmRunner<uint32_t, int32_t> r(execution_mode);
   uint32_t* memory = r.module().AddMemoryElems<uint32_t>(kNumElems);
   const byte kSum = r.AllocateLocal(kWasmI32);
 
-  BUILD(
-      r,
-      WASM_WHILE(
-          WASM_GET_LOCAL(0),
-          WASM_BLOCK(
-              WASM_SET_LOCAL(kSum,
-                             WASM_I32_ADD(WASM_GET_LOCAL(kSum),
+  BUILD(r, WASM_WHILE(
+               WASM_GET_LOCAL(0),
+               WASM_BLOCK(
+                   WASM_SET_LOCAL(
+                       kSum, WASM_I32_ADD(WASM_GET_LOCAL(kSum),
                                           WASM_LOAD_MEM(MachineType::Int32(),
                                                         WASM_GET_LOCAL(0)))),
-              WASM_SET_LOCAL(0, WASM_I32_SUB(WASM_GET_LOCAL(0), WASM_I8(4))))),
-      WASM_GET_LOCAL(1));
+                   WASM_SET_LOCAL(
+                       0, WASM_I32_SUB(WASM_GET_LOCAL(0), WASM_I32V_1(4))))),
+        WASM_GET_LOCAL(1));
 
   // Run 4 trials.
   for (int i = 0; i < 3; ++i) {
     r.module().RandomizeMemory(i * 33);
     uint32_t expected = 0;
     for (size_t j = kNumElems - 1; j > 0; --j) {
       expected += r.module().ReadMemory(&memory[j]);
     }
     uint32_t result = r.Call(4 * (kNumElems - 1));
     CHECK_EQ(expected, result);
   }
 }
 
 WASM_EXEC_TEST(CheckMachIntsZero) {
   const int kNumElems = 55;
   WasmRunner<uint32_t, int32_t> r(execution_mode);
   r.module().AddMemoryElems<uint32_t>(kNumElems);
 
   BUILD(r,                               // --
         /**/ kExprLoop, kLocalVoid,      // --
         /*  */ kExprGetLocal, 0,         // --
         /*  */ kExprIf, kLocalVoid,      // --
         /*    */ kExprGetLocal, 0,       // --
         /*    */ kExprI32LoadMem, 0, 0,  // --
         /*    */ kExprIf, kLocalVoid,    // --
-        /*      */ kExprI8Const, 255,    // --
+        /*      */ kExprI32Const, 127,   // --
         /*      */ kExprReturn,          // --
         /*    */ kExprEnd,               // --
         /*    */ kExprGetLocal, 0,       // --
-        /*    */ kExprI8Const, 4,        // --
+        /*    */ kExprI32Const, 4,       // --
         /*    */ kExprI32Sub,            // --
         /*    */ kExprTeeLocal, 0,       // --
         /*    */ kExprBr, DEPTH_0,       // --
         /*  */ kExprEnd,                 // --
         /**/ kExprEnd,                   // --
-        /**/ kExprI8Const, 0);           // --
+        /**/ kExprI32Const, 0);          // --
 
   r.module().BlankMemory();
   CHECK_EQ(0, r.Call((kNumElems - 1) * 4));
 }
 
 WASM_EXEC_TEST(MemF32_Sum) {
   const int kSize = 5;
   WasmRunner<int32_t, int32_t> r(execution_mode);
   r.module().AddMemoryElems<float>(kSize);
   float* buffer = r.module().raw_mem_start<float>();
   r.module().WriteMemory(&buffer[0], -99.25f);
   r.module().WriteMemory(&buffer[1], -888.25f);
   r.module().WriteMemory(&buffer[2], -77.25f);
   r.module().WriteMemory(&buffer[3], 66666.25f);
   r.module().WriteMemory(&buffer[4], 5555.25f);
   const byte kSum = r.AllocateLocal(kWasmF32);
 
-  BUILD(
-      r,
-      WASM_WHILE(
-          WASM_GET_LOCAL(0),
-          WASM_BLOCK(
-              WASM_SET_LOCAL(kSum,
-                             WASM_F32_ADD(WASM_GET_LOCAL(kSum),
+  BUILD(r, WASM_WHILE(
+               WASM_GET_LOCAL(0),
+               WASM_BLOCK(
+                   WASM_SET_LOCAL(
+                       kSum, WASM_F32_ADD(WASM_GET_LOCAL(kSum),
                                           WASM_LOAD_MEM(MachineType::Float32(),
                                                         WASM_GET_LOCAL(0)))),
-              WASM_SET_LOCAL(0, WASM_I32_SUB(WASM_GET_LOCAL(0), WASM_I8(4))))),
-      WASM_STORE_MEM(MachineType::Float32(), WASM_ZERO, WASM_GET_LOCAL(kSum)),
-      WASM_GET_LOCAL(0));
+                   WASM_SET_LOCAL(
+                       0, WASM_I32_SUB(WASM_GET_LOCAL(0), WASM_I32V_1(4))))),
+        WASM_STORE_MEM(MachineType::Float32(), WASM_ZERO, WASM_GET_LOCAL(kSum)),
+        WASM_GET_LOCAL(0));
 
   CHECK_EQ(0, r.Call(4 * (kSize - 1)));
   CHECK_NE(-99.25f, r.module().ReadMemory(&buffer[0]));
   CHECK_EQ(71256.0f, r.module().ReadMemory(&buffer[0]));
 }
 
 template <typename T>
 T GenerateAndRunFold(WasmExecutionMode execution_mode, WasmOpcode binop,
                      T* buffer, uint32_t size, ValueType astType,
                      MachineType memType) {
   WasmRunner<int32_t, int32_t> r(execution_mode);
   T* memory = r.module().AddMemoryElems<T>(size);
   for (uint32_t i = 0; i < size; ++i) {
     r.module().WriteMemory(&memory[i], buffer[i]);
   }
   const byte kAccum = r.AllocateLocal(astType);
 
-  BUILD(r, WASM_SET_LOCAL(kAccum, WASM_LOAD_MEM(memType, WASM_ZERO)),
-        WASM_WHILE(
-            WASM_GET_LOCAL(0),
-            WASM_BLOCK(WASM_SET_LOCAL(
-                           kAccum, WASM_BINOP(binop, WASM_GET_LOCAL(kAccum),
-                                              WASM_LOAD_MEM(
-                                                  memType, WASM_GET_LOCAL(0)))),
-                       WASM_SET_LOCAL(0, WASM_I32_SUB(WASM_GET_LOCAL(0),
-                                                      WASM_I8(sizeof(T)))))),
-        WASM_STORE_MEM(memType, WASM_ZERO, WASM_GET_LOCAL(kAccum)),
-        WASM_GET_LOCAL(0));
+  BUILD(
+      r, WASM_SET_LOCAL(kAccum, WASM_LOAD_MEM(memType, WASM_ZERO)),
+      WASM_WHILE(
+          WASM_GET_LOCAL(0),
+          WASM_BLOCK(WASM_SET_LOCAL(
+                         kAccum,
+                         WASM_BINOP(binop, WASM_GET_LOCAL(kAccum),
+                                    WASM_LOAD_MEM(memType, WASM_GET_LOCAL(0)))),
+                     WASM_SET_LOCAL(0, WASM_I32_SUB(WASM_GET_LOCAL(0),
+                                                    WASM_I32V_1(sizeof(T)))))),
+      WASM_STORE_MEM(memType, WASM_ZERO, WASM_GET_LOCAL(kAccum)),
+      WASM_GET_LOCAL(0));
   r.Call(static_cast<int>(sizeof(T) * (size - 1)));
   return r.module().ReadMemory(&memory[0]);
 }
 
 WASM_EXEC_TEST(MemF64_Mul) {
   const size_t kSize = 6;
   double buffer[kSize] = {1, 2, 2, 2, 2, 2};
   double result =
       GenerateAndRunFold<double>(execution_mode, kExprF64Mul, buffer, kSize,
                                  kWasmF64, MachineType::Float64());
@@ skipping 10 matching lines @@
   WasmRunner<int32_t, int32_t> r(execution_mode);
   r.module().AddMemoryElems<int8_t>(16);
 
   // Only build the graph and compile, don't run.
   BUILD(r, WASM_LOOP(WASM_LOAD_MEM(MachineType::Int32(), WASM_ZERO), WASM_DROP),
         WASM_ZERO);
 }
 
 WASM_EXEC_TEST(Unreachable0a) {
   WasmRunner<int32_t, int32_t> r(execution_mode);
-  BUILD(r, WASM_BLOCK_I(WASM_BRV(0, WASM_I8(9)), RET(WASM_GET_LOCAL(0))));
+  BUILD(r, WASM_BLOCK_I(WASM_BRV(0, WASM_I32V_1(9)), RET(WASM_GET_LOCAL(0))));
   CHECK_EQ(9, r.Call(0));
   CHECK_EQ(9, r.Call(1));
 }
 
 WASM_EXEC_TEST(Unreachable0b) {
   WasmRunner<int32_t, int32_t> r(execution_mode);
-  BUILD(r, WASM_BLOCK_I(WASM_BRV(0, WASM_I8(7)), WASM_UNREACHABLE));
+  BUILD(r, WASM_BLOCK_I(WASM_BRV(0, WASM_I32V_1(7)), WASM_UNREACHABLE));
   CHECK_EQ(7, r.Call(0));
   CHECK_EQ(7, r.Call(1));
 }
 
 TEST(Build_Wasm_Unreachable1) {
   WasmRunner<int32_t, int32_t> r(kExecuteCompiled);
   BUILD(r, WASM_UNREACHABLE);
 }
 
 TEST(Build_Wasm_Unreachable2) {
@@ skipping 20 matching lines @@
 WASM_EXEC_TEST(Unreachable_Load) {
   WasmRunner<int32_t, int32_t> r(execution_mode);
   BUILD(r, WASM_BLOCK_I(WASM_BRV(0, WASM_GET_LOCAL(0)),
                         WASM_LOAD_MEM(MachineType::Int8(), WASM_GET_LOCAL(0))));
   CHECK_EQ(11, r.Call(11));
   CHECK_EQ(21, r.Call(21));
 }
 
 WASM_EXEC_TEST(Infinite_Loop_not_taken1) {
   WasmRunner<int32_t, int32_t> r(execution_mode);
-  BUILD(r, WASM_IF(WASM_GET_LOCAL(0), WASM_INFINITE_LOOP), WASM_I8(45));
+  BUILD(r, WASM_IF(WASM_GET_LOCAL(0), WASM_INFINITE_LOOP), WASM_I32V_1(45));
   // Run the code, but don't go into the infinite loop.
   CHECK_EQ(45, r.Call(0));
 }
 
 WASM_EXEC_TEST(Infinite_Loop_not_taken2) {
   WasmRunner<int32_t, int32_t> r(execution_mode);
-  BUILD(r,
-        WASM_BLOCK_I(WASM_IF_ELSE(WASM_GET_LOCAL(0), WASM_BRV(1, WASM_I8(45)),
-                                  WASM_INFINITE_LOOP)));
+  BUILD(r, WASM_BLOCK_I(WASM_IF_ELSE(WASM_GET_LOCAL(0),
+                                     WASM_BRV(1, WASM_I32V_1(45)),
+                                     WASM_INFINITE_LOOP)));
   // Run the code, but don't go into the infinite loop.
   CHECK_EQ(45, r.Call(1));
 }
 
 WASM_EXEC_TEST(Infinite_Loop_not_taken2_brif) {
   WasmRunner<int32_t, int32_t> r(execution_mode);
-  BUILD(r, WASM_BLOCK_I(WASM_BRV_IF(0, WASM_I8(45), WASM_GET_LOCAL(0)),
+  BUILD(r, WASM_BLOCK_I(WASM_BRV_IF(0, WASM_I32V_1(45), WASM_GET_LOCAL(0)),
                         WASM_INFINITE_LOOP));
   // Run the code, but don't go into the infinite loop.
   CHECK_EQ(45, r.Call(1));
 }
 
 static void TestBuildGraphForSimpleExpression(WasmOpcode opcode) {
   Isolate* isolate = CcTest::InitIsolateOnce();
   Zone zone(isolate->allocator(), ZONE_NAME);
   HandleScope scope(isolate);
   // Enable all optional operators.
@@ skipping 260 matching lines @@
   WasmRunner<int32_t> r(execution_mode);
 
   const byte kMemOffset = 8;
   const int32_t kElemNum = kMemOffset / sizeof(int32_t);
   const int32_t kExpected = 414444;
   // Build the target function.
   TestSignatures sigs;
   int32_t* memory = r.module().AddMemoryElems<int32_t>(16 / sizeof(int32_t));
   r.module().RandomizeMemory();
   WasmFunctionCompiler& t = r.NewFunction(sigs.v_v());
-  BUILD(t, WASM_STORE_MEM(MachineType::Int32(), WASM_I8(kMemOffset),
+  BUILD(t, WASM_STORE_MEM(MachineType::Int32(), WASM_I32V_1(kMemOffset),
                           WASM_I32V_3(kExpected)));
 
   // Build the calling function.
   BUILD(r, WASM_CALL_FUNCTION0(t.function_index()),
-        WASM_LOAD_MEM(MachineType::Int32(), WASM_I8(kMemOffset)));
+        WASM_LOAD_MEM(MachineType::Int32(), WASM_I32V_1(kMemOffset)));
 
   int32_t result = r.Call();
   CHECK_EQ(kExpected, result);
   CHECK_EQ(static_cast<int64_t>(kExpected),
            static_cast<int64_t>(r.module().ReadMemory(&memory[kElemNum])));
 }
 
 WASM_EXEC_TEST(Call_Int32Add) {
   WasmRunner<int32_t, int32_t, int32_t> r(execution_mode);
 
@@ skipping 29 matching lines @@
     FOR_FLOAT32_INPUTS(j) { CHECK_FLOAT_EQ(*i - *j, r.Call(*i, *j)); }
   }
 }
 
 WASM_EXEC_TEST(Call_Float64Sub) {
   WasmRunner<int32_t> r(execution_mode);
   double* memory = r.module().AddMemoryElems<double>(16);
 
   BUILD(r, WASM_STORE_MEM(
                MachineType::Float64(), WASM_ZERO,
-               WASM_F64_SUB(WASM_LOAD_MEM(MachineType::Float64(), WASM_ZERO),
-                            WASM_LOAD_MEM(MachineType::Float64(), WASM_I8(8)))),
-        WASM_I8(107));
+               WASM_F64_SUB(
+                   WASM_LOAD_MEM(MachineType::Float64(), WASM_ZERO),
+                   WASM_LOAD_MEM(MachineType::Float64(), WASM_I32V_1(8)))),
+        WASM_I32V_2(107));
 
   FOR_FLOAT64_INPUTS(i) {
     FOR_FLOAT64_INPUTS(j) {
       r.module().WriteMemory(&memory[0], *i);
       r.module().WriteMemory(&memory[1], *j);
       double expected = *i - *j;
       CHECK_EQ(107, r.Call());
 
       if (expected != expected) {
         CHECK(r.module().ReadMemory(&memory[0]) !=
@@ skipping 47 matching lines @@
     // Build the calling function.
     // =========================================================================
     std::vector<byte> code;
 
     // Load the offset for the store.
     ADD_CODE(code, WASM_ZERO);
 
     // Load the arguments.
     for (int i = 0; i < num_params; ++i) {
       int offset = (i + 1) * kElemSize;
-      ADD_CODE(code, WASM_LOAD_MEM(memtypes[i], WASM_I8(offset)));
+      ADD_CODE(code, WASM_LOAD_MEM(memtypes[i], WASM_I32V_2(offset)));
     }
 
     // Call the selector function.
     ADD_CODE(code, WASM_CALL_FUNCTION0(t.function_index()));
 
     // Store the result in memory.
     ADD_CODE(code,
              static_cast<byte>(WasmOpcodes::LoadStoreOpcodeOf(result, true)),
              ZERO_ALIGNMENT, ZERO_OFFSET);
 
@@ skipping 22 matching lines @@
 WASM_EXEC_TEST(MixedCall_1) { Run_WasmMixedCall_N(execution_mode, 1); }
 WASM_EXEC_TEST(MixedCall_2) { Run_WasmMixedCall_N(execution_mode, 2); }
 WASM_EXEC_TEST(MixedCall_3) { Run_WasmMixedCall_N(execution_mode, 3); }
 
 WASM_EXEC_TEST(AddCall) {
   WasmRunner<int32_t, int32_t> r(kExecuteCompiled);
   WasmFunctionCompiler& t1 = r.NewFunction<int32_t, int32_t, int32_t>();
   BUILD(t1, WASM_I32_ADD(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
 
   byte local = r.AllocateLocal(kWasmI32);
-  BUILD(r, WASM_SET_LOCAL(local, WASM_I8(99)),
+  BUILD(r, WASM_SET_LOCAL(local, WASM_I32V_2(99)),
         WASM_I32_ADD(WASM_CALL_FUNCTION(t1.function_index(), WASM_GET_LOCAL(0),
                                         WASM_GET_LOCAL(0)),
                      WASM_CALL_FUNCTION(t1.function_index(), WASM_GET_LOCAL(1),
                                         WASM_GET_LOCAL(local))));
 
   CHECK_EQ(198, r.Call(0));
   CHECK_EQ(200, r.Call(1));
   CHECK_EQ(100, r.Call(-49));
 }
 
@@ skipping 73 matching lines @@
 #endif
 }
 
 WASM_EXEC_TEST(MultiReturnSelect_f64) {
   static const double inputs[] = {3.333333, 44444.44, -55.555555, -7777.777};
   RunMultiReturnSelect<double>(execution_mode, inputs);
 }
 
 WASM_EXEC_TEST(ExprBlock2a) {
   WasmRunner<int32_t, int32_t> r(execution_mode);
-  BUILD(r, WASM_BLOCK_I(WASM_IF(WASM_GET_LOCAL(0), WASM_BRV(1, WASM_I8(1))),
-                        WASM_I8(1)));
+  BUILD(r, WASM_BLOCK_I(WASM_IF(WASM_GET_LOCAL(0), WASM_BRV(1, WASM_I32V_1(1))),
+                        WASM_I32V_1(1)));
   CHECK_EQ(1, r.Call(0));
   CHECK_EQ(1, r.Call(1));
 }
 
 WASM_EXEC_TEST(ExprBlock2b) {
   WasmRunner<int32_t, int32_t> r(execution_mode);
-  BUILD(r, WASM_BLOCK_I(WASM_IF(WASM_GET_LOCAL(0), WASM_BRV(1, WASM_I8(1))),
-                        WASM_I8(2)));
+  BUILD(r, WASM_BLOCK_I(WASM_IF(WASM_GET_LOCAL(0), WASM_BRV(1, WASM_I32V_1(1))),
+                        WASM_I32V_1(2)));
   CHECK_EQ(2, r.Call(0));
   CHECK_EQ(1, r.Call(1));
 }
 
 WASM_EXEC_TEST(ExprBlock2c) {
   WasmRunner<int32_t, int32_t> r(execution_mode);
-  BUILD(r, WASM_BLOCK_I(WASM_BRV_IFD(0, WASM_I8(1), WASM_GET_LOCAL(0)),
-                        WASM_I8(1)));
+  BUILD(r, WASM_BLOCK_I(WASM_BRV_IFD(0, WASM_I32V_1(1), WASM_GET_LOCAL(0)),
+                        WASM_I32V_1(1)));
   CHECK_EQ(1, r.Call(0));
   CHECK_EQ(1, r.Call(1));
 }
 
 WASM_EXEC_TEST(ExprBlock2d) {
   WasmRunner<int32_t, int32_t> r(execution_mode);
-  BUILD(r, WASM_BLOCK_I(WASM_BRV_IFD(0, WASM_I8(1), WASM_GET_LOCAL(0)),
-                        WASM_I8(2)));
+  BUILD(r, WASM_BLOCK_I(WASM_BRV_IFD(0, WASM_I32V_1(1), WASM_GET_LOCAL(0)),
+                        WASM_I32V_1(2)));
   CHECK_EQ(2, r.Call(0));
   CHECK_EQ(1, r.Call(1));
 }
 
 WASM_EXEC_TEST(ExprBlock_ManualSwitch) {
   WasmRunner<int32_t, int32_t> r(execution_mode);
-  BUILD(r, WASM_BLOCK_I(WASM_IF(WASM_I32_EQ(WASM_GET_LOCAL(0), WASM_I8(1)),
-                                WASM_BRV(1, WASM_I8(11))),
-                        WASM_IF(WASM_I32_EQ(WASM_GET_LOCAL(0), WASM_I8(2)),
-                                WASM_BRV(1, WASM_I8(12))),
-                        WASM_IF(WASM_I32_EQ(WASM_GET_LOCAL(0), WASM_I8(3)),
-                                WASM_BRV(1, WASM_I8(13))),
-                        WASM_IF(WASM_I32_EQ(WASM_GET_LOCAL(0), WASM_I8(4)),
-                                WASM_BRV(1, WASM_I8(14))),
-                        WASM_IF(WASM_I32_EQ(WASM_GET_LOCAL(0), WASM_I8(5)),
-                                WASM_BRV(1, WASM_I8(15))),
-                        WASM_I8(99)));
+  BUILD(r, WASM_BLOCK_I(WASM_IF(WASM_I32_EQ(WASM_GET_LOCAL(0), WASM_I32V_1(1)),
+                                WASM_BRV(1, WASM_I32V_1(11))),
+                        WASM_IF(WASM_I32_EQ(WASM_GET_LOCAL(0), WASM_I32V_1(2)),
+                                WASM_BRV(1, WASM_I32V_1(12))),
+                        WASM_IF(WASM_I32_EQ(WASM_GET_LOCAL(0), WASM_I32V_1(3)),
+                                WASM_BRV(1, WASM_I32V_1(13))),
+                        WASM_IF(WASM_I32_EQ(WASM_GET_LOCAL(0), WASM_I32V_1(4)),
+                                WASM_BRV(1, WASM_I32V_1(14))),
+                        WASM_IF(WASM_I32_EQ(WASM_GET_LOCAL(0), WASM_I32V_1(5)),
+                                WASM_BRV(1, WASM_I32V_1(15))),
+                        WASM_I32V_2(99)));
   CHECK_EQ(99, r.Call(0));
   CHECK_EQ(11, r.Call(1));
   CHECK_EQ(12, r.Call(2));
   CHECK_EQ(13, r.Call(3));
   CHECK_EQ(14, r.Call(4));
   CHECK_EQ(15, r.Call(5));
   CHECK_EQ(99, r.Call(6));
 }
 
 WASM_EXEC_TEST(ExprBlock_ManualSwitch_brif) {
   WasmRunner<int32_t, int32_t> r(execution_mode);
-  BUILD(r,
-        WASM_BLOCK_I(WASM_BRV_IFD(0, WASM_I8(11),
-                                  WASM_I32_EQ(WASM_GET_LOCAL(0), WASM_I8(1))),
-                     WASM_BRV_IFD(0, WASM_I8(12),
-                                  WASM_I32_EQ(WASM_GET_LOCAL(0), WASM_I8(2))),
-                     WASM_BRV_IFD(0, WASM_I8(13),
-                                  WASM_I32_EQ(WASM_GET_LOCAL(0), WASM_I8(3))),
-                     WASM_BRV_IFD(0, WASM_I8(14),
-                                  WASM_I32_EQ(WASM_GET_LOCAL(0), WASM_I8(4))),
-                     WASM_BRV_IFD(0, WASM_I8(15),
-                                  WASM_I32_EQ(WASM_GET_LOCAL(0), WASM_I8(5))),
-                     WASM_I8(99)));
+  BUILD(r, WASM_BLOCK_I(
+               WASM_BRV_IFD(0, WASM_I32V_1(11),
+                            WASM_I32_EQ(WASM_GET_LOCAL(0), WASM_I32V_1(1))),
+               WASM_BRV_IFD(0, WASM_I32V_1(12),
+                            WASM_I32_EQ(WASM_GET_LOCAL(0), WASM_I32V_1(2))),
+               WASM_BRV_IFD(0, WASM_I32V_1(13),
+                            WASM_I32_EQ(WASM_GET_LOCAL(0), WASM_I32V_1(3))),
+               WASM_BRV_IFD(0, WASM_I32V_1(14),
+                            WASM_I32_EQ(WASM_GET_LOCAL(0), WASM_I32V_1(4))),
+               WASM_BRV_IFD(0, WASM_I32V_1(15),
+                            WASM_I32_EQ(WASM_GET_LOCAL(0), WASM_I32V_1(5))),
+               WASM_I32V_2(99)));
   CHECK_EQ(99, r.Call(0));
   CHECK_EQ(11, r.Call(1));
   CHECK_EQ(12, r.Call(2));
   CHECK_EQ(13, r.Call(3));
   CHECK_EQ(14, r.Call(4));
   CHECK_EQ(15, r.Call(5));
   CHECK_EQ(99, r.Call(6));
 }
 
 WASM_EXEC_TEST(If_nested) {
   WasmRunner<int32_t, int32_t, int32_t> r(execution_mode);
 
-  BUILD(r, WASM_IF_ELSE_I(
-               WASM_GET_LOCAL(0),
-               WASM_IF_ELSE_I(WASM_GET_LOCAL(1), WASM_I8(11), WASM_I8(12)),
-               WASM_IF_ELSE_I(WASM_GET_LOCAL(1), WASM_I8(13), WASM_I8(14))));
+  BUILD(
+      r,
+      WASM_IF_ELSE_I(
+          WASM_GET_LOCAL(0),
+          WASM_IF_ELSE_I(WASM_GET_LOCAL(1), WASM_I32V_1(11), WASM_I32V_1(12)),
+          WASM_IF_ELSE_I(WASM_GET_LOCAL(1), WASM_I32V_1(13), WASM_I32V_1(14))));
 
   CHECK_EQ(11, r.Call(1, 1));
   CHECK_EQ(12, r.Call(1, 0));
   CHECK_EQ(13, r.Call(0, 1));
   CHECK_EQ(14, r.Call(0, 0));
 }
 
 WASM_EXEC_TEST(ExprBlock_if) {
   WasmRunner<int32_t, int32_t> r(execution_mode);
 
-  BUILD(r,
-        WASM_BLOCK_I(WASM_IF_ELSE_I(WASM_GET_LOCAL(0), WASM_BRV(0, WASM_I8(11)),
-                                    WASM_BRV(1, WASM_I8(14)))));
+  BUILD(r, WASM_BLOCK_I(WASM_IF_ELSE_I(WASM_GET_LOCAL(0),
+                                       WASM_BRV(0, WASM_I32V_1(11)),
+                                       WASM_BRV(1, WASM_I32V_1(14)))));
 
   CHECK_EQ(11, r.Call(1));
   CHECK_EQ(14, r.Call(0));
 }
 
 WASM_EXEC_TEST(ExprBlock_nested_ifs) {
   WasmRunner<int32_t, int32_t, int32_t> r(execution_mode);
 
   BUILD(r, WASM_BLOCK_I(WASM_IF_ELSE_I(
                WASM_GET_LOCAL(0),
-               WASM_IF_ELSE_I(WASM_GET_LOCAL(1), WASM_BRV(0, WASM_I8(11)),
-                              WASM_BRV(1, WASM_I8(12))),
-               WASM_IF_ELSE_I(WASM_GET_LOCAL(1), WASM_BRV(0, WASM_I8(13)),
-                              WASM_BRV(1, WASM_I8(14))))));
+               WASM_IF_ELSE_I(WASM_GET_LOCAL(1), WASM_BRV(0, WASM_I32V_1(11)),
+                              WASM_BRV(1, WASM_I32V_1(12))),
+               WASM_IF_ELSE_I(WASM_GET_LOCAL(1), WASM_BRV(0, WASM_I32V_1(13)),
+                              WASM_BRV(1, WASM_I32V_1(14))))));
 
   CHECK_EQ(11, r.Call(1, 1));
   CHECK_EQ(12, r.Call(1, 0));
   CHECK_EQ(13, r.Call(0, 1));
   CHECK_EQ(14, r.Call(0, 0));
 }
 
 WASM_EXEC_TEST_WITH_TRAP(SimpleCallIndirect) {
   TestSignatures sigs;
   WasmRunner<int32_t, int32_t> r(execution_mode);
@@ skipping 13 matching lines @@
 
   // Function table.
   uint16_t indirect_function_table[] = {
       static_cast<uint16_t>(t1.function_index()),
       static_cast<uint16_t>(t2.function_index())};
   r.module().AddIndirectFunctionTable(indirect_function_table,
                                       arraysize(indirect_function_table));
   r.module().PopulateIndirectFunctionTable();
 
   // Build the caller function.
-  BUILD(r, WASM_CALL_INDIRECT2(1, WASM_GET_LOCAL(0), WASM_I8(66), WASM_I8(22)));
+  BUILD(r, WASM_CALL_INDIRECT2(1, WASM_GET_LOCAL(0), WASM_I32V_2(66),
+                               WASM_I32V_1(22)));
 
   CHECK_EQ(88, r.Call(0));
   CHECK_EQ(44, r.Call(1));
   CHECK_TRAP(r.Call(2));
 }
 
 WASM_EXEC_TEST_WITH_TRAP(MultipleCallIndirect) {
   TestSignatures sigs;
   WasmRunner<int32_t, int32_t, int32_t, int32_t> r(execution_mode);
 
@@ skipping 44 matching lines @@
   WasmFunctionCompiler& t1 = r.NewFunction(sigs.i_ii());
   BUILD(t1, WASM_I32_ADD(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
   t1.SetSigIndex(1);
 
   // Signature table.
   r.module().AddSignature(sigs.f_ff());
   r.module().AddSignature(sigs.i_ii());
   r.module().AddIndirectFunctionTable(nullptr, 0);
 
   // Build the caller function.
-  BUILD(r, WASM_CALL_INDIRECT2(1, WASM_GET_LOCAL(0), WASM_I8(66), WASM_I8(22)));
+  BUILD(r, WASM_CALL_INDIRECT2(1, WASM_GET_LOCAL(0), WASM_I32V_2(66),
+                               WASM_I32V_1(22)));
 
   CHECK_TRAP(r.Call(0));
   CHECK_TRAP(r.Call(1));
   CHECK_TRAP(r.Call(2));
 }
 
 WASM_EXEC_TEST_WITH_TRAP(CallIndirect_canonical) {
   TestSignatures sigs;
   WasmRunner<int32_t, int32_t> r(execution_mode);
 
@@ skipping 18 matching lines @@
   uint16_t i1 = static_cast<uint16_t>(t1.function_index());
   uint16_t i2 = static_cast<uint16_t>(t2.function_index());
   uint16_t i3 = static_cast<uint16_t>(t3.function_index());
   uint16_t indirect_function_table[] = {i1, i2, i3, i1, i2};
 
   r.module().AddIndirectFunctionTable(indirect_function_table,
                                       arraysize(indirect_function_table));
   r.module().PopulateIndirectFunctionTable();
 
   // Build the caller function.
-  BUILD(r, WASM_CALL_INDIRECT2(1, WASM_GET_LOCAL(0), WASM_I8(77), WASM_I8(11)));
+  BUILD(r, WASM_CALL_INDIRECT2(1, WASM_GET_LOCAL(0), WASM_I32V_2(77),
+                               WASM_I32V_1(11)));
 
   CHECK_EQ(88, r.Call(0));
   CHECK_EQ(66, r.Call(1));
   CHECK_TRAP(r.Call(2));
   CHECK_EQ(88, r.Call(3));
   CHECK_EQ(66, r.Call(4));
   CHECK_TRAP(r.Call(5));
 }
 
 WASM_EXEC_TEST(F32Floor) {
@@ skipping 193 matching lines @@
     r.module().AddSignature(sig);
     r.module().AddSignature(sig);
     r.module().AddIndirectFunctionTable(nullptr, 0);
 
     WasmFunctionCompiler& t = r.NewFunction(sig);
 
     std::vector<byte> code;
     for (byte p = 0; p < num_params; ++p) {
       ADD_CODE(code, kExprGetLocal, p);
     }
-    ADD_CODE(code, kExprI8Const, 0);
+    ADD_CODE(code, kExprI32Const, 0);
     ADD_CODE(code, kExprCallIndirect, 1, TABLE_ZERO);
 
     t.Build(&code[0], &code[0] + code.size());
   }
 }
 
 TEST(Compile_Wasm_CallIndirect_Many_i32) { CompileCallIndirectMany(kWasmI32); }
 
 TEST(Compile_Wasm_CallIndirect_Many_f32) { CompileCallIndirectMany(kWasmF32); }
 
 TEST(Compile_Wasm_CallIndirect_Many_f64) { CompileCallIndirectMany(kWasmF64); }
 
 WASM_EXEC_TEST_WITH_TRAP(Int32RemS_dead) {
   WasmRunner<int32_t, int32_t, int32_t> r(execution_mode);
   BUILD(r, WASM_I32_REMS(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)), WASM_DROP,
         WASM_ZERO);
   const int32_t kMin = std::numeric_limits<int32_t>::min();
   CHECK_EQ(0, r.Call(133, 100));
   CHECK_EQ(0, r.Call(kMin, -1));
   CHECK_EQ(0, r.Call(0, 1));
   CHECK_TRAP(r.Call(100, 0));
   CHECK_TRAP(r.Call(-1001, 0));
   CHECK_TRAP(r.Call(kMin, 0));
 }