Revert of [heap] Reland decrease large object limit for regular heap objects....

Revert of [heap] Reland decrease large object limit for regular heap objects. (patchset #3 id:40001 of https://codereview.chromium.org/1401173003/ )

Reason for revert:
Still one failing test on Windows.

Original issue's description:
> [heap] Reland decrease large object limit for regular heap objects.
>
> BUG=
>
> Committed: https://crrev.com/9b91bf3a630b5382080ba1d7f9f3e88de3de8a95
> Cr-Commit-Position: refs/heads/master@{#31228}

TBR=mlippautz@chromium.org
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true
BUG=

Review URL: https://codereview.chromium.org/1395653003

Cr-Commit-Position: refs/heads/master@{#31239}

src/heap/mark-compact.cc

@@ -2663,9 +2663,8 @@ void MarkCompactCollector::MigrateObject(
   Address dst_addr = dst->address();
   Address src_addr = src->address();
   DCHECK(heap()->AllowedToBeMigrated(src, dest));
-  DCHECK(dest != LO_SPACE);
+  DCHECK(dest != LO_SPACE && size <= Page::kMaxRegularHeapObjectSize);
   if (dest == OLD_SPACE) {
-    DCHECK_OBJECT_SIZE(size);
     DCHECK(evacuation_slots_buffer != nullptr);
     DCHECK(IsAligned(size, kPointerSize));
     switch (src->ContentType()) {
@@ -2689,14 +2688,12 @@ void MarkCompactCollector::MigrateObject(
                                   evacuation_slots_buffer);
     }
   } else if (dest == CODE_SPACE) {
-    DCHECK_CODEOBJECT_SIZE(size, heap()->code_space());
     DCHECK(evacuation_slots_buffer != nullptr);
     PROFILE(isolate(), CodeMoveEvent(src_addr, dst_addr));
     heap()->MoveBlock(dst_addr, src_addr, size);
     RecordMigratedCodeObjectSlot(dst_addr, evacuation_slots_buffer);
     Code::cast(dst)->Relocate(dst_addr - src_addr);
   } else {
-    DCHECK_OBJECT_SIZE(size);
     DCHECK(evacuation_slots_buffer == nullptr);
     DCHECK(dest == NEW_SPACE);
     heap()->MoveBlock(dst_addr, src_addr, size);
@@ -3080,6 +3077,8 @@ static String* UpdateReferenceInExternalStringTableEntry(Heap* heap,
 
 bool MarkCompactCollector::TryPromoteObject(HeapObject* object,
                                             int object_size) {
+  DCHECK(object_size <= Page::kMaxRegularHeapObjectSize);
+
   OldSpace* old_space = heap()->old_space();
 
   HeapObject* target = nullptr;

src/heap/scavenger.cc

@@ -216,7 +216,7 @@ class ScavengingVisitor : public StaticVisitorBase {
   template <ObjectContents object_contents, AllocationAlignment alignment>
   static inline void EvacuateObject(Map* map, HeapObject** slot,
                                     HeapObject* object, int object_size) {
-    SLOW_DCHECK(object_size <= Page::kAllocatableMemory);
+    SLOW_DCHECK(object_size <= Page::kMaxRegularHeapObjectSize);
     SLOW_DCHECK(object->Size() == object_size);
     Heap* heap = map->GetHeap();
 

src/heap/spaces-inl.h

@@ -133,12 +133,7 @@ HeapObject* HeapObjectIterator::FromCurrentPage() {
     }
 
     if (!obj->IsFiller()) {
-      if (obj->IsCode()) {
-        DCHECK_EQ(space_, space_->heap()->code_space());
-        DCHECK_CODEOBJECT_SIZE(obj_size, space_);
-      } else {
       DCHECK_OBJECT_SIZE(obj_size);
-      }
       return obj;
     }
   }

src/heap/spaces.h

@@ -86,9 +86,6 @@ class Isolate;
 #define DCHECK_OBJECT_SIZE(size) \
   DCHECK((0 < size) && (size <= Page::kMaxRegularHeapObjectSize))
 
-#define DCHECK_CODEOBJECT_SIZE(size, code_space) \
-  DCHECK((0 < size) && (size <= code_space->AreaSize()))
-
 #define DCHECK_PAGE_OFFSET(offset) \
   DCHECK((Page::kObjectStartOffset <= offset) && (offset <= Page::kPageSize))
 
@@ -843,7 +840,7 @@ class Page : public MemoryChunk {
   // memory. This also applies to new space allocation, since objects are never
   // migrated from new space to large object space. Takes double alignment into
   // account.
-  static const int kMaxRegularHeapObjectSize = 128 * KB * (i::kPointerSize / 4);
+  static const int kMaxRegularHeapObjectSize = kPageSize - kObjectStartOffset;
 
   static const int kAllocatableMemory = kPageSize - kObjectStartOffset;
 

src/objects.h

@@ -10048,14 +10048,9 @@ class JSArray: public JSObject {
   static const int kLengthOffset = JSObject::kHeaderSize;
   static const int kSize = kLengthOffset + kPointerSize;
 
-  // 128 * KB is the Page::kMaxRegularHeapObjectSize defined in spaces.h which
-  // we do not want to include in objects.h
-  // Note that Page::kMaxRegularHeapObjectSize has to be in sync with
-  // kInitialMaxFastElementArray which is checked in a DCHECK in heap.cc.
-  static const int kInitialMaxFastElementArray =
-      (128 * KB * (i::kPointerSize / 4) - FixedArray::kHeaderSize - kSize -
-       AllocationMemento::kSize) /
-      kPointerSize;
+  // Note that Page::kMaxRegularHeapObjectSize puts a limit on
+  // permissible values (see the DCHECK in heap.cc).
+  static const int kInitialMaxFastElementArray = 100000;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(JSArray);

test/cctest/test-serialize.cc

@@ -1223,15 +1223,15 @@ TEST(SerializeToplevelThreeBigStrings) {
       CompileRun("a")
           ->ToString(CcTest::isolate()->GetCurrentContext())
           .ToLocalChecked();
-  CHECK(heap->InSpace(*v8::Utils::OpenHandle(*result_str), LO_SPACE));
+  CHECK(heap->InSpace(*v8::Utils::OpenHandle(*result_str), OLD_SPACE));
   result_str = CompileRun("b")
                    ->ToString(CcTest::isolate()->GetCurrentContext())
                    .ToLocalChecked();
-  CHECK(heap->InSpace(*v8::Utils::OpenHandle(*result_str), LO_SPACE));
+  CHECK(heap->InSpace(*v8::Utils::OpenHandle(*result_str), OLD_SPACE));
   result_str = CompileRun("c")
                    ->ToString(CcTest::isolate()->GetCurrentContext())
                    .ToLocalChecked();
-  CHECK(heap->InSpace(*v8::Utils::OpenHandle(*result_str), LO_SPACE));
+  CHECK(heap->InSpace(*v8::Utils::OpenHandle(*result_str), OLD_SPACE));
 
   delete cache;
   source_a.Dispose();

test/cctest/test-spaces.cc

@@ -430,8 +430,7 @@ TEST(CompactionSpace) {
   // and would thus neither grow, nor be able to allocate an object.
   const int kNumObjects = 100;
   const int kExpectedPages = (kNumObjects / (compaction_space->AreaSize() /
-                                             Page::kMaxRegularHeapObjectSize)) +
-                             1;
+                                             Page::kMaxRegularHeapObjectSize));
   for (int i = 0; i < kNumObjects; i++) {
     compaction_space->AllocateRawUnaligned(Page::kMaxRegularHeapObjectSize)
         .ToObjectChecked();