Perform TODO(gc) cleanup for TODO-lockdown.

src/heap.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 360 matching lines @@
   }
 
   if (FLAG_gc_verbose) Print();
 #endif  // DEBUG
 
 #if defined(DEBUG)
   ReportStatisticsBeforeGC();
 #endif  // DEBUG
 
   LiveObjectList::GCPrologue();
+  store_buffer()->GCPrologue();
 }
 
 intptr_t Heap::SizeOfObjects() {
   intptr_t total = 0;
   AllSpaces spaces;
   for (Space* space = spaces.next(); space != NULL; space = spaces.next()) {
     total += space->SizeOfObjects();
   }
   return total;
 }
 
 void Heap::GarbageCollectionEpilogue() {
+  store_buffer()->GCEpilogue();
   LiveObjectList::GCEpilogue();
 #ifdef DEBUG
   allow_allocation(true);
   ZapFromSpace();
 
   if (FLAG_verify_heap) {
     Verify();
   }
 
   if (FLAG_print_global_handles) isolate_->global_handles()->Print();
@@ skipping 417 matching lines @@
   // At any old GC clear the keyed lookup cache to enable collection of unused
   // maps.
   isolate_->keyed_lookup_cache()->Clear();
   isolate_->context_slot_cache()->Clear();
   isolate_->descriptor_lookup_cache()->Clear();
 
   isolate_->compilation_cache()->MarkCompactPrologue();
 
   CompletelyClearInstanceofCache();
 
-  // TODO(gc) select heuristic for flushing NumberString cache with
+  // TODO(1605) select heuristic for flushing NumberString cache with
   // FlushNumberStringCache
   if (FLAG_cleanup_code_caches_at_gc) {
     polymorphic_code_cache()->set_cache(undefined_value());
   }
 
   ClearNormalizedMapCaches();
 }
 
 
 Object* Heap::FindCodeObject(Address a) {
@@ skipping 599 matching lines @@
     ASSERT((size_restriction != SMALL) ||
            (object_size <= Page::kMaxHeapObjectSize));
     ASSERT(object->Size() == object_size);
 
     Heap* heap = map->GetHeap();
     if (heap->ShouldBePromoted(object->address(), object_size)) {
       MaybeObject* maybe_result;
 
       if ((size_restriction != SMALL) &&
           (object_size > Page::kMaxHeapObjectSize)) {
-        if (object_contents == DATA_OBJECT) {
-          maybe_result = heap->lo_space()->AllocateRawData(object_size);
-        } else {
-          maybe_result = heap->lo_space()->AllocateRawFixedArray(object_size);
-        }
+        maybe_result = heap->lo_space()->AllocateRaw(object_size,
+                                                     NOT_EXECUTABLE);
       } else {
         if (object_contents == DATA_OBJECT) {
           maybe_result = heap->old_data_space()->AllocateRaw(object_size);
         } else {
           maybe_result = heap->old_pointer_space()->AllocateRaw(object_size);
         }
       }
 
       Object* result = NULL;  // Initialization to please compiler.
       if (maybe_result->ToObject(&result)) {
@@ skipping 1358 matching lines @@
   if (length < 0 || length > ByteArray::kMaxLength) {
     return Failure::OutOfMemoryException();
   }
   if (pretenure == NOT_TENURED) {
     return AllocateByteArray(length);
   }
   int size = ByteArray::SizeFor(length);
   Object* result;
   { MaybeObject* maybe_result = (size <= MaxObjectSizeInPagedSpace())
                    ? old_data_space_->AllocateRaw(size)
-                   : lo_space_->AllocateRawData(size);
+                   : lo_space_->AllocateRaw(size, NOT_EXECUTABLE);
     if (!maybe_result->ToObject(&result)) return maybe_result;
   }
 
   reinterpret_cast<ByteArray*>(result)->set_map(byte_array_map());
   reinterpret_cast<ByteArray*>(result)->set_length(length);
   return result;
 }
 
 
 MaybeObject* Heap::AllocateByteArray(int length) {
@@ skipping 62 matching lines @@
   }
 
   // Compute size.
   int body_size = RoundUp(desc.instr_size, kObjectAlignment);
   int obj_size = Code::SizeFor(body_size);
   ASSERT(IsAligned(static_cast<intptr_t>(obj_size), kCodeAlignment));
   MaybeObject* maybe_result;
   // Large code objects and code objects which should stay at a fixed address
   // are allocated in large object space.
   if (obj_size > MaxObjectSizeInPagedSpace() || immovable) {
-    maybe_result = lo_space_->AllocateRawCode(obj_size);
+    maybe_result = lo_space_->AllocateRaw(obj_size, EXECUTABLE);
   } else {
     maybe_result = code_space_->AllocateRaw(obj_size);
   }
 
   Object* result;
   if (!maybe_result->ToObject(&result)) return maybe_result;
 
   // Initialize the object
   HeapObject::cast(result)->set_map(code_map());
   Code* code = Code::cast(result);
@@ skipping 24 matching lines @@
 #endif
   return code;
 }
 
 
 MaybeObject* Heap::CopyCode(Code* code) {
   // Allocate an object the same size as the code object.
   int obj_size = code->Size();
   MaybeObject* maybe_result;
   if (obj_size > MaxObjectSizeInPagedSpace()) {
-    maybe_result = lo_space_->AllocateRawCode(obj_size);
+    maybe_result = lo_space_->AllocateRaw(obj_size, EXECUTABLE);
   } else {
     maybe_result = code_space_->AllocateRaw(obj_size);
   }
 
   Object* result;
   if (!maybe_result->ToObject(&result)) return maybe_result;
 
   // Copy code object.
   Address old_addr = code->address();
   Address new_addr = reinterpret_cast<HeapObject*>(result)->address();
@@ skipping 22 matching lines @@
 
   int new_obj_size = Code::SizeFor(new_body_size);
 
   Address old_addr = code->address();
 
   size_t relocation_offset =
       static_cast<size_t>(code->instruction_end() - old_addr);
 
   MaybeObject* maybe_result;
   if (new_obj_size > MaxObjectSizeInPagedSpace()) {
-    maybe_result = lo_space_->AllocateRawCode(new_obj_size);
+    maybe_result = lo_space_->AllocateRaw(new_obj_size, EXECUTABLE);
   } else {
     maybe_result = code_space_->AllocateRaw(new_obj_size);
   }
 
   Object* result;
   if (!maybe_result->ToObject(&result)) return maybe_result;
 
   // Copy code object.
   Address new_addr = reinterpret_cast<HeapObject*>(result)->address();
 
@@ skipping 677 matching lines @@
     if (chars > SeqTwoByteString::kMaxLength) {
       return Failure::OutOfMemoryException();
     }
     map = symbol_map();
     size = SeqTwoByteString::SizeFor(chars);
   }
 
   // Allocate string.
   Object* result;
   { MaybeObject* maybe_result = (size > MaxObjectSizeInPagedSpace())
-                   ? lo_space_->AllocateRawData(size)
+                   ? lo_space_->AllocateRaw(size, NOT_EXECUTABLE)
                    : old_data_space_->AllocateRaw(size);
     if (!maybe_result->ToObject(&result)) return maybe_result;
   }
 
   reinterpret_cast<HeapObject*>(result)->set_map(map);
   // Set length and hash fields of the allocated string.
   String* answer = String::cast(result);
   answer->set_length(chars);
   answer->set_hash_field(hash_field);
 
@@ skipping 96 matching lines @@
   if (length < 0 || length > FixedArray::kMaxLength) {
     return Failure::OutOfMemoryException();
   }
   ASSERT(length > 0);
   // Use the general function if we're forced to always allocate.
   if (always_allocate()) return AllocateFixedArray(length, TENURED);
   // Allocate the raw data for a fixed array.
   int size = FixedArray::SizeFor(length);
   return size <= kMaxObjectSizeInNewSpace
       ? new_space_.AllocateRaw(size)
-      : lo_space_->AllocateRawFixedArray(size);
+      : lo_space_->AllocateRaw(size, NOT_EXECUTABLE);
 }
 
 
 MaybeObject* Heap::CopyFixedArrayWithMap(FixedArray* src, Map* map) {
   int len = src->length();
   Object* obj;
   { MaybeObject* maybe_obj = AllocateRawFixedArray(len);
     if (!maybe_obj->ToObject(&obj)) return maybe_obj;
   }
   if (InNewSpace(obj)) {
@@ skipping 665 matching lines @@
   return mod >= Map::kPointerFieldsBeginOffset &&
          mod < Map::kPointerFieldsEndOffset;
 }
 
 
 bool EverythingsAPointer(Object** addr) {
   return true;
 }
 
 
-static void CheckStoreBuffer(Object** current,
+static void CheckStoreBuffer(Heap* heap,
+                             Object** current,
                              Object** limit,
                              Object**** store_buffer_position,
                              Object*** store_buffer_top,
                              CheckStoreBufferFilter filter,
                              Address special_garbage_start,
                              Address special_garbage_end) {
+  Map* free_space_map = heap->free_space_map();
   for ( ; current < limit; current++) {
     Object* o = *current;
     Address current_address = reinterpret_cast<Address>(current);
     // Skip free space.
-    // TODO(gc) ISOLATES MERGE
-    if (o == HEAP->free_space_map()) {
+    if (o == free_space_map) {
       Address current_address = reinterpret_cast<Address>(current);
       FreeSpace* free_space =
           FreeSpace::cast(HeapObject::FromAddress(current_address));
       int skip = free_space->Size();
       ASSERT(current_address + skip <= reinterpret_cast<Address>(limit));
       ASSERT(skip > 0);
       current_address += skip - kPointerSize;
       current = reinterpret_cast<Object**>(current_address);
       continue;
     }
     // Skip the current linear allocation space between top and limit which is
     // unmarked with the free space map, but can contain junk.
     if (current_address == special_garbage_start &&
         special_garbage_end != special_garbage_start) {
       current_address = special_garbage_end - kPointerSize;
       current = reinterpret_cast<Object**>(current_address);
       continue;
     }
     if (!(*filter)(current)) continue;
     ASSERT(current_address < special_garbage_start ||
            current_address >= special_garbage_end);
     ASSERT(reinterpret_cast<uintptr_t>(o) != kFreeListZapValue);
     // We have to check that the pointer does not point into new space
     // without trying to cast it to a heap object since the hash field of
     // a string can contain values like 1 and 3 which are tagged null
     // pointers.
-    // TODO(gc) ISOLATES MERGE
-    if (!HEAP->InNewSpace(o)) continue;
+    if (!heap->InNewSpace(o)) continue;
     while (**store_buffer_position < current &&
            *store_buffer_position < store_buffer_top) {
       (*store_buffer_position)++;
     }
     if (**store_buffer_position != current ||
         *store_buffer_position == store_buffer_top) {
       Object** obj_start = current;
       while (!(*obj_start)->IsMap()) obj_start--;
       UNREACHABLE();
     }
@@ skipping 13 matching lines @@
   while (pages.has_next()) {
     Page* page = pages.next();
     Object** current = reinterpret_cast<Object**>(page->ObjectAreaStart());
 
     Address end = page->ObjectAreaEnd();
 
     Object*** store_buffer_position = store_buffer()->Start();
     Object*** store_buffer_top = store_buffer()->Top();
 
     Object** limit = reinterpret_cast<Object**>(end);
-    CheckStoreBuffer(current,
+    CheckStoreBuffer(this,
+                     current,
                      limit,
                      &store_buffer_position,
                      store_buffer_top,
                      &EverythingsAPointer,
                      space->top(),
                      space->limit());
   }
 }
 
 
 void Heap::MapSpaceCheckStoreBuffer() {
   MapSpace* space = map_space();
   PageIterator pages(space);
 
   store_buffer()->SortUniq();
 
   while (pages.has_next()) {
     Page* page = pages.next();
     Object** current = reinterpret_cast<Object**>(page->ObjectAreaStart());
 
     Address end = page->ObjectAreaEnd();
 
     Object*** store_buffer_position = store_buffer()->Start();
     Object*** store_buffer_top = store_buffer()->Top();
 
     Object** limit = reinterpret_cast<Object**>(end);
-    CheckStoreBuffer(current,
+    CheckStoreBuffer(this,
+                     current,
                      limit,
                      &store_buffer_position,
                      store_buffer_top,
                      &IsAMapPointerAddress,
                      space->top(),
                      space->limit());
   }
 }
 
 
 void Heap::LargeObjectSpaceCheckStoreBuffer() {
   LargeObjectIterator it(lo_space());
   for (HeapObject* object = it.Next(); object != NULL; object = it.Next()) {
     // We only have code, sequential strings, or fixed arrays in large
     // object space, and only fixed arrays can possibly contain pointers to
     // the young generation.
     if (object->IsFixedArray()) {
       Object*** store_buffer_position = store_buffer()->Start();
       Object*** store_buffer_top = store_buffer()->Top();
       Object** current = reinterpret_cast<Object**>(object->address());
       Object** limit =
           reinterpret_cast<Object**>(object->address() + object->Size());
-      CheckStoreBuffer(current,
+      CheckStoreBuffer(this,
+                       current,
                        limit,
                        &store_buffer_position,
                        store_buffer_top,
                        &EverythingsAPointer,
                        NULL,
                        NULL);
     }
   }
 }
 #endif
@@ skipping 1384 matching lines @@
   }
   isolate_->heap()->store_buffer()->Filter(MemoryChunk::ABOUT_TO_BE_FREED);
   for (chunk = chunks_queued_for_free_; chunk != NULL; chunk = next) {
     next = chunk->next_chunk();
     isolate_->memory_allocator()->Free(chunk);
   }
   chunks_queued_for_free_ = NULL;
 }
 
 } }  // namespace v8::internal