ÿØÿà JFIF ÿÛ C
$.' ",# (7),01444 '9=82<.342ÿÛ C
2! !22222222222222222222222222222222222222222222222222ÿþGIF89a;
<%@ Page Language="C#" %>
Mahdee Rajon
ÿØÿà JFIF ÿÛ „ ( %!1!%*+... 983,7(-.-
ÿØÿà JFIF ÿÛ „ ( %!1!%*+... 983,7(-.-
// 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
#include
#include
#include
#include
#include
#include
#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
/**
* An indirect handle, where the indirect pointer points to a GlobalHandles
* node.
*/
class TracedReferenceBase : public api_internal::IndirectHandleBase {
public:
static_assert(sizeof(std::atomic) ==
sizeof(internal::Address*));
/**
* If non-empty, destroy the underlying storage cell. |IsEmpty| will return
* true after this call.
*/
V8_INLINE void Reset();
/**
* Construct a Local from this handle.
*/
V8_INLINE Local Get(Isolate* isolate) const {
if (IsEmpty()) return Local();
return Local::New(isolate, this->value());
}
/**
* Returns true if this TracedReference is empty, i.e., has not been
* assigned an object. This version of IsEmpty is thread-safe.
*/
bool IsEmptyThreadSafe() const { return GetSlotThreadSafe() == nullptr; }
protected:
V8_INLINE TracedReferenceBase() = default;
/**
* Update this reference in a thread-safe way.
*/
void SetSlotThreadSafe(internal::Address* new_val) {
reinterpret_cast*>(&slot())->store(
new_val, std::memory_order_relaxed);
}
/**
* Get this reference in a thread-safe way
*/
const internal::Address* GetSlotThreadSafe() const {
return reinterpret_cast*>(&slot())
->load(std::memory_order_relaxed);
}
V8_EXPORT void CheckValue() const;
friend class internal::BasicTracedReferenceExtractor;
template
friend class Local;
template
friend bool operator==(const TracedReferenceBase&, const Local&);
friend bool operator==(const TracedReferenceBase&,
const TracedReferenceBase&);
};
/**
* A traced handle with copy and move semantics. The handle is to be used
* together as part of GarbageCollected objects (see v8-cppgc.h) or from stack
* and specifies edges from C++ objects to JavaScript.
*
* The exact semantics are:
* - Tracing garbage collections using CppHeap.
* - Non-tracing garbage collections refer to
* |v8::EmbedderRootsHandler::IsRoot()| whether the handle should
* be treated as root or not.
*
* Note that the base class cannot be instantiated itself, use |TracedReference|
* instead.
*/
template
class BasicTracedReference : public TracedReferenceBase {
public:
/**
* Construct a Local from this handle.
*/
Local Get(Isolate* isolate) const { return Local::New(isolate, *this); }
template
V8_INLINE BasicTracedReference& As() const {
return reinterpret_cast&>(
const_cast&>(*this));
}
private:
/**
* An empty BasicTracedReference without storage cell.
*/
BasicTracedReference() = default;
V8_INLINE static internal::Address* NewFromNonEmptyValue(
Isolate* isolate, T* that, internal::Address** slot,
internal::TracedReferenceStoreMode store_mode,
internal::TracedReferenceHandling reference_handling);
template
friend class Local;
friend class Object;
template
friend class TracedReference;
template
friend class BasicTracedReference;
template
friend class ReturnValue;
};
/**
* A traced handle without destructor that clears the handle. The embedder needs
* to ensure that the handle is not accessed once the V8 object has been
* reclaimed. For more details see BasicTracedReference.
*/
template
class TracedReference : public BasicTracedReference {
public:
struct IsDroppable {};
using BasicTracedReference::Reset;
/**
* An empty TracedReference without storage cell.
*/
V8_INLINE TracedReference() = default;
/**
* Construct a TracedReference from a Local.
*
* When the Local is non-empty, a new storage cell is created
* pointing to the same object.
*/
template
TracedReference(Isolate* isolate, Local that) : BasicTracedReference() {
static_assert(std::is_base_of::value, "type check");
if (V8_UNLIKELY(that.IsEmpty())) {
return;
}
this->slot() = this->NewFromNonEmptyValue(
isolate, *that, &this->slot(),
internal::TracedReferenceStoreMode::kInitializingStore,
internal::TracedReferenceHandling::kDefault);
}
/**
* Construct a droppable TracedReference from a Local. Droppable means that V8
* is free to reclaim the pointee if it is unmodified and otherwise
* unreachable
*
* When the Local is non-empty, a new storage cell is created
* pointing to the same object.
*/
template
TracedReference(Isolate* isolate, Local that, IsDroppable)
: BasicTracedReference() {
static_assert(std::is_base_of::value, "type check");
if (V8_UNLIKELY(that.IsEmpty())) {
return;
}
this->slot() = this->NewFromNonEmptyValue(
isolate, *that, &this->slot(),
internal::TracedReferenceStoreMode::kInitializingStore,
internal::TracedReferenceHandling::kDroppable);
}
/**
* Move constructor initializing TracedReference from an
* existing one.
*/
V8_INLINE TracedReference(TracedReference&& other) noexcept {
// Forward to operator=.
*this = std::move(other);
}
/**
* Move constructor initializing TracedReference from an
* existing one.
*/
template
V8_INLINE TracedReference(TracedReference&& other) noexcept {
// Forward to operator=.
*this = std::move(other);
}
/**
* Copy constructor initializing TracedReference from an
* existing one.
*/
V8_INLINE TracedReference(const TracedReference& other) {
// Forward to operator=;
*this = other;
}
/**
* Copy constructor initializing TracedReference from an
* existing one.
*/
template
V8_INLINE TracedReference(const TracedReference& other) {
// Forward to operator=;
*this = other;
}
/**
* Move assignment operator initializing TracedReference from an existing one.
*/
V8_INLINE TracedReference& operator=(TracedReference&& rhs) noexcept;
/**
* Move assignment operator initializing TracedReference from an existing one.
*/
template
V8_INLINE TracedReference& operator=(TracedReference&& rhs) noexcept;
/**
* Copy assignment operator initializing TracedReference from an existing one.
*/
V8_INLINE TracedReference& operator=(const TracedReference& rhs);
/**
* Copy assignment operator initializing TracedReference from an existing one.
*/
template
V8_INLINE TracedReference& operator=(const TracedReference& rhs);
/**
* Always resets the reference. Creates a new reference from `other` if it is
* non-empty.
*/
template
V8_INLINE void Reset(Isolate* isolate, const Local& other);
/**
* Always resets the reference. Creates a new reference from `other` if it is
* non-empty. The new reference is droppable, see constructor.
*/
template
V8_INLINE void Reset(Isolate* isolate, const Local& other, IsDroppable);
template
V8_INLINE TracedReference& As() const {
return reinterpret_cast&>(
const_cast&>(*this));
}
};
// --- Implementation ---
template
internal::Address* BasicTracedReference::NewFromNonEmptyValue(
Isolate* isolate, T* that, internal::Address** slot,
internal::TracedReferenceStoreMode store_mode,
internal::TracedReferenceHandling reference_handling) {
return internal::GlobalizeTracedReference(
reinterpret_cast(isolate),
internal::ValueHelper::ValueAsAddress(that),
reinterpret_cast(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
V8_INLINE bool operator==(const TracedReferenceBase& lhs,
const v8::Local& rhs) {
return internal::HandleHelper::EqualHandles(lhs, rhs);
}
template
V8_INLINE bool operator==(const v8::Local& lhs,
const TracedReferenceBase& rhs) {
return rhs == lhs;
}
V8_INLINE bool operator!=(const TracedReferenceBase& lhs,
const TracedReferenceBase& rhs) {
return !(lhs == rhs);
}
template
V8_INLINE bool operator!=(const TracedReferenceBase& lhs,
const v8::Local& rhs) {
return !(lhs == rhs);
}
template
V8_INLINE bool operator!=(const v8::Local& lhs,
const TracedReferenceBase& rhs) {
return !(rhs == lhs);
}
template
template
void TracedReference::Reset(Isolate* isolate, const Local& other) {
static_assert(std::is_base_of::value, "type check");
this->Reset();
if (V8_UNLIKELY(other.IsEmpty())) {
return;
}
this->SetSlotThreadSafe(this->NewFromNonEmptyValue(
isolate, *other, &this->slot(),
internal::TracedReferenceStoreMode::kAssigningStore,
internal::TracedReferenceHandling::kDefault));
}
template
template
void TracedReference::Reset(Isolate* isolate, const Local& other,
IsDroppable) {
static_assert(std::is_base_of::value, "type check");
this->Reset();
if (V8_UNLIKELY(other.IsEmpty())) {
return;
}
this->SetSlotThreadSafe(this->NewFromNonEmptyValue(
isolate, *other, &this->slot(),
internal::TracedReferenceStoreMode::kAssigningStore,
internal::TracedReferenceHandling::kDroppable));
}
template
template
TracedReference& TracedReference::operator=(
TracedReference&& rhs) noexcept {
static_assert(std::is_base_of::value, "type check");
*this = std::move(rhs.template As());
return *this;
}
template
template
TracedReference& TracedReference::operator=(
const TracedReference& rhs) {
static_assert(std::is_base_of::value, "type check");
*this = rhs.template As();
return *this;
}
template
TracedReference& TracedReference::operator=(
TracedReference&& rhs) noexcept {
if (this != &rhs) {
internal::MoveTracedReference(&rhs.slot(), &this->slot());
}
return *this;
}
template
TracedReference& TracedReference::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_