[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-utils.h"
 #include "src/builtins/builtins.h"
 #include "src/code-factory.h"
 #include "src/code-stub-assembler.h"
 #include "src/promise-utils.h"
 
 namespace v8 {
 namespace internal {
 
 typedef compiler::Node Node;
 typedef CodeStubAssembler::ParameterMode ParameterMode;
 typedef compiler::CodeAssemblerState CodeAssemblerState;
 
-Node* PromiseBuiltinsAssembler::CreatePromiseResolvingFunctionsContext(
-    Node* promise, Node* debug_event, Node* native_context) {
-  Node* const context =
-      Allocate(FixedArray::SizeFor(PromiseUtils::kPromiseContextLength));
-  StoreMapNoWriteBarrier(context, Heap::kFunctionContextMapRootIndex);
+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(
-      context, FixedArray::kLengthOffset,
-      SmiConstant(PromiseUtils::kPromiseContextLength));
+      capability, JSPromiseCapability::kPromiseOffset, UndefinedConstant());
+  StoreObjectFieldNoWriteBarrier(
+      capability, JSPromiseCapability::kResolveOffset, UndefinedConstant());
+  StoreObjectFieldNoWriteBarrier(capability, JSPromiseCapability::kRejectOffset,
+                                 UndefinedConstant());
 
-  Node* const empty_fn =
-      LoadContextElement(native_context, Context::CLOSURE_INDEX);
-  StoreContextElementNoWriteBarrier(context, Context::CLOSURE_INDEX, empty_fn);
+  Variable var_result(this, MachineRepresentation::kTagged);
+  var_result.Bind(capability);
+
+  Label if_builtin_promise(this), if_custom_promise(this), out(this);

[gsathya, 2016/12/29 21:48:47]

if_custom_promise can be deferred 

+  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::NewInternalPromiseCapability(Node* context,
+                                                             Node* parent) {
+  Node* promise = AllocateJSPromise(context);
+  PromiseInit(promise);
+
+  Label out(this);
+
+  Node* map = LoadRoot(Heap::kJSPromiseCapabilityMapRootIndex);
+  Node* capability = AllocateJSObjectFromMap(map);
+  StoreObjectFieldNoWriteBarrier(capability,
+                                 JSPromiseCapability::kPromiseOffset, promise);
+  StoreObjectFieldNoWriteBarrier(
+      capability, JSPromiseCapability::kResolveOffset, UndefinedConstant());
+  StoreObjectFieldNoWriteBarrier(capability, JSPromiseCapability::kRejectOffset,
+                                 UndefinedConstant());
+
+  GotoUnless(IsPromiseHookEnabled(), &out);
+  CallRuntime(Runtime::kPromiseHookInit, context, promise, parent);
+  Goto(&out);
+
+  Bind(&out);
+  return capability;
+}
+
+Node* PromiseBuiltinsAssembler::CreatePromiseContext(Node* native_context,
+                                                     int slots) {
+  DCHECK_GE(slots, Context::MIN_CONTEXT_SLOTS);
+  Node* script = LoadContextElement(native_context, Context::CLOSURE_INDEX);
+  Node* map = HeapConstant(isolate()->factory()->function_context_map());
+  Node* context = Allocate(FixedArray::SizeFor(slots));
+  StoreMapNoWriteBarrier(context, map);
+  StoreObjectFieldNoWriteBarrier(context, FixedArray::kLengthOffset,
+                                 SmiConstant(slots));
+  StoreContextElementNoWriteBarrier(context, Context::CLOSURE_INDEX, script);
   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;
 }
 
+Node* PromiseBuiltinsAssembler::CreatePromiseGetCapabilitiesExecutorContext(
+    Node* promise_capability, Node* native_context) {
+  int kSize = GetPromiseCapabilityExecutor::kContextLength;
+  Node* context = CreatePromiseContext(native_context, kSize);
+  StoreContextElementNoWriteBarrier(
+      context, GetPromiseCapabilityExecutor::kCapabilitySlot,
+      promise_capability);
+  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 =
@@ skipping 143 matching lines @@
 
   // 4. Let resultCapability be ? NewPromiseCapability(C).
   Callable call_callable = CodeFactory::Call(isolate);
   Label fast_promise_capability(this), promise_capability(this),
       perform_promise_then(this);
   Variable var_deferred(this, MachineRepresentation::kTagged);
 
   Branch(WordEqual(promise_fun, constructor), &fast_promise_capability,
          &promise_capability);
 
-  // TODO(gsathya): Remove deferred object and move
-  // NewPromiseCapabability functions to TF.
+  // TODO(gsathya): Remove deferred object.
   Bind(&fast_promise_capability);
   {
-    // TODO(gsathya): Move this to TF.
-    Node* const promise_internal_capability = LoadContextElement(
-        native_context, Context::INTERNAL_PROMISE_CAPABILITY_INDEX);
-    Node* const capability =
-        CallJS(call_callable, context, promise_internal_capability,
-               UndefinedConstant(), promise);
+    Node* const capability = NewInternalPromiseCapability(context, promise);
     var_deferred.Bind(capability);
     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 capability =
-        CallJS(call_callable, context, new_promise_capability,
-               UndefinedConstant(), constructor);
+    Node* const capability = NewPromiseCapability(context, constructor);
     var_deferred.Bind(capability);
     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.value());
   return result;
@@ skipping 149 matching lines @@
 
           Goto(&out);
         }
       }
     }
   }
 
   Bind(&out);
   PromiseSetHasHandler(promise);
 
