Reverting r4685, r4686, r4687

test/cctest/test-heap.cc

 // Copyright 2006-2008 the V8 project authors. All rights reserved.
 
 #include <stdlib.h>
 
 #include "v8.h"
 
 #include "execution.h"
 #include "factory.h"
 #include "macro-assembler.h"
 #include "global-handles.h"
@@ skipping 159 matching lines @@
   // Check ToString for Numbers
   CheckNumber(1.1, "1.1");
 
   CheckFindCodeObject();
 }
 
 
 TEST(Tagging) {
   InitializeVM();
   int request = 24;
-  CHECK_EQ(request, static_cast<int>(OBJECT_POINTER_ALIGN(request)));
+  CHECK_EQ(request, static_cast<int>(OBJECT_SIZE_ALIGN(request)));
   CHECK(Smi::FromInt(42)->IsSmi());
   CHECK(Failure::RetryAfterGC(request, NEW_SPACE)->IsFailure());
   CHECK_EQ(request, Failure::RetryAfterGC(request, NEW_SPACE)->requested());
   CHECK_EQ(NEW_SPACE,
            Failure::RetryAfterGC(request, NEW_SPACE)->allocation_space());
   CHECK_EQ(OLD_POINTER_SPACE,
            Failure::RetryAfterGC(request,
                                  OLD_POINTER_SPACE)->allocation_space());
   CHECK(Failure::Exception()->IsFailure());
   CHECK(Smi::FromInt(Smi::kMinValue)->IsSmi());
@@ skipping 468 matching lines @@
   array->SetElement(0, *name);
   CHECK_EQ(Smi::FromInt(1), array->length());
   CHECK_EQ(array->GetElement(0), *name);
 
   // Set array length with larger than smi value.
   Handle<Object> length =
       Factory::NewNumberFromUint(static_cast<uint32_t>(Smi::kMaxValue) + 1);
   array->SetElementsLength(*length);
 
   uint32_t int_length = 0;
-  CHECK(length->ToArrayIndex(&int_length));
+  CHECK(Array::IndexFromObject(*length, &int_length));
   CHECK_EQ(*length, array->length());
   CHECK(array->HasDictionaryElements());  // Must be in slow mode.
 
   // array[length] = name.
   array->SetElement(int_length, *name);
   uint32_t new_int_length = 0;
-  CHECK(array->length()->ToArrayIndex(&new_int_length));
+  CHECK(Array::IndexFromObject(array->length(), &new_int_length));
   CHECK_EQ(static_cast<double>(int_length), new_int_length - 1);
   CHECK_EQ(array->GetElement(int_length), *name);
   CHECK_EQ(array->GetElement(0), *name);
 }
 
 
 TEST(JSObjectCopy) {
   InitializeVM();
 
   v8::HandleScope sc;
@@ skipping 136 matching lines @@
   Address next_page = current_page + Page::kPageSize;
   int bytes_to_page = static_cast<int>(next_page - current_top);
   if (bytes_to_page <= FixedArray::kHeaderSize) {
     // Alas, need to cross another page to be able to
     // put desired value.
     next_page += Page::kPageSize;
     bytes_to_page = static_cast<int>(next_page - current_top);
   }
   CHECK(bytes_to_page > FixedArray::kHeaderSize);
 
-  intptr_t* flags_ptr = &Page::FromAddress(next_page)->flags_;
+  int* flags_ptr = &Page::FromAddress(next_page)->flags;
   Address flags_addr = reinterpret_cast<Address>(flags_ptr);
 
   int bytes_to_allocate =
       static_cast<int>(flags_addr - current_top) + kPointerSize;
 
   int n_elements = (bytes_to_allocate - FixedArray::kHeaderSize) /
       kPointerSize;
   CHECK_EQ(bytes_to_allocate, FixedArray::SizeFor(n_elements));
   FixedArray* array = FixedArray::cast(
       Heap::AllocateFixedArray(n_elements));
@@ skipping 37 matching lines @@
   InitializeVM();
 
   // Increase the chance of 'bump-the-pointer' allocation in old space.
   bool force_compaction = true;
   Heap::CollectAllGarbage(force_compaction);
 
   v8::HandleScope scope;
 
   // The plan: create JSObject which references objects in new space.
   // Then clone this object (forcing it to go into old space) and check
-  // that region dirty marks are updated correctly.
+  // that only bits pertaining to the object are updated in remembered set.
 
   // Step 1: prepare a map for the object.  We add 1 inobject property to it.
   Handle<JSFunction> object_ctor(Top::global_context()->object_function());
   CHECK(object_ctor->has_initial_map());
   Handle<Map> object_map(object_ctor->initial_map());
   // Create a map with single inobject property.
   Handle<Map> my_map = Factory::CopyMap(object_map, 1);
   int n_properties = my_map->inobject_properties();
   CHECK_GT(n_properties, 0);
 
@@ skipping 22 matching lines @@
 
   CHECK(!Heap::always_allocate());
   Object* array = Heap::AllocateFixedArray(fixed_array_len);
   CHECK(!array->IsFailure());
   CHECK(new_space->Contains(array));
 
   Object* object = Heap::AllocateJSObjectFromMap(*my_map);
   CHECK(!object->IsFailure());
   CHECK(new_space->Contains(object));
   JSObject* jsobject = JSObject::cast(object);
-  CHECK_EQ(0, FixedArray::cast(jsobject->elements())->length());
+  CHECK_EQ(0, jsobject->elements()->length());
   CHECK_EQ(0, jsobject->properties()->length());
   // Create a reference to object in new space in jsobject.
   jsobject->FastPropertyAtPut(-1, array);
 
   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.
   Address old_pointer_space_top = Heap::old_pointer_space()->top();
   AlwaysAllocateScope aa_scope;
   Object* clone_obj = Heap::CopyJSObject(jsobject);
   CHECK(!object->IsFailure());
   JSObject* clone = JSObject::cast(clone_obj);
   if (clone->address() != old_pointer_space_top) {
     // Alas, got allocated from free list, we cannot do checks.
     return;
   }
   CHECK(Heap::old_pointer_space()->Contains(clone->address()));
 
-  // Step 5: verify validity of region dirty marks.
+  // Step 5: verify validity of remembered set.
   Address clone_addr = clone->address();
   Page* page = Page::FromAddress(clone_addr);
-  // Check that region covering inobject property 1 is marked dirty.
-  CHECK(page->IsRegionDirty(clone_addr + (object_size - kPointerSize)));
+  // Check that remembered set tracks a reference from inobject property 1.
+  CHECK(page->IsRSetSet(clone_addr, object_size - kPointerSize));
+  // Probe several addresses after the object.
+  for (int i = 0; i < 7; i++) {
+    int offset = object_size + i * kPointerSize;
+    if (clone_addr + offset >= page->ObjectAreaEnd()) {
+      break;
+    }
+    CHECK(!page->IsRSetSet(clone_addr, offset));
+  }
 }