diff options
Diffstat (limited to 'deps/v8/src/builtins/builtins-promise-gen.cc')
| -rw-r--r-- | deps/v8/src/builtins/builtins-promise-gen.cc | 298 |
1 files changed, 156 insertions, 142 deletions
diff --git a/deps/v8/src/builtins/builtins-promise-gen.cc b/deps/v8/src/builtins/builtins-promise-gen.cc index a1da55e0d9..b20b288c3d 100644 --- a/deps/v8/src/builtins/builtins-promise-gen.cc +++ b/deps/v8/src/builtins/builtins-promise-gen.cc @@ -21,11 +21,10 @@ namespace v8 { namespace internal { using Node = compiler::Node; -template <class T> -using TNode = CodeStubAssembler::TNode<T>; using IteratorRecord = TorqueStructIteratorRecord; -Node* PromiseBuiltinsAssembler::AllocateJSPromise(Node* context) { +TNode<JSPromise> PromiseBuiltinsAssembler::AllocateJSPromise( + TNode<Context> context) { TNode<NativeContext> const native_context = LoadNativeContext(context); TNode<JSFunction> const promise_fun = CAST(LoadContextElement(native_context, Context::PROMISE_FUNCTION_INDEX)); @@ -39,7 +38,7 @@ Node* PromiseBuiltinsAssembler::AllocateJSPromise(Node* context) { RootIndex::kEmptyFixedArray); StoreObjectFieldRoot(promise, JSPromise::kElementsOffset, RootIndex::kEmptyFixedArray); - return promise; + return CAST(promise); } void PromiseBuiltinsAssembler::PromiseInit(Node* promise) { @@ -54,13 +53,14 @@ void PromiseBuiltinsAssembler::PromiseInit(Node* promise) { } } -Node* PromiseBuiltinsAssembler::AllocateAndInitJSPromise(Node* context) { +TNode<JSPromise> PromiseBuiltinsAssembler::AllocateAndInitJSPromise( + TNode<Context> context) { return AllocateAndInitJSPromise(context, UndefinedConstant()); } -Node* PromiseBuiltinsAssembler::AllocateAndInitJSPromise(Node* context, - Node* parent) { - Node* const instance = AllocateJSPromise(context); +TNode<JSPromise> PromiseBuiltinsAssembler::AllocateAndInitJSPromise( + TNode<Context> context, TNode<Object> parent) { + const TNode<JSPromise> instance = AllocateJSPromise(context); PromiseInit(instance); Label out(this); @@ -72,11 +72,12 @@ Node* PromiseBuiltinsAssembler::AllocateAndInitJSPromise(Node* context, return instance; } -Node* PromiseBuiltinsAssembler::AllocateAndSetJSPromise( - Node* context, v8::Promise::PromiseState status, Node* result) { +TNode<JSPromise> PromiseBuiltinsAssembler::AllocateAndSetJSPromise( + TNode<Context> context, v8::Promise::PromiseState status, + TNode<Object> result) { DCHECK_NE(Promise::kPending, status); - Node* const instance = AllocateJSPromise(context); + const TNode<JSPromise> instance = AllocateJSPromise(context); StoreObjectFieldNoWriteBarrier(instance, JSPromise::kReactionsOrResultOffset, result); STATIC_ASSERT(JSPromise::kStatusShift == 0); @@ -97,22 +98,23 @@ Node* PromiseBuiltinsAssembler::AllocateAndSetJSPromise( return instance; } -std::pair<Node*, Node*> +std::pair<TNode<JSFunction>, TNode<JSFunction>> PromiseBuiltinsAssembler::CreatePromiseResolvingFunctions( - Node* promise, Node* debug_event, Node* native_context) { - Node* const promise_context = CreatePromiseResolvingFunctionsContext( + TNode<JSPromise> promise, TNode<Object> debug_event, + TNode<NativeContext> native_context) { + const TNode<Context> promise_context = CreatePromiseResolvingFunctionsContext( promise, debug_event, native_context); - TNode<Object> const map = LoadContextElement( - native_context, Context::STRICT_FUNCTION_WITHOUT_PROTOTYPE_MAP_INDEX); - TNode<Object> const resolve_info = LoadContextElement( + const TNode<Map> map = CAST(LoadContextElement( + native_context, Context::STRICT_FUNCTION_WITHOUT_PROTOTYPE_MAP_INDEX)); + const TNode<SharedFunctionInfo> resolve_info = CAST(LoadContextElement( native_context, - Context::PROMISE_CAPABILITY_DEFAULT_RESOLVE_SHARED_FUN_INDEX); - Node* const resolve = + Context::PROMISE_CAPABILITY_DEFAULT_RESOLVE_SHARED_FUN_INDEX)); + const TNode<JSFunction> resolve = AllocateFunctionWithMapAndContext(map, resolve_info, promise_context); - TNode<Object> const reject_info = LoadContextElement( + const TNode<SharedFunctionInfo> reject_info = CAST(LoadContextElement( native_context, - Context::PROMISE_CAPABILITY_DEFAULT_REJECT_SHARED_FUN_INDEX); - Node* const reject = + Context::PROMISE_CAPABILITY_DEFAULT_REJECT_SHARED_FUN_INDEX)); + const TNode<JSFunction> reject = AllocateFunctionWithMapAndContext(map, reject_info, promise_context); return std::make_pair(resolve, reject); } @@ -196,7 +198,7 @@ TF_BUILTIN(NewPromiseCapability, PromiseBuiltinsAssembler) { BIND(&if_fast_promise_capability); { - Node* promise = + TNode<JSPromise> promise = AllocateAndInitJSPromise(native_context, UndefinedConstant()); Node* resolve = nullptr; @@ -226,14 +228,15 @@ TF_BUILTIN(NewPromiseCapability, PromiseBuiltinsAssembler) { StoreObjectFieldRoot(capability, PromiseCapability::kRejectOffset, RootIndex::kUndefinedValue); - Node* executor_context = - CreatePromiseGetCapabilitiesExecutorContext(capability, native_context); - TNode<Object> executor_info = LoadContextElement( - native_context, Context::PROMISE_GET_CAPABILITIES_EXECUTOR_SHARED_FUN); - TNode<Object> function_map = LoadContextElement( - native_context, Context::STRICT_FUNCTION_WITHOUT_PROTOTYPE_MAP_INDEX); - TNode<JSFunction> executor = CAST(AllocateFunctionWithMapAndContext( - function_map, executor_info, executor_context)); + TNode<Context> executor_context = + CAST(CreatePromiseGetCapabilitiesExecutorContext(capability, + native_context)); + TNode<SharedFunctionInfo> executor_info = CAST(LoadContextElement( + native_context, Context::PROMISE_GET_CAPABILITIES_EXECUTOR_SHARED_FUN)); + TNode<Map> function_map = CAST(LoadContextElement( + native_context, Context::STRICT_FUNCTION_WITHOUT_PROTOTYPE_MAP_INDEX)); + TNode<JSFunction> executor = AllocateFunctionWithMapAndContext( + function_map, executor_info, executor_context); TNode<JSReceiver> promise = Construct(native_context, CAST(constructor), executor); @@ -258,14 +261,14 @@ TF_BUILTIN(NewPromiseCapability, PromiseBuiltinsAssembler) { ThrowTypeError(context, MessageTemplate::kPromiseNonCallable); } -Node* PromiseBuiltinsAssembler::CreatePromiseContext(Node* native_context, - int slots) { +TNode<Context> PromiseBuiltinsAssembler::CreatePromiseContext( + TNode<NativeContext> native_context, int slots) { DCHECK_GE(slots, Context::MIN_CONTEXT_SLOTS); TNode<HeapObject> const context = AllocateInNewSpace(FixedArray::SizeFor(slots)); InitializeFunctionContext(native_context, context, slots); - return context; + return CAST(context); } Node* PromiseBuiltinsAssembler::CreatePromiseAllResolveElementContext( @@ -278,8 +281,8 @@ Node* PromiseBuiltinsAssembler::CreatePromiseAllResolveElementContext( TNode<JSArray> values_array = AllocateJSArray( PACKED_ELEMENTS, array_map, IntPtrConstant(0), SmiConstant(0)); - Node* const context = CreatePromiseContext( - native_context, PromiseBuiltins::kPromiseAllResolveElementLength); + TNode<Context> const context = CreatePromiseContext( + CAST(native_context), PromiseBuiltins::kPromiseAllResolveElementLength); StoreContextElementNoWriteBarrier( context, PromiseBuiltins::kPromiseAllResolveElementRemainingSlot, SmiConstant(1)); @@ -301,12 +304,12 @@ PromiseBuiltinsAssembler::CreatePromiseAllResolveElementFunction( index, SmiConstant(PropertyArray::HashField::kMax))); CSA_ASSERT(this, IsNativeContext(native_context)); - TNode<Object> const map = LoadContextElement( - native_context, Context::STRICT_FUNCTION_WITHOUT_PROTOTYPE_MAP_INDEX); - TNode<Object> const resolve_info = - LoadContextElement(native_context, slot_index); + const TNode<Map> map = CAST(LoadContextElement( + native_context, Context::STRICT_FUNCTION_WITHOUT_PROTOTYPE_MAP_INDEX)); + const TNode<SharedFunctionInfo> resolve_info = + CAST(LoadContextElement(native_context, slot_index)); TNode<JSFunction> resolve = - Cast(AllocateFunctionWithMapAndContext(map, resolve_info, context)); + AllocateFunctionWithMapAndContext(map, resolve_info, CAST(context)); STATIC_ASSERT(PropertyArray::kNoHashSentinel == 0); StoreObjectFieldNoWriteBarrier(resolve, JSFunction::kPropertiesOrHashOffset, @@ -315,9 +318,10 @@ PromiseBuiltinsAssembler::CreatePromiseAllResolveElementFunction( return resolve; } -Node* PromiseBuiltinsAssembler::CreatePromiseResolvingFunctionsContext( - Node* promise, Node* debug_event, Node* native_context) { - Node* const context = CreatePromiseContext( +TNode<Context> PromiseBuiltinsAssembler::CreatePromiseResolvingFunctionsContext( + TNode<JSPromise> promise, TNode<Object> debug_event, + TNode<NativeContext> native_context) { + const TNode<Context> context = CreatePromiseContext( native_context, PromiseBuiltins::kPromiseContextLength); StoreContextElementNoWriteBarrier(context, PromiseBuiltins::kPromiseSlot, promise); @@ -331,7 +335,8 @@ Node* PromiseBuiltinsAssembler::CreatePromiseResolvingFunctionsContext( Node* PromiseBuiltinsAssembler::CreatePromiseGetCapabilitiesExecutorContext( Node* promise_capability, Node* native_context) { int kContextLength = PromiseBuiltins::kCapabilitiesContextLength; - Node* context = CreatePromiseContext(native_context, kContextLength); + TNode<Context> context = + CreatePromiseContext(CAST(native_context), kContextLength); StoreContextElementNoWriteBarrier(context, PromiseBuiltins::kCapabilitySlot, promise_capability); return context; @@ -386,14 +391,12 @@ void PromiseBuiltinsAssembler::PromiseSetHandledHint(Node* promise) { // ES #sec-performpromisethen void PromiseBuiltinsAssembler::PerformPromiseThen( - Node* context, Node* promise, Node* on_fulfilled, Node* on_rejected, - Node* result_promise_or_capability) { - CSA_ASSERT(this, TaggedIsNotSmi(promise)); - CSA_ASSERT(this, IsJSPromise(promise)); + TNode<Context> context, TNode<JSPromise> promise, + TNode<HeapObject> on_fulfilled, TNode<HeapObject> on_rejected, + TNode<HeapObject> result_promise_or_capability) { CSA_ASSERT(this, Word32Or(IsCallable(on_fulfilled), IsUndefined(on_fulfilled))); CSA_ASSERT(this, Word32Or(IsCallable(on_rejected), IsUndefined(on_rejected))); - CSA_ASSERT(this, TaggedIsNotSmi(result_promise_or_capability)); CSA_ASSERT( this, Word32Or(Word32Or(IsJSPromise(result_promise_or_capability), @@ -411,9 +414,9 @@ void PromiseBuiltinsAssembler::PerformPromiseThen( // PromiseReaction holding both the onFulfilled and onRejected callbacks. // Once the {promise} is resolved we decide on the concrete handler to // push onto the microtask queue. - TNode<Object> const promise_reactions = + const TNode<Object> promise_reactions = LoadObjectField(promise, JSPromise::kReactionsOrResultOffset); - Node* const reaction = + const TNode<PromiseReaction> reaction = AllocatePromiseReaction(promise_reactions, result_promise_or_capability, on_fulfilled, on_rejected); StoreObjectField(promise, JSPromise::kReactionsOrResultOffset, reaction); @@ -422,10 +425,9 @@ void PromiseBuiltinsAssembler::PerformPromiseThen( BIND(&if_notpending); { - VARIABLE(var_map, MachineRepresentation::kTagged); - VARIABLE(var_handler, MachineRepresentation::kTagged); - VARIABLE(var_handler_context, MachineRepresentation::kTagged, - UndefinedConstant()); + TVARIABLE(Map, var_map); + TVARIABLE(HeapObject, var_handler); + TVARIABLE(Object, var_handler_context, UndefinedConstant()); Label if_fulfilled(this), if_rejected(this, Label::kDeferred), enqueue(this); Branch(IsPromiseStatus(status, v8::Promise::kFulfilled), &if_fulfilled, @@ -433,15 +435,15 @@ void PromiseBuiltinsAssembler::PerformPromiseThen( BIND(&if_fulfilled); { - var_map.Bind(PromiseFulfillReactionJobTaskMapConstant()); - var_handler.Bind(on_fulfilled); + var_map = PromiseFulfillReactionJobTaskMapConstant(); + var_handler = on_fulfilled; Label use_fallback(this, Label::kDeferred), done(this); ExtractHandlerContext(on_fulfilled, &var_handler_context); Branch(IsUndefined(var_handler_context.value()), &use_fallback, &done); BIND(&use_fallback); - var_handler_context.Bind(context); + var_handler_context = context; ExtractHandlerContext(on_rejected, &var_handler_context); Goto(&done); @@ -452,15 +454,15 @@ void PromiseBuiltinsAssembler::PerformPromiseThen( BIND(&if_rejected); { CSA_ASSERT(this, IsPromiseStatus(status, v8::Promise::kRejected)); - var_map.Bind(PromiseRejectReactionJobTaskMapConstant()); - var_handler.Bind(on_rejected); + var_map = PromiseRejectReactionJobTaskMapConstant(); + var_handler = on_rejected; Label use_fallback(this, Label::kDeferred), done(this); ExtractHandlerContext(on_rejected, &var_handler_context); Branch(IsUndefined(var_handler_context.value()), &use_fallback, &done); BIND(&use_fallback); - var_handler_context.Bind(context); + var_handler_context = context; ExtractHandlerContext(on_fulfilled, &var_handler_context); Goto(&done); BIND(&done); @@ -474,8 +476,8 @@ void PromiseBuiltinsAssembler::PerformPromiseThen( { TNode<Object> argument = LoadObjectField(promise, JSPromise::kReactionsOrResultOffset); - Node* microtask = AllocatePromiseReactionJobTask( - var_map.value(), var_handler_context.value(), argument, + TNode<PromiseReactionJobTask> microtask = AllocatePromiseReactionJobTask( + var_map.value(), CAST(var_handler_context.value()), argument, var_handler.value(), result_promise_or_capability); CallBuiltin(Builtins::kEnqueueMicrotask, var_handler_context.value(), microtask); @@ -489,13 +491,15 @@ void PromiseBuiltinsAssembler::PerformPromiseThen( // ES #sec-performpromisethen TF_BUILTIN(PerformPromiseThen, PromiseBuiltinsAssembler) { - Node* const context = Parameter(Descriptor::kContext); - Node* const promise = Parameter(Descriptor::kPromise); - Node* const on_fulfilled = Parameter(Descriptor::kOnFulfilled); - Node* const on_rejected = Parameter(Descriptor::kOnRejected); - Node* const result_promise = Parameter(Descriptor::kResultPromise); + const TNode<Context> context = CAST(Parameter(Descriptor::kContext)); + const TNode<JSPromise> promise = CAST(Parameter(Descriptor::kPromise)); + const TNode<HeapObject> on_fulfilled = + CAST(Parameter(Descriptor::kOnFulfilled)); + const TNode<HeapObject> on_rejected = + CAST(Parameter(Descriptor::kOnRejected)); + const TNode<HeapObject> result_promise = + CAST(Parameter(Descriptor::kResultPromise)); - CSA_ASSERT(this, TaggedIsNotSmi(result_promise)); CSA_ASSERT( this, Word32Or(IsJSPromise(result_promise), IsUndefined(result_promise))); @@ -504,9 +508,9 @@ TF_BUILTIN(PerformPromiseThen, PromiseBuiltinsAssembler) { Return(result_promise); } -Node* PromiseBuiltinsAssembler::AllocatePromiseReaction( - Node* next, Node* promise_or_capability, Node* fulfill_handler, - Node* reject_handler) { +TNode<PromiseReaction> PromiseBuiltinsAssembler::AllocatePromiseReaction( + TNode<Object> next, TNode<HeapObject> promise_or_capability, + TNode<HeapObject> fulfill_handler, TNode<HeapObject> reject_handler) { TNode<HeapObject> const reaction = Allocate(PromiseReaction::kSize); StoreMapNoWriteBarrier(reaction, RootIndex::kPromiseReactionMap); StoreObjectFieldNoWriteBarrier(reaction, PromiseReaction::kNextOffset, next); @@ -517,12 +521,13 @@ Node* PromiseBuiltinsAssembler::AllocatePromiseReaction( reaction, PromiseReaction::kFulfillHandlerOffset, fulfill_handler); StoreObjectFieldNoWriteBarrier( reaction, PromiseReaction::kRejectHandlerOffset, reject_handler); - return reaction; + return CAST(reaction); } -Node* PromiseBuiltinsAssembler::AllocatePromiseReactionJobTask( - Node* map, Node* context, Node* argument, Node* handler, - Node* promise_or_capability) { +TNode<PromiseReactionJobTask> +PromiseBuiltinsAssembler::AllocatePromiseReactionJobTask( + TNode<Map> map, TNode<Context> context, TNode<Object> argument, + TNode<HeapObject> handler, TNode<HeapObject> promise_or_capability) { TNode<HeapObject> const microtask = Allocate(PromiseReactionJobTask::kSizeOfAllPromiseReactionJobTasks); StoreMapNoWriteBarrier(microtask, map); @@ -535,12 +540,14 @@ Node* PromiseBuiltinsAssembler::AllocatePromiseReactionJobTask( StoreObjectFieldNoWriteBarrier( microtask, PromiseReactionJobTask::kPromiseOrCapabilityOffset, promise_or_capability); - return microtask; + return CAST(microtask); } -Node* PromiseBuiltinsAssembler::AllocatePromiseResolveThenableJobTask( - Node* promise_to_resolve, Node* then, Node* thenable, Node* context) { - TNode<HeapObject> const microtask = +TNode<PromiseResolveThenableJobTask> +PromiseBuiltinsAssembler::AllocatePromiseResolveThenableJobTask( + TNode<JSPromise> promise_to_resolve, TNode<JSReceiver> then, + TNode<JSReceiver> thenable, TNode<Context> context) { + const TNode<HeapObject> microtask = Allocate(PromiseResolveThenableJobTask::kSize); StoreMapNoWriteBarrier(microtask, RootIndex::kPromiseResolveThenableJobTaskMap); @@ -553,7 +560,7 @@ Node* PromiseBuiltinsAssembler::AllocatePromiseResolveThenableJobTask( microtask, PromiseResolveThenableJobTask::kThenOffset, then); StoreObjectFieldNoWriteBarrier( microtask, PromiseResolveThenableJobTask::kThenableOffset, thenable); - return microtask; + return CAST(microtask); } // ES #sec-triggerpromisereactions @@ -1003,7 +1010,7 @@ TF_BUILTIN(PromiseConstructor, PromiseBuiltinsAssembler) { BIND(&if_targetisnotmodified); { - Node* const instance = AllocateAndInitJSPromise(context); + TNode<JSPromise> const instance = AllocateAndInitJSPromise(context); var_result.Bind(instance); Goto(&debug_push); } @@ -1035,7 +1042,7 @@ TF_BUILTIN(PromiseConstructor, PromiseBuiltinsAssembler) { Node *resolve, *reject; std::tie(resolve, reject) = CreatePromiseResolvingFunctions( - var_result.value(), TrueConstant(), native_context); + CAST(var_result.value()), TrueConstant(), native_context); Node* const maybe_exception = CallJS( CodeFactory::Call(isolate, ConvertReceiverMode::kNullOrUndefined), @@ -1080,8 +1087,8 @@ TF_BUILTIN(PromiseConstructor, PromiseBuiltinsAssembler) { // V8 Extras: v8.createPromise(parent) TF_BUILTIN(PromiseInternalConstructor, PromiseBuiltinsAssembler) { - Node* const parent = Parameter(Descriptor::kParent); - Node* const context = Parameter(Descriptor::kContext); + const TNode<Object> parent = CAST(Parameter(Descriptor::kParent)); + const TNode<Context> context = CAST(Parameter(Descriptor::kContext)); Return(AllocateAndInitJSPromise(context, parent)); } @@ -1127,14 +1134,15 @@ TF_BUILTIN(PromiseInternalResolve, PromiseBuiltinsAssembler) { // Promise.prototype.then ( onFulfilled, onRejected ) TF_BUILTIN(PromisePrototypeThen, PromiseBuiltinsAssembler) { // 1. Let promise be the this value. - Node* const promise = Parameter(Descriptor::kReceiver); - Node* const on_fulfilled = Parameter(Descriptor::kOnFulfilled); - Node* const on_rejected = Parameter(Descriptor::kOnRejected); - Node* const context = Parameter(Descriptor::kContext); + const TNode<Object> maybe_promise = CAST(Parameter(Descriptor::kReceiver)); + const TNode<Object> on_fulfilled = CAST(Parameter(Descriptor::kOnFulfilled)); + const TNode<Object> on_rejected = CAST(Parameter(Descriptor::kOnRejected)); + const TNode<Context> context = CAST(Parameter(Descriptor::kContext)); // 2. If IsPromise(promise) is false, throw a TypeError exception. - ThrowIfNotInstanceType(context, promise, JS_PROMISE_TYPE, + ThrowIfNotInstanceType(context, maybe_promise, JS_PROMISE_TYPE, "Promise.prototype.then"); + TNode<JSPromise> js_promise = CAST(maybe_promise); // 3. Let C be ? SpeciesConstructor(promise, %Promise%). Label fast_promise_capability(this), slow_constructor(this, Label::kDeferred), @@ -1142,26 +1150,27 @@ TF_BUILTIN(PromisePrototypeThen, PromiseBuiltinsAssembler) { TNode<NativeContext> const native_context = LoadNativeContext(context); TNode<JSFunction> promise_fun = CAST(LoadContextElement(native_context, Context::PROMISE_FUNCTION_INDEX)); - TNode<Map> const promise_map = LoadMap(promise); + TNode<Map> const promise_map = LoadMap(js_promise); BranchIfPromiseSpeciesLookupChainIntact( native_context, promise_map, &fast_promise_capability, &slow_constructor); BIND(&slow_constructor); TNode<JSReceiver> constructor = - SpeciesConstructor(native_context, promise, promise_fun); + SpeciesConstructor(native_context, js_promise, promise_fun); Branch(TaggedEqual(constructor, promise_fun), &fast_promise_capability, &slow_promise_capability); // 4. Let resultCapability be ? NewPromiseCapability(C). Label perform_promise_then(this); - VARIABLE(var_result_promise, MachineRepresentation::kTagged); - VARIABLE(var_result_promise_or_capability, MachineRepresentation::kTagged); + TVARIABLE(Object, var_result_promise); + TVARIABLE(HeapObject, var_result_promise_or_capability); BIND(&fast_promise_capability); { - Node* const result_promise = AllocateAndInitJSPromise(context, promise); - var_result_promise_or_capability.Bind(result_promise); - var_result_promise.Bind(result_promise); + const TNode<JSPromise> result_promise = + AllocateAndInitJSPromise(context, js_promise); + var_result_promise_or_capability = result_promise; + var_result_promise = result_promise; Goto(&perform_promise_then); } @@ -1170,9 +1179,9 @@ TF_BUILTIN(PromisePrototypeThen, PromiseBuiltinsAssembler) { TNode<Oddball> const debug_event = TrueConstant(); TNode<PromiseCapability> const capability = CAST(CallBuiltin( Builtins::kNewPromiseCapability, context, constructor, debug_event)); - var_result_promise.Bind( - LoadObjectField(capability, PromiseCapability::kPromiseOffset)); - var_result_promise_or_capability.Bind(capability); + var_result_promise = + LoadObjectField(capability, PromiseCapability::kPromiseOffset); + var_result_promise_or_capability = capability; Goto(&perform_promise_then); } @@ -1187,30 +1196,30 @@ TF_BUILTIN(PromisePrototypeThen, PromiseBuiltinsAssembler) { // 3. If IsCallable(onFulfilled) is false, then // a. Set onFulfilled to undefined. - VARIABLE(var_on_fulfilled, MachineRepresentation::kTagged, on_fulfilled); + TVARIABLE(Object, var_on_fulfilled, on_fulfilled); Label if_fulfilled_done(this), if_fulfilled_notcallable(this); GotoIf(TaggedIsSmi(on_fulfilled), &if_fulfilled_notcallable); - Branch(IsCallable(on_fulfilled), &if_fulfilled_done, + Branch(IsCallable(CAST(on_fulfilled)), &if_fulfilled_done, &if_fulfilled_notcallable); BIND(&if_fulfilled_notcallable); - var_on_fulfilled.Bind(UndefinedConstant()); + var_on_fulfilled = UndefinedConstant(); Goto(&if_fulfilled_done); BIND(&if_fulfilled_done); // 4. If IsCallable(onRejected) is false, then // a. Set onRejected to undefined. - VARIABLE(var_on_rejected, MachineRepresentation::kTagged, on_rejected); + TVARIABLE(Object, var_on_rejected, on_rejected); Label if_rejected_done(this), if_rejected_notcallable(this); GotoIf(TaggedIsSmi(on_rejected), &if_rejected_notcallable); - Branch(IsCallable(on_rejected), &if_rejected_done, + Branch(IsCallable(CAST(on_rejected)), &if_rejected_done, &if_rejected_notcallable); BIND(&if_rejected_notcallable); - var_on_rejected.Bind(UndefinedConstant()); + var_on_rejected = UndefinedConstant(); Goto(&if_rejected_done); BIND(&if_rejected_done); - PerformPromiseThen(context, promise, var_on_fulfilled.value(), - var_on_rejected.value(), + PerformPromiseThen(context, js_promise, CAST(var_on_fulfilled.value()), + CAST(var_on_rejected.value()), var_result_promise_or_capability.value()); Return(var_result_promise.value()); } @@ -1522,7 +1531,7 @@ TF_BUILTIN(PromiseResolve, PromiseBuiltinsAssembler) { // create NewPromiseCapability. BIND(&if_nativepromise); { - Node* const result = AllocateAndInitJSPromise(context); + TNode<JSPromise> const result = AllocateAndInitJSPromise(context); CallBuiltin(Builtins::kResolvePromise, context, result, value); Return(result); } @@ -1592,7 +1601,7 @@ TF_BUILTIN(PromiseReject, PromiseBuiltinsAssembler) { BIND(&if_nativepromise); { - Node* const promise = + TNode<JSPromise> const promise = AllocateAndSetJSPromise(context, v8::Promise::kRejected, reason); CallRuntime(Runtime::kPromiseRejectEventFromStack, context, promise, reason); @@ -1621,21 +1630,21 @@ TF_BUILTIN(PromiseReject, PromiseBuiltinsAssembler) { std::pair<Node*, Node*> PromiseBuiltinsAssembler::CreatePromiseFinallyFunctions( Node* on_finally, Node* constructor, Node* native_context) { - Node* const promise_context = CreatePromiseContext( - native_context, PromiseBuiltins::kPromiseFinallyContextLength); + const TNode<Context> promise_context = CreatePromiseContext( + CAST(native_context), PromiseBuiltins::kPromiseFinallyContextLength); StoreContextElementNoWriteBarrier( promise_context, PromiseBuiltins::kOnFinallySlot, on_finally); StoreContextElementNoWriteBarrier( promise_context, PromiseBuiltins::kConstructorSlot, constructor); - TNode<Object> const map = LoadContextElement( - native_context, Context::STRICT_FUNCTION_WITHOUT_PROTOTYPE_MAP_INDEX); - TNode<Object> const then_finally_info = LoadContextElement( - native_context, Context::PROMISE_THEN_FINALLY_SHARED_FUN); - Node* const then_finally = AllocateFunctionWithMapAndContext( + const TNode<Map> map = CAST(LoadContextElement( + native_context, Context::STRICT_FUNCTION_WITHOUT_PROTOTYPE_MAP_INDEX)); + const TNode<SharedFunctionInfo> then_finally_info = CAST(LoadContextElement( + native_context, Context::PROMISE_THEN_FINALLY_SHARED_FUN)); + TNode<JSFunction> const then_finally = AllocateFunctionWithMapAndContext( map, then_finally_info, promise_context); - TNode<Object> const catch_finally_info = LoadContextElement( - native_context, Context::PROMISE_CATCH_FINALLY_SHARED_FUN); - Node* const catch_finally = AllocateFunctionWithMapAndContext( + const TNode<SharedFunctionInfo> catch_finally_info = CAST(LoadContextElement( + native_context, Context::PROMISE_CATCH_FINALLY_SHARED_FUN)); + TNode<JSFunction> const catch_finally = AllocateFunctionWithMapAndContext( map, catch_finally_info, promise_context); return std::make_pair(then_finally, catch_finally); } @@ -1650,15 +1659,16 @@ TF_BUILTIN(PromiseValueThunkFinally, PromiseBuiltinsAssembler) { Node* PromiseBuiltinsAssembler::CreateValueThunkFunction(Node* value, Node* native_context) { - Node* const value_thunk_context = CreatePromiseContext( - native_context, PromiseBuiltins::kPromiseValueThunkOrReasonContextLength); + const TNode<Context> value_thunk_context = CreatePromiseContext( + CAST(native_context), + PromiseBuiltins::kPromiseValueThunkOrReasonContextLength); StoreContextElementNoWriteBarrier(value_thunk_context, PromiseBuiltins::kValueSlot, value); - TNode<Object> const map = LoadContextElement( - native_context, Context::STRICT_FUNCTION_WITHOUT_PROTOTYPE_MAP_INDEX); - TNode<Object> const value_thunk_info = LoadContextElement( - native_context, Context::PROMISE_VALUE_THUNK_FINALLY_SHARED_FUN); - Node* const value_thunk = AllocateFunctionWithMapAndContext( + const TNode<Map> map = CAST(LoadContextElement( + native_context, Context::STRICT_FUNCTION_WITHOUT_PROTOTYPE_MAP_INDEX)); + const TNode<SharedFunctionInfo> value_thunk_info = CAST(LoadContextElement( + native_context, Context::PROMISE_VALUE_THUNK_FINALLY_SHARED_FUN)); + TNode<JSFunction> const value_thunk = AllocateFunctionWithMapAndContext( map, value_thunk_info, value_thunk_context); return value_thunk; } @@ -1711,15 +1721,16 @@ TF_BUILTIN(PromiseThrowerFinally, PromiseBuiltinsAssembler) { Node* PromiseBuiltinsAssembler::CreateThrowerFunction(Node* reason, Node* native_context) { - Node* const thrower_context = CreatePromiseContext( - native_context, PromiseBuiltins::kPromiseValueThunkOrReasonContextLength); + const TNode<Context> thrower_context = CreatePromiseContext( + CAST(native_context), + PromiseBuiltins::kPromiseValueThunkOrReasonContextLength); StoreContextElementNoWriteBarrier(thrower_context, PromiseBuiltins::kValueSlot, reason); - TNode<Object> const map = LoadContextElement( - native_context, Context::STRICT_FUNCTION_WITHOUT_PROTOTYPE_MAP_INDEX); - TNode<Object> const thrower_info = LoadContextElement( - native_context, Context::PROMISE_THROWER_FINALLY_SHARED_FUN); - Node* const thrower = + const TNode<Map> map = CAST(LoadContextElement( + native_context, Context::STRICT_FUNCTION_WITHOUT_PROTOTYPE_MAP_INDEX)); + const TNode<SharedFunctionInfo> thrower_info = CAST(LoadContextElement( + native_context, Context::PROMISE_THROWER_FINALLY_SHARED_FUN)); + TNode<JSFunction> const thrower = AllocateFunctionWithMapAndContext(map, thrower_info, thrower_context); return thrower; } @@ -1919,7 +1930,7 @@ TF_BUILTIN(ResolvePromise, PromiseBuiltinsAssembler) { Label do_enqueue(this), if_fulfill(this), if_reject(this, Label::kDeferred), if_runtime(this, Label::kDeferred); TVARIABLE(Object, var_reason); - TVARIABLE(Object, var_then); + TVARIABLE(JSReceiver, var_then); // If promise hook is enabled or the debugger is active, let // the runtime handle this operation, which greatly reduces @@ -1955,7 +1966,8 @@ TF_BUILTIN(ResolvePromise, PromiseBuiltinsAssembler) { BIND(&if_fast); { // The {resolution} is a native Promise in this case. - var_then = LoadContextElement(native_context, Context::PROMISE_THEN_INDEX); + var_then = + CAST(LoadContextElement(native_context, Context::PROMISE_THEN_INDEX)); Goto(&do_enqueue); } @@ -1987,7 +1999,7 @@ TF_BUILTIN(ResolvePromise, PromiseBuiltinsAssembler) { GotoIf(TaggedIsSmi(then), &if_fulfill); TNode<Map> const then_map = LoadMap(CAST(then)); GotoIfNot(IsCallableMap(then_map), &if_fulfill); - var_then = then; + var_then = CAST(then); Goto(&do_enqueue); } @@ -1995,8 +2007,9 @@ TF_BUILTIN(ResolvePromise, PromiseBuiltinsAssembler) { { // 12. Perform EnqueueJob("PromiseJobs", PromiseResolveThenableJob, // «promise, resolution, thenAction»). - Node* const task = AllocatePromiseResolveThenableJobTask( - promise, var_then.value(), resolution, native_context); + const TNode<PromiseResolveThenableJobTask> task = + AllocatePromiseResolveThenableJobTask(promise, var_then.value(), + CAST(resolution), native_context); TailCallBuiltin(Builtins::kEnqueueMicrotask, native_context, task); } @@ -2150,8 +2163,9 @@ Node* PromiseBuiltinsAssembler::PerformPromiseAll( // Register the PromiseReaction immediately on the {next_value}, not // passing any chained promise since neither async_hooks nor DevTools // are enabled, so there's no use of the resulting promise. - PerformPromiseThen(native_context, next_value, resolve_element_fun, - reject_element_fun, UndefinedConstant()); + PerformPromiseThen(native_context, CAST(next_value), + CAST(resolve_element_fun), CAST(reject_element_fun), + UndefinedConstant()); Goto(&loop); } |