CSE2410 Fall 2014 Bounce

// 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

//       with the distribution.

//     * Neither the name of Google Inc. nor the names of its

//       contributors may be used to endorse or promote products derived

//       from this software without specific prior written permission.

//

// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

#include <stdlib.h>

#include "v8.h"

#include "compilation-cache.h"

#include "execution.h"

#include "factory.h"

#include "macro-assembler.h"

#include "global-handles.h"

#include "stub-cache.h"

#include "cctest.h"

using namespace v8::internal;

// Go through all incremental marking steps in one swoop.

static void SimulateIncrementalMarking() {

  MarkCompactCollector* collector = CcTest::heap()->mark_compact_collector();

  IncrementalMarking* marking = CcTest::heap()->incremental_marking();

  if (collector->IsConcurrentSweepingInProgress()) {

    collector->WaitUntilSweepingCompleted();

  }

  CHECK(marking->IsMarking() || marking->IsStopped());

  if (marking->IsStopped()) {

    marking->Start();

  }

  CHECK(marking->IsMarking());

  while (!marking->IsComplete()) {

    marking->Step(MB, IncrementalMarking::NO_GC_VIA_STACK_GUARD);

  }

  CHECK(marking->IsComplete());

}

static void CheckMap(Map* map, int type, int instance_size) {

  CHECK(map->IsHeapObject());

#ifdef DEBUG

  CHECK(CcTest::heap()->Contains(map));

#endif

  CHECK_EQ(CcTest::heap()->meta_map(), map->map());

  CHECK_EQ(type, map->instance_type());

  CHECK_EQ(instance_size, map->instance_size());

}

TEST(HeapMaps) {

  CcTest::InitializeVM();

  Heap* heap = CcTest::heap();

  CheckMap(heap->meta_map(), MAP_TYPE, Map::kSize);

  CheckMap(heap->heap_number_map(), HEAP_NUMBER_TYPE, HeapNumber::kSize);

  CheckMap(heap->fixed_array_map(), FIXED_ARRAY_TYPE, kVariableSizeSentinel);

  CheckMap(heap->string_map(), STRING_TYPE, kVariableSizeSentinel);

}

static void CheckOddball(Isolate* isolate, Object* obj, const char* string) {

  CHECK(obj->IsOddball());

  bool exc;

  Handle<Object> handle(obj, isolate);

  Object* print_string =

      *Execution::ToString(isolate, handle, &exc);

  CHECK(String::cast(print_string)->IsUtf8EqualTo(CStrVector(string)));

}

static void CheckSmi(Isolate* isolate, int value, const char* string) {

  bool exc;

  Handle<Object> handle(Smi::FromInt(value), isolate);

  Object* print_string =

      *Execution::ToString(isolate, handle, &exc);

  CHECK(String::cast(print_string)->IsUtf8EqualTo(CStrVector(string)));

}

static void CheckNumber(Isolate* isolate, double value, const char* string) {

  Object* obj = CcTest::heap()->NumberFromDouble(value)->ToObjectChecked();

  CHECK(obj->IsNumber());

  bool exc;

  Handle<Object> handle(obj, isolate);

  Object* print_string =

      *Execution::ToString(isolate, handle, &exc);

  CHECK(String::cast(print_string)->IsUtf8EqualTo(CStrVector(string)));

}

static void CheckFindCodeObject(Isolate* isolate) {

  // Test FindCodeObject

#define __ assm.

  Assembler assm(isolate, NULL, 0);

  __ nop();  // supported on all architectures

  CodeDesc desc;

  assm.GetCode(&desc);

  Heap* heap = isolate->heap();

  Object* code = heap->CreateCode(

      desc,

      Code::ComputeFlags(Code::STUB),

      Handle<Code>())->ToObjectChecked();

  CHECK(code->IsCode());

  HeapObject* obj = HeapObject::cast(code);

  Address obj_addr = obj->address();

  for (int i = 0; i < obj->Size(); i += kPointerSize) {

    Object* found = isolate->FindCodeObject(obj_addr + i);

    CHECK_EQ(code, found);

  }

  Object* copy = heap->CreateCode(

      desc,

      Code::ComputeFlags(Code::STUB),

      Handle<Code>())->ToObjectChecked();

  CHECK(copy->IsCode());

  HeapObject* obj_copy = HeapObject::cast(copy);

  Object* not_right = isolate->FindCodeObject(obj_copy->address() +

                                              obj_copy->Size() / 2);

  CHECK(not_right != code);

}

TEST(HeapObjects) {

  CcTest::InitializeVM();

  Isolate* isolate = CcTest::i_isolate();

  Factory* factory = isolate->factory();

  Heap* heap = isolate->heap();

  HandleScope sc(isolate);

  Object* value = heap->NumberFromDouble(1.000123)->ToObjectChecked();

  CHECK(value->IsHeapNumber());

  CHECK(value->IsNumber());

  CHECK_EQ(1.000123, value->Number());

  value = heap->NumberFromDouble(1.0)->ToObjectChecked();

  CHECK(value->IsSmi());

  CHECK(value->IsNumber());

  CHECK_EQ(1.0, value->Number());

  value = heap->NumberFromInt32(1024)->ToObjectChecked();

  CHECK(value->IsSmi());

  CHECK(value->IsNumber());

  CHECK_EQ(1024.0, value->Number());

  value = heap->NumberFromInt32(Smi::kMinValue)->ToObjectChecked();

  CHECK(value->IsSmi());

  CHECK(value->IsNumber());

  CHECK_EQ(Smi::kMinValue, Smi::cast(value)->value());

  value = heap->NumberFromInt32(Smi::kMaxValue)->ToObjectChecked();

  CHECK(value->IsSmi());

  CHECK(value->IsNumber());

  CHECK_EQ(Smi::kMaxValue, Smi::cast(value)->value());

#ifndef V8_TARGET_ARCH_X64

  // TODO(lrn): We need a NumberFromIntptr function in order to test this.

  value = heap->NumberFromInt32(Smi::kMinValue - 1)->ToObjectChecked();

  CHECK(value->IsHeapNumber());

  CHECK(value->IsNumber());

  CHECK_EQ(static_cast<double>(Smi::kMinValue - 1), value->Number());

#endif

  MaybeObject* maybe_value =

      heap->NumberFromUint32(static_cast<uint32_t>(Smi::kMaxValue) + 1);

  value = maybe_value->ToObjectChecked();

  CHECK(value->IsHeapNumber());

  CHECK(value->IsNumber());

  CHECK_EQ(static_cast<double>(static_cast<uint32_t>(Smi::kMaxValue) + 1),

           value->Number());

  maybe_value = heap->NumberFromUint32(static_cast<uint32_t>(1) << 31);

  value = maybe_value->ToObjectChecked();

  CHECK(value->IsHeapNumber());

  CHECK(value->IsNumber());

  CHECK_EQ(static_cast<double>(static_cast<uint32_t>(1) << 31),

           value->Number());

  // nan oddball checks

  CHECK(heap->nan_value()->IsNumber());

  CHECK(std::isnan(heap->nan_value()->Number()));

  Handle<String> s = factory->NewStringFromAscii(CStrVector("fisk hest "));

  CHECK(s->IsString());

  CHECK_EQ(10, s->length());

  Handle<String> object_string = Handle<String>::cast(factory->Object_string());

  Handle<GlobalObject> global(CcTest::i_isolate()->context()->global_object());

  CHECK(JSReceiver::HasLocalProperty(global, object_string));

  // Check ToString for oddballs

  CheckOddball(isolate, heap->true_value(), "true");

  CheckOddball(isolate, heap->false_value(), "false");

  CheckOddball(isolate, heap->null_value(), "null");

  CheckOddball(isolate, heap->undefined_value(), "undefined");

  // Check ToString for Smis

  CheckSmi(isolate, 0, "0");

  CheckSmi(isolate, 42, "42");

  CheckSmi(isolate, -42, "-42");

  // Check ToString for Numbers

  CheckNumber(isolate, 1.1, "1.1");

  CheckFindCodeObject(isolate);

}

