[esnext] prototype runtime implementation for async functions

src/builtins.cc

 // Copyright 2012 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.h"
 
 #include "src/api-arguments.h"
 #include "src/api-natives.h"
 #include "src/api.h"
 #include "src/base/once.h"
@@ skipping 2347 matching lines @@
 // ES6 section 20.2.2.35 Math.trunc ( x )
 void Builtins::Generate_MathTrunc(CodeStubAssembler* assembler) {
   Generate_MathRoundingOperation(assembler, &CodeStubAssembler::Float64Trunc);
 }
 
 // -----------------------------------------------------------------------------
 // ES6 section 25.3 Generator Objects
 
 namespace {
 
+enum class ResumeType { Generator, Async };
+
 void Generate_GeneratorPrototypeResume(

[Benedikt Meurer, 2016/05/02 02:16:47]

Please don't hijack this helper function for async resume. The core
functionality is already isolated in the ResumeGenerator builtin, so all you
need for AsyncFunction prototype is a thin wrapper around that. I'd even suggest
to introduce AsyncFunctionAwaitStub with two modes (Fullfilled, Rejected) and
use them to implement %_AsyncFunctionAwaitFulfilled and
%_AsyncFunctionAwaitRejected in your .js file.

[caitp (gmail), 2016/05/02 14:45:46]

See the comment on this file in one of the earlier patchsets --- it states that
the changes in builtins.h and builtins.cc are unnecessary, and will be pulled
out later :)

I'm not sure if new codestubs are really needed though, since just reusing the
generator functions is plenty. Are you saying you'd actually prefer code stubs
specifically for AsyncFunctionAwait, rather than the current approach of arrow
functions which call GeneratorNext / GeneratorThrow ?

     CodeStubAssembler* assembler, JSGeneratorObject::ResumeMode resume_mode,
-    char const* const method_name) {
+    char const* const method_name, ResumeType type) {
   typedef CodeStubAssembler::Label Label;
   typedef compiler::Node Node;
 
   Node* receiver = assembler->Parameter(0);
   Node* value = assembler->Parameter(1);
   Node* context = assembler->Parameter(4);
   Node* closed = assembler->SmiConstant(
       Smi::FromInt(JSGeneratorObject::kGeneratorClosed));
 
   // Check if the {receiver} is actually a JSGeneratorObject.
   Label if_receiverisincompatible(assembler, Label::kDeferred);
-  assembler->GotoIf(assembler->WordIsSmi(receiver), &if_receiverisincompatible);
-  Node* receiver_instance_type = assembler->LoadInstanceType(receiver);
-  assembler->GotoUnless(assembler->Word32Equal(
-                            receiver_instance_type,
-                            assembler->Int32Constant(JS_GENERATOR_OBJECT_TYPE)),
-                        &if_receiverisincompatible);
+  if (type == ResumeType::Generator || FLAG_debug_code) {
+    assembler->GotoIf(assembler->WordIsSmi(receiver),
+                      &if_receiverisincompatible);
+    Node* receiver_instance_type = assembler->LoadInstanceType(receiver);
+    assembler->GotoUnless(assembler->Word32Equal(receiver_instance_type,
+                                                 assembler->Int32Constant(
+                                                     JS_GENERATOR_OBJECT_TYPE)),
+                          &if_receiverisincompatible);
+  }
 
   // Check if the {receiver} is running or already closed.
   Node* receiver_continuation = assembler->LoadObjectField(
       receiver, JSGeneratorObject::kContinuationOffset);
   Label if_receiverisclosed(assembler, Label::kDeferred),
       if_receiverisrunning(assembler, Label::kDeferred);
-  assembler->GotoIf(assembler->SmiEqual(receiver_continuation, closed),
-                    &if_receiverisclosed);
-  DCHECK_LT(JSGeneratorObject::kGeneratorExecuting,
-            JSGeneratorObject::kGeneratorClosed);
-  assembler->GotoIf(assembler->SmiLessThan(receiver_continuation, closed),
-                    &if_receiverisrunning);
+  if (type == ResumeType::Generator || FLAG_debug_code) {
+    assembler->GotoIf(assembler->SmiEqual(receiver_continuation, closed),
+                      &if_receiverisclosed);
+    DCHECK_LT(JSGeneratorObject::kGeneratorExecuting,
+              JSGeneratorObject::kGeneratorClosed);
+    assembler->GotoIf(assembler->SmiLessThan(receiver_continuation, closed),
+                      &if_receiverisrunning);
+  }
 
   // Resume the {receiver} using our trampoline.
   Node* result = assembler->CallStub(
       CodeFactory::ResumeGenerator(assembler->isolate()), context, value,
       receiver, assembler->SmiConstant(Smi::FromInt(resume_mode)));
   assembler->Return(result);
 
   assembler->Bind(&if_receiverisincompatible);
-  {
+  if (type == ResumeType::Generator || FLAG_debug_code) {
     // The {receiver} is not a valid JSGeneratorObject.
     Node* result = assembler->CallRuntime(
         Runtime::kThrowIncompatibleMethodReceiver, context,
         assembler->HeapConstant(assembler->factory()->NewStringFromAsciiChecked(
             method_name, TENURED)),
         receiver);
     assembler->Return(result);  // Never reached.
   }
 
-  assembler->Bind(&if_receiverisclosed);
-  {
+  if (type == ResumeType::Generator || FLAG_debug_code) {
+    assembler->Bind(&if_receiverisclosed);
     // The {receiver} is closed already.
     Node* result = nullptr;
     switch (resume_mode) {
       case JSGeneratorObject::kNext:
         result = assembler->CallRuntime(Runtime::kCreateIterResultObject,
                                         context, assembler->UndefinedConstant(),
                                         assembler->BooleanConstant(true));
         break;
       case JSGeneratorObject::kReturn:
         result =
             assembler->CallRuntime(Runtime::kCreateIterResultObject, context,
                                    value, assembler->BooleanConstant(true));
         break;
       case JSGeneratorObject::kThrow:
         result = assembler->CallRuntime(Runtime::kThrow, context, value);
         break;
     }
     assembler->Return(result);
   }
 
-  assembler->Bind(&if_receiverisrunning);
-  {
+  if (type == ResumeType::Generator || FLAG_debug_code) {
+    assembler->Bind(&if_receiverisrunning);
     Node* result =
         assembler->CallRuntime(Runtime::kThrowGeneratorRunning, context);
     assembler->Return(result);  // Never reached.
   }
 }
 
 }  // namespace
 
 // ES6 section 25.3.1.2 Generator.prototype.next ( value )
 void Builtins::Generate_GeneratorPrototypeNext(CodeStubAssembler* assembler) {
   Generate_GeneratorPrototypeResume(assembler, JSGeneratorObject::kNext,
-                                    "[Generator].prototype.next");
+                                    "[Generator].prototype.next",
+                                    ResumeType::Generator);
 }
 
 // ES6 section 25.3.1.3 Generator.prototype.return ( value )
 void Builtins::Generate_GeneratorPrototypeReturn(CodeStubAssembler* assembler) {
   Generate_GeneratorPrototypeResume(assembler, JSGeneratorObject::kReturn,
-                                    "[Generator].prototype.return");
+                                    "[Generator].prototype.return",
+                                    ResumeType::Generator);
 }
 
 // ES6 section 25.3.1.4 Generator.prototype.throw ( exception )
 void Builtins::Generate_GeneratorPrototypeThrow(CodeStubAssembler* assembler) {
   Generate_GeneratorPrototypeResume(assembler, JSGeneratorObject::kThrow,
-                                    "[Generator].prototype.throw");
+                                    "[Generator].prototype.throw",
+                                    ResumeType::Generator);
+}
+
+void Builtins::Generate_AsyncFunctionNext(CodeStubAssembler* assembler) {
+  Generate_GeneratorPrototypeResume(assembler, JSGeneratorObject::kNext,
+                                    "[AsyncFunction].next", ResumeType::Async);
+}
+
+void Builtins::Generate_AsyncFunctionThrow(CodeStubAssembler* assembler) {
+  Generate_GeneratorPrototypeResume(assembler, JSGeneratorObject::kThrow,
+                                    "[AsyncFunction].throw", ResumeType::Async);
 }
 
 // -----------------------------------------------------------------------------
 // ES6 section 26.1 The Reflect Object
 
 // ES6 section 26.1.3 Reflect.defineProperty
 BUILTIN(ReflectDefineProperty) {
   HandleScope scope(isolate);
   DCHECK_EQ(4, args.length());
   Handle<Object> target = args.at<Object>(1);
@@ skipping 2919 matching lines @@
 BUILTIN_LIST_T(DEFINE_BUILTIN_ACCESSOR_T)
 BUILTIN_LIST_H(DEFINE_BUILTIN_ACCESSOR_H)
 BUILTIN_LIST_DEBUG_A(DEFINE_BUILTIN_ACCESSOR_A)
 #undef DEFINE_BUILTIN_ACCESSOR_C
 #undef DEFINE_BUILTIN_ACCESSOR_A
 #undef DEFINE_BUILTIN_ACCESSOR_T
 #undef DEFINE_BUILTIN_ACCESSOR_H
 
 }  // namespace internal
 }  // namespace v8