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

src/spaces.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 1123 matching lines @@
              heap_histograms[i].name(),
              heap_histograms[i].number(),
              heap_histograms[i].bytes());
     }
   }
   PrintF("\n");
 
   // Summarize string types.
   int string_number = 0;
   int string_bytes = 0;
-#define INCREMENT(type, size, name)                  \
+#define INCREMENT(type, size, name, camel_name)      \
     string_number += heap_histograms[type].number(); \
     string_bytes += heap_histograms[type].bytes();
   STRING_TYPE_LIST(INCREMENT)
 #undef INCREMENT
   if (string_number > 0) {
     PrintF("    %-33s%10d (%10d bytes)\n\n", "STRING_TYPE", string_number,
            string_bytes);
   }
 
   if (FLAG_collect_heap_spill_statistics && print_spill) {
@@ skipping 23 matching lines @@
   while (it.has_next()) RecordAllocation(it.next());
 }
 
 
 #ifdef ENABLE_LOGGING_AND_PROFILING
 static void DoReportStatistics(HistogramInfo* info, const char* description) {
   LOG(HeapSampleBeginEvent("NewSpace", description));
   // Lump all the string types together.
   int string_number = 0;
   int string_bytes = 0;
-#define INCREMENT(type, size, name)       \
-    string_number += info[type].number(); \
+#define INCREMENT(type, size, name, camel_name)       \
+    string_number += info[type].number();             \
     string_bytes += info[type].bytes();
   STRING_TYPE_LIST(INCREMENT)
 #undef INCREMENT
   if (string_number > 0) {
     LOG(HeapSampleItemEvent("STRING_TYPE", string_number, string_bytes));
   }
 
   // Then do the other types.
   for (int i = FIRST_NONSTRING_TYPE; i <= LAST_TYPE; ++i) {
     if (info[i].number() > 0) {
@@ skipping 59 matching lines @@
   ASSERT(IsAligned(size_in_bytes, kPointerSize));
 
   // We write a map and possibly size information to the block.  If the block
   // is big enough to be a ByteArray with at least one extra word (the next
   // pointer), we set its map to be the byte array map and its size to an
   // appropriate array length for the desired size from HeapObject::Size().
   // If the block is too small (eg, one or two words), to hold both a size
   // field and a next pointer, we give it a filler map that gives it the
   // correct size.
   if (size_in_bytes > ByteArray::kHeaderSize) {
-    set_map(Heap::byte_array_map());
+    set_map(Heap::raw_unchecked_byte_array_map());
     ByteArray::cast(this)->set_length(ByteArray::LengthFor(size_in_bytes));
   } else if (size_in_bytes == kPointerSize) {
-    set_map(Heap::one_word_filler_map());
+    set_map(Heap::raw_unchecked_one_word_filler_map());
   } else if (size_in_bytes == 2 * kPointerSize) {
-    set_map(Heap::two_word_filler_map());
+    set_map(Heap::raw_unchecked_two_word_filler_map());
   } else {
     UNREACHABLE();
   }
   ASSERT(Size() == size_in_bytes);
 }
 
 
 Address FreeListNode::next() {
-  ASSERT(map() == Heap::byte_array_map());
+  ASSERT(map() == Heap::raw_unchecked_byte_array_map());
   ASSERT(Size() >= kNextOffset + kPointerSize);
   return Memory::Address_at(address() + kNextOffset);
 }
 
 
 void FreeListNode::set_next(Address next) {
-  ASSERT(map() == Heap::byte_array_map());
+  ASSERT(map() == Heap::raw_unchecked_byte_array_map());
   ASSERT(Size() >= kNextOffset + kPointerSize);
   Memory::Address_at(address() + kNextOffset) = next;
 }
 
 
 OldSpaceFreeList::OldSpaceFreeList(AllocationSpace owner) : owner_(owner) {
   Reset();
 }
 
 
@@ skipping 548 matching lines @@
       int rset = Memory::int_at(rset_addr);
       if (rset != 0) {
         // Bits were set
         int intoff = rset_addr - p->address();
         int bitoff = 0;
         for (; bitoff < kBitsPerInt; ++bitoff) {
           if ((rset & (1 << bitoff)) != 0) {
             int bitpos = intoff*kBitsPerByte + bitoff;
             Address slot = p->OffsetToAddress(bitpos << kObjectAlignmentBits);
             Object** obj = reinterpret_cast<Object**>(slot);
-            if (*obj == Heap::fixed_array_map()) {
+            if (*obj == Heap::raw_unchecked_fixed_array_map()) {
               rset_marked_arrays++;
               FixedArray* fa = FixedArray::cast(HeapObject::FromAddress(slot));
 
               rset_marked_array_elements += fa->length();
               // Manually inline FixedArray::IterateBody
               Address elm_start = slot + FixedArray::kHeaderSize;
               Address elm_stop = elm_start + fa->length() * kPointerSize;
               for (Address elm_addr = elm_start;
                    elm_addr < elm_stop; elm_addr += kPointerSize) {
                 // Filter non-heap-object pointers
@@ skipping 759 matching lines @@
                      reinterpret_cast<Object**>(object->address()
                                                 + Page::kObjectAreaSize),
                      allocation_top);
       PrintF("\n");
     }
   }
 }
 #endif  // DEBUG
 
 } }  // namespace v8::internal