1 files changed, 172 insertions, 30 deletions

diff --git a/deps/v8/test/cctest/test-heap.cc b/deps/v8/test/cctest/test-heap.cc
index 68ed83d145..be1098cc4c 100644
--- a/deps/v8/test/cctest/test-heap.cc
+++ b/deps/v8/test/cctest/test-heap.cc
@@ -403,6 +403,7 @@ static void TestWeakGlobalHandleCallback(v8::Isolate* isolate,
 
 
 TEST(WeakGlobalHandlesScavenge) {
+  i::FLAG_stress_compaction = false;
   CcTest::InitializeVM();
   Isolate* isolate = Isolate::Current();
   Heap* heap = isolate->heap();
@@ -489,6 +490,7 @@ TEST(WeakGlobalHandlesMark) {
 
 
 TEST(DeleteWeakGlobalHandle) {
+  i::FLAG_stress_compaction = false;
   CcTest::InitializeVM();
   Isolate* isolate = Isolate::Current();
   Heap* heap = isolate->heap();
@@ -877,6 +879,7 @@ TEST(StringAllocation) {
 static int ObjectsFoundInHeap(Heap* heap, Handle<Object> objs[], int size) {
   // Count the number of objects found in the heap.
   int found_count = 0;
+  heap->EnsureHeapIsIterable();
   HeapIterator iterator(heap);
   for (HeapObject* obj = iterator.next(); obj != NULL; obj = iterator.next()) {
     for (int i = 0; i < size; i++) {
@@ -1969,14 +1972,15 @@ TEST(PrototypeTransitionClearing) {
   CHECK(!space->LastPage()->Contains(
       map->GetPrototypeTransitions()->address()));
   CHECK(space->LastPage()->Contains(prototype->address()));
-  baseObject->SetPrototype(*prototype, false)->ToObjectChecked();
-  CHECK(map->GetPrototypeTransition(*prototype)->IsMap());
+  JSObject::SetPrototype(baseObject, prototype, false);
+  CHECK(Map::GetPrototypeTransition(map, prototype)->IsMap());
   HEAP->CollectAllGarbage(Heap::kNoGCFlags);
-  CHECK(map->GetPrototypeTransition(*prototype)->IsMap());
+  CHECK(Map::GetPrototypeTransition(map, prototype)->IsMap());
 }
 
 
 TEST(ResetSharedFunctionInfoCountersDuringIncrementalMarking) {
+  i::FLAG_stress_compaction = false;
   i::FLAG_allow_natives_syntax = true;
 #ifdef VERIFY_HEAP
   i::FLAG_verify_heap = true;
@@ -2033,6 +2037,7 @@ TEST(ResetSharedFunctionInfoCountersDuringIncrementalMarking) {
 
 
 TEST(ResetSharedFunctionInfoCountersDuringMarkSweep) {
+  i::FLAG_stress_compaction = false;
   i::FLAG_allow_natives_syntax = true;
 #ifdef VERIFY_HEAP
   i::FLAG_verify_heap = true;
@@ -2104,8 +2109,7 @@ TEST(OptimizedAllocationAlwaysInNewSpace) {
 }
 
 
-// Test pretenuring of array literals allocated with HAllocate.
-TEST(OptimizedPretenuringArrayLiterals) {
+TEST(OptimizedPretenuringObjectArrayLiterals) {
   i::FLAG_allow_natives_syntax = true;
   CcTest::InitializeVM();
   if (!i::V8::UseCrankshaft() || i::FLAG_always_opt) return;
@@ -2113,11 +2117,9 @@ TEST(OptimizedPretenuringArrayLiterals) {
   v8::HandleScope scope(CcTest::isolate());
   HEAP->SetNewSpaceHighPromotionModeActive(true);
 
-  AlwaysAllocateScope always_allocate;
   v8::Local<v8::Value> res = CompileRun(
       "function f() {"
-      "  var numbers = [1, 2, 3];"
-      "  numbers[0] = {};"
+      "  var numbers = [{}, {}, {}];"
       "  return numbers;"
       "};"
       "f(); f(); f();"
@@ -2128,21 +2130,22 @@ TEST(OptimizedPretenuringArrayLiterals) {
       v8::Utils::OpenHandle(*v8::Handle<v8::Object>::Cast(res));
 
   CHECK(HEAP->InOldPointerSpace(o->elements()));
+  CHECK(HEAP->InOldPointerSpace(*o));
 }
 
 
-TEST(OptimizedPretenuringSimpleArrayLiterals) {
+TEST(OptimizedPretenuringMixedInObjectProperties) {
   i::FLAG_allow_natives_syntax = true;
-  i::FLAG_pretenuring = false;
   CcTest::InitializeVM();
   if (!i::V8::UseCrankshaft() || i::FLAG_always_opt) return;
   if (i::FLAG_gc_global || i::FLAG_stress_compaction) return;
   v8::HandleScope scope(CcTest::isolate());
+  HEAP->SetNewSpaceHighPromotionModeActive(true);
 
-  AlwaysAllocateScope always_allocate;
   v8::Local<v8::Value> res = CompileRun(
       "function f() {"
-      "  return [1, 2, 3];"
+      "  var numbers = {a: {c: 2.2, d: {}}, b: 1.1};"
+      "  return numbers;"
       "};"
       "f(); f(); f();"
       "%OptimizeFunctionOnNextCall(f);"
@@ -2151,62 +2154,198 @@ TEST(OptimizedPretenuringSimpleArrayLiterals) {
   Handle<JSObject> o =
       v8::Utils::OpenHandle(*v8::Handle<v8::Object>::Cast(res));
 
-  CHECK(HEAP->InNewSpace(*o));
+  CHECK(HEAP->InOldPointerSpace(*o));
+  CHECK(HEAP->InOldPointerSpace(o->RawFastPropertyAt(0)));
+  CHECK(HEAP->InOldDataSpace(o->RawFastPropertyAt(1)));
+
+  JSObject* inner_object = reinterpret_cast<JSObject*>(o->RawFastPropertyAt(0));
+  CHECK(HEAP->InOldPointerSpace(inner_object));
+  CHECK(HEAP->InOldDataSpace(inner_object->RawFastPropertyAt(0)));
+  CHECK(HEAP->InOldPointerSpace(inner_object->RawFastPropertyAt(1)));
 }
 
 
-// Test regular array literals allocation.
-TEST(OptimizedAllocationArrayLiterals) {
+TEST(OptimizedPretenuringDoubleArrayProperties) {
   i::FLAG_allow_natives_syntax = true;
   CcTest::InitializeVM();
   if (!i::V8::UseCrankshaft() || i::FLAG_always_opt) return;
   if (i::FLAG_gc_global || i::FLAG_stress_compaction) return;
   v8::HandleScope scope(CcTest::isolate());
+  HEAP->SetNewSpaceHighPromotionModeActive(true);
 
-  AlwaysAllocateScope always_allocate;
   v8::Local<v8::Value> res = CompileRun(
       "function f() {"
-      "  var numbers = new Array(1, 2, 3);"
-      "  numbers[0] = 3.14;"
+      "  var numbers = {a: 1.1, b: 2.2};"
       "  return numbers;"
       "};"
       "f(); f(); f();"
       "%OptimizeFunctionOnNextCall(f);"
       "f();");
-  CHECK_EQ(static_cast<int>(3.14),
-           v8::Object::Cast(*res)->Get(v8_str("0"))->Int32Value());
 
   Handle<JSObject> o =
       v8::Utils::OpenHandle(*v8::Handle<v8::Object>::Cast(res));
 
-  CHECK(HEAP->InNewSpace(o->elements()));
+  CHECK(HEAP->InOldPointerSpace(*o));
+  CHECK(HEAP->InOldDataSpace(o->properties()));
 }
 
 
-TEST(OptimizedPretenuringCallNew) {
+TEST(OptimizedPretenuringdoubleArrayLiterals) {
+  i::FLAG_allow_natives_syntax = true;
+  CcTest::InitializeVM();
+  if (!i::V8::UseCrankshaft() || i::FLAG_always_opt) return;
+  if (i::FLAG_gc_global || i::FLAG_stress_compaction) return;
+  v8::HandleScope scope(CcTest::isolate());
+  HEAP->SetNewSpaceHighPromotionModeActive(true);
+
+  v8::Local<v8::Value> res = CompileRun(
+      "function f() {"
+      "  var numbers = [1.1, 2.2, 3.3];"
+      "  return numbers;"
+      "};"
+      "f(); f(); f();"
+      "%OptimizeFunctionOnNextCall(f);"
+      "f();");
+
+  Handle<JSObject> o =
+      v8::Utils::OpenHandle(*v8::Handle<v8::Object>::Cast(res));
+
+  CHECK(HEAP->InOldDataSpace(o->elements()));
+  CHECK(HEAP->InOldPointerSpace(*o));
+}
+
+
+TEST(OptimizedPretenuringNestedMixedArrayLiterals) {
+  i::FLAG_allow_natives_syntax = true;
+  CcTest::InitializeVM();
+  if (!i::V8::UseCrankshaft() || i::FLAG_always_opt) return;
+  if (i::FLAG_gc_global || i::FLAG_stress_compaction) return;
+  v8::HandleScope scope(CcTest::isolate());
+  HEAP->SetNewSpaceHighPromotionModeActive(true);
+
+  v8::Local<v8::Value> res = CompileRun(
+      "function f() {"
+      "  var numbers = [[{}, {}, {}],[1.1, 2.2, 3.3]];"
+      "  return numbers;"
+      "};"
+      "f(); f(); f();"
+      "%OptimizeFunctionOnNextCall(f);"
+      "f();");
+
+  v8::Local<v8::Value> int_array = v8::Object::Cast(*res)->Get(v8_str("0"));
+  Handle<JSObject> int_array_handle =
+      v8::Utils::OpenHandle(*v8::Handle<v8::Object>::Cast(int_array));
+  v8::Local<v8::Value> double_array = v8::Object::Cast(*res)->Get(v8_str("1"));
+  Handle<JSObject> double_array_handle =
+      v8::Utils::OpenHandle(*v8::Handle<v8::Object>::Cast(double_array));
+
+  Handle<JSObject> o =
+      v8::Utils::OpenHandle(*v8::Handle<v8::Object>::Cast(res));
+  CHECK(HEAP->InOldPointerSpace(*o));
+  CHECK(HEAP->InOldPointerSpace(*int_array_handle));
+  CHECK(HEAP->InOldPointerSpace(int_array_handle->elements()));
+  CHECK(HEAP->InOldPointerSpace(*double_array_handle));
+  CHECK(HEAP->InOldDataSpace(double_array_handle->elements()));
+}
+
+
+TEST(OptimizedPretenuringNestedObjectLiterals) {
   i::FLAG_allow_natives_syntax = true;
-  i::FLAG_pretenuring_call_new = true;
   CcTest::InitializeVM();
   if (!i::V8::UseCrankshaft() || i::FLAG_always_opt) return;
   if (i::FLAG_gc_global || i::FLAG_stress_compaction) return;
   v8::HandleScope scope(CcTest::isolate());
   HEAP->SetNewSpaceHighPromotionModeActive(true);
 
-  AlwaysAllocateScope always_allocate;
   v8::Local<v8::Value> res = CompileRun(
-      "function g() { this.a = 0; }"
       "function f() {"
-      "  return new g();"
+      "  var numbers = [[{}, {}, {}],[{}, {}, {}]];"
+      "  return numbers;"
       "};"
       "f(); f(); f();"
       "%OptimizeFunctionOnNextCall(f);"
       "f();");
 
+  v8::Local<v8::Value> int_array_1 = v8::Object::Cast(*res)->Get(v8_str("0"));
+  Handle<JSObject> int_array_handle_1 =
+      v8::Utils::OpenHandle(*v8::Handle<v8::Object>::Cast(int_array_1));
+  v8::Local<v8::Value> int_array_2 = v8::Object::Cast(*res)->Get(v8_str("1"));
+  Handle<JSObject> int_array_handle_2 =
+      v8::Utils::OpenHandle(*v8::Handle<v8::Object>::Cast(int_array_2));
+
   Handle<JSObject> o =
       v8::Utils::OpenHandle(*v8::Handle<v8::Object>::Cast(res));
   CHECK(HEAP->InOldPointerSpace(*o));
+  CHECK(HEAP->InOldPointerSpace(*int_array_handle_1));
+  CHECK(HEAP->InOldPointerSpace(int_array_handle_1->elements()));
+  CHECK(HEAP->InOldPointerSpace(*int_array_handle_2));
+  CHECK(HEAP->InOldPointerSpace(int_array_handle_2->elements()));
 }
 
+
+TEST(OptimizedPretenuringNestedDoubleLiterals) {
+  i::FLAG_allow_natives_syntax = true;
+  CcTest::InitializeVM();
+  if (!i::V8::UseCrankshaft() || i::FLAG_always_opt) return;
+  if (i::FLAG_gc_global || i::FLAG_stress_compaction) return;
+  v8::HandleScope scope(CcTest::isolate());
+  HEAP->SetNewSpaceHighPromotionModeActive(true);
+
+  v8::Local<v8::Value> res = CompileRun(
+      "function f() {"
+      "  var numbers = [[1.1, 1.2, 1.3],[2.1, 2.2, 2.3]];"
+      "  return numbers;"
+      "};"
+      "f(); f(); f();"
+      "%OptimizeFunctionOnNextCall(f);"
+      "f();");
+
+  v8::Local<v8::Value> double_array_1 =
+      v8::Object::Cast(*res)->Get(v8_str("0"));
+  Handle<JSObject> double_array_handle_1 =
+      v8::Utils::OpenHandle(*v8::Handle<v8::Object>::Cast(double_array_1));
+  v8::Local<v8::Value> double_array_2 =
+      v8::Object::Cast(*res)->Get(v8_str("1"));
+  Handle<JSObject> double_array_handle_2 =
+      v8::Utils::OpenHandle(*v8::Handle<v8::Object>::Cast(double_array_2));
+
+  Handle<JSObject> o =
+      v8::Utils::OpenHandle(*v8::Handle<v8::Object>::Cast(res));
+  CHECK(HEAP->InOldPointerSpace(*o));
+  CHECK(HEAP->InOldPointerSpace(*double_array_handle_1));
+  CHECK(HEAP->InOldDataSpace(double_array_handle_1->elements()));
+  CHECK(HEAP->InOldPointerSpace(*double_array_handle_2));
+  CHECK(HEAP->InOldDataSpace(double_array_handle_2->elements()));
+}
+
+
+// Test regular array literals allocation.
+TEST(OptimizedAllocationArrayLiterals) {
+  i::FLAG_allow_natives_syntax = true;
+  CcTest::InitializeVM();
+  if (!i::V8::UseCrankshaft() || i::FLAG_always_opt) return;
+  if (i::FLAG_gc_global || i::FLAG_stress_compaction) return;
+  v8::HandleScope scope(CcTest::isolate());
+
+  v8::Local<v8::Value> res = CompileRun(
+      "function f() {"
+      "  var numbers = new Array(1, 2, 3);"
+      "  numbers[0] = 3.14;"
+      "  return numbers;"
+      "};"
+      "f(); f(); f();"
+      "%OptimizeFunctionOnNextCall(f);"
+      "f();");
+  CHECK_EQ(static_cast<int>(3.14),
+           v8::Object::Cast(*res)->Get(v8_str("0"))->Int32Value());
+
+  Handle<JSObject> o =
+      v8::Utils::OpenHandle(*v8::Handle<v8::Object>::Cast(res));
+
+  CHECK(HEAP->InNewSpace(o->elements()));
+}
+
+
 static int CountMapTransitions(Map* map) {
   return map->transitions()->number_of_transitions();
 }
@@ -2215,6 +2354,7 @@ static int CountMapTransitions(Map* map) {
 // Test that map transitions are cleared and maps are collected with
 // incremental marking as well.
 TEST(Regress1465) {
+  i::FLAG_stress_compaction = false;
   i::FLAG_allow_natives_syntax = true;
   i::FLAG_trace_incremental_marking = true;
   CcTest::InitializeVM();
@@ -2382,6 +2522,7 @@ TEST(ReleaseOverReservedPages) {
 
 
 TEST(Regress2237) {
+  i::FLAG_stress_compaction = false;
   CcTest::InitializeVM();
   Isolate* isolate = Isolate::Current();
   Factory* factory = isolate->factory();
@@ -2498,15 +2639,15 @@ TEST(IncrementalMarkingClearsTypeFeedbackCells) {
       f->shared()->code()->type_feedback_info())->type_feedback_cells());
 
   CHECK_EQ(2, cells->CellCount());
-  CHECK(cells->Cell(0)->value()->IsJSFunction());
-  CHECK(cells->Cell(1)->value()->IsJSFunction());
+  CHECK(cells->GetCell(0)->value()->IsJSFunction());
+  CHECK(cells->GetCell(1)->value()->IsJSFunction());
 
   SimulateIncrementalMarking();
   HEAP->CollectAllGarbage(Heap::kNoGCFlags);
 
   CHECK_EQ(2, cells->CellCount());
-  CHECK(cells->Cell(0)->value()->IsTheHole());
-  CHECK(cells->Cell(1)->value()->IsTheHole());
+  CHECK(cells->GetCell(0)->value()->IsTheHole());
+  CHECK(cells->GetCell(1)->value()->IsTheHole());
 }
 
 
@@ -2689,6 +2830,7 @@ TEST(ReleaseStackTraceData) {
 
 
 TEST(Regression144230) {
+  i::FLAG_stress_compaction = false;
   CcTest::InitializeVM();
   Isolate* isolate = Isolate::Current();
   Heap* heap = isolate->heap();