Provide baseline GC version.

src/heap.h

 // 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 1234 matching lines @@
     GCType gc_type;
   };
   static List<GCEpilogueCallbackPair> gc_epilogue_callbacks_;
 
   static GCCallback global_gc_prologue_callback_;
   static GCCallback global_gc_epilogue_callback_;
 
   // Support for computing object sizes during GC.
   static HeapObjectCallback gc_safe_size_of_old_object_;
   static int GcSafeSizeOfOldObject(HeapObject* object);
+#ifndef BASELINE_GC
   static int GcSafeSizeOfOldObjectWithEncodedMap(HeapObject* object);
+#endif
 
   // Update the GC state. Called from the mark-compact collector.
   static void MarkMapPointersAsEncoded(bool encoded) {
+#ifndef BASELINE_GC
     gc_safe_size_of_old_object_ = encoded
         ? &GcSafeSizeOfOldObjectWithEncodedMap
         : &GcSafeSizeOfOldObject;
+#else
+    ASSERT(!encoded);
+    gc_safe_size_of_old_object_ = &GcSafeSizeOfOldObject;
+#endif
   }
 
   // Checks whether a global GC is necessary
   static GarbageCollector SelectGarbageCollector(AllocationSpace space);
 
   // Performs garbage collection
   // Returns whether there is a chance another major GC could
   // collect more garbage.
   static bool PerformGarbageCollection(GarbageCollector collector,
                                        GCTracer* tracer);
@@ skipping 217 matching lines @@
       if ((*current)->IsHeapObject()) {
         HeapObject* object = HeapObject::cast(*current);
         ASSERT(Heap::Contains(object));
         ASSERT(object->map()->IsMap());
       }
     }
   }
 };
 
 
+#ifndef BASELINE_GC
 // Visitor class to verify interior pointers in spaces that use region marks
 // to keep track of intergenerational references.
 // As VerifyPointersVisitor but also checks that dirty marks are set
 // for regions covering intergenerational references.
 class VerifyPointersAndDirtyRegionsVisitor: public ObjectVisitor {
  public:
   void VisitPointers(Object** start, Object** end) {
     for (Object** current = start; current < end; current++) {
       if ((*current)->IsHeapObject()) {
         HeapObject* object = HeapObject::cast(*current);
         ASSERT(Heap::Contains(object));
         ASSERT(object->map()->IsMap());
         if (Heap::InNewSpace(object)) {
           ASSERT(Heap::InToSpace(object));
           Address addr = reinterpret_cast<Address>(current);
           ASSERT(Page::FromAddress(addr)->IsRegionDirty(addr));
         }
       }
     }
   }
 };
 #endif
+#endif
 
 
 // Space iterator for iterating over all spaces of the heap.
 // Returns each space in turn, and null when it is done.
 class AllSpaces BASE_EMBEDDED {
  public:
   Space* next();
   AllSpaces() { counter_ = FIRST_SPACE; }
  private:
   int counter_;
@@ skipping 574 matching lines @@
   // Return whether this object should be retained. If NULL is returned the
   // object has no references. Otherwise the address of the retained object
   // should be returned as in some GC situations the object has been moved.
   virtual Object* RetainAs(Object* object) = 0;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_HEAP_H_