Line data Source code
1 : // Copyright 2014 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/code-factory.h"
6 :
7 : #include "src/bootstrapper.h"
8 : #include "src/builtins/builtins-descriptors.h"
9 : #include "src/ic/ic.h"
10 : #include "src/objects-inl.h"
11 :
12 : namespace v8 {
13 : namespace internal {
14 :
15 : namespace {
16 :
17 : // TODO(ishell): make it (const Stub& stub) once CodeStub::GetCode() is const.
18 : template <typename Stub>
19 3398335 : Callable make_callable(Stub& stub) {
20 : typedef typename Stub::Descriptor Descriptor;
21 10195012 : return Callable(stub.GetCode(), Descriptor(stub.isolate()));
22 : }
23 :
24 : } // namespace
25 :
26 : // static
27 153807 : Handle<Code> CodeFactory::RuntimeCEntry(Isolate* isolate, int result_size) {
28 : CEntryStub stub(isolate, result_size);
29 153807 : return stub.GetCode();
30 : }
31 :
32 : // static
33 2134682 : Callable CodeFactory::LoadIC(Isolate* isolate) {
34 : return Callable(isolate->builtins()->LoadICTrampoline(),
35 6404046 : LoadDescriptor(isolate));
36 : }
37 :
38 : // static
39 903 : Callable CodeFactory::LoadICProtoArray(Isolate* isolate,
40 : bool throw_if_nonexistent) {
41 : return Callable(
42 : throw_if_nonexistent
43 301 : ? isolate->builtins()->LoadICProtoArrayThrowIfNonexistent()
44 602 : : isolate->builtins()->LoadICProtoArray(),
45 3612 : LoadICProtoArrayDescriptor(isolate));
46 : }
47 :
48 : // static
49 1591 : Callable CodeFactory::ApiGetter(Isolate* isolate) {
50 : CallApiGetterStub stub(isolate);
51 1591 : return make_callable(stub);
52 : }
53 :
54 : // static
55 258976 : Callable CodeFactory::LoadICInOptimizedCode(Isolate* isolate) {
56 : return Callable(isolate->builtins()->LoadIC(),
57 776928 : LoadWithVectorDescriptor(isolate));
58 : }
59 :
60 : // static
61 129 : Callable CodeFactory::LoadICInOptimizedCode_Noninlined(Isolate* isolate) {
62 : return Callable(isolate->builtins()->LoadIC_Noninlined(),
63 387 : LoadWithVectorDescriptor(isolate));
64 : }
65 :
66 : // static
67 910895 : Callable CodeFactory::LoadGlobalIC(Isolate* isolate, TypeofMode typeof_mode) {
68 : return Callable(
69 : typeof_mode == NOT_INSIDE_TYPEOF
70 910351 : ? isolate->builtins()->LoadGlobalICTrampoline()
71 545 : : isolate->builtins()->LoadGlobalICInsideTypeofTrampoline(),
72 3643582 : LoadGlobalDescriptor(isolate));
73 : }
74 :
75 : // static
76 54736 : Callable CodeFactory::LoadGlobalICInOptimizedCode(Isolate* isolate,
77 : TypeofMode typeof_mode) {
78 : return Callable(typeof_mode == NOT_INSIDE_TYPEOF
79 54644 : ? isolate->builtins()->LoadGlobalIC()
80 92 : : isolate->builtins()->LoadGlobalICInsideTypeof(),
81 218944 : LoadGlobalWithVectorDescriptor(isolate));
82 : }
83 :
84 : // static
85 279537 : Callable CodeFactory::KeyedLoadIC(Isolate* isolate) {
86 : return Callable(isolate->builtins()->KeyedLoadICTrampoline(),
87 838611 : LoadDescriptor(isolate));
88 : }
89 :
90 : // static
91 74599 : Callable CodeFactory::KeyedLoadICInOptimizedCode(Isolate* isolate) {
92 : return Callable(isolate->builtins()->KeyedLoadIC(),
93 223797 : LoadWithVectorDescriptor(isolate));
94 : }
95 :
96 : // static
97 628481 : Callable CodeFactory::CallIC(Isolate* isolate, ConvertReceiverMode mode,
98 : TailCallMode tail_call_mode) {
99 : CallICStub stub(isolate, mode, tail_call_mode);
100 628481 : return make_callable(stub);
101 : }
102 :
103 : // static
104 1105373 : Callable CodeFactory::CallICTrampoline(Isolate* isolate,
105 : ConvertReceiverMode mode,
106 : TailCallMode tail_call_mode) {
107 : CallICTrampolineStub stub(isolate, mode, tail_call_mode);
108 1105373 : return make_callable(stub);
109 : }
110 :
111 : // static
112 969476 : Callable CodeFactory::StoreIC(Isolate* isolate, LanguageMode language_mode) {
113 : return Callable(language_mode == STRICT
114 905124 : ? isolate->builtins()->StoreICStrictTrampoline()
115 64352 : : isolate->builtins()->StoreICTrampoline(),
116 3877904 : StoreDescriptor(isolate));
117 : }
118 :
119 : // static
120 46448 : Callable CodeFactory::StoreICInOptimizedCode(Isolate* isolate,
121 : LanguageMode language_mode) {
122 32515 : return Callable(language_mode == STRICT ? isolate->builtins()->StoreICStrict()
123 13933 : : isolate->builtins()->StoreIC(),
124 185792 : StoreWithVectorDescriptor(isolate));
125 : }
126 :
127 : // static
128 86 : Callable CodeFactory::StoreIC_Uninitialized(Isolate* isolate,
129 : LanguageMode language_mode) {
130 : return Callable(language_mode == STRICT
131 43 : ? isolate->builtins()->StoreICStrict_Uninitialized()
132 43 : : isolate->builtins()->StoreIC_Uninitialized(),
133 344 : StoreWithVectorDescriptor(isolate));
134 : }
135 :
136 224447 : Callable CodeFactory::StoreOwnIC(Isolate* isolate) {
137 : // TODO(ishell): Currently we use StoreOwnIC only for storing properties that
138 : // already exist in the boilerplate therefore we can use StoreIC.
139 : return Callable(isolate->builtins()->StoreICStrictTrampoline(),
140 673341 : StoreDescriptor(isolate));
141 : }
142 :
143 18978 : Callable CodeFactory::StoreOwnICInOptimizedCode(Isolate* isolate) {
144 : // TODO(ishell): Currently we use StoreOwnIC only for storing properties that
145 : // already exist in the boilerplate therefore we can use StoreIC.
146 : return Callable(isolate->builtins()->StoreICStrict(),
147 56934 : StoreWithVectorDescriptor(isolate));
148 : }
149 :
150 : // static
151 77702 : Callable CodeFactory::StoreGlobalIC(Isolate* isolate,
152 : LanguageMode language_mode) {
153 : // TODO(ishell): Use StoreGlobalIC[Strict]Trampoline when it's ready.
154 : return Callable(language_mode == STRICT
155 1271 : ? isolate->builtins()->StoreICStrictTrampoline()
156 76431 : : isolate->builtins()->StoreICTrampoline(),
157 310808 : StoreDescriptor(isolate));
158 : }
159 :
160 : // static
161 11398 : Callable CodeFactory::StoreGlobalICInOptimizedCode(Isolate* isolate,
162 : LanguageMode language_mode) {
163 : // TODO(ishell): Use StoreGlobalIC[Strict] when it's ready.
164 285 : return Callable(language_mode == STRICT ? isolate->builtins()->StoreICStrict()
165 11113 : : isolate->builtins()->StoreIC(),
166 45592 : StoreWithVectorDescriptor(isolate));
167 : }
168 :
169 : // static
170 239691 : Callable CodeFactory::KeyedStoreIC(Isolate* isolate,
171 : LanguageMode language_mode) {
172 : return Callable(language_mode == STRICT
173 146521 : ? isolate->builtins()->KeyedStoreICStrictTrampoline()
174 93170 : : isolate->builtins()->KeyedStoreICTrampoline(),
175 958764 : StoreDescriptor(isolate));
176 : }
177 :
178 : // static
179 24097 : Callable CodeFactory::KeyedStoreICInOptimizedCode(Isolate* isolate,
180 : LanguageMode language_mode) {
181 : return Callable(language_mode == STRICT
182 8938 : ? isolate->builtins()->KeyedStoreICStrict()
183 15159 : : isolate->builtins()->KeyedStoreIC(),
184 96388 : StoreWithVectorDescriptor(isolate));
185 : }
186 :
187 : // static
188 86 : Callable CodeFactory::KeyedStoreIC_Megamorphic(Isolate* isolate,
189 : LanguageMode language_mode) {
190 : return Callable(language_mode == STRICT
191 43 : ? isolate->builtins()->KeyedStoreIC_Megamorphic_Strict()
192 43 : : isolate->builtins()->KeyedStoreIC_Megamorphic(),
193 344 : StoreWithVectorDescriptor(isolate));
194 : }
195 :
196 : // static
197 712479 : Callable CodeFactory::CompareIC(Isolate* isolate, Token::Value op) {
198 : CompareICStub stub(isolate, op);
199 712479 : return make_callable(stub);
200 : }
201 :
202 : // static
203 834261 : Callable CodeFactory::BinaryOpIC(Isolate* isolate, Token::Value op) {
204 834261 : BinaryOpICStub stub(isolate, op);
205 834261 : return make_callable(stub);
206 : }
207 :
208 : // static
209 3189 : Callable CodeFactory::GetProperty(Isolate* isolate) {
210 : GetPropertyStub stub(isolate);
211 3189 : return make_callable(stub);
212 : }
213 :
214 : // static
215 2200 : Callable CodeFactory::NonPrimitiveToPrimitive(Isolate* isolate,
216 : ToPrimitiveHint hint) {
217 : return Callable(isolate->builtins()->NonPrimitiveToPrimitive(hint),
218 6600 : TypeConversionDescriptor(isolate));
219 : }
220 :
221 : // static
222 215 : Callable CodeFactory::OrdinaryToPrimitive(Isolate* isolate,
223 : OrdinaryToPrimitiveHint hint) {
224 : return Callable(isolate->builtins()->OrdinaryToPrimitive(hint),
225 645 : TypeConversionDescriptor(isolate));
226 : }
227 :
228 : // static
229 430 : Callable CodeFactory::NumberToString(Isolate* isolate) {
230 : NumberToStringStub stub(isolate);
231 430 : return make_callable(stub);
232 : }
233 :
234 : // static
235 0 : Callable CodeFactory::StringFromCharCode(Isolate* isolate) {
236 0 : Handle<Code> code(isolate->builtins()->StringFromCharCode());
237 0 : return Callable(code, BuiltinDescriptor(isolate));
238 : }
239 :
240 : #define TFS_BUILTIN(Name) \
241 : Callable CodeFactory::Name(Isolate* isolate) { \
242 : Handle<Code> code(isolate->builtins()->Name()); \
243 : return Callable(code, Builtin_##Name##_InterfaceDescriptor(isolate)); \
244 : }
245 :
246 21822 : TFS_BUILTIN(ToString)
247 59813 : TFS_BUILTIN(Add)
248 30370 : TFS_BUILTIN(Subtract)
249 36998 : TFS_BUILTIN(Multiply)
250 25588 : TFS_BUILTIN(Divide)
251 1556 : TFS_BUILTIN(Modulus)
252 4028 : TFS_BUILTIN(BitwiseAnd)
253 3392 : TFS_BUILTIN(BitwiseOr)
254 1924 : TFS_BUILTIN(BitwiseXor)
255 2808 : TFS_BUILTIN(ShiftLeft)
256 1178 : TFS_BUILTIN(ShiftRight)
257 802 : TFS_BUILTIN(ShiftRightLogical)
258 47040 : TFS_BUILTIN(LessThan)
259 2473 : TFS_BUILTIN(LessThanOrEqual)
260 12364 : TFS_BUILTIN(GreaterThan)
261 6156 : TFS_BUILTIN(GreaterThanOrEqual)
262 20554 : TFS_BUILTIN(Equal)
263 256086 : TFS_BUILTIN(StrictEqual)
264 688 : TFS_BUILTIN(CreateIterResultObject)
265 24974 : TFS_BUILTIN(HasProperty)
266 20422 : TFS_BUILTIN(NonNumberToNumber)
267 1486 : TFS_BUILTIN(StringToNumber)
268 3022 : TFS_BUILTIN(ToBoolean)
269 4284 : TFS_BUILTIN(ToInteger)
270 5686 : TFS_BUILTIN(ToLength)
271 2742 : TFS_BUILTIN(ToName)
272 180548 : TFS_BUILTIN(ToNumber)
273 11994 : TFS_BUILTIN(ToObject)
274 5666 : TFS_BUILTIN(ClassOf)
275 113448 : TFS_BUILTIN(Typeof)
276 4366 : TFS_BUILTIN(InstanceOf)
277 438 : TFS_BUILTIN(OrdinaryHasInstance)
278 362 : TFS_BUILTIN(CopyFastSmiOrObjectElements)
279 372 : TFS_BUILTIN(GrowFastDoubleElements)
280 3736 : TFS_BUILTIN(GrowFastSmiOrObjectElements)
281 7596 : TFS_BUILTIN(NewUnmappedArgumentsElements)
282 86804 : TFS_BUILTIN(FastCloneRegExp)
283 732226 : TFS_BUILTIN(FastNewClosure)
284 460 : TFS_BUILTIN(FastNewObject)
285 0 : TFS_BUILTIN(FastNewRestParameter)
286 7680 : TFS_BUILTIN(FastNewSloppyArguments)
287 0 : TFS_BUILTIN(FastNewStrictArguments)
288 3662 : TFS_BUILTIN(ForInFilter)
289 148 : TFS_BUILTIN(GetSuperConstructor)
290 172 : TFS_BUILTIN(LoadIC_Uninitialized)
291 86 : TFS_BUILTIN(KeyedLoadIC_Megamorphic)
292 86 : TFS_BUILTIN(PromiseHandleReject)
293 86 : TFS_BUILTIN(RegExpReplace)
294 86 : TFS_BUILTIN(RegExpSplit)
295 574 : TFS_BUILTIN(StringCharAt)
296 758 : TFS_BUILTIN(StringCharCodeAt)
297 32290 : TFS_BUILTIN(StringEqual)
298 1610 : TFS_BUILTIN(StringLessThan)
299 626 : TFS_BUILTIN(StringLessThanOrEqual)
300 372 : TFS_BUILTIN(StringGreaterThan)
301 418 : TFS_BUILTIN(StringGreaterThanOrEqual)
302 316 : TFS_BUILTIN(AsyncGeneratorResolve)
303 100 : TFS_BUILTIN(AsyncGeneratorReject)
304 172 : TFS_BUILTIN(AsyncGeneratorResumeNext)
305 :
306 : #undef TFS_BUILTIN
307 :
308 : // static
309 71435 : Callable CodeFactory::StringAdd(Isolate* isolate, StringAddFlags flags,
310 : PretenureFlag pretenure_flag) {
311 : StringAddStub stub(isolate, flags, pretenure_flag);
312 71435 : return make_callable(stub);
313 : }
314 :
315 : // static
316 13249 : Callable CodeFactory::StringCompare(Isolate* isolate, Token::Value token) {
317 13249 : switch (token) {
318 : case Token::EQ:
319 : case Token::EQ_STRICT:
320 12908 : return StringEqual(isolate);
321 : case Token::LT:
322 254 : return StringLessThan(isolate);
323 : case Token::GT:
324 14 : return StringGreaterThan(isolate);
325 : case Token::LTE:
326 36 : return StringLessThanOrEqual(isolate);
327 : case Token::GTE:
328 37 : return StringGreaterThanOrEqual(isolate);
329 : default:
330 : break;
331 : }
332 0 : UNREACHABLE();
333 : return StringEqual(isolate);
334 : }
335 :
336 : // static
337 211 : Callable CodeFactory::StringIndexOf(Isolate* isolate) {
338 : return Callable(isolate->builtins()->StringIndexOf(),
339 633 : StringIndexOfDescriptor(isolate));
340 : }
341 :
342 : // static
343 492 : Callable CodeFactory::SubString(Isolate* isolate) {
344 : SubStringStub stub(isolate);
345 984 : return Callable(stub.GetCode(), stub.GetCallInterfaceDescriptor());
346 : }
347 :
348 : // static
349 344 : Callable CodeFactory::ResumeGenerator(Isolate* isolate) {
350 : return Callable(isolate->builtins()->ResumeGeneratorTrampoline(),
351 1032 : ResumeGeneratorDescriptor(isolate));
352 : }
353 :
354 : // static
355 903 : Callable CodeFactory::FrameDropperTrampoline(Isolate* isolate) {
356 : return Callable(isolate->builtins()->FrameDropperTrampoline(),
357 2709 : FrameDropperTrampolineDescriptor(isolate));
358 : }
359 :
360 : // static
361 1123 : Callable CodeFactory::HandleDebuggerStatement(Isolate* isolate) {
362 : return Callable(isolate->builtins()->HandleDebuggerStatement(),
363 3369 : ContextOnlyDescriptor(isolate));
364 : }
365 :
366 : // static
367 92354 : Callable CodeFactory::FastCloneShallowArray(
368 : Isolate* isolate, AllocationSiteMode allocation_mode) {
369 : return Callable(isolate->builtins()->NewCloneShallowArray(allocation_mode),
370 277062 : FastCloneShallowArrayDescriptor(isolate));
371 : }
372 :
373 : // static
374 47983 : Callable CodeFactory::FastCloneShallowObject(Isolate* isolate, int length) {
375 : return Callable(isolate->builtins()->NewCloneShallowObject(length),
376 143949 : FastCloneShallowObjectDescriptor(isolate));
377 : }
378 :
379 : // static
380 45327 : Callable CodeFactory::FastNewFunctionContext(Isolate* isolate,
381 : ScopeType scope_type) {
382 : return Callable(isolate->builtins()->NewFunctionContext(scope_type),
383 135981 : FastNewFunctionContextDescriptor(isolate));
384 : }
385 :
386 : // static
387 1299 : Callable CodeFactory::ForInPrepare(Isolate* isolate) {
388 : return Callable(isolate->builtins()->ForInPrepare(),
389 3897 : ForInPrepareDescriptor(isolate));
390 : }
391 :
392 : // static
393 0 : Callable CodeFactory::ForInNext(Isolate* isolate) {
394 : return Callable(isolate->builtins()->ForInNext(),
395 0 : ForInNextDescriptor(isolate));
396 : }
397 :
398 : // static
399 12944 : Callable CodeFactory::AllocateHeapNumber(Isolate* isolate) {
400 : AllocateHeapNumberStub stub(isolate);
401 12944 : return make_callable(stub);
402 : }
403 :
404 : // static
405 51548 : Callable CodeFactory::ArgumentAdaptor(Isolate* isolate) {
406 : return Callable(isolate->builtins()->ArgumentsAdaptorTrampoline(),
407 154644 : ArgumentAdaptorDescriptor(isolate));
408 : }
409 :
410 : // static
411 176186 : Callable CodeFactory::Call(Isolate* isolate, ConvertReceiverMode mode,
412 : TailCallMode tail_call_mode) {
413 : return Callable(isolate->builtins()->Call(mode, tail_call_mode),
414 528558 : CallTrampolineDescriptor(isolate));
415 : }
416 :
417 : // static
418 175 : Callable CodeFactory::CallWithSpread(Isolate* isolate) {
419 : return Callable(isolate->builtins()->CallWithSpread(),
420 525 : CallTrampolineDescriptor(isolate));
421 : }
422 :
423 : // static
424 29225 : Callable CodeFactory::CallFunction(Isolate* isolate, ConvertReceiverMode mode,
425 : TailCallMode tail_call_mode) {
426 : return Callable(isolate->builtins()->CallFunction(mode, tail_call_mode),
427 87675 : CallTrampolineDescriptor(isolate));
428 : }
429 :
430 : // static
431 25 : Callable CodeFactory::CallForwardVarargs(Isolate* isolate) {
432 : return Callable(isolate->builtins()->CallForwardVarargs(),
433 75 : CallForwardVarargsDescriptor(isolate));
434 : }
435 :
436 : // static
437 198 : Callable CodeFactory::CallFunctionForwardVarargs(Isolate* isolate) {
438 : return Callable(isolate->builtins()->CallFunctionForwardVarargs(),
439 594 : CallForwardVarargsDescriptor(isolate));
440 : }
441 :
442 : // static
443 37683 : Callable CodeFactory::Construct(Isolate* isolate) {
444 : return Callable(isolate->builtins()->Construct(),
445 113049 : ConstructTrampolineDescriptor(isolate));
446 : }
447 :
448 : // static
449 247 : Callable CodeFactory::ConstructWithSpread(Isolate* isolate) {
450 : return Callable(isolate->builtins()->ConstructWithSpread(),
451 741 : ConstructTrampolineDescriptor(isolate));
452 : }
453 :
454 : // static
455 656 : Callable CodeFactory::ConstructFunction(Isolate* isolate) {
456 : return Callable(isolate->builtins()->ConstructFunction(),
457 1968 : ConstructTrampolineDescriptor(isolate));
458 : }
459 :
460 : // static
461 1447 : Callable CodeFactory::InterpreterPushArgsThenCall(
462 : Isolate* isolate, ConvertReceiverMode receiver_mode,
463 : TailCallMode tail_call_mode, InterpreterPushArgsMode mode) {
464 : return Callable(isolate->builtins()->InterpreterPushArgsThenCall(
465 : receiver_mode, tail_call_mode, mode),
466 4341 : InterpreterPushArgsThenCallDescriptor(isolate));
467 : }
468 :
469 : // static
470 387 : Callable CodeFactory::InterpreterPushArgsThenConstruct(
471 : Isolate* isolate, InterpreterPushArgsMode mode) {
472 : return Callable(isolate->builtins()->InterpreterPushArgsThenConstruct(mode),
473 1161 : InterpreterPushArgsThenConstructDescriptor(isolate));
474 : }
475 :
476 : // static
477 129 : Callable CodeFactory::InterpreterPushArgsThenConstructArray(Isolate* isolate) {
478 : return Callable(isolate->builtins()->InterpreterPushArgsThenConstructArray(),
479 387 : InterpreterPushArgsThenConstructArrayDescriptor(isolate));
480 : }
481 :
482 : // static
483 270 : Callable CodeFactory::InterpreterCEntry(Isolate* isolate, int result_size) {
484 : // Note: If we ever use fpregs in the interpreter then we will need to
485 : // save fpregs too.
486 : CEntryStub stub(isolate, result_size, kDontSaveFPRegs, kArgvInRegister);
487 810 : return Callable(stub.GetCode(), InterpreterCEntryDescriptor(isolate));
488 : }
489 :
490 : // static
491 129 : Callable CodeFactory::InterpreterOnStackReplacement(Isolate* isolate) {
492 : return Callable(isolate->builtins()->InterpreterOnStackReplacement(),
493 387 : ContextOnlyDescriptor(isolate));
494 : }
495 :
496 : // static
497 28148 : Callable CodeFactory::ArrayConstructor(Isolate* isolate) {
498 28148 : ArrayConstructorStub stub(isolate);
499 28148 : return make_callable(stub);
500 : }
501 :
502 : // static
503 43 : Callable CodeFactory::ArrayPush(Isolate* isolate) {
504 129 : return Callable(isolate->builtins()->ArrayPush(), BuiltinDescriptor(isolate));
505 : }
506 :
507 : // static
508 43 : Callable CodeFactory::ArrayFilterLoopContinuation(Isolate* isolate) {
509 : return Callable(isolate->builtins()->ArrayFilterLoopContinuation(),
510 129 : IteratingArrayBuiltinLoopContinuationDescriptor(isolate));
511 : }
512 :
513 : // static
514 43 : Callable CodeFactory::ArrayMapLoopContinuation(Isolate* isolate) {
515 : return Callable(isolate->builtins()->ArrayMapLoopContinuation(),
516 129 : IteratingArrayBuiltinLoopContinuationDescriptor(isolate));
517 : }
518 :
519 : // static
520 43 : Callable CodeFactory::ArrayForEachLoopContinuation(Isolate* isolate) {
521 : return Callable(isolate->builtins()->ArrayForEachLoopContinuation(),
522 129 : IteratingArrayBuiltinLoopContinuationDescriptor(isolate));
523 : }
524 :
525 : // static
526 43 : Callable CodeFactory::ArraySomeLoopContinuation(Isolate* isolate) {
527 : return Callable(isolate->builtins()->ArraySomeLoopContinuation(),
528 129 : IteratingArrayBuiltinLoopContinuationDescriptor(isolate));
529 : }
530 :
531 : // static
532 43 : Callable CodeFactory::ArrayEveryLoopContinuation(Isolate* isolate) {
533 : return Callable(isolate->builtins()->ArrayEveryLoopContinuation(),
534 129 : IteratingArrayBuiltinLoopContinuationDescriptor(isolate));
535 : }
536 :
537 : // static
538 43 : Callable CodeFactory::ArrayReduceLoopContinuation(Isolate* isolate) {
539 : return Callable(isolate->builtins()->ArrayReduceLoopContinuation(),
540 129 : IteratingArrayBuiltinLoopContinuationDescriptor(isolate));
541 : }
542 :
543 : // static
544 43 : Callable CodeFactory::ArrayReduceRightLoopContinuation(Isolate* isolate) {
545 : return Callable(isolate->builtins()->ArrayReduceRightLoopContinuation(),
546 129 : IteratingArrayBuiltinLoopContinuationDescriptor(isolate));
547 : }
548 :
549 : // static
550 43 : Callable CodeFactory::FunctionPrototypeBind(Isolate* isolate) {
551 : return Callable(isolate->builtins()->FunctionPrototypeBind(),
552 129 : BuiltinDescriptor(isolate));
553 : }
554 :
555 : } // namespace internal
556 : } // namespace v8
|
