heap-consistency.h

Go to the documentation of this file.

// Copyright 2020 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_CPPGC_HEAP_CONSISTENCY_H_
#define INCLUDE_CPPGC_HEAP_CONSISTENCY_H_
 
#include <cstddef>
 
#include "cppgc/internal/write-barrier.h"
#include "cppgc/macros.h"
#include "cppgc/member.h"
#include "cppgc/trace-trait.h"
#include "v8config.h"  // NOLINT(build/include_directory)
 
namespace cppgc {
 
class HeapHandle;
 
namespace subtle {
 
class HeapConsistency final {
 public:
  using WriteBarrierParams = internal::WriteBarrier::Params;
  using WriteBarrierType = internal::WriteBarrier::Type;
 
  static V8_INLINE WriteBarrierType GetWriteBarrierType(
      const void* slot, const void* value, WriteBarrierParams& params) {
    return internal::WriteBarrier::GetWriteBarrierType(slot, value, params);
  }
 
  template <typename T, typename WeaknessTag, typename WriteBarrierPolicy,
            typename CheckingPolicy, typename StorageType>
  static V8_INLINE WriteBarrierType GetWriteBarrierType(
      const internal::BasicMember<T, WeaknessTag, WriteBarrierPolicy,
                                  CheckingPolicy, StorageType>& value,
      WriteBarrierParams& params) {
    return internal::WriteBarrier::GetWriteBarrierType(
        value.GetRawSlot(), value.GetRawStorage(), params);
  }
 
  template <typename HeapHandleCallback>
  static V8_INLINE WriteBarrierType
  GetWriteBarrierType(const void* slot, WriteBarrierParams& params,
                      HeapHandleCallback callback) {
    return internal::WriteBarrier::GetWriteBarrierType(slot, params, callback);
  }
 
  static V8_INLINE WriteBarrierType
  GetWriteBarrierType(const void* value, WriteBarrierParams& params) {
    return internal::WriteBarrier::GetWriteBarrierType(value, params);
  }
 
  static V8_INLINE void DijkstraWriteBarrier(const WriteBarrierParams& params,
                                             const void* object) {
    internal::WriteBarrier::DijkstraMarkingBarrier(params, object);
  }
 
  static V8_INLINE void DijkstraWriteBarrierRange(
      const WriteBarrierParams& params, const void* first_element,
      size_t element_size, size_t number_of_elements,
      TraceCallback trace_callback) {
    internal::WriteBarrier::DijkstraMarkingBarrierRange(
        params, first_element, element_size, number_of_elements,
        trace_callback);
  }
 
  static V8_INLINE void SteeleWriteBarrier(const WriteBarrierParams& params,
                                           const void* object) {
    internal::WriteBarrier::SteeleMarkingBarrier(params, object);
  }
 
  static V8_INLINE void GenerationalBarrier(const WriteBarrierParams& params,
                                            const void* slot) {
    internal::WriteBarrier::GenerationalBarrier<
        internal::WriteBarrier::GenerationalBarrierType::kPreciseSlot>(params,
                                                                       slot);
  }
 
  static V8_INLINE void GenerationalBarrierForUncompressedSlot(
      const WriteBarrierParams& params, const void* uncompressed_slot) {
    internal::WriteBarrier::GenerationalBarrier<
        internal::WriteBarrier::GenerationalBarrierType::
            kPreciseUncompressedSlot>(params, uncompressed_slot);
  }
 
  static V8_INLINE void GenerationalBarrierForSourceObject(
      const WriteBarrierParams& params, const void* inner_pointer) {
    internal::WriteBarrier::GenerationalBarrier<
        internal::WriteBarrier::GenerationalBarrierType::kImpreciseSlot>(
        params, inner_pointer);
  }
 
 private:
  HeapConsistency() = delete;
};
 
class V8_EXPORT V8_NODISCARD DisallowGarbageCollectionScope final {
  CPPGC_STACK_ALLOCATED();
 
 public:
  static bool IsGarbageCollectionAllowed(HeapHandle& heap_handle);
 
  static void Enter(HeapHandle& heap_handle);
 
  static void Leave(HeapHandle& heap_handle);
 
  explicit DisallowGarbageCollectionScope(HeapHandle& heap_handle);
  ~DisallowGarbageCollectionScope();
 
  DisallowGarbageCollectionScope(const DisallowGarbageCollectionScope&) =
      delete;
  DisallowGarbageCollectionScope& operator=(
      const DisallowGarbageCollectionScope&) = delete;
 
 private:
  HeapHandle& heap_handle_;
};
 
class V8_EXPORT V8_NODISCARD NoGarbageCollectionScope final {
  CPPGC_STACK_ALLOCATED();
 
 public:
  static void Enter(HeapHandle& heap_handle);
 
  static void Leave(HeapHandle& heap_handle);
 
  explicit NoGarbageCollectionScope(HeapHandle& heap_handle);
  ~NoGarbageCollectionScope();
 
  NoGarbageCollectionScope(const NoGarbageCollectionScope&) = delete;
  NoGarbageCollectionScope& operator=(const NoGarbageCollectionScope&) = delete;
 
 private:
  HeapHandle& heap_handle_;
};
 
}  // namespace subtle
}  // namespace cppgc
 
#endif  // INCLUDE_CPPGC_HEAP_CONSISTENCY_H_