| Index: src/ia32/macro-assembler-ia32.cc
 | 
| diff --git a/src/ia32/macro-assembler-ia32.cc b/src/ia32/macro-assembler-ia32.cc
 | 
| index 494a1bf21f5d785971b35b7554933e601c88df9a..4aaaf983aae9ea5df64a68997509e5ec40eba6b0 100644
 | 
| --- a/src/ia32/macro-assembler-ia32.cc
 | 
| +++ b/src/ia32/macro-assembler-ia32.cc
 | 
| @@ -1214,8 +1214,8 @@ void MacroAssembler::LoadFromNumberDictionary(Label* miss,
 | 
|  void MacroAssembler::LoadAllocationTopHelper(Register result,
 | 
|                                               Register scratch,
 | 
|                                               AllocationFlags flags) {
 | 
| -  ExternalReference new_space_allocation_top =
 | 
| -      ExternalReference::new_space_allocation_top_address(isolate());
 | 
| +  ExternalReference allocation_top =
 | 
| +      AllocationUtils::GetAllocationTopReference(isolate(), flags);
 | 
|  
 | 
|    // Just return if allocation top is already known.
 | 
|    if ((flags & RESULT_CONTAINS_TOP) != 0) {
 | 
| @@ -1223,7 +1223,7 @@ void MacroAssembler::LoadAllocationTopHelper(Register result,
 | 
|      ASSERT(scratch.is(no_reg));
 | 
|  #ifdef DEBUG
 | 
|      // Assert that result actually contains top on entry.
 | 
| -    cmp(result, Operand::StaticVariable(new_space_allocation_top));
 | 
| +    cmp(result, Operand::StaticVariable(allocation_top));
 | 
|      Check(equal, "Unexpected allocation top");
 | 
|  #endif
 | 
|      return;
 | 
| @@ -1231,39 +1231,40 @@ void MacroAssembler::LoadAllocationTopHelper(Register result,
 | 
|  
 | 
|    // Move address of new object to result. Use scratch register if available.
 | 
|    if (scratch.is(no_reg)) {
 | 
| -    mov(result, Operand::StaticVariable(new_space_allocation_top));
 | 
| +    mov(result, Operand::StaticVariable(allocation_top));
 | 
|    } else {
 | 
| -    mov(scratch, Immediate(new_space_allocation_top));
 | 
| +    mov(scratch, Immediate(allocation_top));
 | 
|      mov(result, Operand(scratch, 0));
 | 
|    }
 | 
|  }
 | 
|  
 | 
|  
 | 
|  void MacroAssembler::UpdateAllocationTopHelper(Register result_end,
 | 
| -                                               Register scratch) {
 | 
| +                                               Register scratch,
 | 
| +                                               AllocationFlags flags) {
 | 
|    if (emit_debug_code()) {
 | 
|      test(result_end, Immediate(kObjectAlignmentMask));
 | 
|      Check(zero, "Unaligned allocation in new space");
 | 
|    }
 | 
|  
 | 
| -  ExternalReference new_space_allocation_top =
 | 
| -      ExternalReference::new_space_allocation_top_address(isolate());
 | 
| +  ExternalReference allocation_top =
 | 
| +      AllocationUtils::GetAllocationTopReference(isolate(), flags);
 | 
|  
 | 
|    // Update new top. Use scratch if available.
 | 
|    if (scratch.is(no_reg)) {
 | 
| -    mov(Operand::StaticVariable(new_space_allocation_top), result_end);
 | 
| +    mov(Operand::StaticVariable(allocation_top), result_end);
 | 
|    } else {
 | 
|      mov(Operand(scratch, 0), result_end);
 | 
|    }
 | 
|  }
 | 
|  
 | 
|  
 | 
| -void MacroAssembler::AllocateInNewSpace(int object_size,
 | 
| -                                        Register result,
 | 
| -                                        Register result_end,
 | 
| -                                        Register scratch,
 | 
| -                                        Label* gc_required,
 | 
| -                                        AllocationFlags flags) {
 | 
| +void MacroAssembler::Allocate(int object_size,
 | 
| +                              Register result,
 | 
| +                              Register result_end,
 | 
| +                              Register scratch,
 | 
| +                              Label* gc_required,
 | 
| +                              AllocationFlags flags) {
 | 
|    ASSERT((flags & (RESULT_CONTAINS_TOP | SIZE_IN_WORDS)) == 0);
 | 
|    if (!FLAG_inline_new) {
 | 
|      if (emit_debug_code()) {
 | 
| @@ -1287,6 +1288,7 @@ void MacroAssembler::AllocateInNewSpace(int object_size,
 | 
|    // Align the next allocation. Storing the filler map without checking top is
 | 
|    // always safe because the limit of the heap is always aligned.
 | 
|    if ((flags & DOUBLE_ALIGNMENT) != 0) {
 | 
| +    ASSERT((flags & PRETENURE_OLD_POINTER_SPACE) == 0);
 | 
|      ASSERT(kPointerAlignment * 2 == kDoubleAlignment);
 | 
|      Label aligned;
 | 
|      test(result, Immediate(kDoubleAlignmentMask));
 | 
| @@ -1299,20 +1301,20 @@ void MacroAssembler::AllocateInNewSpace(int object_size,
 | 
|  
 | 
|    Register top_reg = result_end.is_valid() ? result_end : result;
 | 
|  
 | 
| -  // Calculate new top and bail out if new space is exhausted.
 | 
| -  ExternalReference new_space_allocation_limit =
 | 
| -      ExternalReference::new_space_allocation_limit_address(isolate());
 | 
| +  // Calculate new top and bail out if space is exhausted.
 | 
| +  ExternalReference allocation_limit =
 | 
| +      AllocationUtils::GetAllocationLimitReference(isolate(), flags);
 | 
|  
 | 
|    if (!top_reg.is(result)) {
 | 
|      mov(top_reg, result);
 | 
|    }
 | 
|    add(top_reg, Immediate(object_size));
 | 
|    j(carry, gc_required);
 | 
| -  cmp(top_reg, Operand::StaticVariable(new_space_allocation_limit));
 | 
| +  cmp(top_reg, Operand::StaticVariable(allocation_limit));
 | 
|    j(above, gc_required);
 | 
|  
 | 
|    // Update allocation top.
 | 
| -  UpdateAllocationTopHelper(top_reg, scratch);
 | 
| +  UpdateAllocationTopHelper(top_reg, scratch, flags);
 | 
|  
 | 
|    // Tag result if requested.
 | 
|    bool tag_result = (flags & TAG_OBJECT) != 0;
 | 
| @@ -1340,6 +1342,7 @@ void MacroAssembler::AllocateInNewSpace(
 | 
|      Label* gc_required,
 | 
|      AllocationFlags flags) {
 | 
|    ASSERT((flags & SIZE_IN_WORDS) == 0);
 | 
| +  ASSERT((flags & PRETENURE_OLD_POINTER_SPACE) == 0);
 | 
|    if (!FLAG_inline_new) {
 | 
|      if (emit_debug_code()) {
 | 
|        // Trash the registers to simulate an allocation failure.
 | 
| @@ -1399,7 +1402,7 @@ void MacroAssembler::AllocateInNewSpace(
 | 
|    }
 | 
|  
 | 
|    // Update allocation top.
 | 
| -  UpdateAllocationTopHelper(result_end, scratch);
 | 
| +  UpdateAllocationTopHelper(result_end, scratch, flags);
 | 
|  }
 | 
|  
 | 
|  
 | 
| @@ -1410,6 +1413,7 @@ void MacroAssembler::AllocateInNewSpace(Register object_size,
 | 
|                                          Label* gc_required,
 | 
|                                          AllocationFlags flags) {
 | 
|    ASSERT((flags & (RESULT_CONTAINS_TOP | SIZE_IN_WORDS)) == 0);
 | 
| +  ASSERT((flags & PRETENURE_OLD_POINTER_SPACE) == 0);
 | 
|    if (!FLAG_inline_new) {
 | 
|      if (emit_debug_code()) {
 | 
|        // Trash the registers to simulate an allocation failure.
 | 
| @@ -1459,7 +1463,7 @@ void MacroAssembler::AllocateInNewSpace(Register object_size,
 | 
|    }
 | 
|  
 | 
|    // Update allocation top.
 | 
| -  UpdateAllocationTopHelper(result_end, scratch);
 | 
| +  UpdateAllocationTopHelper(result_end, scratch, flags);
 | 
|  }
 | 
|  
 | 
|  
 | 
| @@ -1482,12 +1486,8 @@ void MacroAssembler::AllocateHeapNumber(Register result,
 | 
|                                          Register scratch2,
 | 
|                                          Label* gc_required) {
 | 
|    // Allocate heap number in new space.
 | 
| -  AllocateInNewSpace(HeapNumber::kSize,
 | 
| -                     result,
 | 
| -                     scratch1,
 | 
| -                     scratch2,
 | 
| -                     gc_required,
 | 
| -                     TAG_OBJECT);
 | 
| +  Allocate(HeapNumber::kSize, result, scratch1, scratch2, gc_required,
 | 
| +           TAG_OBJECT);
 | 
|  
 | 
|    // Set the map.
 | 
|    mov(FieldOperand(result, HeapObject::kMapOffset),
 | 
| @@ -1575,12 +1575,8 @@ void MacroAssembler::AllocateAsciiString(Register result,
 | 
|    ASSERT(length > 0);
 | 
|  
 | 
|    // Allocate ASCII string in new space.
 | 
| -  AllocateInNewSpace(SeqOneByteString::SizeFor(length),
 | 
| -                     result,
 | 
| -                     scratch1,
 | 
| -                     scratch2,
 | 
| -                     gc_required,
 | 
| -                     TAG_OBJECT);
 | 
| +  Allocate(SeqOneByteString::SizeFor(length), result, scratch1, scratch2,
 | 
| +           gc_required, TAG_OBJECT);
 | 
|  
 | 
|    // Set the map, length and hash field.
 | 
|    mov(FieldOperand(result, HeapObject::kMapOffset),
 | 
| @@ -1597,12 +1593,8 @@ void MacroAssembler::AllocateTwoByteConsString(Register result,
 | 
|                                          Register scratch2,
 | 
|                                          Label* gc_required) {
 | 
|    // Allocate heap number in new space.
 | 
| -  AllocateInNewSpace(ConsString::kSize,
 | 
| -                     result,
 | 
| -                     scratch1,
 | 
| -                     scratch2,
 | 
| -                     gc_required,
 | 
| -                     TAG_OBJECT);
 | 
| +  Allocate(ConsString::kSize, result, scratch1, scratch2, gc_required,
 | 
| +           TAG_OBJECT);
 | 
|  
 | 
|    // Set the map. The other fields are left uninitialized.
 | 
|    mov(FieldOperand(result, HeapObject::kMapOffset),
 | 
| @@ -1615,12 +1607,8 @@ void MacroAssembler::AllocateAsciiConsString(Register result,
 | 
|                                               Register scratch2,
 | 
|                                               Label* gc_required) {
 | 
|    // Allocate heap number in new space.
 | 
| -  AllocateInNewSpace(ConsString::kSize,
 | 
| -                     result,
 | 
| -                     scratch1,
 | 
| -                     scratch2,
 | 
| -                     gc_required,
 | 
| -                     TAG_OBJECT);
 | 
| +  Allocate(ConsString::kSize, result, scratch1, scratch2, gc_required,
 | 
| +           TAG_OBJECT);
 | 
|  
 | 
|    // Set the map. The other fields are left uninitialized.
 | 
|    mov(FieldOperand(result, HeapObject::kMapOffset),
 | 
| @@ -1633,12 +1621,8 @@ void MacroAssembler::AllocateTwoByteSlicedString(Register result,
 | 
|                                            Register scratch2,
 | 
|                                            Label* gc_required) {
 | 
|    // Allocate heap number in new space.
 | 
| -  AllocateInNewSpace(SlicedString::kSize,
 | 
| -                     result,
 | 
| -                     scratch1,
 | 
| -                     scratch2,
 | 
| -                     gc_required,
 | 
| -                     TAG_OBJECT);
 | 
| +  Allocate(SlicedString::kSize, result, scratch1, scratch2, gc_required,
 | 
| +           TAG_OBJECT);
 | 
|  
 | 
|    // Set the map. The other fields are left uninitialized.
 | 
|    mov(FieldOperand(result, HeapObject::kMapOffset),
 | 
| @@ -1651,12 +1635,8 @@ void MacroAssembler::AllocateAsciiSlicedString(Register result,
 | 
|                                                 Register scratch2,
 | 
|                                                 Label* gc_required) {
 | 
|    // Allocate heap number in new space.
 | 
| -  AllocateInNewSpace(SlicedString::kSize,
 | 
| -                     result,
 | 
| -                     scratch1,
 | 
| -                     scratch2,
 | 
| -                     gc_required,
 | 
| -                     TAG_OBJECT);
 | 
| +  Allocate(SlicedString::kSize, result, scratch1, scratch2, gc_required,
 | 
| +           TAG_OBJECT);
 | 
|  
 | 
|    // Set the map. The other fields are left uninitialized.
 | 
|    mov(FieldOperand(result, HeapObject::kMapOffset),
 | 
| 
 |