1 // Copyright 2012 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/interface-descriptors.h" 6 7 namespace v8 { 8 namespace internal { 9 10 namespace { 11 // Constructors for common combined semantic and representation types. 12 Type* SmiType(Zone* zone) { 13 return Type::Intersect(Type::SignedSmall(), Type::TaggedSigned(), zone); 14 } 15 16 17 Type* UntaggedIntegral32(Zone* zone) { 18 return Type::Intersect(Type::Signed32(), Type::UntaggedIntegral32(), zone); 19 } 20 21 22 Type* AnyTagged(Zone* zone) { 23 return Type::Intersect( 24 Type::Any(), 25 Type::Union(Type::TaggedPointer(), Type::TaggedSigned(), zone), zone); 26 } 27 28 29 Type* ExternalPointer(Zone* zone) { 30 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 FunctionType* function = 38 Type::Function(AnyTagged(zone), Type::Undefined(), parameter_count, zone) 39 ->AsFunction(); 40 while (parameter_count-- != 0) { 41 function->InitParameter(parameter_count, AnyTagged(zone)); 42 } 43 return function; 44 } 45 46 void CallInterfaceDescriptorData::InitializePlatformSpecific( 47 int register_parameter_count, const Register* registers, 48 PlatformInterfaceDescriptor* platform_descriptor) { 49 platform_specific_descriptor_ = platform_descriptor; 50 register_param_count_ = register_parameter_count; 51 52 // InterfaceDescriptor owns a copy of the registers array. 53 register_params_.Reset(NewArray<Register>(register_parameter_count)); 54 for (int i = 0; i < register_parameter_count; i++) { 55 register_params_[i] = registers[i]; 56 } 57 } 58 59 const char* CallInterfaceDescriptor::DebugName(Isolate* isolate) const { 60 CallInterfaceDescriptorData* start = isolate->call_descriptor_data(0); 61 size_t index = data_ - start; 62 DCHECK(index < CallDescriptors::NUMBER_OF_DESCRIPTORS); 63 CallDescriptors::Key key = static_cast<CallDescriptors::Key>(index); 64 switch (key) { 65 #define DEF_CASE(NAME) \ 66 case CallDescriptors::NAME: \ 67 return #NAME " Descriptor"; 68 INTERFACE_DESCRIPTOR_LIST(DEF_CASE) 69 #undef DEF_CASE 70 case CallDescriptors::NUMBER_OF_DESCRIPTORS: 71 break; 72 } 73 return ""; 74 } 75 76 77 void VoidDescriptor::InitializePlatformSpecific( 78 CallInterfaceDescriptorData* data) { 79 data->InitializePlatformSpecific(0, nullptr); 80 } 81 82 FunctionType* LoadDescriptor::BuildCallInterfaceDescriptorFunctionType( 83 Isolate* isolate, int paramater_count) { 84 Zone* zone = isolate->interface_descriptor_zone(); 85 FunctionType* function = 86 Type::Function(AnyTagged(zone), Type::Undefined(), 3, zone)->AsFunction(); 87 function->InitParameter(0, AnyTagged(zone)); 88 function->InitParameter(1, AnyTagged(zone)); 89 function->InitParameter(2, SmiType(zone)); 90 return function; 91 } 92 93 94 void LoadDescriptor::InitializePlatformSpecific( 95 CallInterfaceDescriptorData* data) { 96 Register registers[] = {ReceiverRegister(), NameRegister(), SlotRegister()}; 97 data->InitializePlatformSpecific(arraysize(registers), registers); 98 } 99 100 FunctionType* LoadGlobalDescriptor::BuildCallInterfaceDescriptorFunctionType( 101 Isolate* isolate, int paramater_count) { 102 Zone* zone = isolate->interface_descriptor_zone(); 103 FunctionType* function = 104 Type::Function(AnyTagged(zone), Type::Undefined(), 1, zone)->AsFunction(); 105 function->InitParameter(0, SmiType(zone)); 106 return function; 107 } 108 109 void LoadGlobalDescriptor::InitializePlatformSpecific( 110 CallInterfaceDescriptorData* data) { 111 Register registers[] = {LoadWithVectorDescriptor::SlotRegister()}; 112 data->InitializePlatformSpecific(arraysize(registers), registers); 113 } 114 115 FunctionType* 116 LoadGlobalWithVectorDescriptor::BuildCallInterfaceDescriptorFunctionType( 117 Isolate* isolate, int paramater_count) { 118 Zone* zone = isolate->interface_descriptor_zone(); 119 FunctionType* function = 120 Type::Function(AnyTagged(zone), Type::Undefined(), 2, zone)->AsFunction(); 121 function->InitParameter(0, SmiType(zone)); 122 function->InitParameter(1, AnyTagged(zone)); 123 return function; 124 } 125 126 void LoadGlobalWithVectorDescriptor::InitializePlatformSpecific( 127 CallInterfaceDescriptorData* data) { 128 Register registers[] = {LoadWithVectorDescriptor::SlotRegister(), 129 LoadWithVectorDescriptor::VectorRegister()}; 130 data->InitializePlatformSpecific(arraysize(registers), registers); 131 } 132 133 void StoreDescriptor::InitializePlatformSpecific( 134 CallInterfaceDescriptorData* data) { 135 Register registers[] = {ReceiverRegister(), NameRegister(), ValueRegister()}; 136 data->InitializePlatformSpecific(arraysize(registers), registers); 137 } 138 139 140 void StoreTransitionDescriptor::InitializePlatformSpecific( 141 CallInterfaceDescriptorData* data) { 142 Register registers[] = {ReceiverRegister(), NameRegister(), ValueRegister(), 143 MapRegister()}; 144 145 data->InitializePlatformSpecific(arraysize(registers), registers); 146 } 147 148 149 void VectorStoreTransitionDescriptor::InitializePlatformSpecific( 150 CallInterfaceDescriptorData* data) { 151 if (SlotRegister().is(no_reg)) { 152 Register registers[] = {ReceiverRegister(), NameRegister(), ValueRegister(), 153 MapRegister(), VectorRegister()}; 154 data->InitializePlatformSpecific(arraysize(registers), registers); 155 } else { 156 Register registers[] = {ReceiverRegister(), NameRegister(), 157 ValueRegister(), MapRegister(), 158 SlotRegister(), VectorRegister()}; 159 data->InitializePlatformSpecific(arraysize(registers), registers); 160 } 161 } 162 163 FunctionType* 164 StoreTransitionDescriptor::BuildCallInterfaceDescriptorFunctionType( 165 Isolate* isolate, int paramater_count) { 166 Zone* zone = isolate->interface_descriptor_zone(); 167 FunctionType* function = 168 Type::Function(AnyTagged(zone), Type::Undefined(), 4, zone)->AsFunction(); 169 function->InitParameter(0, AnyTagged(zone)); // Receiver 170 function->InitParameter(1, AnyTagged(zone)); // Name 171 function->InitParameter(2, AnyTagged(zone)); // Value 172 function->InitParameter(3, AnyTagged(zone)); // Map 173 return function; 174 } 175 176 FunctionType* 177 StoreGlobalViaContextDescriptor::BuildCallInterfaceDescriptorFunctionType( 178 Isolate* isolate, int paramater_count) { 179 Zone* zone = isolate->interface_descriptor_zone(); 180 FunctionType* function = 181 Type::Function(AnyTagged(zone), Type::Undefined(), 2, zone)->AsFunction(); 182 function->InitParameter(0, UntaggedIntegral32(zone)); 183 function->InitParameter(1, AnyTagged(zone)); 184 return function; 185 } 186 187 188 void StoreGlobalViaContextDescriptor::InitializePlatformSpecific( 189 CallInterfaceDescriptorData* data) { 190 Register registers[] = {SlotRegister(), ValueRegister()}; 191 data->InitializePlatformSpecific(arraysize(registers), registers); 192 } 193 194 195 void StringCompareDescriptor::InitializePlatformSpecific( 196 CallInterfaceDescriptorData* data) { 197 Register registers[] = {LeftRegister(), RightRegister()}; 198 data->InitializePlatformSpecific(arraysize(registers), registers); 199 } 200 201 void TypeConversionDescriptor::InitializePlatformSpecific( 202 CallInterfaceDescriptorData* data) { 203 Register registers[] = {ArgumentRegister()}; 204 data->InitializePlatformSpecific(arraysize(registers), registers); 205 } 206 207 void MathPowTaggedDescriptor::InitializePlatformSpecific( 208 CallInterfaceDescriptorData* data) { 209 Register registers[] = {exponent()}; 210 data->InitializePlatformSpecific(arraysize(registers), registers); 211 } 212 213 void MathPowIntegerDescriptor::InitializePlatformSpecific( 214 CallInterfaceDescriptorData* data) { 215 Register registers[] = {exponent()}; 216 data->InitializePlatformSpecific(arraysize(registers), registers); 217 } 218 219 FunctionType* 220 LoadWithVectorDescriptor::BuildCallInterfaceDescriptorFunctionType( 221 Isolate* isolate, int paramater_count) { 222 Zone* zone = isolate->interface_descriptor_zone(); 223 FunctionType* function = 224 Type::Function(AnyTagged(zone), Type::Undefined(), 4, zone)->AsFunction(); 225 function->InitParameter(0, AnyTagged(zone)); 226 function->InitParameter(1, AnyTagged(zone)); 227 function->InitParameter(2, SmiType(zone)); 228 function->InitParameter(3, AnyTagged(zone)); 229 return function; 230 } 231 232 233 void LoadWithVectorDescriptor::InitializePlatformSpecific( 234 CallInterfaceDescriptorData* data) { 235 Register registers[] = {ReceiverRegister(), NameRegister(), SlotRegister(), 236 VectorRegister()}; 237 data->InitializePlatformSpecific(arraysize(registers), registers); 238 } 239 240 FunctionType* 241 VectorStoreTransitionDescriptor::BuildCallInterfaceDescriptorFunctionType( 242 Isolate* isolate, int paramater_count) { 243 Zone* zone = isolate->interface_descriptor_zone(); 244 bool has_slot = !VectorStoreTransitionDescriptor::SlotRegister().is(no_reg); 245 int arg_count = has_slot ? 6 : 5; 246 FunctionType* function = 247 Type::Function(AnyTagged(zone), Type::Undefined(), arg_count, zone) 248 ->AsFunction(); 249 int index = 0; 250 function->InitParameter(index++, AnyTagged(zone)); // receiver 251 function->InitParameter(index++, AnyTagged(zone)); // name 252 function->InitParameter(index++, AnyTagged(zone)); // value 253 function->InitParameter(index++, AnyTagged(zone)); // map 254 if (has_slot) { 255 function->InitParameter(index++, SmiType(zone)); // slot 256 } 257 function->InitParameter(index++, AnyTagged(zone)); // vector 258 return function; 259 } 260 261 FunctionType* VectorStoreICDescriptor::BuildCallInterfaceDescriptorFunctionType( 262 Isolate* isolate, int paramater_count) { 263 Zone* zone = isolate->interface_descriptor_zone(); 264 FunctionType* function = 265 Type::Function(AnyTagged(zone), Type::Undefined(), 5, zone)->AsFunction(); 266 function->InitParameter(0, AnyTagged(zone)); 267 function->InitParameter(1, AnyTagged(zone)); 268 function->InitParameter(2, AnyTagged(zone)); 269 function->InitParameter(3, SmiType(zone)); 270 function->InitParameter(4, AnyTagged(zone)); 271 return function; 272 } 273 274 275 void VectorStoreICDescriptor::InitializePlatformSpecific( 276 CallInterfaceDescriptorData* data) { 277 Register registers[] = {ReceiverRegister(), NameRegister(), ValueRegister(), 278 SlotRegister(), VectorRegister()}; 279 data->InitializePlatformSpecific(arraysize(registers), registers); 280 } 281 282 FunctionType* 283 VectorStoreICTrampolineDescriptor::BuildCallInterfaceDescriptorFunctionType( 284 Isolate* isolate, int paramater_count) { 285 Zone* zone = isolate->interface_descriptor_zone(); 286 FunctionType* function = 287 Type::Function(AnyTagged(zone), Type::Undefined(), 4, zone)->AsFunction(); 288 function->InitParameter(0, AnyTagged(zone)); 289 function->InitParameter(1, AnyTagged(zone)); 290 function->InitParameter(2, AnyTagged(zone)); 291 function->InitParameter(3, SmiType(zone)); 292 return function; 293 } 294 295 296 void VectorStoreICTrampolineDescriptor::InitializePlatformSpecific( 297 CallInterfaceDescriptorData* data) { 298 Register registers[] = {ReceiverRegister(), NameRegister(), ValueRegister(), 299 SlotRegister()}; 300 data->InitializePlatformSpecific(arraysize(registers), registers); 301 } 302 303 const Register ApiGetterDescriptor::ReceiverRegister() { 304 return LoadDescriptor::ReceiverRegister(); 305 } 306 307 void ApiGetterDescriptor::InitializePlatformSpecific( 308 CallInterfaceDescriptorData* data) { 309 Register registers[] = {ReceiverRegister(), HolderRegister(), 310 CallbackRegister()}; 311 data->InitializePlatformSpecific(arraysize(registers), registers); 312 } 313 314 void ContextOnlyDescriptor::InitializePlatformSpecific( 315 CallInterfaceDescriptorData* data) { 316 data->InitializePlatformSpecific(0, nullptr); 317 } 318 319 CallInterfaceDescriptor OnStackArgsDescriptorBase::ForArgs( 320 Isolate* isolate, int parameter_count) { 321 switch (parameter_count) { 322 case 1: 323 return OnStackWith1ArgsDescriptor(isolate); 324 case 2: 325 return OnStackWith2ArgsDescriptor(isolate); 326 case 3: 327 return OnStackWith3ArgsDescriptor(isolate); 328 case 4: 329 return OnStackWith4ArgsDescriptor(isolate); 330 case 5: 331 return OnStackWith5ArgsDescriptor(isolate); 332 case 6: 333 return OnStackWith6ArgsDescriptor(isolate); 334 case 7: 335 return OnStackWith7ArgsDescriptor(isolate); 336 default: 337 UNREACHABLE(); 338 return VoidDescriptor(isolate); 339 } 340 } 341 342 FunctionType* 343 OnStackArgsDescriptorBase::BuildCallInterfaceDescriptorFunctionTypeWithArg( 344 Isolate* isolate, int register_parameter_count, int parameter_count) { 345 DCHECK_EQ(0, register_parameter_count); 346 DCHECK_GT(parameter_count, 0); 347 Zone* zone = isolate->interface_descriptor_zone(); 348 FunctionType* function = 349 Type::Function(AnyTagged(zone), AnyTagged(zone), parameter_count, zone) 350 ->AsFunction(); 351 for (int i = 0; i < parameter_count; i++) { 352 function->InitParameter(i, AnyTagged(zone)); 353 } 354 return function; 355 } 356 357 void OnStackArgsDescriptorBase::InitializePlatformSpecific( 358 CallInterfaceDescriptorData* data) { 359 data->InitializePlatformSpecific(0, nullptr); 360 } 361 362 void GrowArrayElementsDescriptor::InitializePlatformSpecific( 363 CallInterfaceDescriptorData* data) { 364 Register registers[] = {ObjectRegister(), KeyRegister()}; 365 data->InitializePlatformSpecific(arraysize(registers), registers); 366 } 367 368 FunctionType* 369 VarArgFunctionDescriptor::BuildCallInterfaceDescriptorFunctionType( 370 Isolate* isolate, int paramater_count) { 371 Zone* zone = isolate->interface_descriptor_zone(); 372 FunctionType* function = 373 Type::Function(AnyTagged(zone), AnyTagged(zone), 1, zone)->AsFunction(); 374 function->InitParameter(0, UntaggedIntegral32(zone)); // actual #arguments 375 return function; 376 } 377 378 FunctionType* 379 FastCloneRegExpDescriptor::BuildCallInterfaceDescriptorFunctionType( 380 Isolate* isolate, int paramater_count) { 381 Zone* zone = isolate->interface_descriptor_zone(); 382 FunctionType* function = 383 Type::Function(AnyTagged(zone), Type::Undefined(), 4, zone)->AsFunction(); 384 function->InitParameter(0, AnyTagged(zone)); // closure 385 function->InitParameter(1, SmiType(zone)); // literal_index 386 function->InitParameter(2, AnyTagged(zone)); // pattern 387 function->InitParameter(3, AnyTagged(zone)); // flags 388 return function; 389 } 390 391 FunctionType* 392 FastCloneShallowArrayDescriptor::BuildCallInterfaceDescriptorFunctionType( 393 Isolate* isolate, int paramater_count) { 394 Zone* zone = isolate->interface_descriptor_zone(); 395 FunctionType* function = 396 Type::Function(AnyTagged(zone), Type::Undefined(), 3, zone)->AsFunction(); 397 function->InitParameter(0, AnyTagged(zone)); 398 function->InitParameter(1, SmiType(zone)); 399 function->InitParameter(2, AnyTagged(zone)); 400 return function; 401 } 402 403 FunctionType* 404 CreateAllocationSiteDescriptor::BuildCallInterfaceDescriptorFunctionType( 405 Isolate* isolate, int paramater_count) { 406 Zone* zone = isolate->interface_descriptor_zone(); 407 FunctionType* function = 408 Type::Function(AnyTagged(zone), Type::Undefined(), 2, zone)->AsFunction(); 409 function->InitParameter(0, AnyTagged(zone)); 410 function->InitParameter(1, SmiType(zone)); 411 return function; 412 } 413 414 FunctionType* 415 CreateWeakCellDescriptor::BuildCallInterfaceDescriptorFunctionType( 416 Isolate* isolate, int paramater_count) { 417 Zone* zone = isolate->interface_descriptor_zone(); 418 FunctionType* function = 419 Type::Function(AnyTagged(zone), Type::Undefined(), 3, zone)->AsFunction(); 420 function->InitParameter(0, AnyTagged(zone)); 421 function->InitParameter(1, SmiType(zone)); 422 function->InitParameter(2, AnyTagged(zone)); 423 return function; 424 } 425 426 FunctionType* 427 CallTrampolineDescriptor::BuildCallInterfaceDescriptorFunctionType( 428 Isolate* isolate, int paramater_count) { 429 Zone* zone = isolate->interface_descriptor_zone(); 430 FunctionType* function = 431 Type::Function(AnyTagged(zone), Type::Undefined(), 2, zone)->AsFunction(); 432 function->InitParameter(0, AnyTagged(zone)); // target 433 function->InitParameter(1, UntaggedIntegral32(zone)); // actual #arguments 434 return function; 435 } 436 437 FunctionType* ConstructStubDescriptor::BuildCallInterfaceDescriptorFunctionType( 438 Isolate* isolate, int paramater_count) { 439 Zone* zone = isolate->interface_descriptor_zone(); 440 FunctionType* function = 441 Type::Function(AnyTagged(zone), Type::Undefined(), 4, zone)->AsFunction(); 442 function->InitParameter(0, AnyTagged(zone)); // target 443 function->InitParameter(1, AnyTagged(zone)); // new.target 444 function->InitParameter(2, UntaggedIntegral32(zone)); // actual #arguments 445 function->InitParameter(3, AnyTagged(zone)); // opt. allocation site 446 return function; 447 } 448 449 FunctionType* 450 ConstructTrampolineDescriptor::BuildCallInterfaceDescriptorFunctionType( 451 Isolate* isolate, int paramater_count) { 452 Zone* zone = isolate->interface_descriptor_zone(); 453 FunctionType* function = 454 Type::Function(AnyTagged(zone), Type::Undefined(), 3, zone)->AsFunction(); 455 function->InitParameter(0, AnyTagged(zone)); // target 456 function->InitParameter(1, AnyTagged(zone)); // new.target 457 function->InitParameter(2, UntaggedIntegral32(zone)); // actual #arguments 458 return function; 459 } 460 461 FunctionType* 462 CallFunctionWithFeedbackDescriptor::BuildCallInterfaceDescriptorFunctionType( 463 Isolate* isolate, int paramater_count) { 464 Zone* zone = isolate->interface_descriptor_zone(); 465 FunctionType* function = 466 Type::Function(AnyTagged(zone), Type::Undefined(), 2, zone)->AsFunction(); 467 function->InitParameter(0, Type::Receiver()); // JSFunction 468 function->InitParameter(1, SmiType(zone)); 469 return function; 470 } 471 472 FunctionType* CallFunctionWithFeedbackAndVectorDescriptor:: 473 BuildCallInterfaceDescriptorFunctionType(Isolate* isolate, 474 int paramater_count) { 475 Zone* zone = isolate->interface_descriptor_zone(); 476 FunctionType* function = 477 Type::Function(AnyTagged(zone), Type::Undefined(), 3, zone)->AsFunction(); 478 function->InitParameter(0, Type::Receiver()); // JSFunction 479 function->InitParameter(1, SmiType(zone)); 480 function->InitParameter(2, AnyTagged(zone)); 481 return function; 482 } 483 484 FunctionType* 485 ArrayNoArgumentConstructorDescriptor::BuildCallInterfaceDescriptorFunctionType( 486 Isolate* isolate, int paramater_count) { 487 Zone* zone = isolate->interface_descriptor_zone(); 488 FunctionType* function = 489 Type::Function(AnyTagged(zone), Type::Undefined(), 4, zone)->AsFunction(); 490 function->InitParameter(0, Type::Receiver()); // JSFunction 491 function->InitParameter(1, AnyTagged(zone)); 492 function->InitParameter(2, UntaggedIntegral32(zone)); 493 function->InitParameter(3, AnyTagged(zone)); 494 return function; 495 } 496 497 FunctionType* ArraySingleArgumentConstructorDescriptor:: 498 BuildCallInterfaceDescriptorFunctionType(Isolate* isolate, 499 int paramater_count) { 500 Zone* zone = isolate->interface_descriptor_zone(); 501 FunctionType* function = 502 Type::Function(AnyTagged(zone), Type::Undefined(), 5, zone)->AsFunction(); 503 function->InitParameter(0, Type::Receiver()); // JSFunction 504 function->InitParameter(1, AnyTagged(zone)); 505 function->InitParameter(2, UntaggedIntegral32(zone)); 506 function->InitParameter(3, AnyTagged(zone)); 507 function->InitParameter(4, AnyTagged(zone)); 508 return function; 509 } 510 511 FunctionType* 512 ArrayNArgumentsConstructorDescriptor::BuildCallInterfaceDescriptorFunctionType( 513 Isolate* isolate, int paramater_count) { 514 Zone* zone = isolate->interface_descriptor_zone(); 515 FunctionType* function = 516 Type::Function(AnyTagged(zone), Type::Undefined(), 3, zone)->AsFunction(); 517 function->InitParameter(0, Type::Receiver()); // JSFunction 518 function->InitParameter(1, AnyTagged(zone)); // Allocation site or undefined 519 function->InitParameter(2, UntaggedIntegral32(zone)); // Arg count 520 return function; 521 } 522 523 FunctionType* 524 ArgumentAdaptorDescriptor::BuildCallInterfaceDescriptorFunctionType( 525 Isolate* isolate, int paramater_count) { 526 Zone* zone = isolate->interface_descriptor_zone(); 527 FunctionType* function = 528 Type::Function(AnyTagged(zone), Type::Undefined(), 4, zone)->AsFunction(); 529 function->InitParameter(0, Type::Receiver()); // JSFunction 530 function->InitParameter(1, AnyTagged(zone)); // the new target 531 function->InitParameter(2, UntaggedIntegral32(zone)); // actual #arguments 532 function->InitParameter(3, UntaggedIntegral32(zone)); // expected #arguments 533 return function; 534 } 535 536 CallInterfaceDescriptor ApiCallbackDescriptorBase::ForArgs(Isolate* isolate, 537 int argc) { 538 switch (argc) { 539 case 0: 540 return ApiCallbackWith0ArgsDescriptor(isolate); 541 case 1: 542 return ApiCallbackWith1ArgsDescriptor(isolate); 543 case 2: 544 return ApiCallbackWith2ArgsDescriptor(isolate); 545 case 3: 546 return ApiCallbackWith3ArgsDescriptor(isolate); 547 case 4: 548 return ApiCallbackWith4ArgsDescriptor(isolate); 549 case 5: 550 return ApiCallbackWith5ArgsDescriptor(isolate); 551 case 6: 552 return ApiCallbackWith6ArgsDescriptor(isolate); 553 case 7: 554 return ApiCallbackWith7ArgsDescriptor(isolate); 555 default: 556 UNREACHABLE(); 557 return VoidDescriptor(isolate); 558 } 559 } 560 561 FunctionType* 562 ApiCallbackDescriptorBase::BuildCallInterfaceDescriptorFunctionTypeWithArg( 563 Isolate* isolate, int parameter_count, int argc) { 564 Zone* zone = isolate->interface_descriptor_zone(); 565 FunctionType* function = 566 Type::Function(AnyTagged(zone), Type::Undefined(), 4 + argc, zone) 567 ->AsFunction(); 568 function->InitParameter(0, AnyTagged(zone)); // callee 569 function->InitParameter(1, AnyTagged(zone)); // call_data 570 function->InitParameter(2, AnyTagged(zone)); // holder 571 function->InitParameter(3, ExternalPointer(zone)); // api_function_address 572 for (int i = 0; i < argc; i++) { 573 function->InitParameter(i, AnyTagged(zone)); 574 } 575 return function; 576 } 577 578 FunctionType* 579 InterpreterDispatchDescriptor::BuildCallInterfaceDescriptorFunctionType( 580 Isolate* isolate, int parameter_count) { 581 Zone* zone = isolate->interface_descriptor_zone(); 582 FunctionType* function = 583 Type::Function(AnyTagged(zone), Type::Undefined(), 4, zone)->AsFunction(); 584 function->InitParameter(kAccumulatorParameter, AnyTagged(zone)); 585 function->InitParameter(kBytecodeOffsetParameter, UntaggedIntegral32(zone)); 586 function->InitParameter(kBytecodeArrayParameter, AnyTagged(zone)); 587 function->InitParameter(kDispatchTableParameter, AnyTagged(zone)); 588 return function; 589 } 590 591 } // namespace internal 592 } // namespace v8 593