Revert changes 601 and 602. TBR

src/mark-compact.h

 // 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 137 matching lines @@
 
   // Marking operations for objects reachable from roots.
   static void MarkLiveObjects();
 
   static void MarkUnmarkedObject(HeapObject* obj);
 
   static inline void MarkObject(HeapObject* obj) {
      if (!obj->IsMarked()) MarkUnmarkedObject(obj);
   }
 
-  // Creates back pointers for all map transitions, stores them in
-  // the prototype field.  The original prototype pointers are restored
-  // in ClearNonLiveTransitions().  All JSObject maps
-  // connected by map transitions have the same prototype object, which
-  // is why we can use this field temporarily for back pointers.
-  static void CreateBackPointers();
-
-  // Mark a Map and its DescriptorArray together, skipping transitions.
-  static void MarkMapContents(Map* map);
-  static void MarkDescriptorArray(DescriptorArray* descriptors);
-
   // Mark the heap roots and all objects reachable from them.
   static void ProcessRoots(RootMarkingVisitor* visitor);
 
   // Mark objects in object groups that have at least one object in the
   // group marked.
   static void MarkObjectGroups();
 
   // Mark all objects in an object group with at least one marked
   // object, then all objects reachable from marked objects in object
   // groups, and repeat.
@@ skipping 19 matching lines @@
 
 #ifdef DEBUG
   static void UpdateLiveObjectCount(HeapObject* obj);
   static void VerifyHeapAfterMarkingPhase();
 #endif
 
   // We sweep the large object space in the same way whether we are
   // compacting or not, because the large object space is never compacted.
   static void SweepLargeObjectSpace();
 
-  // Test whether a (possibly marked) object is a Map.
-  static inline bool SafeIsMap(HeapObject* object);
-
-    // Map transitions from a live map to a dead map must be killed.
-  // We replace them with a null descriptor, with the same key.
-  static void ClearNonLiveTransitions();
-
   // --------------------------------------------------------------------------
   // Phase 2: functions related to computing and encoding forwarding pointers
   //   before: live objects' map pointers are marked as '00'
   //    after: Map pointers of live old and map objects have encoded
   //           forwarding pointers and map pointers
   //
   //           The 3rd word of a page has the page top offset after compaction.
   //
   //           The 4th word of a page in the map space has the map index
   //           of this page in the map table. This word is not used in
@@ skipping 149 matching lines @@
 
   friend class UnmarkObjectVisitor;
   static void UnmarkObject(HeapObject* obj);
 #endif
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_MARK_COMPACT_H_