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