traps.cc 5.25 KB
Newer Older
1 2 3 4 5 6
// Copyright 2019 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/wasm-api-tests/wasm-api-test.h"

7 8 9 10 11
#include "src/execution/isolate.h"
#include "src/wasm/c-api.h"
#include "src/wasm/module-decoder.h"
#include "src/wasm/wasm-engine.h"

12 13 14 15 16 17
#include <iostream>

namespace v8 {
namespace internal {
namespace wasm {

18
using ::wasm::Frame;
19 20 21 22
using ::wasm::Message;

namespace {

23
own<Trap> FailCallback(void* env, const Val args[], Val results[]) {
24 25 26 27 28 29 30 31 32 33 34 35 36 37
  Store* store = reinterpret_cast<Store*>(env);
  Message message = Message::make(std::string("callback abort"));
  return Trap::make(store, message);
}

void ExpectMessage(const char* expected, const Message& message) {
  size_t len = strlen(expected);
  EXPECT_EQ(len, message.size());
  EXPECT_EQ(0, strncmp(expected, message.get(), len));
}

}  // namespace

TEST_F(WasmCapiTest, Traps) {
38
  FLAG_experimental_wasm_eh = true;
39 40
  ValueType i32_type[] = {kWasmI32};
  FunctionSig sig(1, 0, i32_type);
41 42
  uint32_t callback_index =
      builder()->AddImport(base::CStrVector("callback"), &sig);
43
  byte code[] = {WASM_CALL_FUNCTION0(callback_index)};
44
  AddExportedFunction(base::CStrVector("callback"), code, sizeof(code), &sig);
45 46

  byte code2[] = {WASM_CALL_FUNCTION0(3)};
47 48
  AddExportedFunction(base::CStrVector("unreachable"), code2, sizeof(code2),
                      &sig);
49 50 51 52
  // The first constant is a 4-byte dummy so that the {unreachable} trap
  // has a more interesting offset. This is called by code2.
  byte code3[] = {WASM_I32V_3(0), WASM_UNREACHABLE, WASM_I32V_1(1)};
  AddFunction(code3, sizeof(code3), &sig);
53

54 55 56
  // Check that traps returned from a C callback are uncatchable in Wasm.
  byte code4[] = {WASM_TRY_CATCH_ALL_T(
      kWasmI32, WASM_CALL_FUNCTION0(callback_index), WASM_I32V(42))};
57 58
  AddExportedFunction(base::CStrVector("uncatchable"), code4, sizeof(code4),
                      &sig);
59

60 61 62 63 64
  own<FuncType> func_type =
      FuncType::make(ownvec<ValType>::make(),
                     ownvec<ValType>::make(ValType::make(::wasm::I32)));
  own<Func> cpp_callback = Func::make(store(), func_type.get(), FailCallback,
                                      reinterpret_cast<void*>(store()));
65 66 67
  Extern* imports[] = {cpp_callback.get()};
  Instantiate(imports);

68 69 70 71 72
  // Use internal machinery to parse the module to find the function offsets.
  // This makes the test more robust than hardcoding them.
  i::Isolate* isolate =
      reinterpret_cast<::wasm::StoreImpl*>(store())->i_isolate();
  ModuleResult result = DecodeWasmModule(
73
      WasmFeatures::All(), wire_bytes()->begin(), wire_bytes()->end(), false,
74
      ModuleOrigin::kWasmOrigin, isolate->counters(),
75
      isolate->metrics_recorder(), v8::metrics::Recorder::ContextId::Empty(),
76
      DecodingMethod::kSync, GetWasmEngine()->allocator());
77 78 79
  ASSERT_TRUE(result.ok());
  const WasmFunction* func1 = &result.value()->functions[1];
  const WasmFunction* func2 = &result.value()->functions[2];
80
  const WasmFunction* func3 = &result.value()->functions[3];
81 82
  const uint32_t func1_offset = func1->code.offset();
  const uint32_t func2_offset = func2->code.offset();
83
  const uint32_t func3_offset = func3->code.offset();
84

85
  Func* cpp_trapping_func = GetExportedFunction(0);
86
  own<Trap> cpp_trap = cpp_trapping_func->call();
87 88
  EXPECT_NE(nullptr, cpp_trap.get());
  ExpectMessage("Uncaught Error: callback abort", cpp_trap->message());
89
  own<Frame> frame = cpp_trap->origin();
90 91 92 93
  EXPECT_TRUE(frame->instance()->same(instance()));
  EXPECT_EQ(1u, frame->func_index());
  EXPECT_EQ(1u, frame->func_offset());
  EXPECT_EQ(func1_offset + frame->func_offset(), frame->module_offset());
94
  ownvec<Frame> trace = cpp_trap->trace();
95
  EXPECT_EQ(1u, trace.size());
96
  frame.reset(trace[0].release());
97 98 99 100
  EXPECT_TRUE(frame->instance()->same(instance()));
  EXPECT_EQ(1u, frame->func_index());
  EXPECT_EQ(1u, frame->func_offset());
  EXPECT_EQ(func1_offset + frame->func_offset(), frame->module_offset());
101 102

  Func* wasm_trapping_func = GetExportedFunction(1);
103
  own<Trap> wasm_trap = wasm_trapping_func->call();
104 105
  EXPECT_NE(nullptr, wasm_trap.get());
  ExpectMessage("Uncaught RuntimeError: unreachable", wasm_trap->message());
106 107
  frame = wasm_trap->origin();
  EXPECT_TRUE(frame->instance()->same(instance()));
108
  EXPECT_EQ(3u, frame->func_index());
109
  EXPECT_EQ(5u, frame->func_offset());
110
  EXPECT_EQ(func3_offset + frame->func_offset(), frame->module_offset());
111
  trace = wasm_trap->trace();
112 113
  EXPECT_EQ(2u, trace.size());

114
  frame.reset(trace[0].release());
115
  EXPECT_TRUE(frame->instance()->same(instance()));
116
  EXPECT_EQ(3u, frame->func_index());
117
  EXPECT_EQ(5u, frame->func_offset());
118 119 120 121 122 123
  EXPECT_EQ(func3_offset + frame->func_offset(), frame->module_offset());

  frame.reset(trace[1].release());
  EXPECT_TRUE(frame->instance()->same(instance()));
  EXPECT_EQ(2u, frame->func_index());
  EXPECT_EQ(1u, frame->func_offset());
124
  EXPECT_EQ(func2_offset + frame->func_offset(), frame->module_offset());
125 126 127 128 129 130 131

  Func* wasm_uncatchable_func = GetExportedFunction(2);
  Val* args = nullptr;
  Val results[1] = {Val(3.14)};  // Sentinel value.
  own<Trap> uncatchable_trap = wasm_uncatchable_func->call(args, results);
  EXPECT_NE(nullptr, uncatchable_trap.get());
  EXPECT_EQ(::wasm::F64, results[0].kind());
132 133 134 135 136
}

}  // namespace wasm
}  // namespace internal
}  // namespace v8