v8-traced-handle.h

Go to the documentation of this file.

// 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_V8_TRACED_HANDLE_H_
#define INCLUDE_V8_TRACED_HANDLE_H_
 
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
 
#include <atomic>
#include <memory>
#include <type_traits>
#include <utility>
 
#include "v8-internal.h"            // NOLINT(build/include_directory)
#include "v8-local-handle.h"        // NOLINT(build/include_directory)
#include "v8-weak-callback-info.h"  // NOLINT(build/include_directory)
#include "v8config.h"               // NOLINT(build/include_directory)
 
namespace v8 {
 
class Value;
 
namespace internal {
 
class BasicTracedReferenceExtractor;
 
enum class TracedReferenceStoreMode {
  kInitializingStore,
  kAssigningStore,
};
 
enum class TracedReferenceHandling {
  kDefault,  // See EmbedderRootsHandler::IsRoot().
  kDroppable
};
 
V8_EXPORT Address* GlobalizeTracedReference(
    Isolate* isolate, Address value, Address* slot,
    TracedReferenceStoreMode store_mode,
    TracedReferenceHandling reference_handling);
V8_EXPORT void MoveTracedReference(Address** from, Address** to);
V8_EXPORT void CopyTracedReference(const Address* const* from, Address** to);
V8_EXPORT void DisposeTracedReference(Address* global_handle);
 
}  // namespace internal
 
class TracedReferenceBase : public api_internal::IndirectHandleBase {
 public:
  static_assert(sizeof(std::atomic<internal::Address*>) ==
                sizeof(internal::Address*));
 
  V8_INLINE void Reset();
 
  V8_INLINE Local<Data> Get(Isolate* isolate) const {
    if (IsEmpty()) return Local<Data>();
    return Local<Data>::New(isolate, this->value<Data>());
  }
 
  bool IsEmptyThreadSafe() const { return GetSlotThreadSafe() == nullptr; }
 
 protected:
  V8_INLINE TracedReferenceBase() = default;
 
  void SetSlotThreadSafe(internal::Address* new_val,
                         std::memory_order order = std::memory_order_relaxed) {
    reinterpret_cast<std::atomic<internal::Address*>*>(&slot())->store(new_val,
                                                                       order);
  }
 
  const internal::Address* GetSlotThreadSafe() const {
    return reinterpret_cast<const std::atomic<internal::Address*>*>(&slot())
        ->load(std::memory_order_relaxed);
  }
 
  V8_EXPORT void CheckValue() const;
 
  friend class internal::BasicTracedReferenceExtractor;
  template <typename F>
  friend class Local;
  template <typename U>
  friend bool operator==(const TracedReferenceBase&, const Local<U>&);
  friend bool operator==(const TracedReferenceBase&,
                         const TracedReferenceBase&);
};
 
template <typename T>
class BasicTracedReference : public TracedReferenceBase {
 public:
  Local<T> Get(Isolate* isolate) const { return Local<T>::New(isolate, *this); }
 
  template <class S>
  V8_INLINE BasicTracedReference<S>& As() const {
    return reinterpret_cast<BasicTracedReference<S>&>(
        const_cast<BasicTracedReference<T>&>(*this));
  }
 
 private:
  BasicTracedReference() = default;
 
  V8_INLINE static internal::Address* NewFromNonEmptyValue(
      Isolate* isolate, T* that, internal::Address** slot,
      internal::TracedReferenceStoreMode store_mode,
      internal::TracedReferenceHandling reference_handling);
 
  template <typename F>
  friend class Local;
  friend class Object;
  template <typename F>
  friend class TracedReference;
  template <typename F>
  friend class BasicTracedReference;
  template <typename F>
  friend class ReturnValue;
};
 
template <typename T>
class TracedReference : public BasicTracedReference<T> {
 public:
  struct IsDroppable {};
 
  using BasicTracedReference<T>::Reset;
 
  V8_INLINE TracedReference() = default;
 
  template <class S>
  TracedReference(Isolate* isolate, Local<S> that) : BasicTracedReference<T>() {
    static_assert(std::is_base_of_v<T, S>, "type check");
    if (V8_UNLIKELY(that.IsEmpty())) {
      return;
    }
    this->SetSlotThreadSafe(
        this->NewFromNonEmptyValue(
            isolate, *that, &this->slot(),
            internal::TracedReferenceStoreMode::kInitializingStore,
            internal::TracedReferenceHandling::kDefault),
        std::memory_order_release);
  }
 
  template <class S>
  TracedReference(Isolate* isolate, Local<S> that, IsDroppable)
      : BasicTracedReference<T>() {
    static_assert(std::is_base_of_v<T, S>, "type check");
    if (V8_UNLIKELY(that.IsEmpty())) {
      return;
    }
    this->SetSlotThreadSafe(
        this->NewFromNonEmptyValue(
            isolate, *that, &this->slot(),
            internal::TracedReferenceStoreMode::kInitializingStore,
            internal::TracedReferenceHandling::kDroppable),
        std::memory_order_release);
  }
 
  V8_INLINE TracedReference(TracedReference&& other) noexcept {
    // Forward to operator=.
    *this = std::move(other);
  }
 
  template <typename S>
  V8_INLINE TracedReference(TracedReference<S>&& other) noexcept {
    // Forward to operator=.
    *this = std::move(other);
  }
 
