[builtins] Define interface descriptors for builtins with JSFunction linkage.

This is a first bulk of changes.

BUG=v8:6116

Change-Id: I9308129bd032c0bf5b60c8e0413ee2cb710891ea
Reviewed-on: https://chromium-review.googlesource.com/456556
Commit-Queue: Igor Sheludko <ishell@chromium.org>
Reviewed-by: Jakob Kummerow <jkummerow@chromium.org>
Cr-Commit-Position: refs/heads/master@{#43930}

BUILD.gn

@@ -1049,6 +1049,7 @@ v8_source_set("v8_base") {
     "src/builtins/builtins-dataview.cc",
     "src/builtins/builtins-date.cc",
     "src/builtins/builtins-debug.cc",
+    "src/builtins/builtins-descriptors.h",
     "src/builtins/builtins-error.cc",
     "src/builtins/builtins-forin.h",
     "src/builtins/builtins-function.cc",

src/builtins/builtins-array-gen.cc

@@ -22,6 +22,8 @@ class ArrayBuiltinCodeStubAssembler : public CodeStubAssembler {
       const char* name, const BuiltinResultGenerator& generator,
       const CallResultProcessor& processor,
       const Callable& slow_case_continuation) {
+    // TODO(ishell): use constants from Descriptor once the JSFunction linkage
+    // arguments are reordered.
     Node* receiver = Parameter(IteratingArrayBuiltinDescriptor::kReceiver);
     Node* callbackfn = Parameter(IteratingArrayBuiltinDescriptor::kCallback);
     Node* this_arg = Parameter(IteratingArrayBuiltinDescriptor::kThisArg);
@@ -108,6 +110,8 @@ class ArrayBuiltinCodeStubAssembler : public CodeStubAssembler {
 
   void GenerateIteratingArrayBuiltinLoopContinuation(
       const CallResultProcessor& processor) {
+    // TODO(ishell): use constants from Descriptor once the JSFunction linkage
+    // arguments are reordered.
     Node* callbackfn =
         Parameter(IteratingArrayBuiltinLoopContinuationDescriptor::kCallback);
     Node* this_arg =
@@ -318,6 +322,8 @@ TF_BUILTIN(FastArrayPush, CodeStubAssembler) {
   Label double_transition(this);
   Label runtime(this, Label::kDeferred);
 
+  // TODO(ishell): use constants from Descriptor once the JSFunction linkage
+  // arguments are reordered.
   Node* argc = Parameter(BuiltinDescriptor::kArgumentsCount);
   Node* context = Parameter(BuiltinDescriptor::kContext);
   Node* new_target = Parameter(BuiltinDescriptor::kNewTarget);
@@ -510,8 +516,8 @@ TF_BUILTIN(ArrayEvery, ArrayBuiltinCodeStubAssembler) {
 }
 
 TF_BUILTIN(ArrayIsArray, CodeStubAssembler) {
-  Node* object = Parameter(1);
-  Node* context = Parameter(4);
+  Node* object = Parameter(Descriptor::kArg);
+  Node* context = Parameter(Descriptor::kContext);
 
   Label call_runtime(this), return_true(this), return_false(this);
 
@@ -536,10 +542,10 @@ TF_BUILTIN(ArrayIsArray, CodeStubAssembler) {
 }
 
 TF_BUILTIN(ArrayIncludes, CodeStubAssembler) {
-  Node* const array = Parameter(0);
-  Node* const search_element = Parameter(1);
-  Node* const start_from = Parameter(2);
-  Node* const context = Parameter(3 + 2);
+  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);
 
   Variable index_var(this, MachineType::PointerRepresentation());
 
@@ -825,10 +831,10 @@ TF_BUILTIN(ArrayIncludes, CodeStubAssembler) {
 }
 
 TF_BUILTIN(ArrayIndexOf, CodeStubAssembler) {
-  Node* array = Parameter(0);
-  Node* search_element = Parameter(1);
-  Node* start_from = Parameter(2);
-  Node* context = Parameter(3 + 2);
+  Node* array = Parameter(Descriptor::kReceiver);
+  Node* search_element = Parameter(Descriptor::kSearchElement);
+  Node* start_from = Parameter(Descriptor::kFromIndex);
+  Node* context = Parameter(Descriptor::kContext);
 
   Node* intptr_zero = IntPtrConstant(0);
   Node* intptr_one = IntPtrConstant(1);
@@ -1095,10 +1101,8 @@ class ArrayPrototypeIterationAssembler : public CodeStubAssembler {
       : CodeStubAssembler(state) {}
 
  protected:
-  void Generate_ArrayPrototypeIterationMethod(IterationKind iteration_kind) {
-    Node* receiver = Parameter(0);
-    Node* context = Parameter(3);
-
+  void Generate_ArrayPrototypeIterationMethod(Node* context, Node* receiver,
+                                              IterationKind iteration_kind) {
     Variable var_array(this, MachineRepresentation::kTagged);
     Variable var_map(this, MachineRepresentation::kTagged);
     Variable var_type(this, MachineRepresentation::kWord32);
@@ -1130,23 +1134,32 @@ class ArrayPrototypeIterationAssembler : public CodeStubAssembler {
 };
 
 TF_BUILTIN(ArrayPrototypeValues, ArrayPrototypeIterationAssembler) {
-  Generate_ArrayPrototypeIterationMethod(IterationKind::kValues);
+  Node* context = Parameter(Descriptor::kContext);
+  Node* receiver = Parameter(Descriptor::kReceiver);
+  Generate_ArrayPrototypeIterationMethod(context, receiver,
+                                         IterationKind::kValues);
 }
 
 TF_BUILTIN(ArrayPrototypeEntries, ArrayPrototypeIterationAssembler) {
-  Generate_ArrayPrototypeIterationMethod(IterationKind::kEntries);
+  Node* context = Parameter(Descriptor::kContext);
+  Node* receiver = Parameter(Descriptor::kReceiver);
+  Generate_ArrayPrototypeIterationMethod(context, receiver,
+                                         IterationKind::kEntries);
 }
 
 TF_BUILTIN(ArrayPrototypeKeys, ArrayPrototypeIterationAssembler) {
-  Generate_ArrayPrototypeIterationMethod(IterationKind::kKeys);
+  Node* context = Parameter(Descriptor::kContext);
+  Node* receiver = Parameter(Descriptor::kReceiver);
+  Generate_ArrayPrototypeIterationMethod(context, receiver,
+                                         IterationKind::kKeys);
 }
 
 TF_BUILTIN(ArrayIteratorPrototypeNext, CodeStubAssembler) {
   Handle<String> operation = factory()->NewStringFromAsciiChecked(
       "Array Iterator.prototype.next", TENURED);
 
-  Node* iterator = Parameter(0);
-  Node* context = Parameter(3);
+  Node* context = Parameter(Descriptor::kContext);
+  Node* iterator = Parameter(Descriptor::kReceiver);
 
   Variable var_value(this, MachineRepresentation::kTagged);
   Variable var_done(this, MachineRepresentation::kTagged);

src/builtins/builtins-async-function-gen.cc

@@ -71,8 +71,8 @@ void AsyncFunctionBuiltinsAssembler::AsyncFunctionAwaitResumeClosure(
 
 TF_BUILTIN(AsyncFunctionAwaitRejectClosure, AsyncFunctionBuiltinsAssembler) {
   CSA_ASSERT_JS_ARGC_EQ(this, 1);
-  Node* const sentError = Parameter(1);
-  Node* const context = Parameter(4);
+  Node* const sentError = Parameter(Descriptor::kSentError);
+  Node* const context = Parameter(Descriptor::kContext);
 
   AsyncFunctionAwaitResumeClosure(context, sentError,
                                   JSGeneratorObject::kThrow);
@@ -81,8 +81,8 @@ TF_BUILTIN(AsyncFunctionAwaitRejectClosure, AsyncFunctionBuiltinsAssembler) {
 
 TF_BUILTIN(AsyncFunctionAwaitResolveClosure, AsyncFunctionBuiltinsAssembler) {
   CSA_ASSERT_JS_ARGC_EQ(this, 1);
-  Node* const sentValue = Parameter(1);
-  Node* const context = Parameter(4);
+  Node* const sentValue = Parameter(Descriptor::kSentValue);
+  Node* const context = Parameter(Descriptor::kContext);
 
   AsyncFunctionAwaitResumeClosure(context, sentValue, JSGeneratorObject::kNext);
   Return(UndefinedConstant());
@@ -130,10 +130,10 @@ void AsyncFunctionBuiltinsAssembler::AsyncFunctionAwait(
 // prediction indicates that there is a locally surrounding catch block.
 TF_BUILTIN(AsyncFunctionAwaitCaught, AsyncFunctionBuiltinsAssembler) {
   CSA_ASSERT_JS_ARGC_EQ(this, 3);
-  Node* const generator = Parameter(1);
-  Node* const awaited = Parameter(2);
-  Node* const outer_promise = Parameter(3);
-  Node* const context = Parameter(6);
+  Node* const generator = Parameter(Descriptor::kGenerator);
+  Node* const awaited = Parameter(Descriptor::kAwaited);
+  Node* const outer_promise = Parameter(Descriptor::kOuterPromise);
+  Node* const context = Parameter(Descriptor::kContext);
 
   static const bool kIsPredictedAsCaught = true;
 
@@ -145,10 +145,10 @@ TF_BUILTIN(AsyncFunctionAwaitCaught, AsyncFunctionBuiltinsAssembler) {
 // prediction indicates no locally surrounding catch block.
 TF_BUILTIN(AsyncFunctionAwaitUncaught, AsyncFunctionBuiltinsAssembler) {
   CSA_ASSERT_JS_ARGC_EQ(this, 3);
-  Node* const generator = Parameter(1);
-  Node* const awaited = Parameter(2);
-  Node* const outer_promise = Parameter(3);
-  Node* const context = Parameter(6);
+  Node* const generator = Parameter(Descriptor::kGenerator);
+  Node* const awaited = Parameter(Descriptor::kAwaited);
+  Node* const outer_promise = Parameter(Descriptor::kOuterPromise);
+  Node* const context = Parameter(Descriptor::kContext);
 
   static const bool kIsPredictedAsCaught = false;
 
@@ -158,7 +158,7 @@ TF_BUILTIN(AsyncFunctionAwaitUncaught, AsyncFunctionBuiltinsAssembler) {
 
 TF_BUILTIN(AsyncFunctionPromiseCreate, AsyncFunctionBuiltinsAssembler) {
   CSA_ASSERT_JS_ARGC_EQ(this, 0);
-  Node* const context = Parameter(3);
+  Node* const context = Parameter(Descriptor::kContext);
 
   Node* const promise = AllocateAndInitJSPromise(context);
 
@@ -182,8 +182,8 @@ TF_BUILTIN(AsyncFunctionPromiseCreate, AsyncFunctionBuiltinsAssembler) {
 
 TF_BUILTIN(AsyncFunctionPromiseRelease, AsyncFunctionBuiltinsAssembler) {
   CSA_ASSERT_JS_ARGC_EQ(this, 1);
-  Node* const promise = Parameter(1);
-  Node* const context = Parameter(4);
+  Node* const promise = Parameter(Descriptor::kPromise);
+  Node* const context = Parameter(Descriptor::kContext);
 
   Label if_is_debug_active(this, Label::kDeferred);
   GotoIf(IsDebugActive(), &if_is_debug_active);

src/builtins/builtins-boolean-gen.cc

@@ -12,10 +12,10 @@ namespace internal {
 // -----------------------------------------------------------------------------
 // ES6 section 19.3 Boolean Objects
 
-// ES6 section 19.3.3.2 Boolean.prototype.toString ( )
+// ES6 #sec-boolean.prototype.tostring
 TF_BUILTIN(BooleanPrototypeToString, CodeStubAssembler) {
-  Node* receiver = Parameter(0);
-  Node* context = Parameter(3);
+  Node* context = Parameter(Descriptor::kContext);
+  Node* receiver = Parameter(Descriptor::kReceiver);
 
   Node* value = ToThisValue(context, receiver, PrimitiveType::kBoolean,
                             "Boolean.prototype.toString");
@@ -23,10 +23,10 @@ TF_BUILTIN(BooleanPrototypeToString, CodeStubAssembler) {
   Return(result);
 }
 
-// ES6 section 19.3.3.3 Boolean.prototype.valueOf ( )
+// ES6 #sec-boolean.prototype.valueof
 TF_BUILTIN(BooleanPrototypeValueOf, CodeStubAssembler) {
-  Node* receiver = Parameter(0);
-  Node* context = Parameter(3);
+  Node* context = Parameter(Descriptor::kContext);
+  Node* receiver = Parameter(Descriptor::kReceiver);
 
   Node* result = ToThisValue(context, receiver, PrimitiveType::kBoolean,
                              "Boolean.prototype.valueOf");

src/builtins/builtins-date-gen.cc

@@ -18,13 +18,13 @@ class DateBuiltinsAssembler : public CodeStubAssembler {
       : CodeStubAssembler(state) {}
 
  protected:
-  void Generate_DatePrototype_GetField(int field_index);
+  void Generate_DatePrototype_GetField(Node* context, Node* receiver,
+                                       int field_index);
 };
 
-void DateBuiltinsAssembler::Generate_DatePrototype_GetField(int field_index) {
-  Node* receiver = Parameter(0);
-  Node* context = Parameter(3);
-
+void DateBuiltinsAssembler::Generate_DatePrototype_GetField(Node* context,
+                                                            Node* receiver,
+                                                            int field_index) {
   Label receiver_not_date(this, Label::kDeferred);
 
   GotoIf(TaggedIsSmi(receiver), &receiver_not_date);
@@ -68,85 +68,123 @@ void DateBuiltinsAssembler::Generate_DatePrototype_GetField(int field_index) {
 }
 
 TF_BUILTIN(DatePrototypeGetDate, DateBuiltinsAssembler) {
-  Generate_DatePrototype_GetField(JSDate::kDay);
+  Node* context = Parameter(Descriptor::kContext);
+  Node* receiver = Parameter(Descriptor::kReceiver);
+  Generate_DatePrototype_GetField(context, receiver, JSDate::kDay);
 }
 
 TF_BUILTIN(DatePrototypeGetDay, DateBuiltinsAssembler) {
-  Generate_DatePrototype_GetField(JSDate::kWeekday);
+  Node* context = Parameter(Descriptor::kContext);
+  Node* receiver = Parameter(Descriptor::kReceiver);
+  Generate_DatePrototype_GetField(context, receiver, JSDate::kWeekday);
 }
 
 TF_BUILTIN(DatePrototypeGetFullYear, DateBuiltinsAssembler) {
-  Generate_DatePrototype_GetField(JSDate::kYear);
+  Node* context = Parameter(Descriptor::kContext);
+  Node* receiver = Parameter(Descriptor::kReceiver);
+  Generate_DatePrototype_GetField(context, receiver, JSDate::kYear);
 }
 
 TF_BUILTIN(DatePrototypeGetHours, DateBuiltinsAssembler) {
-  Generate_DatePrototype_GetField(JSDate::kHour);
+  Node* context = Parameter(Descriptor::kContext);
+  Node* receiver = Parameter(Descriptor::kReceiver);
+  Generate_DatePrototype_GetField(context, receiver, JSDate::kHour);
 }
 
 TF_BUILTIN(DatePrototypeGetMilliseconds, DateBuiltinsAssembler) {
-  Generate_DatePrototype_GetField(JSDate::kMillisecond);
+  Node* context = Parameter(Descriptor::kContext);
+  Node* receiver = Parameter(Descriptor::kReceiver);
+  Generate_DatePrototype_GetField(context, receiver, JSDate::kMillisecond);
 }
 
 TF_BUILTIN(DatePrototypeGetMinutes, DateBuiltinsAssembler) {
-  Generate_DatePrototype_GetField(JSDate::kMinute);
+  Node* context = Parameter(Descriptor::kContext);
+  Node* receiver = Parameter(Descriptor::kReceiver);
+  Generate_DatePrototype_GetField(context, receiver, JSDate::kMinute);
 }
 
 TF_BUILTIN(DatePrototypeGetMonth, DateBuiltinsAssembler) {
-  Generate_DatePrototype_GetField(JSDate::kMonth);
+  Node* context = Parameter(Descriptor::kContext);
+  Node* receiver = Parameter(Descriptor::kReceiver);
+  Generate_DatePrototype_GetField(context, receiver, JSDate::kMonth);
 }
 
 TF_BUILTIN(DatePrototypeGetSeconds, DateBuiltinsAssembler) {
-  Generate_DatePrototype_GetField(JSDate::kSecond);
+  Node* context = Parameter(Descriptor::kContext);
+  Node* receiver = Parameter(Descriptor::kReceiver);
+  Generate_DatePrototype_GetField(context, receiver, JSDate::kSecond);
 }
 
 TF_BUILTIN(DatePrototypeGetTime, DateBuiltinsAssembler) {
-  Generate_DatePrototype_GetField(JSDate::kDateValue);
+  Node* context = Parameter(Descriptor::kContext);
+  Node* receiver = Parameter(Descriptor::kReceiver);
+  Generate_DatePrototype_GetField(context, receiver, JSDate::kDateValue);
 }
 
 TF_BUILTIN(DatePrototypeGetTimezoneOffset, DateBuiltinsAssembler) {
-  Generate_DatePrototype_GetField(JSDate::kTimezoneOffset);
+  Node* context = Parameter(Descriptor::kContext);
+  Node* receiver = Parameter(Descriptor::kReceiver);
+  Generate_DatePrototype_GetField(context, receiver, JSDate::kTimezoneOffset);
 }
 
 TF_BUILTIN(DatePrototypeGetUTCDate, DateBuiltinsAssembler) {
-  Generate_DatePrototype_GetField(JSDate::kDayUTC);
+  Node* context = Parameter(Descriptor::kContext);
+  Node* receiver = Parameter(Descriptor::kReceiver);
+  Generate_DatePrototype_GetField(context, receiver, JSDate::kDayUTC);
 }
 
 TF_BUILTIN(DatePrototypeGetUTCDay, DateBuiltinsAssembler) {
-  Generate_DatePrototype_GetField(JSDate::kWeekdayUTC);
+  Node* context = Parameter(Descriptor::kContext);
+  Node* receiver = Parameter(Descriptor::kReceiver);
+  Generate_DatePrototype_GetField(context, receiver, JSDate::kWeekdayUTC);
 }
 
 TF_BUILTIN(DatePrototypeGetUTCFullYear, DateBuiltinsAssembler) {
-  Generate_DatePrototype_GetField(JSDate::kYearUTC);
+  Node* context = Parameter(Descriptor::kContext);
+  Node* receiver = Parameter(Descriptor::kReceiver);
+  Generate_DatePrototype_GetField(context, receiver, JSDate::kYearUTC);
 }
 
 TF_BUILTIN(DatePrototypeGetUTCHours, DateBuiltinsAssembler) {
-  Generate_DatePrototype_GetField(JSDate::kHourUTC);
+  Node* context = Parameter(Descriptor::kContext);
+  Node* receiver = Parameter(Descriptor::kReceiver);
+  Generate_DatePrototype_GetField(context, receiver, JSDate::kHourUTC);
 }
 
 TF_BUILTIN(DatePrototypeGetUTCMilliseconds, DateBuiltinsAssembler) {
-  Generate_DatePrototype_GetField(JSDate::kMillisecondUTC);
+  Node* context = Parameter(Descriptor::kContext);
+  Node* receiver = Parameter(Descriptor::kReceiver);
+  Generate_DatePrototype_GetField(context, receiver, JSDate::kMillisecondUTC);
 }
 
 TF_BUILTIN(DatePrototypeGetUTCMinutes, DateBuiltinsAssembler) {
-  Generate_DatePrototype_GetField(JSDate::kMinuteUTC);
+  Node* context = Parameter(Descriptor::kContext);
+  Node* receiver = Parameter(Descriptor::kReceiver);
+  Generate_DatePrototype_GetField(context, receiver, JSDate::kMinuteUTC);
 }
 
 TF_BUILTIN(DatePrototypeGetUTCMonth, DateBuiltinsAssembler) {
-  Generate_DatePrototype_GetField(JSDate::kMonthUTC);
+  Node* context = Parameter(Descriptor::kContext);
+  Node* receiver = Parameter(Descriptor::kReceiver);
+  Generate_DatePrototype_GetField(context, receiver, JSDate::kMonthUTC);
 }
 
 TF_BUILTIN(DatePrototypeGetUTCSeconds, DateBuiltinsAssembler) {
-  Generate_DatePrototype_GetField(JSDate::kSecondUTC);
+  Node* context = Parameter(Descriptor::kContext);
+  Node* receiver = Parameter(Descriptor::kReceiver);
+  Generate_DatePrototype_GetField(context, receiver, JSDate::kSecondUTC);
 }
 
 TF_BUILTIN(DatePrototypeValueOf, DateBuiltinsAssembler) {
-  Generate_DatePrototype_GetField(JSDate::kDateValue);
+  Node* context = Parameter(Descriptor::kContext);
+  Node* receiver = Parameter(Descriptor::kReceiver);
+  Generate_DatePrototype_GetField(context, receiver, JSDate::kDateValue);
 }
 
 TF_BUILTIN(DatePrototypeToPrimitive, CodeStubAssembler) {
-  Node* receiver = Parameter(0);
-  Node* hint = Parameter(1);
-  Node* context = Parameter(4);
+  Node* context = Parameter(Descriptor::kContext);
+  Node* receiver = Parameter(Descriptor::kReceiver);
+  Node* hint = Parameter(Descriptor::kHint);
 
   // Check if the {receiver} is actually a JSReceiver.
   Label receiver_is_invalid(this, Label::kDeferred);

src/builtins/builtins-descriptors.h

+// 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.
+
+#ifndef V8_BUILTINS_BUILTINS_DESCRIPTORS_H_
+#define V8_BUILTINS_BUILTINS_DESCRIPTORS_H_
+
+#include "src/builtins/builtins.h"
+#include "src/interface-descriptors.h"
+
+namespace v8 {
+namespace internal {
+
+// Define interface descriptors for builtins with JS linkage.
+#define DEFINE_TFJ_INTERFACE_DESCRIPTOR(Name, Argc, ...) \
+  struct Builtin_##Name##_InterfaceDescriptor {          \
+    enum ParameterIndices {                              \
+      kReceiver,                                         \
+      ##__VA_ARGS__,                                     \
+      kNewTarget,                                        \
+      kActualArgumentsCount,                             \
+      kContext,                                          \
+      kParameterCount,                                   \
+    };                                                   \
+  };
+
+// Define interface descriptors for builtins with StubCall linkage.
+#define DEFINE_TFS_INTERFACE_DESCRIPTOR(Name, Kind, Extra,                \
+                                        InterfaceDescriptor, result_size) \
+  typedef InterfaceDescriptor##Descriptor Builtin_##Name##_InterfaceDescriptor;
+
+BUILTIN_LIST(IGNORE_BUILTIN, IGNORE_BUILTIN, DEFINE_TFJ_INTERFACE_DESCRIPTOR,
+             DEFINE_TFS_INTERFACE_DESCRIPTOR, IGNORE_BUILTIN, IGNORE_BUILTIN,
+             IGNORE_BUILTIN)
+
+#undef DEFINE_TFJ_INTERFACE_DESCRIPTOR
+
+}  // namespace internal
+}  // namespace v8
+
+#endif  // V8_BUILTINS_BUILTINS_DESCRIPTORS_H_

src/builtins/builtins-function-gen.cc

@@ -12,6 +12,8 @@ namespace internal {
 TF_BUILTIN(FastFunctionPrototypeBind, CodeStubAssembler) {
   Label slow(this);
 
+  // TODO(ishell): use constants from Descriptor once the JSFunction linkage
+  // arguments are reordered.
   Node* argc = Parameter(BuiltinDescriptor::kArgumentsCount);
   Node* context = Parameter(BuiltinDescriptor::kContext);
   Node* new_target = Parameter(BuiltinDescriptor::kNewTarget);
@@ -165,11 +167,11 @@ TF_BUILTIN(FastFunctionPrototypeBind, CodeStubAssembler) {
                new_target, argc);
 }
 
-// ES6 section 19.2.3.6 Function.prototype [ @@hasInstance ] ( V )
+// ES6 #sec-function.prototype-@@hasinstance
 TF_BUILTIN(FunctionPrototypeHasInstance, CodeStubAssembler) {
-  Node* f = Parameter(0);
-  Node* v = Parameter(1);
-  Node* context = Parameter(4);
+  Node* context = Parameter(Descriptor::kContext);
+  Node* f = Parameter(Descriptor::kReceiver);
+  Node* v = Parameter(Descriptor::kV);
   Node* result = OrdinaryHasInstance(context, f, v);
   Return(result);
 }

src/builtins/builtins-generator-gen.cc

@@ -18,15 +18,14 @@ class GeneratorBuiltinsAssembler : public CodeStubAssembler {
       : CodeStubAssembler(state) {}
 
  protected:
-  void GeneratorPrototypeResume(JSGeneratorObject::ResumeMode resume_mode,
+  void GeneratorPrototypeResume(Node* receiver, Node* value, Node* context,
+                                JSGeneratorObject::ResumeMode resume_mode,
                                 char const* const method_name);
 };
 
 void GeneratorBuiltinsAssembler::GeneratorPrototypeResume(
+    Node* receiver, Node* value, Node* context,
     JSGeneratorObject::ResumeMode resume_mode, char const* const method_name) {
-  Node* receiver = Parameter(0);
-  Node* value = Parameter(1);
-  Node* context = Parameter(4);
   Node* closed = SmiConstant(JSGeneratorObject::kGeneratorClosed);
 
   // Check if the {receiver} is actually a JSGeneratorObject.
@@ -92,21 +91,31 @@ void GeneratorBuiltinsAssembler::GeneratorPrototypeResume(
   }
 }
 
-// ES6 section 25.3.1.2 Generator.prototype.next ( value )
+// ES6 #sec-generator.prototype.next
 TF_BUILTIN(GeneratorPrototypeNext, GeneratorBuiltinsAssembler) {
-  GeneratorPrototypeResume(JSGeneratorObject::kNext,
+  Node* receiver = Parameter(Descriptor::kReceiver);
+  Node* value = Parameter(Descriptor::kValue);
+  Node* context = Parameter(Descriptor::kContext);
+  GeneratorPrototypeResume(receiver, value, context, JSGeneratorObject::kNext,
                            "[Generator].prototype.next");
 }
 
-// ES6 section 25.3.1.3 Generator.prototype.return ( value )
+// ES6 #sec-generator.prototype.return
 TF_BUILTIN(GeneratorPrototypeReturn, GeneratorBuiltinsAssembler) {
-  GeneratorPrototypeResume(JSGeneratorObject::kReturn,
+  Node* receiver = Parameter(Descriptor::kReceiver);
+  Node* value = Parameter(Descriptor::kValue);
+  Node* context = Parameter(Descriptor::kContext);
+  GeneratorPrototypeResume(receiver, value, context, JSGeneratorObject::kReturn,
                            "[Generator].prototype.return");
 }
 
-// ES6 section 25.3.1.4 Generator.prototype.throw ( exception )
+// ES6 #sec-generator.prototype.throw
 TF_BUILTIN(GeneratorPrototypeThrow, GeneratorBuiltinsAssembler) {
-  GeneratorPrototypeResume(JSGeneratorObject::kThrow,
+  Node* receiver = Parameter(Descriptor::kReceiver);
+  Node* exception = Parameter(Descriptor::kException);
+  Node* context = Parameter(Descriptor::kContext);
+  GeneratorPrototypeResume(receiver, exception, context,
+                           JSGeneratorObject::kThrow,
                            "[Generator].prototype.throw");
 }
 

src/builtins/builtins-global-gen.cc

@@ -9,16 +9,16 @@
 namespace v8 {
 namespace internal {
 
-// ES6 section 18.2.2 isFinite ( number )
+// ES #sec-isfinite-number
 TF_BUILTIN(GlobalIsFinite, CodeStubAssembler) {
-  Node* context = Parameter(4);
+  Node* context = Parameter(Descriptor::kContext);
 
   Label return_true(this), return_false(this);
 
   // We might need to loop once for ToNumber conversion.
   Variable var_num(this, MachineRepresentation::kTagged);
   Label loop(this, &var_num);
-  var_num.Bind(Parameter(1));
+  var_num.Bind(Parameter(Descriptor::kNumber));
   Goto(&loop);
   Bind(&loop);
   {
@@ -57,16 +57,16 @@ TF_BUILTIN(GlobalIsFinite, CodeStubAssembler) {
   Return(BooleanConstant(false));
 }
 
-// ES6 section 18.2.3 isNaN ( number )
+// ES6 #sec-isnan-number
 TF_BUILTIN(GlobalIsNaN, CodeStubAssembler) {
-  Node* context = Parameter(4);
+  Node* context = Parameter(Descriptor::kContext);
 
   Label return_true(this), return_false(this);
 
   // We might need to loop once for ToNumber conversion.
   Variable var_num(this, MachineRepresentation::kTagged);
   Label loop(this, &var_num);
-  var_num.Bind(Parameter(1));
+  var_num.Bind(Parameter(Descriptor::kNumber));
   Goto(&loop);
   Bind(&loop);
   {

src/builtins/builtins-internal-gen.cc

@@ -168,7 +168,9 @@ TF_BUILTIN(NewUnmappedArgumentsElements, CodeStubAssembler) {
   }
 }
 
-TF_BUILTIN(ReturnReceiver, CodeStubAssembler) { Return(Parameter(0)); }
+TF_BUILTIN(ReturnReceiver, CodeStubAssembler) {
+  Return(Parameter(Descriptor::kReceiver));
+}
 
 }  // namespace internal
 }  // namespace v8

src/builtins/builtins-number-gen.cc

@@ -34,7 +34,7 @@ class NumberBuiltinsAssembler : public CodeStubAssembler {
 
   template <Signedness signed_result = kSigned>
   void BitwiseShiftOp(std::function<Node*(Node* lhs, Node* shift_count)> body) {
-    BitwiseOp<signed_result>([this, body](Node* lhs, Node* rhs) {
+    BitwiseOp<signed_result>([=](Node* lhs, Node* rhs) {
       Node* shift_count = Word32And(rhs, Int32Constant(0x1f));
       return body(lhs, shift_count);
     });
@@ -49,9 +49,9 @@ class NumberBuiltinsAssembler : public CodeStubAssembler {
   }
 };
 
-// ES6 section 20.1.2.2 Number.isFinite ( number )
+// ES6 #sec-number.isfinite
 TF_BUILTIN(NumberIsFinite, CodeStubAssembler) {
-  Node* number = Parameter(1);
+  Node* number = Parameter(Descriptor::kNumber);
 
   Label return_true(this), return_false(this);
 
@@ -73,9 +73,9 @@ TF_BUILTIN(NumberIsFinite, CodeStubAssembler) {
   Return(BooleanConstant(false));
 }
 
-// ES6 section 20.1.2.3 Number.isInteger ( number )
+// ES6 #sec-number.isinteger
 TF_BUILTIN(NumberIsInteger, CodeStubAssembler) {
-  Node* number = Parameter(1);
+  Node* number = Parameter(Descriptor::kNumber);
 
   Label return_true(this), return_false(this);
 
@@ -102,9 +102,9 @@ TF_BUILTIN(NumberIsInteger, CodeStubAssembler) {
   Return(BooleanConstant(false));
 }
 
-// ES6 section 20.1.2.4 Number.isNaN ( number )
+// ES6 #sec-number.isnan
 TF_BUILTIN(NumberIsNaN, CodeStubAssembler) {
-  Node* number = Parameter(1);
+  Node* number = Parameter(Descriptor::kNumber);
 
   Label return_true(this), return_false(this);
 
@@ -125,9 +125,9 @@ TF_BUILTIN(NumberIsNaN, CodeStubAssembler) {
   Return(BooleanConstant(false));
 }
 
-// ES6 section 20.1.2.5 Number.isSafeInteger ( number )
+// ES6 #sec-number.issafeinteger
 TF_BUILTIN(NumberIsSafeInteger, CodeStubAssembler) {
-  Node* number = Parameter(1);
+  Node* number = Parameter(Descriptor::kNumber);
 
   Label return_true(this), return_false(this);
 
@@ -160,14 +160,14 @@ TF_BUILTIN(NumberIsSafeInteger, CodeStubAssembler) {
   Return(BooleanConstant(false));
 }
 
-// ES6 section 20.1.2.12 Number.parseFloat ( string )
+// ES6 #sec-number.parsefloat
 TF_BUILTIN(NumberParseFloat, CodeStubAssembler) {
-  Node* context = Parameter(4);
+  Node* context = Parameter(Descriptor::kContext);
 
   // We might need to loop once for ToString conversion.
-  Variable var_input(this, MachineRepresentation::kTagged);
+  Variable var_input(this, MachineRepresentation::kTagged,
+                     Parameter(Descriptor::kString));
   Label loop(this, &var_input);
-  var_input.Bind(Parameter(1));
   Goto(&loop);
   Bind(&loop);
   {
@@ -255,11 +255,11 @@ TF_BUILTIN(NumberParseFloat, CodeStubAssembler) {
   }
 }
 
-// ES6 section 20.1.2.13 Number.parseInt ( string, radix )
+// ES6 #sec-number.parseint
 TF_BUILTIN(NumberParseInt, CodeStubAssembler) {
-  Node* input = Parameter(1);
-  Node* radix = Parameter(2);
-  Node* context = Parameter(5);
+  Node* context = Parameter(Descriptor::kContext);
+  Node* input = Parameter(Descriptor::kString);
+  Node* radix = Parameter(Descriptor::kRadix);
 
   // Check if {radix} is treated as 10 (i.e. undefined, 0 or 10).
   Label if_radix10(this), if_generic(this, Label::kDeferred);
@@ -332,10 +332,10 @@ TF_BUILTIN(NumberParseInt, CodeStubAssembler) {
   }
 }
 
-// ES6 section 20.1.3.7 Number.prototype.valueOf ( )
+// ES6 #sec-number.prototype.valueof
 TF_BUILTIN(NumberPrototypeValueOf, CodeStubAssembler) {
-  Node* receiver = Parameter(0);
-  Node* context = Parameter(3);
+  Node* context = Parameter(Descriptor::kContext);
+  Node* receiver = Parameter(Descriptor::kReceiver);
 
   Node* result = ToThisValue(context, receiver, PrimitiveType::kNumber,
                              "Number.prototype.valueOf");
@@ -343,9 +343,9 @@ TF_BUILTIN(NumberPrototypeValueOf, CodeStubAssembler) {
 }
 
 TF_BUILTIN(Add, CodeStubAssembler) {
-  Node* left = Parameter(0);
-  Node* right = Parameter(1);
-  Node* context = Parameter(2);
+  Node* context = Parameter(Descriptor::kContext);
+  Node* left = Parameter(Descriptor::kLeft);
+  Node* right = Parameter(Descriptor::kRight);
 
   // Shared entry for floating point addition.
   Label do_fadd(this);
@@ -686,9 +686,9 @@ TF_BUILTIN(Add, CodeStubAssembler) {
 }
 
 TF_BUILTIN(Subtract, CodeStubAssembler) {
-  Node* left = Parameter(0);
-  Node* right = Parameter(1);
-  Node* context = Parameter(2);
+  Node* context = Parameter(Descriptor::kContext);
+  Node* left = Parameter(Descriptor::kLeft);
+  Node* right = Parameter(Descriptor::kRight);
 
   // Shared entry for floating point subtraction.
   Label do_fsub(this), end(this);
@@ -845,9 +845,9 @@ TF_BUILTIN(Subtract, CodeStubAssembler) {
 }
 
 TF_BUILTIN(Multiply, CodeStubAssembler) {
-  Node* left = Parameter(0);
-  Node* right = Parameter(1);
-  Node* context = Parameter(2);
+  Node* context = Parameter(Descriptor::kContext);
+  Node* left = Parameter(Descriptor::kLeft);
+  Node* right = Parameter(Descriptor::kRight);
 
   // Shared entry point for floating point multiplication.
   Label do_fmul(this), return_result(this);
@@ -982,9 +982,9 @@ TF_BUILTIN(Multiply, CodeStubAssembler) {
 }
 
 TF_BUILTIN(Divide, CodeStubAssembler) {
-  Node* left = Parameter(0);
-  Node* right = Parameter(1);
-  Node* context = Parameter(2);
+  Node* context = Parameter(Descriptor::kContext);
+  Node* left = Parameter(Descriptor::kLeft);
+  Node* right = Parameter(Descriptor::kRight);
 
   // Shared entry point for floating point division.
   Label do_fdiv(this), end(this);
@@ -1177,9 +1177,9 @@ TF_BUILTIN(Divide, CodeStubAssembler) {
 }
 
 TF_BUILTIN(Modulus, CodeStubAssembler) {
-  Node* left = Parameter(0);
-  Node* right = Parameter(1);
-  Node* context = Parameter(2);
+  Node* context = Parameter(Descriptor::kContext);
+  Node* left = Parameter(Descriptor::kLeft);
+  Node* right = Parameter(Descriptor::kRight);
 
   Variable var_result(this, MachineRepresentation::kTagged);
   Label return_result(this, &var_result);

src/builtins/builtins-string-gen.cc

@@ -477,6 +477,8 @@ TF_BUILTIN(StringCharCodeAt, CodeStubAssembler) {
 
 // ES6 section 21.1.2.1 String.fromCharCode ( ...codeUnits )
 TF_BUILTIN(StringFromCharCode, CodeStubAssembler) {
+  // TODO(ishell): use constants from Descriptor once the JSFunction linkage
+  // arguments are reordered.
   Node* argc = Parameter(BuiltinDescriptor::kArgumentsCount);
   Node* context = Parameter(BuiltinDescriptor::kContext);
 
@@ -807,6 +809,8 @@ TF_BUILTIN(StringPrototypeIndexOf, StringBuiltinsAssembler) {
       no_argc_0(this), argc_1(this), no_argc_1(this), argc_2(this),
       fast_path(this), return_minus_1(this);
 
+  // TODO(ishell): use constants from Descriptor once the JSFunction linkage
+  // arguments are reordered.
   Node* argc = Parameter(BuiltinDescriptor::kArgumentsCount);
   Node* context = Parameter(BuiltinDescriptor::kContext);
 

src/builtins/builtins-utils-gen.h

@@ -5,6 +5,8 @@
 #ifndef V8_BUILTINS_BUILTINS_UTILS_GEN_H_
 #define V8_BUILTINS_BUILTINS_UTILS_GEN_H_
 
+#include "src/builtins/builtins-descriptors.h"
+
 namespace v8 {
 namespace internal {
 
@@ -27,6 +29,8 @@ class CodeAssemblerState;
 #define TF_BUILTIN(Name, AssemblerBase)                                 \
   class Name##Assembler : public AssemblerBase {                        \
    public:                                                              \
+    typedef Builtin_##Name##_InterfaceDescriptor Descriptor;            \
+                                                                        \
     explicit Name##Assembler(compiler::CodeAssemblerState* state)       \
         : AssemblerBase(state) {}                                       \
     void Generate##Name##Impl();                                        \

src/builtins/builtins.cc

@@ -137,7 +137,7 @@ void Builtins::SetUp(Isolate* isolate, bool create_heap_objects) {
   code = BuildAdaptor(isolate, FUNCTION_ADDR(Builtin_##Name), EXIT, \
                       kBuiltinFlags, #Name);                        \
   builtins_[index++] = code;
-#define BUILD_TFJ(Name, Argc)                                          \
+#define BUILD_TFJ(Name, Argc, ...)                                     \
   code = BuildWithCodeStubAssemblerJS(isolate, &Generate_##Name, Argc, \
                                       kBuiltinFlags, #Name);           \
   builtins_[index++] = code;

src/code-factory.cc

@@ -5,6 +5,7 @@
 #include "src/code-factory.h"
 
 #include "src/bootstrapper.h"
+#include "src/builtins/builtins-descriptors.h"
 #include "src/ic/ic.h"
 #include "src/objects-inl.h"
 
@@ -223,16 +224,10 @@ Callable CodeFactory::StringFromCharCode(Isolate* isolate) {
   return Callable(code, BuiltinDescriptor(isolate));
 }
 
-#define DECLARE_TFS(Name, Kind, Extra, InterfaceDescriptor, result_size) \
-  typedef InterfaceDescriptor##Descriptor Name##Descriptor;
-BUILTIN_LIST(IGNORE_BUILTIN, IGNORE_BUILTIN, IGNORE_BUILTIN, DECLARE_TFS,
-             IGNORE_BUILTIN, IGNORE_BUILTIN, IGNORE_BUILTIN)
-#undef DECLARE_TFS
-
-#define TFS_BUILTIN(Name)                             \
-  Callable CodeFactory::Name(Isolate* isolate) {      \
-    Handle<Code> code(isolate->builtins()->Name());   \
-    return Callable(code, Name##Descriptor(isolate)); \
+#define TFS_BUILTIN(Name)                                                 \
+  Callable CodeFactory::Name(Isolate* isolate) {                          \
+    Handle<Code> code(isolate->builtins()->Name());                       \
+    return Callable(code, Builtin_##Name##_InterfaceDescriptor(isolate)); \
   }
 
 TFS_BUILTIN(ToString)
@@ -274,6 +269,9 @@ TFS_BUILTIN(NewUnmappedArgumentsElements)
 TFS_BUILTIN(FastCloneRegExp)
 TFS_BUILTIN(FastNewClosure)
 TFS_BUILTIN(FastNewObject)
+TFS_BUILTIN(FastNewRestParameter)
+TFS_BUILTIN(FastNewSloppyArguments)
+TFS_BUILTIN(FastNewStrictArguments)
 TFS_BUILTIN(ForInFilter)
 TFS_BUILTIN(GetSuperConstructor)
 TFS_BUILTIN(LoadIC_Uninitialized)
@@ -369,24 +367,6 @@ Callable CodeFactory::FastNewFunctionContext(Isolate* isolate,
                   FastNewFunctionContextDescriptor(isolate));
 }
 
-// static
-Callable CodeFactory::FastNewRestParameter(Isolate* isolate) {
-  return Callable(isolate->builtins()->FastNewRestParameter(),
-                  FastNewRestParameterDescriptor(isolate));
-}
-
-// static
-Callable CodeFactory::FastNewSloppyArguments(Isolate* isolate) {
-  return Callable(isolate->builtins()->FastNewSloppyArguments(),
-                  FastNewRestParameterDescriptor(isolate));
-}
-
-// static
-Callable CodeFactory::FastNewStrictArguments(Isolate* isolate) {
-  return Callable(isolate->builtins()->FastNewStrictArguments(),
-                  FastNewRestParameterDescriptor(isolate));
-}
-
 // static
 Callable CodeFactory::ForInPrepare(Isolate* isolate) {
   return Callable(isolate->builtins()->ForInPrepare(),

src/v8.gyp

@@ -494,6 +494,7 @@
         'builtins/builtins-date.cc',
         'builtins/builtins-date-gen.cc',
         'builtins/builtins-debug.cc',
+        'builtins/builtins-descriptors.h',
         'builtins/builtins-error.cc',
         'builtins/builtins-forin-gen.cc',
         'builtins/builtins-forin.h',