marking-visitor.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/cppgc/marking-visitor.h"

#include "include/cppgc/internal/member-storage.h"
#include "src/heap/cppgc/globals.h"
#include "src/heap/cppgc/heap.h"
#include "src/heap/cppgc/marking-state.h"

namespace cppgc {
namespace internal {

struct Dummy;

MarkingVisitorBase::MarkingVisitorBase(HeapBase& heap,
                                       BasicMarkingState& marking_state)
    : … { … }

void MarkingVisitorBase::Visit(const void* object, TraceDescriptor desc) { … }

void MarkingVisitorBase::VisitMultipleUncompressedMember(
    const void* start, size_t len,
    TraceDescriptorCallback get_trace_descriptor) { … }

#if defined(CPPGC_POINTER_COMPRESSION)

void MarkingVisitorBase::VisitMultipleCompressedMember(
    const void* start, size_t len,
    TraceDescriptorCallback get_trace_descriptor) { … }

#endif  // defined(CPPGC_POINTER_COMPRESSION)

void MarkingVisitorBase::VisitWeak(const void* object, TraceDescriptor desc,
                                   WeakCallback weak_callback,
                                   const void* weak_member) { … }

void MarkingVisitorBase::VisitEphemeron(const void* key, const void* value,
                                        TraceDescriptor value_desc) { … }

void MarkingVisitorBase::VisitWeakContainer(const void* object,
                                            TraceDescriptor strong_desc,
                                            TraceDescriptor weak_desc,
                                            WeakCallback callback,
                                            const void* data) { … }

void MarkingVisitorBase::RegisterWeakCallback(WeakCallback callback,
                                              const void* object) { … }

void MarkingVisitorBase::HandleMovableReference(const void** slot) { … }

ConservativeMarkingVisitor::ConservativeMarkingVisitor(
    HeapBase& heap, MutatorMarkingState& marking_state, cppgc::Visitor& visitor)
    : … { … }

void ConservativeMarkingVisitor::VisitFullyConstructedConservatively(
    HeapObjectHeader& header) { … }

void ConservativeMarkingVisitor::VisitInConstructionConservatively(
    HeapObjectHeader& header, TraceConservativelyCallback callback) { … }

MutatorMarkingVisitor::MutatorMarkingVisitor(HeapBase& heap,
                                             MutatorMarkingState& marking_state)
    : … { … }

RootMarkingVisitor::RootMarkingVisitor(MutatorMarkingState& marking_state)
    : … { … }

void RootMarkingVisitor::VisitRoot(const void* object, TraceDescriptor desc,
                                   const SourceLocation&) { … }

void RootMarkingVisitor::VisitWeakRoot(const void* object, TraceDescriptor desc,
                                       WeakCallback weak_callback,
                                       const void* weak_root,
                                       const SourceLocation&) { … }

ConcurrentMarkingVisitor::ConcurrentMarkingVisitor(
    HeapBase& heap, ConcurrentMarkingState& marking_state)
    : … { … }

void ConservativeMarkingVisitor::VisitPointer(const void* address) { … }

bool ConcurrentMarkingVisitor::DeferTraceToMutatorThreadIfConcurrent(
    const void* parameter, TraceCallback callback, size_t deferred_size) { … }

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