src/objects/trusted-pointer-inl.h

// Copyright 2025 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 V8_OBJECTS_TRUSTED_POINTER_INL_H_
#define V8_OBJECTS_TRUSTED_POINTER_INL_H_

#include "src/objects/trusted-pointer.h"
// Include the non-inl header before the rest of the headers.

#include <atomic>

#include "src/heap/heap-write-barrier-inl.h"
#include "src/objects/heap-object.h"
#include "src/objects/tagged-field-inl.h"
#include "src/objects/trusted-object.h"
#include "src/sandbox/indirect-pointer-inl.h"
#include "src/sandbox/trusted-pointer-table-inl.h"

namespace v8 {
namespace internal {

template <IndirectPointerTagRange tag_range>
Tagged<TrustedTypeFor<tag_range>> TrustedPointerField::ReadTrustedPointerField(
    Tagged<HeapObject> host, size_t offset, IsolateForSandbox isolate) {
  // Currently, trusted pointer loads always use acquire semantics as the
  // under-the-hood indirect pointer loads use acquire loads anyway.
  return ReadTrustedPointerField<tag_range>(host, offset, isolate,
                                            kAcquireLoad);
}

template <IndirectPointerTagRange tag_range>
Tagged<TrustedTypeFor<tag_range>> TrustedPointerField::ReadTrustedPointerField(
    Tagged<HeapObject> host, size_t offset, IsolateForSandbox isolate,
    AcquireLoadTag acquire_load) {
  Tagged<Object> object = ReadMaybeEmptyTrustedPointerField<tag_range>(
      host, offset, isolate, acquire_load);
  using ReturnType = TrustedTypeFor<tag_range>;
  return TrustedCast<ReturnType>(object);
}

template <IndirectPointerTagRange tag_range>
Tagged<Union<Smi, TrustedTypeFor<tag_range>>>
TrustedPointerField::ReadMaybeEmptyTrustedPointerField(
    Tagged<HeapObject> host, size_t offset, IsolateForSandbox isolate,
    AcquireLoadTag) {
#ifdef V8_ENABLE_SANDBOX
  // Reading a TrustedPointer field is just a ReadIndirectPointerField with the
  // proper tag.
  Address field_address = host->ptr() + offset - kHeapObjectTag;
  Tagged<Object> object =
      ReadIndirectPointerField<tag_range>(field_address, isolate, kAcquireLoad);
#else
  Tagged<Object> object =
      TaggedField<Object>::Acquire_Load(host, static_cast<int>(offset));
#endif
  return TrustedCast<Union<Smi, TrustedTypeFor<tag_range>>>(object);
}

template <IndirectPointerTagRange tag_range>
void TrustedPointerField::WriteTrustedPointerField(
    Tagged<HeapObject> host, size_t offset,
    Tagged<ExposedTrustedObject> value) {
#ifdef V8_ENABLE_SANDBOX
  Address field_address = host->ptr() + offset - kHeapObjectTag;
  WriteIndirectPointerField<tag_range>(field_address, value, kReleaseStore);
#else
  TaggedField<ExposedTrustedObject>::Release_Store(
      host, static_cast<int>(offset), value);
#endif
}

bool TrustedPointerField::IsTrustedPointerFieldEmpty(Tagged<HeapObject> host,
                                                     size_t offset) {
#ifdef V8_ENABLE_SANDBOX
  Address field_address = host->ptr() + offset - kHeapObjectTag;
  IndirectPointerHandle handle = base::AsAtomic32::Acquire_Load(
      reinterpret_cast<IndirectPointerHandle*>(field_address));
  return handle == kNullIndirectPointerHandle;
#else
  return IsSmi(
      TaggedField<Object>::Acquire_Load(host, static_cast<int>(offset)));
#endif
}

template <typename IsolateT>
bool TrustedPointerField::IsTrustedPointerFieldUnpublished(
    Tagged<HeapObject> host, size_t offset, IndirectPointerTagRange tag_range,
    IsolateT isolate) {
#ifdef V8_ENABLE_SANDBOX
  IndirectPointerHandle handle =
      base::AsAtomic32::Acquire_Load(reinterpret_cast<IndirectPointerHandle*>(
          host->ptr() + offset - kHeapObjectTag));
  if (handle == kNullIndirectPointerHandle) return false;
  const TrustedPointerTable& table =
      isolate.GetTrustedPointerTableFor(tag_range);
  return table.IsUnpublished(handle);
#else
  return false;
#endif
}

void TrustedPointerField::ClearTrustedPointerField(Tagged<HeapObject> host,
                                                   size_t offset) {
  ClearTrustedPointerField(host, offset, kReleaseStore);
}

void TrustedPointerField::ClearTrustedPointerField(Tagged<HeapObject> host,
                                                   size_t offset,
                                                   ReleaseStoreTag) {
#ifdef V8_ENABLE_SANDBOX
  Address field_address = host->ptr() + offset - kHeapObjectTag;
  base::AsAtomic32::Release_Store(
      reinterpret_cast<IndirectPointerHandle*>(field_address),
      kNullIndirectPointerHandle);
#else
  TaggedField<Smi>::Release_Store(host, static_cast<int>(offset), Smi::zero());
#endif
}

// Currently, trusted pointer loads/stores always use acquire/release
// semantics as the under-the-hood indirect pointer loads/stores use
// acquire/release loads/stores anyway.
template <typename T, IndirectPointerTagRange kTagRange>
Tagged<T> TrustedPointerMember<T, kTagRange>::load(
    IsolateForSandbox isolate) const {
  return Acquire_Load(isolate);
}
template <typename T, IndirectPointerTagRange kTagRange>
Tagged<Object> TrustedPointerMember<T, kTagRange>::load_maybe_empty(
    IsolateForSandbox isolate) const {
  return Acquire_Load_maybe_empty(isolate);
}
template <typename T, IndirectPointerTagRange kTagRange>
void TrustedPointerMember<T, kTagRange>::store(HeapObject* host,
                                               Tagged<T> value,
                                               WriteBarrierMode mode) {
  Release_Store(host, value, mode);
}
template <typename T, IndirectPointerTagRange kTagRange>
void TrustedPointerMember<T, kTagRange>::store_no_write_barrier(
    HeapObject* host, Tagged<T> value) {
  Release_Store_no_write_barrier(host, value);
}

template <typename T, IndirectPointerTagRange kTagRange>
Tagged<T> TrustedPointerMember<T, kTagRange>::Acquire_Load(
    IsolateForSandbox isolate) const {
#ifdef V8_ENABLE_SANDBOX
  return TrustedCast<T>(ReadIndirectPointerHandle<kTagRange>(
      handle_.load(std::memory_order::acquire), isolate));
#else
  return Base::Acquire_Load();
#endif
}

template <typename T, IndirectPointerTagRange kTagRange>
Tagged<Object> TrustedPointerMember<T, kTagRange>::Acquire_Load_maybe_empty(
    IsolateForSandbox isolate) const {
#ifdef V8_ENABLE_SANDBOX
  IndirectPointerHandle handle = handle_.load(std::memory_order::acquire);
  if (handle == kNullIndirectPointerHandle) return Smi::zero();
  return ReadIndirectPointerHandle<kTagRange>(handle, isolate);
#else
  return Base::Acquire_Load();
#endif
}

template <typename T, IndirectPointerTagRange kTagRange>
void TrustedPointerMember<T, kTagRange>::Release_Store(HeapObject* host,
                                                       Tagged<T> value,
                                                       WriteBarrierMode mode) {
#ifdef V8_ENABLE_SANDBOX
  handle_.store(
      Cast<ExposedTrustedObject>(value)->self_indirect_pointer_handle(),
      std::memory_order_release);
  WriteBarrier::ForIndirectPointer(host, this, value, mode);
#else
  Base::Release_Store(host, value, mode);
#endif
}

template <typename T, IndirectPointerTagRange kTagRange>
void TrustedPointerMember<T, kTagRange>::Release_Store_no_write_barrier(
    HeapObject* host, Tagged<T> value) {
#ifdef V8_ENABLE_SANDBOX
  store(host, value, SKIP_WRITE_BARRIER);
#else
  Base::Release_Store_no_write_barrier(value);
#endif
}

template <typename T, IndirectPointerTagRange kTagRange>
bool TrustedPointerMember<T, kTagRange>::is_empty() const {
#ifdef V8_ENABLE_SANDBOX
  return handle_.load(std::memory_order_acquire) == kNullIndirectPointerHandle;
#else
  return Base::Acquire_Load().is_null();
#endif
}

template <typename T, IndirectPointerTagRange kTagRange>
bool TrustedPointerMember<T, kTagRange>::is_unpublished(
    IsolateForSandbox isolate) const {
#ifdef V8_ENABLE_SANDBOX
  IndirectPointerHandle handle = handle_.load(std::memory_order_acquire);
  if (handle == kNullIndirectPointerHandle) return false;
  const TrustedPointerTable& table =
      isolate.GetTrustedPointerTableFor(kTagRange);
  return table.IsUnpublished(handle);
#else
  return false;
#endif
}

template <typename T, IndirectPointerTagRange kTagRange>
void TrustedPointerMember<T, kTagRange>::clear(HeapObject* host) {
#ifdef V8_ENABLE_SANDBOX
  handle_.store(kNullIndirectPointerHandle, std::memory_order_release);
#else
  Base::Release_Store_no_write_barrier(Tagged<T>());
#endif
}

#ifdef V8_ENABLE_SANDBOX
template <typename T, IndirectPointerTagRange kTagRange>
Address TrustedPointerMember<T, kTagRange>::storage_address() const {
  return reinterpret_cast<Address>(&handle_);
}
#endif

}  // namespace internal
}  // namespace v8

#endif  // V8_OBJECTS_TRUSTED_POINTER_INL_H_