src/v8/src/mips64/interface-descriptors-mips64.cc

   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_MIPS64
   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 CallFunctionWithFeedbackDescriptor::Initialize(
 110     CallInterfaceDescriptorData* data) {
 111   Register registers[] = {cp, a1, a3};
 112   Representation representations[] = {Representation::Tagged(),
 113                                       Representation::Tagged(),
 114                                       Representation::Smi()};
 115   data->Initialize(arraysize(registers), registers, representations);
 116 }
 117
 118
 119 void CallFunctionDescriptor::Initialize(CallInterfaceDescriptorData* data) {
 120   Register registers[] = {cp, a1};
 121   data->Initialize(arraysize(registers), registers, NULL);
 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       a4,  // 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_MIPS64