TEST(Tagging) {

  CcTest::InitializeVM();

  int request = 24;

  CHECK_EQ(request, static_cast<int>(OBJECT_POINTER_ALIGN(request)));

  CHECK(Smi::FromInt(42)->IsSmi());

  CHECK(Failure::RetryAfterGC(NEW_SPACE)->IsFailure());

  CHECK_EQ(NEW_SPACE,

           Failure::RetryAfterGC(NEW_SPACE)->allocation_space());

  CHECK_EQ(OLD_POINTER_SPACE,

           Failure::RetryAfterGC(OLD_POINTER_SPACE)->allocation_space());

  CHECK(Failure::Exception()->IsFailure());

  CHECK(Smi::FromInt(Smi::kMinValue)->IsSmi());

  CHECK(Smi::FromInt(Smi::kMaxValue)->IsSmi());

}

TEST(GarbageCollection) {

  CcTest::InitializeVM();

  Isolate* isolate = CcTest::i_isolate();

  Heap* heap = isolate->heap();

  Factory* factory = isolate->factory();

  HandleScope sc(isolate);

  // Check GC.

  heap->CollectGarbage(NEW_SPACE);

  Handle<GlobalObject> global(CcTest::i_isolate()->context()->global_object());

  Handle<String> name = factory->InternalizeUtf8String("theFunction");

  Handle<String> prop_name = factory->InternalizeUtf8String("theSlot");

  Handle<String> prop_namex = factory->InternalizeUtf8String("theSlotx");

  Handle<String> obj_name = factory->InternalizeUtf8String("theObject");

  Handle<Smi> twenty_three(Smi::FromInt(23), isolate);

  Handle<Smi> twenty_four(Smi::FromInt(24), isolate);

  {

    HandleScope inner_scope(isolate);

    // Allocate a function and keep it in global object's property.

    Handle<JSFunction> function =

        factory->NewFunction(name, factory->undefined_value());

    Handle<Map> initial_map =

        factory->NewMap(JS_OBJECT_TYPE, JSObject::kHeaderSize);

    function->set_initial_map(*initial_map);

    JSReceiver::SetProperty(global, name, function, NONE, kNonStrictMode);

    // Allocate an object.  Unrooted after leaving the scope.

    Handle<JSObject> obj = factory->NewJSObject(function);

    JSReceiver::SetProperty(obj, prop_name, twenty_three, NONE, kNonStrictMode);

    JSReceiver::SetProperty(obj, prop_namex, twenty_four, NONE, kNonStrictMode);

    CHECK_EQ(Smi::FromInt(23), obj->GetProperty(*prop_name));

    CHECK_EQ(Smi::FromInt(24), obj->GetProperty(*prop_namex));

  }

  heap->CollectGarbage(NEW_SPACE);

  // Function should be alive.

  CHECK(JSReceiver::HasLocalProperty(global, name));

  // Check function is retained.

  Object* func_value = CcTest::i_isolate()->context()->global_object()->

      GetProperty(*name)->ToObjectChecked();

  CHECK(func_value->IsJSFunction());

  Handle<JSFunction> function(JSFunction::cast(func_value));

  {

    HandleScope inner_scope(isolate);

    // Allocate another object, make it reachable from global.

    Handle<JSObject> obj = factory->NewJSObject(function);

    JSReceiver::SetProperty(global, obj_name, obj, NONE, kNonStrictMode);

    JSReceiver::SetProperty(obj, prop_name, twenty_three, NONE, kNonStrictMode);

  }

  // After gc, it should survive.

  heap->CollectGarbage(NEW_SPACE);

  CHECK(JSReceiver::HasLocalProperty(global, obj_name));

  CHECK(CcTest::i_isolate()->context()->global_object()->

        GetProperty(*obj_name)->ToObjectChecked()->IsJSObject());

  Object* obj = CcTest::i_isolate()->context()->global_object()->

      GetProperty(*obj_name)->ToObjectChecked();

  JSObject* js_obj = JSObject::cast(obj);

  CHECK_EQ(Smi::FromInt(23), js_obj->GetProperty(*prop_name));

}

static void VerifyStringAllocation(Isolate* isolate, const char* string) {

  HandleScope scope(isolate);

  Handle<String> s = isolate->factory()->NewStringFromUtf8(CStrVector(string));

  CHECK_EQ(StrLength(string), s->length());

  for (int index = 0; index < s->length(); index++) {

    CHECK_EQ(static_cast<uint16_t>(string[index]), s->Get(index));

  }

}

