Revert of Provide a tagged allocation top pointer.

test/cctest/heap/test-heap.cc

 // Copyright 2012 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 2047 matching lines @@
       heap->new_space()->AllocateRawAligned(size, alignment);
   HeapObject* obj = NULL;
   allocation.To(&obj);
   heap->CreateFillerObjectAt(obj->address(), size, ClearRecordedSlots::kNo);
   return obj;
 }
 
 
 // Get new space allocation into the desired alignment.
 static Address AlignNewSpace(AllocationAlignment alignment, int offset) {
-  Address top = CcTest::heap()->new_space()->top();
-  int fill = Heap::GetFillToAlign(top, alignment);
+  Address* top_addr = CcTest::heap()->new_space()->allocation_top_address();
+  int fill = Heap::GetFillToAlign(*top_addr, alignment);
   if (fill) {
     NewSpaceAllocateAligned(fill + offset, kWordAligned);
   }
-  return CcTest::heap()->new_space()->top();
+  return *top_addr;
 }
 
 
 TEST(TestAlignedAllocation) {
   // Double misalignment is 4 on 32-bit platforms, 0 on 64-bit ones.
   const intptr_t double_misalignment = kDoubleSize - kPointerSize;
+  Address* top_addr = CcTest::heap()->new_space()->allocation_top_address();
   Address start;
   HeapObject* obj;
   HeapObject* filler;
   if (double_misalignment) {
     // Allocate a pointer sized object that must be double aligned at an
     // aligned address.
     start = AlignNewSpace(kDoubleAligned, 0);
     obj = NewSpaceAllocateAligned(kPointerSize, kDoubleAligned);
     CHECK(IsAddressAligned(obj->address(), kDoubleAlignment));
     // There is no filler.
-    CHECK_EQ(kPointerSize, CcTest::heap()->new_space()->top() - start);
+    CHECK_EQ(kPointerSize, *top_addr - start);
 
     // Allocate a second pointer sized object that must be double aligned at an
     // unaligned address.
     start = AlignNewSpace(kDoubleAligned, kPointerSize);
     obj = NewSpaceAllocateAligned(kPointerSize, kDoubleAligned);
     CHECK(IsAddressAligned(obj->address(), kDoubleAlignment));
     // There is a filler object before the object.
     filler = HeapObject::FromAddress(start);
     CHECK(obj != filler && filler->IsFiller() &&
           filler->Size() == kPointerSize);
-    CHECK_EQ(kPointerSize + double_misalignment,
-             CcTest::heap()->new_space()->top() - start);
+    CHECK_EQ(kPointerSize + double_misalignment, *top_addr - start);
 
     // Similarly for kDoubleUnaligned.
     start = AlignNewSpace(kDoubleUnaligned, 0);
     obj = NewSpaceAllocateAligned(kPointerSize, kDoubleUnaligned);
     CHECK(IsAddressAligned(obj->address(), kDoubleAlignment, kPointerSize));
-    CHECK_EQ(kPointerSize, CcTest::heap()->new_space()->top() - start);
+    CHECK_EQ(kPointerSize, *top_addr - start);
     start = AlignNewSpace(kDoubleUnaligned, kPointerSize);
     obj = NewSpaceAllocateAligned(kPointerSize, kDoubleUnaligned);
     CHECK(IsAddressAligned(obj->address(), kDoubleAlignment, kPointerSize));
     // There is a filler object before the object.
     filler = HeapObject::FromAddress(start);
     CHECK(obj != filler && filler->IsFiller() &&
           filler->Size() == kPointerSize);
-    CHECK_EQ(kPointerSize + double_misalignment,
-             CcTest::heap()->new_space()->top() - start);
+    CHECK_EQ(kPointerSize + double_misalignment, *top_addr - start);
   }
 
   // Now test SIMD alignment. There are 2 or 4 possible alignments, depending
   // on platform.
   start = AlignNewSpace(kSimd128Unaligned, 0);
   obj = NewSpaceAllocateAligned(kPointerSize, kSimd128Unaligned);
   CHECK(IsAddressAligned(obj->address(), kSimd128Alignment, kPointerSize));
   // There is no filler.
-  CHECK_EQ(kPointerSize, CcTest::heap()->new_space()->top() - start);
+  CHECK_EQ(kPointerSize, *top_addr - start);
   start = AlignNewSpace(kSimd128Unaligned, kPointerSize);
   obj = NewSpaceAllocateAligned(kPointerSize, kSimd128Unaligned);
   CHECK(IsAddressAligned(obj->address(), kSimd128Alignment, kPointerSize));
   // There is a filler object before the object.
   filler = HeapObject::FromAddress(start);
   CHECK(obj != filler && filler->IsFiller() &&
         filler->Size() == kSimd128Size - kPointerSize);
-  CHECK_EQ(kPointerSize + kSimd128Size - kPointerSize,
-           CcTest::heap()->new_space()->top() - start);
+  CHECK_EQ(kPointerSize + kSimd128Size - kPointerSize, *top_addr - start);
 
   if (double_misalignment) {
     // Test the 2 other alignments possible on 32 bit platforms.
     start = AlignNewSpace(kSimd128Unaligned, 2 * kPointerSize);
     obj = NewSpaceAllocateAligned(kPointerSize, kSimd128Unaligned);
     CHECK(IsAddressAligned(obj->address(), kSimd128Alignment, kPointerSize));
     // There is a filler object before the object.
     filler = HeapObject::FromAddress(start);
     CHECK(obj != filler && filler->IsFiller() &&
           filler->Size() == 2 * kPointerSize);
-    CHECK_EQ(kPointerSize + 2 * kPointerSize,
-             CcTest::heap()->new_space()->top() - start);
+    CHECK_EQ(kPointerSize + 2 * kPointerSize, *top_addr - start);
     start = AlignNewSpace(kSimd128Unaligned, 3 * kPointerSize);
     obj = NewSpaceAllocateAligned(kPointerSize, kSimd128Unaligned);
     CHECK(IsAddressAligned(obj->address(), kSimd128Alignment, kPointerSize));
     // There is a filler object before the object.
     filler = HeapObject::FromAddress(start);
     CHECK(obj != filler && filler->IsFiller() &&
           filler->Size() == kPointerSize);
-    CHECK_EQ(kPointerSize + kPointerSize,
-             CcTest::heap()->new_space()->top() - start);
+    CHECK_EQ(kPointerSize + kPointerSize, *top_addr - start);
   }
 }
 
 
 static HeapObject* OldSpaceAllocateAligned(int size,
                                            AllocationAlignment alignment) {
   Heap* heap = CcTest::heap();
   AllocationResult allocation =
       heap->old_space()->AllocateRawAligned(size, alignment);
   HeapObject* obj = NULL;
   allocation.To(&obj);
   heap->CreateFillerObjectAt(obj->address(), size, ClearRecordedSlots::kNo);
   return obj;
 }
 
 
 // Get old space allocation into the desired alignment.
 static Address AlignOldSpace(AllocationAlignment alignment, int offset) {
-  Address top = CcTest::heap()->old_space()->top();
-  int fill = Heap::GetFillToAlign(top, alignment);
+  Address* top_addr = CcTest::heap()->old_space()->allocation_top_address();
+  int fill = Heap::GetFillToAlign(*top_addr, alignment);
   int allocation = fill + offset;
   if (allocation) {
     OldSpaceAllocateAligned(allocation, kWordAligned);
   }
-  top = CcTest::heap()->old_space()->top();
+  Address top = *top_addr;
   // Now force the remaining allocation onto the free list.
   CcTest::heap()->old_space()->EmptyAllocationInfo();
   return top;
 }
 
 
 // Test the case where allocation must be done from the free list, so filler
 // may precede or follow the object.
 TEST(TestAlignedOverAllocation) {
   // Double misalignment is 4 on 32-bit platforms, 0 on 64-bit ones.
@@ skipping 4567 matching lines @@
   CHECK(marking->IsComplete());
   intptr_t size_before = heap->SizeOfObjects();
   CcTest::heap()->CollectAllGarbage();
   intptr_t size_after = heap->SizeOfObjects();
   // Live size does not increase after garbage collection.
   CHECK_LE(size_after, size_before);
 }
 
 }  // namespace internal
 }  // namespace v8