marking-barrier.cc | Explore in Territory

// 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.

#include "src/heap/marking-barrier.h"

#include <memory>

#include "src/base/logging.h"
#include "src/common/globals.h"
#include "src/heap/heap-inl.h"
#include "src/heap/heap-write-barrier.h"
#include "src/heap/heap.h"
#include "src/heap/incremental-marking-inl.h"
#include "src/heap/incremental-marking.h"
#include "src/heap/mark-compact-inl.h"
#include "src/heap/mark-compact.h"
#include "src/heap/marking-barrier-inl.h"
#include "src/heap/marking-worklist-inl.h"
#include "src/heap/marking-worklist.h"
#include "src/heap/minor-mark-sweep.h"
#include "src/heap/mutable-page-metadata.h"
#include "src/heap/safepoint.h"
#include "src/objects/heap-object.h"
#include "src/objects/js-array-buffer.h"
#include "src/objects/objects-inl.h"

namespace v8 {
namespace internal {

MarkingBarrier::MarkingBarrier(LocalHeap* local_heap)
    : … { … }

MarkingBarrier::~MarkingBarrier() { … }

void MarkingBarrier::Write(Tagged<HeapObject> host, IndirectPointerSlot slot) { … }

void MarkingBarrier::WriteWithoutHost(Tagged<HeapObject> value) { … }

void MarkingBarrier::Write(Tagged<InstructionStream> host,
                           RelocInfo* reloc_info, Tagged<HeapObject> value) { … }

void MarkingBarrier::Write(Tagged<JSArrayBuffer> host,
                           ArrayBufferExtension* extension) { … }

void MarkingBarrier::Write(Tagged<DescriptorArray> descriptor_array,
                           int number_of_own_descriptors) { … }

void MarkingBarrier::RecordRelocSlot(Tagged<InstructionStream> host,
                                     RelocInfo* rinfo,
                                     Tagged<HeapObject> target) { … }

namespace {
template <typename Space>
void SetGenerationPageFlags(Space* space, MarkingMode marking_mode) { … }

template <typename Space>
void ActivateSpace(Space* space, MarkingMode marking_mode) { … }

template <typename Space>
void DeactivateSpace(Space* space) { … }

void ActivateSpaces(Heap* heap, MarkingMode marking_mode) { … }

void DeactivateSpaces(Heap* heap, MarkingMode marking_mode) { … }
}  // namespace

// static
void MarkingBarrier::ActivateAll(Heap* heap, bool is_compacting) { … }

// static
void MarkingBarrier::ActivateYoung(Heap* heap) { … }

void MarkingBarrier::Activate(bool is_compacting, MarkingMode marking_mode) { … }

void MarkingBarrier::ActivateShared() { … }

// static
void MarkingBarrier::DeactivateAll(Heap* heap) { … }

// static
void MarkingBarrier::DeactivateYoung(Heap* heap) { … }

void MarkingBarrier::Deactivate() { … }

void MarkingBarrier::DeactivateShared() { … }

// static
void MarkingBarrier::PublishAll(Heap* heap) { … }

// static
void MarkingBarrier::PublishYoung(Heap* heap) { … }

void MarkingBarrier::PublishIfNeeded() { … }

void MarkingBarrier::PublishSharedIfNeeded() { … }

bool MarkingBarrier::IsCurrentMarkingBarrier(
    Tagged<HeapObject> verification_candidate) { … }

Isolate* MarkingBarrier::isolate() const { … }

#if DEBUG
void MarkingBarrier::AssertMarkingIsActivated() const { … }

void MarkingBarrier::AssertSharedMarkingIsActivated() const { … }
#endif  // DEBUG

}  // namespace internal
}  // namespace v8
chromium/v8/src/heap/marking-barrier.cc
