[promises] Move promise constructor to TFS

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/promise-utils.h"
 
 namespace v8 {
 namespace internal {
 
 // ES#sec-promise-resolve-functions
 // Promise Resolve Functions
 BUILTIN(PromiseResolveClosure) {
   HandleScope scope(isolate);
 
@@ skipping 43 matching lines @@
 
 // ES#sec-createresolvingfunctions
 // CreateResolvingFunctions ( promise )
 BUILTIN(CreateResolvingFunctions) {
   HandleScope scope(isolate);
   DCHECK_EQ(3, args.length());
 
   Handle<JSObject> promise = args.at<JSObject>(1);
   Handle<Object> debug_event = args.at<Object>(2);
   Handle<JSFunction> resolve, reject;
-
   PromiseUtils::CreateResolvingFunctions(isolate, promise, debug_event,
                                          &resolve, &reject);
 
   Handle<FixedArray> result = isolate->factory()->NewFixedArray(2);
   result->set(0, *resolve);
   result->set(1, *reject);
 
   return *isolate->factory()->NewJSArrayWithElements(result, FAST_ELEMENTS, 2,
                                                      NOT_TENURED);
 }
 
+// TODO(gsathya): Set up catch prediction
+void Builtins::Generate_PromiseConstructor(CodeStubAssembler* a) {
+  typedef CodeStubAssembler::Variable Variable;
+  typedef CodeStubAssembler::Label Label;
+  typedef compiler::Node Node;
+
+  Node* const executor = a->Parameter(1);
+  Node* const new_target = a->Parameter(2);
+  Node* const context = a->Parameter(4);
+  Isolate* isolate = a->isolate();
+
+  Variable result(a, MachineRepresentation::kTagged),

[jgruber, 2016/11/11 08:05:19]

Nit: The naming convention used elsewhere is to prepend var_. It's not
consistently used everywhere, but just wanted to mention it.

[gsathya, 2016/11/22 04:31:43]

Done.

+      reason(a, MachineRepresentation::kTagged);
+  Label if_targetisnotundefined(a), if_targetisundefined(a, Label::kDeferred);
+
+  a->Branch(a->WordEqual(new_target, a->UndefinedConstant()),

[Benedikt Meurer, 2016/11/11 06:50:31]

Instead of dynamically checking that new.target is not undefined, we could have
a dedicated construct stub for the Promise constructor and implement the normal
code object as a simple call to a CPP builtin that just throws.

[gsathya, 2016/11/22 04:31:43]

The asm wrapper is set as the construct stub, which calls the constructor
function. Not sure how to set up three different constructors.

+            &if_targetisundefined, &if_targetisnotundefined);
+
+  // 1. If NewTarget is undefined, throw a TypeError exception.
+  a->Bind(&if_targetisundefined);
+  {
+    Node* const message_id =
+        a->SmiConstant(Smi::FromInt(MessageTemplate::kNotAPromise));
+    Callable callable = CodeFactory::ToString(isolate);
+    // calling toString on UndefinedConstant?

[jgruber, 2016/11/11 08:05:19]

You probably don't need to call ToString here, just pass in new_target. We will
end up calling Object::NoSideEffectsToString in messages.cc:1147.

[gsathya, 2016/11/22 04:31:43]

Done.

+    Node* const undefined_str = a->CallStub(callable, context, new_target);
+
+    a->CallRuntime(Runtime::kThrowTypeError, context, message_id,
+                   undefined_str);
+    a->Return(a->UndefinedConstant());  // Never reached.
+  }
+
+  a->Bind(&if_targetisnotundefined);
+  {
+    Node* const executor_map = a->LoadMap(executor);
+    Label if_iscallable(a), if_notcallable(a, Label::kDeferred),
+        if_rejectpromise(a, Label::kDeferred);
+    a->Branch(a->IsCallableMap(executor_map), &if_iscallable, &if_notcallable);
+
+    // 2. If IsCallable(executor) is false, throw a TypeError exception.
+    a->Bind(&if_notcallable);
+    {
+      Node* const message_id =
+          a->SmiConstant(Smi::FromInt(MessageTemplate::kResolverNotAFunction));
+      Callable callable = CodeFactory::ToString(isolate);

[jgruber, 2016/11/11 09:25:43]

Danno added ToString to CSA recently, so all CodeFactory::ToString calls could
be replaced by

a->ToString(context, input)

OTOH this inlines a fairly large amount of code, maybe Benedikt can weigh in
what the better choice is for performance-insensitive code paths such as this
one.

[gsathya, 2016/11/22 04:31:43]

Done.

+      Node* const executor_str = a->CallStub(callable, context, executor);
+
+      a->CallRuntime(Runtime::kThrowTypeError, context, message_id,
+                     executor_str);
+      a->Return(a->UndefinedConstant());  // Never reached.
+    }
+
+    a->Bind(&if_iscallable);
+    {
+      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);
+
+      // TODO(gsathya): check if target != new_target
+      Node* const instance = a->AllocateJSObjectFromMap(initial_map);
+      result.Bind(instance);
+
+      Node* const resolving_functions =
+          a->CallRuntime(Runtime::kCreateResolvingFunctions, context, instance);

[gsathya, 2016/11/11 02:48:18]

Is there a way to call a C++ builtin from TFJ? Setting up a runtime function
just for this seems like a bad idea.

Should CreateResolvingFunction be a TFS?

If CreateResolvingFunction needs to be a TFS, I'm not sure how I'd create do the
equivalent of NewFunctionFromSharedFunctionInfo in the code stub? 
The context creation and setting seems straightforward as its just a FixedArray.

[Benedikt Meurer, 2016/11/11 06:50:31]

The runtime function is the correct approach here. (a CPP builtin is also just a
runtime function with a special setup).
It should in TurboFan yes. Allocating JSFunction instances is straight-forward,
you just allocate the JSFunction and fill in the approate map, SFI, and context.

+
+      Callable call_callable = CodeFactory::Call(isolate);
+
+      // TODO(gsathya): Extract resolving functions from JSArray

[jgruber, 2016/11/11 08:05:19]

Once all calls to CreateResolvingFunctions are in JS, do you still need to
create a JSArray? Maybe it could be a FixedArray (or just two separate
functions).

[gsathya, 2016/11/22 04:31:43]

Moved to a FixedArray for now. Next step is to move CreateResolvingFunction to
be a TFJ which will get rid of the runtime call.

+      Node* const maybe_exception =
+          a->CallJS(call_callable, context, executor, a->UndefinedConstant(),
+                    resolving_functions);
+
+      a->GotoIfException(maybe_exception, &if_rejectpromise, &reason);
+      a->Return(result.value());
+    }
+
+    // TODO(gsathya): Reject the promise
+    a->Bind(&if_rejectpromise);
+    { a->Return(result.value()); }

[jgruber, 2016/11/11 08:05:19]

Nit: You can remove these braces.

[gsathya, 2016/11/22 04:31:43]

Done.

+  }
+}
 }  // namespace internal
 }  // namespace v8