libv8 8.4.255.0-universal-darwin-15
Sign up to get free protection for your applications and to get access to all the features.
- checksums.yaml +7 -0
- data/ext/libv8/.location.yml +1 -0
- data/ext/libv8/location.rb +89 -0
- data/ext/libv8/paths.rb +28 -0
- data/lib/libv8.rb +9 -0
- data/lib/libv8/version.rb +3 -0
- data/vendor/v8/include/cppgc/allocation.h +124 -0
- data/vendor/v8/include/cppgc/garbage-collected.h +192 -0
- data/vendor/v8/include/cppgc/heap.h +50 -0
- data/vendor/v8/include/cppgc/internal/accessors.h +26 -0
- data/vendor/v8/include/cppgc/internal/api-constants.h +44 -0
- data/vendor/v8/include/cppgc/internal/compiler-specific.h +26 -0
- data/vendor/v8/include/cppgc/internal/finalizer-trait.h +90 -0
- data/vendor/v8/include/cppgc/internal/gc-info.h +43 -0
- data/vendor/v8/include/cppgc/internal/logging.h +50 -0
- data/vendor/v8/include/cppgc/internal/persistent-node.h +109 -0
- data/vendor/v8/include/cppgc/internal/pointer-policies.h +133 -0
- data/vendor/v8/include/cppgc/internal/prefinalizer-handler.h +31 -0
- data/vendor/v8/include/cppgc/liveness-broker.h +50 -0
- data/vendor/v8/include/cppgc/macros.h +26 -0
- data/vendor/v8/include/cppgc/member.h +206 -0
- data/vendor/v8/include/cppgc/persistent.h +304 -0
- data/vendor/v8/include/cppgc/platform.h +31 -0
- data/vendor/v8/include/cppgc/prefinalizer.h +54 -0
- data/vendor/v8/include/cppgc/source-location.h +59 -0
- data/vendor/v8/include/cppgc/trace-trait.h +67 -0
- data/vendor/v8/include/cppgc/type-traits.h +109 -0
- data/vendor/v8/include/cppgc/visitor.h +137 -0
- data/vendor/v8/include/libplatform/libplatform-export.h +29 -0
- data/vendor/v8/include/libplatform/libplatform.h +85 -0
- data/vendor/v8/include/libplatform/v8-tracing.h +332 -0
- data/vendor/v8/include/v8-fast-api-calls.h +412 -0
- data/vendor/v8/include/v8-inspector-protocol.h +13 -0
- data/vendor/v8/include/v8-inspector.h +327 -0
- data/vendor/v8/include/v8-internal.h +389 -0
- data/vendor/v8/include/v8-platform.h +577 -0
- data/vendor/v8/include/v8-profiler.h +1059 -0
- data/vendor/v8/include/v8-util.h +652 -0
- data/vendor/v8/include/v8-value-serializer-version.h +24 -0
- data/vendor/v8/include/v8-version-string.h +38 -0
- data/vendor/v8/include/v8-version.h +20 -0
- data/vendor/v8/include/v8-wasm-trap-handler-posix.h +31 -0
- data/vendor/v8/include/v8-wasm-trap-handler-win.h +28 -0
- data/vendor/v8/include/v8.h +12018 -0
- data/vendor/v8/include/v8config.h +465 -0
- data/vendor/v8/out.gn/libv8/obj/libv8_libbase.a +0 -0
- data/vendor/v8/out.gn/libv8/obj/libv8_libplatform.a +0 -0
- data/vendor/v8/out.gn/libv8/obj/libv8_monolith.a +0 -0
- data/vendor/v8/out.gn/libv8/obj/third_party/icu/libicui18n.a +0 -0
- data/vendor/v8/out.gn/libv8/obj/third_party/icu/libicuuc.a +0 -0
- data/vendor/v8/out.gn/libv8/obj/third_party/zlib/google/libcompression_utils_portable.a +0 -0
- data/vendor/v8/out.gn/libv8/obj/third_party/zlib/libchrome_zlib.a +0 -0
- metadata +138 -0
@@ -0,0 +1,412 @@
|
|
1
|
+
// Copyright 2020 the V8 project authors. All rights reserved.
|
2
|
+
// Use of this source code is governed by a BSD-style license that can be
|
3
|
+
// found in the LICENSE file.
|
4
|
+
|
5
|
+
/**
|
6
|
+
* This file provides additional API on top of the default one for making
|
7
|
+
* API calls, which come from embedder C++ functions. The functions are being
|
8
|
+
* called directly from optimized code, doing all the necessary typechecks
|
9
|
+
* in the compiler itself, instead of on the embedder side. Hence the "fast"
|
10
|
+
* in the name. Example usage might look like:
|
11
|
+
*
|
12
|
+
* \code
|
13
|
+
* void FastMethod(int param, bool another_param);
|
14
|
+
*
|
15
|
+
* v8::FunctionTemplate::New(isolate, SlowCallback, data,
|
16
|
+
* signature, length, constructor_behavior
|
17
|
+
* side_effect_type,
|
18
|
+
* &v8::CFunction::Make(FastMethod));
|
19
|
+
* \endcode
|
20
|
+
*
|
21
|
+
* An example for custom embedder type support might employ a way to wrap/
|
22
|
+
* unwrap various C++ types in JSObject instances, e.g:
|
23
|
+
*
|
24
|
+
* \code
|
25
|
+
*
|
26
|
+
* // Represents the way this type system maps C++ and JS values.
|
27
|
+
* struct WrapperTypeInfo {
|
28
|
+
* // Store e.g. a method to map from exposed C++ types to the already
|
29
|
+
* // created v8::FunctionTemplate's for instantiating them.
|
30
|
+
* };
|
31
|
+
*
|
32
|
+
* // Helper method with a sanity check.
|
33
|
+
* template <typename T, int offset>
|
34
|
+
* inline T* GetInternalField(v8::Local<v8::Object> wrapper) {
|
35
|
+
* assert(offset < wrapper->InternalFieldCount());
|
36
|
+
* return reinterpret_cast<T*>(
|
37
|
+
* wrapper->GetAlignedPointerFromInternalField(offset));
|
38
|
+
* }
|
39
|
+
*
|
40
|
+
* // Returns the type info from a wrapper JS object.
|
41
|
+
* inline const WrapperTypeInfo* ToWrapperTypeInfo(
|
42
|
+
* v8::Local<v8::Object> wrapper) {
|
43
|
+
* return GetInternalField<WrapperTypeInfo,
|
44
|
+
* kV8EmbedderWrapperTypeIndex>(wrapper);
|
45
|
+
* }
|
46
|
+
*
|
47
|
+
* class CustomEmbedderType {
|
48
|
+
* public:
|
49
|
+
* static constexpr const WrapperTypeInfo* GetWrapperTypeInfo() {
|
50
|
+
* return &custom_type_wrapper_type_info;
|
51
|
+
* }
|
52
|
+
* // Returns the raw C object from a wrapper JS object.
|
53
|
+
* static CustomEmbedderType* Unwrap(v8::Local<v8::Object> wrapper) {
|
54
|
+
* return GetInternalField<CustomEmbedderType,
|
55
|
+
* kV8EmbedderWrapperObjectIndex>(wrapper);
|
56
|
+
* }
|
57
|
+
* static void FastMethod(CustomEmbedderType* receiver, int param) {
|
58
|
+
* assert(receiver != nullptr);
|
59
|
+
* // Type checks are already done by the optimized code.
|
60
|
+
* // Then call some performance-critical method like:
|
61
|
+
* // receiver->Method(param);
|
62
|
+
* }
|
63
|
+
*
|
64
|
+
* static void SlowMethod(
|
65
|
+
* const v8::FunctionCallbackInfo<v8::Value>& info) {
|
66
|
+
* v8::Local<v8::Object> instance =
|
67
|
+
* v8::Local<v8::Object>::Cast(info.Holder());
|
68
|
+
* CustomEmbedderType* receiver = Unwrap(instance);
|
69
|
+
* // TODO: Do type checks and extract {param}.
|
70
|
+
* FastMethod(receiver, param);
|
71
|
+
* }
|
72
|
+
*
|
73
|
+
* private:
|
74
|
+
* static const WrapperTypeInfo custom_type_wrapper_type_info;
|
75
|
+
* };
|
76
|
+
*
|
77
|
+
* // Support for custom embedder types via specialization of WrapperTraits.
|
78
|
+
* namespace v8 {
|
79
|
+
* template <>
|
80
|
+
* class WrapperTraits<CustomEmbedderType> {
|
81
|
+
* public:
|
82
|
+
* static const void* GetTypeInfo() {
|
83
|
+
* // We use the already defined machinery for the custom type.
|
84
|
+
* return CustomEmbedderType::GetWrapperTypeInfo();
|
85
|
+
* }
|
86
|
+
* };
|
87
|
+
* } // namespace v8
|
88
|
+
*
|
89
|
+
* // The constants kV8EmbedderWrapperTypeIndex and
|
90
|
+
* // kV8EmbedderWrapperObjectIndex describe the offsets for the type info
|
91
|
+
* // struct (the one returned by WrapperTraits::GetTypeInfo) and the
|
92
|
+
* // native object, when expressed as internal field indices within a
|
93
|
+
* // JSObject. The existance of this helper function assumes that all
|
94
|
+
* // embedder objects have their JSObject-side type info at the same
|
95
|
+
* // offset, but this is not a limitation of the API itself. For a detailed
|
96
|
+
* // use case, see the third example.
|
97
|
+
* static constexpr int kV8EmbedderWrapperTypeIndex = 0;
|
98
|
+
* static constexpr int kV8EmbedderWrapperObjectIndex = 1;
|
99
|
+
*
|
100
|
+
* // The following setup function can be templatized based on
|
101
|
+
* // the {embedder_object} argument.
|
102
|
+
* void SetupCustomEmbedderObject(v8::Isolate* isolate,
|
103
|
+
* v8::Local<v8::Context> context,
|
104
|
+
* CustomEmbedderType* embedder_object) {
|
105
|
+
* isolate->set_embedder_wrapper_type_index(
|
106
|
+
* kV8EmbedderWrapperTypeIndex);
|
107
|
+
* isolate->set_embedder_wrapper_object_index(
|
108
|
+
* kV8EmbedderWrapperObjectIndex);
|
109
|
+
*
|
110
|
+
* v8::CFunction c_func =
|
111
|
+
* MakeV8CFunction(CustomEmbedderType::FastMethod);
|
112
|
+
*
|
113
|
+
* Local<v8::FunctionTemplate> method_template =
|
114
|
+
* v8::FunctionTemplate::New(
|
115
|
+
* isolate, CustomEmbedderType::SlowMethod, v8::Local<v8::Value>(),
|
116
|
+
* v8::Local<v8::Signature>(), 1, v8::ConstructorBehavior::kAllow,
|
117
|
+
* v8::SideEffectType::kHasSideEffect, &c_func);
|
118
|
+
*
|
119
|
+
* v8::Local<v8::ObjectTemplate> object_template =
|
120
|
+
* v8::ObjectTemplate::New(isolate);
|
121
|
+
* object_template->SetInternalFieldCount(
|
122
|
+
* kV8EmbedderWrapperObjectIndex + 1);
|
123
|
+
* object_template->Set(
|
124
|
+
v8::String::NewFromUtf8Literal(isolate, "method"), method_template);
|
125
|
+
*
|
126
|
+
* // Instantiate the wrapper JS object.
|
127
|
+
* v8::Local<v8::Object> object =
|
128
|
+
* object_template->NewInstance(context).ToLocalChecked();
|
129
|
+
* object->SetAlignedPointerInInternalField(
|
130
|
+
* kV8EmbedderWrapperObjectIndex,
|
131
|
+
* reinterpret_cast<void*>(embedder_object));
|
132
|
+
*
|
133
|
+
* // TODO: Expose {object} where it's necessary.
|
134
|
+
* }
|
135
|
+
* \endcode
|
136
|
+
*
|
137
|
+
* For instance if {object} is exposed via a global "obj" variable,
|
138
|
+
* one could write in JS:
|
139
|
+
* function hot_func() {
|
140
|
+
* obj.method(42);
|
141
|
+
* }
|
142
|
+
* and once {hot_func} gets optimized, CustomEmbedderType::FastMethod
|
143
|
+
* will be called instead of the slow version, with the following arguments:
|
144
|
+
* receiver := the {embedder_object} from above
|
145
|
+
* param := 42
|
146
|
+
*
|
147
|
+
* Currently only void return types are supported.
|
148
|
+
* Currently supported argument types:
|
149
|
+
* - pointer to an embedder type
|
150
|
+
* - bool
|
151
|
+
* - int32_t
|
152
|
+
* - uint32_t
|
153
|
+
* To be supported types:
|
154
|
+
* - int64_t
|
155
|
+
* - uint64_t
|
156
|
+
* - float32_t
|
157
|
+
* - float64_t
|
158
|
+
* - arrays of C types
|
159
|
+
* - arrays of embedder types
|
160
|
+
*/
|
161
|
+
|
162
|
+
#ifndef INCLUDE_V8_FAST_API_CALLS_H_
|
163
|
+
#define INCLUDE_V8_FAST_API_CALLS_H_
|
164
|
+
|
165
|
+
#include <stddef.h>
|
166
|
+
#include <stdint.h>
|
167
|
+
|
168
|
+
#include "v8config.h" // NOLINT(build/include_directory)
|
169
|
+
|
170
|
+
namespace v8 {
|
171
|
+
|
172
|
+
class CTypeInfo {
|
173
|
+
public:
|
174
|
+
enum class Type : char {
|
175
|
+
kVoid,
|
176
|
+
kBool,
|
177
|
+
kInt32,
|
178
|
+
kUint32,
|
179
|
+
kInt64,
|
180
|
+
kUint64,
|
181
|
+
kFloat32,
|
182
|
+
kFloat64,
|
183
|
+
kUnwrappedApiObject,
|
184
|
+
};
|
185
|
+
|
186
|
+
enum class ArgFlags : uint8_t {
|
187
|
+
kNone = 0,
|
188
|
+
kIsArrayBit = 1 << 0, // This argument is first in an array of values.
|
189
|
+
};
|
190
|
+
|
191
|
+
static CTypeInfo FromWrapperType(const void* wrapper_type_info,
|
192
|
+
ArgFlags flags = ArgFlags::kNone) {
|
193
|
+
uintptr_t wrapper_type_info_ptr =
|
194
|
+
reinterpret_cast<uintptr_t>(wrapper_type_info);
|
195
|
+
// Check that the lower kIsWrapperTypeBit bits are 0's.
|
196
|
+
CHECK_EQ(
|
197
|
+
wrapper_type_info_ptr & ~(static_cast<uintptr_t>(~0)
|
198
|
+
<< static_cast<uintptr_t>(kIsWrapperTypeBit)),
|
199
|
+
0u);
|
200
|
+
// TODO(mslekova): Refactor the manual bit manipulations to use
|
201
|
+
// PointerWithPayload instead.
|
202
|
+
return CTypeInfo(wrapper_type_info_ptr | static_cast<int>(flags) |
|
203
|
+
kIsWrapperTypeBit);
|
204
|
+
}
|
205
|
+
|
206
|
+
static constexpr CTypeInfo FromCType(Type ctype,
|
207
|
+
ArgFlags flags = ArgFlags::kNone) {
|
208
|
+
// ctype cannot be Type::kUnwrappedApiObject.
|
209
|
+
return CTypeInfo(
|
210
|
+
((static_cast<uintptr_t>(ctype) << kTypeOffset) & kTypeMask) |
|
211
|
+
static_cast<int>(flags));
|
212
|
+
}
|
213
|
+
|
214
|
+
const void* GetWrapperInfo() const;
|
215
|
+
|
216
|
+
constexpr Type GetType() const {
|
217
|
+
if (payload_ & kIsWrapperTypeBit) {
|
218
|
+
return Type::kUnwrappedApiObject;
|
219
|
+
}
|
220
|
+
return static_cast<Type>((payload_ & kTypeMask) >> kTypeOffset);
|
221
|
+
}
|
222
|
+
|
223
|
+
constexpr bool IsArray() const {
|
224
|
+
return payload_ & static_cast<int>(ArgFlags::kIsArrayBit);
|
225
|
+
}
|
226
|
+
|
227
|
+
private:
|
228
|
+
explicit constexpr CTypeInfo(uintptr_t payload) : payload_(payload) {}
|
229
|
+
|
230
|
+
// That must be the last bit after ArgFlags.
|
231
|
+
static constexpr uintptr_t kIsWrapperTypeBit = 1 << 1;
|
232
|
+
static constexpr uintptr_t kWrapperTypeInfoMask = static_cast<uintptr_t>(~0)
|
233
|
+
<< 2;
|
234
|
+
|
235
|
+
static constexpr unsigned int kTypeOffset = kIsWrapperTypeBit;
|
236
|
+
static constexpr unsigned int kTypeSize = 8 - kTypeOffset;
|
237
|
+
static constexpr uintptr_t kTypeMask =
|
238
|
+
(~(static_cast<uintptr_t>(~0) << kTypeSize)) << kTypeOffset;
|
239
|
+
|
240
|
+
const uintptr_t payload_;
|
241
|
+
};
|
242
|
+
|
243
|
+
class CFunctionInfo {
|
244
|
+
public:
|
245
|
+
virtual const CTypeInfo& ReturnInfo() const = 0;
|
246
|
+
virtual unsigned int ArgumentCount() const = 0;
|
247
|
+
virtual const CTypeInfo& ArgumentInfo(unsigned int index) const = 0;
|
248
|
+
};
|
249
|
+
|
250
|
+
template <typename T>
|
251
|
+
class WrapperTraits {
|
252
|
+
public:
|
253
|
+
static const void* GetTypeInfo() {
|
254
|
+
static_assert(sizeof(T) != sizeof(T),
|
255
|
+
"WrapperTraits must be specialized for this type.");
|
256
|
+
return nullptr;
|
257
|
+
}
|
258
|
+
};
|
259
|
+
|
260
|
+
namespace internal {
|
261
|
+
|
262
|
+
template <typename T>
|
263
|
+
struct GetCType {
|
264
|
+
static_assert(sizeof(T) != sizeof(T), "Unsupported CType");
|
265
|
+
};
|
266
|
+
|
267
|
+
#define SPECIALIZE_GET_C_TYPE_FOR(ctype, ctypeinfo) \
|
268
|
+
template <> \
|
269
|
+
struct GetCType<ctype> { \
|
270
|
+
static constexpr CTypeInfo Get() { \
|
271
|
+
return CTypeInfo::FromCType(CTypeInfo::Type::ctypeinfo); \
|
272
|
+
} \
|
273
|
+
};
|
274
|
+
|
275
|
+
#define SUPPORTED_C_TYPES(V) \
|
276
|
+
V(void, kVoid) \
|
277
|
+
V(bool, kBool) \
|
278
|
+
V(int32_t, kInt32) \
|
279
|
+
V(uint32_t, kUint32) \
|
280
|
+
V(int64_t, kInt64) \
|
281
|
+
V(uint64_t, kUint64) \
|
282
|
+
V(float, kFloat32) \
|
283
|
+
V(double, kFloat64)
|
284
|
+
|
285
|
+
SUPPORTED_C_TYPES(SPECIALIZE_GET_C_TYPE_FOR)
|
286
|
+
|
287
|
+
template <typename T, typename = void>
|
288
|
+
struct EnableIfHasWrapperTypeInfo {};
|
289
|
+
|
290
|
+
template <typename T>
|
291
|
+
struct EnableIfHasWrapperTypeInfo<T, decltype(WrapperTraits<T>::GetTypeInfo(),
|
292
|
+
void())> {
|
293
|
+
typedef void type;
|
294
|
+
};
|
295
|
+
|
296
|
+
// T* where T is a primitive (array of primitives).
|
297
|
+
template <typename T, typename = void>
|
298
|
+
struct GetCTypePointerImpl {
|
299
|
+
static constexpr CTypeInfo Get() {
|
300
|
+
return CTypeInfo::FromCType(GetCType<T>::Get().GetType(),
|
301
|
+
CTypeInfo::ArgFlags::kIsArrayBit);
|
302
|
+
}
|
303
|
+
};
|
304
|
+
|
305
|
+
// T* where T is an API object.
|
306
|
+
template <typename T>
|
307
|
+
struct GetCTypePointerImpl<T, typename EnableIfHasWrapperTypeInfo<T>::type> {
|
308
|
+
static constexpr CTypeInfo Get() {
|
309
|
+
return CTypeInfo::FromWrapperType(WrapperTraits<T>::GetTypeInfo());
|
310
|
+
}
|
311
|
+
};
|
312
|
+
|
313
|
+
// T** where T is a primitive. Not allowed.
|
314
|
+
template <typename T, typename = void>
|
315
|
+
struct GetCTypePointerPointerImpl {
|
316
|
+
static_assert(sizeof(T**) != sizeof(T**), "Unsupported type");
|
317
|
+
};
|
318
|
+
|
319
|
+
// T** where T is an API object (array of API objects).
|
320
|
+
template <typename T>
|
321
|
+
struct GetCTypePointerPointerImpl<
|
322
|
+
T, typename EnableIfHasWrapperTypeInfo<T>::type> {
|
323
|
+
static constexpr CTypeInfo Get() {
|
324
|
+
return CTypeInfo::FromWrapperType(WrapperTraits<T>::GetTypeInfo(),
|
325
|
+
CTypeInfo::ArgFlags::kIsArrayBit);
|
326
|
+
}
|
327
|
+
};
|
328
|
+
|
329
|
+
template <typename T>
|
330
|
+
struct GetCType<T**> : public GetCTypePointerPointerImpl<T> {};
|
331
|
+
|
332
|
+
template <typename T>
|
333
|
+
struct GetCType<T*> : public GetCTypePointerImpl<T> {};
|
334
|
+
|
335
|
+
template <typename R, typename... Args>
|
336
|
+
class CFunctionInfoImpl : public CFunctionInfo {
|
337
|
+
public:
|
338
|
+
CFunctionInfoImpl()
|
339
|
+
: return_info_(internal::GetCType<R>::Get()),
|
340
|
+
arg_count_(sizeof...(Args)),
|
341
|
+
arg_info_{internal::GetCType<Args>::Get()...} {
|
342
|
+
static_assert(
|
343
|
+
internal::GetCType<R>::Get().GetType() == CTypeInfo::Type::kVoid,
|
344
|
+
"Only void return types are currently supported.");
|
345
|
+
}
|
346
|
+
|
347
|
+
const CTypeInfo& ReturnInfo() const override { return return_info_; }
|
348
|
+
unsigned int ArgumentCount() const override { return arg_count_; }
|
349
|
+
const CTypeInfo& ArgumentInfo(unsigned int index) const override {
|
350
|
+
CHECK_LT(index, ArgumentCount());
|
351
|
+
return arg_info_[index];
|
352
|
+
}
|
353
|
+
|
354
|
+
private:
|
355
|
+
CTypeInfo return_info_;
|
356
|
+
const unsigned int arg_count_;
|
357
|
+
CTypeInfo arg_info_[sizeof...(Args)];
|
358
|
+
};
|
359
|
+
|
360
|
+
} // namespace internal
|
361
|
+
|
362
|
+
class V8_EXPORT CFunction {
|
363
|
+
public:
|
364
|
+
constexpr CFunction() : address_(nullptr), type_info_(nullptr) {}
|
365
|
+
|
366
|
+
const CTypeInfo& ReturnInfo() const { return type_info_->ReturnInfo(); }
|
367
|
+
|
368
|
+
const CTypeInfo& ArgumentInfo(unsigned int index) const {
|
369
|
+
return type_info_->ArgumentInfo(index);
|
370
|
+
}
|
371
|
+
|
372
|
+
unsigned int ArgumentCount() const { return type_info_->ArgumentCount(); }
|
373
|
+
|
374
|
+
const void* GetAddress() const { return address_; }
|
375
|
+
const CFunctionInfo* GetTypeInfo() const { return type_info_; }
|
376
|
+
|
377
|
+
template <typename F>
|
378
|
+
static CFunction Make(F* func) {
|
379
|
+
return ArgUnwrap<F*>::Make(func);
|
380
|
+
}
|
381
|
+
|
382
|
+
private:
|
383
|
+
const void* address_;
|
384
|
+
const CFunctionInfo* type_info_;
|
385
|
+
|
386
|
+
CFunction(const void* address, const CFunctionInfo* type_info);
|
387
|
+
|
388
|
+
template <typename R, typename... Args>
|
389
|
+
static CFunctionInfo* GetCFunctionInfo() {
|
390
|
+
static internal::CFunctionInfoImpl<R, Args...> instance;
|
391
|
+
return &instance;
|
392
|
+
}
|
393
|
+
|
394
|
+
template <typename F>
|
395
|
+
class ArgUnwrap {
|
396
|
+
static_assert(sizeof(F) != sizeof(F),
|
397
|
+
"CFunction must be created from a function pointer.");
|
398
|
+
};
|
399
|
+
|
400
|
+
template <typename R, typename... Args>
|
401
|
+
class ArgUnwrap<R (*)(Args...)> {
|
402
|
+
public:
|
403
|
+
static CFunction Make(R (*func)(Args...)) {
|
404
|
+
return CFunction(reinterpret_cast<const void*>(func),
|
405
|
+
GetCFunctionInfo<R, Args...>());
|
406
|
+
}
|
407
|
+
};
|
408
|
+
};
|
409
|
+
|
410
|
+
} // namespace v8
|
411
|
+
|
412
|
+
#endif // INCLUDE_V8_FAST_API_CALLS_H_
|
@@ -0,0 +1,13 @@
|
|
1
|
+
// Copyright 2016 the V8 project authors. All rights reserved.
|
2
|
+
// Use of this source code is governed by a BSD-style license that can be
|
3
|
+
// found in the LICENSE file.
|
4
|
+
|
5
|
+
#ifndef V8_V8_INSPECTOR_PROTOCOL_H_
|
6
|
+
#define V8_V8_INSPECTOR_PROTOCOL_H_
|
7
|
+
|
8
|
+
#include "inspector/Debugger.h" // NOLINT(build/include_directory)
|
9
|
+
#include "inspector/Runtime.h" // NOLINT(build/include_directory)
|
10
|
+
#include "inspector/Schema.h" // NOLINT(build/include_directory)
|
11
|
+
#include "v8-inspector.h" // NOLINT(build/include_directory)
|
12
|
+
|
13
|
+
#endif // V8_V8_INSPECTOR_PROTOCOL_H_
|
@@ -0,0 +1,327 @@
|
|
1
|
+
// Copyright 2016 the V8 project authors. All rights reserved.
|
2
|
+
// Use of this source code is governed by a BSD-style license that can be
|
3
|
+
// found in the LICENSE file.
|
4
|
+
|
5
|
+
#ifndef V8_V8_INSPECTOR_H_
|
6
|
+
#define V8_V8_INSPECTOR_H_
|
7
|
+
|
8
|
+
#include <stdint.h>
|
9
|
+
#include <cctype>
|
10
|
+
|
11
|
+
#include <memory>
|
12
|
+
#include <unordered_map>
|
13
|
+
|
14
|
+
#include "v8.h" // NOLINT(build/include_directory)
|
15
|
+
|
16
|
+
namespace v8_inspector {
|
17
|
+
|
18
|
+
namespace protocol {
|
19
|
+
namespace Debugger {
|
20
|
+
namespace API {
|
21
|
+
class SearchMatch;
|
22
|
+
}
|
23
|
+
}
|
24
|
+
namespace Runtime {
|
25
|
+
namespace API {
|
26
|
+
class RemoteObject;
|
27
|
+
class StackTrace;
|
28
|
+
class StackTraceId;
|
29
|
+
}
|
30
|
+
}
|
31
|
+
namespace Schema {
|
32
|
+
namespace API {
|
33
|
+
class Domain;
|
34
|
+
}
|
35
|
+
}
|
36
|
+
} // namespace protocol
|
37
|
+
|
38
|
+
class V8_EXPORT StringView {
|
39
|
+
public:
|
40
|
+
StringView() : m_is8Bit(true), m_length(0), m_characters8(nullptr) {}
|
41
|
+
|
42
|
+
StringView(const uint8_t* characters, size_t length)
|
43
|
+
: m_is8Bit(true), m_length(length), m_characters8(characters) {}
|
44
|
+
|
45
|
+
StringView(const uint16_t* characters, size_t length)
|
46
|
+
: m_is8Bit(false), m_length(length), m_characters16(characters) {}
|
47
|
+
|
48
|
+
bool is8Bit() const { return m_is8Bit; }
|
49
|
+
size_t length() const { return m_length; }
|
50
|
+
|
51
|
+
// TODO(dgozman): add DCHECK(m_is8Bit) to accessors once platform can be used
|
52
|
+
// here.
|
53
|
+
const uint8_t* characters8() const { return m_characters8; }
|
54
|
+
const uint16_t* characters16() const { return m_characters16; }
|
55
|
+
|
56
|
+
private:
|
57
|
+
bool m_is8Bit;
|
58
|
+
size_t m_length;
|
59
|
+
union {
|
60
|
+
const uint8_t* m_characters8;
|
61
|
+
const uint16_t* m_characters16;
|
62
|
+
};
|
63
|
+
};
|
64
|
+
|
65
|
+
class V8_EXPORT StringBuffer {
|
66
|
+
public:
|
67
|
+
virtual ~StringBuffer() = default;
|
68
|
+
virtual StringView string() const = 0;
|
69
|
+
// This method copies contents.
|
70
|
+
static std::unique_ptr<StringBuffer> create(StringView);
|
71
|
+
};
|
72
|
+
|
73
|
+
class V8_EXPORT V8ContextInfo {
|
74
|
+
public:
|
75
|
+
V8ContextInfo(v8::Local<v8::Context> context, int contextGroupId,
|
76
|
+
StringView humanReadableName)
|
77
|
+
: context(context),
|
78
|
+
contextGroupId(contextGroupId),
|
79
|
+
humanReadableName(humanReadableName),
|
80
|
+
hasMemoryOnConsole(false) {}
|
81
|
+
|
82
|
+
v8::Local<v8::Context> context;
|
83
|
+
// Each v8::Context is a part of a group. The group id must be non-zero.
|
84
|
+
int contextGroupId;
|
85
|
+
StringView humanReadableName;
|
86
|
+
StringView origin;
|
87
|
+
StringView auxData;
|
88
|
+
bool hasMemoryOnConsole;
|
89
|
+
|
90
|
+
static int executionContextId(v8::Local<v8::Context> context);
|
91
|
+
|
92
|
+
// Disallow copying and allocating this one.
|
93
|
+
enum NotNullTagEnum { NotNullLiteral };
|
94
|
+
void* operator new(size_t) = delete;
|
95
|
+
void* operator new(size_t, NotNullTagEnum, void*) = delete;
|
96
|
+
void* operator new(size_t, void*) = delete;
|
97
|
+
V8ContextInfo(const V8ContextInfo&) = delete;
|
98
|
+
V8ContextInfo& operator=(const V8ContextInfo&) = delete;
|
99
|
+
};
|
100
|
+
|
101
|
+
class V8_EXPORT V8StackTrace {
|
102
|
+
public:
|
103
|
+
virtual StringView firstNonEmptySourceURL() const = 0;
|
104
|
+
virtual bool isEmpty() const = 0;
|
105
|
+
virtual StringView topSourceURL() const = 0;
|
106
|
+
virtual int topLineNumber() const = 0;
|
107
|
+
virtual int topColumnNumber() const = 0;
|
108
|
+
virtual StringView topScriptId() const = 0;
|
109
|
+
virtual StringView topFunctionName() const = 0;
|
110
|
+
|
111
|
+
virtual ~V8StackTrace() = default;
|
112
|
+
virtual std::unique_ptr<protocol::Runtime::API::StackTrace>
|
113
|
+
buildInspectorObject() const = 0;
|
114
|
+
virtual std::unique_ptr<protocol::Runtime::API::StackTrace>
|
115
|
+
buildInspectorObject(int maxAsyncDepth) const = 0;
|
116
|
+
virtual std::unique_ptr<StringBuffer> toString() const = 0;
|
117
|
+
|
118
|
+
// Safe to pass between threads, drops async chain.
|
119
|
+
virtual std::unique_ptr<V8StackTrace> clone() = 0;
|
120
|
+
};
|
121
|
+
|
122
|
+
class V8_EXPORT V8InspectorSession {
|
123
|
+
public:
|
124
|
+
virtual ~V8InspectorSession() = default;
|
125
|
+
|
126
|
+
// Cross-context inspectable values (DOM nodes in different worlds, etc.).
|
127
|
+
class V8_EXPORT Inspectable {
|
128
|
+
public:
|
129
|
+
virtual v8::Local<v8::Value> get(v8::Local<v8::Context>) = 0;
|
130
|
+
virtual ~Inspectable() = default;
|
131
|
+
};
|
132
|
+
virtual void addInspectedObject(std::unique_ptr<Inspectable>) = 0;
|
133
|
+
|
134
|
+
// Dispatching protocol messages.
|
135
|
+
static bool canDispatchMethod(StringView method);
|
136
|
+
virtual void dispatchProtocolMessage(StringView message) = 0;
|
137
|
+
virtual std::vector<uint8_t> state() = 0;
|
138
|
+
virtual std::vector<std::unique_ptr<protocol::Schema::API::Domain>>
|
139
|
+
supportedDomains() = 0;
|
140
|
+
|
141
|
+
// Debugger actions.
|
142
|
+
virtual void schedulePauseOnNextStatement(StringView breakReason,
|
143
|
+
StringView breakDetails) = 0;
|
144
|
+
virtual void cancelPauseOnNextStatement() = 0;
|
145
|
+
virtual void breakProgram(StringView breakReason,
|
146
|
+
StringView breakDetails) = 0;
|
147
|
+
virtual void setSkipAllPauses(bool) = 0;
|
148
|
+
virtual void resume(bool setTerminateOnResume = false) = 0;
|
149
|
+
virtual void stepOver() = 0;
|
150
|
+
virtual std::vector<std::unique_ptr<protocol::Debugger::API::SearchMatch>>
|
151
|
+
searchInTextByLines(StringView text, StringView query, bool caseSensitive,
|
152
|
+
bool isRegex) = 0;
|
153
|
+
|
154
|
+
// Remote objects.
|
155
|
+
virtual std::unique_ptr<protocol::Runtime::API::RemoteObject> wrapObject(
|
156
|
+
v8::Local<v8::Context>, v8::Local<v8::Value>, StringView groupName,
|
157
|
+
bool generatePreview) = 0;
|
158
|
+
|
159
|
+
virtual bool unwrapObject(std::unique_ptr<StringBuffer>* error,
|
160
|
+
StringView objectId, v8::Local<v8::Value>*,
|
161
|
+
v8::Local<v8::Context>*,
|
162
|
+
std::unique_ptr<StringBuffer>* objectGroup) = 0;
|
163
|
+
virtual void releaseObjectGroup(StringView) = 0;
|
164
|
+
virtual void triggerPreciseCoverageDeltaUpdate(StringView occassion) = 0;
|
165
|
+
};
|
166
|
+
|
167
|
+
class V8_EXPORT V8InspectorClient {
|
168
|
+
public:
|
169
|
+
virtual ~V8InspectorClient() = default;
|
170
|
+
|
171
|
+
virtual void runMessageLoopOnPause(int contextGroupId) {}
|
172
|
+
virtual void quitMessageLoopOnPause() {}
|
173
|
+
virtual void runIfWaitingForDebugger(int contextGroupId) {}
|
174
|
+
|
175
|
+
virtual void muteMetrics(int contextGroupId) {}
|
176
|
+
virtual void unmuteMetrics(int contextGroupId) {}
|
177
|
+
|
178
|
+
virtual void beginUserGesture() {}
|
179
|
+
virtual void endUserGesture() {}
|
180
|
+
|
181
|
+
virtual std::unique_ptr<StringBuffer> valueSubtype(v8::Local<v8::Value>) {
|
182
|
+
return nullptr;
|
183
|
+
}
|
184
|
+
virtual bool formatAccessorsAsProperties(v8::Local<v8::Value>) {
|
185
|
+
return false;
|
186
|
+
}
|
187
|
+
virtual bool isInspectableHeapObject(v8::Local<v8::Object>) { return true; }
|
188
|
+
|
189
|
+
virtual v8::Local<v8::Context> ensureDefaultContextInGroup(
|
190
|
+
int contextGroupId) {
|
191
|
+
return v8::Local<v8::Context>();
|
192
|
+
}
|
193
|
+
virtual void beginEnsureAllContextsInGroup(int contextGroupId) {}
|
194
|
+
virtual void endEnsureAllContextsInGroup(int contextGroupId) {}
|
195
|
+
|
196
|
+
virtual void installAdditionalCommandLineAPI(v8::Local<v8::Context>,
|
197
|
+
v8::Local<v8::Object>) {}
|
198
|
+
virtual void consoleAPIMessage(int contextGroupId,
|
199
|
+
v8::Isolate::MessageErrorLevel level,
|
200
|
+
const StringView& message,
|
201
|
+
const StringView& url, unsigned lineNumber,
|
202
|
+
unsigned columnNumber, V8StackTrace*) {}
|
203
|
+
virtual v8::MaybeLocal<v8::Value> memoryInfo(v8::Isolate*,
|
204
|
+
v8::Local<v8::Context>) {
|
205
|
+
return v8::MaybeLocal<v8::Value>();
|
206
|
+
}
|
207
|
+
|
208
|
+
virtual void consoleTime(const StringView& title) {}
|
209
|
+
virtual void consoleTimeEnd(const StringView& title) {}
|
210
|
+
virtual void consoleTimeStamp(const StringView& title) {}
|
211
|
+
virtual void consoleClear(int contextGroupId) {}
|
212
|
+
virtual double currentTimeMS() { return 0; }
|
213
|
+
typedef void (*TimerCallback)(void*);
|
214
|
+
virtual void startRepeatingTimer(double, TimerCallback, void* data) {}
|
215
|
+
virtual void cancelTimer(void* data) {}
|
216
|
+
|
217
|
+
// TODO(dgozman): this was added to support service worker shadow page. We
|
218
|
+
// should not connect at all.
|
219
|
+
virtual bool canExecuteScripts(int contextGroupId) { return true; }
|
220
|
+
|
221
|
+
virtual void maxAsyncCallStackDepthChanged(int depth) {}
|
222
|
+
|
223
|
+
virtual std::unique_ptr<StringBuffer> resourceNameToUrl(
|
224
|
+
const StringView& resourceName) {
|
225
|
+
return nullptr;
|
226
|
+
}
|
227
|
+
};
|
228
|
+
|
229
|
+
// These stack trace ids are intended to be passed between debuggers and be
|
230
|
+
// resolved later. This allows to track cross-debugger calls and step between
|
231
|
+
// them if a single client connects to multiple debuggers.
|
232
|
+
struct V8_EXPORT V8StackTraceId {
|
233
|
+
uintptr_t id;
|
234
|
+
std::pair<int64_t, int64_t> debugger_id;
|
235
|
+
bool should_pause = false;
|
236
|
+
|
237
|
+
V8StackTraceId();
|
238
|
+
V8StackTraceId(const V8StackTraceId&) = default;
|
239
|
+
V8StackTraceId(uintptr_t id, const std::pair<int64_t, int64_t> debugger_id);
|
240
|
+
V8StackTraceId(uintptr_t id, const std::pair<int64_t, int64_t> debugger_id,
|
241
|
+
bool should_pause);
|
242
|
+
explicit V8StackTraceId(StringView);
|
243
|
+
V8StackTraceId& operator=(const V8StackTraceId&) = default;
|
244
|
+
V8StackTraceId& operator=(V8StackTraceId&&) noexcept = default;
|
245
|
+
~V8StackTraceId() = default;
|
246
|
+
|
247
|
+
bool IsInvalid() const;
|
248
|
+
std::unique_ptr<StringBuffer> ToString();
|
249
|
+
};
|
250
|
+
|
251
|
+
class V8_EXPORT V8Inspector {
|
252
|
+
public:
|
253
|
+
static std::unique_ptr<V8Inspector> create(v8::Isolate*, V8InspectorClient*);
|
254
|
+
virtual ~V8Inspector() = default;
|
255
|
+
|
256
|
+
// Contexts instrumentation.
|
257
|
+
virtual void contextCreated(const V8ContextInfo&) = 0;
|
258
|
+
virtual void contextDestroyed(v8::Local<v8::Context>) = 0;
|
259
|
+
virtual void resetContextGroup(int contextGroupId) = 0;
|
260
|
+
virtual v8::MaybeLocal<v8::Context> contextById(int contextId) = 0;
|
261
|
+
|
262
|
+
// Various instrumentation.
|
263
|
+
virtual void idleStarted() = 0;
|
264
|
+
virtual void idleFinished() = 0;
|
265
|
+
|
266
|
+
// Async stack traces instrumentation.
|
267
|
+
virtual void asyncTaskScheduled(StringView taskName, void* task,
|
268
|
+
bool recurring) = 0;
|
269
|
+
virtual void asyncTaskCanceled(void* task) = 0;
|
270
|
+
virtual void asyncTaskStarted(void* task) = 0;
|
271
|
+
virtual void asyncTaskFinished(void* task) = 0;
|
272
|
+
virtual void allAsyncTasksCanceled() = 0;
|
273
|
+
|
274
|
+
virtual V8StackTraceId storeCurrentStackTrace(StringView description) = 0;
|
275
|
+
virtual void externalAsyncTaskStarted(const V8StackTraceId& parent) = 0;
|
276
|
+
virtual void externalAsyncTaskFinished(const V8StackTraceId& parent) = 0;
|
277
|
+
|
278
|
+
// Exceptions instrumentation.
|
279
|
+
virtual unsigned exceptionThrown(v8::Local<v8::Context>, StringView message,
|
280
|
+
v8::Local<v8::Value> exception,
|
281
|
+
StringView detailedMessage, StringView url,
|
282
|
+
unsigned lineNumber, unsigned columnNumber,
|
283
|
+
std::unique_ptr<V8StackTrace>,
|
284
|
+
int scriptId) = 0;
|
285
|
+
virtual void exceptionRevoked(v8::Local<v8::Context>, unsigned exceptionId,
|
286
|
+
StringView message) = 0;
|
287
|
+
|
288
|
+
// Connection.
|
289
|
+
class V8_EXPORT Channel {
|
290
|
+
public:
|
291
|
+
virtual ~Channel() = default;
|
292
|
+
virtual void sendResponse(int callId,
|
293
|
+
std::unique_ptr<StringBuffer> message) = 0;
|
294
|
+
virtual void sendNotification(std::unique_ptr<StringBuffer> message) = 0;
|
295
|
+
virtual void flushProtocolNotifications() = 0;
|
296
|
+
};
|
297
|
+
virtual std::unique_ptr<V8InspectorSession> connect(int contextGroupId,
|
298
|
+
Channel*,
|
299
|
+
StringView state) = 0;
|
300
|
+
|
301
|
+
// API methods.
|
302
|
+
virtual std::unique_ptr<V8StackTrace> createStackTrace(
|
303
|
+
v8::Local<v8::StackTrace>) = 0;
|
304
|
+
virtual std::unique_ptr<V8StackTrace> captureStackTrace(bool fullStack) = 0;
|
305
|
+
|
306
|
+
// Performance counters.
|
307
|
+
class V8_EXPORT Counters : public std::enable_shared_from_this<Counters> {
|
308
|
+
public:
|
309
|
+
explicit Counters(v8::Isolate* isolate);
|
310
|
+
~Counters();
|
311
|
+
const std::unordered_map<std::string, int>& getCountersMap() const {
|
312
|
+
return m_countersMap;
|
313
|
+
}
|
314
|
+
|
315
|
+
private:
|
316
|
+
static int* getCounterPtr(const char* name);
|
317
|
+
|
318
|
+
v8::Isolate* m_isolate;
|
319
|
+
std::unordered_map<std::string, int> m_countersMap;
|
320
|
+
};
|
321
|
+
|
322
|
+
virtual std::shared_ptr<Counters> enableCounters() = 0;
|
323
|
+
};
|
324
|
+
|
325
|
+
} // namespace v8_inspector
|
326
|
+
|
327
|
+
#endif // V8_V8_INSPECTOR_H_
|