chromium/v8/src/objects/compressed-slots-inl.h

// Copyright 2019 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_COMPRESSED_SLOTS_INL_H_
#define V8_OBJECTS_COMPRESSED_SLOTS_INL_H_

#ifdef V8_COMPRESS_POINTERS

#include "src/common/ptr-compr-inl.h"
#include "src/objects/casting.h"
#include "src/objects/compressed-slots.h"
#include "src/objects/maybe-object-inl.h"

namespace v8::internal {

//
// CompressedObjectSlot implementation.
//

CompressedObjectSlot::CompressedObjectSlot(Tagged<Object>* object)
    : … { … }

bool CompressedObjectSlot::contains_map_value(Address raw_value) const { … }

bool CompressedObjectSlot::Relaxed_ContainsMapValue(Address raw_value) const { … }

Tagged<Object> CompressedObjectSlot::operator*() const { … }

Tagged<Object> CompressedObjectSlot::load() const { … }

Tagged<Object> CompressedObjectSlot::load(PtrComprCageBase cage_base) const { … }

void CompressedObjectSlot::store(Tagged<Object> value) const { … }

void CompressedObjectSlot::store_map(Tagged<Map> map) const { … }

Tagged<Map> CompressedObjectSlot::load_map() const { … }

Tagged<Object> CompressedObjectSlot::Acquire_Load() const { … }

Tagged<Object> CompressedObjectSlot::Relaxed_Load() const { … }

Tagged<Object> CompressedObjectSlot::Relaxed_Load(
    PtrComprCageBase cage_base) const { … }

Tagged_t CompressedObjectSlot::Relaxed_Load_Raw() const { … }

// static
Tagged<Object> CompressedObjectSlot::RawToTagged(PtrComprCageBase cage_base,
                                                 Tagged_t raw) { … }

void CompressedObjectSlot::Relaxed_Store(Tagged<Object> value) const { … }

void CompressedObjectSlot::Release_Store(Tagged<Object> value) const { … }

Tagged<Object> CompressedObjectSlot::Release_CompareAndSwap(
    Tagged<Object> old, Tagged<Object> target) const { … }

//
// CompressedMaybeObjectSlot implementation.
//

Tagged<MaybeObject> CompressedMaybeObjectSlot::operator*() const { … }

Tagged<MaybeObject> CompressedMaybeObjectSlot::load(
    PtrComprCageBase cage_base) const { … }

void CompressedMaybeObjectSlot::store(Tagged<MaybeObject> value) const { … }

Tagged<MaybeObject> CompressedMaybeObjectSlot::Relaxed_Load() const { … }

Tagged<MaybeObject> CompressedMaybeObjectSlot::Relaxed_Load(
    PtrComprCageBase cage_base) const { … }

Tagged_t CompressedMaybeObjectSlot::Relaxed_Load_Raw() const { … }

// static
Tagged<Object> CompressedMaybeObjectSlot::RawToTagged(
    PtrComprCageBase cage_base, Tagged_t raw) { … }

void CompressedMaybeObjectSlot::Relaxed_Store(Tagged<MaybeObject> value) const { … }

void CompressedMaybeObjectSlot::Release_CompareAndSwap(
    Tagged<MaybeObject> old, Tagged<MaybeObject> target) const { … }

//
// CompressedHeapObjectSlot implementation.
//

Tagged<HeapObjectReference> CompressedHeapObjectSlot::operator*() const { … }

Tagged<HeapObjectReference> CompressedHeapObjectSlot::load(
    PtrComprCageBase cage_base) const { … }

void CompressedHeapObjectSlot::store(Tagged<HeapObjectReference> value) const { … }

Tagged<HeapObject> CompressedHeapObjectSlot::ToHeapObject() const { … }

void CompressedHeapObjectSlot::StoreHeapObject(Tagged<HeapObject> value) const { … }

//
// OffHeapCompressedObjectSlot implementation.
//

template <typename CompressionScheme>
Tagged<Object> OffHeapCompressedObjectSlot<CompressionScheme>::load() const { … }

template <typename CompressionScheme>
Tagged<Object> OffHeapCompressedObjectSlot<CompressionScheme>::load(
    PtrComprCageBase cage_base) const { … }

template <typename CompressionScheme>
void OffHeapCompressedObjectSlot<CompressionScheme>::store(
    Tagged<Object> value) const { … }

template <typename CompressionScheme>
Tagged<Object> OffHeapCompressedObjectSlot<CompressionScheme>::Relaxed_Load()
    const { … }

template <typename CompressionScheme>
Tagged<Object> OffHeapCompressedObjectSlot<CompressionScheme>::Relaxed_Load(
    PtrComprCageBase cage_base) const { … }

template <typename CompressionScheme>
Tagged<Object> OffHeapCompressedObjectSlot<CompressionScheme>::Acquire_Load()
    const { … }

template <typename CompressionScheme>
Tagged<Object> OffHeapCompressedObjectSlot<CompressionScheme>::Acquire_Load(
    PtrComprCageBase cage_base) const { … }

template <typename CompressionScheme>
void OffHeapCompressedObjectSlot<CompressionScheme>::Relaxed_Store(
    Tagged<Object> value) const { … }

template <typename CompressionScheme>
void OffHeapCompressedObjectSlot<CompressionScheme>::Release_Store(
    Tagged<Object> value) const { … }

template <typename CompressionScheme>
void OffHeapCompressedObjectSlot<CompressionScheme>::Release_CompareAndSwap(
    Tagged<Object> old, Tagged<Object> target) const { … }

}  // namespace v8::internal

#endif  // V8_COMPRESS_POINTERS

#endif  // V8_OBJECTS_COMPRESSED_SLOTS_INL_H_