Provide baseline GC version.

src/mark-compact.cc

 // Copyright 2006-2008 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 64 matching lines @@
   // Tell the tracer.
   if (IsCompacting()) tracer_->set_is_compacting();
 
   MarkLiveObjects();
 
   if (FLAG_collect_maps) ClearNonLiveTransitions();
 
   SweepLargeObjectSpace();
 
   if (IsCompacting()) {
+#ifndef BASELINE_GC
     GCTracer::Scope gc_scope(tracer_, GCTracer::Scope::MC_COMPACT);
     EncodeForwardingAddresses();
 
     Heap::MarkMapPointersAsEncoded(true);
     UpdatePointers();
     Heap::MarkMapPointersAsEncoded(false);
     PcToCodeCache::FlushPcToCodeCache();
 
     RelocateObjects();
+#else
+    UNREACHABLE();
+#endif
   } else {
     SweepSpaces();
     PcToCodeCache::FlushPcToCodeCache();
   }
 
   Finish();
 
   // Save the count of marked objects remaining after the collection and
   // null out the GC tracer.
   previous_marked_count_ = tracer_->marked_count();
   ASSERT(previous_marked_count_ == 0);
   tracer_ = NULL;
 }
 
 
 void MarkCompactCollector::Prepare(GCTracer* tracer) {
+#ifdef BASELINE_GC
+  FLAG_flush_code = false;
+  FLAG_always_compact = false;
+  FLAG_never_compact = true;
+#endif
+
   // Rather than passing the tracer around we stash it in a static member
   // variable.
   tracer_ = tracer;
 
 #ifdef DEBUG
   ASSERT(state_ == IDLE);
   state_ = PREPARE_GC;
 #endif
   ASSERT(!FLAG_always_compact || !FLAG_never_compact);
 
@@ skipping 1345 matching lines @@
 // to mark free regions larger than one word, and the size of the free
 // region (including the first word) is written to the second word of the
 // region.
 //
 // Any valid map page offset must lie in the object area of the page, so map
 // page offsets less than Page::kObjectStartOffset are invalid.  We use a
 // pair of distinguished invalid map encodings (for single word and multiple
 // words) to indicate free regions in the page found during computation of
 // forwarding addresses and skipped over in subsequent sweeps.
 
-
+#ifndef BASELINE_GC
 // Encode a free region, defined by the given start address and size, in the
 // first word or two of the region.
 void EncodeFreeRegion(Address free_start, int free_size) {
   ASSERT(free_size >= kIntSize);
   if (free_size == kIntSize) {
     Memory::uint32_at(free_start) = MarkCompactCollector::kSingleFreeEncoding;
   } else {
     ASSERT(free_size >= 2 * kIntSize);
     Memory::uint32_at(free_start) = MarkCompactCollector::kMultiFreeEncoding;
     Memory::int_at(free_start + kIntSize) = free_size;
@@ skipping 196 matching lines @@
     // in the page.
     int offset = 0;
     EncodeForwardingAddressesInRange<Alloc,
                                      EncodeForwardingAddressInPagedSpace,
                                      ProcessNonLive>(
         p->ObjectAreaStart(),
         p->AllocationTop(),
         &offset);
   }
 }
-
+#endif
 
 // We scavange new space simultaneously with sweeping. This is done in two
 // passes.
 // The first pass migrates all alive objects from one semispace to another or
 // promotes them to old space. Forwading address is written directly into
 // first word of object without any encoding. If object is dead we are writing
 // NULL as a forwarding address.
 // The second pass updates pointers to new space in all spaces. It is possible
 // to encounter pointers to dead objects during traversal of dirty regions we
 // should clear them to avoid encountering them during next dirty regions
@@ skipping 352 matching lines @@
       ASSERT(new_allocation_top_page == prec_first_empty_page);
     } else {
       ASSERT(new_allocation_top_page == first_empty_page);
     }
 #endif
 
     space->SetTop(new_allocation_top);
   }
 }
 
-
+#ifndef BASELINE_GC
 void MarkCompactCollector::EncodeForwardingAddresses() {
   ASSERT(state_ == ENCODE_FORWARDING_ADDRESSES);
   // Objects in the active semispace of the young generation may be
   // relocated to the inactive semispace (if not promoted).  Set the
   // relocation info to the beginning of the inactive semispace.
   Heap::new_space()->MCResetRelocationInfo();
 
   // Compute the forwarding pointers in each space.
   EncodeForwardingAddressesInPagedSpace<MCAllocateFromOldPointerSpace,
                                         ReportDeleteIfNeeded>(
@@ skipping 234 matching lines @@
       return;
 
     for (HeapObject* obj = map_to_evacuate_it_.next();
          obj != NULL; obj = map_to_evacuate_it_.next())
       ASSERT(FreeListNode::IsFreeListNode(obj));
   }
 #endif
 };
 
 MapCompact::MapUpdatingVisitor MapCompact::map_updating_visitor_;
