large-spaces.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/large-spaces.h"

#include "src/base/logging.h"
#include "src/base/platform/mutex.h"
#include "src/base/sanitizer/msan.h"
#include "src/common/globals.h"
#include "src/execution/isolate.h"
#include "src/heap/combined-heap.h"
#include "src/heap/concurrent-marking.h"
#include "src/heap/heap-verifier.h"
#include "src/heap/incremental-marking.h"
#include "src/heap/large-page-metadata.h"
#include "src/heap/list.h"
#include "src/heap/marking-state-inl.h"
#include "src/heap/marking.h"
#include "src/heap/memory-allocator.h"
#include "src/heap/memory-chunk-layout.h"
#include "src/heap/mutable-page-metadata-inl.h"
#include "src/heap/remembered-set.h"
#include "src/heap/slot-set.h"
#include "src/heap/spaces-inl.h"
#include "src/logging/log.h"
#include "src/objects/objects-inl.h"
#include "src/utils/ostreams.h"

namespace v8 {
namespace internal {

// -----------------------------------------------------------------------------
// LargeObjectSpaceObjectIterator

LargeObjectSpaceObjectIterator::LargeObjectSpaceObjectIterator(
    LargeObjectSpace* space) { … }

Tagged<HeapObject> LargeObjectSpaceObjectIterator::Next() { … }

// -----------------------------------------------------------------------------
// OldLargeObjectSpace

LargeObjectSpace::LargeObjectSpace(Heap* heap, AllocationSpace id)
    : … { … }

size_t LargeObjectSpace::Available() const { … }

void LargeObjectSpace::TearDown() { … }

void LargeObjectSpace::AdvanceAndInvokeAllocationObservers(Address soon_object,
                                                           size_t object_size) { … }

void LargeObjectSpace::AddAllocationObserver(AllocationObserver* observer) { … }

void LargeObjectSpace::RemoveAllocationObserver(AllocationObserver* observer) { … }

AllocationResult OldLargeObjectSpace::AllocateRaw(LocalHeap* local_heap,
                                                  int object_size) { … }

AllocationResult OldLargeObjectSpace::AllocateRaw(LocalHeap* local_heap,
                                                  int object_size,
                                                  Executability executable) { … }

LargePageMetadata* LargeObjectSpace::AllocateLargePage(
    int object_size, Executability executable) { … }

size_t LargeObjectSpace::CommittedPhysicalMemory() const { … }

void OldLargeObjectSpace::PromoteNewLargeObject(LargePageMetadata* page) { … }

void LargeObjectSpace::AddPage(LargePageMetadata* page, size_t object_size) { … }

void LargeObjectSpace::RemovePage(LargePageMetadata* page) { … }

void LargeObjectSpace::ShrinkPageToObjectSize(LargePageMetadata* page,
                                              Tagged<HeapObject> object,
                                              size_t object_size) { … }

bool LargeObjectSpace::Contains(Tagged<HeapObject> object) const { … }

bool LargeObjectSpace::ContainsSlow(Address addr) const { … }

std::unique_ptr<ObjectIterator> LargeObjectSpace::GetObjectIterator(
    Heap* heap) { … }

#ifdef VERIFY_HEAP
// We do not assume that the large object iterator works, because it depends
// on the invariants we are checking during verification.
void LargeObjectSpace::Verify(Isolate* isolate,
                              SpaceVerificationVisitor* visitor) const { … }
#endif

#ifdef DEBUG
void LargeObjectSpace::Print() { … }
#endif  // DEBUG

void LargeObjectSpace::UpdatePendingObject(Tagged<HeapObject> object) { … }

OldLargeObjectSpace::OldLargeObjectSpace(Heap* heap)
    : … { … }

OldLargeObjectSpace::OldLargeObjectSpace(Heap* heap, AllocationSpace id)
    : … { … }

NewLargeObjectSpace::NewLargeObjectSpace(Heap* heap, size_t capacity)
    : … { … }

AllocationResult NewLargeObjectSpace::AllocateRaw(LocalHeap* local_heap,
                                                  int object_size) { … }

size_t NewLargeObjectSpace::Available() const { … }

void NewLargeObjectSpace::Flip() { … }

void NewLargeObjectSpace::FreeDeadObjects(
    const std::function<bool(Tagged<HeapObject>)>& is_dead) { … }

void NewLargeObjectSpace::SetCapacity(size_t capacity) { … }

CodeLargeObjectSpace::CodeLargeObjectSpace(Heap* heap)
    : … { … }

AllocationResult CodeLargeObjectSpace::AllocateRaw(LocalHeap* local_heap,
                                                   int object_size) { … }

void CodeLargeObjectSpace::AddPage(LargePageMetadata* page,
                                   size_t object_size) { … }

void CodeLargeObjectSpace::RemovePage(LargePageMetadata* page) { … }

SharedLargeObjectSpace::SharedLargeObjectSpace(Heap* heap)
    : … { … }

SharedTrustedLargeObjectSpace::SharedTrustedLargeObjectSpace(Heap* heap)
    : … { … }

TrustedLargeObjectSpace::TrustedLargeObjectSpace(Heap* heap)
    : … { … }

}  // namespace internal
}  // namespace v8
chromium/v8/src/heap/large-spaces.cc
