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

src/bootstrapper.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/bootstrapper.h"
 
 #include "src/accessors.h"
 #include "src/api-natives.h"
 #include "src/base/ieee754.h"
 #include "src/code-stubs.h"
@@ skipping 159 matching lines @@
 
 #define DECLARE_FEATURE_INITIALIZATION(id, descr) \
   void InitializeGlobal_##id();
 
   HARMONY_INPROGRESS(DECLARE_FEATURE_INITIALIZATION)
   HARMONY_STAGED(DECLARE_FEATURE_INITIALIZATION)
   HARMONY_SHIPPING(DECLARE_FEATURE_INITIALIZATION)
 #undef DECLARE_FEATURE_INITIALIZATION
 
   void InstallOneBuiltinFunction(Handle<Object> prototype, const char* method,
-                                 Builtins::Name name);
+                                 Builtins::Name name,
+                                 int internal_formal_parameter_count);
   void InitializeGlobal_experimental_fast_array_builtins();
 
   Handle<JSFunction> InstallArrayBuffer(Handle<JSObject> target,
                                         const char* name,
                                         Builtins::Name call_byteLength,
                                         BuiltinFunctionId byteLength_id,
                                         Builtins::Name call_slice);
   Handle<JSFunction> InstallInternalArray(Handle<JSObject> target,
                                           const char* name,
                                           ElementsKind elements_kind);
@@ skipping 3664 matching lines @@
   Handle<JSObject> symbol = Handle<JSObject>::cast(
       JSObject::GetProperty(global, symbol_string).ToHandleChecked());
   Handle<String> name_string = factory->InternalizeUtf8String(name);
   PropertyAttributes attributes =
       static_cast<PropertyAttributes>(DONT_ENUM | DONT_DELETE | READ_ONLY);
   JSObject::AddProperty(symbol, name_string, value, attributes);
 }
 
 void Genesis::InstallOneBuiltinFunction(Handle<Object> prototype,
                                         const char* method_name,
-                                        Builtins::Name builtin_name) {
+                                        Builtins::Name builtin_name,
+                                        int internal_formal_parameter_count) {
   LookupIterator it(
       prototype, isolate()->factory()->NewStringFromAsciiChecked(method_name),
       LookupIterator::OWN_SKIP_INTERCEPTOR);
   Handle<Object> function = Object::GetProperty(&it).ToHandleChecked();
   Handle<JSFunction>::cast(function)->set_code(
       isolate()->builtins()->builtin(builtin_name));
-  Handle<JSFunction>::cast(function)->shared()->set_code(
-      isolate()->builtins()->builtin(builtin_name));
+  SharedFunctionInfo* info = Handle<JSFunction>::cast(function)->shared();
+  info->set_code(isolate()->builtins()->builtin(builtin_name));
+  info->set_internal_formal_parameter_count(internal_formal_parameter_count);
 }
 
 void Genesis::InitializeGlobal_experimental_fast_array_builtins() {
   if (!FLAG_experimental_fast_array_builtins) return;
   {
     Handle<Object> typed_array_prototype(
         native_context()->typed_array_prototype(), isolate());
     // Insert experimental fast TypedArray builtins here.
     InstallOneBuiltinFunction(typed_array_prototype, "every",
-                              Builtins::kTypedArrayPrototypeEvery);
+                              Builtins::kTypedArrayPrototypeEvery,
+                              SharedFunctionInfo::kDontAdaptArgumentsSentinel);
     InstallOneBuiltinFunction(typed_array_prototype, "some",
-                              Builtins::kTypedArrayPrototypeSome);
+                              Builtins::kTypedArrayPrototypeSome,
+                              SharedFunctionInfo::kDontAdaptArgumentsSentinel);
     InstallOneBuiltinFunction(typed_array_prototype, "reduce",
-                              Builtins::kTypedArrayPrototypeReduce);
+                              Builtins::kTypedArrayPrototypeReduce,
+                              SharedFunctionInfo::kDontAdaptArgumentsSentinel);
     InstallOneBuiltinFunction(typed_array_prototype, "reduceRight",
-                              Builtins::kTypedArrayPrototypeReduceRight);
+                              Builtins::kTypedArrayPrototypeReduceRight,
+                              SharedFunctionInfo::kDontAdaptArgumentsSentinel);
   }
 }
 
 void Genesis::InitializeGlobal_harmony_sharedarraybuffer() {
   if (!FLAG_harmony_sharedarraybuffer) return;
 
   Handle<JSGlobalObject> global(native_context()->global_object());
   Isolate* isolate = global->GetIsolate();
   Factory* factory = isolate->factory();
 
@@ skipping 445 matching lines @@
     // Make sure that Array.prototype.concat appears to be compiled.
     // The code will never be called, but inline caching for call will
     // only work if it appears to be compiled.
     concat->shared()->DontAdaptArguments();
     DCHECK(concat->is_compiled());
     // Set the lengths for the functions to satisfy ECMA-262.
     concat->shared()->set_length(1);
 
     // Install Array.prototype.forEach
     Handle<JSFunction> forEach = InstallArrayBuiltinFunction(
-        proto, "forEach", Builtins::kArrayForEach, 2);
+        proto, "forEach", Builtins::kArrayForEach,
+        SharedFunctionInfo::kDontAdaptArgumentsSentinel);
     // Add forEach to the context.
     native_context()->set_array_for_each_iterator(*forEach);
 
     // Install Array.prototype.filter
