deps/v8/src/compiler/x64/linkage-x64.cc

   1 // Copyright 2014 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/assembler.h"
   6 #include "src/code-stubs.h"
   7 #include "src/compiler/linkage.h"
   8 #include "src/compiler/linkage-impl.h"
   9 #include "src/zone.h"
  10
  11 namespace v8 {
  12 namespace internal {
  13 namespace compiler {
  14
  15 #ifdef _WIN64
  16 const bool kWin64 = true;
  17 #else
  18 const bool kWin64 = false;
  19 #endif
  20
  21 struct X64LinkageHelperTraits {
  22   static Register ReturnValueReg() { return rax; }
  23   static Register ReturnValue2Reg() { return rdx; }
  24   static Register JSCallFunctionReg() { return rdi; }
  25   static Register ContextReg() { return rsi; }
  26   static Register RuntimeCallFunctionReg() { return rbx; }
  27   static Register RuntimeCallArgCountReg() { return rax; }
  28   static RegList CCalleeSaveRegisters() {
  29     if (kWin64) {
  30       return rbx.bit() | rdi.bit() | rsi.bit() | r12.bit() | r13.bit() |
  31              r14.bit() | r15.bit();
  32     } else {
  33       return rbx.bit() | r12.bit() | r13.bit() | r14.bit() | r15.bit();
  34     }
  35   }
  36   static Register CRegisterParameter(int i) {
  37     if (kWin64) {
  38       static Register register_parameters[] = {rcx, rdx, r8, r9};
  39       return register_parameters[i];
  40     } else {
  41       static Register register_parameters[] = {rdi, rsi, rdx, rcx, r8, r9};
  42       return register_parameters[i];
  43     }
  44   }
  45   static int CRegisterParametersLength() { return kWin64 ? 4 : 6; }
  46 };
  47
  48 typedef LinkageHelper<X64LinkageHelperTraits> LH;
  49
  50 CallDescriptor* Linkage::GetJSCallDescriptor(Zone* zone, bool is_osr,
  51                                              int parameter_count,
  52                                              CallDescriptor::Flags flags) {
  53   return LH::GetJSCallDescriptor(zone, is_osr, parameter_count, flags);
  54 }
  55
  56
  57 CallDescriptor* Linkage::GetRuntimeCallDescriptor(
  58     Zone* zone, Runtime::FunctionId function, int parameter_count,
  59     Operator::Properties properties) {
  60   return LH::GetRuntimeCallDescriptor(zone, function, parameter_count,
  61                                       properties);
  62 }
  63
  64
  65 CallDescriptor* Linkage::GetStubCallDescriptor(
  66     Isolate* isolate, Zone* zone, const CallInterfaceDescriptor& descriptor,
  67     int stack_parameter_count, CallDescriptor::Flags flags,
  68     Operator::Properties properties, MachineType return_type) {
  69   return LH::GetStubCallDescriptor(isolate, zone, descriptor,
  70                                    stack_parameter_count, flags, properties,
  71                                    return_type);
  72 }
  73
  74
  75 CallDescriptor* Linkage::GetSimplifiedCDescriptor(Zone* zone,
  76                                                   const MachineSignature* sig) {
  77   return LH::GetSimplifiedCDescriptor(zone, sig);
  78 }
  79
  80 }  // namespace compiler
  81 }  // namespace internal
  82 }  // namespace v8