Emit mementos in crankshaft.

src/hydrogen.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/hydrogen.h"
 
 #include <algorithm>
 
 #include "src/v8.h"
 #include "src/allocation-site-scopes.h"
@@ skipping 1735 matching lines @@
 
 
 HAllocate* HGraphBuilder::BuildAllocate(
     HValue* object_size,
     HType type,
     InstanceType instance_type,
     HAllocationMode allocation_mode) {
   // Compute the effective allocation size.
   HValue* size = object_size;
   if (allocation_mode.CreateAllocationMementos()) {
-    size = AddUncasted<HAdd>(size, Add<HConstant>(AllocationMemento::kSize));
+    NoObservableSideEffectsScope no_effects(this);
+    size = AddInstruction(
+        HAdd::New(zone(), context(), object_size,
+                  Add<HConstant>(AllocationMemento::kSize)));
     size->ClearFlag(HValue::kCanOverflow);
   }
 
   // Perform the actual allocation.
   HAllocate* object = Add<HAllocate>(
       size, type, allocation_mode.GetPretenureMode(),
       instance_type, allocation_mode.feedback_site());
 
   // Setup the allocation memento.
   if (allocation_mode.CreateAllocationMementos()) {
@@ skipping 1024 matching lines @@
   }
 
   if_nil.CaptureContinuation(continuation);
 }
 
 
 void HGraphBuilder::BuildCreateAllocationMemento(
     HValue* previous_object,
     HValue* previous_object_size,
     HValue* allocation_site) {
+  NoObservableSideEffectsScope no_effects(this);
   ASSERT(allocation_site != NULL);
   HInnerAllocatedObject* allocation_memento = Add<HInnerAllocatedObject>(
       previous_object, previous_object_size, HType::HeapObject());
   AddStoreMapConstant(
       allocation_memento, isolate()->factory()->allocation_memento_map());
   Add<HStoreNamedField>(
       allocation_memento,
       HObjectAccess::ForAllocationMementoSite(),
       allocation_site);
   if (FLAG_allocation_site_pretenuring) {
@@ skipping 2346 matching lines @@
   Handle<JSObject> boilerplate;
   if (!literals_cell->IsUndefined()) {
     // Retrieve the boilerplate
     site = Handle<AllocationSite>::cast(literals_cell);
     boilerplate = Handle<JSObject>(JSObject::cast(site->transition_info()),
                                    isolate());
   }
 
   if (!boilerplate.is_null() &&
       IsFastLiteral(boilerplate, kMaxFastLiteralDepth, &max_properties)) {
-    AllocationSiteUsageContext usage_context(isolate(), site, false);
+    bool emit_mementos = FLAG_allocation_site_pretenuring &&
+        site->emit_mementos();
+    AllocationSiteUsageContext usage_context(isolate(), site, emit_mementos);
     usage_context.EnterNewScope();
     literal = BuildFastLiteral(boilerplate, &usage_context);
     usage_context.ExitScope(site, boilerplate);
   } else {
     NoObservableSideEffectsScope no_effects(this);
     Handle<FixedArray> closure_literals(closure->literals(), isolate());
     Handle<FixedArray> constant_properties = expr->constant_properties();
     int literal_index = expr->literal_index();
     int flags = expr->fast_elements()
         ? ObjectLiteral::kFastElements : ObjectLiteral::kNoFlags;
@@ skipping 136 matching lines @@
   ASSERT(site->SitePointsToLiteral());
 
   ElementsKind boilerplate_elements_kind =
       boilerplate_object->GetElementsKind();
 
   // Check whether to use fast or slow deep-copying for boilerplate.
   int max_properties = kMaxFastLiteralProperties;
   if (IsFastLiteral(boilerplate_object,
                     kMaxFastLiteralDepth,
                     &max_properties)) {
-    AllocationSiteUsageContext usage_context(isolate(), site, false);
+    bool emit_mementos = FLAG_allocation_site_pretenuring &&
+        site->emit_mementos();
+    AllocationSiteUsageContext usage_context(isolate(), site, emit_mementos);
     usage_context.EnterNewScope();
     literal = BuildFastLiteral(boilerplate_object, &usage_context);
     usage_context.ExitScope(site, boilerplate_object);
   } else {
     NoObservableSideEffectsScope no_effects(this);
     // Boilerplate already exists and constant elements are never accessed,
     // pass an empty fixed array to the runtime function instead.
     Handle<FixedArray> constants = isolate()->factory()->empty_fixed_array();
     int literal_index = expr->literal_index();
     int flags = expr->depth() == 1
@@ skipping 2985 matching lines @@
         target->context()->global_object()->global_receiver());
     return Add<HConstant>(global_receiver);
   }
   return graph()->GetConstantUndefined();
 }
 
 
 void HOptimizedGraphBuilder::BuildArrayCall(Expression* expression,
                                             int arguments_count,
                                             HValue* function,
-                                            Handle<AllocationSite> site) {
+                                            Handle<AllocationSite> site,
+                                            HAllocationMode mode) {
   Add<HCheckValue>(function, array_function());
 
   if (IsCallArrayInlineable(arguments_count, site)) {
-    BuildInlinedCallArray(expression, arguments_count, site);
+    BuildInlinedCallArray(expression, arguments_count, mode, site);
     return;
   }
 
   HInstruction* call = PreProcessCall(New<HCallNewArray>(
-      function, arguments_count + 1, site->GetElementsKind()));
+      function, arguments_count + 1, site->GetElementsKind(), mode));
   if (expression->IsCall()) {
     Drop(1);
   }
   ast_context()->ReturnInstruction(call, expression->id());
 }
 
 
 HValue* HOptimizedGraphBuilder::BuildArrayIndexOf(HValue* receiver,
                                                   HValue* search_element,
                                                   ElementsKind kind,
@@ skipping 140 matching lines @@
   if (!array_function().is_identical_to(expr->target())) {
     return false;
   }
 
   Handle<AllocationSite> site = expr->allocation_site();
   if (site.is_null()) return false;
 
   BuildArrayCall(expr,
                  expr->arguments()->length(),
                  function,
-                 site);
+                 site,
+                 HAllocationMode());
   return true;
 }
 
 
 bool HOptimizedGraphBuilder::TryHandleArrayCallNew(CallNew* expr,
-                                                   HValue* function) {
+                                                   HValue* function,
+                                                   HAllocationMode mode) {
   if (!array_function().is_identical_to(expr->target())) {
     return false;
   }
 
   BuildArrayCall(expr,
                  expr->arguments()->length(),
                  function,
-                 expr->allocation_site());
+                 expr->allocation_site(),
+                 mode);
   return true;
 }
 
 
 void HOptimizedGraphBuilder::VisitCall(Call* expr) {
   ASSERT(!HasStackOverflow());
   ASSERT(current_block() != NULL);
   ASSERT(current_block()->HasPredecessor());
   Expression* callee = expr->expression();
   int argument_count = expr->arguments()->length() + 1;  // Plus receiver.
@@ skipping 165 matching lines @@
   }
 
   Drop(1);  // Drop the function.
   return ast_context()->ReturnInstruction(call, expr->id());
 }
 
 
 void HOptimizedGraphBuilder::BuildInlinedCallArray(
     Expression* expression,
     int argument_count,
+    HAllocationMode mode,
     Handle<AllocationSite> site) {
   ASSERT(!site.is_null());
   ASSERT(argument_count >= 0 && argument_count <= 1);
   NoObservableSideEffectsScope no_effects(this);
 
   // We should at least have the constructor on the expression stack.
   HValue* constructor = environment()->ExpressionStackAt(argument_count);
 
   // Register on the site for deoptimization if the transition feedback changes.
   AllocationSite::AddDependentCompilationInfo(
       site, AllocationSite::TRANSITIONS, top_info());
   ElementsKind kind = site->GetElementsKind();
   HInstruction* site_instruction = Add<HConstant>(site);
 
   // In the single constant argument case, we may have to adjust elements kind
   // to avoid creating a packed non-empty array.
   if (argument_count == 1 && !IsHoleyElementsKind(kind)) {
     HValue* argument = environment()->Top();
     if (argument->IsConstant()) {
       HConstant* constant_argument = HConstant::cast(argument);
       ASSERT(constant_argument->HasSmiValue());
       int constant_array_size = constant_argument->Integer32Value();
       if (constant_array_size != 0) {
         kind = GetHoleyElementsKind(kind);
       }
     }
   }
 
-  // Build the array.
+  // Build the array. Should we emit mementos?
+  AllocationSiteOverrideMode site_mode = mode.CreateAllocationMementos()
+      ? DONT_OVERRIDE
+      : DISABLE_ALLOCATION_SITES;
+
   JSArrayBuilder array_builder(this,
                                kind,
                                site_instruction,
                                constructor,
-                               DISABLE_ALLOCATION_SITES);
+                               site_mode);
+
   HValue* new_object = argument_count == 0
       ? array_builder.AllocateEmptyArray()
       : BuildAllocateArrayFromLength(&array_builder, Top());
 
   int args_to_drop = argument_count + (expression->IsCall() ? 2 : 1);
   Drop(args_to_drop);
   ast_context()->ReturnValue(new_object);
 }
 
 