TEST(String) {

  CcTest::InitializeVM();

  Isolate* isolate = reinterpret_cast<Isolate*>(CcTest::isolate());

  VerifyStringAllocation(isolate, "a");

  VerifyStringAllocation(isolate, "ab");

  VerifyStringAllocation(isolate, "abc");

  VerifyStringAllocation(isolate, "abcd");

  VerifyStringAllocation(isolate, "fiskerdrengen er paa havet");

}

TEST(LocalHandles) {

  CcTest::InitializeVM();

  Isolate* isolate = CcTest::i_isolate();

  Factory* factory = isolate->factory();

  v8::HandleScope scope(CcTest::isolate());

  const char* name = "Kasper the spunky";

  Handle<String> string = factory->NewStringFromAscii(CStrVector(name));

  CHECK_EQ(StrLength(name), string->length());

}

TEST(GlobalHandles) {

  CcTest::InitializeVM();

  Isolate* isolate = CcTest::i_isolate();

  Heap* heap = isolate->heap();

  Factory* factory = isolate->factory();

  GlobalHandles* global_handles = isolate->global_handles();

  Handle<Object> h1;

  Handle<Object> h2;

  Handle<Object> h3;

  Handle<Object> h4;

  {

    HandleScope scope(isolate);

    Handle<Object> i = factory->NewStringFromAscii(CStrVector("fisk"));

    Handle<Object> u = factory->NewNumber(1.12344);

    h1 = global_handles->Create(*i);

    h2 = global_handles->Create(*u);

    h3 = global_handles->Create(*i);

    h4 = global_handles->Create(*u);

  }

  // after gc, it should survive

  heap->CollectGarbage(NEW_SPACE);

  CHECK((*h1)->IsString());

  CHECK((*h2)->IsHeapNumber());

  CHECK((*h3)->IsString());

  CHECK((*h4)->IsHeapNumber());

  CHECK_EQ(*h3, *h1);

  global_handles->Destroy(h1.location());

  global_handles->Destroy(h3.location());

  CHECK_EQ(*h4, *h2);

  global_handles->Destroy(h2.location());

  global_handles->Destroy(h4.location());

}

static bool WeakPointerCleared = false;

static void TestWeakGlobalHandleCallback(v8::Isolate* isolate,

                                         v8::Persistent<v8::Value>* handle,

                                         void* id) {

  if (1234 == reinterpret_cast<intptr_t>(id)) WeakPointerCleared = true;

  handle->Dispose();

}

TEST(WeakGlobalHandlesScavenge) {

  i::FLAG_stress_compaction = false;

  CcTest::InitializeVM();

  Isolate* isolate = CcTest::i_isolate();

  Heap* heap = isolate->heap();

  Factory* factory = isolate->factory();

  GlobalHandles* global_handles = isolate->global_handles();

  WeakPointerCleared = false;

  Handle<Object> h1;

  Handle<Object> h2;

  {

    HandleScope scope(isolate);

    Handle<Object> i = factory->NewStringFromAscii(CStrVector("fisk"));

    Handle<Object> u = factory->NewNumber(1.12344);

    h1 = global_handles->Create(*i);

    h2 = global_handles->Create(*u);

  }

  global_handles->MakeWeak(h2.location(),

                           reinterpret_cast<void*>(1234),

                           &TestWeakGlobalHandleCallback);

  // Scavenge treats weak pointers as normal roots.

  heap->PerformScavenge();

  CHECK((*h1)->IsString());

  CHECK((*h2)->IsHeapNumber());

  CHECK(!WeakPointerCleared);

  CHECK(!global_handles->IsNearDeath(h2.location()));

  CHECK(!global_handles->IsNearDeath(h1.location()));

  global_handles->Destroy(h1.location());

  global_handles->Destroy(h2.location());

}

TEST(WeakGlobalHandlesMark) {

  CcTest::InitializeVM();

  Isolate* isolate = CcTest::i_isolate();

  Heap* heap = isolate->heap();

  Factory* factory = isolate->factory();

  GlobalHandles* global_handles = isolate->global_handles();

  WeakPointerCleared = false;

  Handle<Object> h1;

  Handle<Object> h2;

  {

    HandleScope scope(isolate);

    Handle<Object> i = factory->NewStringFromAscii(CStrVector("fisk"));

    Handle<Object> u = factory->NewNumber(1.12344);

    h1 = global_handles->Create(*i);

    h2 = global_handles->Create(*u);

  }

  // Make sure the objects are promoted.

  heap->CollectGarbage(OLD_POINTER_SPACE);

  heap->CollectGarbage(NEW_SPACE);

  CHECK(!heap->InNewSpace(*h1) && !heap->InNewSpace(*h2));

  global_handles->MakeWeak(h2.location(),

                           reinterpret_cast<void*>(1234),

                           &TestWeakGlobalHandleCallback);

  CHECK(!GlobalHandles::IsNearDeath(h1.location()));

  CHECK(!GlobalHandles::IsNearDeath(h2.location()));

  // Incremental marking potentially marked handles before they turned weak.

  heap->CollectAllGarbage(Heap::kAbortIncrementalMarkingMask);

  CHECK((*h1)->IsString());

  CHECK(WeakPointerCleared);

  CHECK(!GlobalHandles::IsNearDeath(h1.location()));

  global_handles->Destroy(h1.location());

}

TEST(DeleteWeakGlobalHandle) {

  i::FLAG_stress_compaction = false;

  CcTest::InitializeVM();

  Isolate* isolate = CcTest::i_isolate();

  Heap* heap = isolate->heap();

  Factory* factory = isolate->factory();

  GlobalHandles* global_handles = isolate->global_handles();

  WeakPointerCleared = false;

  Handle<Object> h;

  {

    HandleScope scope(isolate);

    Handle<Object> i = factory->NewStringFromAscii(CStrVector("fisk"));

    h = global_handles->Create(*i);

  }

  global_handles->MakeWeak(h.location(),

                           reinterpret_cast<void*>(1234),

                           &TestWeakGlobalHandleCallback);

  // Scanvenge does not recognize weak reference.

  heap->PerformScavenge();

  CHECK(!WeakPointerCleared);

  // Mark-compact treats weak reference properly.

  heap->CollectGarbage(OLD_POINTER_SPACE);

  CHECK(WeakPointerCleared);

}

