[promises] Move PromiseFulfill to TF

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 667 matching lines @@
     Goto(&do_enqueue);
 
     Bind(&if_isnotpending);
     {
       Label if_fulfilled(this), if_rejected(this);
       Branch(SmiEqual(SmiConstant(v8::Promise::kFulfilled), thenable_status),
              &if_fulfilled, &if_rejected);
 
       Bind(&if_fulfilled);
       {
-        CallRuntime(Runtime::kPromiseFulfill, context, promise,
-                    SmiConstant(v8::Promise::kFulfilled), thenable_value);
+        PromiseFulfill(context, promise, thenable_value,
+                       v8::Promise::kFulfilled);
         PromiseSetHasHandler(promise);
         Goto(&out);
       }
 
       Bind(&if_rejected);
       {
         Label reject(this);
         Node* const has_handler = PromiseHasHandler(result);
 
         // Promise has already been rejected, but had no handler.
@@ skipping 50 matching lines @@
     Bind(&enqueue);
     // TODO(gsathya): Move this to TF
     CallRuntime(Runtime::kEnqueuePromiseResolveThenableJob, context, promise,
                 result, var_then.value());
     Goto(&out);
   }
 
   // 7.b Return FulfillPromise(promise, resolution).
   Bind(&fulfill);
   {
-    CallRuntime(Runtime::kPromiseFulfill, context, promise,
-                SmiConstant(v8::Promise::kFulfilled), result);
+    PromiseFulfill(context, promise, result, v8::Promise::kFulfilled);
     Goto(&out);
   }
 
   Bind(&if_cycle);
   {
     // 6.a Let selfResolutionError be a newly created TypeError object.
     Node* const message_id = SmiConstant(MessageTemplate::kPromiseCyclic);
     Node* const error =
         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());
     Goto(&out);
   }
 
   Bind(&out);
 }
 
+void PromiseBuiltinsAssembler::PromiseFulfill(
+    Node* context, Node* promise, Node* result,
+    v8::Promise::PromiseState status) {
+  Label do_promisereset(this);
+
+  Node* const status_smi = SmiConstant(static_cast<int>(status));
+  Node* const deferred_promise =
+      LoadObjectField(promise, JSPromise::kDeferredPromiseOffset);
+
+  GotoIf(IsUndefined(deferred_promise), &do_promisereset);
+
+  Node* const tasks =
+      status == v8::Promise::kFulfilled
+          ? LoadObjectField(promise, JSPromise::kFulfillReactionsOffset)
+          : LoadObjectField(promise, JSPromise::kRejectReactionsOffset);
+
+  Node* const deferred_on_resolve =
+      LoadObjectField(promise, JSPromise::kDeferredOnResolveOffset);
+  Node* const deferred_on_reject =
+      LoadObjectField(promise, JSPromise::kDeferredOnRejectOffset);
+
+  Node* const info = AllocatePromiseReactionJobInfo(
+      promise, result, tasks, deferred_promise, deferred_on_resolve,
+      deferred_on_reject, context);
+  CallRuntime(Runtime::kEnqueuePromiseReactionJob, context, info, status_smi);
+  Goto(&do_promisereset);
+
+  Bind(&do_promisereset);
+  {
+    StoreObjectField(promise, JSPromise::kStatusOffset, status_smi);
+    StoreObjectField(promise, JSPromise::kResultOffset, result);
+    StoreObjectFieldRoot(promise, JSPromise::kDeferredPromiseOffset,
+                         Heap::kUndefinedValueRootIndex);
+    StoreObjectFieldRoot(promise, JSPromise::kDeferredOnResolveOffset,
+                         Heap::kUndefinedValueRootIndex);
+    StoreObjectFieldRoot(promise, JSPromise::kDeferredOnRejectOffset,
+                         Heap::kUndefinedValueRootIndex);
+    StoreObjectFieldRoot(promise, JSPromise::kFulfillReactionsOffset,
+                         Heap::kUndefinedValueRootIndex);
+    StoreObjectFieldRoot(promise, JSPromise::kRejectReactionsOffset,
+                         Heap::kUndefinedValueRootIndex);
+  }
+}
+
 // ES#sec-promise-reject-functions
 // Promise Reject Functions
 BUILTIN(PromiseRejectClosure) {
   HandleScope scope(isolate);
 
   Handle<Context> context(isolate->context(), isolate);
 
   if (PromiseUtils::HasAlreadyVisited(context)) {
     return isolate->heap()->undefined_value();
   }
@@ skipping 399 matching lines @@
   Node* debug_event = Parameter(2);
   Node* context = Parameter(5);
 
   CSA_ASSERT_JS_ARGC_EQ(this, 2);
 
   Return(NewPromiseCapability(context, constructor, debug_event));
 }
 
 }  // namespace internal
 }  // namespace v8