[promises] Port ResolvePromise 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-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 {
 
-// ES#sec-promise-resolve-functions
-// Promise Resolve Functions
-BUILTIN(PromiseResolveClosure) {
-  HandleScope scope(isolate);
-
-  Handle<Context> context(isolate->context(), isolate);
-
-  if (PromiseUtils::HasAlreadyVisited(context)) {
-    return isolate->heap()->undefined_value();
-  }
-
-  PromiseUtils::SetAlreadyVisited(context);
-  Handle<JSObject> promise = handle(PromiseUtils::GetPromise(context), isolate);
-  Handle<Object> value = args.atOrUndefined(isolate, 1);
-
-  MaybeHandle<Object> maybe_result;
-  Handle<Object> argv[] = {promise, value};
-  RETURN_FAILURE_ON_EXCEPTION(
-      isolate, Execution::Call(isolate, isolate->promise_resolve(),
-                               isolate->factory()->undefined_value(),
-                               arraysize(argv), argv));
-  return isolate->heap()->undefined_value();
-}
-
 // 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 31 matching lines @@
 
   return *isolate->factory()->NewJSArrayWithElements(result, FAST_ELEMENTS, 2,
                                                      NOT_TENURED);
 }
 
 void PromiseInit(CodeStubAssembler* a, compiler::Node* promise,
                  compiler::Node* status, compiler::Node* result) {
   CSA_ASSERT(a, a->TaggedIsSmi(status));
   a->StoreObjectField(promise, JSPromise::kStatusOffset, status);
   a->StoreObjectField(promise, JSPromise::kResultOffset, result);
+  a->StoreObjectField(promise, JSPromise::kHasHandlerOffset, a->SmiConstant(0));
 }
 
 void Builtins::Generate_PromiseConstructor(
     compiler::CodeAssemblerState* state) {
   CodeStubAssembler a(state);
   typedef CodeStubAssembler::Variable Variable;
   typedef CodeStubAssembler::Label Label;
   typedef compiler::Node Node;
 
   Node* const executor = a.Parameter(1);
@@ skipping 274 matching lines @@
 
   Node* elements = a->LoadObjectField(promise, offset);
   Node* length = a->LoadFixedArrayBaseLength(elements);
   CodeStubAssembler::ParameterMode mode = a->OptimalParameterMode();
   length = a->UntagParameter(length, mode);
 
   Node* delta = a->IntPtrOrSmiConstant(1, mode);
   Node* new_capacity = a->IntPtrAdd(length, delta);
   ElementsKind kind = FAST_ELEMENTS;
 
   Node* new_elements = a->AllocateFixedArray(kind, new_capacity, mode);

[jgruber, 2016/12/07 12:59:38]

Do you think we need to handle LO space allocation here as well?

[gsathya, 2016/12/08 05:18:14]

This is handled in https://codereview.chromium.org/2556483002/

 
   a->CopyFixedArrayElements(kind, elements, new_elements, length,
                             UPDATE_WRITE_BARRIER, mode);
   a->StoreFixedArrayElement(new_elements, length, value, UPDATE_WRITE_BARRIER,
                             0, mode);
 
   a->StoreObjectField(promise, offset, new_elements);
 }
 
 compiler::Node* InternalPerformPromiseThen(CodeStubAssembler* a,
                                            compiler::Node* context,
                                            compiler::Node* promise,
                                            compiler::Node* on_resolve,
                                            compiler::Node* on_reject,
                                            compiler::Node* deferred) {
   typedef CodeStubAssembler::Variable Variable;
   typedef CodeStubAssembler::Label Label;
   typedef compiler::Node Node;
-
   Isolate* isolate = a->isolate();
   Node* const native_context = a->LoadNativeContext(context);
 
   Variable var_on_resolve(a, MachineRepresentation::kTagged),
       var_on_reject(a, MachineRepresentation::kTagged);
 
   var_on_resolve.Bind(on_resolve);
   var_on_reject.Bind(on_reject);
 
   Label out(a), if_onresolvenotcallable(a), onrejectcheck(a),
@@ skipping 112 matching lines @@
                     &reject);
 
       // TODO(gsathya): Move this to TF.
       a->CallRuntime(Runtime::kEnqueuePromiseReactionJob, context, result,
                      var_on_resolve.value(), deferred,
                      a->SmiConstant(kPromiseFulfilled));
       a->Goto(&out);
 
       a->Bind(&reject);
       {
-        Callable getproperty_callable = CodeFactory::GetProperty(isolate);
-        Node* const key =
-            a->HeapConstant(isolate->factory()->promise_has_handler_symbol());
         Node* const has_handler =
-            a->CallStub(getproperty_callable, context, promise, key);
-
+            a->LoadObjectField(promise, JSPromise::kHasHandlerOffset);
         Label enqueue(a);
 
         // TODO(gsathya): Fold these runtime calls and move to TF.
-        a->GotoIf(a->WordEqual(has_handler, a->TrueConstant()), &enqueue);
+        a->GotoIf(a->SmiEqual(has_handler, a->SmiConstant(1)), &enqueue);
         a->CallRuntime(Runtime::kPromiseRevokeReject, context, promise);
         a->Goto(&enqueue);
 
         a->Bind(&enqueue);
         {
           a->CallRuntime(Runtime::kEnqueuePromiseReactionJob, context, result,
                          var_on_reject.value(), deferred,
                          a->SmiConstant(kPromiseRejected));
 
           a->Goto(&out);
         }
       }
     }
   }
 
   a->Bind(&out);
