@babylonjs/v8-android-jit-nointl-nosnapshot 11.110.1

package/dist/include/cppgc/internal/finalizer-trait.h

@@ -0,0 +1,93 @@
+// 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_FINALIZER_TRAIT_H_
+#define INCLUDE_CPPGC_INTERNAL_FINALIZER_TRAIT_H_
+
+#include <type_traits>
+
+#include "cppgc/type-traits.h"
+
+namespace cppgc {
+namespace internal {
+
+using FinalizationCallback = void (*)(void*);
+
+template <typename T, typename = void>
+struct HasFinalizeGarbageCollectedObject : std::false_type {};
+
+template <typename T>
+struct HasFinalizeGarbageCollectedObject<
+    T,
+    std::void_t<decltype(std::declval<T>().FinalizeGarbageCollectedObject())>>
+    : std::true_type {};
+
+// The FinalizerTraitImpl specifies how to finalize objects.
+template <typename T, bool isFinalized>
+struct FinalizerTraitImpl;
+
+template <typename T>
+struct FinalizerTraitImpl<T, true> {
+ private:
+  // Dispatch to custom FinalizeGarbageCollectedObject().
+  struct Custom {
+    static void Call(void* obj) {
+      static_cast<T*>(obj)->FinalizeGarbageCollectedObject();
+    }
+  };
+
+  // Dispatch to regular destructor.
+  struct Destructor {
+    static void Call(void* obj) { static_cast<T*>(obj)->~T(); }
+  };
+
+  using FinalizeImpl =
+      std::conditional_t<HasFinalizeGarbageCollectedObject<T>::value, Custom,
+                         Destructor>;
+
+ public:
+  static void Finalize(void* obj) {
+    static_assert(sizeof(T), "T must be fully defined");
+    FinalizeImpl::Call(obj);
+  }
+};
+
+template <typename T>
+struct FinalizerTraitImpl<T, false> {
+  static void Finalize(void* obj) {
+    static_assert(sizeof(T), "T must be fully defined");
+  }
+};
+
+// The FinalizerTrait is used to determine if a type requires finalization and
+// what finalization means.
+template <typename T>
+struct FinalizerTrait {
+ private:
+  // Object has a finalizer if it has
+  // - a custom FinalizeGarbageCollectedObject method, or
+  // - a destructor.
+  static constexpr bool kNonTrivialFinalizer =
+      internal::HasFinalizeGarbageCollectedObject<T>::value ||
+      !std::is_trivially_destructible<typename std::remove_cv<T>::type>::value;
+
+  static void Finalize(void* obj) {
+    internal::FinalizerTraitImpl<T, kNonTrivialFinalizer>::Finalize(obj);
+  }
+
+ public:
+  static constexpr bool HasFinalizer() { return kNonTrivialFinalizer; }
+
+  // The callback used to finalize an object of type T.
+  static constexpr FinalizationCallback kCallback =
+      kNonTrivialFinalizer ? Finalize : nullptr;
+};
+
+template <typename T>
+constexpr FinalizationCallback FinalizerTrait<T>::kCallback;
+
+}  // namespace internal
+}  // namespace cppgc
+
+#endif  // INCLUDE_CPPGC_INTERNAL_FINALIZER_TRAIT_H_

package/dist/include/cppgc/internal/gc-info.h