static const char* not_so_random_string_table[] = {

  "abstract",

  "boolean",

  "break",

  "byte",

  "case",

  "catch",

  "char",

  "class",

  "const",

  "continue",

  "debugger",

  "default",

  "delete",

  "do",

  "double",

  "else",

  "enum",

  "export",

  "extends",

  "false",

  "final",

  "finally",

  "float",

  "for",

  "function",

  "goto",

  "if",

  "implements",

  "import",

  "in",

  "instanceof",

  "int",

  "interface",

  "long",

  "native",

  "new",

  "null",

  "package",

  "private",

  "protected",

  "public",

  "return",

  "short",

  "static",

  "super",

  "switch",

  "synchronized",

  "this",

  "throw",

  "throws",

  "transient",

  "true",

  "try",

  "typeof",

  "var",

  "void",

  "volatile",

  "while",

  "with",

  0

};

static void CheckInternalizedStrings(const char** strings) {

  for (const char* string = *strings; *strings != 0; string = *strings++) {

    Object* a;

    MaybeObject* maybe_a = CcTest::heap()->InternalizeUtf8String(string);

    // InternalizeUtf8String may return a failure if a GC is needed.

    if (!maybe_a->ToObject(&a)) continue;

    CHECK(a->IsInternalizedString());

    Object* b;

    MaybeObject* maybe_b = CcTest::heap()->InternalizeUtf8String(string);

    if (!maybe_b->ToObject(&b)) continue;

    CHECK_EQ(b, a);

    CHECK(String::cast(b)->IsUtf8EqualTo(CStrVector(string)));

  }

}

TEST(StringTable) {

  CcTest::InitializeVM();

  CheckInternalizedStrings(not_so_random_string_table);

  CheckInternalizedStrings(not_so_random_string_table);

}

TEST(FunctionAllocation) {

  CcTest::InitializeVM();

  Isolate* isolate = CcTest::i_isolate();

  Factory* factory = isolate->factory();

  v8::HandleScope sc(CcTest::isolate());

  Handle<String> name = factory->InternalizeUtf8String("theFunction");

  Handle<JSFunction> function =

      factory->NewFunction(name, factory->undefined_value());

  Handle<Map> initial_map =

      factory->NewMap(JS_OBJECT_TYPE, JSObject::kHeaderSize);

  function->set_initial_map(*initial_map);

  Handle<Smi> twenty_three(Smi::FromInt(23), isolate);

  Handle<Smi> twenty_four(Smi::FromInt(24), isolate);

  Handle<String> prop_name = factory->InternalizeUtf8String("theSlot");

  Handle<JSObject> obj = factory->NewJSObject(function);

  JSReceiver::SetProperty(obj, prop_name, twenty_three, NONE, kNonStrictMode);

  CHECK_EQ(Smi::FromInt(23), obj->GetProperty(*prop_name));

  // Check that we can add properties to function objects.

  JSReceiver::SetProperty(function, prop_name, twenty_four, NONE,

                          kNonStrictMode);

  CHECK_EQ(Smi::FromInt(24), function->GetProperty(*prop_name));

}

TEST(ObjectProperties) {

  CcTest::InitializeVM();

  Isolate* isolate = CcTest::i_isolate();

  Factory* factory = isolate->factory();

  v8::HandleScope sc(CcTest::isolate());

  String* object_string = String::cast(CcTest::heap()->Object_string());

  Object* raw_object = CcTest::i_isolate()->context()->global_object()->

      GetProperty(object_string)->ToObjectChecked();

  JSFunction* object_function = JSFunction::cast(raw_object);

  Handle<JSFunction> constructor(object_function);

  Handle<JSObject> obj = factory->NewJSObject(constructor);

  Handle<String> first = factory->InternalizeUtf8String("first");

  Handle<String> second = factory->InternalizeUtf8String("second");

  Handle<Smi> one(Smi::FromInt(1), isolate);

  Handle<Smi> two(Smi::FromInt(2), isolate);

  // check for empty

  CHECK(!JSReceiver::HasLocalProperty(obj, first));

  // add first

  JSReceiver::SetProperty(obj, first, one, NONE, kNonStrictMode);

  CHECK(JSReceiver::HasLocalProperty(obj, first));

  // delete first

  JSReceiver::DeleteProperty(obj, first, JSReceiver::NORMAL_DELETION);

  CHECK(!JSReceiver::HasLocalProperty(obj, first));

  // add first and then second

  JSReceiver::SetProperty(obj, first, one, NONE, kNonStrictMode);

  JSReceiver::SetProperty(obj, second, two, NONE, kNonStrictMode);

  CHECK(JSReceiver::HasLocalProperty(obj, first));

  CHECK(JSReceiver::HasLocalProperty(obj, second));

  // delete first and then second

  JSReceiver::DeleteProperty(obj, first, JSReceiver::NORMAL_DELETION);

  CHECK(JSReceiver::HasLocalProperty(obj, second));

  JSReceiver::DeleteProperty(obj, second, JSReceiver::NORMAL_DELETION);

  CHECK(!JSReceiver::HasLocalProperty(obj, first));

  CHECK(!JSReceiver::HasLocalProperty(obj, second));

  // add first and then second

  JSReceiver::SetProperty(obj, first, one, NONE, kNonStrictMode);

  JSReceiver::SetProperty(obj, second, two, NONE, kNonStrictMode);

  CHECK(JSReceiver::HasLocalProperty(obj, first));

  CHECK(JSReceiver::HasLocalProperty(obj, second));

  // delete second and then first

  JSReceiver::DeleteProperty(obj, second, JSReceiver::NORMAL_DELETION);

  CHECK(JSReceiver::HasLocalProperty(obj, first));

  JSReceiver::DeleteProperty(obj, first, JSReceiver::NORMAL_DELETION);

  CHECK(!JSReceiver::HasLocalProperty(obj, first));

  CHECK(!JSReceiver::HasLocalProperty(obj, second));

  // check string and internalized string match

  const char* string1 = "fisk";

  Handle<String> s1 = factory->NewStringFromAscii(CStrVector(string1));

  JSReceiver::SetProperty(obj, s1, one, NONE, kNonStrictMode);

  Handle<String> s1_string = factory->InternalizeUtf8String(string1);

  CHECK(JSReceiver::HasLocalProperty(obj, s1_string));

  // check internalized string and string match

  const char* string2 = "fugl";

  Handle<String> s2_string = factory->InternalizeUtf8String(string2);

  JSReceiver::SetProperty(obj, s2_string, one, NONE, kNonStrictMode);

  Handle<String> s2 = factory->NewStringFromAscii(CStrVector(string2));

  CHECK(JSReceiver::HasLocalProperty(obj, s2));

}

