Provide a tagged allocation top pointer.

test/cctest/heap/heap-utils.cc

 // Copyright 2016 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "test/cctest/heap/heap-utils.h"
 
 #include "src/factory.h"
 #include "src/heap/heap-inl.h"
 #include "src/heap/incremental-marking.h"
 #include "src/heap/mark-compact.h"
@@ skipping 27 matching lines @@
   int allocate_memory;
   int length;
   int free_memory = padding_size;
   if (tenure == i::TENURED) {
     heap->old_space()->EmptyAllocationInfo();
     int overall_free_memory = static_cast<int>(heap->old_space()->Available());
     CHECK(padding_size <= overall_free_memory || overall_free_memory == 0);
   } else {
     heap->new_space()->DisableInlineAllocationSteps();
     int overall_free_memory =
-        static_cast<int>(*heap->new_space()->allocation_limit_address() -
-                         *heap->new_space()->allocation_top_address());
+        static_cast<int>(heap->new_space()->limit() - heap->new_space()->top());
     CHECK(padding_size <= overall_free_memory || overall_free_memory == 0);
   }
   while (free_memory > 0) {
     if (free_memory > object_size) {
       allocate_memory = object_size;
       length = FixedArrayLenFromSize(allocate_memory);
     } else {
       allocate_memory = free_memory;
       length = FixedArrayLenFromSize(allocate_memory);
       if (length <= 0) {
         // Not enough room to create another fixed array. Let's create a filler.
         if (free_memory > (2 * kPointerSize)) {
-          heap->CreateFillerObjectAt(
-              *heap->old_space()->allocation_top_address(), free_memory,
-              ClearRecordedSlots::kNo);
+          if (tenure == i::TENURED) {
+            heap->CreateFillerObjectAt(heap->old_space()->top(), free_memory,
+                                       ClearRecordedSlots::kNo);
+          } else {
+            heap->CreateFillerObjectAt(heap->new_space()->top(), free_memory,
+                                       ClearRecordedSlots::kNo);
+          }
         }
         break;
       }
     }
     handles.push_back(isolate->factory()->NewFixedArray(length, tenure));
     CHECK((tenure == NOT_TENURED && heap->InNewSpace(*handles.back())) ||
           (tenure == TENURED && heap->InOldSpace(*handles.back())));
     free_memory -= allocate_memory;
   }
   return handles;
 }
 
 void AllocateAllButNBytes(v8::internal::NewSpace* space, int extra_bytes,
                           std::vector<Handle<FixedArray>>* out_handles) {
   space->DisableInlineAllocationSteps();
-  int space_remaining = static_cast<int>(*space->allocation_limit_address() -
-                                         *space->allocation_top_address());
+  int space_remaining = static_cast<int>(space->limit() - space->top());
   CHECK(space_remaining >= extra_bytes);
   int new_linear_size = space_remaining - extra_bytes;
   if (new_linear_size == 0) return;
   std::vector<Handle<FixedArray>> handles =
       heap::CreatePadding(space->heap(), new_linear_size, i::NOT_TENURED);
   if (out_handles != nullptr)
     out_handles->insert(out_handles->end(), handles.begin(), handles.end());
 }
 
 void FillCurrentPage(v8::internal::NewSpace* space,
                      std::vector<Handle<FixedArray>>* out_handles) {
   heap::AllocateAllButNBytes(space, 0, out_handles);
 }
 
 bool FillUpOnePage(v8::internal::NewSpace* space,
                    std::vector<Handle<FixedArray>>* out_handles) {
   space->DisableInlineAllocationSteps();
-  int space_remaining = static_cast<int>(*space->allocation_limit_address() -
-                                         *space->allocation_top_address());
+  int space_remaining = static_cast<int>(space->limit() - space->top());
   if (space_remaining == 0) return false;
   std::vector<Handle<FixedArray>> handles =
       heap::CreatePadding(space->heap(), space_remaining, i::NOT_TENURED);
   if (out_handles != nullptr)
     out_handles->insert(out_handles->end(), handles.begin(), handles.end());
   return true;
 }
 
 void SimulateFullSpace(v8::internal::NewSpace* space,
                        std::vector<Handle<FixedArray>>* out_handles) {
@@ skipping 38 matching lines @@
   }
 }
 
 void GcAndSweep(Heap* heap, AllocationSpace space) {
   heap->CollectGarbage(space);
   if (heap->mark_compact_collector()->sweeping_in_progress()) {
     heap->mark_compact_collector()->EnsureSweepingCompleted();
   }
 }
 
+void MakeSureNewSpaceTopIsNotDoubleAligned(i::Heap* heap) {
+  intptr_t top = reinterpret_cast<intptr_t>(heap->new_space()->top());
+  if ((top & kDoubleAlignmentMaskTagged) == 0) {
+    CreatePadding(heap, kDoubleSize / 2, NOT_TENURED);
+  }
+}
+
 }  // namespace heap
 }  // namespace internal
 }  // namespace v8