libv8-node 16.20.0.0-aarch64-linux-musl → 17.9.1.0-aarch64-linux-musl

Sign up to get free protection for your applications and to get access to all the features.
Files changed (70) hide show
  1. checksums.yaml +4 -4
  2. data/ext/libv8-node/location.rb +1 -1
  3. data/ext/libv8-node/paths.rb +1 -1
  4. data/lib/libv8/node/version.rb +3 -3
  5. data/vendor/v8/aarch64-linux-musl/libv8/obj/libv8_monolith.a +0 -0
  6. data/vendor/v8/include/cppgc/allocation.h +11 -5
  7. data/vendor/v8/include/cppgc/cross-thread-persistent.h +78 -26
  8. data/vendor/v8/include/cppgc/internal/caged-heap-local-data.h +2 -2
  9. data/vendor/v8/include/cppgc/internal/finalizer-trait.h +2 -0
  10. data/vendor/v8/include/cppgc/internal/gc-info.h +90 -10
  11. data/vendor/v8/include/cppgc/internal/name-trait.h +11 -0
  12. data/vendor/v8/include/cppgc/internal/persistent-node.h +44 -12
  13. data/vendor/v8/include/cppgc/internal/pointer-policies.h +22 -11
  14. data/vendor/v8/include/cppgc/internal/write-barrier.h +9 -1
  15. data/vendor/v8/include/cppgc/persistent.h +1 -1
  16. data/vendor/v8/include/cppgc/prefinalizer.h +1 -1
  17. data/vendor/v8/include/v8-array-buffer.h +433 -0
  18. data/vendor/v8/include/v8-callbacks.h +377 -0
  19. data/vendor/v8/include/v8-container.h +129 -0
  20. data/vendor/v8/include/v8-context.h +418 -0
  21. data/vendor/v8/include/v8-cppgc.h +5 -2
  22. data/vendor/v8/include/v8-data.h +65 -0
  23. data/vendor/v8/include/v8-date.h +43 -0
  24. data/vendor/v8/include/v8-debug.h +151 -0
  25. data/vendor/v8/include/v8-embedder-heap.h +238 -0
  26. data/vendor/v8/include/v8-exception.h +224 -0
  27. data/vendor/v8/include/v8-extension.h +62 -0
  28. data/vendor/v8/include/v8-external.h +37 -0
  29. data/vendor/v8/include/v8-fast-api-calls.h +63 -11
  30. data/vendor/v8/include/v8-forward.h +81 -0
  31. data/vendor/v8/include/v8-function-callback.h +475 -0
  32. data/vendor/v8/include/v8-function.h +122 -0
  33. data/vendor/v8/include/v8-initialization.h +282 -0
  34. data/vendor/v8/include/v8-inspector.h +11 -21
  35. data/vendor/v8/include/v8-internal.h +85 -22
  36. data/vendor/v8/include/v8-isolate.h +1662 -0
  37. data/vendor/v8/include/v8-json.h +47 -0
  38. data/vendor/v8/include/v8-local-handle.h +459 -0
  39. data/vendor/v8/include/v8-locker.h +148 -0
  40. data/vendor/v8/include/v8-maybe.h +137 -0
  41. data/vendor/v8/include/v8-memory-span.h +43 -0
  42. data/vendor/v8/include/v8-message.h +241 -0
  43. data/vendor/v8/include/v8-metrics.h +37 -1
  44. data/vendor/v8/include/v8-microtask-queue.h +152 -0
  45. data/vendor/v8/include/v8-microtask.h +28 -0
  46. data/vendor/v8/include/v8-object.h +770 -0
  47. data/vendor/v8/include/v8-persistent-handle.h +590 -0
  48. data/vendor/v8/include/v8-platform.h +41 -17
  49. data/vendor/v8/include/v8-primitive-object.h +118 -0
  50. data/vendor/v8/include/v8-primitive.h +858 -0
  51. data/vendor/v8/include/v8-profiler.h +10 -11
  52. data/vendor/v8/include/v8-promise.h +174 -0
  53. data/vendor/v8/include/v8-proxy.h +50 -0
  54. data/vendor/v8/include/v8-regexp.h +105 -0
  55. data/vendor/v8/include/v8-script.h +771 -0
  56. data/vendor/v8/include/v8-snapshot.h +198 -0
  57. data/vendor/v8/include/v8-statistics.h +215 -0
  58. data/vendor/v8/include/v8-template.h +1052 -0
  59. data/vendor/v8/include/v8-traced-handle.h +605 -0
  60. data/vendor/v8/include/v8-typed-array.h +282 -0
  61. data/vendor/v8/include/v8-unwinder-state.h +4 -3
  62. data/vendor/v8/include/v8-unwinder.h +129 -0
  63. data/vendor/v8/include/v8-util.h +7 -1
  64. data/vendor/v8/include/v8-value-serializer.h +249 -0
  65. data/vendor/v8/include/v8-value.h +526 -0
  66. data/vendor/v8/include/v8-version.h +3 -3
  67. data/vendor/v8/include/v8-wasm.h +245 -0
  68. data/vendor/v8/include/v8-weak-callback-info.h +73 -0
  69. data/vendor/v8/include/v8.h +41 -12604
  70. metadata +47 -5
