LCOV - code coverage report
Current view: top level - src - interface-descriptors.cc (source / functions) Hit Total Coverage
Test: app.info Lines: 280 288 97.2 %
Date: 2017-04-26 Functions: 71 76 93.4 %

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

Generated by: LCOV version 1.10