1 /*
2 * Copyright (c) 2008, 2018, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #include "precompiled.hpp"
26 #include "interpreter/interpreter.hpp"
27 #include "interpreter/interpreterRuntime.hpp"
28 #include "memory/allocation.inline.hpp"
29 #include "memory/universe.hpp"
30 #include "oops/method.hpp"
31 #include "oops/oop.inline.hpp"
32 #include "runtime/handles.inline.hpp"
33 #include "runtime/icache.hpp"
34 #include "runtime/interfaceSupport.hpp"
35 #include "runtime/signature.hpp"
36
37 #define __ _masm->
38
39 #ifdef SHARING_FAST_NATIVE_FINGERPRINTS
40 // mapping from SignatureIterator param to (common) type of parsing
41 static const u1 shared_type[] = {
42 (u1) SignatureIterator::int_parm, // bool
43 (u1) SignatureIterator::int_parm, // byte
44 (u1) SignatureIterator::int_parm, // char
45 (u1) SignatureIterator::int_parm, // short
46 (u1) SignatureIterator::int_parm, // int
47 (u1) SignatureIterator::long_parm, // long
48 #ifndef __ABI_HARD__
49 (u1) SignatureIterator::int_parm, // float, passed as int
50 (u1) SignatureIterator::long_parm, // double, passed as long
51 #else
52 (u1) SignatureIterator::float_parm, // float
53 (u1) SignatureIterator::double_parm, // double
54 #endif
55 (u1) SignatureIterator::obj_parm, // obj
56 (u1) SignatureIterator::done_parm // done
57 };
58
59 uint64_t InterpreterRuntime::normalize_fast_native_fingerprint(uint64_t fingerprint) {
60 if (fingerprint == UCONST64(-1)) {
61 // special signature used when the argument list cannot be encoded in a 64 bits value
62 return fingerprint;
63 }
64 int shift = SignatureIterator::static_feature_size;
65 uint64_t result = fingerprint & ((1 << shift) - 1);
66 fingerprint >>= shift;
67
68 BasicType ret_type = (BasicType) (fingerprint & SignatureIterator::result_feature_mask);
69 // For ARM, the fast signature handler only needs to know whether
70 // the return value must be unboxed. T_OBJECT and T_ARRAY need not
71 // be distinguished from each other and all other return values
72 // behave like integers with respect to the handler.
73 bool unbox = (ret_type == T_OBJECT) || (ret_type == T_ARRAY);
74 if (unbox) {
75 ret_type = T_OBJECT;
76 } else {
77 ret_type = T_INT;
78 }
79 result |= ((uint64_t) ret_type) << shift;
80 shift += SignatureIterator::result_feature_size;
81 fingerprint >>= SignatureIterator::result_feature_size;
82
83 while (true) {
84 uint32_t type = (uint32_t) (fingerprint & SignatureIterator::parameter_feature_mask);
85 if (type == SignatureIterator::done_parm) {
86 result |= ((uint64_t) SignatureIterator::done_parm) << shift;
87 return result;
88 }
89 assert((type >= SignatureIterator::bool_parm) && (type <= SignatureIterator::obj_parm), "check fingerprint encoding");
90 int shared = shared_type[type - SignatureIterator::bool_parm];
91 result |= ((uint64_t) shared) << shift;
92 shift += SignatureIterator::parameter_feature_size;
93 fingerprint >>= SignatureIterator::parameter_feature_size;
94 }
95 }
96 #endif // SHARING_FAST_NATIVE_FINGERPRINTS
97
98 // Implementation of SignatureHandlerGenerator
99 void InterpreterRuntime::SignatureHandlerGenerator::pass_int() {
100 if (_ireg < GPR_PARAMS) {
101 Register dst = as_Register(_ireg);
102 __ ldr_s32(dst, Address(Rlocals, Interpreter::local_offset_in_bytes(offset())));
103 _ireg++;
104 } else {
105 __ ldr_s32(Rtemp, Address(Rlocals, Interpreter::local_offset_in_bytes(offset())));
106 __ str_32(Rtemp, Address(SP, _abi_offset * wordSize));
107 _abi_offset++;
108 }
109 }
110
111 void InterpreterRuntime::SignatureHandlerGenerator::pass_long() {
112 #ifdef AARCH64
113 if (_ireg < GPR_PARAMS) {
114 Register dst = as_Register(_ireg);
115 __ ldr(dst, Address(Rlocals, Interpreter::local_offset_in_bytes(offset() + 1)));
116 _ireg++;
117 } else {
118 __ ldr(Rtemp, Address(Rlocals, Interpreter::local_offset_in_bytes(offset() + 1)));
119 __ str(Rtemp, Address(SP, _abi_offset * wordSize));
120 _abi_offset++;
121 }
122 #else
123 if (_ireg <= 2) {
124 #if (ALIGN_WIDE_ARGUMENTS == 1)
125 if ((_ireg & 1) != 0) {
126 // 64-bit values should be 8-byte aligned
127 _ireg++;
128 }
129 #endif
130 Register dst1 = as_Register(_ireg);
131 Register dst2 = as_Register(_ireg+1);
132 __ ldr(dst1, Address(Rlocals, Interpreter::local_offset_in_bytes(offset()+1)));
133 __ ldr(dst2, Address(Rlocals, Interpreter::local_offset_in_bytes(offset())));
134 _ireg += 2;
135 #if (ALIGN_WIDE_ARGUMENTS == 0)
136 } else if (_ireg == 3) {
137 // uses R3 + one stack slot
138 Register dst1 = as_Register(_ireg);
139 __ ldr(Rtemp, Address(Rlocals, Interpreter::local_offset_in_bytes(offset())));
140 __ ldr(dst1, Address(Rlocals, Interpreter::local_offset_in_bytes(offset()+1)));
141 __ str(Rtemp, Address(SP, _abi_offset * wordSize));
142 _ireg += 1;
143 _abi_offset += 1;
144 #endif
145 } else {
146 #if (ALIGN_WIDE_ARGUMENTS == 1)
147 if(_abi_offset & 1) _abi_offset++;
148 #endif
149 __ ldr(Rtemp, Address(Rlocals, Interpreter::local_offset_in_bytes(offset()+1)));
150 __ str(Rtemp, Address(SP, (_abi_offset) * wordSize));
151 __ ldr(Rtemp, Address(Rlocals, Interpreter::local_offset_in_bytes(offset())));
152 __ str(Rtemp, Address(SP, (_abi_offset+1) * wordSize));
153 _abi_offset += 2;
154 _ireg = 4;
155 }
156 #endif // AARCH64
157 }
158
159 void InterpreterRuntime::SignatureHandlerGenerator::pass_object() {
160 #ifdef AARCH64
161 __ ldr(Rtemp, Address(Rlocals, Interpreter::local_offset_in_bytes(offset())));
162 __ cmp(Rtemp, 0);
163 __ sub(Rtemp, Rlocals, -Interpreter::local_offset_in_bytes(offset()));
164 if (_ireg < GPR_PARAMS) {
165 Register dst = as_Register(_ireg);
166 __ csel(dst, ZR, Rtemp, eq);
167 _ireg++;
168 } else {
169 __ csel(Rtemp, ZR, Rtemp, eq);
170 __ str(Rtemp, Address(SP, _abi_offset * wordSize));
171 _abi_offset++;
172 }
173 #else
174 if (_ireg < 4) {
175 Register dst = as_Register(_ireg);
176 __ ldr(dst, Address(Rlocals, Interpreter::local_offset_in_bytes(offset())));
177 __ cmp(dst, 0);
178 __ sub(dst, Rlocals, -Interpreter::local_offset_in_bytes(offset()), ne);
179 _ireg++;
180 } else {
181 __ ldr(Rtemp, Address(Rlocals, Interpreter::local_offset_in_bytes(offset())));
182 __ cmp(Rtemp, 0);
183 __ sub(Rtemp, Rlocals, -Interpreter::local_offset_in_bytes(offset()), ne);
184 __ str(Rtemp, Address(SP, _abi_offset * wordSize));
185 _abi_offset++;
186 }
187 #endif // AARCH64
188 }
189
190 #ifndef __ABI_HARD__
191 void InterpreterRuntime::SignatureHandlerGenerator::pass_float() {
192 if (_ireg < 4) {
193 Register dst = as_Register(_ireg);
194 __ ldr(dst, Address(Rlocals, Interpreter::local_offset_in_bytes(offset())));
195 _ireg++;
196 } else {
197 __ ldr(Rtemp, Address(Rlocals, Interpreter::local_offset_in_bytes(offset())));
198 __ str(Rtemp, Address(SP, _abi_offset * wordSize));
199 _abi_offset++;
200 }
201 }
202
203 #else
204 #ifndef __SOFTFP__
205 void InterpreterRuntime::SignatureHandlerGenerator::pass_float() {
206 #ifdef AARCH64
207 if (_freg < FPR_PARAMS) {
208 FloatRegister dst = as_FloatRegister(_freg);
209 __ ldr_s(dst, Address(Rlocals, Interpreter::local_offset_in_bytes(offset())));
210 _freg++;
211 } else {
212 __ ldr_u32(Rtemp, Address(Rlocals, Interpreter::local_offset_in_bytes(offset())));
213 __ str_32(Rtemp, Address(SP, _abi_offset * wordSize));
214 _abi_offset++;
215 }
216 #else
217 if((_fp_slot < 16) || (_single_fpr_slot & 1)) {
218 if ((_single_fpr_slot & 1) == 0) {
219 _single_fpr_slot = _fp_slot;
220 _fp_slot += 2;
221 }
222 __ flds(as_FloatRegister(_single_fpr_slot), Address(Rlocals, Interpreter::local_offset_in_bytes(offset())));
223 _single_fpr_slot++;
224 } else {
225 __ ldr(Rtemp, Address(Rlocals, Interpreter::local_offset_in_bytes(offset())));
226 __ str(Rtemp, Address(SP, _abi_offset * wordSize));
227 _abi_offset++;
228 }
229 #endif // AARCH64
230 }
231
232 void InterpreterRuntime::SignatureHandlerGenerator::pass_double() {
233 #ifdef AARCH64
234 if (_freg < FPR_PARAMS) {
235 FloatRegister dst = as_FloatRegister(_freg);
236 __ ldr_d(dst, Address(Rlocals, Interpreter::local_offset_in_bytes(offset() + 1)));
237 _freg++;
238 } else {
239 __ ldr(Rtemp, Address(Rlocals, Interpreter::local_offset_in_bytes(offset() + 1)));
240 __ str(Rtemp, Address(SP, _abi_offset * wordSize));
241 _abi_offset++;
242 }
243 #else
244 if(_fp_slot <= 14) {
245 __ fldd(as_FloatRegister(_fp_slot), Address(Rlocals, Interpreter::local_offset_in_bytes(offset()+1)));
246 _fp_slot += 2;
247 } else {
248 __ ldr(Rtemp, Address(Rlocals, Interpreter::local_offset_in_bytes(offset()+1)));
249 __ str(Rtemp, Address(SP, (_abi_offset) * wordSize));
250 __ ldr(Rtemp, Address(Rlocals, Interpreter::local_offset_in_bytes(offset())));
251 __ str(Rtemp, Address(SP, (_abi_offset+1) * wordSize));
252 _abi_offset += 2;
253 _single_fpr_slot = 16;
254 }
255 #endif // AARCH64
256 }
257 #endif // __SOFTFP__
258 #endif // __ABI_HARD__
259
260 void InterpreterRuntime::SignatureHandlerGenerator::generate(uint64_t fingerprint) {
261 iterate(fingerprint);
262
263 BasicType result_type = SignatureIterator::return_type(fingerprint);
264
265 address result_handler = Interpreter::result_handler(result_type);
266
267 #ifdef AARCH64
268 __ mov_slow(R0, (address)result_handler);
269 #else
270 // Check that result handlers are not real handler on ARM (0 or -1).
271 // This ensures the signature handlers do not need symbolic information.
272 assert((result_handler == NULL)||(result_handler==(address)0xffffffff),"");
273 __ mov_slow(R0, (intptr_t)result_handler);
274 #endif
275
276 __ ret();
277 }
278
279
280 // Implementation of SignatureHandlerLibrary
281
282 void SignatureHandlerLibrary::pd_set_handler(address handler) {}
283
284 class SlowSignatureHandler: public NativeSignatureIterator {
285 private:
286 address _from;
287 intptr_t* _to;
288
289 #ifndef __ABI_HARD__
290 virtual void pass_int() {
291 *_to++ = *(jint *)(_from+Interpreter::local_offset_in_bytes(0));
292 _from -= Interpreter::stackElementSize;
293 }
294
295 virtual void pass_float() {
296 *_to++ = *(jint *)(_from+Interpreter::local_offset_in_bytes(0));
297 _from -= Interpreter::stackElementSize;
298 }
299
300 virtual void pass_long() {
301 #if (ALIGN_WIDE_ARGUMENTS == 1)
302 if (((intptr_t)_to & 7) != 0) {
303 // 64-bit values should be 8-byte aligned
304 _to++;
305 }
306 #endif
307 _to[0] = *(intptr_t*)(_from+Interpreter::local_offset_in_bytes(1));
308 _to[1] = *(intptr_t*)(_from+Interpreter::local_offset_in_bytes(0));
309 _to += 2;
310 _from -= 2*Interpreter::stackElementSize;
311 }
312
313 virtual void pass_object() {
314 intptr_t from_addr = (intptr_t)(_from + Interpreter::local_offset_in_bytes(0));
315 *_to++ = (*(intptr_t*)from_addr == 0) ? (intptr_t)NULL : from_addr;
316 _from -= Interpreter::stackElementSize;
317 }
318
319 #else
320
321 intptr_t* _toFP;
322 intptr_t* _toGP;
323 int _last_gp;
324 int _last_fp;
325 #ifndef AARCH64
326 int _last_single_fp;
327 #endif // !AARCH64
328
329 virtual void pass_int() {
330 if(_last_gp < GPR_PARAMS) {
331 _toGP[_last_gp++] = *(jint *)(_from+Interpreter::local_offset_in_bytes(0));
332 } else {
333 *_to++ = *(jint *)(_from+Interpreter::local_offset_in_bytes(0));
334 }
335 _from -= Interpreter::stackElementSize;
336 }
337
338 virtual void pass_long() {
339 #ifdef AARCH64
340 if(_last_gp < GPR_PARAMS) {
341 _toGP[_last_gp++] = *(jlong *)(_from+Interpreter::local_offset_in_bytes(1));
342 } else {
343 *_to++ = *(jlong *)(_from+Interpreter::local_offset_in_bytes(1));
344 }
345 #else
346 assert(ALIGN_WIDE_ARGUMENTS == 1, "ABI_HARD not supported with unaligned wide arguments");
347 if (_last_gp <= 2) {
348 if(_last_gp & 1) _last_gp++;
349 _toGP[_last_gp++] = *(jint *)(_from+Interpreter::local_offset_in_bytes(1));
350 _toGP[_last_gp++] = *(jint *)(_from+Interpreter::local_offset_in_bytes(0));
351 } else {
352 if (((intptr_t)_to & 7) != 0) {
353 // 64-bit values should be 8-byte aligned
354 _to++;
355 }
356 _to[0] = *(intptr_t*)(_from+Interpreter::local_offset_in_bytes(1));
357 _to[1] = *(intptr_t*)(_from+Interpreter::local_offset_in_bytes(0));
358 _to += 2;
359 _last_gp = 4;
360 }
361 #endif // AARCH64
362 _from -= 2*Interpreter::stackElementSize;
363 }
364
365 virtual void pass_object() {
366 intptr_t from_addr = (intptr_t)(_from + Interpreter::local_offset_in_bytes(0));
367 if(_last_gp < GPR_PARAMS) {
368 _toGP[_last_gp++] = (*(intptr_t*)from_addr == 0) ? NULL : from_addr;
369 } else {
370 *_to++ = (*(intptr_t*)from_addr == 0) ? NULL : from_addr;
371 }
372 _from -= Interpreter::stackElementSize;
373 }
374
375 virtual void pass_float() {
376 #ifdef AARCH64
377 if(_last_fp < FPR_PARAMS) {
378 _toFP[_last_fp++] = *(jint *)(_from+Interpreter::local_offset_in_bytes(0));
379 } else {
380 *_to++ = *(jint *)(_from+Interpreter::local_offset_in_bytes(0));
381 }
382 #else
383 if((_last_fp < 16) || (_last_single_fp & 1)) {
384 if ((_last_single_fp & 1) == 0) {
385 _last_single_fp = _last_fp;
386 _last_fp += 2;
387 }
388
389 _toFP[_last_single_fp++] = *(jint *)(_from+Interpreter::local_offset_in_bytes(0));
390 } else {
391 *_to++ = *(jint *)(_from+Interpreter::local_offset_in_bytes(0));
392 }
393 #endif // AARCH64
394 _from -= Interpreter::stackElementSize;
395 }
396
397 virtual void pass_double() {
398 #ifdef AARCH64
399 if(_last_fp < FPR_PARAMS) {
400 _toFP[_last_fp++] = *(intptr_t*)(_from+Interpreter::local_offset_in_bytes(1));
401 } else {
402 *_to++ = *(intptr_t*)(_from+Interpreter::local_offset_in_bytes(1));
403 }
404 #else
405 assert(ALIGN_WIDE_ARGUMENTS == 1, "ABI_HARD not supported with unaligned wide arguments");
406 if(_last_fp <= 14) {
407 _toFP[_last_fp++] = *(intptr_t*)(_from+Interpreter::local_offset_in_bytes(1));
408 _toFP[_last_fp++] = *(intptr_t*)(_from+Interpreter::local_offset_in_bytes(0));
409 } else {
410 if (((intptr_t)_to & 7) != 0) { // 64-bit values should be 8-byte aligned
411 _to++;
412 }
413 _to[0] = *(intptr_t*)(_from+Interpreter::local_offset_in_bytes(1));
414 _to[1] = *(intptr_t*)(_from+Interpreter::local_offset_in_bytes(0));
415 _to += 2;
416 _last_single_fp = 16;
417 }
418 #endif // AARCH64
419 _from -= 2*Interpreter::stackElementSize;
420 }
421
422 #endif // !__ABI_HARD__
423
424 public:
425 SlowSignatureHandler(const methodHandle& method, address from, intptr_t* to) :
426 NativeSignatureIterator(method) {
427 _from = from;
428
429 #ifdef __ABI_HARD__
430 _toGP = to;
431 _toFP = _toGP + GPR_PARAMS;
432 _to = _toFP + AARCH64_ONLY(FPR_PARAMS) NOT_AARCH64(8*2);
433 _last_gp = (is_static() ? 2 : 1);
434 _last_fp = 0;
435 #ifndef AARCH64
436 _last_single_fp = 0;
437 #endif // !AARCH64
438 #else
439 _to = to + (is_static() ? 2 : 1);
440 #endif // __ABI_HARD__
441 }
442 };
443
444 IRT_ENTRY(address, InterpreterRuntime::slow_signature_handler(JavaThread* thread, Method* method, intptr_t* from, intptr_t* to))
445 methodHandle m(thread, (Method*)method);
446 assert(m->is_native(), "sanity check");
447 SlowSignatureHandler(m, (address)from, to).iterate(UCONST64(-1));
448 return Interpreter::result_handler(m->result_type());
449 IRT_END