[WASM] Exception handling prototype.

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/cctest/wasm/test-signatures.h"
 
@@ skipping 1811 matching lines @@
 
   EXPECT_FAILURE_INLINE(
       sigs.i_i(),
       WASM_SELECT(WASM_GET_LOCAL(0), WASM_F64(0.25), WASM_GET_LOCAL(0)));
 
   EXPECT_FAILURE_INLINE(
       sigs.i_i(),
       WASM_SELECT(WASM_F32(9.9), WASM_GET_LOCAL(0), WASM_I64V_1(0)));
 }
 
+TEST_F(AstDecoderTest, Throw) {
+  FLAG_wasm_eh_prototype = true;
+  EXPECT_VERIFIES_INLINE(sigs.v_i(), WASM_GET_LOCAL(0), kExprThrow);
+
+  // TODO(jpp): can't throw d, f, or l.

[bradnelson, 2016/08/11 00:39:29]

Wait just to clarify.
You're asserting the current behavior, but the intention is to restrict to
int32?

[John, 2016/08/11 11:22:27]

Yes. I am testing the (current) implementation, leaving the TODO behind so that
once the implementation is finished I'll remember why these tests are failing.

+  EXPECT_VERIFIES_INLINE(sigs.i_d(), WASM_GET_LOCAL(0), kExprThrow,
+                         WASM_I32V(0));
+  EXPECT_VERIFIES_INLINE(sigs.i_f(), WASM_GET_LOCAL(0), kExprThrow,
+                         WASM_I32V(0));
+  EXPECT_VERIFIES_INLINE(sigs.l_l(), WASM_GET_LOCAL(0), kExprThrow,
+                         WASM_I64V(0));
+}
+
+#define WASM_CATCH(local) kExprCatch, static_cast<byte>(local)
+TEST_F(AstDecoderTest, TryCatch) {
+  FLAG_wasm_eh_prototype = true;
+  EXPECT_VERIFIES_INLINE(sigs.v_i(), kExprTryCatch, WASM_CATCH(0), kExprEnd);
+
+  // Missing catch.
+  EXPECT_FAILURE_INLINE(sigs.v_v(), kExprTryCatch, kExprEnd);
+
+  // Missing end.
+  EXPECT_FAILURE_INLINE(sigs.v_i(), kExprTryCatch, WASM_CATCH(0));
+
+  // Double catch.
+  EXPECT_FAILURE_INLINE(sigs.v_i(), kExprTryCatch, WASM_CATCH(0), WASM_CATCH(0),
+                        kExprEnd);
+
+  // Unexpected finally.
+  EXPECT_FAILURE_INLINE(sigs.v_i(), kExprTryCatch, WASM_CATCH(0), kExprFinally,
+                        kExprEnd);
+}
+
+TEST_F(AstDecoderTest, TryFinally) {
+  FLAG_wasm_eh_prototype = true;
+  EXPECT_VERIFIES_INLINE(sigs.v_v(), kExprTryFinally, kExprFinally, kExprEnd);
+
+  // Mising finally.
+  EXPECT_FAILURE_INLINE(sigs.v_v(), kExprTryFinally, kExprEnd);
+
+  // Missing end.
+  EXPECT_FAILURE_INLINE(sigs.v_v(), kExprTryFinally, kExprFinally);
+
+  // Double finally.
+  EXPECT_FAILURE_INLINE(sigs.v_v(), kExprTryFinally, kExprFinally, kExprFinally,
+                        kExprEnd);
+
+  // Unexpected catch.
+  EXPECT_FAILURE_INLINE(sigs.v_i(), kExprTryCatch, WASM_CATCH(0), kExprFinally,
+                        kExprEnd);
+}
+
+TEST_F(AstDecoderTest, TryCatchFinally) {
+  FLAG_wasm_eh_prototype = true;
+  EXPECT_VERIFIES_INLINE(sigs.v_i(), kExprTryCatchFinally, WASM_CATCH(0),
+                         kExprFinally, kExprEnd);
+
+  // Missing catch.
+  EXPECT_FAILURE_INLINE(sigs.v_i(), kExprTryCatchFinally, kExprFinally,
+                        kExprEnd);
+
+  // Double catch.
+  EXPECT_FAILURE_INLINE(sigs.v_i(), kExprTryCatchFinally, WASM_CATCH(0),
+                        WASM_CATCH(0), kExprFinally, kExprEnd);
+
+  // Missing finally.
+  EXPECT_FAILURE_INLINE(sigs.v_i(), kExprTryCatchFinally, WASM_CATCH(0),
+                        kExprEnd);
+
+  // Double finally.
+  EXPECT_FAILURE_INLINE(sigs.v_i(), kExprTryCatchFinally, WASM_CATCH(0),
+                        kExprFinally, kExprFinally, kExprEnd);
+
+  // Finally before catch.
+  EXPECT_FAILURE_INLINE(sigs.v_i(), kExprTryCatchFinally, kExprFinally,
+                        WASM_CATCH(0), kExprEnd);
+
+  // Missing both try and finally.
+  EXPECT_FAILURE_INLINE(sigs.v_i(), kExprTryCatchFinally, kExprEnd);
+
+  // Missing end.
+  EXPECT_FAILURE_INLINE(sigs.v_i(), kExprTryCatchFinally, WASM_CATCH(0),
+                        kExprFinally);
+}
+
 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_N(expected, ...)                            \
   {                                                               \
     static const byte code[] = {__VA_ARGS__};                     \
     EXPECT_EQ(expected, OpcodeLength(code, code + sizeof(code))); \
   }
 
 TEST_F(WasmOpcodeLengthTest, Statements) {
   EXPECT_LENGTH(1, kExprNop);
   EXPECT_LENGTH(1, kExprBlock);
   EXPECT_LENGTH(1, kExprLoop);
   EXPECT_LENGTH(1, kExprIf);
   EXPECT_LENGTH(1, kExprElse);
   EXPECT_LENGTH(1, kExprEnd);
   EXPECT_LENGTH(1, kExprSelect);
   EXPECT_LENGTH(3, kExprBr);
   EXPECT_LENGTH(3, kExprBrIf);
+  EXPECT_LENGTH(1, kExprThrow);
+  EXPECT_LENGTH(1, kExprTryCatch);
+  EXPECT_LENGTH(1, kExprTryFinally);
+  EXPECT_LENGTH(1, kExprTryCatchFinally);
+  EXPECT_LENGTH(2, kExprCatch);
+  EXPECT_LENGTH(1, kExprFinally);
 }
 
 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);