TEST(JSObjectMaps) {

  CcTest::InitializeVM();

  Isolate* isolate = CcTest::i_isolate();

  Factory* factory = isolate->factory();

  v8::HandleScope sc(CcTest::isolate());

  Handle<String> name = factory->InternalizeUtf8String("theFunction");

  Handle<JSFunction> function =

      factory->NewFunction(name, factory->undefined_value());

  Handle<Map> initial_map =

      factory->NewMap(JS_OBJECT_TYPE, JSObject::kHeaderSize);

  function->set_initial_map(*initial_map);

  Handle<String> prop_name = factory->InternalizeUtf8String("theSlot");

  Handle<JSObject> obj = factory->NewJSObject(function);

  // Set a propery

  Handle<Smi> twenty_three(Smi::FromInt(23), isolate);

  JSReceiver::SetProperty(obj, prop_name, twenty_three, NONE, kNonStrictMode);

  CHECK_EQ(Smi::FromInt(23), obj->GetProperty(*prop_name));

  // Check the map has changed

  CHECK(*initial_map != obj->map());

}

TEST(JSArray) {

  CcTest::InitializeVM();

  Isolate* isolate = CcTest::i_isolate();

  Factory* factory = isolate->factory();

  v8::HandleScope sc(CcTest::isolate());

  Handle<String> name = factory->InternalizeUtf8String("Array");

  Object* raw_object = CcTest::i_isolate()->context()->global_object()->

      GetProperty(*name)->ToObjectChecked();

  Handle<JSFunction> function = Handle<JSFunction>(

      JSFunction::cast(raw_object));

  // Allocate the object.

  Handle<JSObject> object = factory->NewJSObject(function);

  Handle<JSArray> array = Handle<JSArray>::cast(object);

  // We just initialized the VM, no heap allocation failure yet.

  array->Initialize(0)->ToObjectChecked();

  // Set array length to 0.

  array->SetElementsLength(Smi::FromInt(0))->ToObjectChecked();

  CHECK_EQ(Smi::FromInt(0), array->length());

  // Must be in fast mode.

  CHECK(array->HasFastSmiOrObjectElements());

  // array[length] = name.

  array->SetElement(0, *name, NONE, kNonStrictMode)->ToObjectChecked();

  CHECK_EQ(Smi::FromInt(1), array->length());

  CHECK_EQ(array->GetElement(isolate, 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)->ToObjectChecked();

  uint32_t int_length = 0;

  CHECK(length->ToArrayIndex(&int_length));

  CHECK_EQ(*length, array->length());

  CHECK(array->HasDictionaryElements());  // Must be in slow mode.

  // array[length] = name.

  array->SetElement(int_length, *name, NONE, kNonStrictMode)->ToObjectChecked();

  uint32_t new_int_length = 0;

  CHECK(array->length()->ToArrayIndex(&new_int_length));

  CHECK_EQ(static_cast<double>(int_length), new_int_length - 1);

  CHECK_EQ(array->GetElement(isolate, int_length), *name);

  CHECK_EQ(array->GetElement(isolate, 0), *name);

}

TEST(JSObjectCopy) {

  CcTest::InitializeVM();

  Isolate* isolate = CcTest::i_isolate();

  Factory* factory = isolate->factory();

  v8::HandleScope sc(CcTest::isolate());

  String* object_string = String::cast(CcTest::heap()->Object_string());

  Object* raw_object = CcTest::i_isolate()->context()->global_object()->

      GetProperty(object_string)->ToObjectChecked();

  JSFunction* object_function = JSFunction::cast(raw_object);

  Handle<JSFunction> constructor(object_function);

  Handle<JSObject> obj = factory->NewJSObject(constructor);

  Handle<String> first = factory->InternalizeUtf8String("first");

  Handle<String> second = factory->InternalizeUtf8String("second");

  Handle<Smi> one(Smi::FromInt(1), isolate);

  Handle<Smi> two(Smi::FromInt(2), isolate);

  JSReceiver::SetProperty(obj, first, one, NONE, kNonStrictMode);

  JSReceiver::SetProperty(obj, second, two, NONE, kNonStrictMode);

  obj->SetElement(0, *first, NONE, kNonStrictMode)->ToObjectChecked();

  obj->SetElement(1, *second, NONE, kNonStrictMode)->ToObjectChecked();

  // Make the clone.

  Handle<JSObject> clone = JSObject::Copy(obj);

  CHECK(!clone.is_identical_to(obj));

  CHECK_EQ(obj->GetElement(isolate, 0), clone->GetElement(isolate, 0));

  CHECK_EQ(obj->GetElement(isolate, 1), clone->GetElement(isolate, 1));

  CHECK_EQ(obj->GetProperty(*first), clone->GetProperty(*first));

  CHECK_EQ(obj->GetProperty(*second), clone->GetProperty(*second));

  // Flip the values.

  JSReceiver::SetProperty(clone, first, two, NONE, kNonStrictMode);

  JSReceiver::SetProperty(clone, second, one, NONE, kNonStrictMode);

  clone->SetElement(0, *second, NONE, kNonStrictMode)->ToObjectChecked();

  clone->SetElement(1, *first, NONE, kNonStrictMode)->ToObjectChecked();

  CHECK_EQ(obj->GetElement(isolate, 1), clone->GetElement(isolate, 0));

  CHECK_EQ(obj->GetElement(isolate, 0), clone->GetElement(isolate, 1));

  CHECK_EQ(obj->GetProperty(*second), clone->GetProperty(*first));

  CHECK_EQ(obj->GetProperty(*first), clone->GetProperty(*second));

}

TEST(StringAllocation) {

  CcTest::InitializeVM();

  Isolate* isolate = CcTest::i_isolate();

  Factory* factory = isolate->factory();

  const unsigned char chars[] = { 0xe5, 0xa4, 0xa7 };

  for (int length = 0; length < 100; length++) {

    v8::HandleScope scope(CcTest::isolate());

    char* non_ascii = NewArray<char>(3 * length + 1);

    char* ascii = NewArray<char>(length + 1);

    non_ascii[3 * length] = 0;

    ascii[length] = 0;

    for (int i = 0; i < length; i++) {

      ascii[i] = 'a';

      non_ascii[3 * i] = chars[0];

      non_ascii[3 * i + 1] = chars[1];

      non_ascii[3 * i + 2] = chars[2];

    }

    Handle<String> non_ascii_sym =

        factory->InternalizeUtf8String(

            Vector<const char>(non_ascii, 3 * length));

    CHECK_EQ(length, non_ascii_sym->length());

    Handle<String> ascii_sym =

        factory->InternalizeOneByteString(OneByteVector(ascii, length));

    CHECK_EQ(length, ascii_sym->length());

    Handle<String> non_ascii_str =

        factory->NewStringFromUtf8(Vector<const char>(non_ascii, 3 * length));

    non_ascii_str->Hash();

    CHECK_EQ(length, non_ascii_str->length());

    Handle<String> ascii_str =

        factory->NewStringFromUtf8(Vector<const char>(ascii, length));

    ascii_str->Hash();

    CHECK_EQ(length, ascii_str->length());

    DeleteArray(non_ascii);

    DeleteArray(ascii);

  }

}

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++) {

      if (*objs[i] == obj) {

        found_count++;

      }

    }

  }

  return found_count;

}