@@ -0,0 +1,155 @@
+// 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/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 returns the index. In addition, also
+  // updates `registered_index` atomically.
+  template <typename T>
+  V8_INLINE static GCInfoIndex EnsureIndex(
+      std::atomic<GCInfoIndex>& registered_index) {
+    return EnsureGCInfoIndexTraitDispatch<T>{}(registered_index);
+  }
+
+ private:
+  template <typename T, bool = std::is_polymorphic<T>::value,
+            bool = FinalizerTrait<T>::HasFinalizer(),
+            bool = NameTrait<T>::HasNonHiddenName()>
+  struct EnsureGCInfoIndexTraitDispatch;
+
+  static GCInfoIndex EnsureGCInfoIndexPolymorphic(std::atomic<GCInfoIndex>&,
+                                                  TraceCallback,
+                                                  FinalizationCallback,
+                                                  NameCallback);
+  static GCInfoIndex EnsureGCInfoIndexPolymorphic(std::atomic<GCInfoIndex>&,
+                                                  TraceCallback,
+                                                  FinalizationCallback);
+  static GCInfoIndex EnsureGCInfoIndexPolymorphic(std::atomic<GCInfoIndex>&,
+                                                  TraceCallback, NameCallback);
+  static GCInfoIndex EnsureGCInfoIndexPolymorphic(std::atomic<GCInfoIndex>&,
+                                                  TraceCallback);
+  static GCInfoIndex EnsureGCInfoIndexNonPolymorphic(std::atomic<GCInfoIndex>&,
+                                                     TraceCallback,
+                                                     FinalizationCallback,
+                                                     NameCallback);
+  static GCInfoIndex EnsureGCInfoIndexNonPolymorphic(std::atomic<GCInfoIndex>&,
+                                                     TraceCallback,
+                                                     FinalizationCallback);
+  static GCInfoIndex EnsureGCInfoIndexNonPolymorphic(std::atomic<GCInfoIndex>&,
+                                                     TraceCallback,
+                                                     NameCallback);
+  static GCInfoIndex EnsureGCInfoIndexNonPolymorphic(std::atomic<GCInfoIndex>&,
+                                                     TraceCallback);
+};
+
+#define DISPATCH(is_polymorphic, has_finalizer, has_non_hidden_name, function) \
+  template <typename T>                                                        \
+  struct EnsureGCInfoIndexTrait::EnsureGCInfoIndexTraitDispatch<               \
+      T, is_polymorphic, has_finalizer, has_non_hidden_name> {                 \
+    V8_INLINE GCInfoIndex                                                      \
+    operator()(std::atomic<GCInfoIndex>& registered_index) {                   \
+      return function;                                                         \
+    }                                                                          \
+  };
+
+// --------------------------------------------------------------------- //
+// DISPATCH(is_polymorphic, has_finalizer, has_non_hidden_name, function)
+// --------------------------------------------------------------------- //
+DISPATCH(true, true, true,                                               //
+         EnsureGCInfoIndexPolymorphic(registered_index,                  //
+                                      TraceTrait<T>::Trace,              //
+                                      FinalizerTrait<T>::kCallback,      //
+                                      NameTrait<T>::GetName))            //
+DISPATCH(true, true, false,                                              //
+         EnsureGCInfoIndexPolymorphic(registered_index,                  //
+                                      TraceTrait<T>::Trace,              //
+                                      FinalizerTrait<T>::kCallback))     //
+DISPATCH(true, false, true,                                              //
+         EnsureGCInfoIndexPolymorphic(registered_index,                  //
+                                      TraceTrait<T>::Trace,              //
+                                      NameTrait<T>::GetName))            //
+DISPATCH(true, false, false,                                             //
+         EnsureGCInfoIndexPolymorphic(registered_index,                  //
+                                      TraceTrait<T>::Trace))             //
+DISPATCH(false, true, true,                                              //
+         EnsureGCInfoIndexNonPolymorphic(registered_index,               //
+                                         TraceTrait<T>::Trace,           //
+                                         FinalizerTrait<T>::kCallback,   //
+                                         NameTrait<T>::GetName))         //
+DISPATCH(false, true, false,                                             //
+         EnsureGCInfoIndexNonPolymorphic(registered_index,               //
+                                         TraceTrait<T>::Trace,           //
+                                         FinalizerTrait<T>::kCallback))  //
+DISPATCH(false, false, true,                                             //
+         EnsureGCInfoIndexNonPolymorphic(registered_index,               //
+                                         TraceTrait<T>::Trace,           //
+                                         NameTrait<T>::GetName))         //
+DISPATCH(false, false, false,                                            //
+         EnsureGCInfoIndexNonPolymorphic(registered_index,               //
+                                         TraceTrait<T>::Trace))          //
+
+#undef DISPATCH
+
+// 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 {
+  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
+
+  // Folding would regresses 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<(kHasVirtualDestructorAtBase ||
+                                         kBothTypesAreTriviallyDestructible ||
+                                         kHasCustomFinalizerDispatchAtBase) &&
+                                            !kWantsDetailedObjectNames,
+                                        ParentMostGarbageCollectedType, T>;
+};
+
+// 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.
+    const GCInfoIndex index = registered_index.load(std::memory_order_acquire);
+    return index ? index
+                 : EnsureGCInfoIndexTrait::EnsureIndex<T>(registered_index);
+  }
+};
+
+}  // namespace internal
+}  // namespace cppgc
+
+#endif  // INCLUDE_CPPGC_INTERNAL_GC_INFO_H_

package/dist/include/cppgc/internal/logging.h

