src/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   data->Initialize(arraysize(registers), registers, NULL);
 102 }
 103
 104
 105 void StoreArrayLiteralElementDescriptor::Initialize(
 106     CallInterfaceDescriptorData* data) {
 107   Register registers[] = {cp, r3, r0};
 108   data->Initialize(arraysize(registers), registers, NULL);
 109 }
 110
 111
 112 void CallFunctionDescriptor::Initialize(CallInterfaceDescriptorData* data) {
 113   Register registers[] = {cp, r1};
 114   data->Initialize(arraysize(registers), registers, NULL);
 115 }
 116
 117
 118 void CallFunctionWithFeedbackDescriptor::Initialize(
 119     CallInterfaceDescriptorData* data) {
 120   Register registers[] = {cp, r1, r3};
 121   Representation representations[] = {Representation::Tagged(),
 122                                       Representation::Tagged(),
 123                                       Representation::Smi()};
 124   data->Initialize(arraysize(registers), registers, representations);
 125 }
 126
 127
 128 void CallConstructDescriptor::Initialize(CallInterfaceDescriptorData* data) {
 129   // r0 : number of arguments
 130   // r1 : the function to call
 131   // r2 : feedback vector
 132   // r3 : (only if r2 is not the megamorphic symbol) slot in feedback
 133   //      vector (Smi)
 134   // TODO(turbofan): So far we don't gather type feedback and hence skip the
 135   // slot parameter, but ArrayConstructStub needs the vector to be undefined.
 136   Register registers[] = {cp, r0, r1, r2};
 137   data->Initialize(arraysize(registers), registers, NULL);
 138 }
 139
 140
 141 void RegExpConstructResultDescriptor::Initialize(
 142     CallInterfaceDescriptorData* data) {
 143   Register registers[] = {cp, r2, r1, r0};
 144   data->Initialize(arraysize(registers), registers, NULL);
 145 }
 146
 147
 148 void TransitionElementsKindDescriptor::Initialize(
 149     CallInterfaceDescriptorData* data) {
 150   Register registers[] = {cp, r0, r1};
 151   data->Initialize(arraysize(registers), registers, NULL);
 152 }
 153
 154
 155 void AllocateHeapNumberDescriptor::Initialize(
 156     CallInterfaceDescriptorData* data) {
 157   // register state
 158   // cp -- context
 159   Register registers[] = {cp};
 160   data->Initialize(arraysize(registers), registers, nullptr);
 161 }
 162
 163
 164 void ArrayConstructorConstantArgCountDescriptor::Initialize(
 165     CallInterfaceDescriptorData* data) {
 166   // register state
 167   // cp -- context
 168   // r0 -- number of arguments
 169   // r1 -- function
 170   // r2 -- allocation site with elements kind
 171   Register registers[] = {cp, r1, r2};
 172   data->Initialize(arraysize(registers), registers, NULL);
 173 }
 174
 175
 176 void ArrayConstructorDescriptor::Initialize(CallInterfaceDescriptorData* data) {
 177   // stack param count needs (constructor pointer, and single argument)
 178   Register registers[] = {cp, r1, r2, r0};
 179   Representation representations[] = {
 180       Representation::Tagged(), Representation::Tagged(),
 181       Representation::Tagged(), Representation::Integer32()};
 182   data->Initialize(arraysize(registers), registers, representations);
 183 }
 184
 185
 186 void InternalArrayConstructorConstantArgCountDescriptor::Initialize(
 187     CallInterfaceDescriptorData* data) {
 188   // register state
 189   // cp -- context
 190   // r0 -- number of arguments
 191   // r1 -- constructor function
 192   Register registers[] = {cp, r1};
 193   data->Initialize(arraysize(registers), registers, NULL);
 194 }
 195
 196
 197 void InternalArrayConstructorDescriptor::Initialize(
 198     CallInterfaceDescriptorData* data) {
 199   // stack param count needs (constructor pointer, and single argument)
 200   Register registers[] = {cp, r1, r0};
 201   Representation representations[] = {Representation::Tagged(),
 202                                       Representation::Tagged(),
 203                                       Representation::Integer32()};
 204   data->Initialize(arraysize(registers), registers, representations);
 205 }
 206
 207
 208 void CompareNilDescriptor::Initialize(CallInterfaceDescriptorData* data) {
 209   Register registers[] = {cp, r0};
 210   data->Initialize(arraysize(registers), registers, NULL);
 211 }
 212
 213
 214 void ToBooleanDescriptor::Initialize(CallInterfaceDescriptorData* data) {
 215   Register registers[] = {cp, r0};
 216   data->Initialize(arraysize(registers), registers, NULL);
 217 }
 218
 219
 220 void BinaryOpDescriptor::Initialize(CallInterfaceDescriptorData* data) {
 221   Register registers[] = {cp, r1, r0};
 222   data->Initialize(arraysize(registers), registers, NULL);
 223 }
 224
 225
 226 void BinaryOpWithAllocationSiteDescriptor::Initialize(
 227     CallInterfaceDescriptorData* data) {
 228   Register registers[] = {cp, r2, r1, r0};
 229   data->Initialize(arraysize(registers), registers, NULL);
 230 }
 231
 232
 233 void StringAddDescriptor::Initialize(CallInterfaceDescriptorData* data) {
 234   Register registers[] = {cp, r1, r0};
 235   data->Initialize(arraysize(registers), registers, NULL);
 236 }
 237
 238
 239 void KeyedDescriptor::Initialize(CallInterfaceDescriptorData* data) {
 240   static PlatformInterfaceDescriptor noInlineDescriptor =
 241       PlatformInterfaceDescriptor(NEVER_INLINE_TARGET_ADDRESS);
 242
 243   Register registers[] = {
 244       cp,  // context
 245       r2,  // key
 246   };
 247   Representation representations[] = {
 248       Representation::Tagged(),  // context
 249       Representation::Tagged(),  // key
 250   };
 251   data->Initialize(arraysize(registers), registers, representations,
 252                    &noInlineDescriptor);
 253 }
 254
 255
 256 void NamedDescriptor::Initialize(CallInterfaceDescriptorData* data) {
 257   static PlatformInterfaceDescriptor noInlineDescriptor =
 258       PlatformInterfaceDescriptor(NEVER_INLINE_TARGET_ADDRESS);
 259
 260   Register registers[] = {
 261       cp,  // context
 262       r2,  // name
 263   };
 264   Representation representations[] = {
 265       Representation::Tagged(),  // context
 266       Representation::Tagged(),  // name
 267   };
 268   data->Initialize(arraysize(registers), registers, representations,
 269                    &noInlineDescriptor);
 270 }
 271
 272
 273 void CallHandlerDescriptor::Initialize(CallInterfaceDescriptorData* data) {
 274   static PlatformInterfaceDescriptor default_descriptor =
 275       PlatformInterfaceDescriptor(CAN_INLINE_TARGET_ADDRESS);
 276
 277   Register registers[] = {
 278       cp,  // context
 279       r0,  // receiver
 280   };
 281   Representation representations[] = {
 282       Representation::Tagged(),  // context
 283       Representation::Tagged(),  // receiver
 284   };
 285   data->Initialize(arraysize(registers), registers, representations,
 286                    &default_descriptor);
 287 }
 288
 289
 290 void ArgumentAdaptorDescriptor::Initialize(CallInterfaceDescriptorData* data) {
 291   static PlatformInterfaceDescriptor default_descriptor =
 292       PlatformInterfaceDescriptor(CAN_INLINE_TARGET_ADDRESS);
 293
 294   Register registers[] = {
 295       cp,  // context
 296       r1,  // JSFunction
 297       r0,  // actual number of arguments
 298       r2,  // expected number of arguments
 299   };
 300   Representation representations[] = {
 301       Representation::Tagged(),     // context
 302       Representation::Tagged(),     // JSFunction
 303       Representation::Integer32(),  // actual number of arguments
 304       Representation::Integer32(),  // expected number of arguments
 305   };
 306   data->Initialize(arraysize(registers), registers, representations,
 307                    &default_descriptor);
 308 }
 309
 310
 311 void ApiFunctionDescriptor::Initialize(CallInterfaceDescriptorData* data) {
 312   static PlatformInterfaceDescriptor default_descriptor =
 313       PlatformInterfaceDescriptor(CAN_INLINE_TARGET_ADDRESS);
 314
 315   Register registers[] = {
 316       cp,  // context
 317       r0,  // callee
 318       r4,  // call_data
 319       r2,  // holder
 320       r1,  // api_function_address
 321   };
 322   Representation representations[] = {
 323       Representation::Tagged(),    // context
 324       Representation::Tagged(),    // callee
 325       Representation::Tagged(),    // call_data
 326       Representation::Tagged(),    // holder
 327       Representation::External(),  // api_function_address
 328   };
 329   data->Initialize(arraysize(registers), registers, representations,
 330                    &default_descriptor);
 331 }
 332 }
 333 }  // namespace v8::internal
 334
 335 #endif  // V8_TARGET_ARCH_ARM