Revert "Upgrade to 5.0.71.48"
This reverts commit 8389745919cae02139ddc085a63c00d024269cf2.
Change-Id: Ic5c75c8b3ddaf795972372fbc863a514862953c1
diff --git a/test/unittests/wasm/ast-decoder-unittest.cc b/test/unittests/wasm/ast-decoder-unittest.cc
index 6721587..923c554 100644
--- a/test/unittests/wasm/ast-decoder-unittest.cc
+++ b/test/unittests/wasm/ast-decoder-unittest.cc
@@ -35,8 +35,6 @@
kExprI32Shl, kExprI32ShrU, kExprI32ShrS, kExprI32Eq, kExprI32LtS,
kExprI32LeS, kExprI32LtU, kExprI32LeU};
-#define WASM_BRV_IF_ZERO(depth, val) \
- kExprBrIf, static_cast<byte>(depth), val, WASM_ZERO
#define EXPECT_VERIFIES(env, x) Verify(kSuccess, env, x, x + arraysize(x))
@@ -89,10 +87,10 @@
static void init_env(FunctionEnv* env, FunctionSig* sig) {
env->module = nullptr;
env->sig = sig;
- env->local_i32_count = 0;
- env->local_i64_count = 0;
- env->local_f32_count = 0;
- env->local_f64_count = 0;
+ env->local_int32_count = 0;
+ env->local_int64_count = 0;
+ env->local_float32_count = 0;
+ env->local_float64_count = 0;
env->SumLocals();
}
@@ -181,9 +179,9 @@
FunctionEnv env;
env.module = nullptr;
env.sig = sig;
- env.local_i32_count = count;
- env.local_f64_count = 0;
- env.local_f32_count = 0;
+ env.local_int32_count = count;
+ env.local_float64_count = 0;
+ env.local_float32_count = 0;
env.total_locals = static_cast<unsigned>(count + sig->parameter_count());
return env;
}
@@ -253,6 +251,9 @@
}
+// TODO(tizer): Fix on arm and reenable.
+#if !V8_TARGET_ARCH_ARM && !V8_TARGET_ARCH_ARM64
+
TEST_F(WasmDecoderTest, Float32Const) {
byte code[] = {kExprF32Const, 0, 0, 0, 0};
float* ptr = reinterpret_cast<float*>(code + 1);
@@ -272,6 +273,8 @@
}
}
+#endif
+
TEST_F(WasmDecoderTest, Int32Const_off_end) {
byte code[] = {kExprI32Const, 0xaa, 0xbb, 0xcc, 0x44};
@@ -335,7 +338,7 @@
TEST_F(WasmDecoderTest, GetLocal_varint) {
- env_i_i.local_i32_count = 1000000000;
+ env_i_i.local_int32_count = 1000000000;
env_i_i.total_locals += 1000000000;
{
@@ -529,11 +532,16 @@
}
+// TODO(tizer): Fix on arm and reenable.
+#if !V8_TARGET_ARCH_ARM && !V8_TARGET_ARCH_ARM64
+
TEST_F(WasmDecoderTest, ExprBlock1c) {
static const byte code[] = {kExprBlock, 1, kExprF32Const, 0, 0, 0, 0};
EXPECT_VERIFIES(&env_f_ff, code);
}
+#endif
+
TEST_F(WasmDecoderTest, IfEmpty) {
static const byte code[] = {kExprIf, kExprGetLocal, 0, kExprNop};
@@ -696,6 +704,9 @@
}
+// TODO(tizer): Fix on arm and reenable.
+#if !V8_TARGET_ARCH_ARM && !V8_TARGET_ARCH_ARM64
+
TEST_F(WasmDecoderTest, ReturnVoid3) {
EXPECT_VERIFIES_INLINE(&env_v_v, kExprI8Const, 0);
EXPECT_VERIFIES_INLINE(&env_v_v, kExprI32Const, 0, 0, 0, 0);
@@ -706,6 +717,8 @@
EXPECT_VERIFIES_INLINE(&env_v_i, kExprGetLocal, 0);
}
+#endif
+
TEST_F(WasmDecoderTest, Unreachable1) {
EXPECT_VERIFIES_INLINE(&env_v_v, kExprUnreachable);
@@ -868,6 +881,9 @@
}
+// TODO(tizer): Fix on arm and reenable.
+#if !V8_TARGET_ARCH_ARM && !V8_TARGET_ARCH_ARM64
+
TEST_F(WasmDecoderTest, MacrosBreak) {
EXPECT_VERIFIES_INLINE(&env_v_v, WASM_LOOP(1, WASM_BREAK(0)));
@@ -879,6 +895,8 @@
WASM_LOOP(1, WASM_BREAKV(0, WASM_F64(0.0))));
}
+#endif
+
TEST_F(WasmDecoderTest, MacrosContinue) {
EXPECT_VERIFIES_INLINE(&env_v_v, WASM_LOOP(1, WASM_CONTINUE(0)));
@@ -1186,13 +1204,14 @@
class TestModuleEnv : public ModuleEnv {
public:
TestModuleEnv() {
- instance = nullptr;
+ mem_start = 0;
+ mem_end = 0;
module = &mod;
linker = nullptr;
+ function_code = nullptr;
mod.globals = new std::vector<WasmGlobal>;
mod.signatures = new std::vector<FunctionSig*>;
mod.functions = new std::vector<WasmFunction>;
- mod.import_table = new std::vector<WasmImport>;
}
byte AddGlobal(MachineType mem_type) {
mod.globals->push_back({0, mem_type, 0, false});
@@ -1209,11 +1228,6 @@
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});
- CHECK(mod.import_table->size() <= 127);
- return static_cast<byte>(mod.import_table->size() - 1);
- }
private:
WasmModule mod;
@@ -1251,6 +1265,9 @@
}
+// TODO(tizer): Fix on arm and reenable.
+#if !V8_TARGET_ARCH_ARM && !V8_TARGET_ARCH_ARM64
+
TEST_F(WasmDecoderTest, CallsWithSpilloverArgs) {
static LocalType a_i_ff[] = {kAstI32, kAstF32, kAstF32};
FunctionSig sig_i_ff(1, 2, a_i_ff);
@@ -1314,6 +1331,8 @@
EXPECT_FAILURE_INLINE(env, WASM_CALL_FUNCTION(1, WASM_F32(17.6)));
}
+#endif
+
TEST_F(WasmDecoderTest, SimpleIndirectCalls) {
FunctionEnv* env = &env_i_i;
@@ -1370,39 +1389,6 @@
EXPECT_FAILURE_INLINE(env, WASM_CALL_INDIRECT(f1, WASM_ZERO, WASM_F32(17.6)));
}
-TEST_F(WasmDecoderTest, SimpleImportCalls) {
- FunctionEnv* env = &env_i_i;
- TestModuleEnv module_env;
- env->module = &module_env;
-
- byte f0 = module_env.AddImport(sigs.i_v());
- byte f1 = module_env.AddImport(sigs.i_i());
- byte f2 = module_env.AddImport(sigs.i_ii());
-
- EXPECT_VERIFIES_INLINE(env, WASM_CALL_IMPORT0(f0));
- EXPECT_VERIFIES_INLINE(env, WASM_CALL_IMPORT(f1, WASM_I8(22)));
- EXPECT_VERIFIES_INLINE(env, WASM_CALL_IMPORT(f2, WASM_I8(32), WASM_I8(72)));
-}
-
-TEST_F(WasmDecoderTest, ImportCallsWithMismatchedSigs3) {
- FunctionEnv* env = &env_i_i;
- TestModuleEnv module_env;
- env->module = &module_env;
-
- byte f0 = module_env.AddImport(sigs.i_f());
-
- EXPECT_FAILURE_INLINE(env, WASM_CALL_IMPORT0(f0));
- EXPECT_FAILURE_INLINE(env, WASM_CALL_IMPORT(f0, WASM_I8(17)));
- EXPECT_FAILURE_INLINE(env, WASM_CALL_IMPORT(f0, WASM_I64(27)));
- EXPECT_FAILURE_INLINE(env, WASM_CALL_IMPORT(f0, WASM_F64(37.2)));
-
- byte f1 = module_env.AddImport(sigs.i_d());
-
- EXPECT_FAILURE_INLINE(env, WASM_CALL_IMPORT0(f1));
- EXPECT_FAILURE_INLINE(env, WASM_CALL_IMPORT(f1, WASM_I8(16)));
- EXPECT_FAILURE_INLINE(env, WASM_CALL_IMPORT(f1, WASM_I64(16)));
- EXPECT_FAILURE_INLINE(env, WASM_CALL_IMPORT(f1, WASM_F32(17.6)));
-}
TEST_F(WasmDecoderTest, Int32Globals) {
FunctionEnv* env = &env_i_i;
@@ -1589,22 +1575,28 @@
}
+// TODO(tizer): Fix on arm and reenable.
+#if !V8_TARGET_ARCH_ARM && !V8_TARGET_ARCH_ARM64
+
TEST_F(WasmDecoderTest, BreaksWithMultipleTypes) {
EXPECT_FAILURE_INLINE(
- &env_i_i, WASM_BLOCK(2, WASM_BRV_IF_ZERO(0, WASM_I8(7)), WASM_F32(7.7)));
-
+ &env_i_i,
+ WASM_BLOCK(2, WASM_BRV_IF(0, WASM_ZERO, WASM_I8(7)), WASM_F32(7.7)));
EXPECT_FAILURE_INLINE(&env_i_i,
- WASM_BLOCK(2, WASM_BRV_IF_ZERO(0, WASM_I8(7)),
- WASM_BRV_IF_ZERO(0, WASM_F32(7.7))));
+ WASM_BLOCK(2, WASM_BRV_IF(0, WASM_ZERO, WASM_I8(7)),
+ WASM_BRV_IF(0, WASM_ZERO, WASM_F32(7.7))));
EXPECT_FAILURE_INLINE(&env_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(&env_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))));
+ WASM_BLOCK(3, WASM_BRV_IF(0, WASM_ZERO, WASM_I8(8)),
+ WASM_BRV_IF(0, WASM_ZERO, WASM_I8(0)),
+ WASM_BRV_IF(0, WASM_ZERO, WASM_F32(7.7))));
+ EXPECT_FAILURE_INLINE(&env_i_i,
+ WASM_BLOCK(3, WASM_BRV_IF(0, WASM_ZERO, WASM_I8(9)),
+ WASM_BRV_IF(0, WASM_ZERO, WASM_F32(7.7)),
+ WASM_BRV_IF(0, WASM_ZERO, WASM_I8(11))));
}
+#endif
+
TEST_F(WasmDecoderTest, BreakNesting_6_levels) {
for (int mask = 0; mask < 64; mask++) {
@@ -1638,6 +1630,9 @@
}
+// TODO(tizer): Fix on arm and reenable.
+#if !V8_TARGET_ARCH_ARM && !V8_TARGET_ARCH_ARM64
+
TEST_F(WasmDecoderTest, ExprBreak_TypeCheck) {
FunctionEnv* envs[] = {&env_i_i, &env_l_l, &env_f_ff, &env_d_dd};
for (size_t i = 0; i < arraysize(envs); i++) {
@@ -1660,14 +1655,17 @@
WASM_F64(1.2)));
}
+#endif
+
TEST_F(WasmDecoderTest, 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[] = {WASM_BLOCK(
+ 2, WASM_IF(WASM_ZERO, WASM_BRV_IF(0, WASM_ZERO, 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++) {
@@ -1717,42 +1715,37 @@
}
}
-TEST_F(WasmDecoderTest, ExprBrIf_cond_type) {
+
+TEST_F(WasmDecoderTest, ExprBrIf_type) {
+ EXPECT_VERIFIES_INLINE(
+ &env_i_i,
+ WASM_BLOCK(2, WASM_BRV_IF(0, WASM_GET_LOCAL(0), WASM_GET_LOCAL(0)),
+ WASM_GET_LOCAL(0)));
+ EXPECT_FAILURE_INLINE(
+ &env_d_dd,
+ WASM_BLOCK(2, WASM_BRV_IF(0, WASM_GET_LOCAL(0), WASM_GET_LOCAL(0)),
+ WASM_GET_LOCAL(0)));
+
FunctionEnv env;
- byte code[] = {
- WASM_BLOCK(1, 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]};
- FunctionSig sig(0, 2, types);
- init_env(&env, &sig);
+ LocalType type = kLocalTypes[i];
+ LocalType storage[] = {kAstI32, kAstI32, type};
+ FunctionSig sig(1, 2, storage);
+ init_env(&env, &sig); // (i32, X) -> i32
- if (types[1] == kAstI32) {
- EXPECT_VERIFIES(&env, code);
- } else {
- EXPECT_FAILURE(&env, code);
- }
- }
- }
-}
+ byte code1[] = {
+ WASM_BLOCK(2, WASM_BRV_IF(0, WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)),
+ WASM_GET_LOCAL(0))};
-TEST_F(WasmDecoderTest, ExprBrIf_val_type) {
- FunctionEnv env;
- byte code[] = {
- WASM_BLOCK(2, 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],
- kAstI32};
- FunctionSig sig(1, 3, types);
- init_env(&env, &sig);
-
- if (i == j) {
- EXPECT_VERIFIES(&env, code);
- } else {
- EXPECT_FAILURE(&env, code);
- }
+ byte code2[] = {
+ WASM_BLOCK(2, WASM_BRV_IF(0, WASM_GET_LOCAL(1), WASM_GET_LOCAL(0)),
+ WASM_GET_LOCAL(0))};
+ if (type == kAstI32) {
+ EXPECT_VERIFIES(&env, code1);
+ EXPECT_VERIFIES(&env, code2);
+ } else {
+ EXPECT_FAILURE(&env, code1);
+ EXPECT_FAILURE(&env, code2);
}
}
}
@@ -1768,10 +1761,13 @@
FunctionSig sig(1, 2, storage);
init_env(&env, &sig); // (i32, X) -> i32
- byte code1[] = {WASM_BLOCK(2, 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))};
+ byte code1[] = {
+ WASM_BLOCK(2, WASM_BRV_IF(0, WASM_ZERO, WASM_GET_LOCAL(which)),
+ WASM_GET_LOCAL(which ^ 1))};
+ byte code2[] = {
+ WASM_LOOP(2, WASM_BRV_IF(1, WASM_ZERO, WASM_GET_LOCAL(which)),
+ WASM_GET_LOCAL(which ^ 1))};
+
if (type == kAstI32) {
EXPECT_VERIFIES(&env, code1);
@@ -1804,12 +1800,6 @@
EXPECT_VERIFIES(&env_v_v, code);
}
-TEST_F(WasmDecoderTest, TableSwitch0d) {
- static byte code[] = {
- WASM_BLOCK(1, WASM_TABLESWITCH_OP(0, 2, WASM_CASE_BR(0), WASM_CASE_BR(1)),
- WASM_I8(67))};
- EXPECT_VERIFIES(&env_v_v, code);
-}
TEST_F(WasmDecoderTest, TableSwitch1) {
static byte code[] = {WASM_TABLESWITCH_OP(1, 1, WASM_CASE(0)),
@@ -1841,6 +1831,9 @@
}
+// TODO(tizer): Fix on arm and reenable.
+#if !V8_TARGET_ARCH_ARM && !V8_TARGET_ARCH_ARM64
+
TEST_F(WasmDecoderTest, TableSwitch1b) {
EXPECT_VERIFIES_INLINE(&env_i_i, WASM_TABLESWITCH_OP(1, 1, WASM_CASE(0)),
WASM_TABLESWITCH_BODY(WASM_GET_LOCAL(0), WASM_ZERO));
@@ -1852,25 +1845,29 @@
WASM_TABLESWITCH_BODY(WASM_ZERO, WASM_F64(0.0)));
}
-TEST_F(WasmDecoderTest, TableSwitch_br1) {
+#endif
+
+
+TEST_F(WasmDecoderTest, TableSwitch_br) {
+ EXPECT_VERIFIES_INLINE(&env_i_i, WASM_TABLESWITCH_OP(0, 1, WASM_CASE_BR(0)),
+ WASM_GET_LOCAL(0));
for (int depth = 0; depth < 2; depth++) {
- byte code[] = {WASM_BLOCK(1, WASM_TABLESWITCH_OP(0, 1, WASM_CASE_BR(depth)),
- WASM_GET_LOCAL(0))};
- EXPECT_VERIFIES(&env_v_i, code);
- EXPECT_FAILURE(&env_i_i, code);
+ EXPECT_VERIFIES_INLINE(
+ &env_i_i, WASM_BLOCK(1, WASM_TABLESWITCH_OP(0, 1, WASM_CASE_BR(depth)),
+ WASM_GET_LOCAL(0)));
}
}
TEST_F(WasmDecoderTest, TableSwitch_invalid_br) {
for (int depth = 1; depth < 4; depth++) {
- EXPECT_FAILURE_INLINE(&env_v_i,
+ EXPECT_FAILURE_INLINE(&env_i_i,
WASM_TABLESWITCH_OP(0, 1, WASM_CASE_BR(depth)),
WASM_GET_LOCAL(0));
EXPECT_FAILURE_INLINE(
- &env_v_i,
- WASM_TABLESWITCH_OP(0, 2, WASM_CASE_BR(depth), WASM_CASE_BR(depth)),
- WASM_GET_LOCAL(0));
+ &env_i_i,
+ WASM_BLOCK(1, WASM_TABLESWITCH_OP(0, 1, WASM_CASE_BR(depth + 1)),
+ WASM_GET_LOCAL(0)));
}
}
@@ -1883,12 +1880,17 @@
}
+// TODO(tizer): Fix on arm and reenable.
+#if !V8_TARGET_ARCH_ARM && !V8_TARGET_ARCH_ARM64
+
TEST_F(WasmDecoderTest, TableSwitch1_br) {
EXPECT_VERIFIES_INLINE(
&env_i_i, WASM_TABLESWITCH_OP(1, 1, WASM_CASE(0)),
WASM_TABLESWITCH_BODY(WASM_GET_LOCAL(0), WASM_BRV(0, WASM_ZERO)));
}
+#endif
+
TEST_F(WasmDecoderTest, TableSwitch2_br) {
EXPECT_VERIFIES_INLINE(
@@ -1912,6 +1914,9 @@
}
+// TODO(tizer): Fix on arm and reenable.
+#if !V8_TARGET_ARCH_ARM && !V8_TARGET_ARCH_ARM64
+
TEST_F(WasmDecoderTest, ExprBreakNesting1) {
EXPECT_VERIFIES_INLINE(&env_v_v, WASM_BLOCK(1, WASM_BRV(0, WASM_ZERO)));
EXPECT_VERIFIES_INLINE(&env_v_v, WASM_BLOCK(1, WASM_BR(0)));
@@ -1929,56 +1934,18 @@
EXPECT_VERIFIES_INLINE(&env_v_v, WASM_LOOP(1, WASM_BR(1)));
}
+#endif
+
TEST_F(WasmDecoderTest, Select) {
EXPECT_VERIFIES_INLINE(
- &env_i_i, WASM_SELECT(WASM_GET_LOCAL(0), WASM_GET_LOCAL(0), WASM_ZERO));
- EXPECT_VERIFIES_INLINE(&env_f_ff,
- WASM_SELECT(WASM_F32(0.0), WASM_F32(0.0), WASM_ZERO));
- EXPECT_VERIFIES_INLINE(&env_d_dd,
- WASM_SELECT(WASM_F64(0.0), WASM_F64(0.0), WASM_ZERO));
- EXPECT_VERIFIES_INLINE(&env_l_l,
- WASM_SELECT(WASM_I64(0), WASM_I64(0), WASM_ZERO));
-}
-
-TEST_F(WasmDecoderTest, Select_fail1) {
- EXPECT_FAILURE_INLINE(&env_i_i, WASM_SELECT(WASM_F32(0.0), WASM_GET_LOCAL(0),
- WASM_GET_LOCAL(0)));
- EXPECT_FAILURE_INLINE(&env_i_i, WASM_SELECT(WASM_GET_LOCAL(0), WASM_F32(0.0),
- WASM_GET_LOCAL(0)));
- EXPECT_FAILURE_INLINE(
&env_i_i,
- WASM_SELECT(WASM_GET_LOCAL(0), WASM_GET_LOCAL(0), WASM_F32(0.0)));
+ WASM_SELECT(WASM_GET_LOCAL(0), WASM_GET_LOCAL(0), WASM_GET_LOCAL(0)));
}
-TEST_F(WasmDecoderTest, Select_fail2) {
- for (size_t i = 0; i < arraysize(kLocalTypes); i++) {
- LocalType type = kLocalTypes[i];
- if (type == kAstI32) continue;
- LocalType types[] = {type, kAstI32, type};
- FunctionSig sig(1, 2, types);
- FunctionEnv env;
- init_env(&env, &sig);
-
- EXPECT_VERIFIES_INLINE(
- &env,
- WASM_SELECT(WASM_GET_LOCAL(1), WASM_GET_LOCAL(1), WASM_GET_LOCAL(0)));
-
- EXPECT_FAILURE_INLINE(
- &env,
- WASM_SELECT(WASM_GET_LOCAL(1), WASM_GET_LOCAL(0), WASM_GET_LOCAL(0)));
-
- EXPECT_FAILURE_INLINE(
- &env,
- WASM_SELECT(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1), WASM_GET_LOCAL(0)));
-
- EXPECT_FAILURE_INLINE(
- &env,
- WASM_SELECT(WASM_GET_LOCAL(0), WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
- }
-}
-
+// TODO(tizer): Fix on arm and reenable.
+#if !V8_TARGET_ARCH_ARM && !V8_TARGET_ARCH_ARM64
TEST_F(WasmDecoderTest, Select_TypeCheck) {
EXPECT_FAILURE_INLINE(&env_i_i, WASM_SELECT(WASM_F32(9.9), WASM_GET_LOCAL(0),
@@ -1991,18 +1958,22 @@
&env_i_i, WASM_SELECT(WASM_F32(9.9), WASM_GET_LOCAL(0), WASM_I64(0)));
}
+#endif
+
class WasmOpcodeLengthTest : public TestWithZone {
public:
WasmOpcodeLengthTest() : TestWithZone() {}
};
-#define EXPECT_LENGTH(expected, opcode) \
- { \
- static const byte code[] = {opcode, 0, 0, 0, 0, 0, 0, 0, 0}; \
- EXPECT_EQ(expected, OpcodeLength(code, code + sizeof(code))); \
+
+#define EXPECT_LENGTH(expected, opcode) \
+ { \
+ static const byte code[] = {opcode, 0, 0, 0, 0, 0, 0, 0, 0}; \
+ EXPECT_EQ(expected, OpcodeLength(code)); \
}
+
TEST_F(WasmOpcodeLengthTest, Statements) {
EXPECT_LENGTH(1, kExprNop);
EXPECT_LENGTH(2, kExprBlock);
@@ -2026,7 +1997,6 @@
EXPECT_LENGTH(2, kExprLoadGlobal);
EXPECT_LENGTH(2, kExprStoreGlobal);
EXPECT_LENGTH(2, kExprCallFunction);
- EXPECT_LENGTH(2, kExprCallImport);
EXPECT_LENGTH(2, kExprCallIndirect);
EXPECT_LENGTH(1, kExprIf);
EXPECT_LENGTH(1, kExprIfElse);
@@ -2044,11 +2014,11 @@
byte size5[] = {kExprLoadGlobal, 1 | 0x80, 2 | 0x80, 3 | 0x80, 4};
byte size6[] = {kExprLoadGlobal, 1 | 0x80, 2 | 0x80, 3 | 0x80, 4 | 0x80, 5};
- EXPECT_EQ(2, OpcodeLength(size2, size2 + sizeof(size2)));
- EXPECT_EQ(3, OpcodeLength(size3, size3 + sizeof(size3)));
- EXPECT_EQ(4, OpcodeLength(size4, size4 + sizeof(size4)));
- EXPECT_EQ(5, OpcodeLength(size5, size5 + sizeof(size5)));
- EXPECT_EQ(6, OpcodeLength(size6, size6 + sizeof(size6)));
+ EXPECT_EQ(2, OpcodeLength(size2));
+ EXPECT_EQ(3, OpcodeLength(size3));
+ EXPECT_EQ(4, OpcodeLength(size4));
+ EXPECT_EQ(5, OpcodeLength(size5));
+ EXPECT_EQ(6, OpcodeLength(size6));
}
@@ -2213,12 +2183,14 @@
WasmOpcodeArityTest() : TestWithZone() {}
};
-#define EXPECT_ARITY(expected, ...) \
- { \
- static const byte code[] = {__VA_ARGS__}; \
- EXPECT_EQ(expected, OpcodeArity(&env, code, code + sizeof(code))); \
+
+#define EXPECT_ARITY(expected, ...) \
+ { \
+ static const byte code[] = {__VA_ARGS__}; \
+ EXPECT_EQ(expected, OpcodeArity(&env, code)); \
}
+
TEST_F(WasmOpcodeArityTest, Control) {
FunctionEnv env;
EXPECT_ARITY(0, kExprNop);
@@ -2277,16 +2249,12 @@
module.AddSignature(sigs.f_ff());
module.AddSignature(sigs.i_d());
- module.AddImport(sigs.f_ff());
- module.AddImport(sigs.i_d());
-
{
FunctionEnv env;
WasmDecoderTest::init_env(&env, sigs.i_ii());
env.module = &module;
EXPECT_ARITY(2, kExprCallFunction, 0);
- EXPECT_ARITY(2, kExprCallImport, 0);
EXPECT_ARITY(3, kExprCallIndirect, 0);
EXPECT_ARITY(1, kExprBr);
EXPECT_ARITY(2, kExprBrIf);
@@ -2298,7 +2266,6 @@
env.module = &module;
EXPECT_ARITY(1, kExprCallFunction, 1);
- EXPECT_ARITY(1, kExprCallImport, 1);
EXPECT_ARITY(2, kExprCallIndirect, 1);
EXPECT_ARITY(1, kExprBr);
EXPECT_ARITY(2, kExprBrIf);