Revert trunk to bleeding_edge at r12484

test/cctest/test-heap.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 
 #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;
 
 static v8::Persistent<v8::Context> env;
 
 static void InitializeVM() {
   if (env.IsEmpty()) env = v8::Context::New();
   v8::HandleScope scope;
   env->Enter();
@@ skipping 1216 matching lines @@
 
 TEST(TestSizeOfObjectsVsHeapIteratorPrecision) {
   InitializeVM();
   HEAP->EnsureHeapIsIterable();
   intptr_t size_of_objects_1 = HEAP->SizeOfObjects();
   HeapIterator iterator;
   intptr_t size_of_objects_2 = 0;
   for (HeapObject* obj = iterator.next();
        obj != NULL;
        obj = iterator.next()) {
-    if (!obj->IsFreeSpace()) {
-      size_of_objects_2 += obj->Size();
-    }
+    size_of_objects_2 += obj->Size();
   }
   // Delta must be within 5% of the larger result.
   // TODO(gc): Tighten this up by distinguishing between byte
   // arrays that are real and those that merely mark free space
   // on the heap.
   if (size_of_objects_1 > size_of_objects_2) {
     intptr_t delta = size_of_objects_1 - size_of_objects_2;
     PrintF("Heap::SizeOfObjects: %" V8_PTR_PREFIX "d, "
            "Iterator: %" V8_PTR_PREFIX "d, "
            "delta: %" V8_PTR_PREFIX "d\n",
            size_of_objects_1, size_of_objects_2, delta);
     CHECK_GT(size_of_objects_1 / 20, delta);
   } else {
     intptr_t delta = size_of_objects_2 - size_of_objects_1;
     PrintF("Heap::SizeOfObjects: %" V8_PTR_PREFIX "d, "
            "Iterator: %" V8_PTR_PREFIX "d, "
            "delta: %" V8_PTR_PREFIX "d\n",
            size_of_objects_1, size_of_objects_2, delta);
     CHECK_GT(size_of_objects_2 / 20, delta);
   }
 }
 
 
 static void FillUpNewSpace(NewSpace* new_space) {
   // Fill up new space to the point that it is completely full. Make sure
   // that the scavenger does not undo the filling.
   v8::HandleScope scope;
   AlwaysAllocateScope always_allocate;
+  LinearAllocationScope allocate_linearly;
   intptr_t available = new_space->EffectiveCapacity() - new_space->Size();
   intptr_t number_of_fillers = (available / FixedArray::SizeFor(32)) - 1;
   for (intptr_t i = 0; i < number_of_fillers; i++) {
     CHECK(HEAP->InNewSpace(*FACTORY->NewFixedArray(32, NOT_TENURED)));
   }
 }
 
 
 TEST(GrowAndShrinkNewSpace) {
   InitializeVM();
@@ skipping 634 matching lines @@
   HEAP->CollectAllGarbage(Heap::kNoGCFlags, "triggered for preparation");
   CHECK_EQ(number_of_test_pages + 1, old_pointer_space->CountTotalPages());
 
   // Triggering subsequent GCs should cause at least half of the pages
   // to be released to the OS after at most two cycles.
   HEAP->CollectAllGarbage(Heap::kNoGCFlags, "triggered by test 1");
   CHECK_GE(number_of_test_pages + 1, old_pointer_space->CountTotalPages());
   HEAP->CollectAllGarbage(Heap::kNoGCFlags, "triggered by test 2");
   CHECK_GE(number_of_test_pages + 1, old_pointer_space->CountTotalPages() * 2);
 
-  // Triggering a last-resort GC should cause all pages to be released to the
-  // OS so that other processes can seize the memory.  If we get a failure here
-  // where there are 2 pages left instead of 1, then we should increase the
-  // size of the first page a little in SizeOfFirstPage in spaces.cc.  The
-  // first page should be small in order to reduce memory used when the VM
-  // boots, but if the 20 small arrays don't fit on the first page then that's
-  // an indication that it is too small.
+  // Triggering a last-resort GC should cause all pages to be released
+  // to the OS so that other processes can seize the memory.
   HEAP->CollectAllAvailableGarbage("triggered really hard");
   CHECK_EQ(1, old_pointer_space->CountTotalPages());
 }
 
 
 TEST(Regress2237) {
   InitializeVM();
   v8::HandleScope scope;
   Handle<String> slice(HEAP->empty_string());
 
@@ skipping 288 matching lines @@
   // External source is being retained by the stack trace.
   CHECK(!resource->IsDisposed());
 
   CompileRun("error.stack; error.stack;");
   HEAP->CollectAllAvailableGarbage();
   // External source has been released.
   CHECK(resource->IsDisposed());
 
   delete resource;
 }
-
-
-TEST(Regression144230) {
-  InitializeVM();
-  v8::HandleScope scope;
-
-  // First make sure that the uninitialized CallIC stub is on a single page
-  // that will later be selected as an evacuation candidate.
-  {
-    v8::HandleScope inner_scope;
-    AlwaysAllocateScope always_allocate;
-    SimulateFullSpace(HEAP->code_space());
-    ISOLATE->stub_cache()->ComputeCallInitialize(9, RelocInfo::CODE_TARGET);
-  }
-
-  // Second compile a CallIC and execute it once so that it gets patched to
-  // the pre-monomorphic stub. These code objects are on yet another page.
-  {
-    v8::HandleScope inner_scope;
-    AlwaysAllocateScope always_allocate;
-    SimulateFullSpace(HEAP->code_space());
-    CompileRun("var o = { f:function(a,b,c,d,e,f,g,h,i) {}};"
-               "function call() { o.f(1,2,3,4,5,6,7,8,9); };"
-               "call();");
-  }
-
-  // Third we fill up the last page of the code space so that it does not get
-  // chosen as an evacuation candidate.
-  {
-    v8::HandleScope inner_scope;
-    AlwaysAllocateScope always_allocate;
-    CompileRun("for (var i = 0; i < 2000; i++) {"
-               "  eval('function f' + i + '() { return ' + i +'; };' +"
-               "       'f' + i + '();');"
-               "}");
-  }
-  HEAP->CollectAllGarbage(Heap::kNoGCFlags);
-
-  // Fourth is the tricky part. Make sure the code containing the CallIC is
-  // visited first without clearing the IC. The shared function info is then
-  // visited later, causing the CallIC to be cleared.
-  Handle<String> name = FACTORY->LookupAsciiSymbol("call");
-  Handle<GlobalObject> global(ISOLATE->context()->global_object());
-  MaybeObject* maybe_call = global->GetProperty(*name);
-  JSFunction* call = JSFunction::cast(maybe_call->ToObjectChecked());
-  USE(global->SetProperty(*name, Smi::FromInt(0), NONE, kNonStrictMode));
-  ISOLATE->compilation_cache()->Clear();
-  call->shared()->set_ic_age(HEAP->global_ic_age() + 1);
-  Handle<Object> call_code(call->code());
-  Handle<Object> call_function(call);
-
-  // Now we are ready to mess up the heap.
-  HEAP->CollectAllGarbage(Heap::kReduceMemoryFootprintMask);
-
-  // Either heap verification caught the problem already or we go kaboom once
-  // the CallIC is executed the next time.
-  USE(global->SetProperty(*name, *call_function, NONE, kNonStrictMode));
-  CompileRun("call();");
-}