src/mark-compact.cc - Issue 6760025: Cleanup usage of HEAP in mark-compact.

Unified Diff: src/mark-compact.cc

Issue 6760025: Cleanup usage of HEAP in mark-compact. (Closed) Base URL: https://v8.googlecode.com/svn/branches/bleeding_edge

Patch Set: Merge. Created 9 years, 9 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Download patch

Index: src/mark-compact.cc

diff --git a/src/mark-compact.cc b/src/mark-compact.cc

index 6d40ea07ded208b14c67d76194bcc222f8843994..3770bc3b35572a3b33e3cb7b82b5ad4d83276bb9 100644

--- a/src/mark-compact.cc

+++ b/src/mark-compact.cc

@@ -86,15 +86,15 @@ void MarkCompactCollector::CollectGarbage() {

GCTracer::Scope gc_scope(tracer_, GCTracer::Scope::MC_COMPACT);

EncodeForwardingAddresses();

- heap_->MarkMapPointersAsEncoded(true);

+ heap()->MarkMapPointersAsEncoded(true);

UpdatePointers();

- heap_->MarkMapPointersAsEncoded(false);

- heap_->isolate()->pc_to_code_cache()->Flush();

+ heap()->MarkMapPointersAsEncoded(false);

+ heap()->isolate()->pc_to_code_cache()->Flush();

RelocateObjects();

} else {

SweepSpaces();

- heap_->isolate()->pc_to_code_cache()->Flush();

+ heap()->isolate()->pc_to_code_cache()->Flush();

}

Finish();

