Provide baseline for new GC infrastructure.

src/heap.cc

 // Copyright 2010 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 208 matching lines @@
   ASSERT(!Heap::InNewSpace(object));  // Code only works for old objects.
   ASSERT(!MarkCompactCollector::are_map_pointers_encoded());
   MapWord map_word = object->map_word();
   map_word.ClearMark();
   map_word.ClearOverflow();
   return object->SizeFromMap(map_word.ToMap());
 }
 
 
 int Heap::GcSafeSizeOfOldObjectWithEncodedMap(HeapObject* object) {
+  ASSERT(!FLAG_new_gc);  // Should not be used in new GC.
   ASSERT(!Heap::InNewSpace(object));  // Code only works for old objects.
   ASSERT(MarkCompactCollector::are_map_pointers_encoded());
   uint32_t marker = Memory::uint32_at(object->address());
   if (marker == MarkCompactCollector::kSingleFreeEncoding) {
     return kIntSize;
   } else if (marker == MarkCompactCollector::kMultiFreeEncoding) {
     return Memory::int_at(object->address() + kIntSize);
   } else {
     MapWord map_word = object->map_word();
     Address map_address = map_word.DecodeMapAddress(Heap::map_space());
@@ skipping 3738 matching lines @@
 
 
 void Heap::Verify() {
   ASSERT(HasBeenSetup());
 
   VerifyPointersVisitor visitor;
   IterateRoots(&visitor, VISIT_ONLY_STRONG);
 
   new_space_.Verify();
 
-  VerifyPointersAndDirtyRegionsVisitor dirty_regions_visitor;
-  old_pointer_space_->Verify(&dirty_regions_visitor);
-  map_space_->Verify(&dirty_regions_visitor);
+  if (!FLAG_new_gc) {
+    VerifyPointersAndDirtyRegionsVisitor dirty_regions_visitor;
+    old_pointer_space_->Verify(&dirty_regions_visitor);
+    map_space_->Verify(&dirty_regions_visitor);
+  } else {
+    old_pointer_space_->Verify(&visitor);
+    map_space_->Verify(&visitor);
+  }
 
   VerifyPointersUnderWatermark(old_pointer_space_,
                                &IteratePointersInDirtyRegion);
   VerifyPointersUnderWatermark(map_space_,
                                &IteratePointersInDirtyMapsRegion);
   VerifyPointersUnderWatermark(lo_space_);
 
   VerifyPageWatermarkValidity(old_pointer_space_, ALL_INVALID);
   VerifyPageWatermarkValidity(map_space_, ALL_INVALID);
 
@@ skipping 200 matching lines @@
   page->SetRegionMarks(marks);
 }
 
 
 uint32_t Heap::IterateDirtyRegions(
     uint32_t marks,
     Address area_start,
     Address area_end,
     DirtyRegionCallback visit_dirty_region,
     ObjectSlotCallback copy_object_func) {
+  if (FLAG_new_gc) {
+    visit_dirty_region(area_start, area_end, copy_object_func);
+    return Page::kAllRegionsDirtyMarks;
+  }
+
   uint32_t newmarks = 0;
   uint32_t mask = 1;
 
   if (area_start >= area_end) {
     return newmarks;
   }
 
   Address region_start = area_start;
 
   // area_start does not necessarily coincide with start of the first region.
@@ skipping 1218 matching lines @@
 void ExternalStringTable::TearDown() {
   new_space_strings_.Free();
   old_space_strings_.Free();
 }
 
 
 List<Object*> ExternalStringTable::new_space_strings_;
 List<Object*> ExternalStringTable::old_space_strings_;
 
 } }  // namespace v8::internal