File Explorer

1// Copyright 2020 the V8 project authors. All rights reserved.2// Use of this source code is governed by a BSD-style license that can be3// found in the LICENSE file.4 5#ifndef INCLUDE_CPPGC_INTERNAL_GC_INFO_H_6#define INCLUDE_CPPGC_INTERNAL_GC_INFO_H_7 8#include <atomic>9#include <cstdint>10#include <type_traits>11 12#include "cppgc/internal/finalizer-trait.h"13#include "cppgc/internal/logging.h"14#include "cppgc/internal/name-trait.h"15#include "cppgc/trace-trait.h"16#include "v8config.h"  // NOLINT(build/include_directory)17 18namespace cppgc {19namespace internal {20 21using GCInfoIndex = uint16_t;22 23struct V8_EXPORT EnsureGCInfoIndexTrait final {24  // Acquires a new GC info object and updates `registered_index` with the index25  // that identifies that new info accordingly.26  template <typename T>27  V8_INLINE static GCInfoIndex EnsureIndex(28      std::atomic<GCInfoIndex>& registered_index) {29    return EnsureGCInfoIndexTraitDispatch<T>{}(registered_index);30  }31 32 private:33  template <typename T, bool = FinalizerTrait<T>::HasFinalizer(),34            bool = NameTrait<T>::HasNonHiddenName()>35  struct EnsureGCInfoIndexTraitDispatch;36 37  static GCInfoIndex V8_PRESERVE_MOST38  EnsureGCInfoIndex(std::atomic<GCInfoIndex>&, TraceCallback,39                    FinalizationCallback, NameCallback);40  static GCInfoIndex V8_PRESERVE_MOST EnsureGCInfoIndex(41      std::atomic<GCInfoIndex>&, TraceCallback, FinalizationCallback);42  static GCInfoIndex V8_PRESERVE_MOST43  EnsureGCInfoIndex(std::atomic<GCInfoIndex>&, TraceCallback, NameCallback);44  static GCInfoIndex V8_PRESERVE_MOST45  EnsureGCInfoIndex(std::atomic<GCInfoIndex>&, TraceCallback);46};47 48#define DISPATCH(has_finalizer, has_non_hidden_name, function)   \49  template <typename T>                                          \50  struct EnsureGCInfoIndexTrait::EnsureGCInfoIndexTraitDispatch< \51      T, has_finalizer, has_non_hidden_name> {                   \52    V8_INLINE GCInfoIndex                                        \53    operator()(std::atomic<GCInfoIndex>& registered_index) {     \54      return function;                                           \55    }                                                            \56  };57 58// ------------------------------------------------------- //59// DISPATCH(has_finalizer, has_non_hidden_name, function)  //60// ------------------------------------------------------- //61DISPATCH(true, true,                                       //62         EnsureGCInfoIndex(registered_index,               //63                           TraceTrait<T>::Trace,           //64                           FinalizerTrait<T>::kCallback,   //65                           NameTrait<T>::GetName))         //66DISPATCH(true, false,                                      //67         EnsureGCInfoIndex(registered_index,               //68                           TraceTrait<T>::Trace,           //69                           FinalizerTrait<T>::kCallback))  //70DISPATCH(false, true,                                      //71         EnsureGCInfoIndex(registered_index,               //72                           TraceTrait<T>::Trace,           //73                           NameTrait<T>::GetName))         //74DISPATCH(false, false,                                     //75         EnsureGCInfoIndex(registered_index,               //76                           TraceTrait<T>::Trace))          //77 78#undef DISPATCH79 80// Trait determines how the garbage collector treats objects wrt. to traversing,81// finalization, and naming.82template <typename T>83struct GCInfoTrait final {84  V8_INLINE static GCInfoIndex Index() {85    static_assert(sizeof(T), "T must be fully defined");86    static std::atomic<GCInfoIndex>87        registered_index;  // Uses zero initialization.88    GCInfoIndex index = registered_index.load(std::memory_order_acquire);89    if (V8_UNLIKELY(!index)) {90      index = EnsureGCInfoIndexTrait::EnsureIndex<T>(registered_index);91      CPPGC_DCHECK(index != 0);92      CPPGC_DCHECK(index == registered_index.load(std::memory_order_acquire));93    }94    return index;95  }96 97  static constexpr void CheckCallbacksAreDefined() {98    // No USE() macro available.99    (void)static_cast<TraceCallback>(TraceTrait<T>::Trace);100    (void)static_cast<FinalizationCallback>(FinalizerTrait<T>::kCallback);101    (void)static_cast<NameCallback>(NameTrait<T>::GetName);102  }103};104 105// Fold types based on finalizer behavior. Note that finalizer characteristics106// align with trace behavior, i.e., destructors are virtual when trace methods107// are and vice versa.108template <typename T, typename ParentMostGarbageCollectedType>109struct GCInfoFolding final {110  static constexpr bool kHasVirtualDestructorAtBase =111      std::has_virtual_destructor<ParentMostGarbageCollectedType>::value;112  static constexpr bool kBothTypesAreTriviallyDestructible =113      std::is_trivially_destructible<ParentMostGarbageCollectedType>::value &&114      std::is_trivially_destructible<T>::value;115  static constexpr bool kHasCustomFinalizerDispatchAtBase =116      internal::HasFinalizeGarbageCollectedObject<117          ParentMostGarbageCollectedType>::value;118#ifdef CPPGC_SUPPORTS_OBJECT_NAMES119  static constexpr bool kWantsDetailedObjectNames = true;120#else   // !CPPGC_SUPPORTS_OBJECT_NAMES121  static constexpr bool kWantsDetailedObjectNames = false;122#endif  // !CPPGC_SUPPORTS_OBJECT_NAMES123 124  // Always true. Forces the compiler to resolve callbacks which ensures that125  // both modes don't break without requiring compiling a separate126  // configuration. Only a single GCInfo (for `ResultType` below) will actually127  // be instantiated but existence (and well-formedness) of all callbacks is128  // checked.129  static constexpr bool WantToFold() {130    if constexpr ((kHasVirtualDestructorAtBase ||131                   kBothTypesAreTriviallyDestructible ||132                   kHasCustomFinalizerDispatchAtBase) &&133                  !kWantsDetailedObjectNames) {134      GCInfoTrait<T>::CheckCallbacksAreDefined();135      GCInfoTrait<ParentMostGarbageCollectedType>::CheckCallbacksAreDefined();136      return true;137    }138    return false;139  }140 141  // Folding would regress name resolution when deriving names from C++142  // class names as it would just folds a name to the base class name.143  using ResultType =144      std::conditional_t<WantToFold(), ParentMostGarbageCollectedType, T>;145};146 147}  // namespace internal148}  // namespace cppgc149 150#endif  // INCLUDE_CPPGC_INTERNAL_GC_INFO_H_151