[wasm] Initial signal handler

test/cctest/wasm/test-run-wasm.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 <stdint.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include "src/base/platform/elapsed-timer.h"
+#include "src/trap-handler/trap-handler.h"
 #include "src/utils.h"
 #include "src/wasm/wasm-macro-gen.h"
 
 #include "test/cctest/cctest.h"
 #include "test/cctest/compiler/value-helper.h"
 #include "test/cctest/wasm/wasm-run-utils.h"
 #include "test/common/wasm/test-signatures.h"
 
 using namespace v8::base;
 using namespace v8::internal;
@@ skipping 1056 matching lines @@
         WASM_I8(107));
 
   FOR_INT32_INPUTS(i) {
     int32_t expected = *i;
     CHECK_EQ(107, r.Call(expected));
     CHECK_EQ(expected, r.module().ReadMemory(&memory[0]));
   }
 }
 
 WASM_EXEC_TEST_WITH_TRAP(LoadMaxUint32Offset) {
+  if (trap_handler::EnableTrapHandler()) {

[titzer, 2017/01/09 09:26:56]

I think this is because we'd need to put the trap handler data registration into
either compiler/wasm-compiler.cc or into compiler/pipeline.cc. In addition to
that, we'd have to make the code generated for the trap handler landing pads
work in cctests as well.

Recommend changing the definition of WASM_EXEC_TEST_WITH_TRAP to do this check.

[Eric Holk, 2017/01/10 23:10:48]

Done.

+    // cctests don't register the handler data, so this test won't work
+    // TODO(eholk): find out why and fix it.
+    return;
+  }
   WasmRunner<int32_t> r(execution_mode);
   r.module().AddMemoryElems<int32_t>(8);
 
   BUILD(r, kExprI8Const, 0,  // index
         static_cast<byte>(v8::internal::wasm::WasmOpcodes::LoadStoreOpcodeOf(
             MachineType::Int32(), false)),  // --
         0,                                  // alignment
         U32V_5(0xffffffff));                // offset
 
   CHECK_TRAP32(r.Call());
@@ skipping 371 matching lines @@
 
     r.module().WriteMemory(&memory[0], 0x5e6f7a8b);
     CHECK_EQ(0x5e6f7a8b, r.Call(0));
 
     r.module().WriteMemory(&memory[0], 0x7ca0b1c2);
     CHECK_EQ(0x7ca0b1c2, r.Call(0));
   }
 }
 
 WASM_EXEC_TEST_WITH_TRAP(LoadMemI32_oob) {
+  if (trap_handler::EnableTrapHandler()) {
+    // With trap handlers enabled, we need additional guard pages and such set
+    // up. This path does not enable these, so we skip this test. The behavior
+    // covered by this tests is also covered by mjsunit tests, such as
+    // test/mjsunit/wasm/import-memory.js
+    return;
+  }
   WasmRunner<int32_t, uint32_t> r(execution_mode);
   int32_t* memory = r.module().AddMemoryElems<int32_t>(8);
   r.module().RandomizeMemory(1111);
 
   BUILD(r, WASM_LOAD_MEM(MachineType::Int32(), WASM_GET_LOCAL(0)));
 
   r.module().WriteMemory(&memory[0], 88888888);
   CHECK_EQ(88888888, r.Call(0u));
   for (uint32_t offset = 29; offset < 40; ++offset) {
     CHECK_TRAP(r.Call(offset));
   }
 
   for (uint32_t offset = 0x80000000; offset < 0x80000010; ++offset) {
     CHECK_TRAP(r.Call(offset));
   }
 }
 
 WASM_EXEC_TEST_WITH_TRAP(LoadMem_offset_oob) {
+  if (trap_handler::EnableTrapHandler()) {
+    // With trap handlers enabled, we need additional guard pages and such set
+    // up. This path does not enable these, so we skip this test. The behavior
+    // covered by this tests is also covered by mjsunit tests, such as
+    // test/mjsunit/wasm/import-memory.js
+    return;
+  }
   static const MachineType machineTypes[] = {
       MachineType::Int8(),   MachineType::Uint8(),  MachineType::Int16(),
       MachineType::Uint16(), MachineType::Int32(),  MachineType::Uint32(),
       MachineType::Int64(),  MachineType::Uint64(), MachineType::Float32(),
       MachineType::Float64()};
 
   for (size_t m = 0; m < arraysize(machineTypes); ++m) {
     WasmRunner<int32_t, uint32_t> r(execution_mode);
     r.module().AddMemoryElems<int32_t>(8);
     r.module().RandomizeMemory(1116 + static_cast<int>(m));
@@ skipping 29 matching lines @@
   r.module().WriteMemory(&memory[0], 11111111);
   r.module().WriteMemory(&memory[1], 22222222);
   r.module().WriteMemory(&memory[2], 33333333);
   r.module().WriteMemory(&memory[3], 44444444);
   CHECK_EQ(22222222, r.Call(0));
   CHECK_EQ(33333333, r.Call(4));
   CHECK_EQ(44444444, r.Call(8));
 }
 
 WASM_EXEC_TEST_WITH_TRAP(LoadMemI32_const_oob_misaligned) {
+  if (trap_handler::EnableTrapHandler()) {
+    // With trap handlers enabled, we need additional guard pages and such set
+    // up. This path does not enable these, so we skip this test. The behavior
+    // covered by this tests is also covered by mjsunit tests, such as
+    // test/mjsunit/wasm/import-memory.js
+    return;
+  }
   const int kMemSize = 12;
   // TODO(titzer): Fix misaligned accesses on MIPS and re-enable.
   for (int offset = 0; offset < kMemSize + 5; ++offset) {
     for (int index = 0; index < kMemSize + 5; ++index) {
       WasmRunner<int32_t> r(execution_mode);
       r.module().AddMemoryElems<byte>(kMemSize);
       r.module().RandomizeMemory();
 
       BUILD(r,
             WASM_LOAD_MEM_OFFSET(MachineType::Int32(), offset, WASM_I8(index)));
 
       if ((offset + index) <= static_cast<int>((kMemSize - sizeof(int32_t)))) {
         CHECK_EQ(r.module().raw_val_at<int32_t>(offset + index), r.Call());
       } else {
         CHECK_TRAP(r.Call());
       }
     }
   }
 }
 
 WASM_EXEC_TEST_WITH_TRAP(LoadMemI32_const_oob) {
+  if (trap_handler::EnableTrapHandler()) {
+    // With trap handlers enabled, we need additional guard pages and such set
+    // up. This path does not enable these, so we skip this test. The behavior
+    // covered by this tests is also covered by mjsunit tests, such as
+    // test/mjsunit/wasm/import-memory.js
+    return;
+  }
   const int kMemSize = 24;
   for (int offset = 0; offset < kMemSize + 5; offset += 4) {
     for (int index = 0; index < kMemSize + 5; index += 4) {
       WasmRunner<int32_t> r(execution_mode);
       r.module().AddMemoryElems<byte>(kMemSize);
       r.module().RandomizeMemory();
 
       BUILD(r,
             WASM_LOAD_MEM_OFFSET(MachineType::Int32(), offset, WASM_I8(index)));
 
@@ skipping 40 matching lines @@
     r.module().WriteMemory(&memory[3], 99999999);
     CHECK_EQ(kWritten, r.Call(i * 4));
     CHECK_EQ(66666666, r.module().ReadMemory(&memory[0]));
     CHECK_EQ(i == 0 ? kWritten : 77777777, r.module().ReadMemory(&memory[1]));
     CHECK_EQ(i == 1 ? kWritten : 88888888, r.module().ReadMemory(&memory[2]));
     CHECK_EQ(i == 2 ? kWritten : 99999999, r.module().ReadMemory(&memory[3]));
   }
 }
 
 WASM_EXEC_TEST_WITH_TRAP(StoreMem_offset_oob) {
+  if (trap_handler::EnableTrapHandler()) {
+    // With trap handlers enabled, we need additional guard pages and such set
+    // up. This path does not enable these, so we skip this test. The behavior
+    // covered by this tests is also covered by mjsunit tests, such as
+    // test/mjsunit/wasm/import-memory.js
+    return;
+  }
   // 64-bit cases are handled in test-run-wasm-64.cc
   static const MachineType machineTypes[] = {
       MachineType::Int8(),    MachineType::Uint8(),  MachineType::Int16(),
       MachineType::Uint16(),  MachineType::Int32(),  MachineType::Uint32(),
       MachineType::Float32(), MachineType::Float64()};
 
   for (size_t m = 0; m < arraysize(machineTypes); ++m) {
     WasmRunner<int32_t, uint32_t> r(execution_mode);
     byte* memory = r.module().AddMemoryElems<byte>(32);
 
@@ skipping 1252 matching lines @@
   BUILD(r, WASM_I32_REMS(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)), WASM_DROP,
         WASM_ZERO);
   const int32_t kMin = std::numeric_limits<int32_t>::min();
   CHECK_EQ(0, r.Call(133, 100));
   CHECK_EQ(0, r.Call(kMin, -1));
   CHECK_EQ(0, r.Call(0, 1));
   CHECK_TRAP(r.Call(100, 0));
   CHECK_TRAP(r.Call(-1001, 0));
   CHECK_TRAP(r.Call(kMin, 0));
 }