[promises] Move Promise.prototype.catch 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"
@@ skipping 162 matching lines @@
   Node* new_elements = AllocateFixedArray(kind, new_capacity, mode, flags);
 
   CopyFixedArrayElements(kind, elements, new_elements, length, barrier_mode,
                          mode);
   StoreFixedArrayElement(new_elements, length, value, barrier_mode,
                          additional_offset, mode);
 
   StoreObjectField(promise, offset, new_elements);
 }
 
+Node* PromiseBuiltinsAssembler::InternalPromiseThen(Node* context,
+                                                    Node* promise,
+                                                    Node* on_resolve,
+                                                    Node* on_reject) {
+  Isolate* isolate = this->isolate();
+
+  // 2. If IsPromise(promise) is false, throw a TypeError exception.
+  ThrowIfNotInstanceType(context, promise, JS_PROMISE_TYPE,
+                         "Promise.prototype.then");
+
+  Node* const native_context = LoadNativeContext(context);
+  Node* const promise_fun =
+      LoadContextElement(native_context, Context::PROMISE_FUNCTION_INDEX);
+
+  // 3. Let C be ? SpeciesConstructor(promise, %Promise%).
+  Node* constructor = SpeciesConstructor(context, promise, promise_fun);
+
+  // 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.
+  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);
+    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);
+    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;
+}
+
 Node* PromiseBuiltinsAssembler::InternalPerformPromiseThen(Node* context,
                                                            Node* promise,
                                                            Node* on_resolve,
                                                            Node* on_reject,
                                                            Node* deferred) {
   Node* const native_context = LoadNativeContext(context);
 
   Variable var_on_resolve(this, MachineRepresentation::kTagged),
       var_on_reject(this, MachineRepresentation::kTagged);
 
@@ skipping 178 matching lines @@
       LoadContextElement(native_context, Context::PROMISE_PROTOTYPE_MAP_INDEX);
   Node* const proto_map = LoadMap(LoadMapPrototype(map));
   Node* const proto_has_initialmap =
       WordEqual(proto_map, initial_proto_initial_map);
 
   Branch(proto_has_initialmap, if_isunmodified, if_ismodified);
 }
 
 void PromiseBuiltinsAssembler::InternalResolvePromise(Node* context,
                                                       Node* promise,
-                                                      Node* result,
-                                                      Label* out) {
+                                                      Node* result) {
   Isolate* isolate = this->isolate();
 
   Variable var_reason(this, MachineRepresentation::kTagged),
       var_then(this, MachineRepresentation::kTagged);
 
   Label do_enqueue(this), fulfill(this), if_cycle(this, Label::kDeferred),
-      if_rejectpromise(this, Label::kDeferred);
+      if_rejectpromise(this, Label::kDeferred), out(this);
 
   Label cycle_check(this);
   GotoUnless(IsPromiseHookEnabled(), &cycle_check);
   CallRuntime(Runtime::kPromiseHookResolve, context, promise);
   Goto(&cycle_check);
 
   Bind(&cycle_check);
   // 6. If SameValue(resolution, promise) is true, then
   GotoIf(SameValue(promise, result, context), &if_cycle);
 
@@ skipping 31 matching lines @@
     {
       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);
         PromiseSetHasHandler(promise);
-        Goto(out);
+        Goto(&out);
       }
 
       Bind(&if_rejected);
       {
         Label reject(this);
         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());
         PromiseSetHasHandler(result);
-        Goto(out);
+        Goto(&out);
       }
     }
   }
 
   Bind(&if_notnativepromise);
   {
     // 8. Let then be Get(resolution, "then").
     Node* const then_str = HeapConstant(isolate->factory()->then_string());
     Callable getproperty_callable = CodeFactory::GetProperty(isolate);
     Node* const then =
@@ skipping 22 matching lines @@
     CallRuntime(Runtime::kSetProperty, context, result, key, promise,
                 SmiConstant(STRICT));
     Goto(&enqueue);
 
     // 12. Perform EnqueueJob("PromiseJobs",
     // PromiseResolveThenableJob, « promise, resolution, thenAction
     // »).
     Bind(&enqueue);
     CallRuntime(Runtime::kEnqueuePromiseResolveThenableJob, context, promise,
                 result, var_then.value());
-    Goto(out);
+    Goto(&out);
   }
 
   // 7.b Return FulfillPromise(promise, resolution).
   Bind(&fulfill);
   {
     CallRuntime(Runtime::kPromiseFulfill, context, promise,
                 SmiConstant(v8::Promise::kFulfilled), result);
-    Goto(out);
+    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);
+    Goto(&out);
   }
