| OLD | NEW |
|---|
| (Empty) |
| 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/builtins/builtins-async.h" | |
| 6 #include "src/builtins/builtins-utils.h" | |
| 7 #include "src/builtins/builtins.h" | |
| 8 #include "src/code-factory.h" | |
| 9 #include "src/code-stub-assembler.h" | |
| 10 #include "src/frames-inl.h" | |
| 11 | |
| 12 namespace v8 { | |
| 13 namespace internal { | |
| 14 | |
| 15 namespace { | |
| 16 | |
| 17 // Describe fields of Context associated with the AsyncIterator unwrap closure. | |
| 18 class ValueUnwrapContext { | |
| 19 public: | |
| 20 enum Fields { kDoneSlot = Context::MIN_CONTEXT_SLOTS, kLength }; | |
| 21 }; | |
| 22 | |
| 23 class AsyncFromSyncBuiltinsAssembler : public AsyncBuiltinsAssembler { | |
| 24 public: | |
| 25 explicit AsyncFromSyncBuiltinsAssembler(CodeAssemblerState* state) | |
| 26 : AsyncBuiltinsAssembler(state) {} | |
| 27 | |
| 28 void ThrowIfNotAsyncFromSyncIterator(Node* const context, Node* const object, | |
| 29 Label* if_exception, | |
| 30 Variable* var_exception, | |
| 31 const char* method_name); | |
| 32 | |
| 33 typedef std::function<void(Node* const context, Node* const promise, | |
| 34 Label* if_exception)> | |
| 35 UndefinedMethodHandler; | |
| 36 void Generate_AsyncFromSyncIteratorMethod( | |
| 37 Node* const context, Node* const iterator, Node* const sent_value, | |
| 38 Handle<Name> method_name, UndefinedMethodHandler&& if_method_undefined, | |
| 39 const char* operation_name, | |
| 40 Label::Type reject_label_type = Label::kDeferred, | |
| 41 Node* const initial_exception_value = nullptr); | |
| 42 | |
| 43 Node* AllocateAsyncIteratorValueUnwrapContext(Node* native_context, | |
| 44 Node* done); | |
| 45 | |
| 46 // Load "value" and "done" from an iterator result object. If an exception | |
| 47 // is thrown at any point, jumps to te `if_exception` label with exception | |
| 48 // stored in `var_exception`. | |
| 49 // | |
| 50 // Returns a Pair of Nodes, whose first element is the value of the "value" | |
| 51 // property, and whose second element is the value of the "done" property, | |
| 52 // converted to a Boolean if needed. | |
| 53 std::pair<Node*, Node*> LoadIteratorResult(Node* const context, | |
| 54 Node* const native_context, | |
| 55 Node* const iter_result, | |
| 56 Label* if_exception, | |
| 57 Variable* var_exception); | |
| 58 | |
| 59 Node* CreateUnwrapClosure(Node* const native_context, Node* const done); | |
| 60 }; | |
| 61 | |
| 62 void AsyncFromSyncBuiltinsAssembler::ThrowIfNotAsyncFromSyncIterator( | |
| 63 Node* const context, Node* const object, Label* if_exception, | |
| 64 Variable* var_exception, const char* method_name) { | |
| 65 Label if_receiverisincompatible(this, Label::kDeferred), done(this); | |
| 66 | |
| 67 GotoIf(TaggedIsSmi(object), &if_receiverisincompatible); | |
| 68 Branch(HasInstanceType(object, JS_ASYNC_FROM_SYNC_ITERATOR_TYPE), &done, | |
| 69 &if_receiverisincompatible); | |
| 70 | |
| 71 Bind(&if_receiverisincompatible); | |
| 72 { | |
| 73 // If Type(O) is not Object, or if O does not have a [[SyncIterator]] | |
| 74 // internal slot, then | |
| 75 | |
| 76 // Let badIteratorError be a new TypeError exception. | |
| 77 Node* const error = | |
| 78 MakeTypeError(MessageTemplate::kIncompatibleMethodReceiver, context, | |
| 79 CStringConstant(method_name), object); | |
| 80 | |
| 81 // Perform ! Call(promiseCapability.[[Reject]], undefined, | |
| 82 // « badIteratorError »). | |
| 83 var_exception->Bind(error); | |
| 84 Goto(if_exception); | |
| 85 } | |
| 86 | |
| 87 Bind(&done); | |
| 88 } | |
| 89 | |
| 90 void AsyncFromSyncBuiltinsAssembler::Generate_AsyncFromSyncIteratorMethod( | |
| 91 Node* const context, Node* const iterator, Node* const sent_value, | |
| 92 Handle<Name> method_name, UndefinedMethodHandler&& if_method_undefined, | |
| 93 const char* operation_name, Label::Type reject_label_type, | |
| 94 Node* const initial_exception_value) { | |
| 95 Node* const native_context = LoadNativeContext(context); | |
| 96 Node* const promise = AllocateAndInitJSPromise(context); | |
| 97 | |
| 98 Variable var_exception(this, MachineRepresentation::kTagged, | |
| 99 initial_exception_value == nullptr | |
| 100 ? UndefinedConstant() | |
| 101 : initial_exception_value); | |
| 102 Label reject_promise(this, reject_label_type); | |
| 103 | |
| 104 ThrowIfNotAsyncFromSyncIterator(context, iterator, &reject_promise, | |
| 105 &var_exception, operation_name); | |
| 106 | |
| 107 Node* const sync_iterator = | |
| 108 LoadObjectField(iterator, JSAsyncFromSyncIterator::kSyncIteratorOffset); | |
| 109 | |
| 110 Node* const method = GetProperty(context, sync_iterator, method_name); | |
| 111 | |
| 112 if (if_method_undefined) { | |
| 113 Label if_isnotundefined(this); | |
| 114 | |
| 115 GotoIfNot(IsUndefined(method), &if_isnotundefined); | |
| 116 if_method_undefined(native_context, promise, &reject_promise); | |
| 117 | |
| 118 Bind(&if_isnotundefined); | |
| 119 } | |
| 120 | |
| 121 Node* const iter_result = CallJS(CodeFactory::Call(isolate()), context, | |
| 122 method, sync_iterator, sent_value); | |
| 123 GotoIfException(iter_result, &reject_promise, &var_exception); | |
| 124 | |
| 125 Node* value; | |
| 126 Node* done; | |
| 127 std::tie(value, done) = LoadIteratorResult( | |
| 128 context, native_context, iter_result, &reject_promise, &var_exception); | |
| 129 Node* const wrapper = AllocateAndInitJSPromise(context); | |
| 130 | |
| 131 // Perform ! Call(valueWrapperCapability.[[Resolve]], undefined, « | |
| 132 // throwValue »). | |
| 133 InternalResolvePromise(context, wrapper, value); | |
| 134 | |
| 135 // Let onFulfilled be a new built-in function object as defined in | |
| 136 // Async Iterator Value Unwrap Functions. | |
| 137 // Set onFulfilled.[[Done]] to throwDone. | |
| 138 Node* const on_fulfilled = CreateUnwrapClosure(native_context, done); | |
| 139 | |
| 140 // Perform ! PerformPromiseThen(valueWrapperCapability.[[Promise]], | |
| 141 // onFulfilled, undefined, promiseCapability). | |
| 142 Node* const undefined = UndefinedConstant(); | |
| 143 InternalPerformPromiseThen(context, wrapper, on_fulfilled, undefined, promise, | |
| 144 undefined, undefined); | |
| 145 Return(promise); | |
| 146 | |
| 147 Bind(&reject_promise); | |
| 148 { | |
| 149 Node* const exception = var_exception.value(); | |
| 150 InternalPromiseReject(context, promise, exception, TrueConstant()); | |
| 151 | |
| 152 Return(promise); | |
| 153 } | |
| 154 } | |
| 155 | |
| 156 std::pair<Node*, Node*> AsyncFromSyncBuiltinsAssembler::LoadIteratorResult( | |
| 157 Node* const context, Node* const native_context, Node* const iter_result, | |
| 158 Label* if_exception, Variable* var_exception) { | |
| 159 Label if_fastpath(this), if_slowpath(this), merge(this), to_boolean(this), | |
| 160 done(this), if_notanobject(this, Label::kDeferred); | |
| 161 GotoIf(TaggedIsSmi(iter_result), &if_notanobject); | |
| 162 | |
| 163 Node* const iter_result_map = LoadMap(iter_result); | |
| 164 GotoIfNot(IsJSReceiverMap(iter_result_map), &if_notanobject); | |
| 165 | |
| 166 Node* const fast_iter_result_map = | |
| 167 LoadContextElement(native_context, Context::ITERATOR_RESULT_MAP_INDEX); | |
| 168 | |
| 169 Variable var_value(this, MachineRepresentation::kTagged); | |
| 170 Variable var_done(this, MachineRepresentation::kTagged); | |
| 171 Branch(WordEqual(iter_result_map, fast_iter_result_map), &if_fastpath, | |
| 172 &if_slowpath); | |
| 173 | |
| 174 Bind(&if_fastpath); | |
| 175 { | |
| 176 var_value.Bind( | |
| 177 LoadObjectField(iter_result, JSIteratorResult::kValueOffset)); | |
| 178 var_done.Bind(LoadObjectField(iter_result, JSIteratorResult::kDoneOffset)); | |
| 179 Goto(&merge); | |
| 180 } | |
| 181 | |
| 182 Bind(&if_slowpath); | |
| 183 { | |
| 184 // Let nextValue be IteratorValue(nextResult). | |
| 185 // IfAbruptRejectPromise(nextValue, promiseCapability). | |
| 186 Node* const value = | |
| 187 GetProperty(context, iter_result, factory()->value_string()); | |
| 188 GotoIfException(value, if_exception, var_exception); | |
| 189 | |
| 190 // Let nextDone be IteratorComplete(nextResult). | |
| 191 // IfAbruptRejectPromise(nextDone, promiseCapability). | |
| 192 Node* const done = | |
| 193 GetProperty(context, iter_result, factory()->done_string()); | |
| 194 GotoIfException(done, if_exception, var_exception); | |
| 195 | |
| 196 var_value.Bind(value); | |
| 197 var_done.Bind(done); | |
| 198 Goto(&merge); | |
| 199 } | |
| 200 | |
| 201 Bind(&if_notanobject); | |
| 202 { | |
| 203 // Sync iterator result is not an object --- Produce a TypeError and jump | |
| 204 // to the `if_exception` path. | |
| 205 Node* const error = MakeTypeError( | |
| 206 MessageTemplate::kIteratorResultNotAnObject, context, iter_result); | |
| 207 var_exception->Bind(error); | |
| 208 Goto(if_exception); | |
| 209 } | |
| 210 | |
| 211 Bind(&merge); | |
| 212 // Ensure `iterResult.done` is a Boolean. | |
| 213 GotoIf(TaggedIsSmi(var_done.value()), &to_boolean); | |
| 214 Branch(IsBoolean(var_done.value()), &done, &to_boolean); | |
| 215 | |
| 216 Bind(&to_boolean); | |
| 217 { | |
| 218 Node* const result = | |
| 219 CallStub(CodeFactory::ToBoolean(isolate()), context, var_done.value()); | |
| 220 var_done.Bind(result); | |
| 221 Goto(&done); | |
| 222 } | |
| 223 | |
| 224 Bind(&done); | |
| 225 return std::make_pair(var_value.value(), var_done.value()); | |
| 226 } | |
| 227 | |
| 228 Node* AsyncFromSyncBuiltinsAssembler::CreateUnwrapClosure(Node* native_context, | |
| 229 Node* done) { | |
| 230 Node* const map = LoadContextElement( | |
| 231 native_context, Context::STRICT_FUNCTION_WITHOUT_PROTOTYPE_MAP_INDEX); | |
| 232 Node* const on_fulfilled_shared = LoadContextElement( | |
| 233 native_context, Context::ASYNC_ITERATOR_VALUE_UNWRAP_SHARED_FUN); | |
| 234 CSA_ASSERT(this, | |
| 235 HasInstanceType(on_fulfilled_shared, SHARED_FUNCTION_INFO_TYPE)); | |
| 236 Node* const closure_context = | |
| 237 AllocateAsyncIteratorValueUnwrapContext(native_context, done); | |
| 238 return AllocateFunctionWithMapAndContext(map, on_fulfilled_shared, | |
| 239 closure_context); | |
| 240 } | |
| 241 | |
| 242 Node* AsyncFromSyncBuiltinsAssembler::AllocateAsyncIteratorValueUnwrapContext( | |
| 243 Node* native_context, Node* done) { | |
| 244 CSA_ASSERT(this, IsNativeContext(native_context)); | |
| 245 CSA_ASSERT(this, IsBoolean(done)); | |
| 246 | |
| 247 Node* const context = | |
| 248 CreatePromiseContext(native_context, ValueUnwrapContext::kLength); | |
| 249 StoreContextElementNoWriteBarrier(context, ValueUnwrapContext::kDoneSlot, | |
| 250 done); | |
| 251 return context; | |
| 252 } | |
| 253 } // namespace | |
| 254 | |
| 255 // https://tc39.github.io/proposal-async-iteration/ | |
| 256 // Section #sec-%asyncfromsynciteratorprototype%.next | |
| 257 TF_BUILTIN(AsyncFromSyncIteratorPrototypeNext, AsyncFromSyncBuiltinsAssembler) { | |
| 258 Node* const iterator = Parameter(0); | |
| 259 Node* const value = Parameter(1); | |
| 260 Node* const context = Parameter(4); | |
| 261 | |
| 262 Generate_AsyncFromSyncIteratorMethod( | |
| 263 context, iterator, value, factory()->next_string(), | |
| 264 UndefinedMethodHandler(), "[Async-from-Sync Iterator].prototype.next"); | |
| 265 } | |
| 266 | |
| 267 // https://tc39.github.io/proposal-async-iteration/ | |
| 268 // Section #sec-%asyncfromsynciteratorprototype%.return | |
| 269 TF_BUILTIN(AsyncFromSyncIteratorPrototypeReturn, | |
| 270 AsyncFromSyncBuiltinsAssembler) { | |
| 271 Node* const iterator = Parameter(0); | |
| 272 Node* const value = Parameter(1); | |
| 273 Node* const context = Parameter(4); | |
| 274 | |
| 275 auto if_return_undefined = [=](Node* const native_context, | |
| 276 Node* const promise, Label* if_exception) { | |
| 277 // If return is undefined, then | |
| 278 // Let iterResult be ! CreateIterResultObject(value, true) | |
| 279 Node* const iter_result = | |
| 280 CallStub(CodeFactory::CreateIterResultObject(isolate()), context, value, | |
| 281 TrueConstant()); | |
| 282 | |
| 283 // Perform ! Call(promiseCapability.[[Resolve]], undefined, « iterResult »). | |
| 284 // IfAbruptRejectPromise(nextDone, promiseCapability). | |
| 285 // Return promiseCapability.[[Promise]]. | |
| 286 PromiseFulfill(context, promise, iter_result, v8::Promise::kFulfilled); | |
| 287 Return(promise); | |
| 288 }; | |
| 289 | |
| 290 Generate_AsyncFromSyncIteratorMethod( | |
| 291 context, iterator, value, factory()->return_string(), if_return_undefined, | |
| 292 "[Async-from-Sync Iterator].prototype.return"); | |
| 293 } | |
| 294 | |
| 295 // https://tc39.github.io/proposal-async-iteration/ | |
| 296 // Section #sec-%asyncfromsynciteratorprototype%.throw | |
| 297 TF_BUILTIN(AsyncFromSyncIteratorPrototypeThrow, | |
| 298 AsyncFromSyncBuiltinsAssembler) { | |
| 299 Node* const iterator = Parameter(0); | |
| 300 Node* const reason = Parameter(1); | |
| 301 Node* const context = Parameter(4); | |
| 302 | |
| 303 auto if_throw_undefined = [=](Node* const native_context, Node* const promise, | |
| 304 Label* if_exception) { Goto(if_exception); }; | |
| 305 | |
| 306 Generate_AsyncFromSyncIteratorMethod( | |
| 307 context, iterator, reason, factory()->throw_string(), if_throw_undefined, | |
| 308 "[Async-from-Sync Iterator].prototype.throw", Label::kNonDeferred, | |
| 309 reason); | |
| 310 } | |
| 311 | |
| 312 TF_BUILTIN(AsyncIteratorValueUnwrap, AsyncFromSyncBuiltinsAssembler) { | |
| 313 Node* const value = Parameter(1); | |
| 314 Node* const context = Parameter(4); | |
| 315 | |
| 316 Node* const done = LoadContextElement(context, ValueUnwrapContext::kDoneSlot); | |
| 317 CSA_ASSERT(this, IsBoolean(done)); | |
| 318 | |
| 319 Node* const unwrapped_value = CallStub( | |
| 320 CodeFactory::CreateIterResultObject(isolate()), context, value, done); | |
| 321 | |
| 322 Return(unwrapped_value); | |
| 323 } | |
| 324 | |
| 325 } // namespace internal | |
| 326 } // namespace v8 | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2752143004:
[refactor] Separate generated builtins and C++ builtins into separate files (Closed)
