[wasm] Implement polymorphic checking, matching the reference interpreter.

test/unittests/wasm/function-body-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 555 matching lines @@
 }
 
 TEST_F(FunctionBodyDecoderTest, Block1_br) {
   EXPECT_VERIFIES(v_v, B1(WASM_BR(0)));
   EXPECT_VERIFIES(v_v, B1(WASM_BR(1)));
   EXPECT_FAILURE(v_v, B1(WASM_BR(2)));
 }
 
 TEST_F(FunctionBodyDecoderTest, Block2_br) {
   EXPECT_VERIFIES(v_v, B2(WASM_NOP, WASM_BR(0)));
-  EXPECT_VERIFIES(v_v, B2(WASM_BR(0), WASM_NOP));
-  EXPECT_VERIFIES(v_v, B2(WASM_BR(0), WASM_BR(0)));
+  //  EXPECT_VERIFIES(v_v, B2(WASM_BR(0), WASM_NOP));

[rossberg, 2017/02/02 13:01:27]

What's with these?

[titzer, 2017/02/02 18:50:19]

Done.

+  //  EXPECT_VERIFIES(v_v, B2(WASM_BR(0), WASM_BR(0)));
 }
 
 TEST_F(FunctionBodyDecoderTest, Block2) {
   EXPECT_FAILURE(i_i, WASM_BLOCK(WASM_NOP, WASM_NOP));
   EXPECT_FAILURE(i_i, WASM_BLOCK_I(WASM_NOP, WASM_NOP));
   EXPECT_VERIFIES(i_i, WASM_BLOCK_I(WASM_NOP, WASM_ZERO));
   EXPECT_VERIFIES(i_i, WASM_BLOCK_I(WASM_ZERO, WASM_NOP));
   EXPECT_FAILURE(i_i, WASM_BLOCK_I(WASM_ZERO, WASM_ZERO));
 }
 
@@ skipping 76 matching lines @@
 }
 
 TEST_F(FunctionBodyDecoderTest, Block3_continue) {
   EXPECT_VERIFIES(v_v, B1(WASM_LOOP(WASM_NOP, WASM_BR(0))));
   EXPECT_VERIFIES(v_v, B1(WASM_LOOP(WASM_NOP, WASM_BR(1))));
   EXPECT_VERIFIES(v_v, B1(WASM_LOOP(WASM_NOP, WASM_BR(2))));
   EXPECT_FAILURE(v_v, B1(WASM_LOOP(WASM_NOP, WASM_BR(3))));
 }
 
 TEST_F(FunctionBodyDecoderTest, NestedBlock_return) {
-  EXPECT_VERIFIES(i_i, B1(B1(WASM_RETURN1(WASM_ZERO))));
+  EXPECT_VERIFIES(i_i, B1(B1(WASM_RETURN1(WASM_ZERO))), WASM_ZERO);
 }
 
 TEST_F(FunctionBodyDecoderTest, BlockBrBinop) {
   EXPECT_VERIFIES(i_i, WASM_I32_AND(WASM_BLOCK_I(WASM_BRV(0, WASM_I32V_1(1))),
                                     WASM_I32V_1(2)));
 }
 
 TEST_F(FunctionBodyDecoderTest, If_empty1) {
   EXPECT_VERIFIES(v_v, WASM_ZERO, WASM_IF_OP, kExprEnd);
 }
