upgrade node and swig

2025-03-18 22:41:01 -05:00
parent 31cda1b61d
commit 4ef2c342b5
1411 changed files with 45964 additions and 105826 deletions
--- a/linx64/include/node/cppgc/internal/gc-info.h
+++ b/linx64/include/node/cppgc/internal/gc-info.h
@@ -0,0 +1,148 @@
+// 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_INTERNAL_GC_INFO_H_
+#define INCLUDE_CPPGC_INTERNAL_GC_INFO_H_
+
+#include <atomic>
+#include <cstdint>
+#include <type_traits>
+
+#include "cppgc/internal/finalizer-trait.h"
+#include "cppgc/internal/logging.h"
+#include "cppgc/internal/name-trait.h"
+#include "cppgc/trace-trait.h"
+#include "v8config.h"  // NOLINT(build/include_directory)
+
+namespace cppgc {
+namespace internal {
+
+using GCInfoIndex = uint16_t;
+
+struct V8_EXPORT EnsureGCInfoIndexTrait final {
+  // Acquires a new GC info object and updates `registered_index` with the index
+  // that identifies that new info accordingly.
+  template <typename T>
+  V8_INLINE static GCInfoIndex EnsureIndex(
+      std::atomic<GCInfoIndex>& registered_index) {
+    return EnsureGCInfoIndexTraitDispatch<T>{}(registered_index);
+  }
+
+ private:
+  template <typename T, bool = FinalizerTrait<T>::HasFinalizer(),
+            bool = NameTrait<T>::HasNonHiddenName()>
+  struct EnsureGCInfoIndexTraitDispatch;
+
+  static GCInfoIndex V8_PRESERVE_MOST
+  EnsureGCInfoIndex(std::atomic<GCInfoIndex>&, TraceCallback,
+                    FinalizationCallback, NameCallback);
+  static GCInfoIndex V8_PRESERVE_MOST EnsureGCInfoIndex(
+      std::atomic<GCInfoIndex>&, TraceCallback, FinalizationCallback);
+  static GCInfoIndex V8_PRESERVE_MOST
+  EnsureGCInfoIndex(std::atomic<GCInfoIndex>&, TraceCallback, NameCallback);
+  static GCInfoIndex V8_PRESERVE_MOST
+  EnsureGCInfoIndex(std::atomic<GCInfoIndex>&, TraceCallback);
+};
+
+#define DISPATCH(has_finalizer, has_non_hidden_name, function)   \
+  template <typename T>                                          \
+  struct EnsureGCInfoIndexTrait::EnsureGCInfoIndexTraitDispatch< \
+      T, has_finalizer, has_non_hidden_name> {                   \
+    V8_INLINE GCInfoIndex                                        \
+    operator()(std::atomic<GCInfoIndex>& registered_index) {     \
+      return function;                                           \
+    }                                                            \
+  };
+
+// ------------------------------------------------------- //
+// DISPATCH(has_finalizer, has_non_hidden_name, function)  //
+// ------------------------------------------------------- //
+DISPATCH(true, true,                                       //
+         EnsureGCInfoIndex(registered_index,               //
+                           TraceTrait<T>::Trace,           //
+                           FinalizerTrait<T>::kCallback,   //
+                           NameTrait<T>::GetName))         //
+DISPATCH(true, false,                                      //
+         EnsureGCInfoIndex(registered_index,               //
+                           TraceTrait<T>::Trace,           //
+                           FinalizerTrait<T>::kCallback))  //
+DISPATCH(false, true,                                      //
+         EnsureGCInfoIndex(registered_index,               //
+                           TraceTrait<T>::Trace,           //
+                           NameTrait<T>::GetName))         //
+DISPATCH(false, false,                                     //
+         EnsureGCInfoIndex(registered_index,               //
+                           TraceTrait<T>::Trace))          //
+
+#undef DISPATCH
+
+// Trait determines how the garbage collector treats objects wrt. to traversing,
+// finalization, and naming.
+template <typename T>
+struct GCInfoTrait final {
+  V8_INLINE static GCInfoIndex Index() {
+    static_assert(sizeof(T), "T must be fully defined");
+    static std::atomic<GCInfoIndex>
+        registered_index;  // Uses zero initialization.
+    GCInfoIndex index = registered_index.load(std::memory_order_acquire);
+    if (V8_UNLIKELY(!index)) {
+      index = EnsureGCInfoIndexTrait::EnsureIndex<T>(registered_index);
+      CPPGC_DCHECK(index != 0);
+      CPPGC_DCHECK(index == registered_index.load(std::memory_order_acquire));
+    }
+    return index;
+  }
+
+  static constexpr bool CheckCallbacksAreDefined() {
+    // No USE() macro available.
+    (void)static_cast<TraceCallback>(TraceTrait<T>::Trace);
+    (void)static_cast<FinalizationCallback>(FinalizerTrait<T>::kCallback);
+    (void)static_cast<NameCallback>(NameTrait<T>::GetName);
+    return true;
+  }
+};
+
+// Fold types based on finalizer behavior. Note that finalizer characteristics
+// align with trace behavior, i.e., destructors are virtual when trace methods
+// are and vice versa.
+template <typename T, typename ParentMostGarbageCollectedType>
+struct GCInfoFolding final {
+  static constexpr bool kHasVirtualDestructorAtBase =
+      std::has_virtual_destructor<ParentMostGarbageCollectedType>::value;
+  static constexpr bool kBothTypesAreTriviallyDestructible =
+      std::is_trivially_destructible<ParentMostGarbageCollectedType>::value &&
+      std::is_trivially_destructible<T>::value;
+  static constexpr bool kHasCustomFinalizerDispatchAtBase =
+      internal::HasFinalizeGarbageCollectedObject<
+          ParentMostGarbageCollectedType>::value;
+#ifdef CPPGC_SUPPORTS_OBJECT_NAMES
+  static constexpr bool kWantsDetailedObjectNames = true;
+#else   // !CPPGC_SUPPORTS_OBJECT_NAMES
+  static constexpr bool kWantsDetailedObjectNames = false;
+#endif  // !CPPGC_SUPPORTS_OBJECT_NAMES
+
+  // Always true. Forces the compiler to resolve callbacks which ensures that
+  // both modes don't break without requiring compiling a separate
+  // configuration. Only a single GCInfo (for `ResultType` below) will actually
+  // be instantiated but existence (and well-formedness) of all callbacks is
+  // checked.
+  static constexpr bool kCheckTypeGuardAlwaysTrue =
+      GCInfoTrait<T>::CheckCallbacksAreDefined() &&
+      GCInfoTrait<ParentMostGarbageCollectedType>::CheckCallbacksAreDefined();
+
+  // Folding would regress name resolution when deriving names from C++
+  // class names as it would just folds a name to the base class name.
+  using ResultType =
+      std::conditional_t<kCheckTypeGuardAlwaysTrue &&
+                             (kHasVirtualDestructorAtBase ||
+                              kBothTypesAreTriviallyDestructible ||
+                              kHasCustomFinalizerDispatchAtBase) &&
+                             !kWantsDetailedObjectNames,
+                         ParentMostGarbageCollectedType, T>;
+};
+
+}  // namespace internal
+}  // namespace cppgc
+
+#endif  // INCLUDE_CPPGC_INTERNAL_GC_INFO_H_