TEST(Iteration) {

  CcTest::InitializeVM();

  Isolate* isolate = CcTest::i_isolate();

  Factory* factory = isolate->factory();

  v8::HandleScope scope(CcTest::isolate());

  // Array of objects to scan haep for.

  const int objs_count = 6;

  Handle<Object> objs[objs_count];

  int next_objs_index = 0;

  // Allocate a JS array to OLD_POINTER_SPACE and NEW_SPACE

  objs[next_objs_index++] = factory->NewJSArray(10);

  objs[next_objs_index++] = factory->NewJSArray(10,

                                                FAST_HOLEY_ELEMENTS,

                                                TENURED);

  // Allocate a small string to OLD_DATA_SPACE and NEW_SPACE

  objs[next_objs_index++] =

      factory->NewStringFromAscii(CStrVector("abcdefghij"));

  objs[next_objs_index++] =

      factory->NewStringFromAscii(CStrVector("abcdefghij"), TENURED);

  // Allocate a large string (for large object space).

  int large_size = Page::kMaxNonCodeHeapObjectSize + 1;

  char* str = new char[large_size];

  for (int i = 0; i < large_size - 1; ++i) str[i] = 'a';

  str[large_size - 1] = '\0';

  objs[next_objs_index++] =

      factory->NewStringFromAscii(CStrVector(str), TENURED);

  delete[] str;

  // Add a Map object to look for.

  objs[next_objs_index++] = Handle<Map>(HeapObject::cast(*objs[0])->map());

  CHECK_EQ(objs_count, next_objs_index);

  CHECK_EQ(objs_count, ObjectsFoundInHeap(CcTest::heap(), objs, objs_count));

}

TEST(EmptyHandleEscapeFrom) {

  CcTest::InitializeVM();

  v8::HandleScope scope(CcTest::isolate());

  Handle<JSObject> runaway;

  {

      v8::HandleScope nested(CcTest::isolate());

      Handle<JSObject> empty;

      runaway = empty.EscapeFrom(&nested);

  }

  CHECK(runaway.is_null());

}

static int LenFromSize(int size) {

  return (size - FixedArray::kHeaderSize) / kPointerSize;

}

TEST(Regression39128) {

  // Test case for crbug.com/39128.

  CcTest::InitializeVM();

  Isolate* isolate = CcTest::i_isolate();

  Factory* factory = isolate->factory();

  Heap* heap = isolate->heap();

  // Increase the chance of 'bump-the-pointer' allocation in old space.

  heap->CollectAllGarbage(Heap::kAbortIncrementalMarkingMask);

  v8::HandleScope scope(CcTest::isolate());

  // 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.

  // Step 1: prepare a map for the object.  We add 1 inobject property to it.

  Handle<JSFunction> object_ctor(

      CcTest::i_isolate()->native_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);

  int object_size = my_map->instance_size();

  // Step 2: allocate a lot of objects so to almost fill new space: we need

  // just enough room to allocate JSObject and thus fill the newspace.

  int allocation_amount = Min(FixedArray::kMaxSize,

                              Page::kMaxNonCodeHeapObjectSize + kPointerSize);

  int allocation_len = LenFromSize(allocation_amount);

  NewSpace* new_space = heap->new_space();

  Address* top_addr = new_space->allocation_top_address();

  Address* limit_addr = new_space->allocation_limit_address();

  while ((*limit_addr - *top_addr) > allocation_amount) {

    CHECK(!heap->always_allocate());

    Object* array = heap->AllocateFixedArray(allocation_len)->ToObjectChecked();

    CHECK(!array->IsFailure());

    CHECK(new_space->Contains(array));

  }

  // Step 3: now allocate fixed array and JSObject to fill the whole new space.

  int to_fill = static_cast<int>(*limit_addr - *top_addr - object_size);

  int fixed_array_len = LenFromSize(to_fill);

  CHECK(fixed_array_len < FixedArray::kMaxLength);

  CHECK(!heap->always_allocate());

  Object* array = heap->AllocateFixedArray(fixed_array_len)->ToObjectChecked();

  CHECK(!array->IsFailure());

  CHECK(new_space->Contains(array));

  Object* object = heap->AllocateJSObjectFromMap(*my_map)->ToObjectChecked();

  CHECK(new_space->Contains(object));

  JSObject* jsobject = JSObject::cast(object);

  CHECK_EQ(0, FixedArray::cast(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)->ToObjectChecked();

  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()));

}

