[turbofan] Avoid going through ArgumentsAdaptorTrampoline for CSA/C++ builtins

src/compiler/js-call-reducer.cc

 // Copyright 2015 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/compiler/js-call-reducer.h"
 
 #include "src/code-factory.h"
 #include "src/code-stubs.h"
 #include "src/compilation-dependencies.h"
 #include "src/compiler/js-graph.h"
@@ skipping 564 matching lines @@
 
       // Raise a TypeError if the {target} is a "classConstructor".
       if (IsClassConstructor(shared->kind())) {
         NodeProperties::ReplaceValueInputs(node, target);
         NodeProperties::ChangeOp(
             node, javascript()->CallRuntime(
                       Runtime::kThrowConstructorNonCallableError, 1));
         return Changed(node);
       }
 
+      // For CSA/C++ builtin {target}s, we can ensure that the number

[Benedikt Meurer, 2017/04/26 16:17:57]

As discussed a few weeks ago, I don't think we should reland this. Instead we
should change it on the builtins side and declare the interesting ones with
kDontAdaptArgumentsSentinel. Then JSTypedLowering will generate direct calls for
those.

[danno, 2017/04/28 06:58:10]

Done.

+      // of parameters we pass to the {target} matches exactly the
+      // number of formal parameters expected by the builtin, and thus
+      // avoid creating an ArgumentsAdaptorFrame. This is safe because
+      // all CSA/C++ builtins that care about variable arguments are
+      // declared with the kDontAdaptArgumentsSentinel marker.
+      int builtin_index = shared->code()->builtin_index();
+      if (builtin_index != -1 && shared->native() && !shared->IsInterpreted()) {
+        // Check if we have an arguments mismatch for {target}.
+        int arity = static_cast<int>(p.arity() - 2);
+        int num_parameters = shared->internal_formal_parameter_count();
+        if (num_parameters != arity &&
+            num_parameters != SharedFunctionInfo::kDontAdaptArgumentsSentinel) {
+          // Fill up missing parameters with undefined.
+          while (arity < num_parameters) {
+            node->InsertInput(graph()->zone(), arity + 2,
+                              jsgraph()->UndefinedConstant());
+            arity++;
+          }
+          // Remove additional parameters.
+          while (arity > num_parameters) {
+            node->RemoveInput(arity + 1);
+            arity--;
+          }
+          NodeProperties::ChangeOp(
+              node, javascript()->Call(arity + 2, p.frequency(), p.feedback(),
+                                       p.convert_mode(), p.tail_call_mode()));
+          // Try to further reduce the JSCall {node}.
+          Reduction const reduction = ReduceJSCall(node);
+          return reduction.Changed() ? reduction : Changed(node);
+        }
+      }
+
       // Don't inline cross native context.
       if (function->native_context() != *native_context()) return NoChange();
 
       // Check for known builtin functions.
-      switch (shared->code()->builtin_index()) {
+      switch (builtin_index) {
         case Builtins::kBooleanConstructor:
           return ReduceBooleanConstructor(node);
         case Builtins::kFunctionPrototypeApply:
           return ReduceFunctionPrototypeApply(node);
         case Builtins::kFunctionPrototypeCall:
           return ReduceFunctionPrototypeCall(node);
         case Builtins::kFunctionPrototypeHasInstance:
           return ReduceFunctionPrototypeHasInstance(node);
         case Builtins::kNumberConstructor:
           return ReduceNumberConstructor(node);
@@ skipping 274 matching lines @@
   return jsgraph()->javascript();
 }
 
 SimplifiedOperatorBuilder* JSCallReducer::simplified() const {
   return jsgraph()->simplified();
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8