[promises] port NewPromiseCapability 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 13 matching lines @@
 
   Label out(this);
   GotoUnless(IsPromiseHookEnabled(), &out);
   CallRuntime(Runtime::kPromiseHookInit, context, instance, parent);
   Goto(&out);
 
   Bind(&out);
   return instance;
 }
 
-Node* PromiseBuiltinsAssembler::CreatePromiseResolvingFunctionsContext(
+std::pair<Node*, Node*>
+PromiseBuiltinsAssembler::CreatePromiseResolvingFunctions(
     Node* promise, Node* debug_event, Node* native_context) {
-  Node* const context =
-      Allocate(FixedArray::SizeFor(PromiseUtils::kPromiseContextLength));
+  Node* const promise_context = CreatePromiseResolvingFunctionsContext(
+      promise, debug_event, native_context);
+  Node* const map = LoadContextElement(
+      native_context, Context::STRICT_FUNCTION_WITHOUT_PROTOTYPE_MAP_INDEX);
+  Node* const resolve_info =
+      LoadContextElement(native_context, Context::PROMISE_RESOLVE_SHARED_FUN);
+  Node* const resolve =
+      AllocateFunctionWithMapAndContext(map, resolve_info, promise_context);
+  Node* const reject_info =
+      LoadContextElement(native_context, Context::PROMISE_REJECT_SHARED_FUN);
+  Node* const reject =
+      AllocateFunctionWithMapAndContext(map, reject_info, promise_context);
+  return std::make_pair(resolve, reject);
+}
+
+Node* PromiseBuiltinsAssembler::NewPromiseCapability(Node* context,
+                                                     Node* constructor,
+                                                     Node* debug_event) {
+  if (debug_event == nullptr) {
+    debug_event = TrueConstant();
+  }
+
+  Node* native_context = LoadNativeContext(context);
+
+  Node* map = LoadRoot(Heap::kJSPromiseCapabilityMapRootIndex);
+  Node* capability = AllocateJSObjectFromMap(map);
+
+  StoreObjectFieldNoWriteBarrier(
+      capability, JSPromiseCapability::kPromiseOffset, UndefinedConstant());
+  StoreObjectFieldNoWriteBarrier(
+      capability, JSPromiseCapability::kResolveOffset, UndefinedConstant());
+  StoreObjectFieldNoWriteBarrier(capability, JSPromiseCapability::kRejectOffset,
+                                 UndefinedConstant());
+
+  Variable var_result(this, MachineRepresentation::kTagged);
+  var_result.Bind(capability);
+
+  Label if_builtin_promise(this), if_custom_promise(this, Label::kDeferred),
+      out(this);
+  Branch(WordEqual(constructor,
+                   LoadContextElement(native_context,
+                                      Context::PROMISE_FUNCTION_INDEX)),
+         &if_builtin_promise, &if_custom_promise);
+
+  Bind(&if_builtin_promise);
+  {
+    Node* promise = AllocateJSPromise(context);
+    PromiseInit(promise);
+    StoreObjectFieldNoWriteBarrier(
+        capability, JSPromiseCapability::kPromiseOffset, promise);
+
+    Node* resolve = nullptr;
+    Node* reject = nullptr;
+
+    std::tie(resolve, reject) =
+        CreatePromiseResolvingFunctions(promise, debug_event, native_context);
+    StoreObjectField(capability, JSPromiseCapability::kResolveOffset, resolve);
+    StoreObjectField(capability, JSPromiseCapability::kRejectOffset, reject);
+
+    GotoUnless(IsPromiseHookEnabled(), &out);
+    CallRuntime(Runtime::kPromiseHookInit, context, promise,
+                UndefinedConstant());
+    Goto(&out);
+  }
+
+  Bind(&if_custom_promise);
+  {
+    Label if_notcallable(this, Label::kDeferred);
+    Node* executor_context =
+        CreatePromiseGetCapabilitiesExecutorContext(capability, native_context);
+    Node* executor_info = LoadContextElement(
+        native_context, Context::PROMISE_GET_CAPABILITIES_EXECUTOR_SHARED_FUN);
+    Node* function_map = LoadContextElement(
+        native_context, Context::STRICT_FUNCTION_WITHOUT_PROTOTYPE_MAP_INDEX);
+    Node* executor = AllocateFunctionWithMapAndContext(
+        function_map, executor_info, executor_context);
+
+    Node* promise = ConstructJS(CodeFactory::Construct(isolate()), context,
+                                constructor, executor);
+
+    Node* resolve =
+        LoadObjectField(capability, JSPromiseCapability::kResolveOffset);
+    GotoIf(TaggedIsSmi(resolve), &if_notcallable);
+    GotoUnless(IsCallableMap(LoadMap(resolve)), &if_notcallable);
+
+    Node* reject =
+        LoadObjectField(capability, JSPromiseCapability::kRejectOffset);
+    GotoIf(TaggedIsSmi(reject), &if_notcallable);
+    GotoUnless(IsCallableMap(LoadMap(reject)), &if_notcallable);
+
+    StoreObjectField(capability, JSPromiseCapability::kPromiseOffset, promise);
+
+    Goto(&out);
+
+    Bind(&if_notcallable);
+    Node* message = SmiConstant(MessageTemplate::kPromiseNonCallable);
+    StoreObjectField(capability, JSPromiseCapability::kPromiseOffset,
+                     UndefinedConstant());
+    StoreObjectField(capability, JSPromiseCapability::kResolveOffset,
+                     UndefinedConstant());
+    StoreObjectField(capability, JSPromiseCapability::kRejectOffset,
+                     UndefinedConstant());
+    CallRuntime(Runtime::kThrowTypeError, context, message);
+    var_result.Bind(UndefinedConstant());
+    Goto(&out);
+  }
+
+  Bind(&out);
+  return var_result.value();
+}
+
+Node* PromiseBuiltinsAssembler::CreatePromiseContext(Node* native_context,
+                                                     int slots) {
+  DCHECK_GE(slots, Context::MIN_CONTEXT_SLOTS);
+
+  Node* const context = Allocate(FixedArray::SizeFor(slots));
   StoreMapNoWriteBarrier(context, Heap::kFunctionContextMapRootIndex);
-  StoreObjectFieldNoWriteBarrier(
-      context, FixedArray::kLengthOffset,
-      SmiConstant(PromiseUtils::kPromiseContextLength));
+  StoreObjectFieldNoWriteBarrier(context, FixedArray::kLengthOffset,
+                                 SmiConstant(slots));
 
   Node* const empty_fn =
       LoadContextElement(native_context, Context::CLOSURE_INDEX);
   StoreContextElementNoWriteBarrier(context, Context::CLOSURE_INDEX, empty_fn);
   StoreContextElementNoWriteBarrier(context, Context::PREVIOUS_INDEX,
                                     UndefinedConstant());
   StoreContextElementNoWriteBarrier(context, Context::EXTENSION_INDEX,
                                     TheHoleConstant());
   StoreContextElementNoWriteBarrier(context, Context::NATIVE_CONTEXT_INDEX,
                                     native_context);
+  return context;
+}
+
+Node* PromiseBuiltinsAssembler::CreatePromiseResolvingFunctionsContext(
+    Node* promise, Node* debug_event, Node* native_context) {
+  Node* const context =
+      CreatePromiseContext(native_context, PromiseUtils::kPromiseContextLength);
   StoreContextElementNoWriteBarrier(context, PromiseUtils::kAlreadyVisitedSlot,
                                     SmiConstant(0));
   StoreContextElementNoWriteBarrier(context, PromiseUtils::kPromiseSlot,
                                     promise);
   StoreContextElementNoWriteBarrier(context, PromiseUtils::kDebugEventSlot,
                                     debug_event);
   return context;
 }
 
-std::pair<Node*, Node*>
-PromiseBuiltinsAssembler::CreatePromiseResolvingFunctions(
-    Node* promise, Node* debug_event, Node* native_context) {
-  Node* const promise_context = CreatePromiseResolvingFunctionsContext(
-      promise, debug_event, native_context);
-  Node* const map = LoadContextElement(
-      native_context, Context::STRICT_FUNCTION_WITHOUT_PROTOTYPE_MAP_INDEX);
-  Node* const resolve_info =
-      LoadContextElement(native_context, Context::PROMISE_RESOLVE_SHARED_FUN);
-  Node* const resolve =
-      AllocateFunctionWithMapAndContext(map, resolve_info, promise_context);
-  Node* const reject_info =
-      LoadContextElement(native_context, Context::PROMISE_REJECT_SHARED_FUN);
-  Node* const reject =
-      AllocateFunctionWithMapAndContext(map, reject_info, promise_context);
-
-  return std::make_pair(resolve, reject);
+Node* PromiseBuiltinsAssembler::CreatePromiseGetCapabilitiesExecutorContext(
+    Node* promise_capability, Node* native_context) {
+  int kContextLength = GetPromiseCapabilityExecutor::kContextLength;
+  Node* context = CreatePromiseContext(native_context, kContextLength);
+  StoreContextElementNoWriteBarrier(
+      context, GetPromiseCapabilityExecutor::kCapabilitySlot,
+      promise_capability);
+  return context;
 }
 
 Node* PromiseBuiltinsAssembler::ThrowIfNotJSReceiver(
     Node* context, Node* value, MessageTemplate::Template msg_template) {
   Label out(this), throw_exception(this, Label::kDeferred);
   Variable var_value_map(this, MachineRepresentation::kTagged);
 
   GotoIf(TaggedIsSmi(value), &throw_exception);
 
   // Load the instance type of the {value}.
@@ skipping 139 matching lines @@
   {
     Node* const deferred_promise = AllocateAndInitPromise(context, promise);
     var_deferred_promise.Bind(deferred_promise);
     var_deferred_on_resolve.Bind(UndefinedConstant());
     var_deferred_on_reject.Bind(UndefinedConstant());
     Goto(&perform_promise_then);
   }
 
   Bind(&promise_capability);
   {
-    // TODO(gsathya): Move this to TF.
-    Node* const new_promise_capability = LoadContextElement(
-        native_context, Context::NEW_PROMISE_CAPABILITY_INDEX);
-    Node* const deferred =
-        CallJS(call_callable, context, new_promise_capability,
-               UndefinedConstant(), constructor);
-    Callable getproperty_callable = CodeFactory::GetProperty(isolate);
-    Node* key = HeapConstant(isolate->factory()->promise_string());
-    Node* const deferred_promise =
-        CallStub(getproperty_callable, context, deferred, key);
-    var_deferred_promise.Bind(deferred_promise);
-
-    key = HeapConstant(isolate->factory()->resolve_string());
-    Node* const deferred_on_resolve =
-        CallStub(getproperty_callable, context, deferred, key);
-    var_deferred_on_resolve.Bind(deferred_on_resolve);
-
-    key = HeapConstant(isolate->factory()->reject_string());
-    Node* const deferred_on_reject =
-        CallStub(getproperty_callable, context, deferred, key);
-    var_deferred_on_reject.Bind(deferred_on_reject);
-
+    Node* const capability = NewPromiseCapability(context, constructor);
+    var_deferred_promise.Bind(
+        LoadObjectField(capability, JSPromiseCapability::kPromiseOffset));
+    var_deferred_on_resolve.Bind(
+        LoadObjectField(capability, JSPromiseCapability::kResolveOffset));
+    var_deferred_on_reject.Bind(
+        LoadObjectField(capability, JSPromiseCapability::kRejectOffset));
     Goto(&perform_promise_then);
   }
 
   // 5. Return PerformPromiseThen(promise, onFulfilled, onRejected,
   //    resultCapability).
   Bind(&perform_promise_then);
   Node* const result = InternalPerformPromiseThen(
       context, promise, on_resolve, on_reject, var_deferred_promise.value(),
       var_deferred_on_resolve.value(), var_deferred_on_reject.value());
   return result;
@@ skipping 395 matching lines @@
       handle(PromiseUtils::GetDebugEvent(context), isolate);
   MaybeHandle<Object> maybe_result;
   Handle<Object> argv[] = {promise, value, debug_event};
   RETURN_FAILURE_ON_EXCEPTION(
       isolate, Execution::Call(isolate, isolate->promise_internal_reject(),
                                isolate->factory()->undefined_value(),
                                arraysize(argv), argv));
   return isolate->heap()->undefined_value();
 }
 
-// ES#sec-createresolvingfunctions
-// CreateResolvingFunctions ( promise )
-TF_BUILTIN(CreateResolvingFunctions, PromiseBuiltinsAssembler) {
-  Node* const promise = Parameter(1);
-  Node* const debug_event = Parameter(2);
-  Node* const context = Parameter(5);
-  Node* const native_context = LoadNativeContext(context);
-
-  Node* resolve = nullptr;
-  Node* reject = nullptr;
-
-  std::tie(resolve, reject) =
-      CreatePromiseResolvingFunctions(promise, debug_event, native_context);
-
-  Node* const kSize = IntPtrConstant(2);
-  const ElementsKind kind = FAST_ELEMENTS;
-  const WriteBarrierMode barrier_mode = SKIP_WRITE_BARRIER;
-  const ParameterMode parameter_mode = INTPTR_PARAMETERS;
-  Node* const arr = AllocateFixedArray(kind, kSize, parameter_mode);
-  StoreFixedArrayElement(arr, 0, resolve, barrier_mode);
-  StoreFixedArrayElement(arr, 1, reject, barrier_mode);
-
-  Node* const array_map = LoadJSArrayElementsMap(kind, native_context);
-  Node* const length = SmiTag(kSize);
-  Node* const result = AllocateUninitializedJSArrayWithoutElements(
-      kind, array_map, length, nullptr);
-
-  StoreObjectField(result, JSObject::kElementsOffset, arr);
-  Return(result);
-}
-
 TF_BUILTIN(PromiseConstructor, PromiseBuiltinsAssembler) {
   Node* const executor = Parameter(1);
   Node* const new_target = Parameter(2);
   Node* const context = Parameter(4);
   Isolate* isolate = this->isolate();
 
   Label if_targetisundefined(this, Label::kDeferred);
 
   GotoIf(IsUndefined(new_target), &if_targetisundefined);
 
@@ skipping 347 matching lines @@
     Callable getproperty_callable = CodeFactory::GetProperty(isolate);
     Node* const then =
         CallStub(getproperty_callable, context, promise, then_str);
     Callable call_callable = CodeFactory::Call(isolate);
     Node* const result =
         CallJS(call_callable, context, then, promise, on_resolve, on_reject);
     Return(result);
   }
 }
 
+TF_BUILTIN(PromiseGetCapabilitiesExecutor, PromiseBuiltinsAssembler) {
+  Node* const resolve = Parameter(1);
+  Node* const reject = Parameter(2);
+  Node* const context = Parameter(5);
+
+  Node* const capability = LoadContextElement(
+      context, GetPromiseCapabilityExecutor::kCapabilitySlot);
+
+  Label if_alreadyinvoked(this, Label::kDeferred);
+  GotoIf(WordNotEqual(
+             LoadObjectField(capability, JSPromiseCapability::kResolveOffset),
+             UndefinedConstant()),
+         &if_alreadyinvoked);
+  GotoIf(WordNotEqual(
+             LoadObjectField(capability, JSPromiseCapability::kRejectOffset),
+             UndefinedConstant()),
+         &if_alreadyinvoked);
+
+  StoreObjectField(capability, JSPromiseCapability::kResolveOffset, resolve);
+  StoreObjectField(capability, JSPromiseCapability::kRejectOffset, reject);
+
+  Return(UndefinedConstant());
+
+  Bind(&if_alreadyinvoked);
+  Node* message = SmiConstant(MessageTemplate::kPromiseExecutorAlreadyInvoked);
+  Return(CallRuntime(Runtime::kThrowTypeError, context, message));
+}
+
+TF_BUILTIN(NewPromiseCapability, PromiseBuiltinsAssembler) {
+  Node* constructor = Parameter(1);
+  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