Reland of [wasm] Enforce that function bodies end with the \"end\" opcode.

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 90 matching lines @@
   LocalDeclEncoder local_decls;
 
   void AddLocals(ValueType type, uint32_t count) {
     local_decls.AddLocals(count, type);
   }
 
   // Prepends local variable declarations and renders nice error messages for
   // verification failures.
   void Verify(ErrorCode expected, FunctionSig* sig, const byte* start,
               const byte* end) {
-    local_decls.Prepend(zone(), &start, &end);
+    size_t locals_size = local_decls.Size();
+    size_t total_size = end - start + locals_size + 1;
+    byte* buffer = static_cast<byte*>(zone()->New(total_size));
+    // Prepend the local decls to the code.
+    local_decls.Emit(buffer);
+    // Emit the code.
+    memcpy(buffer + locals_size, start, end - start);
+    // Append an extra end opcode.
+    buffer[total_size - 1] = kExprEnd;
+
+    start = buffer;
+    end = buffer + total_size;
+
     // Verify the code.
     DecodeResult result = VerifyWasmCode(
         zone()->allocator(), module == nullptr ? nullptr : module->module, sig,
         start, end);
 
     if (result.error_code != expected) {
       ptrdiff_t pc = result.error_pc - result.start;
       ptrdiff_t pt = result.error_pt - result.start;
       std::ostringstream str;
       if (expected == kSuccess) {
@@ skipping 332 matching lines @@
   EXPECT_FAILURE_C(i_i, code);
 }
 
 TEST_F(FunctionBodyDecoderTest, Block0Block0) {
   static const byte code[] = {WASM_EMPTY_BLOCK, WASM_EMPTY_BLOCK};
   EXPECT_VERIFIES_C(v_v, code);
   EXPECT_FAILURE_C(i_i, code);
 }
 
 TEST_F(FunctionBodyDecoderTest, Block0_end) {
-  EXPECT_VERIFIES(v_v, WASM_EMPTY_BLOCK, kExprEnd);
-}
-
-TEST_F(FunctionBodyDecoderTest, Block0_end_end) {
-  EXPECT_FAILURE(v_v, WASM_EMPTY_BLOCK, kExprEnd, kExprEnd);
+  EXPECT_FAILURE(v_v, WASM_EMPTY_BLOCK, kExprEnd);
 }
 
 TEST_F(FunctionBodyDecoderTest, Block1) {
   byte code[] = {WASM_BLOCK_I(WASM_GET_LOCAL(0))};
   EXPECT_VERIFIES_C(i_i, code);
   EXPECT_FAILURE_C(v_i, code);
   EXPECT_FAILURE_C(d_dd, code);
   EXPECT_FAILURE_C(i_f, code);
   EXPECT_FAILURE_C(i_d, code);
 }
@@ skipping 232 matching lines @@
 }
 
 TEST_F(FunctionBodyDecoderTest, IfNop) {
   EXPECT_VERIFIES(v_i, WASM_IF(WASM_GET_LOCAL(0), WASM_NOP));
 }
 
 TEST_F(FunctionBodyDecoderTest, IfNopElseNop) {
   EXPECT_VERIFIES(v_i, WASM_IF_ELSE(WASM_GET_LOCAL(0), WASM_NOP, WASM_NOP));
 }
 
+TEST_F(FunctionBodyDecoderTest, If_end) {
+  static const byte code[] = {kExprGetLocal, 0, WASM_IF_OP, kExprEnd};
+  EXPECT_VERIFIES_C(v_i, code);
+}
+
 TEST_F(FunctionBodyDecoderTest, If_end_end) {
   static const byte code[] = {kExprGetLocal, 0, WASM_IF_OP, kExprEnd, kExprEnd};
-  EXPECT_VERIFIES_C(v_i, code);
-}
-
-TEST_F(FunctionBodyDecoderTest, If_end_end_end) {
-  static const byte code[] = {kExprGetLocal, 0,        WASM_IF_OP,
-                              kExprEnd,      kExprEnd, kExprEnd};
   EXPECT_FAILURE_C(v_i, code);
 }
 
 TEST_F(FunctionBodyDecoderTest, If_falloff1) {
   static const byte code[] = {kExprGetLocal, 0, kExprIf};
   EXPECT_FAILURE_C(v_i, code);
 }
 
 TEST_F(FunctionBodyDecoderTest, If_falloff2) {
   static const byte code[] = {kExprGetLocal, 0, WASM_IF_OP};
@@ skipping 1989 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