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 8198 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_pretenuring_call_new) {
+      if (FLAG_allocation_site_pretenuring) {
+        // Try to use pretenuring feedback.
+        Handle<AllocationSite> allocation_site = expr->allocation_site();
+        if (!allocation_site.is_null()) {

[Hannes Payer (out of office), 2014/02/18 16:24:26]

When is the allocation_site null?

[mvstanton, 2014/02/19 08:40:26]

Wow. Never. Simplifying this. In the past it was more like, "if the call new
site never went megamorphic then it could be null." However, we only come down
this code path anywhere if we are monomorphic.

BTW, two lines in type-info.cc could be simplified,
TypeFeedbackOracle::CallIsMonomorphic() and
TypeFeedbackOracle::CallNewIsMonomorphic(). Those calls were accepting an
AllocationSite in their type vector slot, but now we've separated it out into a
different slot.

+          allocation_mode = HAllocationMode(allocation_site);
+          // Take a dependency on allocation site.
+          AllocationSite::AddDependentCompilationInfo(allocation_site,
+                                                      AllocationSite::TENURING,
+                                                      top_info());
+        }
+      } else {
+        allocation_mode = HAllocationMode(
+            isolate()->heap()->GetPretenureMode());
+      }
+    }
+
     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 2952 matching lines @@
   if (ShouldProduceTraceOutput()) {
     isolate()->GetHTracer()->TraceHydrogen(name(), graph_);
   }
 
 #ifdef DEBUG
   graph_->Verify(false);  // No full verify.
 #endif
 }
 
 } }  // namespace v8::internal