libv8-node 20.12.1.0-arm64-darwin → 22.5.1.0-arm64-darwin

data/vendor/v8/include/v8-snapshot.h

@@ -6,6 +6,7 @@
 #define INCLUDE_V8_SNAPSHOT_H_
 
 #include "v8-internal.h"      // NOLINT(build/include_directory)
+#include "v8-isolate.h"       // NOLINT(build/include_directory)
 #include "v8-local-handle.h"  // NOLINT(build/include_directory)
 #include "v8config.h"         // NOLINT(build/include_directory)
 
@@ -13,6 +14,10 @@ namespace v8 {
 
 class Object;
 
+namespace internal {
+class SnapshotCreatorImpl;
+}  // namespace internal
+
 class V8_EXPORT StartupData {
  public:
   /**
@@ -33,7 +38,7 @@ class V8_EXPORT StartupData {
 
 /**
  * Callback and supporting data used in SnapshotCreator to implement embedder
- * logic to serialize internal fields.
+ * logic to serialize internal fields of v8::Objects.
  * Internal fields that directly reference V8 objects are serialized without
  * calling this callback. Internal fields that contain aligned pointers are
  * serialized by this callback if it returns non-zero result. Otherwise it is
@@ -48,13 +53,24 @@ struct SerializeInternalFieldsCallback {
   CallbackFunction callback;
   void* data;
 };
-// Note that these fields are called "internal fields" in the API and called
-// "embedder fields" within V8.
-using SerializeEmbedderFieldsCallback = SerializeInternalFieldsCallback;
+
+/**
+ * Similar to SerializeInternalFieldsCallback, but works with the embedder data
+ * in a v8::Context.
+ */
+struct SerializeContextDataCallback {
+  using CallbackFunction = StartupData (*)(Local<Context> holder, int index,
+                                           void* data);
+  SerializeContextDataCallback(CallbackFunction function = nullptr,
+                               void* data_arg = nullptr)
+      : callback(function), data(data_arg) {}
+  CallbackFunction callback;
+  void* data;
+};
 
 /**
  * Callback and supporting data used to implement embedder logic to deserialize
- * internal fields.
+ * internal fields of v8::Objects.
  */
 struct DeserializeInternalFieldsCallback {
   using CallbackFunction = void (*)(Local<Object> holder, int index,
@@ -62,12 +78,24 @@ struct DeserializeInternalFieldsCallback {
   DeserializeInternalFieldsCallback(CallbackFunction function = nullptr,
                                     void* data_arg = nullptr)
       : callback(function), data(data_arg) {}
-  void (*callback)(Local<Object> holder, int index, StartupData payload,
-                   void* data);
+
+  CallbackFunction callback;
   void* data;
 };
 
-using DeserializeEmbedderFieldsCallback = DeserializeInternalFieldsCallback;
+/**
+ * Similar to DeserializeInternalFieldsCallback, but works with the embedder
+ * data in a v8::Context.
+ */
+struct DeserializeContextDataCallback {
+  using CallbackFunction = void (*)(Local<Context> holder, int index,
+                                    StartupData payload, void* data);
+  DeserializeContextDataCallback(CallbackFunction function = nullptr,
+                                 void* data_arg = nullptr)
+      : callback(function), data(data_arg) {}
+  CallbackFunction callback;
+  void* data;
+};
 
 /**
  * Helper class to create a snapshot data blob.
@@ -88,10 +116,14 @@ class V8_EXPORT SnapshotCreator {
    * \param existing_blob existing snapshot from which to create this one.
    * \param external_references a null-terminated array of external references
    *        that must be equivalent to CreateParams::external_references.
+   * \param owns_isolate whether this SnapshotCreator should call
+   *        v8::Isolate::Dispose() during its destructor.
    */
-  SnapshotCreator(Isolate* isolate,
-                  const intptr_t* external_references = nullptr,
-                  const StartupData* existing_blob = nullptr);
+  V8_DEPRECATE_SOON("Use the version that passes CreateParams instead.")
+  explicit SnapshotCreator(Isolate* isolate,
+                           const intptr_t* external_references = nullptr,
+                           const StartupData* existing_blob = nullptr,
+                           bool owns_isolate = true);
 
   /**
    * Create and enter an isolate, and set it up for serialization.
@@ -101,8 +133,35 @@ class V8_EXPORT SnapshotCreator {
    * \param external_references a null-terminated array of external references
    *        that must be equivalent to CreateParams::external_references.
    */
-  SnapshotCreator(const intptr_t* external_references = nullptr,
-                  const StartupData* existing_blob = nullptr);
+  V8_DEPRECATE_SOON("Use the version that passes CreateParams instead.")
+  explicit SnapshotCreator(const intptr_t* external_references = nullptr,
+                           const StartupData* existing_blob = nullptr);
+
+  /**
+   * Creates an Isolate for serialization and enters it. The creator fully owns
+   * the Isolate and will invoke `v8::Isolate::Dispose()` during destruction.
+   *
+   * \param params The parameters to initialize the Isolate for. Details:
+   *               - `params.external_references` are expected to be a
+   *                 null-terminated array of external references.
+   *               - `params.existing_blob` is an optional snapshot blob from
+   *                 which can be used to initialize the new blob.
+   */
+  explicit SnapshotCreator(const v8::Isolate::CreateParams& params);
+
+  /**
+   * Initializes an Isolate for serialization and enters it. The creator does
+   * not own the Isolate but merely initialize it properly.
+   *
+   * \param isolate The isolate that was allocated by `Isolate::Allocate()~.
+   * \param params The parameters to initialize the Isolate for. Details:
+   *               - `params.external_references` are expected to be a
+   *                 null-terminated array of external references.
+   *               - `params.existing_blob` is an optional snapshot blob from
+   *                 which can be used to initialize the new blob.
+   */
+  SnapshotCreator(v8::Isolate* isolate,
+                  const v8::Isolate::CreateParams& params);
 
   /**
    * Destroy the snapshot creator, and exit and dispose of the Isolate
@@ -120,23 +179,37 @@ class V8_EXPORT SnapshotCreator {
    * The snapshot will not contain the global proxy, and we expect one or a
    * global object template to create one, to be provided upon deserialization.
    *
-   * \param callback optional callback to serialize internal fields.
+   * \param internal_fields_serializer An optional callback used to serialize
+   * internal pointer fields set by
+   * v8::Object::SetAlignedPointerInInternalField().
+   *
+   * \param context_data_serializer An optional callback used to serialize
+   * context embedder data set by
+   * v8::Context::SetAlignedPointerInEmbedderData().
+   *
    */
-  void SetDefaultContext(Local<Context> context,
-                         SerializeInternalFieldsCallback callback =
-                             SerializeInternalFieldsCallback());
+  void SetDefaultContext(
+      Local<Context> context,
+      SerializeInternalFieldsCallback internal_fields_serializer =
+          SerializeInternalFieldsCallback(),
+      SerializeContextDataCallback context_data_serializer =
+          SerializeContextDataCallback());
 
   /**
    * Add additional context to be included in the snapshot blob.
    * The snapshot will include the global proxy.
    *
-   * \param callback optional callback to serialize internal fields.
+   * \param internal_fields_serializer Similar to internal_fields_serializer
+   * in SetDefaultContext() but only applies to the context being added.
    *
-   * \returns the index of the context in the snapshot blob.
+   * \param context_data_serializer Similar to context_data_serializer
+   * in SetDefaultContext() but only applies to the context being added.
    */
   size_t AddContext(Local<Context> context,
-                    SerializeInternalFieldsCallback callback =
-                        SerializeInternalFieldsCallback());
+                    SerializeInternalFieldsCallback internal_fields_serializer =
+                        SerializeInternalFieldsCallback(),
+                    SerializeContextDataCallback context_data_serializer =
+                        SerializeContextDataCallback());
 
   /**
    * Attach arbitrary V8::Data to the context snapshot, which can be retrieved
@@ -174,7 +247,8 @@ class V8_EXPORT SnapshotCreator {
   size_t AddData(Local<Context> context, internal::Address object);
   size_t AddData(internal::Address object);
 
-  void* data_;
+  internal::SnapshotCreatorImpl* impl_;
+  friend class internal::SnapshotCreatorImpl;
 };
 
 template <class T>

data/vendor/v8/include/v8-source-location.h

@@ -0,0 +1,92 @@
+// Copyright 2020 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef INCLUDE_SOURCE_LOCATION_H_
+#define INCLUDE_SOURCE_LOCATION_H_
+
+#include <cstddef>
+#include <string>
+
+#include "v8config.h"  // NOLINT(build/include_directory)
+
+#if defined(__has_builtin)
+#define V8_SUPPORTS_SOURCE_LOCATION                                      \
+  (__has_builtin(__builtin_FUNCTION) && __has_builtin(__builtin_FILE) && \
+   __has_builtin(__builtin_LINE))  // NOLINT
+#elif defined(V8_CC_GNU) && __GNUC__ >= 7
+#define V8_SUPPORTS_SOURCE_LOCATION 1
+#elif defined(V8_CC_INTEL) && __ICC >= 1800
+#define V8_SUPPORTS_SOURCE_LOCATION 1
+#else
+#define V8_SUPPORTS_SOURCE_LOCATION 0
+#endif
+
+namespace v8 {
+
+/**
+ * Encapsulates source location information. Mimics C++20's
+ * `std::source_location`.
+ */
+class V8_EXPORT SourceLocation final {
+ public:
+  /**
+   * Construct source location information corresponding to the location of the
+   * call site.
+   */
+#if V8_SUPPORTS_SOURCE_LOCATION
+  static constexpr SourceLocation Current(
+      const char* function = __builtin_FUNCTION(),
+      const char* file = __builtin_FILE(), size_t line = __builtin_LINE()) {
+    return SourceLocation(function, file, line);
+  }
+#else
+  static constexpr SourceLocation Current() { return SourceLocation(); }
+#endif  // V8_SUPPORTS_SOURCE_LOCATION
+
+  /**
+   * Constructs unspecified source location information.
+   */
+  constexpr SourceLocation() = default;
+
+  /**
+   * Returns the name of the function associated with the position represented
+   * by this object, if any.
+   *
+   * \returns the function name as cstring.
+   */
+  constexpr const char* Function() const { return function_; }
+
+  /**
+   * Returns the name of the current source file represented by this object.
+   *
+   * \returns the file name as cstring.
+   */
+  constexpr const char* FileName() const { return file_; }
+
+  /**
+   * Returns the line number represented by this object.
+   *
+   * \returns the line number.
+   */
+  constexpr size_t Line() const { return line_; }
+
+  /**
+   * Returns a human-readable string representing this object.
+   *
+   * \returns a human-readable string representing source location information.
+   */
+  std::string ToString() const;
+
+ private:
+  constexpr SourceLocation(const char* function, const char* file, size_t line)
+      : function_(function), file_(file), line_(line) {}
+
+  const char* function_ = nullptr;
+  const char* file_ = nullptr;
+  size_t line_ = 0u;
+};
+
+}  // namespace v8
+
+#endif  // INCLUDE_SOURCE_LOCATION_H_

data/vendor/v8/include/v8-statistics.h

@@ -13,6 +13,7 @@
 #include <vector>
 
 #include "v8-local-handle.h"  // NOLINT(build/include_directory)
+#include "v8-memory-span.h"   // NOLINT(build/include_directory)
 #include "v8-promise.h"       // NOLINT(build/include_directory)
 #include "v8config.h"         // NOLINT(build/include_directory)
 
@@ -46,6 +47,10 @@ enum class MeasureMemoryExecution { kDefault, kEager, kLazy };
  *
  * It specifies the contexts that need to be measured and gets called when
  * the measurement is completed to report the results.
+ *
+ * Both MeasurementComplete() callbacks will be invoked on completion.
+ * Each implementation of this class should hence implement only one of them,
+ * and leave the other empty.
  */
 class V8_EXPORT MeasureMemoryDelegate {
  public:
@@ -56,20 +61,36 @@ class V8_EXPORT MeasureMemoryDelegate {
    */
   virtual bool ShouldMeasure(Local<Context> context) = 0;
 
+  /** Holds the result of a memory measurement request. */
+  struct Result {
+    /**
+     * Two spans of equal length: the first includes each context for which
+     * ShouldMeasure returned true and that was not garbage collected while
+     * the memory measurement was in progress; the second includes the size
+     * of the respective context.
+     */
+    const MemorySpan<const Local<Context>>& contexts;
+    const MemorySpan<const size_t>& sizes_in_bytes;
+
+    /**
+     * Total size of objects that were not attributed to any context (i.e. are
+     * likely shared objects).
+     */
+    size_t unattributed_size_in_bytes;
+
+    /** Total size of generated code for Wasm (shared across contexts). */
+    size_t wasm_code_size_in_bytes;
+
+    /** Total size of Wasm metadata (except code; shared across contexts). */
+    size_t wasm_metadata_size_in_bytes;
+  };
+
   /**
    * This function is called when memory measurement finishes.
    *
-   * \param context_sizes_in_bytes a vector of (context, size) pairs that
-   *   includes each context for which ShouldMeasure returned true and that
-   *   was not garbage collected while the memory measurement was in progress.
-   *
-   * \param unattributed_size_in_bytes total size of objects that were not
-   *   attributed to any context (i.e. are likely shared objects).
+   * \param result the result of the measurement.
    */
-  virtual void MeasurementComplete(
-      const std::vector<std::pair<Local<Context>, size_t>>&
-          context_sizes_in_bytes,
-      size_t unattributed_size_in_bytes) = 0;
+  virtual void MeasurementComplete(Result result) {}
 
   /**
    * Returns a default delegate that resolves the given promise when