deps/v8/src/arm/interface-descriptors-arm.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_ARM
   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 r1; }
  18 const Register LoadDescriptor::NameRegister() { return r2; }
  19
  20
  21 const Register VectorLoadICTrampolineDescriptor::SlotRegister() { return r0; }
  22
  23
  24 const Register VectorLoadICDescriptor::VectorRegister() { return r3; }
  25
  26
  27 const Register StoreDescriptor::ReceiverRegister() { return r1; }
  28 const Register StoreDescriptor::NameRegister() { return r2; }
  29 const Register StoreDescriptor::ValueRegister() { return r0; }
  30
  31
  32 const Register StoreTransitionDescriptor::MapRegister() { return r3; }
  33
  34
  35 const Register ElementTransitionAndStoreDescriptor::MapRegister() { return r3; }
  36
  37
  38 const Register InstanceofDescriptor::left() { return r0; }
  39 const Register InstanceofDescriptor::right() { return r1; }
  40
  41
  42 const Register ArgumentsAccessReadDescriptor::index() { return r1; }
  43 const Register ArgumentsAccessReadDescriptor::parameter_count() { return r0; }
  44
  45
  46 const Register ApiGetterDescriptor::function_address() { return r2; }
  47
  48
  49 const Register MathPowTaggedDescriptor::exponent() { return r2; }
  50
  51
  52 const Register MathPowIntegerDescriptor::exponent() {
  53   return MathPowTaggedDescriptor::exponent();
  54 }
  55
  56
  57 void FastNewClosureDescriptor::Initialize(CallInterfaceDescriptorData* data) {
  58   Register registers[] = {cp, r2};
  59   data->Initialize(arraysize(registers), registers, NULL);
  60 }
  61
  62
  63 void FastNewContextDescriptor::Initialize(CallInterfaceDescriptorData* data) {
  64   Register registers[] = {cp, r1};
  65   data->Initialize(arraysize(registers), registers, NULL);
  66 }
  67
  68
  69 void ToNumberDescriptor::Initialize(CallInterfaceDescriptorData* data) {
  70   Register registers[] = {cp, r0};
  71   data->Initialize(arraysize(registers), registers, NULL);
  72 }
  73
  74
  75 void NumberToStringDescriptor::Initialize(CallInterfaceDescriptorData* data) {
  76   Register registers[] = {cp, r0};
  77   data->Initialize(arraysize(registers), registers, NULL);
  78 }
  79
  80
  81 void FastCloneShallowArrayDescriptor::Initialize(
  82     CallInterfaceDescriptorData* data) {
  83   Register registers[] = {cp, r3, r2, r1};
  84   Representation representations[] = {
  85       Representation::Tagged(), Representation::Tagged(), Representation::Smi(),
  86       Representation::Tagged()};
  87   data->Initialize(arraysize(registers), registers, representations);
  88 }
  89
  90
  91 void FastCloneShallowObjectDescriptor::Initialize(
  92     CallInterfaceDescriptorData* data) {
  93   Register registers[] = {cp, r3, r2, r1, r0};
  94   data->Initialize(arraysize(registers), registers, NULL);
  95 }
  96
  97
  98 void CreateAllocationSiteDescriptor::Initialize(
  99     CallInterfaceDescriptorData* data) {
 100   Register registers[] = {cp, r2, r3};
 101   Representation representations[] = {Representation::Tagged(),
 102                                       Representation::Tagged(),
 103                                       Representation::Smi()};
 104   data->Initialize(arraysize(registers), registers, representations);
 105 }
 106
 107
 108 void CreateWeakCellDescriptor::Initialize(CallInterfaceDescriptorData* data) {
 109   Register registers[] = {cp, r2, r3, r1};
 110   Representation representations[] = {
 111       Representation::Tagged(), Representation::Tagged(), Representation::Smi(),
 112       Representation::Tagged()};
 113   data->Initialize(arraysize(registers), registers, representations);
 114 }
 115
 116
 117 void StoreArrayLiteralElementDescriptor::Initialize(
 118     CallInterfaceDescriptorData* data) {
 119   Register registers[] = {cp, r3, r0};
 120   data->Initialize(arraysize(registers), registers, NULL);
 121 }
 122
 123
 124 void CallFunctionDescriptor::Initialize(CallInterfaceDescriptorData* data) {
 125   Register registers[] = {cp, r1};
 126   data->Initialize(arraysize(registers), registers, NULL);
 127 }
 128
 129
 130 void CallFunctionWithFeedbackDescriptor::Initialize(
 131     CallInterfaceDescriptorData* data) {
 132   Register registers[] = {cp, r1, r3};
 133   Representation representations[] = {Representation::Tagged(),
 134                                       Representation::Tagged(),
 135                                       Representation::Smi()};
 136   data->Initialize(arraysize(registers), registers, representations);
 137 }
 138
 139
 140 void CallFunctionWithFeedbackAndVectorDescriptor::Initialize(
 141     CallInterfaceDescriptorData* data) {
 142   Register registers[] = {cp, r1, r3, r2};
 143   Representation representations[] = {
 144       Representation::Tagged(), Representation::Tagged(), Representation::Smi(),
 145       Representation::Tagged()};
 146   data->Initialize(arraysize(registers), registers, representations);
 147 }
 148
 149
 150 void CallConstructDescriptor::Initialize(CallInterfaceDescriptorData* data) {
 151   // r0 : number of arguments
 152   // r1 : the function to call
 153   // r2 : feedback vector
 154   // r3 : (only if r2 is not the megamorphic symbol) slot in feedback
 155   //      vector (Smi)
 156   // TODO(turbofan): So far we don't gather type feedback and hence skip the
 157   // slot parameter, but ArrayConstructStub needs the vector to be undefined.
 158   Register registers[] = {cp, r0, r1, r2};
 159   data->Initialize(arraysize(registers), registers, NULL);
 160 }
 161
 162
 163 void RegExpConstructResultDescriptor::Initialize(
 164     CallInterfaceDescriptorData* data) {
 165   Register registers[] = {cp, r2, r1, r0};
 166   data->Initialize(arraysize(registers), registers, NULL);
 167 }
 168
 169
 170 void TransitionElementsKindDescriptor::Initialize(
 171     CallInterfaceDescriptorData* data) {
 172   Register registers[] = {cp, r0, r1};
 173   data->Initialize(arraysize(registers), registers, NULL);
 174 }
 175
 176
 177 void AllocateHeapNumberDescriptor::Initialize(
 178     CallInterfaceDescriptorData* data) {
 179   // register state
 180   // cp -- context
 181   Register registers[] = {cp};
 182   data->Initialize(arraysize(registers), registers, nullptr);
 183 }
 184
 185
 186 void ArrayConstructorConstantArgCountDescriptor::Initialize(
 187     CallInterfaceDescriptorData* data) {
 188   // register state
 189   // cp -- context
 190   // r0 -- number of arguments
 191   // r1 -- function
 192   // r2 -- allocation site with elements kind
 193   Register registers[] = {cp, r1, r2};
 194   data->Initialize(arraysize(registers), registers, NULL);
 195 }
 196
 197
 198 void ArrayConstructorDescriptor::Initialize(CallInterfaceDescriptorData* data) {
 199   // stack param count needs (constructor pointer, and single argument)
 200   Register registers[] = {cp, r1, r2, r0};
 201   Representation representations[] = {
 202       Representation::Tagged(), Representation::Tagged(),
 203       Representation::Tagged(), Representation::Integer32()};
 204   data->Initialize(arraysize(registers), registers, representations);
 205 }
 206
 207
 208 void InternalArrayConstructorConstantArgCountDescriptor::Initialize(
 209     CallInterfaceDescriptorData* data) {
 210   // register state
 211   // cp -- context
 212   // r0 -- number of arguments
 213   // r1 -- constructor function
 214   Register registers[] = {cp, r1};
 215   data->Initialize(arraysize(registers), registers, NULL);
 216 }
 217
 218
 219 void InternalArrayConstructorDescriptor::Initialize(
 220     CallInterfaceDescriptorData* data) {
 221   // stack param count needs (constructor pointer, and single argument)
 222   Register registers[] = {cp, r1, r0};
 223   Representation representations[] = {Representation::Tagged(),
 224                                       Representation::Tagged(),
 225                                       Representation::Integer32()};
 226   data->Initialize(arraysize(registers), registers, representations);
 227 }
 228
 229
 230 void CompareDescriptor::Initialize(CallInterfaceDescriptorData* data) {
 231   Register registers[] = {cp, r1, r0};
 232   data->Initialize(arraysize(registers), registers, NULL);
 233 }
 234
 235
 236 void CompareNilDescriptor::Initialize(CallInterfaceDescriptorData* data) {
 237   Register registers[] = {cp, r0};
 238   data->Initialize(arraysize(registers), registers, NULL);
 239 }
 240
 241
 242 void ToBooleanDescriptor::Initialize(CallInterfaceDescriptorData* data) {
 243   Register registers[] = {cp, r0};
 244   data->Initialize(arraysize(registers), registers, NULL);
 245 }
 246
 247
 248 void BinaryOpDescriptor::Initialize(CallInterfaceDescriptorData* data) {
 249   Register registers[] = {cp, r1, r0};
 250   data->Initialize(arraysize(registers), registers, NULL);
 251 }
 252
 253
 254 void BinaryOpWithAllocationSiteDescriptor::Initialize(
 255     CallInterfaceDescriptorData* data) {
 256   Register registers[] = {cp, r2, r1, r0};
 257   data->Initialize(arraysize(registers), registers, NULL);
 258 }
 259
 260
 261 void StringAddDescriptor::Initialize(CallInterfaceDescriptorData* data) {
 262   Register registers[] = {cp, r1, r0};
 263   data->Initialize(arraysize(registers), registers, NULL);
 264 }
 265
 266
 267 void KeyedDescriptor::Initialize(CallInterfaceDescriptorData* data) {
 268   static PlatformInterfaceDescriptor noInlineDescriptor =
 269       PlatformInterfaceDescriptor(NEVER_INLINE_TARGET_ADDRESS);
 270
 271   Register registers[] = {
 272       cp,  // context
 273       r2,  // key
 274   };
 275   Representation representations[] = {
 276       Representation::Tagged(),  // context
 277       Representation::Tagged(),  // key
 278   };
 279   data->Initialize(arraysize(registers), registers, representations,
 280                    &noInlineDescriptor);
 281 }
 282
 283
 284 void NamedDescriptor::Initialize(CallInterfaceDescriptorData* data) {
 285   static PlatformInterfaceDescriptor noInlineDescriptor =
 286       PlatformInterfaceDescriptor(NEVER_INLINE_TARGET_ADDRESS);
 287
 288   Register registers[] = {
 289       cp,  // context
 290       r2,  // name
 291   };
 292   Representation representations[] = {
 293       Representation::Tagged(),  // context
 294       Representation::Tagged(),  // name
 295   };
 296   data->Initialize(arraysize(registers), registers, representations,
 297                    &noInlineDescriptor);
 298 }
 299
 300
 301 void CallHandlerDescriptor::Initialize(CallInterfaceDescriptorData* data) {
 302   static PlatformInterfaceDescriptor default_descriptor =
 303       PlatformInterfaceDescriptor(CAN_INLINE_TARGET_ADDRESS);
 304
 305   Register registers[] = {
 306       cp,  // context
 307       r0,  // receiver
 308   };
 309   Representation representations[] = {
 310       Representation::Tagged(),  // context
 311       Representation::Tagged(),  // receiver
 312   };
 313   data->Initialize(arraysize(registers), registers, representations,
 314                    &default_descriptor);
 315 }
 316
 317
 318 void ArgumentAdaptorDescriptor::Initialize(CallInterfaceDescriptorData* data) {
 319   static PlatformInterfaceDescriptor default_descriptor =
 320       PlatformInterfaceDescriptor(CAN_INLINE_TARGET_ADDRESS);
 321
 322   Register registers[] = {
 323       cp,  // context
 324       r1,  // JSFunction
 325       r0,  // actual number of arguments
 326       r2,  // expected number of arguments
 327   };
 328   Representation representations[] = {
 329       Representation::Tagged(),     // context
 330       Representation::Tagged(),     // JSFunction
 331       Representation::Integer32(),  // actual number of arguments
 332       Representation::Integer32(),  // expected number of arguments
 333   };
 334   data->Initialize(arraysize(registers), registers, representations,
 335                    &default_descriptor);
 336 }
 337
 338
 339 void ApiFunctionDescriptor::Initialize(CallInterfaceDescriptorData* data) {
 340   static PlatformInterfaceDescriptor default_descriptor =
 341       PlatformInterfaceDescriptor(CAN_INLINE_TARGET_ADDRESS);
 342
 343   Register registers[] = {
 344       cp,  // context
 345       r0,  // callee
 346       r4,  // call_data
 347       r2,  // holder
 348       r1,  // api_function_address
 349       r3,  // actual number of arguments
 350   };
 351   Representation representations[] = {
 352       Representation::Tagged(),     // context
 353       Representation::Tagged(),     // callee
 354       Representation::Tagged(),     // call_data
 355       Representation::Tagged(),     // holder
 356       Representation::External(),   // api_function_address
 357       Representation::Integer32(),  // actual number of arguments
 358   };
 359   data->Initialize(arraysize(registers), registers, representations,
 360                    &default_descriptor);
 361 }
 362
 363
 364 void ApiAccessorDescriptor::Initialize(CallInterfaceDescriptorData* data) {
 365   static PlatformInterfaceDescriptor default_descriptor =
 366       PlatformInterfaceDescriptor(CAN_INLINE_TARGET_ADDRESS);
 367
 368   Register registers[] = {
 369       cp,  // context
 370       r0,  // callee
 371       r4,  // call_data
 372       r2,  // holder
 373       r1,  // api_function_address
 374   };
 375   Representation representations[] = {
 376       Representation::Tagged(),    // context
 377       Representation::Tagged(),    // callee
 378       Representation::Tagged(),    // call_data
 379       Representation::Tagged(),    // holder
 380       Representation::External(),  // api_function_address
 381   };
 382   data->Initialize(arraysize(registers), registers, representations,
 383                    &default_descriptor);
 384 }
 385 }
 386 }  // namespace v8::internal
 387
 388 #endif  // V8_TARGET_ARCH_ARM