X64: Disabled RSet in 64-bit mode.

src/spaces.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 80 matching lines @@
 // three areas: the first two words are used for bookkeeping, the next 248
 // bytes are used as remembered set, and the rest of the page is the object
 // area.
 //
 // Pointers are aligned to the pointer size (4 bytes), only 1 bit is needed
 // for a pointer in the remembered set. Given an address, its remembered set
 // bit position (offset from the start of the page) is calculated by dividing
 // its page offset by 32. Therefore, the object area in a page starts at the
 // 256th byte (8K/32). Bytes 0 to 255 do not need the remembered set, so that
 // the first two words (64 bits) in a page can be used for other purposes.
+// TODO(X64): This description only represents the 32-bit layout.
 //
 // The mark-compact collector transforms a map pointer into a page index and a
 // page offset. The map space can have up to 1024 pages, and 8M bytes (1024 *
 // 8K) in total.  Because a map pointer is aligned to the pointer size (4
 // bytes), 11 bits are enough to encode the page offset. 21 bits (10 for the
 // page index + 11 for the offset in the page) are required to encode a map
 // pointer.
 //
 // The only way to get a page pointer is by calling factory methods:
 //   Page* p = Page::FromAddress(addr); or
@@ skipping 95 matching lines @@
   static void set_rset_state(RSetState state) { rset_state_ = state; }
 #endif
 
   // 8K bytes per page.
   static const int kPageSizeBits = 13;
 
   // Page size in bytes.  This must be a multiple of the OS page size.
   static const int kPageSize = 1 << kPageSizeBits;
 
   // Page size mask.
-  static const int kPageAlignmentMask = (1 << kPageSizeBits) - 1;
+  static const intptr_t kPageAlignmentMask = (1 << kPageSizeBits) - 1;
 
   // The end offset of the remembered set in a page
   // (heaps are aligned to pointer size).
   static const int kRSetEndOffset= kPageSize / kBitsPerPointer;
 
   // The start offset of the remembered set in a page.
   static const int kRSetStartOffset = kRSetEndOffset / kBitsPerPointer;
 
   // The start offset of the object area in a page.
   static const int kObjectStartOffset = kRSetEndOffset;
 
   // Object area size in bytes.
   static const int kObjectAreaSize = kPageSize - kObjectStartOffset;
 
   // Maximum object size that fits in a page.
   static const int kMaxHeapObjectSize = kObjectAreaSize;
 
   //---------------------------------------------------------------------------
   // Page header description.
   //
   // If a page is not in the large object space, the first word,
   // opaque_header, encodes the next page address (aligned to kPageSize 8K)
   // and the chunk number (0 ~ 8K-1).  Only MemoryAllocator should use
   // opaque_header. The value range of the opaque_header is [0..kPageSize[,
   // or [next_page_start, next_page_end[. It cannot point to a valid address
   // in the current page.  If a page is in the large object space, the first
   // word *may* (if the page start and large object chunk start are the
   // same) contain the address of the next large object chunk.
-  int opaque_header;
+  intptr_t opaque_header;
 
   // If the page is not in the large object space, the low-order bit of the
   // second word is set. If the page is in the large object space, the
   // second word *may* (if the page start and large object chunk start are
   // the same) contain the large object chunk size.  In either case, the
   // low-order bit for large object pages will be cleared.
   int is_normal_page;
 
   // The following fields overlap with remembered set, they can only
   // be used in the mark-compact collector when remembered set is not
@@ skipping 1472 matching lines @@
 
  private:
   LargeObjectChunk* current_;
   HeapObjectCallback size_func_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_SPACES_H_