src/mark-compact.cc - Issue 6794050: Revert "[Arguments] Merge (7442,7496] from bleeding_edge."

Unified Diff: src/mark-compact.cc

Issue 6794050: Revert "[Arguments] Merge (7442,7496] from bleeding_edge." (Closed) Base URL: https://v8.googlecode.com/svn/branches/experimental/arguments

Patch Set: 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 3770bc3b35572a3b33e3cb7b82b5ad4d83276bb9..38f9239b781984780c1f67e8141411fb2e2f41f9 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(Heap* heap, RelocInfo* rinfo) {

+ static inline void VisitCodeTarget(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,50 +464,48 @@ 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 {

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

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

}

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

+ static void VisitGlobalPropertyCell(RelocInfo* rinfo) {

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

Object* cell = rinfo->target_cell();

Object* old_cell = cell;

- VisitPointer(heap, &cell);

+ VisitPointer(HEAP, &cell);

if (cell != old_cell) {

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

}

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

+ static inline void VisitDebugTarget(RelocInfo* rinfo) {

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

rinfo->IsPatchedReturnSequence()) ||

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

rinfo->IsPatchedDebugBreakSlotSequence()));

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

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

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

}

// Mark object pointed to by p.

INLINE(static void MarkObjectByPointer(Heap* heap, Object** p)) {

if (!(*p)->IsHeapObject()) return;

HeapObject* object = ShortCircuitConsString(p);

- if (!object->IsMarked()) {

- heap->mark_compact_collector()->MarkUnmarkedObject(object);

- }

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

}

// Visit an unmarked object.

- INLINE(static void VisitUnmarkedObject(MarkCompactCollector* collector,

- HeapObject* obj)) {

+ static inline void VisitUnmarkedObject(HeapObject* obj) {

#ifdef DEBUG

- ASSERT(Isolate::Current()->heap()->Contains(obj));

+ ASSERT(HEAP->Contains(obj));

ASSERT(!obj->IsMarked());

#endif

Map* map = obj->map();

+ MarkCompactCollector* collector = map->heap()->mark_compact_collector();

collector->SetMark(obj);

// Mark the map pointer and the body.

- if (!map->IsMarked()) collector->MarkUnmarkedObject(map);

+ collector->MarkObject(map);

IterateBody(map, obj);

}

@@ -520,13 +518,12 @@ class StaticMarkingVisitor : public StaticVisitorBase {

StackLimitCheck check(heap->isolate());

if (check.HasOverflowed()) return false;

- MarkCompactCollector* collector = heap->mark_compact_collector();

// Visit the unmarked objects.

for (Object** p = start; p < end; p++) {

if (!(*p)->IsHeapObject()) continue;

HeapObject* obj = HeapObject::cast(*p);

if (obj->IsMarked()) continue;

- VisitUnmarkedObject(collector, obj);

+ VisitUnmarkedObject(obj);

}

return true;

}

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

// flushed.

static const int kCodeAgeThreshold = 5;

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

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

+ inline static bool HasSourceCode(SharedFunctionInfo* info) {

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

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

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

}

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

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

}

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

+ inline static bool IsFlushable(JSFunction* function) {

SharedFunctionInfo* shared_info = function->unchecked_shared();

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

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

return false;

}

- return IsFlushable(heap, shared_info);

+ return IsFlushable(shared_info);

}

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

+ inline static bool IsFlushable(SharedFunctionInfo* shared_info) {

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

// by optimized version of function.

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

@@ -609,7 +606,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(heap, shared_info))) {

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

return false;

}

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

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

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

+ if (!IsFlushable(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

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

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

if (!known_flush_code_candidate) {

- known_flush_code_candidate = IsFlushable(heap, shared);

+ known_flush_code_candidate = IsFlushable(shared);

if (known_flush_code_candidate) {

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

}

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

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

}

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

- StaticMarkingVisitor::VisitCodeTarget(heap, rinfo);

+ void VisitCodeTarget(RelocInfo* rinfo) {

+ StaticMarkingVisitor::VisitCodeTarget(rinfo);

}

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

- StaticMarkingVisitor::VisitGlobalPropertyCell(heap, rinfo);

+ void VisitGlobalPropertyCell(RelocInfo* rinfo) {

+ StaticMarkingVisitor::VisitGlobalPropertyCell(rinfo);

}

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

- StaticMarkingVisitor::VisitDebugTarget(heap, rinfo);

+ void VisitDebugTarget(RelocInfo* rinfo) {

+ StaticMarkingVisitor::VisitDebugTarget(rinfo);

}

private:

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

void MarkCompactCollector::PrepareForCodeFlushing() {

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

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

if (!FLAG_flush_code) {

EnableCodeFlushing(false);

@@ -933,8 +930,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;

}

@@ -943,10 +940,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());

}

@@ -954,12 +951,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();

}

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

// Helper class for pruning the symbol table.

class SymbolTableCleaner : public ObjectVisitor {

public:

- explicit SymbolTableCleaner(Heap* heap)

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

+ SymbolTableCleaner() : pointers_removed_(0) { }

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

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

@@ -1020,10 +1016,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,7 +1029,6 @@ class SymbolTableCleaner : public ObjectVisitor {

return pointers_removed_;

}

private:

- Heap* heap_;

int pointers_removed_;

};

@@ -1059,7 +1054,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 &&

@@ -1130,7 +1125,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.

@@ -1139,7 +1134,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());

}

@@ -1187,11 +1182,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();

}

@@ -1200,7 +1195,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();

@@ -1215,7 +1210,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);

@@ -1251,7 +1246,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);

@@ -1284,7 +1279,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());

@@ -1308,32 +1303,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);