chromium/v8/test/cctest/heap/heap-utils.cc

// Copyright 2016 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 "test/cctest/heap/heap-utils.h"

#include "src/base/platform/mutex.h"
#include "src/common/assert-scope.h"
#include "src/common/globals.h"
#include "src/execution/isolate.h"
#include "src/heap/factory.h"
#include "src/heap/free-list.h"
#include "src/heap/gc-tracer-inl.h"
#include "src/heap/heap-inl.h"
#include "src/heap/heap.h"
#include "src/heap/incremental-marking.h"
#include "src/heap/mark-compact.h"
#include "src/heap/marking-barrier.h"
#include "src/heap/mutable-page-metadata.h"
#include "src/heap/page-metadata-inl.h"
#include "src/heap/safepoint.h"
#include "src/heap/spaces.h"
#include "src/objects/free-space-inl.h"
#include "test/cctest/cctest.h"

namespace v8 {
namespace internal {
namespace heap {

void SealCurrentObjects(Heap* heap) { … }

int FixedArrayLenFromSize(int size) { … }

std::vector<Handle<FixedArray>> FillOldSpacePageWithFixedArrays(Heap* heap,
                                                                int remainder) { … }

std::vector<Handle<FixedArray>> CreatePadding(Heap* heap, int padding_size,
                                              AllocationType allocation,
                                              int object_size) { … }

namespace {
void FillPageInPagedSpace(PageMetadata* page,
                          std::vector<Handle<FixedArray>>* out_handles) { … }
}  // namespace

void FillCurrentPage(v8::internal::NewSpace* space,
                     std::vector<Handle<FixedArray>>* out_handles) { … }

void FillCurrentPageButNBytes(v8::internal::SemiSpaceNewSpace* space,
                              int extra_bytes,
                              std::vector<Handle<FixedArray>>* out_handles) { … }

void SimulateIncrementalMarking(i::Heap* heap, bool force_completion) { … }

void SimulateFullSpace(v8::internal::PagedSpace* space) { … }

void AbandonCurrentlyFreeMemory(PagedSpace* space) { … }

void InvokeMajorGC(Heap* heap) { … }

void InvokeMajorGC(Heap* heap, GCFlag gc_flag) { … }

void InvokeMinorGC(Heap* heap) { … }

void InvokeAtomicMajorGC(Heap* heap) { … }

void InvokeAtomicMinorGC(Heap* heap) { … }

void InvokeMemoryReducingMajorGCs(Heap* heap) { … }

void CollectSharedGarbage(Heap* heap) { … }

void EmptyNewSpaceUsingGC(Heap* heap) { … }

void ForceEvacuationCandidate(PageMetadata* page) { … }

bool InCorrectGeneration(Tagged<HeapObject> object) { … }

void GrowNewSpace(Heap* heap) { … }

void GrowNewSpaceToMaximumCapacity(Heap* heap) { … }

}  // namespace heap

ManualGCScope::ManualGCScope(Isolate* isolate)
    : … { … }

ManualGCScope::~ManualGCScope() { … }

}  // namespace internal
}  // namespace v8