There are a bunch of places where to do pointer arithmetic, v8 mashes things
into uint32_t's. intptr_t's are the more correct way of doing this so that
it's always the right size. These are the fixes for space.h, space-inl.h,
and one fix to heap.cc to make sure that things work.
Test built on ia32-linux. Is there an equivalent to 'make check' on SCons?
Index: src/spaces-inl.h
===================================================================
--- src/spaces-inl.h (revision 1129)
+++ src/spaces-inl.h (working copy)
@@ -102,7 +102,7 @@
// page_address + words * 4
Address Page::ComputeRSetBitPosition(Address address, int offset,
- uint32_t* bitmask) {
+ intptr_t* bitmask) {
ASSERT(Page::is_rset_in_use());
Page* page = Page::FromAddress(address);
@@ -137,7 +137,7 @@
void Page::SetRSet(Address address, int offset) {
- uint32_t bitmask = 0;
+ intptr_t bitmask = 0;
Address rset_address = ComputeRSetBitPosition(address, offset, &bitmask);
Memory::uint32_at(rset_address) |= bitmask;
@@ -147,7 +147,7 @@
// Clears the corresponding remembered set bit for a given address.
void Page::UnsetRSet(Address address, int offset) {
- uint32_t bitmask = 0;
+ intptr_t bitmask = 0;
Address rset_address = ComputeRSetBitPosition(address, offset, &bitmask);
Memory::uint32_at(rset_address) &= ~bitmask;
@@ -156,7 +156,7 @@
bool Page::IsRSetSet(Address address, int offset) {
- uint32_t bitmask = 0;
+ intptr_t bitmask = 0;
Address rset_address = ComputeRSetBitPosition(address, offset, &bitmask);
return (Memory::uint32_at(rset_address) & bitmask) != 0;
}
Index: src/heap.cc
===================================================================
--- src/heap.cc (revision 1129)
+++ src/heap.cc (working copy)
@@ -616,10 +616,10 @@
void Heap::ClearRSetRange(Address start, int size_in_bytes) {
- uint32_t start_bit;
+ intptr_t start_bit;
Address start_word_address =
Page::ComputeRSetBitPosition(start, 0, &start_bit);
- uint32_t end_bit;
+ intptr_t end_bit;
Address end_word_address =
Page::ComputeRSetBitPosition(start + size_in_bytes - kIntSize,
0,
Index: src/spaces.h
===================================================================
--- src/spaces.h (revision 1129)
+++ src/spaces.h (working copy)
@@ -187,7 +187,7 @@
// object address/offset pair, and the bit encoded as a single-bit
// mask in the output parameter 'bitmask'.
INLINE(static Address ComputeRSetBitPosition(Address address, int offset,
- uint32_t* bitmask));
+ intptr_t* bitmask));
// Sets the corresponding remembered set bit for a given address.
INLINE(static void SetRSet(Address address, int offset));
@@ -912,14 +912,14 @@
// True if the address is in the address range of this semispace (not
// necessarily below the allocation pointer).
bool Contains(Address a) {
- return (reinterpret_cast<uint32_t>(a) & address_mask_)
- == reinterpret_cast<uint32_t>(start_);
+ return (reinterpret_cast<intptr_t>(a) & address_mask_)
+ == reinterpret_cast<intptr_t>(start_);
}
// True if the object is a heap object in the address range of this
// semispace (not necessarily below the allocation pointer).
bool Contains(Object* o) {
- return (reinterpret_cast<uint32_t>(o) & object_mask_) ==
object_expected_;
+ return (reinterpret_cast<intptr_t>(o) & object_mask_) ==
object_expected_;
}
// The offset of an address from the beginning of the space.
@@ -948,9 +948,9 @@
Address age_mark_;
// Masks and comparison values to test for containment in this semispace.
- uint32_t address_mask_;
- uint32_t object_mask_;
- uint32_t object_expected_;
+ intptr_t address_mask_;
+ intptr_t object_mask_;
+ intptr_t object_expected_;
public:
TRACK_MEMORY("SemiSpace")
@@ -1036,11 +1036,11 @@
// True if the address or object lies in the address range of either
// semispace (not necessarily below the allocation pointer).
bool Contains(Address a) {
- return (reinterpret_cast<uint32_t>(a) & address_mask_)
- == reinterpret_cast<uint32_t>(start_);
+ return (reinterpret_cast<intptr_t>(a) & address_mask_)
+ == reinterpret_cast<intptr_t>(start_);
}
bool Contains(Object* o) {
- return (reinterpret_cast<uint32_t>(o) & object_mask_) ==
object_expected_;
+ return (reinterpret_cast<intptr_t>(o) & object_mask_) ==
object_expected_;
}
// Return the allocated bytes in the active semispace.
@@ -1066,7 +1066,7 @@
// The start address of the space and a bit mask. Anding an address in
the
// new space with the mask will result in the start address.
Address start() { return start_; }
- uint32_t mask() { return address_mask_; }
+ intptr_t mask() { return address_mask_; }
// The allocation top and limit addresses.
Address* allocation_top_address() { return &allocation_info_.top; }
@@ -1150,9 +1150,9 @@
// Start address and bit mask for containment testing.
Address start_;
- uint32_t address_mask_;
- uint32_t object_mask_;
- uint32_t object_expected_;
+ intptr_t address_mask_;
+ intptr_t object_mask_;
+ intptr_t object_expected_;
// Allocation pointer and limit for normal allocation and allocation
during
// mark-compact collection.
Jeff Bailey >|< Google, Inc. >|< +1 514 670-8754
--~--~---------~--~----~------------~-------~--~----~
v8-dev mailing list
[email protected]
http://groups.google.com/group/v8-dev
-~----------~----~----~----~------~----~------~--~---
