LCOV - code coverage report
Current view: top level - src - interface-descriptors.h (source / functions) Hit Total Coverage
Test: app.info Lines: 167 169 98.8 %
Date: 2017-04-26 Functions: 108 290 37.2 %

          Line data    Source code
       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_CALL_INTERFACE_DESCRIPTOR_H_
       6             : #define V8_CALL_INTERFACE_DESCRIPTOR_H_
       7             : 
       8             : #include <memory>
       9             : 
      10             : #include "src/assembler.h"
      11             : #include "src/globals.h"
      12             : #include "src/macro-assembler.h"
      13             : 
      14             : namespace v8 {
      15             : namespace internal {
      16             : 
      17             : class PlatformInterfaceDescriptor;
      18             : 
      19             : #define INTERFACE_DESCRIPTOR_LIST(V)       \
      20             :   V(Void)                                  \
      21             :   V(ContextOnly)                           \
      22             :   V(Load)                                  \
      23             :   V(LoadWithVector)                        \
      24             :   V(LoadField)                             \
      25             :   V(LoadICProtoArray)                      \
      26             :   V(LoadGlobal)                            \
      27             :   V(LoadGlobalWithVector)                  \
      28             :   V(Store)                                 \
      29             :   V(StoreWithVector)                       \
      30             :   V(StoreNamedTransition)                  \
      31             :   V(StoreTransition)                       \
      32             :   V(VarArgFunction)                        \
      33             :   V(FastNewClosure)                        \
      34             :   V(FastNewFunctionContext)                \
      35             :   V(FastNewObject)                         \
      36             :   V(FastNewArguments)                      \
      37             :   V(TypeConversion)                        \
      38             :   V(Typeof)                                \
      39             :   V(FastCloneRegExp)                       \
      40             :   V(FastCloneShallowArray)                 \
      41             :   V(FastCloneShallowObject)                \
      42             :   V(CreateAllocationSite)                  \
      43             :   V(CreateWeakCell)                        \
      44             :   V(CallFunction)                          \
      45             :   V(CallIC)                                \
      46             :   V(CallICTrampoline)                      \
      47             :   V(CallForwardVarargs)                    \
      48             :   V(CallConstruct)                         \
      49             :   V(CallTrampoline)                        \
      50             :   V(ConstructStub)                         \
      51             :   V(ConstructTrampoline)                   \
      52             :   V(TransitionElementsKind)                \
      53             :   V(AllocateHeapNumber)                    \
      54             :   V(Builtin)                               \
      55             :   V(ArrayConstructor)                      \
      56             :   V(IteratingArrayBuiltin)                 \
      57             :   V(IteratingArrayBuiltinLoopContinuation) \
      58             :   V(ArrayNoArgumentConstructor)            \
      59             :   V(ArraySingleArgumentConstructor)        \
      60             :   V(ArrayNArgumentsConstructor)            \
      61             :   V(Compare)                               \
      62             :   V(BinaryOp)                              \
      63             :   V(BinaryOpWithAllocationSite)            \
      64             :   V(BinaryOpWithVector)                    \
      65             :   V(CountOp)                               \
      66             :   V(StringAdd)                             \
      67             :   V(StringCharAt)                          \
      68             :   V(StringCharCodeAt)                      \
      69             :   V(StringCompare)                         \
      70             :   V(SubString)                             \
      71             :   V(ForInPrepare)                          \
      72             :   V(GetProperty)                           \
      73             :   V(ArgumentAdaptor)                       \
      74             :   V(ApiCallback)                           \
      75             :   V(ApiGetter)                             \
      76             :   V(MathPowTagged)                         \
      77             :   V(MathPowInteger)                        \
      78             :   V(GrowArrayElements)                     \
      79             :   V(NewArgumentsElements)                  \
      80             :   V(InterpreterDispatch)                   \
      81             :   V(InterpreterPushArgsThenCall)           \
      82             :   V(InterpreterPushArgsThenConstruct)      \
      83             :   V(InterpreterPushArgsThenConstructArray) \
      84             :   V(InterpreterCEntry)                     \
      85             :   V(ResumeGenerator)                       \
      86             :   V(FrameDropperTrampoline)                \
      87             :   V(WasmRuntimeCall)                       \
      88             :   BUILTIN_LIST_TFS(V)
      89             : 
      90    10315424 : class V8_EXPORT_PRIVATE CallInterfaceDescriptorData {
      91             :  public:
      92     5288034 :   CallInterfaceDescriptorData() : register_param_count_(-1), param_count_(-1) {}
      93             : 
      94             :   // A copy of the passed in registers and param_representations is made
      95             :   // and owned by the CallInterfaceDescriptorData.
      96             : 
      97             :   void InitializePlatformSpecific(
      98             :       int register_parameter_count, const Register* registers,
      99             :       PlatformInterfaceDescriptor* platform_descriptor = NULL);
     100             : 
     101             :   // if machine_types is null, then an array of size
     102             :   // (register_parameter_count + extra_parameter_count) will be created
     103             :   // with MachineType::AnyTagged() for each member.
     104             :   //
     105             :   // if machine_types is not null, then it should be of the size
     106             :   // register_parameter_count. Those members of the parameter array
     107             :   // will be initialized from {machine_types}, and the rest initialized
     108             :   // to MachineType::AnyTagged().
     109             :   void InitializePlatformIndependent(int parameter_count,
     110             :                                      int extra_parameter_count,
     111             :                                      const MachineType* machine_types);
     112             : 
     113             :   bool IsInitialized() const {
     114    15749773 :     return register_param_count_ >= 0 && param_count_ >= 0;
     115             :   }
     116             : 
     117             :   int param_count() const { return param_count_; }
     118             :   int register_param_count() const { return register_param_count_; }
     119    19504520 :   Register register_param(int index) const { return register_params_[index]; }
     120             :   Register* register_params() const { return register_params_.get(); }
     121    15181952 :   MachineType param_type(int index) const { return machine_types_[index]; }
     122             :   PlatformInterfaceDescriptor* platform_specific_descriptor() const {
     123             :     return platform_specific_descriptor_;
     124             :   }
     125             : 
     126             :  private:
     127             :   int register_param_count_;
     128             :   int param_count_;
     129             : 
     130             :   // The Register params are allocated dynamically by the
     131             :   // InterfaceDescriptor, and freed on destruction. This is because static
     132             :   // arrays of Registers cause creation of runtime static initializers
     133             :   // which we don't want.
     134             :   std::unique_ptr<Register[]> register_params_;
     135             :   std::unique_ptr<MachineType[]> machine_types_;
     136             : 
     137             :   PlatformInterfaceDescriptor* platform_specific_descriptor_;
     138             : 
     139             :   DISALLOW_COPY_AND_ASSIGN(CallInterfaceDescriptorData);
     140             : };
     141             : 
     142             : 
     143             : class CallDescriptors {
     144             :  public:
     145             :   enum Key {
     146             : #define DEF_ENUM(name, ...) name,
     147             :     INTERFACE_DESCRIPTOR_LIST(DEF_ENUM)
     148             : #undef DEF_ENUM
     149             :         NUMBER_OF_DESCRIPTORS
     150             :   };
     151             : };
     152             : 
     153    32076821 : class V8_EXPORT_PRIVATE CallInterfaceDescriptor {
     154             :  public:
     155       26647 :   CallInterfaceDescriptor() : data_(NULL) {}
     156    14520031 :   virtual ~CallInterfaceDescriptor() {}
     157             : 
     158             :   CallInterfaceDescriptor(Isolate* isolate, CallDescriptors::Key key)
     159    21043589 :       : data_(isolate->call_descriptor_data(key)) {}
     160             : 
     161     2103186 :   int GetParameterCount() const { return data()->param_count(); }
     162             : 
     163     3119251 :   int GetRegisterParameterCount() const {
     164     7111576 :     return data()->register_param_count();
     165             :   }
     166             : 
     167      242657 :   int GetStackParameterCount() const {
     168     1526190 :     return data()->param_count() - data()->register_param_count();
     169             :   }
     170             : 
     171     6416152 :   Register GetRegisterParameter(int index) const {
     172             :     return data()->register_param(index);
     173             :   }
     174             : 
     175     4350032 :   MachineType GetParameterType(int index) const {
     176             :     DCHECK(index < data()->param_count());
     177             :     return data()->param_type(index);
     178             :   }
     179             : 
     180             :   // Some platforms have extra information to associate with the descriptor.
     181             :   PlatformInterfaceDescriptor* platform_specific_descriptor() const {
     182             :     return data()->platform_specific_descriptor();
     183             :   }
     184             : 
     185             :   static const Register ContextRegister();
     186             : 
     187             :   const char* DebugName(Isolate* isolate) const;
     188             : 
     189             :  protected:
     190             :   const CallInterfaceDescriptorData* data() const { return data_; }
     191             : 
     192           0 :   virtual void InitializePlatformSpecific(CallInterfaceDescriptorData* data) {
     193           0 :     UNREACHABLE();
     194             :   }
     195             : 
     196     1905152 :   virtual void InitializePlatformIndependent(
     197     1905152 :       CallInterfaceDescriptorData* data) {
     198     1905152 :     data->InitializePlatformIndependent(data->register_param_count(), 0, NULL);
     199     1905152 :   }
     200             : 
     201    15749773 :   void Initialize(Isolate* isolate, CallDescriptors::Key key) {
     202    31499546 :     if (!data()->IsInitialized()) {
     203             :       // We should only initialize descriptors on the isolate's main thread.
     204             :       DCHECK(ThreadId::Current().Equals(isolate->thread_id()));
     205     5288034 :       CallInterfaceDescriptorData* d = isolate->call_descriptor_data(key);
     206             :       DCHECK(d == data());  // d should be a modifiable pointer to data().
     207     5288034 :       InitializePlatformSpecific(d);
     208     5288032 :       InitializePlatformIndependent(d);
     209             :     }
     210    15749772 :   }
     211             : 
     212             :   // Initializes |data| using the platform dependent default set of registers.
     213             :   // It is intended to be used for TurboFan stubs when particular set of
     214             :   // registers does not matter.
     215             :   static void DefaultInitializePlatformSpecific(
     216             :       CallInterfaceDescriptorData* data, int register_parameter_count);
     217             : 
     218             :  private:
     219             :   const CallInterfaceDescriptorData* data_;
     220             : };
     221             : 
     222             : #define DECLARE_DESCRIPTOR_WITH_BASE(name, base)           \
     223             :  public:                                                   \
     224             :   explicit name(Isolate* isolate) : base(isolate, key()) { \
     225             :     Initialize(isolate, key());                            \
     226             :   }                                                        \
     227             :   static inline CallDescriptors::Key key();
     228             : 
     229             : #define DECLARE_DEFAULT_DESCRIPTOR(name, base, parameter_count)            \
     230             :   DECLARE_DESCRIPTOR_WITH_BASE(name, base)                                 \
     231             :  protected:                                                                \
     232             :   void InitializePlatformSpecific(CallInterfaceDescriptorData* data)       \
     233             :       override {                                                           \
     234             :     DefaultInitializePlatformSpecific(data, parameter_count);              \
     235             :   }                                                                        \
     236             :   name(Isolate* isolate, CallDescriptors::Key key) : base(isolate, key) {} \
     237             :                                                                            \
     238             :  public:
     239             : 
     240             : #define DECLARE_DESCRIPTOR(name, base)                                         \
     241             :   DECLARE_DESCRIPTOR_WITH_BASE(name, base)                                     \
     242             :  protected:                                                                    \
     243             :   void InitializePlatformSpecific(CallInterfaceDescriptorData* data) override; \
     244             :   name(Isolate* isolate, CallDescriptors::Key key) : base(isolate, key) {}     \
     245             :                                                                                \
     246             :  public:
     247             : 
     248             : #define DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(name, base)        \
     249             :   DECLARE_DESCRIPTOR(name, base)                                        \
     250             :  protected:                                                             \
     251             :   void InitializePlatformIndependent(CallInterfaceDescriptorData* data) \
     252             :       override;                                                         \
     253             :                                                                         \
     254             :  public:
     255             : 
     256             : #define DECLARE_DESCRIPTOR_WITH_STACK_ARGS(name, base)                  \
     257             :   DECLARE_DESCRIPTOR_WITH_BASE(name, base)                              \
     258             :  protected:                                                             \
     259             :   void InitializePlatformIndependent(CallInterfaceDescriptorData* data) \
     260             :       override {                                                        \
     261             :     data->InitializePlatformIndependent(0, kParameterCount, NULL);      \
     262             :   }                                                                     \
     263             :   void InitializePlatformSpecific(CallInterfaceDescriptorData* data)    \
     264             :       override {                                                        \
     265             :     data->InitializePlatformSpecific(0, nullptr);                       \
     266             :   }                                                                     \
     267             :                                                                         \
     268             :  public:
     269             : 
     270             : #define DEFINE_EMPTY_PARAMETERS()                       \
     271             :   enum ParameterIndices {                               \
     272             :     kParameterCount,                                    \
     273             :     kContext = kParameterCount /* implicit parameter */ \
     274             :   };
     275             : 
     276             : #define DEFINE_PARAMETERS(...)                          \
     277             :   enum ParameterIndices {                               \
     278             :     __VA_ARGS__,                                        \
     279             :                                                         \
     280             :     kParameterCount,                                    \
     281             :     kContext = kParameterCount /* implicit parameter */ \
     282             :   };
     283             : 
     284             : #define DECLARE_BUILTIN_DESCRIPTOR(name)                                      \
     285             :   DECLARE_DESCRIPTOR_WITH_BASE(name, BuiltinDescriptor)                       \
     286             :  protected:                                                                   \
     287             :   void InitializePlatformIndependent(CallInterfaceDescriptorData* data)       \
     288             :       override {                                                              \
     289             :     MachineType machine_types[] = {MachineType::AnyTagged(),                  \
     290             :                                    MachineType::AnyTagged(),                  \
     291             :                                    MachineType::Int32()};                     \
     292             :     data->InitializePlatformIndependent(arraysize(machine_types),             \
     293             :                                         kStackParameterCount, machine_types); \
     294             :   }                                                                           \
     295             :   void InitializePlatformSpecific(CallInterfaceDescriptorData* data)          \
     296             :       override {                                                              \
     297             :     Register registers[] = {TargetRegister(), NewTargetRegister(),            \
     298             :                             ArgumentsCountRegister()};                        \
     299             :     data->InitializePlatformSpecific(arraysize(registers), registers);        \
     300             :   }                                                                           \
     301             :                                                                               \
     302             :  public:
     303             : 
     304             : #define DEFINE_BUILTIN_PARAMETERS(...)                                  \
     305             :   enum ParameterIndices {                                               \
     306             :     kReceiver,                                                          \
     307             :     kBeforeFirstStackParameter = kReceiver,                             \
     308             :     __VA_ARGS__,                                                        \
     309             :     kAfterLastStackParameter,                                           \
     310             :     kNewTarget = kAfterLastStackParameter,                              \
     311             :     kArgumentsCount,                                                    \
     312             :     kContext, /* implicit parameter */                                  \
     313             :     kParameterCount = kContext,                                         \
     314             :     kArity = kAfterLastStackParameter - kBeforeFirstStackParameter - 1, \
     315             :     kStackParameterCount = kArity + 1                                   \
     316             :   };
     317             : 
     318       60782 : class VoidDescriptor : public CallInterfaceDescriptor {
     319             :  public:
     320       60782 :   DECLARE_DESCRIPTOR(VoidDescriptor, CallInterfaceDescriptor)
     321             : };
     322             : 
     323       60782 : class ContextOnlyDescriptor : public CallInterfaceDescriptor {
     324             :  public:
     325       63286 :   DECLARE_DESCRIPTOR(ContextOnlyDescriptor, CallInterfaceDescriptor)
     326             : };
     327             : 
     328             : // LoadDescriptor is used by all stubs that implement Load/KeyedLoad ICs.
     329      183894 : class LoadDescriptor : public CallInterfaceDescriptor {
     330             :  public:
     331             :   DEFINE_PARAMETERS(kReceiver, kName, kSlot)
     332     5362616 :   DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(LoadDescriptor,
     333             :                                                CallInterfaceDescriptor)
     334             : 
     335             :   static const Register ReceiverRegister();
     336             :   static const Register NameRegister();
     337             :   static const Register SlotRegister();
     338             : };
     339             : 
     340             : // LoadFieldDescriptor is used by the shared handler that loads a field from an
     341             : // object based on the smi-encoded field description.
     342       60825 : class LoadFieldDescriptor : public CallInterfaceDescriptor {
     343             :  public:
     344             :   DEFINE_PARAMETERS(kReceiver, kSmiHandler)
     345       60868 :   DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(LoadFieldDescriptor,
     346             :                                                CallInterfaceDescriptor)
     347             : 
     348             :   static const Register ReceiverRegister();
     349             :   static const Register SmiHandlerRegister();
     350             : };
     351             : 
     352      121822 : class LoadGlobalDescriptor : public CallInterfaceDescriptor {
     353             :  public:
     354             :   DEFINE_PARAMETERS(kName, kSlot)
     355     1998434 :   DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(LoadGlobalDescriptor,
     356             :                                                CallInterfaceDescriptor)
     357             : 
     358             :   static const Register NameRegister() {
     359      121564 :     return LoadDescriptor::NameRegister();
     360             :   }
     361             : 
     362             :   static const Register SlotRegister() {
     363      936129 :     return LoadDescriptor::SlotRegister();
     364             :   }
     365             : };
     366             : 
     367      244117 : class StoreDescriptor : public CallInterfaceDescriptor {
     368             :  public:
     369             :   DEFINE_PARAMETERS(kReceiver, kName, kValue, kSlot)
     370     3374854 :   DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(StoreDescriptor,
     371             :                                                CallInterfaceDescriptor)
     372             : 
     373             :   static const Register ReceiverRegister();
     374             :   static const Register NameRegister();
     375             :   static const Register ValueRegister();
     376             :   static const Register SlotRegister();
     377             : 
     378             : #if V8_TARGET_ARCH_IA32 || V8_TARGET_ARCH_X87
     379             :   static const bool kPassLastArgsOnStack = true;
     380             : #else
     381             :   static const bool kPassLastArgsOnStack = false;
     382             : #endif
     383             : 
     384             :   // Pass value and slot through the stack.
     385             :   static const int kStackArgumentsCount = kPassLastArgsOnStack ? 2 : 0;
     386             : };
     387             : 
     388      121650 : class StoreTransitionDescriptor : public StoreDescriptor {
     389             :  public:
     390             :   DEFINE_PARAMETERS(kReceiver, kName, kMap, kValue, kSlot, kVector)
     391      126012 :   DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(StoreTransitionDescriptor,
     392             :                                                StoreDescriptor)
     393             : 
     394             :   static const Register MapRegister();
     395             :   static const Register SlotRegister();
     396             :   static const Register VectorRegister();
     397             : 
     398             :   // Pass value, slot and vector through the stack.
     399             :   static const int kStackArgumentsCount = kPassLastArgsOnStack ? 3 : 0;
     400             : };
     401             : 
     402       60782 : class StoreNamedTransitionDescriptor : public StoreTransitionDescriptor {
     403             :  public:
     404             :   DEFINE_PARAMETERS(kReceiver, kFieldOffset, kMap, kValue, kSlot, kVector,
     405             :                     kName)
     406       60782 :   DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(StoreNamedTransitionDescriptor,
     407             :                                                StoreTransitionDescriptor)
     408             : 
     409             :   // Always pass name on the stack.
     410             :   static const bool kPassLastArgsOnStack = true;
     411             :   static const int kStackArgumentsCount =
     412             :       StoreTransitionDescriptor::kStackArgumentsCount + 1;
     413             : 
     414             :   static const Register NameRegister() { return no_reg; }
     415             :   static const Register FieldOffsetRegister() {
     416       60782 :     return StoreTransitionDescriptor::NameRegister();
     417             :   }
     418             : };
     419             : 
     420       61513 : class StoreWithVectorDescriptor : public StoreDescriptor {
     421             :  public:
     422             :   DEFINE_PARAMETERS(kReceiver, kName, kValue, kSlot, kVector)
     423      273834 :   DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(StoreWithVectorDescriptor,
     424             :                                                StoreDescriptor)
     425             : 
     426             :   static const Register VectorRegister();
     427             : 
     428             :   // Pass value, slot and vector through the stack.
     429             :   static const int kStackArgumentsCount = kPassLastArgsOnStack ? 3 : 0;
     430             : };
     431             : 
     432      123026 : class LoadWithVectorDescriptor : public LoadDescriptor {
     433             :  public:
     434             :   DEFINE_PARAMETERS(kReceiver, kName, kSlot, kVector)
     435      823895 :   DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(LoadWithVectorDescriptor,
     436             :                                                LoadDescriptor)
     437             : 
     438             :   static const Register VectorRegister();
     439             : };
     440             : 
     441       60868 : class LoadICProtoArrayDescriptor : public LoadWithVectorDescriptor {
     442             :  public:
     443             :   DEFINE_PARAMETERS(kReceiver, kName, kSlot, kVector, kHandler)
     444       62760 :   DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(LoadICProtoArrayDescriptor,
     445             :                                                LoadWithVectorDescriptor)
     446             : 
     447             :   static const Register HandlerRegister();
     448             : };
     449             : 
     450       60954 : class LoadGlobalWithVectorDescriptor : public LoadGlobalDescriptor {
     451             :  public:
     452             :   DEFINE_PARAMETERS(kName, kSlot, kVector)
     453      170598 :   DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(LoadGlobalWithVectorDescriptor,
     454             :                                                LoadGlobalDescriptor)
     455             : 
     456             :   static const Register VectorRegister() {
     457       60782 :     return LoadWithVectorDescriptor::VectorRegister();
     458             :   }
     459             : };
     460             : 
     461       60825 : class FastNewClosureDescriptor : public CallInterfaceDescriptor {
     462             :  public:
     463             :   DEFINE_PARAMETERS(kSharedFunctionInfo, kVector, kSlot)
     464      793094 :   DECLARE_DESCRIPTOR(FastNewClosureDescriptor, CallInterfaceDescriptor)
     465             : };
     466             : 
     467       60868 : class FastNewFunctionContextDescriptor : public CallInterfaceDescriptor {
     468             :  public:
     469             :   DEFINE_PARAMETERS(kFunction, kSlots)
     470      151608 :   DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(FastNewFunctionContextDescriptor,
     471             :                                                CallInterfaceDescriptor)
     472             : 
     473             :   static const Register FunctionRegister();
     474             :   static const Register SlotsRegister();
     475             : };
     476             : 
     477       60825 : class FastNewObjectDescriptor : public CallInterfaceDescriptor {
     478             :  public:
     479             :   DEFINE_PARAMETERS(kTarget, kNewTarget)
     480       61328 :   DECLARE_DESCRIPTOR(FastNewObjectDescriptor, CallInterfaceDescriptor)
     481             :   static const Register TargetRegister();
     482             :   static const Register NewTargetRegister();
     483             : };
     484             : 
     485       60911 : class FastNewArgumentsDescriptor : public CallInterfaceDescriptor {
     486             :  public:
     487             :   DEFINE_PARAMETERS(kFunction)
     488       68720 :   DECLARE_DESCRIPTOR(FastNewArgumentsDescriptor, CallInterfaceDescriptor)
     489             :   static const Register TargetRegister();
     490             : };
     491             : 
     492       61384 : class TypeConversionDescriptor final : public CallInterfaceDescriptor {
     493             :  public:
     494             :   DEFINE_PARAMETERS(kArgument)
     495      454304 :   DECLARE_DESCRIPTOR(TypeConversionDescriptor, CallInterfaceDescriptor)
     496             : 
     497             :   static const Register ArgumentRegister();
     498             : };
     499             : 
     500       60825 : class ForInPrepareDescriptor final : public CallInterfaceDescriptor {
     501             :  public:
     502             :   DEFINE_PARAMETERS(kObject)
     503      124248 :   DECLARE_DEFAULT_DESCRIPTOR(ForInPrepareDescriptor, CallInterfaceDescriptor,
     504             :                              kParameterCount)
     505             : };
     506             : 
     507       60782 : class GetPropertyDescriptor final : public CallInterfaceDescriptor {
     508             :  public:
     509             :   DEFINE_PARAMETERS(kObject, kKey)
     510      128114 :   DECLARE_DEFAULT_DESCRIPTOR(GetPropertyDescriptor, CallInterfaceDescriptor,
     511             :                              kParameterCount)
     512             : };
     513             : 
     514       60911 : class TypeofDescriptor : public CallInterfaceDescriptor {
     515             :  public:
     516             :   DEFINE_PARAMETERS(kObject)
     517      180302 :   DECLARE_DESCRIPTOR(TypeofDescriptor, CallInterfaceDescriptor)
     518             : };
     519             : 
     520             : 
     521       60825 : class FastCloneRegExpDescriptor : public CallInterfaceDescriptor {
     522             :  public:
     523             :   DEFINE_PARAMETERS(kClosure, kLiteralIndex, kPattern, kFlags)
     524      147672 :   DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(FastCloneRegExpDescriptor,
     525             :                                                CallInterfaceDescriptor)
     526             : };
     527             : 
     528             : 
     529       60868 : class FastCloneShallowArrayDescriptor : public CallInterfaceDescriptor {
     530             :  public:
     531             :   DEFINE_PARAMETERS(kClosure, kLiteralIndex, kConstantElements)
     532      245662 :   DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(FastCloneShallowArrayDescriptor,
     533             :                                                CallInterfaceDescriptor)
     534             : };
     535             : 
     536             : 
     537       61083 : class FastCloneShallowObjectDescriptor : public CallInterfaceDescriptor {
     538             :  public:
     539             :   DEFINE_PARAMETERS(kClosure, kLiteralIndex, kConstantProperties, kFlags)
     540      157350 :   DECLARE_DESCRIPTOR(FastCloneShallowObjectDescriptor, CallInterfaceDescriptor)
     541             : };
     542             : 
     543             : 
     544       60782 : class CreateAllocationSiteDescriptor : public CallInterfaceDescriptor {
     545             :  public:
     546             :   DEFINE_PARAMETERS(kVector, kSlot)
     547       60868 :   DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(CreateAllocationSiteDescriptor,
     548             :                                                CallInterfaceDescriptor)
     549             : };
     550             : 
     551             : 
     552       60782 : class CreateWeakCellDescriptor : public CallInterfaceDescriptor {
     553             :  public:
     554             :   DEFINE_PARAMETERS(kVector, kSlot, kValue)
     555       60868 :   DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(CreateWeakCellDescriptor,
     556             :                                                CallInterfaceDescriptor)
     557             : };
     558             : 
     559             : 
     560       72642 : class CallTrampolineDescriptor : public CallInterfaceDescriptor {
     561             :  public:
     562             :   DEFINE_PARAMETERS(kFunction, kActualArgumentsCount)
     563      483986 :   DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(CallTrampolineDescriptor,
     564             :                                                CallInterfaceDescriptor)
     565             : };
     566             : 
     567       60782 : class CallForwardVarargsDescriptor : public CallInterfaceDescriptor {
     568             :  public:
     569             :   DEFINE_PARAMETERS(kTarget, kStartIndex)
     570       61228 :   DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(CallForwardVarargsDescriptor,
     571             :                                                CallInterfaceDescriptor)
     572             : };
     573             : 
     574       79389 : class ConstructStubDescriptor : public CallInterfaceDescriptor {
     575             :  public:
     576             :   DEFINE_PARAMETERS(kFunction, kNewTarget, kActualArgumentsCount,
     577             :                     kAllocationSite)
     578       97996 :   DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(ConstructStubDescriptor,
     579             :                                                CallInterfaceDescriptor)
     580             : };
     581             : 
     582             : 
     583       60782 : class ConstructTrampolineDescriptor : public CallInterfaceDescriptor {
     584             :  public:
     585             :   DEFINE_PARAMETERS(kFunction, kNewTarget, kActualArgumentsCount)
     586      137954 :   DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(ConstructTrampolineDescriptor,
     587             :                                                CallInterfaceDescriptor)
     588             : };
     589             : 
     590             : 
     591       60782 : class CallFunctionDescriptor : public CallInterfaceDescriptor {
     592             :  public:
     593       60782 :   DECLARE_DESCRIPTOR(CallFunctionDescriptor, CallInterfaceDescriptor)
     594             : };
     595             : 
     596       60782 : class CallICDescriptor : public CallInterfaceDescriptor {
     597             :  public:
     598             :   DEFINE_PARAMETERS(kTarget, kActualArgumentsCount, kSlot, kVector)
     599     1374040 :   DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(CallICDescriptor,
     600             :                                                CallInterfaceDescriptor)
     601             : };
     602             : 
     603       60782 : class CallICTrampolineDescriptor : public CallInterfaceDescriptor {
     604             :  public:
     605             :   DEFINE_PARAMETERS(kTarget, kActualArgumentsCount, kSlot)
     606     2323858 :   DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(CallICTrampolineDescriptor,
     607             :                                                CallInterfaceDescriptor)
     608             : };
     609             : 
     610       60782 : class CallConstructDescriptor : public CallInterfaceDescriptor {
     611             :  public:
     612       60782 :   DECLARE_DESCRIPTOR(CallConstructDescriptor, CallInterfaceDescriptor)
     613             : };
     614             : 
     615       60782 : class TransitionElementsKindDescriptor : public CallInterfaceDescriptor {
     616             :  public:
     617             :   DEFINE_PARAMETERS(kObject, kMap)
     618       61330 :   DECLARE_DESCRIPTOR(TransitionElementsKindDescriptor, CallInterfaceDescriptor)
     619             : };
     620             : 
     621             : 
     622       60782 : class AllocateHeapNumberDescriptor : public CallInterfaceDescriptor {
     623             :  public:
     624             :   DEFINE_EMPTY_PARAMETERS()
     625       87866 :   DECLARE_DESCRIPTOR(AllocateHeapNumberDescriptor, CallInterfaceDescriptor)
     626             : };
     627             : 
     628      182346 : class BuiltinDescriptor : public CallInterfaceDescriptor {
     629             :  public:
     630             :   // TODO(ishell): Where is kFunction??
     631             :   DEFINE_PARAMETERS(kNewTarget, kArgumentsCount)
     632      182905 :   DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(BuiltinDescriptor,
     633             :                                                CallInterfaceDescriptor)
     634             :   static const Register ArgumentsCountRegister();
     635             :   static const Register NewTargetRegister();
     636             :   static const Register TargetRegister();
     637             : };
     638             : 
     639       60782 : class IteratingArrayBuiltinDescriptor : public BuiltinDescriptor {
     640             :  public:
     641             :   DEFINE_BUILTIN_PARAMETERS(kCallback, kThisArg)
     642      182346 :   DECLARE_BUILTIN_DESCRIPTOR(IteratingArrayBuiltinDescriptor)
     643             : };
     644             : 
     645       60782 : class IteratingArrayBuiltinLoopContinuationDescriptor
     646             :     : public BuiltinDescriptor {
     647             :  public:
     648             :   DEFINE_BUILTIN_PARAMETERS(kCallback, kThisArg, kArray, kObject, kInitialK,
     649             :                             kLength, kTo)
     650      182948 :   DECLARE_BUILTIN_DESCRIPTOR(IteratingArrayBuiltinLoopContinuationDescriptor)
     651             : };
     652             : 
     653       60782 : class ArrayConstructorDescriptor : public CallInterfaceDescriptor {
     654             :  public:
     655             :   DEFINE_PARAMETERS(kTarget, kNewTarget, kActualArgumentsCount, kAllocationSite)
     656      117078 :   DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(ArrayConstructorDescriptor,
     657             :                                                CallInterfaceDescriptor)
     658             : };
     659             : 
     660       60782 : class ArrayNoArgumentConstructorDescriptor : public CallInterfaceDescriptor {
     661             :  public:
     662             :   DEFINE_PARAMETERS(kFunction, kAllocationSite, kActualArgumentsCount,
     663             :                     kFunctionParameter)
     664       61642 :   DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(
     665             :       ArrayNoArgumentConstructorDescriptor, CallInterfaceDescriptor)
     666             : };
     667             : 
     668       60782 : class ArraySingleArgumentConstructorDescriptor
     669             :     : public CallInterfaceDescriptor {
     670             :  public:
     671             :   DEFINE_PARAMETERS(kFunction, kAllocationSite, kActualArgumentsCount,
     672             :                     kFunctionParameter, kArraySizeSmiParameter)
     673       62284 :   DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(
     674             :       ArraySingleArgumentConstructorDescriptor, CallInterfaceDescriptor)
     675             : };
     676             : 
     677       60782 : class ArrayNArgumentsConstructorDescriptor : public CallInterfaceDescriptor {
     678             :  public:
     679             :   DEFINE_PARAMETERS(kFunction, kAllocationSite, kActualArgumentsCount)
     680       60824 :   DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(
     681             :       ArrayNArgumentsConstructorDescriptor, CallInterfaceDescriptor)
     682             : };
     683             : 
     684             : 
     685       61341 : class CompareDescriptor : public CallInterfaceDescriptor {
     686             :  public:
     687             :   DEFINE_PARAMETERS(kLeft, kRight)
     688      446694 :   DECLARE_DESCRIPTOR(CompareDescriptor, CallInterfaceDescriptor)
     689             : };
     690             : 
     691             : 
     692       61255 : class BinaryOpDescriptor : public CallInterfaceDescriptor {
     693             :  public:
     694             :   DEFINE_PARAMETERS(kLeft, kRight)
     695     3392562 :   DECLARE_DESCRIPTOR(BinaryOpDescriptor, CallInterfaceDescriptor)
     696             : };
     697             : 
     698             : 
     699       60782 : class BinaryOpWithAllocationSiteDescriptor : public CallInterfaceDescriptor {
     700             :  public:
     701             :   DEFINE_PARAMETERS(kAllocationSite, kLeft, kRight)
     702       84906 :   DECLARE_DESCRIPTOR(BinaryOpWithAllocationSiteDescriptor,
     703             :                      CallInterfaceDescriptor)
     704             : };
     705             : 
     706       60997 : class BinaryOpWithVectorDescriptor : public CallInterfaceDescriptor {
     707             :  public:
     708             :   DEFINE_PARAMETERS(kLeft, kRight, kSlot, kVector)
     709       62502 :   DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(BinaryOpWithVectorDescriptor,
     710             :                                                CallInterfaceDescriptor)
     711             : };
     712             : 
     713       60782 : class CountOpDescriptor final : public CallInterfaceDescriptor {
     714             :  public:
     715       60782 :   DECLARE_DESCRIPTOR(CountOpDescriptor, CallInterfaceDescriptor)
     716             : };
     717             : 
     718       60782 : class StringAddDescriptor : public CallInterfaceDescriptor {
     719             :  public:
     720             :   DEFINE_PARAMETERS(kLeft, kRight)
     721      203910 :   DECLARE_DESCRIPTOR(StringAddDescriptor, CallInterfaceDescriptor)
     722             : };
     723             : 
     724       60825 : class StringCharAtDescriptor final : public CallInterfaceDescriptor {
     725             :  public:
     726             :   DEFINE_PARAMETERS(kReceiver, kPosition)
     727       61442 :   DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(StringCharAtDescriptor,
     728             :                                                CallInterfaceDescriptor)
     729             : };
     730             : 
     731       60825 : class StringCharCodeAtDescriptor final : public CallInterfaceDescriptor {
     732             :  public:
     733             :   DEFINE_PARAMETERS(kReceiver, kPosition)
     734       61626 :   DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(StringCharCodeAtDescriptor,
     735             :                                                CallInterfaceDescriptor)
     736             : };
     737             : 
     738       60782 : class StringCompareDescriptor : public CallInterfaceDescriptor {
     739             :  public:
     740             :   DEFINE_PARAMETERS(kLeft, kRight)
     741       60782 :   DECLARE_DESCRIPTOR(StringCompareDescriptor, CallInterfaceDescriptor)
     742             : 
     743             :   static const Register LeftRegister();
     744             :   static const Register RightRegister();
     745             : };
     746             : 
     747       60782 : class SubStringDescriptor : public CallInterfaceDescriptor {
     748             :  public:
     749             :   DEFINE_PARAMETERS(kString, kFrom, kTo)
     750      183416 :   DECLARE_DESCRIPTOR_WITH_STACK_ARGS(SubStringDescriptor,
     751             :                                      CallInterfaceDescriptor)
     752             : };
     753             : 
     754       60782 : class ArgumentAdaptorDescriptor : public CallInterfaceDescriptor {
     755             :  public:
     756             :   DEFINE_PARAMETERS(kFunction, kNewTarget, kActualArgumentsCount,
     757             :                     kExpectedArgumentsCount)
     758      163878 :   DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(ArgumentAdaptorDescriptor,
     759             :                                                CallInterfaceDescriptor)
     760             : };
     761             : 
     762       60782 : class ApiCallbackDescriptor : public CallInterfaceDescriptor {
     763             :  public:
     764             :   DEFINE_PARAMETERS(kFunction, kCallData, kHolder, kApiFunctionAddress)
     765      101188 :   DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(ApiCallbackDescriptor,
     766             :                                                CallInterfaceDescriptor)
     767             : };
     768             : 
     769       60782 : class ApiGetterDescriptor : public CallInterfaceDescriptor {
     770             :  public:
     771             :   DEFINE_PARAMETERS(kReceiver, kHolder, kCallback)
     772       63964 :   DECLARE_DESCRIPTOR(ApiGetterDescriptor, CallInterfaceDescriptor)
     773             : 
     774             :   static const Register ReceiverRegister();
     775             :   static const Register HolderRegister();
     776             :   static const Register CallbackRegister();
     777             : };
     778             : 
     779       60782 : class MathPowTaggedDescriptor : public CallInterfaceDescriptor {
     780             :  public:
     781             :   DEFINE_PARAMETERS(kExponent)
     782       60782 :   DECLARE_DESCRIPTOR(MathPowTaggedDescriptor, CallInterfaceDescriptor)
     783             : 
     784             :   static const Register exponent();
     785             : };
     786             : 
     787       60782 : class MathPowIntegerDescriptor : public CallInterfaceDescriptor {
     788             :  public:
     789             :   DEFINE_PARAMETERS(kExponent)
     790       60782 :   DECLARE_DESCRIPTOR(MathPowIntegerDescriptor, CallInterfaceDescriptor)
     791             : 
     792             :   static const Register exponent();
     793             : };
     794             : 
     795       60782 : class VarArgFunctionDescriptor : public CallInterfaceDescriptor {
     796             :  public:
     797             :   DEFINE_PARAMETERS(kActualArgumentsCount)
     798       60782 :   DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(VarArgFunctionDescriptor,
     799             :                                                CallInterfaceDescriptor)
     800             : };
     801             : 
     802             : // TODO(turbofan): We should probably rename this to GrowFastElementsDescriptor.
     803       60868 : class GrowArrayElementsDescriptor : public CallInterfaceDescriptor {
     804             :  public:
     805             :   DEFINE_PARAMETERS(kObject, kKey)
     806       65680 :   DECLARE_DESCRIPTOR(GrowArrayElementsDescriptor, CallInterfaceDescriptor)
     807             : 
     808             :   static const Register ObjectRegister();
     809             :   static const Register KeyRegister();
     810             : };
     811             : 
     812       60825 : class NewArgumentsElementsDescriptor final : public CallInterfaceDescriptor {
     813             :  public:
     814             :   DEFINE_PARAMETERS(kFrame, kLength)
     815       68464 :   DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(NewArgumentsElementsDescriptor,
     816             :                                                CallInterfaceDescriptor)
     817             : };
     818             : 
     819       79315 : class V8_EXPORT_PRIVATE InterpreterDispatchDescriptor
     820             :     : public CallInterfaceDescriptor {
     821             :  public:
     822             :   DEFINE_PARAMETERS(kAccumulator, kBytecodeOffset, kBytecodeArray,
     823             :                     kDispatchTable)
     824      145320 :   DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(InterpreterDispatchDescriptor,
     825             :                                                CallInterfaceDescriptor)
     826             : };
     827             : 
     828       60782 : class InterpreterPushArgsThenCallDescriptor : public CallInterfaceDescriptor {
     829             :  public:
     830             :   DEFINE_PARAMETERS(kNumberOfArguments, kFirstArgument, kFunction)
     831       63676 :   DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(
     832             :       InterpreterPushArgsThenCallDescriptor, CallInterfaceDescriptor)
     833             : };
     834             : 
     835       60782 : class InterpreterPushArgsThenConstructDescriptor
     836             :     : public CallInterfaceDescriptor {
     837             :  public:
     838             :   DEFINE_PARAMETERS(kNumberOfArguments, kNewTarget, kConstructor,
     839             :                     kFeedbackElement, kFirstArgument)
     840       61556 :   DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(
     841             :       InterpreterPushArgsThenConstructDescriptor, CallInterfaceDescriptor)
     842             : };
     843             : 
     844       60782 : class InterpreterPushArgsThenConstructArrayDescriptor
     845             :     : public CallInterfaceDescriptor {
     846             :  public:
     847             :   DEFINE_PARAMETERS(kNumberOfArguments, kFunction, kFeedbackElement,
     848             :                     kFirstArgument)
     849       61040 :   DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(
     850             :       InterpreterPushArgsThenConstructArrayDescriptor, CallInterfaceDescriptor)
     851             : };
     852             : 
     853       60782 : class InterpreterCEntryDescriptor : public CallInterfaceDescriptor {
     854             :  public:
     855             :   DEFINE_PARAMETERS(kNumberOfArguments, kFirstArgument, kFunctionEntry)
     856       61322 :   DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(InterpreterCEntryDescriptor,
     857             :                                                CallInterfaceDescriptor)
     858             : };
     859             : 
     860       60782 : class ResumeGeneratorDescriptor final : public CallInterfaceDescriptor {
     861             :  public:
     862       61470 :   DECLARE_DESCRIPTOR(ResumeGeneratorDescriptor, CallInterfaceDescriptor)
     863             : };
     864             : 
     865       60782 : class FrameDropperTrampolineDescriptor final : public CallInterfaceDescriptor {
     866       62588 :   DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(FrameDropperTrampolineDescriptor,
     867             :                                                CallInterfaceDescriptor)
     868             : };
     869             : 
     870      117248 : class WasmRuntimeCallDescriptor final : public CallInterfaceDescriptor {
     871             :  public:
     872             :   DEFINE_EMPTY_PARAMETERS()
     873      234481 :   DECLARE_DEFAULT_DESCRIPTOR(WasmRuntimeCallDescriptor, CallInterfaceDescriptor,
     874             :                              0)
     875             : };
     876             : 
     877             : #define DEFINE_TFS_BUILTIN_DESCRIPTOR(Name, ...)                          \
     878             :   class Name##Descriptor : public CallInterfaceDescriptor {               \
     879             :    public:                                                                \
     880             :     DEFINE_PARAMETERS(__VA_ARGS__)                                        \
     881             :     DECLARE_DEFAULT_DESCRIPTOR(Name##Descriptor, CallInterfaceDescriptor, \
     882             :                                kParameterCount)                           \
     883             :   };
     884     2349568 : BUILTIN_LIST_TFS(DEFINE_TFS_BUILTIN_DESCRIPTOR)
     885             : #undef DEFINE_TFS_BUILTIN_DESCRIPTOR
     886             : 
     887             : #undef DECLARE_DESCRIPTOR_WITH_BASE
     888             : #undef DECLARE_DESCRIPTOR
     889             : #undef DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE
     890             : #undef DECLARE_DESCRIPTOR_WITH_BASE_AND_FUNCTION_TYPE_ARG
     891             : #undef DEFINE_PARAMETERS
     892             : 
     893             : // We define the association between CallDescriptors::Key and the specialized
     894             : // descriptor here to reduce boilerplate and mistakes.
     895             : #define DEF_KEY(name, ...) \
     896             :   CallDescriptors::Key name##Descriptor::key() { return CallDescriptors::name; }
     897             : INTERFACE_DESCRIPTOR_LIST(DEF_KEY)
     898             : #undef DEF_KEY
     899             : }  // namespace internal
     900             : }  // namespace v8
     901             : 
     902             : 
     903             : #if V8_TARGET_ARCH_ARM64
     904             : #include "src/arm64/interface-descriptors-arm64.h"
     905             : #elif V8_TARGET_ARCH_ARM
     906             : #include "src/arm/interface-descriptors-arm.h"
     907             : #endif
     908             : 
     909             : #endif  // V8_CALL_INTERFACE_DESCRIPTOR_H_

Generated by: LCOV version 1.10