V8 API Reference, 7.2.502.16 (for Deno 0.2.4)
code-factory.cc
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 Callable make_callable(Stub& stub) {
20  typedef typename Stub::Descriptor Descriptor;
21  return Callable(stub.GetCode(), Descriptor{});
22 }
23 
24 } // namespace
25 
26 // static
27 Handle<Code> CodeFactory::RuntimeCEntry(Isolate* isolate, int result_size) {
28  return CodeFactory::CEntry(isolate, result_size);
29 }
30 
31 #define CENTRY_CODE(RS, SD, AM, BE) \
32  BUILTIN_CODE(isolate, CEntry_##RS##_##SD##_##AM##_##BE)
33 
34 // static
35 Handle<Code> CodeFactory::CEntry(Isolate* isolate, int result_size,
36  SaveFPRegsMode save_doubles,
37  ArgvMode argv_mode, bool builtin_exit_frame) {
38  // Aliases for readability below.
39  const int rs = result_size;
40  const SaveFPRegsMode sd = save_doubles;
41  const ArgvMode am = argv_mode;
42  const bool be = builtin_exit_frame;
43 
44  if (rs == 1 && sd == kDontSaveFPRegs && am == kArgvOnStack && !be) {
45  return CENTRY_CODE(Return1, DontSaveFPRegs, ArgvOnStack, NoBuiltinExit);
46  } else if (rs == 1 && sd == kDontSaveFPRegs && am == kArgvOnStack && be) {
47  return CENTRY_CODE(Return1, DontSaveFPRegs, ArgvOnStack, BuiltinExit);
48  } else if (rs == 1 && sd == kDontSaveFPRegs && am == kArgvInRegister && !be) {
49  return CENTRY_CODE(Return1, DontSaveFPRegs, ArgvInRegister, NoBuiltinExit);
50  } else if (rs == 1 && sd == kSaveFPRegs && am == kArgvOnStack && !be) {
51  return CENTRY_CODE(Return1, SaveFPRegs, ArgvOnStack, NoBuiltinExit);
52  } else if (rs == 1 && sd == kSaveFPRegs && am == kArgvOnStack && be) {
53  return CENTRY_CODE(Return1, SaveFPRegs, ArgvOnStack, BuiltinExit);
54  } else if (rs == 2 && sd == kDontSaveFPRegs && am == kArgvOnStack && !be) {
55  return CENTRY_CODE(Return2, DontSaveFPRegs, ArgvOnStack, NoBuiltinExit);
56  } else if (rs == 2 && sd == kDontSaveFPRegs && am == kArgvOnStack && be) {
57  return CENTRY_CODE(Return2, DontSaveFPRegs, ArgvOnStack, BuiltinExit);
58  } else if (rs == 2 && sd == kDontSaveFPRegs && am == kArgvInRegister && !be) {
59  return CENTRY_CODE(Return2, DontSaveFPRegs, ArgvInRegister, NoBuiltinExit);
60  } else if (rs == 2 && sd == kSaveFPRegs && am == kArgvOnStack && !be) {
61  return CENTRY_CODE(Return2, SaveFPRegs, ArgvOnStack, NoBuiltinExit);
62  } else if (rs == 2 && sd == kSaveFPRegs && am == kArgvOnStack && be) {
63  return CENTRY_CODE(Return2, SaveFPRegs, ArgvOnStack, BuiltinExit);
64  }
65 
66  UNREACHABLE();
67 }
68 
69 #undef CENTRY_CODE
70 
71 // static
72 Callable CodeFactory::ApiGetter(Isolate* isolate) {
73  return Callable(BUILTIN_CODE(isolate, CallApiGetter), ApiGetterDescriptor{});
74 }
75 
76 // static
77 Callable CodeFactory::CallApiCallback(Isolate* isolate, int argc) {
78  switch (argc) {
79  case 0:
80  return Callable(BUILTIN_CODE(isolate, CallApiCallback_Argc0),
81  ApiCallbackDescriptor{});
82  case 1:
83  return Callable(BUILTIN_CODE(isolate, CallApiCallback_Argc1),
84  ApiCallbackDescriptor{});
85  default: {
86  CallApiCallbackStub stub(isolate, argc);
87  return make_callable(stub);
88  }
89  }
90  UNREACHABLE();
91 }
92 
93 // static
94 Callable CodeFactory::LoadGlobalIC(Isolate* isolate, TypeofMode typeof_mode) {
95  return Callable(
96  typeof_mode == NOT_INSIDE_TYPEOF
97  ? BUILTIN_CODE(isolate, LoadGlobalICTrampoline)
98  : BUILTIN_CODE(isolate, LoadGlobalICInsideTypeofTrampoline),
99  LoadGlobalDescriptor{});
100 }
101 
102 // static
103 Callable CodeFactory::LoadGlobalICInOptimizedCode(Isolate* isolate,
104  TypeofMode typeof_mode) {
105  return Callable(typeof_mode == NOT_INSIDE_TYPEOF
106  ? BUILTIN_CODE(isolate, LoadGlobalIC)
107  : BUILTIN_CODE(isolate, LoadGlobalICInsideTypeof),
108  LoadGlobalWithVectorDescriptor{});
109 }
110 
111 Callable CodeFactory::StoreOwnIC(Isolate* isolate) {
112  // TODO(ishell): Currently we use StoreOwnIC only for storing properties that
113  // already exist in the boilerplate therefore we can use StoreIC.
114  return Callable(BUILTIN_CODE(isolate, StoreICTrampoline), StoreDescriptor{});
115 }
116 
117 Callable CodeFactory::StoreOwnICInOptimizedCode(Isolate* isolate) {
118  // TODO(ishell): Currently we use StoreOwnIC only for storing properties that
119  // already exist in the boilerplate therefore we can use StoreIC.
120  return Callable(BUILTIN_CODE(isolate, StoreIC), StoreWithVectorDescriptor{});
121 }
122 
123 Callable CodeFactory::KeyedStoreIC_SloppyArguments(Isolate* isolate,
124  KeyedAccessStoreMode mode) {
125  Builtins::Name builtin_index;
126  switch (mode) {
127  case STANDARD_STORE:
128  builtin_index = Builtins::kKeyedStoreIC_SloppyArguments_Standard;
129  break;
130  case STORE_AND_GROW_NO_TRANSITION_HANDLE_COW:
131  builtin_index =
132  Builtins::kKeyedStoreIC_SloppyArguments_GrowNoTransitionHandleCOW;
133  break;
134  case STORE_NO_TRANSITION_IGNORE_OUT_OF_BOUNDS:
135  builtin_index =
136  Builtins::kKeyedStoreIC_SloppyArguments_NoTransitionIgnoreOOB;
137  break;
138  case STORE_NO_TRANSITION_HANDLE_COW:
139  builtin_index =
140  Builtins::kKeyedStoreIC_SloppyArguments_NoTransitionHandleCOW;
141  break;
142  default:
143  UNREACHABLE();
144  }
145  return isolate->builtins()->CallableFor(isolate, builtin_index);
146 }
147 
148 Callable CodeFactory::KeyedStoreIC_Slow(Isolate* isolate,
149  KeyedAccessStoreMode mode) {
150  Builtins::Name builtin_index;
151  switch (mode) {
152  case STANDARD_STORE:
153  builtin_index = Builtins::kKeyedStoreIC_Slow_Standard;
154  break;
155  case STORE_AND_GROW_NO_TRANSITION_HANDLE_COW:
156  builtin_index = Builtins::kKeyedStoreIC_Slow_GrowNoTransitionHandleCOW;
157  break;
158  case STORE_NO_TRANSITION_IGNORE_OUT_OF_BOUNDS:
159  builtin_index = Builtins::kKeyedStoreIC_Slow_NoTransitionIgnoreOOB;
160  break;
161  case STORE_NO_TRANSITION_HANDLE_COW:
162  builtin_index = Builtins::kKeyedStoreIC_Slow_NoTransitionHandleCOW;
163  break;
164  default:
165  UNREACHABLE();
166  }
167  return isolate->builtins()->CallableFor(isolate, builtin_index);
168 }
169 
170 Callable CodeFactory::StoreInArrayLiteralIC_Slow(Isolate* isolate,
171  KeyedAccessStoreMode mode) {
172  Builtins::Name builtin_index;
173  switch (mode) {
174  case STANDARD_STORE:
175  builtin_index = Builtins::kStoreInArrayLiteralIC_Slow_Standard;
176  break;
177  case STORE_AND_GROW_NO_TRANSITION_HANDLE_COW:
178  builtin_index =
179  Builtins::kStoreInArrayLiteralIC_Slow_GrowNoTransitionHandleCOW;
180  break;
181  case STORE_NO_TRANSITION_IGNORE_OUT_OF_BOUNDS:
182  builtin_index =
183  Builtins::kStoreInArrayLiteralIC_Slow_NoTransitionIgnoreOOB;
184  break;
185  case STORE_NO_TRANSITION_HANDLE_COW:
186  builtin_index =
187  Builtins::kStoreInArrayLiteralIC_Slow_NoTransitionHandleCOW;
188  break;
189  default:
190  UNREACHABLE();
191  }
192  return isolate->builtins()->CallableFor(isolate, builtin_index);
193 }
194 
195 Callable CodeFactory::ElementsTransitionAndStore(Isolate* isolate,
196  KeyedAccessStoreMode mode) {
197  Builtins::Name builtin_index;
198  switch (mode) {
199  case STANDARD_STORE:
200  builtin_index = Builtins::kElementsTransitionAndStore_Standard;
201  break;
202  case STORE_AND_GROW_NO_TRANSITION_HANDLE_COW:
203  builtin_index =
204  Builtins::kElementsTransitionAndStore_GrowNoTransitionHandleCOW;
205  break;
206  case STORE_NO_TRANSITION_IGNORE_OUT_OF_BOUNDS:
207  builtin_index =
208  Builtins::kElementsTransitionAndStore_NoTransitionIgnoreOOB;
209  break;
210  case STORE_NO_TRANSITION_HANDLE_COW:
211  builtin_index =
212  Builtins::kElementsTransitionAndStore_NoTransitionHandleCOW;
213  break;
214  default:
215  UNREACHABLE();
216  }
217  return isolate->builtins()->CallableFor(isolate, builtin_index);
218 }
219 
220 Callable CodeFactory::StoreFastElementIC(Isolate* isolate,
221  KeyedAccessStoreMode mode) {
222  Builtins::Name builtin_index;
223  switch (mode) {
224  case STANDARD_STORE:
225  builtin_index = Builtins::kStoreFastElementIC_Standard;
226  break;
227  case STORE_AND_GROW_NO_TRANSITION_HANDLE_COW:
228  builtin_index = Builtins::kStoreFastElementIC_GrowNoTransitionHandleCOW;
229  break;
230  case STORE_NO_TRANSITION_IGNORE_OUT_OF_BOUNDS:
231  builtin_index = Builtins::kStoreFastElementIC_NoTransitionIgnoreOOB;
232  break;
233  case STORE_NO_TRANSITION_HANDLE_COW:
234  builtin_index = Builtins::kStoreFastElementIC_NoTransitionHandleCOW;
235  break;
236  default:
237  UNREACHABLE();
238  }
239  return isolate->builtins()->CallableFor(isolate, builtin_index);
240 }
241 
242 // static
243 Callable CodeFactory::BinaryOperation(Isolate* isolate, Operation op) {
244  switch (op) {
245  case Operation::kShiftRight:
246  return Builtins::CallableFor(isolate, Builtins::kShiftRight);
247  case Operation::kShiftLeft:
248  return Builtins::CallableFor(isolate, Builtins::kShiftLeft);
249  case Operation::kShiftRightLogical:
250  return Builtins::CallableFor(isolate, Builtins::kShiftRightLogical);
251  case Operation::kAdd:
252  return Builtins::CallableFor(isolate, Builtins::kAdd);
253  case Operation::kSubtract:
254  return Builtins::CallableFor(isolate, Builtins::kSubtract);
255  case Operation::kMultiply:
256  return Builtins::CallableFor(isolate, Builtins::kMultiply);
257  case Operation::kDivide:
258  return Builtins::CallableFor(isolate, Builtins::kDivide);
259  case Operation::kModulus:
260  return Builtins::CallableFor(isolate, Builtins::kModulus);
261  case Operation::kBitwiseOr:
262  return Builtins::CallableFor(isolate, Builtins::kBitwiseOr);
263  case Operation::kBitwiseAnd:
264  return Builtins::CallableFor(isolate, Builtins::kBitwiseAnd);
265  case Operation::kBitwiseXor:
266  return Builtins::CallableFor(isolate, Builtins::kBitwiseXor);
267  default:
268  break;
269  }
270  UNREACHABLE();
271 }
272 
273 // static
274 Callable CodeFactory::NonPrimitiveToPrimitive(Isolate* isolate,
275  ToPrimitiveHint hint) {
276  return Callable(isolate->builtins()->NonPrimitiveToPrimitive(hint),
277  TypeConversionDescriptor{});
278 }
279 
280 // static
281 Callable CodeFactory::OrdinaryToPrimitive(Isolate* isolate,
282  OrdinaryToPrimitiveHint hint) {
283  return Callable(isolate->builtins()->OrdinaryToPrimitive(hint),
284  TypeConversionDescriptor{});
285 }
286 
287 // static
288 Callable CodeFactory::StringAdd(Isolate* isolate, StringAddFlags flags) {
289  switch (flags) {
290  case STRING_ADD_CHECK_NONE:
291  return Builtins::CallableFor(isolate, Builtins::kStringAdd_CheckNone);
292  case STRING_ADD_CONVERT_LEFT:
293  return Builtins::CallableFor(isolate, Builtins::kStringAdd_ConvertLeft);
294  case STRING_ADD_CONVERT_RIGHT:
295  return Builtins::CallableFor(isolate, Builtins::kStringAdd_ConvertRight);
296  }
297  UNREACHABLE();
298 }
299 
300 // static
301 Callable CodeFactory::ResumeGenerator(Isolate* isolate) {
302  return Callable(BUILTIN_CODE(isolate, ResumeGeneratorTrampoline),
303  ResumeGeneratorDescriptor{});
304 }
305 
306 // static
307 Callable CodeFactory::FrameDropperTrampoline(Isolate* isolate) {
308  return Callable(BUILTIN_CODE(isolate, FrameDropperTrampoline),
309  FrameDropperTrampolineDescriptor{});
310 }
311 
312 // static
313 Callable CodeFactory::HandleDebuggerStatement(Isolate* isolate) {
314  return Callable(BUILTIN_CODE(isolate, HandleDebuggerStatement),
315  ContextOnlyDescriptor{});
316 }
317 
318 // static
319 Callable CodeFactory::FastNewFunctionContext(Isolate* isolate,
320  ScopeType scope_type) {
321  return Callable(isolate->builtins()->NewFunctionContext(scope_type),
322  FastNewFunctionContextDescriptor{});
323 }
324 
325 // static
326 Callable CodeFactory::ArgumentAdaptor(Isolate* isolate) {
327  return Callable(BUILTIN_CODE(isolate, ArgumentsAdaptorTrampoline),
328  ArgumentsAdaptorDescriptor{});
329 }
330 
331 // static
332 Callable CodeFactory::Call(Isolate* isolate, ConvertReceiverMode mode) {
333  return Callable(isolate->builtins()->Call(mode), CallTrampolineDescriptor{});
334 }
335 
336 // static
337 Callable CodeFactory::CallWithArrayLike(Isolate* isolate) {
338  return Callable(BUILTIN_CODE(isolate, CallWithArrayLike),
339  CallWithArrayLikeDescriptor{});
340 }
341 
342 // static
343 Callable CodeFactory::CallWithSpread(Isolate* isolate) {
344  return Callable(BUILTIN_CODE(isolate, CallWithSpread),
345  CallWithSpreadDescriptor{});
346 }
347 
348 // static
349 Callable CodeFactory::CallFunction(Isolate* isolate, ConvertReceiverMode mode) {
350  return Callable(isolate->builtins()->CallFunction(mode),
351  CallTrampolineDescriptor{});
352 }
353 
354 // static
355 Callable CodeFactory::CallVarargs(Isolate* isolate) {
356  return Callable(BUILTIN_CODE(isolate, CallVarargs), CallVarargsDescriptor{});
357 }
358 
359 // static
360 Callable CodeFactory::CallForwardVarargs(Isolate* isolate) {
361  return Callable(BUILTIN_CODE(isolate, CallForwardVarargs),
362  CallForwardVarargsDescriptor{});
363 }
364 
365 // static
366 Callable CodeFactory::CallFunctionForwardVarargs(Isolate* isolate) {
367  return Callable(BUILTIN_CODE(isolate, CallFunctionForwardVarargs),
368  CallForwardVarargsDescriptor{});
369 }
370 
371 // static
372 Callable CodeFactory::Construct(Isolate* isolate) {
373  return Callable(BUILTIN_CODE(isolate, Construct), JSTrampolineDescriptor{});
374 }
375 
376 // static
377 Callable CodeFactory::ConstructWithSpread(Isolate* isolate) {
378  return Callable(BUILTIN_CODE(isolate, ConstructWithSpread),
379  ConstructWithSpreadDescriptor{});
380 }
381 
382 // static
383 Callable CodeFactory::ConstructFunction(Isolate* isolate) {
384  return Callable(BUILTIN_CODE(isolate, ConstructFunction),
385  JSTrampolineDescriptor{});
386 }
387 
388 // static
389 Callable CodeFactory::ConstructVarargs(Isolate* isolate) {
390  return Callable(BUILTIN_CODE(isolate, ConstructVarargs),
391  ConstructVarargsDescriptor{});
392 }
393 
394 // static
395 Callable CodeFactory::ConstructForwardVarargs(Isolate* isolate) {
396  return Callable(BUILTIN_CODE(isolate, ConstructForwardVarargs),
397  ConstructForwardVarargsDescriptor{});
398 }
399 
400 // static
401 Callable CodeFactory::ConstructFunctionForwardVarargs(Isolate* isolate) {
402  return Callable(BUILTIN_CODE(isolate, ConstructFunctionForwardVarargs),
403  ConstructForwardVarargsDescriptor{});
404 }
405 
406 // static
407 Callable CodeFactory::InterpreterPushArgsThenCall(
408  Isolate* isolate, ConvertReceiverMode receiver_mode,
409  InterpreterPushArgsMode mode) {
410  return Callable(
411  isolate->builtins()->InterpreterPushArgsThenCall(receiver_mode, mode),
412  InterpreterPushArgsThenCallDescriptor{});
413 }
414 
415 // static
416 Callable CodeFactory::InterpreterPushArgsThenConstruct(
417  Isolate* isolate, InterpreterPushArgsMode mode) {
418  return Callable(isolate->builtins()->InterpreterPushArgsThenConstruct(mode),
419  InterpreterPushArgsThenConstructDescriptor{});
420 }
421 
422 // static
423 Callable CodeFactory::InterpreterCEntry(Isolate* isolate, int result_size) {
424  // Note: If we ever use fpregs in the interpreter then we will need to
425  // save fpregs too.
426  Handle<Code> code = CodeFactory::CEntry(isolate, result_size, kDontSaveFPRegs,
427  kArgvInRegister);
428  if (result_size == 1) {
429  return Callable(code, InterpreterCEntry1Descriptor{});
430  } else {
431  DCHECK_EQ(result_size, 2);
432  return Callable(code, InterpreterCEntry2Descriptor{});
433  }
434 }
435 
436 // static
437 Callable CodeFactory::InterpreterOnStackReplacement(Isolate* isolate) {
438  return Callable(BUILTIN_CODE(isolate, InterpreterOnStackReplacement),
439  ContextOnlyDescriptor{});
440 }
441 
442 // static
443 Callable CodeFactory::ArrayNoArgumentConstructor(
444  Isolate* isolate, ElementsKind kind,
445  AllocationSiteOverrideMode override_mode) {
446 #define CASE(kind_caps, kind_camel, mode_camel) \
447  case kind_caps: \
448  return Callable( \
449  BUILTIN_CODE(isolate, \
450  ArrayNoArgumentConstructor_##kind_camel##_##mode_camel), \
451  ArrayNoArgumentConstructorDescriptor{})
452  if (override_mode == DONT_OVERRIDE && AllocationSite::ShouldTrack(kind)) {
453  DCHECK(IsSmiElementsKind(kind));
454  switch (kind) {
455  CASE(PACKED_SMI_ELEMENTS, PackedSmi, DontOverride);
456  CASE(HOLEY_SMI_ELEMENTS, HoleySmi, DontOverride);
457  default:
458  UNREACHABLE();
459  }
460  } else {
461  DCHECK(override_mode == DISABLE_ALLOCATION_SITES ||
462  !AllocationSite::ShouldTrack(kind));
463  switch (kind) {
464  CASE(PACKED_SMI_ELEMENTS, PackedSmi, DisableAllocationSites);
465  CASE(HOLEY_SMI_ELEMENTS, HoleySmi, DisableAllocationSites);
466  CASE(PACKED_ELEMENTS, Packed, DisableAllocationSites);
467  CASE(HOLEY_ELEMENTS, Holey, DisableAllocationSites);
468  CASE(PACKED_DOUBLE_ELEMENTS, PackedDouble, DisableAllocationSites);
469  CASE(HOLEY_DOUBLE_ELEMENTS, HoleyDouble, DisableAllocationSites);
470  default:
471  UNREACHABLE();
472  }
473  }
474 #undef CASE
475 }
476 
477 // static
478 Callable CodeFactory::ArraySingleArgumentConstructor(
479  Isolate* isolate, ElementsKind kind,
480  AllocationSiteOverrideMode override_mode) {
481 #define CASE(kind_caps, kind_camel, mode_camel) \
482  case kind_caps: \
483  return Callable( \
484  BUILTIN_CODE( \
485  isolate, \
486  ArraySingleArgumentConstructor_##kind_camel##_##mode_camel), \
487  ArraySingleArgumentConstructorDescriptor{})
488  if (override_mode == DONT_OVERRIDE && AllocationSite::ShouldTrack(kind)) {
489  DCHECK(IsSmiElementsKind(kind));
490  switch (kind) {
491  CASE(PACKED_SMI_ELEMENTS, PackedSmi, DontOverride);
492  CASE(HOLEY_SMI_ELEMENTS, HoleySmi, DontOverride);
493  default:
494  UNREACHABLE();
495  }
496  } else {
497  DCHECK(override_mode == DISABLE_ALLOCATION_SITES ||
498  !AllocationSite::ShouldTrack(kind));
499  switch (kind) {
500  CASE(PACKED_SMI_ELEMENTS, PackedSmi, DisableAllocationSites);
501  CASE(HOLEY_SMI_ELEMENTS, HoleySmi, DisableAllocationSites);
502  CASE(PACKED_ELEMENTS, Packed, DisableAllocationSites);
503  CASE(HOLEY_ELEMENTS, Holey, DisableAllocationSites);
504  CASE(PACKED_DOUBLE_ELEMENTS, PackedDouble, DisableAllocationSites);
505  CASE(HOLEY_DOUBLE_ELEMENTS, HoleyDouble, DisableAllocationSites);
506  default:
507  UNREACHABLE();
508  }
509  }
510 #undef CASE
511 }
512 
513 // static
514 Callable CodeFactory::InternalArrayNoArgumentConstructor(Isolate* isolate,
515  ElementsKind kind) {
516  switch (kind) {
517  case PACKED_ELEMENTS:
518  return Callable(
519  BUILTIN_CODE(isolate, InternalArrayNoArgumentConstructor_Packed),
520  ArrayNoArgumentConstructorDescriptor{});
521  case HOLEY_ELEMENTS:
522  return Callable(
523  BUILTIN_CODE(isolate, InternalArrayNoArgumentConstructor_Holey),
524  ArrayNoArgumentConstructorDescriptor{});
525  default:
526  UNREACHABLE();
527  }
528 }
529 
530 // static
531 Callable CodeFactory::InternalArraySingleArgumentConstructor(
532  Isolate* isolate, ElementsKind kind) {
533  switch (kind) {
534  case PACKED_ELEMENTS:
535  return Callable(
536  BUILTIN_CODE(isolate, InternalArraySingleArgumentConstructor_Packed),
537  ArraySingleArgumentConstructorDescriptor{});
538  case HOLEY_ELEMENTS:
539  return Callable(
540  BUILTIN_CODE(isolate, InternalArraySingleArgumentConstructor_Holey),
541  ArraySingleArgumentConstructorDescriptor{});
542  default:
543  UNREACHABLE();
544  }
545 }
546 
547 } // namespace internal
548 } // namespace v8
v8
Definition: libplatform.h:13