libv8-node 15.14.0.1-aarch64-linux-musl → 18.8.0.0-aarch64-linux-musl

data/vendor/v8/include/cppgc/platform.h

@@ -5,6 +5,9 @@
 #ifndef INCLUDE_CPPGC_PLATFORM_H_
 #define INCLUDE_CPPGC_PLATFORM_H_
 
+#include <memory>
+
+#include "cppgc/source-location.h"
 #include "v8-platform.h"  // NOLINT(build/include_directory)
 #include "v8config.h"     // NOLINT(build/include_directory)
 
@@ -20,6 +23,7 @@ using PageAllocator = v8::PageAllocator;
 using Task = v8::Task;
 using TaskPriority = v8::TaskPriority;
 using TaskRunner = v8::TaskRunner;
+using TracingController = v8::TracingController;
 
 /**
  * Platform interface used by Heap. Contains allocators and executors.
@@ -51,22 +55,23 @@ class V8_EXPORT Platform {
   }
 
   /**
-   * Posts |job_task| to run in parallel. Returns a JobHandle associated with
-   * the Job, which can be joined or canceled.
+   * Posts `job_task` to run in parallel. Returns a `JobHandle` associated with
+   * the `Job`, which can be joined or canceled.
    * This avoids degenerate cases:
-   * - Calling CallOnWorkerThread() for each work item, causing significant
+   * - Calling `CallOnWorkerThread()` for each work item, causing significant
    *   overhead.
-   * - Fixed number of CallOnWorkerThread() calls that split the work and might
-   *   run for a long time. This is problematic when many components post
+   * - Fixed number of `CallOnWorkerThread()` calls that split the work and
+   *   might run for a long time. This is problematic when many components post
    *   "num cores" tasks and all expect to use all the cores. In these cases,
    *   the scheduler lacks context to be fair to multiple same-priority requests
    *   and/or ability to request lower priority work to yield when high priority
    *   work comes in.
-   * A canonical implementation of |job_task| looks like:
+   * A canonical implementation of `job_task` looks like:
+   * \code
    * class MyJobTask : public JobTask {
    *  public:
    *   MyJobTask(...) : worker_queue_(...) {}
-   *   // JobTask:
+   *   // JobTask implementation.
    *   void Run(JobDelegate* delegate) override {
    *     while (!delegate->ShouldYield()) {
    *       // Smallest unit of work.
@@ -80,51 +85,72 @@ class V8_EXPORT Platform {
    *     return worker_queue_.GetSize(); // Thread safe.
    *   }
    * };
+   *
+   * // ...
    * auto handle = PostJob(TaskPriority::kUserVisible,
    *                       std::make_unique<MyJobTask>(...));
    * handle->Join();
+   * \endcode
    *
-   * PostJob() and methods of the returned JobHandle/JobDelegate, must never be
-   * called while holding a lock that could be acquired by JobTask::Run or
-   * JobTask::GetMaxConcurrency -- that could result in a deadlock. This is
-   * because [1] JobTask::GetMaxConcurrency may be invoked while holding
-   * internal lock (A), hence JobTask::GetMaxConcurrency can only use a lock (B)
-   * if that lock is *never* held while calling back into JobHandle from any
-   * thread (A=>B/B=>A deadlock) and [2] JobTask::Run or
-   * JobTask::GetMaxConcurrency may be invoked synchronously from JobHandle
-   * (B=>JobHandle::foo=>B deadlock).
+   * `PostJob()` and methods of the returned JobHandle/JobDelegate, must never
+   * be called while holding a lock that could be acquired by `JobTask::Run()`
+   * or `JobTask::GetMaxConcurrency()` -- that could result in a deadlock. This
+   * is because (1) `JobTask::GetMaxConcurrency()` may be invoked while holding
+   * internal lock (A), hence `JobTask::GetMaxConcurrency()` can only use a lock
+   * (B) if that lock is *never* held while calling back into `JobHandle` from
+   * any thread (A=>B/B=>A deadlock) and (2) `JobTask::Run()` or
+   * `JobTask::GetMaxConcurrency()` may be invoked synchronously from
+   * `JobHandle` (B=>JobHandle::foo=>B deadlock).
    *
-   * A sufficient PostJob() implementation that uses the default Job provided in
-   * libplatform looks like:
-   *  std::unique_ptr<JobHandle> PostJob(
-   *      TaskPriority priority, std::unique_ptr<JobTask> job_task) override {
-   *    return std::make_unique<DefaultJobHandle>(
-   *        std::make_shared<DefaultJobState>(
-   *            this, std::move(job_task), kNumThreads));
+   * A sufficient `PostJob()` implementation that uses the default Job provided
+   * in libplatform looks like:
+   * \code
+   * std::unique_ptr<JobHandle> PostJob(
+   *     TaskPriority priority, std::unique_ptr<JobTask> job_task) override {
+   *   return std::make_unique<DefaultJobHandle>(
+   *       std::make_shared<DefaultJobState>(
+   *           this, std::move(job_task), kNumThreads));
    * }
+   * \endcode
    */
   virtual std::unique_ptr<JobHandle> PostJob(
       TaskPriority priority, std::unique_ptr<JobTask> job_task) {
     return nullptr;
   }
