src/builtins/builtins-promise.cc - Issue 2567333002: [promises] port NewPromiseCapability to TF

Unified Diff: src/builtins/builtins-promise.cc

Issue 2567333002: [promises] port NewPromiseCapability to TF (Closed)

Patch Set: git rid of stuff that snuck into patch Created 4 years ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Index: src/builtins/builtins-promise.cc

diff --git a/src/builtins/builtins-promise.cc b/src/builtins/builtins-promise.cc

index 49e9d6de2ed0d4906f96c254177a1bbd4ab2db8e..e7416b390fe816689e946079c01648f4bdd57c9c 100644

--- a/src/builtins/builtins-promise.cc

+++ b/src/builtins/builtins-promise.cc

@@ -16,24 +16,148 @@ typedef compiler::Node Node;

typedef CodeStubAssembler::ParameterMode ParameterMode;

typedef compiler::CodeAssemblerState CodeAssemblerState;

-Node* PromiseBuiltinsAssembler::CreatePromiseResolvingFunctionsContext(

- Node* promise, Node* debug_event, Node* native_context) {

- Node* const context =

- Allocate(FixedArray::SizeFor(PromiseUtils::kPromiseContextLength));

- StoreMapNoWriteBarrier(context, Heap::kFunctionContextMapRootIndex);

+Node* PromiseBuiltinsAssembler::NewPromiseCapability(Node* context,

+ Node* constructor,

+ Node* debug_event) {

+ if (debug_event == nullptr) {

+ debug_event = TrueConstant();

+ }

+ Node* native_context = LoadNativeContext(context);

+ Node* map = LoadRoot(Heap::kJSPromiseCapabilityMapRootIndex);

+ Node* capability = AllocateJSObjectFromMap(map);

+ StoreObjectFieldNoWriteBarrier(

+ capability, JSPromiseCapability::kPromiseOffset, UndefinedConstant());

StoreObjectFieldNoWriteBarrier(

- context, FixedArray::kLengthOffset,

- SmiConstant(PromiseUtils::kPromiseContextLength));

+ capability, JSPromiseCapability::kResolveOffset, UndefinedConstant());

+ StoreObjectFieldNoWriteBarrier(capability, JSPromiseCapability::kRejectOffset,

+ UndefinedConstant());

+ Variable var_result(this, MachineRepresentation::kTagged);

+ var_result.Bind(capability);

+ Label if_builtin_promise(this), if_custom_promise(this), out(this);

gsathya 2016/12/29 21:48:47 if_custom_promise can be deferred

+ Branch(WordEqual(constructor,

+ LoadContextElement(native_context,

+ Context::PROMISE_FUNCTION_INDEX)),

+ &if_builtin_promise, &if_custom_promise);

+ Bind(&if_builtin_promise);

+ {

+ Node* promise = AllocateJSPromise(context);

+ PromiseInit(promise);

+ StoreObjectFieldNoWriteBarrier(

+ capability, JSPromiseCapability::kPromiseOffset, promise);

+ Node* resolve = nullptr;

+ Node* reject = nullptr;

+ std::tie(resolve, reject) =

+ CreatePromiseResolvingFunctions(promise, debug_event, native_context);

+ StoreObjectField(capability, JSPromiseCapability::kResolveOffset, resolve);

+ StoreObjectField(capability, JSPromiseCapability::kRejectOffset, reject);

+ GotoUnless(IsPromiseHookEnabled(), &out);

+ CallRuntime(Runtime::kPromiseHookInit, context, promise,

+ UndefinedConstant());

+ Goto(&out);

+ }

+ Bind(&if_custom_promise);

+ {

+ Label if_notcallable(this, Label::kDeferred);

+ Node* executor_context =

+ CreatePromiseGetCapabilitiesExecutorContext(capability, native_context);

+ Node* executor_info = LoadContextElement(

+ native_context, Context::PROMISE_GET_CAPABILITIES_EXECUTOR_SHARED_FUN);

+ Node* function_map = LoadContextElement(

+ native_context, Context::STRICT_FUNCTION_WITHOUT_PROTOTYPE_MAP_INDEX);

+ Node* executor = AllocateFunctionWithMapAndContext(

+ function_map, executor_info, executor_context);

+ Node* promise = ConstructJS(CodeFactory::Construct(isolate()), context,

+ constructor, executor);

+ Node* resolve =

+ LoadObjectField(capability, JSPromiseCapability::kResolveOffset);

+ GotoIf(TaggedIsSmi(resolve), &if_notcallable);

+ GotoUnless(IsCallableMap(LoadMap(resolve)), &if_notcallable);

+ Node* reject =

+ LoadObjectField(capability, JSPromiseCapability::kRejectOffset);

+ GotoIf(TaggedIsSmi(reject), &if_notcallable);

+ GotoUnless(IsCallableMap(LoadMap(reject)), &if_notcallable);

+ StoreObjectField(capability, JSPromiseCapability::kPromiseOffset, promise);

+ Goto(&out);

+ Bind(&if_notcallable);

+ Node* message = SmiConstant(MessageTemplate::kPromiseNonCallable);

+ StoreObjectField(capability, JSPromiseCapability::kPromiseOffset,

+ UndefinedConstant());

+ StoreObjectField(capability, JSPromiseCapability::kResolveOffset,

+ UndefinedConstant());

+ StoreObjectField(capability, JSPromiseCapability::kRejectOffset,

+ UndefinedConstant());

+ CallRuntime(Runtime::kThrowTypeError, context, message);

+ var_result.Bind(UndefinedConstant());

+ Goto(&out);

+ }

+ Bind(&out);

+ return var_result.value();

+Node* PromiseBuiltinsAssembler::NewInternalPromiseCapability(Node* context,

+ Node* parent) {

+ Node* promise = AllocateJSPromise(context);

+ PromiseInit(promise);

+ Label out(this);

+ Node* map = LoadRoot(Heap::kJSPromiseCapabilityMapRootIndex);

+ Node* capability = AllocateJSObjectFromMap(map);

+ StoreObjectFieldNoWriteBarrier(capability,

+ JSPromiseCapability::kPromiseOffset, promise);

+ StoreObjectFieldNoWriteBarrier(

+ capability, JSPromiseCapability::kResolveOffset, UndefinedConstant());

+ StoreObjectFieldNoWriteBarrier(capability, JSPromiseCapability::kRejectOffset,

+ UndefinedConstant());

+ GotoUnless(IsPromiseHookEnabled(), &out);

+ CallRuntime(Runtime::kPromiseHookInit, context, promise, parent);

+ Goto(&out);

+ Bind(&out);

+ return capability;

- Node* const empty_fn =

- LoadContextElement(native_context, Context::CLOSURE_INDEX);

- StoreContextElementNoWriteBarrier(context, Context::CLOSURE_INDEX, empty_fn);

+Node* PromiseBuiltinsAssembler::CreatePromiseContext(Node* native_context,

+ int slots) {

+ DCHECK_GE(slots, Context::MIN_CONTEXT_SLOTS);

+ Node* script = LoadContextElement(native_context, Context::CLOSURE_INDEX);

+ Node* map = HeapConstant(isolate()->factory()->function_context_map());

+ Node* context = Allocate(FixedArray::SizeFor(slots));

+ StoreMapNoWriteBarrier(context, map);

+ StoreObjectFieldNoWriteBarrier(context, FixedArray::kLengthOffset,

+ SmiConstant(slots));

+ StoreContextElementNoWriteBarrier(context, Context::CLOSURE_INDEX, script);

StoreContextElementNoWriteBarrier(context, Context::PREVIOUS_INDEX,

UndefinedConstant());

StoreContextElementNoWriteBarrier(context, Context::EXTENSION_INDEX,

TheHoleConstant());

StoreContextElementNoWriteBarrier(context, Context::NATIVE_CONTEXT_INDEX,

native_context);

+ return context;

+Node* PromiseBuiltinsAssembler::CreatePromiseResolvingFunctionsContext(

+ Node* promise, Node* debug_event, Node* native_context) {

+ Node* const context =

+ CreatePromiseContext(native_context, PromiseUtils::kPromiseContextLength);

StoreContextElementNoWriteBarrier(context, PromiseUtils::kAlreadyVisitedSlot,

SmiConstant(0));

StoreContextElementNoWriteBarrier(context, PromiseUtils::kPromiseSlot,

@@ -43,6 +167,16 @@ Node* PromiseBuiltinsAssembler::CreatePromiseResolvingFunctionsContext(

return context;

}

+Node* PromiseBuiltinsAssembler::CreatePromiseGetCapabilitiesExecutorContext(

+ Node* promise_capability, Node* native_context) {

+ int kSize = GetPromiseCapabilityExecutor::kContextLength;

+ Node* context = CreatePromiseContext(native_context, kSize);

+ StoreContextElementNoWriteBarrier(

+ context, GetPromiseCapabilityExecutor::kCapabilitySlot,

+ promise_capability);

+ return context;

std::pair<Node*, Node*>

PromiseBuiltinsAssembler::CreatePromiseResolvingFunctions(

Node* promise, Node* debug_event, Node* native_context) {

@@ -206,28 +340,17 @@ Node* PromiseBuiltinsAssembler::InternalPromiseThen(Node* context,

Branch(WordEqual(promise_fun, constructor), &fast_promise_capability,

&promise_capability);

- // TODO(gsathya): Remove deferred object and move

- // NewPromiseCapabability functions to TF.

+ // TODO(gsathya): Remove deferred object.

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);

+ Node* const capability = NewInternalPromiseCapability(context, 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);

+ Node* const capability = NewPromiseCapability(context, constructor);

var_deferred.Bind(capability);

Goto(&perform_promise_then);

}

@@ -397,15 +520,10 @@ Node* PromiseBuiltinsAssembler::InternalPerformPromiseThen(Node* context,

Bind(&out);

PromiseSetHasHandler(promise);

- // TODO(gsathya): This call will be removed once we don't have to

- // deal with deferred objects.

- Isolate* isolate = this->isolate();

- Callable getproperty_callable = CodeFactory::GetProperty(isolate);

- Node* const key =

- HeapConstant(isolate->factory()->NewStringFromAsciiChecked("promise"));

- Node* const result = CallStub(getproperty_callable, context, deferred, key);

- return result;

+ CSA_ASSERT(this, HasInstanceType(deferred, JS_PROMISE_CAPABILITY_TYPE));

+ Node* then_promise =

+ LoadObjectField(deferred, JSPromiseCapability::kPromiseOffset);

+ return then_promise;

}

// Promise fast path implementations rely on unmodified JSPromise instances.

@@ -618,37 +736,6 @@ BUILTIN(PromiseRejectClosure) {

return isolate->heap()->undefined_value();

}

-// ES#sec-createresolvingfunctions

-// CreateResolvingFunctions ( promise )

-TF_BUILTIN(CreateResolvingFunctions, PromiseBuiltinsAssembler) {

- Node* const promise = Parameter(1);

- Node* const debug_event = Parameter(2);

- Node* const context = Parameter(5);

- Node* const native_context = LoadNativeContext(context);

- Node* resolve = nullptr;

- Node* reject = nullptr;

- std::tie(resolve, reject) =

- CreatePromiseResolvingFunctions(promise, debug_event, native_context);

- Node* const kSize = IntPtrConstant(2);

- const ElementsKind kind = FAST_ELEMENTS;

- const WriteBarrierMode barrier_mode = SKIP_WRITE_BARRIER;

- const ParameterMode parameter_mode = INTPTR_PARAMETERS;

- Node* const arr = AllocateFixedArray(kind, kSize, parameter_mode);

- StoreFixedArrayElement(arr, 0, resolve, barrier_mode);

- StoreFixedArrayElement(arr, 1, reject, barrier_mode);

- Node* const array_map = LoadJSArrayElementsMap(kind, native_context);

- Node* const length = SmiTag(kSize);

- Node* const result = AllocateUninitializedJSArrayWithoutElements(

- kind, array_map, length, nullptr);

- StoreObjectField(result, JSObject::kElementsOffset, arr);

- Return(result);

TF_BUILTIN(PromiseConstructor, PromiseBuiltinsAssembler) {

Node* const executor = Parameter(1);

Node* const new_target = Parameter(2);

@@ -915,11 +1002,9 @@ TF_BUILTIN(PromiseHandle, PromiseBuiltinsAssembler) {

Isolate* isolate = this->isolate();

// Get promise from deferred

- // TODO(gsathya): Remove this lookup by getting rid of the deferred object.

- Callable getproperty_callable = CodeFactory::GetProperty(isolate);

- Node* const key = HeapConstant(isolate->factory()->promise_string());

+ CSA_ASSERT(this, HasInstanceType(deferred, JS_PROMISE_CAPABILITY_TYPE));

Node* const deferred_promise =

- CallStub(getproperty_callable, context, deferred, key);

+ LoadObjectField(deferred, JSPromiseCapability::kPromiseOffset);

Variable var_reason(this, MachineRepresentation::kTagged);

@@ -947,10 +1032,8 @@ TF_BUILTIN(PromiseHandle, PromiseBuiltinsAssembler) {

GotoIfException(result, &if_rejectpromise, &var_reason);

- // 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);

+ LoadObjectField(deferred, JSPromiseCapability::kResolveOffset);

Label if_internalhandler(this), if_customhandler(this, Label::kDeferred);

Branch(IsUndefined(on_resolve), &if_internalhandler, &if_customhandler);

@@ -970,10 +1053,8 @@ TF_BUILTIN(PromiseHandle, PromiseBuiltinsAssembler) {

Bind(&if_rejectpromise);

{

- // TODO(gsathya): Remove this lookup by getting rid of the deferred object.

- Node* const key = HeapConstant(isolate->factory()->reject_string());

Node* const on_reject =

- CallStub(getproperty_callable, context, deferred, key);

+ LoadObjectField(deferred, JSPromiseCapability::kRejectOffset);

Callable promise_handle_reject = CodeFactory::PromiseHandleReject(isolate);

CallStub(promise_handle_reject, context, deferred_promise, on_reject,

@@ -1034,5 +1115,51 @@ TF_BUILTIN(PromiseCatch, PromiseBuiltinsAssembler) {

}

+TF_BUILTIN(PromiseGetCapabilitiesExecutor, PromiseBuiltinsAssembler) {

+ Node* const resolve = Parameter(1);

+ Node* const reject = Parameter(2);

+ Node* const context = Parameter(5);

+ Node* const capability = LoadContextElement(

+ context, GetPromiseCapabilityExecutor::kCapabilitySlot);

+ Label if_alreadyinvoked(this, Label::kDeferred);

+ GotoIf(WordNotEqual(

+ LoadObjectField(capability, JSPromiseCapability::kResolveOffset),

+ UndefinedConstant()),

+ &if_alreadyinvoked);

+ GotoIf(WordNotEqual(

+ LoadObjectField(capability, JSPromiseCapability::kRejectOffset),

+ UndefinedConstant()),

+ &if_alreadyinvoked);

+ StoreObjectField(capability, JSPromiseCapability::kResolveOffset, resolve);

+ StoreObjectField(capability, JSPromiseCapability::kRejectOffset, reject);

+ Return(UndefinedConstant());

+ Bind(&if_alreadyinvoked);

+ Node* message = SmiConstant(MessageTemplate::kPromiseExecutorAlreadyInvoked);

+ Return(CallRuntime(Runtime::kThrowTypeError, context, message));

+TF_BUILTIN(NewPromiseCapability, PromiseBuiltinsAssembler) {

+ Node* constructor = Parameter(1);

+ Node* debug_event = Parameter(2);

+ Node* context = Parameter(5);

+ CSA_ASSERT_JS_ARGC_EQ(this, 2);

+ Return(NewPromiseCapability(context, constructor, debug_event));

+TF_BUILTIN(NewInternalPromiseCapability, PromiseBuiltinsAssembler) {

+ Node* parent = Parameter(1);

+ Node* context = Parameter(4);

+ CSA_ASSERT_JS_ARGC_EQ(this, 1);

+ Return(NewInternalPromiseCapability(context, parent));

} // namespace internal

} // namespace v8

« src/builtins/builtins-promise.h ('K') | « src/builtins/builtins-promise.h ('k') | src/code-stub-assembler.h » ('j') | src/code-stub-assembler.h » ('J')