[wasm] Add a more exhaustive test for unreachable code validation.

test/mjsunit/wasm/unreachable-validation.js

Index: test/mjsunit/wasm/unreachable-validation.js
diff --git a/test/mjsunit/wasm/unreachable-validation.js b/test/mjsunit/wasm/unreachable-validation.js
new file mode 100644
index 0000000000000000000000000000000000000000..3e24cb56a5a4b6096a3b9bbaa5162ef6514fab28
--- /dev/null
+++ b/test/mjsunit/wasm/unreachable-validation.js
@@ -0,0 +1,88 @@
+// 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.
+
+// Flags: --expose-wasm
+
+load("test/mjsunit/wasm/wasm-constants.js");
+load("test/mjsunit/wasm/wasm-module-builder.js");
+
+// Set unittest to false to run this test and just print results, without failing.
+let unittest = true;
+
+function run(expected, name, code) {
+  let builder = new WasmModuleBuilder();
+  builder.addFunction("main", kSig_v_v).
+    addBody(code);
+  let buffer = builder.toBuffer();
+
+  while (name.length < 32) name += " ";
+
+  var valid = WebAssembly.validate(buffer);
+  var success = expected == undefined ? "" : (valid == expected ? "(pass)" : "(fail)");
+  if (valid) {
+    print(name + "|   valid " + success);
+  } else {
+    print(name + "| invalid " + success);
+  }
+
+  if (unittest && (expected !== undefined)) {
+    if (expected) assertTrue(valid);

[rossberg, 2017/01/19 08:14:29]

Nit: why not assertTrue(valid === expected) ?

+    else assertFalse(valid);
+  }
+}
+
+let V = true;
+let I = false;
+let X = undefined;
+
+let nop = kExprNop;
+let iadd = kExprI32Add;
+let unr = kExprUnreachable;
+let ret = kExprReturn;
+let br0 = [kExprBr, 0]
+let f32 = [kExprF32Const, 0, 0, 0, 0];
+let zero = [kExprI32Const, 0];
+let if_else_empty = [kExprIf, kWasmStmt, kExprElse, kExprEnd];
+let if_unr = [kExprIf, kWasmStmt, kExprUnreachable, kExprEnd];
+let if_else_unr = [kExprIf, kWasmStmt, kExprUnreachable, kExprElse, kExprUnreachable, kExprEnd];
+let block_unr = [kExprBlock, kWasmStmt, kExprUnreachable, kExprEnd];
+let loop_unr = [kExprLoop, kWasmStmt, kExprUnreachable, kExprEnd];
+let block_block_unr = [kExprBlock, kWasmStmt, kExprBlock, kWasmStmt, kExprUnreachable, kExprEnd, kExprEnd];
+let drop = kExprDrop;
+
+run(V, "U", [unr]);
+run(V, "U U", [unr, unr]);
+run(V, "(if 0 () else ())", [...zero, ...if_else_empty]);
+run(V, "(if 0 U)", [...zero, ...if_unr]);
+run(V, "(if 0 U U)", [...zero, ...if_else_unr]);
+run(I, "(if 0 U) iadd", [...zero, ...if_unr, iadd]);
+run(V, "0 0 (if 0 U) iadd", [...zero, ...zero, ...zero, ...if_unr, iadd, drop]);
+run(V, "(if 0 U) 0 0 iadd", [...zero, ...if_unr, ...zero, ...zero, iadd, drop]);
+
+run(V, "(block U)", [...block_unr]);
+run(V, "(loop U)", [...loop_unr]);
+run(V, "(if 0 U U)", [...zero, ...if_else_unr]);
+
+run(V, "U nop", [unr, nop]);
+run(V, "U iadd", [unr, iadd]);

[rossberg, 2017/01/19 08:32:26]

Oh, and you probably want to add drops here (and for others) as well, so that a
return-type mismatch is removed from the equation.

+run(V, "br0 iadd", [br0, iadd]);
+run(V, "ret iadd", [ret, iadd]);
+run(V, "(block U) iadd", [...block_unr, iadd]);

[rossberg, 2017/01/19 08:14:29]

Could add "(block (block U)) iadd"

+run(V, "(loop U) iadd", [...loop_unr, iadd]);
+run(V, "(if 0 U U) iadd", [...zero, ...if_else_unr, iadd]);
+
+run(V, "U 0 0 iadd", [unr, ...zero, ...zero, iadd]);
+run(V, "(block U) 0 0 iadd", [...block_unr, ...zero, ...zero, iadd]);
+run(V, "(loop U) 0 0 iadd", [...loop_unr, ...zero, ...zero, iadd]);
+run(V, "(block (block U)) 0 0 iadd", [...block_block_unr, ...zero, ...zero, iadd]);
+run(V, "0 0 U iadd", [...zero, ...zero, unr, iadd]);
+run(V, "0 0 (block U) iadd", [...zero, ...zero, ...block_unr, iadd]);
+run(V, "0 0 (loop U) iadd", [...zero, ...zero, ...loop_unr, iadd]);
+run(V, "0 0 (block (block U)) iadd", [...zero, ...zero, ...block_block_unr, iadd]);
+
+run(I, "U F32 iadd", [unr, ...f32, iadd]);

[rossberg, 2017/01/19 08:14:29]

You probably want to add a 0 operand before the F32 in all these, so that
failure is really due to types, not stack depth (or add that as a separate
variant).

+run(I, "(if 0 U U) F32 iadd", [...zero, ...if_else_unr, ...f32, iadd]);
+run(I, "(block U) F32 iadd", [...block_unr, ...f32, iadd]);
+run(I, "(loop U) F32 iadd", [...loop_unr, ...f32, iadd]);
+run(I, "(block (block U)) F32 iadd", [...block_block_unr, ...f32, iadd]);

[rossberg, 2017/01/19 08:14:29]

Another relevant category:

"0 F32 U iadd"
"0 F32 (block U) iadd"
"0 F32 (loop U) iadd"
etc