Changed allocation to allow large objects to be allocated in new space....

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 929 matching lines @@
          offset < free_size;
          offset += kPointerSize) {
       Memory::Address_at(free_start + offset) = kZapValue;
     }
   }
 #endif
 }
 
 
 // Try to promote all objects in new space.  Heap numbers and sequential
 // strings are promoted to the code space, all others to the old space.

[Mads Ager (chromium), 2009/06/18 14:01:20]

Not your code, but this comment seems wrong.  Heap numbers and sequential
strings are promoted to old data space, not code space.

 inline Object* MCAllocateFromNewSpace(HeapObject* object, int object_size) {
-  OldSpace* target_space = Heap::TargetSpace(object);
-  ASSERT(target_space == Heap::old_pointer_space() ||
-         target_space == Heap::old_data_space());
-  Object* forwarded = target_space->MCAllocateRaw(object_size);
-
+  Object* forwarded ;

[Mads Ager (chromium), 2009/06/18 14:01:20]

Remove space before ';'.

+  if (object_size > Heap::MaxObjectSizeInPagedSpace()) {
+    forwarded = Failure::Exception();
+  } else {
+    OldSpace* target_space = Heap::TargetSpace(object);
+    ASSERT(target_space == Heap::old_pointer_space() ||
+           target_space == Heap::old_data_space());
+    forwarded = target_space->MCAllocateRaw(object_size);
+  }
   if (forwarded->IsFailure()) {
     forwarded = Heap::new_space()->MCAllocateRaw(object_size);
   }
   return forwarded;
 }
 
 
 // Allocation functions for the paged spaces call the space's MCAllocateRaw.
 inline Object* MCAllocateFromOldPointerSpace(HeapObject* object,
                                              int object_size) {
@@ skipping 700 matching lines @@
   obj->set_map(reinterpret_cast<Map*>(HeapObject::FromAddress(map_addr)));
 
   // This is a non-map object, it relies on the assumption that the Map space
   // is compacted before the Old space (see RelocateObjects).
   int obj_size = obj->Size();
   ASSERT_OBJECT_SIZE(obj_size);
 
   ASSERT(space->MCSpaceOffsetForAddress(new_addr) <=
          space->MCSpaceOffsetForAddress(obj->address()));
 
-  space->MCAdjustRelocationEnd(new_addr, obj_size);
+  reinterpret_cast<OldSpace*>(space)->MCAdjustRelocationEnd(new_addr, obj_size);

[Mads Ager (chromium), 2009/06/18 14:01:20]

space is already has type OldSpace*, so there should be no need for the cast?

 
 #ifdef DEBUG
   if (FLAG_gc_verbose) {
     PrintF("relocate %p -> %p\n", obj->address(), new_addr);
   }
 #endif
 
   return obj_size;
 }
 
@@ skipping 107 matching lines @@
 
 void MarkCompactCollector::RebuildRSets() {
 #ifdef DEBUG
   ASSERT(state_ == RELOCATE_OBJECTS);
   state_ = REBUILD_RSETS;
 #endif
   Heap::RebuildRSets();
 }
 
 } }  // namespace v8::internal