Provide baseline GC version.

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 206 matching lines @@
 
 int Heap::GcSafeSizeOfOldObject(HeapObject* object) {
   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());
 }
 
-
+#ifndef BASELINE_GC
 int Heap::GcSafeSizeOfOldObjectWithEncodedMap(HeapObject* object) {
   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());
     Map* map = reinterpret_cast<Map*>(HeapObject::FromAddress(map_address));
     return object->SizeFromMap(map);
   }
 }
+#endif
 
 
 GarbageCollector Heap::SelectGarbageCollector(AllocationSpace space) {
   // Is global GC requested?
   if (space != NEW_SPACE || FLAG_gc_global) {
     Counters::gc_compactor_caused_by_request.Increment();
     return MARK_COMPACTOR;
   }
 
   // Is enough data promoted to justify a global GC?
@@ skipping 3724 matching lines @@
 
 
 void Heap::Verify() {
   ASSERT(HasBeenSetup());
 
   VerifyPointersVisitor visitor;
   IterateRoots(&visitor, VISIT_ONLY_STRONG);
 
   new_space_.Verify();
 
+#ifndef BASELINE_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);
+#endif
 
   VerifyPointersUnderWatermark(old_pointer_space_,
                                &IteratePointersInDirtyRegion);
   VerifyPointersUnderWatermark(map_space_,
                                &IteratePointersInDirtyMapsRegion);
   VerifyPointersUnderWatermark(lo_space_);
 
   VerifyPageWatermarkValidity(old_pointer_space_, ALL_INVALID);
   VerifyPageWatermarkValidity(map_space_, ALL_INVALID);
 
@@ skipping 175 matching lines @@
   return contains_pointers_to_new_space;
 }
 
 
 void Heap::IterateAndMarkPointersToFromSpace(Address start,
                                              Address end,
                                              ObjectSlotCallback callback) {
   Address slot_address = start;
   Page* page = Page::FromAddress(start);
 
+#ifndef BASELINE_GC
   uint32_t marks = page->GetRegionMarks();
+#else
+  uint32_t marks = 0;
+#endif
 
   while (slot_address < end) {
     Object** slot = reinterpret_cast<Object**>(slot_address);
     if (Heap::InFromSpace(*slot)) {
       ASSERT((*slot)->IsHeapObject());
       callback(reinterpret_cast<HeapObject**>(slot));
       if (Heap::InNewSpace(*slot)) {
         ASSERT((*slot)->IsHeapObject());
         marks |= page->GetRegionMaskForAddress(slot_address);
       }
     }
     slot_address += kPointerSize;
   }
 
+#ifndef BASELINE_GC
   page->SetRegionMarks(marks);
+#endif
 }
 
 
 uint32_t Heap::IterateDirtyRegions(
     uint32_t marks,
     Address area_start,
     Address area_end,
     DirtyRegionCallback visit_dirty_region,
     ObjectSlotCallback copy_object_func) {
+#ifndef BASELINE_GC
   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 36 matching lines @@
     // with region end. Check whether region covering last part of area is
     // dirty.
     if (marks & mask) {
       if (visit_dirty_region(region_start, area_end, copy_object_func)) {
         newmarks |= mask;
       }
     }
   }
 
   return newmarks;
+#else
+  visit_dirty_region(area_start, area_end, copy_object_func);
+  return 0;
+#endif
 }
 
 
 
 void Heap::IterateDirtyRegions(
     PagedSpace* space,
     DirtyRegionCallback visit_dirty_region,
     ObjectSlotCallback copy_object_func,
     ExpectedPageWatermarkState expected_page_watermark_state) {
 
@@ skipping 1162 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