@@ -0,0 +1,50 @@
+// 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_LOGGING_H_
+#define INCLUDE_CPPGC_INTERNAL_LOGGING_H_
+
+#include "cppgc/source-location.h"
+#include "v8config.h"  // NOLINT(build/include_directory)
+
+namespace cppgc {
+namespace internal {
+
+void V8_EXPORT DCheckImpl(const char*,
+                          const SourceLocation& = SourceLocation::Current());
+[[noreturn]] void V8_EXPORT
+FatalImpl(const char*, const SourceLocation& = SourceLocation::Current());
+
+// Used to ignore -Wunused-variable.
+template <typename>
+struct EatParams {};
+
+#if defined(DEBUG)
+#define CPPGC_DCHECK_MSG(condition, message)  \
+  do {                                        \
+    if (V8_UNLIKELY(!(condition))) {          \
+      ::cppgc::internal::DCheckImpl(message); \
+    }                                         \
+  } while (false)
+#else  // !defined(DEBUG)
+#define CPPGC_DCHECK_MSG(condition, message)                \
+  (static_cast<void>(::cppgc::internal::EatParams<decltype( \
+                         static_cast<void>(condition), message)>{}))
+#endif  // !defined(DEBUG)
+
+#define CPPGC_DCHECK(condition) CPPGC_DCHECK_MSG(condition, #condition)
+
+#define CPPGC_CHECK_MSG(condition, message)  \
+  do {                                       \
+    if (V8_UNLIKELY(!(condition))) {         \
+      ::cppgc::internal::FatalImpl(message); \
+    }                                        \
+  } while (false)
+
+#define CPPGC_CHECK(condition) CPPGC_CHECK_MSG(condition, #condition)
+
+}  // namespace internal
+}  // namespace cppgc
+
+#endif  // INCLUDE_CPPGC_INTERNAL_LOGGING_H_

package/dist/include/cppgc/internal/member-storage.h

