Add pretenuring support to HAllocateObject.

src/hydrogen-instructions.h

 // 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 4822 matching lines @@
   DECLARE_CONCRETE_INSTRUCTION(LoadGlobalGeneric)
 
  private:
   Handle<Object> name_;
   bool for_typeof_;
 };
 
 
 class HAllocateObject: public HTemplateInstruction<1> {
  public:
-  HAllocateObject(HValue* context, Handle<JSFunction> constructor)
-      : constructor_(constructor) {
+  enum Flags {
+    CAN_ALLOCATE_IN_NEW_SPACE = 1 << 0,
+    CAN_ALLOCATE_IN_OLD_POINTER_SPACE = 1 << 1
+  };
+
+  HAllocateObject(HValue* context, Handle<JSFunction> constructor, Flags flags)
+      : constructor_(constructor),
+        flags_(flags) {
     SetOperandAt(0, context);
     set_representation(Representation::Tagged());
     SetGVNFlag(kChangesNewSpacePromotion);
     constructor_initial_map_ = constructor->has_initial_map()
         ? Handle<Map>(constructor->initial_map())
         : Handle<Map>::null();
     // If slack tracking finished, the instance size and property counts
     // remain unchanged so that we can allocate memory for the object.
     ASSERT(!constructor->shared()->IsInobjectSlackTrackingInProgress());
   }
 
   // Maximum instance size for which allocations will be inlined.
   static const int kMaxSize = 64 * kPointerSize;
 
   HValue* context() { return OperandAt(0); }
   Handle<JSFunction> constructor() { return constructor_; }
   Handle<Map> constructor_initial_map() { return constructor_initial_map_; }
 
   virtual Representation RequiredInputRepresentation(int index) {
     return Representation::Tagged();
   }
   virtual Handle<Map> GetMonomorphicJSObjectMap() {
     ASSERT(!constructor_initial_map_.is_null());
     return constructor_initial_map_;
   }
   virtual HType CalculateInferredType();
 
+  static Flags DefaultFlags() {

[mvstanton, 2013/05/23 12:47:46]

It would be nice if these ~20 lines could be shared with the similar lines in
HAllocate. If it is straightforward to make a base class for those two hydrogen
instructions, I would say do it. 

+    return CAN_ALLOCATE_IN_NEW_SPACE;
+  }
+
+  bool CanAllocateInNewSpace() const {
+    return (flags_ & CAN_ALLOCATE_IN_NEW_SPACE) != 0;
+  }
+
+  bool CanAllocateInOldPointerSpace() const {
+    return (flags_ & CAN_ALLOCATE_IN_OLD_POINTER_SPACE) != 0;
+  }
+
+  bool GuaranteedInNewSpace() const {
+    return CanAllocateInNewSpace() && !CanAllocateInOldPointerSpace();
+  }
+
   DECLARE_CONCRETE_INSTRUCTION(AllocateObject)
 
  private:
   // TODO(svenpanne) Might be safe, but leave it out until we know for sure.
   //  virtual bool IsDeletable() const { return true; }
 
   Handle<JSFunction> constructor_;
   Handle<Map> constructor_initial_map_;
+  Flags flags_;
 };
 
 
 class HAllocate: public HTemplateInstruction<2> {
  public:
   enum Flags {
     CAN_ALLOCATE_IN_NEW_SPACE = 1 << 0,
     CAN_ALLOCATE_IN_OLD_DATA_SPACE = 1 << 1,
     CAN_ALLOCATE_IN_OLD_POINTER_SPACE = 1 << 2,
     ALLOCATE_DOUBLE_ALIGNED = 1 << 3
@@ skipping 102 matching lines @@
 
 
 inline bool ReceiverObjectNeedsWriteBarrier(HValue* object,
                                             HValue* new_space_dominator) {
   if (object->IsInnerAllocatedObject()) {
     return ReceiverObjectNeedsWriteBarrier(
         HInnerAllocatedObject::cast(object)->base_object(),
         new_space_dominator);
   }
   if (object != new_space_dominator) return true;
-  if (object->IsAllocateObject()) return false;
+  if (object->IsAllocateObject()) {
+    return !HAllocateObject::cast(object)->GuaranteedInNewSpace();
+  }
   if (object->IsAllocate()) {
     return !HAllocate::cast(object)->GuaranteedInNewSpace();
   }
   return true;
 }
 
 
 class HStoreGlobalCell: public HUnaryOperation {
  public:
   HStoreGlobalCell(HValue* value,
@@ skipping 1449 matching lines @@
   virtual bool IsDeletable() const { return true; }
 };
 
 
 #undef DECLARE_INSTRUCTION
 #undef DECLARE_CONCRETE_INSTRUCTION
 
 } }  // namespace v8::internal
 
 #endif  // V8_HYDROGEN_INSTRUCTIONS_H_