Revert of Reland: Fix logic for incremental marking steps on tenured allocation

test/cctest/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 2011 matching lines @@
 // may precede or follow the object.
 TEST(TestAlignedOverAllocation) {
   // Double misalignment is 4 on 32-bit platforms, 0 on 64-bit ones.
   const intptr_t double_misalignment = kDoubleSize - kPointerSize;
   Address start;
   HeapObject* obj;
   HeapObject* filler1;
   HeapObject* filler2;
   if (double_misalignment) {
     start = AlignOldSpace(kDoubleAligned, 0);
-    // If we run out of linear allocation area then we might get null here.  In
-    // that case we are unlucky and the test is not going to work, but it's not
-    // a test failure, this is a reasonable thing to happen.  Just abandon.
-    if (start == NULL) return;
     obj = OldSpaceAllocateAligned(kPointerSize, kDoubleAligned);
     // The object is aligned, and a filler object is created after.
     CHECK(IsAddressAligned(obj->address(), kDoubleAlignment));
     filler1 = HeapObject::FromAddress(start + kPointerSize);
     CHECK(obj != filler1 && filler1->IsFiller() &&
           filler1->Size() == kPointerSize);
     // Try the opposite alignment case.
     start = AlignOldSpace(kDoubleAligned, kPointerSize);
-    if (start == NULL) return;
     obj = OldSpaceAllocateAligned(kPointerSize, kDoubleAligned);
     CHECK(IsAddressAligned(obj->address(), kDoubleAlignment));
     filler1 = HeapObject::FromAddress(start);
     CHECK(obj != filler1);
     CHECK(filler1->IsFiller());
     CHECK(filler1->Size() == kPointerSize);
     CHECK(obj != filler1 && filler1->IsFiller() &&
           filler1->Size() == kPointerSize);
 
     // Similarly for kDoubleUnaligned.
     start = AlignOldSpace(kDoubleUnaligned, 0);
-    if (start == NULL) return;
     obj = OldSpaceAllocateAligned(kPointerSize, kDoubleUnaligned);
     // The object is aligned, and a filler object is created after.
     CHECK(IsAddressAligned(obj->address(), kDoubleAlignment, kPointerSize));
     filler1 = HeapObject::FromAddress(start + kPointerSize);
     CHECK(obj != filler1 && filler1->IsFiller() &&
           filler1->Size() == kPointerSize);
     // Try the opposite alignment case.
     start = AlignOldSpace(kDoubleUnaligned, kPointerSize);
-    if (start == NULL) return;
     obj = OldSpaceAllocateAligned(kPointerSize, kDoubleUnaligned);
     CHECK(IsAddressAligned(obj->address(), kDoubleAlignment, kPointerSize));
     filler1 = HeapObject::FromAddress(start);
     CHECK(obj != filler1 && filler1->IsFiller() &&
           filler1->Size() == kPointerSize);
   }
 
   // Now test SIMD alignment. There are 2 or 4 possible alignments, depending
   // on platform.
   start = AlignOldSpace(kSimd128Unaligned, 0);
-  if (start == NULL) return;
   obj = OldSpaceAllocateAligned(kPointerSize, kSimd128Unaligned);
   CHECK(IsAddressAligned(obj->address(), kSimd128Alignment, kPointerSize));
   // There is a filler object after the object.
   filler1 = HeapObject::FromAddress(start + kPointerSize);
   CHECK(obj != filler1 && filler1->IsFiller() &&
         filler1->Size() == kSimd128Size - kPointerSize);
   start = AlignOldSpace(kSimd128Unaligned, kPointerSize);
-  if (start == NULL) return;
   obj = OldSpaceAllocateAligned(kPointerSize, kSimd128Unaligned);
   CHECK(IsAddressAligned(obj->address(), kSimd128Alignment, kPointerSize));
   // There is a filler object before the object.
   filler1 = HeapObject::FromAddress(start);
   CHECK(obj != filler1 && filler1->IsFiller() &&
         filler1->Size() == kSimd128Size - kPointerSize);
 
   if (double_misalignment) {
     // Test the 2 other alignments possible on 32 bit platforms.
     start = AlignOldSpace(kSimd128Unaligned, 2 * kPointerSize);
-    if (start == NULL) return;
     obj = OldSpaceAllocateAligned(kPointerSize, kSimd128Unaligned);
     CHECK(IsAddressAligned(obj->address(), kSimd128Alignment, kPointerSize));
     // There are filler objects before and after the object.
     filler1 = HeapObject::FromAddress(start);
     CHECK(obj != filler1 && filler1->IsFiller() &&
           filler1->Size() == 2 * kPointerSize);
     filler2 = HeapObject::FromAddress(start + 3 * kPointerSize);
     CHECK(obj != filler2 && filler2->IsFiller() &&
           filler2->Size() == kPointerSize);
     start = AlignOldSpace(kSimd128Unaligned, 3 * kPointerSize);
-    if (start == NULL) return;
     obj = OldSpaceAllocateAligned(kPointerSize, kSimd128Unaligned);
     CHECK(IsAddressAligned(obj->address(), kSimd128Alignment, kPointerSize));
     // There are filler objects before and after the object.
     filler1 = HeapObject::FromAddress(start);
     CHECK(obj != filler1 && filler1->IsFiller() &&
           filler1->Size() == kPointerSize);
     filler2 = HeapObject::FromAddress(start + 2 * kPointerSize);
     CHECK(obj != filler2 && filler2->IsFiller() &&
           filler2->Size() == 2 * kPointerSize);
   }
@@ skipping 3277 matching lines @@
 
     Handle<FixedArray> temp2 =
         factory->NewFixedArray(padding_array_length, TENURED);
     Page* page = Page::FromAddress(temp2->address());
     CHECK_EQ(Page::kObjectStartOffset, page->Offset(temp2->address()));
   }
 
   Handle<JSObject> o = factory->NewJSObjectFromMap(map1, TENURED, false);
   o->set_properties(*factory->empty_fixed_array());
 
-  // Ensure that the object allocated where we need it.  If not, then abandon
-  // the test, since this isn't actually something we can reasonably require.
+  // Ensure that the object allocated where we need it.
   Page* page = Page::FromAddress(o->address());
-  if (desired_offset != page->Offset(o->address())) return;
+  CHECK_EQ(desired_offset, page->Offset(o->address()));
 
   // Now we have an object right at the end of the page.
 
   // Enable incremental marking to trigger actions in Heap::AdjustLiveBytes()
   // that would cause crash.
   IncrementalMarking* marking = CcTest::heap()->incremental_marking();
   marking->Abort();
   marking->Start(Heap::kNoGCFlags);
   CHECK(marking->IsMarking());
 
@@ skipping 638 matching lines @@
          HeapObject::RawField(*array, FixedArray::kHeaderSize));
   SlotsBuffer::RemoveObjectSlots(CcTest::i_isolate()->heap(), buffer, *array);
   DCHECK(reinterpret_cast<void*>(buffer->Get(1)) ==
          HeapObject::RawField(heap->empty_fixed_array(),
                               FixedArrayBase::kLengthOffset));
   DCHECK(reinterpret_cast<void*>(buffer->Get(2)) ==
          HeapObject::RawField(heap->empty_fixed_array(),
                               FixedArrayBase::kLengthOffset));
   delete buffer;
 }