-  // TODO(gsathya): This call will be removed once we don't have to
-  // deal with deferred objects.
-  Isolate* isolate = this->isolate();
-  Callable getproperty_callable = CodeFactory::GetProperty(isolate);
-  Node* const key =
-      HeapConstant(isolate->factory()->NewStringFromAsciiChecked("promise"));
-  Node* const result = CallStub(getproperty_callable, context, deferred, key);
-
-  return result;
+  CSA_ASSERT(this, HasInstanceType(deferred, JS_PROMISE_CAPABILITY_TYPE));
+  Node* then_promise =
+      LoadObjectField(deferred, JSPromiseCapability::kPromiseOffset);
+  return then_promise;
 }
 
 // Promise fast path implementations rely on unmodified JSPromise instances.
 // We use a fairly coarse granularity for this and simply check whether both
 // the promise itself is unmodified (i.e. its map has not changed) and its
 // prototype is unmodified.
 // TODO(gsathya): Refactor this out to prevent code dupe with builtins-regexp
 void PromiseBuiltinsAssembler::BranchIfFastPath(Node* context, Node* promise,
                                                 Label* if_isunmodified,
                                                 Label* if_ismodified) {
@@ skipping 192 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 246 matching lines @@
 
 TF_BUILTIN(PromiseHandle, PromiseBuiltinsAssembler) {
   Node* const promise = Parameter(1);
   Node* const value = Parameter(2);
   Node* const handler = Parameter(3);
   Node* const deferred = Parameter(4);
   Node* const context = Parameter(7);
   Isolate* isolate = this->isolate();
 
   // Get promise from deferred
-  // TODO(gsathya): Remove this lookup by getting rid of the deferred object.
-  Callable getproperty_callable = CodeFactory::GetProperty(isolate);
-  Node* const key = HeapConstant(isolate->factory()->promise_string());
+  CSA_ASSERT(this, HasInstanceType(deferred, JS_PROMISE_CAPABILITY_TYPE));
   Node* const deferred_promise =
-      CallStub(getproperty_callable, context, deferred, key);
+      LoadObjectField(deferred, JSPromiseCapability::kPromiseOffset);
 
   Variable var_reason(this, MachineRepresentation::kTagged);
 
   Node* const is_debug_active = IsDebugActive();
   Label run_handler(this), if_rejectpromise(this), promisehook_before(this),
       promisehook_after(this), debug_pop(this);
 
   GotoUnless(is_debug_active, &promisehook_before);
   CallRuntime(Runtime::kDebugPushPromise, context, deferred_promise);
   Goto(&promisehook_before);
 
   Bind(&promisehook_before);
   {
     GotoUnless(IsPromiseHookEnabled(), &run_handler);
     CallRuntime(Runtime::kPromiseHookBefore, context, promise);
     Goto(&run_handler);
   }
 
   Bind(&run_handler);
   {
     Callable call_callable = CodeFactory::Call(isolate);
 
     Node* const result =
         CallJS(call_callable, context, handler, UndefinedConstant(), value);
 
     GotoIfException(result, &if_rejectpromise, &var_reason);
 
-    // TODO(gsathya): Remove this lookup by getting rid of the deferred object.
-    Node* const key = HeapConstant(isolate->factory()->resolve_string());
     Node* const on_resolve =
-        CallStub(getproperty_callable, context, deferred, key);
+        LoadObjectField(deferred, JSPromiseCapability::kResolveOffset);
 
     Label if_internalhandler(this), if_customhandler(this, Label::kDeferred);
     Branch(IsUndefined(on_resolve), &if_internalhandler, &if_customhandler);
 
     Bind(&if_internalhandler);
     InternalResolvePromise(context, deferred_promise, result);
     Goto(&promisehook_after);
 
     Bind(&if_customhandler);
     {
       Node* const maybe_exception = CallJS(call_callable, context, on_resolve,
                                            UndefinedConstant(), result);
       GotoIfException(maybe_exception, &if_rejectpromise, &var_reason);
       Goto(&promisehook_after);
     }
   }
 
   Bind(&if_rejectpromise);
   {
-    // TODO(gsathya): Remove this lookup by getting rid of the deferred object.
-    Node* const key = HeapConstant(isolate->factory()->reject_string());
     Node* const on_reject =
-        CallStub(getproperty_callable, context, deferred, key);
+        LoadObjectField(deferred, JSPromiseCapability::kRejectOffset);
 
     Callable promise_handle_reject = CodeFactory::PromiseHandleReject(isolate);
     CallStub(promise_handle_reject, context, deferred_promise, on_reject,
              var_reason.value());
     Goto(&promisehook_after);
   }
 
   Bind(&promisehook_after);
   {
     GotoUnless(IsPromiseHookEnabled(), &debug_pop);
@@ skipping 40 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));
+}
+
+TF_BUILTIN(NewInternalPromiseCapability, PromiseBuiltinsAssembler) {
+  Node* parent = Parameter(1);
+  Node* context = Parameter(4);
+  CSA_ASSERT_JS_ARGC_EQ(this, 1);
+
+  Return(NewInternalPromiseCapability(context, parent));
+}
+
 }  // namespace internal
 }  // namespace v8