Lines Matching defs:Heap
39 #include "heap-profiler.h"
66 Heap::Heap()
139 previous_survival_rate_trend_(Heap::STABLE),
140 survival_rate_trend_(Heap::STABLE),
196 intptr_t Heap::Capacity() {
209 intptr_t Heap::CommittedMemory() {
223 size_t Heap::CommittedPhysicalMemory() {
237 intptr_t Heap::CommittedMemoryExecutable() {
244 intptr_t Heap::Available() {
257 bool Heap::HasBeenSetUp() {
268 int Heap::GcSafeSizeOfOldObject(HeapObject* object) {
276 GarbageCollector Heap::SelectGarbageCollector(AllocationSpace space,
327 // TODO(1238405): Combine the infrastructure for --heap-stats and
329 void Heap::ReportStatisticsBeforeGC() {
330 // Heap::ReportHeapStatistics will also log NewSpace statistics when
351 void Heap::PrintShortHeapStatistics() {
417 // TODO(1238405): Combine the infrastructure for --heap-stats and
419 void Heap::ReportStatisticsAfterGC() {
435 void Heap::GarbageCollectionPrologue() {
465 intptr_t Heap::SizeOfObjects() {
475 void Heap::RepairFreeListsAfterBoot() {
485 void Heap::GarbageCollectionEpilogue() {
488 // In release mode, we only zap the from space under heap verification.
489 if (Heap::ShouldZapGarbage()) {
589 void Heap::CollectAllGarbage(int flags, const char* gc_reason) {
599 void Heap::CollectAllAvailableGarbage(const char* gc_reason) {
629 bool Heap::CollectGarbage(AllocationSpace space,
693 // Start incremental marking for the next cycle. The heap snapshot
706 int Heap::NotifyContextDisposed() {
716 void Heap::PerformScavenge() {
726 void Heap::MoveElements(FixedArray* array,
732 ASSERT(array->map() != HEAP->fixed_cow_array_map());
768 HEAP->string_table()->IterateElements(&verifier);
774 Heap* heap,
777 heap->mark_compact_collector()->SetFlags(Heap::kAbortIncrementalMarkingMask);
778 bool result = heap->CollectGarbage(space, gc_reason);
779 heap->mark_compact_collector()->SetFlags(Heap::kNoGCFlags);
784 void Heap::ReserveSpace(
804 Heap::CollectGarbage(NEW_SPACE,
826 V8::FatalProcessOutOfMemory("Heap::ReserveSpace");
831 void Heap::EnsureFromSpaceIsCommitted() {
840 void Heap::ClearJSFunctionResultCaches() {
863 void Heap::ClearNormalizedMapCaches() {
883 void Heap::UpdateSurvivalRateTrend(int start_new_space_size) {
913 bool Heap::PerformGarbageCollection(GarbageCollector collector,
939 int start_new_space_size = Heap::new_space()->SizeAsInt();
1055 void Heap::CallGCPrologueCallbacks(GCType gc_type, GCCallbackFlags flags) {
1067 void Heap::CallGCEpilogueCallbacks(GCType gc_type) {
1079 void Heap::MarkCompact(GCTracer* tracer) {
1104 void Heap::MarkCompactPrologue() {
1129 explicit ScavengeVisitor(Heap* heap) : heap_(heap) {}
1142 Heap::ScavengeObject(reinterpret_cast<HeapObject**>(p),
1146 Heap* heap_;
1158 CHECK(!HEAP->InNewSpace(HeapObject::cast(*current)));
1169 HeapObjectIterator code_it(HEAP->code_space());
1176 if (!HEAP->old_data_space()->was_swept_conservatively()) {
1177 HeapObjectIterator data_it(HEAP->old_data_space());
1186 void Heap::CheckNewSpaceExpansionCriteria() {
1199 static bool IsUnscavengedHeapObject(Heap* heap, Object** p) {
1200 return heap->InNewSpace(*p) &&
1205 void Heap::ScavengeStoreBufferCallback(
1206 Heap* heap,
1209 heap->store_buffer_rebuilder_.Callback(page, event);
1301 explicit ScavengeWeakObjectRetainer(Heap* heap) : heap_(heap) { }
1316 Heap* heap_;
1320 void Heap::Scavenge() {
1473 String* Heap::UpdateNewSpaceReferenceInExternalStringTableEntry(Heap* heap,
1479 heap->FinalizeExternalString(String::cast(*p));
1488 void Heap::UpdateNewSpaceReferencesInExternalStringTable(
1525 void Heap::UpdateReferencesInExternalStringTable(
1544 static Object* VisitWeakList(Heap* heap,
1548 Object* undefined = heap->undefined_value();
1551 MarkCompactCollector* collector = heap->mark_compact_collector();
1578 heap, tail, retainer, record_slots);
1580 WeakListVisitor<T>::VisitPhantomObject(heap, candidate);
1609 static void VisitLiveObject(Heap*, JSFunction*,
1613 static void VisitPhantomObject(Heap*, JSFunction*) {
1630 static void VisitLiveObject(Heap* heap,
1637 heap,
1648 heap->mark_compact_collector()->RecordSlot(
1653 static void VisitPhantomObject(Heap*, Context*) {
1662 void Heap::ProcessWeakReferences(WeakObjectRetainer* retainer) {
1675 void Heap::ProcessNativeContexts(WeakObjectRetainer* retainer,
1695 static void VisitLiveObject(Heap*,
1700 static void VisitPhantomObject(Heap*, JSArrayBufferView*) {}
1718 static void VisitLiveObject(Heap* heap,
1724 heap,
1728 if (typed_array_obj != heap->undefined_value() && record_slots) {
1731 heap->mark_compact_collector()->RecordSlot(slot, slot, typed_array_obj);
1735 static void VisitPhantomObject(Heap* heap, JSArrayBuffer* phantom) {
1736 Runtime::FreeArrayBuffer(heap->isolate(), phantom);
1745 void Heap::ProcessArrayBuffers(WeakObjectRetainer* retainer,
1755 void Heap::TearDownArrayBuffers() {
1776 static void VisitLiveObject(Heap* heap,
1781 static void VisitPhantomObject(Heap* heap, AllocationSite* phantom) {}
1789 void Heap::ProcessAllocationSites(WeakObjectRetainer* retainer,
1799 void Heap::VisitExternalResources(v8::ExternalResourceVisitor* visitor) {
1852 static inline void VisitPointer(Heap* heap, Object** p) {
1854 if (!heap->InNewSpace(object)) return;
1855 Heap::ScavengeObject(reinterpret_cast<HeapObject**>(p),
1861 Address Heap::DoScavenge(ObjectVisitor* scavenge_visitor,
1911 INLINE(static HeapObject* EnsureDoubleAligned(Heap* heap,
1915 static HeapObject* EnsureDoubleAligned(Heap* heap,
1919 heap->CreateFillerObjectAt(object->address(), kPointerSize);
1922 heap->CreateFillerObjectAt(object->address() + size - kPointerSize,
2022 static void RecordCopiedObject(Heap* heap, HeapObject* obj) {
2029 if (heap->new_space()->Contains(obj)) {
2030 heap->new_space()->RecordAllocation(obj);
2032 heap->new_space()->RecordPromotion(obj);
2040 INLINE(static void MigrateObject(Heap* heap,
2045 heap->CopyBlock(target->address(), source->address(), size);
2052 RecordCopiedObject(heap, target);
2053 HEAP_PROFILE(heap, ObjectMoveEvent(source->address(), target->address()));
2054 Isolate* isolate = heap->isolate();
2086 Heap* heap = map->GetHeap();
2087 if (heap->ShouldBePromoted(object->address(), object_size)) {
2092 CHECK(heap->AllowedToBeMigrated(object, OLD_DATA_SPACE));
2093 maybe_result = heap->old_data_space()->AllocateRaw(allocation_size);
2096 CHECK(heap->AllowedToBeMigrated(object, OLD_POINTER_SPACE));
2097 maybe_result = heap->old_pointer_space()->AllocateRaw(allocation_size);
2105 target = EnsureDoubleAligned(heap, target, allocation_size);
2112 MigrateObject(heap, object, target, object_size);
2116 heap->promotion_queue()->insert(
2119 heap->promotion_queue()->insert(target, object_size);
2123 heap->tracer()->increment_promoted_objects_size(object_size);
2128 CHECK(heap->AllowedToBeMigrated(object, NEW_SPACE));
2129 MaybeObject* allocation = heap->new_space()->AllocateRaw(allocation_size);
2130 heap->promotion_queue()->SetNewLimit(heap->new_space()->top());
2135 target = EnsureDoubleAligned(heap, target, allocation_size);
2142 MigrateObject(heap, object, target, object_size);
2226 Heap* heap = map->GetHeap();
2230 heap->empty_string()) {
2236 if (!heap->InNewSpace(first)) {
2250 heap->DoScavengeObject(first->map(), slot, first);
2300 void Heap::SelectScavengingVisitorsTable() {
2342 void Heap::ScavengeObjectSlow(HeapObject** p, HeapObject* object) {
2343 SLOW_ASSERT(HEAP->InFromSpace(object));
2351 MaybeObject* Heap::AllocatePartialMap(InstanceType instance_type,
2375 MaybeObject* Heap::AllocateMap(InstanceType instance_type,
2409 MaybeObject* Heap::AllocateCodeCache() {
2420 MaybeObject* Heap::AllocatePolymorphicCodeCache() {
2425 MaybeObject* Heap::AllocateAccessorPair() {
2436 MaybeObject* Heap::AllocateTypeFeedbackInfo() {
2448 MaybeObject* Heap::AllocateAliasedArgumentsEntry(int aliased_context_slot) {
2458 const Heap::StringTypeTable Heap::string_type_table[] = {
2466 const Heap::ConstantStringTable Heap::constant_string_table[] = {
2474 const Heap::StructTable Heap::struct_table[] = {
2482 bool Heap::CreateInitialMaps() {
2845 MaybeObject* Heap::AllocateHeapNumber(double value, PretenureFlag pretenure) {
2846 // Statically ensure that it is safe to allocate heap numbers in paged
2863 MaybeObject* Heap::AllocateHeapNumber(double value) {
2880 MaybeObject* Heap::AllocateCell(Object* value) {
2891 MaybeObject* Heap::AllocatePropertyCell(Object* value) {
2909 MaybeObject* Heap::AllocateBox(Object* value, PretenureFlag pretenure) {
2918 MaybeObject* Heap::AllocateAllocationSite() {
2933 MaybeObject* Heap::CreateOddball(const char* to_string,
2944 bool Heap::CreateApiObjects() {
2973 void Heap::CreateJSEntryStub() {
2979 void Heap::CreateJSConstructEntryStub() {
2985 void Heap::CreateFixedStubs() {
2999 Heap::CreateJSEntryStub();
3000 Heap::CreateJSConstructEntryStub();
3010 bool Heap::CreateInitialObjects() {
3242 bool Heap::RootCanBeWrittenAfterInitialization(Heap::RootListIndex root_index) {
3271 bool Heap::RootCanBeTreatedAsConstant(RootListIndex root_index) {
3277 Object* RegExpResultsCache::Lookup(Heap* heap,
3286 cache = heap->string_split_cache();
3290 cache = heap->regexp_multiple_cache();
3310 void RegExpResultsCache::Enter(Heap* heap,
3320 cache = heap->string_split_cache();
3324 cache = heap->regexp_multiple_cache();
3356 MaybeObject* maybe_string = heap->InternalizeString(str);
3363 value_array->set_map_no_write_barrier(heap->fixed_cow_array_map());
3374 MaybeObject* Heap::AllocateInitialNumberStringCache() {
3381 int Heap::FullSizeNumberStringCacheLength() {
3394 void Heap::AllocateFullSizeNumberStringCache() {
3412 void Heap::FlushNumberStringCache() {
3432 Object* Heap::GetNumberStringCache(Object* number) {
3452 void Heap::SetNumberStringCache(Object* number, String* string) {
3472 MaybeObject* Heap::NumberToString(Object* number,
3504 MaybeObject* Heap::Uint32ToString(uint32_t value,
3513 Map* Heap::MapForExternalArrayType(ExternalArrayType array_type) {
3518 Heap::RootListIndex Heap::RootIndexForExternalArrayType(
3545 Heap::RootListIndex Heap::RootIndexForEmptyExternalArray(
3573 ExternalArray* Heap::EmptyExternalArrayForMap(Map* map) {
3581 MaybeObject* Heap::NumberFromDouble(double value, PretenureFlag pretenure) {
3597 // Materialize the value in the heap.
3602 MaybeObject* Heap::AllocateForeign(Address address, PretenureFlag pretenure) {
3614 MaybeObject* Heap::AllocateSharedFunctionInfo(Object* name) {
3653 MaybeObject* Heap::AllocateJSMessageObject(String* type,
3665 message->set_properties(Heap::empty_fixed_array(), SKIP_WRITE_BARRIER);
3667 message->set_elements(Heap::empty_fixed_array(), SKIP_WRITE_BARRIER);
3688 Heap* heap,
3695 heap->string_table()->LookupTwoCharsStringIfExists(c1, c2, &result)) {
3703 { MaybeObject* maybe_result = heap->AllocateRawOneByteString(2);
3712 { MaybeObject* maybe_result = heap->AllocateRawTwoByteString(2);
3723 MaybeObject* Heap::AllocateConsString(String* first, String* second) {
3841 MaybeObject* Heap::AllocateSubString(String* buffer,
3935 MaybeObject* Heap::AllocateExternalStringFromAscii(
3958 MaybeObject* Heap::AllocateExternalStringFromTwoByte(
3987 MaybeObject* Heap::LookupSingleCharacterStringFromCode(uint16_t code) {
4013 MaybeObject* Heap::AllocateByteArray(int length, PretenureFlag pretenure) {
4035 MaybeObject* Heap::AllocateByteArray(int length) {
4054 void Heap::CreateFillerObjectAt(Address addr, int size) {
4068 MaybeObject* Heap::AllocateExternalArray(int length,
4090 MaybeObject* Heap::CreateCode(const CodeDesc& desc,
4096 // leaving uninitialized Code object (and breaking the heap).
4155 // that are dereferenced during the copy to point directly to the actual heap
4169 MaybeObject* Heap::CopyCode(Code* code) {
4195 MaybeObject* Heap::CopyCode(Code* code, Vector<byte> reloc_info) {
4197 // leaving uninitialized Code object (and breaking the heap).
4253 MaybeObject* Heap::AllocateWithAllocationSite(Map* map, AllocationSpace space,
4275 MaybeObject* Heap::Allocate(Map* map, AllocationSpace space) {
4292 void Heap::InitializeFunction(JSFunction* function,
4307 MaybeObject* Heap::AllocateFunctionPrototype(JSFunction* function) {
4340 MaybeObject* Heap::AllocateFunction(Map* function_map,
4355 MaybeObject* Heap::AllocateArgumentsObject(Object* callee, int length) {
4374 // This calls Copy directly rather than using Heap::AllocateRaw so we
4415 MaybeObject* Heap::AllocateInitialMap(JSFunction* fun) {
4457 void Heap::InitializeJSObjectFromMap(JSObject* obj,
4466 // fixed array (e.g. Heap::empty_fixed_array()). Currently, the object
4481 filler = Heap::one_pointer_filler_map();
4483 filler = Heap::undefined_value();
4485 obj->InitializeBody(map, Heap::undefined_value(), filler);
4489 MaybeObject* Heap::AllocateJSObjectFromMap(
4528 MaybeObject* Heap::AllocateJSObjectFromMapWithAllocationSite(
4562 MaybeObject* Heap::AllocateJSObject(JSFunction* constructor,
4585 MaybeObject* Heap::AllocateJSObjectWithAllocationSite(JSFunction* constructor,
4627 MaybeObject* Heap::AllocateJSGeneratorObject(JSFunction *function) {
4644 MaybeObject* Heap::AllocateJSModule(Context* context, ScopeInfo* scope_info) {
4659 MaybeObject* Heap::AllocateJSArrayAndStorage(
4705 MaybeObject* Heap::AllocateJSArrayAndStorageWithAllocationSite(
4719 MaybeObject* Heap::AllocateJSArrayStorage(
4759 MaybeObject* Heap::AllocateJSArrayWithElements(
4775 MaybeObject* Heap::AllocateJSProxy(Object* handler, Object* prototype) {
4795 MaybeObject* Heap::AllocateJSFunctionProxy(Object* handler,
4821 MaybeObject* Heap::AllocateGlobalObject(JSFunction* constructor) {
4888 MaybeObject* Heap::CopyJSObject(JSObject* source) {
4961 MaybeObject* Heap::CopyJSObjectWithAllocationSite(
5070 MaybeObject* Heap
5131 MaybeObject* Heap::ReinitializeJSGlobalProxy(JSFunction* constructor,
5157 MaybeObject* Heap::AllocateStringFromOneByte(Vector<const uint8_t> string,
5161 return Heap::LookupSingleCharacterStringFromCode(string[0]);
5177 MaybeObject* Heap::AllocateStringFromUtf8Slow(Vector<const char> string,
5211 MaybeObject* Heap::AllocateStringFromTwoByte(Vector<const uc16> string,
5231 Map* Heap::InternalizedStringMapForString(String* string) {
5306 MaybeObject* Heap::AllocateInternalizedStringImpl(
5354 MaybeObject* Heap::AllocateInternalizedStringImpl<true>(String*, int, uint32_t);
5356 MaybeObject* Heap::AllocateInternalizedStringImpl<false>(
5359 MaybeObject* Heap::AllocateInternalizedStringImpl<false>(
5363 MaybeObject* Heap::AllocateRawOneByteString(int length,
5393 MaybeObject* Heap::AllocateRawTwoByteString(int length,
5422 MaybeObject* Heap::AllocateJSArray(
5434 MaybeObject* Heap::AllocateJSArrayWithAllocationSite(
5452 MaybeObject* Heap::AllocateEmptyFixedArray() {
5467 MaybeObject* Heap::AllocateEmptyExternalArray(ExternalArrayType array_type) {
5472 MaybeObject* Heap::AllocateRawFixedArray(int length) {
5487 MaybeObject* Heap::CopyFixedArrayWithMap(FixedArray* src, Map* map) {
5513 MaybeObject* Heap::CopyFixedDoubleArrayWithMap(FixedDoubleArray* src,
5530 MaybeObject* Heap::AllocateFixedArray(int length) {
5548 MaybeObject* Heap::AllocateRawFixedArray(int length, PretenureFlag pretenure) {
5567 Heap* heap,
5572 ASSERT(heap->empty_fixed_array()->IsFixedArray());
5573 if (length == 0) return heap->empty_fixed_array();
5575 ASSERT(!heap->InNewSpace(filler));
5577 { MaybeObject* maybe_result = heap->AllocateRawFixedArray(length, pretenure);
5581 HeapObject::cast(result)->set_map_no_write_barrier(heap->fixed_array_map());
5589 MaybeObject* Heap::AllocateFixedArray(int length, PretenureFlag pretenure) {
5597 MaybeObject* Heap::AllocateFixedArrayWithHoles(int length,
5606 MaybeObject* Heap::AllocateUninitializedFixedArray(int length) {
5621 MaybeObject* Heap::AllocateEmptyFixedDoubleArray() {
5636 MaybeObject* Heap::AllocateUninitializedFixedDoubleArray(
5653 MaybeObject* Heap::AllocateFixedDoubleArrayWithHoles(
5674 MaybeObject* Heap::AllocateRawFixedDoubleArray(int length,
5701 MaybeObject* Heap::AllocateHashTable(int length, PretenureFlag pretenure) {
5713 MaybeObject* Heap::AllocateSymbol() {
5742 MaybeObject* Heap::AllocateNativeContext() {
5757 MaybeObject* Heap::AllocateGlobalContext(JSFunction* function,
5776 MaybeObject* Heap::AllocateModuleContext(ScopeInfo* scope_info) {
5790 MaybeObject* Heap::AllocateFunctionContext(int length, JSFunction* function) {
5806 MaybeObject* Heap::AllocateCatchContext(JSFunction* function,
5827 MaybeObject* Heap::AllocateWithContext(JSFunction* function,
5844 MaybeObject* Heap::AllocateBlockContext(JSFunction* function,
5862 MaybeObject* Heap::AllocateScopeInfo(int length) {
5871 MaybeObject* Heap::AllocateExternal(void* value) {
5885 MaybeObject* Heap::AllocateStruct(InstanceType type) {
5908 bool Heap::IsHeapIterable() {
5914 void Heap::EnsureHeapIsIterable() {
5917 CollectAllGarbage(kMakeHeapIterableMask, "Heap::EnsureHeapIsIterable");
5923 void Heap::AdvanceIdleIncrementalMarking(intptr_t step_size) {
5945 bool Heap::IdleNotification(int hint) {
6043 bool Heap::IdleGlobalGC() {
6105 void Heap::Print() {
6115 void Heap::ReportCodeStatistics(const char* title) {
6129 void Heap::ReportHeapStatistics(const char* title) {
6141 PrintF("Heap statistics : ");
6164 bool Heap::Contains(HeapObject* value) {
6169 bool Heap::Contains(Address addr) {
6183 bool Heap::InSpace(HeapObject* value, AllocationSpace space) {
6188 bool Heap::InSpace(Address addr, AllocationSpace space) {
6216 void Heap::Verify() {
6240 MaybeObject* Heap::InternalizeUtf8String(Vector<const char> string) {
6255 MaybeObject* Heap::InternalizeOneByteString(Vector<const uint8_t> string) {
6270 MaybeObject* Heap::InternalizeOneByteString(Handle<SeqOneByteString> string,
6290 MaybeObject* Heap::InternalizeTwoByteString(Vector<const uc16> string) {
6305 MaybeObject* Heap::InternalizeString(String* string) {
6321 bool Heap::InternalizeStringIfExists(String* string, String** result) {
6330 void Heap::ZapFromSpace() {
6344 void Heap::IterateAndMarkPointersToFromSpace(Address start,
6369 if (Heap::InFromSpace(object)) {
6374 SLOW_ASSERT(Heap::InToSpace(new_object));
6407 static void CheckStoreBuffer(Heap* heap,
6415 Map* free_space_map = heap->free_space_map();
6444 // without trying to cast it to a heap object since the hash field of
6447 if (!heap->InNewSpace(o)) continue;
6465 void Heap::OldPointerSpaceCheckStoreBuffer() {
6493 void Heap::MapSpaceCheckStoreBuffer() {
6521 void Heap::LargeObjectSpaceCheckStoreBuffer() {
6547 void Heap::IterateRoots(ObjectVisitor* v, VisitMode mode) {
6553 void Heap::IterateWeakRoots(ObjectVisitor* v, VisitMode mode) {
6565 void Heap::IterateStrongRoots(ObjectVisitor* v, VisitMode mode) {
6595 // heap. Note that it is not necessary to iterate over code objects
6645 // TODO(1236194): Since the heap size is configurable on the command line
6646 // and through the API, we should gracefully handle the case that the heap
6648 bool Heap::ConfigureHeap(int max_semispace_size,
6723 bool Heap::ConfigureHeapDefault() {
6730 void Heap::RecordStats(HeapStats* stats, bool take_snapshot) {
6769 intptr_t Heap::PromotedSpaceSizeOfObjects() {
6780 intptr_t Heap::PromotedExternalMemorySize() {
6797 bool Heap::SetUp() {
6802 // Initialize heap spaces and initial maps and objects. Whenever something
6804 // call Heap::TearDown() to release allocated memory.
6806 // If the heap is not yet configured (e.g. through the API), configure it.
6894 LOG(isolate_, IntPtrTEvent("heap-capacity", Capacity()));
6895 LOG(isolate_, IntPtrTEvent("heap-available", Available()));
6908 bool Heap::CreateHeapObjects() {
6923 void Heap::SetStackLimits() {
6940 void Heap::TearDown() {
7022 void Heap::AddGCPrologueCallback(GCPrologueCallback callback, GCType gc_type) {
7030 void Heap::RemoveGCPrologueCallback(GCPrologueCallback callback) {
7042 void Heap::AddGCEpilogueCallback(GCEpilogueCallback callback, GCType gc_type) {
7050 void Heap::RemoveGCEpilogueCallback(GCEpilogueCallback callback) {
7075 void Heap::PrintHandles() {
7143 SpaceIterator::SpaceIterator(Heap* heap)
7144 : heap_(heap),
7151 SpaceIterator::SpaceIterator(Heap* heap, HeapObjectCallback size_func)
7152 : heap_(heap),
7240 Isolate::Current()->heap()->mark_compact_collector()->ClearMarkbits();
7277 Heap* heap = Isolate::Current()->heap();
7279 heap->IterateRoots(&visitor, VISIT_ALL);
7287 HeapIterator::HeapIterator(Heap* heap)
7288 : heap_(heap),
7295 HeapIterator::HeapIterator(Heap* heap,
7297 : heap_(heap),
7326 // objects. Otherwise, heap will be left in an inconsistent state.
7548 // given root object and finds a path to a specific heap object and
7550 void Heap::TracePathToObjectFrom(Object* target, Object* root) {
7557 // and finds a path to a specific heap object and prints it.
7558 void Heap::TracePathToObject(Object* target) {
7567 void Heap::TracePathToGlobal() {
7576 static intptr_t CountTotalHolesSize(Heap* heap) {
7578 OldSpaces spaces(heap);
7588 GCTracer::GCTracer(Heap* heap,
7602 heap_(heap),
7614 in_free_list_or_wasted_before_gc_ = CountTotalHolesSize(heap);
7799 if (!HEAP->InternalizeStringIfExists(
7807 ASSERT(!HEAP->InNewSpace(name));
7850 void Heap::GarbageCollectionGreedyCheck() {
7921 void Heap::QueueMemoryChunkForFree(MemoryChunk* chunk) {
7927 void Heap::FreeQueuedChunks() {
7965 isolate_->heap()->store_buffer()->Compact();
7966 isolate_->heap()->store_buffer()->Filter(MemoryChunk::ABOUT_TO_BE_FREED);
7975 void Heap::RememberUnmappedPage(Address page, bool compacted) {
7990 void Heap::ClearObjectStats(bool clear_last_time_stats) {
8003 void Heap::CheckpointObjectStats() {
8049 Heap::RelocationLock::RelocationLock(Heap* heap) : heap_(heap) {
