deps/v8/src/x64/interface-descriptors-x64.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_X64
   8
   9 #include "src/interface-descriptors.h"
  10
  11 namespace v8 {
  12 namespace internal {
  13
  14 const Register CallInterfaceDescriptor::ContextRegister() { return rsi; }
  15
  16
  17 const Register LoadDescriptor::ReceiverRegister() { return rdx; }
  18 const Register LoadDescriptor::NameRegister() { return rcx; }
  19
  20
  21 const Register VectorLoadICTrampolineDescriptor::SlotRegister() { return rax; }
  22
  23
  24 const Register VectorLoadICDescriptor::VectorRegister() { return rbx; }
  25
  26
  27 const Register StoreDescriptor::ReceiverRegister() { return rdx; }
  28 const Register StoreDescriptor::NameRegister() { return rcx; }
  29 const Register StoreDescriptor::ValueRegister() { return rax; }
  30
  31
  32 const Register StoreTransitionDescriptor::MapRegister() { return rbx; }
  33
  34
  35 const Register ElementTransitionAndStoreDescriptor::MapRegister() {
  36   return rbx;
  37 }
  38
  39
  40 const Register InstanceofDescriptor::left() { return rax; }
  41 const Register InstanceofDescriptor::right() { return rdx; }
  42
  43
  44 const Register ArgumentsAccessReadDescriptor::index() { return rdx; }
  45 const Register ArgumentsAccessReadDescriptor::parameter_count() { return rax; }
  46
  47
  48 const Register ApiGetterDescriptor::function_address() { return r8; }
  49
  50
  51 const Register MathPowTaggedDescriptor::exponent() { return rdx; }
  52
  53
  54 const Register MathPowIntegerDescriptor::exponent() {
  55   return MathPowTaggedDescriptor::exponent();
  56 }
  57
  58
  59 void FastNewClosureDescriptor::Initialize(CallInterfaceDescriptorData* data) {
  60   Register registers[] = {rsi, rbx};
  61   data->Initialize(arraysize(registers), registers, NULL);
  62 }
  63
  64
  65 void FastNewContextDescriptor::Initialize(CallInterfaceDescriptorData* data) {
  66   Register registers[] = {rsi, rdi};
  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[] = {rsi, rax};
  74   data->Initialize(arraysize(registers), registers, NULL);
  75 }
  76
  77
  78 void NumberToStringDescriptor::Initialize(CallInterfaceDescriptorData* data) {
  79   Register registers[] = {rsi, rax};
  80   data->Initialize(arraysize(registers), registers, NULL);
  81 }
  82
  83
  84 void FastCloneShallowArrayDescriptor::Initialize(
  85     CallInterfaceDescriptorData* data) {
  86   Register registers[] = {rsi, rax, rbx, rcx};
  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[] = {rsi, rax, rbx, rcx, rdx};
  97   data->Initialize(arraysize(registers), registers, NULL);
  98 }
  99
 100
 101 void CreateAllocationSiteDescriptor::Initialize(
 102     CallInterfaceDescriptorData* data) {
 103   Register registers[] = {rsi, rbx, rdx};
 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[] = {rsi, rbx, rdx, rdi};
 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[] = {rsi, rcx, rax};
 123   data->Initialize(arraysize(registers), registers, NULL);
 124 }
 125
 126
 127 void CallFunctionDescriptor::Initialize(CallInterfaceDescriptorData* data) {
 128   Register registers[] = {rsi, rdi};
 129   data->Initialize(arraysize(registers), registers, NULL);
 130 }
 131
 132
 133 void CallFunctionWithFeedbackDescriptor::Initialize(
 134     CallInterfaceDescriptorData* data) {
 135   Register registers[] = {rsi, rdi, rdx};
 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[] = {rsi, rdi, rdx, rbx};
 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   // rax : number of arguments
 155   // rbx : feedback vector
 156   // rdx : (only if rbx is not the megamorphic symbol) slot in feedback
 157   //       vector (Smi)
 158   // rdi : 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[] = {rsi, rax, rdi, rbx};
 162   data->Initialize(arraysize(registers), registers, NULL);
 163 }
 164
 165
 166 void RegExpConstructResultDescriptor::Initialize(
 167     CallInterfaceDescriptorData* data) {
 168   Register registers[] = {rsi, rcx, rbx, rax};
 169   data->Initialize(arraysize(registers), registers, NULL);
 170 }
 171
 172
 173 void TransitionElementsKindDescriptor::Initialize(
 174     CallInterfaceDescriptorData* data) {
 175   Register registers[] = {rsi, rax, rbx};
 176   data->Initialize(arraysize(registers), registers, NULL);
 177 }
 178
 179
 180 void AllocateHeapNumberDescriptor::Initialize(
 181     CallInterfaceDescriptorData* data) {
 182   // register state
 183   // rsi -- context
 184   Register registers[] = {rsi};
 185   data->Initialize(arraysize(registers), registers, nullptr);
 186 }
 187
 188
 189 void ArrayConstructorConstantArgCountDescriptor::Initialize(
 190     CallInterfaceDescriptorData* data) {
 191   // register state
 192   // rax -- number of arguments
 193   // rdi -- function
 194   // rbx -- allocation site with elements kind
 195   Register registers[] = {rsi, rdi, rbx};
 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[] = {rsi, rdi, rbx, rax};
 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   // rsi -- context
 214   // rax -- number of arguments
 215   // rdi -- constructor function
 216   Register registers[] = {rsi, rdi};
 217   data->Initialize(arraysize(registers), registers, NULL);
 218 }
 219
 220
 221 void InternalArrayConstructorDescriptor::Initialize(
 222     CallInterfaceDescriptorData* data) {
 223   // stack param count needs (constructor pointer, and single argument)
 224   Register registers[] = {rsi, rdi, rax};
 225   Representation representations[] = {Representation::Tagged(),
 226                                       Representation::Tagged(),
 227                                       Representation::Integer32()};
 228   data->Initialize(arraysize(registers), registers, representations);
 229 }
 230
 231
 232 void CompareNilDescriptor::Initialize(CallInterfaceDescriptorData* data) {
 233   Register registers[] = {rsi, rax};
 234   data->Initialize(arraysize(registers), registers, NULL);
 235 }
 236
 237
 238 void ToBooleanDescriptor::Initialize(CallInterfaceDescriptorData* data) {
 239   Register registers[] = {rsi, rax};
 240   data->Initialize(arraysize(registers), registers, NULL);
 241 }
 242
 243
 244 void BinaryOpDescriptor::Initialize(CallInterfaceDescriptorData* data) {
 245   Register registers[] = {rsi, rdx, rax};
 246   data->Initialize(arraysize(registers), registers, NULL);
 247 }
 248
 249
 250 void BinaryOpWithAllocationSiteDescriptor::Initialize(
 251     CallInterfaceDescriptorData* data) {
 252   Register registers[] = {rsi, rcx, rdx, rax};
 253   data->Initialize(arraysize(registers), registers, NULL);
 254 }
 255
 256
 257 void StringAddDescriptor::Initialize(CallInterfaceDescriptorData* data) {
 258   Register registers[] = {rsi, rdx, rax};
 259   data->Initialize(arraysize(registers), registers, NULL);
 260 }
 261
 262
 263 void KeyedDescriptor::Initialize(CallInterfaceDescriptorData* data) {
 264   Register registers[] = {
 265       rsi,  // context
 266       rcx,  // key
 267   };
 268   Representation representations[] = {
 269       Representation::Tagged(),  // context
 270       Representation::Tagged(),  // key
 271   };
 272   data->Initialize(arraysize(registers), registers, representations);
 273 }
 274
 275
 276 void NamedDescriptor::Initialize(CallInterfaceDescriptorData* data) {
 277   Register registers[] = {
 278       rsi,  // context
 279       rcx,  // name
 280   };
 281   Representation representations[] = {
 282       Representation::Tagged(),  // context
 283       Representation::Tagged(),  // name
 284   };
 285   data->Initialize(arraysize(registers), registers, representations);
 286 }
 287
 288
 289 void CallHandlerDescriptor::Initialize(CallInterfaceDescriptorData* data) {
 290   Register registers[] = {
 291       rsi,  // context
 292       rdx,  // receiver
 293   };
 294   Representation representations[] = {
 295       Representation::Tagged(),  // context
 296       Representation::Tagged(),  // receiver
 297   };
 298   data->Initialize(arraysize(registers), registers, representations);
 299 }
 300
 301
 302 void ArgumentAdaptorDescriptor::Initialize(CallInterfaceDescriptorData* data) {
 303   Register registers[] = {
 304       rsi,  // context
 305       rdi,  // JSFunction
 306       rax,  // actual number of arguments
 307       rbx,  // expected number of arguments
 308   };
 309   Representation representations[] = {
 310       Representation::Tagged(),     // context
 311       Representation::Tagged(),     // JSFunction
 312       Representation::Integer32(),  // actual number of arguments
 313       Representation::Integer32(),  // expected number of arguments
 314   };
 315   data->Initialize(arraysize(registers), registers, representations);
 316 }
 317
 318
 319 void ApiFunctionDescriptor::Initialize(CallInterfaceDescriptorData* data) {
 320   Register registers[] = {
 321       rsi,  // context
 322       rdi,  // callee
 323       rbx,  // call_data
 324       rcx,  // holder
 325       rdx,  // api_function_address
 326       rax,  // actual number of arguments
 327   };
 328   Representation representations[] = {
 329       Representation::Tagged(),     // context
 330       Representation::Tagged(),     // callee
 331       Representation::Tagged(),     // call_data
 332       Representation::Tagged(),     // holder
 333       Representation::External(),   // api_function_address
 334       Representation::Integer32(),  // actual number of arguments
 335   };
 336   data->Initialize(arraysize(registers), registers, representations);
 337 }
 338
 339
 340 void ApiAccessorDescriptor::Initialize(CallInterfaceDescriptorData* data) {
 341   Register registers[] = {
 342       rsi,  // context
 343       rdi,  // callee
 344       rbx,  // call_data
 345       rcx,  // holder
 346       rdx,  // api_function_address
 347   };
 348   Representation representations[] = {
 349       Representation::Tagged(),    // context
 350       Representation::Tagged(),    // callee
 351       Representation::Tagged(),    // call_data
 352       Representation::Tagged(),    // holder
 353       Representation::External(),  // api_function_address
 354   };
 355   data->Initialize(arraysize(registers), registers, representations);
 356 }
 357 }
 358 }  // namespace v8::internal
 359
 360 #endif  // V8_TARGET_ARCH_X64