  V8_INLINE TracedReference(const TracedReference& other) {
    // Forward to operator=;
    *this = other;
  }
 
  template <typename S>
  V8_INLINE TracedReference(const TracedReference<S>& other) {
    // Forward to operator=;
    *this = other;
  }
 
  V8_INLINE TracedReference& operator=(TracedReference&& rhs) noexcept;
 
  template <class S>
  V8_INLINE TracedReference& operator=(TracedReference<S>&& rhs) noexcept;
 
  V8_INLINE TracedReference& operator=(const TracedReference& rhs);
 
  template <class S>
  V8_INLINE TracedReference& operator=(const TracedReference<S>& rhs);
 
  template <class S>
  V8_INLINE void Reset(Isolate* isolate, const Local<S>& other);
 
  template <class S>
  V8_INLINE void Reset(Isolate* isolate, const Local<S>& other, IsDroppable);
 
  template <class S>
  V8_INLINE TracedReference<S>& As() const {
    return reinterpret_cast<TracedReference<S>&>(
        const_cast<TracedReference<T>&>(*this));
  }
};
 
// --- Implementation ---
template <class T>
internal::Address* BasicTracedReference<T>::NewFromNonEmptyValue(
    Isolate* isolate, T* that, internal::Address** slot,
    internal::TracedReferenceStoreMode store_mode,
    internal::TracedReferenceHandling reference_handling) {
  return internal::GlobalizeTracedReference(
      reinterpret_cast<internal::Isolate*>(isolate),
      internal::ValueHelper::ValueAsAddress(that),
      reinterpret_cast<internal::Address*>(slot), store_mode,
      reference_handling);
}
 
void TracedReferenceBase::Reset() {
  if (V8_UNLIKELY(IsEmpty())) {
    return;
  }
  internal::DisposeTracedReference(slot());
  SetSlotThreadSafe(nullptr);
}
 
V8_INLINE bool operator==(const TracedReferenceBase& lhs,
                          const TracedReferenceBase& rhs) {
  return internal::HandleHelper::EqualHandles(lhs, rhs);
}
 
template <typename U>
V8_INLINE bool operator==(const TracedReferenceBase& lhs,
                          const v8::Local<U>& rhs) {
  return internal::HandleHelper::EqualHandles(lhs, rhs);
}
 
template <typename U>
V8_INLINE bool operator==(const v8::Local<U>& lhs,
                          const TracedReferenceBase& rhs) {
  return rhs == lhs;
}
 
V8_INLINE bool operator!=(const TracedReferenceBase& lhs,
                          const TracedReferenceBase& rhs) {
  return !(lhs == rhs);
}
 
template <typename U>
V8_INLINE bool operator!=(const TracedReferenceBase& lhs,
                          const v8::Local<U>& rhs) {
  return !(lhs == rhs);
}
 
template <typename U>
V8_INLINE bool operator!=(const v8::Local<U>& lhs,
                          const TracedReferenceBase& rhs) {
  return !(rhs == lhs);
}
 
template <class T>
template <class S>
void TracedReference<T>::Reset(Isolate* isolate, const Local<S>& other) {
  static_assert(std::is_base_of_v<T, S>, "type check");
  this->Reset();
  if (V8_UNLIKELY(other.IsEmpty())) {
    return;
  }
  this->SetSlotThreadSafe(
      this->NewFromNonEmptyValue(
          isolate, *other, &this->slot(),
          internal::TracedReferenceStoreMode::kAssigningStore,
          internal::TracedReferenceHandling::kDefault),
      std::memory_order_release);
}
 
template <class T>
template <class S>
void TracedReference<T>::Reset(Isolate* isolate, const Local<S>& other,
                               IsDroppable) {
  static_assert(std::is_base_of_v<T, S>, "type check");
  this->Reset();
  if (V8_UNLIKELY(other.IsEmpty())) {
    return;
  }
  this->SetSlotThreadSafe(
      this->NewFromNonEmptyValue(
          isolate, *other, &this->slot(),
          internal::TracedReferenceStoreMode::kAssigningStore,
          internal::TracedReferenceHandling::kDroppable),
      std::memory_order_release);
}
 
template <class T>
template <class S>
TracedReference<T>& TracedReference<T>::operator=(
    TracedReference<S>&& rhs) noexcept {
  static_assert(std::is_base_of_v<T, S>, "type check");
  *this = std::move(rhs.template As<T>());
  return *this;
}
 
template <class T>
template <class S>
TracedReference<T>& TracedReference<T>::operator=(
    const TracedReference<S>& rhs) {
  static_assert(std::is_base_of_v<T, S>, "type check");
  *this = rhs.template As<T>();
  return *this;
}
 
template <class T>
TracedReference<T>& TracedReference<T>::operator=(
    TracedReference&& rhs) noexcept {
  if (this != &rhs) {
    internal::MoveTracedReference(&rhs.slot(), &this->slot());
  }
  return *this;
}
 
template <class T>
TracedReference<T>& TracedReference<T>::operator=(const TracedReference& rhs) {
  if (this != &rhs) {
    this->Reset();
    if (!rhs.IsEmpty()) {
      internal::CopyTracedReference(&rhs.slot(), &this->slot());
    }
  }
  return *this;
}
 
}  // namespace v8
 
#endif  // INCLUDE_V8_TRACED_HANDLE_H_