-    InstallArrayBuiltinFunction(proto, "filter", Builtins::kArrayFilter, 2);
+    InstallArrayBuiltinFunction(
+        proto, "filter", Builtins::kArrayFilter,
+        SharedFunctionInfo::kDontAdaptArgumentsSentinel);
 
     // Install Array.prototype.map
-    InstallArrayBuiltinFunction(proto, "map", Builtins::kArrayMap, 2);
+    InstallArrayBuiltinFunction(
+        proto, "map", Builtins::kArrayMap,
+        SharedFunctionInfo::kDontAdaptArgumentsSentinel);
 
     // Install Array.prototype.every
-    InstallArrayBuiltinFunction(proto, "every", Builtins::kArrayEvery, 2);
+    InstallArrayBuiltinFunction(
+        proto, "every", Builtins::kArrayEvery,
+        SharedFunctionInfo::kDontAdaptArgumentsSentinel);
 
     // Install Array.prototype.some
-    InstallArrayBuiltinFunction(proto, "some", Builtins::kArraySome, 2);
+    InstallArrayBuiltinFunction(
+        proto, "some", Builtins::kArraySome,
+        SharedFunctionInfo::kDontAdaptArgumentsSentinel);
 
     // Install Array.prototype.reduce
-    InstallArrayBuiltinFunction(proto, "reduce", Builtins::kArrayReduce, 2);
+    InstallArrayBuiltinFunction(
+        proto, "reduce", Builtins::kArrayReduce,
+        SharedFunctionInfo::kDontAdaptArgumentsSentinel);
 
     // Install Array.prototype.reduceRight
-    InstallArrayBuiltinFunction(proto, "reduceRight",
-                                Builtins::kArrayReduceRight, 2);
+    InstallArrayBuiltinFunction(
+        proto, "reduceRight", Builtins::kArrayReduceRight,
+        SharedFunctionInfo::kDontAdaptArgumentsSentinel);
   }
 
   // Install InternalArray.prototype.concat
   {
     Handle<JSFunction> array_constructor(
         native_context()->internal_array_function());
     Handle<JSObject> proto(JSObject::cast(array_constructor->prototype()));
     Handle<JSFunction> concat =
         InstallFunction(proto, "concat", JS_OBJECT_TYPE, JSObject::kHeaderSize,
                         MaybeHandle<JSObject>(), Builtins::kArrayConcat);
@@ skipping 884 matching lines @@
 }
 
 
 // Called when the top-level V8 mutex is destroyed.
 void Bootstrapper::FreeThreadResources() {
   DCHECK(!IsActive());
 }
 
 }  // namespace internal
 }  // namespace v8