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 7namespace v8 { 8namespace internal { 9 10 11void CallInterfaceDescriptorData::InitializePlatformSpecific( 12 int register_parameter_count, const Register* registers, 13 PlatformInterfaceDescriptor* platform_descriptor) { 14 platform_specific_descriptor_ = platform_descriptor; 15 register_param_count_ = register_parameter_count; 16 17 // InterfaceDescriptor owns a copy of the registers array. 18 register_params_.reset(NewArray<Register>(register_parameter_count)); 19 for (int i = 0; i < register_parameter_count; i++) { 20 register_params_[i] = registers[i]; 21 } 22} 23 24void CallInterfaceDescriptorData::InitializePlatformIndependent( 25 int parameter_count, int extra_parameter_count, 26 const MachineType* machine_types) { 27 // InterfaceDescriptor owns a copy of the MachineType array. 28 // We only care about parameters, not receiver and result. 29 param_count_ = parameter_count + extra_parameter_count; 30 machine_types_.reset(NewArray<MachineType>(param_count_)); 31 for (int i = 0; i < param_count_; i++) { 32 if (machine_types == NULL || i >= parameter_count) { 33 machine_types_[i] = MachineType::AnyTagged(); 34 } else { 35 machine_types_[i] = machine_types[i]; 36 } 37 } 38} 39 40const char* CallInterfaceDescriptor::DebugName(Isolate* isolate) const { 41 CallInterfaceDescriptorData* start = isolate->call_descriptor_data(0); 42 size_t index = data_ - start; 43 DCHECK(index < CallDescriptors::NUMBER_OF_DESCRIPTORS); 44 CallDescriptors::Key key = static_cast<CallDescriptors::Key>(index); 45 switch (key) { 46#define DEF_CASE(NAME) \ 47 case CallDescriptors::NAME: \ 48 return #NAME " Descriptor"; 49 INTERFACE_DESCRIPTOR_LIST(DEF_CASE) 50#undef DEF_CASE 51 case CallDescriptors::NUMBER_OF_DESCRIPTORS: 52 break; 53 } 54 return ""; 55} 56 57 58void VoidDescriptor::InitializePlatformSpecific( 59 CallInterfaceDescriptorData* data) { 60 data->InitializePlatformSpecific(0, nullptr); 61} 62 63void FastNewFunctionContextDescriptor::InitializePlatformIndependent( 64 CallInterfaceDescriptorData* data) { 65 MachineType machine_types[] = {MachineType::AnyTagged(), 66 MachineType::Int32()}; 67 data->InitializePlatformIndependent(arraysize(machine_types), 0, 68 machine_types); 69} 70 71void FastNewFunctionContextDescriptor::InitializePlatformSpecific( 72 CallInterfaceDescriptorData* data) { 73 Register registers[] = {FunctionRegister(), SlotsRegister()}; 74 data->InitializePlatformSpecific(arraysize(registers), registers); 75} 76 77void FastNewObjectDescriptor::InitializePlatformSpecific( 78 CallInterfaceDescriptorData* data) { 79 Register registers[] = {TargetRegister(), NewTargetRegister()}; 80 data->InitializePlatformSpecific(arraysize(registers), registers); 81} 82 83const Register FastNewObjectDescriptor::TargetRegister() { 84 return kJSFunctionRegister; 85} 86 87const Register FastNewObjectDescriptor::NewTargetRegister() { 88 return kJavaScriptCallNewTargetRegister; 89} 90 91void FastNewArgumentsDescriptor::InitializePlatformSpecific( 92 CallInterfaceDescriptorData* data) { 93 Register registers[] = {TargetRegister()}; 94 data->InitializePlatformSpecific(arraysize(registers), registers); 95} 96 97const Register FastNewArgumentsDescriptor::TargetRegister() { 98 return kJSFunctionRegister; 99} 100 101void LoadDescriptor::InitializePlatformIndependent( 102 CallInterfaceDescriptorData* data) { 103 // kReceiver, kName, kSlot 104 MachineType machine_types[] = {MachineType::AnyTagged(), 105 MachineType::AnyTagged(), 106 MachineType::TaggedSigned()}; 107 data->InitializePlatformIndependent(arraysize(machine_types), 0, 108 machine_types); 109} 110 111void LoadDescriptor::InitializePlatformSpecific( 112 CallInterfaceDescriptorData* data) { 113 Register registers[] = {ReceiverRegister(), NameRegister(), SlotRegister()}; 114 data->InitializePlatformSpecific(arraysize(registers), registers); 115} 116 117void LoadFieldDescriptor::InitializePlatformIndependent( 118 CallInterfaceDescriptorData* data) { 119 // kReceiver, kSmiHandler 120 MachineType machine_types[] = {MachineType::AnyTagged(), 121 MachineType::AnyTagged()}; 122 data->InitializePlatformIndependent(arraysize(machine_types), 0, 123 machine_types); 124} 125 126void LoadFieldDescriptor::InitializePlatformSpecific( 127 CallInterfaceDescriptorData* data) { 128 Register registers[] = {ReceiverRegister(), SmiHandlerRegister()}; 129 data->InitializePlatformSpecific(arraysize(registers), registers); 130} 131 132void LoadGlobalDescriptor::InitializePlatformIndependent( 133 CallInterfaceDescriptorData* data) { 134 // kName, kSlot 135 MachineType machine_types[] = {MachineType::AnyTagged(), 136 MachineType::TaggedSigned()}; 137 data->InitializePlatformIndependent(arraysize(machine_types), 0, 138 machine_types); 139} 140 141void LoadGlobalDescriptor::InitializePlatformSpecific( 142 CallInterfaceDescriptorData* data) { 143 Register registers[] = {NameRegister(), SlotRegister()}; 144 data->InitializePlatformSpecific(arraysize(registers), registers); 145} 146 147void LoadGlobalWithVectorDescriptor::InitializePlatformIndependent( 148 CallInterfaceDescriptorData* data) { 149 // kName, kSlot, kVector 150 MachineType machine_types[] = {MachineType::AnyTagged(), 151 MachineType::TaggedSigned(), 152 MachineType::AnyTagged()}; 153 data->InitializePlatformIndependent(arraysize(machine_types), 0, 154 machine_types); 155} 156 157void LoadGlobalWithVectorDescriptor::InitializePlatformSpecific( 158 CallInterfaceDescriptorData* data) { 159 Register registers[] = {NameRegister(), SlotRegister(), VectorRegister()}; 160 data->InitializePlatformSpecific(arraysize(registers), registers); 161} 162 163void StoreDescriptor::InitializePlatformIndependent( 164 CallInterfaceDescriptorData* data) { 165 // kReceiver, kName, kValue, kSlot 166 MachineType machine_types[] = { 167 MachineType::AnyTagged(), MachineType::AnyTagged(), 168 MachineType::AnyTagged(), MachineType::TaggedSigned()}; 169 data->InitializePlatformIndependent(arraysize(machine_types), 0, 170 machine_types); 171} 172 173void StoreDescriptor::InitializePlatformSpecific( 174 CallInterfaceDescriptorData* data) { 175 Register registers[] = {ReceiverRegister(), NameRegister(), ValueRegister(), 176 SlotRegister()}; 177 178 int len = arraysize(registers) - kStackArgumentsCount; 179 data->InitializePlatformSpecific(len, registers); 180} 181 182void StoreTransitionDescriptor::InitializePlatformSpecific( 183 CallInterfaceDescriptorData* data) { 184 Register registers[] = { 185 ReceiverRegister(), NameRegister(), MapRegister(), 186 ValueRegister(), SlotRegister(), VectorRegister(), 187 }; 188 int len = arraysize(registers) - kStackArgumentsCount; 189 data->InitializePlatformSpecific(len, registers); 190} 191 192void StoreTransitionDescriptor::InitializePlatformIndependent( 193 CallInterfaceDescriptorData* data) { 194 // kReceiver, kName, kMap, kValue, kSlot, kVector 195 MachineType machine_types[] = { 196 MachineType::AnyTagged(), MachineType::AnyTagged(), 197 MachineType::AnyTagged(), MachineType::AnyTagged(), 198 MachineType::TaggedSigned(), MachineType::AnyTagged()}; 199 data->InitializePlatformIndependent(arraysize(machine_types), 0, 200 machine_types); 201} 202 203void StoreNamedTransitionDescriptor::InitializePlatformIndependent( 204 CallInterfaceDescriptorData* data) { 205 // kReceiver, kFieldOffset, kMap, kValue, kSlot, kVector, kName 206 MachineType machine_types[] = { 207 MachineType::AnyTagged(), MachineType::TaggedSigned(), 208 MachineType::AnyTagged(), MachineType::AnyTagged(), 209 MachineType::TaggedSigned(), MachineType::AnyTagged(), 210 MachineType::AnyTagged()}; 211 data->InitializePlatformIndependent(arraysize(machine_types), 0, 212 machine_types); 213} 214 215void StoreNamedTransitionDescriptor::InitializePlatformSpecific( 216 CallInterfaceDescriptorData* data) { 217 Register registers[] = { 218 ReceiverRegister(), FieldOffsetRegister(), MapRegister(), 219 ValueRegister(), SlotRegister(), VectorRegister(), 220 NameRegister(), 221 }; 222 int len = arraysize(registers) - kStackArgumentsCount; 223 data->InitializePlatformSpecific(len, registers); 224} 225 226void StringCharAtDescriptor::InitializePlatformIndependent( 227 CallInterfaceDescriptorData* data) { 228 // kReceiver, kPosition 229 MachineType machine_types[] = {MachineType::AnyTagged(), 230 MachineType::IntPtr()}; 231 data->InitializePlatformIndependent(arraysize(machine_types), 0, 232 machine_types); 233} 234 235void StringCharAtDescriptor::InitializePlatformSpecific( 236 CallInterfaceDescriptorData* data) { 237 DefaultInitializePlatformSpecific(data, kParameterCount); 238} 239 240void StringCharCodeAtDescriptor::InitializePlatformIndependent( 241 CallInterfaceDescriptorData* data) { 242 // kReceiver, kPosition 243 // TODO(turbofan): Allow builtins to return untagged values. 244 MachineType machine_types[] = {MachineType::AnyTagged(), 245 MachineType::IntPtr()}; 246 data->InitializePlatformIndependent(arraysize(machine_types), 0, 247 machine_types); 248} 249 250void StringCharCodeAtDescriptor::InitializePlatformSpecific( 251 CallInterfaceDescriptorData* data) { 252 DefaultInitializePlatformSpecific(data, kParameterCount); 253} 254 255void StringCompareDescriptor::InitializePlatformSpecific( 256 CallInterfaceDescriptorData* data) { 257 Register registers[] = {LeftRegister(), RightRegister()}; 258 data->InitializePlatformSpecific(arraysize(registers), registers); 259} 260 261void TypeConversionDescriptor::InitializePlatformSpecific( 262 CallInterfaceDescriptorData* data) { 263 Register registers[] = {ArgumentRegister()}; 264 data->InitializePlatformSpecific(arraysize(registers), registers); 265} 266 267void MathPowTaggedDescriptor::InitializePlatformSpecific( 268 CallInterfaceDescriptorData* data) { 269 Register registers[] = {exponent()}; 270 data->InitializePlatformSpecific(arraysize(registers), registers); 271} 272 273void MathPowIntegerDescriptor::InitializePlatformSpecific( 274 CallInterfaceDescriptorData* data) { 275 Register registers[] = {exponent()}; 276 data->InitializePlatformSpecific(arraysize(registers), registers); 277} 278 279const Register LoadFieldDescriptor::ReceiverRegister() { 280 // Reuse the register from the LoadDescriptor, since given the 281 // LoadFieldDescriptor's usage, it doesn't matter exactly which registers are 282 // used to pass parameters in. 283 return LoadDescriptor::ReceiverRegister(); 284} 285const Register LoadFieldDescriptor::SmiHandlerRegister() { 286 // Reuse the register from the LoadDescriptor, since given the 287 // LoadFieldDescriptor's usage, it doesn't matter exactly which registers are 288 // used to pass parameters in. 289 return LoadDescriptor::NameRegister(); 290} 291 292void LoadWithVectorDescriptor::InitializePlatformIndependent( 293 CallInterfaceDescriptorData* data) { 294 // kReceiver, kName, kSlot, kVector 295 MachineType machine_types[] = { 296 MachineType::AnyTagged(), MachineType::AnyTagged(), 297 MachineType::TaggedSigned(), MachineType::AnyTagged()}; 298 data->InitializePlatformIndependent(arraysize(machine_types), 0, 299 machine_types); 300} 301 302void LoadWithVectorDescriptor::InitializePlatformSpecific( 303 CallInterfaceDescriptorData* data) { 304 Register registers[] = {ReceiverRegister(), NameRegister(), SlotRegister(), 305 VectorRegister()}; 306 data->InitializePlatformSpecific(arraysize(registers), registers); 307} 308 309void LoadICProtoArrayDescriptor::InitializePlatformIndependent( 310 CallInterfaceDescriptorData* data) { 311 // kReceiver, kName, kSlot, kVector, kHandler 312 MachineType machine_types[] = { 313 MachineType::AnyTagged(), MachineType::AnyTagged(), 314 MachineType::TaggedSigned(), MachineType::AnyTagged(), 315 MachineType::AnyTagged()}; 316 data->InitializePlatformIndependent(arraysize(machine_types), 0, 317 machine_types); 318} 319 320void LoadICProtoArrayDescriptor::InitializePlatformSpecific( 321 CallInterfaceDescriptorData* data) { 322 Register registers[] = {ReceiverRegister(), NameRegister(), SlotRegister(), 323 VectorRegister(), HandlerRegister()}; 324 data->InitializePlatformSpecific(arraysize(registers), registers); 325} 326 327void StoreWithVectorDescriptor::InitializePlatformIndependent( 328 CallInterfaceDescriptorData* data) { 329 // kReceiver, kName, kValue, kSlot, kVector 330 MachineType machine_types[] = { 331 MachineType::AnyTagged(), MachineType::AnyTagged(), 332 MachineType::AnyTagged(), MachineType::TaggedSigned(), 333 MachineType::AnyTagged()}; 334 data->InitializePlatformIndependent(arraysize(machine_types), 0, 335 machine_types); 336} 337 338void StoreWithVectorDescriptor::InitializePlatformSpecific( 339 CallInterfaceDescriptorData* data) { 340 Register registers[] = {ReceiverRegister(), NameRegister(), ValueRegister(), 341 SlotRegister(), VectorRegister()}; 342 int len = arraysize(registers) - kStackArgumentsCount; 343 data->InitializePlatformSpecific(len, registers); 344} 345 346void BinaryOpWithVectorDescriptor::InitializePlatformIndependent( 347 CallInterfaceDescriptorData* data) { 348 // kLeft, kRight, kSlot, kVector 349 MachineType machine_types[] = {MachineType::AnyTagged(), 350 MachineType::AnyTagged(), MachineType::Int32(), 351 MachineType::AnyTagged()}; 352 data->InitializePlatformIndependent(arraysize(machine_types), 0, 353 machine_types); 354} 355 356const Register ApiGetterDescriptor::ReceiverRegister() { 357 return LoadDescriptor::ReceiverRegister(); 358} 359 360void ApiGetterDescriptor::InitializePlatformSpecific( 361 CallInterfaceDescriptorData* data) { 362 Register registers[] = {ReceiverRegister(), HolderRegister(), 363 CallbackRegister()}; 364 data->InitializePlatformSpecific(arraysize(registers), registers); 365} 366 367void ContextOnlyDescriptor::InitializePlatformSpecific( 368 CallInterfaceDescriptorData* data) { 369 data->InitializePlatformSpecific(0, nullptr); 370} 371 372void GrowArrayElementsDescriptor::InitializePlatformSpecific( 373 CallInterfaceDescriptorData* data) { 374 Register registers[] = {ObjectRegister(), KeyRegister()}; 375 data->InitializePlatformSpecific(arraysize(registers), registers); 376} 377 378void NewArgumentsElementsDescriptor::InitializePlatformIndependent( 379 CallInterfaceDescriptorData* data) { 380 MachineType const kMachineTypes[] = {MachineType::IntPtr()}; 381 data->InitializePlatformIndependent(arraysize(kMachineTypes), 0, 382 kMachineTypes); 383} 384 385void NewArgumentsElementsDescriptor::InitializePlatformSpecific( 386 CallInterfaceDescriptorData* data) { 387 DefaultInitializePlatformSpecific(data, 1); 388} 389 390void VarArgFunctionDescriptor::InitializePlatformIndependent( 391 CallInterfaceDescriptorData* data) { 392 // kActualArgumentsCount 393 MachineType machine_types[] = {MachineType::Int32()}; 394 data->InitializePlatformIndependent(arraysize(machine_types), 0, 395 machine_types); 396} 397 398void FastCloneRegExpDescriptor::InitializePlatformIndependent( 399 CallInterfaceDescriptorData* data) { 400 // kClosure, kLiteralIndex, kPattern, kFlags 401 MachineType machine_types[] = { 402 MachineType::AnyTagged(), MachineType::TaggedSigned(), 403 MachineType::AnyTagged(), MachineType::AnyTagged()}; 404 data->InitializePlatformIndependent(arraysize(machine_types), 0, 405 machine_types); 406} 407 408void FastCloneShallowArrayDescriptor::InitializePlatformIndependent( 409 CallInterfaceDescriptorData* data) { 410 // kClosure, kLiteralIndex, kConstantElements 411 MachineType machine_types[] = {MachineType::AnyTagged(), 412 MachineType::TaggedSigned(), 413 MachineType::AnyTagged()}; 414 data->InitializePlatformIndependent(arraysize(machine_types), 0, 415 machine_types); 416} 417 418void CreateAllocationSiteDescriptor::InitializePlatformIndependent( 419 CallInterfaceDescriptorData* data) { 420 // kVector, kSlot 421 MachineType machine_types[] = {MachineType::AnyTagged(), 422 MachineType::TaggedSigned()}; 423 data->InitializePlatformIndependent(arraysize(machine_types), 0, 424 machine_types); 425} 426 427void CreateWeakCellDescriptor::InitializePlatformIndependent( 428 CallInterfaceDescriptorData* data) { 429 // kVector, kSlot, kValue 430 MachineType machine_types[] = {MachineType::AnyTagged(), 431 MachineType::TaggedSigned(), 432 MachineType::AnyTagged()}; 433 data->InitializePlatformIndependent(arraysize(machine_types), 0, 434 machine_types); 435} 436 437void CallTrampolineDescriptor::InitializePlatformIndependent( 438 CallInterfaceDescriptorData* data) { 439 // kFunction, kActualArgumentsCount 440 MachineType machine_types[] = {MachineType::AnyTagged(), 441 MachineType::Int32()}; 442 data->InitializePlatformIndependent(arraysize(machine_types), 0, 443 machine_types); 444} 445 446void CallForwardVarargsDescriptor::InitializePlatformIndependent( 447 CallInterfaceDescriptorData* data) { 448 // kTarget, kStartIndex 449 MachineType machine_types[] = {MachineType::AnyTagged(), 450 MachineType::Int32()}; 451 data->InitializePlatformIndependent(arraysize(machine_types), 0, 452 machine_types); 453} 454 455void ConstructStubDescriptor::InitializePlatformIndependent( 456 CallInterfaceDescriptorData* data) { 457 // kFunction, kNewTarget, kActualArgumentsCount, kAllocationSite 458 MachineType machine_types[] = {MachineType::AnyTagged(), 459 MachineType::AnyTagged(), MachineType::Int32(), 460 MachineType::AnyTagged()}; 461 data->InitializePlatformIndependent(arraysize(machine_types), 0, 462 machine_types); 463} 464 465void ConstructTrampolineDescriptor::InitializePlatformIndependent( 466 CallInterfaceDescriptorData* data) { 467 // kFunction, kNewTarget, kActualArgumentsCount 468 MachineType machine_types[] = { 469 MachineType::AnyTagged(), MachineType::AnyTagged(), MachineType::Int32()}; 470 data->InitializePlatformIndependent(arraysize(machine_types), 0, 471 machine_types); 472} 473 474void CallICDescriptor::InitializePlatformIndependent( 475 CallInterfaceDescriptorData* data) { 476 // kTarget, kActualArgumentsCount, kSlot, kVector 477 MachineType machine_types[] = {MachineType::AnyTagged(), MachineType::Int32(), 478 MachineType::Int32(), 479 MachineType::AnyTagged()}; 480 data->InitializePlatformIndependent(arraysize(machine_types), 0, 481 machine_types); 482} 483 484void CallICTrampolineDescriptor::InitializePlatformIndependent( 485 CallInterfaceDescriptorData* data) { 486 // kTarget, kActualArgumentsCount, kSlot 487 MachineType machine_types[] = {MachineType::AnyTagged(), MachineType::Int32(), 488 MachineType::Int32()}; 489 data->InitializePlatformIndependent(arraysize(machine_types), 0, 490 machine_types); 491} 492 493void BuiltinDescriptor::InitializePlatformIndependent( 494 CallInterfaceDescriptorData* data) { 495 // kTarget, kNewTarget, kArgumentsCount 496 MachineType machine_types[] = { 497 MachineType::AnyTagged(), MachineType::AnyTagged(), MachineType::Int32()}; 498 data->InitializePlatformIndependent(arraysize(machine_types), 0, 499 machine_types); 500} 501 502void BuiltinDescriptor::InitializePlatformSpecific( 503 CallInterfaceDescriptorData* data) { 504 Register registers[] = {TargetRegister(), NewTargetRegister(), 505 ArgumentsCountRegister()}; 506 data->InitializePlatformSpecific(arraysize(registers), registers); 507} 508 509const Register BuiltinDescriptor::ArgumentsCountRegister() { 510 return kJavaScriptCallArgCountRegister; 511} 512const Register BuiltinDescriptor::NewTargetRegister() { 513 return kJavaScriptCallNewTargetRegister; 514} 515 516const Register BuiltinDescriptor::TargetRegister() { 517 return kJSFunctionRegister; 518} 519 520void ArrayConstructorDescriptor::InitializePlatformIndependent( 521 CallInterfaceDescriptorData* data) { 522 // kTarget, kNewTarget, kActualArgumentsCount, kAllocationSite 523 MachineType machine_types[] = {MachineType::AnyTagged(), 524 MachineType::AnyTagged(), MachineType::Int32(), 525 MachineType::AnyTagged()}; 526 data->InitializePlatformIndependent(arraysize(machine_types), 0, 527 machine_types); 528} 529 530void ArrayNoArgumentConstructorDescriptor::InitializePlatformIndependent( 531 CallInterfaceDescriptorData* data) { 532 // kFunction, kAllocationSite, kActualArgumentsCount, kFunctionParameter 533 MachineType machine_types[] = {MachineType::TaggedPointer(), 534 MachineType::AnyTagged(), MachineType::Int32(), 535 MachineType::AnyTagged()}; 536 data->InitializePlatformIndependent(arraysize(machine_types), 0, 537 machine_types); 538} 539 540void ArraySingleArgumentConstructorDescriptor::InitializePlatformIndependent( 541 CallInterfaceDescriptorData* data) { 542 // kFunction, kAllocationSite, kActualArgumentsCount, kFunctionParameter, 543 // kArraySizeSmiParameter 544 MachineType machine_types[] = { 545 MachineType::TaggedPointer(), MachineType::AnyTagged(), 546 MachineType::Int32(), MachineType::AnyTagged(), MachineType::AnyTagged()}; 547 data->InitializePlatformIndependent(arraysize(machine_types), 0, 548 machine_types); 549} 550 551void ArrayNArgumentsConstructorDescriptor::InitializePlatformIndependent( 552 CallInterfaceDescriptorData* data) { 553 // kFunction, kAllocationSite, kActualArgumentsCount 554 MachineType machine_types[] = { 555 MachineType::AnyTagged(), MachineType::AnyTagged(), MachineType::Int32()}; 556 data->InitializePlatformIndependent(arraysize(machine_types), 0, 557 machine_types); 558} 559 560void ArgumentAdaptorDescriptor::InitializePlatformIndependent( 561 CallInterfaceDescriptorData* data) { 562 // kFunction, kNewTarget, kActualArgumentsCount, kExpectedArgumentsCount 563 MachineType machine_types[] = {MachineType::TaggedPointer(), 564 MachineType::AnyTagged(), MachineType::Int32(), 565 MachineType::Int32()}; 566 data->InitializePlatformIndependent(arraysize(machine_types), 0, 567 machine_types); 568} 569 570void ApiCallbackDescriptor::InitializePlatformIndependent( 571 CallInterfaceDescriptorData* data) { 572 // kFunction, kCallData, kHolder, kApiFunctionAddress 573 MachineType machine_types[] = { 574 MachineType::AnyTagged(), MachineType::AnyTagged(), 575 MachineType::AnyTagged(), MachineType::Pointer()}; 576 data->InitializePlatformIndependent(arraysize(machine_types), 0, 577 machine_types); 578} 579 580void InterpreterDispatchDescriptor::InitializePlatformIndependent( 581 CallInterfaceDescriptorData* data) { 582 // kAccumulator, kBytecodeOffset, kBytecodeArray, kDispatchTable 583 MachineType machine_types[] = { 584 MachineType::AnyTagged(), MachineType::IntPtr(), MachineType::AnyTagged(), 585 MachineType::IntPtr()}; 586 data->InitializePlatformIndependent(arraysize(machine_types), 0, 587 machine_types); 588} 589 590void InterpreterPushArgsAndCallDescriptor::InitializePlatformIndependent( 591 CallInterfaceDescriptorData* data) { 592 // kNumberOfArguments, kFirstArgument, kFunction 593 MachineType machine_types[] = {MachineType::Int32(), MachineType::Pointer(), 594 MachineType::AnyTagged()}; 595 data->InitializePlatformIndependent(arraysize(machine_types), 0, 596 machine_types); 597} 598 599void InterpreterPushArgsAndConstructDescriptor::InitializePlatformIndependent( 600 CallInterfaceDescriptorData* data) { 601 // kNumberOfArguments, kNewTarget, kConstructor, kFeedbackElement, 602 // kFirstArgument 603 MachineType machine_types[] = { 604 MachineType::Int32(), MachineType::AnyTagged(), MachineType::AnyTagged(), 605 MachineType::AnyTagged(), MachineType::Pointer()}; 606 data->InitializePlatformIndependent(arraysize(machine_types), 0, 607 machine_types); 608} 609 610void InterpreterPushArgsAndConstructArrayDescriptor:: 611 InitializePlatformIndependent(CallInterfaceDescriptorData* data) { 612 // kNumberOfArguments, kFunction, kFeedbackElement, kFirstArgument 613 MachineType machine_types[] = {MachineType::Int32(), MachineType::AnyTagged(), 614 MachineType::AnyTagged(), 615 MachineType::Pointer()}; 616 data->InitializePlatformIndependent(arraysize(machine_types), 0, 617 machine_types); 618} 619 620void InterpreterCEntryDescriptor::InitializePlatformIndependent( 621 CallInterfaceDescriptorData* data) { 622 // kNumberOfArguments, kFirstArgument, kFunctionEntry 623 MachineType machine_types[] = {MachineType::Int32(), MachineType::Pointer(), 624 MachineType::Pointer()}; 625 data->InitializePlatformIndependent(arraysize(machine_types), 0, 626 machine_types); 627} 628 629void FrameDropperTrampolineDescriptor::InitializePlatformIndependent( 630 CallInterfaceDescriptorData* data) { 631 // New FP value. 632 MachineType machine_types[] = {MachineType::Pointer()}; 633 data->InitializePlatformIndependent(arraysize(machine_types), 0, 634 machine_types); 635} 636 637} // namespace internal 638} // namespace v8 639