libv8-node 15.14.0.1-arm64-darwin-21
Sign up to get free protection for your applications and to get access to all the features.
- checksums.yaml +7 -0
- data/ext/libv8-node/.location.yml +1 -0
- data/ext/libv8-node/location.rb +76 -0
- data/ext/libv8-node/paths.rb +30 -0
- data/lib/libv8/node/version.rb +7 -0
- data/lib/libv8/node.rb +11 -0
- data/lib/libv8-node.rb +1 -0
- data/vendor/v8/include/cppgc/allocation.h +173 -0
- data/vendor/v8/include/cppgc/common.h +26 -0
- data/vendor/v8/include/cppgc/custom-space.h +62 -0
- data/vendor/v8/include/cppgc/default-platform.h +76 -0
- data/vendor/v8/include/cppgc/garbage-collected.h +116 -0
- data/vendor/v8/include/cppgc/heap.h +139 -0
- data/vendor/v8/include/cppgc/internal/api-constants.h +47 -0
- data/vendor/v8/include/cppgc/internal/atomic-entry-flag.h +48 -0
- data/vendor/v8/include/cppgc/internal/caged-heap-local-data.h +67 -0
- data/vendor/v8/include/cppgc/internal/compiler-specific.h +38 -0
- data/vendor/v8/include/cppgc/internal/finalizer-trait.h +90 -0
- data/vendor/v8/include/cppgc/internal/gc-info.h +45 -0
- data/vendor/v8/include/cppgc/internal/logging.h +50 -0
- data/vendor/v8/include/cppgc/internal/persistent-node.h +116 -0
- data/vendor/v8/include/cppgc/internal/pointer-policies.h +134 -0
- data/vendor/v8/include/cppgc/internal/prefinalizer-handler.h +30 -0
- data/vendor/v8/include/cppgc/internal/process-heap.h +34 -0
- data/vendor/v8/include/cppgc/internal/write-barrier.h +78 -0
- data/vendor/v8/include/cppgc/liveness-broker.h +68 -0
- data/vendor/v8/include/cppgc/macros.h +24 -0
- data/vendor/v8/include/cppgc/member.h +226 -0
- data/vendor/v8/include/cppgc/persistent.h +341 -0
- data/vendor/v8/include/cppgc/platform.h +130 -0
- data/vendor/v8/include/cppgc/prefinalizer.h +52 -0
- data/vendor/v8/include/cppgc/source-location.h +91 -0
- data/vendor/v8/include/cppgc/trace-trait.h +111 -0
- data/vendor/v8/include/cppgc/type-traits.h +109 -0
- data/vendor/v8/include/cppgc/visitor.h +213 -0
- data/vendor/v8/include/libplatform/libplatform-export.h +29 -0
- data/vendor/v8/include/libplatform/libplatform.h +106 -0
- data/vendor/v8/include/libplatform/v8-tracing.h +332 -0
- data/vendor/v8/include/v8-cppgc.h +226 -0
- data/vendor/v8/include/v8-fast-api-calls.h +388 -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 +427 -0
- data/vendor/v8/include/v8-metrics.h +133 -0
- data/vendor/v8/include/v8-platform.h +684 -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 +12098 -0
- data/vendor/v8/include/v8config.h +484 -0
- data/vendor/v8/out.gn/libv8/obj/libv8_monolith.a +0 -0
- metadata +126 -0
@@ -0,0 +1,139 @@
|
|
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_H_
|
6
|
+
#define INCLUDE_CPPGC_HEAP_H_
|
7
|
+
|
8
|
+
#include <memory>
|
9
|
+
#include <vector>
|
10
|
+
|
11
|
+
#include "cppgc/common.h"
|
12
|
+
#include "cppgc/custom-space.h"
|
13
|
+
#include "cppgc/platform.h"
|
14
|
+
#include "v8config.h" // NOLINT(build/include_directory)
|
15
|
+
|
16
|
+
/**
|
17
|
+
* cppgc - A C++ garbage collection library.
|
18
|
+
*/
|
19
|
+
namespace cppgc {
|
20
|
+
|
21
|
+
class AllocationHandle;
|
22
|
+
|
23
|
+
/**
|
24
|
+
* Implementation details of cppgc. Those details are considered internal and
|
25
|
+
* may change at any point in time without notice. Users should never rely on
|
26
|
+
* the contents of this namespace.
|
27
|
+
*/
|
28
|
+
namespace internal {
|
29
|
+
class Heap;
|
30
|
+
} // namespace internal
|
31
|
+
|
32
|
+
class V8_EXPORT Heap {
|
33
|
+
public:
|
34
|
+
/**
|
35
|
+
* Specifies the stack state the embedder is in.
|
36
|
+
*/
|
37
|
+
using StackState = EmbedderStackState;
|
38
|
+
|
39
|
+
/**
|
40
|
+
* Specifies whether conservative stack scanning is supported.
|
41
|
+
*/
|
42
|
+
enum class StackSupport : uint8_t {
|
43
|
+
/**
|
44
|
+
* Conservative stack scan is supported.
|
45
|
+
*/
|
46
|
+
kSupportsConservativeStackScan,
|
47
|
+
/**
|
48
|
+
* Conservative stack scan is not supported. Embedders may use this option
|
49
|
+
* when using custom infrastructure that is unsupported by the library.
|
50
|
+
*/
|
51
|
+
kNoConservativeStackScan,
|
52
|
+
};
|
53
|
+
|
54
|
+
/**
|
55
|
+
* Constraints for a Heap setup.
|
56
|
+
*/
|
57
|
+
struct ResourceConstraints {
|
58
|
+
/**
|
59
|
+
* Allows the heap to grow to some initial size in bytes before triggering
|
60
|
+
* garbage collections. This is useful when it is known that applications
|
61
|
+
* need a certain minimum heap to run to avoid repeatedly invoking the
|
62
|
+
* garbage collector when growing the heap.
|
63
|
+
*/
|
64
|
+
size_t initial_heap_size_bytes = 0;
|
65
|
+
};
|
66
|
+
|
67
|
+
/**
|
68
|
+
* Options specifying Heap properties (e.g. custom spaces) when initializing a
|
69
|
+
* heap through Heap::Create().
|
70
|
+
*/
|
71
|
+
struct HeapOptions {
|
72
|
+
/**
|
73
|
+
* Creates reasonable defaults for instantiating a Heap.
|
74
|
+
*
|
75
|
+
* \returns the HeapOptions that can be passed to Heap::Create().
|
76
|
+
*/
|
77
|
+
static HeapOptions Default() { return {}; }
|
78
|
+
|
79
|
+
/**
|
80
|
+
* Custom spaces added to heap are required to have indices forming a
|
81
|
+
* numbered sequence starting at 0, i.e., their kSpaceIndex must correspond
|
82
|
+
* to the index they reside in the vector.
|
83
|
+
*/
|
84
|
+
std::vector<std::unique_ptr<CustomSpaceBase>> custom_spaces;
|
85
|
+
|
86
|
+
/**
|
87
|
+
* Specifies whether conserative stack scan is supported. When conservative
|
88
|
+
* stack scan is not supported, the collector may try to invoke
|
89
|
+
* garbage collections using non-nestable task, which are guaranteed to have
|
90
|
+
* no interesting stack, through the provided Platform. If such tasks are
|
91
|
+
* not supported by the Platform, the embedder must take care of invoking
|
92
|
+
* the GC through ForceGarbageCollectionSlow().
|
93
|
+
*/
|
94
|
+
StackSupport stack_support = StackSupport::kSupportsConservativeStackScan;
|
95
|
+
|
96
|
+
/**
|
97
|
+
* Resource constraints specifying various properties that the internal
|
98
|
+
* GC scheduler follows.
|
99
|
+
*/
|
100
|
+
ResourceConstraints resource_constraints;
|
101
|
+
};
|
102
|
+
|
103
|
+
/**
|
104
|
+
* Creates a new heap that can be used for object allocation.
|
105
|
+
*
|
106
|
+
* \param platform implemented and provided by the embedder.
|
107
|
+
* \param options HeapOptions specifying various properties for the Heap.
|
108
|
+
* \returns a new Heap instance.
|
109
|
+
*/
|
110
|
+
static std::unique_ptr<Heap> Create(
|
111
|
+
std::shared_ptr<Platform> platform,
|
112
|
+
HeapOptions options = HeapOptions::Default());
|
113
|
+
|
114
|
+
virtual ~Heap() = default;
|
115
|
+
|
116
|
+
/**
|
117
|
+
* Forces garbage collection.
|
118
|
+
*
|
119
|
+
* \param source String specifying the source (or caller) triggering a
|
120
|
+
* forced garbage collection.
|
121
|
+
* \param reason String specifying the reason for the forced garbage
|
122
|
+
* collection.
|
123
|
+
* \param stack_state The embedder stack state, see StackState.
|
124
|
+
*/
|
125
|
+
void ForceGarbageCollectionSlow(
|
126
|
+
const char* source, const char* reason,
|
127
|
+
StackState stack_state = StackState::kMayContainHeapPointers);
|
128
|
+
|
129
|
+
AllocationHandle& GetAllocationHandle();
|
130
|
+
|
131
|
+
private:
|
132
|
+
Heap() = default;
|
133
|
+
|
134
|
+
friend class internal::Heap;
|
135
|
+
};
|
136
|
+
|
137
|
+
} // namespace cppgc
|
138
|
+
|
139
|
+
#endif // INCLUDE_CPPGC_HEAP_H_
|
@@ -0,0 +1,47 @@
|
|
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_INTERNAL_API_CONSTANTS_H_
|
6
|
+
#define INCLUDE_CPPGC_INTERNAL_API_CONSTANTS_H_
|
7
|
+
|
8
|
+
#include <stddef.h>
|
9
|
+
#include <stdint.h>
|
10
|
+
|
11
|
+
#include "v8config.h" // NOLINT(build/include_directory)
|
12
|
+
|
13
|
+
namespace cppgc {
|
14
|
+
namespace internal {
|
15
|
+
|
16
|
+
// Embedders should not rely on this code!
|
17
|
+
|
18
|
+
// Internal constants to avoid exposing internal types on the API surface.
|
19
|
+
namespace api_constants {
|
20
|
+
|
21
|
+
constexpr size_t kKB = 1024;
|
22
|
+
constexpr size_t kMB = kKB * 1024;
|
23
|
+
constexpr size_t kGB = kMB * 1024;
|
24
|
+
|
25
|
+
// Offset of the uint16_t bitfield from the payload contaning the
|
26
|
+
// in-construction bit. This is subtracted from the payload pointer to get
|
27
|
+
// to the right bitfield.
|
28
|
+
static constexpr size_t kFullyConstructedBitFieldOffsetFromPayload =
|
29
|
+
2 * sizeof(uint16_t);
|
30
|
+
// Mask for in-construction bit.
|
31
|
+
static constexpr size_t kFullyConstructedBitMask = size_t{1};
|
32
|
+
|
33
|
+
static constexpr size_t kPageSize = size_t{1} << 17;
|
34
|
+
|
35
|
+
static constexpr size_t kLargeObjectSizeThreshold = kPageSize / 2;
|
36
|
+
|
37
|
+
#if defined(CPPGC_CAGED_HEAP)
|
38
|
+
constexpr size_t kCagedHeapReservationSize = static_cast<size_t>(4) * kGB;
|
39
|
+
constexpr size_t kCagedHeapReservationAlignment = kCagedHeapReservationSize;
|
40
|
+
#endif
|
41
|
+
|
42
|
+
} // namespace api_constants
|
43
|
+
|
44
|
+
} // namespace internal
|
45
|
+
} // namespace cppgc
|
46
|
+
|
47
|
+
#endif // INCLUDE_CPPGC_INTERNAL_API_CONSTANTS_H_
|
@@ -0,0 +1,48 @@
|
|
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_INTERNAL_ATOMIC_ENTRY_FLAG_H_
|
6
|
+
#define INCLUDE_CPPGC_INTERNAL_ATOMIC_ENTRY_FLAG_H_
|
7
|
+
|
8
|
+
#include <atomic>
|
9
|
+
|
10
|
+
namespace cppgc {
|
11
|
+
namespace internal {
|
12
|
+
|
13
|
+
// A flag which provides a fast check whether a scope may be entered on the
|
14
|
+
// current thread, without needing to access thread-local storage or mutex. Can
|
15
|
+
// have false positives (i.e., spuriously report that it might be entered), so
|
16
|
+
// it is expected that this will be used in tandem with a precise check that the
|
17
|
+
// scope is in fact entered on that thread.
|
18
|
+
//
|
19
|
+
// Example:
|
20
|
+
// g_frobnicating_flag.MightBeEntered() &&
|
21
|
+
// ThreadLocalFrobnicator().IsFrobnicating()
|
22
|
+
//
|
23
|
+
// Relaxed atomic operations are sufficient, since:
|
24
|
+
// - all accesses remain atomic
|
25
|
+
// - each thread must observe its own operations in order
|
26
|
+
// - no thread ever exits the flag more times than it enters (if used correctly)
|
27
|
+
// And so if a thread observes zero, it must be because it has observed an equal
|
28
|
+
// number of exits as entries.
|
29
|
+
class AtomicEntryFlag final {
|
30
|
+
public:
|
31
|
+
void Enter() { entries_.fetch_add(1, std::memory_order_relaxed); }
|
32
|
+
void Exit() { entries_.fetch_sub(1, std::memory_order_relaxed); }
|
33
|
+
|
34
|
+
// Returns false only if the current thread is not between a call to Enter
|
35
|
+
// and a call to Exit. Returns true if this thread or another thread may
|
36
|
+
// currently be in the scope guarded by this flag.
|
37
|
+
bool MightBeEntered() const {
|
38
|
+
return entries_.load(std::memory_order_relaxed) != 0;
|
39
|
+
}
|
40
|
+
|
41
|
+
private:
|
42
|
+
std::atomic_int entries_{0};
|
43
|
+
};
|
44
|
+
|
45
|
+
} // namespace internal
|
46
|
+
} // namespace cppgc
|
47
|
+
|
48
|
+
#endif // INCLUDE_CPPGC_INTERNAL_ATOMIC_ENTRY_FLAG_H_
|
@@ -0,0 +1,67 @@
|
|
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_INTERNAL_CAGED_HEAP_LOCAL_DATA_H_
|
6
|
+
#define INCLUDE_CPPGC_INTERNAL_CAGED_HEAP_LOCAL_DATA_H_
|
7
|
+
|
8
|
+
#include <array>
|
9
|
+
|
10
|
+
#include "cppgc/internal/api-constants.h"
|
11
|
+
#include "cppgc/internal/logging.h"
|
12
|
+
#include "cppgc/platform.h"
|
13
|
+
|
14
|
+
namespace cppgc {
|
15
|
+
namespace internal {
|
16
|
+
|
17
|
+
class HeapBase;
|
18
|
+
|
19
|
+
#if defined(CPPGC_YOUNG_GENERATION)
|
20
|
+
|
21
|
+
// AgeTable contains entries that correspond to 4KB memory regions. Each entry
|
22
|
+
// can be in one of three states: kOld, kYoung or kUnknown.
|
23
|
+
class AgeTable final {
|
24
|
+
static constexpr size_t kGranularityBits = 12; // 4KiB per byte.
|
25
|
+
|
26
|
+
public:
|
27
|
+
enum class Age : uint8_t { kOld, kYoung, kUnknown };
|
28
|
+
|
29
|
+
static constexpr size_t kEntrySizeInBytes = 1 << kGranularityBits;
|
30
|
+
|
31
|
+
Age& operator[](uintptr_t offset) { return table_[entry(offset)]; }
|
32
|
+
Age operator[](uintptr_t offset) const { return table_[entry(offset)]; }
|
33
|
+
|
34
|
+
void Reset(PageAllocator* allocator);
|
35
|
+
|
36
|
+
private:
|
37
|
+
static constexpr size_t kAgeTableSize =
|
38
|
+
api_constants::kCagedHeapReservationSize >> kGranularityBits;
|
39
|
+
|
40
|
+
size_t entry(uintptr_t offset) const {
|
41
|
+
const size_t entry = offset >> kGranularityBits;
|
42
|
+
CPPGC_DCHECK(table_.size() > entry);
|
43
|
+
return entry;
|
44
|
+
}
|
45
|
+
|
46
|
+
std::array<Age, kAgeTableSize> table_;
|
47
|
+
};
|
48
|
+
|
49
|
+
static_assert(sizeof(AgeTable) == 1 * api_constants::kMB,
|
50
|
+
"Size of AgeTable is 1MB");
|
51
|
+
|
52
|
+
#endif // CPPGC_YOUNG_GENERATION
|
53
|
+
|
54
|
+
struct CagedHeapLocalData final {
|
55
|
+
explicit CagedHeapLocalData(HeapBase* heap_base) : heap_base(heap_base) {}
|
56
|
+
|
57
|
+
bool is_marking_in_progress = false;
|
58
|
+
HeapBase* heap_base = nullptr;
|
59
|
+
#if defined(CPPGC_YOUNG_GENERATION)
|
60
|
+
AgeTable age_table;
|
61
|
+
#endif
|
62
|
+
};
|
63
|
+
|
64
|
+
} // namespace internal
|
65
|
+
} // namespace cppgc
|
66
|
+
|
67
|
+
#endif // INCLUDE_CPPGC_INTERNAL_CAGED_HEAP_LOCAL_DATA_H_
|
@@ -0,0 +1,38 @@
|
|
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_INTERNAL_COMPILER_SPECIFIC_H_
|
6
|
+
#define INCLUDE_CPPGC_INTERNAL_COMPILER_SPECIFIC_H_
|
7
|
+
|
8
|
+
namespace cppgc {
|
9
|
+
|
10
|
+
#if defined(__has_attribute)
|
11
|
+
#define CPPGC_HAS_ATTRIBUTE(FEATURE) __has_attribute(FEATURE)
|
12
|
+
#else
|
13
|
+
#define CPPGC_HAS_ATTRIBUTE(FEATURE) 0
|
14
|
+
#endif
|
15
|
+
|
16
|
+
#if defined(__has_cpp_attribute)
|
17
|
+
#define CPPGC_HAS_CPP_ATTRIBUTE(FEATURE) __has_cpp_attribute(FEATURE)
|
18
|
+
#else
|
19
|
+
#define CPPGC_HAS_CPP_ATTRIBUTE(FEATURE) 0
|
20
|
+
#endif
|
21
|
+
|
22
|
+
// [[no_unique_address]] comes in C++20 but supported in clang with -std >=
|
23
|
+
// c++11.
|
24
|
+
#if CPPGC_HAS_CPP_ATTRIBUTE(no_unique_address) // NOLINTNEXTLINE
|
25
|
+
#define CPPGC_NO_UNIQUE_ADDRESS [[no_unique_address]]
|
26
|
+
#else
|
27
|
+
#define CPPGC_NO_UNIQUE_ADDRESS
|
28
|
+
#endif
|
29
|
+
|
30
|
+
#if CPPGC_HAS_ATTRIBUTE(unused) // NOLINTNEXTLINE
|
31
|
+
#define CPPGC_UNUSED __attribute__((unused))
|
32
|
+
#else
|
33
|
+
#define CPPGC_UNUSED
|
34
|
+
#endif
|
35
|
+
|
36
|
+
} // namespace cppgc
|
37
|
+
|
38
|
+
#endif // INCLUDE_CPPGC_INTERNAL_COMPILER_SPECIFIC_H_
|
@@ -0,0 +1,90 @@
|
|
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_INTERNAL_FINALIZER_TRAIT_H_
|
6
|
+
#define INCLUDE_CPPGC_INTERNAL_FINALIZER_TRAIT_H_
|
7
|
+
|
8
|
+
#include <type_traits>
|
9
|
+
|
10
|
+
#include "cppgc/type-traits.h"
|
11
|
+
|
12
|
+
namespace cppgc {
|
13
|
+
namespace internal {
|
14
|
+
|
15
|
+
using FinalizationCallback = void (*)(void*);
|
16
|
+
|
17
|
+
template <typename T, typename = void>
|
18
|
+
struct HasFinalizeGarbageCollectedObject : std::false_type {};
|
19
|
+
|
20
|
+
template <typename T>
|
21
|
+
struct HasFinalizeGarbageCollectedObject<
|
22
|
+
T, void_t<decltype(std::declval<T>().FinalizeGarbageCollectedObject())>>
|
23
|
+
: std::true_type {};
|
24
|
+
|
25
|
+
// The FinalizerTraitImpl specifies how to finalize objects.
|
26
|
+
template <typename T, bool isFinalized>
|
27
|
+
struct FinalizerTraitImpl;
|
28
|
+
|
29
|
+
template <typename T>
|
30
|
+
struct FinalizerTraitImpl<T, true> {
|
31
|
+
private:
|
32
|
+
// Dispatch to custom FinalizeGarbageCollectedObject().
|
33
|
+
struct Custom {
|
34
|
+
static void Call(void* obj) {
|
35
|
+
static_cast<T*>(obj)->FinalizeGarbageCollectedObject();
|
36
|
+
}
|
37
|
+
};
|
38
|
+
|
39
|
+
// Dispatch to regular destructor.
|
40
|
+
struct Destructor {
|
41
|
+
static void Call(void* obj) { static_cast<T*>(obj)->~T(); }
|
42
|
+
};
|
43
|
+
|
44
|
+
using FinalizeImpl =
|
45
|
+
std::conditional_t<HasFinalizeGarbageCollectedObject<T>::value, Custom,
|
46
|
+
Destructor>;
|
47
|
+
|
48
|
+
public:
|
49
|
+
static void Finalize(void* obj) {
|
50
|
+
static_assert(sizeof(T), "T must be fully defined");
|
51
|
+
FinalizeImpl::Call(obj);
|
52
|
+
}
|
53
|
+
};
|
54
|
+
|
55
|
+
template <typename T>
|
56
|
+
struct FinalizerTraitImpl<T, false> {
|
57
|
+
static void Finalize(void* obj) {
|
58
|
+
static_assert(sizeof(T), "T must be fully defined");
|
59
|
+
}
|
60
|
+
};
|
61
|
+
|
62
|
+
// The FinalizerTrait is used to determine if a type requires finalization and
|
63
|
+
// what finalization means.
|
64
|
+
template <typename T>
|
65
|
+
struct FinalizerTrait {
|
66
|
+
private:
|
67
|
+
// Object has a finalizer if it has
|
68
|
+
// - a custom FinalizeGarbageCollectedObject method, or
|
69
|
+
// - a destructor.
|
70
|
+
static constexpr bool kNonTrivialFinalizer =
|
71
|
+
internal::HasFinalizeGarbageCollectedObject<T>::value ||
|
72
|
+
!std::is_trivially_destructible<typename std::remove_cv<T>::type>::value;
|
73
|
+
|
74
|
+
static void Finalize(void* obj) {
|
75
|
+
internal::FinalizerTraitImpl<T, kNonTrivialFinalizer>::Finalize(obj);
|
76
|
+
}
|
77
|
+
|
78
|
+
public:
|
79
|
+
// The callback used to finalize an object of type T.
|
80
|
+
static constexpr FinalizationCallback kCallback =
|
81
|
+
kNonTrivialFinalizer ? Finalize : nullptr;
|
82
|
+
};
|
83
|
+
|
84
|
+
template <typename T>
|
85
|
+
constexpr FinalizationCallback FinalizerTrait<T>::kCallback;
|
86
|
+
|
87
|
+
} // namespace internal
|
88
|
+
} // namespace cppgc
|
89
|
+
|
90
|
+
#endif // INCLUDE_CPPGC_INTERNAL_FINALIZER_TRAIT_H_
|
@@ -0,0 +1,45 @@
|
|
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_INTERNAL_GC_INFO_H_
|
6
|
+
#define INCLUDE_CPPGC_INTERNAL_GC_INFO_H_
|
7
|
+
|
8
|
+
#include <stdint.h>
|
9
|
+
|
10
|
+
#include "cppgc/internal/finalizer-trait.h"
|
11
|
+
#include "cppgc/trace-trait.h"
|
12
|
+
#include "v8config.h" // NOLINT(build/include_directory)
|
13
|
+
|
14
|
+
namespace cppgc {
|
15
|
+
namespace internal {
|
16
|
+
|
17
|
+
using GCInfoIndex = uint16_t;
|
18
|
+
|
19
|
+
class V8_EXPORT RegisteredGCInfoIndex final {
|
20
|
+
public:
|
21
|
+
RegisteredGCInfoIndex(FinalizationCallback finalization_callback,
|
22
|
+
TraceCallback trace_callback, bool has_v_table);
|
23
|
+
GCInfoIndex GetIndex() const { return index_; }
|
24
|
+
|
25
|
+
private:
|
26
|
+
const GCInfoIndex index_;
|
27
|
+
};
|
28
|
+
|
29
|
+
// Trait determines how the garbage collector treats objects wrt. to traversing,
|
30
|
+
// finalization, and naming.
|
31
|
+
template <typename T>
|
32
|
+
struct GCInfoTrait {
|
33
|
+
static GCInfoIndex Index() {
|
34
|
+
static_assert(sizeof(T), "T must be fully defined");
|
35
|
+
static const RegisteredGCInfoIndex registered_index(
|
36
|
+
FinalizerTrait<T>::kCallback, TraceTrait<T>::Trace,
|
37
|
+
std::is_polymorphic<T>::value);
|
38
|
+
return registered_index.GetIndex();
|
39
|
+
}
|
40
|
+
};
|
41
|
+
|
42
|
+
} // namespace internal
|
43
|
+
} // namespace cppgc
|
44
|
+
|
45
|
+
#endif // INCLUDE_CPPGC_INTERNAL_GC_INFO_H_
|
@@ -0,0 +1,50 @@
|
|
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_INTERNAL_LOGGING_H_
|
6
|
+
#define INCLUDE_CPPGC_INTERNAL_LOGGING_H_
|
7
|
+
|
8
|
+
#include "cppgc/source-location.h"
|
9
|
+
#include "v8config.h" // NOLINT(build/include_directory)
|
10
|
+
|
11
|
+
namespace cppgc {
|
12
|
+
namespace internal {
|
13
|
+
|
14
|
+
void V8_EXPORT DCheckImpl(const char*,
|
15
|
+
const SourceLocation& = SourceLocation::Current());
|
16
|
+
[[noreturn]] void V8_EXPORT
|
17
|
+
FatalImpl(const char*, const SourceLocation& = SourceLocation::Current());
|
18
|
+
|
19
|
+
// Used to ignore -Wunused-variable.
|
20
|
+
template <typename>
|
21
|
+
struct EatParams {};
|
22
|
+
|
23
|
+
#if DEBUG
|
24
|
+
#define CPPGC_DCHECK_MSG(condition, message) \
|
25
|
+
do { \
|
26
|
+
if (V8_UNLIKELY(!(condition))) { \
|
27
|
+
::cppgc::internal::DCheckImpl(message); \
|
28
|
+
} \
|
29
|
+
} while (false)
|
30
|
+
#else
|
31
|
+
#define CPPGC_DCHECK_MSG(condition, message) \
|
32
|
+
(static_cast<void>(::cppgc::internal::EatParams<decltype( \
|
33
|
+
static_cast<void>(condition), message)>{}))
|
34
|
+
#endif
|
35
|
+
|
36
|
+
#define CPPGC_DCHECK(condition) CPPGC_DCHECK_MSG(condition, #condition)
|
37
|
+
|
38
|
+
#define CPPGC_CHECK_MSG(condition, message) \
|
39
|
+
do { \
|
40
|
+
if (V8_UNLIKELY(!(condition))) { \
|
41
|
+
::cppgc::internal::FatalImpl(message); \
|
42
|
+
} \
|
43
|
+
} while (false)
|
44
|
+
|
45
|
+
#define CPPGC_CHECK(condition) CPPGC_CHECK_MSG(condition, #condition)
|
46
|
+
|
47
|
+
} // namespace internal
|
48
|
+
} // namespace cppgc
|
49
|
+
|
50
|
+
#endif // INCLUDE_CPPGC_INTERNAL_LOGGING_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_INTERNAL_PERSISTENT_NODE_H_
|
6
|
+
#define INCLUDE_CPPGC_INTERNAL_PERSISTENT_NODE_H_
|
7
|
+
|
8
|
+
#include <array>
|
9
|
+
#include <memory>
|
10
|
+
#include <vector>
|
11
|
+
|
12
|
+
#include "cppgc/internal/logging.h"
|
13
|
+
#include "cppgc/trace-trait.h"
|
14
|
+
#include "v8config.h" // NOLINT(build/include_directory)
|
15
|
+
|
16
|
+
namespace cppgc {
|
17
|
+
|
18
|
+
class Visitor;
|
19
|
+
|
20
|
+
namespace internal {
|
21
|
+
|
22
|
+
// PersistentNode represesents a variant of two states:
|
23
|
+
// 1) traceable node with a back pointer to the Persistent object;
|
24
|
+
// 2) freelist entry.
|
25
|
+
class PersistentNode final {
|
26
|
+
public:
|
27
|
+
PersistentNode() = default;
|
28
|
+
|
29
|
+
PersistentNode(const PersistentNode&) = delete;
|
30
|
+
PersistentNode& operator=(const PersistentNode&) = delete;
|
31
|
+
|
32
|
+
void InitializeAsUsedNode(void* owner, TraceCallback trace) {
|
33
|
+
owner_ = owner;
|
34
|
+
trace_ = trace;
|
35
|
+
}
|
36
|
+
|
37
|
+
void InitializeAsFreeNode(PersistentNode* next) {
|
38
|
+
next_ = next;
|
39
|
+
trace_ = nullptr;
|
40
|
+
}
|
41
|
+
|
42
|
+
void UpdateOwner(void* owner) {
|
43
|
+
CPPGC_DCHECK(IsUsed());
|
44
|
+
owner_ = owner;
|
45
|
+
}
|
46
|
+
|
47
|
+
PersistentNode* FreeListNext() const {
|
48
|
+
CPPGC_DCHECK(!IsUsed());
|
49
|
+
return next_;
|
50
|
+
}
|
51
|
+
|
52
|
+
void Trace(Visitor* visitor) const {
|
53
|
+
CPPGC_DCHECK(IsUsed());
|
54
|
+
trace_(visitor, owner_);
|
55
|
+
}
|
56
|
+
|
57
|
+
bool IsUsed() const { return trace_; }
|
58
|
+
|
59
|
+
void* owner() const {
|
60
|
+
CPPGC_DCHECK(IsUsed());
|
61
|
+
return owner_;
|
62
|
+
}
|
63
|
+
|
64
|
+
private:
|
65
|
+
// PersistentNode acts as a designated union:
|
66
|
+
// If trace_ != nullptr, owner_ points to the corresponding Persistent handle.
|
67
|
+
// Otherwise, next_ points to the next freed PersistentNode.
|
68
|
+
union {
|
69
|
+
void* owner_ = nullptr;
|
70
|
+
PersistentNode* next_;
|
71
|
+
};
|
72
|
+
TraceCallback trace_ = nullptr;
|
73
|
+
};
|
74
|
+
|
75
|
+
class V8_EXPORT PersistentRegion final {
|
76
|
+
using PersistentNodeSlots = std::array<PersistentNode, 256u>;
|
77
|
+
|
78
|
+
public:
|
79
|
+
PersistentRegion() = default;
|
80
|
+
// Clears Persistent fields to avoid stale pointers after heap teardown.
|
81
|
+
~PersistentRegion();
|
82
|
+
|
83
|
+
PersistentRegion(const PersistentRegion&) = delete;
|
84
|
+
PersistentRegion& operator=(const PersistentRegion&) = delete;
|
85
|
+
|
86
|
+
PersistentNode* AllocateNode(void* owner, TraceCallback trace) {
|
87
|
+
if (!free_list_head_) {
|
88
|
+
EnsureNodeSlots();
|
89
|
+
}
|
90
|
+
PersistentNode* node = free_list_head_;
|
91
|
+
free_list_head_ = free_list_head_->FreeListNext();
|
92
|
+
node->InitializeAsUsedNode(owner, trace);
|
93
|
+
return node;
|
94
|
+
}
|
95
|
+
|
96
|
+
void FreeNode(PersistentNode* node) {
|
97
|
+
node->InitializeAsFreeNode(free_list_head_);
|
98
|
+
free_list_head_ = node;
|
99
|
+
}
|
100
|
+
|
101
|
+
void Trace(Visitor*);
|
102
|
+
|
103
|
+
size_t NodesInUse() const;
|
104
|
+
|
105
|
+
private:
|
106
|
+
void EnsureNodeSlots();
|
107
|
+
|
108
|
+
std::vector<std::unique_ptr<PersistentNodeSlots>> nodes_;
|
109
|
+
PersistentNode* free_list_head_ = nullptr;
|
110
|
+
};
|
111
|
+
|
112
|
+
} // namespace internal
|
113
|
+
|
114
|
+
} // namespace cppgc
|
115
|
+
|
116
|
+
#endif // INCLUDE_CPPGC_INTERNAL_PERSISTENT_NODE_H_
|