TEST(TestCodeFlushing) {

  // If we do not flush code this test is invalid.

  if (!FLAG_flush_code) return;

  i::FLAG_allow_natives_syntax = true;

  i::FLAG_optimize_for_size = false;

  CcTest::InitializeVM();

  Isolate* isolate = CcTest::i_isolate();

  Factory* factory = isolate->factory();

  v8::HandleScope scope(CcTest::isolate());

  const char* source = "function foo() {"

                       "  var x = 42;"

                       "  var y = 42;"

                       "  var z = x + y;"

                       "};"

                       "foo()";

  Handle<String> foo_name = factory->InternalizeUtf8String("foo");

  // This compile will add the code to the compilation cache.

  { v8::HandleScope scope(CcTest::isolate());

    CompileRun(source);

  }

  // Check function is compiled.

  Object* func_value = CcTest::i_isolate()->context()->global_object()->

      GetProperty(*foo_name)->ToObjectChecked();

  CHECK(func_value->IsJSFunction());

  Handle<JSFunction> function(JSFunction::cast(func_value));

  CHECK(function->shared()->is_compiled());

  // The code will survive at least two GCs.

  CcTest::heap()->CollectAllGarbage(Heap::kAbortIncrementalMarkingMask);

  CcTest::heap()->CollectAllGarbage(Heap::kAbortIncrementalMarkingMask);

  CHECK(function->shared()->is_compiled());

  // Simulate several GCs that use full marking.

  const int kAgingThreshold = 6;

  for (int i = 0; i < kAgingThreshold; i++) {

    CcTest::heap()->CollectAllGarbage(Heap::kAbortIncrementalMarkingMask);

  }

  // foo should no longer be in the compilation cache

  CHECK(!function->shared()->is_compiled() || function->IsOptimized());

  CHECK(!function->is_compiled() || function->IsOptimized());

  // Call foo to get it recompiled.

  CompileRun("foo()");

  CHECK(function->shared()->is_compiled());

  CHECK(function->is_compiled());

}

TEST(TestCodeFlushingPreAged) {

  // If we do not flush code this test is invalid.

  if (!FLAG_flush_code) return;

  i::FLAG_allow_natives_syntax = true;

  i::FLAG_optimize_for_size = true;

  CcTest::InitializeVM();

  Isolate* isolate = Isolate::Current();

  Factory* factory = isolate->factory();

  v8::HandleScope scope(CcTest::isolate());

  const char* source = "function foo() {"

                       "  var x = 42;"

                       "  var y = 42;"

                       "  var z = x + y;"

                       "};"

                       "foo()";

  Handle<String> foo_name = factory->InternalizeUtf8String("foo");

  // Compile foo, but don't run it.

  { v8::HandleScope scope(CcTest::isolate());

    CompileRun(source);

  }

  // Check function is compiled.

  Object* func_value = Isolate::Current()->context()->global_object()->

      GetProperty(*foo_name)->ToObjectChecked();

  CHECK(func_value->IsJSFunction());

  Handle<JSFunction> function(JSFunction::cast(func_value));

  CHECK(function->shared()->is_compiled());

  // The code has been run so will survive at least one GC.

  CcTest::heap()->CollectAllGarbage(Heap::kAbortIncrementalMarkingMask);

  CHECK(function->shared()->is_compiled());

  // The code was only run once, so it should be pre-aged and collected on the

  // next GC.

  CcTest::heap()->CollectAllGarbage(Heap::kAbortIncrementalMarkingMask);

  CHECK(!function->shared()->is_compiled() || function->IsOptimized());

  // Execute the function again twice, and ensure it is reset to the young age.

  { v8::HandleScope scope(CcTest::isolate());

    CompileRun("foo();"

               "foo();");

  }

  // The code will survive at least two GC now that it is young again.

  CcTest::heap()->CollectAllGarbage(Heap::kAbortIncrementalMarkingMask);

  CcTest::heap()->CollectAllGarbage(Heap::kAbortIncrementalMarkingMask);

  CHECK(function->shared()->is_compiled());

  // Simulate several GCs that use full marking.

  const int kAgingThreshold = 6;

  for (int i = 0; i < kAgingThreshold; i++) {

    CcTest::heap()->CollectAllGarbage(Heap::kAbortIncrementalMarkingMask);

  }

  // foo should no longer be in the compilation cache

  CHECK(!function->shared()->is_compiled() || function->IsOptimized());

  CHECK(!function->is_compiled() || function->IsOptimized());

  // Call foo to get it recompiled.

  CompileRun("foo()");

  CHECK(function->shared()->is_compiled());

  CHECK(function->is_compiled());

}

TEST(TestCodeFlushingIncremental) {

  // If we do not flush code this test is invalid.

  if (!FLAG_flush_code || !FLAG_flush_code_incrementally) return;

  i::FLAG_allow_natives_syntax = true;

  i::FLAG_optimize_for_size = false;

  CcTest::InitializeVM();

  Isolate* isolate = CcTest::i_isolate();

  Factory* factory = isolate->factory();

  v8::HandleScope scope(CcTest::isolate());

  const char* source = "function foo() {"

                       "  var x = 42;"

                       "  var y = 42;"

                       "  var z = x + y;"

                       "};"

                       "foo()";

  Handle<String> foo_name = factory->InternalizeUtf8String("foo");

  // This compile will add the code to the compilation cache.

  { v8::HandleScope scope(CcTest::isolate());

    CompileRun(source);

  }

  // Check function is compiled.

  Object* func_value = CcTest::i_isolate()->context()->global_object()->

      GetProperty(*foo_name)->ToObjectChecked();

  CHECK(func_value->IsJSFunction());

  Handle<JSFunction> function(JSFunction::cast(func_value));

  CHECK(function->shared()->is_compiled());

  // The code will survive at least two GCs.

  CcTest::heap()->CollectAllGarbage(Heap::kAbortIncrementalMarkingMask);

  CcTest::heap()->CollectAllGarbage(Heap::kAbortIncrementalMarkingMask);

  CHECK(function->shared()->is_compiled());

  // Simulate several GCs that use incremental marking.

  const int kAgingThreshold = 6;

  for (int i = 0; i < kAgingThreshold; i++) {

    SimulateIncrementalMarking();

    CcTest::heap()->CollectAllGarbage(Heap::kNoGCFlags);

  }

  CHECK(!function->shared()->is_compiled() || function->IsOptimized());

  CHECK(!function->is_compiled() || function->IsOptimized());

  // This compile will compile the function again.

  { v8::HandleScope scope(CcTest::isolate());

    CompileRun("foo();");

  }

  // Simulate several GCs that use incremental marking but make sure

  // the loop breaks once the function is enqueued as a candidate.

  for (int i = 0; i < kAgingThreshold; i++) {

    SimulateIncrementalMarking();

    if (!function->next_function_link()->IsUndefined()) break;

    CcTest::heap()->CollectAllGarbage(Heap::kNoGCFlags);

  }

  // Force optimization while incremental marking is active and while

  // the function is enqueued as a candidate.

  { v8::HandleScope scope(CcTest::isolate());

    CompileRun("%OptimizeFunctionOnNextCall(foo); foo();");

  }

  // Simulate one final GC to make sure the candidate queue is sane.

  CcTest::heap()->CollectAllGarbage(Heap::kNoGCFlags);

  CHECK(function->shared()->is_compiled() || !function->IsOptimized());

  CHECK(function->is_compiled() || !function->IsOptimized());

}

