aha-libv8-node 16.0.0.0-linux

Sign up to get free protection for your applications and to get access to all the features.
Files changed (67) 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.rb +1 -0
  6. data/lib/libv8/node.rb +11 -0
  7. data/lib/libv8/node/version.rb +7 -0
  8. data/vendor/v8/include/cppgc/allocation.h +229 -0
  9. data/vendor/v8/include/cppgc/common.h +29 -0
  10. data/vendor/v8/include/cppgc/cross-thread-persistent.h +345 -0
  11. data/vendor/v8/include/cppgc/custom-space.h +97 -0
  12. data/vendor/v8/include/cppgc/default-platform.h +75 -0
  13. data/vendor/v8/include/cppgc/ephemeron-pair.h +30 -0
  14. data/vendor/v8/include/cppgc/garbage-collected.h +116 -0
  15. data/vendor/v8/include/cppgc/heap-consistency.h +236 -0
  16. data/vendor/v8/include/cppgc/heap-state.h +59 -0
  17. data/vendor/v8/include/cppgc/heap-statistics.h +110 -0
  18. data/vendor/v8/include/cppgc/heap.h +199 -0
  19. data/vendor/v8/include/cppgc/internal/api-constants.h +47 -0
  20. data/vendor/v8/include/cppgc/internal/atomic-entry-flag.h +48 -0
  21. data/vendor/v8/include/cppgc/internal/caged-heap-local-data.h +68 -0
  22. data/vendor/v8/include/cppgc/internal/compiler-specific.h +38 -0
  23. data/vendor/v8/include/cppgc/internal/finalizer-trait.h +90 -0
  24. data/vendor/v8/include/cppgc/internal/gc-info.h +47 -0
  25. data/vendor/v8/include/cppgc/internal/logging.h +50 -0
  26. data/vendor/v8/include/cppgc/internal/name-trait.h +111 -0
  27. data/vendor/v8/include/cppgc/internal/persistent-node.h +132 -0
  28. data/vendor/v8/include/cppgc/internal/pointer-policies.h +143 -0
  29. data/vendor/v8/include/cppgc/internal/prefinalizer-handler.h +30 -0
  30. data/vendor/v8/include/cppgc/internal/write-barrier.h +390 -0
  31. data/vendor/v8/include/cppgc/liveness-broker.h +74 -0
  32. data/vendor/v8/include/cppgc/macros.h +26 -0
  33. data/vendor/v8/include/cppgc/member.h +271 -0
  34. data/vendor/v8/include/cppgc/name-provider.h +65 -0
  35. data/vendor/v8/include/cppgc/object-size-trait.h +58 -0
  36. data/vendor/v8/include/cppgc/persistent.h +365 -0
  37. data/vendor/v8/include/cppgc/platform.h +151 -0
  38. data/vendor/v8/include/cppgc/prefinalizer.h +52 -0
  39. data/vendor/v8/include/cppgc/process-heap-statistics.h +36 -0
  40. data/vendor/v8/include/cppgc/sentinel-pointer.h +32 -0
  41. data/vendor/v8/include/cppgc/source-location.h +91 -0
  42. data/vendor/v8/include/cppgc/testing.h +50 -0
  43. data/vendor/v8/include/cppgc/trace-trait.h +116 -0
  44. data/vendor/v8/include/cppgc/type-traits.h +228 -0
  45. data/vendor/v8/include/cppgc/visitor.h +340 -0
  46. data/vendor/v8/include/libplatform/libplatform-export.h +29 -0
  47. data/vendor/v8/include/libplatform/libplatform.h +117 -0
  48. data/vendor/v8/include/libplatform/v8-tracing.h +334 -0
  49. data/vendor/v8/include/v8-cppgc.h +278 -0
  50. data/vendor/v8/include/v8-fast-api-calls.h +419 -0
  51. data/vendor/v8/include/v8-inspector-protocol.h +13 -0
  52. data/vendor/v8/include/v8-inspector.h +336 -0
  53. data/vendor/v8/include/v8-internal.h +462 -0
  54. data/vendor/v8/include/v8-metrics.h +189 -0
  55. data/vendor/v8/include/v8-platform.h +710 -0
  56. data/vendor/v8/include/v8-profiler.h +1116 -0
  57. data/vendor/v8/include/v8-unwinder-state.h +30 -0
  58. data/vendor/v8/include/v8-util.h +652 -0
  59. data/vendor/v8/include/v8-value-serializer-version.h +24 -0
  60. data/vendor/v8/include/v8-version-string.h +38 -0
  61. data/vendor/v8/include/v8-version.h +20 -0
  62. data/vendor/v8/include/v8-wasm-trap-handler-posix.h +31 -0
  63. data/vendor/v8/include/v8-wasm-trap-handler-win.h +28 -0
  64. data/vendor/v8/include/v8.h +12479 -0
  65. data/vendor/v8/include/v8config.h +521 -0
  66. data/vendor/v8/out.gn/libv8/obj/libv8_monolith.a +0 -0
  67. metadata +137 -0
@@ -0,0 +1,97 @@
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 INCLUDE_CPPGC_CUSTOM_SPACE_H_
6
+ #define INCLUDE_CPPGC_CUSTOM_SPACE_H_
7
+
8
+ #include <stddef.h>
9
+
10
+ namespace cppgc {
11
+
12
+ /**
13
+ * Index identifying a custom space.
14
+ */
15
+ struct CustomSpaceIndex {
16
+ constexpr CustomSpaceIndex(size_t value) : value(value) {} // NOLINT
17
+ size_t value;
18
+ };
19
+
20
+ /**
21
+ * Top-level base class for custom spaces. Users must inherit from CustomSpace
22
+ * below.
23
+ */
24
+ class CustomSpaceBase {
25
+ public:
26
+ virtual ~CustomSpaceBase() = default;
27
+ virtual CustomSpaceIndex GetCustomSpaceIndex() const = 0;
28
+ virtual bool IsCompactable() const = 0;
29
+ };
30
+
31
+ /**
32
+ * Base class custom spaces should directly inherit from. The class inheriting
33
+ * from `CustomSpace` must define `kSpaceIndex` as unique space index. These
34
+ * indices need for form a sequence starting at 0.
35
+ *
36
+ * Example:
37
+ * \code
38
+ * class CustomSpace1 : public CustomSpace<CustomSpace1> {
39
+ * public:
40
+ * static constexpr CustomSpaceIndex kSpaceIndex = 0;
41
+ * };
42
+ * class CustomSpace2 : public CustomSpace<CustomSpace2> {
43
+ * public:
44
+ * static constexpr CustomSpaceIndex kSpaceIndex = 1;
45
+ * };
46
+ * \endcode
47
+ */
48
+ template <typename ConcreteCustomSpace>
49
+ class CustomSpace : public CustomSpaceBase {
50
+ public:
51
+ /**
52
+ * Compaction is only supported on spaces that manually manage slots
53
+ * recording.
54
+ */
55
+ static constexpr bool kSupportsCompaction = false;
56
+
57
+ CustomSpaceIndex GetCustomSpaceIndex() const final {
58
+ return ConcreteCustomSpace::kSpaceIndex;
59
+ }
60
+ bool IsCompactable() const final {
61
+ return ConcreteCustomSpace::kSupportsCompaction;
62
+ }
63
+ };
64
+
65
+ /**
66
+ * User-overridable trait that allows pinning types to custom spaces.
67
+ */
68
+ template <typename T, typename = void>
69
+ struct SpaceTrait {
70
+ using Space = void;
71
+ };
72
+
73
+ namespace internal {
74
+
75
+ template <typename CustomSpace>
76
+ struct IsAllocatedOnCompactableSpaceImpl {
77
+ static constexpr bool value = CustomSpace::kSupportsCompaction;
78
+ };
79
+
80
+ template <>
81
+ struct IsAllocatedOnCompactableSpaceImpl<void> {
82
+ // Non-custom spaces are by default not compactable.
83
+ static constexpr bool value = false;
84
+ };
85
+
86
+ template <typename T>
87
+ struct IsAllocatedOnCompactableSpace {
88
+ public:
89
+ static constexpr bool value =
90
+ IsAllocatedOnCompactableSpaceImpl<typename SpaceTrait<T>::Space>::value;
91
+ };
92
+
93
+ } // namespace internal
94
+
95
+ } // namespace cppgc
96
+
97
+ #endif // INCLUDE_CPPGC_CUSTOM_SPACE_H_
@@ -0,0 +1,75 @@
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 INCLUDE_CPPGC_DEFAULT_PLATFORM_H_
6
+ #define INCLUDE_CPPGC_DEFAULT_PLATFORM_H_
7
+
8
+ #include <memory>
9
+ #include <vector>
10
+
11
+ #include "cppgc/platform.h"
12
+ #include "libplatform/libplatform.h"
13
+ #include "v8config.h" // NOLINT(build/include_directory)
14
+
15
+ namespace cppgc {
16
+
17
+ /**
18
+ * Platform provided by cppgc. Uses V8's DefaultPlatform provided by
19
+ * libplatform internally. Exception: `GetForegroundTaskRunner()`, see below.
20
+ */
21
+ class V8_EXPORT DefaultPlatform : public Platform {
22
+ public:
23
+ /**
24
+ * Use this method instead of 'cppgc::InitializeProcess' when using
25
+ * 'cppgc::DefaultPlatform'. 'cppgc::DefaultPlatform::InitializeProcess'
26
+ * will initialize cppgc and v8 if needed (for non-standalone builds).
27
+ *
28
+ * \param platform DefaultPlatform instance used to initialize cppgc/v8.
29
+ */
30
+ static void InitializeProcess(DefaultPlatform* platform);
31
+
32
+ using IdleTaskSupport = v8::platform::IdleTaskSupport;
33
+ explicit DefaultPlatform(
34
+ int thread_pool_size = 0,
35
+ IdleTaskSupport idle_task_support = IdleTaskSupport::kDisabled,
36
+ std::unique_ptr<TracingController> tracing_controller = {})
37
+ : v8_platform_(v8::platform::NewDefaultPlatform(
38
+ thread_pool_size, idle_task_support,
39
+ v8::platform::InProcessStackDumping::kDisabled,
40
+ std::move(tracing_controller))) {}
41
+
42
+ cppgc::PageAllocator* GetPageAllocator() override {
43
+ return v8_platform_->GetPageAllocator();
44
+ }
45
+
46
+ double MonotonicallyIncreasingTime() override {
47
+ return v8_platform_->MonotonicallyIncreasingTime();
48
+ }
49
+
50
+ std::shared_ptr<cppgc::TaskRunner> GetForegroundTaskRunner() override {
51
+ // V8's default platform creates a new task runner when passed the
52
+ // `v8::Isolate` pointer the first time. For non-default platforms this will
53
+ // require getting the appropriate task runner.
54
+ return v8_platform_->GetForegroundTaskRunner(kNoIsolate);
55
+ }
56
+
57
+ std::unique_ptr<cppgc::JobHandle> PostJob(
58
+ cppgc::TaskPriority priority,
59
+ std::unique_ptr<cppgc::JobTask> job_task) override {
60
+ return v8_platform_->PostJob(priority, std::move(job_task));
61
+ }
62
+
63
+ TracingController* GetTracingController() override {
64
+ return v8_platform_->GetTracingController();
65
+ }
66
+
67
+ protected:
68
+ static constexpr v8::Isolate* kNoIsolate = nullptr;
69
+
70
+ std::unique_ptr<v8::Platform> v8_platform_;
71
+ };
72
+
73
+ } // namespace cppgc
74
+
75
+ #endif // INCLUDE_CPPGC_DEFAULT_PLATFORM_H_
@@ -0,0 +1,30 @@
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 INCLUDE_CPPGC_EPHEMERON_PAIR_H_
6
+ #define INCLUDE_CPPGC_EPHEMERON_PAIR_H_
7
+
8
+ #include "cppgc/liveness-broker.h"
9
+ #include "cppgc/member.h"
10
+
11
+ namespace cppgc {
12
+
13
+ /**
14
+ * An ephemeron pair is used to conditionally retain an object.
15
+ * The `value` will be kept alive only if the `key` is alive.
16
+ */
17
+ template <typename K, typename V>
18
+ struct EphemeronPair {
19
+ EphemeronPair(K* k, V* v) : key(k), value(v) {}
20
+ WeakMember<K> key;
21
+ Member<V> value;
22
+
23
+ void ClearValueIfKeyIsDead(const LivenessBroker& broker) {
24
+ if (!broker.IsHeapObjectAlive(key)) value = nullptr;
25
+ }
26
+ };
27
+
28
+ } // namespace cppgc
29
+
30
+ #endif // INCLUDE_CPPGC_EPHEMERON_PAIR_H_
@@ -0,0 +1,116 @@
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 INCLUDE_CPPGC_GARBAGE_COLLECTED_H_
6
+ #define INCLUDE_CPPGC_GARBAGE_COLLECTED_H_
7
+
8
+ #include <type_traits>
9
+
10
+ #include "cppgc/internal/api-constants.h"
11
+ #include "cppgc/platform.h"
12
+ #include "cppgc/trace-trait.h"
13
+ #include "cppgc/type-traits.h"
14
+
15
+ namespace cppgc {
16
+
17
+ class Visitor;
18
+
19
+ namespace internal {
20
+
21
+ class GarbageCollectedBase {
22
+ public:
23
+ // Must use MakeGarbageCollected.
24
+ void* operator new(size_t) = delete;
25
+ void* operator new[](size_t) = delete;
26
+ // The garbage collector is taking care of reclaiming the object. Also,
27
+ // virtual destructor requires an unambiguous, accessible 'operator delete'.
28
+ void operator delete(void*) {
29
+ #ifdef V8_ENABLE_CHECKS
30
+ internal::Abort();
31
+ #endif // V8_ENABLE_CHECKS
32
+ }
33
+ void operator delete[](void*) = delete;
34
+
35
+ protected:
36
+ GarbageCollectedBase() = default;
37
+ };
38
+
39
+ } // namespace internal
40
+
41
+ /**
42
+ * Base class for managed objects. Only descendent types of `GarbageCollected`
43
+ * can be constructed using `MakeGarbageCollected()`. Must be inherited from as
44
+ * left-most base class.
45
+ *
46
+ * Types inheriting from GarbageCollected must provide a method of
47
+ * signature `void Trace(cppgc::Visitor*) const` that dispatchs all managed
48
+ * pointers to the visitor and delegates to garbage-collected base classes.
49
+ * The method must be virtual if the type is not directly a child of
50
+ * GarbageCollected and marked as final.
51
+ *
52
+ * \code
53
+ * // Example using final class.
54
+ * class FinalType final : public GarbageCollected<FinalType> {
55
+ * public:
56
+ * void Trace(cppgc::Visitor* visitor) const {
57
+ * // Dispatch using visitor->Trace(...);
58
+ * }
59
+ * };
60
+ *
61
+ * // Example using non-final base class.
62
+ * class NonFinalBase : public GarbageCollected<NonFinalBase> {
63
+ * public:
64
+ * virtual void Trace(cppgc::Visitor*) const {}
65
+ * };
66
+ *
67
+ * class FinalChild final : public NonFinalBase {
68
+ * public:
69
+ * void Trace(cppgc::Visitor* visitor) const final {
70
+ * // Dispatch using visitor->Trace(...);
71
+ * NonFinalBase::Trace(visitor);
72
+ * }
73
+ * };
74
+ * \endcode
75
+ */
76
+ template <typename>
77
+ class GarbageCollected : public internal::GarbageCollectedBase {
78
+ public:
79
+ using IsGarbageCollectedTypeMarker = void;
80
+
81
+ protected:
82
+ GarbageCollected() = default;
83
+ };
84
+
85
+ /**
86
+ * Base class for managed mixin objects. Such objects cannot be constructed
87
+ * directly but must be mixed into the inheritance hierarchy of a
88
+ * GarbageCollected object.
89
+ *
90
+ * Types inheriting from GarbageCollectedMixin must override a virtual method
91
+ * of signature `void Trace(cppgc::Visitor*) const` that dispatchs all managed
92
+ * pointers to the visitor and delegates to base classes.
93
+ *
94
+ * \code
95
+ * class Mixin : public GarbageCollectedMixin {
96
+ * public:
97
+ * void Trace(cppgc::Visitor* visitor) const override {
98
+ * // Dispatch using visitor->Trace(...);
99
+ * }
100
+ * };
101
+ * \endcode
102
+ */
103
+ class GarbageCollectedMixin : public internal::GarbageCollectedBase {
104
+ public:
105
+ using IsGarbageCollectedMixinTypeMarker = void;
106
+
107
+ /**
108
+ * This Trace method must be overriden by objects inheriting from
109
+ * GarbageCollectedMixin.
110
+ */
111
+ virtual void Trace(cppgc::Visitor*) const {}
112
+ };
113
+
114
+ } // namespace cppgc
115
+
116
+ #endif // INCLUDE_CPPGC_GARBAGE_COLLECTED_H_
@@ -0,0 +1,236 @@
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 INCLUDE_CPPGC_HEAP_CONSISTENCY_H_
6
+ #define INCLUDE_CPPGC_HEAP_CONSISTENCY_H_
7
+
8
+ #include <cstddef>
9
+
10
+ #include "cppgc/internal/write-barrier.h"
11
+ #include "cppgc/macros.h"
12
+ #include "cppgc/trace-trait.h"
13
+ #include "v8config.h" // NOLINT(build/include_directory)
14
+
15
+ namespace cppgc {
16
+
17
+ class HeapHandle;
18
+
19
+ namespace subtle {
20
+
21
+ /**
22
+ * **DO NOT USE: Use the appropriate managed types.**
23
+ *
24
+ * Consistency helpers that aid in maintaining a consistent internal state of
25
+ * the garbage collector.
26
+ */
27
+ class HeapConsistency final {
28
+ public:
29
+ using WriteBarrierParams = internal::WriteBarrier::Params;
30
+ using WriteBarrierType = internal::WriteBarrier::Type;
31
+
32
+ /**
33
+ * Gets the required write barrier type for a specific write.
34
+ *
35
+ * \param slot Slot containing the pointer to the object. The slot itself
36
+ * must reside in an object that has been allocated using
37
+ * `MakeGarbageCollected()`.
38
+ * \param value The pointer to the object. May be an interior pointer to an
39
+ * interface of the actual object.
40
+ * \param params Parameters that may be used for actual write barrier calls.
41
+ * Only filled if return value indicates that a write barrier is needed. The
42
+ * contents of the `params` are an implementation detail.
43
+ * \returns whether a write barrier is needed and which barrier to invoke.
44
+ */
45
+ static V8_INLINE WriteBarrierType GetWriteBarrierType(
46
+ const void* slot, const void* value, WriteBarrierParams& params) {
47
+ return internal::WriteBarrier::GetWriteBarrierType(slot, value, params);
48
+ }
49
+
50
+ /**
51
+ * Gets the required write barrier type for a specific write.
52
+ *
53
+ * \param slot Slot to some part of an object. The object must not necessarily
54
+ have been allocated using `MakeGarbageCollected()` but can also live
55
+ off-heap or on stack.
56
+ * \param params Parameters that may be used for actual write barrier calls.
57
+ * Only filled if return value indicates that a write barrier is needed. The
58
+ * contents of the `params` are an implementation detail.
59
+ * \param callback Callback returning the corresponding heap handle. The
60
+ * callback is only invoked if the heap cannot otherwise be figured out. The
61
+ * callback must not allocate.
62
+ * \returns whether a write barrier is needed and which barrier to invoke.
63
+ */
64
+ template <typename HeapHandleCallback>
65
+ static V8_INLINE WriteBarrierType
66
+ GetWriteBarrierType(const void* slot, WriteBarrierParams& params,
67
+ HeapHandleCallback callback) {
68
+ return internal::WriteBarrier::GetWriteBarrierType(slot, params, callback);
69
+ }
70
+
71
+ /**
72
+ * Conservative Dijkstra-style write barrier that processes an object if it
73
+ * has not yet been processed.
74
+ *
75
+ * \param params The parameters retrieved from `GetWriteBarrierType()`.
76
+ * \param object The pointer to the object. May be an interior pointer to a
77
+ * an interface of the actual object.
78
+ */
79
+ static V8_INLINE void DijkstraWriteBarrier(const WriteBarrierParams& params,
80
+ const void* object) {
81
+ internal::WriteBarrier::DijkstraMarkingBarrier(params, object);
82
+ }
83
+
84
+ /**
85
+ * Conservative Dijkstra-style write barrier that processes a range of
86
+ * elements if they have not yet been processed.
87
+ *
88
+ * \param params The parameters retrieved from `GetWriteBarrierType()`.
89
+ * \param first_element Pointer to the first element that should be processed.
90
+ * The slot itself must reside in an object that has been allocated using
91
+ * `MakeGarbageCollected()`.
92
+ * \param element_size Size of the element in bytes.
93
+ * \param number_of_elements Number of elements that should be processed,
94
+ * starting with `first_element`.
95
+ * \param trace_callback The trace callback that should be invoked for each
96
+ * element if necessary.
97
+ */
98
+ static V8_INLINE void DijkstraWriteBarrierRange(
99
+ const WriteBarrierParams& params, const void* first_element,
100
+ size_t element_size, size_t number_of_elements,
101
+ TraceCallback trace_callback) {
102
+ internal::WriteBarrier::DijkstraMarkingBarrierRange(
103
+ params, first_element, element_size, number_of_elements,
104
+ trace_callback);
105
+ }
106
+
107
+ /**
108
+ * Steele-style write barrier that re-processes an object if it has already
109
+ * been processed.
110
+ *
111
+ * \param params The parameters retrieved from `GetWriteBarrierType()`.
112
+ * \param object The pointer to the object which must point to an object that
113
+ * has been allocated using `MakeGarbageCollected()`. Interior pointers are
114
+ * not supported.
115
+ */
116
+ static V8_INLINE void SteeleWriteBarrier(const WriteBarrierParams& params,
117
+ const void* object) {
118
+ internal::WriteBarrier::SteeleMarkingBarrier(params, object);
119
+ }
120
+
121
+ /**
122
+ * Generational barrier for maintaining consistency when running with multiple
123
+ * generations.
124
+ *
125
+ * \param params The parameters retrieved from `GetWriteBarrierType()`.
126
+ * \param slot Slot containing the pointer to the object. The slot itself
127
+ * must reside in an object that has been allocated using
128
+ * `MakeGarbageCollected()`.
129
+ */
130
+ static V8_INLINE void GenerationalBarrier(const WriteBarrierParams& params,
131
+ const void* slot) {
132
+ internal::WriteBarrier::GenerationalBarrier(params, slot);
133
+ }
134
+
135
+ private:
136
+ HeapConsistency() = delete;
137
+ };
138
+
139
+ /**
140
+ * Disallows garbage collection finalizations. Any garbage collection triggers
141
+ * result in a crash when in this scope.
142
+ *
143
+ * Note that the garbage collector already covers paths that can lead to garbage
144
+ * collections, so user code does not require checking
145
+ * `IsGarbageCollectionAllowed()` before allocations.
146
+ */
147
+ class V8_EXPORT V8_NODISCARD DisallowGarbageCollectionScope final {
148
+ CPPGC_STACK_ALLOCATED();
149
+
150
+ public:
151
+ /**
152
+ * \returns whether garbage collections are currently allowed.
153
+ */
154
+ static bool IsGarbageCollectionAllowed(HeapHandle& heap_handle);
155
+
156
+ /**
157
+ * Enters a disallow garbage collection scope. Must be paired with `Leave()`.
158
+ * Prefer a scope instance of `DisallowGarbageCollectionScope`.
159
+ *
160
+ * \param heap_handle The corresponding heap.
161
+ */
162
+ static void Enter(HeapHandle& heap_handle);
163
+
164
+ /**
165
+ * Leaves a disallow garbage collection scope. Must be paired with `Enter()`.
166
+ * Prefer a scope instance of `DisallowGarbageCollectionScope`.
167
+ *
168
+ * \param heap_handle The corresponding heap.
169
+ */
170
+ static void Leave(HeapHandle& heap_handle);
171
+
172
+ /**
173
+ * Constructs a scoped object that automatically enters and leaves a disallow
174
+ * garbage collection scope based on its lifetime.
175
+ *
176
+ * \param heap_handle The corresponding heap.
177
+ */
178
+ explicit DisallowGarbageCollectionScope(HeapHandle& heap_handle);
179
+ ~DisallowGarbageCollectionScope();
180
+
181
+ DisallowGarbageCollectionScope(const DisallowGarbageCollectionScope&) =
182
+ delete;
183
+ DisallowGarbageCollectionScope& operator=(
184
+ const DisallowGarbageCollectionScope&) = delete;
185
+
186
+ private:
187
+ HeapHandle& heap_handle_;
188
+ };
189
+
190
+ /**
191
+ * Avoids invoking garbage collection finalizations. Already running garbage
192
+ * collection phase are unaffected by this scope.
193
+ *
194
+ * Should only be used temporarily as the scope has an impact on memory usage
195
+ * and follow up garbage collections.
196
+ */
197
+ class V8_EXPORT V8_NODISCARD NoGarbageCollectionScope final {
198
+ CPPGC_STACK_ALLOCATED();
199
+
200
+ public:
201
+ /**
202
+ * Enters a no garbage collection scope. Must be paired with `Leave()`. Prefer
203
+ * a scope instance of `NoGarbageCollectionScope`.
204
+ *
205
+ * \param heap_handle The corresponding heap.
206
+ */
207
+ static void Enter(HeapHandle& heap_handle);
208
+
209
+ /**
210
+ * Leaves a no garbage collection scope. Must be paired with `Enter()`. Prefer
211
+ * a scope instance of `NoGarbageCollectionScope`.
212
+ *
213
+ * \param heap_handle The corresponding heap.
214
+ */
215
+ static void Leave(HeapHandle& heap_handle);
216
+
217
+ /**
218
+ * Constructs a scoped object that automatically enters and leaves a no
219
+ * garbage collection scope based on its lifetime.
220
+ *
221
+ * \param heap_handle The corresponding heap.
222
+ */
223
+ explicit NoGarbageCollectionScope(HeapHandle& heap_handle);
224
+ ~NoGarbageCollectionScope();
225
+
226
+ NoGarbageCollectionScope(const NoGarbageCollectionScope&) = delete;
227
+ NoGarbageCollectionScope& operator=(const NoGarbageCollectionScope&) = delete;
228
+
229
+ private:
230
+ HeapHandle& heap_handle_;
231
+ };
232
+
233
+ } // namespace subtle
234
+ } // namespace cppgc
235
+
236
+ #endif // INCLUDE_CPPGC_HEAP_CONSISTENCY_H_