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

src/compiler/js-call-reducer.cc

Index: src/compiler/js-call-reducer.cc
diff --git a/src/compiler/js-call-reducer.cc b/src/compiler/js-call-reducer.cc
index 2be5c161f58d59d6c80f9dfecfcdef3511f10380..1f977e28c7fd8c2af07bfcf405154cba23019eb4 100644
--- a/src/compiler/js-call-reducer.cc
+++ b/src/compiler/js-call-reducer.cc
@@ -582,11 +582,44 @@ Reduction JSCallReducer::ReduceJSCall(Node* node) {
         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: