1 #ifdef USE_PRAGMA_IDENT_SRC
2 #pragma ident "@(#)interpreterRT_x86_64.cpp 1.27 07/09/17 09:26:03 JVM"
3 #endif
4 /*
5 * Copyright 2003-2005 Sun Microsystems, Inc. All Rights Reserved.
6 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
7 *
8 * This code is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License version 2 only, as
10 * published by the Free Software Foundation.
11 *
12 * This code is distributed in the hope that it will be useful, but WITHOUT
13 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15 * version 2 for more details (a copy is included in the LICENSE file that
16 * accompanied this code).
17 *
18 * You should have received a copy of the GNU General Public License version
19 * 2 along with this work; if not, write to the Free Software Foundation,
20 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
21 *
22 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
23 * CA 95054 USA or visit www.sun.com if you need additional information or
24 * have any questions.
25 *
26 */
27
28 #include "incls/_precompiled.incl"
29 #include "incls/_interpreterRT_x86_64.cpp.incl"
30
31 #define __ _masm->
32
33 // Implementation of SignatureHandlerGenerator
34
35 Register InterpreterRuntime::SignatureHandlerGenerator::from() { return r14; }
36 Register InterpreterRuntime::SignatureHandlerGenerator::to() { return rsp; }
37 Register InterpreterRuntime::SignatureHandlerGenerator::temp() { return rscratch1; }
38
39 void InterpreterRuntime::SignatureHandlerGenerator::pass_int() {
40 const Address src(from(), Interpreter::local_offset_in_bytes(offset()));
41
42 #ifdef _WIN64
43 switch (_num_args) {
44 case 0:
45 __ movl(c_rarg1, src);
46 _num_args++;
47 break;
48 case 1:
49 __ movl(c_rarg2, src);
50 _num_args++;
51 break;
52 case 2:
53 __ movl(c_rarg3, src);
54 _num_args++;
55 break;
56 default:
57 __ movl(rax, src);
58 __ movl(Address(to(), _stack_offset), rax);
59 _stack_offset += wordSize;
60 break;
61 }
62 #else
63 switch (_num_int_args) {
64 case 0:
65 __ movl(c_rarg1, src);
66 _num_int_args++;
67 break;
68 case 1:
69 __ movl(c_rarg2, src);
70 _num_int_args++;
71 break;
72 case 2:
73 __ movl(c_rarg3, src);
74 _num_int_args++;
75 break;
76 case 3:
77 __ movl(c_rarg4, src);
78 _num_int_args++;
79 break;
80 case 4:
81 __ movl(c_rarg5, src);
82 _num_int_args++;
83 break;
84 default:
85 __ movl(rax, src);
86 __ movl(Address(to(), _stack_offset), rax);
87 _stack_offset += wordSize;
88 break;
89 }
90 #endif
91 }
92
93 void InterpreterRuntime::SignatureHandlerGenerator::pass_long() {
94 const Address src(from(), Interpreter::local_offset_in_bytes(offset() + 1));
95
96 #ifdef _WIN64
97 switch (_num_args) {
98 case 0:
99 __ movq(c_rarg1, src);
100 _num_args++;
101 break;
102 case 1:
103 __ movq(c_rarg2, src);
104 _num_args++;
105 break;
106 case 2:
107 __ movq(c_rarg3, src);
108 _num_args++;
109 break;
110 case 3:
111 default:
112 __ movq(rax, src);
113 __ movq(Address(to(), _stack_offset), rax);
114 _stack_offset += wordSize;
115 break;
116 }
117 #else
118 switch (_num_int_args) {
119 case 0:
120 __ movq(c_rarg1, src);
121 _num_int_args++;
122 break;
123 case 1:
124 __ movq(c_rarg2, src);
125 _num_int_args++;
126 break;
127 case 2:
128 __ movq(c_rarg3, src);
129 _num_int_args++;
130 break;
131 case 3:
132 __ movq(c_rarg4, src);
133 _num_int_args++;
134 break;
135 case 4:
136 __ movq(c_rarg5, src);
137 _num_int_args++;
138 break;
139 default:
140 __ movq(rax, src);
141 __ movq(Address(to(), _stack_offset), rax);
142 _stack_offset += wordSize;
143 break;
144 }
145 #endif
146 }
147
148 void InterpreterRuntime::SignatureHandlerGenerator::pass_float() {
149 const Address src(from(), Interpreter::local_offset_in_bytes(offset()));
150
151 #ifdef _WIN64
152 if (_num_args < Argument::n_float_register_parameters_c-1) {
153 __ movflt(as_XMMRegister(++_num_args), src);
154 } else {
155 __ movl(rax, src);
156 __ movl(Address(to(), _stack_offset), rax);
157 _stack_offset += wordSize;
158 }
159 #else
160 if (_num_fp_args < Argument::n_float_register_parameters_c) {
161 __ movflt(as_XMMRegister(_num_fp_args++), src);
162 } else {
163 __ movl(rax, src);
164 __ movl(Address(to(), _stack_offset), rax);
165 _stack_offset += wordSize;
166 }
167 #endif
168 }
169
170 void InterpreterRuntime::SignatureHandlerGenerator::pass_double() {
171 const Address src(from(), Interpreter::local_offset_in_bytes(offset() + 1));
172
173 #ifdef _WIN64
174 if (_num_args < Argument::n_float_register_parameters_c-1) {
175 __ movdbl(as_XMMRegister(++_num_args), src);
176 } else {
177 __ movq(rax, src);
178 __ movq(Address(to(), _stack_offset), rax);
179 _stack_offset += wordSize;
180 }
181 #else
182 if (_num_fp_args < Argument::n_float_register_parameters_c) {
183 __ movdbl(as_XMMRegister(_num_fp_args++), src);
184 } else {
185 __ movq(rax, src);
186 __ movq(Address(to(), _stack_offset), rax);
187 _stack_offset += wordSize;
188 }
189 #endif
190 }
191
192 void InterpreterRuntime::SignatureHandlerGenerator::pass_object() {
193 const Address src(from(), Interpreter::local_offset_in_bytes(offset()));
194
195 #ifdef _WIN64
196 switch (_num_args) {
197 case 0:
198 assert(offset() == 0, "argument register 1 can only be (non-null) receiver");
199 __ leaq(c_rarg1, src);
200 _num_args++;
201 break;
202 case 1:
203 __ leaq(rax, src);
204 __ xorl(c_rarg2, c_rarg2);
205 __ cmpq(src, 0);
206 __ cmovq(Assembler::notEqual, c_rarg2, rax);
207 _num_args++;
208 break;
209 case 2:
210 __ leaq(rax, src);
211 __ xorl(c_rarg3, c_rarg3);
212 __ cmpq(src, 0);
213 __ cmovq(Assembler::notEqual, c_rarg3, rax);
214 _num_args++;
215 break;
216 default:
217 __ leaq(rax, src);
218 __ xorl(temp(), temp());
219 __ cmpq(src, 0);
220 __ cmovq(Assembler::notEqual, temp(), rax);
221 __ movq(Address(to(), _stack_offset), temp());
222 _stack_offset += wordSize;
223 break;
224 }
225 #else
226 switch (_num_int_args) {
227 case 0:
228 assert(offset() == 0, "argument register 1 can only be (non-null) receiver");
229 __ leaq(c_rarg1, src);
230 _num_int_args++;
231 break;
232 case 1:
233 __ leaq(rax, src);
234 __ xorl(c_rarg2, c_rarg2);
235 __ cmpq(src, 0);
236 __ cmovq(Assembler::notEqual, c_rarg2, rax);
237 _num_int_args++;
238 break;
239 case 2:
240 __ leaq(rax, src);
241 __ xorl(c_rarg3, c_rarg3);
242 __ cmpq(src, 0);
243 __ cmovq(Assembler::notEqual, c_rarg3, rax);
244 _num_int_args++;
245 break;
246 case 3:
247 __ leaq(rax, src);
248 __ xorl(c_rarg4, c_rarg4);
249 __ cmpq(src, 0);
250 __ cmovq(Assembler::notEqual, c_rarg4, rax);
251 _num_int_args++;
252 break;
253 case 4:
254 __ leaq(rax, src);
255 __ xorl(c_rarg5, c_rarg5);
256 __ cmpq(src, 0);
257 __ cmovq(Assembler::notEqual, c_rarg5, rax);
258 _num_int_args++;
259 break;
260 default:
261 __ leaq(rax, src);
262 __ xorl(temp(), temp());
263 __ cmpq(src, 0);
264 __ cmovq(Assembler::notEqual, temp(), rax);
265 __ movq(Address(to(), _stack_offset), temp());
266 _stack_offset += wordSize;
267 break;
268 }
269 #endif
270 }
271
272 void InterpreterRuntime::SignatureHandlerGenerator::generate(uint64_t fingerprint) {
273 // generate code to handle arguments
274 iterate(fingerprint);
275
276 // return result handler
277 __ lea(rax, ExternalAddress(Interpreter::result_handler(method()->result_type())));
278 __ ret(0);
279
280 __ flush();
281 }
282
283
284 // Implementation of SignatureHandlerLibrary
285
286 void SignatureHandlerLibrary::pd_set_handler(address handler) {}
287
288
289 #ifdef _WIN64
290 class SlowSignatureHandler
291 : public NativeSignatureIterator {
292 private:
293 address _from;
294 intptr_t* _to;
295 intptr_t* _reg_args;
296 intptr_t* _fp_identifiers;
297 unsigned int _num_args;
298
299 #ifdef ASSERT
300 void verify_tag(frame::Tag t) {
301 assert(!TaggedStackInterpreter ||
302 *(intptr_t*)(_from+Interpreter::local_tag_offset_in_bytes(0)) == t, "wrong tag");
303 }
304 #endif // ASSERT
305
306 virtual void pass_int()
307 {
308 jint from_obj = *(jint *)(_from+Interpreter::local_offset_in_bytes(0));
309 debug_only(verify_tag(frame::TagValue));
310 _from -= Interpreter::stackElementSize();
311
312 if (_num_args < Argument::n_int_register_parameters_c-1) {
313 *_reg_args++ = from_obj;
314 _num_args++;
315 } else {
316 *_to++ = from_obj;
317 }
318 }
319
320 virtual void pass_long()
321 {
322 intptr_t from_obj = *(intptr_t*)(_from+Interpreter::local_offset_in_bytes(1));
323 debug_only(verify_tag(frame::TagValue));
324 _from -= 2*Interpreter::stackElementSize();
325
326 if (_num_args < Argument::n_int_register_parameters_c-1) {
327 *_reg_args++ = from_obj;
328 _num_args++;
329 } else {
330 *_to++ = from_obj;
331 }
332 }
333
334 virtual void pass_object()
335 {
336 intptr_t *from_addr = (intptr_t*)(_from + Interpreter::local_offset_in_bytes(0));
337 debug_only(verify_tag(frame::TagReference));
338 _from -= Interpreter::stackElementSize();
339 if (_num_args < Argument::n_int_register_parameters_c-1) {
340 *_reg_args++ = (*from_addr == 0) ? NULL : (intptr_t) from_addr;
341 _num_args++;
342 } else {
343 *_to++ = (*from_addr == 0) ? NULL : (intptr_t) from_addr;
344 }
345 }
346
347 virtual void pass_float()
348 {
349 jint from_obj = *(jint *)(_from+Interpreter::local_offset_in_bytes(0));
350 debug_only(verify_tag(frame::TagValue));
351 _from -= Interpreter::stackElementSize();
352
353 if (_num_args < Argument::n_float_register_parameters_c-1) {
354 *_reg_args++ = from_obj;
355 *_fp_identifiers |= (0x01 << (_num_args*2)); // mark as float
356 _num_args++;
357 } else {
358 *_to++ = from_obj;
359 }
360 }
361
362 virtual void pass_double()
363 {
364 intptr_t from_obj = *(intptr_t*)(_from+Interpreter::local_offset_in_bytes(1));
365 debug_only(verify_tag(frame::TagValue));
366 _from -= 2*Interpreter::stackElementSize();
367
368 if (_num_args < Argument::n_float_register_parameters_c-1) {
369 *_reg_args++ = from_obj;
370 *_fp_identifiers |= (0x3 << (_num_args*2)); // mark as double
371 _num_args++;
372 } else {
373 *_to++ = from_obj;
374 }
375 }
376
377 public:
378 SlowSignatureHandler(methodHandle method, address from, intptr_t* to)
379 : NativeSignatureIterator(method)
380 {
381 _from = from;
382 _to = to;
383
384 _reg_args = to - (method->is_static() ? 4 : 5);
385 _fp_identifiers = to - 2;
386 _to = _to + 4; // Windows reserves stack space for register arguments
387 *(int*) _fp_identifiers = 0;
388 _num_args = (method->is_static() ? 1 : 0);
389 }
390 };
391 #else
392 class SlowSignatureHandler
393 : public NativeSignatureIterator {
394 private:
395 address _from;
396 intptr_t* _to;
397 intptr_t* _int_args;
398 intptr_t* _fp_args;
399 intptr_t* _fp_identifiers;
400 unsigned int _num_int_args;
401 unsigned int _num_fp_args;
402
403 #ifdef ASSERT
404 void verify_tag(frame::Tag t) {
405 assert(!TaggedStackInterpreter ||
406 *(intptr_t*)(_from+Interpreter::local_tag_offset_in_bytes(0)) == t, "wrong tag");
407 }
408 #endif // ASSERT
409
410 virtual void pass_int()
411 {
412 jint from_obj = *(jint *)(_from+Interpreter::local_offset_in_bytes(0));
413 debug_only(verify_tag(frame::TagValue));
414 _from -= Interpreter::stackElementSize();
415
416 if (_num_int_args < Argument::n_int_register_parameters_c-1) {
417 *_int_args++ = from_obj;
418 _num_int_args++;
419 } else {
420 *_to++ = from_obj;
421 }
422 }
423
424 virtual void pass_long()
425 {
426 intptr_t from_obj = *(intptr_t*)(_from+Interpreter::local_offset_in_bytes(1));
427 debug_only(verify_tag(frame::TagValue));
428 _from -= 2*Interpreter::stackElementSize();
429
430 if (_num_int_args < Argument::n_int_register_parameters_c-1) {
431 *_int_args++ = from_obj;
432 _num_int_args++;
433 } else {
434 *_to++ = from_obj;
435 }
436 }
437
438 virtual void pass_object()
439 {
440 intptr_t *from_addr = (intptr_t*)(_from + Interpreter::local_offset_in_bytes(0));
441 debug_only(verify_tag(frame::TagReference));
442 _from -= Interpreter::stackElementSize();
443
444 if (_num_int_args < Argument::n_int_register_parameters_c-1) {
445 *_int_args++ = (*from_addr == 0) ? NULL : (intptr_t)from_addr;
446 _num_int_args++;
447 } else {
448 *_to++ = (*from_addr == 0) ? NULL : (intptr_t) from_addr;
449 }
450 }
451
452 virtual void pass_float()
453 {
454 jint from_obj = *(jint*)(_from+Interpreter::local_offset_in_bytes(0));
455 debug_only(verify_tag(frame::TagValue));
456 _from -= Interpreter::stackElementSize();
457
458 if (_num_fp_args < Argument::n_float_register_parameters_c) {
459 *_fp_args++ = from_obj;
460 _num_fp_args++;
461 } else {
462 *_to++ = from_obj;
463 }
464 }
465
466 virtual void pass_double()
467 {
468 intptr_t from_obj = *(intptr_t*)(_from+Interpreter::local_offset_in_bytes(1));
469 _from -= 2*Interpreter::stackElementSize();
470
471 if (_num_fp_args < Argument::n_float_register_parameters_c) {
472 *_fp_args++ = from_obj;
473 *_fp_identifiers |= (1 << _num_fp_args); // mark as double
474 _num_fp_args++;
475 } else {
476 *_to++ = from_obj;
477 }
478 }
479
480 public:
481 SlowSignatureHandler(methodHandle method, address from, intptr_t* to)
482 : NativeSignatureIterator(method)
483 {
484 _from = from;
485 _to = to;
486
487 _int_args = to - (method->is_static() ? 14 : 15);
488 _fp_args = to - 9;
489 _fp_identifiers = to - 10;
490 *(int*) _fp_identifiers = 0;
491 _num_int_args = (method->is_static() ? 1 : 0);
492 _num_fp_args = 0;
493 }
494 };
495 #endif
496
497
498 IRT_ENTRY(address,
499 InterpreterRuntime::slow_signature_handler(JavaThread* thread,
500 methodOopDesc* method,
501 intptr_t* from,
502 intptr_t* to))
503 methodHandle m(thread, (methodOop)method);
504 assert(m->is_native(), "sanity check");
505
506 // handle arguments
507 SlowSignatureHandler(m, (address)from, to + 1).iterate(UCONST64(-1));
508
509 // return result handler
510 return Interpreter::result_handler(m->result_type());
511 IRT_END