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#ifndef V8_CODEGEN_INTERFACE_DESCRIPTORS_H_ 6#define V8_CODEGEN_INTERFACE_DESCRIPTORS_H_ 7 8#include <memory> 9 10#include "src/base/logging.h" 11#include "src/codegen/machine-type.h" 12#include "src/codegen/register.h" 13#include "src/codegen/tnode.h" 14#include "src/common/globals.h" 15#include "src/execution/isolate.h" 16 17namespace v8 { 18namespace internal { 19 20#define TORQUE_BUILTIN_LIST_TFC(V) \ 21 BUILTIN_LIST_FROM_TORQUE(IGNORE_BUILTIN, IGNORE_BUILTIN, V, IGNORE_BUILTIN, \ 22 IGNORE_BUILTIN, IGNORE_BUILTIN) 23 24#define INTERFACE_DESCRIPTOR_LIST(V) \ 25 V(Abort) \ 26 V(Allocate) \ 27 V(ApiCallback) \ 28 V(ApiGetter) \ 29 V(ArrayConstructor) \ 30 V(ArrayNArgumentsConstructor) \ 31 V(ArrayNoArgumentConstructor) \ 32 V(ArraySingleArgumentConstructor) \ 33 V(AsyncFunctionStackParameter) \ 34 V(BigIntToI32Pair) \ 35 V(BigIntToI64) \ 36 V(BinaryOp) \ 37 V(BinaryOp_Baseline) \ 38 V(BinarySmiOp_Baseline) \ 39 V(BinaryOp_WithFeedback) \ 40 V(CallForwardVarargs) \ 41 V(CallFunctionTemplate) \ 42 V(CopyDataPropertiesWithExcludedProperties) \ 43 V(CopyDataPropertiesWithExcludedPropertiesOnStack) \ 44 V(CallTrampoline) \ 45 V(CallTrampoline_Baseline) \ 46 V(CallTrampoline_Baseline_Compact) \ 47 V(CallTrampoline_WithFeedback) \ 48 V(CallVarargs) \ 49 V(CallWithArrayLike) \ 50 V(CallWithArrayLike_WithFeedback) \ 51 V(CallWithSpread) \ 52 V(CallWithSpread_Baseline) \ 53 V(CallWithSpread_WithFeedback) \ 54 V(CEntry1ArgvOnStack) \ 55 V(CloneObjectBaseline) \ 56 V(CloneObjectWithVector) \ 57 V(Compare) \ 58 V(Compare_Baseline) \ 59 V(Compare_WithFeedback) \ 60 V(ConstructForwardVarargs) \ 61 V(ConstructStub) \ 62 V(ConstructVarargs) \ 63 V(ConstructWithArrayLike) \ 64 V(ConstructWithArrayLike_WithFeedback) \ 65 V(Construct_WithFeedback) \ 66 V(Construct_Baseline) \ 67 V(ConstructWithSpread) \ 68 V(ConstructWithSpread_Baseline) \ 69 V(ConstructWithSpread_WithFeedback) \ 70 V(ContextOnly) \ 71 V(CppBuiltinAdaptor) \ 72 V(FastNewObject) \ 73 V(ForInPrepare) \ 74 V(GetIteratorStackParameter) \ 75 V(GetProperty) \ 76 V(GrowArrayElements) \ 77 V(I32PairToBigInt) \ 78 V(I64ToBigInt) \ 79 V(InterpreterCEntry1) \ 80 V(InterpreterCEntry2) \ 81 V(InterpreterDispatch) \ 82 V(InterpreterPushArgsThenCall) \ 83 V(InterpreterPushArgsThenConstruct) \ 84 V(JSTrampoline) \ 85 V(BaselineOutOfLinePrologue) \ 86 V(BaselineLeaveFrame) \ 87 V(Load) \ 88 V(LoadBaseline) \ 89 V(LoadGlobal) \ 90 V(LoadGlobalBaseline) \ 91 V(LoadGlobalNoFeedback) \ 92 V(LoadGlobalWithVector) \ 93 V(LoadNoFeedback) \ 94 V(LoadWithVector) \ 95 V(KeyedLoad) \ 96 V(KeyedLoadBaseline) \ 97 V(KeyedLoadWithVector) \ 98 V(KeyedHasICBaseline) \ 99 V(KeyedHasICWithVector) \ 100 V(LoadWithReceiverAndVector) \ 101 V(LoadWithReceiverBaseline) \ 102 V(LookupBaseline) \ 103 V(NoContext) \ 104 V(ResumeGenerator) \ 105 V(SuspendGeneratorBaseline) \ 106 V(ResumeGeneratorBaseline) \ 107 V(RunMicrotasks) \ 108 V(RunMicrotasksEntry) \ 109 V(SingleParameterOnStack) \ 110 V(Store) \ 111 V(StoreBaseline) \ 112 V(StoreGlobal) \ 113 V(StoreGlobalBaseline) \ 114 V(StoreGlobalWithVector) \ 115 V(StoreTransition) \ 116 V(StoreWithVector) \ 117 V(StringAtAsString) \ 118 V(StringSubstring) \ 119 IF_TSAN(V, TSANStore) \ 120 IF_TSAN(V, TSANLoad) \ 121 V(TypeConversion) \ 122 V(TypeConversionNoContext) \ 123 V(TypeConversion_Baseline) \ 124 V(Typeof) \ 125 V(UnaryOp_Baseline) \ 126 V(UnaryOp_WithFeedback) \ 127 V(Void) \ 128 V(WasmFloat32ToNumber) \ 129 V(WasmFloat64ToNumber) \ 130 V(WasmI32AtomicWait32) \ 131 V(WasmI64AtomicWait32) \ 132 V(WasmSuspend) \ 133 V(WriteBarrier) \ 134 BUILTIN_LIST_TFS(V) \ 135 TORQUE_BUILTIN_LIST_TFC(V) 136 137enum class StackArgumentOrder { 138 kDefault, // Arguments in the stack are pushed in the default/stub order (the 139 // first argument is pushed first). 140 kJS, // Arguments in the stack are pushed in the same order as the one used 141 // by JS-to-JS function calls. This should be used if calling a 142 // JSFunction or if the builtin is expected to be called directly from a 143 // JSFunction. This order is reversed compared to kDefault. 144}; 145 146class V8_EXPORT_PRIVATE CallInterfaceDescriptorData { 147 public: 148 enum Flag { 149 kNoFlags = 0u, 150 kNoContext = 1u << 0, 151 // This indicates that the code uses a special frame that does not scan the 152 // stack arguments, e.g. EntryFrame. And this allows the code to use 153 // untagged stack arguments. 154 kNoStackScan = 1u << 1, 155 // In addition to the specified parameters, additional arguments can be 156 // passed on the stack. 157 // This does not indicate if arguments adaption is used or not. 158 kAllowVarArgs = 1u << 2, 159 // Callee save allocatable_registers. 160 kCalleeSaveRegisters = 1u << 3, 161 }; 162 using Flags = base::Flags<Flag>; 163 164 static constexpr int kUninitializedCount = -1; 165 166 CallInterfaceDescriptorData() = default; 167 168 CallInterfaceDescriptorData(const CallInterfaceDescriptorData&) = delete; 169 CallInterfaceDescriptorData& operator=(const CallInterfaceDescriptorData&) = 170 delete; 171 172 // The passed registers are owned by the caller, and their lifetime is 173 // expected to exceed that of this data. In practice, they are expected to 174 // be in a static local. 175 void InitializeRegisters(Flags flags, int return_count, int parameter_count, 176 StackArgumentOrder stack_order, 177 int register_parameter_count, 178 const Register* registers); 179 180 // if machine_types is null, then an array of size 181 // (return_count + parameter_count) will be created with 182 // MachineType::AnyTagged() for each member. 183 // 184 // if machine_types is not null, then it should be of the size 185 // (return_count + parameter_count). Those members of the parameter array will 186 // be initialized from {machine_types}, and the rest initialized to 187 // MachineType::AnyTagged(). 188 void InitializeTypes(const MachineType* machine_types, 189 int machine_types_length); 190 191 void Reset(); 192 193 bool IsInitialized() const { 194 return IsInitializedRegisters() && IsInitializedTypes(); 195 } 196 197 Flags flags() const { return flags_; } 198 int return_count() const { return return_count_; } 199 int param_count() const { return param_count_; } 200 int register_param_count() const { return register_param_count_; } 201 Register register_param(int index) const { return register_params_[index]; } 202 MachineType return_type(int index) const { 203 DCHECK_LT(index, return_count_); 204 return machine_types_[index]; 205 } 206 MachineType param_type(int index) const { 207 DCHECK_LT(index, param_count_); 208 return machine_types_[return_count_ + index]; 209 } 210 StackArgumentOrder stack_order() const { return stack_order_; } 211 212 void RestrictAllocatableRegisters(const Register* registers, size_t num) { 213 DCHECK(allocatable_registers_.is_empty()); 214 for (size_t i = 0; i < num; ++i) { 215 allocatable_registers_.set(registers[i]); 216 } 217 DCHECK(!allocatable_registers_.is_empty()); 218 } 219 220 RegList allocatable_registers() const { return allocatable_registers_; } 221 222 private: 223 bool IsInitializedRegisters() const { 224 const bool initialized = 225 return_count_ != kUninitializedCount && 226 param_count_ != kUninitializedCount && 227 (register_param_count_ == 0 || register_params_ != nullptr); 228 // Register initialization happens before type initialization. 229 return initialized; 230 } 231 bool IsInitializedTypes() const { 232 const bool initialized = machine_types_ != nullptr; 233 // Register initialization happens before type initialization. 234 return initialized; 235 } 236 237#ifdef DEBUG 238 bool AllStackParametersAreTagged() const; 239#endif // DEBUG 240 241 int register_param_count_ = kUninitializedCount; 242 int return_count_ = kUninitializedCount; 243 int param_count_ = kUninitializedCount; 244 Flags flags_ = kNoFlags; 245 StackArgumentOrder stack_order_ = StackArgumentOrder::kDefault; 246 247 // Specifying the set of registers that could be used by the register 248 // allocator. Currently, it's only used by RecordWrite code stub. 249 RegList allocatable_registers_; 250 251 // |registers_params_| defines registers that are used for parameter passing. 252 // |machine_types_| defines machine types for resulting values and incomping 253 // parameters. 254 // The register params array is owned by the caller, and it's expected that it 255 // is a static local stored in the caller function. The machine types are 256 // allocated dynamically by the InterfaceDescriptor and freed on destruction. 257 const Register* register_params_ = nullptr; 258 MachineType* machine_types_ = nullptr; 259}; 260 261class V8_EXPORT_PRIVATE CallDescriptors : public AllStatic { 262 public: 263 enum Key { 264#define DEF_ENUM(name, ...) name, 265 INTERFACE_DESCRIPTOR_LIST(DEF_ENUM) 266#undef DEF_ENUM 267 NUMBER_OF_DESCRIPTORS 268 }; 269 270 static void InitializeOncePerProcess(); 271 static void TearDown(); 272 273 static CallInterfaceDescriptorData* call_descriptor_data( 274 CallDescriptors::Key key) { 275 return &call_descriptor_data_[key]; 276 } 277 278 static Key GetKey(const CallInterfaceDescriptorData* data) { 279 ptrdiff_t index = data - call_descriptor_data_; 280 DCHECK_LE(0, index); 281 DCHECK_LT(index, CallDescriptors::NUMBER_OF_DESCRIPTORS); 282 return static_cast<CallDescriptors::Key>(index); 283 } 284 285 private: 286 static CallInterfaceDescriptorData 287 call_descriptor_data_[NUMBER_OF_DESCRIPTORS]; 288}; 289 290#if defined(V8_TARGET_ARCH_IA32) 291// To support all possible cases, we must limit the number of register args for 292// TFS builtins on ia32 to 3. Out of the 6 allocatable registers, esi is taken 293// as the context register and ebx is the root register. One register must 294// remain available to store the jump/call target. Thus 3 registers remain for 295// arguments. The reason this applies to TFS builtins specifically is because 296// this becomes relevant for builtins used as targets of Torque function 297// pointers (which must have a register available to store the target). 298// TODO(jgruber): Ideally we should just decrement kMaxBuiltinRegisterParams but 299// that comes with its own set of complications. It's possible, but requires 300// refactoring the calling convention of other existing stubs. 301constexpr int kMaxBuiltinRegisterParams = 4; 302constexpr int kMaxTFSBuiltinRegisterParams = 3; 303#else 304constexpr int kMaxBuiltinRegisterParams = 5; 305constexpr int kMaxTFSBuiltinRegisterParams = kMaxBuiltinRegisterParams; 306#endif 307STATIC_ASSERT(kMaxTFSBuiltinRegisterParams <= kMaxBuiltinRegisterParams); 308constexpr int kJSBuiltinRegisterParams = 4; 309 310// Polymorphic base class for call interface descriptors, which defines getters 311// for the various descriptor properties via a runtime-loaded 312// CallInterfaceDescriptorData field. 313class V8_EXPORT_PRIVATE CallInterfaceDescriptor { 314 public: 315 using Flags = CallInterfaceDescriptorData::Flags; 316 317 CallInterfaceDescriptor() : data_(nullptr) {} 318 ~CallInterfaceDescriptor() = default; 319 320 explicit CallInterfaceDescriptor(CallDescriptors::Key key) 321 : data_(CallDescriptors::call_descriptor_data(key)) {} 322 323 Flags flags() const { return data()->flags(); } 324 325 bool HasContextParameter() const { 326 return (flags() & CallInterfaceDescriptorData::kNoContext) == 0; 327 } 328 329 bool AllowVarArgs() const { 330 return flags() & CallInterfaceDescriptorData::kAllowVarArgs; 331 } 332 333 bool CalleeSaveRegisters() const { 334 return flags() & CallInterfaceDescriptorData::kCalleeSaveRegisters; 335 } 336 337 int GetReturnCount() const { return data()->return_count(); } 338 339 MachineType GetReturnType(int index) const { 340 DCHECK_LT(index, data()->return_count()); 341 return data()->return_type(index); 342 } 343 344 int GetParameterCount() const { return data()->param_count(); } 345 346 int GetRegisterParameterCount() const { 347 return data()->register_param_count(); 348 } 349 350 int GetStackParameterCount() const { 351 return data()->param_count() - data()->register_param_count(); 352 } 353 354 Register GetRegisterParameter(int index) const { 355 DCHECK_LT(index, data()->register_param_count()); 356 return data()->register_param(index); 357 } 358 359 MachineType GetParameterType(int index) const { 360 DCHECK_LT(index, data()->param_count()); 361 return data()->param_type(index); 362 } 363 364 RegList allocatable_registers() const { 365 return data()->allocatable_registers(); 366 } 367 368 StackArgumentOrder GetStackArgumentOrder() const { 369 return data()->stack_order(); 370 } 371 372 static constexpr inline Register ContextRegister() { 373 return kContextRegister; 374 } 375 376 const char* DebugName() const; 377 378 bool operator==(const CallInterfaceDescriptor& other) const { 379 return data() == other.data(); 380 } 381 382 protected: 383 const CallInterfaceDescriptorData* data() const { return data_; } 384 385 // Helper for defining the default register set. 386 // 387 // Use auto for the return type to allow different architectures to have 388 // differently sized default register arrays. 389 static constexpr inline auto DefaultRegisterArray(); 390 static constexpr inline std::array<Register, kJSBuiltinRegisterParams> 391 DefaultJSRegisterArray(); 392 393 // Checks if float parameters are not assigned invalid registers. 394 bool CheckFloatingPointParameters(CallInterfaceDescriptorData* data) { 395 for (int i = 0; i < data->register_param_count(); i++) { 396 if (IsFloatingPoint(data->param_type(i).representation())) { 397 if (!IsValidFloatParameterRegister(data->register_param(i))) { 398 return false; 399 } 400 } 401 } 402 return true; 403 } 404 405 bool IsValidFloatParameterRegister(Register reg); 406 407 private: 408 const CallInterfaceDescriptorData* data_; 409}; 410 411// CRTP base class for call interface descriptors, which defines static getters 412// for the various descriptor properties based on static values defined in the 413// subclass. 414template <typename DerivedDescriptor> 415class StaticCallInterfaceDescriptor : public CallInterfaceDescriptor { 416 public: 417 // =========================================================================== 418 // The following are the descriptor's CRTP configuration points, overwritable 419 // by DerivedDescriptor. 420 static constexpr int kReturnCount = 421 CallInterfaceDescriptorData::kUninitializedCount; 422 static constexpr int kParameterCount = 423 CallInterfaceDescriptorData::kUninitializedCount; 424 static constexpr bool kNoContext = false; 425 static constexpr bool kAllowVarArgs = false; 426 static constexpr bool kNoStackScan = false; 427 static constexpr auto kStackArgumentOrder = StackArgumentOrder::kDefault; 428 429 // The set of registers available to the parameters, as a 430 // std::array<Register,N>. Can be larger or smaller than kParameterCount; if 431 // larger then any remaining registers are ignored; if smaller, any parameters 432 // after registers().size() will be stack registers. 433 // 434 // Defaults to CallInterfaceDescriptor::DefaultRegisterArray(). 435 static constexpr inline auto registers(); 436 437 // An additional limit on the number of register parameters allowed. This is 438 // here so that it can be overwritten to kMaxTFSBuiltinRegisterParams for TFS 439 // builtins, see comment on kMaxTFSBuiltinRegisterParams above. 440 static constexpr int kMaxRegisterParams = kMaxBuiltinRegisterParams; 441 442 // If set to true, the descriptor will restrict the set of allocatable 443 // registers to the set returned by registers(). Then, it is expected that 444 // the first kParameterCount registers() are the parameters of the builtin. 445 static constexpr bool kRestrictAllocatableRegisters = false; 446 447 // If set to true, builtins will callee save the set returned by registers(). 448 static constexpr bool kCalleeSaveRegisters = false; 449 450 // End of customization points. 451 // =========================================================================== 452 453 static constexpr inline Flags flags() { 454 return Flags((DerivedDescriptor::kNoContext 455 ? CallInterfaceDescriptorData::kNoContext 456 : 0) | 457 (DerivedDescriptor::kAllowVarArgs 458 ? CallInterfaceDescriptorData::kAllowVarArgs 459 : 0) | 460 (DerivedDescriptor::kNoStackScan 461 ? CallInterfaceDescriptorData::kNoStackScan 462 : 0) | 463 (DerivedDescriptor::kCalleeSaveRegisters 464 ? CallInterfaceDescriptorData::kCalleeSaveRegisters 465 : 0)); 466 } 467 static constexpr inline bool AllowVarArgs() { 468 return DerivedDescriptor::kAllowVarArgs; 469 } 470 static constexpr inline bool HasContextParameter() { 471 return !DerivedDescriptor::kNoContext; 472 } 473 474 static constexpr inline int GetReturnCount(); 475 static constexpr inline int GetParameterCount(); 476 static constexpr inline int GetRegisterParameterCount(); 477 static constexpr inline int GetStackParameterCount(); 478 static constexpr inline Register* GetRegisterData(); 479 static constexpr inline Register GetRegisterParameter(int i); 480 481 explicit StaticCallInterfaceDescriptor(CallDescriptors::Key key) 482 : CallInterfaceDescriptor(key) {} 483 484#if DEBUG 485 // Overwritten in DerivedDescriptor. 486 static void Verify(CallInterfaceDescriptorData* data); 487 // Verify that the CallInterfaceDescriptorData contains the default 488 // argument registers for {argc} arguments. 489 static inline void VerifyArgumentRegisterCount( 490 CallInterfaceDescriptorData* data, int nof_expected_args); 491#endif 492 493 private: 494 // {CallDescriptors} is allowed to call the private {Initialize} method. 495 friend class CallDescriptors; 496 497 inline void Initialize(CallInterfaceDescriptorData* data); 498 499 // Set up the types of the descriptor. This is a static function, so that it 500 // is overwritable by subclasses. By default, all parameters have 501 // MachineType::AnyTagged() type. 502 static void InitializeTypes(CallInterfaceDescriptorData* data) { 503 data->InitializeTypes(nullptr, 0); 504 } 505}; 506 507template <typename Descriptor> 508class StaticJSCallInterfaceDescriptor 509 : public StaticCallInterfaceDescriptor<Descriptor> { 510 public: 511 static constexpr auto kStackArgumentOrder = StackArgumentOrder::kJS; 512 static constexpr inline auto registers(); 513 514 using StaticCallInterfaceDescriptor< 515 Descriptor>::StaticCallInterfaceDescriptor; 516}; 517 518template <Builtin kBuiltin> 519struct CallInterfaceDescriptorFor; 520 521// Stub class replacing std::array<Register, 0>, as a workaround for MSVC's 522// https://github.com/microsoft/STL/issues/942 523struct EmptyRegisterArray { 524 Register* data() { return nullptr; } 525 size_t size() const { return 0; } 526 Register operator[](size_t i) const { UNREACHABLE(); } 527}; 528 529// Helper method for defining an array of unique registers for the various 530// Descriptor::registers() methods. 531template <typename... Registers> 532constexpr std::array<Register, 1 + sizeof...(Registers)> RegisterArray( 533 Register first_reg, Registers... regs) { 534 DCHECK(!AreAliased(first_reg, regs...)); 535 return {first_reg, regs...}; 536} 537constexpr EmptyRegisterArray RegisterArray() { return {}; } 538 539#define DECLARE_DESCRIPTOR_WITH_BASE(name, base) \ 540 public: \ 541 /* StaticCallInterfaceDescriptor can call Initialize methods */ \ 542 friend class StaticCallInterfaceDescriptor<name>; \ 543 explicit name() : base(key()) {} \ 544 static inline CallDescriptors::Key key(); 545 546#define DECLARE_DEFAULT_DESCRIPTOR(name) \ 547 DECLARE_DESCRIPTOR_WITH_BASE(name, StaticCallInterfaceDescriptor) \ 548 static constexpr int kMaxRegisterParams = kMaxTFSBuiltinRegisterParams; \ 549 \ 550 protected: \ 551 explicit name(CallDescriptors::Key key) \ 552 : StaticCallInterfaceDescriptor(key) {} \ 553 \ 554 public: 555 556#define DECLARE_JS_COMPATIBLE_DESCRIPTOR(name) \ 557 DECLARE_DESCRIPTOR_WITH_BASE(name, StaticJSCallInterfaceDescriptor) \ 558 protected: \ 559 explicit name(CallDescriptors::Key key) \ 560 : StaticJSCallInterfaceDescriptor(key) {} \ 561 \ 562 public: 563 564#define DEFINE_RESULT_AND_PARAMETERS(return_count, ...) \ 565 static constexpr int kReturnCount = return_count; \ 566 enum ParameterIndices { \ 567 __dummy = -1, /* to be able to pass zero arguments */ \ 568 ##__VA_ARGS__, \ 569 \ 570 kParameterCount, \ 571 kContext = kParameterCount /* implicit parameter */ \ 572 }; 573 574// This is valid only for builtins that use EntryFrame, which does not scan 575// stack arguments on GC. 576#define DEFINE_PARAMETERS_ENTRY(...) \ 577 static constexpr bool kNoContext = true; \ 578 static constexpr bool kNoStackScan = true; \ 579 static constexpr StackArgumentOrder kStackArgumentOrder = \ 580 StackArgumentOrder::kDefault; \ 581 static constexpr int kReturnCount = 1; \ 582 enum ParameterIndices { \ 583 __dummy = -1, /* to be able to pass zero arguments */ \ 584 ##__VA_ARGS__, \ 585 \ 586 kParameterCount \ 587 }; 588 589#define DEFINE_PARAMETERS(...) DEFINE_RESULT_AND_PARAMETERS(1, ##__VA_ARGS__) 590 591#define DEFINE_PARAMETERS_NO_CONTEXT(...) \ 592 DEFINE_PARAMETERS(__VA_ARGS__) \ 593 static constexpr bool kNoContext = true; 594 595#define DEFINE_PARAMETERS_VARARGS(...) \ 596 DEFINE_PARAMETERS(__VA_ARGS__) \ 597 static constexpr bool kAllowVarArgs = true; \ 598 static constexpr StackArgumentOrder kStackArgumentOrder = \ 599 StackArgumentOrder::kJS; 600 601#define DEFINE_PARAMETERS_NO_CONTEXT_VARARGS(...) \ 602 DEFINE_PARAMETERS_NO_CONTEXT(__VA_ARGS__) \ 603 static constexpr bool kAllowVarArgs = true; \ 604 static constexpr StackArgumentOrder kStackArgumentOrder = \ 605 StackArgumentOrder::kJS; 606 607#define DEFINE_RESULT_AND_PARAMETERS_NO_CONTEXT(return_count, ...) \ 608 DEFINE_RESULT_AND_PARAMETERS(return_count, ##__VA_ARGS__) \ 609 static constexpr bool kNoContext = true; 610 611#define DEFINE_RESULT_AND_PARAMETER_TYPES(...) \ 612 static void InitializeTypes(CallInterfaceDescriptorData* data) { \ 613 MachineType machine_types[] = {__VA_ARGS__}; \ 614 static_assert( \ 615 kReturnCount + kParameterCount == arraysize(machine_types), \ 616 "Parameter names definition is not consistent with parameter types"); \ 617 data->InitializeTypes(machine_types, arraysize(machine_types)); \ 618 } 619 620#define DEFINE_PARAMETER_TYPES(...) \ 621 DEFINE_RESULT_AND_PARAMETER_TYPES(MachineType::AnyTagged() /* result */, \ 622 ##__VA_ARGS__) 623 624// When the extra arguments described here are located in the stack, they are 625// just above the return address in the frame (first arguments). 626#define DEFINE_JS_PARAMETERS(...) \ 627 static constexpr bool kAllowVarArgs = true; \ 628 static constexpr int kReturnCount = 1; \ 629 static constexpr StackArgumentOrder kStackArgumentOrder = \ 630 StackArgumentOrder::kJS; \ 631 enum ParameterIndices { \ 632 kTarget, \ 633 kNewTarget, \ 634 kActualArgumentsCount, \ 635 ##__VA_ARGS__, \ 636 kParameterCount, \ 637 kContext = kParameterCount /* implicit parameter */ \ 638 }; 639 640#define DEFINE_JS_PARAMETERS_NO_CONTEXT(...) \ 641 static constexpr bool kAllowVarArgs = true; \ 642 static constexpr bool kNoContext = true; \ 643 static constexpr int kReturnCount = 1; \ 644 static constexpr StackArgumentOrder kStackArgumentOrder = \ 645 StackArgumentOrder::kJS; \ 646 enum ParameterIndices { \ 647 kTarget, \ 648 kNewTarget, \ 649 kActualArgumentsCount, \ 650 ##__VA_ARGS__, \ 651 kParameterCount, \ 652 }; 653 654#define DEFINE_JS_PARAMETER_TYPES(...) \ 655 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), /* kTarget */ \ 656 MachineType::AnyTagged(), /* kNewTarget */ \ 657 MachineType::Int32(), /* kActualArgumentsCount */ \ 658 ##__VA_ARGS__) 659 660#define DECLARE_DESCRIPTOR(name) \ 661 DECLARE_DESCRIPTOR_WITH_BASE(name, StaticCallInterfaceDescriptor) \ 662 protected: \ 663 explicit name(CallDescriptors::Key key) \ 664 : StaticCallInterfaceDescriptor(key) {} \ 665 \ 666 public: 667 668class V8_EXPORT_PRIVATE VoidDescriptor 669 : public StaticCallInterfaceDescriptor<VoidDescriptor> { 670 public: 671 DEFINE_PARAMETERS() 672 DEFINE_PARAMETER_TYPES() 673 DECLARE_DESCRIPTOR(VoidDescriptor) 674 675 static constexpr auto registers(); 676}; 677 678// Dummy descriptor used to mark builtins that don't yet have their proper 679// descriptor associated. 680using DummyDescriptor = VoidDescriptor; 681 682// Dummy descriptor that marks builtins with C calling convention. 683using CCallDescriptor = VoidDescriptor; 684 685// Marks deoptimization entry builtins. Precise calling conventions currently 686// differ based on the platform. 687// TODO(jgruber): Once this is unified, we could create a better description 688// here. 689using DeoptimizationEntryDescriptor = VoidDescriptor; 690 691class AllocateDescriptor 692 : public StaticCallInterfaceDescriptor<AllocateDescriptor> { 693 public: 694 DEFINE_PARAMETERS_NO_CONTEXT(kRequestedSize) 695 DEFINE_RESULT_AND_PARAMETER_TYPES(MachineType::TaggedPointer(), // result 1 696 MachineType::IntPtr()) // kRequestedSize 697 DECLARE_DESCRIPTOR(AllocateDescriptor) 698 699 static constexpr auto registers(); 700}; 701 702// This descriptor defines the JavaScript calling convention that can be used 703// by stubs: target, new.target, argc and context are passed in registers while 704// receiver and the rest of the JS arguments are passed on the stack. 705class JSTrampolineDescriptor 706 : public StaticJSCallInterfaceDescriptor<JSTrampolineDescriptor> { 707 public: 708 DEFINE_JS_PARAMETERS() 709 DEFINE_JS_PARAMETER_TYPES() 710 711 DECLARE_JS_COMPATIBLE_DESCRIPTOR(JSTrampolineDescriptor) 712}; 713 714class ContextOnlyDescriptor 715 : public StaticCallInterfaceDescriptor<ContextOnlyDescriptor> { 716 public: 717 DEFINE_PARAMETERS() 718 DEFINE_PARAMETER_TYPES() 719 DECLARE_DESCRIPTOR(ContextOnlyDescriptor) 720 721 static constexpr auto registers(); 722}; 723 724class NoContextDescriptor 725 : public StaticCallInterfaceDescriptor<NoContextDescriptor> { 726 public: 727 DEFINE_PARAMETERS_NO_CONTEXT() 728 DEFINE_PARAMETER_TYPES() 729 DECLARE_DESCRIPTOR(NoContextDescriptor) 730 731 static constexpr auto registers(); 732}; 733 734// LoadDescriptor is used by all stubs that implement Load ICs. 735class LoadDescriptor : public StaticCallInterfaceDescriptor<LoadDescriptor> { 736 public: 737 DEFINE_PARAMETERS(kReceiver, kName, kSlot) 738 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kReceiver 739 MachineType::AnyTagged(), // kName 740 MachineType::TaggedSigned()) // kSlot 741 DECLARE_DESCRIPTOR(LoadDescriptor) 742 743 static constexpr inline Register ReceiverRegister(); 744 static constexpr inline Register NameRegister(); 745 static constexpr inline Register SlotRegister(); 746 747 static constexpr auto registers(); 748}; 749 750// LoadBaselineDescriptor is a load descriptor that does not take a context as 751// input. 752class LoadBaselineDescriptor 753 : public StaticCallInterfaceDescriptor<LoadBaselineDescriptor> { 754 public: 755 DEFINE_PARAMETERS_NO_CONTEXT(kReceiver, kName, kSlot) 756 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kReceiver 757 MachineType::AnyTagged(), // kName 758 MachineType::TaggedSigned()) // kSlot 759 DECLARE_DESCRIPTOR(LoadBaselineDescriptor) 760 761 static constexpr auto registers(); 762}; 763 764class LoadGlobalNoFeedbackDescriptor 765 : public StaticCallInterfaceDescriptor<LoadGlobalNoFeedbackDescriptor> { 766 public: 767 DEFINE_PARAMETERS(kName, kICKind) 768 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kName 769 MachineType::TaggedSigned()) // kICKind 770 DECLARE_DESCRIPTOR(LoadGlobalNoFeedbackDescriptor) 771 772 static constexpr inline Register ICKindRegister(); 773 774 static constexpr auto registers(); 775}; 776 777class LoadNoFeedbackDescriptor 778 : public StaticCallInterfaceDescriptor<LoadNoFeedbackDescriptor> { 779 public: 780 DEFINE_PARAMETERS(kReceiver, kName, kICKind) 781 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kReceiver 782 MachineType::AnyTagged(), // kName 783 MachineType::TaggedSigned()) // kICKind 784 DECLARE_DESCRIPTOR(LoadNoFeedbackDescriptor) 785 786 static constexpr inline Register ICKindRegister(); 787 788 static constexpr auto registers(); 789}; 790 791class LoadGlobalDescriptor 792 : public StaticCallInterfaceDescriptor<LoadGlobalDescriptor> { 793 public: 794 DEFINE_PARAMETERS(kName, kSlot) 795 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kName 796 MachineType::TaggedSigned()) // kSlot 797 DECLARE_DESCRIPTOR(LoadGlobalDescriptor) 798 799 static constexpr auto registers(); 800}; 801 802class LoadGlobalBaselineDescriptor 803 : public StaticCallInterfaceDescriptor<LoadGlobalBaselineDescriptor> { 804 public: 805 DEFINE_PARAMETERS_NO_CONTEXT(kName, kSlot) 806 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kName 807 MachineType::TaggedSigned()) // kSlot 808 DECLARE_DESCRIPTOR(LoadGlobalBaselineDescriptor) 809 810 static constexpr auto registers(); 811}; 812 813class LookupBaselineDescriptor 814 : public StaticCallInterfaceDescriptor<LookupBaselineDescriptor> { 815 public: 816 DEFINE_PARAMETERS_NO_CONTEXT(kName, kDepth, kSlot) 817 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kName 818 MachineType::AnyTagged(), // kDepth 819 MachineType::AnyTagged()) // kSlot 820 DECLARE_DESCRIPTOR(LookupBaselineDescriptor) 821}; 822 823class StoreDescriptor : public StaticCallInterfaceDescriptor<StoreDescriptor> { 824 public: 825 DEFINE_PARAMETERS(kReceiver, kName, kValue, kSlot) 826 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kReceiver 827 MachineType::AnyTagged(), // kName 828 MachineType::AnyTagged(), // kValue 829 MachineType::TaggedSigned()) // kSlot 830 DECLARE_DESCRIPTOR(StoreDescriptor) 831 832 static constexpr inline Register ReceiverRegister(); 833 static constexpr inline Register NameRegister(); 834 static constexpr inline Register ValueRegister(); 835 static constexpr inline Register SlotRegister(); 836 837 static constexpr auto registers(); 838}; 839 840class StoreBaselineDescriptor 841 : public StaticCallInterfaceDescriptor<StoreBaselineDescriptor> { 842 public: 843 DEFINE_PARAMETERS_NO_CONTEXT(kReceiver, kName, kValue, kSlot) 844 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kReceiver 845 MachineType::AnyTagged(), // kName 846 MachineType::AnyTagged(), // kValue 847 MachineType::TaggedSigned()) // kSlot 848 DECLARE_DESCRIPTOR(StoreBaselineDescriptor) 849 850 static constexpr auto registers(); 851}; 852 853class StoreTransitionDescriptor 854 : public StaticCallInterfaceDescriptor<StoreTransitionDescriptor> { 855 public: 856 DEFINE_PARAMETERS(kReceiver, kName, kMap, kValue, kSlot, kVector) 857 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kReceiver 858 MachineType::AnyTagged(), // kName 859 MachineType::AnyTagged(), // kMap 860 MachineType::AnyTagged(), // kValue 861 MachineType::TaggedSigned(), // kSlot 862 MachineType::AnyTagged()) // kVector 863 DECLARE_DESCRIPTOR(StoreTransitionDescriptor) 864 865 static constexpr inline Register MapRegister(); 866 867 static constexpr auto registers(); 868}; 869 870class StoreWithVectorDescriptor 871 : public StaticCallInterfaceDescriptor<StoreWithVectorDescriptor> { 872 public: 873 DEFINE_PARAMETERS(kReceiver, kName, kValue, kSlot, kVector) 874 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kReceiver 875 MachineType::AnyTagged(), // kName 876 MachineType::AnyTagged(), // kValue 877 MachineType::TaggedSigned(), // kSlot 878 MachineType::AnyTagged()) // kVector 879 DECLARE_DESCRIPTOR(StoreWithVectorDescriptor) 880 881 static constexpr inline Register VectorRegister(); 882 883 static constexpr auto registers(); 884}; 885 886class StoreGlobalDescriptor 887 : public StaticCallInterfaceDescriptor<StoreGlobalDescriptor> { 888 public: 889 DEFINE_PARAMETERS(kName, kValue, kSlot) 890 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kName 891 MachineType::AnyTagged(), // kValue 892 MachineType::TaggedSigned()) // kSlot 893 DECLARE_DESCRIPTOR(StoreGlobalDescriptor) 894 895 static constexpr auto registers(); 896}; 897 898class StoreGlobalBaselineDescriptor 899 : public StaticCallInterfaceDescriptor<StoreGlobalBaselineDescriptor> { 900 public: 901 DEFINE_PARAMETERS_NO_CONTEXT(kName, kValue, kSlot) 902 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kName 903 MachineType::AnyTagged(), // kValue 904 MachineType::TaggedSigned()) // kSlot 905 DECLARE_DESCRIPTOR(StoreGlobalBaselineDescriptor) 906 907 static constexpr auto registers(); 908}; 909 910class StoreGlobalWithVectorDescriptor 911 : public StaticCallInterfaceDescriptor<StoreGlobalWithVectorDescriptor> { 912 public: 913 DEFINE_PARAMETERS(kName, kValue, kSlot, kVector) 914 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kName 915 MachineType::AnyTagged(), // kValue 916 MachineType::TaggedSigned(), // kSlot 917 MachineType::AnyTagged()) // kVector 918 DECLARE_DESCRIPTOR(StoreGlobalWithVectorDescriptor) 919 920 static constexpr auto registers(); 921}; 922 923class LoadWithVectorDescriptor 924 : public StaticCallInterfaceDescriptor<LoadWithVectorDescriptor> { 925 public: 926 // TODO(v8:9497): Revert the Machine type for kSlot to the 927 // TaggedSigned once Torque can emit better call descriptors 928 DEFINE_PARAMETERS(kReceiver, kName, kSlot, kVector) 929 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kReceiver 930 MachineType::AnyTagged(), // kName 931 MachineType::AnyTagged(), // kSlot 932 MachineType::AnyTagged()) // kVector 933 DECLARE_DESCRIPTOR(LoadWithVectorDescriptor) 934 935 static constexpr inline Register VectorRegister(); 936 937 static constexpr auto registers(); 938}; 939 940class KeyedLoadBaselineDescriptor 941 : public StaticCallInterfaceDescriptor<KeyedLoadBaselineDescriptor> { 942 public: 943 DEFINE_PARAMETERS_NO_CONTEXT(kReceiver, kName, kSlot) 944 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kReceiver 945 MachineType::AnyTagged(), // kName 946 MachineType::TaggedSigned()) // kSlot 947 DECLARE_DESCRIPTOR(KeyedLoadBaselineDescriptor) 948 949 static constexpr inline Register ReceiverRegister(); 950 static constexpr inline Register NameRegister(); 951 static constexpr inline Register SlotRegister(); 952 953 static constexpr auto registers(); 954}; 955 956class KeyedLoadDescriptor 957 : public StaticCallInterfaceDescriptor<KeyedLoadDescriptor> { 958 public: 959 DEFINE_PARAMETERS(kReceiver, kName, kSlot) 960 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kReceiver 961 MachineType::AnyTagged(), // kName 962 MachineType::TaggedSigned()) // kSlot 963 DECLARE_DESCRIPTOR(KeyedLoadDescriptor) 964 965 static constexpr auto registers(); 966}; 967 968class KeyedLoadWithVectorDescriptor 969 : public StaticCallInterfaceDescriptor<KeyedLoadWithVectorDescriptor> { 970 public: 971 DEFINE_PARAMETERS(kReceiver, kName, kSlot, kVector) 972 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kReceiver 973 MachineType::AnyTagged(), // kName 974 MachineType::TaggedSigned(), // kSlot 975 MachineType::AnyTagged()) // kVector 976 DECLARE_DESCRIPTOR(KeyedLoadWithVectorDescriptor) 977 978 static constexpr inline Register VectorRegister(); 979 980 static constexpr auto registers(); 981}; 982 983class KeyedHasICBaselineDescriptor 984 : public StaticCallInterfaceDescriptor<KeyedHasICBaselineDescriptor> { 985 public: 986 DEFINE_PARAMETERS_NO_CONTEXT(kReceiver, kName, kSlot) 987 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kReceiver 988 MachineType::AnyTagged(), // kName 989 MachineType::TaggedSigned()) // kSlot 990 DECLARE_DESCRIPTOR(KeyedHasICBaselineDescriptor) 991 992 static constexpr inline Register ReceiverRegister(); 993 static constexpr inline Register NameRegister(); 994 static constexpr inline Register SlotRegister(); 995 996 static constexpr auto registers(); 997}; 998 999class KeyedHasICWithVectorDescriptor 1000 : public StaticCallInterfaceDescriptor<KeyedHasICWithVectorDescriptor> { 1001 public: 1002 DEFINE_PARAMETERS(kReceiver, kName, kSlot, kVector) 1003 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kReceiver 1004 MachineType::AnyTagged(), // kName 1005 MachineType::TaggedSigned(), // kSlot 1006 MachineType::AnyTagged()) // kVector 1007 DECLARE_DESCRIPTOR(KeyedHasICWithVectorDescriptor) 1008 1009 static constexpr inline Register VectorRegister(); 1010 1011 static constexpr auto registers(); 1012}; 1013 1014// Like LoadWithVectorDescriptor, except we pass the receiver (the object which 1015// should be used as the receiver for accessor function calls) and the lookup 1016// start object separately. 1017class LoadWithReceiverAndVectorDescriptor 1018 : public StaticCallInterfaceDescriptor< 1019 LoadWithReceiverAndVectorDescriptor> { 1020 public: 1021 // TODO(v8:9497): Revert the Machine type for kSlot to the 1022 // TaggedSigned once Torque can emit better call descriptors 1023 DEFINE_PARAMETERS(kReceiver, kLookupStartObject, kName, kSlot, kVector) 1024 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kReceiver 1025 MachineType::AnyTagged(), // kLookupStartObject 1026 MachineType::AnyTagged(), // kName 1027 MachineType::AnyTagged(), // kSlot 1028 MachineType::AnyTagged()) // kVector 1029 DECLARE_DESCRIPTOR(LoadWithReceiverAndVectorDescriptor) 1030 1031 static constexpr inline Register LookupStartObjectRegister(); 1032 1033 static constexpr auto registers(); 1034}; 1035 1036class LoadWithReceiverBaselineDescriptor 1037 : public StaticCallInterfaceDescriptor<LoadWithReceiverBaselineDescriptor> { 1038 public: 1039 // TODO(v8:9497): Revert the Machine type for kSlot to the 1040 // TaggedSigned once Torque can emit better call descriptors 1041 DEFINE_PARAMETERS_NO_CONTEXT(kReceiver, kLookupStartObject, kName, kSlot) 1042 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kReceiver 1043 MachineType::AnyTagged(), // kLookupStartObject 1044 MachineType::AnyTagged(), // kName 1045 MachineType::AnyTagged()) // kSlot 1046 DECLARE_DESCRIPTOR(LoadWithReceiverBaselineDescriptor) 1047 1048 static constexpr auto registers(); 1049}; 1050 1051class LoadGlobalWithVectorDescriptor 1052 : public StaticCallInterfaceDescriptor<LoadGlobalWithVectorDescriptor> { 1053 public: 1054 DEFINE_PARAMETERS(kName, kSlot, kVector) 1055 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kName 1056 MachineType::TaggedSigned(), // kSlot 1057 MachineType::AnyTagged()) // kVector 1058 DECLARE_DESCRIPTOR(LoadGlobalWithVectorDescriptor) 1059 1060 static constexpr inline Register VectorRegister(); 1061 1062 static constexpr auto registers(); 1063}; 1064 1065class FastNewObjectDescriptor 1066 : public StaticCallInterfaceDescriptor<FastNewObjectDescriptor> { 1067 public: 1068 DEFINE_PARAMETERS(kTarget, kNewTarget) 1069 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kTarget 1070 MachineType::AnyTagged()) // kNewTarget 1071 DECLARE_DESCRIPTOR(FastNewObjectDescriptor) 1072 1073 static constexpr inline Register TargetRegister(); 1074 static constexpr inline Register NewTargetRegister(); 1075 1076 static constexpr auto registers(); 1077}; 1078 1079class WriteBarrierDescriptor final 1080 : public StaticCallInterfaceDescriptor<WriteBarrierDescriptor> { 1081 public: 1082 DEFINE_PARAMETERS_NO_CONTEXT(kObject, kSlotAddress) 1083 DEFINE_PARAMETER_TYPES(MachineType::TaggedPointer(), // kObject 1084 MachineType::Pointer()) // kSlotAddress 1085 1086 DECLARE_DESCRIPTOR(WriteBarrierDescriptor) 1087 static constexpr auto registers(); 1088 static constexpr bool kRestrictAllocatableRegisters = true; 1089 static constexpr bool kCalleeSaveRegisters = true; 1090 static constexpr inline Register ObjectRegister(); 1091 static constexpr inline Register SlotAddressRegister(); 1092 // A temporary register used in helpers. 1093 static constexpr inline Register ValueRegister(); 1094 static constexpr inline RegList ComputeSavedRegisters( 1095 Register object, Register slot_address = no_reg); 1096#if DEBUG 1097 static void Verify(CallInterfaceDescriptorData* data); 1098#endif 1099}; 1100 1101#ifdef V8_IS_TSAN 1102class TSANStoreDescriptor final 1103 : public StaticCallInterfaceDescriptor<TSANStoreDescriptor> { 1104 public: 1105 DEFINE_PARAMETERS_NO_CONTEXT(kAddress, kValue) 1106 DEFINE_PARAMETER_TYPES(MachineType::Pointer(), // kAddress 1107 MachineType::AnyTagged()) // kValue 1108 1109 DECLARE_DESCRIPTOR(TSANStoreDescriptor) 1110 1111 static constexpr auto registers(); 1112 static constexpr bool kRestrictAllocatableRegisters = true; 1113}; 1114 1115class TSANLoadDescriptor final 1116 : public StaticCallInterfaceDescriptor<TSANLoadDescriptor> { 1117 public: 1118 DEFINE_PARAMETERS_NO_CONTEXT(kAddress) 1119 DEFINE_PARAMETER_TYPES(MachineType::Pointer()) // kAddress 1120 1121 DECLARE_DESCRIPTOR(TSANLoadDescriptor) 1122 1123 static constexpr auto registers(); 1124 static constexpr bool kRestrictAllocatableRegisters = true; 1125}; 1126 1127#endif // V8_IS_TSAN 1128 1129class TypeConversionDescriptor final 1130 : public StaticCallInterfaceDescriptor<TypeConversionDescriptor> { 1131 public: 1132 DEFINE_PARAMETERS(kArgument) 1133 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged()) 1134 DECLARE_DESCRIPTOR(TypeConversionDescriptor) 1135 1136 static constexpr inline Register ArgumentRegister(); 1137 1138 static constexpr auto registers(); 1139}; 1140 1141class TypeConversionNoContextDescriptor final 1142 : public StaticCallInterfaceDescriptor<TypeConversionNoContextDescriptor> { 1143 public: 1144 DEFINE_PARAMETERS_NO_CONTEXT(kArgument) 1145 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged()) 1146 DECLARE_DESCRIPTOR(TypeConversionNoContextDescriptor) 1147 1148 static constexpr auto registers(); 1149}; 1150 1151class TypeConversion_BaselineDescriptor final 1152 : public StaticCallInterfaceDescriptor<TypeConversion_BaselineDescriptor> { 1153 public: 1154 DEFINE_PARAMETERS_NO_CONTEXT(kArgument, kSlot) 1155 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), MachineType::UintPtr()) 1156 DECLARE_DESCRIPTOR(TypeConversion_BaselineDescriptor) 1157}; 1158 1159class SingleParameterOnStackDescriptor final 1160 : public StaticCallInterfaceDescriptor<SingleParameterOnStackDescriptor> { 1161 public: 1162 DEFINE_PARAMETERS(kArgument) 1163 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged()) 1164 DECLARE_DESCRIPTOR(SingleParameterOnStackDescriptor) 1165 1166 static constexpr auto registers(); 1167}; 1168 1169class AsyncFunctionStackParameterDescriptor final 1170 : public StaticCallInterfaceDescriptor< 1171 AsyncFunctionStackParameterDescriptor> { 1172 public: 1173 DEFINE_PARAMETERS(kPromise, kResult) 1174 DEFINE_PARAMETER_TYPES(MachineType::TaggedPointer(), MachineType::AnyTagged()) 1175 DECLARE_DESCRIPTOR(AsyncFunctionStackParameterDescriptor) 1176 1177 static constexpr auto registers(); 1178}; 1179 1180class GetIteratorStackParameterDescriptor final 1181 : public StaticCallInterfaceDescriptor< 1182 GetIteratorStackParameterDescriptor> { 1183 public: 1184 DEFINE_PARAMETERS(kReceiver, kCallSlot, kFeedback, kResult) 1185 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), MachineType::AnyTagged(), 1186 MachineType::AnyTagged(), MachineType::AnyTagged()) 1187 DECLARE_DESCRIPTOR(GetIteratorStackParameterDescriptor) 1188 1189 static constexpr auto registers(); 1190}; 1191 1192class GetPropertyDescriptor final 1193 : public StaticCallInterfaceDescriptor<GetPropertyDescriptor> { 1194 public: 1195 DEFINE_PARAMETERS(kObject, kKey) 1196 DECLARE_DEFAULT_DESCRIPTOR(GetPropertyDescriptor) 1197}; 1198 1199class TypeofDescriptor 1200 : public StaticCallInterfaceDescriptor<TypeofDescriptor> { 1201 public: 1202 DEFINE_PARAMETERS(kObject) 1203 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged()) 1204 DECLARE_DESCRIPTOR(TypeofDescriptor) 1205 1206 static constexpr inline auto registers(); 1207}; 1208 1209class CallTrampolineDescriptor 1210 : public StaticCallInterfaceDescriptor<CallTrampolineDescriptor> { 1211 public: 1212 DEFINE_PARAMETERS_VARARGS(kFunction, kActualArgumentsCount) 1213 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kFunction 1214 MachineType::Int32()) // kActualArgumentsCount 1215 DECLARE_DESCRIPTOR(CallTrampolineDescriptor) 1216 1217 static constexpr inline auto registers(); 1218}; 1219 1220class CopyDataPropertiesWithExcludedPropertiesDescriptor 1221 : public StaticCallInterfaceDescriptor< 1222 CopyDataPropertiesWithExcludedPropertiesDescriptor> { 1223 public: 1224 DEFINE_PARAMETERS_VARARGS(kSource, kExcludedPropertyCount) 1225 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kSource 1226 MachineType::AnyTagged()) // kExcludedPropertyCount 1227 DECLARE_DESCRIPTOR(CopyDataPropertiesWithExcludedPropertiesDescriptor) 1228 1229 static constexpr inline auto registers(); 1230}; 1231 1232class CopyDataPropertiesWithExcludedPropertiesOnStackDescriptor 1233 : public StaticCallInterfaceDescriptor< 1234 CopyDataPropertiesWithExcludedPropertiesOnStackDescriptor> { 1235 public: 1236 DEFINE_PARAMETERS(kSource, kExcludedPropertyCount, kExcludedPropertyBase) 1237 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kSource 1238 MachineType::IntPtr(), 1239 MachineType::IntPtr()) // kExcludedPropertyCount 1240 DECLARE_DESCRIPTOR(CopyDataPropertiesWithExcludedPropertiesOnStackDescriptor) 1241 1242 static constexpr inline auto registers(); 1243}; 1244 1245class CallVarargsDescriptor 1246 : public StaticCallInterfaceDescriptor<CallVarargsDescriptor> { 1247 public: 1248 DEFINE_PARAMETERS_VARARGS(kTarget, kActualArgumentsCount, kArgumentsLength, 1249 kArgumentsList) 1250 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kTarget 1251 MachineType::Int32(), // kActualArgumentsCount 1252 MachineType::Int32(), // kArgumentsLength 1253 MachineType::AnyTagged()) // kArgumentsList 1254 DECLARE_DESCRIPTOR(CallVarargsDescriptor) 1255 1256 static constexpr inline auto registers(); 1257}; 1258 1259class CallForwardVarargsDescriptor 1260 : public StaticCallInterfaceDescriptor<CallForwardVarargsDescriptor> { 1261 public: 1262 DEFINE_PARAMETERS_VARARGS(kTarget, kActualArgumentsCount, kStartIndex) 1263 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kTarget 1264 MachineType::Int32(), // kActualArgumentsCount 1265 MachineType::Int32()) // kStartIndex 1266 DECLARE_DESCRIPTOR(CallForwardVarargsDescriptor) 1267 1268 static constexpr inline auto registers(); 1269}; 1270 1271class CallFunctionTemplateDescriptor 1272 : public StaticCallInterfaceDescriptor<CallFunctionTemplateDescriptor> { 1273 public: 1274 DEFINE_PARAMETERS_VARARGS(kFunctionTemplateInfo, kArgumentsCount) 1275 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kFunctionTemplateInfo 1276 MachineType::IntPtr()) // kArgumentsCount 1277 DECLARE_DESCRIPTOR(CallFunctionTemplateDescriptor) 1278 1279 static constexpr inline auto registers(); 1280}; 1281 1282class CallWithSpreadDescriptor 1283 : public StaticCallInterfaceDescriptor<CallWithSpreadDescriptor> { 1284 public: 1285 DEFINE_PARAMETERS_VARARGS(kTarget, kArgumentsCount, kSpread) 1286 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kTarget 1287 MachineType::Int32(), // kArgumentsCount 1288 MachineType::AnyTagged()) // kSpread 1289 DECLARE_DESCRIPTOR(CallWithSpreadDescriptor) 1290 1291 static constexpr inline auto registers(); 1292}; 1293 1294class CallWithSpread_BaselineDescriptor 1295 : public StaticCallInterfaceDescriptor<CallWithSpread_BaselineDescriptor> { 1296 public: 1297 DEFINE_PARAMETERS_NO_CONTEXT_VARARGS(kTarget, kArgumentsCount, kSpread, kSlot) 1298 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kTarget 1299 MachineType::Int32(), // kArgumentsCount 1300 MachineType::AnyTagged(), // kSpread 1301 MachineType::UintPtr()) // kSlot 1302 DECLARE_DESCRIPTOR(CallWithSpread_BaselineDescriptor) 1303}; 1304 1305class CallWithSpread_WithFeedbackDescriptor 1306 : public StaticCallInterfaceDescriptor< 1307 CallWithSpread_WithFeedbackDescriptor> { 1308 public: 1309 DEFINE_PARAMETERS_VARARGS(kTarget, kArgumentsCount, kSpread, kSlot, 1310 kFeedbackVector, kReceiver) 1311 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kTarget 1312 MachineType::Int32(), // kArgumentsCount 1313 MachineType::AnyTagged(), // kSpread 1314 MachineType::UintPtr(), // kSlot 1315 MachineType::AnyTagged(), // kFeedbackVector 1316 MachineType::AnyTagged()) // kReceiver 1317 DECLARE_DESCRIPTOR(CallWithSpread_WithFeedbackDescriptor) 1318}; 1319 1320class CallWithArrayLikeDescriptor 1321 : public StaticCallInterfaceDescriptor<CallWithArrayLikeDescriptor> { 1322 public: 1323 DEFINE_PARAMETERS(kTarget, kArgumentsList) 1324 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kTarget 1325 MachineType::AnyTagged()) // kArgumentsList 1326 DECLARE_DESCRIPTOR(CallWithArrayLikeDescriptor) 1327 1328 static constexpr inline auto registers(); 1329}; 1330 1331class CallWithArrayLike_WithFeedbackDescriptor 1332 : public StaticCallInterfaceDescriptor< 1333 CallWithArrayLike_WithFeedbackDescriptor> { 1334 public: 1335 DEFINE_PARAMETERS(kTarget, kArgumentsList, kSlot, kFeedbackVector, kReceiver) 1336 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kTarget 1337 MachineType::AnyTagged(), // kArgumentsList 1338 MachineType::UintPtr(), // kSlot 1339 MachineType::AnyTagged(), // kFeedbackVector 1340 MachineType::AnyTagged()) // kReceiver 1341 DECLARE_DESCRIPTOR(CallWithArrayLike_WithFeedbackDescriptor) 1342}; 1343 1344class ConstructVarargsDescriptor 1345 : public StaticCallInterfaceDescriptor<ConstructVarargsDescriptor> { 1346 public: 1347 DEFINE_JS_PARAMETERS(kArgumentsLength, kArgumentsList) 1348 DEFINE_JS_PARAMETER_TYPES(MachineType::Int32(), // kArgumentsLength 1349 MachineType::AnyTagged()) // kArgumentsList 1350 1351 DECLARE_DESCRIPTOR(ConstructVarargsDescriptor) 1352 1353 static constexpr inline auto registers(); 1354}; 1355 1356class ConstructForwardVarargsDescriptor 1357 : public StaticCallInterfaceDescriptor<ConstructForwardVarargsDescriptor> { 1358 public: 1359 DEFINE_JS_PARAMETERS(kStartIndex) 1360 DEFINE_JS_PARAMETER_TYPES(MachineType::Int32()) 1361 DECLARE_DESCRIPTOR(ConstructForwardVarargsDescriptor) 1362 1363 static constexpr inline auto registers(); 1364}; 1365 1366class ConstructWithSpreadDescriptor 1367 : public StaticCallInterfaceDescriptor<ConstructWithSpreadDescriptor> { 1368 public: 1369 DEFINE_JS_PARAMETERS(kSpread) 1370 DEFINE_JS_PARAMETER_TYPES(MachineType::AnyTagged()) 1371 DECLARE_DESCRIPTOR(ConstructWithSpreadDescriptor) 1372 1373 static constexpr inline auto registers(); 1374}; 1375 1376class ConstructWithSpread_BaselineDescriptor 1377 : public StaticCallInterfaceDescriptor< 1378 ConstructWithSpread_BaselineDescriptor> { 1379 public: 1380 // Note: kSlot comes before kSpread since as an untagged value it must be 1381 // passed in a register. 1382 DEFINE_JS_PARAMETERS_NO_CONTEXT(kSlot, kSpread) 1383 DEFINE_JS_PARAMETER_TYPES(MachineType::UintPtr(), // kSlot 1384 MachineType::AnyTagged()) // kSpread 1385 DECLARE_DESCRIPTOR(ConstructWithSpread_BaselineDescriptor) 1386}; 1387 1388class ConstructWithSpread_WithFeedbackDescriptor 1389 : public StaticCallInterfaceDescriptor< 1390 ConstructWithSpread_WithFeedbackDescriptor> { 1391 public: 1392 // Note: kSlot comes before kSpread since as an untagged value it must be 1393 // passed in a register. 1394 DEFINE_JS_PARAMETERS(kSlot, kSpread, kFeedbackVector) 1395 DEFINE_JS_PARAMETER_TYPES(MachineType::UintPtr(), // kSlot 1396 MachineType::AnyTagged(), // kSpread 1397 MachineType::AnyTagged()) // kFeedbackVector 1398 DECLARE_DESCRIPTOR(ConstructWithSpread_WithFeedbackDescriptor) 1399}; 1400 1401class ConstructWithArrayLikeDescriptor 1402 : public StaticCallInterfaceDescriptor<ConstructWithArrayLikeDescriptor> { 1403 public: 1404 DEFINE_PARAMETERS(kTarget, kNewTarget, kArgumentsList) 1405 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kTarget 1406 MachineType::AnyTagged(), // kNewTarget 1407 MachineType::AnyTagged()) // kArgumentsList 1408 DECLARE_DESCRIPTOR(ConstructWithArrayLikeDescriptor) 1409 1410 static constexpr inline auto registers(); 1411}; 1412 1413class ConstructWithArrayLike_WithFeedbackDescriptor 1414 : public StaticCallInterfaceDescriptor< 1415 ConstructWithArrayLike_WithFeedbackDescriptor> { 1416 public: 1417 DEFINE_PARAMETERS(kTarget, kNewTarget, kArgumentsList, kSlot, kFeedbackVector) 1418 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kTarget 1419 MachineType::AnyTagged(), // kNewTarget 1420 MachineType::AnyTagged(), // kArgumentsList 1421 MachineType::UintPtr(), // kSlot 1422 MachineType::AnyTagged()) // kFeedbackVector 1423 DECLARE_DESCRIPTOR(ConstructWithArrayLike_WithFeedbackDescriptor) 1424}; 1425 1426// TODO(ishell): consider merging this with ArrayConstructorDescriptor 1427class ConstructStubDescriptor 1428 : public StaticCallInterfaceDescriptor<ConstructStubDescriptor> { 1429 public: 1430 // TODO(jgruber): Remove the unused allocation site parameter. 1431 DEFINE_JS_PARAMETERS(kAllocationSite) 1432 DEFINE_JS_PARAMETER_TYPES(MachineType::AnyTagged()) 1433 1434 // TODO(ishell): Use DECLARE_JS_COMPATIBLE_DESCRIPTOR if registers match 1435 DECLARE_DESCRIPTOR(ConstructStubDescriptor) 1436 1437 static constexpr inline auto registers(); 1438}; 1439 1440class AbortDescriptor : public StaticCallInterfaceDescriptor<AbortDescriptor> { 1441 public: 1442 DEFINE_PARAMETERS_NO_CONTEXT(kMessageOrMessageId) 1443 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged()) 1444 DECLARE_DESCRIPTOR(AbortDescriptor) 1445 1446 static constexpr inline auto registers(); 1447}; 1448 1449class ArrayConstructorDescriptor 1450 : public StaticJSCallInterfaceDescriptor<ArrayConstructorDescriptor> { 1451 public: 1452 DEFINE_JS_PARAMETERS(kAllocationSite) 1453 DEFINE_JS_PARAMETER_TYPES(MachineType::AnyTagged()) 1454 1455 DECLARE_JS_COMPATIBLE_DESCRIPTOR(ArrayConstructorDescriptor) 1456}; 1457 1458class ArrayNArgumentsConstructorDescriptor 1459 : public StaticCallInterfaceDescriptor< 1460 ArrayNArgumentsConstructorDescriptor> { 1461 public: 1462 // This descriptor declares only register arguments while respective number 1463 // of JS arguments stay on the expression stack. 1464 // The ArrayNArgumentsConstructor builtin does not access stack arguments 1465 // directly it just forwards them to the runtime function. 1466 DEFINE_PARAMETERS(kFunction, kAllocationSite, kActualArgumentsCount) 1467 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kFunction, 1468 MachineType::AnyTagged(), // kAllocationSite 1469 MachineType::Int32()) // kActualArgumentsCount 1470 DECLARE_DESCRIPTOR(ArrayNArgumentsConstructorDescriptor) 1471 1472 static constexpr auto registers(); 1473}; 1474 1475class ArrayNoArgumentConstructorDescriptor 1476 : public StaticCallInterfaceDescriptor< 1477 ArrayNoArgumentConstructorDescriptor> { 1478 public: 1479 // This descriptor declares same register arguments as the parent 1480 // ArrayNArgumentsConstructorDescriptor and it declares indices for 1481 // JS arguments passed on the expression stack. 1482 DEFINE_PARAMETERS(kFunction, kAllocationSite, kActualArgumentsCount, 1483 kFunctionParameter) 1484 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kFunction 1485 MachineType::AnyTagged(), // kAllocationSite 1486 MachineType::Int32(), // kActualArgumentsCount 1487 MachineType::AnyTagged()) // kFunctionParameter 1488 DECLARE_DESCRIPTOR(ArrayNoArgumentConstructorDescriptor) 1489 1490 static constexpr auto registers(); 1491}; 1492 1493class ArraySingleArgumentConstructorDescriptor 1494 : public StaticCallInterfaceDescriptor< 1495 ArraySingleArgumentConstructorDescriptor> { 1496 public: 1497 // This descriptor declares same register arguments as the parent 1498 // ArrayNArgumentsConstructorDescriptor and it declares indices for 1499 // JS arguments passed on the expression stack. 1500 DEFINE_PARAMETERS(kFunction, kAllocationSite, kActualArgumentsCount, 1501 kArraySizeSmiParameter, kReceiverParameter) 1502 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kFunction 1503 MachineType::AnyTagged(), // kAllocationSite 1504 MachineType::Int32(), // kActualArgumentsCount 1505 // JS arguments on the stack 1506 MachineType::AnyTagged(), // kArraySizeSmiParameter 1507 MachineType::AnyTagged()) // kReceiverParameter 1508 DECLARE_DESCRIPTOR(ArraySingleArgumentConstructorDescriptor) 1509 1510 static constexpr auto registers(); 1511}; 1512 1513class CompareDescriptor 1514 : public StaticCallInterfaceDescriptor<CompareDescriptor> { 1515 public: 1516 DEFINE_PARAMETERS(kLeft, kRight) 1517 DECLARE_DESCRIPTOR(CompareDescriptor) 1518 1519 static constexpr inline auto registers(); 1520}; 1521 1522class BinaryOpDescriptor 1523 : public StaticCallInterfaceDescriptor<BinaryOpDescriptor> { 1524 public: 1525 DEFINE_PARAMETERS(kLeft, kRight) 1526 DECLARE_DESCRIPTOR(BinaryOpDescriptor) 1527 1528 static constexpr inline auto registers(); 1529}; 1530 1531class BinaryOp_BaselineDescriptor 1532 : public StaticCallInterfaceDescriptor<BinaryOp_BaselineDescriptor> { 1533 public: 1534 DEFINE_PARAMETERS_NO_CONTEXT(kLeft, kRight, kSlot) 1535 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kLeft 1536 MachineType::AnyTagged(), // kRight 1537 MachineType::UintPtr()) // kSlot 1538 DECLARE_DESCRIPTOR(BinaryOp_BaselineDescriptor) 1539 1540 static constexpr inline auto registers(); 1541}; 1542 1543class BinarySmiOp_BaselineDescriptor 1544 : public StaticCallInterfaceDescriptor<BinarySmiOp_BaselineDescriptor> { 1545 public: 1546 DEFINE_PARAMETERS_NO_CONTEXT(kLeft, kRight, kSlot) 1547 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kLeft 1548 MachineType::TaggedSigned(), // kRight 1549 MachineType::UintPtr()) // kSlot 1550 DECLARE_DESCRIPTOR(BinarySmiOp_BaselineDescriptor) 1551 1552 static constexpr inline auto registers(); 1553}; 1554 1555class StringAtAsStringDescriptor final 1556 : public StaticCallInterfaceDescriptor<StringAtAsStringDescriptor> { 1557 public: 1558 DEFINE_PARAMETERS(kReceiver, kPosition) 1559 // TODO(turbofan): Return untagged value here. 1560 DEFINE_RESULT_AND_PARAMETER_TYPES( 1561 MachineType::TaggedPointer(), // result string 1562 MachineType::AnyTagged(), // kReceiver 1563 MachineType::IntPtr()) // kPosition 1564 DECLARE_DESCRIPTOR(StringAtAsStringDescriptor) 1565}; 1566 1567class StringSubstringDescriptor final 1568 : public StaticCallInterfaceDescriptor<StringSubstringDescriptor> { 1569 public: 1570 DEFINE_PARAMETERS(kString, kFrom, kTo) 1571 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kString 1572 MachineType::IntPtr(), // kFrom 1573 MachineType::IntPtr()) // kTo 1574 1575 // TODO(turbofan): Allow builtins to return untagged values. 1576 DECLARE_DESCRIPTOR(StringSubstringDescriptor) 1577}; 1578 1579class CppBuiltinAdaptorDescriptor 1580 : public StaticJSCallInterfaceDescriptor<CppBuiltinAdaptorDescriptor> { 1581 public: 1582 DEFINE_JS_PARAMETERS(kCFunction) 1583 DEFINE_JS_PARAMETER_TYPES(MachineType::Pointer()) 1584 DECLARE_JS_COMPATIBLE_DESCRIPTOR(CppBuiltinAdaptorDescriptor) 1585}; 1586 1587class CEntry1ArgvOnStackDescriptor 1588 : public StaticCallInterfaceDescriptor<CEntry1ArgvOnStackDescriptor> { 1589 public: 1590 DEFINE_PARAMETERS(kArity, // register argument 1591 kCFunction, // register argument 1592 kPadding, // stack argument 1 (just padding) 1593 kArgcSmi, // stack argument 2 1594 kTargetCopy, // stack argument 3 1595 kNewTargetCopy) // stack argument 4 1596 DEFINE_PARAMETER_TYPES(MachineType::Int32(), // kArity 1597 MachineType::Pointer(), // kCFunction 1598 MachineType::AnyTagged(), // kPadding 1599 MachineType::AnyTagged(), // kArgcSmi 1600 MachineType::AnyTagged(), // kTargetCopy 1601 MachineType::AnyTagged()) // kNewTargetCopy 1602 DECLARE_DESCRIPTOR(CEntry1ArgvOnStackDescriptor) 1603 1604 static constexpr auto registers(); 1605}; 1606 1607class ApiCallbackDescriptor 1608 : public StaticCallInterfaceDescriptor<ApiCallbackDescriptor> { 1609 public: 1610 DEFINE_PARAMETERS_VARARGS(kApiFunctionAddress, kActualArgumentsCount, 1611 kCallData, kHolder) 1612 // receiver is implicit stack argument 1 1613 // argv are implicit stack arguments [2, 2 + kArgc[ 1614 DEFINE_PARAMETER_TYPES(MachineType::Pointer(), // kApiFunctionAddress 1615 MachineType::IntPtr(), // kActualArgumentsCount 1616 MachineType::AnyTagged(), // kCallData 1617 MachineType::AnyTagged()) // kHolder 1618 DECLARE_DESCRIPTOR(ApiCallbackDescriptor) 1619 1620 static constexpr inline auto registers(); 1621}; 1622 1623class ApiGetterDescriptor 1624 : public StaticCallInterfaceDescriptor<ApiGetterDescriptor> { 1625 public: 1626 DEFINE_PARAMETERS(kReceiver, kHolder, kCallback) 1627 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kReceiver 1628 MachineType::AnyTagged(), // kHolder 1629 MachineType::AnyTagged()) // kCallback 1630 DECLARE_DESCRIPTOR(ApiGetterDescriptor) 1631 1632 static constexpr inline Register ReceiverRegister(); 1633 static constexpr inline Register HolderRegister(); 1634 static constexpr inline Register CallbackRegister(); 1635 1636 static constexpr auto registers(); 1637}; 1638 1639// TODO(turbofan): We should probably rename this to GrowFastElementsDescriptor. 1640class GrowArrayElementsDescriptor 1641 : public StaticCallInterfaceDescriptor<GrowArrayElementsDescriptor> { 1642 public: 1643 DEFINE_PARAMETERS(kObject, kKey) 1644 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kObject 1645 MachineType::AnyTagged()) // kKey 1646 DECLARE_DESCRIPTOR(GrowArrayElementsDescriptor) 1647 1648 static constexpr inline Register ObjectRegister(); 1649 static constexpr inline Register KeyRegister(); 1650 1651 static constexpr auto registers(); 1652}; 1653 1654class BaselineOutOfLinePrologueDescriptor 1655 : public StaticCallInterfaceDescriptor< 1656 BaselineOutOfLinePrologueDescriptor> { 1657 public: 1658 DEFINE_PARAMETERS_NO_CONTEXT(kCalleeContext, kClosure, 1659 kJavaScriptCallArgCount, kStackFrameSize, 1660 kJavaScriptCallNewTarget, 1661 kInterpreterBytecodeArray) 1662 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kCalleeContext 1663 MachineType::AnyTagged(), // kClosure 1664 MachineType::Int32(), // kJavaScriptCallArgCount 1665 MachineType::Int32(), // kStackFrameSize 1666 MachineType::AnyTagged(), // kJavaScriptCallNewTarget 1667 MachineType::AnyTagged()) // kInterpreterBytecodeArray 1668 DECLARE_DESCRIPTOR(BaselineOutOfLinePrologueDescriptor) 1669 1670 static constexpr inline auto registers(); 1671 1672 // We pass the context manually, so we have one extra register. 1673 static constexpr int kMaxRegisterParams = 1674 StaticCallInterfaceDescriptor::kMaxRegisterParams + 1; 1675}; 1676 1677class BaselineLeaveFrameDescriptor 1678 : public StaticCallInterfaceDescriptor<BaselineLeaveFrameDescriptor> { 1679 public: 1680 DEFINE_PARAMETERS_NO_CONTEXT(kParamsSize, kWeight) 1681 DEFINE_PARAMETER_TYPES(MachineType::Int32(), // kParamsSize 1682 MachineType::Int32()) // kWeight 1683 DECLARE_DESCRIPTOR(BaselineLeaveFrameDescriptor) 1684 1685 static constexpr inline Register ParamsSizeRegister(); 1686 static constexpr inline Register WeightRegister(); 1687 1688 static constexpr inline auto registers(); 1689}; 1690 1691class V8_EXPORT_PRIVATE InterpreterDispatchDescriptor 1692 : public StaticCallInterfaceDescriptor<InterpreterDispatchDescriptor> { 1693 public: 1694 DEFINE_PARAMETERS(kAccumulator, kBytecodeOffset, kBytecodeArray, 1695 kDispatchTable) 1696 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kAccumulator 1697 MachineType::IntPtr(), // kBytecodeOffset 1698 MachineType::AnyTagged(), // kBytecodeArray 1699 MachineType::IntPtr()) // kDispatchTable 1700 DECLARE_DESCRIPTOR(InterpreterDispatchDescriptor) 1701 1702 static constexpr inline auto registers(); 1703}; 1704 1705class InterpreterPushArgsThenCallDescriptor 1706 : public StaticCallInterfaceDescriptor< 1707 InterpreterPushArgsThenCallDescriptor> { 1708 public: 1709 DEFINE_PARAMETERS(kNumberOfArguments, kFirstArgument, kFunction) 1710 DEFINE_PARAMETER_TYPES(MachineType::Int32(), // kNumberOfArguments 1711 MachineType::Pointer(), // kFirstArgument 1712 MachineType::AnyTagged()) // kFunction 1713 DECLARE_DESCRIPTOR(InterpreterPushArgsThenCallDescriptor) 1714 1715 static constexpr inline auto registers(); 1716}; 1717 1718class InterpreterPushArgsThenConstructDescriptor 1719 : public StaticCallInterfaceDescriptor< 1720 InterpreterPushArgsThenConstructDescriptor> { 1721 public: 1722 DEFINE_PARAMETERS(kNumberOfArguments, kFirstArgument, kConstructor, 1723 kNewTarget, kFeedbackElement) 1724 DEFINE_PARAMETER_TYPES(MachineType::Int32(), // kNumberOfArguments 1725 MachineType::Pointer(), // kFirstArgument 1726 MachineType::AnyTagged(), // kConstructor 1727 MachineType::AnyTagged(), // kNewTarget 1728 MachineType::AnyTagged()) // kFeedbackElement 1729 DECLARE_DESCRIPTOR(InterpreterPushArgsThenConstructDescriptor) 1730 1731 static constexpr inline auto registers(); 1732}; 1733 1734class InterpreterCEntry1Descriptor 1735 : public StaticCallInterfaceDescriptor<InterpreterCEntry1Descriptor> { 1736 public: 1737 DEFINE_RESULT_AND_PARAMETERS(1, kNumberOfArguments, kFirstArgument, 1738 kFunctionEntry) 1739 DEFINE_RESULT_AND_PARAMETER_TYPES(MachineType::AnyTagged(), // result 1 1740 MachineType::Int32(), // kNumberOfArguments 1741 MachineType::Pointer(), // kFirstArgument 1742 MachineType::Pointer()) // kFunctionEntry 1743 DECLARE_DESCRIPTOR(InterpreterCEntry1Descriptor) 1744 1745 static constexpr auto registers(); 1746}; 1747 1748class InterpreterCEntry2Descriptor 1749 : public StaticCallInterfaceDescriptor<InterpreterCEntry2Descriptor> { 1750 public: 1751 DEFINE_RESULT_AND_PARAMETERS(2, kNumberOfArguments, kFirstArgument, 1752 kFunctionEntry) 1753 DEFINE_RESULT_AND_PARAMETER_TYPES(MachineType::AnyTagged(), // result 1 1754 MachineType::AnyTagged(), // result 2 1755 MachineType::Int32(), // kNumberOfArguments 1756 MachineType::Pointer(), // kFirstArgument 1757 MachineType::Pointer()) // kFunctionEntry 1758 DECLARE_DESCRIPTOR(InterpreterCEntry2Descriptor) 1759 1760 static constexpr auto registers(); 1761}; 1762 1763class ForInPrepareDescriptor 1764 : public StaticCallInterfaceDescriptor<ForInPrepareDescriptor> { 1765 public: 1766 DEFINE_RESULT_AND_PARAMETERS(2, kEnumerator, kVectorIndex, kFeedbackVector) 1767 DEFINE_RESULT_AND_PARAMETER_TYPES( 1768 MachineType::AnyTagged(), // result 1 (cache array) 1769 MachineType::AnyTagged(), // result 2 (cache length) 1770 MachineType::AnyTagged(), // kEnumerator 1771 MachineType::TaggedSigned(), // kVectorIndex 1772 MachineType::AnyTagged()) // kFeedbackVector 1773 DECLARE_DESCRIPTOR(ForInPrepareDescriptor) 1774}; 1775 1776class ResumeGeneratorDescriptor final 1777 : public StaticCallInterfaceDescriptor<ResumeGeneratorDescriptor> { 1778 public: 1779 DEFINE_PARAMETERS(kValue, kGenerator) 1780 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kValue 1781 MachineType::AnyTagged()) // kGenerator 1782 DECLARE_DESCRIPTOR(ResumeGeneratorDescriptor) 1783 1784 static constexpr inline auto registers(); 1785}; 1786 1787class ResumeGeneratorBaselineDescriptor final 1788 : public StaticCallInterfaceDescriptor<ResumeGeneratorBaselineDescriptor> { 1789 public: 1790 DEFINE_PARAMETERS_NO_CONTEXT(kGeneratorObject, kRegisterCount) 1791 DEFINE_RESULT_AND_PARAMETER_TYPES( 1792 MachineType::TaggedSigned(), // return type 1793 MachineType::AnyTagged(), // kGeneratorObject 1794 MachineType::IntPtr(), // kRegisterCount 1795 ) 1796 DECLARE_DESCRIPTOR(ResumeGeneratorBaselineDescriptor) 1797}; 1798 1799class SuspendGeneratorBaselineDescriptor final 1800 : public StaticCallInterfaceDescriptor<SuspendGeneratorBaselineDescriptor> { 1801 public: 1802 DEFINE_PARAMETERS_NO_CONTEXT(kGeneratorObject, kSuspendId, kBytecodeOffset, 1803 kRegisterCount) 1804 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kGeneratorObject 1805 MachineType::IntPtr(), // kSuspendId 1806 MachineType::IntPtr(), // kBytecodeOffset 1807 MachineType::IntPtr(), // kRegisterCount 1808 ) 1809 DECLARE_DESCRIPTOR(SuspendGeneratorBaselineDescriptor) 1810}; 1811 1812class RunMicrotasksEntryDescriptor final 1813 : public StaticCallInterfaceDescriptor<RunMicrotasksEntryDescriptor> { 1814 public: 1815 DEFINE_PARAMETERS_ENTRY(kRootRegisterValue, kMicrotaskQueue) 1816 DEFINE_PARAMETER_TYPES(MachineType::Pointer(), // kRootRegisterValue 1817 MachineType::Pointer()) // kMicrotaskQueue 1818 DECLARE_DESCRIPTOR(RunMicrotasksEntryDescriptor) 1819 1820 static constexpr inline auto registers(); 1821}; 1822 1823class RunMicrotasksDescriptor final 1824 : public StaticCallInterfaceDescriptor<RunMicrotasksDescriptor> { 1825 public: 1826 DEFINE_PARAMETERS(kMicrotaskQueue) 1827 DEFINE_PARAMETER_TYPES(MachineType::Pointer()) 1828 DECLARE_DESCRIPTOR(RunMicrotasksDescriptor) 1829 1830 static constexpr inline Register MicrotaskQueueRegister(); 1831}; 1832 1833class WasmFloat32ToNumberDescriptor final 1834 : public StaticCallInterfaceDescriptor<WasmFloat32ToNumberDescriptor> { 1835 public: 1836 DEFINE_PARAMETERS_NO_CONTEXT(kValue) 1837 DEFINE_RESULT_AND_PARAMETER_TYPES(MachineType::AnyTagged(), // result 1838 MachineType::Float32()) // value 1839 DECLARE_DESCRIPTOR(WasmFloat32ToNumberDescriptor) 1840 1841#if V8_TARGET_ARCH_IA32 1842 // We need a custom descriptor on ia32 to avoid using xmm0. 1843 static constexpr inline auto registers(); 1844#endif 1845}; 1846 1847class WasmFloat64ToNumberDescriptor final 1848 : public StaticCallInterfaceDescriptor<WasmFloat64ToNumberDescriptor> { 1849 public: 1850 DEFINE_PARAMETERS_NO_CONTEXT(kValue) 1851 DEFINE_RESULT_AND_PARAMETER_TYPES(MachineType::AnyTagged(), // result 1852 MachineType::Float64()) // value 1853 DECLARE_DESCRIPTOR(WasmFloat64ToNumberDescriptor) 1854 1855#if V8_TARGET_ARCH_IA32 1856 // We need a custom descriptor on ia32 to avoid using xmm0. 1857 static constexpr inline auto registers(); 1858#endif 1859}; 1860 1861class WasmSuspendDescriptor final 1862 : public StaticCallInterfaceDescriptor<WasmSuspendDescriptor> { 1863 public: 1864 DEFINE_RESULT_AND_PARAMETERS_NO_CONTEXT(1, kArg0, kArg1) 1865 DEFINE_RESULT_AND_PARAMETER_TYPES(MachineType::AnyTagged(), // result 1866 MachineType::AnyTagged(), // value 1867 MachineType::AnyTagged()) // value 1868 DECLARE_DESCRIPTOR(WasmSuspendDescriptor) 1869}; 1870 1871class V8_EXPORT_PRIVATE I64ToBigIntDescriptor final 1872 : public StaticCallInterfaceDescriptor<I64ToBigIntDescriptor> { 1873 public: 1874 DEFINE_PARAMETERS_NO_CONTEXT(kArgument) 1875 DEFINE_PARAMETER_TYPES(MachineType::Int64()) // kArgument 1876 DECLARE_DESCRIPTOR(I64ToBigIntDescriptor) 1877}; 1878 1879// 32 bits version of the I64ToBigIntDescriptor call interface descriptor 1880class V8_EXPORT_PRIVATE I32PairToBigIntDescriptor final 1881 : public StaticCallInterfaceDescriptor<I32PairToBigIntDescriptor> { 1882 public: 1883 DEFINE_PARAMETERS_NO_CONTEXT(kLow, kHigh) 1884 DEFINE_PARAMETER_TYPES(MachineType::Uint32(), // kLow 1885 MachineType::Uint32()) // kHigh 1886 DECLARE_DESCRIPTOR(I32PairToBigIntDescriptor) 1887}; 1888 1889class V8_EXPORT_PRIVATE BigIntToI64Descriptor final 1890 : public StaticCallInterfaceDescriptor<BigIntToI64Descriptor> { 1891 public: 1892 DEFINE_PARAMETERS(kArgument) 1893 DEFINE_RESULT_AND_PARAMETER_TYPES(MachineType::Int64(), // result 1 1894 MachineType::AnyTagged()) // kArgument 1895 DECLARE_DESCRIPTOR(BigIntToI64Descriptor) 1896}; 1897 1898class V8_EXPORT_PRIVATE BigIntToI32PairDescriptor final 1899 : public StaticCallInterfaceDescriptor<BigIntToI32PairDescriptor> { 1900 public: 1901 DEFINE_RESULT_AND_PARAMETERS(2, kArgument) 1902 DEFINE_RESULT_AND_PARAMETER_TYPES(MachineType::Uint32(), // result 1 1903 MachineType::Uint32(), // result 2 1904 MachineType::AnyTagged()) // kArgument 1905 DECLARE_DESCRIPTOR(BigIntToI32PairDescriptor) 1906}; 1907 1908class WasmI32AtomicWait32Descriptor final 1909 : public StaticCallInterfaceDescriptor<WasmI32AtomicWait32Descriptor> { 1910 public: 1911 DEFINE_PARAMETERS_NO_CONTEXT(kAddress, kExpectedValue, kTimeoutLow, 1912 kTimeoutHigh) 1913 DEFINE_RESULT_AND_PARAMETER_TYPES(MachineType::Uint32(), // result 1 1914 MachineType::Uint32(), // kAddress 1915 MachineType::Int32(), // kExpectedValue 1916 MachineType::Uint32(), // kTimeoutLow 1917 MachineType::Uint32()) // kTimeoutHigh 1918 DECLARE_DESCRIPTOR(WasmI32AtomicWait32Descriptor) 1919}; 1920 1921class WasmI64AtomicWait32Descriptor final 1922 : public StaticCallInterfaceDescriptor<WasmI64AtomicWait32Descriptor> { 1923 public: 1924 DEFINE_PARAMETERS_NO_CONTEXT(kAddress, kExpectedValueLow, kExpectedValueHigh, 1925 kTimeoutLow, kTimeoutHigh) 1926 1927 static constexpr bool kNoStackScan = true; 1928 1929 DEFINE_RESULT_AND_PARAMETER_TYPES( 1930 MachineType::Uint32(), // result 1 1931 MachineType::Uint32(), // kAddress 1932 MachineType::Uint32(), // kExpectedValueLow 1933 MachineType::Uint32(), // kExpectedValueHigh 1934 MachineType::Uint32(), // kTimeoutLow 1935 MachineType::Uint32()) // kTimeoutHigh 1936 1937 DECLARE_DESCRIPTOR(WasmI64AtomicWait32Descriptor) 1938}; 1939 1940class CloneObjectWithVectorDescriptor final 1941 : public StaticCallInterfaceDescriptor<CloneObjectWithVectorDescriptor> { 1942 public: 1943 DEFINE_PARAMETERS(kSource, kFlags, kSlot, kVector) 1944 DEFINE_RESULT_AND_PARAMETER_TYPES(MachineType::TaggedPointer(), // result 1 1945 MachineType::AnyTagged(), // kSource 1946 MachineType::TaggedSigned(), // kFlags 1947 MachineType::TaggedSigned(), // kSlot 1948 MachineType::AnyTagged()) // kVector 1949 DECLARE_DESCRIPTOR(CloneObjectWithVectorDescriptor) 1950}; 1951 1952class CloneObjectBaselineDescriptor final 1953 : public StaticCallInterfaceDescriptor<CloneObjectBaselineDescriptor> { 1954 public: 1955 DEFINE_PARAMETERS_NO_CONTEXT(kSource, kFlags, kSlot) 1956 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kSource 1957 MachineType::TaggedSigned(), // kFlags 1958 MachineType::TaggedSigned()) // kSlot 1959 DECLARE_DESCRIPTOR(CloneObjectBaselineDescriptor) 1960}; 1961 1962class BinaryOp_WithFeedbackDescriptor 1963 : public StaticCallInterfaceDescriptor<BinaryOp_WithFeedbackDescriptor> { 1964 public: 1965 DEFINE_PARAMETERS(kLeft, kRight, kSlot, kFeedbackVector) 1966 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kLeft 1967 MachineType::AnyTagged(), // kRight 1968 MachineType::UintPtr(), // kSlot 1969 MachineType::AnyTagged()) // kFeedbackVector 1970 DECLARE_DESCRIPTOR(BinaryOp_WithFeedbackDescriptor) 1971}; 1972 1973class CallTrampoline_Baseline_CompactDescriptor 1974 : public StaticCallInterfaceDescriptor< 1975 CallTrampoline_Baseline_CompactDescriptor> { 1976 public: 1977 using ArgumentCountField = base::BitField<uint32_t, 0, 8>; 1978 using SlotField = base::BitField<uintptr_t, 8, 24>; 1979 1980 static bool EncodeBitField(uint32_t argc, uintptr_t slot, uint32_t* out) { 1981 if (ArgumentCountField::is_valid(argc) && SlotField::is_valid(slot)) { 1982 *out = ArgumentCountField::encode(argc) | SlotField::encode(slot); 1983 return true; 1984 } 1985 return false; 1986 } 1987 1988 DEFINE_PARAMETERS_NO_CONTEXT_VARARGS(kFunction, kBitField) 1989 DEFINE_PARAMETER_TYPES( 1990 MachineType::AnyTagged(), // kFunction 1991 MachineType::Uint32()) // kBitField = ArgumentCountField | SlotField 1992 DECLARE_DESCRIPTOR(CallTrampoline_Baseline_CompactDescriptor) 1993}; 1994 1995class CallTrampoline_BaselineDescriptor 1996 : public StaticCallInterfaceDescriptor<CallTrampoline_BaselineDescriptor> { 1997 public: 1998 DEFINE_PARAMETERS_NO_CONTEXT_VARARGS(kFunction, kActualArgumentsCount, kSlot) 1999 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kFunction 2000 MachineType::Int32(), // kActualArgumentsCount 2001 MachineType::UintPtr()) // kSlot 2002 DECLARE_DESCRIPTOR(CallTrampoline_BaselineDescriptor) 2003}; 2004 2005class CallTrampoline_WithFeedbackDescriptor 2006 : public StaticCallInterfaceDescriptor< 2007 CallTrampoline_WithFeedbackDescriptor> { 2008 public: 2009 DEFINE_PARAMETERS_VARARGS(kFunction, kActualArgumentsCount, kSlot, 2010 kFeedbackVector, kReceiver) 2011 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kFunction 2012 MachineType::Int32(), // kActualArgumentsCount 2013 MachineType::UintPtr(), // kSlot 2014 MachineType::AnyTagged(), // kFeedbackVector 2015 MachineType::AnyTagged()) // kReceiver 2016 DECLARE_DESCRIPTOR(CallTrampoline_WithFeedbackDescriptor) 2017}; 2018 2019class Compare_WithFeedbackDescriptor 2020 : public StaticCallInterfaceDescriptor<Compare_WithFeedbackDescriptor> { 2021 public: 2022 DEFINE_PARAMETERS(kLeft, kRight, kSlot, kFeedbackVector) 2023 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kLeft 2024 MachineType::AnyTagged(), // kRight 2025 MachineType::UintPtr(), // kSlot 2026 MachineType::AnyTagged()) // kFeedbackVector 2027 DECLARE_DESCRIPTOR(Compare_WithFeedbackDescriptor) 2028}; 2029 2030class Compare_BaselineDescriptor 2031 : public StaticCallInterfaceDescriptor<Compare_BaselineDescriptor> { 2032 public: 2033 DEFINE_PARAMETERS_NO_CONTEXT(kLeft, kRight, kSlot) 2034 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kLeft 2035 MachineType::AnyTagged(), // kRight 2036 MachineType::UintPtr()) // kSlot 2037 DECLARE_DESCRIPTOR(Compare_BaselineDescriptor) 2038 2039 static constexpr inline auto registers(); 2040}; 2041 2042class Construct_BaselineDescriptor 2043 : public StaticJSCallInterfaceDescriptor<Construct_BaselineDescriptor> { 2044 public: 2045 DEFINE_JS_PARAMETERS_NO_CONTEXT(kSlot) 2046 DEFINE_JS_PARAMETER_TYPES(MachineType::UintPtr()) // kSlot 2047 DECLARE_JS_COMPATIBLE_DESCRIPTOR(Construct_BaselineDescriptor) 2048}; 2049 2050class Construct_WithFeedbackDescriptor 2051 : public StaticJSCallInterfaceDescriptor<Construct_WithFeedbackDescriptor> { 2052 public: 2053 // kSlot is passed in a register, kFeedbackVector on the stack. 2054 DEFINE_JS_PARAMETERS(kSlot, kFeedbackVector) 2055 DEFINE_JS_PARAMETER_TYPES(MachineType::UintPtr(), // kSlot 2056 MachineType::AnyTagged()) // kFeedbackVector 2057 DECLARE_JS_COMPATIBLE_DESCRIPTOR(Construct_WithFeedbackDescriptor) 2058}; 2059 2060class UnaryOp_WithFeedbackDescriptor 2061 : public StaticCallInterfaceDescriptor<UnaryOp_WithFeedbackDescriptor> { 2062 public: 2063 DEFINE_PARAMETERS(kValue, kSlot, kFeedbackVector) 2064 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kValue 2065 MachineType::UintPtr(), // kSlot 2066 MachineType::AnyTagged()) // kFeedbackVector 2067 DECLARE_DESCRIPTOR(UnaryOp_WithFeedbackDescriptor) 2068}; 2069 2070class UnaryOp_BaselineDescriptor 2071 : public StaticCallInterfaceDescriptor<UnaryOp_BaselineDescriptor> { 2072 public: 2073 DEFINE_PARAMETERS_NO_CONTEXT(kValue, kSlot) 2074 DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(), // kValue 2075 MachineType::UintPtr()) // kSlot 2076 DECLARE_DESCRIPTOR(UnaryOp_BaselineDescriptor) 2077}; 2078 2079#define DEFINE_TFS_BUILTIN_DESCRIPTOR(Name, ...) \ 2080 class Name##Descriptor \ 2081 : public StaticCallInterfaceDescriptor<Name##Descriptor> { \ 2082 public: \ 2083 DEFINE_PARAMETERS(__VA_ARGS__) \ 2084 DECLARE_DEFAULT_DESCRIPTOR(Name##Descriptor) \ 2085 }; 2086BUILTIN_LIST_TFS(DEFINE_TFS_BUILTIN_DESCRIPTOR) 2087#undef DEFINE_TFS_BUILTIN_DESCRIPTOR 2088 2089// This file contains interface descriptor class definitions for builtins 2090// defined in Torque. It is included here because the class definitions need to 2091// precede the definition of name##Descriptor::key() below. 2092#include "torque-generated/interface-descriptors.inc" 2093 2094#undef DECLARE_DEFAULT_DESCRIPTOR 2095#undef DECLARE_DESCRIPTOR_WITH_BASE 2096#undef DECLARE_DESCRIPTOR 2097#undef DECLARE_JS_COMPATIBLE_DESCRIPTOR 2098#undef DEFINE_RESULT_AND_PARAMETERS 2099#undef DEFINE_PARAMETERS_ENTRY 2100#undef DEFINE_PARAMETERS 2101#undef DEFINE_PARAMETERS_VARARGS 2102#undef DEFINE_PARAMETERS_NO_CONTEXT 2103#undef DEFINE_RESULT_AND_PARAMETERS_NO_CONTEXT 2104#undef DEFINE_RESULT_AND_PARAMETER_TYPES 2105#undef DEFINE_PARAMETER_TYPES 2106#undef DEFINE_JS_PARAMETERS 2107#undef DEFINE_JS_PARAMETER_TYPES 2108 2109// We define the association between CallDescriptors::Key and the specialized 2110// descriptor here to reduce boilerplate and mistakes. 2111#define DEF_KEY(name, ...) \ 2112 CallDescriptors::Key name##Descriptor::key() { return CallDescriptors::name; } 2113INTERFACE_DESCRIPTOR_LIST(DEF_KEY) 2114#undef DEF_KEY 2115} // namespace internal 2116} // namespace v8 2117 2118#endif // V8_CODEGEN_INTERFACE_DESCRIPTORS_H_ 2119