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_PERSISTENT_H_6#define INCLUDE_CPPGC_PERSISTENT_H_7 8#include <type_traits>9 10#include "cppgc/internal/persistent-node.h"11#include "cppgc/internal/pointer-policies.h"12#include "cppgc/sentinel-pointer.h"13#include "cppgc/source-location.h"14#include "cppgc/type-traits.h"15#include "cppgc/visitor.h"16#include "v8config.h"  // NOLINT(build/include_directory)17 18namespace cppgc {19namespace internal {20 21// PersistentBase always refers to the object as const object and defers to22// BasicPersistent on casting to the right type as needed.23class PersistentBase {24 protected:25  PersistentBase() = default;26  explicit PersistentBase(const void* raw) : raw_(raw) {}27 28  const void* GetValue() const { return raw_; }29  void SetValue(const void* value) { raw_ = value; }30 31  PersistentNode* GetNode() const { return node_; }32  void SetNode(PersistentNode* node) { node_ = node; }33 34  // Performs a shallow clear which assumes that internal persistent nodes are35  // destroyed elsewhere.36  void ClearFromGC() const {37    raw_ = nullptr;38    node_ = nullptr;39  }40 41 protected:42  mutable const void* raw_ = nullptr;43  mutable PersistentNode* node_ = nullptr;44 45  friend class PersistentRegionBase;46};47 48// The basic class from which all Persistent classes are generated.49template <typename T, typename WeaknessPolicy, typename LocationPolicy,50          typename CheckingPolicy>51class BasicPersistent final : public PersistentBase,52                              public LocationPolicy,53                              private WeaknessPolicy,54                              private CheckingPolicy {55 public:56  using typename WeaknessPolicy::IsStrongPersistent;57  using PointeeType = T;58 59  // Null-state/sentinel constructors.60  BasicPersistent(  // NOLINT61      const SourceLocation& loc = SourceLocation::Current())62      : LocationPolicy(loc) {}63 64  BasicPersistent(std::nullptr_t,  // NOLINT65                  const SourceLocation& loc = SourceLocation::Current())66      : LocationPolicy(loc) {}67 68  BasicPersistent(  // NOLINT69      SentinelPointer s, const SourceLocation& loc = SourceLocation::Current())70      : PersistentBase(s), LocationPolicy(loc) {}71 72  // Raw value constructors.73  BasicPersistent(T* raw,  // NOLINT74                  const SourceLocation& loc = SourceLocation::Current())75      : PersistentBase(raw), LocationPolicy(loc) {76    if (!IsValid()) return;77    SetNode(WeaknessPolicy::GetPersistentRegion(GetValue())78                .AllocateNode(this, &TraceAsRoot));79    this->CheckPointer(Get());80  }81 82  BasicPersistent(T& raw,  // NOLINT83                  const SourceLocation& loc = SourceLocation::Current())84      : BasicPersistent(&raw, loc) {}85 86  // Copy ctor.87  BasicPersistent(const BasicPersistent& other,88                  const SourceLocation& loc = SourceLocation::Current())89      : BasicPersistent(other.Get(), loc) {}90 91  // Heterogeneous ctor.92  template <typename U, typename OtherWeaknessPolicy,93            typename OtherLocationPolicy, typename OtherCheckingPolicy,94            typename = std::enable_if_t<std::is_base_of<T, U>::value>>95  // NOLINTNEXTLINE96  BasicPersistent(97      const BasicPersistent<U, OtherWeaknessPolicy, OtherLocationPolicy,98                            OtherCheckingPolicy>& other,99      const SourceLocation& loc = SourceLocation::Current())100      : BasicPersistent(other.Get(), loc) {}101 102  // Move ctor. The heterogeneous move ctor is not supported since e.g.103  // persistent can't reuse persistent node from weak persistent.104  BasicPersistent(105      BasicPersistent&& other,106      const SourceLocation& loc = SourceLocation::Current()) noexcept107      : PersistentBase(std::move(other)), LocationPolicy(std::move(other)) {108    if (!IsValid()) return;109    GetNode()->UpdateOwner(this);110    other.SetValue(nullptr);111    other.SetNode(nullptr);112    this->CheckPointer(Get());113  }114 115  // Constructor from member.116  template <typename U, typename MemberBarrierPolicy,117            typename MemberWeaknessTag, typename MemberCheckingPolicy,118            typename MemberStorageType,119            typename = std::enable_if_t<std::is_base_of<T, U>::value>>120  // NOLINTNEXTLINE121  BasicPersistent(const internal::BasicMember<122                      U, MemberBarrierPolicy, MemberWeaknessTag,123                      MemberCheckingPolicy, MemberStorageType>& member,124                  const SourceLocation& loc = SourceLocation::Current())125      : BasicPersistent(member.Get(), loc) {}126 127  ~BasicPersistent() { Clear(); }128 129  // Copy assignment.130  BasicPersistent& operator=(const BasicPersistent& other) {131    return operator=(other.Get());132  }133 134  template <typename U, typename OtherWeaknessPolicy,135            typename OtherLocationPolicy, typename OtherCheckingPolicy,136            typename = std::enable_if_t<std::is_base_of<T, U>::value>>137  BasicPersistent& operator=(138      const BasicPersistent<U, OtherWeaknessPolicy, OtherLocationPolicy,139                            OtherCheckingPolicy>& other) {140    return operator=(other.Get());141  }142 143  // Move assignment.144  BasicPersistent& operator=(BasicPersistent&& other) noexcept {145    if (this == &other) return *this;146    Clear();147    PersistentBase::operator=(std::move(other));148    LocationPolicy::operator=(std::move(other));149    if (!IsValid()) return *this;150    GetNode()->UpdateOwner(this);151    other.SetValue(nullptr);152    other.SetNode(nullptr);153    this->CheckPointer(Get());154    return *this;155  }156 157  // Assignment from member.158  template <typename U, typename MemberBarrierPolicy,159            typename MemberWeaknessTag, typename MemberCheckingPolicy,160            typename MemberStorageType,161            typename = std::enable_if_t<std::is_base_of<T, U>::value>>162  BasicPersistent& operator=(163      const internal::BasicMember<U, MemberBarrierPolicy, MemberWeaknessTag,164                                  MemberCheckingPolicy, MemberStorageType>&165          member) {166    return operator=(member.Get());167  }168 169  BasicPersistent& operator=(T* other) {170    Assign(other);171    return *this;172  }173 174  BasicPersistent& operator=(std::nullptr_t) {175    Clear();176    return *this;177  }178 179  BasicPersistent& operator=(SentinelPointer s) {180    Assign(s);181    return *this;182  }183 184  explicit operator bool() const { return Get(); }185  // Historically we allow implicit conversions to T*.186  // NOLINTNEXTLINE187  operator T*() const { return Get(); }188  T* operator->() const { return Get(); }189  T& operator*() const { return *Get(); }190 191  // CFI cast exemption to allow passing SentinelPointer through T* and support192  // heterogeneous assignments between different Member and Persistent handles193  // based on their actual types.194  V8_CLANG_NO_SANITIZE("cfi-unrelated-cast") T* Get() const {195    // The const_cast below removes the constness from PersistentBase storage.196    // The following static_cast re-adds any constness if specified through the197    // user-visible template parameter T.198    return static_cast<T*>(const_cast<void*>(GetValue()));199  }200 201  void Clear() {202    // Simplified version of `Assign()` to allow calling without a complete type203    // `T`.204    if (IsValid()) {205      WeaknessPolicy::GetPersistentRegion(GetValue()).FreeNode(GetNode());206      SetNode(nullptr);207    }208    SetValue(nullptr);209  }210 211  T* Release() {212    T* result = Get();213    Clear();214    return result;215  }216 217  template <typename U, typename OtherWeaknessPolicy = WeaknessPolicy,218            typename OtherLocationPolicy = LocationPolicy,219            typename OtherCheckingPolicy = CheckingPolicy>220  BasicPersistent<U, OtherWeaknessPolicy, OtherLocationPolicy,221                  OtherCheckingPolicy>222  To() const {223    return BasicPersistent<U, OtherWeaknessPolicy, OtherLocationPolicy,224                           OtherCheckingPolicy>(static_cast<U*>(Get()));225  }226 227 private:228  static void TraceAsRoot(RootVisitor& root_visitor, const void* ptr) {229    root_visitor.Trace(*static_cast<const BasicPersistent*>(ptr));230  }231 232  bool IsValid() const {233    // Ideally, handling kSentinelPointer would be done by the embedder. On the234    // other hand, having Persistent aware of it is beneficial since no node235    // gets wasted.236    return GetValue() != nullptr && GetValue() != kSentinelPointer;237  }238 239  void Assign(T* ptr) {240    if (IsValid()) {241      if (ptr && ptr != kSentinelPointer) {242        // Simply assign the pointer reusing the existing node.243        SetValue(ptr);244        this->CheckPointer(ptr);245        return;246      }247      WeaknessPolicy::GetPersistentRegion(GetValue()).FreeNode(GetNode());248      SetNode(nullptr);249    }250    SetValue(ptr);251    if (!IsValid()) return;252    SetNode(WeaknessPolicy::GetPersistentRegion(GetValue())253                .AllocateNode(this, &TraceAsRoot));254    this->CheckPointer(Get());255  }256 257  void ClearFromGC() const {258    if (IsValid()) {259      WeaknessPolicy::GetPersistentRegion(GetValue()).FreeNode(GetNode());260      PersistentBase::ClearFromGC();261    }262  }263 264  // Set Get() for details.265  V8_CLANG_NO_SANITIZE("cfi-unrelated-cast")266  T* GetFromGC() const {267    return static_cast<T*>(const_cast<void*>(GetValue()));268  }269 270  friend class internal::RootVisitor;271};272 273template <typename T1, typename WeaknessPolicy1, typename LocationPolicy1,274          typename CheckingPolicy1, typename T2, typename WeaknessPolicy2,275          typename LocationPolicy2, typename CheckingPolicy2>276bool operator==(const BasicPersistent<T1, WeaknessPolicy1, LocationPolicy1,277                                      CheckingPolicy1>& p1,278                const BasicPersistent<T2, WeaknessPolicy2, LocationPolicy2,279                                      CheckingPolicy2>& p2) {280  return p1.Get() == p2.Get();281}282 283template <typename T1, typename WeaknessPolicy1, typename LocationPolicy1,284          typename CheckingPolicy1, typename T2, typename WeaknessPolicy2,285          typename LocationPolicy2, typename CheckingPolicy2>286bool operator!=(const BasicPersistent<T1, WeaknessPolicy1, LocationPolicy1,287                                      CheckingPolicy1>& p1,288                const BasicPersistent<T2, WeaknessPolicy2, LocationPolicy2,289                                      CheckingPolicy2>& p2) {290  return !(p1 == p2);291}292 293template <typename T1, typename PersistentWeaknessPolicy,294          typename PersistentLocationPolicy, typename PersistentCheckingPolicy,295          typename T2, typename MemberWriteBarrierPolicy,296          typename MemberWeaknessTag, typename MemberCheckingPolicy,297          typename MemberStorageType>298bool operator==(299    const BasicPersistent<T1, PersistentWeaknessPolicy,300                          PersistentLocationPolicy, PersistentCheckingPolicy>&301        p,302    const BasicMember<T2, MemberWeaknessTag, MemberWriteBarrierPolicy,303                      MemberCheckingPolicy, MemberStorageType>& m) {304  return p.Get() == m.Get();305}306 307template <typename T1, typename PersistentWeaknessPolicy,308          typename PersistentLocationPolicy, typename PersistentCheckingPolicy,309          typename T2, typename MemberWriteBarrierPolicy,310          typename MemberWeaknessTag, typename MemberCheckingPolicy,311          typename MemberStorageType>312bool operator!=(313    const BasicPersistent<T1, PersistentWeaknessPolicy,314                          PersistentLocationPolicy, PersistentCheckingPolicy>&315        p,316    const BasicMember<T2, MemberWeaknessTag, MemberWriteBarrierPolicy,317                      MemberCheckingPolicy, MemberStorageType>& m) {318  return !(p == m);319}320 321template <typename T1, typename MemberWriteBarrierPolicy,322          typename MemberWeaknessTag, typename MemberCheckingPolicy,323          typename MemberStorageType, typename T2,324          typename PersistentWeaknessPolicy, typename PersistentLocationPolicy,325          typename PersistentCheckingPolicy>326bool operator==(327    const BasicMember<T2, MemberWeaknessTag, MemberWriteBarrierPolicy,328                      MemberCheckingPolicy, MemberStorageType>& m,329    const BasicPersistent<T1, PersistentWeaknessPolicy,330                          PersistentLocationPolicy, PersistentCheckingPolicy>&331        p) {332  return m.Get() == p.Get();333}334 335template <typename T1, typename MemberWriteBarrierPolicy,336          typename MemberWeaknessTag, typename MemberCheckingPolicy,337          typename MemberStorageType, typename T2,338          typename PersistentWeaknessPolicy, typename PersistentLocationPolicy,339          typename PersistentCheckingPolicy>340bool operator!=(341    const BasicMember<T2, MemberWeaknessTag, MemberWriteBarrierPolicy,342                      MemberCheckingPolicy, MemberStorageType>& m,343    const BasicPersistent<T1, PersistentWeaknessPolicy,344                          PersistentLocationPolicy, PersistentCheckingPolicy>&345        p) {346  return !(m == p);347}348 349template <typename T, typename LocationPolicy, typename CheckingPolicy>350struct IsWeak<BasicPersistent<T, internal::WeakPersistentPolicy, LocationPolicy,351                              CheckingPolicy>> : std::true_type {};352}  // namespace internal353 354/**355 * Persistent is a way to create a strong pointer from an off-heap object to356 * another on-heap object. As long as the Persistent handle is alive the GC will357 * keep the object pointed to alive. The Persistent handle is always a GC root358 * from the point of view of the GC. Persistent must be constructed and359 * destructed in the same thread.360 */361template <typename T>362using Persistent =363    internal::BasicPersistent<T, internal::StrongPersistentPolicy>;364 365/**366 * WeakPersistent is a way to create a weak pointer from an off-heap object to367 * an on-heap object. The pointer is automatically cleared when the pointee gets368 * collected. WeakPersistent must be constructed and destructed in the same369 * thread.370 */371template <typename T>372using WeakPersistent =373    internal::BasicPersistent<T, internal::WeakPersistentPolicy>;374 375}  // namespace cppgc376 377#endif  // INCLUDE_CPPGC_PERSISTENT_H_378