Pretenure call new support.

src/hydrogen.cc

 // Copyright 2013 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 8219 matching lines @@
     }
 
     // Calculate instance size from initial map of constructor.
     ASSERT(constructor->has_initial_map());
     Handle<Map> initial_map(constructor->initial_map());
     int instance_size = initial_map->instance_size();
     ASSERT(initial_map->InitialPropertiesLength() == 0);
 
     // Allocate an instance of the implicit receiver object.
     HValue* size_in_bytes = Add<HConstant>(instance_size);
-    PretenureFlag pretenure_flag =
-        (FLAG_pretenuring_call_new && !FLAG_allocation_site_pretenuring) ?
-            isolate()->heap()->GetPretenureMode() : NOT_TENURED;
+    HAllocationMode allocation_mode;
+    if (!FLAG_allocation_site_pretenuring) {

[Hannes Payer (out of office), 2014/02/11 15:51:23]

Can we re-order this combination of cases to:
if (FLAG_pretenuring_call_new)
  if (FLAG_allocation_site_pretenuring)
  else

I think this improves readability.

[mvstanton, 2014/02/17 15:53:08]

very true, thx!

+      PretenureFlag pretenure_flag = FLAG_pretenuring_call_new
+          ? isolate()->heap()->GetPretenureMode()
+          : NOT_TENURED;
+      allocation_mode = HAllocationMode(pretenure_flag);
+    } else if (FLAG_pretenuring_call_new) {
+      // Try to use pretenuring feedback.
+      Handle<AllocationSite> allocation_site = expr->allocation_site();
+      if (!allocation_site.is_null()) {
+        allocation_mode = HAllocationMode(allocation_site);
+        // Take a dependency on allocation site.
+        AllocationSite::AddDependentCompilationInfo(allocation_site,
+                                                    AllocationSite::TENURING,
+                                                    top_info());
+      }
+    }
+
     HAllocate* receiver =
-        Add<HAllocate>(size_in_bytes, HType::JSObject(), pretenure_flag,
-        JS_OBJECT_TYPE);
+        BuildAllocate(size_in_bytes, HType::JSObject(), JS_OBJECT_TYPE,
+                      allocation_mode);
     receiver->set_known_initial_map(initial_map);
 
     // Load the initial map from the constructor.
     HValue* constructor_value = Add<HConstant>(constructor);
     HValue* initial_map_value =
       Add<HLoadNamedField>(constructor_value, static_cast<HValue*>(NULL),
                            HObjectAccess::ForMapAndOffset(
                                handle(constructor->map()),
                                JSFunction::kPrototypeOrInitialMapOffset));
 
@@ skipping 2939 matching lines @@
   if (ShouldProduceTraceOutput()) {
     isolate()->GetHTracer()->TraceHydrogen(name(), graph_);
   }
 
 #ifdef DEBUG
   graph_->Verify(false);  // No full verify.
 #endif
 }
 
 } }  // namespace v8::internal