Incremental mode now works for x64. The only difference

src/spaces.h

 // Copyright 2011 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 149 matching lines @@
   // pointers.  This enables some optimizations when marking.
   // It is expected that this field is inlined and turned into control flow
   // at the place where the MarkBit object is created.
   bool data_only_;
 };
 
 
 // Bitmap is a sequence of cells each containing fixed number of bits.
 class Bitmap {
  public:
   static const uint32_t kBitsPerCell = 32;

[Lasse Reichstein, 2011/06/10 13:55:44]

kBitsPerInt ?

[Erik Corry, 2011/06/10 21:57:29]

Not really.

   static const uint32_t kBitsPerCellLog2 = 5;
   static const uint32_t kBitIndexMask = kBitsPerCell - 1;
+  static const uint32_t kBytesPerCell = kBitsPerCell / 8;

[Lasse Reichstein, 2011/06/10 13:55:44]

8 -> kBitsPerByte

[Erik Corry, 2011/06/10 21:57:29]

Done.

+  static const uint32_t kBytesPerCellLog2 = kBitsPerCellLog2 - 3;

[Lasse Reichstein, 2011/06/10 13:55:44]

3 -> kBitesPerByteLog2

[Erik Corry, 2011/06/10 21:57:29]

Done.

 
   static const size_t kLength =
     (1 << kPageSizeBits) >> (kPointerSizeLog2);
 
   static const size_t kSize =
     (1 << kPageSizeBits) >> (kPointerSizeLog2 + kBitsPerByteLog2);
 
 
   static int CellsForLength(int length) {
     return (length + kBitsPerCell - 1) >> kBitsPerCellLog2;
@@ skipping 463 matching lines @@
   // Identity used in error reporting.
   AllocationSpace identity() { return id_; }
 
   // Returns allocated size.
   virtual intptr_t Size() = 0;
 
   // Returns size of objects. Can differ from the allocated size
   // (e.g. see LargeObjectSpace).
   virtual intptr_t SizeOfObjects() { return Size(); }
 
+  virtual int RoundSizeDownToObjectAlignment(int size) {
+    if (id_ == CODE_SPACE) {
+      return RoundDown(size, kCodeAlignment);
+    } else {
+      return RoundDown(size, kPointerSize);
+    }
+  }
+
 #ifdef ENABLE_HEAP_PROTECTION
   // Protect/unprotect the space by marking it read-only/writable.
   virtual void Protect() = 0;
   virtual void Unprotect() = 0;
 #endif
 
 #ifdef DEBUG
   virtual void Print() = 0;
 #endif
 
@@ skipping 1528 matching lines @@
   bool MapPointersEncodable() {
     return false;
   }
 
   // Should be called after forced sweep to find out if map space needs
   // compaction.
   bool NeedsCompaction(int live_maps) {
     return false;  // TODO(gc): Bring back map compaction.
   }
 
+  virtual int RoundSizeDownToObjectAlignment(int size) {
+    if (IsPowerOf2(Map::kSize)) {
+      return RoundDown(size, Map::kSize);
+    } else {
+      return (size / Map::kSize) * Map::kSize;
+    }
+  }
+
  protected:
 #ifdef DEBUG
   virtual void VerifyObject(HeapObject* obj);
 #endif
 
  private:
   static const int kMapsPerPage = Page::kObjectAreaSize / Map::kSize;
 
   // Do map space compaction if there is a page gap.
   int CompactionThreshold() {
@@ skipping 10 matching lines @@
 // -----------------------------------------------------------------------------
 // Old space for all global object property cell objects
 
 class CellSpace : public FixedSpace {
  public:
   // Creates a property cell space object with a maximum capacity.
   CellSpace(Heap* heap, intptr_t max_capacity, AllocationSpace id)
       : FixedSpace(heap, max_capacity, id, JSGlobalPropertyCell::kSize, "cell")
   {}
 
+  virtual int RoundSizeDownToObjectAlignment(int size) {
+    if (IsPowerOf2(JSGlobalPropertyCell::kSize)) {
+      return RoundDown(size, JSGlobalPropertyCell::kSize);
+    } else {
+      return (size / JSGlobalPropertyCell::kSize) * JSGlobalPropertyCell::kSize;
+    }
+  }
+
  protected:
 #ifdef DEBUG
   virtual void VerifyObject(HeapObject* obj);
 #endif
 
  public:
   TRACK_MEMORY("CellSpace")
 };
 
 
@@ skipping 194 matching lines @@
   }
   // Must be small, since an iteration is used for lookup.
   static const int kMaxComments = 64;
 };
 #endif
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_SPACES_H_