+
+  /**
+   * Returns an instance of a `TracingController`. This must be non-nullptr. The
+   * default implementation returns an empty `TracingController` that consumes
+   * trace data without effect.
+   */
+  virtual TracingController* GetTracingController();
 };
 
 /**
  * Process-global initialization of the garbage collector. Must be called before
  * creating a Heap.
+ *
+ * Can be called multiple times when paired with `ShutdownProcess()`.
+ *
+ * \param page_allocator The allocator used for maintaining meta data. Must not
+ *   change between multiple calls to InitializeProcess.
  */
-V8_EXPORT void InitializeProcess(PageAllocator*);
+V8_EXPORT void InitializeProcess(PageAllocator* page_allocator);
 
 /**
- * Must be called after destroying the last used heap.
+ * Must be called after destroying the last used heap. Some process-global
+ * metadata may not be returned and reused upon a subsequent
+ * `InitializeProcess()` call.
  */
 V8_EXPORT void ShutdownProcess();
 
 namespace internal {
 
-V8_EXPORT void Abort();
+V8_EXPORT void Fatal(const std::string& reason = std::string(),
+                     const SourceLocation& = SourceLocation::Current());
 
 }  // namespace internal
+
 }  // namespace cppgc
 
 #endif  // INCLUDE_CPPGC_PLATFORM_H_

data/vendor/v8/include/cppgc/prefinalizer.h

@@ -6,23 +6,17 @@
 #define INCLUDE_CPPGC_PREFINALIZER_H_
 
 #include "cppgc/internal/compiler-specific.h"
