1 /*
2 * Copyright (C) 2011 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 "base/logging.h"
18 #include "calling_convention_arm.h"
19 #include "utils/arm/managed_register_arm.h"
20
21 namespace art {
22 namespace arm {
23
24 // Calling convention
25
InterproceduralScratchRegister()26 ManagedRegister ArmManagedRuntimeCallingConvention::InterproceduralScratchRegister() {
27 return ArmManagedRegister::FromCoreRegister(IP); // R12
28 }
29
InterproceduralScratchRegister()30 ManagedRegister ArmJniCallingConvention::InterproceduralScratchRegister() {
31 return ArmManagedRegister::FromCoreRegister(IP); // R12
32 }
33
ReturnRegisterForShorty(const char * shorty)34 static ManagedRegister ReturnRegisterForShorty(const char* shorty) {
35 if (shorty[0] == 'F') {
36 return ArmManagedRegister::FromCoreRegister(R0);
37 } else if (shorty[0] == 'D') {
38 return ArmManagedRegister::FromRegisterPair(R0_R1);
39 } else if (shorty[0] == 'J') {
40 return ArmManagedRegister::FromRegisterPair(R0_R1);
41 } else if (shorty[0] == 'V') {
42 return ArmManagedRegister::NoRegister();
43 } else {
44 return ArmManagedRegister::FromCoreRegister(R0);
45 }
46 }
47
ReturnRegister()48 ManagedRegister ArmManagedRuntimeCallingConvention::ReturnRegister() {
49 return ReturnRegisterForShorty(GetShorty());
50 }
51
ReturnRegister()52 ManagedRegister ArmJniCallingConvention::ReturnRegister() {
53 return ReturnRegisterForShorty(GetShorty());
54 }
55
IntReturnRegister()56 ManagedRegister ArmJniCallingConvention::IntReturnRegister() {
57 return ArmManagedRegister::FromCoreRegister(R0);
58 }
59
60 // Managed runtime calling convention
61
MethodRegister()62 ManagedRegister ArmManagedRuntimeCallingConvention::MethodRegister() {
63 return ArmManagedRegister::FromCoreRegister(R0);
64 }
65
IsCurrentParamInRegister()66 bool ArmManagedRuntimeCallingConvention::IsCurrentParamInRegister() {
67 return false; // Everything moved to stack on entry.
68 }
69
IsCurrentParamOnStack()70 bool ArmManagedRuntimeCallingConvention::IsCurrentParamOnStack() {
71 return true;
72 }
73
CurrentParamRegister()74 ManagedRegister ArmManagedRuntimeCallingConvention::CurrentParamRegister() {
75 LOG(FATAL) << "Should not reach here";
76 return ManagedRegister::NoRegister();
77 }
78
CurrentParamStackOffset()79 FrameOffset ArmManagedRuntimeCallingConvention::CurrentParamStackOffset() {
80 CHECK(IsCurrentParamOnStack());
81 FrameOffset result =
82 FrameOffset(displacement_.Int32Value() + // displacement
83 kFramePointerSize + // Method*
84 (itr_slots_ * kFramePointerSize)); // offset into in args
85 return result;
86 }
87
EntrySpills()88 const ManagedRegisterEntrySpills& ArmManagedRuntimeCallingConvention::EntrySpills() {
89 // We spill the argument registers on ARM to free them up for scratch use, we then assume
90 // all arguments are on the stack.
91 if (entry_spills_.size() == 0) {
92 size_t num_spills = NumArgs() + NumLongOrDoubleArgs();
93 if (num_spills > 0) {
94 entry_spills_.push_back(ArmManagedRegister::FromCoreRegister(R1));
95 if (num_spills > 1) {
96 entry_spills_.push_back(ArmManagedRegister::FromCoreRegister(R2));
97 if (num_spills > 2) {
98 entry_spills_.push_back(ArmManagedRegister::FromCoreRegister(R3));
99 }
100 }
101 }
102 }
103 return entry_spills_;
104 }
105 // JNI calling convention
106
ArmJniCallingConvention(bool is_static,bool is_synchronized,const char * shorty)107 ArmJniCallingConvention::ArmJniCallingConvention(bool is_static, bool is_synchronized,
108 const char* shorty)
109 : JniCallingConvention(is_static, is_synchronized, shorty, kFramePointerSize) {
110 // Compute padding to ensure longs and doubles are not split in AAPCS. Ignore the 'this' jobject
111 // or jclass for static methods and the JNIEnv. We start at the aligned register r2.
112 size_t padding = 0;
113 for (size_t cur_arg = IsStatic() ? 0 : 1, cur_reg = 2; cur_arg < NumArgs(); cur_arg++) {
114 if (IsParamALongOrDouble(cur_arg)) {
115 if ((cur_reg & 1) != 0) {
116 padding += 4;
117 cur_reg++; // additional bump to ensure alignment
118 }
119 cur_reg++; // additional bump to skip extra long word
120 }
121 cur_reg++; // bump the iterator for every argument
122 }
123 padding_ = padding;
124
125 callee_save_regs_.push_back(ArmManagedRegister::FromCoreRegister(R5));
126 callee_save_regs_.push_back(ArmManagedRegister::FromCoreRegister(R6));
127 callee_save_regs_.push_back(ArmManagedRegister::FromCoreRegister(R7));
128 callee_save_regs_.push_back(ArmManagedRegister::FromCoreRegister(R8));
129 callee_save_regs_.push_back(ArmManagedRegister::FromCoreRegister(R10));
130 callee_save_regs_.push_back(ArmManagedRegister::FromCoreRegister(R11));
131 }
132
CoreSpillMask() const133 uint32_t ArmJniCallingConvention::CoreSpillMask() const {
134 // Compute spill mask to agree with callee saves initialized in the constructor
135 uint32_t result = 0;
136 result = 1 << R5 | 1 << R6 | 1 << R7 | 1 << R8 | 1 << R10 | 1 << R11 | 1 << LR;
137 return result;
138 }
139
ReturnScratchRegister() const140 ManagedRegister ArmJniCallingConvention::ReturnScratchRegister() const {
141 return ArmManagedRegister::FromCoreRegister(R2);
142 }
143
FrameSize()144 size_t ArmJniCallingConvention::FrameSize() {
145 // Method*, LR and callee save area size, local reference segment state
146 size_t frame_data_size = sizeof(StackReference<mirror::ArtMethod>) +
147 (2 + CalleeSaveRegisters().size()) * kFramePointerSize;
148 // References plus 2 words for HandleScope header
149 size_t handle_scope_size = HandleScope::SizeOf(kFramePointerSize, ReferenceCount());
150 // Plus return value spill area size
151 return RoundUp(frame_data_size + handle_scope_size + SizeOfReturnValue(), kStackAlignment);
152 }
153
OutArgSize()154 size_t ArmJniCallingConvention::OutArgSize() {
155 return RoundUp(NumberOfOutgoingStackArgs() * kFramePointerSize + padding_,
156 kStackAlignment);
157 }
158
159 // JniCallingConvention ABI follows AAPCS where longs and doubles must occur
160 // in even register numbers and stack slots
Next()161 void ArmJniCallingConvention::Next() {
162 JniCallingConvention::Next();
163 size_t arg_pos = itr_args_ - NumberOfExtraArgumentsForJni();
164 if ((itr_args_ >= 2) &&
165 (arg_pos < NumArgs()) &&
166 IsParamALongOrDouble(arg_pos)) {
167 // itr_slots_ needs to be an even number, according to AAPCS.
168 if ((itr_slots_ & 0x1u) != 0) {
169 itr_slots_++;
170 }
171 }
172 }
173
IsCurrentParamInRegister()174 bool ArmJniCallingConvention::IsCurrentParamInRegister() {
175 return itr_slots_ < 4;
176 }
177
IsCurrentParamOnStack()178 bool ArmJniCallingConvention::IsCurrentParamOnStack() {
179 return !IsCurrentParamInRegister();
180 }
181
182 static const Register kJniArgumentRegisters[] = {
183 R0, R1, R2, R3
184 };
CurrentParamRegister()185 ManagedRegister ArmJniCallingConvention::CurrentParamRegister() {
186 CHECK_LT(itr_slots_, 4u);
187 int arg_pos = itr_args_ - NumberOfExtraArgumentsForJni();
188 if ((itr_args_ >= 2) && IsParamALongOrDouble(arg_pos)) {
189 CHECK_EQ(itr_slots_, 2u);
190 return ArmManagedRegister::FromRegisterPair(R2_R3);
191 } else {
192 return
193 ArmManagedRegister::FromCoreRegister(kJniArgumentRegisters[itr_slots_]);
194 }
195 }
196
CurrentParamStackOffset()197 FrameOffset ArmJniCallingConvention::CurrentParamStackOffset() {
198 CHECK_GE(itr_slots_, 4u);
199 size_t offset = displacement_.Int32Value() - OutArgSize() + ((itr_slots_ - 4) * kFramePointerSize);
200 CHECK_LT(offset, OutArgSize());
201 return FrameOffset(offset);
202 }
203
NumberOfOutgoingStackArgs()204 size_t ArmJniCallingConvention::NumberOfOutgoingStackArgs() {
205 size_t static_args = IsStatic() ? 1 : 0; // count jclass
206 // regular argument parameters and this
207 size_t param_args = NumArgs() + NumLongOrDoubleArgs();
208 // count JNIEnv* less arguments in registers
209 return static_args + param_args + 1 - 4;
210 }
211
212 } // namespace arm
213 } // namespace art
214