Revert 10413-10416 initial memory use reduction due to

src/mark-compact.cc

 // Copyright 2011 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
@@ skipping 2869 matching lines @@
        cell_index++, object_address += 32 * kPointerSize) {
     ASSERT((unsigned)cell_index ==
         Bitmap::IndexToCell(
             Bitmap::CellAlignIndex(
                 p->AddressToMarkbitIndex(object_address))));
     int live_objects = MarkWordToObjectStarts(cells[cell_index], offsets);
     int live_index = 0;
     for ( ; live_objects != 0; live_objects--) {
       Address free_end = object_address + offsets[live_index++] * kPointerSize;
       if (free_end != free_start) {
-        space->AddToFreeLists(free_start,
-                              static_cast<int>(free_end - free_start));
+        space->Free(free_start, static_cast<int>(free_end - free_start));
       }
       HeapObject* live_object = HeapObject::FromAddress(free_end);
       ASSERT(Marking::IsBlack(Marking::MarkBitFrom(live_object)));
       Map* map = live_object->map();
       int size = live_object->SizeFromMap(map);
       if (sweeping_mode == SWEEP_AND_VISIT_LIVE_OBJECTS) {
         live_object->IterateBody(map->instance_type(), size, v);
       }
       if ((skip_list_mode == REBUILD_SKIP_LIST) && skip_list != NULL) {
         int new_region_start =
             SkipList::RegionNumber(free_end);
         int new_region_end =
             SkipList::RegionNumber(free_end + size - kPointerSize);
         if (new_region_start != curr_region ||
             new_region_end != curr_region) {
           skip_list->AddObject(free_end, size);
           curr_region = new_region_end;
         }
       }
       free_start = free_end + size;
     }
     // Clear marking bits for current cell.
     cells[cell_index] = 0;
   }
   if (free_start != p->ObjectAreaEnd()) {
-    space->AddToFreeLists(free_start,
-                          static_cast<int>(p->ObjectAreaEnd() - free_start));
+    space->Free(free_start, static_cast<int>(p->ObjectAreaEnd() - free_start));
   }
   p->ResetLiveBytes();
 }
 
 
 static bool SetMarkBitsUnderInvalidatedCode(Code* code, bool value) {
   Page* p = Page::FromAddress(code->address());
 
   if (p->IsEvacuationCandidate() ||
       p->IsFlagSet(Page::RESCAN_ON_EVACUATION)) {
@@ skipping 272 matching lines @@
     VerifyEvacuation(heap_);
   }
 #endif
 
   slots_buffer_allocator_.DeallocateChain(&migration_slots_buffer_);
   ASSERT(migration_slots_buffer_ == NULL);
   for (int i = 0; i < npages; i++) {
     Page* p = evacuation_candidates_[i];
     if (!p->IsEvacuationCandidate()) continue;
     PagedSpace* space = static_cast<PagedSpace*>(p->owner());
-    space->AddToFreeLists(p->ObjectAreaStart(),
-                          p->ObjectAreaEnd() - p->ObjectAreaStart());
+    space->Free(p->ObjectAreaStart(), Page::kObjectAreaSize);
     p->set_scan_on_scavenge(false);
     slots_buffer_allocator_.DeallocateChain(p->slots_buffer_address());
     p->ClearEvacuationCandidate();
   }
   evacuation_candidates_.Rewind(0);
   compacting_ = false;
 }
 
 
 static const int kStartTableEntriesPerLine = 5;
@@ skipping 296 matching lines @@
   Address block_address = p->ObjectAreaStart();
 
   // Skip over all the dead objects at the start of the page and mark them free.
   for (cell_index = Page::kFirstUsedCell;
        cell_index < last_cell_index;
        cell_index++, block_address += 32 * kPointerSize) {
     if (cells[cell_index] != 0) break;
   }
   size_t size = block_address - p->ObjectAreaStart();
   if (cell_index == last_cell_index) {
-    freed_bytes += static_cast<int>(space->AddToFreeLists(
-        p->ObjectAreaStart(), static_cast<int>(size)));
+    freed_bytes += static_cast<int>(space->Free(p->ObjectAreaStart(),
+                                                static_cast<int>(size)));
     ASSERT_EQ(0, p->LiveBytes());
     return freed_bytes;
   }
   // Grow the size of the start-of-page free space a little to get up to the
   // first live object.
   Address free_end = StartOfLiveObject(block_address, cells[cell_index]);
   // Free the first free space.
   size = free_end - p->ObjectAreaStart();
-  freed_bytes += space->AddToFreeLists(p->ObjectAreaStart(),
-                                       static_cast<int>(size));
+  freed_bytes += space->Free(p->ObjectAreaStart(),
+                             static_cast<int>(size));
   // The start of the current free area is represented in undigested form by
   // the address of the last 32-word section that contained a live object and
   // the marking bitmap for that cell, which describes where the live object
   // started.  Unless we find a large free space in the bitmap we will not
   // digest this pair into a real address.  We start the iteration here at the
   // first word in the marking bit map that indicates a live object.
   Address free_start = block_address;
   uint32_t free_start_cell = cells[cell_index];
 
   for ( ;
        cell_index < last_cell_index;
        cell_index++, block_address += 32 * kPointerSize) {
     ASSERT((unsigned)cell_index ==
         Bitmap::IndexToCell(
             Bitmap::CellAlignIndex(
                 p->AddressToMarkbitIndex(block_address))));
     uint32_t cell = cells[cell_index];
     if (cell != 0) {
       // We have a live object.  Check approximately whether it is more than 32
       // words since the last live object.
       if (block_address - free_start > 32 * kPointerSize) {
         free_start = DigestFreeStart(free_start, free_start_cell);
         if (block_address - free_start > 32 * kPointerSize) {
           // Now that we know the exact start of the free space it still looks
           // like we have a large enough free space to be worth bothering with.
           // so now we need to find the start of the first live object at the
           // end of the free space.
           free_end = StartOfLiveObject(block_address, cell);
-          freed_bytes += space->AddToFreeLists(
-              free_start, static_cast<int>(free_end - free_start));
+          freed_bytes += space->Free(free_start,
+                                     static_cast<int>(free_end - free_start));
         }
       }
       // Update our undigested record of where the current free area started.
       free_start = block_address;
       free_start_cell = cell;
       // Clear marking bits for current cell.
       cells[cell_index] = 0;
     }
   }
 
   // Handle the free space at the end of the page.
   if (block_address - free_start > 32 * kPointerSize) {
     free_start = DigestFreeStart(free_start, free_start_cell);
-    freed_bytes += space->AddToFreeLists(
-        free_start, static_cast<int>(block_address - free_start));
+    freed_bytes += space->Free(free_start,
+                               static_cast<int>(block_address - free_start));
   }
 
   p->ResetLiveBytes();
   return freed_bytes;
 }
 
 
 void MarkCompactCollector::SweepSpace(PagedSpace* space, SweeperType sweeper) {
   space->set_was_swept_conservatively(sweeper == CONSERVATIVE ||
                                       sweeper == LAZY_CONSERVATIVE);
@@ skipping 311 matching lines @@
   while (buffer != NULL) {
     SlotsBuffer* next_buffer = buffer->next();
     DeallocateBuffer(buffer);
     buffer = next_buffer;
   }
   *buffer_address = NULL;
 }
 
 
 } }  // namespace v8::internal