Reland "Merge old data and pointer space."

test/cctest/test-unboxed-doubles.cc

 // Copyright 2014 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 <stdlib.h>
 #include <utility>
 
 #include "src/v8.h"
 
 #include "src/compilation-cache.h"
@@ skipping 1033 matching lines @@
   double boom_value = bit_cast<double>(fake_object);
 
   FieldIndex field_index = FieldIndex::ForDescriptor(obj->map(), 0);
   Handle<HeapNumber> boom_number = factory->NewHeapNumber(boom_value, MUTABLE);
   obj->FastPropertyAtPut(field_index, *boom_number);
 
   // Now |obj| moves to old gen and it has a double field that looks like
   // a pointer to a from semi-space.
   CcTest::heap()->CollectGarbage(i::NEW_SPACE, "boom");
 
-  CHECK(isolate->heap()->old_pointer_space()->Contains(*obj));
+  CHECK(isolate->heap()->old_space()->Contains(*obj));
 
   CHECK_EQ(boom_value, GetDoubleFieldValue(*obj, field_index));
 }
 
 
 TEST(DoScavengeWithIncrementalWriteBarrier) {
   if (FLAG_never_compact || !FLAG_incremental_marking) return;
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
   Factory* factory = isolate->factory();
   Heap* heap = CcTest::heap();
-  PagedSpace* old_pointer_space = heap->old_pointer_space();
+  PagedSpace* old_space = heap->old_space();
 
   // The plan: create |obj_value| in old space and ensure that it is allocated
   // on evacuation candidate page, create |obj| with double and tagged fields
   // in new space and write |obj_value| to tagged field of |obj|, do two
   // scavenges to promote |obj| to old space, a GC in old space and ensure that
   // the tagged value was properly updated after candidates evacuation.
 
   Handle<HeapType> any_type = HeapType::Any(isolate);
   Handle<Map> map = Map::Create(isolate, 10);
   map = Map::CopyWithField(map, MakeName("prop", 0), any_type, NONE,
                            Representation::Double(),
                            INSERT_TRANSITION).ToHandleChecked();
   map = Map::CopyWithField(map, MakeName("prop", 1), any_type, NONE,
                            Representation::Tagged(),
                            INSERT_TRANSITION).ToHandleChecked();
 
   // Create |obj_value| in old space.
   Handle<HeapObject> obj_value;
   Page* ec_page;
   {
     AlwaysAllocateScope always_allocate(isolate);
     // Make sure |obj_value| is placed on an old-space evacuation candidate.
-    SimulateFullSpace(old_pointer_space);
+    SimulateFullSpace(old_space);
     obj_value = factory->NewJSArray(32 * KB, FAST_HOLEY_ELEMENTS, TENURED);
     ec_page = Page::FromAddress(obj_value->address());
   }
 
   // Create object in new space.
   Handle<JSObject> obj = factory->NewJSObjectFromMap(map, NOT_TENURED, false);
 
   Handle<HeapNumber> heap_number = factory->NewHeapNumber(42.5);
   obj->WriteToField(0, *heap_number);
   obj->WriteToField(1, *obj_value);
@@ skipping 25 matching lines @@
   // in compacting mode and |obj_value|'s page is an evacuation candidate).
   IncrementalMarking* marking = heap->incremental_marking();
   CHECK(marking->IsCompacting());
   CHECK(Marking::IsBlack(Marking::MarkBitFrom(*obj)));
   CHECK(MarkCompactCollector::IsOnEvacuationCandidate(*obj_value));
 
   // Trigger GCs so that |obj| moves to old gen.
   heap->CollectGarbage(i::NEW_SPACE);  // in survivor space now
   heap->CollectGarbage(i::NEW_SPACE);  // in old gen now
 
-  CHECK(isolate->heap()->old_pointer_space()->Contains(*obj));
-  CHECK(isolate->heap()->old_pointer_space()->Contains(*obj_value));
+  CHECK(isolate->heap()->old_space()->Contains(*obj));
+  CHECK(isolate->heap()->old_space()->Contains(*obj_value));
   CHECK(MarkCompactCollector::IsOnEvacuationCandidate(*obj_value));
 
-  heap->CollectGarbage(i::OLD_POINTER_SPACE, "boom");
+  heap->CollectGarbage(i::OLD_SPACE, "boom");
 
   // |obj_value| must be evacuated.
   CHECK(!MarkCompactCollector::IsOnEvacuationCandidate(*obj_value));
 
   FieldIndex field_index = FieldIndex::ForDescriptor(*map, 1);
   CHECK_EQ(*obj_value, obj->RawFastPropertyAt(field_index));
 }
 
 
 static void TestLayoutDescriptorHelper(Isolate* isolate,
@@ skipping 212 matching lines @@
     CHECK(field_index.is_inobject() && field_index.is_double());
     CHECK_EQ(FLAG_unbox_double_fields, map->IsUnboxedDoubleField(field_index));
     CHECK_EQ(42.5, GetDoubleFieldValue(*obj, field_index));
   }
   CHECK(isolate->heap()->new_space()->Contains(*obj));
 
   // Trigger GCs so that the newly allocated object moves to old gen.
   CcTest::heap()->CollectGarbage(i::NEW_SPACE);  // in survivor space now
   CcTest::heap()->CollectGarbage(i::NEW_SPACE);  // in old gen now
 
