[promises] Port CreateResolvingFunctions 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"
 
@@ skipping 20 matching lines @@
   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 )
-BUILTIN(CreateResolvingFunctions) {
-  HandleScope scope(isolate);
-  DCHECK_EQ(3, args.length());
+void Builtins::Generate_CreateResolvingFunctions(
+    compiler::CodeAssemblerState* state) {
+  CodeStubAssembler a(state);
+  typedef compiler::Node Node;
 
-  Handle<JSObject> promise = args.at<JSObject>(1);
-  Handle<Object> debug_event = args.at<Object>(2);
-  Handle<JSFunction> resolve, reject;
+  Node* const promise = a.Parameter(1);
+  Node* const debug_event = a.Parameter(2);
+  Node* const context = a.Parameter(5);
+  Node* const native_context = a.LoadNativeContext(context);
 
-  PromiseUtils::CreateResolvingFunctions(isolate, promise, debug_event,
-                                         &resolve, &reject);
+  Node* resolve = nullptr;
+  Node* reject = nullptr;
 
-  Handle<FixedArray> result = isolate->factory()->NewFixedArray(2);
-  result->set(0, *resolve);
-  result->set(1, *reject);
+  std::tie(resolve, reject) =
+      a.CreatePromiseResolvingFunctions(promise, debug_event, native_context);
 
-  return *isolate->factory()->NewJSArrayWithElements(result, FAST_ELEMENTS, 2,
-                                                     NOT_TENURED);
+  Node* const kSize = a.Int32Constant(2);
+  Node* const arr = a.AllocateFixedArray(FAST_ELEMENTS, kSize);
+  a.StoreFixedArrayElement(arr, 0, resolve);

[jgruber, 2016/12/13 10:44:04]

We can skip write barriers when arr is guaranteed to be in new space (also
below).

[gsathya, 2016/12/13 13:01:46]

Done.

+  a.StoreFixedArrayElement(arr, 1, reject);
+
+  const ElementsKind kind = FAST_ELEMENTS;

[jgruber, 2016/12/13 10:44:04]

If you pull this up you could use it in AllocateFixedArray.

[gsathya, 2016/12/13 13:01:46]

Done.

+  Node* const array_map = a.LoadJSArrayElementsMap(kind, native_context);
+  Node* const length = a.SmiTag(kSize);
+  Node* const result = a.AllocateUninitializedJSArrayWithoutElements(
+      kind, array_map, length, nullptr);
+
+  a.StoreObjectField(result, JSObject::kElementsOffset, arr);
+  a.Return(result);
 }
 
 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 52 matching lines @@
   a.Bind(&debug_push);
   {
     a.CallRuntime(Runtime::kDebugPushPromise, context, var_result.value());
     a.Goto(&run_executor);
   }
 
   a.Bind(&run_executor);
   {
     Label out(&a), if_rejectpromise(&a), debug_pop(&a, Label::kDeferred);
 
-    // TODO(gsathya): Move this to TF.
-    Node* const resolving_functions = a.CallRuntime(
-        Runtime::kCreateResolvingFunctions, context, var_result.value());
-    Node* const resolve =
-        a.LoadFixedArrayElement(resolving_functions, a.IntPtrConstant(0));
-    Node* const reject =
-        a.LoadFixedArrayElement(resolving_functions, a.IntPtrConstant(1));
+    Node* resolve = nullptr;
+    Node* reject = nullptr;
+
+    std::tie(resolve, reject) = a.CreatePromiseResolvingFunctions(
+        var_result.value(), a.BooleanConstant(true), native_context);

[jgruber, 2016/12/13 10:44:04]

a.TrueConstant()

[gsathya, 2016/12/13 13:01:46]

Done.

+
     Callable call_callable = CodeFactory::Call(isolate);
 
     Node* const maybe_exception =
         a.CallJS(call_callable, context, executor, a.UndefinedConstant(),
                  resolve, reject);
 
     a.GotoIfException(maybe_exception, &if_rejectpromise, &var_reason);
     a.Branch(is_debug_active, &debug_pop, &out);
 
     a.Bind(&if_rejectpromise);
@@ skipping 715 matching lines @@
 
   Label out(&a);
   InternalResolvePromise(&a, context, promise, result, &out);
 
   a.Bind(&out);
   a.Return(a.UndefinedConstant());
 }
 
 }  // namespace internal
 }  // namespace v8