@@ skipping 221 matching lines @@
   EXPECT_ARITY(1, kExprBrTable);
 
   EXPECT_ARITY(1, kExprBr, ARITY_1);
   EXPECT_ARITY(2, kExprBrIf, ARITY_1);
   EXPECT_ARITY(2, kExprBrTable, ARITY_1);
 
   {
     EXPECT_ARITY(0, kExprReturn, ARITY_0);
     EXPECT_ARITY(1, kExprReturn, ARITY_1);
   }
+
+  EXPECT_ARITY(0, kExprThrow);
+  EXPECT_ARITY(0, kExprTryCatch);
+  EXPECT_ARITY(0, kExprTryFinally);
+  EXPECT_ARITY(0, kExprTryCatchFinally);
+  EXPECT_ARITY(1, kExprCatch, 2);
+  EXPECT_ARITY(0, kExprFinally);
 }
 
 TEST_F(WasmOpcodeArityTest, Misc) {
   EXPECT_ARITY(0, kExprI8Const);
   EXPECT_ARITY(0, kExprI32Const);
   EXPECT_ARITY(0, kExprF32Const);
   EXPECT_ARITY(0, kExprI64Const);
   EXPECT_ARITY(0, kExprF64Const);
   EXPECT_ARITY(0, kExprGetLocal);
   EXPECT_ARITY(1, kExprSetLocal);
@@ skipping 354 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