X64: Move remembered set to a safe location on x64 platform.

src/spaces-inl.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 75 matching lines @@
 }
 
 
 Address Page::AllocationTop() {
   PagedSpace* owner = MemoryAllocator::PageOwner(this);
   return owner->PageAllocationTop(this);
 }
 
 
 void Page::ClearRSet() {
-#ifndef V8_HOST_ARCH_64_BIT
   // This method can be called in all rset states.
   memset(RSetStart(), 0, kRSetEndOffset - kRSetStartOffset);
-#endif
 }
 
 
-// Give an address a (32-bits):
+// Given an address (32-bits), separate its bits into:
 // | page address | words (6) | bit offset (5) | pointer alignment (2) |
 // The rset address is computed as:
 //    page_address + words * 4
+// For a 64-bit address, if it is:
+// | page address | quadwords(5) | bit offset(5) | pointer alignment (3) |
+// The reset address is computed as:

[Lasse Reichstein, 2009/07/01 12:30:18]

reset -> rset (or RSet?)

+//    page_address + words * 4 + kRSetOffset.

[Lasse Reichstein, 2009/07/01 12:30:18]

words -> quadwords

+// The rset is accessed as 32-bit words, and bit offsets in a 32-bit word,
+// even on the X64 architecture.

[Lasse Reichstein, 2009/07/01 12:30:18]

We could probably speed up a little by loading 64 bits at a time when scanning
for non-null bits.

 
 Address Page::ComputeRSetBitPosition(Address address, int offset,
                                      uint32_t* bitmask) {
   ASSERT(Page::is_rset_in_use());
 
   Page* page = Page::FromAddress(address);
   uint32_t bit_offset = ArithmeticShiftRight(page->Offset(address) + offset,
                                              kObjectAlignmentBits);
   *bitmask = 1 << (bit_offset % kBitsPerInt);
 
   Address rset_address =
-      page->address() + (bit_offset / kBitsPerInt) * kIntSize;
+      page->address() + kRSetOffset + (bit_offset / kBitsPerInt) * kIntSize;
   // The remembered set address is either in the normal remembered set range
   // of a page or else we have a large object page.
   ASSERT((page->RSetStart() <= rset_address && rset_address < page->RSetEnd())
          || page->IsLargeObjectPage());
 
   if (rset_address >= page->RSetEnd()) {
     // We have a large object page, and the remembered set address is actually
     // past the end of the object.  The address of the remembered set in this
     // case is the extra remembered set start address at the address of the
     // end of the object:
     //   (page->ObjectAreaStart() + object size)
     // plus the offset of the computed remembered set address from the start
     // of the object:
     //   (rset_address - page->ObjectAreaStart()).
     // Ie, we can just add the object size.
+    // In the X64 architecture, the remembered set ends before the object start,
+    // so we need to add an additional offset, from rset end to object start
     ASSERT(HeapObject::FromAddress(address)->IsFixedArray());
-    rset_address +=
+    rset_address += kObjectStartOffset - kRSetEndOffset +
         FixedArray::SizeFor(Memory::int_at(page->ObjectAreaStart()
                                            + Array::kLengthOffset));
   }
   return rset_address;
 }
 
 
 void Page::SetRSet(Address address, int offset) {
   uint32_t bitmask = 0;
   Address rset_address = ComputeRSetBitPosition(address, offset, &bitmask);
   Memory::uint32_at(rset_address) |= bitmask;
 
   ASSERT(IsRSetSet(address, offset));
 }
 
 
 // Clears the corresponding remembered set bit for a given address.
 void Page::UnsetRSet(Address address, int offset) {
   uint32_t bitmask = 0;
   Address rset_address = ComputeRSetBitPosition(address, offset, &bitmask);
   Memory::uint32_at(rset_address) &= ~bitmask;
 
   ASSERT(!IsRSetSet(address, offset));
 }
 
 
 bool Page::IsRSetSet(Address address, int offset) {
-#ifdef V8_HOST_ARCH_64_BIT
-  // TODO(X64): Reenable when RSet works.
-  return true;
-#else  // V8_HOST_ARCH_64_BIT
   uint32_t bitmask = 0;
   Address rset_address = ComputeRSetBitPosition(address, offset, &bitmask);
   return (Memory::uint32_at(rset_address) & bitmask) != 0;
-#endif  // V8_HOST_ARCH_64_BIT
 }
 
 
 // -----------------------------------------------------------------------------
 // MemoryAllocator
 
 bool MemoryAllocator::IsValidChunk(int chunk_id) {
   if (!IsValidChunkId(chunk_id)) return false;
 
   ChunkInfo& c = chunks_[chunk_id];
@@ skipping 175 matching lines @@
   ASSERT(space->low() <= alloc_info->top
          && alloc_info->top <= space->high()
          && alloc_info->limit == space->high());
 #endif
   return obj;
 }
 
 } }  // namespace v8::internal
 
 #endif  // V8_SPACES_INL_H_