As discussed on the phone, I'd like your thoughts on the...

src/serialize.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 575 matching lines @@
       3,
       "StackGuard::address_of_limit()");
   Add(ExternalReference::debug_break().address(),
       UNCLASSIFIED,
       4,
       "Debug::Break()");
   Add(ExternalReference::new_space_start().address(),
       UNCLASSIFIED,
       5,
       "Heap::NewSpaceStart()");
+  Add(ExternalReference::heap_always_allocate_scope_depth().address(),
+      UNCLASSIFIED,
+      6,
+      "Heap::always_allocate_scope_depth()");
   Add(ExternalReference::new_space_allocation_limit_address().address(),
       UNCLASSIFIED,
-      6,
+      7,
       "Heap::NewSpaceAllocationLimitAddress()");
   Add(ExternalReference::new_space_allocation_top_address().address(),
       UNCLASSIFIED,
-      7,
+      8,
       "Heap::NewSpaceAllocationTopAddress()");
   Add(ExternalReference::debug_step_in_fp_address().address(),
       UNCLASSIFIED,
-      8,
+      9,
       "Debug::step_in_fp_addr()");
 }
 
 
 ExternalReferenceEncoder::ExternalReferenceEncoder()
     : encodings_(Match) {
   ExternalReferenceTable* external_references =
       ExternalReferenceTable::instance();
   for (int i = 0; i < external_references->size(); ++i) {
     Put(external_references->address(i), i);
@@ skipping 777 matching lines @@
   Address a = GetEncodedAddress();
 
   // Get a raw object of the right size in the right space.
   AllocationSpace space = GetSpace(a);
   Object* o;
   if (IsLargeExecutableObject(a)) {
     o = Heap::lo_space()->AllocateRawCode(size);
   } else if (IsLargeFixedArray(a)) {
     o = Heap::lo_space()->AllocateRawFixedArray(size);
   } else {
-    o = Heap::AllocateRaw(size, space);
+    AllocationSpace retry_space = (space == NEW_SPACE)
+        ? Heap::TargetSpaceId(type)
+        : space;
+    o = Heap::AllocateRaw(size, space, retry_space);
   }
   ASSERT(!o->IsFailure());
   // Check that the simulation of heap allocation was correct.
   ASSERT(o == Resolve(a));
 
   // Read any recursively embedded objects.
   int c = reader_.GetC();
   while (c == '[') {
     GetObject();
     c = reader_.GetC();
@@ skipping 92 matching lines @@
         ASSERT(index < large_objects_.length());
       }
       return large_objects_[index];  // s.page_offset() is ignored.
   }
   UNREACHABLE();
   return NULL;
 }
 
 
 } }  // namespace v8::internal