-  CHECK(isolate->heap()->old_pointer_space()->Contains(*obj));
+  CHECK(isolate->heap()->old_space()->Contains(*obj));
 
   // Create temp object in the new space.
   Handle<JSArray> temp = factory->NewJSArray(FAST_ELEMENTS, NOT_TENURED);
   CHECK(isolate->heap()->new_space()->Contains(*temp));
 
   // Construct a double value that looks like a pointer to the new space object
   // and store it into the obj.
   Address fake_object = reinterpret_cast<Address>(*temp) + kPointerSize;
   double boom_value = bit_cast<double>(fake_object);
 
@@ skipping 81 matching lines @@
   FieldIndex index = FieldIndex::ForDescriptor(*my_map, 0);
   jsobject->RawFastDoublePropertyAtPut(index, boom_value);
 
   CHECK_EQ(0, static_cast<int>(*limit_addr - *top_addr));
 
   // Step 4: clone jsobject, but force always allocate first to create a clone
   // in old pointer space.
   AlwaysAllocateScope aa_scope(isolate);
   Object* clone_obj = heap->CopyJSObject(jsobject).ToObjectChecked();
   Handle<JSObject> clone(JSObject::cast(clone_obj));
-  CHECK(heap->old_pointer_space()->Contains(clone->address()));
+  CHECK(heap->old_space()->Contains(clone->address()));
 
   CcTest::heap()->CollectGarbage(NEW_SPACE, "boom");
 
   // The value in cloned object should not be corrupted by GC.
   CHECK_EQ(boom_value, clone->RawFastDoublePropertyAt(index));
 }
 
 
 static void TestWriteBarrier(Handle<Map> map, Handle<Map> new_map,
                              int tagged_descriptor, int double_descriptor,
                              bool check_tagged_value = true) {
   FLAG_stress_compaction = true;
   FLAG_manual_evacuation_candidates_selection = true;
   Isolate* isolate = CcTest::i_isolate();
   Factory* factory = isolate->factory();
   Heap* heap = CcTest::heap();
-  PagedSpace* old_pointer_space = heap->old_pointer_space();
+  PagedSpace* old_space = heap->old_space();
 
   // The plan: create |obj| by |map| in old space, create |obj_value| in
   // new space and ensure that write barrier is triggered when |obj_value| is
   // written to property |tagged_descriptor| of |obj|.
   // Then migrate object to |new_map| and set proper value for property
   // |double_descriptor|. Call GC and ensure that it did not crash during
   // store buffer entries updating.
 
   Handle<JSObject> obj;
   Handle<HeapObject> obj_value;
   {
     AlwaysAllocateScope always_allocate(isolate);
     obj = factory->NewJSObjectFromMap(map, TENURED, false);
-    CHECK(old_pointer_space->Contains(*obj));
+    CHECK(old_space->Contains(*obj));
 
     obj_value = factory->NewJSArray(32 * KB, FAST_HOLEY_ELEMENTS);
   }
 
   CHECK(heap->InNewSpace(*obj_value));
 
   {
     FieldIndex index = FieldIndex::ForDescriptor(*map, tagged_descriptor);
     const int n = 153;
     for (int i = 0; i < n; i++) {
@@ skipping 28 matching lines @@
 static void TestIncrementalWriteBarrier(Handle<Map> map, Handle<Map> new_map,
                                         int tagged_descriptor,
                                         int double_descriptor,
                                         bool check_tagged_value = true) {
   if (FLAG_never_compact || !FLAG_incremental_marking) return;
   FLAG_stress_compaction = true;
   FLAG_manual_evacuation_candidates_selection = true;
   Isolate* isolate = CcTest::i_isolate();
   Factory* factory = isolate->factory();
   Heap* heap = CcTest::heap();
-  PagedSpace* old_pointer_space = heap->old_pointer_space();
+  PagedSpace* old_space = heap->old_space();
 
   // The plan: create |obj| by |map| in old space, create |obj_value| in
   // old space and ensure it end up in evacuation candidate page. Start
   // incremental marking and ensure that incremental write barrier is triggered
   // when |obj_value| is written to property |tagged_descriptor| of |obj|.
   // Then migrate object to |new_map| and set proper value for property
   // |double_descriptor|. Call GC and ensure that it did not crash during
   // slots buffer entries updating.
 
   Handle<JSObject> obj;
   Handle<HeapObject> obj_value;
   Page* ec_page;
   {
     AlwaysAllocateScope always_allocate(isolate);
     obj = factory->NewJSObjectFromMap(map, TENURED, false);
-    CHECK(old_pointer_space->Contains(*obj));
+    CHECK(old_space->Contains(*obj));
 
     // Make sure |obj_value| is placed on an old-space evacuation candidate.
-    SimulateFullSpace(old_pointer_space);
+    SimulateFullSpace(old_space);
     obj_value = factory->NewJSArray(32 * KB, FAST_HOLEY_ELEMENTS, TENURED);
     ec_page = Page::FromAddress(obj_value->address());
     CHECK_NE(ec_page, Page::FromAddress(obj->address()));
   }
 
   // Heap is ready, force |ec_page| to become an evacuation candidate and
   // simulate incremental marking.
   ec_page->SetFlag(MemoryChunk::FORCE_EVACUATION_CANDIDATE_FOR_TESTING);
   SimulateIncrementalMarking(heap);
 
@@ skipping 26 matching lines @@
   JSObject::MigrateToMap(obj, new_map);
 
   double boom_value = bit_cast<double>(UINT64_C(0xbaad0176a37c28e1));
 
   FieldIndex double_field_index =
       FieldIndex::ForDescriptor(*new_map, double_descriptor);
   CHECK(obj->IsUnboxedDoubleField(double_field_index));
   obj->RawFastDoublePropertyAtPut(double_field_index, boom_value);
 
   // Trigger GC to evacuate all candidates.
-  CcTest::heap()->CollectGarbage(OLD_POINTER_SPACE, "boom");
+  CcTest::heap()->CollectGarbage(OLD_SPACE, "boom");
 
   // Ensure that the values are still there and correct.
   CHECK(!MarkCompactCollector::IsOnEvacuationCandidate(*obj_value));
 
   if (check_tagged_value) {
     FieldIndex tagged_field_index =
         FieldIndex::ForDescriptor(*new_map, tagged_descriptor);
     CHECK_EQ(*obj_value, obj->RawFastPropertyAt(tagged_field_index));
   }
   CHECK_EQ(boom_value, obj->RawFastDoublePropertyAt(double_field_index));
@@ skipping 49 matching lines @@
 
 // TODO(ishell): add respective tests for property kind reconfiguring from
 // accessor field to double, once accessor fields are supported by
 // Map::ReconfigureProperty().
 
 
 // TODO(ishell): add respective tests for fast property removal case once
 // Map::ReconfigureProperty() supports that.
 
 #endif