Perform TODO(gc) cleanup for TODO-lockdown.

src/spaces.h

 // 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 102 matching lines @@
   ASSERT((0 <= index) && (index <= MapSpace::kMaxMapPageIndex))
 
 
 class PagedSpace;
 class MemoryAllocator;
 class AllocationInfo;
 class Space;
 class FreeList;
 class MemoryChunk;
 
-// TODO(gc): Check that this all gets inlined and register allocated on
-// all platforms.
 class MarkBit {
  public:
   typedef uint32_t CellType;
 
   inline MarkBit(CellType* cell, CellType mask, bool data_only)
       : cell_(cell), mask_(mask), data_only_(data_only) { }
 
   inline CellType* cell() { return cell_; }
   inline CellType mask() { return mask_; }
 
@@ skipping 774 matching lines @@
   void AddMemoryAllocationCallback(MemoryAllocationCallback callback,
                                           ObjectSpace space,
                                           AllocationAction action);
 
   void RemoveMemoryAllocationCallback(
       MemoryAllocationCallback callback);
 
   bool MemoryAllocationCallbackRegistered(
       MemoryAllocationCallback callback);
 
-
-  // TODO(gc) ISOLATSE
-
  private:
   Isolate* isolate_;
 
   // Maximum space size in bytes.
   size_t capacity_;
   // Maximum subset of capacity_ that can be executable
   size_t capacity_executable_;
 
   // Allocated space size in bytes.
   size_t size_;
@@ skipping 133 matching lines @@
 class AllocationInfo {
  public:
   AllocationInfo() : top(NULL), limit(NULL) {
   }
 
   Address top;  // Current allocation top.
   Address limit;  // Current allocation limit.
 
 #ifdef DEBUG
   bool VerifyPagedAllocation() {
-    // TODO(gc): Make this type-correct. NewSpacePage isn't a Page,
-    // but NewSpace still uses AllocationInfo.
     return (Page::FromAllocationTop(top) == Page::FromAllocationTop(limit))
         && (top <= limit);
   }
 #endif
 };
 
 
 // An abstraction of the accounting statistics of a page-structured space.
 // The 'capacity' of a space is the number of object-area bytes (ie, not
 // including page bookkeeping structures) currently in the space. The 'size'
@@ skipping 1174 matching lines @@
   // Creates a map space object with a maximum capacity.
   MapSpace(Heap* heap,
            intptr_t max_capacity,
            int max_map_space_pages,
            AllocationSpace id)
       : FixedSpace(heap, max_capacity, id, Map::kSize, "map"),
         max_map_space_pages_(max_map_space_pages) {
   }
 
   // Given an index, returns the page address.
-  // TODO(gc): this limit is artifical just to keep code compilable
+  // TODO(1600): this limit is artifical just to keep code compilable
   static const int kMaxMapPageIndex = 1 << 16;
 
-  // Are map pointers encodable into map word?
-  bool MapPointersEncodable() {
-    return false;
-  }
-
-  // Should be called after forced sweep to find out if map space needs
-  // compaction.
-  bool NeedsCompaction(int live_maps) {
-    return false;  // TODO(gc): Bring back map compaction.
-  }
-
   virtual int RoundSizeDownToObjectAlignment(int size) {
     if (IsPowerOf2(Map::kSize)) {
       return RoundDown(size, Map::kSize);
     } else {
       return (size / Map::kSize) * Map::kSize;
     }
   }
 
  protected:
 #ifdef DEBUG
@@ skipping 54 matching lines @@
  public:
   LargeObjectSpace(Heap* heap, AllocationSpace id);
   virtual ~LargeObjectSpace() {}
 
   // Initializes internal data structures.
   bool Setup();
 
   // Releases internal resources, frees objects in this space.
   void TearDown();
 
-  // Allocates a (non-FixedArray, non-Code) large object.
-  MUST_USE_RESULT MaybeObject* AllocateRawData(int size_in_bytes);
-  // Allocates a large Code object.
-  MUST_USE_RESULT MaybeObject* AllocateRawCode(int size_in_bytes);
-  // Allocates a large FixedArray.
-  MUST_USE_RESULT MaybeObject* AllocateRawFixedArray(int size_in_bytes);
-
   static intptr_t ObjectSizeFor(intptr_t chunk_size) {
     if (chunk_size <= (Page::kPageSize + Page::kObjectStartOffset)) return 0;
     return chunk_size - Page::kPageSize - Page::kObjectStartOffset;
   }
 
+  // Shared implementation of AllocateRaw, AllocateRawCode and
+  // AllocateRawFixedArray.
+  MUST_USE_RESULT MaybeObject* AllocateRaw(int object_size,
+                                           Executability executable);
+
   // Available bytes for objects in this space.
   inline intptr_t Available();
 
   virtual intptr_t Size() {
     return size_;
   }
 
   virtual intptr_t SizeOfObjects() {
     return objects_size_;
   }
@@ skipping 37 matching lines @@
   // iterates all objects in the space. May be slow.
   bool SlowContains(Address addr) { return !FindObject(addr)->IsFailure(); }
 
  private:
   // The head of the linked list of large object chunks.
   LargePage* first_page_;
   intptr_t size_;  // allocated bytes
   int page_count_;  // number of chunks
   intptr_t objects_size_;  // size of objects
 
-  // Shared implementation of AllocateRaw, AllocateRawCode and
-  // AllocateRawFixedArray.
-  MUST_USE_RESULT MaybeObject* AllocateRawInternal(int object_size,
-                                                   Executability executable);
-
   friend class LargeObjectIterator;
 
  public:
   TRACK_MEMORY("LargeObjectSpace")
 };
 
 
 class LargeObjectIterator: public ObjectIterator {
  public:
   explicit LargeObjectIterator(LargeObjectSpace* space);
   LargeObjectIterator(LargeObjectSpace* space, HeapObjectCallback size_func);
 
   HeapObject* Next();
 
   // implementation of ObjectIterator.
   virtual HeapObject* next_object() { return Next(); }
 
  private:
   LargePage* current_;
   HeapObjectCallback size_func_;
 };
 
 
 // Iterates over the chunks (pages and large object pages) that can contain
 // pointers to new space.
 class PointerChunkIterator BASE_EMBEDDED {
  public:
-  inline PointerChunkIterator();
+  inline explicit PointerChunkIterator(Heap* heap_);

[Erik Corry, 2011/08/16 11:17:20]

No underscore here.

 
   // Return NULL when the iterator is done.
   MemoryChunk* next() {
     switch (state_) {
       case kOldPointerState: {
         if (old_pointer_iterator_.has_next()) {
           return old_pointer_iterator_.next();
         }
         state_ = kMapState;
         // Fall through.
@@ skipping 55 matching lines @@
   }
   // Must be small, since an iteration is used for lookup.
   static const int kMaxComments = 64;
 };
 #endif
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_SPACES_H_