Add pretenuring support to HAllocateObject.

src/arm/lithium-codegen-arm.cc

 // Copyright 2012 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 5344 matching lines @@
   Register result = ToRegister(instr->result());
   Register scratch = ToRegister(instr->temp());
   Register scratch2 = ToRegister(instr->temp2());
   Handle<JSFunction> constructor = instr->hydrogen()->constructor();
   Handle<Map> initial_map = instr->hydrogen()->constructor_initial_map();
   int instance_size = initial_map->instance_size();
   ASSERT(initial_map->pre_allocated_property_fields() +
          initial_map->unused_property_fields() -
          initial_map->inobject_properties() == 0);
 
+  AllocationFlags flags = TAG_OBJECT;
+  if (instr->hydrogen()->CanAllocateInOldPointerSpace()) {
+    flags = static_cast<AllocationFlags>(flags | PRETENURE_OLD_POINTER_SPACE);
+  }
+
   __ Allocate(instance_size, result, scratch, scratch2, deferred->entry(),
-              TAG_OBJECT);
+              flags);
 
   __ bind(deferred->exit());
-  if (FLAG_debug_code) {
+  if (FLAG_debug_code && !instr->hydrogen()->CanAllocateInOldPointerSpace()) {
     Label is_in_new_space;
     __ JumpIfInNewSpace(result, scratch, &is_in_new_space);
     __ Abort("Allocated object is not in new-space");
     __ bind(&is_in_new_space);
   }
 
   // Load the initial map.
   Register map = scratch;
   __ LoadHeapObject(map, constructor);
+  // Recording the map slot can be skipped, because maps are not compacted.
   __ ldr(map, FieldMemOperand(map, JSFunction::kPrototypeOrInitialMapOffset));
 
   // Initialize map and fields of the newly allocated object.
   ASSERT(initial_map->instance_type() == JS_OBJECT_TYPE);
   __ str(map, FieldMemOperand(result, JSObject::kMapOffset));
   __ LoadRoot(scratch, Heap::kEmptyFixedArrayRootIndex);
   __ str(scratch, FieldMemOperand(result, JSObject::kElementsOffset));
   __ str(scratch, FieldMemOperand(result, JSObject::kPropertiesOffset));
   if (initial_map->inobject_properties() != 0) {
     __ LoadRoot(scratch, Heap::kUndefinedValueRootIndex);
@@ skipping 11 matching lines @@
   int instance_size = initial_map->instance_size();
 
   // TODO(3095996): Get rid of this. For now, we need to make the
   // result register contain a valid pointer because it is already
   // contained in the register pointer map.
   __ mov(result, Operand::Zero());
 
   PushSafepointRegistersScope scope(this, Safepoint::kWithRegisters);
   __ mov(r0, Operand(Smi::FromInt(instance_size)));
   __ push(r0);
-  CallRuntimeFromDeferred(Runtime::kAllocateInNewSpace, 1, instr);
+  if (instr->hydrogen()->CanAllocateInOldPointerSpace()) {
+    CallRuntimeFromDeferred(Runtime::kAllocateInOldPointerSpace, 1, instr);
+  } else {
+    CallRuntimeFromDeferred(Runtime::kAllocateInNewSpace, 1, instr);
+  }
   __ StoreToSafepointRegisterSlot(r0, result);
 }
 
 
 void LCodeGen::DoAllocate(LAllocate* instr) {
   class DeferredAllocate: public LDeferredCode {
    public:
     DeferredAllocate(LCodeGen* codegen, LAllocate* instr)
         : LDeferredCode(codegen), instr_(instr) { }
     virtual void Generate() { codegen()->DoDeferredAllocate(instr_); }
@@ skipping 501 matching lines @@
   __ sub(scratch, result, Operand::PointerOffsetFromSmiKey(index));
   __ ldr(result, FieldMemOperand(scratch,
                                  FixedArray::kHeaderSize - kPointerSize));
   __ bind(&done);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal