[wasm] Introduce the TrapIf and TrapUnless operators to generate trap code.

test/cctest/wasm/wasm-run-utils.h

 // Copyright 2016 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.
 
 #ifndef WASM_RUN_UTILS_H
 #define WASM_RUN_UTILS_H
 
+#include <setjmp.h>
 #include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
 #include <memory>
 
 #include "src/base/utils/random-number-generator.h"
 #include "src/zone/accounting-allocator.h"
 
 #include "src/compiler/compiler-source-position-table.h"
 #include "src/compiler/graph-visualizer.h"
 #include "src/compiler/int64-lowering.h"
 #include "src/compiler/js-graph.h"
 #include "src/compiler/node.h"
 #include "src/compiler/pipeline.h"
 #include "src/compiler/wasm-compiler.h"
 #include "src/compiler/zone-stats.h"
 #include "src/wasm/ast-decoder.h"
+#include "src/wasm/wasm-external-refs.h"
 #include "src/wasm/wasm-interpreter.h"
 #include "src/wasm/wasm-js.h"
 #include "src/wasm/wasm-macro-gen.h"
 #include "src/wasm/wasm-module.h"
 #include "src/wasm/wasm-objects.h"
 #include "src/wasm/wasm-opcodes.h"
 
 #include "src/zone/zone.h"
 
 #include "test/cctest/cctest.h"
@@ skipping 569 matching lines @@
   void SetModuleContext() {
     if (!testing_module_->instance->context.is_null()) {
       CHECK(testing_module_->instance->context.is_identical_to(
           main_isolate()->native_context()));
       return;
     }
     testing_module_->instance->context = main_isolate()->native_context();
   }
 };
 