@@ -123,7 +123,7 @@ void MarkCompactCollector::Prepare(GCTracer* tracer) {

compact_on_next_gc_ = false;

if (FLAG_never_compact) compacting_collection_ = false;

- if (!HEAP->map_space()->MapPointersEncodable())

+ if (!heap()->map_space()->MapPointersEncodable())

compacting_collection_ = false;

if (FLAG_collect_maps) CreateBackPointers();

#ifdef ENABLE_GDB_JIT_INTERFACE

@@ -161,9 +161,9 @@ void MarkCompactCollector::Finish() {

// force lazy re-initialization of it. This must be done after the

// GC, because it relies on the new address of certain old space

// objects (empty string, illegal builtin).

- heap_->isolate()->stub_cache()->Clear();

+ heap()->isolate()->stub_cache()->Clear();

- heap_->external_string_table_.CleanUp();

+ heap()->external_string_table_.CleanUp();

// If we've just compacted old space there's no reason to check the

// fragmentation limit. Just return.

@@ -456,7 +456,7 @@ class StaticMarkingVisitor : public StaticVisitorBase {

for (Object** p = start; p < end; p++) MarkObjectByPointer(heap, p);

}

- static inline void VisitCodeTarget(RelocInfo* rinfo) {

+ static inline void VisitCodeTarget(Heap* heap, RelocInfo* rinfo) {

ASSERT(RelocInfo::IsCodeTarget(rinfo->rmode()));

Code* code = Code::GetCodeFromTargetAddress(rinfo->target_address());

if (FLAG_cleanup_ics_at_gc && code->is_inline_cache_stub()) {

@@ -464,28 +464,27 @@ class StaticMarkingVisitor : public StaticVisitorBase {

// Please note targets for cleared inline cached do not have to be

// marked since they are contained in HEAP->non_monomorphic_cache().

} else {

- code->heap()->mark_compact_collector()->MarkObject(code);

+ heap->mark_compact_collector()->MarkObject(code);

}

- static void VisitGlobalPropertyCell(RelocInfo* rinfo) {

+ static void VisitGlobalPropertyCell(Heap* heap, RelocInfo* rinfo) {

ASSERT(rinfo->rmode() == RelocInfo::GLOBAL_PROPERTY_CELL);

Object* cell = rinfo->target_cell();

Object* old_cell = cell;

- VisitPointer(reinterpret_cast<JSGlobalPropertyCell*>(cell)->heap(), &cell);

+ VisitPointer(heap, &cell);

if (cell != old_cell) {

rinfo->set_target_cell(reinterpret_cast<JSGlobalPropertyCell*>(cell));

}

- static inline void VisitDebugTarget(RelocInfo* rinfo) {

+ static inline void VisitDebugTarget(Heap* heap, RelocInfo* rinfo) {

ASSERT((RelocInfo::IsJSReturn(rinfo->rmode()) &&

rinfo->IsPatchedReturnSequence()) ||

(RelocInfo::IsDebugBreakSlot(rinfo->rmode()) &&

rinfo->IsPatchedDebugBreakSlotSequence()));

HeapObject* code = Code::GetCodeFromTargetAddress(rinfo->call_address());

- reinterpret_cast<Code*>(code)->heap()->mark_compact_collector()->

- MarkObject(code);

+ heap->mark_compact_collector()->MarkObject(code);

}

// Mark object pointed to by p.

@@ -565,8 +564,8 @@ class StaticMarkingVisitor : public StaticVisitorBase {

// flushed.

static const int kCodeAgeThreshold = 5;

- inline static bool HasSourceCode(SharedFunctionInfo* info) {

- Object* undefined = HEAP->raw_unchecked_undefined_value();

+ inline static bool HasSourceCode(Heap* heap, SharedFunctionInfo* info) {

+ Object* undefined = heap->raw_unchecked_undefined_value();

return (info->script() != undefined) &&

(reinterpret_cast<Script*>(info->script())->source() != undefined);

}

@@ -582,7 +581,7 @@ class StaticMarkingVisitor : public StaticVisitorBase {

function->GetIsolate()->builtins()->builtin(Builtins::kLazyCompile);

}

- inline static bool IsFlushable(JSFunction* function) {

+ inline static bool IsFlushable(Heap* heap, JSFunction* function) {

SharedFunctionInfo* shared_info = function->unchecked_shared();

// Code is either on stack, in compilation cache or referenced

@@ -597,10 +596,10 @@ class StaticMarkingVisitor : public StaticVisitorBase {

return false;

}

- return IsFlushable(shared_info);

+ return IsFlushable(heap, shared_info);

}

- inline static bool IsFlushable(SharedFunctionInfo* shared_info) {

+ inline static bool IsFlushable(Heap* heap, SharedFunctionInfo* shared_info) {

// Code is either on stack, in compilation cache or referenced

// by optimized version of function.

if (shared_info->unchecked_code()->IsMarked()) {

@@ -610,7 +609,7 @@ class StaticMarkingVisitor : public StaticVisitorBase {

// The function must be compiled and have the source code available,

// to be able to recompile it in case we need the function again.

- if (!(shared_info->is_compiled() && HasSourceCode(shared_info))) {

+ if (!(shared_info->is_compiled() && HasSourceCode(heap, shared_info))) {

return false;

}

@@ -642,7 +641,7 @@ class StaticMarkingVisitor : public StaticVisitorBase {

static bool FlushCodeForFunction(Heap* heap, JSFunction* function) {

- if (!IsFlushable(function)) return false;

+ if (!IsFlushable(heap, function)) return false;

// This function's code looks flushable. But we have to postpone the

// decision until we see all functions that point to the same

@@ -719,7 +718,7 @@ class StaticMarkingVisitor : public StaticVisitorBase {

if (shared->IsInobjectSlackTrackingInProgress()) shared->DetachInitialMap();

if (!known_flush_code_candidate) {

- known_flush_code_candidate = IsFlushable(shared);

+ known_flush_code_candidate = IsFlushable(heap, shared);

if (known_flush_code_candidate) {

heap->mark_compact_collector()->code_flusher()->AddCandidate(shared);

}

@@ -869,16 +868,16 @@ class MarkingVisitor : public ObjectVisitor {

StaticMarkingVisitor::VisitPointers(heap_, start, end);

}

- void VisitCodeTarget(RelocInfo* rinfo) {

- StaticMarkingVisitor::VisitCodeTarget(rinfo);

+ void VisitCodeTarget(Heap* heap, RelocInfo* rinfo) {

+ StaticMarkingVisitor::VisitCodeTarget(heap, rinfo);

}

- void VisitGlobalPropertyCell(RelocInfo* rinfo) {

- StaticMarkingVisitor::VisitGlobalPropertyCell(rinfo);

+ void VisitGlobalPropertyCell(Heap* heap, RelocInfo* rinfo) {

+ StaticMarkingVisitor::VisitGlobalPropertyCell(heap, rinfo);

}

- void VisitDebugTarget(RelocInfo* rinfo) {

- StaticMarkingVisitor::VisitDebugTarget(rinfo);

+ void VisitDebugTarget(Heap* heap, RelocInfo* rinfo) {

+ StaticMarkingVisitor::VisitDebugTarget(heap, rinfo);

}

private:

@@ -926,7 +925,7 @@ class SharedFunctionInfoMarkingVisitor : public ObjectVisitor {

void MarkCompactCollector::PrepareForCodeFlushing() {

- ASSERT(heap_ == Isolate::Current()->heap());

+ ASSERT(heap() == Isolate::Current()->heap());

if (!FLAG_flush_code) {

EnableCodeFlushing(false);

@@ -934,8 +933,8 @@ void MarkCompactCollector::PrepareForCodeFlushing() {

}

#ifdef ENABLE_DEBUGGER_SUPPORT

- if (heap_->isolate()->debug()->IsLoaded() ||

- heap_->isolate()->debug()->has_break_points()) {

+ if (heap()->isolate()->debug()->IsLoaded() ||

+ heap()->isolate()->debug()->has_break_points()) {

EnableCodeFlushing(false);

return;

}

@@ -944,10 +943,10 @@ void MarkCompactCollector::PrepareForCodeFlushing() {

// Ensure that empty descriptor array is marked. Method MarkDescriptorArray

// relies on it being marked before any other descriptor array.

- MarkObject(heap_->raw_unchecked_empty_descriptor_array());

+ MarkObject(heap()->raw_unchecked_empty_descriptor_array());

// Make sure we are not referencing the code from the stack.

- ASSERT(this == heap_->mark_compact_collector());

+ ASSERT(this == heap()->mark_compact_collector());

for (StackFrameIterator it; !it.done(); it.Advance()) {

MarkObject(it.frame()->unchecked_code());

}

@@ -955,12 +954,12 @@ void MarkCompactCollector::PrepareForCodeFlushing() {

// Iterate the archived stacks in all threads to check if

// the code is referenced.

CodeMarkingVisitor code_marking_visitor(this);

- heap_->isolate()->thread_manager()->IterateArchivedThreads(

+ heap()->isolate()->thread_manager()->IterateArchivedThreads(

&code_marking_visitor);

SharedFunctionInfoMarkingVisitor visitor(this);

- heap_->isolate()->compilation_cache()->IterateFunctions(&visitor);

- heap_->isolate()->handle_scope_implementer()->Iterate(&visitor);

+ heap()->isolate()->compilation_cache()->IterateFunctions(&visitor);

+ heap()->isolate()->handle_scope_implementer()->Iterate(&visitor);

ProcessMarkingStack();

}

@@ -1008,7 +1007,8 @@ class RootMarkingVisitor : public ObjectVisitor {

// Helper class for pruning the symbol table.

class SymbolTableCleaner : public ObjectVisitor {

public:

- SymbolTableCleaner() : pointers_removed_(0) { }

+ explicit SymbolTableCleaner(Heap* heap)

+ : heap_(heap), pointers_removed_(0) { }

virtual void VisitPointers(Object** start, Object** end) {

// Visit all HeapObject pointers in [start, end).

@@ -1020,10 +1020,10 @@ class SymbolTableCleaner : public ObjectVisitor {

// Since no objects have yet been moved we can safely access the map of

// the object.

if ((*p)->IsExternalString()) {

- HEAP->FinalizeExternalString(String::cast(*p));

+ heap_->FinalizeExternalString(String::cast(*p));

}

// Set the entry to null_value (as deleted).

- *p = HEAP->raw_unchecked_null_value();

+ *p = heap_->raw_unchecked_null_value();

pointers_removed_++;

}

@@ -1033,6 +1033,7 @@ class SymbolTableCleaner : public ObjectVisitor {

return pointers_removed_;

}

private:

+ Heap* heap_;

int pointers_removed_;

};

@@ -1058,7 +1059,7 @@ void MarkCompactCollector::MarkUnmarkedObject(HeapObject* object) {

if (object->IsMap()) {

Map* map = Map::cast(object);

if (FLAG_cleanup_caches_in_maps_at_gc) {

- map->ClearCodeCache(heap_);

+ map->ClearCodeCache(heap());

}

SetMark(map);

if (FLAG_collect_maps &&

@@ -1129,7 +1130,7 @@ void MarkCompactCollector::MarkDescriptorArray(

void MarkCompactCollector::CreateBackPointers() {

- HeapObjectIterator iterator(HEAP->map_space());

+ HeapObjectIterator iterator(heap()->map_space());

for (HeapObject* next_object = iterator.next();

next_object != NULL; next_object = iterator.next()) {

if (next_object->IsMap()) { // Could also be ByteArray on free list.

@@ -1138,7 +1139,7 @@ void MarkCompactCollector::CreateBackPointers() {

map->instance_type() <= JS_FUNCTION_TYPE) {

map->CreateBackPointers();

} else {

- ASSERT(map->instance_descriptors() == HEAP->empty_descriptor_array());

+ ASSERT(map->instance_descriptors() == heap()->empty_descriptor_array());

}

@@ -1186,11 +1187,11 @@ bool MarkCompactCollector::IsUnmarkedHeapObject(Object** p) {

void MarkCompactCollector::MarkSymbolTable() {

- SymbolTable* symbol_table = heap_->raw_unchecked_symbol_table();

+ SymbolTable* symbol_table = heap()->raw_unchecked_symbol_table();

// Mark the symbol table itself.

SetMark(symbol_table);

// Explicitly mark the prefix.

- MarkingVisitor marker(heap_);

+ MarkingVisitor marker(heap());

symbol_table->IteratePrefix(&marker);

ProcessMarkingStack();

}

@@ -1199,7 +1200,7 @@ void MarkCompactCollector::MarkSymbolTable() {

void MarkCompactCollector::MarkRoots(RootMarkingVisitor* visitor) {

// Mark the heap roots including global variables, stack variables,

// etc., and all objects reachable from them.

- HEAP->IterateStrongRoots(visitor, VISIT_ONLY_STRONG);

+ heap()->IterateStrongRoots(visitor, VISIT_ONLY_STRONG);

// Handle the symbol table specially.

MarkSymbolTable();

@@ -1214,7 +1215,7 @@ void MarkCompactCollector::MarkRoots(RootMarkingVisitor* visitor) {

void MarkCompactCollector::MarkObjectGroups() {

List<ObjectGroup*>* object_groups =

- heap_->isolate()->global_handles()->object_groups();

+ heap()->isolate()->global_handles()->object_groups();

for (int i = 0; i < object_groups->length(); i++) {

ObjectGroup* entry = object_groups->at(i);

@@ -1250,7 +1251,7 @@ void MarkCompactCollector::MarkObjectGroups() {

void MarkCompactCollector::MarkImplicitRefGroups() {

List<ImplicitRefGroup*>* ref_groups =

- heap_->isolate()->global_handles()->implicit_ref_groups();

+ heap()->isolate()->global_handles()->implicit_ref_groups();

for (int i = 0; i < ref_groups->length(); i++) {

ImplicitRefGroup* entry = ref_groups->at(i);

@@ -1283,7 +1284,7 @@ void MarkCompactCollector::EmptyMarkingStack() {

while (!marking_stack_.is_empty()) {

HeapObject* object = marking_stack_.Pop();

ASSERT(object->IsHeapObject());

- ASSERT(heap_->Contains(object));

+ ASSERT(heap()->Contains(object));

ASSERT(object->IsMarked());

ASSERT(!object->IsOverflowed());

@@ -1307,32 +1308,32 @@ void MarkCompactCollector::EmptyMarkingStack() {

void MarkCompactCollector::RefillMarkingStack() {

ASSERT(marking_stack_.overflowed());

- SemiSpaceIterator new_it(HEAP->new_space(), &OverflowObjectSize);

+ SemiSpaceIterator new_it(heap()->new_space(), &OverflowObjectSize);

OverflowedObjectsScanner::ScanOverflowedObjects(this, &new_it);