Optimize various forms of slice.call(arguments, ...)

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 8320 matching lines @@
   HInstruction* call = New<HCallWithDescriptor>(
       code_value, argc + 1, descriptor,
       Vector<HValue*>(op_vals, descriptor->environment_length()));
 
   if (drop_extra) Drop(1);  // Drop function.
   ast_context()->ReturnInstruction(call, ast_id);
   return true;
 }
 
 
-bool HOptimizedGraphBuilder::TryCallApply(Call* expr) {
+static Handle<JSFunction> BuiltinFunctionById(Handle<Context> native_context,
+                                              BuiltinFunctionId id) {
+  Handle<FixedArray> builtins(native_context->builtin_js_functions());
+  Handle<JSFunction> result(
+      JSFunction::cast(builtins->get(static_cast<int>(id))));
+  return result;
+}
+
+
+bool HOptimizedGraphBuilder::TryIndirectCall(Call* expr) {
   ASSERT(expr->expression()->IsProperty());
 
   if (!expr->IsMonomorphic()) {
     return false;
   }
   Handle<Map> function_map = expr->GetReceiverTypes()->first();
   if (function_map->instance_type() != JS_FUNCTION_TYPE ||
-      !expr->target()->shared()->HasBuiltinFunctionId() ||
-      expr->target()->shared()->builtin_function_id() != kFunctionApply) {
+      !expr->target()->shared()->HasBuiltinFunctionId()) {
     return false;
   }
 
+  switch (expr->target()->shared()->builtin_function_id()) {
+    case kFunctionApply:
+      return TryCallApply(expr);
+    case kFunctionCall:
+      return TryCallCall(expr);
+    default:
+      return false;
+  }
+}
+
+
+bool HOptimizedGraphBuilder::TryCallCall(Call* expr) {
+  if (current_info()->scope()->arguments() == NULL) return false;
+  // It is very likely that x in x.call(...) is reference to .slice
+  // in all the recognized patterns, however, if it's not,
+  // we shouldn't go into a deopt loop
+  if (!current_info()->shared_info()->use_optimistic_optimizations()) {
+    return false;
+  }
+
+  ZoneList<Expression*>* args = expr->arguments();
+  if (args->length() < 1 || args->length() > 3) return false;
+  if (!IsLiveArguments(args->at(0))) return false;
+
+  HValue* lower_bound = graph()->GetConstant0();
+  HValue* upper_bound = NULL;
+  // f.call(arguments, ConstantSmi) or
+  // f.call(arguments, ConstantSmi, ConstantSmi)
+  if (args->length() >= 2) {
+    CHECK_ALIVE_OR_RETURN(VisitForValue(args->at(1)), true);
+    HValue* lower_bound_arg = Pop();
+    if (!lower_bound_arg->IsConstant() ||
+        !HConstant::cast(lower_bound_arg)->HasSmiValue()) {
+      return false;
+    }
+    lower_bound = lower_bound_arg;
+  }
+  // f.call(arguments, ConstantSmi, ConstantSmi)
+  if (args->length() >= 3) {
+    CHECK_ALIVE_OR_RETURN(VisitForValue(args->at(2)), true);
+    HValue* upper_bound_arg = Pop();
+    if (!upper_bound_arg->IsConstant() ||
+        !HConstant::cast(upper_bound_arg)->HasSmiValue()) {
+      return false;
+    }
+    upper_bound = upper_bound_arg;
+  }
+
+  NoObservableSideEffectsScope scope(this);
+
+  HValue* arguments_length = NULL;
+  HInstruction* arguments_elements  = NULL;
+  int max_length = JSObject::kInitialMaxFastElementArray;
+  HValue* function = Pop();  // f
+  Drop(1);  // call
+
+  {
+    HConstant* slice = Add<HConstant>(
+        BuiltinFunctionById(isolate()->native_context(), kArraySlice));
+    IfBuilder check_slice(this);
+    check_slice.IfNot<HCompareObjectEqAndBranch>(function, slice);
+    check_slice.Then();
+    Handle<SharedFunctionInfo> shared_info = current_info()->shared_info();
+    Add<HPushArguments>(AddUncasted<HConstant>(shared_info));
+    Add<HCallRuntime>(
+        isolate()->factory()->empty_string(),
+        Runtime::FunctionForId(Runtime::kDisableOptimisticOptimizations),
+        1);
+    check_slice.Deopt("expected a reference to Array.prototype.slice");
+    check_slice.End();
+  }
+
+  if (function_state()->outer() == NULL) {
+    arguments_elements = Add<HArgumentsElements>(false);
+    arguments_length = AddUncasted<HArgumentsLength>(arguments_elements);
+  } else {
+    EnsureArgumentsArePushedForAccess();
+
+    arguments_elements = function_state()->arguments_elements();
+    int args_count = environment()->
+          arguments_environment()->parameter_count() - 1;
+    arguments_length = AddUncasted<HConstant>(
+        static_cast<int32_t>(args_count));
+  }
+  Add<HBoundsCheck>(arguments_length, Add<HConstant>(max_length));
+
+  // Sanitize lower bound
+  if (HConstant::cast(lower_bound)->Integer32Value() < 0) {
+    lower_bound = AddUncasted<HAdd>(lower_bound, arguments_length);
+    lower_bound = AddUncasted<HMathMinMax>(
+        lower_bound, graph()->GetConstant0(), HMathMinMax::kMathMax);
+  } else {
+    lower_bound = AddUncasted<HMathMinMax>(
+        lower_bound, arguments_length, HMathMinMax::kMathMin);
+  }
+
+  // Sanitize upper bound
+  if (upper_bound == NULL) {
+    upper_bound = arguments_length;
+  } else if (HConstant::cast(upper_bound)->Integer32Value() < 0) {
+    upper_bound = AddUncasted<HAdd>(upper_bound, arguments_length);
+    upper_bound = AddUncasted<HMathMinMax>(
+        upper_bound, graph()->GetConstant0(), HMathMinMax::kMathMax);
+  } else {
+    upper_bound = AddUncasted<HMathMinMax>(
+        upper_bound, arguments_length, HMathMinMax::kMathMin);
+  }
+
+  // Allocate correctly sized array
+  HValue* result_length = AddUncasted<HSub>(upper_bound, lower_bound);
+  result_length->ClearFlag(HValue::kCanOverflow);
+  result_length = AddUncasted<HMathMinMax>(
+      result_length, graph()->GetConstant0(), HMathMinMax::kMathMax);
+
+  ElementsKind elements_kind = FAST_HOLEY_ELEMENTS;
+  Handle<JSFunction> array_function(
+      isolate()->native_context()->array_function());
+  JSArrayBuilder array_builder(this,
+                               elements_kind,
+                               AddUncasted<HConstant>(array_function));
+  HValue* result =
+      BuildAllocateArrayFromLength(&array_builder, result_length);
+  HValue* result_elements = array_builder.elements_location();
+
+  // Copy arguments to the array
+  LoopBuilder loop(this, context(), LoopBuilder::kPostIncrement);
+
+  HValue* index =
+      loop.BeginBody(graph()->GetConstant0(), result_length, Token::LT);
+  {
+    HValue* arguments_index = AddUncasted<HAdd>(lower_bound, index);
+    arguments_index->ClearFlag(HValue::kCanOverflow);
+    HValue* value = AddUncasted<HAccessArgumentsAt>(
+      arguments_elements, arguments_length, arguments_index);
+    Add<HStoreKeyed>(result_elements, index, value, elements_kind);
+  }
+  loop.EndBody();
+  ast_context()->ReturnValue(result);
+
+  return true;
+}
+
+
+bool HOptimizedGraphBuilder::TryCallApply(Call* expr) {
   if (current_info()->scope()->arguments() == NULL) return false;
 
   ZoneList<Expression*>* args = expr->arguments();
   if (args->length() != 2) return false;
-
-  VariableProxy* arg_two = args->at(1)->AsVariableProxy();
-  if (arg_two == NULL || !arg_two->var()->IsStackAllocated()) return false;
-  HValue* arg_two_value = LookupAndMakeLive(arg_two->var());
-  if (!arg_two_value->CheckFlag(HValue::kIsArguments)) return false;
+  if (!IsLiveArguments(args->at(1))) return false;
 
   // Found pattern f.apply(receiver, arguments).
   CHECK_ALIVE_OR_RETURN(VisitForValue(args->at(0)), true);
   HValue* receiver = Pop();  // receiver
   HValue* function = Pop();  // f
   Drop(1);  // apply
 
   if (function_state()->outer() == NULL) {
     HInstruction* elements = Add<HArgumentsElements>(false);
     HInstruction* length = Add<HArgumentsLength>(elements);
@@ skipping 291 matching lines @@
     environment()->SetExpressionStackAt(0, function);
 
     Push(receiver);
 
     if (function->IsConstant() &&
         HConstant::cast(function)->handle(isolate())->IsJSFunction()) {
       Handle<JSFunction> known_function = Handle<JSFunction>::cast(
           HConstant::cast(function)->handle(isolate()));
       expr->set_target(known_function);
 
-      if (TryCallApply(expr)) return;
+      if (TryIndirectCall(expr)) return;
       CHECK_ALIVE(VisitExpressions(expr->arguments()));
 
       Handle<Map> map = types->length() == 1 ? types->first() : Handle<Map>();
       if (TryInlineBuiltinMethodCall(expr, receiver, map)) {
         if (FLAG_trace_inlining) {
           PrintF("Inlining builtin ");
           known_function->ShortPrint();
           PrintF("\n");
         }
         return;
@@ skipping 1174 matching lines @@
   if (expected_obj->Is(Type::Undefined(zone()))) {
     // This is already done by HChange.
     *expected = Type::Union(expected_number, Type::Number(zone()), zone());
     return value;
   }
 
   return value;
 }
 
 
+bool HOptimizedGraphBuilder::IsLiveArguments(Expression* expr) {
+  VariableProxy* proxy = expr->AsVariableProxy();
+  if (proxy == NULL || !proxy->var()->IsStackAllocated()) return false;
+  HValue* value = LookupAndMakeLive(proxy->var());
+  return value->CheckFlag(HValue::kIsArguments);
+}
+
+
 HValue* HOptimizedGraphBuilder::BuildBinaryOperation(
     BinaryOperation* expr,
     HValue* left,
     HValue* right,
     PushBeforeSimulateBehavior push_sim_result) {
   Type* left_type = expr->left()->bounds().lower;
   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();
@@ skipping 2269 matching lines @@
   if (ShouldProduceTraceOutput()) {
     isolate()->GetHTracer()->TraceHydrogen(name(), graph_);
   }
 
 #ifdef DEBUG
   graph_->Verify(false);  // No full verify.
 #endif
 }
 
 } }  // namespace v8::internal