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