+
+  Bind(&out);
 }
 
 // ES#sec-promise-reject-functions
 // Promise Reject Functions
 BUILTIN(PromiseRejectClosure) {
   HandleScope scope(isolate);
 
   Handle<Context> context(isolate->context(), isolate);
 
   if (PromiseUtils::HasAlreadyVisited(context)) {
@@ skipping 212 matching lines @@
   Node* const deferred = Parameter(4);
   Node* const context = Parameter(7);
 
   Node* const result = InternalPerformPromiseThen(context, promise, on_resolve,
                                                   on_reject, deferred);
 
   // TODO(gsathya): This is unused, but value is returned according to spec.
   Return(result);
 }
 
+// ES#sec-promise.prototype.then
+// Promise.prototype.catch ( onFulfilled, onRejected )
 TF_BUILTIN(PromiseThen, PromiseBuiltinsAssembler) {
   // 1. Let promise be the this value.
   Node* const promise = Parameter(0);
   Node* const on_resolve = Parameter(1);
   Node* const on_reject = Parameter(2);
   Node* const context = Parameter(5);
-  Isolate* isolate = this->isolate();
 
-  // 2. If IsPromise(promise) is false, throw a TypeError exception.
-  ThrowIfNotInstanceType(context, promise, JS_PROMISE_TYPE,
-                         "Promise.prototype.then");
-
-  Node* const native_context = LoadNativeContext(context);
-  Node* const promise_fun =
-      LoadContextElement(native_context, Context::PROMISE_FUNCTION_INDEX);
-
-  // 3. Let C be ? SpeciesConstructor(promise, %Promise%).
-  Node* constructor = SpeciesConstructor(context, promise, promise_fun);
-
-  // 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.
-  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);
-    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);
-    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());
+  Node* const result =
+      InternalPromiseThen(context, promise, on_resolve, on_reject);
   Return(result);
 }
 
 // ES#sec-promise-resolve-functions
 // Promise Resolve Functions
 TF_BUILTIN(PromiseResolveClosure, PromiseBuiltinsAssembler) {
   Node* const value = Parameter(1);
   Node* const context = Parameter(4);
 
   Label out(this);
 
   // 3. Let alreadyResolved be F.[[AlreadyResolved]].
   Node* const has_already_visited_slot =
       IntPtrConstant(PromiseUtils::kAlreadyVisitedSlot);
 
   Node* const has_already_visited =
       LoadFixedArrayElement(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.
   StoreFixedArrayElement(context, has_already_visited_slot, SmiConstant(1));
 
   // 2. Let promise be F.[[Promise]].
   Node* const promise = LoadFixedArrayElement(
       context, IntPtrConstant(PromiseUtils::kPromiseSlot));
 
-  InternalResolvePromise(context, promise, value, &out);
+  InternalResolvePromise(context, promise, value);
+  Return(UndefinedConstant());
 
   Bind(&out);
   Return(UndefinedConstant());
 }
 
 TF_BUILTIN(ResolvePromise, PromiseBuiltinsAssembler) {
   Node* const promise = Parameter(1);
   Node* const result = Parameter(2);
   Node* const context = Parameter(5);
 
-  Label out(this);
-  InternalResolvePromise(context, promise, result, &out);
-
-  Bind(&out);
+  InternalResolvePromise(context, promise, result);
   Return(UndefinedConstant());
 }
 
 TF_BUILTIN(PromiseHandleReject, PromiseBuiltinsAssembler) {
   typedef PromiseHandleRejectDescriptor Descriptor;
 
   Node* const promise = Parameter(Descriptor::kPromise);
   Node* const on_reject = Parameter(Descriptor::kOnReject);
   Node* const exception = Parameter(Descriptor::kException);
   Node* const context = Parameter(Descriptor::kContext);
@@ skipping 61 matching lines @@
 
     // 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);
 
     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,
-                           &promisehook_after);
+    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);
     }
   }
 
@@ skipping 23 matching lines @@
 
     GotoUnless(is_debug_active, &out);
     CallRuntime(Runtime::kDebugPopPromise, context);
     Goto(&out);
 
     Bind(&out);
     Return(UndefinedConstant());
   }
 }
 
+// ES#sec-promise.prototype.catch
+// Promise.prototype.catch ( onRejected )
+TF_BUILTIN(PromiseCatch, PromiseBuiltinsAssembler) {
+  // 1. Let promise be the this value.
+  Node* const promise = Parameter(0);
+  Node* const on_resolve = UndefinedConstant();
+  Node* const on_reject = Parameter(1);
+  Node* const context = Parameter(4);
+
+  Label if_internalthen(this), if_customthen(this, Label::kDeferred);
+  BranchIfFastPath(context, promise, &if_internalthen, &if_customthen);
+
+  Bind(&if_internalthen);
+  {
+    Node* const result =
+        InternalPromiseThen(context, promise, on_resolve, on_reject);
+    Return(result);
+  }
+
+  Bind(&if_customthen);
+  {
+    Isolate* isolate = this->isolate();
+    Node* const then_str = HeapConstant(isolate->factory()->then_string());
+    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);
+  }
+}
+
 }  // namespace internal
 }  // namespace v8