@@ -0,0 +1,236 @@
+// Copyright 2022 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_MEMBER_STORAGE_H_
+#define INCLUDE_CPPGC_INTERNAL_MEMBER_STORAGE_H_
+
+#include <atomic>
+#include <cstddef>
+#include <type_traits>
+
+#include "cppgc/internal/api-constants.h"
+#include "cppgc/internal/logging.h"
+#include "cppgc/sentinel-pointer.h"
+#include "v8config.h"  // NOLINT(build/include_directory)
+
+namespace cppgc {
+namespace internal {
+
+#if defined(CPPGC_POINTER_COMPRESSION)
+
+#if defined(__clang__)
+// Attribute const allows the compiler to assume that CageBaseGlobal::g_base_
+// doesn't change (e.g. across calls) and thereby avoid redundant loads.
+#define CPPGC_CONST __attribute__((const))
+#define CPPGC_REQUIRE_CONSTANT_INIT \
+  __attribute__((require_constant_initialization))
+#else  // defined(__clang__)
+#define CPPGC_CONST
+#define CPPGC_REQUIRE_CONSTANT_INIT
+#endif  // defined(__clang__)
+
+class CageBaseGlobal final {
+ public:
+  V8_INLINE CPPGC_CONST static uintptr_t Get() {
+    CPPGC_DCHECK(IsBaseConsistent());
+    return g_base_;
+  }
+
+  V8_INLINE CPPGC_CONST static bool IsSet() {
+    CPPGC_DCHECK(IsBaseConsistent());
+    return (g_base_ & ~kLowerHalfWordMask) != 0;
+  }
+
+ private:
+  // We keep the lower halfword as ones to speed up decompression.
+  static constexpr uintptr_t kLowerHalfWordMask =
+      (api_constants::kCagedHeapReservationAlignment - 1);
+
+  static V8_EXPORT uintptr_t g_base_ CPPGC_REQUIRE_CONSTANT_INIT;
+
+  CageBaseGlobal() = delete;
+
+  V8_INLINE static bool IsBaseConsistent() {
+    return kLowerHalfWordMask == (g_base_ & kLowerHalfWordMask);
+  }
+
+  friend class CageBaseGlobalUpdater;
+};
+
+#undef CPPGC_REQUIRE_CONSTANT_INIT
+#undef CPPGC_CONST
+
+class V8_TRIVIAL_ABI CompressedPointer final {
+ public:
+  using IntegralType = uint32_t;
+
+  V8_INLINE CompressedPointer() : value_(0u) {}
+  V8_INLINE explicit CompressedPointer(const void* ptr)
+      : value_(Compress(ptr)) {}
+  V8_INLINE explicit CompressedPointer(std::nullptr_t) : value_(0u) {}
+  V8_INLINE explicit CompressedPointer(SentinelPointer)
+      : value_(kCompressedSentinel) {}
+
+  V8_INLINE const void* Load() const { return Decompress(value_); }
+  V8_INLINE const void* LoadAtomic() const {
+    return Decompress(
+        reinterpret_cast<const std::atomic<IntegralType>&>(value_).load(
+            std::memory_order_relaxed));
+  }
+
+  V8_INLINE void Store(const void* ptr) { value_ = Compress(ptr); }
+  V8_INLINE void StoreAtomic(const void* value) {
+    reinterpret_cast<std::atomic<IntegralType>&>(value_).store(
+        Compress(value), std::memory_order_relaxed);
+  }
+
+  V8_INLINE void Clear() { value_ = 0u; }
+  V8_INLINE bool IsCleared() const { return !value_; }
+
+  V8_INLINE bool IsSentinel() const { return value_ == kCompressedSentinel; }
+
+  V8_INLINE uint32_t GetAsInteger() const { return value_; }
+
+  V8_INLINE friend bool operator==(CompressedPointer a, CompressedPointer b) {
+    return a.value_ == b.value_;
+  }
+  V8_INLINE friend bool operator!=(CompressedPointer a, CompressedPointer b) {
+    return a.value_ != b.value_;
+  }
+  V8_INLINE friend bool operator<(CompressedPointer a, CompressedPointer b) {
+    return a.value_ < b.value_;
+  }
+  V8_INLINE friend bool operator<=(CompressedPointer a, CompressedPointer b) {
+    return a.value_ <= b.value_;
+  }
+  V8_INLINE friend bool operator>(CompressedPointer a, CompressedPointer b) {
+    return a.value_ > b.value_;
+  }
+  V8_INLINE friend bool operator>=(CompressedPointer a, CompressedPointer b) {
+    return a.value_ >= b.value_;
+  }
+
+  static V8_INLINE IntegralType Compress(const void* ptr) {
+    static_assert(
+        SentinelPointer::kSentinelValue == 0b10,
+        "The compression scheme relies on the sentinel encoded as 0b10");
+    static constexpr size_t kGigaCageMask =
+        ~(api_constants::kCagedHeapReservationAlignment - 1);
+
+    CPPGC_DCHECK(CageBaseGlobal::IsSet());
+    const uintptr_t base = CageBaseGlobal::Get();
+    CPPGC_DCHECK(!ptr || ptr == kSentinelPointer ||
+                 (base & kGigaCageMask) ==
+                     (reinterpret_cast<uintptr_t>(ptr) & kGigaCageMask));
+
+#if defined(CPPGC_2GB_CAGE)
+    // Truncate the pointer.
+    auto compressed =
+        static_cast<IntegralType>(reinterpret_cast<uintptr_t>(ptr));
+#else   // !defined(CPPGC_2GB_CAGE)
+    const auto uptr = reinterpret_cast<uintptr_t>(ptr);
+    // Shift the pointer by one and truncate.
+    auto compressed = static_cast<IntegralType>(uptr >> 1);
+#endif  // !defined(CPPGC_2GB_CAGE)
+    // Normal compressed pointers must have the MSB set.
+    CPPGC_DCHECK((!compressed || compressed == kCompressedSentinel) ||
+                 (compressed & (1 << 31)));
+    return compressed;
+  }
+
+  static V8_INLINE void* Decompress(IntegralType ptr) {
+    CPPGC_DCHECK(CageBaseGlobal::IsSet());
+    const uintptr_t base = CageBaseGlobal::Get();
+    // Treat compressed pointer as signed and cast it to uint64_t, which will
+    // sign-extend it.
+#if defined(CPPGC_2GB_CAGE)
+    const uint64_t mask = static_cast<uint64_t>(static_cast<int32_t>(ptr));
+#else   // !defined(CPPGC_2GB_CAGE)
+    // Then, shift the result by one. It's important to shift the unsigned
+    // value, as otherwise it would result in undefined behavior.
+    const uint64_t mask = static_cast<uint64_t>(static_cast<int32_t>(ptr)) << 1;
+#endif  // !defined(CPPGC_2GB_CAGE)
+    return reinterpret_cast<void*>(mask & base);
+  }
+
+ private:
+#if defined(CPPGC_2GB_CAGE)
+  static constexpr IntegralType kCompressedSentinel =
+      SentinelPointer::kSentinelValue;
+#else   // !defined(CPPGC_2GB_CAGE)
+  static constexpr IntegralType kCompressedSentinel =
+      SentinelPointer::kSentinelValue >> 1;
+#endif  // !defined(CPPGC_2GB_CAGE)
+  // All constructors initialize `value_`. Do not add a default value here as it
+  // results in a non-atomic write on some builds, even when the atomic version
+  // of the constructor is used.
+  IntegralType value_;
+};
+
+#endif  // defined(CPPGC_POINTER_COMPRESSION)
+
+class V8_TRIVIAL_ABI RawPointer final {
+ public:
+  using IntegralType = uintptr_t;
+
+  V8_INLINE RawPointer() : ptr_(nullptr) {}
+  V8_INLINE explicit RawPointer(const void* ptr) : ptr_(ptr) {}
+
+  V8_INLINE const void* Load() const { return ptr_; }
+  V8_INLINE const void* LoadAtomic() const {
+    return reinterpret_cast<const std::atomic<const void*>&>(ptr_).load(
+        std::memory_order_relaxed);
+  }
+
+  V8_INLINE void Store(const void* ptr) { ptr_ = ptr; }
+  V8_INLINE void StoreAtomic(const void* ptr) {
+    reinterpret_cast<std::atomic<const void*>&>(ptr_).store(
+        ptr, std::memory_order_relaxed);
+  }
+
+  V8_INLINE void Clear() { ptr_ = nullptr; }
+  V8_INLINE bool IsCleared() const { return !ptr_; }
+
+  V8_INLINE bool IsSentinel() const { return ptr_ == kSentinelPointer; }
+
+  V8_INLINE uintptr_t GetAsInteger() const {
+    return reinterpret_cast<uintptr_t>(ptr_);
+  }
+
+  V8_INLINE friend bool operator==(RawPointer a, RawPointer b) {
+    return a.ptr_ == b.ptr_;
+  }
+  V8_INLINE friend bool operator!=(RawPointer a, RawPointer b) {
+    return a.ptr_ != b.ptr_;
+  }
+  V8_INLINE friend bool operator<(RawPointer a, RawPointer b) {
+    return a.ptr_ < b.ptr_;
+  }
+  V8_INLINE friend bool operator<=(RawPointer a, RawPointer b) {
+    return a.ptr_ <= b.ptr_;
+  }
+  V8_INLINE friend bool operator>(RawPointer a, RawPointer b) {
+    return a.ptr_ > b.ptr_;
+  }
+  V8_INLINE friend bool operator>=(RawPointer a, RawPointer b) {
+    return a.ptr_ >= b.ptr_;
+  }
+
+ private:
+  // All constructors initialize `ptr_`. Do not add a default value here as it
+  // results in a non-atomic write on some builds, even when the atomic version
+  // of the constructor is used.
+  const void* ptr_;
+};
+
+#if defined(CPPGC_POINTER_COMPRESSION)
+using MemberStorage = CompressedPointer;
+#else   // !defined(CPPGC_POINTER_COMPRESSION)
+using MemberStorage = RawPointer;
+#endif  // !defined(CPPGC_POINTER_COMPRESSION)
+
+}  // namespace internal
+}  // namespace cppgc
+
+#endif  // INCLUDE_CPPGC_INTERNAL_MEMBER_STORAGE_H_

