[wasm] Do not use setjmp/longjmp in cctests.

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>
@@ skipping 723 matching lines @@
   Zone zone_;
   TestingModule module_;
   std::vector<std::unique_ptr<WasmFunctionCompiler>> functions_;
   WasmFunctionWrapper wrapper_;
   bool compiled_ = false;
   bool possible_nondeterminism_ = false;
 
   bool interpret() { return module_.execution_mode() == kExecuteInterpreted; }
 
  public:
   // This field has to be static. Otherwise, gcc complains about the using in

[Clemens Hammacher, 2017/02/08 22:13:20]

Can you fix this typo ("using" should be "use" IMO) while you are here?

[ahaas, 2017/02/09 16:59:37]

Done.

   // the lambda context below.
-  static jmp_buf jump_buffer;
+  static bool trap_happened;
 };
 
 template <typename ReturnType, typename... ParamTypes>
 class WasmRunner : public WasmRunnerBase {
  public:
   explicit WasmRunner(WasmExecutionMode execution_mode,
                       const char* main_fn_name = "main")
       : WasmRunnerBase(execution_mode, sizeof...(ParamTypes)) {
     NewFunction<ReturnType, ParamTypes...>(main_fn_name);
     if (!interpret()) {
       wrapper_.Init<ReturnType, ParamTypes...>(functions_[0]->descriptor());
     }
   }
 
   ReturnType Call(ParamTypes... p) {
     DCHECK(compiled_);
     if (interpret()) return CallInterpreter(p...);
 
     // Use setjmp/longjmp to deal with traps in WebAssembly code.

[Clemens Hammacher, 2017/02/08 22:13:20]

This comment is obsolete now.

[ahaas, 2017/02/09 16:59:37]

Done.

     ReturnType return_value = static_cast<ReturnType>(0xdeadbeefdeadbeef);
-    static int setjmp_ret;
-    setjmp_ret = setjmp(WasmRunnerBase::jump_buffer);
-    // setjmp returns 0 on the first return, 1 (passed to longjmp) after trap.
-    if (setjmp_ret == 0) {
-      DoCall(static_cast<void*>(&p)..., static_cast<void*>(&return_value));
-    }
-    return return_value;
+    WasmRunnerBase::trap_happened = false;
+    auto trap_callback = []() -> void {
+      WasmRunnerBase::trap_happened = true;
+      set_trap_callback_for_testing(nullptr);
+    };
+    set_trap_callback_for_testing(trap_callback);
+
+    wrapper_.SetInnerCode(
+        module_.GetFunctionCode(functions_[0]->function_index()));
+    CodeRunner<int32_t> runner(CcTest::InitIsolateOnce(),
+                               wrapper_.GetWrapperCode(), wrapper_.signature());
+    int32_t result = runner.Call(static_cast<void*>(&p)...,
+                                 static_cast<void*>(&return_value));
+    CHECK_EQ(WASM_WRAPPER_RETURN_VALUE, result);
+    return WasmRunnerBase::trap_happened
+               ? static_cast<ReturnType>(0xdeadbeefdeadbeef)
+               : return_value;
   }
 
   ReturnType CallInterpreter(ParamTypes... p) {
     WasmInterpreter::Thread* thread = interpreter()->GetThread(0);
     thread->Reset();
     std::array<WasmVal, sizeof...(p)> args{{WasmVal(p)...}};
     thread->PushFrame(function(), args.data());
     if (thread->Run() == WasmInterpreter::FINISHED) {
       WasmVal val = thread->GetReturnValue();
       possible_nondeterminism_ |= thread->PossibleNondeterminism();
       return val.to<ReturnType>();
     } else if (thread->state() == WasmInterpreter::TRAPPED) {
       // TODO(titzer): return the correct trap code
       int64_t result = 0xdeadbeefdeadbeef;
       return static_cast<ReturnType>(result);
     } else {
       // TODO(titzer): falling off end
       return ReturnType{0};
     }
   }
-
- private:
-  // Don't inline this function. The setjmp above should be followed immediately
-  // by a call.
-  template <typename... Ptrs>
-  V8_NOINLINE void DoCall(Ptrs... ptrs) {
-    auto trap_callback = []() -> void {
-      set_trap_callback_for_testing(nullptr);
-      longjmp(WasmRunnerBase::jump_buffer, 1);
-    };
-    set_trap_callback_for_testing(trap_callback);
-
-    wrapper_.SetInnerCode(
-        module_.GetFunctionCode(functions_[0]->function_index()));
-    CodeRunner<int32_t> runner(CcTest::InitIsolateOnce(),
-                               wrapper_.GetWrapperCode(), wrapper_.signature());
-    int32_t result = runner.Call(ptrs...);
-    // If we arrive here, no trap happened.
-    CHECK_EQ(WASM_WRAPPER_RETURN_VALUE, result);
-  }
 };
 
 // Declare static variable.
-jmp_buf WasmRunnerBase::jump_buffer;
+bool WasmRunnerBase::trap_happened;
 
 // 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(RunWasmCompiledWithoutTrapIf_##name) {                              \
     bool trap_if = FLAG_wasm_trap_if;                                      \
     FLAG_wasm_trap_if = false;                                             \
     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