Skip the CallFunctionStub when the callee function can be statically determined.

src/compiler/js-generic-lowering.cc

 // Copyright 2014 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/code-factory.h"
 #include "src/code-stubs.h"
 #include "src/compiler/common-operator.h"
 #include "src/compiler/graph-inl.h"
 #include "src/compiler/js-generic-lowering.h"
 #include "src/compiler/machine-operator.h"
 #include "src/compiler/node-aux-data-inl.h"
+#include "src/compiler/node-matchers.h"
 #include "src/compiler/node-properties-inl.h"
 #include "src/unique.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 JSGenericLowering::JSGenericLowering(CompilationInfo* info, JSGraph* jsgraph)
     : info_(info),
       jsgraph_(jsgraph),
@@ skipping 376 matching lines @@
   Node* stub_code = CodeConstant(stub.GetCode());
   Node* construct = NodeProperties::GetValueInput(node, 0);
   PatchInsertInput(node, 0, stub_code);
   PatchInsertInput(node, 1, Int32Constant(arity - 1));
   PatchInsertInput(node, 2, construct);
   PatchInsertInput(node, 3, jsgraph()->UndefinedConstant());
   PatchOperator(node, common()->Call(desc));
 }
 
 
+static Node* ReuseContextIfPossible(JSGraph* jsgraph,
+                                    Handle<JSFunction> function,
+                                    Node* maybe_the_right_one) {
+  // TODO(titzer): total hack to share function context constants.
+  // Remove this when the JSGraph canonicalizes heap constants.
+  HeapObjectMatcher<Context> context(maybe_the_right_one);
+  if (context.HasValue() &&
+      *(context.Value().handle()) == function->context()) {
+    return maybe_the_right_one;
+  }
+  return jsgraph->HeapConstant(Handle<Context>(function->context()));
+}
+
+
 void JSGenericLowering::LowerJSCallFunction(Node* node) {
   const CallFunctionParameters& p = CallFunctionParametersOf(node->op());
-  CallFunctionStub stub(isolate(), static_cast<int>(p.arity() - 2), p.flags());
+  int argument_count = static_cast<int>(p.arity() - 2);
+  HeapObjectMatcher<JSFunction> func(node->InputAt(0));
+  if (func.HasValue()) {

[Michael Starzinger, 2014/10/31 12:28:06]

suggestion: How would you feel about moving this optimization into a separate
helper? That way it would visually be clear that this is an optional
optimization, a comment in that regard might also be nice/

+    // Call to a constant JSFunction. Skip CallFunctionStub if arity matches.
+    Handle<JSFunction> function = func.Value().handle();
+    if (argument_count == function->shared()->formal_parameter_count()) {
+      int index = NodeProperties::FirstContextIndex(node);
+      Node* context =
+          ReuseContextIfPossible(jsgraph(), function, node->InputAt(index));
+      node->ReplaceInput(index, context);
+      CallDescriptor* desc = linkage()->GetJSCallDescriptor(
+          1 + argument_count, jsgraph()->zone(), FlagsForNode(node));
+      PatchOperator(node, common()->Call(desc));
+      return;
+    }
+  }
+  // Call to computed function; use CallFunctionStub;
+  CallFunctionStub stub(isolate(), argument_count, p.flags());
   CallInterfaceDescriptor d = stub.GetCallInterfaceDescriptor();
   CallDescriptor* desc = linkage()->GetStubCallDescriptor(
       d, static_cast<int>(p.arity() - 1), FlagsForNode(node));
   Node* stub_code = CodeConstant(stub.GetCode());
   PatchInsertInput(node, 0, stub_code);
   PatchOperator(node, common()->Call(desc));
 }
 
 
 void JSGenericLowering::LowerJSCallRuntime(Node* node) {
   const CallRuntimeParameters& p = CallRuntimeParametersOf(node->op());
   ReplaceWithRuntimeCall(node, p.id(), static_cast<int>(p.arity()));
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8