interface-descriptors.cc 22.9 KB
Newer Older
1 2 3 4 5 6 7 8 9
// Copyright 2012 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "src/interface-descriptors.h"

namespace v8 {
namespace internal {

10 11
namespace {
// Constructors for common combined semantic and representation types.
12 13
Type* SmiType(Zone* zone) {
  return Type::Intersect(Type::SignedSmall(), Type::TaggedSigned(), zone);
14 15 16
}


17 18
Type* UntaggedIntegral32(Zone* zone) {
  return Type::Intersect(Type::Signed32(), Type::UntaggedIntegral32(), zone);
19 20 21
}


22
Type* AnyTagged(Zone* zone) {
23
  return Type::Intersect(
24 25
      Type::Any(),
      Type::Union(Type::TaggedPointer(), Type::TaggedSigned(), zone), zone);
26 27 28
}


29 30
Type* ExternalPointer(Zone* zone) {
  return Type::Intersect(Type::Internal(), Type::UntaggedPointer(), zone);
31
}
32
}  // namespace
33

34
FunctionType* CallInterfaceDescriptor::BuildDefaultFunctionType(
35
    Isolate* isolate, int parameter_count) {
36
  Zone* zone = isolate->interface_descriptor_zone();
37 38 39
  FunctionType* function =
      Type::Function(AnyTagged(zone), Type::Undefined(), parameter_count, zone)
          ->AsFunction();
40
  while (parameter_count-- != 0) {
41
    function->InitParameter(parameter_count, AnyTagged(zone));
42 43 44 45 46
  }
  return function;
}

void CallInterfaceDescriptorData::InitializePlatformSpecific(
47
    int register_parameter_count, const Register* registers,
48 49 50 51 52
    PlatformInterfaceDescriptor* platform_descriptor) {
  platform_specific_descriptor_ = platform_descriptor;
  register_param_count_ = register_parameter_count;

  // InterfaceDescriptor owns a copy of the registers array.
53
  register_params_.reset(NewArray<Register>(register_parameter_count));
54 55 56 57 58
  for (int i = 0; i < register_parameter_count; i++) {
    register_params_[i] = registers[i];
  }
}

59
const char* CallInterfaceDescriptor::DebugName(Isolate* isolate) const {
60
  CallInterfaceDescriptorData* start = isolate->call_descriptor_data(0);
61
  size_t index = data_ - start;
62 63 64 65 66 67 68 69 70 71 72 73 74 75 76
  DCHECK(index < CallDescriptors::NUMBER_OF_DESCRIPTORS);
  CallDescriptors::Key key = static_cast<CallDescriptors::Key>(index);
  switch (key) {
#define DEF_CASE(NAME)        \
  case CallDescriptors::NAME: \
    return #NAME " Descriptor";
    INTERFACE_DESCRIPTOR_LIST(DEF_CASE)
#undef DEF_CASE
    case CallDescriptors::NUMBER_OF_DESCRIPTORS:
      break;
  }
  return "";
}


77 78 79 80 81
void VoidDescriptor::InitializePlatformSpecific(
    CallInterfaceDescriptorData* data) {
  data->InitializePlatformSpecific(0, nullptr);
}

82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98
FunctionType*
FastNewFunctionContextDescriptor::BuildCallInterfaceDescriptorFunctionType(
    Isolate* isolate, int parameter_count) {
  Zone* zone = isolate->interface_descriptor_zone();
  FunctionType* function =
      Type::Function(AnyTagged(zone), Type::Undefined(), 2, zone)->AsFunction();
  function->InitParameter(0, AnyTagged(zone));
  function->InitParameter(1, UntaggedIntegral32(zone));
  return function;
}

void FastNewFunctionContextDescriptor::InitializePlatformSpecific(
    CallInterfaceDescriptorData* data) {
  Register registers[] = {FunctionRegister(), SlotsRegister()};
  data->InitializePlatformSpecific(arraysize(registers), registers);
}

99
FunctionType* LoadDescriptor::BuildCallInterfaceDescriptorFunctionType(
100
    Isolate* isolate, int parameter_count) {
101
  Zone* zone = isolate->interface_descriptor_zone();
102
  FunctionType* function =
103 104 105 106 107
      Type::Function(AnyTagged(zone), Type::Undefined(), kParameterCount, zone)
          ->AsFunction();
  function->InitParameter(kReceiver, AnyTagged(zone));
  function->InitParameter(kName, AnyTagged(zone));
  function->InitParameter(kSlot, SmiType(zone));
108 109 110
  return function;
}

111

112 113
void LoadDescriptor::InitializePlatformSpecific(
    CallInterfaceDescriptorData* data) {
114
  Register registers[] = {ReceiverRegister(), NameRegister(), SlotRegister()};
115
  data->InitializePlatformSpecific(arraysize(registers), registers);
116 117
}

118
FunctionType* LoadGlobalDescriptor::BuildCallInterfaceDescriptorFunctionType(
119
    Isolate* isolate, int parameter_count) {
120
  Zone* zone = isolate->interface_descriptor_zone();
121
  FunctionType* function =
122 123 124
      Type::Function(AnyTagged(zone), Type::Undefined(), kParameterCount, zone)
          ->AsFunction();
  function->InitParameter(kSlot, SmiType(zone));
125 126 127 128 129
  return function;
}

void LoadGlobalDescriptor::InitializePlatformSpecific(
    CallInterfaceDescriptorData* data) {
130
  Register registers[] = {LoadWithVectorDescriptor::SlotRegister()};
131 132 133 134 135
  data->InitializePlatformSpecific(arraysize(registers), registers);
}

FunctionType*
LoadGlobalWithVectorDescriptor::BuildCallInterfaceDescriptorFunctionType(
136
    Isolate* isolate, int parameter_count) {
137
  Zone* zone = isolate->interface_descriptor_zone();
138
  FunctionType* function =
139 140 141 142
      Type::Function(AnyTagged(zone), Type::Undefined(), kParameterCount, zone)
          ->AsFunction();
  function->InitParameter(kSlot, SmiType(zone));
  function->InitParameter(kVector, AnyTagged(zone));
143 144 145
  return function;
}

146
void LoadGlobalWithVectorDescriptor::InitializePlatformSpecific(
147
    CallInterfaceDescriptorData* data) {
148
  Register registers[] = {LoadWithVectorDescriptor::SlotRegister(),
149 150 151
                          LoadWithVectorDescriptor::VectorRegister()};
  data->InitializePlatformSpecific(arraysize(registers), registers);
}
152

153 154 155 156
FunctionType* StoreDescriptor::BuildCallInterfaceDescriptorFunctionType(
    Isolate* isolate, int parameter_count) {
  Zone* zone = isolate->interface_descriptor_zone();
  FunctionType* function =
157 158 159 160 161 162
      Type::Function(AnyTagged(zone), Type::Undefined(), kParameterCount, zone)
          ->AsFunction();
  function->InitParameter(kReceiver, AnyTagged(zone));
  function->InitParameter(kName, AnyTagged(zone));
  function->InitParameter(kValue, AnyTagged(zone));
  function->InitParameter(kSlot, SmiType(zone));
163 164 165
  return function;
}

166 167
void StoreDescriptor::InitializePlatformSpecific(
    CallInterfaceDescriptorData* data) {
168 169
  Register registers[] = {ReceiverRegister(), NameRegister(), ValueRegister(),
                          SlotRegister()};
170
  data->InitializePlatformSpecific(arraysize(registers), registers);
171 172 173
}


174 175 176 177 178 179 180 181 182
void StoreTransitionDescriptor::InitializePlatformSpecific(
    CallInterfaceDescriptorData* data) {
  Register registers[] = {ReceiverRegister(), NameRegister(), ValueRegister(),
                          MapRegister()};

  data->InitializePlatformSpecific(arraysize(registers), registers);
}


183 184 185 186 187 188 189 190 191 192 193 194 195 196
void VectorStoreTransitionDescriptor::InitializePlatformSpecific(
    CallInterfaceDescriptorData* data) {
  if (SlotRegister().is(no_reg)) {
    Register registers[] = {ReceiverRegister(), NameRegister(), ValueRegister(),
                            MapRegister(), VectorRegister()};
    data->InitializePlatformSpecific(arraysize(registers), registers);
  } else {
    Register registers[] = {ReceiverRegister(), NameRegister(),
                            ValueRegister(),    MapRegister(),
                            SlotRegister(),     VectorRegister()};
    data->InitializePlatformSpecific(arraysize(registers), registers);
  }
}

197
FunctionType*
198
StoreTransitionDescriptor::BuildCallInterfaceDescriptorFunctionType(
199
    Isolate* isolate, int parameter_count) {
200
  Zone* zone = isolate->interface_descriptor_zone();
201
  FunctionType* function =
202 203 204 205 206 207
      Type::Function(AnyTagged(zone), Type::Undefined(), kParameterCount, zone)
          ->AsFunction();
  function->InitParameter(kReceiver, AnyTagged(zone));
  function->InitParameter(kName, AnyTagged(zone));
  function->InitParameter(kValue, AnyTagged(zone));
  function->InitParameter(kMap, AnyTagged(zone));
208
  return function;
209 210
}

211
FunctionType*
212
StoreGlobalViaContextDescriptor::BuildCallInterfaceDescriptorFunctionType(
213
    Isolate* isolate, int parameter_count) {
214
  Zone* zone = isolate->interface_descriptor_zone();
215
  FunctionType* function =
216 217 218 219
      Type::Function(AnyTagged(zone), Type::Undefined(), kParameterCount, zone)
          ->AsFunction();
  function->InitParameter(kSlot, UntaggedIntegral32(zone));
  function->InitParameter(kValue, AnyTagged(zone));
220 221 222 223 224 225
  return function;
}


void StoreGlobalViaContextDescriptor::InitializePlatformSpecific(
    CallInterfaceDescriptorData* data) {
226
  Register registers[] = {SlotRegister(), ValueRegister()};
227 228 229 230
  data->InitializePlatformSpecific(arraysize(registers), registers);
}


231 232 233 234 235 236
void StringCompareDescriptor::InitializePlatformSpecific(
    CallInterfaceDescriptorData* data) {
  Register registers[] = {LeftRegister(), RightRegister()};
  data->InitializePlatformSpecific(arraysize(registers), registers);
}

237
void TypeConversionDescriptor::InitializePlatformSpecific(
238
    CallInterfaceDescriptorData* data) {
239
  Register registers[] = {ArgumentRegister()};
240 241 242
  data->InitializePlatformSpecific(arraysize(registers), registers);
}

243 244
void MathPowTaggedDescriptor::InitializePlatformSpecific(
    CallInterfaceDescriptorData* data) {
245
  Register registers[] = {exponent()};
246
  data->InitializePlatformSpecific(arraysize(registers), registers);
247 248
}

249 250
void MathPowIntegerDescriptor::InitializePlatformSpecific(
    CallInterfaceDescriptorData* data) {
251
  Register registers[] = {exponent()};
252 253 254
  data->InitializePlatformSpecific(arraysize(registers), registers);
}

255
FunctionType*
256
LoadWithVectorDescriptor::BuildCallInterfaceDescriptorFunctionType(
257
    Isolate* isolate, int parameter_count) {
258
  Zone* zone = isolate->interface_descriptor_zone();
259
  FunctionType* function =
260 261 262 263 264 265
      Type::Function(AnyTagged(zone), Type::Undefined(), kParameterCount, zone)
          ->AsFunction();
  function->InitParameter(kReceiver, AnyTagged(zone));
  function->InitParameter(kName, AnyTagged(zone));
  function->InitParameter(kSlot, SmiType(zone));
  function->InitParameter(kVector, AnyTagged(zone));
266
  return function;
267 268 269
}


270 271
void LoadWithVectorDescriptor::InitializePlatformSpecific(
    CallInterfaceDescriptorData* data) {
272 273
  Register registers[] = {ReceiverRegister(), NameRegister(), SlotRegister(),
                          VectorRegister()};
274 275 276
  data->InitializePlatformSpecific(arraysize(registers), registers);
}

277
FunctionType*
278
VectorStoreTransitionDescriptor::BuildCallInterfaceDescriptorFunctionType(
279
    Isolate* isolate, int parameter_count) {
280
  Zone* zone = isolate->interface_descriptor_zone();
281 282
  bool has_slot = !VectorStoreTransitionDescriptor::SlotRegister().is(no_reg);
  int arg_count = has_slot ? 6 : 5;
283 284 285
  FunctionType* function =
      Type::Function(AnyTagged(zone), Type::Undefined(), arg_count, zone)
          ->AsFunction();
286
  int index = 0;
287
  // TODO(ishell): use ParameterIndices here
288 289 290 291 292 293 294 295
  function->InitParameter(index++, AnyTagged(zone));  // receiver
  function->InitParameter(index++, AnyTagged(zone));  // name
  function->InitParameter(index++, AnyTagged(zone));  // value
  function->InitParameter(index++, AnyTagged(zone));  // map
  if (has_slot) {
    function->InitParameter(index++, SmiType(zone));  // slot
  }
  function->InitParameter(index++, AnyTagged(zone));  // vector
296 297 298
  return function;
}

299 300 301
FunctionType*
StoreWithVectorDescriptor::BuildCallInterfaceDescriptorFunctionType(
    Isolate* isolate, int parameter_count) {
302
  Zone* zone = isolate->interface_descriptor_zone();
303
  FunctionType* function =
304 305 306 307 308 309 310
      Type::Function(AnyTagged(zone), Type::Undefined(), kParameterCount, zone)
          ->AsFunction();
  function->InitParameter(kReceiver, AnyTagged(zone));
  function->InitParameter(kName, AnyTagged(zone));
  function->InitParameter(kValue, AnyTagged(zone));
  function->InitParameter(kSlot, SmiType(zone));
  function->InitParameter(kVector, AnyTagged(zone));
311
  return function;
312 313
}

314
void StoreWithVectorDescriptor::InitializePlatformSpecific(
315
    CallInterfaceDescriptorData* data) {
316 317
  Register registers[] = {ReceiverRegister(), NameRegister(), ValueRegister(),
                          SlotRegister(), VectorRegister()};
318
  data->InitializePlatformSpecific(arraysize(registers), registers);
319 320
}

321 322
const Register ApiGetterDescriptor::ReceiverRegister() {
  return LoadDescriptor::ReceiverRegister();
323 324 325 326
}

void ApiGetterDescriptor::InitializePlatformSpecific(
    CallInterfaceDescriptorData* data) {
327 328
  Register registers[] = {ReceiverRegister(), HolderRegister(),
                          CallbackRegister()};
329
  data->InitializePlatformSpecific(arraysize(registers), registers);
330 331
}

332 333
void ContextOnlyDescriptor::InitializePlatformSpecific(
    CallInterfaceDescriptorData* data) {
334
  data->InitializePlatformSpecific(0, nullptr);
335 336
}

337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378
CallInterfaceDescriptor OnStackArgsDescriptorBase::ForArgs(
    Isolate* isolate, int parameter_count) {
  switch (parameter_count) {
    case 1:
      return OnStackWith1ArgsDescriptor(isolate);
    case 2:
      return OnStackWith2ArgsDescriptor(isolate);
    case 3:
      return OnStackWith3ArgsDescriptor(isolate);
    case 4:
      return OnStackWith4ArgsDescriptor(isolate);
    case 5:
      return OnStackWith5ArgsDescriptor(isolate);
    case 6:
      return OnStackWith6ArgsDescriptor(isolate);
    case 7:
      return OnStackWith7ArgsDescriptor(isolate);
    default:
      UNREACHABLE();
      return VoidDescriptor(isolate);
  }
}

FunctionType*
OnStackArgsDescriptorBase::BuildCallInterfaceDescriptorFunctionTypeWithArg(
    Isolate* isolate, int register_parameter_count, int parameter_count) {
  DCHECK_EQ(0, register_parameter_count);
  DCHECK_GT(parameter_count, 0);
  Zone* zone = isolate->interface_descriptor_zone();
  FunctionType* function =
      Type::Function(AnyTagged(zone), AnyTagged(zone), parameter_count, zone)
          ->AsFunction();
  for (int i = 0; i < parameter_count; i++) {
    function->InitParameter(i, AnyTagged(zone));
  }
  return function;
}

void OnStackArgsDescriptorBase::InitializePlatformSpecific(
    CallInterfaceDescriptorData* data) {
  data->InitializePlatformSpecific(0, nullptr);
}
379

380
void GrowArrayElementsDescriptor::InitializePlatformSpecific(
381
    CallInterfaceDescriptorData* data) {
382
  Register registers[] = {ObjectRegister(), KeyRegister()};
383 384 385
  data->InitializePlatformSpecific(arraysize(registers), registers);
}

386 387
FunctionType*
VarArgFunctionDescriptor::BuildCallInterfaceDescriptorFunctionType(
388
    Isolate* isolate, int parameter_count) {
389 390
  Zone* zone = isolate->interface_descriptor_zone();
  FunctionType* function =
391 392 393
      Type::Function(AnyTagged(zone), AnyTagged(zone), kParameterCount, zone)
          ->AsFunction();
  function->InitParameter(kActualArgumentsCount, UntaggedIntegral32(zone));
394 395 396
  return function;
}

397
FunctionType*
398
FastCloneRegExpDescriptor::BuildCallInterfaceDescriptorFunctionType(
399
    Isolate* isolate, int parameter_count) {
400
  Zone* zone = isolate->interface_descriptor_zone();
401
  FunctionType* function =
402 403 404 405 406 407
      Type::Function(AnyTagged(zone), Type::Undefined(), kParameterCount, zone)
          ->AsFunction();
  function->InitParameter(kClosure, AnyTagged(zone));
  function->InitParameter(kLiteralIndex, SmiType(zone));
  function->InitParameter(kPattern, AnyTagged(zone));
  function->InitParameter(kFlags, AnyTagged(zone));
408 409 410
  return function;
}

411
FunctionType*
412
FastCloneShallowArrayDescriptor::BuildCallInterfaceDescriptorFunctionType(
413
    Isolate* isolate, int parameter_count) {
414
  Zone* zone = isolate->interface_descriptor_zone();
415
  FunctionType* function =
416 417 418 419 420
      Type::Function(AnyTagged(zone), Type::Undefined(), kParameterCount, zone)
          ->AsFunction();
  function->InitParameter(kClosure, AnyTagged(zone));
  function->InitParameter(kLiteralIndex, SmiType(zone));
  function->InitParameter(kConstantElements, AnyTagged(zone));
421 422 423
  return function;
}

424
FunctionType*
425
CreateAllocationSiteDescriptor::BuildCallInterfaceDescriptorFunctionType(
426
    Isolate* isolate, int parameter_count) {
427
  Zone* zone = isolate->interface_descriptor_zone();
428
  FunctionType* function =
429 430 431 432
      Type::Function(AnyTagged(zone), Type::Undefined(), kParameterCount, zone)
          ->AsFunction();
  function->InitParameter(kVector, AnyTagged(zone));
  function->InitParameter(kSlot, SmiType(zone));
433
  return function;
434
}
435

436
FunctionType*
437
CreateWeakCellDescriptor::BuildCallInterfaceDescriptorFunctionType(
438
    Isolate* isolate, int parameter_count) {
439
  Zone* zone = isolate->interface_descriptor_zone();
440
  FunctionType* function =
441 442 443 444 445
      Type::Function(AnyTagged(zone), Type::Undefined(), kParameterCount, zone)
          ->AsFunction();
  function->InitParameter(kVector, AnyTagged(zone));
  function->InitParameter(kSlot, SmiType(zone));
  function->InitParameter(kValue, AnyTagged(zone));
446 447 448
  return function;
}

449
FunctionType*
450
CallTrampolineDescriptor::BuildCallInterfaceDescriptorFunctionType(
451
    Isolate* isolate, int parameter_count) {
452
  Zone* zone = isolate->interface_descriptor_zone();
453
  FunctionType* function =
454 455 456 457
      Type::Function(AnyTagged(zone), Type::Undefined(), kParameterCount, zone)
          ->AsFunction();
  function->InitParameter(kFunction, AnyTagged(zone));
  function->InitParameter(kActualArgumentsCount, UntaggedIntegral32(zone));
458 459 460
  return function;
}

461
FunctionType* ConstructStubDescriptor::BuildCallInterfaceDescriptorFunctionType(
462
    Isolate* isolate, int parameter_count) {
463
  Zone* zone = isolate->interface_descriptor_zone();
464
  FunctionType* function =
465 466 467 468 469 470
      Type::Function(AnyTagged(zone), Type::Undefined(), kParameterCount, zone)
          ->AsFunction();
  function->InitParameter(kFunction, AnyTagged(zone));
  function->InitParameter(kNewTarget, AnyTagged(zone));
  function->InitParameter(kActualArgumentsCount, UntaggedIntegral32(zone));
  function->InitParameter(kAllocationSite, AnyTagged(zone));
471 472 473
  return function;
}

474
FunctionType*
475
ConstructTrampolineDescriptor::BuildCallInterfaceDescriptorFunctionType(
476
    Isolate* isolate, int parameter_count) {
477
  Zone* zone = isolate->interface_descriptor_zone();
478
  FunctionType* function =
479 480 481 482 483
      Type::Function(AnyTagged(zone), Type::Undefined(), kParameterCount, zone)
          ->AsFunction();
  function->InitParameter(kFunction, AnyTagged(zone));
  function->InitParameter(kNewTarget, AnyTagged(zone));
  function->InitParameter(kActualArgumentsCount, UntaggedIntegral32(zone));
484 485 486
  return function;
}

487
FunctionType*
488
CallFunctionWithFeedbackDescriptor::BuildCallInterfaceDescriptorFunctionType(
489
    Isolate* isolate, int parameter_count) {
490
  Zone* zone = isolate->interface_descriptor_zone();
491
  FunctionType* function =
492 493 494 495
      Type::Function(AnyTagged(zone), Type::Undefined(), kParameterCount, zone)
          ->AsFunction();
  function->InitParameter(kFunction, Type::Receiver());
  function->InitParameter(kSlot, SmiType(zone));
496 497 498
  return function;
}

499
FunctionType* CallFunctionWithFeedbackAndVectorDescriptor::
500
    BuildCallInterfaceDescriptorFunctionType(Isolate* isolate,
501
                                             int parameter_count) {
502
  Zone* zone = isolate->interface_descriptor_zone();
503
  FunctionType* function =
504 505 506 507 508
      Type::Function(AnyTagged(zone), Type::Undefined(), kParameterCount, zone)
          ->AsFunction();
  function->InitParameter(kFunction, Type::Receiver());
  function->InitParameter(kSlot, SmiType(zone));
  function->InitParameter(kVector, AnyTagged(zone));
509 510 511
  return function;
}

512 513
FunctionType*
ArrayNoArgumentConstructorDescriptor::BuildCallInterfaceDescriptorFunctionType(
514
    Isolate* isolate, int parameter_count) {
515 516
  Zone* zone = isolate->interface_descriptor_zone();
  FunctionType* function =
517 518 519 520 521 522
      Type::Function(AnyTagged(zone), Type::Undefined(), kParameterCount, zone)
          ->AsFunction();
  function->InitParameter(kFunction, Type::Receiver());
  function->InitParameter(kAllocationSite, AnyTagged(zone));
  function->InitParameter(kActualArgumentsCount, UntaggedIntegral32(zone));
  function->InitParameter(kFunctionParameter, AnyTagged(zone));
523 524 525
  return function;
}

526 527
FunctionType* ArraySingleArgumentConstructorDescriptor::
    BuildCallInterfaceDescriptorFunctionType(Isolate* isolate,
528
                                             int parameter_count) {
529 530
  Zone* zone = isolate->interface_descriptor_zone();
  FunctionType* function =
531 532 533 534 535 536 537
      Type::Function(AnyTagged(zone), Type::Undefined(), kParameterCount, zone)
          ->AsFunction();
  function->InitParameter(kFunction, Type::Receiver());
  function->InitParameter(kAllocationSite, AnyTagged(zone));
  function->InitParameter(kActualArgumentsCount, UntaggedIntegral32(zone));
  function->InitParameter(kFunctionParameter, AnyTagged(zone));
  function->InitParameter(kArraySizeSmiParameter, AnyTagged(zone));
538 539 540
  return function;
}

541
FunctionType*
542
ArrayNArgumentsConstructorDescriptor::BuildCallInterfaceDescriptorFunctionType(
543
    Isolate* isolate, int parameter_count) {
544
  Zone* zone = isolate->interface_descriptor_zone();
545
  FunctionType* function =
546 547 548 549 550
      Type::Function(AnyTagged(zone), Type::Undefined(), kParameterCount, zone)
          ->AsFunction();
  function->InitParameter(kFunction, Type::Receiver());
  function->InitParameter(kAllocationSite, AnyTagged(zone));
  function->InitParameter(kActualArgumentsCount, UntaggedIntegral32(zone));
551 552 553
  return function;
}

554
FunctionType*
555
ArgumentAdaptorDescriptor::BuildCallInterfaceDescriptorFunctionType(
556
    Isolate* isolate, int parameter_count) {
557
  Zone* zone = isolate->interface_descriptor_zone();
558
  FunctionType* function =
559 560 561 562 563 564
      Type::Function(AnyTagged(zone), Type::Undefined(), kParameterCount, zone)
          ->AsFunction();
  function->InitParameter(kFunction, Type::Receiver());
  function->InitParameter(kNewTarget, AnyTagged(zone));
  function->InitParameter(kActualArgumentsCount, UntaggedIntegral32(zone));
  function->InitParameter(kExpectedArgumentsCount, UntaggedIntegral32(zone));
565 566 567
  return function;
}

vogelheim's avatar
vogelheim committed
568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590
CallInterfaceDescriptor ApiCallbackDescriptorBase::ForArgs(Isolate* isolate,
                                                           int argc) {
  switch (argc) {
    case 0:
      return ApiCallbackWith0ArgsDescriptor(isolate);
    case 1:
      return ApiCallbackWith1ArgsDescriptor(isolate);
    case 2:
      return ApiCallbackWith2ArgsDescriptor(isolate);
    case 3:
      return ApiCallbackWith3ArgsDescriptor(isolate);
    case 4:
      return ApiCallbackWith4ArgsDescriptor(isolate);
    case 5:
      return ApiCallbackWith5ArgsDescriptor(isolate);
    case 6:
      return ApiCallbackWith6ArgsDescriptor(isolate);
    case 7:
      return ApiCallbackWith7ArgsDescriptor(isolate);
    default:
      UNREACHABLE();
      return VoidDescriptor(isolate);
  }
591 592
}

vogelheim's avatar
vogelheim committed
593 594 595
FunctionType*
ApiCallbackDescriptorBase::BuildCallInterfaceDescriptorFunctionTypeWithArg(
    Isolate* isolate, int parameter_count, int argc) {
596
  Zone* zone = isolate->interface_descriptor_zone();
597 598 599 600 601 602 603
  FunctionType* function = Type::Function(AnyTagged(zone), Type::Undefined(),
                                          kParameterCount + argc, zone)
                               ->AsFunction();
  function->InitParameter(kFunction, AnyTagged(zone));
  function->InitParameter(kCallData, AnyTagged(zone));
  function->InitParameter(kHolder, AnyTagged(zone));
  function->InitParameter(kApiFunctionAddress, ExternalPointer(zone));
vogelheim's avatar
vogelheim committed
604 605 606
  for (int i = 0; i < argc; i++) {
    function->InitParameter(i, AnyTagged(zone));
  }
607 608 609
  return function;
}

610 611 612 613 614
FunctionType*
InterpreterDispatchDescriptor::BuildCallInterfaceDescriptorFunctionType(
    Isolate* isolate, int parameter_count) {
  Zone* zone = isolate->interface_descriptor_zone();
  FunctionType* function =
615 616 617 618 619 620
      Type::Function(AnyTagged(zone), Type::Undefined(), kParameterCount, zone)
          ->AsFunction();
  function->InitParameter(kAccumulator, AnyTagged(zone));
  function->InitParameter(kBytecodeOffset, UntaggedIntegral32(zone));
  function->InitParameter(kBytecodeArray, AnyTagged(zone));
  function->InitParameter(kDispatchTable, AnyTagged(zone));
621 622
  return function;
}
623

624 625
}  // namespace internal
}  // namespace v8