@@ skipping 45 matching lines @@
     TraceInline(target, caller, "AllocationSite requested no inlining.");
   }
 
   if (inline_ok) {
     TraceInline(target, caller, NULL);
   }
   return inline_ok;
 }
 
 
+void HOptimizedGraphBuilder::InitializeAllocationModeForCallNew(
+    CallNew* expr,
+    HAllocationMode* mode) {
+  if (FLAG_pretenuring_call_new) {
+    if (FLAG_allocation_site_pretenuring) {
+      Handle<AllocationSite> allocation_site = expr->allocation_site();
+      HConstant* site_constant = NULL;
+      // By passing a non-null HConstant AllocationSite to HAllocationMode,
+      // we ensure that a memento will be emitted.
+      if (allocation_site->emit_mementos()) {
+        site_constant = Add<HConstant>(allocation_site);
+      }
+      // Try to use pretenuring feedback.
+      *mode = HAllocationMode(allocation_site, site_constant);
+      // Take a dependency on allocation site.
+      AllocationSite::AddDependentCompilationInfo(allocation_site,
+                                                  AllocationSite::TENURING,
+                                                  top_info());
+    }
+  }
+  // No else case, the mode will be left at it's default.
+}
+
+
 void HOptimizedGraphBuilder::VisitCallNew(CallNew* expr) {
   ASSERT(!HasStackOverflow());
   ASSERT(current_block() != NULL);
   ASSERT(current_block()->HasPredecessor());
   if (!FLAG_hydrogen_track_positions) SetSourcePosition(expr->position());
   int argument_count = expr->arguments()->length() + 1;  // Plus constructor.
   Factory* factory = isolate()->factory();
 
   // The constructor function is on the stack in the unoptimized code
   // during evaluation of the arguments.
@@ skipping 15 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);
     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();