+template <typename ReturnType>
+union ReturnTypeUnion {
+  ReturnType value;
+  uint64_t trap;
+};
+
 // A helper class to build graphs from Wasm bytecode, generate machine
 // code, and run that code.
 template <typename ReturnType>
 class WasmRunner {
  public:
   WasmRunner(WasmExecutionMode execution_mode,
              MachineType p0 = MachineType::None(),
              MachineType p1 = MachineType::None(),
              MachineType p2 = MachineType::None(),
              MachineType p3 = MachineType::None())
@@ skipping 92 matching lines @@
   template <typename P0, typename P1, typename P2>
   ReturnType Call(P0 p0, P1 p1, P2 p2) {
     if (interpret()) {
       WasmVal args[] = {WasmVal(p0), WasmVal(p1), WasmVal(p2)};
       return CallInterpreter(ArrayVector(args));
     } else {
       return Call(p0, p1, p2, 0);
     }
   }
 
+  static jmp_buf jump_buffer;
+  static int jump_value;
+  static ReturnTypeUnion<ReturnType> return_value;
+
+  template <typename P0, typename P1, typename P2, typename P3>
+  void DoCall(P0 p0, P1 p1, P2 p2, P3 p3) {
+    auto trap_callback = []() {
+      WasmRunner<ReturnType>::return_value.trap = 0xdeadbeefdeadbeef;
+      longjmp(WasmRunner<ReturnType>::jump_buffer, 1);
+    };
+    set_trap_callback_for_testing(trap_callback);
+    CodeRunner<int32_t> runner(CcTest::InitIsolateOnce(),
+                               wrapper_.GetWrapperCode(), wrapper_.signature());
+
+    int32_t result = runner.Call<void*, void*, void*, void*, void*>(
+        &p0, &p1, &p2, &p3, &WasmRunner<ReturnType>::return_value.value);
+    CHECK_EQ(WASM_WRAPPER_RETURN_VALUE, result);
+  }
+
   template <typename P0, typename P1, typename P2, typename P3>
   ReturnType Call(P0 p0, P1 p1, P2 p2, P3 p3) {
     if (interpret()) {
       WasmVal args[] = {WasmVal(p0), WasmVal(p1), WasmVal(p2), WasmVal(p3)};
       return CallInterpreter(ArrayVector(args));
     } else {
-      CodeRunner<int32_t> runner(CcTest::InitIsolateOnce(),
-                                 wrapper_.GetWrapperCode(),
-                                 wrapper_.signature());
-      ReturnType return_value;
-      int32_t result = runner.Call<void*, void*, void*, void*, void*>(
-          &p0, &p1, &p2, &p3, &return_value);
-      CHECK_EQ(WASM_WRAPPER_RETURN_VALUE, result);
-      return return_value;
+      // Use setjmp/longjmp to deal with traps in WebAssembly code.
+      WasmRunner<ReturnType>::jump_value =
+          setjmp(WasmRunner<ReturnType>::jump_buffer);
+      if (!WasmRunner<ReturnType>::jump_value) {
+        DoCall(p0, p1, p2, p3);
+      }
+      set_trap_callback_for_testing(nullptr);
+      return WasmRunner<ReturnType>::return_value.value;
     }
   }
 
   ReturnType CallInterpreter(Vector<WasmVal> args) {
     CHECK_EQ(args.length(),
              static_cast<int>(compiler_.function_->sig->parameter_count()));
     WasmInterpreter::Thread* thread = interpreter()->GetThread(0);
     thread->Reset();
     thread->PushFrame(compiler_.function_, args.start());
     if (thread->Run() == WasmInterpreter::FINISHED) {
@@ skipping 32 matching lines @@
   static size_t GetParameterCount(MachineType p0, MachineType p1,
                                   MachineType p2, MachineType p3) {
     if (p0 == MachineType::None()) return 0;
     if (p1 == MachineType::None()) return 1;
     if (p2 == MachineType::None()) return 2;
     if (p3 == MachineType::None()) return 3;
     return 4;
   }
 };
 
+template <typename ReturnType>
+jmp_buf WasmRunner<ReturnType>::jump_buffer;
+template <typename ReturnType>
+int WasmRunner<ReturnType>::jump_value;
+template <typename ReturnType>
+ReturnTypeUnion<ReturnType> WasmRunner<ReturnType>::return_value;
+
 // A macro to define tests that run in different engine configurations.
 #define WASM_EXEC_TEST(name)                                               \
   void RunWasm_##name(WasmExecutionMode execution_mode);                   \
   TEST(RunWasmCompiled_##name) { RunWasm_##name(kExecuteCompiled); }       \
   TEST(RunWasmInterpreted_##name) { RunWasm_##name(kExecuteInterpreted); } \
   void RunWasm_##name(WasmExecutionMode execution_mode)
 
+#define WASM_EXEC_TEST_WITH_TRAP(name)                                     \
+  void RunWasm_##name(WasmExecutionMode execution_mode);                   \
+  TEST(RunWasmCompiled_##name) { RunWasm_##name(kExecuteCompiled); }       \
+  void RunWasm_##name(WasmExecutionMode execution_mode);                   \
+  TEST(RunWasmCompiledWithTrapIf_##name) {                                 \
+    bool trap_if = FLAG_wasm_trap_if;                                      \
+    FLAG_wasm_trap_if = true;                                              \
+    RunWasm_##name(kExecuteCompiled);                                      \
+    FLAG_wasm_trap_if = trap_if;                                           \
+  }                                                                        \
+  TEST(RunWasmInterpreted_##name) { RunWasm_##name(kExecuteInterpreted); } \
+  void RunWasm_##name(WasmExecutionMode execution_mode)
+
 #define WASM_EXEC_COMPILED_TEST(name)                                \
   void RunWasm_##name(WasmExecutionMode execution_mode);             \
   TEST(RunWasmCompiled_##name) { RunWasm_##name(kExecuteCompiled); } \
   void RunWasm_##name(WasmExecutionMode execution_mode)
 
 }  // namespace
 
 #endif