1 // Copyright 2017 the V8 project authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4 
5 #include "src/base/optional.h"
6 #include "src/builtins/builtins-async-gen.h"
7 #include "src/builtins/builtins-utils-gen.h"
8 #include "src/builtins/builtins.h"
9 #include "src/codegen/code-factory.h"
10 #include "src/codegen/code-stub-assembler.h"
11 #include "src/execution/frames-inl.h"
12 
13 namespace v8 {
14 namespace internal {
15 
16 namespace {
17 class AsyncFromSyncBuiltinsAssembler : public AsyncBuiltinsAssembler {
18  public:
19   // The 'next' and 'return' take an optional value parameter, and the 'throw'
20   // method take an optional reason parameter.
21   static const int kValueOrReasonArg = 0;
22 
AsyncFromSyncBuiltinsAssembler(compiler::CodeAssemblerState* state)23   explicit AsyncFromSyncBuiltinsAssembler(compiler::CodeAssemblerState* state)
24       : AsyncBuiltinsAssembler(state) {}
25 
26   void ThrowIfNotAsyncFromSyncIterator(const TNode<Context> context,
27                                        const TNode<Object> object,
28                                        Label* if_exception,
29                                        TVariable<Object>* var_exception,
30                                        const char* method_name);
31 
32   using UndefinedMethodHandler =
33       std::function<void(const TNode<NativeContext> native_context,
34                          const TNode<JSPromise> promise, Label* if_exception)>;
35   using SyncIteratorNodeGenerator =
36       std::function<TNode<Object>(TNode<JSReceiver>)>;
37   void Generate_AsyncFromSyncIteratorMethod(
38       CodeStubArguments* args, const TNode<Context> context,
39       const TNode<Object> iterator, const TNode<Object> sent_value,
40       const SyncIteratorNodeGenerator& get_method,
41       const UndefinedMethodHandler& if_method_undefined,
42       const char* operation_name,
43       Label::Type reject_label_type = Label::kDeferred,
44       base::Optional<TNode<Object>> initial_exception_value = base::nullopt);
45 
Generate_AsyncFromSyncIteratorMethod( CodeStubArguments* args, 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, base::Optional<TNode<Object>> initial_exception_value = base::nullopt)46   void Generate_AsyncFromSyncIteratorMethod(
47       CodeStubArguments* args, const TNode<Context> context,
48       const TNode<Object> iterator, const TNode<Object> sent_value,
49       Handle<String> name, const UndefinedMethodHandler& if_method_undefined,
50       const char* operation_name,
51       Label::Type reject_label_type = Label::kDeferred,
52       base::Optional<TNode<Object>> initial_exception_value = base::nullopt) {
53     auto get_method = [=](const TNode<JSReceiver> sync_iterator) {
54       return GetProperty(context, sync_iterator, name);
55     };
56     return Generate_AsyncFromSyncIteratorMethod(
57         args, context, iterator, sent_value, get_method, if_method_undefined,
58         operation_name, reject_label_type, initial_exception_value);
59   }
60 
61   // Load "value" and "done" from an iterator result object. If an exception
62   // is thrown at any point, jumps to the `if_exception` label with exception
63   // stored in `var_exception`.
64   //
65   // Returns a Pair of Nodes, whose first element is the value of the "value"
66   // property, and whose second element is the value of the "done" property,
67   // converted to a Boolean if needed.
68   std::pair<TNode<Object>, TNode<Oddball>> LoadIteratorResult(
69       const TNode<Context> context, const TNode<NativeContext> native_context,
70       const TNode<Object> iter_result, Label* if_exception,
71       TVariable<Object>* var_exception);
72 };
73 
ThrowIfNotAsyncFromSyncIterator( const TNode<Context> context, const TNode<Object> object, Label* if_exception, TVariable<Object>* var_exception, const char* method_name)74 void AsyncFromSyncBuiltinsAssembler::ThrowIfNotAsyncFromSyncIterator(
75     const TNode<Context> context, const TNode<Object> object,
76     Label* if_exception, TVariable<Object>* var_exception,
77     const char* method_name) {
78   Label if_receiverisincompatible(this, Label::kDeferred), done(this);
79 
80   GotoIf(TaggedIsSmi(object), &if_receiverisincompatible);
81   Branch(HasInstanceType(CAST(object), JS_ASYNC_FROM_SYNC_ITERATOR_TYPE), &done,
82          &if_receiverisincompatible);
83 
84   BIND(&if_receiverisincompatible);
85   {
86     // If Type(O) is not Object, or if O does not have a [[SyncIterator]]
87     // internal slot, then
88 
89     // Let badIteratorError be a new TypeError exception.
90     TNode<HeapObject> error =
91         MakeTypeError(MessageTemplate::kIncompatibleMethodReceiver, context,
92                       StringConstant(method_name), object);
93 
94     // Perform ! Call(promiseCapability.[[Reject]], undefined,
95     //                « badIteratorError »).
96     *var_exception = error;
97     Goto(if_exception);
98   }
99 
100   BIND(&done);
101 }
102 
Generate_AsyncFromSyncIteratorMethod( CodeStubArguments* args, 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, base::Optional<TNode<Object>> initial_exception_value)103 void AsyncFromSyncBuiltinsAssembler::Generate_AsyncFromSyncIteratorMethod(
104     CodeStubArguments* args, const TNode<Context> context,
105     const TNode<Object> iterator, const TNode<Object> sent_value,
106     const SyncIteratorNodeGenerator& get_method,
107     const UndefinedMethodHandler& if_method_undefined,
108     const char* operation_name, Label::Type reject_label_type,
109     base::Optional<TNode<Object>> initial_exception_value) {
110   const TNode<NativeContext> native_context = LoadNativeContext(context);
111   const TNode<JSPromise> promise = NewJSPromise(context);
112 
113   TVARIABLE(
114       Object, var_exception,
115       initial_exception_value ? *initial_exception_value : UndefinedConstant());
116   Label reject_promise(this, reject_label_type);
117 
118   ThrowIfNotAsyncFromSyncIterator(context, iterator, &reject_promise,
119                                   &var_exception, operation_name);
120 
121   TNode<JSAsyncFromSyncIterator> async_iterator = CAST(iterator);
122   const TNode<JSReceiver> sync_iterator = LoadObjectField<JSReceiver>(
123       async_iterator, JSAsyncFromSyncIterator::kSyncIteratorOffset);
124 
125   TNode<Object> method = get_method(sync_iterator);
126 
127   if (if_method_undefined) {
128     Label if_isnotundefined(this);
129 
130     GotoIfNot(IsNullOrUndefined(method), &if_isnotundefined);
131     if_method_undefined(native_context, promise, &reject_promise);
132 
133     BIND(&if_isnotundefined);
134   }
135 
136   TVARIABLE(Object, iter_result);
137   {
138     Label has_sent_value(this), no_sent_value(this), merge(this);
139     ScopedExceptionHandler handler(this, &reject_promise, &var_exception);
140     Branch(IntPtrGreaterThan(args->GetLengthWithoutReceiver(),
141                              IntPtrConstant(kValueOrReasonArg)),
142            &has_sent_value, &no_sent_value);
143     BIND(&has_sent_value);
144     {
145       iter_result = Call(context, method, sync_iterator, sent_value);
146       Goto(&merge);
147     }
148     BIND(&no_sent_value);
149     {
150       iter_result = Call(context, method, sync_iterator);
151       Goto(&merge);
152     }
153     BIND(&merge);
154   }
155 
156   TNode<Object> value;
157   TNode<Oddball> done;
158   std::tie(value, done) =
159       LoadIteratorResult(context, native_context, iter_result.value(),
160                          &reject_promise, &var_exception);
161 
162   const TNode<JSFunction> promise_fun =
163       CAST(LoadContextElement(native_context, Context::PROMISE_FUNCTION_INDEX));
164   CSA_DCHECK(this, IsConstructor(promise_fun));
165 
166   // Let valueWrapper be PromiseResolve(%Promise%, « value »).
167   // IfAbruptRejectPromise(valueWrapper, promiseCapability).
168   TNode<Object> value_wrapper;
169   {
170     ScopedExceptionHandler handler(this, &reject_promise, &var_exception);
171     value_wrapper = CallBuiltin(Builtin::kPromiseResolve, native_context,
172                                 promise_fun, value);
173   }
174 
175   // Let onFulfilled be a new built-in function object as defined in
176   // Async Iterator Value Unwrap Functions.
177   // Set onFulfilled.[[Done]] to throwDone.
178   const TNode<JSFunction> on_fulfilled =
179       CreateUnwrapClosure(native_context, done);
180 
181   // Perform ! PerformPromiseThen(valueWrapper,
182   //     onFulfilled, undefined, promiseCapability).
183   args->PopAndReturn(CallBuiltin(Builtin::kPerformPromiseThen, context,
184                                  value_wrapper, on_fulfilled,
185                                  UndefinedConstant(), promise));
186 
187   BIND(&reject_promise);
188   {
189     const TNode<Object> exception = var_exception.value();
190     CallBuiltin(Builtin::kRejectPromise, context, promise, exception,
191                 TrueConstant());
192     args->PopAndReturn(promise);
193   }
194 }
195 
196 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)197 AsyncFromSyncBuiltinsAssembler::LoadIteratorResult(
198     const TNode<Context> context, const TNode<NativeContext> native_context,
199     const TNode<Object> iter_result, Label* if_exception,
200     TVariable<Object>* var_exception) {
201   Label if_fastpath(this), if_slowpath(this), merge(this), to_boolean(this),
202       done(this), if_notanobject(this, Label::kDeferred);
203   GotoIf(TaggedIsSmi(iter_result), &if_notanobject);
204 
205   const TNode<Map> iter_result_map = LoadMap(CAST(iter_result));
206   GotoIfNot(IsJSReceiverMap(iter_result_map), &if_notanobject);
207 
208   const TNode<Object> fast_iter_result_map =
209       LoadContextElement(native_context, Context::ITERATOR_RESULT_MAP_INDEX);
210 
211   TVARIABLE(Object, var_value);
212   TVARIABLE(Object, var_done);
213   Branch(TaggedEqual(iter_result_map, fast_iter_result_map), &if_fastpath,
214          &if_slowpath);
215 
216   BIND(&if_fastpath);
217   {
218     TNode<JSObject> fast_iter_result = CAST(iter_result);
219     var_done = LoadObjectField(fast_iter_result, JSIteratorResult::kDoneOffset);
220     var_value =
221         LoadObjectField(fast_iter_result, JSIteratorResult::kValueOffset);
222     Goto(&merge);
223   }
224 
225   BIND(&if_slowpath);
226   {
227     ScopedExceptionHandler handler(this, if_exception, var_exception);
228 
229     // Let nextDone be IteratorComplete(nextResult).
230     // IfAbruptRejectPromise(nextDone, promiseCapability).
231     const TNode<Object> iter_result_done =
232         GetProperty(context, iter_result, factory()->done_string());
233 
234     // Let nextValue be IteratorValue(nextResult).
235     // IfAbruptRejectPromise(nextValue, promiseCapability).
236     const TNode<Object> iter_result_value =
237         GetProperty(context, iter_result, factory()->value_string());
238 
239     var_value = iter_result_value;
240     var_done = iter_result_done;
241     Goto(&merge);
242   }
243 
244   BIND(&if_notanobject);
245   {
246     // Sync iterator result is not an object --- Produce a TypeError and jump
247     // to the `if_exception` path.
248     const TNode<Object> error = MakeTypeError(
249         MessageTemplate::kIteratorResultNotAnObject, context, iter_result);
250     *var_exception = error;
251     Goto(if_exception);
252   }
253 
254   BIND(&merge);
255   // Ensure `iterResult.done` is a Boolean.
256   GotoIf(TaggedIsSmi(var_done.value()), &to_boolean);
257   Branch(IsBoolean(CAST(var_done.value())), &done, &to_boolean);
258 
259   BIND(&to_boolean);
260   {
261     const TNode<Object> result =
262         CallBuiltin(Builtin::kToBoolean, context, var_done.value());
263     var_done = result;
264     Goto(&done);
265   }
266 
267   BIND(&done);
268   return std::make_pair(var_value.value(), CAST(var_done.value()));
269 }
270 
271 }  // namespace
272 
273 // https://tc39.github.io/proposal-async-iteration/
274 // Section #sec-%asyncfromsynciteratorprototype%.next
TF_BUILTIN(AsyncFromSyncIteratorPrototypeNext, AsyncFromSyncBuiltinsAssembler)275 TF_BUILTIN(AsyncFromSyncIteratorPrototypeNext, AsyncFromSyncBuiltinsAssembler) {
276   TNode<IntPtrT> argc = ChangeInt32ToIntPtr(
277       UncheckedParameter<Int32T>(Descriptor::kJSActualArgumentsCount));
278   CodeStubArguments args(this, argc);
279 
280   const TNode<Object> iterator = args.GetReceiver();
281   const TNode<Object> value = args.GetOptionalArgumentValue(kValueOrReasonArg);
282   const auto context = Parameter<Context>(Descriptor::kContext);
283 
284   auto get_method = [=](const TNode<JSReceiver> unused) {
285     return LoadObjectField(CAST(iterator),
286                            JSAsyncFromSyncIterator::kNextOffset);
287   };
288   Generate_AsyncFromSyncIteratorMethod(
289       &args, context, iterator, value, get_method, UndefinedMethodHandler(),
290       "[Async-from-Sync Iterator].prototype.next");
291 }
292 
293 // https://tc39.github.io/proposal-async-iteration/
294 // Section #sec-%asyncfromsynciteratorprototype%.return
TF_BUILTIN(AsyncFromSyncIteratorPrototypeReturn, AsyncFromSyncBuiltinsAssembler)295 TF_BUILTIN(AsyncFromSyncIteratorPrototypeReturn,
296            AsyncFromSyncBuiltinsAssembler) {
297   TNode<IntPtrT> argc = ChangeInt32ToIntPtr(
298       UncheckedParameter<Int32T>(Descriptor::kJSActualArgumentsCount));
299   CodeStubArguments args(this, argc);
300 
301   const TNode<Object> iterator = args.GetReceiver();
302   const TNode<Object> value = args.GetOptionalArgumentValue(kValueOrReasonArg);
303   const auto context = Parameter<Context>(Descriptor::kContext);
304 
305   auto if_return_undefined = [=, &args](
306                                  const TNode<NativeContext> native_context,
307                                  const TNode<JSPromise> promise,
308                                  Label* if_exception) {
309     // If return is undefined, then
310     // Let iterResult be ! CreateIterResultObject(value, true)
311     const TNode<Object> iter_result = CallBuiltin(
312         Builtin::kCreateIterResultObject, context, value, TrueConstant());
313 
314     // Perform ! Call(promiseCapability.[[Resolve]], undefined, « iterResult »).
315     // IfAbruptRejectPromise(nextDone, promiseCapability).
316     // Return promiseCapability.[[Promise]].
317     CallBuiltin(Builtin::kResolvePromise, context, promise, iter_result);
318     args.PopAndReturn(promise);
319   };
320 
321   Generate_AsyncFromSyncIteratorMethod(
322       &args, context, iterator, value, factory()->return_string(),
323       if_return_undefined, "[Async-from-Sync Iterator].prototype.return");
324 }
325 
326 // https://tc39.github.io/proposal-async-iteration/
327 // Section #sec-%asyncfromsynciteratorprototype%.throw
TF_BUILTIN(AsyncFromSyncIteratorPrototypeThrow, AsyncFromSyncBuiltinsAssembler)328 TF_BUILTIN(AsyncFromSyncIteratorPrototypeThrow,
329            AsyncFromSyncBuiltinsAssembler) {
330   TNode<IntPtrT> argc = ChangeInt32ToIntPtr(
331       UncheckedParameter<Int32T>(Descriptor::kJSActualArgumentsCount));
332   CodeStubArguments args(this, argc);
333 
334   const TNode<Object> iterator = args.GetReceiver();
335   const TNode<Object> reason = args.GetOptionalArgumentValue(kValueOrReasonArg);
336   const auto context = Parameter<Context>(Descriptor::kContext);
337 
338   auto if_throw_undefined = [=](const TNode<NativeContext> native_context,
339                                 const TNode<JSPromise> promise,
340                                 Label* if_exception) { Goto(if_exception); };
341 
342   Generate_AsyncFromSyncIteratorMethod(
343       &args, context, iterator, reason, factory()->throw_string(),
344       if_throw_undefined, "[Async-from-Sync Iterator].prototype.throw",
345       Label::kNonDeferred, reason);
346 }
347 
348 }  // namespace internal
349 }  // namespace v8
350