-        allocation_mode = HAllocationMode(allocation_site);
-        // Take a dependency on allocation site.
-        AllocationSite::AddDependentCompilationInfo(allocation_site,
-                                                    AllocationSite::TENURING,
-                                                    top_info());
-      }
-    }
+    InitializeAllocationModeForCallNew(expr, &allocation_mode);
 
     HAllocate* receiver = BuildAllocate(
         size_in_bytes, HType::JSObject(), JS_OBJECT_TYPE, allocation_mode);
     receiver->set_known_initial_map(initial_map);
 
     // Initialize map and fields of the newly allocated object.
     { NoObservableSideEffectsScope no_effects(this);
       ASSERT(initial_map->instance_type() == JS_OBJECT_TYPE);
       Add<HStoreNamedField>(receiver,
           HObjectAccess::ForMapAndOffset(initial_map, JSObject::kMapOffset),
@@ skipping 31 matching lines @@
       Map::AddDependentCompilationInfo(
           initial_map, DependentCode::kInitialMapChangedGroup, top_info());
       return;
     }
 
     // TODO(mstarzinger): For now we remove the previous HAllocate and all
     // corresponding instructions and instead add HPushArguments for the
     // arguments in case inlining failed.  What we actually should do is for
     // inlining to try to build a subgraph without mutating the parent graph.
     HInstruction* instr = current_block()->last();
-    do {
+
+    // If we decided to emit a memento for this allocation, we need to
+    // remember the instruction of the HConstant for the site added
+    // in InitializeAllocationModeForCallNew().
+    HValue* delete_to_this_instruction =
+        allocation_mode.CreateAllocationMementos()
+        ? allocation_mode.current_site()
+        : receiver;
+    ASSERT(delete_to_this_instruction != NULL);
+    while (instr != delete_to_this_instruction) {
       HInstruction* prev_instr = instr->previous();
       instr->DeleteAndReplaceWith(NULL);
       instr = prev_instr;
-    } while (instr != check);
+    }
+    // initial_map_value->DeleteAndReplaceWith(NULL);
+    if (delete_to_this_instruction == receiver) {
+      receiver->DeleteAndReplaceWith(NULL);
+    }
+    check->DeleteAndReplaceWith(NULL);
     environment()->SetExpressionStackAt(receiver_index, function);
-    HInstruction* call =
-      PreProcessCall(New<HCallNew>(function, argument_count));
+    HInstruction* call = PreProcessCall(
+        New<HCallNew>(function, argument_count, allocation_mode));
     return ast_context()->ReturnInstruction(call, expr->id());
   } else {
+    HAllocationMode allocation_mode;
+    InitializeAllocationModeForCallNew(expr, &allocation_mode);
+
     // The constructor function is both an operand to the instruction and an
     // argument to the construct call.
-    if (TryHandleArrayCallNew(expr, function)) return;
+    if (TryHandleArrayCallNew(expr, function, allocation_mode)) return;
 
     HInstruction* call =
-        PreProcessCall(New<HCallNew>(function, argument_count));
+        PreProcessCall(New<HCallNew>(function, argument_count,
+                                     allocation_mode));
     return ast_context()->ReturnInstruction(call, expr->id());
   }
 }
 
 
 // Support for generating inlined runtime functions.
 
 // Lookup table for generators for runtime calls that are generated inline.
 // Elements of the table are member pointers to functions of
 // HOptimizedGraphBuilder.
