libv8-node 15.14.0.1-x86_64-darwin-21

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (56) hide show
  1. checksums.yaml +7 -0
  2. data/ext/libv8-node/.location.yml +1 -0
  3. data/ext/libv8-node/location.rb +76 -0
  4. data/ext/libv8-node/paths.rb +30 -0
  5. data/lib/libv8/node/version.rb +7 -0
  6. data/lib/libv8/node.rb +11 -0
  7. data/lib/libv8-node.rb +1 -0
  8. data/vendor/v8/include/cppgc/allocation.h +173 -0
  9. data/vendor/v8/include/cppgc/common.h +26 -0
  10. data/vendor/v8/include/cppgc/custom-space.h +62 -0
  11. data/vendor/v8/include/cppgc/default-platform.h +76 -0
  12. data/vendor/v8/include/cppgc/garbage-collected.h +116 -0
  13. data/vendor/v8/include/cppgc/heap.h +139 -0
  14. data/vendor/v8/include/cppgc/internal/api-constants.h +47 -0
  15. data/vendor/v8/include/cppgc/internal/atomic-entry-flag.h +48 -0
  16. data/vendor/v8/include/cppgc/internal/caged-heap-local-data.h +67 -0
  17. data/vendor/v8/include/cppgc/internal/compiler-specific.h +38 -0
  18. data/vendor/v8/include/cppgc/internal/finalizer-trait.h +90 -0
  19. data/vendor/v8/include/cppgc/internal/gc-info.h +45 -0
  20. data/vendor/v8/include/cppgc/internal/logging.h +50 -0
  21. data/vendor/v8/include/cppgc/internal/persistent-node.h +116 -0
  22. data/vendor/v8/include/cppgc/internal/pointer-policies.h +134 -0
  23. data/vendor/v8/include/cppgc/internal/prefinalizer-handler.h +30 -0
  24. data/vendor/v8/include/cppgc/internal/process-heap.h +34 -0
  25. data/vendor/v8/include/cppgc/internal/write-barrier.h +78 -0
  26. data/vendor/v8/include/cppgc/liveness-broker.h +68 -0
  27. data/vendor/v8/include/cppgc/macros.h +24 -0
  28. data/vendor/v8/include/cppgc/member.h +226 -0
  29. data/vendor/v8/include/cppgc/persistent.h +341 -0
  30. data/vendor/v8/include/cppgc/platform.h +130 -0
  31. data/vendor/v8/include/cppgc/prefinalizer.h +52 -0
  32. data/vendor/v8/include/cppgc/source-location.h +91 -0
  33. data/vendor/v8/include/cppgc/trace-trait.h +111 -0
  34. data/vendor/v8/include/cppgc/type-traits.h +109 -0
  35. data/vendor/v8/include/cppgc/visitor.h +213 -0
  36. data/vendor/v8/include/libplatform/libplatform-export.h +29 -0
  37. data/vendor/v8/include/libplatform/libplatform.h +106 -0
  38. data/vendor/v8/include/libplatform/v8-tracing.h +332 -0
  39. data/vendor/v8/include/v8-cppgc.h +226 -0
  40. data/vendor/v8/include/v8-fast-api-calls.h +388 -0
  41. data/vendor/v8/include/v8-inspector-protocol.h +13 -0
  42. data/vendor/v8/include/v8-inspector.h +327 -0
  43. data/vendor/v8/include/v8-internal.h +427 -0
  44. data/vendor/v8/include/v8-metrics.h +133 -0
  45. data/vendor/v8/include/v8-platform.h +684 -0
  46. data/vendor/v8/include/v8-profiler.h +1059 -0
  47. data/vendor/v8/include/v8-util.h +652 -0
  48. data/vendor/v8/include/v8-value-serializer-version.h +24 -0
  49. data/vendor/v8/include/v8-version-string.h +38 -0
  50. data/vendor/v8/include/v8-version.h +20 -0
  51. data/vendor/v8/include/v8-wasm-trap-handler-posix.h +31 -0
  52. data/vendor/v8/include/v8-wasm-trap-handler-win.h +28 -0
  53. data/vendor/v8/include/v8.h +12098 -0
  54. data/vendor/v8/include/v8config.h +484 -0
  55. data/vendor/v8/out.gn/libv8/obj/libv8_monolith.a +0 -0
  56. metadata +126 -0
