Implement verification of new space evacuation.

src/mark-compact.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 91 matching lines @@
     object = HeapObject::FromAddress(current);
     if (MarkCompactCollector::IsMarked(object)) {
       ASSERT(current >= next_object_must_be_here_or_later);
       object->Iterate(&visitor);
       next_object_must_be_here_or_later = current + object->Size();
     }
   }
 }
 
 
-static void VerifyMarking(Page* p) {
-  VerifyMarking(p->ObjectAreaStart(), p->ObjectAreaEnd());
-}
-
-
 static void VerifyMarking(NewSpace* space) {
   Address end = space->top();
   NewSpacePageIterator it(space->bottom(), end);
   // The bottom position is at the start of its page. Allows us to use
   // page->body() as start of range on all pages.
   ASSERT_EQ(space->bottom(),
             NewSpacePage::FromAddress(space->bottom())->body());
   while (it.has_next()) {
     NewSpacePage* page = it.next();
     Address limit = it.has_next() ? page->body_limit() : end;
     ASSERT(limit == end || !page->Contains(end));
     VerifyMarking(page->body(), limit);
   }
 }
 
 
 static void VerifyMarking(PagedSpace* space) {
   PageIterator it(space);
 
   while (it.has_next()) {
-    VerifyMarking(it.next());
+    Page* p = it.next();
+    VerifyMarking(p->ObjectAreaStart(), p->ObjectAreaEnd());
   }
 }
 
 
 static void VerifyMarking(Heap* heap) {
   VerifyMarking(heap->old_pointer_space());
   VerifyMarking(heap->old_data_space());
   VerifyMarking(heap->code_space());
   VerifyMarking(heap->cell_space());
   VerifyMarking(heap->map_space());
   VerifyMarking(heap->new_space());
 
   VerifyMarkingVisitor visitor;
   heap->IterateStrongRoots(&visitor, VISIT_ONLY_STRONG);
 }
 
 
 class VerifyEvacuationVisitor: public ObjectVisitor {
  public:
   void VisitPointers(Object** start, Object** end) {
     for (Object** current = start; current < end; current++) {
       if ((*current)->IsHeapObject()) {
         HeapObject* object = HeapObject::cast(*current);
-        if (MarkCompactCollector::IsOnEvacuationCandidate(object)) {
-          CHECK(false);
-        }
+        CHECK(!MarkCompactCollector::IsOnEvacuationCandidate(object));
       }
     }
   }
-
-  HeapObject* source_;
 };
 
 
 static void VerifyEvacuation(Address bottom, Address top) {
   VerifyEvacuationVisitor visitor;
   HeapObject* object;
   Address next_object_must_be_here_or_later = bottom;
 
   for (Address current = bottom;
        current < top;
        current += kPointerSize) {
     object = HeapObject::FromAddress(current);
     if (MarkCompactCollector::IsMarked(object)) {
       ASSERT(current >= next_object_must_be_here_or_later);
-      visitor.source_ = object;
       object->Iterate(&visitor);
       next_object_must_be_here_or_later = current + object->Size();
     }
   }
 }
 
 
-static void VerifyEvacuation(Page* p) {
-  if (p->IsEvacuationCandidate()) return;
-
-  VerifyEvacuation(p->ObjectAreaStart(), p->ObjectAreaEnd());
-}
-
-
 static void VerifyEvacuation(NewSpace* space) {
-  // TODO(gc) Verify evacution for new space.
+  NewSpacePageIterator it(space->bottom(), space->top());
+  VerifyEvacuationVisitor visitor;
+
+  while (it.has_next()) {
+    NewSpacePage* page = it.next();
+    Address current = page->body();
+    Address limit = it.has_next() ? page->body_limit() : space->top();
+    ASSERT(limit == space->top() || !page->Contains(space->top()));
+    while (current < limit) {
+      HeapObject* object = HeapObject::FromAddress(current);
+      object->Iterate(&visitor);
+      current += object->Size();
+    }
+  }
 }
 
 
 static void VerifyEvacuation(PagedSpace* space) {
   PageIterator it(space);
 
   while (it.has_next()) {
-    VerifyEvacuation(it.next());
+    Page* p = it.next();
+    if (p->IsEvacuationCandidate()) continue;
+    VerifyEvacuation(p->ObjectAreaStart(), p->ObjectAreaEnd());
   }
 }
 
 
 static void VerifyEvacuation(Heap* heap) {
   VerifyEvacuation(heap->old_pointer_space());
   VerifyEvacuation(heap->old_data_space());
   VerifyEvacuation(heap->code_space());
   VerifyEvacuation(heap->cell_space());
   VerifyEvacuation(heap->map_space());
@@ skipping 3378 matching lines @@
   while (buffer != NULL) {
     SlotsBuffer* next_buffer = buffer->next();
     DeallocateBuffer(buffer);
     buffer = next_buffer;
   }
   *buffer_address = NULL;
 }
 
 
 } }  // namespace v8::internal