// 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" #include "src/objects-inl.h" namespace v8 { namespace internal { typedef compiler::Node Node; typedef CodeStubAssembler::ParameterMode ParameterMode; typedef compiler::CodeAssemblerState CodeAssemblerState; Node* PromiseBuiltinsAssembler::AllocateJSPromise(Node* context) { Node* const native_context = LoadNativeContext(context); Node* const promise_fun = LoadContextElement(native_context, Context::PROMISE_FUNCTION_INDEX); Node* const initial_map = LoadObjectField(promise_fun, JSFunction::kPrototypeOrInitialMapOffset); Node* const instance = AllocateJSObjectFromMap(initial_map); return instance; } void PromiseBuiltinsAssembler::PromiseInit(Node* promise) { StoreObjectField(promise, JSPromise::kStatusOffset, SmiConstant(v8::Promise::kPending)); StoreObjectField(promise, JSPromise::kFlagsOffset, SmiConstant(0)); } Node* PromiseBuiltinsAssembler::AllocateAndInitJSPromise(Node* context) { return AllocateAndInitJSPromise(context, UndefinedConstant()); } Node* PromiseBuiltinsAssembler::AllocateAndInitJSPromise(Node* context, Node* parent) { Node* const instance = AllocateJSPromise(context); PromiseInit(instance); Label out(this); GotoIfNot(IsPromiseHookEnabledOrDebugIsActive(), &out); CallRuntime(Runtime::kPromiseHookInit, context, instance, parent); Goto(&out); Bind(&out); return instance; } Node* PromiseBuiltinsAssembler::AllocateAndSetJSPromise(Node* context, Node* status, Node* result) { CSA_ASSERT(this, TaggedIsSmi(status)); Node* const instance = AllocateJSPromise(context); StoreObjectFieldNoWriteBarrier(instance, JSPromise::kStatusOffset, status); StoreObjectFieldNoWriteBarrier(instance, JSPromise::kResultOffset, result); StoreObjectFieldNoWriteBarrier(instance, JSPromise::kFlagsOffset, SmiConstant(0)); Label out(this); GotoIfNot(IsPromiseHookEnabledOrDebugIsActive(), &out); CallRuntime(Runtime::kPromiseHookInit, context, instance, UndefinedConstant()); Goto(&out); Bind(&out); return instance; } std::pair PromiseBuiltinsAssembler::CreatePromiseResolvingFunctions( Node* promise, Node* debug_event, Node* native_context) { Node* const promise_context = CreatePromiseResolvingFunctionsContext( promise, debug_event, native_context); Node* const map = LoadContextElement( native_context, Context::STRICT_FUNCTION_WITHOUT_PROTOTYPE_MAP_INDEX); Node* const resolve_info = LoadContextElement(native_context, Context::PROMISE_RESOLVE_SHARED_FUN); Node* const resolve = AllocateFunctionWithMapAndContext(map, resolve_info, promise_context); Node* const reject_info = LoadContextElement(native_context, Context::PROMISE_REJECT_SHARED_FUN); Node* const reject = AllocateFunctionWithMapAndContext(map, reject_info, promise_context); return std::make_pair(resolve, reject); } 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( 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, Label::kDeferred), out(this); 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); GotoIfNot(IsPromiseHookEnabledOrDebugIsActive(), &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); GotoIfNot(IsCallableMap(LoadMap(resolve)), &if_notcallable); Node* reject = LoadObjectField(capability, JSPromiseCapability::kRejectOffset); GotoIf(TaggedIsSmi(reject), &if_notcallable); GotoIfNot(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); Unreachable(); } Bind(&out); return var_result.value(); } Node* PromiseBuiltinsAssembler::CreatePromiseContext(Node* native_context, int slots) { DCHECK_GE(slots, Context::MIN_CONTEXT_SLOTS); Node* const context = Allocate(FixedArray::SizeFor(slots)); StoreMapNoWriteBarrier(context, Heap::kFunctionContextMapRootIndex); StoreObjectFieldNoWriteBarrier(context, FixedArray::kLengthOffset, SmiConstant(slots)); Node* const empty_fn = LoadContextElement(native_context, Context::CLOSURE_INDEX); StoreContextElementNoWriteBarrier(context, Context::CLOSURE_INDEX, empty_fn); 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, kPromiseContextLength); StoreContextElementNoWriteBarrier(context, kAlreadyVisitedSlot, SmiConstant(0)); StoreContextElementNoWriteBarrier(context, kPromiseSlot, promise); StoreContextElementNoWriteBarrier(context, kDebugEventSlot, debug_event); return context; } Node* PromiseBuiltinsAssembler::CreatePromiseGetCapabilitiesExecutorContext( Node* promise_capability, Node* native_context) { int kContextLength = kCapabilitiesContextLength; Node* context = CreatePromiseContext(native_context, kContextLength); StoreContextElementNoWriteBarrier(context, kCapabilitySlot, promise_capability); return context; } Node* PromiseBuiltinsAssembler::ThrowIfNotJSReceiver( Node* context, Node* value, MessageTemplate::Template msg_template, const char* method_name) { Label out(this), throw_exception(this, Label::kDeferred); Variable var_value_map(this, MachineRepresentation::kTagged); GotoIf(TaggedIsSmi(value), &throw_exception); // Load the instance type of the {value}. var_value_map.Bind(LoadMap(value)); Node* const value_instance_type = LoadMapInstanceType(var_value_map.value()); Branch(IsJSReceiverInstanceType(value_instance_type), &out, &throw_exception); // The {value} is not a compatible receiver for this method. Bind(&throw_exception); { Node* const method = method_name == nullptr ? UndefinedConstant() : HeapConstant( isolate()->factory()->NewStringFromAsciiChecked(method_name)); Node* const message_id = SmiConstant(msg_template); CallRuntime(Runtime::kThrowTypeError, context, message_id, method); Unreachable(); } Bind(&out); return var_value_map.value(); } Node* PromiseBuiltinsAssembler::PromiseHasHandler(Node* promise) { Node* const flags = LoadObjectField(promise, JSPromise::kFlagsOffset); 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); Node* const constructor = CallStub(getproperty_callable, context, object, constructor_str); // 3. If C is undefined, return defaultConstructor. Label out(this); GotoIf(IsUndefined(constructor), &out); // 4. If Type(C) is not Object, throw a TypeError exception. ThrowIfNotJSReceiver(context, constructor, MessageTemplate::kConstructorNotReceiver); // 5. Let S be ? Get(C, @@species). Node* const species_symbol = HeapConstant(isolate->factory()->species_symbol()); Node* const species = CallStub(getproperty_callable, context, constructor, species_symbol); // 6. If S is either undefined or null, return defaultConstructor. GotoIf(IsUndefined(species), &out); GotoIf(WordEqual(species, NullConstant()), &out); // 7. If IsConstructor(S) is true, return S. Label throw_error(this); Node* species_bitfield = LoadMapBitField(LoadMap(species)); GotoIfNot(Word32Equal(Word32And(species_bitfield, Int32Constant((1 << Map::kIsConstructor))), Int32Constant(1 << Map::kIsConstructor)), &throw_error); var_result.Bind(species); Goto(&out); // 8. Throw a TypeError exception. Bind(&throw_error); { Node* const message_id = SmiConstant(MessageTemplate::kSpeciesNotConstructor); CallRuntime(Runtime::kThrowTypeError, context, message_id); Unreachable(); } Bind(&out); return var_result.value(); } void PromiseBuiltinsAssembler::AppendPromiseCallback(int offset, Node* promise, Node* value) { Node* elements = LoadObjectField(promise, offset); Node* length = LoadFixedArrayBaseLength(elements); CodeStubAssembler::ParameterMode mode = OptimalParameterMode(); length = TaggedToParameter(length, mode); Node* delta = IntPtrOrSmiConstant(1, mode); Node* new_capacity = IntPtrOrSmiAdd(length, delta, mode); const ElementsKind kind = FAST_ELEMENTS; const WriteBarrierMode barrier_mode = UPDATE_WRITE_BARRIER; const CodeStubAssembler::AllocationFlags flags = CodeStubAssembler::kAllowLargeObjectAllocation; int additional_offset = 0; 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_promise(this, MachineRepresentation::kTagged), var_deferred_on_resolve(this, MachineRepresentation::kTagged), var_deferred_on_reject(this, MachineRepresentation::kTagged); Branch(WordEqual(promise_fun, constructor), &fast_promise_capability, &promise_capability); Bind(&fast_promise_capability); { Node* const deferred_promise = AllocateAndInitJSPromise(context, promise); var_deferred_promise.Bind(deferred_promise); var_deferred_on_resolve.Bind(UndefinedConstant()); var_deferred_on_reject.Bind(UndefinedConstant()); Goto(&perform_promise_then); } Bind(&promise_capability); { Node* const capability = NewPromiseCapability(context, constructor); var_deferred_promise.Bind( LoadObjectField(capability, JSPromiseCapability::kPromiseOffset)); var_deferred_on_resolve.Bind( LoadObjectField(capability, JSPromiseCapability::kResolveOffset)); var_deferred_on_reject.Bind( LoadObjectField(capability, JSPromiseCapability::kRejectOffset)); 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_promise.value(), var_deferred_on_resolve.value(), var_deferred_on_reject.value()); return result; } Node* PromiseBuiltinsAssembler::InternalPerformPromiseThen( Node* context, Node* promise, Node* on_resolve, Node* on_reject, Node* deferred_promise, Node* deferred_on_resolve, Node* deferred_on_reject) { Variable var_on_resolve(this, MachineRepresentation::kTagged), var_on_reject(this, MachineRepresentation::kTagged); var_on_resolve.Bind(on_resolve); var_on_reject.Bind(on_reject); Label out(this), if_onresolvenotcallable(this), onrejectcheck(this), append_callbacks(this); GotoIf(TaggedIsSmi(on_resolve), &if_onresolvenotcallable); Isolate* isolate = this->isolate(); Node* const on_resolve_map = LoadMap(on_resolve); Branch(IsCallableMap(on_resolve_map), &onrejectcheck, &if_onresolvenotcallable); Bind(&if_onresolvenotcallable); { Node* const default_resolve_handler_symbol = HeapConstant( isolate->factory()->promise_default_resolve_handler_symbol()); var_on_resolve.Bind(default_resolve_handler_symbol); Goto(&onrejectcheck); } Bind(&onrejectcheck); { Label if_onrejectnotcallable(this); GotoIf(TaggedIsSmi(on_reject), &if_onrejectnotcallable); Node* const on_reject_map = LoadMap(on_reject); Branch(IsCallableMap(on_reject_map), &append_callbacks, &if_onrejectnotcallable); Bind(&if_onrejectnotcallable); { Node* const default_reject_handler_symbol = HeapConstant( isolate->factory()->promise_default_reject_handler_symbol()); var_on_reject.Bind(default_reject_handler_symbol); Goto(&append_callbacks); } } Bind(&append_callbacks); { Label fulfilled_check(this); Node* const status = LoadObjectField(promise, JSPromise::kStatusOffset); GotoIfNot(SmiEqual(status, SmiConstant(v8::Promise::kPending)), &fulfilled_check); Node* const existing_deferred_promise = LoadObjectField(promise, JSPromise::kDeferredPromiseOffset); Label if_noexistingcallbacks(this), if_existingcallbacks(this); Branch(IsUndefined(existing_deferred_promise), &if_noexistingcallbacks, &if_existingcallbacks); Bind(&if_noexistingcallbacks); { // Store callbacks directly in the slots. StoreObjectField(promise, JSPromise::kDeferredPromiseOffset, deferred_promise); StoreObjectField(promise, JSPromise::kDeferredOnResolveOffset, deferred_on_resolve); StoreObjectField(promise, JSPromise::kDeferredOnRejectOffset, deferred_on_reject); StoreObjectField(promise, JSPromise::kFulfillReactionsOffset, var_on_resolve.value()); StoreObjectField(promise, JSPromise::kRejectReactionsOffset, var_on_reject.value()); Goto(&out); } Bind(&if_existingcallbacks); { Label if_singlecallback(this), if_multiplecallbacks(this); BranchIfJSObject(existing_deferred_promise, &if_singlecallback, &if_multiplecallbacks); Bind(&if_singlecallback); { // Create new FixedArrays to store callbacks, and migrate // existing callbacks. Node* const deferred_promise_arr = AllocateFixedArray(FAST_ELEMENTS, IntPtrConstant(2)); StoreFixedArrayElement(deferred_promise_arr, 0, existing_deferred_promise); StoreFixedArrayElement(deferred_promise_arr, 1, deferred_promise); Node* const deferred_on_resolve_arr = AllocateFixedArray(FAST_ELEMENTS, IntPtrConstant(2)); StoreFixedArrayElement( deferred_on_resolve_arr, 0, LoadObjectField(promise, JSPromise::kDeferredOnResolveOffset)); StoreFixedArrayElement(deferred_on_resolve_arr, 1, deferred_on_resolve); Node* const deferred_on_reject_arr = AllocateFixedArray(FAST_ELEMENTS, IntPtrConstant(2)); StoreFixedArrayElement( deferred_on_reject_arr, 0, LoadObjectField(promise, JSPromise::kDeferredOnRejectOffset)); StoreFixedArrayElement(deferred_on_reject_arr, 1, deferred_on_reject); Node* const fulfill_reactions = AllocateFixedArray(FAST_ELEMENTS, IntPtrConstant(2)); StoreFixedArrayElement( fulfill_reactions, 0, LoadObjectField(promise, JSPromise::kFulfillReactionsOffset)); StoreFixedArrayElement(fulfill_reactions, 1, var_on_resolve.value()); Node* const reject_reactions = AllocateFixedArray(FAST_ELEMENTS, IntPtrConstant(2)); StoreFixedArrayElement( reject_reactions, 0, LoadObjectField(promise, JSPromise::kRejectReactionsOffset)); StoreFixedArrayElement(reject_reactions, 1, var_on_reject.value()); // Store new FixedArrays in promise. StoreObjectField(promise, JSPromise::kDeferredPromiseOffset, deferred_promise_arr); StoreObjectField(promise, JSPromise::kDeferredOnResolveOffset, deferred_on_resolve_arr); StoreObjectField(promise, JSPromise::kDeferredOnRejectOffset, deferred_on_reject_arr); StoreObjectField(promise, JSPromise::kFulfillReactionsOffset, fulfill_reactions); StoreObjectField(promise, JSPromise::kRejectReactionsOffset, reject_reactions); Goto(&out); } Bind(&if_multiplecallbacks); { AppendPromiseCallback(JSPromise::kDeferredPromiseOffset, promise, deferred_promise); AppendPromiseCallback(JSPromise::kDeferredOnResolveOffset, promise, deferred_on_resolve); AppendPromiseCallback(JSPromise::kDeferredOnRejectOffset, promise, deferred_on_reject); AppendPromiseCallback(JSPromise::kFulfillReactionsOffset, promise, var_on_resolve.value()); AppendPromiseCallback(JSPromise::kRejectReactionsOffset, promise, var_on_reject.value()); Goto(&out); } } Bind(&fulfilled_check); { Label reject(this); Node* const result = LoadObjectField(promise, JSPromise::kResultOffset); GotoIfNot(WordEqual(status, SmiConstant(v8::Promise::kFulfilled)), &reject); Node* info = AllocatePromiseReactionJobInfo( result, var_on_resolve.value(), deferred_promise, deferred_on_resolve, deferred_on_reject, context); // TODO(gsathya): Move this to TF CallRuntime(Runtime::kEnqueuePromiseReactionJob, context, info); Goto(&out); Bind(&reject); { Node* const has_handler = PromiseHasHandler(promise); Label enqueue(this); // TODO(gsathya): Fold these runtime calls and move to TF. GotoIf(has_handler, &enqueue); CallRuntime(Runtime::kPromiseRevokeReject, context, promise); Goto(&enqueue); Bind(&enqueue); { Node* info = AllocatePromiseReactionJobInfo( result, var_on_reject.value(), deferred_promise, deferred_on_resolve, deferred_on_reject, context); // TODO(gsathya): Move this to TF CallRuntime(Runtime::kEnqueuePromiseReactionJob, context, info); Goto(&out); } } } } Bind(&out); PromiseSetHasHandler(promise); return deferred_promise; } // Promise fast path implementations rely on unmodified JSPromise instances. // We use a fairly coarse granularity for this and simply check whether both // the promise itself is unmodified (i.e. its map has not changed) and its // prototype is unmodified. // TODO(gsathya): Refactor this out to prevent code dupe with builtins-regexp void PromiseBuiltinsAssembler::BranchIfFastPath(Node* context, Node* promise, Label* if_isunmodified, Label* if_ismodified) { Node* const native_context = LoadNativeContext(context); Node* const promise_fun = LoadContextElement(native_context, Context::PROMISE_FUNCTION_INDEX); BranchIfFastPath(native_context, promise_fun, promise, if_isunmodified, if_ismodified); } void PromiseBuiltinsAssembler::BranchIfFastPath(Node* native_context, Node* promise_fun, Node* promise, Label* if_isunmodified, Label* if_ismodified) { CSA_ASSERT(this, IsNativeContext(native_context)); CSA_ASSERT(this, WordEqual(promise_fun, LoadContextElement(native_context, Context::PROMISE_FUNCTION_INDEX))); Node* const map = LoadMap(promise); Node* const initial_map = LoadObjectField(promise_fun, JSFunction::kPrototypeOrInitialMapOffset); Node* const has_initialmap = WordEqual(map, initial_map); GotoIfNot(has_initialmap, if_ismodified); Node* const initial_proto_initial_map = 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); } Node* PromiseBuiltinsAssembler::AllocatePromiseResolveThenableJobInfo( Node* thenable, Node* then, Node* resolve, Node* reject, Node* context) { Node* const info = Allocate(PromiseResolveThenableJobInfo::kSize); StoreMapNoWriteBarrier(info, Heap::kPromiseResolveThenableJobInfoMapRootIndex); StoreObjectFieldNoWriteBarrier( info, PromiseResolveThenableJobInfo::kThenableOffset, thenable); StoreObjectFieldNoWriteBarrier( info, PromiseResolveThenableJobInfo::kThenOffset, then); StoreObjectFieldNoWriteBarrier( info, PromiseResolveThenableJobInfo::kResolveOffset, resolve); StoreObjectFieldNoWriteBarrier( info, PromiseResolveThenableJobInfo::kRejectOffset, reject); StoreObjectFieldNoWriteBarrier( info, PromiseResolveThenableJobInfo::kContextOffset, context); return info; } void PromiseBuiltinsAssembler::InternalResolvePromise(Node* context, Node* promise, 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), out(this); Label cycle_check(this); GotoIfNot(IsPromiseHookEnabledOrDebugIsActive(), &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); // 7. If Type(resolution) is not Object, then GotoIf(TaggedIsSmi(result), &fulfill); GotoIfNot(IsJSReceiver(result), &fulfill); Label if_nativepromise(this), if_notnativepromise(this, Label::kDeferred); Node* const native_context = LoadNativeContext(context); Node* const promise_fun = LoadContextElement(native_context, Context::PROMISE_FUNCTION_INDEX); BranchIfFastPath(native_context, promise_fun, result, &if_nativepromise, &if_notnativepromise); // Resolution is a native promise and if it's already resolved or // rejected, shortcircuit the resolution procedure by directly // reusing the value from the promise. Bind(&if_nativepromise); { Node* const thenable_status = LoadObjectField(result, JSPromise::kStatusOffset); Node* const thenable_value = LoadObjectField(result, JSPromise::kResultOffset); Label if_isnotpending(this); GotoIfNot(SmiEqual(SmiConstant(v8::Promise::kPending), thenable_status), &if_isnotpending); // TODO(gsathya): Use a marker here instead of the actual then // callback, and check for the marker in PromiseResolveThenableJob // and perform PromiseThen. Node* const then = LoadContextElement(native_context, Context::PROMISE_THEN_INDEX); var_then.Bind(then); Goto(&do_enqueue); Bind(&if_isnotpending); { Label if_fulfilled(this), if_rejected(this); Branch(SmiEqual(SmiConstant(v8::Promise::kFulfilled), thenable_status), &if_fulfilled, &if_rejected); Bind(&if_fulfilled); { PromiseFulfill(context, promise, thenable_value, v8::Promise::kFulfilled); PromiseSetHasHandler(promise); 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 InternalPromiseReject(context, promise, thenable_value, false); PromiseSetHasHandler(result); 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 = CallStub(getproperty_callable, context, result, then_str); // 9. If then is an abrupt completion, then GotoIfException(then, &if_rejectpromise, &var_reason); // 11. If IsCallable(thenAction) is false, then GotoIf(TaggedIsSmi(then), &fulfill); Node* const then_map = LoadMap(then); GotoIfNot(IsCallableMap(then_map), &fulfill); var_then.Bind(then); Goto(&do_enqueue); } Bind(&do_enqueue); { // TODO(gsathya): Add fast path for native promises with unmodified // PromiseThen (which don't need these resolving functions, but // instead can just call resolve/reject directly). Node* resolve = nullptr; Node* reject = nullptr; std::tie(resolve, reject) = CreatePromiseResolvingFunctions( promise, FalseConstant(), native_context); Node* const info = AllocatePromiseResolveThenableJobInfo( result, var_then.value(), resolve, reject, context); Label enqueue(this); GotoIfNot(IsDebugActive(), &enqueue); GotoIf(TaggedIsSmi(result), &enqueue); GotoIfNot(HasInstanceType(result, JS_PROMISE_TYPE), &enqueue); // Mark the dependency of the new promise on the resolution Node* const key = HeapConstant(isolate->factory()->promise_handled_by_symbol()); CallRuntime(Runtime::kSetProperty, context, result, key, promise, SmiConstant(STRICT)); Goto(&enqueue); // 12. Perform EnqueueJob("PromiseJobs", // PromiseResolveThenableJob, « promise, resolution, thenAction»). Bind(&enqueue); // TODO(gsathya): Move this to TF CallRuntime(Runtime::kEnqueuePromiseResolveThenableJob, context, info); Goto(&out); } // 7.b Return FulfillPromise(promise, resolution). Bind(&fulfill); { PromiseFulfill(context, promise, result, v8::Promise::kFulfilled); 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); { InternalPromiseReject(context, promise, var_reason.value(), true); Goto(&out); } Bind(&out); } void PromiseBuiltinsAssembler::PromiseFulfill( Node* context, Node* promise, Node* result, v8::Promise::PromiseState status) { Label do_promisereset(this), debug_async_event_enqueue_recurring(this); Node* const status_smi = SmiConstant(static_cast(status)); Node* const deferred_promise = LoadObjectField(promise, JSPromise::kDeferredPromiseOffset); GotoIf(IsUndefined(deferred_promise), &debug_async_event_enqueue_recurring); Node* const tasks = status == v8::Promise::kFulfilled ? LoadObjectField(promise, JSPromise::kFulfillReactionsOffset) : LoadObjectField(promise, JSPromise::kRejectReactionsOffset); Node* const deferred_on_resolve = LoadObjectField(promise, JSPromise::kDeferredOnResolveOffset); Node* const deferred_on_reject = LoadObjectField(promise, JSPromise::kDeferredOnRejectOffset); Node* const info = AllocatePromiseReactionJobInfo( result, tasks, deferred_promise, deferred_on_resolve, deferred_on_reject, context); CallRuntime(Runtime::kEnqueuePromiseReactionJob, context, info); Goto(&debug_async_event_enqueue_recurring); Bind(&debug_async_event_enqueue_recurring); { GotoIfNot(IsDebugActive(), &do_promisereset); CallRuntime(Runtime::kDebugAsyncEventEnqueueRecurring, context, promise, status_smi); Goto(&do_promisereset); } Bind(&do_promisereset); { StoreObjectField(promise, JSPromise::kStatusOffset, status_smi); StoreObjectField(promise, JSPromise::kResultOffset, result); StoreObjectFieldRoot(promise, JSPromise::kDeferredPromiseOffset, Heap::kUndefinedValueRootIndex); StoreObjectFieldRoot(promise, JSPromise::kDeferredOnResolveOffset, Heap::kUndefinedValueRootIndex); StoreObjectFieldRoot(promise, JSPromise::kDeferredOnRejectOffset, Heap::kUndefinedValueRootIndex); StoreObjectFieldRoot(promise, JSPromise::kFulfillReactionsOffset, Heap::kUndefinedValueRootIndex); StoreObjectFieldRoot(promise, JSPromise::kRejectReactionsOffset, Heap::kUndefinedValueRootIndex); } } void PromiseBuiltinsAssembler::BranchIfAccessCheckFailed( Node* context, Node* native_context, Node* promise_constructor, Node* executor, Label* if_noaccess) { Variable var_executor(this, MachineRepresentation::kTagged); var_executor.Bind(executor); Label has_access(this), call_runtime(this, Label::kDeferred); // If executor is a bound function, load the bound function until we've // reached an actual function. Label found_function(this), loop_over_bound_function(this, &var_executor); Goto(&loop_over_bound_function); Bind(&loop_over_bound_function); { Node* executor_type = LoadInstanceType(var_executor.value()); GotoIf(InstanceTypeEqual(executor_type, JS_FUNCTION_TYPE), &found_function); GotoIfNot(InstanceTypeEqual(executor_type, JS_BOUND_FUNCTION_TYPE), &call_runtime); var_executor.Bind(LoadObjectField( var_executor.value(), JSBoundFunction::kBoundTargetFunctionOffset)); Goto(&loop_over_bound_function); } // Load the context from the function and compare it to the Promise // constructor's context. If they match, everything is fine, otherwise, bail // out to the runtime. Bind(&found_function); { Node* function_context = LoadObjectField(var_executor.value(), JSFunction::kContextOffset); Node* native_function_context = LoadNativeContext(function_context); Branch(WordEqual(native_context, native_function_context), &has_access, &call_runtime); } Bind(&call_runtime); { Branch(WordEqual(CallRuntime(Runtime::kAllowDynamicFunction, context, promise_constructor), BooleanConstant(true)), &has_access, if_noaccess); } Bind(&has_access); } void PromiseBuiltinsAssembler::InternalPromiseReject(Node* context, Node* promise, Node* value, Node* debug_event) { Label out(this); GotoIfNot(IsDebugActive(), &out); GotoIfNot(WordEqual(TrueConstant(), debug_event), &out); CallRuntime(Runtime::kDebugPromiseReject, context, promise, value); Goto(&out); Bind(&out); InternalPromiseReject(context, promise, value, false); } // This duplicates a lot of logic from PromiseRejectEvent in // runtime-promise.cc void PromiseBuiltinsAssembler::InternalPromiseReject(Node* context, Node* promise, Node* value, bool debug_event) { Label fulfill(this), report_unhandledpromise(this), run_promise_hook(this); if (debug_event) { GotoIfNot(IsDebugActive(), &run_promise_hook); CallRuntime(Runtime::kDebugPromiseReject, context, promise, value); Goto(&run_promise_hook); } else { Goto(&run_promise_hook); } Bind(&run_promise_hook); { GotoIfNot(IsPromiseHookEnabledOrDebugIsActive(), &report_unhandledpromise); CallRuntime(Runtime::kPromiseHookResolve, context, promise); Goto(&report_unhandledpromise); } Bind(&report_unhandledpromise); { GotoIf(PromiseHasHandler(promise), &fulfill); CallRuntime(Runtime::kReportPromiseReject, context, promise, value); Goto(&fulfill); } Bind(&fulfill); PromiseFulfill(context, promise, value, v8::Promise::kRejected); } // ES#sec-promise-reject-functions // Promise Reject Functions TF_BUILTIN(PromiseRejectClosure, PromiseBuiltinsAssembler) { Node* const value = Parameter(1); Node* const context = Parameter(4); Label out(this); // 3. Let alreadyResolved be F.[[AlreadyResolved]]. int has_already_visited_slot = kAlreadyVisitedSlot; Node* const has_already_visited = LoadContextElement(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. StoreContextElementNoWriteBarrier(context, has_already_visited_slot, SmiConstant(1)); // 2. Let promise be F.[[Promise]]. Node* const promise = LoadContextElement(context, IntPtrConstant(kPromiseSlot)); Node* const debug_event = LoadContextElement(context, IntPtrConstant(kDebugEventSlot)); InternalPromiseReject(context, promise, value, debug_event); Return(UndefinedConstant()); Bind(&out); Return(UndefinedConstant()); } TF_BUILTIN(PromiseConstructor, PromiseBuiltinsAssembler) { Node* const executor = Parameter(1); Node* const new_target = Parameter(2); Node* const context = Parameter(4); Isolate* isolate = this->isolate(); Label if_targetisundefined(this, Label::kDeferred); GotoIf(IsUndefined(new_target), &if_targetisundefined); Label if_notcallable(this, Label::kDeferred); GotoIf(TaggedIsSmi(executor), &if_notcallable); Node* const executor_map = LoadMap(executor); GotoIfNot(IsCallableMap(executor_map), &if_notcallable); Node* const native_context = LoadNativeContext(context); Node* const promise_fun = LoadContextElement(native_context, Context::PROMISE_FUNCTION_INDEX); Node* const is_debug_active = IsDebugActive(); Label if_targetisnotmodified(this), if_targetismodified(this, Label::kDeferred), run_executor(this), debug_push(this), if_noaccess(this, Label::kDeferred); BranchIfAccessCheckFailed(context, native_context, promise_fun, executor, &if_noaccess); Branch(WordEqual(promise_fun, new_target), &if_targetisnotmodified, &if_targetismodified); Variable var_result(this, MachineRepresentation::kTagged), var_reject_call(this, MachineRepresentation::kTagged), var_reason(this, MachineRepresentation::kTagged); Bind(&if_targetisnotmodified); { Node* const instance = AllocateAndInitJSPromise(context); var_result.Bind(instance); Goto(&debug_push); } Bind(&if_targetismodified); { ConstructorBuiltinsAssembler constructor_assembler(this->state()); Node* const instance = constructor_assembler.EmitFastNewObject( context, promise_fun, new_target); PromiseInit(instance); var_result.Bind(instance); GotoIfNot(IsPromiseHookEnabledOrDebugIsActive(), &debug_push); CallRuntime(Runtime::kPromiseHookInit, context, instance, UndefinedConstant()); Goto(&debug_push); } Bind(&debug_push); { GotoIfNot(is_debug_active, &run_executor); CallRuntime(Runtime::kDebugPushPromise, context, var_result.value()); Goto(&run_executor); } Bind(&run_executor); { Label out(this), if_rejectpromise(this), debug_pop(this, Label::kDeferred); Node *resolve, *reject; std::tie(resolve, reject) = CreatePromiseResolvingFunctions( var_result.value(), TrueConstant(), native_context); Callable call_callable = CodeFactory::Call(isolate); Node* const maybe_exception = CallJS(call_callable, context, executor, UndefinedConstant(), resolve, reject); GotoIfException(maybe_exception, &if_rejectpromise, &var_reason); Branch(is_debug_active, &debug_pop, &out); Bind(&if_rejectpromise); { Callable call_callable = CodeFactory::Call(isolate); CallJS(call_callable, context, reject, UndefinedConstant(), var_reason.value()); Branch(is_debug_active, &debug_pop, &out); } Bind(&debug_pop); { CallRuntime(Runtime::kDebugPopPromise, context); Goto(&out); } Bind(&out); Return(var_result.value()); } // 1. If NewTarget is undefined, throw a TypeError exception. Bind(&if_targetisundefined); { Node* const message_id = SmiConstant(MessageTemplate::kNotAPromise); CallRuntime(Runtime::kThrowTypeError, context, message_id, new_target); Unreachable(); } // 2. If IsCallable(executor) is false, throw a TypeError exception. Bind(&if_notcallable); { Node* const message_id = SmiConstant(MessageTemplate::kResolverNotAFunction); CallRuntime(Runtime::kThrowTypeError, context, message_id, executor); Unreachable(); } // Silently fail if the stack looks fishy. Bind(&if_noaccess); { Node* const counter_id = SmiConstant(v8::Isolate::kPromiseConstructorReturnedUndefined); CallRuntime(Runtime::kIncrementUseCounter, context, counter_id); Return(UndefinedConstant()); } } TF_BUILTIN(PromiseInternalConstructor, PromiseBuiltinsAssembler) { Node* const parent = Parameter(1); Node* const context = Parameter(4); Return(AllocateAndInitJSPromise(context, parent)); } TF_BUILTIN(IsPromise, PromiseBuiltinsAssembler) { Node* const maybe_promise = Parameter(1); Label if_notpromise(this, Label::kDeferred); GotoIf(TaggedIsSmi(maybe_promise), &if_notpromise); Node* const result = SelectBooleanConstant(HasInstanceType(maybe_promise, JS_PROMISE_TYPE)); Return(result); Bind(&if_notpromise); Return(FalseConstant()); } // 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 = 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]]. int has_already_visited_slot = kAlreadyVisitedSlot; Node* const has_already_visited = LoadContextElement(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. StoreContextElementNoWriteBarrier(context, has_already_visited_slot, SmiConstant(1)); // 2. Let promise be F.[[Promise]]. Node* const promise = LoadContextElement(context, IntPtrConstant(kPromiseSlot)); 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); 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); Callable call_callable = CodeFactory::Call(isolate()); Variable var_unused(this, MachineRepresentation::kTagged); Label if_internalhandler(this), if_customhandler(this, Label::kDeferred); Branch(IsUndefined(on_reject), &if_internalhandler, &if_customhandler); Bind(&if_internalhandler); { InternalPromiseReject(context, promise, exception, false); Return(UndefinedConstant()); } Bind(&if_customhandler); { CallJS(call_callable, context, on_reject, UndefinedConstant(), exception); Return(UndefinedConstant()); } } TF_BUILTIN(PromiseHandle, PromiseBuiltinsAssembler) { Node* const value = Parameter(1); Node* const handler = Parameter(2); Node* const deferred_promise = Parameter(3); Node* const deferred_on_resolve = Parameter(4); Node* const deferred_on_reject = Parameter(5); Node* const context = Parameter(8); Isolate* isolate = this->isolate(); Variable var_reason(this, MachineRepresentation::kTagged); Node* const is_debug_active = IsDebugActive(); Label run_handler(this), if_rejectpromise(this), promisehook_before(this), promisehook_after(this), debug_pop(this); GotoIfNot(is_debug_active, &promisehook_before); CallRuntime(Runtime::kDebugPushPromise, context, deferred_promise); Goto(&promisehook_before); Bind(&promisehook_before); { GotoIfNot(IsPromiseHookEnabledOrDebugIsActive(), &run_handler); CallRuntime(Runtime::kPromiseHookBefore, context, deferred_promise); Goto(&run_handler); } Bind(&run_handler); { Label if_defaulthandler(this), if_callablehandler(this), if_internalhandler(this), if_customhandler(this, Label::kDeferred); Variable var_result(this, MachineRepresentation::kTagged); Branch(IsSymbol(handler), &if_defaulthandler, &if_callablehandler); Bind(&if_defaulthandler); { Label if_resolve(this), if_reject(this); Node* const default_resolve_handler_symbol = HeapConstant( isolate->factory()->promise_default_resolve_handler_symbol()); Branch(WordEqual(default_resolve_handler_symbol, handler), &if_resolve, &if_reject); Bind(&if_resolve); { var_result.Bind(value); Branch(IsUndefined(deferred_on_resolve), &if_internalhandler, &if_customhandler); } Bind(&if_reject); { var_reason.Bind(value); Goto(&if_rejectpromise); } } Bind(&if_callablehandler); { Callable call_callable = CodeFactory::Call(isolate); Node* const result = CallJS(call_callable, context, handler, UndefinedConstant(), value); var_result.Bind(result); GotoIfException(result, &if_rejectpromise, &var_reason); Branch(IsUndefined(deferred_on_resolve), &if_internalhandler, &if_customhandler); } Bind(&if_internalhandler); InternalResolvePromise(context, deferred_promise, var_result.value()); Goto(&promisehook_after); Bind(&if_customhandler); { Callable call_callable = CodeFactory::Call(isolate); Node* const maybe_exception = CallJS(call_callable, context, deferred_on_resolve, UndefinedConstant(), var_result.value()); GotoIfException(maybe_exception, &if_rejectpromise, &var_reason); Goto(&promisehook_after); } } Bind(&if_rejectpromise); { Callable promise_handle_reject = CodeFactory::PromiseHandleReject(isolate); CallStub(promise_handle_reject, context, deferred_promise, deferred_on_reject, var_reason.value()); Goto(&promisehook_after); } Bind(&promisehook_after); { GotoIfNot(IsPromiseHookEnabledOrDebugIsActive(), &debug_pop); CallRuntime(Runtime::kPromiseHookAfter, context, deferred_promise); Goto(&debug_pop); } Bind(&debug_pop); { Label out(this); GotoIfNot(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); GotoIf(TaggedIsSmi(promise), &if_customthen); 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); } } TF_BUILTIN(PromiseResolve, PromiseBuiltinsAssembler) { // 1. Let C be the this value. Node* receiver = Parameter(0); Node* value = Parameter(1); Node* context = Parameter(4); Isolate* isolate = this->isolate(); // 2. If Type(C) is not Object, throw a TypeError exception. ThrowIfNotJSReceiver(context, receiver, MessageTemplate::kCalledOnNonObject, "PromiseResolve"); Label if_valueisnativepromise(this), if_valueisnotnativepromise(this), if_valueisnotpromise(this); // 3.If IsPromise(x) is true, then GotoIf(TaggedIsSmi(value), &if_valueisnotpromise); // This shortcircuits the constructor lookups. GotoIfNot(HasInstanceType(value, JS_PROMISE_TYPE), &if_valueisnotpromise); // This adds a fast path as non-subclassed native promises don't have // an observable constructor lookup. Node* const native_context = LoadNativeContext(context); Node* const promise_fun = LoadContextElement(native_context, Context::PROMISE_FUNCTION_INDEX); BranchIfFastPath(native_context, promise_fun, value, &if_valueisnativepromise, &if_valueisnotnativepromise); Bind(&if_valueisnativepromise); { GotoIfNot(WordEqual(promise_fun, receiver), &if_valueisnotnativepromise); Return(value); } // At this point, value or/and receiver are not native promises, but // they could be of the same subclass. Bind(&if_valueisnotnativepromise); { // 3.a Let xConstructor be ? Get(x, "constructor"). // The constructor lookup is observable. Node* const constructor_str = HeapConstant(isolate->factory()->constructor_string()); Callable getproperty_callable = CodeFactory::GetProperty(isolate); Node* const constructor = CallStub(getproperty_callable, context, value, constructor_str); // 3.b If SameValue(xConstructor, C) is true, return x. GotoIfNot(SameValue(constructor, receiver, context), &if_valueisnotpromise); Return(value); } Bind(&if_valueisnotpromise); { Label if_nativepromise(this), if_notnativepromise(this); BranchIfFastPath(context, receiver, &if_nativepromise, &if_notnativepromise); // This adds a fast path for native promises that don't need to // create NewPromiseCapability. Bind(&if_nativepromise); { Label do_resolve(this); Node* const result = AllocateAndInitJSPromise(context); InternalResolvePromise(context, result, value); Return(result); } Bind(&if_notnativepromise); { // 4. Let promiseCapability be ? NewPromiseCapability(C). Node* const capability = NewPromiseCapability(context, receiver); // 5. Perform ? Call(promiseCapability.[[Resolve]], undefined, « x »). Callable call_callable = CodeFactory::Call(isolate); Node* const resolve = LoadObjectField(capability, JSPromiseCapability::kResolveOffset); CallJS(call_callable, context, resolve, UndefinedConstant(), value); // 6. Return promiseCapability.[[Promise]]. Node* const result = LoadObjectField(capability, JSPromiseCapability::kPromiseOffset); Return(result); } } } TF_BUILTIN(PromiseGetCapabilitiesExecutor, PromiseBuiltinsAssembler) { Node* const resolve = Parameter(1); Node* const reject = Parameter(2); Node* const context = Parameter(5); Node* const capability = LoadContextElement(context, 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); CallRuntime(Runtime::kThrowTypeError, context, message); Unreachable(); } 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(PromiseReject, PromiseBuiltinsAssembler) { // 1. Let C be the this value. Node* const receiver = Parameter(0); Node* const reason = Parameter(1); Node* const context = Parameter(4); // 2. If Type(C) is not Object, throw a TypeError exception. ThrowIfNotJSReceiver(context, receiver, MessageTemplate::kCalledOnNonObject, "PromiseReject"); Label if_nativepromise(this), if_custompromise(this, Label::kDeferred); Node* const native_context = LoadNativeContext(context); Node* const promise_fun = LoadContextElement(native_context, Context::PROMISE_FUNCTION_INDEX); Branch(WordEqual(promise_fun, receiver), &if_nativepromise, &if_custompromise); Bind(&if_nativepromise); { Node* const promise = AllocateAndSetJSPromise( context, SmiConstant(v8::Promise::kRejected), reason); CallRuntime(Runtime::kPromiseRejectEventFromStack, context, promise, reason); Return(promise); } Bind(&if_custompromise); { // 3. Let promiseCapability be ? NewPromiseCapability(C). Node* const capability = NewPromiseCapability(context, receiver); // 4. Perform ? Call(promiseCapability.[[Reject]], undefined, « r »). Node* const reject = LoadObjectField(capability, JSPromiseCapability::kRejectOffset); Callable call_callable = CodeFactory::Call(isolate()); CallJS(call_callable, context, reject, UndefinedConstant(), reason); // 5. Return promiseCapability.[[Promise]]. Node* const promise = LoadObjectField(capability, JSPromiseCapability::kPromiseOffset); Return(promise); } } TF_BUILTIN(InternalPromiseReject, PromiseBuiltinsAssembler) { Node* const promise = Parameter(1); Node* const reason = Parameter(2); Node* const debug_event = Parameter(3); Node* const context = Parameter(6); InternalPromiseReject(context, promise, reason, debug_event); Return(UndefinedConstant()); } Node* PromiseBuiltinsAssembler::CreatePromiseFinallyContext( Node* on_finally, Node* native_context) { Node* const context = CreatePromiseContext(native_context, kOnFinallyContextLength); StoreContextElementNoWriteBarrier(context, kOnFinallySlot, on_finally); return context; } std::pair PromiseBuiltinsAssembler::CreatePromiseFinallyFunctions( Node* on_finally, Node* native_context) { Node* const promise_context = CreatePromiseFinallyContext(on_finally, native_context); Node* const map = LoadContextElement( native_context, Context::STRICT_FUNCTION_WITHOUT_PROTOTYPE_MAP_INDEX); Node* const then_finally_info = LoadContextElement( native_context, Context::PROMISE_THEN_FINALLY_SHARED_FUN); Node* const then_finally = AllocateFunctionWithMapAndContext( map, then_finally_info, promise_context); Node* const catch_finally_info = LoadContextElement( native_context, Context::PROMISE_CATCH_FINALLY_SHARED_FUN); Node* const catch_finally = AllocateFunctionWithMapAndContext( map, catch_finally_info, promise_context); return std::make_pair(then_finally, catch_finally); } TF_BUILTIN(PromiseValueThunkFinally, PromiseBuiltinsAssembler) { Node* const context = Parameter(3); Node* const value = LoadContextElement(context, kOnFinallySlot); Return(value); } Node* PromiseBuiltinsAssembler::CreateValueThunkFunctionContext( Node* value, Node* native_context) { Node* const context = CreatePromiseContext(native_context, kOnFinallyContextLength); StoreContextElementNoWriteBarrier(context, kOnFinallySlot, value); return context; } Node* PromiseBuiltinsAssembler::CreateValueThunkFunction(Node* value, Node* native_context) { Node* const value_thunk_context = CreateValueThunkFunctionContext(value, native_context); Node* const map = LoadContextElement( native_context, Context::STRICT_FUNCTION_WITHOUT_PROTOTYPE_MAP_INDEX); Node* const value_thunk_info = LoadContextElement( native_context, Context::PROMISE_VALUE_THUNK_FINALLY_SHARED_FUN); Node* const value_thunk = AllocateFunctionWithMapAndContext( map, value_thunk_info, value_thunk_context); return value_thunk; } TF_BUILTIN(PromiseThenFinally, PromiseBuiltinsAssembler) { CSA_ASSERT_JS_ARGC_EQ(this, 1); Node* const value = Parameter(1); Node* const context = Parameter(4); Node* const on_finally = LoadContextElement(context, kOnFinallySlot); // 2.a Let result be ? Call(onFinally, undefined). Callable call_callable = CodeFactory::Call(isolate()); Node* result = CallJS(call_callable, context, on_finally, UndefinedConstant()); // 2.b Let promise be ! PromiseResolve( %Promise%, result). Node* const promise = AllocateAndInitJSPromise(context); InternalResolvePromise(context, promise, result); // 2.c Let valueThunk be equivalent to a function that returns value. Node* native_context = LoadNativeContext(context); Node* const value_thunk = CreateValueThunkFunction(value, native_context); // 2.d Let promiseCapability be ! NewPromiseCapability( %Promise%). Node* const promise_capability = AllocateAndInitJSPromise(context, promise); // 2.e Return PerformPromiseThen(promise, valueThunk, undefined, // promiseCapability). InternalPerformPromiseThen(context, promise, value_thunk, UndefinedConstant(), promise_capability, UndefinedConstant(), UndefinedConstant()); Return(promise_capability); } TF_BUILTIN(PromiseThrowerFinally, PromiseBuiltinsAssembler) { Node* const context = Parameter(3); Node* const reason = LoadContextElement(context, kOnFinallySlot); CallRuntime(Runtime::kThrow, context, reason); Unreachable(); } Node* PromiseBuiltinsAssembler::CreateThrowerFunctionContext( Node* reason, Node* native_context) { Node* const context = CreatePromiseContext(native_context, kOnFinallyContextLength); StoreContextElementNoWriteBarrier(context, kOnFinallySlot, reason); return context; } Node* PromiseBuiltinsAssembler::CreateThrowerFunction(Node* reason, Node* native_context) { Node* const thrower_context = CreateThrowerFunctionContext(reason, native_context); Node* const map = LoadContextElement( native_context, Context::STRICT_FUNCTION_WITHOUT_PROTOTYPE_MAP_INDEX); Node* const thrower_info = LoadContextElement( native_context, Context::PROMISE_THROWER_FINALLY_SHARED_FUN); Node* const thrower = AllocateFunctionWithMapAndContext(map, thrower_info, thrower_context); return thrower; } TF_BUILTIN(PromiseCatchFinally, PromiseBuiltinsAssembler) { CSA_ASSERT_JS_ARGC_EQ(this, 1); Node* const reason = Parameter(1); Node* const context = Parameter(4); Node* const on_finally = LoadContextElement(context, kOnFinallySlot); // 2.a Let result be ? Call(onFinally, undefined). Callable call_callable = CodeFactory::Call(isolate()); Node* result = CallJS(call_callable, context, on_finally, UndefinedConstant()); // 2.b Let promise be ! PromiseResolve( %Promise%, result). Node* const promise = AllocateAndInitJSPromise(context); InternalResolvePromise(context, promise, result); // 2.c Let thrower be equivalent to a function that throws reason. Node* native_context = LoadNativeContext(context); Node* const thrower = CreateThrowerFunction(reason, native_context); // 2.d Let promiseCapability be ! NewPromiseCapability( %Promise%). Node* const promise_capability = AllocateAndInitJSPromise(context, promise); // 2.e Return PerformPromiseThen(promise, thrower, undefined, // promiseCapability). InternalPerformPromiseThen(context, promise, thrower, UndefinedConstant(), promise_capability, UndefinedConstant(), UndefinedConstant()); Return(promise_capability); } TF_BUILTIN(PromiseFinally, PromiseBuiltinsAssembler) { CSA_ASSERT_JS_ARGC_EQ(this, 1); // 1. Let promise be the this value. Node* const promise = Parameter(0); Node* const on_finally = Parameter(1); Node* const context = Parameter(4); // 2. If IsPromise(promise) is false, throw a TypeError exception. ThrowIfNotInstanceType(context, promise, JS_PROMISE_TYPE, "Promise.prototype.finally"); Variable var_then_finally(this, MachineRepresentation::kTagged), var_catch_finally(this, MachineRepresentation::kTagged); Label if_notcallable(this, Label::kDeferred), perform_finally(this); // 3. Let thenFinally be ! CreateThenFinally(onFinally). // 4. Let catchFinally be ! CreateCatchFinally(onFinally). GotoIf(TaggedIsSmi(on_finally), &if_notcallable); Node* const on_finally_map = LoadMap(on_finally); GotoIfNot(IsCallableMap(on_finally_map), &if_notcallable); Node* const native_context = LoadNativeContext(context); Node* then_finally = nullptr; Node* catch_finally = nullptr; std::tie(then_finally, catch_finally) = CreatePromiseFinallyFunctions(on_finally, native_context); var_then_finally.Bind(then_finally); var_catch_finally.Bind(catch_finally); Goto(&perform_finally); Bind(&if_notcallable); { var_then_finally.Bind(on_finally); var_catch_finally.Bind(on_finally); Goto(&perform_finally); } // 5. Return PerformPromiseThen(promise, valueThunk, undefined, // promiseCapability). Bind(&perform_finally); Label if_nativepromise(this), if_custompromise(this, Label::kDeferred); BranchIfFastPath(context, promise, &if_nativepromise, &if_custompromise); Bind(&if_nativepromise); { Node* deferred_promise = AllocateAndInitJSPromise(context, promise); InternalPerformPromiseThen(context, promise, var_then_finally.value(), var_catch_finally.value(), deferred_promise, UndefinedConstant(), UndefinedConstant()); Return(deferred_promise); } Bind(&if_custompromise); { 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); // 5. Return ? Invoke(promise, "then", « thenFinally, catchFinally »). Node* const result = CallJS(call_callable, context, then, promise, var_then_finally.value(), var_catch_finally.value()); Return(result); } } } // namespace internal } // namespace v8