wasm-result.h 4.92 KB
Newer Older
1 2 3 4
// 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.

5 6
#ifndef V8_WASM_WASM_RESULT_H_
#define V8_WASM_WASM_RESULT_H_
7

8
#include <cstdarg>
9 10
#include <memory>

jfb's avatar
jfb committed
11
#include "src/base/compiler-specific.h"
12 13
#include "src/base/macros.h"
#include "src/base/platform/platform.h"
14 15 16 17 18 19 20

#include "src/globals.h"

namespace v8 {
namespace internal {

class Isolate;
21 22
template <typename T>
class Handle;
23 24 25

namespace wasm {

26 27 28
class V8_EXPORT_PRIVATE WasmError {
 public:
  WasmError() = default;
29

30 31 32 33 34
  WasmError(uint32_t offset, std::string message)
      : offset_(offset), message_(std::move(message)) {
    // The error message must not be empty, otherwise {empty()} would be true.
    DCHECK(!message_.empty());
  }
35

36 37 38 39 40 41 42 43 44
  PRINTF_FORMAT(3, 4)
  WasmError(uint32_t offset, const char* format, ...) : offset_(offset) {
    va_list args;
    va_start(args, format);
    message_ = FormatError(format, args);
    va_end(args);
    // The error message must not be empty, otherwise {empty()} would be true.
    DCHECK(!message_.empty());
  }
45

46 47
  bool empty() const { return message_.empty(); }
  bool has_error() const { return !message_.empty(); }
48

49 50 51
  uint32_t offset() const { return offset_; }
  const std::string& message() const& { return message_; }
  std::string&& message() && { return std::move(message_); }
52

53 54 55
 protected:
  static std::string FormatError(const char* format, va_list args);

56
 private:
57 58
  uint32_t offset_ = 0;
  std::string message_;
59 60
};

61
// Either a result of type T, or a WasmError.
62
template <typename T>
63
class Result {
64 65 66 67
 public:
  Result() = default;

  template <typename S>
68
  explicit Result(S&& value) : value_(std::forward<S>(value)) {}
69

70
  template <typename S>
71 72
  Result(Result<S>&& other) V8_NOEXCEPT : value_(std::move(other.value_)),
                                          error_(std::move(other.error_)) {}
73

74
  explicit Result(WasmError error) : error_(std::move(error)) {}
75

76 77 78 79 80
  template <typename S>
  Result& operator=(Result<S>&& other) V8_NOEXCEPT {
    value_ = std::move(other.value_);
    error_ = std::move(other.error_);
    return *this;
81 82
  }

83 84 85 86
  bool ok() const { return error_.empty(); }
  bool failed() const { return error_.has_error(); }
  const WasmError& error() const& { return error_; }
  WasmError&& error() && { return std::move(error_); }
87

88 89 90 91 92 93 94 95 96 97 98 99
  // Accessor for the value. Returns const reference if {this} is l-value or
  // const, and returns r-value reference if {this} is r-value. This allows to
  // extract non-copyable values like {std::unique_ptr} by using
  // {std::move(result).value()}.
  const T& value() const & {
    DCHECK(ok());
    return value_;
  }
  T&& value() && {
    DCHECK(ok());
    return std::move(value_);
  }
100

101
 private:
102 103
  template <typename S>
  friend class Result;
104

105 106
  T value_ = T{};
  WasmError error_;
107

108 109
  DISALLOW_COPY_AND_ASSIGN(Result);
};
110 111

// A helper for generating error messages that bubble up to JS exceptions.
112
class V8_EXPORT_PRIVATE ErrorThrower {
113
 public:
114
  ErrorThrower(Isolate* isolate, const char* context)
rossberg's avatar
rossberg committed
115
      : isolate_(isolate), context_(context) {}
116
  // Explicitly allow move-construction. Disallow copy (below).
117
  ErrorThrower(ErrorThrower&& other) V8_NOEXCEPT;
rossberg's avatar
rossberg committed
118
  ~ErrorThrower();
119

120 121
  PRINTF_FORMAT(2, 3) void TypeError(const char* fmt, ...);
  PRINTF_FORMAT(2, 3) void RangeError(const char* fmt, ...);
122
  PRINTF_FORMAT(2, 3) void CompileError(const char* fmt, ...);
123
  PRINTF_FORMAT(2, 3) void LinkError(const char* fmt, ...);
124
  PRINTF_FORMAT(2, 3) void RuntimeError(const char* fmt, ...);
125

126 127 128
  void CompileFailed(const WasmError& error) {
    DCHECK(error.has_error());
    CompileError("%s @+%u", error.message().c_str(), error.offset());
129 130
  }

131
  // Create and return exception object.
132
  V8_WARN_UNUSED_RESULT Handle<Object> Reify();
133 134 135

  // Reset any error which was set on this thrower.
  void Reset();
rossberg's avatar
rossberg committed
136

137 138
  bool error() const { return error_type_ != kNone; }
  bool wasm_error() { return error_type_ >= kFirstWasmError; }
139
  const char* error_msg() { return error_msg_.c_str(); }
140

141 142
  Isolate* isolate() const { return isolate_; }

143
 private:
144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160
  enum ErrorType {
    kNone,
    // General errors.
    kTypeError,
    kRangeError,
    // Wasm errors.
    kCompileError,
    kLinkError,
    kRuntimeError,

    // Marker.
    kFirstWasmError = kCompileError
  };

  void Format(ErrorType error_type_, const char* fmt, va_list);

  Isolate* isolate_;
161
  const char* context_;
162 163
  ErrorType error_type_ = kNone;
  std::string error_msg_;
164

165 166
  // ErrorThrower should always be stack-allocated, since it constitutes a scope
  // (things happen in the destructor).
167
  DISALLOW_NEW_AND_DELETE()
168
  DISALLOW_COPY_AND_ASSIGN(ErrorThrower);
169
};
170

171 172 173 174 175
// Use {nullptr_t} as data value to indicate that this only stores the error,
// but no result value (the only valid value is {nullptr}).
// [Storing {void} would require template specialization.]
using VoidResult = Result<std::nullptr_t>;

176 177 178 179
}  // namespace wasm
}  // namespace internal
}  // namespace v8

180
#endif  // V8_WASM_WASM_RESULT_H_