package/dist/include/cppgc/internal/name-trait.h

@@ -0,0 +1,137 @@
+// 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_NAME_TRAIT_H_
+#define INCLUDE_CPPGC_INTERNAL_NAME_TRAIT_H_
+
+#include <cstddef>
+#include <cstdint>
+#include <type_traits>
+
+#include "cppgc/name-provider.h"
+#include "v8config.h"  // NOLINT(build/include_directory)
+
+namespace cppgc {
+namespace internal {
+
+#if CPPGC_SUPPORTS_OBJECT_NAMES && defined(__clang__)
+#define CPPGC_SUPPORTS_COMPILE_TIME_TYPENAME 1
+
+// Provides constexpr c-string storage for a name of fixed |Size| characters.
+// Automatically appends terminating 0 byte.
+template <size_t Size>
+struct NameBuffer {
+  char name[Size + 1]{};
+
+  static constexpr NameBuffer FromCString(const char* str) {
+    NameBuffer result;
+    for (size_t i = 0; i < Size; ++i) result.name[i] = str[i];
+    result.name[Size] = 0;
+    return result;
+  }
+};
+
+template <typename T>
+const char* GetTypename() {
+  static constexpr char kSelfPrefix[] =
+      "const char *cppgc::internal::GetTypename() [T =";
+  static_assert(__builtin_strncmp(__PRETTY_FUNCTION__, kSelfPrefix,
+                                  sizeof(kSelfPrefix) - 1) == 0,
+                "The prefix must match");
+  static constexpr const char* kTypenameStart =
+      __PRETTY_FUNCTION__ + sizeof(kSelfPrefix);
+  static constexpr size_t kTypenameSize =
+      __builtin_strlen(__PRETTY_FUNCTION__) - sizeof(kSelfPrefix) - 1;
+  // NameBuffer is an indirection that is needed to make sure that only a
+  // substring of __PRETTY_FUNCTION__ gets materialized in the binary.
+  static constexpr auto buffer =
+      NameBuffer<kTypenameSize>::FromCString(kTypenameStart);
+  return buffer.name;
+}
+
+#else
+#define CPPGC_SUPPORTS_COMPILE_TIME_TYPENAME 0
+#endif
+
+struct HeapObjectName {
+  const char* value;
+  bool name_was_hidden;
+};
+
+enum class HeapObjectNameForUnnamedObject : uint8_t {
+  kUseClassNameIfSupported,
+  kUseHiddenName,
+};
+
+class V8_EXPORT NameTraitBase {
+ protected:
+  static HeapObjectName GetNameFromTypeSignature(const char*);
+};
+
+// Trait that specifies how the garbage collector retrieves the name for a
+// given object.
+template <typename T>
+class NameTrait final : public NameTraitBase {
+ public:
+  static constexpr bool HasNonHiddenName() {
+#if CPPGC_SUPPORTS_COMPILE_TIME_TYPENAME
+    return true;
+#elif CPPGC_SUPPORTS_OBJECT_NAMES
+    return true;
+#else   // !CPPGC_SUPPORTS_OBJECT_NAMES
+    return std::is_base_of<NameProvider, T>::value;
+#endif  // !CPPGC_SUPPORTS_OBJECT_NAMES
+  }
+
+  static HeapObjectName GetName(
+      const void* obj, HeapObjectNameForUnnamedObject name_retrieval_mode) {
+    return GetNameFor(static_cast<const T*>(obj), name_retrieval_mode);
+  }
+
+ private:
+  static HeapObjectName GetNameFor(const NameProvider* name_provider,
+                                   HeapObjectNameForUnnamedObject) {
+    // Objects inheriting from `NameProvider` are not considered unnamed as
+    // users already provided a name for them.
+    return {name_provider->GetHumanReadableName(), false};
+  }
+
+  static HeapObjectName GetNameFor(
+      const void*, HeapObjectNameForUnnamedObject name_retrieval_mode) {
+    if (name_retrieval_mode == HeapObjectNameForUnnamedObject::kUseHiddenName)
+      return {NameProvider::kHiddenName, true};
+
+#if CPPGC_SUPPORTS_COMPILE_TIME_TYPENAME
+    return {GetTypename<T>(), false};
+#elif CPPGC_SUPPORTS_OBJECT_NAMES
+
+#if defined(V8_CC_GNU)
+#define PRETTY_FUNCTION_VALUE __PRETTY_FUNCTION__
+#elif defined(V8_CC_MSVC)
+#define PRETTY_FUNCTION_VALUE __FUNCSIG__
+#else
+#define PRETTY_FUNCTION_VALUE nullptr
+#endif
+
+    static const HeapObjectName leaky_name =
+        GetNameFromTypeSignature(PRETTY_FUNCTION_VALUE);
+    return leaky_name;
+
+#undef PRETTY_FUNCTION_VALUE
+
+#else   // !CPPGC_SUPPORTS_OBJECT_NAMES
+    return {NameProvider::kHiddenName, true};
+#endif  // !CPPGC_SUPPORTS_OBJECT_NAMES
+  }
+};
+
+using NameCallback = HeapObjectName (*)(const void*,
+                                        HeapObjectNameForUnnamedObject);
+
+}  // namespace internal
+}  // namespace cppgc
+
+#undef CPPGC_SUPPORTS_COMPILE_TIME_TYPENAME
+
+#endif  // INCLUDE_CPPGC_INTERNAL_NAME_TRAIT_H_