Home | History | Annotate | Download | only in mips
      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/v8.h"
      6 
      7 #if V8_TARGET_ARCH_MIPS
      8 
      9 #include "src/interface-descriptors.h"
     10 
     11 namespace v8 {
     12 namespace internal {
     13 
     14 const Register CallInterfaceDescriptor::ContextRegister() { return cp; }
     15 
     16 
     17 const Register LoadDescriptor::ReceiverRegister() { return a1; }
     18 const Register LoadDescriptor::NameRegister() { return a2; }
     19 
     20 
     21 const Register VectorLoadICTrampolineDescriptor::SlotRegister() { return a0; }
     22 
     23 
     24 const Register VectorLoadICDescriptor::VectorRegister() { return a3; }
     25 
     26 
     27 const Register StoreDescriptor::ReceiverRegister() { return a1; }
     28 const Register StoreDescriptor::NameRegister() { return a2; }
     29 const Register StoreDescriptor::ValueRegister() { return a0; }
     30 
     31 
     32 const Register ElementTransitionAndStoreDescriptor::MapRegister() { return a3; }
     33 
     34 
     35 const Register InstanceofDescriptor::left() { return a0; }
     36 const Register InstanceofDescriptor::right() { return a1; }
     37 
     38 
     39 const Register ArgumentsAccessReadDescriptor::index() { return a1; }
     40 const Register ArgumentsAccessReadDescriptor::parameter_count() { return a0; }
     41 
     42 
     43 const Register ApiGetterDescriptor::function_address() { return a2; }
     44 
     45 
     46 const Register MathPowTaggedDescriptor::exponent() { return a2; }
     47 
     48 
     49 const Register MathPowIntegerDescriptor::exponent() {
     50   return MathPowTaggedDescriptor::exponent();
     51 }
     52 
     53 
     54 void FastNewClosureDescriptor::Initialize(CallInterfaceDescriptorData* data) {
     55   Register registers[] = {cp, a2};
     56   data->Initialize(arraysize(registers), registers, NULL);
     57 }
     58 
     59 
     60 void FastNewContextDescriptor::Initialize(CallInterfaceDescriptorData* data) {
     61   Register registers[] = {cp, a1};
     62   data->Initialize(arraysize(registers), registers, NULL);
     63 }
     64 
     65 
     66 void ToNumberDescriptor::Initialize(CallInterfaceDescriptorData* data) {
     67   Register registers[] = {cp, a0};
     68   data->Initialize(arraysize(registers), registers, NULL);
     69 }
     70 
     71 
     72 void NumberToStringDescriptor::Initialize(CallInterfaceDescriptorData* data) {
     73   Register registers[] = {cp, a0};
     74   data->Initialize(arraysize(registers), registers, NULL);
     75 }
     76 
     77 
     78 void FastCloneShallowArrayDescriptor::Initialize(
     79     CallInterfaceDescriptorData* data) {
     80   Register registers[] = {cp, a3, a2, a1};
     81   Representation representations[] = {
     82       Representation::Tagged(), Representation::Tagged(), Representation::Smi(),
     83       Representation::Tagged()};
     84   data->Initialize(arraysize(registers), registers, representations);
     85 }
     86 
     87 
     88 void FastCloneShallowObjectDescriptor::Initialize(
     89     CallInterfaceDescriptorData* data) {
     90   Register registers[] = {cp, a3, a2, a1, a0};
     91   data->Initialize(arraysize(registers), registers, NULL);
     92 }
     93 
     94 
     95 void CreateAllocationSiteDescriptor::Initialize(
     96     CallInterfaceDescriptorData* data) {
     97   Register registers[] = {cp, a2, a3};
     98   data->Initialize(arraysize(registers), registers, NULL);
     99 }
    100 
    101 
    102 void StoreArrayLiteralElementDescriptor::Initialize(
    103     CallInterfaceDescriptorData* data) {
    104   Register registers[] = {cp, a3, a0};
    105   data->Initialize(arraysize(registers), registers, NULL);
    106 }
    107 
    108 
    109 void CallFunctionDescriptor::Initialize(CallInterfaceDescriptorData* data) {
    110   Register registers[] = {cp, a1};
    111   data->Initialize(arraysize(registers), registers, NULL);
    112 }
    113 
    114 
    115 void CallFunctionWithFeedbackDescriptor::Initialize(
    116     CallInterfaceDescriptorData* data) {
    117   Register registers[] = {cp, a1, a3};
    118   Representation representations[] = {Representation::Tagged(),
    119                                       Representation::Tagged(),
    120                                       Representation::Smi()};
    121   data->Initialize(arraysize(registers), registers, representations);
    122 }
    123 
    124 
    125 void CallConstructDescriptor::Initialize(CallInterfaceDescriptorData* data) {
    126   // a0 : number of arguments
    127   // a1 : the function to call
    128   // a2 : feedback vector
    129   // a3 : (only if a2 is not the megamorphic symbol) slot in feedback
    130   //      vector (Smi)
    131   // TODO(turbofan): So far we don't gather type feedback and hence skip the
    132   // slot parameter, but ArrayConstructStub needs the vector to be undefined.
    133   Register registers[] = {cp, a0, a1, a2};
    134   data->Initialize(arraysize(registers), registers, NULL);
    135 }
    136 
    137 
    138 void RegExpConstructResultDescriptor::Initialize(
    139     CallInterfaceDescriptorData* data) {
    140   Register registers[] = {cp, a2, a1, a0};
    141   data->Initialize(arraysize(registers), registers, NULL);
    142 }
    143 
    144 
    145 void TransitionElementsKindDescriptor::Initialize(
    146     CallInterfaceDescriptorData* data) {
    147   Register registers[] = {cp, a0, a1};
    148   data->Initialize(arraysize(registers), registers, NULL);
    149 }
    150 
    151 
    152 void ArrayConstructorConstantArgCountDescriptor::Initialize(
    153     CallInterfaceDescriptorData* data) {
    154   // register state
    155   // cp -- context
    156   // a0 -- number of arguments
    157   // a1 -- function
    158   // a2 -- allocation site with elements kind
    159   Register registers[] = {cp, a1, a2};
    160   data->Initialize(arraysize(registers), registers, NULL);
    161 }
    162 
    163 
    164 void ArrayConstructorDescriptor::Initialize(CallInterfaceDescriptorData* data) {
    165   // stack param count needs (constructor pointer, and single argument)
    166   Register registers[] = {cp, a1, a2, a0};
    167   Representation representations[] = {
    168       Representation::Tagged(), Representation::Tagged(),
    169       Representation::Tagged(), Representation::Integer32()};
    170   data->Initialize(arraysize(registers), registers, representations);
    171 }
    172 
    173 
    174 void InternalArrayConstructorConstantArgCountDescriptor::Initialize(
    175     CallInterfaceDescriptorData* data) {
    176   // register state
    177   // cp -- context
    178   // a0 -- number of arguments
    179   // a1 -- constructor function
    180   Register registers[] = {cp, a1};
    181   data->Initialize(arraysize(registers), registers, NULL);
    182 }
    183 
    184 
    185 void InternalArrayConstructorDescriptor::Initialize(
    186     CallInterfaceDescriptorData* data) {
    187   // stack param count needs (constructor pointer, and single argument)
    188   Register registers[] = {cp, a1, a0};
    189   Representation representations[] = {Representation::Tagged(),
    190                                       Representation::Tagged(),
    191                                       Representation::Integer32()};
    192   data->Initialize(arraysize(registers), registers, representations);
    193 }
    194 
    195 
    196 void CompareNilDescriptor::Initialize(CallInterfaceDescriptorData* data) {
    197   Register registers[] = {cp, a0};
    198   data->Initialize(arraysize(registers), registers, NULL);
    199 }
    200 
    201 
    202 void ToBooleanDescriptor::Initialize(CallInterfaceDescriptorData* data) {
    203   Register registers[] = {cp, a0};
    204   data->Initialize(arraysize(registers), registers, NULL);
    205 }
    206 
    207 
    208 void BinaryOpDescriptor::Initialize(CallInterfaceDescriptorData* data) {
    209   Register registers[] = {cp, a1, a0};
    210   data->Initialize(arraysize(registers), registers, NULL);
    211 }
    212 
    213 
    214 void BinaryOpWithAllocationSiteDescriptor::Initialize(
    215     CallInterfaceDescriptorData* data) {
    216   Register registers[] = {cp, a2, a1, a0};
    217   data->Initialize(arraysize(registers), registers, NULL);
    218 }
    219 
    220 
    221 void StringAddDescriptor::Initialize(CallInterfaceDescriptorData* data) {
    222   Register registers[] = {cp, a1, a0};
    223   data->Initialize(arraysize(registers), registers, NULL);
    224 }
    225 
    226 
    227 void KeyedDescriptor::Initialize(CallInterfaceDescriptorData* data) {
    228   Register registers[] = {
    229       cp,  // context
    230       a2,  // key
    231   };
    232   Representation representations[] = {
    233       Representation::Tagged(),  // context
    234       Representation::Tagged(),  // key
    235   };
    236   data->Initialize(arraysize(registers), registers, representations);
    237 }
    238 
    239 
    240 void NamedDescriptor::Initialize(CallInterfaceDescriptorData* data) {
    241   Register registers[] = {
    242       cp,  // context
    243       a2,  // name
    244   };
    245   Representation representations[] = {
    246       Representation::Tagged(),  // context
    247       Representation::Tagged(),  // name
    248   };
    249   data->Initialize(arraysize(registers), registers, representations);
    250 }
    251 
    252 
    253 void CallHandlerDescriptor::Initialize(CallInterfaceDescriptorData* data) {
    254   Register registers[] = {
    255       cp,  // context
    256       a0,  // receiver
    257   };
    258   Representation representations[] = {
    259       Representation::Tagged(),  // context
    260       Representation::Tagged(),  // receiver
    261   };
    262   data->Initialize(arraysize(registers), registers, representations);
    263 }
    264 
    265 
    266 void ArgumentAdaptorDescriptor::Initialize(CallInterfaceDescriptorData* data) {
    267   Register registers[] = {
    268       cp,  // context
    269       a1,  // JSFunction
    270       a0,  // actual number of arguments
    271       a2,  // expected number of arguments
    272   };
    273   Representation representations[] = {
    274       Representation::Tagged(),     // context
    275       Representation::Tagged(),     // JSFunction
    276       Representation::Integer32(),  // actual number of arguments
    277       Representation::Integer32(),  // expected number of arguments
    278   };
    279   data->Initialize(arraysize(registers), registers, representations);
    280 }
    281 
    282 
    283 void ApiFunctionDescriptor::Initialize(CallInterfaceDescriptorData* data) {
    284   Register registers[] = {
    285       cp,  // context
    286       a0,  // callee
    287       t0,  // call_data
    288       a2,  // holder
    289       a1,  // api_function_address
    290   };
    291   Representation representations[] = {
    292       Representation::Tagged(),    // context
    293       Representation::Tagged(),    // callee
    294       Representation::Tagged(),    // call_data
    295       Representation::Tagged(),    // holder
    296       Representation::External(),  // api_function_address
    297   };
    298   data->Initialize(arraysize(registers), registers, representations);
    299 }
    300 }
    301 }  // namespace v8::internal
    302 
    303 #endif  // V8_TARGET_ARCH_MIPS
    304