interpreterRT_x86_64.cpp revision 1472:c18cbe5936b8
1/* 2 * Copyright (c) 2003, 2010, 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 "incls/_precompiled.incl" 26#include "incls/_interpreterRT_x86_64.cpp.incl" 27 28#define __ _masm-> 29 30// Implementation of SignatureHandlerGenerator 31 32Register InterpreterRuntime::SignatureHandlerGenerator::from() { return r14; } 33Register InterpreterRuntime::SignatureHandlerGenerator::to() { return rsp; } 34Register InterpreterRuntime::SignatureHandlerGenerator::temp() { return rscratch1; } 35 36void InterpreterRuntime::SignatureHandlerGenerator::pass_int() { 37 const Address src(from(), Interpreter::local_offset_in_bytes(offset())); 38 39#ifdef _WIN64 40 switch (_num_args) { 41 case 0: 42 __ movl(c_rarg1, src); 43 _num_args++; 44 break; 45 case 1: 46 __ movl(c_rarg2, src); 47 _num_args++; 48 break; 49 case 2: 50 __ movl(c_rarg3, src); 51 _num_args++; 52 break; 53 default: 54 __ movl(rax, src); 55 __ movl(Address(to(), _stack_offset), rax); 56 _stack_offset += wordSize; 57 break; 58 } 59#else 60 switch (_num_int_args) { 61 case 0: 62 __ movl(c_rarg1, src); 63 _num_int_args++; 64 break; 65 case 1: 66 __ movl(c_rarg2, src); 67 _num_int_args++; 68 break; 69 case 2: 70 __ movl(c_rarg3, src); 71 _num_int_args++; 72 break; 73 case 3: 74 __ movl(c_rarg4, src); 75 _num_int_args++; 76 break; 77 case 4: 78 __ movl(c_rarg5, src); 79 _num_int_args++; 80 break; 81 default: 82 __ movl(rax, src); 83 __ movl(Address(to(), _stack_offset), rax); 84 _stack_offset += wordSize; 85 break; 86 } 87#endif 88} 89 90void InterpreterRuntime::SignatureHandlerGenerator::pass_long() { 91 const Address src(from(), Interpreter::local_offset_in_bytes(offset() + 1)); 92 93#ifdef _WIN64 94 switch (_num_args) { 95 case 0: 96 __ movptr(c_rarg1, src); 97 _num_args++; 98 break; 99 case 1: 100 __ movptr(c_rarg2, src); 101 _num_args++; 102 break; 103 case 2: 104 __ movptr(c_rarg3, src); 105 _num_args++; 106 break; 107 case 3: 108 default: 109 __ movptr(rax, src); 110 __ movptr(Address(to(), _stack_offset), rax); 111 _stack_offset += wordSize; 112 break; 113 } 114#else 115 switch (_num_int_args) { 116 case 0: 117 __ movptr(c_rarg1, src); 118 _num_int_args++; 119 break; 120 case 1: 121 __ movptr(c_rarg2, src); 122 _num_int_args++; 123 break; 124 case 2: 125 __ movptr(c_rarg3, src); 126 _num_int_args++; 127 break; 128 case 3: 129 __ movptr(c_rarg4, src); 130 _num_int_args++; 131 break; 132 case 4: 133 __ movptr(c_rarg5, src); 134 _num_int_args++; 135 break; 136 default: 137 __ movptr(rax, src); 138 __ movptr(Address(to(), _stack_offset), rax); 139 _stack_offset += wordSize; 140 break; 141 } 142#endif 143} 144 145void InterpreterRuntime::SignatureHandlerGenerator::pass_float() { 146 const Address src(from(), Interpreter::local_offset_in_bytes(offset())); 147 148#ifdef _WIN64 149 if (_num_args < Argument::n_float_register_parameters_c-1) { 150 __ movflt(as_XMMRegister(++_num_args), src); 151 } else { 152 __ movl(rax, src); 153 __ movl(Address(to(), _stack_offset), rax); 154 _stack_offset += wordSize; 155 } 156#else 157 if (_num_fp_args < Argument::n_float_register_parameters_c) { 158 __ movflt(as_XMMRegister(_num_fp_args++), src); 159 } else { 160 __ movl(rax, src); 161 __ movl(Address(to(), _stack_offset), rax); 162 _stack_offset += wordSize; 163 } 164#endif 165} 166 167void InterpreterRuntime::SignatureHandlerGenerator::pass_double() { 168 const Address src(from(), Interpreter::local_offset_in_bytes(offset() + 1)); 169 170#ifdef _WIN64 171 if (_num_args < Argument::n_float_register_parameters_c-1) { 172 __ movdbl(as_XMMRegister(++_num_args), src); 173 } else { 174 __ movptr(rax, src); 175 __ movptr(Address(to(), _stack_offset), rax); 176 _stack_offset += wordSize; 177 } 178#else 179 if (_num_fp_args < Argument::n_float_register_parameters_c) { 180 __ movdbl(as_XMMRegister(_num_fp_args++), src); 181 } else { 182 __ movptr(rax, src); 183 __ movptr(Address(to(), _stack_offset), rax); 184 _stack_offset += wordSize; 185 } 186#endif 187} 188 189void InterpreterRuntime::SignatureHandlerGenerator::pass_object() { 190 const Address src(from(), Interpreter::local_offset_in_bytes(offset())); 191 192#ifdef _WIN64 193 switch (_num_args) { 194 case 0: 195 assert(offset() == 0, "argument register 1 can only be (non-null) receiver"); 196 __ lea(c_rarg1, src); 197 _num_args++; 198 break; 199 case 1: 200 __ lea(rax, src); 201 __ xorl(c_rarg2, c_rarg2); 202 __ cmpptr(src, 0); 203 __ cmov(Assembler::notEqual, c_rarg2, rax); 204 _num_args++; 205 break; 206 case 2: 207 __ lea(rax, src); 208 __ xorl(c_rarg3, c_rarg3); 209 __ cmpptr(src, 0); 210 __ cmov(Assembler::notEqual, c_rarg3, rax); 211 _num_args++; 212 break; 213 default: 214 __ lea(rax, src); 215 __ xorl(temp(), temp()); 216 __ cmpptr(src, 0); 217 __ cmov(Assembler::notEqual, temp(), rax); 218 __ movptr(Address(to(), _stack_offset), temp()); 219 _stack_offset += wordSize; 220 break; 221 } 222#else 223 switch (_num_int_args) { 224 case 0: 225 assert(offset() == 0, "argument register 1 can only be (non-null) receiver"); 226 __ lea(c_rarg1, src); 227 _num_int_args++; 228 break; 229 case 1: 230 __ lea(rax, src); 231 __ xorl(c_rarg2, c_rarg2); 232 __ cmpptr(src, 0); 233 __ cmov(Assembler::notEqual, c_rarg2, rax); 234 _num_int_args++; 235 break; 236 case 2: 237 __ lea(rax, src); 238 __ xorl(c_rarg3, c_rarg3); 239 __ cmpptr(src, 0); 240 __ cmov(Assembler::notEqual, c_rarg3, rax); 241 _num_int_args++; 242 break; 243 case 3: 244 __ lea(rax, src); 245 __ xorl(c_rarg4, c_rarg4); 246 __ cmpptr(src, 0); 247 __ cmov(Assembler::notEqual, c_rarg4, rax); 248 _num_int_args++; 249 break; 250 case 4: 251 __ lea(rax, src); 252 __ xorl(c_rarg5, c_rarg5); 253 __ cmpptr(src, 0); 254 __ cmov(Assembler::notEqual, c_rarg5, rax); 255 _num_int_args++; 256 break; 257 default: 258 __ lea(rax, src); 259 __ xorl(temp(), temp()); 260 __ cmpptr(src, 0); 261 __ cmov(Assembler::notEqual, temp(), rax); 262 __ movptr(Address(to(), _stack_offset), temp()); 263 _stack_offset += wordSize; 264 break; 265 } 266#endif 267} 268 269void InterpreterRuntime::SignatureHandlerGenerator::generate(uint64_t fingerprint) { 270 // generate code to handle arguments 271 iterate(fingerprint); 272 273 // return result handler 274 __ lea(rax, ExternalAddress(Interpreter::result_handler(method()->result_type()))); 275 __ ret(0); 276 277 __ flush(); 278} 279 280 281// Implementation of SignatureHandlerLibrary 282 283void SignatureHandlerLibrary::pd_set_handler(address handler) {} 284 285 286#ifdef _WIN64 287class SlowSignatureHandler 288 : public NativeSignatureIterator { 289 private: 290 address _from; 291 intptr_t* _to; 292 intptr_t* _reg_args; 293 intptr_t* _fp_identifiers; 294 unsigned int _num_args; 295 296 virtual void pass_int() 297 { 298 jint from_obj = *(jint *)(_from+Interpreter::local_offset_in_bytes(0)); 299 _from -= Interpreter::stackElementSize; 300 301 if (_num_args < Argument::n_int_register_parameters_c-1) { 302 *_reg_args++ = from_obj; 303 _num_args++; 304 } else { 305 *_to++ = from_obj; 306 } 307 } 308 309 virtual void pass_long() 310 { 311 intptr_t from_obj = *(intptr_t*)(_from+Interpreter::local_offset_in_bytes(1)); 312 _from -= 2*Interpreter::stackElementSize; 313 314 if (_num_args < Argument::n_int_register_parameters_c-1) { 315 *_reg_args++ = from_obj; 316 _num_args++; 317 } else { 318 *_to++ = from_obj; 319 } 320 } 321 322 virtual void pass_object() 323 { 324 intptr_t *from_addr = (intptr_t*)(_from + Interpreter::local_offset_in_bytes(0)); 325 _from -= Interpreter::stackElementSize; 326 if (_num_args < Argument::n_int_register_parameters_c-1) { 327 *_reg_args++ = (*from_addr == 0) ? NULL : (intptr_t) from_addr; 328 _num_args++; 329 } else { 330 *_to++ = (*from_addr == 0) ? NULL : (intptr_t) from_addr; 331 } 332 } 333 334 virtual void pass_float() 335 { 336 jint from_obj = *(jint *)(_from+Interpreter::local_offset_in_bytes(0)); 337 _from -= Interpreter::stackElementSize; 338 339 if (_num_args < Argument::n_float_register_parameters_c-1) { 340 *_reg_args++ = from_obj; 341 *_fp_identifiers |= (intptr_t)(0x01 << (_num_args*2)); // mark as float 342 _num_args++; 343 } else { 344 *_to++ = from_obj; 345 } 346 } 347 348 virtual void pass_double() 349 { 350 intptr_t from_obj = *(intptr_t*)(_from+Interpreter::local_offset_in_bytes(1)); 351 _from -= 2*Interpreter::stackElementSize; 352 353 if (_num_args < Argument::n_float_register_parameters_c-1) { 354 *_reg_args++ = from_obj; 355 *_fp_identifiers |= (intptr_t)(0x3 << (_num_args*2)); // mark as double 356 _num_args++; 357 } else { 358 *_to++ = from_obj; 359 } 360 } 361 362 public: 363 SlowSignatureHandler(methodHandle method, address from, intptr_t* to) 364 : NativeSignatureIterator(method) 365 { 366 _from = from; 367 _to = to; 368 369 _reg_args = to - (method->is_static() ? 4 : 5); 370 _fp_identifiers = to - 2; 371 _to = _to + 4; // Windows reserves stack space for register arguments 372 *(int*) _fp_identifiers = 0; 373 _num_args = (method->is_static() ? 1 : 0); 374 } 375}; 376#else 377class SlowSignatureHandler 378 : public NativeSignatureIterator { 379 private: 380 address _from; 381 intptr_t* _to; 382 intptr_t* _int_args; 383 intptr_t* _fp_args; 384 intptr_t* _fp_identifiers; 385 unsigned int _num_int_args; 386 unsigned int _num_fp_args; 387 388 virtual void pass_int() 389 { 390 jint from_obj = *(jint *)(_from+Interpreter::local_offset_in_bytes(0)); 391 _from -= Interpreter::stackElementSize; 392 393 if (_num_int_args < Argument::n_int_register_parameters_c-1) { 394 *_int_args++ = from_obj; 395 _num_int_args++; 396 } else { 397 *_to++ = from_obj; 398 } 399 } 400 401 virtual void pass_long() 402 { 403 intptr_t from_obj = *(intptr_t*)(_from+Interpreter::local_offset_in_bytes(1)); 404 _from -= 2*Interpreter::stackElementSize; 405 406 if (_num_int_args < Argument::n_int_register_parameters_c-1) { 407 *_int_args++ = from_obj; 408 _num_int_args++; 409 } else { 410 *_to++ = from_obj; 411 } 412 } 413 414 virtual void pass_object() 415 { 416 intptr_t *from_addr = (intptr_t*)(_from + Interpreter::local_offset_in_bytes(0)); 417 _from -= Interpreter::stackElementSize; 418 419 if (_num_int_args < Argument::n_int_register_parameters_c-1) { 420 *_int_args++ = (*from_addr == 0) ? NULL : (intptr_t)from_addr; 421 _num_int_args++; 422 } else { 423 *_to++ = (*from_addr == 0) ? NULL : (intptr_t) from_addr; 424 } 425 } 426 427 virtual void pass_float() 428 { 429 jint from_obj = *(jint*)(_from+Interpreter::local_offset_in_bytes(0)); 430 _from -= Interpreter::stackElementSize; 431 432 if (_num_fp_args < Argument::n_float_register_parameters_c) { 433 *_fp_args++ = from_obj; 434 _num_fp_args++; 435 } else { 436 *_to++ = from_obj; 437 } 438 } 439 440 virtual void pass_double() 441 { 442 intptr_t from_obj = *(intptr_t*)(_from+Interpreter::local_offset_in_bytes(1)); 443 _from -= 2*Interpreter::stackElementSize; 444 445 if (_num_fp_args < Argument::n_float_register_parameters_c) { 446 *_fp_args++ = from_obj; 447 *_fp_identifiers |= (1 << _num_fp_args); // mark as double 448 _num_fp_args++; 449 } else { 450 *_to++ = from_obj; 451 } 452 } 453 454 public: 455 SlowSignatureHandler(methodHandle method, address from, intptr_t* to) 456 : NativeSignatureIterator(method) 457 { 458 _from = from; 459 _to = to; 460 461 _int_args = to - (method->is_static() ? 14 : 15); 462 _fp_args = to - 9; 463 _fp_identifiers = to - 10; 464 *(int*) _fp_identifiers = 0; 465 _num_int_args = (method->is_static() ? 1 : 0); 466 _num_fp_args = 0; 467 } 468}; 469#endif 470 471 472IRT_ENTRY(address, 473 InterpreterRuntime::slow_signature_handler(JavaThread* thread, 474 methodOopDesc* method, 475 intptr_t* from, 476 intptr_t* to)) 477 methodHandle m(thread, (methodOop)method); 478 assert(m->is_native(), "sanity check"); 479 480 // handle arguments 481 SlowSignatureHandler(m, (address)from, to + 1).iterate(UCONST64(-1)); 482 483 // return result handler 484 return Interpreter::result_handler(m->result_type()); 485IRT_END 486