1 /*
2  * Copyright (C) 2014 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 #include "calling_convention_x86_64.h"
18 
19 #include "base/bit_utils.h"
20 #include "base/logging.h"
21 #include "handle_scope-inl.h"
22 #include "utils/x86_64/managed_register_x86_64.h"
23 
24 namespace art {
25 namespace x86_64 {
26 
27 // Calling convention
28 
InterproceduralScratchRegister()29 ManagedRegister X86_64ManagedRuntimeCallingConvention::InterproceduralScratchRegister() {
30   return X86_64ManagedRegister::FromCpuRegister(RAX);
31 }
32 
InterproceduralScratchRegister()33 ManagedRegister X86_64JniCallingConvention::InterproceduralScratchRegister() {
34   return X86_64ManagedRegister::FromCpuRegister(RAX);
35 }
36 
ReturnScratchRegister() const37 ManagedRegister X86_64JniCallingConvention::ReturnScratchRegister() const {
38   return ManagedRegister::NoRegister();  // No free regs, so assembler uses push/pop
39 }
40 
ReturnRegisterForShorty(const char * shorty,bool jni)41 static ManagedRegister ReturnRegisterForShorty(const char* shorty, bool jni) {
42   UNUSED(jni);
43   if (shorty[0] == 'F' || shorty[0] == 'D') {
44     return X86_64ManagedRegister::FromXmmRegister(XMM0);
45   } else if (shorty[0] == 'J') {
46     return X86_64ManagedRegister::FromCpuRegister(RAX);
47   } else if (shorty[0] == 'V') {
48     return ManagedRegister::NoRegister();
49   } else {
50     return X86_64ManagedRegister::FromCpuRegister(RAX);
51   }
52 }
53 
ReturnRegister()54 ManagedRegister X86_64ManagedRuntimeCallingConvention::ReturnRegister() {
55   return ReturnRegisterForShorty(GetShorty(), false);
56 }
57 
ReturnRegister()58 ManagedRegister X86_64JniCallingConvention::ReturnRegister() {
59   return ReturnRegisterForShorty(GetShorty(), true);
60 }
61 
IntReturnRegister()62 ManagedRegister X86_64JniCallingConvention::IntReturnRegister() {
63   return X86_64ManagedRegister::FromCpuRegister(RAX);
64 }
65 
66 // Managed runtime calling convention
67 
MethodRegister()68 ManagedRegister X86_64ManagedRuntimeCallingConvention::MethodRegister() {
69   return X86_64ManagedRegister::FromCpuRegister(RDI);
70 }
71 
IsCurrentParamInRegister()72 bool X86_64ManagedRuntimeCallingConvention::IsCurrentParamInRegister() {
73   return !IsCurrentParamOnStack();
74 }
75 
IsCurrentParamOnStack()76 bool X86_64ManagedRuntimeCallingConvention::IsCurrentParamOnStack() {
77   // We assume all parameters are on stack, args coming via registers are spilled as entry_spills
78   return true;
79 }
80 
CurrentParamRegister()81 ManagedRegister X86_64ManagedRuntimeCallingConvention::CurrentParamRegister() {
82   ManagedRegister res = ManagedRegister::NoRegister();
83   if (!IsCurrentParamAFloatOrDouble()) {
84     switch (itr_args_ - itr_float_and_doubles_) {
85     case 0: res = X86_64ManagedRegister::FromCpuRegister(RSI); break;
86     case 1: res = X86_64ManagedRegister::FromCpuRegister(RDX); break;
87     case 2: res = X86_64ManagedRegister::FromCpuRegister(RCX); break;
88     case 3: res = X86_64ManagedRegister::FromCpuRegister(R8); break;
89     case 4: res = X86_64ManagedRegister::FromCpuRegister(R9); break;
90     }
91   } else if (itr_float_and_doubles_ < 8) {
92     // First eight float parameters are passed via XMM0..XMM7
93     res = X86_64ManagedRegister::FromXmmRegister(
94                                  static_cast<FloatRegister>(XMM0 + itr_float_and_doubles_));
95   }
96   return res;
97 }
98 
CurrentParamStackOffset()99 FrameOffset X86_64ManagedRuntimeCallingConvention::CurrentParamStackOffset() {
100   return FrameOffset(displacement_.Int32Value() +  // displacement
101                      kX86_64PointerSize +  // Method ref
102                      itr_slots_ * sizeof(uint32_t));  // offset into in args
103 }
104 
EntrySpills()105 const ManagedRegisterEntrySpills& X86_64ManagedRuntimeCallingConvention::EntrySpills() {
106   // We spill the argument registers on X86 to free them up for scratch use, we then assume
107   // all arguments are on the stack.
108   if (entry_spills_.size() == 0) {
109     ResetIterator(FrameOffset(0));
110     while (HasNext()) {
111       ManagedRegister in_reg = CurrentParamRegister();
112       if (!in_reg.IsNoRegister()) {
113         int32_t size = IsParamALongOrDouble(itr_args_)? 8 : 4;
114         int32_t spill_offset = CurrentParamStackOffset().Uint32Value();
115         ManagedRegisterSpill spill(in_reg, size, spill_offset);
116         entry_spills_.push_back(spill);
117       }
118       Next();
119     }
120   }
121   return entry_spills_;
122 }
123 
124 // JNI calling convention
125 
X86_64JniCallingConvention(bool is_static,bool is_synchronized,const char * shorty)126 X86_64JniCallingConvention::X86_64JniCallingConvention(bool is_static, bool is_synchronized,
127                                                        const char* shorty)
128     : JniCallingConvention(is_static, is_synchronized, shorty, kFramePointerSize) {
129   callee_save_regs_.push_back(X86_64ManagedRegister::FromCpuRegister(RBX));
130   callee_save_regs_.push_back(X86_64ManagedRegister::FromCpuRegister(RBP));
131   callee_save_regs_.push_back(X86_64ManagedRegister::FromCpuRegister(R12));
132   callee_save_regs_.push_back(X86_64ManagedRegister::FromCpuRegister(R13));
133   callee_save_regs_.push_back(X86_64ManagedRegister::FromCpuRegister(R14));
134   callee_save_regs_.push_back(X86_64ManagedRegister::FromCpuRegister(R15));
135   callee_save_regs_.push_back(X86_64ManagedRegister::FromXmmRegister(XMM12));
136   callee_save_regs_.push_back(X86_64ManagedRegister::FromXmmRegister(XMM13));
137   callee_save_regs_.push_back(X86_64ManagedRegister::FromXmmRegister(XMM14));
138   callee_save_regs_.push_back(X86_64ManagedRegister::FromXmmRegister(XMM15));
139 }
140 
CoreSpillMask() const141 uint32_t X86_64JniCallingConvention::CoreSpillMask() const {
142   return 1 << RBX | 1 << RBP | 1 << R12 | 1 << R13 | 1 << R14 | 1 << R15 |
143       1 << kNumberOfCpuRegisters;
144 }
145 
FpSpillMask() const146 uint32_t X86_64JniCallingConvention::FpSpillMask() const {
147   return 1 << XMM12 | 1 << XMM13 | 1 << XMM14 | 1 << XMM15;
148 }
149 
FrameSize()150 size_t X86_64JniCallingConvention::FrameSize() {
151   // Method*, return address and callee save area size, local reference segment state
152   size_t frame_data_size = kX86_64PointerSize +
153       (2 + CalleeSaveRegisters().size()) * kFramePointerSize;
154   // References plus link_ (pointer) and number_of_references_ (uint32_t) for HandleScope header
155   size_t handle_scope_size = HandleScope::SizeOf(kFramePointerSize, ReferenceCount());
156   // Plus return value spill area size
157   return RoundUp(frame_data_size + handle_scope_size + SizeOfReturnValue(), kStackAlignment);
158 }
159 
OutArgSize()160 size_t X86_64JniCallingConvention::OutArgSize() {
161   return RoundUp(NumberOfOutgoingStackArgs() * kFramePointerSize, kStackAlignment);
162 }
163 
IsCurrentParamInRegister()164 bool X86_64JniCallingConvention::IsCurrentParamInRegister() {
165   return !IsCurrentParamOnStack();
166 }
167 
IsCurrentParamOnStack()168 bool X86_64JniCallingConvention::IsCurrentParamOnStack() {
169   return CurrentParamRegister().IsNoRegister();
170 }
171 
CurrentParamRegister()172 ManagedRegister X86_64JniCallingConvention::CurrentParamRegister() {
173   ManagedRegister res = ManagedRegister::NoRegister();
174   if (!IsCurrentParamAFloatOrDouble()) {
175     switch (itr_args_ - itr_float_and_doubles_) {
176     case 0: res = X86_64ManagedRegister::FromCpuRegister(RDI); break;
177     case 1: res = X86_64ManagedRegister::FromCpuRegister(RSI); break;
178     case 2: res = X86_64ManagedRegister::FromCpuRegister(RDX); break;
179     case 3: res = X86_64ManagedRegister::FromCpuRegister(RCX); break;
180     case 4: res = X86_64ManagedRegister::FromCpuRegister(R8); break;
181     case 5: res = X86_64ManagedRegister::FromCpuRegister(R9); break;
182     }
183   } else if (itr_float_and_doubles_ < 8) {
184     // First eight float parameters are passed via XMM0..XMM7
185     res = X86_64ManagedRegister::FromXmmRegister(
186                                  static_cast<FloatRegister>(XMM0 + itr_float_and_doubles_));
187   }
188   return res;
189 }
190 
CurrentParamStackOffset()191 FrameOffset X86_64JniCallingConvention::CurrentParamStackOffset() {
192   size_t offset = itr_args_
193       - std::min(8U, itr_float_and_doubles_)               // Float arguments passed through Xmm0..Xmm7
194       - std::min(6U, itr_args_ - itr_float_and_doubles_);  // Integer arguments passed through GPR
195   return FrameOffset(displacement_.Int32Value() - OutArgSize() + (offset * kFramePointerSize));
196 }
197 
NumberOfOutgoingStackArgs()198 size_t X86_64JniCallingConvention::NumberOfOutgoingStackArgs() {
199   size_t static_args = IsStatic() ? 1 : 0;  // count jclass
200   // regular argument parameters and this
201   size_t param_args = NumArgs() + NumLongOrDoubleArgs();
202   // count JNIEnv* and return pc (pushed after Method*)
203   size_t total_args = static_args + param_args + 2;
204 
205   // Float arguments passed through Xmm0..Xmm7
206   // Other (integer) arguments passed through GPR (RDI, RSI, RDX, RCX, R8, R9)
207   size_t total_stack_args = total_args
208                             - std::min(8U, static_cast<unsigned int>(NumFloatOrDoubleArgs()))
209                             - std::min(6U, static_cast<unsigned int>(NumArgs() - NumFloatOrDoubleArgs()));
210 
211   return total_stack_args;
212 }
213 
214 }  // namespace x86_64
215 }  // namespace art
216