-#include "cppgc/internal/prefinalizer-handler.h"
 #include "cppgc/liveness-broker.h"
 
 namespace cppgc {
 
 namespace internal {
 
-template <typename T>
-class PrefinalizerRegistration final {
+class V8_EXPORT PrefinalizerRegistration final {
  public:
-  explicit PrefinalizerRegistration(T* self) {
-    static_assert(sizeof(&T::InvokePreFinalizer) > 0,
-                  "USING_PRE_FINALIZER(T) must be defined.");
+  using Callback = bool (*)(const cppgc::LivenessBroker&, void*);
 
-    cppgc::internal::PreFinalizerRegistrationDispatcher::RegisterPrefinalizer(
-        {self, T::InvokePreFinalizer});
-  }
+  PrefinalizerRegistration(void*, Callback);
 
   void* operator new(size_t, void* location) = delete;
   void* operator new(size_t) = delete;
@@ -30,21 +24,50 @@ class PrefinalizerRegistration final {
 
 }  // namespace internal
 
+/**
+ * Macro must be used in the private section of `Class` and registers a
+ * prefinalization callback `void Class::PreFinalizer()`. The callback is
+ * invoked on garbage collection after the collector has found an object to be
+ * dead.
+ *
+ * Callback properties:
+ * - The callback is invoked before a possible destructor for the corresponding
+ *   object.
+ * - The callback may access the whole object graph, irrespective of whether
+ *   objects are considered dead or alive.
+ * - The callback is invoked on the same thread as the object was created on.
+ *
+ * Example:
+ * \code
+ * class WithPrefinalizer : public GarbageCollected<WithPrefinalizer> {
+ *   CPPGC_USING_PRE_FINALIZER(WithPrefinalizer, Dispose);
+ *
+ *  public:
+ *   void Trace(Visitor*) const {}
+ *   void Dispose() { prefinalizer_called = true; }
+ *   ~WithPrefinalizer() {
+ *     // prefinalizer_called == true
+ *   }
+ *  private:
+ *   bool prefinalizer_called = false;
+ * };
+ * \endcode
+ */
 #define CPPGC_USING_PRE_FINALIZER(Class, PreFinalizer)                         \
  public:                                                                       \
   static bool InvokePreFinalizer(const cppgc::LivenessBroker& liveness_broker, \
                                  void* object) {                               \
-    static_assert(cppgc::internal::IsGarbageCollectedTypeV<Class>,             \
+    static_assert(cppgc::IsGarbageCollectedOrMixinTypeV<Class>,                \
                   "Only garbage collected objects can have prefinalizers");    \
     Class* self = static_cast<Class*>(object);                                 \
     if (liveness_broker.IsHeapObjectAlive(self)) return false;                 \
-    self->Class::PreFinalizer();                                               \
+    self->PreFinalizer();                                                      \
     return true;                                                               \
   }                                                                            \
                                                                                \
  private:                                                                      \
-  CPPGC_NO_UNIQUE_ADDRESS cppgc::internal::PrefinalizerRegistration<Class>     \
-      prefinalizer_dummy_{this};                                               \
+  CPPGC_NO_UNIQUE_ADDRESS cppgc::internal::PrefinalizerRegistration            \
+      prefinalizer_dummy_{this, Class::InvokePreFinalizer};                    \
   static_assert(true, "Force semicolon.")
 
 }  // namespace cppgc

data/vendor/v8/include/cppgc/process-heap-statistics.h

@@ -0,0 +1,36 @@
+// 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_CPPGC_PROCESS_HEAP_STATISTICS_H_
+#define INCLUDE_CPPGC_PROCESS_HEAP_STATISTICS_H_
+
+#include <atomic>
+#include <cstddef>
+
+#include "v8config.h"  // NOLINT(build/include_directory)
+
+namespace cppgc {
+namespace internal {
+class ProcessHeapStatisticsUpdater;
+}  // namespace internal
+
+class V8_EXPORT ProcessHeapStatistics final {
+ public:
+  static size_t TotalAllocatedObjectSize() {
+    return total_allocated_object_size_.load(std::memory_order_relaxed);
+  }
+  static size_t TotalAllocatedSpace() {
+    return total_allocated_space_.load(std::memory_order_relaxed);
+  }
+
+ private:
+  static std::atomic_size_t total_allocated_space_;
+  static std::atomic_size_t total_allocated_object_size_;
+
+  friend class internal::ProcessHeapStatisticsUpdater;
+};
+
+}  // namespace cppgc
+
+#endif  // INCLUDE_CPPGC_PROCESS_HEAP_STATISTICS_H_

data/vendor/v8/include/cppgc/sentinel-pointer.h

@@ -0,0 +1,32 @@
+// Copyright 2021 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_CPPGC_SENTINEL_POINTER_H_
+#define INCLUDE_CPPGC_SENTINEL_POINTER_H_
+
+#include <cstdint>
+
+namespace cppgc {
+namespace internal {
+
+// Special tag type used to denote some sentinel member. The semantics of the
+// sentinel is defined by the embedder.
+struct SentinelPointer {
+  template <typename T>
+  operator T*() const {
+    static constexpr intptr_t kSentinelValue = 1;
+    return reinterpret_cast<T*>(kSentinelValue);
+  }
+  // Hidden friends.
+  friend bool operator==(SentinelPointer, SentinelPointer) { return true; }
+  friend bool operator!=(SentinelPointer, SentinelPointer) { return false; }
+};
+
+}  // namespace internal
+
+constexpr internal::SentinelPointer kSentinelPointer;
+
+}  // namespace cppgc
+
+#endif  // INCLUDE_CPPGC_SENTINEL_POINTER_H_

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

@@ -5,6 +5,7 @@
 #ifndef INCLUDE_CPPGC_SOURCE_LOCATION_H_
 #define INCLUDE_CPPGC_SOURCE_LOCATION_H_
 
+#include <cstddef>
 #include <string>
 
 #include "v8config.h"  // NOLINT(build/include_directory)
@@ -25,7 +26,7 @@ namespace cppgc {
 
 /**
  * Encapsulates source location information. Mimics C++20's
- * std::source_location.
+ * `std::source_location`.
  */
 class V8_EXPORT SourceLocation final {
  public:

data/vendor/v8/include/cppgc/testing.h

@@ -0,0 +1,106 @@
+// Copyright 2021 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_CPPGC_TESTING_H_
+#define INCLUDE_CPPGC_TESTING_H_
+
+#include "cppgc/common.h"
+#include "cppgc/macros.h"
+#include "v8config.h"  // NOLINT(build/include_directory)
+
+namespace cppgc {
+
+class HeapHandle;
+
+/**
+ * Namespace contains testing helpers.
+ */
+namespace testing {
+
+/**
+ * Overrides the state of the stack with the provided value. Parameters passed
+ * to explicit garbage collection calls still take precedence. Must not be
+ * nested.
+ *
+ * This scope is useful to make the garbage collector consider the stack when
+ * tasks that invoke garbage collection (through the provided platform) contain
+ * interesting pointers on its stack.
+ */
+class V8_EXPORT V8_NODISCARD OverrideEmbedderStackStateScope final {
+  CPPGC_STACK_ALLOCATED();
+
+ public:
+  /**
+   * Constructs a scoped object that automatically enters and leaves the scope.
+   *
+   * \param heap_handle The corresponding heap.
+   */
+  explicit OverrideEmbedderStackStateScope(HeapHandle& heap_handle,
+                                           EmbedderStackState state);
+  ~OverrideEmbedderStackStateScope();
+
+  OverrideEmbedderStackStateScope(const OverrideEmbedderStackStateScope&) =
+      delete;
+  OverrideEmbedderStackStateScope& operator=(
+      const OverrideEmbedderStackStateScope&) = delete;
+
+ private:
+  HeapHandle& heap_handle_;
+};
+
+/**
+ * Testing interface for managed heaps that allows for controlling garbage
+ * collection timings. Embedders should use this class when testing the
+ * interaction of their code with incremental/concurrent garbage collection.
+ */
+class V8_EXPORT StandaloneTestingHeap final {
+ public:
+  explicit StandaloneTestingHeap(HeapHandle&);
+
+  /**
+   * Start an incremental garbage collection.
+   */
+  void StartGarbageCollection();
+
+  /**
+   * Perform an incremental step. This will also schedule concurrent steps if
+   * needed.
+   *
+   * \param stack_state The state of the stack during the step.
+   */
+  bool PerformMarkingStep(EmbedderStackState stack_state);
+
+  /**
+   * Finalize the current garbage collection cycle atomically.
+   * Assumes that garbage collection is in progress.
+   *
+   * \param stack_state The state of the stack for finalizing the garbage
+   * collection cycle.
+   */
+  void FinalizeGarbageCollection(EmbedderStackState stack_state);
+
+  /**
+   * Toggle main thread marking on/off. Allows to stress concurrent marking
+   * (e.g. to better detect data races).
+   *
+   * \param should_mark Denotes whether the main thread should contribute to
+   * marking. Defaults to true.
+   */
+  void ToggleMainThreadMarking(bool should_mark);
+
+  /**
+   * Force enable compaction for the next garbage collection cycle.
+   */
+  void ForceCompactionForNextGarbageCollection();
+
+ private:
+  HeapHandle& heap_handle_;
+};
+
+V8_EXPORT bool IsHeapObjectOld(void*);
+
+}  // namespace testing
+}  // namespace cppgc
+
+#endif  // INCLUDE_CPPGC_TESTING_H_

data/vendor/v8/include/cppgc/trace-trait.h

@@ -55,8 +55,6 @@ struct V8_EXPORT TraceTraitFromInnerAddressImpl {
   static TraceDescriptor GetTraceDescriptor(const void* address);
 };
 
-}  // namespace internal
-
 /**
  * Trait specifying how the garbage collector processes an object of type T.
  *
@@ -64,7 +62,7 @@ struct V8_EXPORT TraceTraitFromInnerAddressImpl {
  * type.
  */
 template <typename T>
-struct TraceTrait {
+struct TraceTraitBase {
   static_assert(internal::IsTraceableV<T>, "T must have a Trace() method");
 
   /**
@@ -89,10 +87,17 @@ struct TraceTrait {
   }
 };
 
+}  // namespace internal
+
+template <typename T>
+struct TraceTrait : public internal::TraceTraitBase<T> {};
+
 namespace internal {
 
 template <typename T>
 struct TraceTraitImpl<T, false> {
+  static_assert(IsGarbageCollectedTypeV<T>,
+                "T must be of type GarbageCollected or GarbageCollectedMixin");
   static TraceDescriptor GetTraceDescriptor(const void* self) {
     return {self, TraceTrait<T>::Trace};
   }