1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
|
// 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.
#ifndef V8_WASM_WASM_RESULT_H_
#define V8_WASM_WASM_RESULT_H_
#include <cstdarg>
#include <memory>
#include "src/base/compiler-specific.h"
#include "src/utils.h"
#include "src/globals.h"
#include "src/handles.h"
namespace v8 {
namespace internal {
class Isolate;
namespace wasm {
// Base class for Result<T>.
class V8_EXPORT_PRIVATE ResultBase {
protected:
ResultBase() = default;
ResultBase& operator=(ResultBase&& other) = default;
public:
ResultBase(ResultBase&& other)
: error_offset_(other.error_offset_),
error_msg_(std::move(other.error_msg_)) {}
void error(uint32_t offset, std::string error_msg);
void PRINTF_FORMAT(2, 3) error(const char* format, ...) {
va_list args;
va_start(args, format);
verror(format, args);
va_end(args);
}
void PRINTF_FORMAT(2, 0) verror(const char* format, va_list args);
void MoveErrorFrom(ResultBase& that) {
error_offset_ = that.error_offset_;
// Use {swap()} + {clear()} instead of move assign, as {that} might still
// be used afterwards.
error_msg_.swap(that.error_msg_);
that.error_msg_.clear();
}
bool ok() const { return error_msg_.empty(); }
bool failed() const { return !ok(); }
uint32_t error_offset() const { return error_offset_; }
const std::string& error_msg() const { return error_msg_; }
private:
uint32_t error_offset_ = 0;
std::string error_msg_;
};
// The overall result of decoding a function or a module.
template <typename T>
class Result : public ResultBase {
public:
Result() = default;
template <typename S>
explicit Result(S&& value) : val(std::forward<S>(value)) {}
template <typename S>
Result(Result<S>&& other)
: ResultBase(std::move(other)), val(std::move(other.val)) {}
Result& operator=(Result&& other) = default;
static Result<T> PRINTF_FORMAT(1, 2) Error(const char* format, ...) {
va_list args;
va_start(args, format);
Result<T> result;
result.verror(format, args);
va_end(args);
return result;
}
T val = T{};
private:
DISALLOW_COPY_AND_ASSIGN(Result);
};
// A helper for generating error messages that bubble up to JS exceptions.
class V8_EXPORT_PRIVATE ErrorThrower {
public:
ErrorThrower(Isolate* isolate, const char* context)
: isolate_(isolate), context_(context) {}
// Explicitly allow move-construction. Disallow copy (below).
ErrorThrower(ErrorThrower&& other);
~ErrorThrower();
PRINTF_FORMAT(2, 3) void TypeError(const char* fmt, ...);
PRINTF_FORMAT(2, 3) void RangeError(const char* fmt, ...);
PRINTF_FORMAT(2, 3) void CompileError(const char* fmt, ...);
PRINTF_FORMAT(2, 3) void LinkError(const char* fmt, ...);
PRINTF_FORMAT(2, 3) void RuntimeError(const char* fmt, ...);
template <typename T>
void CompileFailed(const char* error, Result<T>& result) {
DCHECK(result.failed());
CompileError("%s: %s @+%u", error, result.error_msg().c_str(),
result.error_offset());
}
// Create and return exception object.
V8_WARN_UNUSED_RESULT Handle<Object> Reify();
// Reset any error which was set on this thrower.
void Reset();
bool error() const { return error_type_ != kNone; }
bool wasm_error() { return error_type_ >= kFirstWasmError; }
Isolate* isolate() const { return isolate_; }
private:
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_;
const char* context_;
ErrorType error_type_ = kNone;
std::string error_msg_;
DISALLOW_COPY_AND_ASSIGN(ErrorThrower);
// ErrorThrower should always be stack-allocated, since it constitutes a scope
// (things happen in the destructor).
DISALLOW_NEW_AND_DELETE();
};
} // namespace wasm
} // namespace internal
} // namespace v8
#endif // V8_WASM_WASM_RESULT_H_
|