@@ -0,0 +1,198 @@
1
+ // Copyright 2021 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_SNAPSHOT_H_
6
+ #define INCLUDE_V8_SNAPSHOT_H_
7
+
8
+ #include <vector>
9
+
10
+ #include "v8-internal.h" // NOLINT(build/include_directory)
11
+ #include "v8-local-handle.h" // NOLINT(build/include_directory)
12
+ #include "v8config.h" // NOLINT(build/include_directory)
13
+
14
+ namespace v8 {
15
+
16
+ class Object;
17
+
18
+ class V8_EXPORT StartupData {
19
+ public:
20
+ /**
21
+ * Whether the data created can be rehashed and and the hash seed can be
22
+ * recomputed when deserialized.
23
+ * Only valid for StartupData returned by SnapshotCreator::CreateBlob().
24
+ */
25
+ bool CanBeRehashed() const;
26
+ /**
27
+ * Allows embedders to verify whether the data is valid for the current
28
+ * V8 instance.
29
+ */
30
+ bool IsValid() const;
31
+
32
+ const char* data;
33
+ int raw_size;
34
+ };
35
+
36
+ /**
37
+ * Callback and supporting data used in SnapshotCreator to implement embedder
38
+ * logic to serialize internal fields.
39
+ * Internal fields that directly reference V8 objects are serialized without
40
+ * calling this callback. Internal fields that contain aligned pointers are
41
+ * serialized by this callback if it returns non-zero result. Otherwise it is
42
+ * serialized verbatim.
43
+ */
44
+ struct SerializeInternalFieldsCallback {
45
+ using CallbackFunction = StartupData (*)(Local<Object> holder, int index,
46
+ void* data);
47
+ SerializeInternalFieldsCallback(CallbackFunction function = nullptr,
48
+ void* data_arg = nullptr)
49
+ : callback(function), data(data_arg) {}
50
+ CallbackFunction callback;
51
+ void* data;
52
+ };
53
+ // Note that these fields are called "internal fields" in the API and called
54
+ // "embedder fields" within V8.
55
+ using SerializeEmbedderFieldsCallback = SerializeInternalFieldsCallback;
56
+
57
+ /**
58
+ * Callback and supporting data used to implement embedder logic to deserialize
59
+ * internal fields.
60
+ */
61
+ struct DeserializeInternalFieldsCallback {
62
+ using CallbackFunction = void (*)(Local<Object> holder, int index,
63
+ StartupData payload, void* data);
64
+ DeserializeInternalFieldsCallback(CallbackFunction function = nullptr,
65
+ void* data_arg = nullptr)
66
+ : callback(function), data(data_arg) {}
67
+ void (*callback)(Local<Object> holder, int index, StartupData payload,
68
+ void* data);
69
+ void* data;
70
+ };
71
+
72
+ using DeserializeEmbedderFieldsCallback = DeserializeInternalFieldsCallback;
73
+
74
+ /**
75
+ * Helper class to create a snapshot data blob.
76
+ *
77
+ * The Isolate used by a SnapshotCreator is owned by it, and will be entered
78
+ * and exited by the constructor and destructor, respectively; The destructor
79
+ * will also destroy the Isolate. Experimental language features, including
80
+ * those available by default, are not available while creating a snapshot.
81
+ */
82
+ class V8_EXPORT SnapshotCreator {
83
+ public:
84
+ enum class FunctionCodeHandling { kClear, kKeep };
85
+
86
+ /**
87
+ * Initialize and enter an isolate, and set it up for serialization.
88
+ * The isolate is either created from scratch or from an existing snapshot.
89
+ * The caller keeps ownership of the argument snapshot.
90
+ * \param existing_blob existing snapshot from which to create this one.
91
+ * \param external_references a null-terminated array of external references
92
+ * that must be equivalent to CreateParams::external_references.
93
+ */
94
+ SnapshotCreator(Isolate* isolate,
95
+ const intptr_t* external_references = nullptr,
96
+ StartupData* existing_blob = nullptr);
97
+
98
+ /**
99
+ * Create and enter an isolate, and set it up for serialization.
100
+ * The isolate is either created from scratch or from an existing snapshot.
101
+ * The caller keeps ownership of the argument snapshot.
102
+ * \param existing_blob existing snapshot from which to create this one.
103
+ * \param external_references a null-terminated array of external references
104
+ * that must be equivalent to CreateParams::external_references.
105
+ */
106
+ SnapshotCreator(const intptr_t* external_references = nullptr,
107
+ StartupData* existing_blob = nullptr);
108
+
109
+ /**
110
+ * Destroy the snapshot creator, and exit and dispose of the Isolate
111
+ * associated with it.
112
+ */
113
+ ~SnapshotCreator();
114
+
115
+ /**
116
+ * \returns the isolate prepared by the snapshot creator.
117
+ */
118
+ Isolate* GetIsolate();
119
+
120
+ /**
121
+ * Set the default context to be included in the snapshot blob.
122
+ * The snapshot will not contain the global proxy, and we expect one or a
123
+ * global object template to create one, to be provided upon deserialization.
124
+ *
125
+ * \param callback optional callback to serialize internal fields.
126
+ */
127
+ void SetDefaultContext(Local<Context> context,
128
+ SerializeInternalFieldsCallback callback =
129
+ SerializeInternalFieldsCallback());
130
+
131
+ /**
132
+ * Add additional context to be included in the snapshot blob.
133
+ * The snapshot will include the global proxy.
134
+ *
135
+ * \param callback optional callback to serialize internal fields.
136
+ *
137
+ * \returns the index of the context in the snapshot blob.
138
+ */
139
+ size_t AddContext(Local<Context> context,
140
+ SerializeInternalFieldsCallback callback =
141
+ SerializeInternalFieldsCallback());
142
+
143
+ /**
144
+ * Attach arbitrary V8::Data to the context snapshot, which can be retrieved
145
+ * via Context::GetDataFromSnapshotOnce after deserialization. This data does
146
+ * not survive when a new snapshot is created from an existing snapshot.
147
+ * \returns the index for retrieval.
148
+ */
149
+ template <class T>
150
+ V8_INLINE size_t AddData(Local<Context> context, Local<T> object);
151
+
152
+ /**
153
+ * Attach arbitrary V8::Data to the isolate snapshot, which can be retrieved
154
+ * via Isolate::GetDataFromSnapshotOnce after deserialization. This data does
155
+ * not survive when a new snapshot is created from an existing snapshot.
156
+ * \returns the index for retrieval.
157
+ */
158
+ template <class T>
159
+ V8_INLINE size_t AddData(Local<T> object);
160
+
161
+ /**
162
+ * Created a snapshot data blob.
163
+ * This must not be called from within a handle scope.
164
+ * \param function_code_handling whether to include compiled function code
165
+ * in the snapshot.
166
+ * \returns { nullptr, 0 } on failure, and a startup snapshot on success. The
167
+ * caller acquires ownership of the data array in the return value.
168
+ */
169
+ StartupData CreateBlob(FunctionCodeHandling function_code_handling);
170
+
171
+ // Disallow copying and assigning.
172
+ SnapshotCreator(const SnapshotCreator&) = delete;
173
+ void operator=(const SnapshotCreator&) = delete;
174
+
175
+ private:
176
+ size_t AddData(Local<Context> context, internal::Address object);
177
+ size_t AddData(internal::Address object);
178
+
179
+ void* data_;
180
+ };
181
+
182
+ template <class T>
183
+ size_t SnapshotCreator::AddData(Local<Context> context, Local<T> object) {
184
+ T* object_ptr = *object;
185
+ internal::Address* p = reinterpret_cast<internal::Address*>(object_ptr);
186
+ return AddData(context, *p);
187
+ }
188
+
189
+ template <class T>
190
+ size_t SnapshotCreator::AddData(Local<T> object) {
191
+ T* object_ptr = *object;
192
+ internal::Address* p = reinterpret_cast<internal::Address*>(object_ptr);
193
+ return AddData(*p);
194
+ }
195
+
196
+ } // namespace v8
197
+
198
+ #endif // INCLUDE_V8_SNAPSHOT_H_
@@ -0,0 +1,215 @@
1
+ // Copyright 2021 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_STATISTICS_H_
6
+ #define INCLUDE_V8_STATISTICS_H_
7
+
8
+ #include <stddef.h>
9
+ #include <stdint.h>
10
+
11
+ #include <memory>
12
+ #include <utility>
13
+ #include <vector>
14
+
15
+ #include "v8-local-handle.h" // NOLINT(build/include_directory)
16
+ #include "v8-promise.h" // NOLINT(build/include_directory)
17
+ #include "v8config.h" // NOLINT(build/include_directory)
18
+
19
+ namespace v8 {
20
+
21
+ class Context;
22
+ class Isolate;
23
+
24
+ namespace internal {
25
+ class ReadOnlyHeap;
26
+ } // namespace internal
27
+
28
+ /**
29
+ * Controls how the default MeasureMemoryDelegate reports the result of
30
+ * the memory measurement to JS. With kSummary only the total size is reported.
31
+ * With kDetailed the result includes the size of each native context.
32
+ */
33
+ enum class MeasureMemoryMode { kSummary, kDetailed };
34
+
35
+ /**
36
+ * Controls how promptly a memory measurement request is executed.
37
+ * By default the measurement is folded with the next scheduled GC which may
38
+ * happen after a while and is forced after some timeout.
39
+ * The kEager mode starts incremental GC right away and is useful for testing.
40
+ * The kLazy mode does not force GC.
41
+ */
42
+ enum class MeasureMemoryExecution { kDefault, kEager, kLazy };
43
+
44
+ /**
45
+ * The delegate is used in Isolate::MeasureMemory API.
46
+ *
47
+ * It specifies the contexts that need to be measured and gets called when
48
+ * the measurement is completed to report the results.
49
+ */
50
+ class V8_EXPORT MeasureMemoryDelegate {
51
+ public:
52
+ virtual ~MeasureMemoryDelegate() = default;
53
+
54
+ /**
55
+ * Returns true if the size of the given context needs to be measured.
56
+ */
57
+ virtual bool ShouldMeasure(Local<Context> context) = 0;
58
+
59
+ /**
60
+ * This function is called when memory measurement finishes.
61
+ *
62
+ * \param context_sizes_in_bytes a vector of (context, size) pairs that
63
+ * includes each context for which ShouldMeasure returned true and that
64
+ * was not garbage collected while the memory measurement was in progress.
65
+ *
66
+ * \param unattributed_size_in_bytes total size of objects that were not
67
+ * attributed to any context (i.e. are likely shared objects).
68
+ */
69
+ virtual void MeasurementComplete(
70
+ const std::vector<std::pair<Local<Context>, size_t>>&
71
+ context_sizes_in_bytes,
72
+ size_t unattributed_size_in_bytes) = 0;
73
+
74
+ /**
75
+ * Returns a default delegate that resolves the given promise when
76
+ * the memory measurement completes.
77
+ *
78
+ * \param isolate the current isolate
79
+ * \param context the current context
80
+ * \param promise_resolver the promise resolver that is given the
81
+ * result of the memory measurement.
82
+ * \param mode the detail level of the result.
83
+ */
84
+ static std::unique_ptr<MeasureMemoryDelegate> Default(
85
+ Isolate* isolate, Local<Context> context,
86
+ Local<Promise::Resolver> promise_resolver, MeasureMemoryMode mode);
87
+ };
88
+
89
+ /**
90
+ * Collection of shared per-process V8 memory information.
91
+ *
92
+ * Instances of this class can be passed to
93
+ * v8::V8::GetSharedMemoryStatistics to get shared memory statistics from V8.
94
+ */
95
+ class V8_EXPORT SharedMemoryStatistics {
96
+ public:
97
+ SharedMemoryStatistics();
98
+ size_t read_only_space_size() { return read_only_space_size_; }
99
+ size_t read_only_space_used_size() { return read_only_space_used_size_; }
100
+ size_t read_only_space_physical_size() {
101
+ return read_only_space_physical_size_;
102
+ }
103
+
104
+ private:
105
+ size_t read_only_space_size_;
106
+ size_t read_only_space_used_size_;
107
+ size_t read_only_space_physical_size_;
108
+
109
+ friend class V8;
110
+ friend class internal::ReadOnlyHeap;
111
+ };
112
+
113
+ /**
114
+ * Collection of V8 heap information.
115
+ *
116
+ * Instances of this class can be passed to v8::Isolate::GetHeapStatistics to
117
+ * get heap statistics from V8.
118
+ */
119
+ class V8_EXPORT HeapStatistics {
120
+ public:
121
+ HeapStatistics();
122
+ size_t total_heap_size() { return total_heap_size_; }
123
+ size_t total_heap_size_executable() { return total_heap_size_executable_; }
124
+ size_t total_physical_size() { return total_physical_size_; }
125
+ size_t total_available_size() { return total_available_size_; }
126
+ size_t total_global_handles_size() { return total_global_handles_size_; }
127
+ size_t used_global_handles_size() { return used_global_handles_size_; }
128
+ size_t used_heap_size() { return used_heap_size_; }
129
+ size_t heap_size_limit() { return heap_size_limit_; }
130
+ size_t malloced_memory() { return malloced_memory_; }
131
+ size_t external_memory() { return external_memory_; }
132
+ size_t peak_malloced_memory() { return peak_malloced_memory_; }
133
+ size_t number_of_native_contexts() { return number_of_native_contexts_; }
134
+ size_t number_of_detached_contexts() { return number_of_detached_contexts_; }
135
+
136
+ /**
137
+ * Returns a 0/1 boolean, which signifies whether the V8 overwrite heap
138
+ * garbage with a bit pattern.
139
+ */
140
+ size_t does_zap_garbage() { return does_zap_garbage_; }
141
+
142
+ private:
143
+ size_t total_heap_size_;
144
+ size_t total_heap_size_executable_;
145
+ size_t total_physical_size_;
146
+ size_t total_available_size_;
147
+ size_t used_heap_size_;
148
+ size_t heap_size_limit_;
149
+ size_t malloced_memory_;
150
+ size_t external_memory_;
151
+ size_t peak_malloced_memory_;
152
+ bool does_zap_garbage_;
153
+ size_t number_of_native_contexts_;
154
+ size_t number_of_detached_contexts_;
155
+ size_t total_global_handles_size_;
156
+ size_t used_global_handles_size_;
157
+
158
+ friend class V8;
159
+ friend class Isolate;
160
+ };
161
+
162
+ class V8_EXPORT HeapSpaceStatistics {
163
+ public:
164
+ HeapSpaceStatistics();
165
+ const char* space_name() { return space_name_; }
166
+ size_t space_size() { return space_size_; }
167
+ size_t space_used_size() { return space_used_size_; }
168
+ size_t space_available_size() { return space_available_size_; }
169
+ size_t physical_space_size() { return physical_space_size_; }
170
+
171
+ private:
172
+ const char* space_name_;
173
+ size_t space_size_;
174
+ size_t space_used_size_;
175
+ size_t space_available_size_;
176
+ size_t physical_space_size_;
177
+
178
+ friend class Isolate;
179
+ };
180
+
181
+ class V8_EXPORT HeapObjectStatistics {
182
+ public:
183
+ HeapObjectStatistics();
184
+ const char* object_type() { return object_type_; }
185
+ const char* object_sub_type() { return object_sub_type_; }
186
+ size_t object_count() { return object_count_; }
187
+ size_t object_size() { return object_size_; }
188
+
189
+ private:
190
+ const char* object_type_;
191
+ const char* object_sub_type_;
192
+ size_t object_count_;
193
+ size_t object_size_;
194
+
195
+ friend class Isolate;
196
+ };
197
+
198
+ class V8_EXPORT HeapCodeStatistics {
199
+ public:
200
+ HeapCodeStatistics();
201
+ size_t code_and_metadata_size() { return code_and_metadata_size_; }
202
+ size_t bytecode_and_metadata_size() { return bytecode_and_metadata_size_; }
203
+ size_t external_script_source_size() { return external_script_source_size_; }
204
+
205
+ private:
206
+ size_t code_and_metadata_size_;
207
+ size_t bytecode_and_metadata_size_;
208
+ size_t external_script_source_size_;
209
+
210
+ friend class Isolate;
211
+ };
212
+
213
+ } // namespace v8
214
+
215
+ #endif // INCLUDE_V8_STATISTICS_H_