@@ skipping 845 matching lines @@
   Type* right_type = expr->right()->bounds().lower;
   Type* result_type = expr->bounds().lower;
   Maybe<int> fixed_right_arg = expr->fixed_right_arg();
   Handle<AllocationSite> allocation_site = expr->allocation_site();
 
   HAllocationMode allocation_mode;
   if (FLAG_allocation_site_pretenuring && !allocation_site.is_null()) {
     allocation_mode = HAllocationMode(allocation_site);
   }
 
+  if (FLAG_allocation_site_pretenuring &&
+      !allocation_site.is_null() &&
+      allocation_site->emit_mementos()) {
+    // This allows crankshaft to continue emitting mementos if a pretenuring
+    // decision wasn't made yet. A dependency is registered on the site in
+    // the BuildBinaryOperation call below.
+    HConstant* site_constant = Add<HConstant>(allocation_site);
+    allocation_mode = HAllocationMode(allocation_site, site_constant);
+  }
+
   HValue* result = HGraphBuilder::BuildBinaryOperation(
       expr->op(), left, right, left_type, right_type, result_type,
       fixed_right_arg, allocation_mode);
   // Add a simulate after instructions with observable side effects, and
   // after phis, which are the result of BuildBinaryOperation when we
   // inlined some complex subgraph.
   if (result->HasObservableSideEffects() || result->IsPhi()) {
     if (push_sim_result == PUSH_BEFORE_SIMULATE) {
       Push(result);
       Add<HSimulate>(expr->id(), REMOVABLE_SIMULATE);
@@ skipping 682 matching lines @@
 
 HInstruction* HOptimizedGraphBuilder::BuildFastLiteral(
     Handle<JSObject> boilerplate_object,
     AllocationSiteUsageContext* site_context) {
   NoObservableSideEffectsScope no_effects(this);
   InstanceType instance_type = boilerplate_object->map()->instance_type();
   ASSERT(instance_type == JS_ARRAY_TYPE || instance_type == JS_OBJECT_TYPE);
 
   HType type = instance_type == JS_ARRAY_TYPE
       ? HType::JSArray() : HType::JSObject();
-  HValue* object_size_constant = Add<HConstant>(
-      boilerplate_object->map()->instance_size());
+  int instance_size = boilerplate_object->map()->instance_size();
+  bool emit_memento = site_context->ShouldCreateMemento(boilerplate_object);
+  // Should the object allocation include a manually folded memento?
+  int alloc_size = emit_memento
+      ? instance_size + AllocationMemento::kSize
+      : instance_size;
+  HValue* alloc_size_constant = Add<HConstant>(alloc_size);
+  HValue* allocation_site_constant = Add<HConstant>(site_context->current());
 
   PretenureFlag pretenure_flag = NOT_TENURED;
   if (FLAG_allocation_site_pretenuring) {
     pretenure_flag = site_context->current()->GetPretenureMode();
     Handle<AllocationSite> site(site_context->current());
     AllocationSite::AddDependentCompilationInfo(
         site, AllocationSite::TENURING, top_info());
   }
 
-  HInstruction* object = Add<HAllocate>(object_size_constant, type,
+  HInstruction* object = Add<HAllocate>(alloc_size_constant, type,
       pretenure_flag, instance_type, site_context->current());
 
   // If allocation folding reaches Page::kMaxRegularHeapObjectSize the
   // elements array may not get folded into the object. Hence, we set the
   // elements pointer to empty fixed array and let store elimination remove
   // this store in the folding case.
   HConstant* empty_fixed_array = Add<HConstant>(
       isolate()->factory()->empty_fixed_array());
   Add<HStoreNamedField>(object, HObjectAccess::ForElementsPointer(),
       empty_fixed_array);
 
   BuildEmitObjectHeader(boilerplate_object, object);
+  if (emit_memento) {
+    BuildCreateAllocationMemento(object,
+                                 Add<HConstant>(instance_size),
+                                 allocation_site_constant);
+  }
 
   Handle<FixedArrayBase> elements(boilerplate_object->elements());
   int elements_size = (elements->length() > 0 &&
       elements->map() != isolate()->heap()->fixed_cow_array_map()) ?
           elements->Size() : 0;
 
   if (pretenure_flag == TENURED &&
       elements->map() == isolate()->heap()->fixed_cow_array_map() &&
       isolate()->heap()->InNewSpace(*elements)) {
     // If we would like to pretenure a fixed cow array, we must ensure that the
@@ skipping 1525 matching lines @@
   if (ShouldProduceTraceOutput()) {
     isolate()->GetHTracer()->TraceHydrogen(name(), graph_);
   }
 
 #ifdef DEBUG
   graph_->Verify(false);  // No full verify.
 #endif
 }
 
 } }  // namespace v8::internal