Skip to content

Commit

Permalink
[csa] Tnodifiy builtins-async-iterator-gen.cc
Browse files Browse the repository at this point in the history 
Bug: v8:6949
Change-Id: I6cafec59b063e46d55967b678b209202d0328cd3
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1852770
Reviewed-by: Santiago Aboy Solanes <solanes@chromium.org>
Commit-Queue: Dan Elphick <delphick@chromium.org>
Cr-Commit-Position: refs/heads/master@{#64237}
  • Loading branch information
@danelphick
danelphick authored and Commit Bot committed Oct 11, 2019
1 parent 7aa91da commit 2f1bc98
Show file tree
Hide file tree
Showing 3 changed files with 98 additions and 84 deletions.
4 changes: 2 additions & 2 deletions src/builtins/builtins-async-gen.cc
View file
Expand Up @@ -278,7 +278,7 @@ void AsyncBuiltinsAssembler::InitializeNativeClosure(
}

TNode<JSFunction> AsyncBuiltinsAssembler::CreateUnwrapClosure(
TNode<NativeContext> native_context, TNode<HeapObject> done) {
TNode<NativeContext> native_context, TNode<Oddball> done) {
const TNode<Map> map = CAST(LoadContextElement(
native_context, Context::STRICT_FUNCTION_WITHOUT_PROTOTYPE_MAP_INDEX));
const TNode<SharedFunctionInfo> on_fulfilled_shared = CAST(LoadContextElement(
Expand All @@ -290,7 +290,7 @@ TNode<JSFunction> AsyncBuiltinsAssembler::CreateUnwrapClosure(
}

TNode<Context> AsyncBuiltinsAssembler::AllocateAsyncIteratorValueUnwrapContext(
TNode<NativeContext> native_context, TNode<HeapObject> done) {
TNode<NativeContext> native_context, TNode<Oddball> done) {
CSA_ASSERT(this, IsBoolean(done));

TNode<Context> context =
Expand Down
4 changes: 2 additions & 2 deletions src/builtins/builtins-async-gen.h
View file
Expand Up @@ -50,15 +50,15 @@ class AsyncBuiltinsAssembler : public PromiseBuiltinsAssembler {
// Return a new built-in function object as defined in
// Async Iterator Value Unwrap Functions
TNode<JSFunction> CreateUnwrapClosure(TNode<NativeContext> native_context,
TNode<HeapObject> done);
TNode<Oddball> done);

private:
void InitializeNativeClosure(TNode<Context> context,
TNode<NativeContext> native_context,
TNode<HeapObject> function,
TNode<IntPtrT> context_index);
TNode<Context> AllocateAsyncIteratorValueUnwrapContext(
TNode<NativeContext> native_context, TNode<HeapObject> done);
TNode<NativeContext> native_context, TNode<Oddball> done);

TNode<Object> AwaitOld(TNode<Context> context,
TNode<JSGeneratorObject> generator,
Expand Down
174 changes: 94 additions & 80 deletions src/builtins/builtins-async-iterator-gen.cc
View file
Expand Up @@ -2,6 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "src/base/optional.h"
#include "src/builtins/builtins-async-gen.h"
#include "src/builtins/builtins-utils-gen.h"
#include "src/builtins/builtins.h"
Expand All @@ -20,29 +21,34 @@ class AsyncFromSyncBuiltinsAssembler : public AsyncBuiltinsAssembler {
explicit AsyncFromSyncBuiltinsAssembler(compiler::CodeAssemblerState* state)
: AsyncBuiltinsAssembler(state) {}

void ThrowIfNotAsyncFromSyncIterator(Node* const context, Node* const object,
void ThrowIfNotAsyncFromSyncIterator(const TNode<Context> context,
const TNode<Object> object,
Label* if_exception,
Variable* var_exception,
TVariable<Object>* var_exception,
const char* method_name);

using UndefinedMethodHandler = std::function<void(
Node* const context, Node* const promise, Label* if_exception)>;
using SyncIteratorNodeGenerator = std::function<Node*(Node*)>;
using UndefinedMethodHandler =
std::function<void(const TNode<NativeContext> native_context,
const TNode<JSPromise> promise, Label* if_exception)>;
using SyncIteratorNodeGenerator =
std::function<TNode<Object>(TNode<JSReceiver>)>;
void Generate_AsyncFromSyncIteratorMethod(
Node* const context, Node* const iterator, Node* const sent_value,
const TNode<Context> context, const TNode<Object> iterator,
const TNode<Object> sent_value,
const SyncIteratorNodeGenerator& get_method,
const UndefinedMethodHandler& if_method_undefined,
const char* operation_name,
Label::Type reject_label_type = Label::kDeferred,
Node* const initial_exception_value = nullptr);
base::Optional<TNode<Object>> initial_exception_value = base::nullopt);

void Generate_AsyncFromSyncIteratorMethod(
Node* const context, Node* const iterator, Node* const sent_value,
Handle<String> name, const UndefinedMethodHandler& if_method_undefined,
const TNode<Context> context, const TNode<Object> iterator,
const TNode<Object> sent_value, Handle<String> name,
const UndefinedMethodHandler& if_method_undefined,
const char* operation_name,
Label::Type reject_label_type = Label::kDeferred,
Node* const initial_exception_value = nullptr) {
auto get_method = [=](Node* const sync_iterator) {
base::Optional<TNode<Object>> initial_exception_value = base::nullopt) {
auto get_method = [=](const TNode<JSReceiver> sync_iterator) {
return GetProperty(context, sync_iterator, name);
};
return Generate_AsyncFromSyncIteratorMethod(
Expand All @@ -51,26 +57,26 @@ class AsyncFromSyncBuiltinsAssembler : public AsyncBuiltinsAssembler {
}

// Load "value" and "done" from an iterator result object. If an exception
// is thrown at any point, jumps to te `if_exception` label with exception
// is thrown at any point, jumps to the `if_exception` label with exception
// stored in `var_exception`.
//
// Returns a Pair of Nodes, whose first element is the value of the "value"
// property, and whose second element is the value of the "done" property,
// converted to a Boolean if needed.
std::pair<Node*, Node*> LoadIteratorResult(Node* const context,
Node* const native_context,
Node* const iter_result,
Label* if_exception,
Variable* var_exception);
std::pair<TNode<Object>, TNode<Oddball>> LoadIteratorResult(
const TNode<Context> context, const TNode<NativeContext> native_context,
const TNode<Object> iter_result, Label* if_exception,
TVariable<Object>* var_exception);
};

void AsyncFromSyncBuiltinsAssembler::ThrowIfNotAsyncFromSyncIterator(
Node* const context, Node* const object, Label* if_exception,
Variable* var_exception, const char* method_name) {
const TNode<Context> context, const TNode<Object> object,
Label* if_exception, TVariable<Object>* var_exception,
const char* method_name) {
Label if_receiverisincompatible(this, Label::kDeferred), done(this);

GotoIf(TaggedIsSmi(object), &if_receiverisincompatible);
Branch(HasInstanceType(object, JS_ASYNC_FROM_SYNC_ITERATOR_TYPE), &done,
Branch(HasInstanceType(CAST(object), JS_ASYNC_FROM_SYNC_ITERATOR_TYPE), &done,
&if_receiverisincompatible);

BIND(&if_receiverisincompatible);
Expand All @@ -79,40 +85,41 @@ void AsyncFromSyncBuiltinsAssembler::ThrowIfNotAsyncFromSyncIterator(
// internal slot, then

// Let badIteratorError be a new TypeError exception.
Node* const error =
MakeTypeError(MessageTemplate::kIncompatibleMethodReceiver, context,
StringConstant(method_name), object);
TNode<HeapObject> error =
CAST(MakeTypeError(MessageTemplate::kIncompatibleMethodReceiver,
context, StringConstant(method_name), object));

// Perform ! Call(promiseCapability.[[Reject]], undefined,
// « badIteratorError »).
var_exception->Bind(error);
*var_exception = error;
Goto(if_exception);
}

BIND(&done);
}

void AsyncFromSyncBuiltinsAssembler::Generate_AsyncFromSyncIteratorMethod(
Node* const context, Node* const iterator, Node* const sent_value,
const SyncIteratorNodeGenerator& get_method,
const TNode<Context> context, const TNode<Object> iterator,
const TNode<Object> sent_value, const SyncIteratorNodeGenerator& get_method,
const UndefinedMethodHandler& if_method_undefined,
const char* operation_name, Label::Type reject_label_type,
Node* const initial_exception_value) {
TNode<NativeContext> const native_context = LoadNativeContext(context);
TNode<JSPromise> const promise = AllocateAndInitJSPromise(CAST(context));
base::Optional<TNode<Object>> initial_exception_value) {
const TNode<NativeContext> native_context = LoadNativeContext(context);
const TNode<JSPromise> promise = AllocateAndInitJSPromise(context);

VARIABLE(var_exception, MachineRepresentation::kTagged,
initial_exception_value == nullptr ? UndefinedConstant()
: initial_exception_value);
TVARIABLE(
Object, var_exception,
initial_exception_value ? *initial_exception_value : UndefinedConstant());
Label reject_promise(this, reject_label_type);

ThrowIfNotAsyncFromSyncIterator(context, iterator, &reject_promise,
&var_exception, operation_name);

TNode<Object> const sync_iterator =
LoadObjectField(iterator, JSAsyncFromSyncIterator::kSyncIteratorOffset);
TNode<JSAsyncFromSyncIterator> async_iterator = CAST(iterator);
const TNode<JSReceiver> sync_iterator = LoadObjectField<JSReceiver>(
async_iterator, JSAsyncFromSyncIterator::kSyncIteratorOffset);

Node* const method = get_method(sync_iterator);
TNode<Object> method = get_method(sync_iterator);

if (if_method_undefined) {
Label if_isnotundefined(this);
Expand All @@ -123,30 +130,30 @@ void AsyncFromSyncBuiltinsAssembler::Generate_AsyncFromSyncIteratorMethod(
BIND(&if_isnotundefined);
}

Node* const iter_result = CallJS(CodeFactory::Call(isolate()), context,
method, sync_iterator, sent_value);
const TNode<Object> iter_result = CallJS(
CodeFactory::Call(isolate()), context, method, sync_iterator, sent_value);
GotoIfException(iter_result, &reject_promise, &var_exception);

Node* value;
Node* done;
TNode<Object> value;
TNode<Oddball> done;
std::tie(value, done) = LoadIteratorResult(
context, native_context, iter_result, &reject_promise, &var_exception);

TNode<JSFunction> const promise_fun =
const TNode<JSFunction> promise_fun =
CAST(LoadContextElement(native_context, Context::PROMISE_FUNCTION_INDEX));
CSA_ASSERT(this, IsConstructor(promise_fun));

// Let valueWrapper be PromiseResolve(%Promise%, « value »).
TNode<Object> const value_wrapper = CallBuiltin(
const TNode<Object> value_wrapper = CallBuiltin(
Builtins::kPromiseResolve, native_context, promise_fun, value);
// IfAbruptRejectPromise(valueWrapper, promiseCapability).
GotoIfException(value_wrapper, &reject_promise, &var_exception);

// Let onFulfilled be a new built-in function object as defined in
// Async Iterator Value Unwrap Functions.
// Set onFulfilled.[[Done]] to throwDone.
TNode<JSFunction> const on_fulfilled =
CreateUnwrapClosure(native_context, CAST(done));
const TNode<JSFunction> on_fulfilled =
CreateUnwrapClosure(native_context, done);

// Perform ! PerformPromiseThen(valueWrapper,
// onFulfilled, undefined, promiseCapability).
Expand All @@ -155,95 +162,100 @@ void AsyncFromSyncBuiltinsAssembler::Generate_AsyncFromSyncIteratorMethod(

BIND(&reject_promise);
{
Node* const exception = var_exception.value();
const TNode<Object> exception = var_exception.value();
CallBuiltin(Builtins::kRejectPromise, context, promise, exception,
TrueConstant());
Return(promise);
}
}
std::pair<Node*, Node*> AsyncFromSyncBuiltinsAssembler::LoadIteratorResult(
Node* const context, Node* const native_context, Node* const iter_result,
Label* if_exception, Variable* var_exception) {

std::pair<TNode<Object>, TNode<Oddball>>
AsyncFromSyncBuiltinsAssembler::LoadIteratorResult(
const TNode<Context> context, const TNode<NativeContext> native_context,
const TNode<Object> iter_result, Label* if_exception,
TVariable<Object>* var_exception) {
Label if_fastpath(this), if_slowpath(this), merge(this), to_boolean(this),
done(this), if_notanobject(this, Label::kDeferred);
GotoIf(TaggedIsSmi(iter_result), &if_notanobject);

TNode<Map> const iter_result_map = LoadMap(iter_result);
const TNode<Map> iter_result_map = LoadMap(CAST(iter_result));
GotoIfNot(IsJSReceiverMap(iter_result_map), &if_notanobject);

TNode<Object> const fast_iter_result_map =
const TNode<Object> fast_iter_result_map =
LoadContextElement(native_context, Context::ITERATOR_RESULT_MAP_INDEX);

VARIABLE(var_value, MachineRepresentation::kTagged);
VARIABLE(var_done, MachineRepresentation::kTagged);
TVARIABLE(Object, var_value);
TVARIABLE(Object, var_done);
Branch(TaggedEqual(iter_result_map, fast_iter_result_map), &if_fastpath,
&if_slowpath);

BIND(&if_fastpath);
{
var_done.Bind(LoadObjectField(iter_result, JSIteratorResult::kDoneOffset));
var_value.Bind(
LoadObjectField(iter_result, JSIteratorResult::kValueOffset));
TNode<JSObject> fast_iter_result = CAST(iter_result);
var_done = LoadObjectField(fast_iter_result, JSIteratorResult::kDoneOffset);
var_value =
LoadObjectField(fast_iter_result, JSIteratorResult::kValueOffset);
Goto(&merge);
}

BIND(&if_slowpath);
{
// Let nextDone be IteratorComplete(nextResult).
// IfAbruptRejectPromise(nextDone, promiseCapability).
TNode<Object> const done =
const TNode<Object> done =
GetProperty(context, iter_result, factory()->done_string());
GotoIfException(done, if_exception, var_exception);

// Let nextValue be IteratorValue(nextResult).
// IfAbruptRejectPromise(nextValue, promiseCapability).
TNode<Object> const value =
const TNode<Object> value =
GetProperty(context, iter_result, factory()->value_string());
GotoIfException(value, if_exception, var_exception);

var_value.Bind(value);
var_done.Bind(done);
var_value = value;
var_done = done;
Goto(&merge);
}

BIND(&if_notanobject);
{
// Sync iterator result is not an object --- Produce a TypeError and jump
// to the `if_exception` path.
Node* const error = MakeTypeError(
MessageTemplate::kIteratorResultNotAnObject, context, iter_result);
var_exception->Bind(error);
const TNode<Object> error = CAST(MakeTypeError(
MessageTemplate::kIteratorResultNotAnObject, context, iter_result));
*var_exception = error;
Goto(if_exception);
}

BIND(&merge);
// Ensure `iterResult.done` is a Boolean.
GotoIf(TaggedIsSmi(var_done.value()), &to_boolean);
Branch(IsBoolean(var_done.value()), &done, &to_boolean);
Branch(IsBoolean(CAST(var_done.value())), &done, &to_boolean);

BIND(&to_boolean);
{
TNode<Object> const result =
const TNode<Object> result =
CallBuiltin(Builtins::kToBoolean, context, var_done.value());
var_done.Bind(result);
var_done = result;
Goto(&done);
}

BIND(&done);
return std::make_pair(var_value.value(), var_done.value());
return std::make_pair(var_value.value(), CAST(var_done.value()));
}

} // namespace

// https://tc39.github.io/proposal-async-iteration/
// Section #sec-%asyncfromsynciteratorprototype%.next
TF_BUILTIN(AsyncFromSyncIteratorPrototypeNext, AsyncFromSyncBuiltinsAssembler) {
Node* const iterator = Parameter(Descriptor::kReceiver);
Node* const value = Parameter(Descriptor::kValue);
Node* const context = Parameter(Descriptor::kContext);
const TNode<Object> iterator = CAST(Parameter(Descriptor::kReceiver));
const TNode<Object> value = CAST(Parameter(Descriptor::kValue));
const TNode<Context> context = CAST(Parameter(Descriptor::kContext));

auto get_method = [=](Node* const unused) {
return LoadObjectField(iterator, JSAsyncFromSyncIterator::kNextOffset);
auto get_method = [=](const TNode<JSReceiver> unused) {
return LoadObjectField(CAST(iterator),
JSAsyncFromSyncIterator::kNextOffset);
};
Generate_AsyncFromSyncIteratorMethod(
context, iterator, value, get_method, UndefinedMethodHandler(),
Expand All @@ -254,15 +266,16 @@ TF_BUILTIN(AsyncFromSyncIteratorPrototypeNext, AsyncFromSyncBuiltinsAssembler) {
// Section #sec-%asyncfromsynciteratorprototype%.return
TF_BUILTIN(AsyncFromSyncIteratorPrototypeReturn,
AsyncFromSyncBuiltinsAssembler) {
Node* const iterator = Parameter(Descriptor::kReceiver);
Node* const value = Parameter(Descriptor::kValue);
Node* const context = Parameter(Descriptor::kContext);
const TNode<Object> iterator = CAST(Parameter(Descriptor::kReceiver));
const TNode<Object> value = CAST(Parameter(Descriptor::kValue));
const TNode<Context> context = CAST(Parameter(Descriptor::kContext));

auto if_return_undefined = [=](Node* const native_context,
Node* const promise, Label* if_exception) {
auto if_return_undefined = [=](const TNode<NativeContext> native_context,
const TNode<JSPromise> promise,
Label* if_exception) {
// If return is undefined, then
// Let iterResult be ! CreateIterResultObject(value, true)
TNode<Object> const iter_result = CallBuiltin(
const TNode<Object> iter_result = CallBuiltin(
Builtins::kCreateIterResultObject, context, value, TrueConstant());

// Perform ! Call(promiseCapability.[[Resolve]], undefined, « iterResult »).
Expand All @@ -281,11 +294,12 @@ TF_BUILTIN(AsyncFromSyncIteratorPrototypeReturn,
// Section #sec-%asyncfromsynciteratorprototype%.throw
TF_BUILTIN(AsyncFromSyncIteratorPrototypeThrow,
AsyncFromSyncBuiltinsAssembler) {
Node* const iterator = Parameter(Descriptor::kReceiver);
Node* const reason = Parameter(Descriptor::kReason);
Node* const context = Parameter(Descriptor::kContext);
const TNode<Object> iterator = CAST(Parameter(Descriptor::kReceiver));
const TNode<Object> reason = CAST(Parameter(Descriptor::kReason));
const TNode<Context> context = CAST(Parameter(Descriptor::kContext));

auto if_throw_undefined = [=](Node* const native_context, Node* const promise,
auto if_throw_undefined = [=](const TNode<NativeContext> native_context,
const TNode<JSPromise> promise,
Label* if_exception) { Goto(if_exception); };

Generate_AsyncFromSyncIteratorMethod(
Expand Down

0 comments on commit 2f1bc98

Please sign in to comment.