TEST(TestCodeFlushingIncrementalScavenge) {

  // If we do not flush code this test is invalid.

  if (!FLAG_flush_code || !FLAG_flush_code_incrementally) return;

  i::FLAG_allow_natives_syntax = true;

  i::FLAG_optimize_for_size = false;

  CcTest::InitializeVM();

  Isolate* isolate = CcTest::i_isolate();

  Factory* factory = isolate->factory();

  v8::HandleScope scope(CcTest::isolate());

  const char* source = "var foo = function() {"

                       "  var x = 42;"

                       "  var y = 42;"

                       "  var z = x + y;"

                       "};"

                       "foo();"

                       "var bar = function() {"

                       "  var x = 23;"

                       "};"

                       "bar();";

  Handle<String> foo_name = factory->InternalizeUtf8String("foo");

  Handle<String> bar_name = factory->InternalizeUtf8String("bar");

  // Perfrom one initial GC to enable code flushing.

  CcTest::heap()->CollectAllGarbage(Heap::kAbortIncrementalMarkingMask);

  // This compile will add the code to the compilation cache.

  { v8::HandleScope scope(CcTest::isolate());

    CompileRun(source);

  }

  // Check functions are compiled.

  Object* func_value = CcTest::i_isolate()->context()->global_object()->

      GetProperty(*foo_name)->ToObjectChecked();

  CHECK(func_value->IsJSFunction());

  Handle<JSFunction> function(JSFunction::cast(func_value));

  CHECK(function->shared()->is_compiled());

  Object* func_value2 = CcTest::i_isolate()->context()->global_object()->

      GetProperty(*bar_name)->ToObjectChecked();

  CHECK(func_value2->IsJSFunction());

  Handle<JSFunction> function2(JSFunction::cast(func_value2));

  CHECK(function2->shared()->is_compiled());

  // Clear references to functions so that one of them can die.

  { v8::HandleScope scope(CcTest::isolate());

    CompileRun("foo = 0; bar = 0;");

  }

  // Bump the code age so that flushing is triggered while the function

  // object is still located in new-space.

  const int kAgingThreshold = 6;

  for (int i = 0; i < kAgingThreshold; i++) {

    function->shared()->code()->MakeOlder(static_cast<MarkingParity>(i % 2));

    function2->shared()->code()->MakeOlder(static_cast<MarkingParity>(i % 2));

  }

  // Simulate incremental marking so that the functions are enqueued as

  // code flushing candidates. Then kill one of the functions. Finally

  // perform a scavenge while incremental marking is still running.

  SimulateIncrementalMarking();

  *function2.location() = NULL;

  CcTest::heap()->CollectGarbage(NEW_SPACE, "test scavenge while marking");

  // Simulate one final GC to make sure the candidate queue is sane.

  CcTest::heap()->CollectAllGarbage(Heap::kNoGCFlags);

  CHECK(!function->shared()->is_compiled() || function->IsOptimized());

  CHECK(!function->is_compiled() || function->IsOptimized());

}

TEST(TestCodeFlushingIncrementalAbort) {

  // If we do not flush code this test is invalid.

  if (!FLAG_flush_code || !FLAG_flush_code_incrementally) return;

  i::FLAG_allow_natives_syntax = true;

  i::FLAG_optimize_for_size = false;

  CcTest::InitializeVM();

  Isolate* isolate = CcTest::i_isolate();

  Factory* factory = isolate->factory();

  Heap* heap = isolate->heap();

  v8::HandleScope scope(CcTest::isolate());

  const char* source = "function foo() {"

                       "  var x = 42;"

                       "  var y = 42;"

                       "  var z = x + y;"

                       "};"

                       "foo()";

  Handle<String> foo_name = factory->InternalizeUtf8String("foo");

  // This compile will add the code to the compilation cache.

  { v8::HandleScope scope(CcTest::isolate());

    CompileRun(source);

  }

  // Check function is compiled.

  Object* func_value = CcTest::i_isolate()->context()->global_object()->

      GetProperty(*foo_name)->ToObjectChecked();

  CHECK(func_value->IsJSFunction());

  Handle<JSFunction> function(JSFunction::cast(func_value));

  CHECK(function->shared()->is_compiled());

  // The code will survive at least two GCs.

  heap->CollectAllGarbage(Heap::kAbortIncrementalMarkingMask);

  heap->CollectAllGarbage(Heap::kAbortIncrementalMarkingMask);

  CHECK(function->shared()->is_compiled());

  // Bump the code age so that flushing is triggered.

  const int kAgingThreshold = 6;

  for (int i = 0; i < kAgingThreshold; i++) {

    function->shared()->code()->MakeOlder(static_cast<MarkingParity>(i % 2));

  }

  // Simulate incremental marking so that the function is enqueued as

  // code flushing candidate.

  SimulateIncrementalMarking();

#ifdef ENABLE_DEBUGGER_SUPPORT

  // Enable the debugger and add a breakpoint while incremental marking

  // is running so that incremental marking aborts and code flushing is

  // disabled.

  int position = 0;

  Handle<Object> breakpoint_object(Smi::FromInt(0), isolate);

  isolate->debug()->SetBreakPoint(function, breakpoint_object, &position);

  isolate->debug()->ClearAllBreakPoints();

#endif  // ENABLE_DEBUGGER_SUPPORT

  // Force optimization now that code flushing is disabled.

  { v8::HandleScope scope(CcTest::isolate());

    CompileRun("%OptimizeFunctionOnNextCall(foo); foo();");

  }

  // Simulate one final GC to make sure the candidate queue is sane.

  heap->CollectAllGarbage(Heap::kNoGCFlags);

  CHECK(function->shared()->is_compiled() || !function->IsOptimized());

  CHECK(function->is_compiled() || !function->IsOptimized());

}

// Count the number of native contexts in the weak list of native contexts.

int CountNativeContexts() {

  int count = 0;

  Object* object = CcTest::heap()->native_contexts_list();

  while (!object->IsUndefined()) {

    count++;

    object = Context::cast(object)->get(Context::NEXT_CONTEXT_LINK);

  }

  return count;

}