@@ -0,0 +1,427 @@
1
+ // Copyright 2018 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 INCLUDE_V8_INTERNAL_H_
6
+ #define INCLUDE_V8_INTERNAL_H_
7
+
8
+ #include <stddef.h>
9
+ #include <stdint.h>
10
+ #include <string.h>
11
+ #include <type_traits>
12
+
13
+ #include "v8-version.h" // NOLINT(build/include_directory)
14
+ #include "v8config.h" // NOLINT(build/include_directory)
15
+
16
+ namespace v8 {
17
+
18
+ class Context;
19
+ class Data;
20
+ class Isolate;
21
+
22
+ namespace internal {
23
+
24
+ class Isolate;
25
+
26
+ typedef uintptr_t Address;
27
+ static const Address kNullAddress = 0;
28
+
29
+ /**
30
+ * Configuration of tagging scheme.
31
+ */
32
+ const int kApiSystemPointerSize = sizeof(void*);
33
+ const int kApiDoubleSize = sizeof(double);
34
+ const int kApiInt32Size = sizeof(int32_t);
35
+ const int kApiInt64Size = sizeof(int64_t);
36
+
37
+ // Tag information for HeapObject.
38
+ const int kHeapObjectTag = 1;
39
+ const int kWeakHeapObjectTag = 3;
40
+ const int kHeapObjectTagSize = 2;
41
+ const intptr_t kHeapObjectTagMask = (1 << kHeapObjectTagSize) - 1;
42
+
43
+ // Tag information for Smi.
44
+ const int kSmiTag = 0;
45
+ const int kSmiTagSize = 1;
46
+ const intptr_t kSmiTagMask = (1 << kSmiTagSize) - 1;
47
+
48
+ template <size_t tagged_ptr_size>
49
+ struct SmiTagging;
50
+
51
+ constexpr intptr_t kIntptrAllBitsSet = intptr_t{-1};
52
+ constexpr uintptr_t kUintptrAllBitsSet =
53
+ static_cast<uintptr_t>(kIntptrAllBitsSet);
54
+
55
+ // Smi constants for systems where tagged pointer is a 32-bit value.
56
+ template <>
57
+ struct SmiTagging<4> {
58
+ enum { kSmiShiftSize = 0, kSmiValueSize = 31 };
59
+
60
+ static constexpr intptr_t kSmiMinValue =
61
+ static_cast<intptr_t>(kUintptrAllBitsSet << (kSmiValueSize - 1));
62
+ static constexpr intptr_t kSmiMaxValue = -(kSmiMinValue + 1);
63
+
64
+ V8_INLINE static int SmiToInt(const internal::Address value) {
65
+ int shift_bits = kSmiTagSize + kSmiShiftSize;
66
+ // Truncate and shift down (requires >> to be sign extending).
67
+ return static_cast<int32_t>(static_cast<uint32_t>(value)) >> shift_bits;
68
+ }
69
+ V8_INLINE static constexpr bool IsValidSmi(intptr_t value) {
70
+ // Is value in range [kSmiMinValue, kSmiMaxValue].
71
+ // Use unsigned operations in order to avoid undefined behaviour in case of
72
+ // signed integer overflow.
73
+ return (static_cast<uintptr_t>(value) -
74
+ static_cast<uintptr_t>(kSmiMinValue)) <=
75
+ (static_cast<uintptr_t>(kSmiMaxValue) -
76
+ static_cast<uintptr_t>(kSmiMinValue));
77
+ }
78
+ };
79
+
80
+ // Smi constants for systems where tagged pointer is a 64-bit value.
81
+ template <>
82
+ struct SmiTagging<8> {
83
+ enum { kSmiShiftSize = 31, kSmiValueSize = 32 };
84
+
85
+ static constexpr intptr_t kSmiMinValue =
86
+ static_cast<intptr_t>(kUintptrAllBitsSet << (kSmiValueSize - 1));
87
+ static constexpr intptr_t kSmiMaxValue = -(kSmiMinValue + 1);
88
+
89
+ V8_INLINE static int SmiToInt(const internal::Address value) {
90
+ int shift_bits = kSmiTagSize + kSmiShiftSize;
91
+ // Shift down and throw away top 32 bits.
92
+ return static_cast<int>(static_cast<intptr_t>(value) >> shift_bits);
93
+ }
94
+ V8_INLINE static constexpr bool IsValidSmi(intptr_t value) {
95
+ // To be representable as a long smi, the value must be a 32-bit integer.
96
+ return (value == static_cast<int32_t>(value));
97
+ }
98
+ };
99
+
100
+ #ifdef V8_COMPRESS_POINTERS
101
+ static_assert(
102
+ kApiSystemPointerSize == kApiInt64Size,
103
+ "Pointer compression can be enabled only for 64-bit architectures");
104
+ const int kApiTaggedSize = kApiInt32Size;
105
+ #else
106
+ const int kApiTaggedSize = kApiSystemPointerSize;
107
+ #endif
108
+
109
+ constexpr bool PointerCompressionIsEnabled() {
110
+ return kApiTaggedSize != kApiSystemPointerSize;
111
+ }
112
+
113
+ constexpr bool HeapSandboxIsEnabled() {
114
+ #ifdef V8_HEAP_SANDBOX
115
+ return true;
116
+ #else
117
+ return false;
118
+ #endif
119
+ }
120
+
121
+ using ExternalPointer_t = Address;
122
+
123
+ #ifdef V8_31BIT_SMIS_ON_64BIT_ARCH
124
+ using PlatformSmiTagging = SmiTagging<kApiInt32Size>;
125
+ #else
126
+ using PlatformSmiTagging = SmiTagging<kApiTaggedSize>;
127
+ #endif
128
+
129
+ // TODO(ishell): Consinder adding kSmiShiftBits = kSmiShiftSize + kSmiTagSize
130
+ // since it's used much more often than the inividual constants.
131
+ const int kSmiShiftSize = PlatformSmiTagging::kSmiShiftSize;
132
+ const int kSmiValueSize = PlatformSmiTagging::kSmiValueSize;
133
+ const int kSmiMinValue = static_cast<int>(PlatformSmiTagging::kSmiMinValue);
134
+ const int kSmiMaxValue = static_cast<int>(PlatformSmiTagging::kSmiMaxValue);
135
+ constexpr bool SmiValuesAre31Bits() { return kSmiValueSize == 31; }
136
+ constexpr bool SmiValuesAre32Bits() { return kSmiValueSize == 32; }
137
+
138
+ V8_INLINE static constexpr internal::Address IntToSmi(int value) {
139
+ return (static_cast<Address>(value) << (kSmiTagSize + kSmiShiftSize)) |
140
+ kSmiTag;
141
+ }
142
+
143
+ // {obj} must be the raw tagged pointer representation of a HeapObject
144
+ // that's guaranteed to never be in ReadOnlySpace.
145
+ V8_EXPORT internal::Isolate* IsolateFromNeverReadOnlySpaceObject(Address obj);
146
+
147
+ // Returns if we need to throw when an error occurs. This infers the language
148
+ // mode based on the current context and the closure. This returns true if the
149
+ // language mode is strict.
150
+ V8_EXPORT bool ShouldThrowOnError(v8::internal::Isolate* isolate);
151
+
152
+ /**
153
+ * This class exports constants and functionality from within v8 that
154
+ * is necessary to implement inline functions in the v8 api. Don't
155
+ * depend on functions and constants defined here.
156
+ */
157
+ class Internals {
158
+ public:
159
+ // These values match non-compiler-dependent values defined within
160
+ // the implementation of v8.
161
+ static const int kHeapObjectMapOffset = 0;
162
+ static const int kMapInstanceTypeOffset = 1 * kApiTaggedSize + kApiInt32Size;
163
+ static const int kStringResourceOffset =
164
+ 1 * kApiTaggedSize + 2 * kApiInt32Size;
165
+
166
+ static const int kOddballKindOffset = 4 * kApiTaggedSize + kApiDoubleSize;
167
+ static const int kJSObjectHeaderSize = 3 * kApiTaggedSize;
168
+ static const int kFixedArrayHeaderSize = 2 * kApiTaggedSize;
169
+ static const int kEmbedderDataArrayHeaderSize = 2 * kApiTaggedSize;
170
+ static const int kEmbedderDataSlotSize = kApiSystemPointerSize;
171
+ static const int kNativeContextEmbedderDataOffset = 6 * kApiTaggedSize;
172
+ static const int kFullStringRepresentationMask = 0x0f;
173
+ static const int kStringEncodingMask = 0x8;
174
+ static const int kExternalTwoByteRepresentationTag = 0x02;
175
+ static const int kExternalOneByteRepresentationTag = 0x0a;
176
+
177
+ static const uint32_t kNumIsolateDataSlots = 4;
178
+
179
+ // IsolateData layout guarantees.
180
+ static const int kIsolateEmbedderDataOffset = 0;
181
+ static const int kIsolateFastCCallCallerFpOffset =
182
+ kNumIsolateDataSlots * kApiSystemPointerSize;
183
+ static const int kIsolateFastCCallCallerPcOffset =
184
+ kIsolateFastCCallCallerFpOffset + kApiSystemPointerSize;
185
+ static const int kIsolateStackGuardOffset =
186
+ kIsolateFastCCallCallerPcOffset + kApiSystemPointerSize;
187
+ static const int kIsolateRootsOffset =
188
+ kIsolateStackGuardOffset + 7 * kApiSystemPointerSize;
189
+
190
+ static const int kUndefinedValueRootIndex = 4;
191
+ static const int kTheHoleValueRootIndex = 5;
192
+ static const int kNullValueRootIndex = 6;
193
+ static const int kTrueValueRootIndex = 7;
194
+ static const int kFalseValueRootIndex = 8;
195
+ static const int kEmptyStringRootIndex = 9;
196
+
197
+ static const int kNodeClassIdOffset = 1 * kApiSystemPointerSize;
198
+ static const int kNodeFlagsOffset = 1 * kApiSystemPointerSize + 3;
199
+ static const int kNodeStateMask = 0x7;
200
+ static const int kNodeStateIsWeakValue = 2;
201
+ static const int kNodeStateIsPendingValue = 3;
202
+
203
+ static const int kFirstNonstringType = 0x40;
204
+ static const int kOddballType = 0x43;
205
+ static const int kForeignType = 0x46;
206
+ static const int kJSSpecialApiObjectType = 0x410;
207
+ static const int kJSApiObjectType = 0x420;
208
+ static const int kJSObjectType = 0x421;
209
+
210
+ static const int kUndefinedOddballKind = 5;
211
+ static const int kNullOddballKind = 3;
212
+
213
+ // Constants used by PropertyCallbackInfo to check if we should throw when an
214
+ // error occurs.
215
+ static const int kThrowOnError = 0;
216
+ static const int kDontThrow = 1;
217
+ static const int kInferShouldThrowMode = 2;
218
+
219
+ // Soft limit for AdjustAmountofExternalAllocatedMemory. Trigger an
220
+ // incremental GC once the external memory reaches this limit.
221
+ static constexpr int kExternalAllocationSoftLimit = 64 * 1024 * 1024;
222
+
223
+ V8_EXPORT static void CheckInitializedImpl(v8::Isolate* isolate);
224
+ V8_INLINE static void CheckInitialized(v8::Isolate* isolate) {
225
+ #ifdef V8_ENABLE_CHECKS
226
+ CheckInitializedImpl(isolate);
227
+ #endif
228
+ }
229
+
230
+ V8_INLINE static bool HasHeapObjectTag(const internal::Address value) {
231
+ return (value & kHeapObjectTagMask) == static_cast<Address>(kHeapObjectTag);
232
+ }
233
+
234
+ V8_INLINE static int SmiValue(const internal::Address value) {
235
+ return PlatformSmiTagging::SmiToInt(value);
236
+ }
237
+
238
+ V8_INLINE static constexpr internal::Address IntToSmi(int value) {
239
+ return internal::IntToSmi(value);
240
+ }
241
+
242
+ V8_INLINE static constexpr bool IsValidSmi(intptr_t value) {
243
+ return PlatformSmiTagging::IsValidSmi(value);
244
+ }
245
+
246
+ V8_INLINE static int GetInstanceType(const internal::Address obj) {
247
+ typedef internal::Address A;
248
+ A map = ReadTaggedPointerField(obj, kHeapObjectMapOffset);
249
+ return ReadRawField<uint16_t>(map, kMapInstanceTypeOffset);
250
+ }
251
+
252
+ V8_INLINE static int GetOddballKind(const internal::Address obj) {
253
+ return SmiValue(ReadTaggedSignedField(obj, kOddballKindOffset));
254
+ }
255
+
256
+ V8_INLINE static bool IsExternalTwoByteString(int instance_type) {
257
+ int representation = (instance_type & kFullStringRepresentationMask);
258
+ return representation == kExternalTwoByteRepresentationTag;
259
+ }
260
+
261
+ V8_INLINE static uint8_t GetNodeFlag(internal::Address* obj, int shift) {
262
+ uint8_t* addr = reinterpret_cast<uint8_t*>(obj) + kNodeFlagsOffset;
263
+ return *addr & static_cast<uint8_t>(1U << shift);
264
+ }
265
+
266
+ V8_INLINE static void UpdateNodeFlag(internal::Address* obj, bool value,
267
+ int shift) {
268
+ uint8_t* addr = reinterpret_cast<uint8_t*>(obj) + kNodeFlagsOffset;
269
+ uint8_t mask = static_cast<uint8_t>(1U << shift);
270
+ *addr = static_cast<uint8_t>((*addr & ~mask) | (value << shift));
271
+ }
272
+
273
+ V8_INLINE static uint8_t GetNodeState(internal::Address* obj) {
274
+ uint8_t* addr = reinterpret_cast<uint8_t*>(obj) + kNodeFlagsOffset;
275
+ return *addr & kNodeStateMask;
276
+ }
277
+
278
+ V8_INLINE static void UpdateNodeState(internal::Address* obj, uint8_t value) {
279
+ uint8_t* addr = reinterpret_cast<uint8_t*>(obj) + kNodeFlagsOffset;
280
+ *addr = static_cast<uint8_t>((*addr & ~kNodeStateMask) | value);
281
+ }
282
+
283
+ V8_INLINE static void SetEmbedderData(v8::Isolate* isolate, uint32_t slot,
284
+ void* data) {
285
+ internal::Address addr = reinterpret_cast<internal::Address>(isolate) +
286
+ kIsolateEmbedderDataOffset +
287
+ slot * kApiSystemPointerSize;
288
+ *reinterpret_cast<void**>(addr) = data;
289
+ }
290
+
291
+ V8_INLINE static void* GetEmbedderData(const v8::Isolate* isolate,
292
+ uint32_t slot) {
293
+ internal::Address addr = reinterpret_cast<internal::Address>(isolate) +
294
+ kIsolateEmbedderDataOffset +
295
+ slot * kApiSystemPointerSize;
296
+ return *reinterpret_cast<void* const*>(addr);
297
+ }
298
+
299
+ V8_INLINE static internal::Address* GetRoot(v8::Isolate* isolate, int index) {
300
+ internal::Address addr = reinterpret_cast<internal::Address>(isolate) +
301
+ kIsolateRootsOffset +
302
+ index * kApiSystemPointerSize;
303
+ return reinterpret_cast<internal::Address*>(addr);
304
+ }
305
+
306
+ template <typename T>
307
+ V8_INLINE static T ReadRawField(internal::Address heap_object_ptr,
308
+ int offset) {
309
+ internal::Address addr = heap_object_ptr + offset - kHeapObjectTag;
310
+ #ifdef V8_COMPRESS_POINTERS
311
+ if (sizeof(T) > kApiTaggedSize) {
312
+ // TODO(ishell, v8:8875): When pointer compression is enabled 8-byte size
313
+ // fields (external pointers, doubles and BigInt data) are only
314
+ // kTaggedSize aligned so we have to use unaligned pointer friendly way of
315
+ // accessing them in order to avoid undefined behavior in C++ code.
316
+ T r;
317
+ memcpy(&r, reinterpret_cast<void*>(addr), sizeof(T));
318
+ return r;
319
+ }
320
+ #endif
321
+ return *reinterpret_cast<const T*>(addr);
322
+ }
323
+
324
+ V8_INLINE static internal::Address ReadTaggedPointerField(
325
+ internal::Address heap_object_ptr, int offset) {
326
+ #ifdef V8_COMPRESS_POINTERS
327
+ uint32_t value = ReadRawField<uint32_t>(heap_object_ptr, offset);
328
+ internal::Address root = GetRootFromOnHeapAddress(heap_object_ptr);
329
+ return root + static_cast<internal::Address>(static_cast<uintptr_t>(value));
330
+ #else
331
+ return ReadRawField<internal::Address>(heap_object_ptr, offset);
332
+ #endif
333
+ }
334
+
335
+ V8_INLINE static internal::Address ReadTaggedSignedField(
336
+ internal::Address heap_object_ptr, int offset) {
337
+ #ifdef V8_COMPRESS_POINTERS
338
+ uint32_t value = ReadRawField<uint32_t>(heap_object_ptr, offset);
339
+ return static_cast<internal::Address>(static_cast<uintptr_t>(value));
340
+ #else
341
+ return ReadRawField<internal::Address>(heap_object_ptr, offset);
342
+ #endif
343
+ }
344
+
345
+ V8_INLINE static internal::Isolate* GetIsolateForHeapSandbox(
346
+ internal::Address obj) {
347
+ #ifdef V8_HEAP_SANDBOX
348
+ return internal::IsolateFromNeverReadOnlySpaceObject(obj);
349
+ #else
350
+ // Not used in non-sandbox mode.
351
+ return nullptr;
352
+ #endif
353
+ }
354
+
355
+ V8_INLINE static internal::Address ReadExternalPointerField(
356
+ internal::Isolate* isolate, internal::Address heap_object_ptr,
357
+ int offset) {
358
+ internal::Address value = ReadRawField<Address>(heap_object_ptr, offset);
359
+ #ifdef V8_HEAP_SANDBOX
360
+ // We currently have to treat zero as nullptr in embedder slots.
361
+ if (value) value = DecodeExternalPointer(isolate, value);
362
+ #endif
363
+ return value;
364
+ }
365
+
366
+ #ifdef V8_COMPRESS_POINTERS
367
+ // See v8:7703 or src/ptr-compr.* for details about pointer compression.
368
+ static constexpr size_t kPtrComprHeapReservationSize = size_t{1} << 32;
369
+ static constexpr size_t kPtrComprIsolateRootAlignment = size_t{1} << 32;
370
+
371
+ // See v8:10391 for details about V8 heap sandbox.
372
+ static constexpr uint32_t kExternalPointerSalt =
373
+ 0x7fffffff & ~static_cast<uint32_t>(kHeapObjectTagMask);
374
+
375
+ V8_INLINE static internal::Address GetRootFromOnHeapAddress(
376
+ internal::Address addr) {
377
+ return addr & -static_cast<intptr_t>(kPtrComprIsolateRootAlignment);
378
+ }
379
+
380
+ V8_INLINE static internal::Address DecompressTaggedAnyField(
381
+ internal::Address heap_object_ptr, uint32_t value) {
382
+ internal::Address root = GetRootFromOnHeapAddress(heap_object_ptr);
383
+ return root + static_cast<internal::Address>(static_cast<uintptr_t>(value));
384
+ }
385
+
386
+ V8_INLINE static Address DecodeExternalPointer(
387
+ const Isolate* isolate, ExternalPointer_t encoded_pointer) {
388
+ #ifndef V8_HEAP_SANDBOX
389
+ return encoded_pointer;
390
+ #else
391
+ return encoded_pointer ^ kExternalPointerSalt;
392
+ #endif
393
+ }
394
+ #endif // V8_COMPRESS_POINTERS
395
+ };
396
+
397
+ // Only perform cast check for types derived from v8::Data since
398
+ // other types do not implement the Cast method.
399
+ template <bool PerformCheck>
400
+ struct CastCheck {
401
+ template <class T>
402
+ static void Perform(T* data);
403
+ };
404
+
405
+ template <>
406
+ template <class T>
407
+ void CastCheck<true>::Perform(T* data) {
408
+ T::Cast(data);
409
+ }
410
+
411
+ template <>
412
+ template <class T>
413
+ void CastCheck<false>::Perform(T* data) {}
414
+
415
+ template <class T>
416
+ V8_INLINE void PerformCastCheck(T* data) {
417
+ CastCheck<std::is_base_of<Data, T>::value>::Perform(data);
418
+ }
419
+
420
+ // A base class for backing stores, which is needed due to vagaries of
421
+ // how static casts work with std::shared_ptr.
422
+ class BackingStoreBase {};
423
+
424
+ } // namespace internal
425
+ } // namespace v8
426
+
427
+ #endif // INCLUDE_V8_INTERNAL_H_
@@ -0,0 +1,133 @@
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
+ #ifndef V8_METRICS_H_
6
+ #define V8_METRICS_H_
7
+
8
+ #include "v8.h" // NOLINT(build/include_directory)
9
+
10
+ namespace v8 {
11
+ namespace metrics {
12
+
13
+ struct WasmModuleDecoded {
14
+ bool async = false;
15
+ bool streamed = false;
16
+ bool success = false;
17
+ size_t module_size_in_bytes = 0;
18
+ size_t function_count = 0;
19
+ int64_t wall_clock_time_in_us = 0;
20
+ };
21
+
22
+ struct WasmModuleCompiled {
23
+ bool async = false;
24
+ bool streamed = false;
25
+ bool cached = false;
26
+ bool deserialized = false;
27
+ bool lazy = false;
28
+ bool success = false;
29
+ size_t code_size_in_bytes = 0;
30
+ size_t liftoff_bailout_count = 0;
31
+ int64_t wall_clock_time_in_us = 0;
32
+ };
33
+
34
+ struct WasmModuleInstantiated {
35
+ bool async = false;
36
+ bool success = false;
37
+ size_t imported_function_count = 0;
38
+ int64_t wall_clock_time_in_us = 0;
39
+ };
40
+
41
+ struct WasmModuleTieredUp {
42
+ bool lazy = false;
43
+ size_t code_size_in_bytes = 0;
44
+ int64_t wall_clock_time_in_us = 0;
45
+ };
46
+
47
+ struct WasmModulesPerIsolate {
48
+ size_t count = 0;
49
+ };
50
+
51
+ #define V8_MAIN_THREAD_METRICS_EVENTS(V) \
52
+ V(WasmModuleDecoded) \
53
+ V(WasmModuleCompiled) \
54
+ V(WasmModuleInstantiated) \
55
+ V(WasmModuleTieredUp)
56
+
57
+ #define V8_THREAD_SAFE_METRICS_EVENTS(V) V(WasmModulesPerIsolate)
58
+
59
+ /**
60
+ * This class serves as a base class for recording event-based metrics in V8.
61
+ * There a two kinds of metrics, those which are expected to be thread-safe and
62
+ * whose implementation is required to fulfill this requirement and those whose
63
+ * implementation does not have that requirement and only needs to be
64
+ * executable on the main thread. If such an event is triggered from a
65
+ * background thread, it will be delayed and executed by the foreground task
66
+ * runner.
67
+ *
68
+ * The thread-safe events are listed in the V8_THREAD_SAFE_METRICS_EVENTS
69
+ * macro above while the main thread event are listed in
70
+ * V8_MAIN_THREAD_METRICS_EVENTS above. For the former, a virtual method
71
+ * AddMainThreadEvent(const E& event, v8::Context::Token token) will be
72
+ * generated and for the latter AddThreadSafeEvent(const E& event).
73
+ *
74
+ * Thread-safe events are not allowed to access the context and therefore do
75
+ * not carry a context ID with them. These IDs can be generated using
76
+ * Recorder::GetContextId() and the ID will be valid throughout the lifetime
77
+ * of the isolate. It is not guaranteed that the ID will still resolve to
78
+ * a valid context using Recorder::GetContext() at the time the metric is
79
+ * recorded. In this case, an empty handle will be returned.
80
+ *
81
+ * The embedder is expected to call v8::Isolate::SetMetricsRecorder()
82
+ * providing its implementation and have the virtual methods overwritten
83
+ * for the events it cares about.
84
+ */
85
+ class V8_EXPORT Recorder {
86
+ public:
87
+ // A unique identifier for a context in this Isolate.
88
+ // It is guaranteed to not be reused throughout the lifetime of the Isolate.
89
+ class ContextId {
90
+ public:
91
+ ContextId() : id_(kEmptyId) {}
92
+
93
+ bool IsEmpty() const { return id_ == kEmptyId; }
94
+ static const ContextId Empty() { return ContextId{kEmptyId}; }
95
+
96
+ bool operator==(const ContextId& other) const { return id_ == other.id_; }
97
+ bool operator!=(const ContextId& other) const { return id_ != other.id_; }
98
+
99
+ private:
100
+ friend class ::v8::Context;
101
+ friend class ::v8::internal::Isolate;
102
+
103
+ explicit ContextId(uintptr_t id) : id_(id) {}
104
+
105
+ static constexpr uintptr_t kEmptyId = 0;
106
+ uintptr_t id_;
107
+ };
108
+
109
+ virtual ~Recorder() = default;
110
+
111
+ #define ADD_MAIN_THREAD_EVENT(E) \
112
+ virtual void AddMainThreadEvent(const E& event, ContextId context_id) {}
113
+ V8_MAIN_THREAD_METRICS_EVENTS(ADD_MAIN_THREAD_EVENT)
114
+ #undef ADD_MAIN_THREAD_EVENT
115
+
116
+ #define ADD_THREAD_SAFE_EVENT(E) \
117
+ virtual void AddThreadSafeEvent(const E& event) {}
118
+ V8_THREAD_SAFE_METRICS_EVENTS(ADD_THREAD_SAFE_EVENT)
119
+ #undef ADD_THREAD_SAFE_EVENT
120
+
121
+ virtual void NotifyIsolateDisposal() {}
122
+
123
+ // Return the context with the given id or an empty handle if the context
124
+ // was already garbage collected.
125
+ static MaybeLocal<Context> GetContext(Isolate* isolate, ContextId id);
126
+ // Return the unique id corresponding to the given context.
127
+ static ContextId GetContextId(Local<Context> context);
128
+ };
129
+
130
+ } // namespace metrics
131
+ } // namespace v8
132
+
133
+ #endif // V8_METRICS_H_