src/heap/mark-compact.cc - Issue 437993003: Move a bunch of GC related files to heap/ subdirectory

Unified Diff: src/heap/mark-compact.cc

Issue 437993003: Move a bunch of GC related files to heap/ subdirectory (Closed) Base URL: https://v8.googlecode.com/svn/branches/bleeding_edge

Patch Set: make presubmit happy Created 6 years, 4 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/heap/mark-compact.cc

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

similarity index 87%

rename from src/mark-compact.cc

rename to src/heap/mark-compact.cc

index a2d9f02e0fbeb04f263435af9104a67a354b9f21..100fd24bf0fe5b1caa7659c96894b103e2b1e781 100644

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

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

@@ -12,15 +12,15 @@

#include "src/execution.h"

#include "src/gdb-jit.h"

#include "src/global-handles.h"

+#include "src/heap/incremental-marking.h"

+#include "src/heap/mark-compact.h"

+#include "src/heap/spaces-inl.h"

+#include "src/heap/sweeper-thread.h"

#include "src/heap-profiler.h"

#include "src/ic-inl.h"

-#include "src/incremental-marking.h"

-#include "src/mark-compact.h"

#include "src/objects-visiting.h"

#include "src/objects-visiting-inl.h"

-#include "src/spaces-inl.h"

#include "src/stub-cache.h"

-#include "src/sweeper-thread.h"