-
+#endif
 
 void MarkCompactCollector::SweepSpaces() {
   GCTracer::Scope gc_scope(tracer_, GCTracer::Scope::MC_SWEEP);
 
   ASSERT(state_ == SWEEP_SPACES);
   ASSERT(!IsCompacting());
   // Noncompacting collections simply sweep the spaces to clear the mark
   // bits and free the nonlive blocks (for old and map spaces).  We sweep
   // the map space last because freeing non-live maps overwrites them and
   // the other spaces rely on possibly non-live maps to get the sizes for
   // non-live objects.
   SweepSpace(Heap::old_pointer_space());
   SweepSpace(Heap::old_data_space());
   SweepSpace(Heap::code_space());
   SweepSpace(Heap::cell_space());
   { GCTracer::Scope gc_scope(tracer_, GCTracer::Scope::MC_SWEEP_NEWSPACE);
     SweepNewSpace(Heap::new_space());
   }
   SweepSpace(Heap::map_space());
 
   Heap::IterateDirtyRegions(Heap::map_space(),
                             &Heap::IteratePointersInDirtyMapsRegion,
                             &UpdatePointerToNewGen,
                             Heap::WATERMARK_SHOULD_BE_VALID);
 
   intptr_t live_maps_size = Heap::map_space()->Size();
   int live_maps = static_cast<int>(live_maps_size / Map::kSize);
   ASSERT(live_map_objects_size_ == live_maps_size);
 
+#ifndef BASELINE_GC
   if (Heap::map_space()->NeedsCompaction(live_maps)) {
     MapCompact map_compact(live_maps);
 
     map_compact.CompactMaps();
     map_compact.UpdateMapPointersInRoots();
 
     PagedSpaces spaces;
     for (PagedSpace* space = spaces.next();
          space != NULL; space = spaces.next()) {
       if (space == Heap::map_space()) continue;
       map_compact.UpdateMapPointersInPagedSpace(space);
     }
     map_compact.UpdateMapPointersInNewSpace();
     map_compact.UpdateMapPointersInLargeObjectSpace();
 
     map_compact.Finish();
   }
+#else
+  USE(live_maps);
+#endif
 }
 
 
 // Iterate the live objects in a range of addresses (eg, a page or a
 // semispace).  The live regions of the range have been linked into a list.
 // The first live region is [first_live_start, first_live_end), and the last
 // address in the range is top.  The callback function is used to get the
 // size of each live object.
 int MarkCompactCollector::IterateLiveObjectsInRange(
     Address start,
@@ skipping 32 matching lines @@
   while (it.has_next()) {
     Page* p = it.next();
     total += IterateLiveObjectsInRange(p->ObjectAreaStart(),
                                        p->AllocationTop(),
                                        size_f);
   }
   return total;
 }
 
 
+#ifndef BASELINE_GC
 // -------------------------------------------------------------------------
 // Phase 3: Update pointers
 
 // Helper class for updating pointers in HeapObjects.
 class UpdatingVisitor: public ObjectVisitor {
  public:
   void VisitPointer(Object** p) {
     UpdatePointer(p);
   }
 
@@ skipping 462 matching lines @@
 
   HeapObject* copied_to = HeapObject::FromAddress(new_addr);
   if (copied_to->IsJSFunction()) {
     PROFILE(FunctionMoveEvent(old_addr, new_addr));
     PROFILE(FunctionCreateEventFromMove(JSFunction::cast(copied_to)));
   }
   HEAP_PROFILE(ObjectMoveEvent(old_addr, new_addr));
 
   return obj_size;
 }
+#endif
 
 
 void MarkCompactCollector::ReportDeleteIfNeeded(HeapObject* obj) {
 #ifdef ENABLE_LOGGING_AND_PROFILING
   if (obj->IsCode()) {
     PROFILE(CodeDeleteEvent(obj->address()));
   } else if (obj->IsJSFunction()) {
     PROFILE(FunctionDeleteEvent(obj->address()));
   }
 #endif
 }
 
 
 int MarkCompactCollector::SizeOfMarkedObject(HeapObject* obj) {
   MapWord map_word = obj->map_word();
   map_word.ClearMark();
   return obj->SizeFromMap(map_word.ToMap());
 }
 
 
 void MarkCompactCollector::Initialize() {
   StaticPointersToNewGenUpdatingVisitor::Initialize();
   StaticMarkingVisitor::Initialize();
 }
 
 
 } }  // namespace v8::internal