the idea is that often times in code, you will see something like this:...

src/heap.cc

 // Copyright 2009 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 1646 matching lines @@
   share->set_start_position_and_type(0);
   share->set_debug_info(undefined_value());
   share->set_inferred_name(empty_string());
   share->set_compiler_hints(0);
   share->set_this_property_assignments_count(0);
   share->set_this_property_assignments(undefined_value());
   return result;
 }
 
 
-Object* Heap::AllocateConsString(String* first, String* second) {
+Object* Heap::AllocateConsString(String* first,
+                                 String* second,
+                                 PretenureFlag pretenure) {
   int first_length = first->length();
   if (first_length == 0) return second;
 
   int second_length = second->length();
   if (second_length == 0) return first;
 
   int length = first_length + second_length;
   bool is_ascii = first->IsAsciiRepresentation()
       && second->IsAsciiRepresentation();
 
   // Make sure that an out of memory exception is thrown if the length
   // of the new cons string is too large to fit in a Smi.
   if (length > Smi::kMaxValue || length < -0) {
     Top::context()->mark_out_of_memory();
     return Failure::OutOfMemoryException();
   }
 
   // If the resulting string is small make a flat string.
   if (length < String::kMinNonFlatLength) {
     ASSERT(first->IsFlat());
     ASSERT(second->IsFlat());
     if (is_ascii) {
-      Object* result = AllocateRawAsciiString(length);
+      Object* result = AllocateRawAsciiString(length, pretenure);
       if (result->IsFailure()) return result;
       // Copy the characters into the new object.
       char* dest = SeqAsciiString::cast(result)->GetChars();
       // Copy first part.
       char* src = SeqAsciiString::cast(first)->GetChars();
       for (int i = 0; i < first_length; i++) *dest++ = src[i];
       // Copy second part.
       src = SeqAsciiString::cast(second)->GetChars();
       for (int i = 0; i < second_length; i++) *dest++ = src[i];
       return result;
     } else {
-      Object* result = AllocateRawTwoByteString(length);
+      Object* result = AllocateRawTwoByteString(length, pretenure);
       if (result->IsFailure()) return result;
       // Copy the characters into the new object.
       uc16* dest = SeqTwoByteString::cast(result)->GetChars();
       String::WriteToFlat(first, dest, 0, first_length);
       String::WriteToFlat(second, dest + first_length, 0, second_length);
       return result;
     }
   }
 
   Map* map;
   if (length <= String::kMaxShortStringSize) {
     map = is_ascii ? short_cons_ascii_string_map()
       : short_cons_string_map();
   } else if (length <= String::kMaxMediumStringSize) {
     map = is_ascii ? medium_cons_ascii_string_map()
       : medium_cons_string_map();
   } else {
     map = is_ascii ? long_cons_ascii_string_map()
       : long_cons_string_map();
   }
 
-  Object* result = Allocate(map, NEW_SPACE);
+  AllocationSpace space =
+      (pretenure == TENURED) ? OLD_POINTER_SPACE : NEW_SPACE;
+  if (map->instance_size() > MaxObjectSizeInPagedSpace()) space = LO_SPACE;
+  Object* result = Allocate(map, space);
   if (result->IsFailure()) return result;
-  ASSERT(InNewSpace(result));
+  ASSERT(pretenure == TENURED ? !InNewSpace(result) : InNewSpace(result));
   ConsString* cons_string = ConsString::cast(result);
-  cons_string->set_first(first, SKIP_WRITE_BARRIER);
-  cons_string->set_second(second, SKIP_WRITE_BARRIER);
+  WriteBarrierMode write_barrier_mode =
+      (pretenure == TENURED) ? UPDATE_WRITE_BARRIER : SKIP_WRITE_BARRIER;
+  cons_string->set_first(first, write_barrier_mode);
+  cons_string->set_second(second, write_barrier_mode);
   cons_string->set_length(length);
   return result;
 }
 
 
 Object* Heap::AllocateSlicedString(String* buffer,
                                    int start,
                                    int end) {
   int length = end - start;
 
@@ skipping 2134 matching lines @@
   for (int i = 0; i < kNumberOfCaches; i++) {
     if (caches_[i] != NULL) {
       delete caches_[i];
       caches_[i] = NULL;
     }
   }
 }
 
 
 } }  // namespace v8::internal