-  // TODO(gsathya): Protect with debug check.
-  a->CallRuntime(
-      Runtime::kSetProperty, context, promise,
-      a->HeapConstant(isolate->factory()->promise_has_handler_symbol()),
-      a->TrueConstant(), a->SmiConstant(STRICT));
+  a->StoreObjectField(promise, JSPromise::kHasHandlerOffset, a->SmiConstant(1));
 
   // TODO(gsathya): This call will be removed once we don't have to
   // deal with deferred objects.
   Callable getproperty_callable = CodeFactory::GetProperty(isolate);
   Node* const key =
       a->HeapConstant(isolate->factory()->NewStringFromAsciiChecked("promise"));
   Node* const result =
       a->CallStub(getproperty_callable, context, deferred, key);
 
   return result;
@@ skipping 80 matching lines @@
   }
 
   // 5. Return PerformPromiseThen(promise, onFulfilled, onRejected,
   //    resultCapability).
   a.Bind(&perform_promise_then);
   Node* const result = InternalPerformPromiseThen(
       &a, context, promise, on_resolve, on_reject, var_deferred.value());
   a.Return(result);
 }
 
+namespace {
+// 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 BranchIfFastPath(CodeStubAssembler* a, compiler::Node* context,
+                      compiler::Node* promise,
+                      CodeStubAssembler::Label* if_isunmodified,
+                      CodeStubAssembler::Label* if_ismodified) {
+  typedef compiler::Node Node;
+
+  // TODO(gsathya): Assert if promise is receiver
+  Node* const map = a->LoadMap(promise);
+  Node* const native_context = a->LoadNativeContext(context);
+  Node* const promise_fun =
+      a->LoadContextElement(native_context, Context::PROMISE_FUNCTION_INDEX);
+  Node* const initial_map =
+      a->LoadObjectField(promise_fun, JSFunction::kPrototypeOrInitialMapOffset);
+  Node* const has_initialmap = a->WordEqual(map, initial_map);
+
+  a->GotoUnless(has_initialmap, if_ismodified);
+
+  Node* const initial_proto_initial_map = a->LoadContextElement(
+      native_context, Context::PROMISE_PROTOTYPE_MAP_INDEX);
+  Node* const proto_map = a->LoadMap(a->LoadMapPrototype(map));
+  Node* const proto_has_initialmap =
+      a->WordEqual(proto_map, initial_proto_initial_map);
+
+  a->Branch(proto_has_initialmap, if_isunmodified, if_ismodified);
+}
+}  // namespace
+
+void InternalResolvePromise(CodeStubAssembler* a, compiler::Node* context,
+                            compiler::Node* promise, compiler::Node* result,
+                            CodeStubAssembler::Label* out) {

[jgruber, 2016/12/07 12:59:38]

I don't think you gain much through the style

IRP(.., out) { Goto(out); }
caller() {
 IRP(...)
 Bind(&out)
 Return(UndefinedConstant());
}

vs. the simpler

IRP(...) { Bind(&out); return UndefinedConstant(); }
caller() {
 Return(IRP(...));
}

or

IRP(...) { Bind(&out); }
caller() {
 IRP(...);
 Return(UndefinedConstant());
}

But I don't feel too strongly about this.

[gsathya, 2016/12/08 05:18:14]

I use this here in the follow on patch --
https://codereview.chromium.org/2561443003/diff/60001/src/builtins/builtins-p...

+  typedef CodeStubAssembler::Variable Variable;
+  typedef CodeStubAssembler::Label Label;
+  typedef compiler::Node Node;
+
+  Isolate* isolate = a->isolate();
+
+  Variable var_reason(a, MachineRepresentation::kTagged),
+      var_then(a, MachineRepresentation::kTagged);
+
+  Label do_enqueue(a), fulfill(a), if_cycle(a, Label::kDeferred),
+      if_rejectpromise(a, Label::kDeferred);
+
+  // 6. If SameValue(resolution, promise) is true, then
+  a->GotoIf(a->SameValue(promise, result, context), &if_cycle);
+
+  // 7. If Type(resolution) is not Object, then
+  a->GotoIf(a->TaggedIsSmi(result), &fulfill);
+  a->GotoUnless(a->IsJSReceiver(result), &fulfill);
+
+  Label if_nativepromise(a), if_notnativepromise(a, Label::kDeferred);
+  BranchIfFastPath(a, context, result, &if_nativepromise, &if_notnativepromise);
+
+  // Resolution is a native promise and if it's already resolved or
+  // rejected, shortcircuit the resolution procedure by directly
+  // reusing the value from the promise.
+  a->Bind(&if_nativepromise);
+  {
+    Node* const thenable_status =
+        a->LoadObjectField(result, JSPromise::kStatusOffset);
+    Node* const thenable_value =
+        a->LoadObjectField(result, JSPromise::kResultOffset);
+
+    Label if_isnotpending(a);
+    a->GotoUnless(a->SmiEqual(a->SmiConstant(kPromisePending), thenable_status),
+                  &if_isnotpending);
+
+    // TODO(gsathya): Use a marker here instead of the actual then
+    // callback, and check for the marker in PromiseResolveThenableJob
+    // and perform PromiseThen.
+    Node* const native_context = a->LoadNativeContext(context);
+    Node* const then =
+        a->LoadContextElement(native_context, Context::PROMISE_THEN_INDEX);
+    var_then.Bind(then);
+    a->Goto(&do_enqueue);
+
+    a->Bind(&if_isnotpending);
+    {
+      Label if_fulfilled(a), if_rejected(a);
+      a->Branch(a->SmiEqual(a->SmiConstant(kPromiseFulfilled), thenable_status),
+                &if_fulfilled, &if_rejected);
+
+      a->Bind(&if_fulfilled);
+      {
+        a->CallRuntime(Runtime::kPromiseFulfill, context, promise,
+                       a->SmiConstant(kPromiseFulfilled), thenable_value);
+        a->StoreObjectField(promise, JSPromise::kHasHandlerOffset,
+                            a->SmiConstant(1));
+        a->Goto(out);
+      }
+
+      a->Bind(&if_rejected);
+      {
+        Label reject(a);
+        Node* const has_handler =
+            a->LoadObjectField(promise, JSPromise::kHasHandlerOffset);
+
+        // Promise has already been rejected, but had no handler.
+        // Revoke previously triggered reject event.
+        a->GotoIf(a->SmiEqual(has_handler, a->SmiConstant(1)), &reject);
+        a->CallRuntime(Runtime::kPromiseRevokeReject, context, result);
+        a->Goto(&reject);
+
+        a->Bind(&reject);
+        // Don't cause a debug event as this case is forwarding a rejection
+        a->CallRuntime(Runtime::kPromiseReject, context, promise,
+                       thenable_value, a->FalseConstant());
+        a->StoreObjectField(result, JSPromise::kHasHandlerOffset,
+                            a->SmiConstant(1));
+        a->Goto(out);
+      }
+    }
+  }
+
+  a->Bind(&if_notnativepromise);
+  {
+    // 8. Let then be Get(resolution, "then").
+    Node* const then_str = a->HeapConstant(isolate->factory()->then_string());
+    Callable getproperty_callable = CodeFactory::GetProperty(a->isolate());
+    Node* const then =
+        a->CallStub(getproperty_callable, context, result, then_str);
+
+    // 9. If then is an abrupt completion, then
+    a->GotoIfException(then, &if_rejectpromise, &var_reason);
+
+    // 11. If IsCallable(thenAction) is false, then
+    a->GotoIf(a->TaggedIsSmi(then), &fulfill);
+    Node* const then_map = a->LoadMap(then);
+    a->GotoUnless(a->IsCallableMap(then_map), &fulfill);
+    var_then.Bind(then);
+    a->Goto(&do_enqueue);
+  }
+
+  a->Bind(&do_enqueue);
+  {
+    Label enqueue(a);
+    a->GotoUnless(a->IsDebugActive(), &enqueue);
+    a->GotoIf(a->TaggedIsSmi(result), &enqueue);
+    Node* const is_promise =
+        a->SelectBooleanConstant(a->HasInstanceType(result, JS_PROMISE_TYPE));
+    a->GotoUnless(is_promise, &enqueue);

[jgruber, 2016/12/07 12:59:38]

This will always evaluate to true (even if you pass in FalseConstant).
Branch/Gotos interpret IntPtrConstant(0) as false and everything else as true.

Just skip the SelectBooleanConstant call.

[gsathya, 2016/12/08 05:18:14]

Done.

+    Node* const key =
+        a->HeapConstant(isolate->factory()->promise_handled_by_symbol());
+    a->CallRuntime(Runtime::kSetProperty, context, result, key, promise,
+                   a->SmiConstant(STRICT));
+    a->Goto(&enqueue);
+
+    // 12. Perform EnqueueJob("PromiseJobs",
+    // PromiseResolveThenableJob, « promise, resolution, thenAction
+    // »).
+    a->Bind(&enqueue);
+    a->CallRuntime(Runtime::kEnqueuePromiseResolveThenableJob, context, promise,
+                   result, var_then.value());
+    a->Goto(out);
+  }
+  // 7.b Return FulfillPromise(promise, resolution).
+  a->Bind(&fulfill);
+  {
+    a->CallRuntime(Runtime::kPromiseFulfill, context, promise,
+                   a->SmiConstant(kPromiseFulfilled), result);
+    a->Goto(out);
+  }
+
+  a->Bind(&if_cycle);
+  {
+    // 6.a Let selfResolutionError be a newly created TypeError object.
+    Node* const message_id = a->SmiConstant(MessageTemplate::kPromiseCyclic);
+    Node* const error =
+        a->CallRuntime(Runtime::kNewTypeError, context, message_id, result);
+    var_reason.Bind(error);
+
+    // 6.b Return RejectPromise(promise, selfResolutionError).
+    a->Goto(&if_rejectpromise);
+  }
+
+  // 9.a Return RejectPromise(promise, then.[[Value]]).
+  a->Bind(&if_rejectpromise);
+  {
+    a->CallRuntime(Runtime::kPromiseReject, context, promise,
+                   var_reason.value(), a->TrueConstant());
+    a->Goto(out);
+  }
+}
+
+// ES#sec-promise-resolve-functions
+// Promise Resolve Functions
+void Builtins::Generate_PromiseResolveClosure(
+    compiler::CodeAssemblerState* state) {
+  CodeStubAssembler a(state);
+  typedef compiler::Node Node;
+  typedef CodeStubAssembler::Label Label;
+
+  Node* const value = a.Parameter(1);
+  Node* const context = a.Parameter(4);
+
+  Label out(&a);
+
+  // 3. Let alreadyResolved be F.[[AlreadyResolved]].
+  Node* const has_already_visited_slot =
+      a.IntPtrConstant(PromiseUtils::kAlreadyVisitedSlot);
+
+  Node* const has_already_visited =
+      a.LoadFixedArrayElement(context, has_already_visited_slot);
+
+  // 4. If alreadyResolved.[[Value]] is true, return undefined.
+  a.GotoIf(a.SmiEqual(has_already_visited, a.SmiConstant(1)), &out);
+
+  // 5.Set alreadyResolved.[[Value]] to true.
+  a.StoreFixedArrayElement(context, has_already_visited_slot, a.SmiConstant(1));
+
+  // 2. Let promise be F.[[Promise]].
+  Node* const promise = a.LoadFixedArrayElement(
+      context, a.IntPtrConstant(PromiseUtils::kPromiseSlot));
+
+  InternalResolvePromise(&a, context, promise, value, &out);
+
+  a.Bind(&out);
+  a.Return(a.UndefinedConstant());
+}
+
+void Builtins::Generate_ResolvePromise(compiler::CodeAssemblerState* state) {
+  CodeStubAssembler a(state);
+  typedef compiler::Node Node;
+  typedef CodeStubAssembler::Label Label;
+
+  Node* const promise = a.Parameter(1);
+  Node* const result = a.Parameter(2);
+  Node* const context = a.Parameter(5);
+
+  Label out(&a);
+  InternalResolvePromise(&a, context, promise, result, &out);
+
+  a.Bind(&out);
+  a.Return(a.UndefinedConstant());
+}
+
 }  // namespace internal
 }  // namespace v8