@@ skipping 46 matching lines @@
   EXPECT_VERIFIES(v_i, WASM_IF_ELSE(WASM_GET_LOCAL(0),
                                     WASM_SET_LOCAL(0, WASM_ZERO), WASM_NOP));
 }
 
 TEST_F(FunctionBodyDecoderTest, IfElseEmpty) {
   EXPECT_VERIFIES(v_i, WASM_GET_LOCAL(0), WASM_IF_OP, kExprElse, kExprEnd);
   EXPECT_VERIFIES(v_i, WASM_IF_ELSE(WASM_GET_LOCAL(0), WASM_NOP, WASM_NOP));
 }
 
 TEST_F(FunctionBodyDecoderTest, IfElseUnreachable1) {
-  EXPECT_VERIFIES(i_i, WASM_IF_ELSE_I(WASM_GET_LOCAL(0), WASM_UNREACHABLE,
-                                      WASM_GET_LOCAL(0)));
+  //  EXPECT_VERIFIES(i_i, WASM_IF_ELSE_I(WASM_GET_LOCAL(0), WASM_UNREACHABLE,

[rossberg, 2017/02/02 13:01:27]

And these?

[titzer, 2017/02/02 18:50:19]

Done.

+  //                                      WASM_GET_LOCAL(0)));
   EXPECT_VERIFIES(i_i, WASM_IF_ELSE_I(WASM_GET_LOCAL(0), WASM_GET_LOCAL(0),
                                       WASM_UNREACHABLE));
 }
 
 TEST_F(FunctionBodyDecoderTest, IfElseUnreachable2) {
   static const byte code[] = {
       WASM_IF_ELSE_I(WASM_GET_LOCAL(0), WASM_UNREACHABLE, WASM_GET_LOCAL(0))};
 
   for (size_t i = 0; i < arraysize(kValueTypes); i++) {
     ValueType types[] = {kWasmI32, kValueTypes[i]};
@@ skipping 101 matching lines @@
 }
 
 TEST_F(FunctionBodyDecoderTest, Loop2_continue) {
   EXPECT_VERIFIES(v_i, WASM_LOOP(WASM_SET_LOCAL(0, WASM_ZERO), WASM_BR(0)));
 }
 
 TEST_F(FunctionBodyDecoderTest, Loop2_break) {
   EXPECT_VERIFIES(v_i, WASM_LOOP(WASM_SET_LOCAL(0, WASM_ZERO), WASM_BR(1)));
 }
 
-TEST_F(FunctionBodyDecoderTest, InfiniteLoop) {
-  EXPECT_VERIFIES(i_i, WASM_LOOP(WASM_BR(0)));
-  EXPECT_VERIFIES(i_i, WASM_LOOP(WASM_BRV(1, WASM_ZERO)));
+TEST_F(FunctionBodyDecoderTest, InfiniteLoop1) {
+  EXPECT_VERIFIES(i_i, WASM_LOOP(WASM_BR(0)), WASM_ZERO);
+  EXPECT_VERIFIES(i_i, WASM_LOOP(WASM_BR(0)), WASM_ZERO);
+  EXPECT_VERIFIES(i_i, WASM_LOOP_I(WASM_BRV(1, WASM_ZERO)));
+}
+
+TEST_F(FunctionBodyDecoderTest, InfiniteLoop2) {
+  EXPECT_FAILURE(i_i, WASM_LOOP(WASM_BR(0), WASM_ZERO), WASM_ZERO);
 }
 
 TEST_F(FunctionBodyDecoderTest, Loop2_unreachable) {
-  EXPECT_VERIFIES(i_i, WASM_LOOP(WASM_BR(0), WASM_NOP));
+  EXPECT_VERIFIES(i_i, WASM_LOOP_I(WASM_BR(0), WASM_NOP));
 }
 
 TEST_F(FunctionBodyDecoderTest, LoopType) {
   EXPECT_VERIFIES(i_i, WASM_LOOP_I(WASM_GET_LOCAL(0)));
   EXPECT_VERIFIES(l_l, WASM_LOOP_L(WASM_GET_LOCAL(0)));
   EXPECT_VERIFIES(f_f, WASM_LOOP_F(WASM_GET_LOCAL(0)));
   EXPECT_VERIFIES(d_d, WASM_LOOP_D(WASM_GET_LOCAL(0)));
 }
 
 TEST_F(FunctionBodyDecoderTest, LoopType_void) {
@@ skipping 38 matching lines @@
 TEST_F(FunctionBodyDecoderTest, ReturnVoid3) {
   EXPECT_FAILURE(v_v, kExprI32Const, 0);
   EXPECT_FAILURE(v_v, kExprI64Const, 0);
   EXPECT_FAILURE(v_v, kExprF32Const, 0, 0, 0, 0);
   EXPECT_FAILURE(v_v, kExprF64Const, 0, 0, 0, 0, 0, 0, 0, 0);
 
   EXPECT_FAILURE(v_i, kExprGetLocal, 0);
 }
 
 TEST_F(FunctionBodyDecoderTest, Unreachable1) {
-  EXPECT_VERIFIES(v_v, kExprUnreachable);
-  EXPECT_VERIFIES(v_v, kExprUnreachable, kExprUnreachable);
-  EXPECT_VERIFIES(v_v, B2(WASM_UNREACHABLE, WASM_ZERO));
-  EXPECT_VERIFIES(v_v, B2(WASM_BR(0), WASM_ZERO));
-  EXPECT_VERIFIES(v_v, WASM_LOOP(WASM_UNREACHABLE, WASM_ZERO));
-  EXPECT_VERIFIES(v_v, WASM_LOOP(WASM_BR(0), WASM_ZERO));
+  EXPECT_VERIFIES(v_v, WASM_UNREACHABLE);
+  EXPECT_VERIFIES(v_v, WASM_UNREACHABLE, WASM_UNREACHABLE);
+  EXPECT_VERIFIES(i_i, WASM_UNREACHABLE, WASM_ZERO);
 }
 
-TEST_F(FunctionBodyDecoderTest, Unreachable_binop) {
+TEST_F(FunctionBodyDecoderTest, Unreachable2) {
+  EXPECT_FAILURE(v_v, B2(WASM_UNREACHABLE, WASM_ZERO));
+  EXPECT_FAILURE(v_v, B2(WASM_BR(0), WASM_ZERO));
+}
+
+TEST_F(FunctionBodyDecoderTest, UnreachableLoop1) {
+  EXPECT_FAILURE(v_v, WASM_LOOP(WASM_UNREACHABLE, WASM_ZERO));
+  EXPECT_FAILURE(v_v, WASM_LOOP(WASM_BR(0), WASM_ZERO));
+  EXPECT_VERIFIES(v_v, WASM_LOOP(WASM_UNREACHABLE, WASM_NOP));
+  EXPECT_VERIFIES(v_v, WASM_LOOP(WASM_BR(0), WASM_NOP));
+}
+
+TEST_F(FunctionBodyDecoderTest, Unreachable_binop1) {
   EXPECT_VERIFIES(i_i, WASM_I32_AND(WASM_ZERO, WASM_UNREACHABLE));
   EXPECT_VERIFIES(i_i, WASM_I32_AND(WASM_UNREACHABLE, WASM_ZERO));
 }
 
-TEST_F(FunctionBodyDecoderTest, Unreachable_select) {
+TEST_F(FunctionBodyDecoderTest, Unreachable_binop2) {
+  EXPECT_VERIFIES(i_i, WASM_I32_AND(WASM_F32(0.0), WASM_UNREACHABLE));
+  EXPECT_FAILURE(i_i, WASM_I32_AND(WASM_UNREACHABLE, WASM_F32(0.0)));
+}
+
+TEST_F(FunctionBodyDecoderTest, Unreachable_select1) {
   EXPECT_VERIFIES(i_i, WASM_SELECT(WASM_UNREACHABLE, WASM_ZERO, WASM_ZERO));
   EXPECT_VERIFIES(i_i, WASM_SELECT(WASM_ZERO, WASM_UNREACHABLE, WASM_ZERO));
   EXPECT_VERIFIES(i_i, WASM_SELECT(WASM_ZERO, WASM_ZERO, WASM_UNREACHABLE));
 }
 
+TEST_F(FunctionBodyDecoderTest, Unreachable_select2) {
+  EXPECT_VERIFIES(i_i, WASM_SELECT(WASM_F32(0.0), WASM_UNREACHABLE, WASM_ZERO));
+  EXPECT_FAILURE(i_i, WASM_SELECT(WASM_UNREACHABLE, WASM_F32(0.0), WASM_ZERO));
+  EXPECT_FAILURE(i_i, WASM_SELECT(WASM_UNREACHABLE, WASM_ZERO, WASM_F32(0.0)));
+}
+
 TEST_F(FunctionBodyDecoderTest, If1) {
   EXPECT_VERIFIES(
       i_i, WASM_IF_ELSE_I(WASM_GET_LOCAL(0), WASM_I32V_1(9), WASM_I32V_1(8)));
   EXPECT_VERIFIES(i_i, WASM_IF_ELSE_I(WASM_GET_LOCAL(0), WASM_I32V_1(9),
                                       WASM_GET_LOCAL(0)));
   EXPECT_VERIFIES(i_i, WASM_IF_ELSE_I(WASM_GET_LOCAL(0), WASM_GET_LOCAL(0),
                                       WASM_I32V_1(8)));
 }
 
 TEST_F(FunctionBodyDecoderTest, If_off_end) {
@@ skipping 843 matching lines @@
     TestModuleEnv module_env;
     module = &module_env;
     module_env.InitializeMemory();
     for (size_t i = 0; i < arraysize(AsmJsUnOps); i++) {
       byte code[] = {WASM_UNOP(AsmJsUnOps[i].op, WASM_GET_LOCAL(0))};
       EXPECT_FAILURE_SC(AsmJsUnOps[i].sig, code);
     }
   }
 }
 
-TEST_F(FunctionBodyDecoderTest, BreakEnd) {
-  EXPECT_VERIFIES(
-      i_i, WASM_BLOCK_I(WASM_I32_ADD(WASM_BRV(0, WASM_ZERO), WASM_ZERO)));
-  EXPECT_VERIFIES(
-      i_i, WASM_BLOCK_I(WASM_I32_ADD(WASM_ZERO, WASM_BRV(0, WASM_ZERO))));
-}
+// TEST_F(FunctionBodyDecoderTest, BreakEnd) {

[rossberg, 2017/02/02 13:01:27]

And this?

[titzer, 2017/02/02 18:50:19]

Done.

+//  EXPECT_VERIFIES(
+//      i_i, WASM_BLOCK_I(WASM_I32_ADD(WASM_BRV(0, WASM_ZERO), WASM_ZERO)));
+//  EXPECT_VERIFIES(
+//      i_i, WASM_BLOCK_I(WASM_I32_ADD(WASM_ZERO, WASM_BRV(0, WASM_ZERO))));
+//}
 
 TEST_F(FunctionBodyDecoderTest, BreakIfBinop) {
   EXPECT_VERIFIES(i_i, WASM_BLOCK_I(WASM_I32_ADD(
                            WASM_BRV_IF(0, WASM_ZERO, WASM_ZERO), WASM_ZERO)));
   EXPECT_VERIFIES(i_i, WASM_BLOCK_I(WASM_I32_ADD(
                            WASM_ZERO, WASM_BRV_IF(0, WASM_ZERO, WASM_ZERO))));
   EXPECT_VERIFIES_S(
       sigs.f_ff(),
       WASM_BLOCK_F(WASM_F32_ABS(WASM_BRV_IF(0, WASM_F32(0.0f), WASM_ZERO))));
 }
@@ skipping 299 matching lines @@
     byte code[] = {
         WASM_LOOP(WASM_BR_TABLE(WASM_GET_LOCAL(0), 0, BR_TARGET(depth)))};
     if (depth < 2) {
       EXPECT_VERIFIES_C(v_i, code);
     } else {
       EXPECT_FAILURE_C(v_i, code);
     }
   }
 }
 
-TEST_F(FunctionBodyDecoderTest, BrUnreachable) {
-  static byte code[] = {WASM_GET_LOCAL(0), kExprBrTable,  0,
-                        BR_TARGET(0),      kExprSetLocal, 0};
-  EXPECT_VERIFIES_C(v_i, code);
+TEST_F(FunctionBodyDecoderTest, BrUnreachable1) {
+  EXPECT_VERIFIES(v_i, WASM_GET_LOCAL(0), kExprBrTable, 0, BR_TARGET(0));
+}
+
+TEST_F(FunctionBodyDecoderTest, BrUnreachable2) {
+  EXPECT_VERIFIES(v_i, WASM_GET_LOCAL(0), kExprBrTable, 0, BR_TARGET(0),
+                  WASM_NOP);
+  EXPECT_FAILURE(v_i, WASM_GET_LOCAL(0), kExprBrTable, 0, BR_TARGET(0),
+                 WASM_ZERO);
 }
 
 TEST_F(FunctionBodyDecoderTest, Brv1) {
   EXPECT_VERIFIES(i_i, WASM_BLOCK_I(WASM_BRV(0, WASM_ZERO)));
-  EXPECT_VERIFIES(i_i, WASM_BLOCK_I(WASM_LOOP(WASM_BRV(2, WASM_ZERO))));
+  EXPECT_VERIFIES(i_i, WASM_BLOCK_I(WASM_LOOP_I(WASM_BRV(2, WASM_ZERO))));
 }
 
 TEST_F(FunctionBodyDecoderTest, Brv1_type) {
   EXPECT_VERIFIES(i_ii, WASM_BLOCK_I(WASM_BRV(0, WASM_GET_LOCAL(0))));
   EXPECT_VERIFIES(l_ll, WASM_BLOCK_L(WASM_BRV(0, WASM_GET_LOCAL(0))));
   EXPECT_VERIFIES(f_ff, WASM_BLOCK_F(WASM_BRV(0, WASM_GET_LOCAL(0))));
   EXPECT_VERIFIES(d_dd, WASM_BLOCK_D(WASM_BRV(0, WASM_GET_LOCAL(0))));
 }
 
 TEST_F(FunctionBodyDecoderTest, Brv1_type_n) {
@@ skipping 622 matching lines @@
   iter.next();
   EXPECT_TRUE(iter.has_next());
   EXPECT_EQ(kExprI32Const, iter.current());
   iter.next();
   EXPECT_FALSE(iter.has_next());
 }
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8