[array] Don't adapt arguments for ArrayIndexOf and ArrayIncludes

src/builtins/builtins-array-gen.cc

 // Copyright 2017 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/builtins/builtins-utils-gen.h"
 #include "src/builtins/builtins.h"
 #include "src/code-stub-assembler.h"
 
 namespace v8 {
 namespace internal {
@@ skipping 1337 matching lines @@
   Return(BooleanConstant(true));
 
   BIND(&return_false);
   Return(BooleanConstant(false));
 
   BIND(&call_runtime);
   Return(CallRuntime(Runtime::kArrayIsArray, context, object));
 }
 
 TF_BUILTIN(ArrayIncludes, CodeStubAssembler) {
-  Node* const array = Parameter(Descriptor::kReceiver);
-  Node* const search_element = Parameter(Descriptor::kSearchElement);
-  Node* const start_from = Parameter(Descriptor::kFromIndex);
-  Node* const context = Parameter(Descriptor::kContext);
+  const int kSearchElementArg = 0;
+  const int kFromIndexArg = 1;
+
+  Node* argc =
+      ChangeInt32ToIntPtr(Parameter(BuiltinDescriptor::kArgumentsCount));
+  CodeStubArguments args(this, argc);
+
+  Node* array = args.GetReceiver();
+  Node* search_element =
+      args.GetOptionalArgumentValue(kSearchElementArg, UndefinedConstant());
+  Node* start_from =
+      args.GetOptionalArgumentValue(kFromIndexArg, UndefinedConstant());
+  Node* const context = Parameter(BuiltinDescriptor::kContext);
 
   VARIABLE(index_var, MachineType::PointerRepresentation());
 
   Label init_k(this), return_true(this), return_false(this), call_runtime(this);
   Label init_len(this), select_loop(this);
 
   index_var.Bind(IntPtrConstant(0));
 
   // Take slow path if not a JSArray, if retrieving elements requires
   // traversing prototype, or if access checks are required.
@@ skipping 254 matching lines @@
       LoadFixedDoubleArrayElement(elements, index_var.value(),
                                   MachineType::None(), 0, INTPTR_PARAMETERS,
                                   &return_true);
 
       index_var.Bind(IntPtrAdd(index_var.value(), IntPtrConstant(1)));
       Goto(&hole_loop);
     }
   }
 
   BIND(&return_true);
-  Return(TrueConstant());
+  args.PopAndReturn(TrueConstant());
 
   BIND(&return_false);
-  Return(FalseConstant());
+  args.PopAndReturn(FalseConstant());
 
   BIND(&call_runtime);
-  Return(CallRuntime(Runtime::kArrayIncludes_Slow, context, array,
-                     search_element, start_from));
+  args.PopAndReturn(CallRuntime(Runtime::kArrayIncludes_Slow, context, array,
+                                search_element, start_from));
 }
 
 TF_BUILTIN(ArrayIndexOf, CodeStubAssembler) {
-  Node* array = Parameter(Descriptor::kReceiver);
-  Node* search_element = Parameter(Descriptor::kSearchElement);
-  Node* start_from = Parameter(Descriptor::kFromIndex);
-  Node* context = Parameter(Descriptor::kContext);
+  const int kSearchElementArg = 0;
+  const int kFromIndexArg = 1;
+
+  Node* argc =
+      ChangeInt32ToIntPtr(Parameter(BuiltinDescriptor::kArgumentsCount));
+  CodeStubArguments args(this, argc);
+
+  Node* array = args.GetReceiver();
+  Node* search_element =
+      args.GetOptionalArgumentValue(kSearchElementArg, UndefinedConstant());
+  Node* start_from =
+      args.GetOptionalArgumentValue(kFromIndexArg, UndefinedConstant());
+  Node* context = Parameter(BuiltinDescriptor::kContext);
 
   Node* intptr_zero = IntPtrConstant(0);
   Node* intptr_one = IntPtrConstant(1);
 
   VARIABLE(len_var, MachineType::PointerRepresentation());
   VARIABLE(index_var, MachineType::PointerRepresentation());
   VARIABLE(start_from_var, MachineType::PointerRepresentation());
 
   Label init_k(this), return_found(this), return_not_found(this),
       call_runtime(this);
@@ skipping 230 matching lines @@
 
       Branch(Float64Equal(element_k, search_num.value()), &return_found,
              &continue_loop);
       BIND(&continue_loop);
       index_var.Bind(IntPtrAdd(index_var.value(), intptr_one));
       Goto(&not_nan_loop);
     }
   }
 
   BIND(&return_found);
-  Return(SmiTag(index_var.value()));
+  args.PopAndReturn(SmiTag(index_var.value()));
 
   BIND(&return_not_found);
-  Return(NumberConstant(-1));
+  args.PopAndReturn(NumberConstant(-1));
 
   BIND(&call_runtime);
-  Return(CallRuntime(Runtime::kArrayIndexOf, context, array, search_element,
-                     start_from));
+  args.PopAndReturn(CallRuntime(Runtime::kArrayIndexOf, context, array,
+                                search_element, start_from));
 }
 
 class ArrayPrototypeIterationAssembler : public CodeStubAssembler {
  public:
   explicit ArrayPrototypeIterationAssembler(compiler::CodeAssemblerState* state)
       : CodeStubAssembler(state) {}
 
  protected:
   void Generate_ArrayPrototypeIterationMethod(Node* context, Node* receiver,
                                               IterationKind iteration_kind) {
@@ skipping 463 matching lines @@
   {
     Node* message = SmiConstant(MessageTemplate::kDetachedOperation);
     CallRuntime(Runtime::kThrowTypeError, context, message,
                 HeapConstant(operation));
     Unreachable();
   }
 }
 
 }  // namespace internal
 }  // namespace v8