[builtins] De-duplicate specification of array builtin parameter count

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,
-                                 int internal_formal_parameter_count);
+                                 Builtins::Name name);
   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 198 matching lines @@
     fun->shared()->set_internal_formal_parameter_count(len);
   } else {
     fun->shared()->DontAdaptArguments();
   }
   fun->shared()->set_length(len);
   return fun;
 }
 
 Handle<JSFunction> InstallArrayBuiltinFunction(Handle<JSObject> base,
                                                const char* name,
-                                               Builtins::Name call,
-                                               int argument_count) {
+                                               Builtins::Name call) {
   Isolate* isolate = base->GetIsolate();
   Handle<String> str_name = isolate->factory()->InternalizeUtf8String(name);
   Handle<JSFunction> fun =
       CreateFunction(isolate, str_name, JS_OBJECT_TYPE, JSObject::kHeaderSize,
                      MaybeHandle<JSObject>(), call, true);
-  fun->shared()->set_internal_formal_parameter_count(argument_count);
+  fun->shared()->set_internal_formal_parameter_count(
+      Builtins::GetBuiltinParameterCount(isolate, call));
 
   // Set the length to 1 to satisfy ECMA-262.
   fun->shared()->set_length(1);
   fun->shared()->set_language_mode(STRICT);
   InstallFunction(base, fun, str_name);
   return fun;
 }
 
 Handle<JSFunction> SimpleInstallFunction(Handle<JSObject> base,
                                          Handle<String> name,
@@ skipping 3438 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,
-                                        int internal_formal_parameter_count) {
+                                        Builtins::Name builtin_name) {
   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));
   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);
+  info->set_internal_formal_parameter_count(
+      Builtins::GetBuiltinParameterCount(isolate(), builtin_name));
 }
 
 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,
-                              SharedFunctionInfo::kDontAdaptArgumentsSentinel);
+                              Builtins::kTypedArrayPrototypeEvery);
     InstallOneBuiltinFunction(typed_array_prototype, "some",
-                              Builtins::kTypedArrayPrototypeSome,
-                              SharedFunctionInfo::kDontAdaptArgumentsSentinel);
+                              Builtins::kTypedArrayPrototypeSome);
     InstallOneBuiltinFunction(typed_array_prototype, "reduce",
-                              Builtins::kTypedArrayPrototypeReduce,
-                              SharedFunctionInfo::kDontAdaptArgumentsSentinel);
+                              Builtins::kTypedArrayPrototypeReduce);
     InstallOneBuiltinFunction(typed_array_prototype, "reduceRight",
-                              Builtins::kTypedArrayPrototypeReduceRight,
-                              SharedFunctionInfo::kDontAdaptArgumentsSentinel);
+                              Builtins::kTypedArrayPrototypeReduceRight);
   }
 }
 
 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 444 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,
-        SharedFunctionInfo::kDontAdaptArgumentsSentinel);
+    Handle<JSFunction> forEach =
+        InstallArrayBuiltinFunction(proto, "forEach", Builtins::kArrayForEach);
     // Add forEach to the context.
     native_context()->set_array_for_each_iterator(*forEach);
 
     // Install Array.prototype.filter
-    InstallArrayBuiltinFunction(
-        proto, "filter", Builtins::kArrayFilter,
-        SharedFunctionInfo::kDontAdaptArgumentsSentinel);
+    InstallArrayBuiltinFunction(proto, "filter", Builtins::kArrayFilter);
 
     // Install Array.prototype.map
-    InstallArrayBuiltinFunction(
-        proto, "map", Builtins::kArrayMap,
-        SharedFunctionInfo::kDontAdaptArgumentsSentinel);
+    InstallArrayBuiltinFunction(proto, "map", Builtins::kArrayMap);
 
     // Install Array.prototype.every
-    InstallArrayBuiltinFunction(
-        proto, "every", Builtins::kArrayEvery,
-        SharedFunctionInfo::kDontAdaptArgumentsSentinel);
+    InstallArrayBuiltinFunction(proto, "every", Builtins::kArrayEvery);
 
     // Install Array.prototype.some
-    InstallArrayBuiltinFunction(
-        proto, "some", Builtins::kArraySome,
-        SharedFunctionInfo::kDontAdaptArgumentsSentinel);
+    InstallArrayBuiltinFunction(proto, "some", Builtins::kArraySome);
 
     // Install Array.prototype.reduce
-    InstallArrayBuiltinFunction(
-        proto, "reduce", Builtins::kArrayReduce,
-        SharedFunctionInfo::kDontAdaptArgumentsSentinel);
+    InstallArrayBuiltinFunction(proto, "reduce", Builtins::kArrayReduce);
 
     // Install Array.prototype.reduceRight
-    InstallArrayBuiltinFunction(
-        proto, "reduceRight", Builtins::kArrayReduceRight,
-        SharedFunctionInfo::kDontAdaptArgumentsSentinel);
+    InstallArrayBuiltinFunction(proto, "reduceRight",
+                                Builtins::kArrayReduceRight);
   }
 
   // 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