namespace v8 {

namespace internal {

@@ -35,7 +35,8 @@ const char* Marking::kImpossibleBitPattern = "01";

// -------------------------------------------------------------------------

// MarkCompactCollector

-MarkCompactCollector::MarkCompactCollector(Heap* heap) : // NOLINT

+MarkCompactCollector::MarkCompactCollector(Heap* heap)

+ : // NOLINT

#ifdef DEBUG

state_(IDLE),

#endif

@@ -51,10 +52,11 @@ MarkCompactCollector::MarkCompactCollector(Heap* heap) : // NOLINT

migration_slots_buffer_(NULL),

heap_(heap),

code_flusher_(NULL),

- have_code_to_deoptimize_(false) { }

+ have_code_to_deoptimize_(false) {

#ifdef VERIFY_HEAP

-class VerifyMarkingVisitor: public ObjectVisitor {

+class VerifyMarkingVisitor : public ObjectVisitor {

public:

explicit VerifyMarkingVisitor(Heap* heap) : heap_(heap) {}

@@ -93,9 +95,7 @@ static void VerifyMarking(Heap* heap, Address bottom, Address top) {

HeapObject* object;

Address next_object_must_be_here_or_later = bottom;

- for (Address current = bottom;

- current < top;

- current += kPointerSize) {

+ for (Address current = bottom; current < top; current += kPointerSize) {

object = HeapObject::FromAddress(current);

if (MarkCompactCollector::IsMarked(object)) {

CHECK(current >= next_object_must_be_here_or_later);

@@ -154,7 +154,7 @@ static void VerifyMarking(Heap* heap) {

}

-class VerifyEvacuationVisitor: public ObjectVisitor {

+class VerifyEvacuationVisitor : public ObjectVisitor {

public:

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

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

@@ -171,7 +171,7 @@ static void VerifyEvacuation(Page* page) {

VerifyEvacuationVisitor visitor;

HeapObjectIterator iterator(page, NULL);

for (HeapObject* heap_object = iterator.Next(); heap_object != NULL;

- heap_object = iterator.Next()) {

+ heap_object = iterator.Next()) {

// We skip free space objects.

if (!heap_object->IsFiller()) {

heap_object->Iterate(&visitor);

@@ -230,7 +230,7 @@ static void VerifyEvacuation(Heap* heap) {

#ifdef DEBUG

-class VerifyNativeContextSeparationVisitor: public ObjectVisitor {

+class VerifyNativeContextSeparationVisitor : public ObjectVisitor {

public:

VerifyNativeContextSeparationVisitor() : current_native_context_(NULL) {}

@@ -269,8 +269,8 @@ class VerifyNativeContextSeparationVisitor: public ObjectVisitor {

// Set array length to zero to prevent cycles while iterating

// over array bodies, this is easier than intrusive marking.

array->set_length(0);

- array->IterateBody(

- FIXED_ARRAY_TYPE, FixedArray::SizeFor(length), this);

+ array->IterateBody(FIXED_ARRAY_TYPE, FixedArray::SizeFor(length),

+ this);

array->set_length(length);

}

break;

@@ -332,9 +332,7 @@ void MarkCompactCollector::SetUp() {

}

-void MarkCompactCollector::TearDown() {

- AbortCompaction();

+void MarkCompactCollector::TearDown() { AbortCompaction(); }

void MarkCompactCollector::AddEvacuationCandidate(Page* p) {

@@ -348,10 +346,8 @@ static void TraceFragmentation(PagedSpace* space) {

intptr_t reserved = (number_of_pages * space->AreaSize());

intptr_t free = reserved - space->SizeOfObjects();

PrintF("[%s]: %d pages, %d (%.1f%%) free\n",

- AllocationSpaceName(space->identity()),

- number_of_pages,

- static_cast<int>(free),

- static_cast<double>(free) * 100 / reserved);

+ AllocationSpaceName(space->identity()), number_of_pages,

+ static_cast<int>(free), static_cast<double>(free) * 100 / reserved);

}

@@ -367,9 +363,8 @@ bool MarkCompactCollector::StartCompaction(CompactionMode mode) {

CollectEvacuationCandidates(heap()->old_pointer_space());

CollectEvacuationCandidates(heap()->old_data_space());

- if (FLAG_compact_code_space &&

- (mode == NON_INCREMENTAL_COMPACTION ||

- FLAG_incremental_code_compaction)) {

+ if (FLAG_compact_code_space && (mode == NON_INCREMENTAL_COMPACTION ||

+ FLAG_incremental_code_compaction)) {

CollectEvacuationCandidates(heap()->code_space());

} else if (FLAG_trace_fragmentation) {

TraceFragmentation(heap()->code_space());

@@ -481,8 +476,7 @@ void MarkCompactCollector::VerifyMarkbitsAreClean() {

void MarkCompactCollector::VerifyWeakEmbeddedObjectsInCode() {

HeapObjectIterator code_iterator(heap()->code_space());

- for (HeapObject* obj = code_iterator.Next();

- obj != NULL;

+ for (HeapObject* obj = code_iterator.Next(); obj != NULL;

obj = code_iterator.Next()) {

Code* code = Code::cast(obj);

if (!code->is_optimized_code() && !code->is_weak_stub()) continue;

@@ -494,9 +488,7 @@ void MarkCompactCollector::VerifyWeakEmbeddedObjectsInCode() {

void MarkCompactCollector::VerifyOmittedMapChecks() {

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

- for (HeapObject* obj = iterator.Next();

- obj != NULL;

- obj = iterator.Next()) {

+ for (HeapObject* obj = iterator.Next(); obj != NULL; obj = iterator.Next()) {

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

map->VerifyOmittedMapChecks();

}

@@ -544,8 +536,7 @@ void MarkCompactCollector::ClearMarkbits() {

class MarkCompactCollector::SweeperTask : public v8::Task {

public:

- SweeperTask(Heap* heap, PagedSpace* space)

- : heap_(heap), space_(space) {}

+ SweeperTask(Heap* heap, PagedSpace* space) : heap_(heap), space_(space) {}

virtual ~SweeperTask() {}

@@ -700,15 +691,22 @@ void Marking::TransferMark(Address old_start, Address new_start) {

const char* AllocationSpaceName(AllocationSpace space) {

switch (space) {

- case NEW_SPACE: return "NEW_SPACE";

- case OLD_POINTER_SPACE: return "OLD_POINTER_SPACE";

- case OLD_DATA_SPACE: return "OLD_DATA_SPACE";

- case CODE_SPACE: return "CODE_SPACE";

- case MAP_SPACE: return "MAP_SPACE";

- case CELL_SPACE: return "CELL_SPACE";

+ case NEW_SPACE:

+ return "NEW_SPACE";

+ case OLD_POINTER_SPACE:

+ return "OLD_POINTER_SPACE";

+ case OLD_DATA_SPACE:

+ return "OLD_DATA_SPACE";

+ case CODE_SPACE:

+ return "CODE_SPACE";

+ case MAP_SPACE:

+ return "MAP_SPACE";

+ case CELL_SPACE:

+ return "CELL_SPACE";

case PROPERTY_CELL_SPACE:

return "PROPERTY_CELL_SPACE";

- case LO_SPACE: return "LO_SPACE";

+ case LO_SPACE:

+ return "LO_SPACE";

default:

UNREACHABLE();

}

@@ -724,10 +722,8 @@ static int FreeListFragmentation(PagedSpace* space, Page* p) {

// If page was not swept then there are no free list items on it.

if (!p->WasSwept()) {

if (FLAG_trace_fragmentation) {

- PrintF("%p [%s]: %d bytes live (unswept)\n",

- reinterpret_cast<void*>(p),

- AllocationSpaceName(space->identity()),

- p->LiveBytes());

+ PrintF("%p [%s]: %d bytes live (unswept)\n", reinterpret_cast<void*>(p),

+ AllocationSpaceName(space->identity()), p->LiveBytes());

}

return 0;

}

@@ -739,31 +735,24 @@ static int FreeListFragmentation(PagedSpace* space, Page* p) {

intptr_t ratio_threshold;

intptr_t area_size = space->AreaSize();

if (space->identity() == CODE_SPACE) {

- ratio = (sizes.medium_size_ * 10 + sizes.large_size_ * 2) * 100 /

- area_size;

+ ratio = (sizes.medium_size_ * 10 + sizes.large_size_ * 2) * 100 / area_size;

ratio_threshold = 10;

} else {

- ratio = (sizes.small_size_ * 5 + sizes.medium_size_) * 100 /

- area_size;

+ ratio = (sizes.small_size_ * 5 + sizes.medium_size_) * 100 / area_size;

ratio_threshold = 15;

}

if (FLAG_trace_fragmentation) {

PrintF("%p [%s]: %d (%.2f%%) %d (%.2f%%) %d (%.2f%%) %d (%.2f%%) %s\n",

- reinterpret_cast<void*>(p),

- AllocationSpaceName(space->identity()),

+ reinterpret_cast<void*>(p), AllocationSpaceName(space->identity()),

static_cast<int>(sizes.small_size_),

- static_cast<double>(sizes.small_size_ * 100) /

- area_size,

+ static_cast<double>(sizes.small_size_ * 100) / area_size,

static_cast<int>(sizes.medium_size_),

- static_cast<double>(sizes.medium_size_ * 100) /

- area_size,

+ static_cast<double>(sizes.medium_size_ * 100) / area_size,

static_cast<int>(sizes.large_size_),

- static_cast<double>(sizes.large_size_ * 100) /

- area_size,

+ static_cast<double>(sizes.large_size_ * 100) / area_size,

static_cast<int>(sizes.huge_size_),

- static_cast<double>(sizes.huge_size_ * 100) /

- area_size,

+ static_cast<double>(sizes.huge_size_ * 100) / area_size,

(ratio > ratio_threshold) ? "[fragmented]" : "");

}

@@ -793,8 +782,8 @@ void MarkCompactCollector::CollectEvacuationCandidates(PagedSpace* space) {

class Candidate {

public:

- Candidate() : fragmentation_(0), page_(NULL) { }

- Candidate(int f, Page* p) : fragmentation_(f), page_(p) { }

+ Candidate() : fragmentation_(0), page_(NULL) {}

+ Candidate(int f, Page* p) : fragmentation_(f), page_(p) {}

int fragmentation() { return fragmentation_; }

Page* page() { return page_; }

@@ -804,10 +793,7 @@ void MarkCompactCollector::CollectEvacuationCandidates(PagedSpace* space) {

Page* page_;

};

- enum CompactionMode {

- COMPACT_FREE_LISTS,

- REDUCE_MEMORY_FOOTPRINT

- };

+ enum CompactionMode { COMPACT_FREE_LISTS, REDUCE_MEMORY_FOOTPRINT };

CompactionMode mode = COMPACT_FREE_LISTS;

@@ -833,12 +819,12 @@ void MarkCompactCollector::CollectEvacuationCandidates(PagedSpace* space) {

}

if (FLAG_trace_fragmentation && mode == REDUCE_MEMORY_FOOTPRINT) {

- PrintF("Estimated over reserved memory: %.1f / %.1f MB (threshold %d), "

- "evacuation candidate limit: %d\n",

- static_cast<double>(over_reserved) / MB,

- static_cast<double>(reserved) / MB,

- static_cast<int>(kFreenessThreshold),

- max_evacuation_candidates);

+ PrintF(

+ "Estimated over reserved memory: %.1f / %.1f MB (threshold %d), "

+ "evacuation candidate limit: %d\n",

+ static_cast<double>(over_reserved) / MB,

+ static_cast<double>(reserved) / MB,

+ static_cast<int>(kFreenessThreshold), max_evacuation_candidates);

}

intptr_t estimated_release = 0;

@@ -889,8 +875,7 @@ void MarkCompactCollector::CollectEvacuationCandidates(PagedSpace* space) {

}

if (FLAG_trace_fragmentation) {

- PrintF("%p [%s]: %d (%.2f%%) free %s\n",

- reinterpret_cast<void*>(p),

+ PrintF("%p [%s]: %d (%.2f%%) free %s\n", reinterpret_cast<void*>(p),

AllocationSpaceName(space->identity()),

static_cast<int>(free_bytes),

static_cast<double>(free_bytes * 100) / p->area_size(),

@@ -925,8 +910,7 @@ void MarkCompactCollector::CollectEvacuationCandidates(PagedSpace* space) {

}

if (count > 0 && FLAG_trace_fragmentation) {

- PrintF("Collected %d evacuation candidates for space %s\n",

- count,

+ PrintF("Collected %d evacuation candidates for space %s\n", count,

AllocationSpaceName(space->identity()));

}

@@ -979,8 +963,7 @@ void MarkCompactCollector::Prepare() {

}

PagedSpaces spaces(heap());

- for (PagedSpace* space = spaces.next();

- space != NULL;

+ for (PagedSpace* space = spaces.next(); space != NULL;

space = spaces.next()) {

space->PrepareForMarkCompact();

}

@@ -1071,13 +1054,13 @@ void CodeFlusher::ProcessJSFunctionCandidates() {

// setter did not record the slot update and we have to do that manually.

Address slot = candidate->address() + JSFunction::kCodeEntryOffset;

Code* target = Code::cast(Code::GetObjectFromEntryAddress(slot));

- isolate_->heap()->mark_compact_collector()->

- RecordCodeEntrySlot(slot, target);

+ isolate_->heap()->mark_compact_collector()->RecordCodeEntrySlot(slot,

+ target);

Object** shared_code_slot =

HeapObject::RawField(shared, SharedFunctionInfo::kCodeOffset);

- isolate_->heap()->mark_compact_collector()->

- RecordSlot(shared_code_slot, shared_code_slot, *shared_code_slot);

+ isolate_->heap()->mark_compact_collector()->RecordSlot(

+ shared_code_slot, shared_code_slot, *shared_code_slot);

candidate = next_candidate;

}

@@ -1109,8 +1092,8 @@ void CodeFlusher::ProcessSharedFunctionInfoCandidates() {

Object** code_slot =

HeapObject::RawField(candidate, SharedFunctionInfo::kCodeOffset);

- isolate_->heap()->mark_compact_collector()->

- RecordSlot(code_slot, code_slot, *code_slot);

+ isolate_->heap()->mark_compact_collector()->RecordSlot(code_slot, code_slot,

+ *code_slot);

candidate = next_candidate;

}

@@ -1132,8 +1115,7 @@ void CodeFlusher::ProcessOptimizedCodeMaps() {

FixedArray* code_map = FixedArray::cast(holder->optimized_code_map());

int new_length = SharedFunctionInfo::kEntriesStart;

int old_length = code_map->length();

- for (int i = SharedFunctionInfo::kEntriesStart;

- i < old_length;

+ for (int i = SharedFunctionInfo::kEntriesStart; i < old_length;

i += SharedFunctionInfo::kEntryLength) {

Code* code =

Code::cast(code_map->get(i + SharedFunctionInfo::kCachedCodeOffset));

@@ -1148,10 +1130,10 @@ void CodeFlusher::ProcessOptimizedCodeMaps() {

if (j == SharedFunctionInfo::kOsrAstIdOffset) {

DCHECK(object->IsSmi());

} else {

- DCHECK(Marking::IsBlack(

- Marking::MarkBitFrom(HeapObject::cast(*slot))));

- isolate_->heap()->mark_compact_collector()->

- RecordSlot(slot, slot, *slot);

+ DCHECK(

+ Marking::IsBlack(Marking::MarkBitFrom(HeapObject::cast(*slot))));

+ isolate_->heap()->mark_compact_collector()->RecordSlot(slot, slot,

+ *slot);

}

@@ -1239,8 +1221,9 @@ void CodeFlusher::EvictCandidate(JSFunction* function) {

void CodeFlusher::EvictOptimizedCodeMap(SharedFunctionInfo* code_map_holder) {

- DCHECK(!FixedArray::cast(code_map_holder->optimized_code_map())->

- get(SharedFunctionInfo::kNextMapIndex)->IsUndefined());

+ DCHECK(!FixedArray::cast(code_map_holder->optimized_code_map())

+ ->get(SharedFunctionInfo::kNextMapIndex)

+ ->IsUndefined());

// Make sure previous flushing decisions are revisited.

isolate_->heap()->incremental_marking()->RecordWrites(code_map_holder);

@@ -1372,15 +1355,14 @@ static inline HeapObject* ShortCircuitConsString(Object** p) {

class MarkCompactMarkingVisitor

: public StaticMarkingVisitor<MarkCompactMarkingVisitor> {

public:

- static void ObjectStatsVisitBase(StaticVisitorBase::VisitorId id,

- Map* map, HeapObject* obj);

+ static void ObjectStatsVisitBase(StaticVisitorBase::VisitorId id, Map* map,

+ HeapObject* obj);

static void ObjectStatsCountFixedArray(

- FixedArrayBase* fixed_array,

- FixedArraySubInstanceType fast_type,

+ FixedArrayBase* fixed_array, FixedArraySubInstanceType fast_type,

FixedArraySubInstanceType dictionary_type);

- template<MarkCompactMarkingVisitor::VisitorId id>

+ template <MarkCompactMarkingVisitor::VisitorId id>

class ObjectStatsTracker {

public:

static inline void Visit(Map* map, HeapObject* obj);

@@ -1424,8 +1406,7 @@ class MarkCompactMarkingVisitor

// Mark object pointed to by p.

INLINE(static void MarkObjectByPointer(MarkCompactCollector* collector,

- Object** anchor_slot,

- Object** p)) {

+ Object** anchor_slot, Object** p)) {

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

HeapObject* object = ShortCircuitConsString(p);

collector->RecordSlot(anchor_slot, p, object);

@@ -1453,8 +1434,7 @@ class MarkCompactMarkingVisitor

// Visit all unmarked objects pointed to by [start, end).

// Returns false if the operation fails (lack of stack space).

- INLINE(static bool VisitUnmarkedObjects(Heap* heap,

- Object** start,

+ INLINE(static bool VisitUnmarkedObjects(Heap* heap, Object** start,

Object** end)) {

// Return false is we are close to the stack limit.

StackLimitCheck check(heap->isolate());

@@ -1475,20 +1455,20 @@ class MarkCompactMarkingVisitor

}

private:

- template<int id>

+ template <int id>

static inline void TrackObjectStatsAndVisit(Map* map, HeapObject* obj);

// Code flushing support.

static const int kRegExpCodeThreshold = 5;

- static void UpdateRegExpCodeAgeAndFlush(Heap* heap,

- JSRegExp* re,

+ static void UpdateRegExpCodeAgeAndFlush(Heap* heap, JSRegExp* re,

bool is_ascii) {

// Make sure that the fixed array is in fact initialized on the RegExp.

// We could potentially trigger a GC when initializing the RegExp.

if (HeapObject::cast(re->data())->map()->instance_type() !=

- FIXED_ARRAY_TYPE) return;

+ FIXED_ARRAY_TYPE)

+ return;

// Make sure this is a RegExp that actually contains code.

if (re->TypeTag() != JSRegExp::IRREGEXP) return;

@@ -1505,8 +1485,7 @@ class MarkCompactMarkingVisitor

// object.

FixedArray* data = FixedArray::cast(re->data());

Object** slot = data->data_start() + JSRegExp::saved_code_index(is_ascii);

- heap->mark_compact_collector()->

- RecordSlot(slot, slot, code);

+ heap->mark_compact_collector()->RecordSlot(slot, slot, code);

// Set a number in the 0-255 range to guarantee no smi overflow.

re->SetDataAt(JSRegExp::code_index(is_ascii),

@@ -1555,19 +1534,16 @@ class MarkCompactMarkingVisitor

void MarkCompactMarkingVisitor::ObjectStatsCountFixedArray(

- FixedArrayBase* fixed_array,

- FixedArraySubInstanceType fast_type,

+ FixedArrayBase* fixed_array, FixedArraySubInstanceType fast_type,

FixedArraySubInstanceType dictionary_type) {

Heap* heap = fixed_array->map()->GetHeap();

if (fixed_array->map() != heap->fixed_cow_array_map() &&

fixed_array->map() != heap->fixed_double_array_map() &&

fixed_array != heap->empty_fixed_array()) {

if (fixed_array->IsDictionary()) {

- heap->RecordFixedArraySubTypeStats(dictionary_type,

- fixed_array->Size());

+ heap->RecordFixedArraySubTypeStats(dictionary_type, fixed_array->Size());

} else {

- heap->RecordFixedArraySubTypeStats(fast_type,

- fixed_array->Size());

+ heap->RecordFixedArraySubTypeStats(fast_type, fixed_array->Size());

}

@@ -1581,8 +1557,7 @@ void MarkCompactMarkingVisitor::ObjectStatsVisitBase(

non_count_table_.GetVisitorById(id)(map, obj);

if (obj->IsJSObject()) {

JSObject* object = JSObject::cast(obj);

- ObjectStatsCountFixedArray(object->elements(),

- DICTIONARY_ELEMENTS_SUB_TYPE,

+ ObjectStatsCountFixedArray(object->elements(), DICTIONARY_ELEMENTS_SUB_TYPE,

FAST_ELEMENTS_SUB_TYPE);

ObjectStatsCountFixedArray(object->properties(),

DICTIONARY_PROPERTIES_SUB_TYPE,

@@ -1591,14 +1566,14 @@ void MarkCompactMarkingVisitor::ObjectStatsVisitBase(

}

-template<MarkCompactMarkingVisitor::VisitorId id>

-void MarkCompactMarkingVisitor::ObjectStatsTracker<id>::Visit(

- Map* map, HeapObject* obj) {

+template <MarkCompactMarkingVisitor::VisitorId id>

+void MarkCompactMarkingVisitor::ObjectStatsTracker<id>::Visit(Map* map,

+ HeapObject* obj) {

ObjectStatsVisitBase(id, map, obj);

}

-template<>

+template <>

class MarkCompactMarkingVisitor::ObjectStatsTracker<

MarkCompactMarkingVisitor::kVisitMap> {

public:

@@ -1633,7 +1608,7 @@ class MarkCompactMarkingVisitor::ObjectStatsTracker<

};

-template<>

+template <>

class MarkCompactMarkingVisitor::ObjectStatsTracker<

MarkCompactMarkingVisitor::kVisitCode> {

public:

@@ -1649,7 +1624,7 @@ class MarkCompactMarkingVisitor::ObjectStatsTracker<

};

-template<>

+template <>

class MarkCompactMarkingVisitor::ObjectStatsTracker<

MarkCompactMarkingVisitor::kVisitSharedFunctionInfo> {

public:

@@ -1658,15 +1633,14 @@ class MarkCompactMarkingVisitor::ObjectStatsTracker<

SharedFunctionInfo* sfi = SharedFunctionInfo::cast(obj);

if (sfi->scope_info() != heap->empty_fixed_array()) {

heap->RecordFixedArraySubTypeStats(

- SCOPE_INFO_SUB_TYPE,

- FixedArray::cast(sfi->scope_info())->Size());

+ SCOPE_INFO_SUB_TYPE, FixedArray::cast(sfi->scope_info())->Size());

}

ObjectStatsVisitBase(kVisitSharedFunctionInfo, map, obj);

}

};

-template<>

+template <>

class MarkCompactMarkingVisitor::ObjectStatsTracker<

MarkCompactMarkingVisitor::kVisitFixedArray> {

public:

@@ -1674,9 +1648,8 @@ class MarkCompactMarkingVisitor::ObjectStatsTracker<

Heap* heap = map->GetHeap();

FixedArray* fixed_array = FixedArray::cast(obj);

if (fixed_array == heap->string_table()) {

- heap->RecordFixedArraySubTypeStats(

- STRING_TABLE_SUB_TYPE,

- fixed_array->Size());

+ heap->RecordFixedArraySubTypeStats(STRING_TABLE_SUB_TYPE,

+ fixed_array->Size());

}

ObjectStatsVisitBase(kVisitFixedArray, map, obj);

}

@@ -1686,14 +1659,13 @@ class MarkCompactMarkingVisitor::ObjectStatsTracker<

void MarkCompactMarkingVisitor::Initialize() {

StaticMarkingVisitor<MarkCompactMarkingVisitor>::Initialize();

- table_.Register(kVisitJSRegExp,

- &VisitRegExpAndFlushCode);

+ table_.Register(kVisitJSRegExp, &VisitRegExpAndFlushCode);

if (FLAG_track_gc_object_stats) {

// Copy the visitor table to make call-through possible.

non_count_table_.CopyFrom(&table_);

-#define VISITOR_ID_COUNT_FUNCTION(id) \

- table_.Register(kVisit##id, ObjectStatsTracker<kVisit##id>::Visit);

+#define VISITOR_ID_COUNT_FUNCTION(id) \

+ table_.Register(kVisit##id, ObjectStatsTracker<kVisit##id>::Visit);

VISITOR_ID_LIST(VISITOR_ID_COUNT_FUNCTION)

#undef VISITOR_ID_COUNT_FUNCTION

}

@@ -1800,11 +1772,9 @@ void MarkCompactCollector::PrepareForCodeFlushing() {

class RootMarkingVisitor : public ObjectVisitor {

public:

explicit RootMarkingVisitor(Heap* heap)

- : collector_(heap->mark_compact_collector()) { }

+ : collector_(heap->mark_compact_collector()) {}

- void VisitPointer(Object** p) {

- MarkObjectByPointer(p);

- }

+ void VisitPointer(Object** p) { MarkObjectByPointer(p); }

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

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

@@ -1812,7 +1782,7 @@ class RootMarkingVisitor : public ObjectVisitor {

// Skip the weak next code link in a code object, which is visited in

// ProcessTopOptimizedFrame.

- void VisitNextCodeLink(Object** p) { }

+ void VisitNextCodeLink(Object** p) {}

private:

void MarkObjectByPointer(Object** p) {

@@ -1842,11 +1812,10 @@ class RootMarkingVisitor : public ObjectVisitor {

// Helper class for pruning the string table.

-template<bool finalize_external_strings>

+template <bool finalize_external_strings>

class StringTableCleaner : public ObjectVisitor {

public:

- explicit StringTableCleaner(Heap* heap)

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

+ explicit StringTableCleaner(Heap* heap) : heap_(heap), pointers_removed_(0) {}

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

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

@@ -1906,7 +1875,7 @@ class MarkCompactWeakObjectRetainer : public WeakObjectRetainer {

// Fill the marking stack with overflowed objects returned by the given

// iterator. Stop when the marking stack is filled or the end of the space

// is reached, whichever comes first.

-template<class T>

+template <class T>

static void DiscoverGreyObjectsWithIterator(Heap* heap,

MarkingDeque* marking_deque,

T* it) {

@@ -1915,9 +1884,7 @@ static void DiscoverGreyObjectsWithIterator(Heap* heap,

DCHECK(!marking_deque->IsFull());

Map* filler_map = heap->one_pointer_filler_map();

- for (HeapObject* object = it->Next();

- object != NULL;

- object = it->Next()) {

+ for (HeapObject* object = it->Next(); object != NULL; object = it->Next()) {

MarkBit markbit = Marking::MarkBitFrom(object);

if ((object->map() != filler_map) && Marking::IsGrey(markbit)) {

Marking::GreyToBlack(markbit);

@@ -1949,9 +1916,9 @@ static void DiscoverGreyObjectsOnPage(MarkingDeque* marking_deque,

MarkBit::CellType grey_objects;

if (it.HasNext()) {

- const MarkBit::CellType next_cell = *(cell+1);

- grey_objects = current_cell &

- ((current_cell >> 1) | (next_cell << (Bitmap::kBitsPerCell - 1)));

+ const MarkBit::CellType next_cell = *(cell + 1);

+ grey_objects = current_cell & ((current_cell >> 1) |

+ (next_cell << (Bitmap::kBitsPerCell - 1)));

} else {

grey_objects = current_cell & (current_cell >> 1);

}

@@ -1979,8 +1946,7 @@ static void DiscoverGreyObjectsOnPage(MarkingDeque* marking_deque,

int MarkCompactCollector::DiscoverAndEvacuateBlackObjectsOnPage(

- NewSpace* new_space,

- NewSpacePage* p) {

+ NewSpace* new_space, NewSpacePage* p) {

DCHECK(strcmp(Marking::kWhiteBitPattern, "00") == 0);

DCHECK(strcmp(Marking::kBlackBitPattern, "10") == 0);

DCHECK(strcmp(Marking::kGreyBitPattern, "11") == 0);

@@ -2031,10 +1997,7 @@ int MarkCompactCollector::DiscoverAndEvacuateBlackObjectsOnPage(

}

Object* target = allocation.ToObjectChecked();

- MigrateObject(HeapObject::cast(target),

- object,

- size,

- NEW_SPACE);

+ MigrateObject(HeapObject::cast(target), object, size, NEW_SPACE);

heap()->IncrementSemiSpaceCopiedObjectSize(size);

}

*cells = 0;

@@ -2043,8 +2006,7 @@ int MarkCompactCollector::DiscoverAndEvacuateBlackObjectsOnPage(

}

-static void DiscoverGreyObjectsInSpace(Heap* heap,

- MarkingDeque* marking_deque,

+static void DiscoverGreyObjectsInSpace(Heap* heap, MarkingDeque* marking_deque,

PagedSpace* space) {

if (space->swept_precisely()) {

HeapObjectIterator it(space);

@@ -2202,40 +2164,28 @@ void MarkCompactCollector::RefillMarkingDeque() {

DiscoverGreyObjectsInNewSpace(heap(), &marking_deque_);