[async-await] Move remaining async-await code 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 253 matching lines @@
   return IsSetWord(SmiUntag(flags), 1 << JSPromise::kHasHandlerBit);
 }
 
 void PromiseBuiltinsAssembler::PromiseSetHasHandler(Node* promise) {
   Node* const flags = LoadObjectField(promise, JSPromise::kFlagsOffset);
   Node* const new_flags =
       SmiOr(flags, SmiConstant(1 << JSPromise::kHasHandlerBit));
   StoreObjectFieldNoWriteBarrier(promise, JSPromise::kFlagsOffset, new_flags);
 }
 
+void PromiseBuiltinsAssembler::PromiseSetHandledHint(Node* promise) {
+  Node* const flags = LoadObjectField(promise, JSPromise::kFlagsOffset);
+  Node* const new_flags =
+      SmiOr(flags, SmiConstant(1 << JSPromise::kHandledHintBit));
+  StoreObjectFieldNoWriteBarrier(promise, JSPromise::kFlagsOffset, new_flags);
+}
+
 Node* PromiseBuiltinsAssembler::SpeciesConstructor(Node* context, Node* object,
                                                    Node* default_constructor) {
   Isolate* isolate = this->isolate();
   Variable var_result(this, MachineRepresentation::kTagged);
   var_result.Bind(default_constructor);
 
   // 2. Let C be ? Get(O, "constructor").
   Node* const constructor_str =
       HeapConstant(isolate->factory()->constructor_string());
   Callable getproperty_callable = CodeFactory::GetProperty(isolate);
@@ skipping 868 matching lines @@
   GotoIf(TaggedIsSmi(maybe_promise), &if_notpromise);
 
   Node* const result =
       SelectBooleanConstant(HasInstanceType(maybe_promise, JS_PROMISE_TYPE));
   Return(result);
 
   Bind(&if_notpromise);
   Return(FalseConstant());
 }
 
-TF_BUILTIN(PerformPromiseThen, PromiseBuiltinsAssembler) {
-  Node* const promise = Parameter(1);
-  Node* const on_resolve = Parameter(2);
-  Node* const on_reject = Parameter(3);
-  Node* const deferred_promise = Parameter(4);
-  Node* const context = Parameter(7);
-
-  // No deferred_on_resolve/deferred_on_reject because this is just an
-  // internal promise created by async-await.
-  Node* const result = InternalPerformPromiseThen(
-      context, promise, on_resolve, on_reject, deferred_promise,
-      UndefinedConstant(), UndefinedConstant());
-
-  // 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);
 
   Node* const result =
@@ skipping 358 matching lines @@
   Node* const reason = Parameter(2);
   Node* const debug_event = Parameter(3);
   Node* const context = Parameter(6);
 
   InternalPromiseReject(context, promise, reason, debug_event);
   Return(UndefinedConstant());
 }
 
 }  // namespace internal
 }  // namespace v8