Allow full inlining of f.apply(this, arguments) calls.

src/hydrogen.cc

 // 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 7736 matching lines @@
   return TryInline(CALL_AS_METHOD,
                    setter,
                    1,
                    implicit_return_value,
                    assignment->id(),
                    assignment->AssignmentId(),
                    SETTER_CALL_RETURN);
 }
 
 
+bool HOptimizedGraphBuilder::TryInlineApply(Handle<JSFunction> function,
+                                            Call* expr,
+                                            int arguments_count) {
+  return TryInline(CALL_AS_METHOD,
+                   function,
+                   arguments_count,
+                   NULL,
+                   expr->id(),
+                   expr->ReturnId(),
+                   NORMAL_RETURN);
+}
+
+
 bool HOptimizedGraphBuilder::TryInlineBuiltinFunctionCall(Call* expr,
                                                           bool drop_extra) {
   if (!expr->target()->shared()->HasBuiltinFunctionId()) return false;
   BuiltinFunctionId id = expr->target()->shared()->builtin_function_id();
   switch (id) {
     case kMathExp:
       if (!FLAG_fast_math) break;
       // Fall through if FLAG_fast_math.
     case kMathRound:
     case kMathAbs:
@@ skipping 207 matching lines @@
                                     elements);
     result->set_position(expr->position());
     ast_context()->ReturnInstruction(result, expr->id());
     return true;
   } else {
     // We are inside inlined function and we know exactly what is inside
     // arguments object. But we need to be able to materialize at deopt.
     // TODO(mstarzinger): For now we just ensure arguments are pushed
     // right after HEnterInlined, but we could be smarter about this.
     EnsureArgumentsArePushedForAccess();
-    HValue* context = environment()->LookupContext();
+    HEnvironment* arguments_env = environment()->arguments_environment();
+    int parameter_count = arguments_env->parameter_count();
+    PushAndAdd(new(zone()) HWrapReceiver(receiver, function));
+    for (int i = 1; i < arguments_env->parameter_count(); i++) {
+      Push(arguments_env->Lookup(i));
+    }
 
-    HValue* wrapped_receiver =
-        AddInstruction(new(zone()) HWrapReceiver(receiver, function));
-    PushAndAdd(new(zone()) HPushArgument(wrapped_receiver));
+    Handle<JSFunction> known_function;
+    if (function->IsConstant()) {
+      HConstant* constant_function = HConstant::cast(function);
+      known_function = Handle<JSFunction>::cast(constant_function->handle());
+      int arguments_count = parameter_count - 1;  // Excluding receiver.
+      if (TryInlineApply(known_function, expr, arguments_count)) return true;
+    }
 
-    HEnvironment* arguments_env = environment()->arguments_environment();
-
-    int parameter_count = arguments_env->parameter_count();
+    Drop(parameter_count - 1);
+    PushAndAdd(new(zone()) HPushArgument(Pop()));
     for (int i = 1; i < arguments_env->parameter_count(); i++) {
       PushAndAdd(new(zone()) HPushArgument(arguments_env->Lookup(i)));
     }
 
+    HValue* context = environment()->LookupContext();
     HInvokeFunction* call = new(zone()) HInvokeFunction(
         context,
         function,
+        known_function,
         parameter_count);
     Drop(parameter_count);
     call->set_position(expr->position());
     ast_context()->ReturnInstruction(call, expr->id());
     return true;
   }
 }
 
 
 // Checks if all maps in |types| are from the same family, i.e., are elements
@@ skipping 2621 matching lines @@
     }
   }
 
 #ifdef DEBUG
   if (graph_ != NULL) graph_->Verify(false);  // No full verify.
   if (allocator_ != NULL) allocator_->Verify();
 #endif
 }
 
 } }  // namespace v8::internal