[promises] Remove runtime call from fastpath in PromiseReject

src/builtins/builtins-promise.cc

 // Copyright 2016 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-promise.h"
 #include "src/builtins/builtins-constructor.h"
 #include "src/builtins/builtins-utils.h"
 #include "src/builtins/builtins.h"
 #include "src/code-factory.h"
 #include "src/code-stub-assembler.h"
@@ skipping 730 matching lines @@
         Node* const has_handler = PromiseHasHandler(result);
 
         // Promise has already been rejected, but had no handler.
         // Revoke previously triggered reject event.
         GotoIf(has_handler, &reject);
         CallRuntime(Runtime::kPromiseRevokeReject, context, result);
         Goto(&reject);
 
         Bind(&reject);
         // Don't cause a debug event as this case is forwarding a rejection
-        CallRuntime(Runtime::kPromiseReject, context, promise, thenable_value,
-                    FalseConstant());
+        InternalPromiseReject(context, promise, thenable_value,
+                              FalseConstant());
         PromiseSetHasHandler(result);
         Goto(&out);
       }
     }
   }
 
   Bind(&if_notnativepromise);
   {
     // 8. Let then be Get(resolution, "then").
     Node* const then_str = HeapConstant(isolate->factory()->then_string());
@@ skipping 66 matching lines @@
         CallRuntime(Runtime::kNewTypeError, context, message_id, result);
     var_reason.Bind(error);
 
     // 6.b Return RejectPromise(promise, selfResolutionError).
     Goto(&if_rejectpromise);
   }
 
   // 9.a Return RejectPromise(promise, then.[[Value]]).
   Bind(&if_rejectpromise);
   {
-    CallRuntime(Runtime::kPromiseReject, context, promise, var_reason.value(),
-                TrueConstant());
+    InternalPromiseReject(context, promise, var_reason.value(), TrueConstant());
     Goto(&out);
   }
 
   Bind(&out);
 }
 
 void PromiseBuiltinsAssembler::PromiseFulfill(
     Node* context, Node* promise, Node* result,
     v8::Promise::PromiseState status) {
   Label do_promisereset(this), debug_async_event_enqueue_recurring(this);
@@ skipping 85 matching lines @@
   {
     Branch(WordEqual(CallRuntime(Runtime::kAllowDynamicFunction, context,
                                  promise_constructor),
                      BooleanConstant(true)),
            &has_access, if_noaccess);
   }
 
   Bind(&has_access);
 }
 
+// This duplicates a lot of logic from PromiseRejectEvent in
+// runtime-promise.cc
+void PromiseBuiltinsAssembler::InternalPromiseReject(Node* context,
+                                                     Node* promise, Node* value,
+                                                     Node* debug_event) {
+  Label fulfill(this), report_unhandledpromise(this), run_debughandler(this),
+      run_promise_hook(this, Label::kDeferred);
+  Branch(IsPromiseHookEnabled(), &run_promise_hook, &run_debughandler);
+
+  Bind(&run_promise_hook);
+  {
+    CallRuntime(Runtime::kPromiseHookResolve, context, promise);
+    Goto(&run_debughandler);
+  }
+
+  Bind(&run_debughandler);
+  {
+    GotoUnless(IsDebugActive(), &report_unhandledpromise);
+    GotoUnless(WordEqual(debug_event, TrueConstant()),
+               &report_unhandledpromise);
+    CallRuntime(Runtime::kDebugPromiseReject, context, promise, value);
+    Goto(&report_unhandledpromise);
+  }
+
+  Bind(&report_unhandledpromise);
+  {
+    GotoIf(PromiseHasHandler(promise), &fulfill);
+    CallRuntime(Runtime::kReportPromiseReject, context, promise, value);
+    Goto(&fulfill);
+  }
+
+  Bind(&fulfill);
+  PromiseFulfill(context, promise, value, v8::Promise::kRejected);
+}
+
 // ES#sec-promise-reject-functions
 // Promise Reject Functions
 TF_BUILTIN(PromiseRejectClosure, PromiseBuiltinsAssembler) {
   Node* const value = Parameter(1);
   Node* const context = Parameter(4);
 
   Label out(this);
 
   // 3. Let alreadyResolved be F.[[AlreadyResolved]].
   int has_already_visited_slot = PromiseUtils::kAlreadyVisitedSlot;
 
   Node* const has_already_visited =
       LoadContextElement(context, has_already_visited_slot);
 
   // 4. If alreadyResolved.[[Value]] is true, return undefined.
   GotoIf(SmiEqual(has_already_visited, SmiConstant(1)), &out);
 
   // 5.Set alreadyResolved.[[Value]] to true.
   StoreContextElementNoWriteBarrier(context, has_already_visited_slot,
                                     SmiConstant(1));
 
   // 2. Let promise be F.[[Promise]].
   Node* const promise =
       LoadContextElement(context, IntPtrConstant(PromiseUtils::kPromiseSlot));
   Node* const debug_event = LoadContextElement(
       context, IntPtrConstant(PromiseUtils::kDebugEventSlot));
 
-  CallRuntime(Runtime::kPromiseReject, context, promise, value, debug_event);
+  InternalPromiseReject(context, promise, value, debug_event);

[Igor Sheludko, 2017/01/16 11:43:18]

This is the only case where debug_event value is really dynamic. I think it
would be nice to avoid unnecessary checks for the cases where the debug value is
known statically.

[gsathya, 2017/01/17 06:33:18]

There's another dynamic call in TF_BUILTIN(InternalPromiseReject). 

I've split this function into two, lmk if this is better.

   Return(UndefinedConstant());
 
   Bind(&out);
   Return(UndefinedConstant());
 }
 
 TF_BUILTIN(PromiseConstructor, PromiseBuiltinsAssembler) {
   Node* const executor = Parameter(1);
   Node* const new_target = Parameter(2);
   Node* const context = Parameter(4);
@@ skipping 216 matching lines @@
   Node* const context = Parameter(Descriptor::kContext);
 
   Callable call_callable = CodeFactory::Call(isolate());
   Variable var_unused(this, MachineRepresentation::kTagged);
 
   Label if_internalhandler(this), if_customhandler(this, Label::kDeferred);
   Branch(IsUndefined(on_reject), &if_internalhandler, &if_customhandler);
 
   Bind(&if_internalhandler);
   {
-    CallRuntime(Runtime::kPromiseReject, context, promise, exception,
-                FalseConstant());
+    InternalPromiseReject(context, promise, exception, FalseConstant());
     Return(UndefinedConstant());
   }
 
   Bind(&if_customhandler);
   {
     CallJS(call_callable, context, on_reject, UndefinedConstant(), exception);
     Return(UndefinedConstant());
   }
 }
 
@@ skipping 275 matching lines @@
     Callable call_callable = CodeFactory::Call(isolate());
     CallJS(call_callable, context, reject, UndefinedConstant(), reason);
 
     // 5. Return promiseCapability.[[Promise]].
     Node* const promise =
         LoadObjectField(capability, JSPromiseCapability::kPromiseOffset);
     Return(promise);
   }
 }
 
+TF_BUILTIN(InternalPromiseReject, PromiseBuiltinsAssembler) {
+  Node* const promise = Parameter(1);
+  Node* const reason = Parameter(2);
+  Node* const debug_event = Parameter(3);
+  Node* const context = Parameter(6);
+
+  InternalPromiseReject(context, promise, reason, debug_event);
+  Return(UndefinedConstant());
+}
+
 }  // namespace internal
 }  // namespace v8