* Move almost all roots into an array ready for use by a constant-pool...

src/mark-compact.cc

 // Copyright 2006-2008 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 206 matching lines @@
   //   (ConsString::cast(object)->second() == Heap::empty_string())
   // except the maps for the object and its possible substrings might be
   // marked.
   HeapObject* object = HeapObject::cast(*p);
   MapWord map_word = object->map_word();
   map_word.ClearMark();
   InstanceType type = map_word.ToMap()->instance_type();
   if ((type & kShortcutTypeMask) != kShortcutTypeTag) return object;
 
   Object* second = reinterpret_cast<ConsString*>(object)->unchecked_second();
-  if (reinterpret_cast<String*>(second) != Heap::empty_string()) return object;
+  if (reinterpret_cast<String*>(second) !=

[Kasper Lund, 2009/07/08 12:42:37]

Why is the reinterpret_cast necessary here? It's really an Object* identity
check, right? It should fit nicely on a single line.

[Erik Corry, 2009/07/08 14:19:50]

It wasn't necessary.

+      Heap::raw_unchecked_empty_string()) {
+    return object;
+  }
 
   // Since we don't have the object's start, it is impossible to update the
   // remembered set.  Therefore, we only replace the string with its left
   // substring when the remembered set does not change.
   Object* first = reinterpret_cast<ConsString*>(object)->unchecked_first();
   if (!Heap::InNewSpace(object) && Heap::InNewSpace(first)) return object;
 
   *p = first;
   return HeapObject::cast(first);
 }
@@ skipping 176 matching lines @@
           } else {
             v8::String::ExternalAsciiStringResource** resource =
                 reinterpret_cast<v8::String::ExternalAsciiStringResource**>
                 (resource_addr);
             delete *resource;
             // Clear the resource pointer in the symbol.
             *resource = NULL;
           }
         }
         // Set the entry to null_value (as deleted).
-        *p = Heap::null_value();
+        *p = Heap::raw_unchecked_null_value();
         pointers_removed_++;
       }
     }
   }
 
   int PointersRemoved() {
     return pointers_removed_;
   }
  private:
   int pointers_removed_;
@@ skipping 33 matching lines @@
   MarkingVisitor visitor;  // Has no state or contents.
   visitor.VisitPointers(HeapObject::RawField(map, Map::kPrototypeOffset),
                         HeapObject::RawField(map, Map::kSize));
 }
 
 
 void MarkCompactCollector::MarkDescriptorArray(
     DescriptorArray* descriptors) {
   if (descriptors->IsMarked()) return;
   // Empty descriptor array is marked as a root before any maps are marked.
-  ASSERT(descriptors != Heap::empty_descriptor_array());
+  ASSERT(descriptors != Heap::raw_unchecked_empty_descriptor_array());
   SetMark(descriptors);
 
   FixedArray* contents = reinterpret_cast<FixedArray*>(
       descriptors->get(DescriptorArray::kContentArrayIndex));
   ASSERT(contents->IsHeapObject());
   ASSERT(!contents->IsMarked());
   ASSERT(contents->IsFixedArray());
   ASSERT(contents->length() >= 2);
   SetMark(contents);
   // Contents contains (value, details) pairs.  If the details say
@@ skipping 94 matching lines @@
   }
 };
 
 
 void MarkCompactCollector::MarkSymbolTable() {
   // Objects reachable from symbols are marked as live so as to ensure
   // that if the symbol itself remains alive after GC for any reason,
   // and if it is a sliced string or a cons string backed by an
   // external string (even indirectly), then the external string does
   // not receive a weak reference callback.
-  SymbolTable* symbol_table = SymbolTable::cast(Heap::symbol_table());
+  SymbolTable* symbol_table =
+      reinterpret_cast<SymbolTable*>(Heap::raw_unchecked_symbol_table());

[Kasper Lund, 2009/07/08 12:42:37]

Doesn't raw_unchecked_symbol_table return something of type SymbolTable*
already? Can't you get rid of reinterpret_cast?

   // Mark the symbol table itself.
   SetMark(symbol_table);
   // Explicitly mark the prefix.
   MarkingVisitor marker;
   symbol_table->IteratePrefix(&marker);
   ProcessMarkingStack(&marker);
   // Mark subparts of the symbols but not the symbols themselves
   // (unless reachable from another symbol).
   SymbolMarkingVisitor symbol_marker;
   symbol_table->IterateElements(&symbol_marker);
@@ skipping 172 matching lines @@
   }
 
   // Repeat the object groups to mark unmarked groups reachable from the
   // weak roots.
   ProcessObjectGroups(root_visitor.stack_visitor());
 
   // Prune the symbol table removing all symbols only pointed to by the
   // symbol table.  Cannot use SymbolTable::cast here because the symbol
   // table is marked.
   SymbolTable* symbol_table =
-      reinterpret_cast<SymbolTable*>(Heap::symbol_table());
+      reinterpret_cast<SymbolTable*>(Heap::raw_unchecked_symbol_table());

[Kasper Lund, 2009/07/08 12:42:37]

Do you need reinterpret_cast here?

   SymbolTableCleaner v;
   symbol_table->IterateElements(&v);
   symbol_table->ElementsRemoved(v.PointersRemoved());
 
   // Remove object groups after marking phase.
   GlobalHandles::RemoveObjectGroups();
 }
 
 
 static int CountMarkedCallback(HeapObject* obj) {
@@ skipping 338 matching lines @@
        current += object->Size()) {
     object = HeapObject::FromAddress(current);
     if (object->IsMarked()) {
       object->ClearMark();
       MarkCompactCollector::tracer()->decrement_marked_count();
     } else {
       // We give non-live objects a map that will correctly give their size,
       // since their existing map might not be live after the collection.
       int size = object->Size();
       if (size >= ByteArray::kHeaderSize) {
-        object->set_map(Heap::byte_array_map());
+        object->set_map(Heap::raw_unchecked_byte_array_map());
         ByteArray::cast(object)->set_length(ByteArray::LengthFor(size));
       } else {
         ASSERT(size == kPointerSize);
-        object->set_map(Heap::one_word_filler_map());
+        object->set_map(Heap::raw_unchecked_one_word_filler_map());
       }
       ASSERT(object->Size() == size);
     }
     // The object is now unmarked for the call to Size() at the top of the
     // loop.
   }
 }
 
 
 static void SweepSpace(PagedSpace* space, DeallocateFunction dealloc) {
@@ skipping 640 matching lines @@
 
 void MarkCompactCollector::RebuildRSets() {
 #ifdef DEBUG
   ASSERT(state_ == RELOCATE_OBJECTS);
   state_ = REBUILD_RSETS;
 #endif
   Heap::RebuildRSets();
 }
 
 } }  // namespace v8::internal