1 #ifdef USE_PRAGMA_IDENT_SRC 2 #pragma ident "@(#)templateTable_x86_32.cpp 1.323 07/09/17 09:26:00 JVM" 3 #endif 4 /* 5 * Copyright 1997-2007 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/_templateTable_x86_32.cpp.incl" 30 31 #ifndef CC_INTERP 32 #define __ _masm-> 33 34 //---------------------------------------------------------------------------------------------------- 35 // Platform-dependent initialization 36 37 void TemplateTable::pd_initialize() { 38 // No i486 specific initialization 39 } 40 41 //---------------------------------------------------------------------------------------------------- 42 // Address computation 43 44 // local variables 45 static inline Address iaddress(int n) { 46 return Address(rdi, Interpreter::local_offset_in_bytes(n)); 47 } 48 49 static inline Address laddress(int n) { return iaddress(n + 1); } 50 static inline Address haddress(int n) { return iaddress(n + 0); } 51 static inline Address faddress(int n) { return iaddress(n); } 52 static inline Address daddress(int n) { return laddress(n); } 53 static inline Address aaddress(int n) { return iaddress(n); } 54 55 static inline Address iaddress(Register r) { 56 return Address(rdi, r, Interpreter::stackElementScale(), Interpreter::value_offset_in_bytes()); 57 } 58 static inline Address laddress(Register r) { 59 return Address(rdi, r, Interpreter::stackElementScale(), Interpreter::local_offset_in_bytes(1)); 60 } 61 static inline Address haddress(Register r) { 62 return Address(rdi, r, Interpreter::stackElementScale(), Interpreter::local_offset_in_bytes(0)); 63 } 64 65 static inline Address faddress(Register r) { return iaddress(r); }; 66 static inline Address daddress(Register r) { 67 assert(!TaggedStackInterpreter, "This doesn't work"); 68 return laddress(r); 69 }; 70 static inline Address aaddress(Register r) { return iaddress(r); }; 71 72 // expression stack 73 // (Note: Must not use symmetric equivalents at_rsp_m1/2 since they store 74 // data beyond the rsp which is potentially unsafe in an MT environment; 75 // an interrupt may overwrite that data.) 76 static inline Address at_rsp () { 77 return Address(rsp, 0); 78 } 79 80 // At top of Java expression stack which may be different than rsp(). It 81 // isn't for category 1 objects. 82 static inline Address at_tos () { 83 Address tos = Address(rsp, Interpreter::expr_offset_in_bytes(0)); 84 return tos; 85 } 86 87 static inline Address at_tos_p1() { 88 return Address(rsp, Interpreter::expr_offset_in_bytes(1)); 89 } 90 91 static inline Address at_tos_p2() { 92 return Address(rsp, Interpreter::expr_offset_in_bytes(2)); 93 } 94 95 // Condition conversion 96 static Assembler::Condition j_not(TemplateTable::Condition cc) { 97 switch (cc) { 98 case TemplateTable::equal : return Assembler::notEqual; 99 case TemplateTable::not_equal : return Assembler::equal; 100 case TemplateTable::less : return Assembler::greaterEqual; 101 case TemplateTable::less_equal : return Assembler::greater; 102 case TemplateTable::greater : return Assembler::lessEqual; 103 case TemplateTable::greater_equal: return Assembler::less; 104 } 105 ShouldNotReachHere(); 106 return Assembler::zero; 107 } 108 109 110 //---------------------------------------------------------------------------------------------------- 111 // Miscelaneous helper routines 112 113 Address TemplateTable::at_bcp(int offset) { 114 assert(_desc->uses_bcp(), "inconsistent uses_bcp information"); 115 return Address(rsi, offset); 116 } 117 118 119 void TemplateTable::patch_bytecode(Bytecodes::Code bytecode, Register bc, 120 Register scratch, 121 bool load_bc_into_scratch/*=true*/) { 122 123 if (!RewriteBytecodes) return; 124 // the pair bytecodes have already done the load. 125 if (load_bc_into_scratch) __ movl(bc, bytecode); 126 Label patch_done; 127 if (JvmtiExport::can_post_breakpoint()) { 128 Label fast_patch; 129 // if a breakpoint is present we can't rewrite the stream directly 130 __ movzxb(scratch, at_bcp(0)); 131 __ cmpl(scratch, Bytecodes::_breakpoint); 132 __ jcc(Assembler::notEqual, fast_patch); 133 __ get_method(scratch); 134 // Let breakpoint table handling rewrite to quicker bytecode 135 __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::set_original_bytecode_at), scratch, rsi, bc); 136 #ifndef ASSERT 137 __ jmpb(patch_done); 138 __ bind(fast_patch); 139 } 140 #else 141 __ jmp(patch_done); 142 __ bind(fast_patch); 143 } 144 Label okay; 145 __ load_unsigned_byte(scratch, at_bcp(0)); 146 __ cmpl(scratch, (int)Bytecodes::java_code(bytecode)); 147 __ jccb(Assembler::equal, okay); 148 __ cmpl(scratch, bc); 149 __ jcc(Assembler::equal, okay); 150 __ stop("patching the wrong bytecode"); 151 __ bind(okay); 152 #endif 153 // patch bytecode 154 __ movb(at_bcp(0), bc); 155 __ bind(patch_done); 156 } 157 158 //---------------------------------------------------------------------------------------------------- 159 // Individual instructions 160 161 void TemplateTable::nop() { 162 transition(vtos, vtos); 163 // nothing to do 164 } 165 166 void TemplateTable::shouldnotreachhere() { 167 transition(vtos, vtos); 168 __ stop("shouldnotreachhere bytecode"); 169 } 170 171 172 173 void TemplateTable::aconst_null() { 174 transition(vtos, atos); 175 __ xorl(rax, rax); 176 } 177 178 179 void TemplateTable::iconst(int value) { 180 transition(vtos, itos); 181 if (value == 0) { 182 __ xorl(rax, rax); 183 } else { 184 __ movl(rax, value); 185 } 186 } 187 188 189 void TemplateTable::lconst(int value) { 190 transition(vtos, ltos); 191 if (value == 0) { 192 __ xorl(rax, rax); 193 } else { 194 __ movl(rax, value); 195 } 196 assert(value >= 0, "check this code"); 197 __ xorl(rdx, rdx); 198 } 199 200 201 void TemplateTable::fconst(int value) { 202 transition(vtos, ftos); 203 if (value == 0) { __ fldz(); 204 } else if (value == 1) { __ fld1(); 205 } else if (value == 2) { __ fld1(); __ fld1(); __ faddp(); // should do a better solution here 206 } else { ShouldNotReachHere(); 207 } 208 } 209 210 211 void TemplateTable::dconst(int value) { 212 transition(vtos, dtos); 213 if (value == 0) { __ fldz(); 214 } else if (value == 1) { __ fld1(); 215 } else { ShouldNotReachHere(); 216 } 217 } 218 219 220 void TemplateTable::bipush() { 221 transition(vtos, itos); 222 __ load_signed_byte(rax, at_bcp(1)); 223 } 224 225 226 void TemplateTable::sipush() { 227 transition(vtos, itos); 228 __ load_unsigned_word(rax, at_bcp(1)); 229 __ bswap(rax); 230 __ sarl(rax, 16); 231 } 232 233 void TemplateTable::ldc(bool wide) { 234 transition(vtos, vtos); 235 Label call_ldc, notFloat, notClass, Done; 236 237 if (wide) { 238 __ get_unsigned_2_byte_index_at_bcp(rbx, 1); 239 } else { 240 __ load_unsigned_byte(rbx, at_bcp(1)); 241 } 242 __ get_cpool_and_tags(rcx, rax); 243 const int base_offset = constantPoolOopDesc::header_size() * wordSize; 244 const int tags_offset = typeArrayOopDesc::header_size(T_BYTE) * wordSize; 245 246 // get type 247 __ xorl(rdx, rdx); 248 __ movb(rdx, Address(rax, rbx, Address::times_1, tags_offset)); 249 250 // unresolved string - get the resolved string 251 __ cmpl(rdx, JVM_CONSTANT_UnresolvedString); 252 __ jccb(Assembler::equal, call_ldc); 253 254 // unresolved class - get the resolved class 255 __ cmpl(rdx, JVM_CONSTANT_UnresolvedClass); 256 __ jccb(Assembler::equal, call_ldc); 257 258 // unresolved class in error (resolution failed) - call into runtime 259 // so that the same error from first resolution attempt is thrown. 260 __ cmpl(rdx, JVM_CONSTANT_UnresolvedClassInError); 261 __ jccb(Assembler::equal, call_ldc); 262 263 // resolved class - need to call vm to get java mirror of the class 264 __ cmpl(rdx, JVM_CONSTANT_Class); 265 __ jcc(Assembler::notEqual, notClass); 266 267 __ bind(call_ldc); 268 __ movl(rcx, wide); 269 call_VM(rax, CAST_FROM_FN_PTR(address, InterpreterRuntime::ldc), rcx); 270 __ push(atos); 271 __ jmp(Done); 272 273 __ bind(notClass); 274 __ cmpl(rdx, JVM_CONSTANT_Float); 275 __ jccb(Assembler::notEqual, notFloat); 276 // ftos 277 __ fld_s( Address(rcx, rbx, Address::times_4, base_offset)); 278 __ push(ftos); 279 __ jmp(Done); 280 281 __ bind(notFloat); 282 #ifdef ASSERT 283 { Label L; 284 __ cmpl(rdx, JVM_CONSTANT_Integer); 285 __ jcc(Assembler::equal, L); 286 __ cmpl(rdx, JVM_CONSTANT_String); 287 __ jcc(Assembler::equal, L); 288 __ stop("unexpected tag type in ldc"); 289 __ bind(L); 290 } 291 #endif 292 Label isOop; 293 // atos and itos 294 __ movl(rax, Address(rcx, rbx, Address::times_4, base_offset)); 295 // String is only oop type we will see here 296 __ cmpl(rdx, JVM_CONSTANT_String); 297 __ jccb(Assembler::equal, isOop); 298 __ push(itos); 299 __ jmp(Done); 300 __ bind(isOop); 301 __ push(atos); 302 303 if (VerifyOops) { 304 __ verify_oop(rax); 305 } 306 __ bind(Done); 307 } 308 309 void TemplateTable::ldc2_w() { 310 transition(vtos, vtos); 311 Label Long, Done; 312 __ get_unsigned_2_byte_index_at_bcp(rbx, 1); 313 314 __ get_cpool_and_tags(rcx, rax); 315 const int base_offset = constantPoolOopDesc::header_size() * wordSize; 316 const int tags_offset = typeArrayOopDesc::header_size(T_BYTE) * wordSize; 317 318 // get type 319 __ cmpb(Address(rax, rbx, Address::times_1, tags_offset), JVM_CONSTANT_Double); 320 __ jccb(Assembler::notEqual, Long); 321 // dtos 322 __ fld_d( Address(rcx, rbx, Address::times_4, base_offset)); 323 __ push(dtos); 324 __ jmpb(Done); 325 326 __ bind(Long); 327 // ltos 328 __ movl(rax, Address(rcx, rbx, Address::times_4, base_offset + 0 * wordSize)); 329 __ movl(rdx, Address(rcx, rbx, Address::times_4, base_offset + 1 * wordSize)); 330 331 __ push(ltos); 332 333 __ bind(Done); 334 } 335 336 337 void TemplateTable::locals_index(Register reg, int offset) { 338 __ load_unsigned_byte(reg, at_bcp(offset)); 339 __ negl(reg); 340 } 341 342 343 void TemplateTable::iload() { 344 transition(vtos, itos); 345 if (RewriteFrequentPairs) { 346 Label rewrite, done; 347 348 // get next byte 349 __ load_unsigned_byte(rbx, at_bcp(Bytecodes::length_for(Bytecodes::_iload))); 350 // if _iload, wait to rewrite to iload2. We only want to rewrite the 351 // last two iloads in a pair. Comparing against fast_iload means that 352 // the next bytecode is neither an iload or a caload, and therefore 353 // an iload pair. 354 __ cmpl(rbx, Bytecodes::_iload); 355 __ jcc(Assembler::equal, done); 356 357 __ cmpl(rbx, Bytecodes::_fast_iload); 358 __ movl(rcx, Bytecodes::_fast_iload2); 359 __ jccb(Assembler::equal, rewrite); 360 361 // if _caload, rewrite to fast_icaload 362 __ cmpl(rbx, Bytecodes::_caload); 363 __ movl(rcx, Bytecodes::_fast_icaload); 364 __ jccb(Assembler::equal, rewrite); 365 366 // rewrite so iload doesn't check again. 367 __ movl(rcx, Bytecodes::_fast_iload); 368 369 // rewrite 370 // rcx: fast bytecode 371 __ bind(rewrite); 372 patch_bytecode(Bytecodes::_iload, rcx, rbx, false); 373 __ bind(done); 374 } 375 376 // Get the local value into tos 377 locals_index(rbx); 378 __ movl(rax, iaddress(rbx)); 379 debug_only(__ verify_local_tag(frame::TagValue, rbx)); 380 } 381 382 383 void TemplateTable::fast_iload2() { 384 transition(vtos, itos); 385 locals_index(rbx); 386 __ movl(rax, iaddress(rbx)); 387 debug_only(__ verify_local_tag(frame::TagValue, rbx)); 388 __ push(itos); 389 locals_index(rbx, 3); 390 __ movl(rax, iaddress(rbx)); 391 debug_only(__ verify_local_tag(frame::TagValue, rbx)); 392 } 393 394 void TemplateTable::fast_iload() { 395 transition(vtos, itos); 396 locals_index(rbx); 397 __ movl(rax, iaddress(rbx)); 398 debug_only(__ verify_local_tag(frame::TagValue, rbx)); 399 } 400 401 402 void TemplateTable::lload() { 403 transition(vtos, ltos); 404 locals_index(rbx); 405 __ movl(rax, laddress(rbx)); 406 __ movl(rdx, haddress(rbx)); 407 debug_only(__ verify_local_tag(frame::TagCategory2, rbx)); 408 } 409 410 411 void TemplateTable::fload() { 412 transition(vtos, ftos); 413 locals_index(rbx); 414 __ fld_s(faddress(rbx)); 415 debug_only(__ verify_local_tag(frame::TagValue, rbx)); 416 } 417 418 419 void TemplateTable::dload() { 420 transition(vtos, dtos); 421 locals_index(rbx); 422 if (TaggedStackInterpreter) { 423 // Get double out of locals array, onto temp stack and load with 424 // float instruction into ST0 425 __ movl(rax, laddress(rbx)); 426 __ movl(rdx, haddress(rbx)); 427 __ pushl(rdx); // push hi first 428 __ pushl(rax); 429 __ fld_d(Address(rsp, 0)); 430 __ addl(rsp, 2*wordSize); 431 debug_only(__ verify_local_tag(frame::TagCategory2, rbx)); 432 } else { 433 __ fld_d(daddress(rbx)); 434 } 435 } 436 437 438 void TemplateTable::aload() { 439 transition(vtos, atos); 440 locals_index(rbx); 441 __ movl(rax, iaddress(rbx)); 442 debug_only(__ verify_local_tag(frame::TagReference, rbx)); 443 } 444 445 446 void TemplateTable::locals_index_wide(Register reg) { 447 __ movl(reg, at_bcp(2)); 448 __ bswap(reg); 449 __ shrl(reg, 16); 450 __ negl(reg); 451 } 452 453 454 void TemplateTable::wide_iload() { 455 transition(vtos, itos); 456 locals_index_wide(rbx); 457 __ movl(rax, iaddress(rbx)); 458 debug_only(__ verify_local_tag(frame::TagValue, rbx)); 459 } 460 461 462 void TemplateTable::wide_lload() { 463 transition(vtos, ltos); 464 locals_index_wide(rbx); 465 __ movl(rax, laddress(rbx)); 466 __ movl(rdx, haddress(rbx)); 467 debug_only(__ verify_local_tag(frame::TagCategory2, rbx)); 468 } 469 470 471 void TemplateTable::wide_fload() { 472 transition(vtos, ftos); 473 locals_index_wide(rbx); 474 __ fld_s(faddress(rbx)); 475 debug_only(__ verify_local_tag(frame::TagValue, rbx)); 476 } 477 478 479 void TemplateTable::wide_dload() { 480 transition(vtos, dtos); 481 locals_index_wide(rbx); 482 if (TaggedStackInterpreter) { 483 // Get double out of locals array, onto temp stack and load with 484 // float instruction into ST0 485 __ movl(rax, laddress(rbx)); 486 __ movl(rdx, haddress(rbx)); 487 __ pushl(rdx); // push hi first 488 __ pushl(rax); 489 __ fld_d(Address(rsp, 0)); 490 __ addl(rsp, 2*wordSize); 491 debug_only(__ verify_local_tag(frame::TagCategory2, rbx)); 492 } else { 493 __ fld_d(daddress(rbx)); 494 } 495 } 496 497 498 void TemplateTable::wide_aload() { 499 transition(vtos, atos); 500 locals_index_wide(rbx); 501 __ movl(rax, iaddress(rbx)); 502 debug_only(__ verify_local_tag(frame::TagReference, rbx)); 503 } 504 505 void TemplateTable::index_check(Register array, Register index) { 506 // Pop ptr into array 507 __ pop_ptr(array); 508 index_check_without_pop(array, index); 509 } 510 511 void TemplateTable::index_check_without_pop(Register array, Register index) { 512 // destroys rbx, 513 // check array 514 __ null_check(array, arrayOopDesc::length_offset_in_bytes()); 515 // check index 516 __ cmpl(index, Address(array, arrayOopDesc::length_offset_in_bytes())); 517 if (index != rbx) { 518 // ??? convention: move aberrant index into rbx, for exception message 519 assert(rbx != array, "different registers"); 520 __ movl(rbx, index); 521 } 522 __ jump_cc(Assembler::aboveEqual, 523 ExternalAddress(Interpreter::_throw_ArrayIndexOutOfBoundsException_entry)); 524 } 525 526 527 void TemplateTable::iaload() { 528 transition(itos, itos); 529 // rdx: array 530 index_check(rdx, rax); // kills rbx, 531 // rax,: index 532 __ movl(rax, Address(rdx, rax, Address::times_4, arrayOopDesc::base_offset_in_bytes(T_INT))); 533 } 534 535 536 void TemplateTable::laload() { 537 transition(itos, ltos); 538 // rax,: index 539 // rdx: array 540 index_check(rdx, rax); 541 __ movl(rbx, rax); 542 // rbx,: index 543 __ movl(rax, Address(rdx, rbx, Address::times_8, arrayOopDesc::base_offset_in_bytes(T_LONG) + 0 * wordSize)); 544 __ movl(rdx, Address(rdx, rbx, Address::times_8, arrayOopDesc::base_offset_in_bytes(T_LONG) + 1 * wordSize)); 545 } 546 547 548 void TemplateTable::faload() { 549 transition(itos, ftos); 550 // rdx: array 551 index_check(rdx, rax); // kills rbx, 552 // rax,: index 553 __ fld_s(Address(rdx, rax, Address::times_4, arrayOopDesc::base_offset_in_bytes(T_FLOAT))); 554 } 555 556 557 void TemplateTable::daload() { 558 transition(itos, dtos); 559 // rdx: array 560 index_check(rdx, rax); // kills rbx, 561 // rax,: index 562 __ fld_d(Address(rdx, rax, Address::times_8, arrayOopDesc::base_offset_in_bytes(T_DOUBLE))); 563 } 564 565 566 void TemplateTable::aaload() { 567 transition(itos, atos); 568 // rdx: array 569 index_check(rdx, rax); // kills rbx, 570 // rax,: index 571 __ movl(rax, Address(rdx, rax, Address::times_4, arrayOopDesc::base_offset_in_bytes(T_OBJECT))); 572 } 573 574 575 void TemplateTable::baload() { 576 transition(itos, itos); 577 // rdx: array 578 index_check(rdx, rax); // kills rbx, 579 // rax,: index 580 // can do better code for P5 - fix this at some point 581 __ load_signed_byte(rbx, Address(rdx, rax, Address::times_1, arrayOopDesc::base_offset_in_bytes(T_BYTE))); 582 __ movl(rax, rbx); 583 } 584 585 586 void TemplateTable::caload() { 587 transition(itos, itos); 588 // rdx: array 589 index_check(rdx, rax); // kills rbx, 590 // rax,: index 591 // can do better code for P5 - may want to improve this at some point 592 __ load_unsigned_word(rbx, Address(rdx, rax, Address::times_2, arrayOopDesc::base_offset_in_bytes(T_CHAR))); 593 __ movl(rax, rbx); 594 } 595 596 // iload followed by caload frequent pair 597 void TemplateTable::fast_icaload() { 598 transition(vtos, itos); 599 // load index out of locals 600 locals_index(rbx); 601 __ movl(rax, iaddress(rbx)); 602 debug_only(__ verify_local_tag(frame::TagValue, rbx)); 603 604 // rdx: array 605 index_check(rdx, rax); 606 // rax,: index 607 __ load_unsigned_word(rbx, Address(rdx, rax, Address::times_2, arrayOopDesc::base_offset_in_bytes(T_CHAR))); 608 __ movl(rax, rbx); 609 } 610 611 void TemplateTable::saload() { 612 transition(itos, itos); 613 // rdx: array 614 index_check(rdx, rax); // kills rbx, 615 // rax,: index 616 // can do better code for P5 - may want to improve this at some point 617 __ load_signed_word(rbx, Address(rdx, rax, Address::times_2, arrayOopDesc::base_offset_in_bytes(T_SHORT))); 618 __ movl(rax, rbx); 619 } 620 621 622 void TemplateTable::iload(int n) { 623 transition(vtos, itos); 624 __ movl(rax, iaddress(n)); 625 debug_only(__ verify_local_tag(frame::TagValue, n)); 626 } 627 628 629 void TemplateTable::lload(int n) { 630 transition(vtos, ltos); 631 __ movl(rax, laddress(n)); 632 __ movl(rdx, haddress(n)); 633 debug_only(__ verify_local_tag(frame::TagCategory2, n)); 634 } 635 636 637 void TemplateTable::fload(int n) { 638 transition(vtos, ftos); 639 __ fld_s(faddress(n)); 640 debug_only(__ verify_local_tag(frame::TagValue, n)); 641 } 642 643 644 void TemplateTable::dload(int n) { 645 transition(vtos, dtos); 646 if (TaggedStackInterpreter) { 647 // Get double out of locals array, onto temp stack and load with 648 // float instruction into ST0 649 __ movl(rax, laddress(n)); 650 __ movl(rdx, haddress(n)); 651 __ pushl(rdx); // push hi first 652 __ pushl(rax); 653 __ fld_d(Address(rsp, 0)); 654 __ addl(rsp, 2*wordSize); // reset rsp 655 debug_only(__ verify_local_tag(frame::TagCategory2, n)); 656 } else { 657 __ fld_d(daddress(n)); 658 } 659 } 660 661 662 void TemplateTable::aload(int n) { 663 transition(vtos, atos); 664 __ movl(rax, aaddress(n)); 665 debug_only(__ verify_local_tag(frame::TagReference, n)); 666 } 667 668 669 void TemplateTable::aload_0() { 670 transition(vtos, atos); 671 // According to bytecode histograms, the pairs: 672 // 673 // _aload_0, _fast_igetfield 674 // _aload_0, _fast_agetfield 675 // _aload_0, _fast_fgetfield 676 // 677 // occur frequently. If RewriteFrequentPairs is set, the (slow) _aload_0 678 // bytecode checks if the next bytecode is either _fast_igetfield, 679 // _fast_agetfield or _fast_fgetfield and then rewrites the 680 // current bytecode into a pair bytecode; otherwise it rewrites the current 681 // bytecode into _fast_aload_0 that doesn't do the pair check anymore. 682 // 683 // Note: If the next bytecode is _getfield, the rewrite must be delayed, 684 // otherwise we may miss an opportunity for a pair. 685 // 686 // Also rewrite frequent pairs 687 // aload_0, aload_1 688 // aload_0, iload_1 689 // These bytecodes with a small amount of code are most profitable to rewrite 690 if (RewriteFrequentPairs) { 691 Label rewrite, done; 692 // get next byte 693 __ load_unsigned_byte(rbx, at_bcp(Bytecodes::length_for(Bytecodes::_aload_0))); 694 695 // do actual aload_0 696 aload(0); 697 698 // if _getfield then wait with rewrite 699 __ cmpl(rbx, Bytecodes::_getfield); 700 __ jcc(Assembler::equal, done); 701 702 // if _igetfield then reqrite to _fast_iaccess_0 703 assert(Bytecodes::java_code(Bytecodes::_fast_iaccess_0) == Bytecodes::_aload_0, "fix bytecode definition"); 704 __ cmpl(rbx, Bytecodes::_fast_igetfield); 705 __ movl(rcx, Bytecodes::_fast_iaccess_0); 706 __ jccb(Assembler::equal, rewrite); 707 708 // if _agetfield then reqrite to _fast_aaccess_0 709 assert(Bytecodes::java_code(Bytecodes::_fast_aaccess_0) == Bytecodes::_aload_0, "fix bytecode definition"); 710 __ cmpl(rbx, Bytecodes::_fast_agetfield); 711 __ movl(rcx, Bytecodes::_fast_aaccess_0); 712 __ jccb(Assembler::equal, rewrite); 713 714 // if _fgetfield then reqrite to _fast_faccess_0 715 assert(Bytecodes::java_code(Bytecodes::_fast_faccess_0) == Bytecodes::_aload_0, "fix bytecode definition"); 716 __ cmpl(rbx, Bytecodes::_fast_fgetfield); 717 __ movl(rcx, Bytecodes::_fast_faccess_0); 718 __ jccb(Assembler::equal, rewrite); 719 720 // else rewrite to _fast_aload0 721 assert(Bytecodes::java_code(Bytecodes::_fast_aload_0) == Bytecodes::_aload_0, "fix bytecode definition"); 722 __ movl(rcx, Bytecodes::_fast_aload_0); 723 724 // rewrite 725 // rcx: fast bytecode 726 __ bind(rewrite); 727 patch_bytecode(Bytecodes::_aload_0, rcx, rbx, false); 728 729 __ bind(done); 730 } else { 731 aload(0); 732 } 733 } 734 735 void TemplateTable::istore() { 736 transition(itos, vtos); 737 locals_index(rbx); 738 __ movl(iaddress(rbx), rax); 739 __ tag_local(frame::TagValue, rbx); 740 } 741 742 743 void TemplateTable::lstore() { 744 transition(ltos, vtos); 745 locals_index(rbx); 746 __ movl(laddress(rbx), rax); 747 __ movl(haddress(rbx), rdx); 748 __ tag_local(frame::TagCategory2, rbx); 749 } 750 751 752 void TemplateTable::fstore() { 753 transition(ftos, vtos); 754 locals_index(rbx); 755 __ fstp_s(faddress(rbx)); 756 __ tag_local(frame::TagValue, rbx); 757 } 758 759 760 void TemplateTable::dstore() { 761 transition(dtos, vtos); 762 locals_index(rbx); 763 if (TaggedStackInterpreter) { 764 // Store double on stack and reload into locals nonadjacently 765 __ subl(rsp, 2 * wordSize); 766 __ fstp_d(Address(rsp, 0)); 767 __ popl(rax); 768 __ popl(rdx); 769 __ movl(laddress(rbx), rax); 770 __ movl(haddress(rbx), rdx); 771 __ tag_local(frame::TagCategory2, rbx); 772 } else { 773 __ fstp_d(daddress(rbx)); 774 } 775 } 776 777 778 void TemplateTable::astore() { 779 transition(vtos, vtos); 780 __ pop_ptr(rax, rdx); // will need to pop tag too 781 locals_index(rbx); 782 __ movl(aaddress(rbx), rax); 783 __ tag_local(rdx, rbx); // need to store same tag in local may be returnAddr 784 } 785 786 787 void TemplateTable::wide_istore() { 788 transition(vtos, vtos); 789 __ pop_i(rax); 790 locals_index_wide(rbx); 791 __ movl(iaddress(rbx), rax); 792 __ tag_local(frame::TagValue, rbx); 793 } 794 795 796 void TemplateTable::wide_lstore() { 797 transition(vtos, vtos); 798 __ pop_l(rax, rdx); 799 locals_index_wide(rbx); 800 __ movl(laddress(rbx), rax); 801 __ movl(haddress(rbx), rdx); 802 __ tag_local(frame::TagCategory2, rbx); 803 } 804 805 806 void TemplateTable::wide_fstore() { 807 wide_istore(); 808 } 809 810 811 void TemplateTable::wide_dstore() { 812 wide_lstore(); 813 } 814 815 816 void TemplateTable::wide_astore() { 817 transition(vtos, vtos); 818 __ pop_ptr(rax, rdx); 819 locals_index_wide(rbx); 820 __ movl(aaddress(rbx), rax); 821 __ tag_local(rdx, rbx); 822 } 823 824 825 void TemplateTable::iastore() { 826 transition(itos, vtos); 827 __ pop_i(rbx); 828 // rax,: value 829 // rdx: array 830 index_check(rdx, rbx); // prefer index in rbx, 831 // rbx,: index 832 __ movl(Address(rdx, rbx, Address::times_4, arrayOopDesc::base_offset_in_bytes(T_INT)), rax); 833 } 834 835 836 void TemplateTable::lastore() { 837 transition(ltos, vtos); 838 __ pop_i(rbx); 839 // rax,: low(value) 840 // rcx: array 841 // rdx: high(value) 842 index_check(rcx, rbx); // prefer index in rbx, 843 // rbx,: index 844 __ movl(Address(rcx, rbx, Address::times_8, arrayOopDesc::base_offset_in_bytes(T_LONG) + 0 * wordSize), rax); 845 __ movl(Address(rcx, rbx, Address::times_8, arrayOopDesc::base_offset_in_bytes(T_LONG) + 1 * wordSize), rdx); 846 } 847 848 849 void TemplateTable::fastore() { 850 transition(ftos, vtos); 851 __ pop_i(rbx); 852 // rdx: array 853 // st0: value 854 index_check(rdx, rbx); // prefer index in rbx, 855 // rbx,: index 856 __ fstp_s(Address(rdx, rbx, Address::times_4, arrayOopDesc::base_offset_in_bytes(T_FLOAT))); 857 } 858 859 860 void TemplateTable::dastore() { 861 transition(dtos, vtos); 862 __ pop_i(rbx); 863 // rdx: array 864 // st0: value 865 index_check(rdx, rbx); // prefer index in rbx, 866 // rbx,: index 867 __ fstp_d(Address(rdx, rbx, Address::times_8, arrayOopDesc::base_offset_in_bytes(T_DOUBLE))); 868 } 869 870 871 void TemplateTable::aastore() { 872 Label is_null, ok_is_subtype, done; 873 transition(vtos, vtos); 874 // stack: ..., array, index, value 875 __ movl(rax, at_tos()); // Value 876 __ movl(rcx, at_tos_p1()); // Index 877 __ movl(rdx, at_tos_p2()); // Array 878 index_check_without_pop(rdx, rcx); // kills rbx, 879 // do array store check - check for NULL value first 880 __ testl(rax, rax); 881 __ jcc(Assembler::zero, is_null); 882 883 // Move subklass into EBX 884 __ movl(rbx, Address(rax, oopDesc::klass_offset_in_bytes())); 885 // Move superklass into EAX 886 __ movl(rax, Address(rdx, oopDesc::klass_offset_in_bytes())); 887 __ movl(rax, Address(rax, sizeof(oopDesc) + objArrayKlass::element_klass_offset_in_bytes())); 888 // Compress array+index*4+12 into a single register. Frees ECX. 889 __ leal(rdx, Address(rdx, rcx, Address::times_4, arrayOopDesc::base_offset_in_bytes(T_OBJECT))); 890 891 // Generate subtype check. Blows ECX. Resets EDI to locals. 892 // Superklass in EAX. Subklass in EBX. 893 __ gen_subtype_check( rbx, ok_is_subtype ); 894 895 // Come here on failure 896 // object is at TOS 897 __ jump(ExternalAddress(Interpreter::_throw_ArrayStoreException_entry)); 898 899 // Come here on success 900 __ bind(ok_is_subtype); 901 __ movl(rax, at_rsp()); // Value 902 __ movl(Address(rdx, 0), rax); 903 __ store_check(rdx); 904 __ jmpb(done); 905 906 // Have a NULL in EAX, EDX=array, ECX=index. Store NULL at ary[idx] 907 __ bind(is_null); 908 __ profile_null_seen(rbx); 909 __ movl(Address(rdx, rcx, Address::times_4, arrayOopDesc::base_offset_in_bytes(T_OBJECT)), rax); 910 911 // Pop stack arguments 912 __ bind(done); 913 __ addl(rsp, 3 * Interpreter::stackElementSize()); 914 } 915 916 917 void TemplateTable::bastore() { 918 transition(itos, vtos); 919 __ pop_i(rbx); 920 // rax,: value 921 // rdx: array 922 index_check(rdx, rbx); // prefer index in rbx, 923 // rbx,: index 924 __ movb(Address(rdx, rbx, Address::times_1, arrayOopDesc::base_offset_in_bytes(T_BYTE)), rax); 925 } 926 927 928 void TemplateTable::castore() { 929 transition(itos, vtos); 930 __ pop_i(rbx); 931 // rax,: value 932 // rdx: array 933 index_check(rdx, rbx); // prefer index in rbx, 934 // rbx,: index 935 __ movw(Address(rdx, rbx, Address::times_2, arrayOopDesc::base_offset_in_bytes(T_CHAR)), rax); 936 } 937 938 939 void TemplateTable::sastore() { 940 castore(); 941 } 942 943 944 void TemplateTable::istore(int n) { 945 transition(itos, vtos); 946 __ movl(iaddress(n), rax); 947 __ tag_local(frame::TagValue, n); 948 } 949 950 951 void TemplateTable::lstore(int n) { 952 transition(ltos, vtos); 953 __ movl(laddress(n), rax); 954 __ movl(haddress(n), rdx); 955 __ tag_local(frame::TagCategory2, n); 956 } 957 958 959 void TemplateTable::fstore(int n) { 960 transition(ftos, vtos); 961 __ fstp_s(faddress(n)); 962 __ tag_local(frame::TagValue, n); 963 } 964 965 966 void TemplateTable::dstore(int n) { 967 transition(dtos, vtos); 968 if (TaggedStackInterpreter) { 969 __ subl(rsp, 2 * wordSize); 970 __ fstp_d(Address(rsp, 0)); 971 __ popl(rax); 972 __ popl(rdx); 973 __ movl(laddress(n), rax); 974 __ movl(haddress(n), rdx); 975 __ tag_local(frame::TagCategory2, n); 976 } else { 977 __ fstp_d(daddress(n)); 978 } 979 } 980 981 982 void TemplateTable::astore(int n) { 983 transition(vtos, vtos); 984 __ pop_ptr(rax, rdx); 985 __ movl(aaddress(n), rax); 986 __ tag_local(rdx, n); 987 } 988 989 990 void TemplateTable::pop() { 991 transition(vtos, vtos); 992 __ addl(rsp, Interpreter::stackElementSize()); 993 } 994 995 996 void TemplateTable::pop2() { 997 transition(vtos, vtos); 998 __ addl(rsp, 2*Interpreter::stackElementSize()); 999 } 1000 1001 1002 void TemplateTable::dup() { 1003 transition(vtos, vtos); 1004 // stack: ..., a 1005 __ load_ptr_and_tag(0, rax, rdx); 1006 __ push_ptr(rax, rdx); 1007 // stack: ..., a, a 1008 } 1009 1010 1011 void TemplateTable::dup_x1() { 1012 transition(vtos, vtos); 1013 // stack: ..., a, b 1014 __ load_ptr_and_tag(0, rax, rdx); // load b 1015 __ load_ptr_and_tag(1, rcx, rbx); // load a 1016 __ store_ptr_and_tag(1, rax, rdx); // store b 1017 __ store_ptr_and_tag(0, rcx, rbx); // store a 1018 __ push_ptr(rax, rdx); // push b 1019 // stack: ..., b, a, b 1020 } 1021 1022 1023 void TemplateTable::dup_x2() { 1024 transition(vtos, vtos); 1025 // stack: ..., a, b, c 1026 __ load_ptr_and_tag(0, rax, rdx); // load c 1027 __ load_ptr_and_tag(2, rcx, rbx); // load a 1028 __ store_ptr_and_tag(2, rax, rdx); // store c in a 1029 __ push_ptr(rax, rdx); // push c 1030 // stack: ..., c, b, c, c 1031 __ load_ptr_and_tag(2, rax, rdx); // load b 1032 __ store_ptr_and_tag(2, rcx, rbx); // store a in b 1033 // stack: ..., c, a, c, c 1034 __ store_ptr_and_tag(1, rax, rdx); // store b in c 1035 // stack: ..., c, a, b, c 1036 } 1037 1038 1039 void TemplateTable::dup2() { 1040 transition(vtos, vtos); 1041 // stack: ..., a, b 1042 __ load_ptr_and_tag(1, rax, rdx); // load a 1043 __ push_ptr(rax, rdx); // push a 1044 __ load_ptr_and_tag(1, rax, rdx); // load b 1045 __ push_ptr(rax, rdx); // push b 1046 // stack: ..., a, b, a, b 1047 } 1048 1049 1050 void TemplateTable::dup2_x1() { 1051 transition(vtos, vtos); 1052 // stack: ..., a, b, c 1053 __ load_ptr_and_tag(0, rcx, rbx); // load c 1054 __ load_ptr_and_tag(1, rax, rdx); // load b 1055 __ push_ptr(rax, rdx); // push b 1056 __ push_ptr(rcx, rbx); // push c 1057 // stack: ..., a, b, c, b, c 1058 __ store_ptr_and_tag(3, rcx, rbx); // store c in b 1059 // stack: ..., a, c, c, b, c 1060 __ load_ptr_and_tag(4, rcx, rbx); // load a 1061 __ store_ptr_and_tag(2, rcx, rbx); // store a in 2nd c 1062 // stack: ..., a, c, a, b, c 1063 __ store_ptr_and_tag(4, rax, rdx); // store b in a 1064 // stack: ..., b, c, a, b, c 1065 // stack: ..., b, c, a, b, c 1066 } 1067 1068 1069 void TemplateTable::dup2_x2() { 1070 transition(vtos, vtos); 1071 // stack: ..., a, b, c, d 1072 __ load_ptr_and_tag(0, rcx, rbx); // load d 1073 __ load_ptr_and_tag(1, rax, rdx); // load c 1074 __ push_ptr(rax, rdx); // push c 1075 __ push_ptr(rcx, rbx); // push d 1076 // stack: ..., a, b, c, d, c, d 1077 __ load_ptr_and_tag(4, rax, rdx); // load b 1078 __ store_ptr_and_tag(2, rax, rdx); // store b in d 1079 __ store_ptr_and_tag(4, rcx, rbx); // store d in b 1080 // stack: ..., a, d, c, b, c, d 1081 __ load_ptr_and_tag(5, rcx, rbx); // load a 1082 __ load_ptr_and_tag(3, rax, rdx); // load c 1083 __ store_ptr_and_tag(3, rcx, rbx); // store a in c 1084 __ store_ptr_and_tag(5, rax, rdx); // store c in a 1085 // stack: ..., c, d, a, b, c, d 1086 // stack: ..., c, d, a, b, c, d 1087 } 1088 1089 1090 void TemplateTable::swap() { 1091 transition(vtos, vtos); 1092 // stack: ..., a, b 1093 __ load_ptr_and_tag(1, rcx, rbx); // load a 1094 __ load_ptr_and_tag(0, rax, rdx); // load b 1095 __ store_ptr_and_tag(0, rcx, rbx); // store a in b 1096 __ store_ptr_and_tag(1, rax, rdx); // store b in a 1097 // stack: ..., b, a 1098 } 1099 1100 1101 void TemplateTable::iop2(Operation op) { 1102 transition(itos, itos); 1103 switch (op) { 1104 case add : __ pop_i(rdx); __ addl (rax, rdx); break; 1105 case sub : __ movl(rdx, rax); __ pop_i(rax); __ subl (rax, rdx); break; 1106 case mul : __ pop_i(rdx); __ imull(rax, rdx); break; 1107 case _and : __ pop_i(rdx); __ andl (rax, rdx); break; 1108 case _or : __ pop_i(rdx); __ orl (rax, rdx); break; 1109 case _xor : __ pop_i(rdx); __ xorl (rax, rdx); break; 1110 case shl : __ movl(rcx, rax); __ pop_i(rax); __ shll (rax); break; // implicit masking of lower 5 bits by Intel shift instr. 1111 case shr : __ movl(rcx, rax); __ pop_i(rax); __ sarl (rax); break; // implicit masking of lower 5 bits by Intel shift instr. 1112 case ushr : __ movl(rcx, rax); __ pop_i(rax); __ shrl (rax); break; // implicit masking of lower 5 bits by Intel shift instr. 1113 default : ShouldNotReachHere(); 1114 } 1115 } 1116 1117 1118 void TemplateTable::lop2(Operation op) { 1119 transition(ltos, ltos); 1120 __ pop_l(rbx, rcx); 1121 switch (op) { 1122 case add : __ addl(rax, rbx); __ adcl(rdx, rcx); break; 1123 case sub : __ subl(rbx, rax); __ sbbl(rcx, rdx); 1124 __ movl(rax, rbx); __ movl(rdx, rcx); break; 1125 case _and: __ andl(rax, rbx); __ andl(rdx, rcx); break; 1126 case _or : __ orl (rax, rbx); __ orl (rdx, rcx); break; 1127 case _xor: __ xorl(rax, rbx); __ xorl(rdx, rcx); break; 1128 default : ShouldNotReachHere(); 1129 } 1130 } 1131 1132 1133 void TemplateTable::idiv() { 1134 transition(itos, itos); 1135 __ movl(rcx, rax); 1136 __ pop_i(rax); 1137 // Note: could xor rax, and rcx and compare with (-1 ^ min_int). If 1138 // they are not equal, one could do a normal division (no correction 1139 // needed), which may speed up this implementation for the common case. 1140 // (see also JVM spec., p.243 & p.271) 1141 __ corrected_idivl(rcx); 1142 } 1143 1144 1145 void TemplateTable::irem() { 1146 transition(itos, itos); 1147 __ movl(rcx, rax); 1148 __ pop_i(rax); 1149 // Note: could xor rax, and rcx and compare with (-1 ^ min_int). If 1150 // they are not equal, one could do a normal division (no correction 1151 // needed), which may speed up this implementation for the common case. 1152 // (see also JVM spec., p.243 & p.271) 1153 __ corrected_idivl(rcx); 1154 __ movl(rax, rdx); 1155 } 1156 1157 1158 void TemplateTable::lmul() { 1159 transition(ltos, ltos); 1160 __ pop_l(rbx, rcx); 1161 __ pushl(rcx); __ pushl(rbx); 1162 __ pushl(rdx); __ pushl(rax); 1163 __ lmul(2 * wordSize, 0); 1164 __ addl(rsp, 4 * wordSize); // take off temporaries 1165 } 1166 1167 1168 void TemplateTable::ldiv() { 1169 transition(ltos, ltos); 1170 __ pop_l(rbx, rcx); 1171 __ pushl(rcx); __ pushl(rbx); 1172 __ pushl(rdx); __ pushl(rax); 1173 // check if y = 0 1174 __ orl(rax, rdx); 1175 __ jump_cc(Assembler::zero, 1176 ExternalAddress(Interpreter::_throw_ArithmeticException_entry)); 1177 __ call_VM_leaf(CAST_FROM_FN_PTR(address, SharedRuntime::ldiv)); 1178 __ addl(rsp, 4 * wordSize); // take off temporaries 1179 } 1180 1181 1182 void TemplateTable::lrem() { 1183 transition(ltos, ltos); 1184 __ pop_l(rbx, rcx); 1185 __ pushl(rcx); __ pushl(rbx); 1186 __ pushl(rdx); __ pushl(rax); 1187 // check if y = 0 1188 __ orl(rax, rdx); 1189 __ jump_cc(Assembler::zero, 1190 ExternalAddress(Interpreter::_throw_ArithmeticException_entry)); 1191 __ call_VM_leaf(CAST_FROM_FN_PTR(address, SharedRuntime::lrem)); 1192 __ addl(rsp, 4 * wordSize); 1193 } 1194 1195 1196 void TemplateTable::lshl() { 1197 transition(itos, ltos); 1198 __ movl(rcx, rax); // get shift count 1199 __ pop_l(rax, rdx); // get shift value 1200 __ lshl(rdx, rax); 1201 } 1202 1203 1204 void TemplateTable::lshr() { 1205 transition(itos, ltos); 1206 __ movl(rcx, rax); // get shift count 1207 __ pop_l(rax, rdx); // get shift value 1208 __ lshr(rdx, rax, true); 1209 } 1210 1211 1212 void TemplateTable::lushr() { 1213 transition(itos, ltos); 1214 __ movl(rcx, rax); // get shift count 1215 __ pop_l(rax, rdx); // get shift value 1216 __ lshr(rdx, rax); 1217 } 1218 1219 1220 void TemplateTable::fop2(Operation op) { 1221 transition(ftos, ftos); 1222 __ pop_ftos_to_rsp(); // pop ftos into rsp 1223 switch (op) { 1224 case add: __ fadd_s (at_rsp()); break; 1225 case sub: __ fsubr_s(at_rsp()); break; 1226 case mul: __ fmul_s (at_rsp()); break; 1227 case div: __ fdivr_s(at_rsp()); break; 1228 case rem: __ fld_s (at_rsp()); __ fremr(rax); break; 1229 default : ShouldNotReachHere(); 1230 } 1231 __ f2ieee(); 1232 __ popl(rax); // pop float thing off 1233 } 1234 1235 1236 void TemplateTable::dop2(Operation op) { 1237 transition(dtos, dtos); 1238 __ pop_dtos_to_rsp(); // pop dtos into rsp 1239 1240 switch (op) { 1241 case add: __ fadd_d (at_rsp()); break; 1242 case sub: __ fsubr_d(at_rsp()); break; 1243 case mul: { 1244 Label L_strict; 1245 Label L_join; 1246 const Address access_flags (rcx, methodOopDesc::access_flags_offset()); 1247 __ get_method(rcx); 1248 __ movl(rcx, access_flags); 1249 __ testl(rcx, JVM_ACC_STRICT); 1250 __ jccb(Assembler::notZero, L_strict); 1251 __ fmul_d (at_rsp()); 1252 __ jmpb(L_join); 1253 __ bind(L_strict); 1254 __ fld_x(ExternalAddress(StubRoutines::addr_fpu_subnormal_bias1())); 1255 __ fmulp(); 1256 __ fmul_d (at_rsp()); 1257 __ fld_x(ExternalAddress(StubRoutines::addr_fpu_subnormal_bias2())); 1258 __ fmulp(); 1259 __ bind(L_join); 1260 break; 1261 } 1262 case div: { 1263 Label L_strict; 1264 Label L_join; 1265 const Address access_flags (rcx, methodOopDesc::access_flags_offset()); 1266 __ get_method(rcx); 1267 __ movl(rcx, access_flags); 1268 __ testl(rcx, JVM_ACC_STRICT); 1269 __ jccb(Assembler::notZero, L_strict); 1270 __ fdivr_d(at_rsp()); 1271 __ jmp(L_join); 1272 __ bind(L_strict); 1273 __ fld_x(ExternalAddress(StubRoutines::addr_fpu_subnormal_bias1())); 1274 __ fmul_d (at_rsp()); 1275 __ fdivrp(); 1276 __ fld_x(ExternalAddress(StubRoutines::addr_fpu_subnormal_bias2())); 1277 __ fmulp(); 1278 __ bind(L_join); 1279 break; 1280 } 1281 case rem: __ fld_d (at_rsp()); __ fremr(rax); break; 1282 default : ShouldNotReachHere(); 1283 } 1284 __ d2ieee(); 1285 // Pop double precision number from rsp. 1286 __ popl(rax); 1287 __ popl(rdx); 1288 } 1289 1290 1291 void TemplateTable::ineg() { 1292 transition(itos, itos); 1293 __ negl(rax); 1294 } 1295 1296 1297 void TemplateTable::lneg() { 1298 transition(ltos, ltos); 1299 __ lneg(rdx, rax); 1300 } 1301 1302 1303 void TemplateTable::fneg() { 1304 transition(ftos, ftos); 1305 __ fchs(); 1306 } 1307 1308 1309 void TemplateTable::dneg() { 1310 transition(dtos, dtos); 1311 __ fchs(); 1312 } 1313 1314 1315 void TemplateTable::iinc() { 1316 transition(vtos, vtos); 1317 __ load_signed_byte(rdx, at_bcp(2)); // get constant 1318 locals_index(rbx); 1319 __ addl(iaddress(rbx), rdx); 1320 } 1321 1322 1323 void TemplateTable::wide_iinc() { 1324 transition(vtos, vtos); 1325 __ movl(rdx, at_bcp(4)); // get constant 1326 locals_index_wide(rbx); 1327 __ bswap(rdx); // swap bytes & sign-extend constant 1328 __ sarl(rdx, 16); 1329 __ addl(iaddress(rbx), rdx); 1330 // Note: should probably use only one movl to get both 1331 // the index and the constant -> fix this 1332 } 1333 1334 1335 void TemplateTable::convert() { 1336 // Checking 1337 #ifdef ASSERT 1338 { TosState tos_in = ilgl; 1339 TosState tos_out = ilgl; 1340 switch (bytecode()) { 1341 case Bytecodes::_i2l: // fall through 1342 case Bytecodes::_i2f: // fall through 1343 case Bytecodes::_i2d: // fall through 1344 case Bytecodes::_i2b: // fall through 1345 case Bytecodes::_i2c: // fall through 1346 case Bytecodes::_i2s: tos_in = itos; break; 1347 case Bytecodes::_l2i: // fall through 1348 case Bytecodes::_l2f: // fall through 1349 case Bytecodes::_l2d: tos_in = ltos; break; 1350 case Bytecodes::_f2i: // fall through 1351 case Bytecodes::_f2l: // fall through 1352 case Bytecodes::_f2d: tos_in = ftos; break; 1353 case Bytecodes::_d2i: // fall through 1354 case Bytecodes::_d2l: // fall through 1355 case Bytecodes::_d2f: tos_in = dtos; break; 1356 default : ShouldNotReachHere(); 1357 } 1358 switch (bytecode()) { 1359 case Bytecodes::_l2i: // fall through 1360 case Bytecodes::_f2i: // fall through 1361 case Bytecodes::_d2i: // fall through 1362 case Bytecodes::_i2b: // fall through 1363 case Bytecodes::_i2c: // fall through 1364 case Bytecodes::_i2s: tos_out = itos; break; 1365 case Bytecodes::_i2l: // fall through 1366 case Bytecodes::_f2l: // fall through 1367 case Bytecodes::_d2l: tos_out = ltos; break; 1368 case Bytecodes::_i2f: // fall through 1369 case Bytecodes::_l2f: // fall through 1370 case Bytecodes::_d2f: tos_out = ftos; break; 1371 case Bytecodes::_i2d: // fall through 1372 case Bytecodes::_l2d: // fall through 1373 case Bytecodes::_f2d: tos_out = dtos; break; 1374 default : ShouldNotReachHere(); 1375 } 1376 transition(tos_in, tos_out); 1377 } 1378 #endif // ASSERT 1379 1380 // Conversion 1381 // (Note: use pushl(rcx)/popl(rcx) for 1/2-word stack-ptr manipulation) 1382 switch (bytecode()) { 1383 case Bytecodes::_i2l: 1384 __ extend_sign(rdx, rax); 1385 break; 1386 case Bytecodes::_i2f: 1387 __ pushl(rax); // store int on tos 1388 __ fild_s(at_rsp()); // load int to ST0 1389 __ f2ieee(); // truncate to float size 1390 __ popl(rcx); // adjust rsp 1391 break; 1392 case Bytecodes::_i2d: 1393 __ pushl(rax); // add one slot for d2ieee() 1394 __ pushl(rax); // store int on tos 1395 __ fild_s(at_rsp()); // load int to ST0 1396 __ d2ieee(); // truncate to double size 1397 __ popl(rcx); // adjust rsp 1398 __ popl(rcx); 1399 break; 1400 case Bytecodes::_i2b: 1401 __ shll(rax, 24); // truncate upper 24 bits 1402 __ sarl(rax, 24); // and sign-extend byte 1403 break; 1404 case Bytecodes::_i2c: 1405 __ andl(rax, 0xFFFF); // truncate upper 16 bits 1406 break; 1407 case Bytecodes::_i2s: 1408 __ shll(rax, 16); // truncate upper 16 bits 1409 __ sarl(rax, 16); // and sign-extend short 1410 break; 1411 case Bytecodes::_l2i: 1412 /* nothing to do */ 1413 break; 1414 case Bytecodes::_l2f: 1415 __ pushl(rdx); // store long on tos 1416 __ pushl(rax); 1417 __ fild_d(at_rsp()); // load long to ST0 1418 __ f2ieee(); // truncate to float size 1419 __ popl(rcx); // adjust rsp 1420 __ popl(rcx); 1421 break; 1422 case Bytecodes::_l2d: 1423 __ pushl(rdx); // store long on tos 1424 __ pushl(rax); 1425 __ fild_d(at_rsp()); // load long to ST0 1426 __ d2ieee(); // truncate to double size 1427 __ popl(rcx); // adjust rsp 1428 __ popl(rcx); 1429 break; 1430 case Bytecodes::_f2i: 1431 __ pushl(rcx); // reserve space for argument 1432 __ fstp_s(at_rsp()); // pass float argument on stack 1433 __ call_VM_leaf(CAST_FROM_FN_PTR(address, SharedRuntime::f2i), 1); 1434 break; 1435 case Bytecodes::_f2l: 1436 __ pushl(rcx); // reserve space for argument 1437 __ fstp_s(at_rsp()); // pass float argument on stack 1438 __ call_VM_leaf(CAST_FROM_FN_PTR(address, SharedRuntime::f2l), 1); 1439 break; 1440 case Bytecodes::_f2d: 1441 /* nothing to do */ 1442 break; 1443 case Bytecodes::_d2i: 1444 __ pushl(rcx); // reserve space for argument 1445 __ pushl(rcx); 1446 __ fstp_d(at_rsp()); // pass double argument on stack 1447 __ call_VM_leaf(CAST_FROM_FN_PTR(address, SharedRuntime::d2i), 2); 1448 break; 1449 case Bytecodes::_d2l: 1450 __ pushl(rcx); // reserve space for argument 1451 __ pushl(rcx); 1452 __ fstp_d(at_rsp()); // pass double argument on stack 1453 __ call_VM_leaf(CAST_FROM_FN_PTR(address, SharedRuntime::d2l), 2); 1454 break; 1455 case Bytecodes::_d2f: 1456 __ pushl(rcx); // reserve space for f2ieee() 1457 __ f2ieee(); // truncate to float size 1458 __ popl(rcx); // adjust rsp 1459 break; 1460 default : 1461 ShouldNotReachHere(); 1462 } 1463 } 1464 1465 1466 void TemplateTable::lcmp() { 1467 transition(ltos, itos); 1468 // y = rdx:rax 1469 __ pop_l(rbx, rcx); // get x = rcx:rbx 1470 __ lcmp2int(rcx, rbx, rdx, rax);// rcx := cmp(x, y) 1471 __ movl(rax, rcx); 1472 } 1473 1474 1475 void TemplateTable::float_cmp(bool is_float, int unordered_result) { 1476 if (is_float) { 1477 __ pop_ftos_to_rsp(); 1478 __ fld_s(at_rsp()); 1479 } else { 1480 __ pop_dtos_to_rsp(); 1481 __ fld_d(at_rsp()); 1482 __ popl(rdx); 1483 } 1484 __ popl(rcx); 1485 __ fcmp2int(rax, unordered_result < 0); 1486 } 1487 1488 1489 void TemplateTable::branch(bool is_jsr, bool is_wide) { 1490 __ get_method(rcx); // ECX holds method 1491 __ profile_taken_branch(rax,rbx); // EAX holds updated MDP, EBX holds bumped taken count 1492 1493 const ByteSize be_offset = methodOopDesc::backedge_counter_offset() + InvocationCounter::counter_offset(); 1494 const ByteSize inv_offset = methodOopDesc::invocation_counter_offset() + InvocationCounter::counter_offset(); 1495 const int method_offset = frame::interpreter_frame_method_offset * wordSize; 1496 1497 // Load up EDX with the branch displacement 1498 __ movl(rdx, at_bcp(1)); 1499 __ bswap(rdx); 1500 if (!is_wide) __ sarl(rdx, 16); 1501 1502 // Handle all the JSR stuff here, then exit. 1503 // It's much shorter and cleaner than intermingling with the 1504 // non-JSR normal-branch stuff occuring below. 1505 if (is_jsr) { 1506 // Pre-load the next target bytecode into EBX 1507 __ load_unsigned_byte(rbx, Address(rsi, rdx, Address::times_1, 0)); 1508 1509 // compute return address as bci in rax, 1510 __ leal(rax, at_bcp((is_wide ? 5 : 3) - in_bytes(constMethodOopDesc::codes_offset()))); 1511 __ subl(rax, Address(rcx, methodOopDesc::const_offset())); 1512 // Adjust the bcp in ESI by the displacement in EDX 1513 __ addl(rsi, rdx); 1514 // Push return address 1515 __ push_i(rax); 1516 // jsr returns vtos 1517 __ dispatch_only_noverify(vtos); 1518 return; 1519 } 1520 1521 // Normal (non-jsr) branch handling 1522 1523 // Adjust the bcp in ESI by the displacement in EDX 1524 __ addl(rsi, rdx); 1525 1526 assert(UseLoopCounter || !UseOnStackReplacement, "on-stack-replacement requires loop counters"); 1527 Label backedge_counter_overflow; 1528 Label profile_method; 1529 Label dispatch; 1530 if (UseLoopCounter) { 1531 // increment backedge counter for backward branches 1532 // rax,: MDO 1533 // rbx,: MDO bumped taken-count 1534 // rcx: method 1535 // rdx: target offset 1536 // rsi: target bcp 1537 // rdi: locals pointer 1538 __ testl(rdx, rdx); // check if forward or backward branch 1539 __ jcc(Assembler::positive, dispatch); // count only if backward branch 1540 1541 // increment counter 1542 __ movl(rax, Address(rcx, be_offset)); // load backedge counter 1543 __ increment(rax, InvocationCounter::count_increment); // increment counter 1544 __ movl(Address(rcx, be_offset), rax); // store counter 1545 1546 __ movl(rax, Address(rcx, inv_offset)); // load invocation counter 1547 __ andl(rax, InvocationCounter::count_mask_value); // and the status bits 1548 __ addl(rax, Address(rcx, be_offset)); // add both counters 1549 1550 if (ProfileInterpreter) { 1551 // Test to see if we should create a method data oop 1552 __ cmp32(rax, 1553 ExternalAddress((address) &InvocationCounter::InterpreterProfileLimit)); 1554 __ jcc(Assembler::less, dispatch); 1555 1556 // if no method data exists, go to profile method 1557 __ test_method_data_pointer(rax, profile_method); 1558 1559 if (UseOnStackReplacement) { 1560 // check for overflow against rbx, which is the MDO taken count 1561 __ cmp32(rbx, 1562 ExternalAddress((address) &InvocationCounter::InterpreterBackwardBranchLimit)); 1563 __ jcc(Assembler::below, dispatch); 1564 1565 // When ProfileInterpreter is on, the backedge_count comes from the 1566 // methodDataOop, which value does not get reset on the call to 1567 // frequency_counter_overflow(). To avoid excessive calls to the overflow 1568 // routine while the method is being compiled, add a second test to make 1569 // sure the overflow function is called only once every overflow_frequency. 1570 const int overflow_frequency = 1024; 1571 __ andl(rbx, overflow_frequency-1); 1572 __ jcc(Assembler::zero, backedge_counter_overflow); 1573 1574 } 1575 } else { 1576 if (UseOnStackReplacement) { 1577 // check for overflow against rax, which is the sum of the counters 1578 __ cmp32(rax, 1579 ExternalAddress((address) &InvocationCounter::InterpreterBackwardBranchLimit)); 1580 __ jcc(Assembler::aboveEqual, backedge_counter_overflow); 1581 1582 } 1583 } 1584 __ bind(dispatch); 1585 } 1586 1587 // Pre-load the next target bytecode into EBX 1588 __ load_unsigned_byte(rbx, Address(rsi, 0)); 1589 1590 // continue with the bytecode @ target 1591 // rax,: return bci for jsr's, unused otherwise 1592 // rbx,: target bytecode 1593 // rsi: target bcp 1594 __ dispatch_only(vtos); 1595 1596 if (UseLoopCounter) { 1597 if (ProfileInterpreter) { 1598 // Out-of-line code to allocate method data oop. 1599 __ bind(profile_method); 1600 __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::profile_method), rsi); 1601 __ load_unsigned_byte(rbx, Address(rsi, 0)); // restore target bytecode 1602 __ movl(rcx, Address(rbp, method_offset)); 1603 __ movl(rcx, Address(rcx, in_bytes(methodOopDesc::method_data_offset()))); 1604 __ movl(Address(rbp, frame::interpreter_frame_mdx_offset * wordSize), rcx); 1605 __ test_method_data_pointer(rcx, dispatch); 1606 // offset non-null mdp by MDO::data_offset() + IR::profile_method() 1607 __ addl(rcx, in_bytes(methodDataOopDesc::data_offset())); 1608 __ addl(rcx, rax); 1609 __ movl(Address(rbp, frame::interpreter_frame_mdx_offset * wordSize), rcx); 1610 __ jmp(dispatch); 1611 } 1612 1613 if (UseOnStackReplacement) { 1614 1615 // invocation counter overflow 1616 __ bind(backedge_counter_overflow); 1617 __ negl(rdx); 1618 __ addl(rdx, rsi); // branch bcp 1619 call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::frequency_counter_overflow), rdx); 1620 __ load_unsigned_byte(rbx, Address(rsi, 0)); // restore target bytecode 1621 1622 // rax,: osr nmethod (osr ok) or NULL (osr not possible) 1623 // rbx,: target bytecode 1624 // rdx: scratch 1625 // rdi: locals pointer 1626 // rsi: bcp 1627 __ testl(rax, rax); // test result 1628 __ jcc(Assembler::zero, dispatch); // no osr if null 1629 // nmethod may have been invalidated (VM may block upon call_VM return) 1630 __ movl(rcx, Address(rax, nmethod::entry_bci_offset())); 1631 __ cmpl(rcx, InvalidOSREntryBci); 1632 __ jcc(Assembler::equal, dispatch); 1633 1634 // We have the address of an on stack replacement routine in rax, 1635 // We need to prepare to execute the OSR method. First we must 1636 // migrate the locals and monitors off of the stack. 1637 1638 __ movl(rsi, rax); // save the nmethod 1639 1640 const Register thread = rcx; 1641 __ get_thread(thread); 1642 call_VM(noreg, CAST_FROM_FN_PTR(address, SharedRuntime::OSR_migration_begin)); 1643 // rax, is OSR buffer, move it to expected parameter location 1644 __ movl(rcx, rax); 1645 1646 // pop the interpreter frame 1647 __ movl(rdx, Address(rbp, frame::interpreter_frame_sender_sp_offset * wordSize)); // get sender sp 1648 __ leave(); // remove frame anchor 1649 __ popl(rdi); // get return address 1650 __ movl(rsp, rdx); // set sp to sender sp 1651 1652 1653 Label skip; 1654 Label chkint; 1655 1656 // The interpreter frame we have removed may be returning to 1657 // either the callstub or the interpreter. Since we will 1658 // now be returning from a compiled (OSR) nmethod we must 1659 // adjust the return to the return were it can handler compiled 1660 // results and clean the fpu stack. This is very similar to 1661 // what a i2c adapter must do. 1662 1663 // Are we returning to the call stub? 1664 1665 __ cmp32(rdi, ExternalAddress(StubRoutines::_call_stub_return_address)); 1666 __ jcc(Assembler::notEqual, chkint); 1667 1668 // yes adjust to the specialized call stub return. 1669 assert(StubRoutines::i486::get_call_stub_compiled_return() != NULL, "must be set"); 1670 __ lea(rdi, ExternalAddress(StubRoutines::i486::get_call_stub_compiled_return())); 1671 __ jmp(skip); 1672 1673 __ bind(chkint); 1674 1675 // Are we returning to the interpreter? Look for sentinel 1676 1677 __ cmpl(Address(rdi, -8), Interpreter::return_sentinel); 1678 __ jcc(Assembler::notEqual, skip); 1679 1680 // Adjust to compiled return back to interpreter 1681 1682 __ movl(rdi, Address(rdi, -4)); 1683 __ bind(skip); 1684 1685 // Align stack pointer for compiled code (note that caller is 1686 // responsible for undoing this fixup by remembering the old SP 1687 // in an rbp,-relative location) 1688 __ andl(rsp, -(StackAlignmentInBytes)); 1689 1690 // push the (possibly adjusted) return address 1691 __ pushl(rdi); 1692 1693 // and begin the OSR nmethod 1694 __ jmp(Address(rsi, nmethod::osr_entry_point_offset())); 1695 } 1696 } 1697 } 1698 1699 1700 void TemplateTable::if_0cmp(Condition cc) { 1701 transition(itos, vtos); 1702 // assume branch is more often taken than not (loops use backward branches) 1703 Label not_taken; 1704 __ testl(rax, rax); 1705 __ jcc(j_not(cc), not_taken); 1706 branch(false, false); 1707 __ bind(not_taken); 1708 __ profile_not_taken_branch(rax); 1709 } 1710 1711 1712 void TemplateTable::if_icmp(Condition cc) { 1713 transition(itos, vtos); 1714 // assume branch is more often taken than not (loops use backward branches) 1715 Label not_taken; 1716 __ pop_i(rdx); 1717 __ cmpl(rdx, rax); 1718 __ jcc(j_not(cc), not_taken); 1719 branch(false, false); 1720 __ bind(not_taken); 1721 __ profile_not_taken_branch(rax); 1722 } 1723 1724 1725 void TemplateTable::if_nullcmp(Condition cc) { 1726 transition(atos, vtos); 1727 // assume branch is more often taken than not (loops use backward branches) 1728 Label not_taken; 1729 __ testl(rax, rax); 1730 __ jcc(j_not(cc), not_taken); 1731 branch(false, false); 1732 __ bind(not_taken); 1733 __ profile_not_taken_branch(rax); 1734 } 1735 1736 1737 void TemplateTable::if_acmp(Condition cc) { 1738 transition(atos, vtos); 1739 // assume branch is more often taken than not (loops use backward branches) 1740 Label not_taken; 1741 __ pop_ptr(rdx); 1742 __ cmpl(rdx, rax); 1743 __ jcc(j_not(cc), not_taken); 1744 branch(false, false); 1745 __ bind(not_taken); 1746 __ profile_not_taken_branch(rax); 1747 } 1748 1749 1750 void TemplateTable::ret() { 1751 transition(vtos, vtos); 1752 locals_index(rbx); 1753 __ movl(rbx, iaddress(rbx)); // get return bci, compute return bcp 1754 __ profile_ret(rbx, rcx); 1755 __ get_method(rax); 1756 __ movl(rsi, Address(rax, methodOopDesc::const_offset())); 1757 __ leal(rsi, Address(rsi, rbx, Address::times_1, 1758 constMethodOopDesc::codes_offset())); 1759 __ dispatch_next(vtos); 1760 } 1761 1762 1763 void TemplateTable::wide_ret() { 1764 transition(vtos, vtos); 1765 locals_index_wide(rbx); 1766 __ movl(rbx, iaddress(rbx)); // get return bci, compute return bcp 1767 __ profile_ret(rbx, rcx); 1768 __ get_method(rax); 1769 __ movl(rsi, Address(rax, methodOopDesc::const_offset())); 1770 __ leal(rsi, Address(rsi, rbx, Address::times_1, constMethodOopDesc::codes_offset())); 1771 __ dispatch_next(vtos); 1772 } 1773 1774 1775 void TemplateTable::tableswitch() { 1776 Label default_case, continue_execution; 1777 transition(itos, vtos); 1778 // align rsi 1779 __ leal(rbx, at_bcp(wordSize)); 1780 __ andl(rbx, -wordSize); 1781 // load lo & hi 1782 __ movl(rcx, Address(rbx, 1 * wordSize)); 1783 __ movl(rdx, Address(rbx, 2 * wordSize)); 1784 __ bswap(rcx); 1785 __ bswap(rdx); 1786 // check against lo & hi 1787 __ cmpl(rax, rcx); 1788 __ jccb(Assembler::less, default_case); 1789 __ cmpl(rax, rdx); 1790 __ jccb(Assembler::greater, default_case); 1791 // lookup dispatch offset 1792 __ subl(rax, rcx); 1793 __ movl(rdx, Address(rbx, rax, Address::times_4, 3 * wordSize)); 1794 __ profile_switch_case(rax, rbx, rcx); 1795 // continue execution 1796 __ bind(continue_execution); 1797 __ bswap(rdx); 1798 __ load_unsigned_byte(rbx, Address(rsi, rdx, Address::times_1)); 1799 __ addl(rsi, rdx); 1800 __ dispatch_only(vtos); 1801 // handle default 1802 __ bind(default_case); 1803 __ profile_switch_default(rax); 1804 __ movl(rdx, Address(rbx, 0)); 1805 __ jmp(continue_execution); 1806 } 1807 1808 1809 void TemplateTable::lookupswitch() { 1810 transition(itos, itos); 1811 __ stop("lookupswitch bytecode should have been rewritten"); 1812 } 1813 1814 1815 void TemplateTable::fast_linearswitch() { 1816 transition(itos, vtos); 1817 Label loop_entry, loop, found, continue_execution; 1818 // bswap rax, so we can avoid bswapping the table entries 1819 __ bswap(rax); 1820 // align rsi 1821 __ leal(rbx, at_bcp(wordSize)); // btw: should be able to get rid of this instruction (change offsets below) 1822 __ andl(rbx, -wordSize); 1823 // set counter 1824 __ movl(rcx, Address(rbx, wordSize)); 1825 __ bswap(rcx); 1826 __ jmpb(loop_entry); 1827 // table search 1828 __ bind(loop); 1829 __ cmpl(rax, Address(rbx, rcx, Address::times_8, 2 * wordSize)); 1830 __ jccb(Assembler::equal, found); 1831 __ bind(loop_entry); 1832 __ decrement(rcx); 1833 __ jcc(Assembler::greaterEqual, loop); 1834 // default case 1835 __ profile_switch_default(rax); 1836 __ movl(rdx, Address(rbx, 0)); 1837 __ jmpb(continue_execution); 1838 // entry found -> get offset 1839 __ bind(found); 1840 __ movl(rdx, Address(rbx, rcx, Address::times_8, 3 * wordSize)); 1841 __ profile_switch_case(rcx, rax, rbx); 1842 // continue execution 1843 __ bind(continue_execution); 1844 __ bswap(rdx); 1845 __ load_unsigned_byte(rbx, Address(rsi, rdx, Address::times_1)); 1846 __ addl(rsi, rdx); 1847 __ dispatch_only(vtos); 1848 } 1849 1850 1851 void TemplateTable::fast_binaryswitch() { 1852 transition(itos, vtos); 1853 // Implementation using the following core algorithm: 1854 // 1855 // int binary_search(int key, LookupswitchPair* array, int n) { 1856 // // Binary search according to "Methodik des Programmierens" by 1857 // // Edsger W. Dijkstra and W.H.J. Feijen, Addison Wesley Germany 1985. 1858 // int i = 0; 1859 // int j = n; 1860 // while (i+1 < j) { 1861 // // invariant P: 0 <= i < j <= n and (a[i] <= key < a[j] or Q) 1862 // // with Q: for all i: 0 <= i < n: key < a[i] 1863 // // where a stands for the array and assuming that the (inexisting) 1864 // // element a[n] is infinitely big. 1865 // int h = (i + j) >> 1; 1866 // // i < h < j 1867 // if (key < array[h].fast_match()) { 1868 // j = h; 1869 // } else { 1870 // i = h; 1871 // } 1872 // } 1873 // // R: a[i] <= key < a[i+1] or Q 1874 // // (i.e., if key is within array, i is the correct index) 1875 // return i; 1876 // } 1877 1878 // register allocation 1879 const Register key = rax; // already set (tosca) 1880 const Register array = rbx; 1881 const Register i = rcx; 1882 const Register j = rdx; 1883 const Register h = rdi; // needs to be restored 1884 const Register temp = rsi; 1885 // setup array 1886 __ save_bcp(); 1887 1888 __ leal(array, at_bcp(3*wordSize)); // btw: should be able to get rid of this instruction (change offsets below) 1889 __ andl(array, -wordSize); 1890 // initialize i & j 1891 __ xorl(i, i); // i = 0; 1892 __ movl(j, Address(array, -wordSize)); // j = length(array); 1893 // Convert j into native byteordering 1894 __ bswap(j); 1895 // and start 1896 Label entry; 1897 __ jmp(entry); 1898 1899 // binary search loop 1900 { Label loop; 1901 __ bind(loop); 1902 // int h = (i + j) >> 1; 1903 __ leal(h, Address(i, j, Address::times_1)); // h = i + j; 1904 __ sarl(h, 1); // h = (i + j) >> 1; 1905 // if (key < array[h].fast_match()) { 1906 // j = h; 1907 // } else { 1908 // i = h; 1909 // } 1910 // Convert array[h].match to native byte-ordering before compare 1911 __ movl(temp, Address(array, h, Address::times_8, 0*wordSize)); 1912 __ bswap(temp); 1913 __ cmpl(key, temp); 1914 if (VM_Version::supports_cmov()) { 1915 __ cmovl(Assembler::less , j, h); // j = h if (key < array[h].fast_match()) 1916 __ cmovl(Assembler::greaterEqual, i, h); // i = h if (key >= array[h].fast_match()) 1917 } else { 1918 Label set_i, end_of_if; 1919 __ jccb(Assembler::greaterEqual, set_i); // { 1920 __ movl(j, h); // j = h; 1921 __ jmp(end_of_if); // } 1922 __ bind(set_i); // else { 1923 __ movl(i, h); // i = h; 1924 __ bind(end_of_if); // } 1925 } 1926 // while (i+1 < j) 1927 __ bind(entry); 1928 __ leal(h, Address(i, 1)); // i+1 1929 __ cmpl(h, j); // i+1 < j 1930 __ jcc(Assembler::less, loop); 1931 } 1932 1933 // end of binary search, result index is i (must check again!) 1934 Label default_case; 1935 // Convert array[i].match to native byte-ordering before compare 1936 __ movl(temp, Address(array, i, Address::times_8, 0*wordSize)); 1937 __ bswap(temp); 1938 __ cmpl(key, temp); 1939 __ jcc(Assembler::notEqual, default_case); 1940 1941 // entry found -> j = offset 1942 __ movl(j , Address(array, i, Address::times_8, 1*wordSize)); 1943 __ profile_switch_case(i, key, array); 1944 __ bswap(j); 1945 __ restore_bcp(); 1946 __ restore_locals(); // restore rdi 1947 __ load_unsigned_byte(rbx, Address(rsi, j, Address::times_1)); 1948 1949 __ addl(rsi, j); 1950 __ dispatch_only(vtos); 1951 1952 // default case -> j = default offset 1953 __ bind(default_case); 1954 __ profile_switch_default(i); 1955 __ movl(j, Address(array, -2*wordSize)); 1956 __ bswap(j); 1957 __ restore_bcp(); 1958 __ restore_locals(); // restore rdi 1959 __ load_unsigned_byte(rbx, Address(rsi, j, Address::times_1)); 1960 __ addl(rsi, j); 1961 __ dispatch_only(vtos); 1962 } 1963 1964 1965 void TemplateTable::_return(TosState state) { 1966 transition(state, state); 1967 assert(_desc->calls_vm(), "inconsistent calls_vm information"); // call in remove_activation 1968 1969 if (_desc->bytecode() == Bytecodes::_return_register_finalizer) { 1970 assert(state == vtos, "only valid state"); 1971 __ movl(rax, aaddress(0)); 1972 __ movl(rdi, Address(rax, oopDesc::klass_offset_in_bytes())); 1973 __ movl(rdi, Address(rdi, Klass::access_flags_offset_in_bytes() + sizeof(oopDesc))); 1974 __ testl(rdi, JVM_ACC_HAS_FINALIZER); 1975 Label skip_register_finalizer; 1976 __ jcc(Assembler::zero, skip_register_finalizer); 1977 1978 __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::register_finalizer), rax); 1979 1980 __ bind(skip_register_finalizer); 1981 } 1982 1983 __ remove_activation(state, rsi); 1984 __ jmp(rsi); 1985 } 1986 1987 1988 // ---------------------------------------------------------------------------- 1989 // Volatile variables demand their effects be made known to all CPU's in 1990 // order. Store buffers on most chips allow reads & writes to reorder; the 1991 // JMM's ReadAfterWrite.java test fails in -Xint mode without some kind of 1992 // memory barrier (i.e., it's not sufficient that the interpreter does not 1993 // reorder volatile references, the hardware also must not reorder them). 1994 // 1995 // According to the new Java Memory Model (JMM): 1996 // (1) All volatiles are serialized wrt to each other. 1997 // ALSO reads & writes act as aquire & release, so: 1998 // (2) A read cannot let unrelated NON-volatile memory refs that happen after 1999 // the read float up to before the read. It's OK for non-volatile memory refs 2000 // that happen before the volatile read to float down below it. 2001 // (3) Similar a volatile write cannot let unrelated NON-volatile memory refs 2002 // that happen BEFORE the write float down to after the write. It's OK for 2003 // non-volatile memory refs that happen after the volatile write to float up 2004 // before it. 2005 // 2006 // We only put in barriers around volatile refs (they are expensive), not 2007 // _between_ memory refs (that would require us to track the flavor of the 2008 // previous memory refs). Requirements (2) and (3) require some barriers 2009 // before volatile stores and after volatile loads. These nearly cover 2010 // requirement (1) but miss the volatile-store-volatile-load case. This final 2011 // case is placed after volatile-stores although it could just as well go 2012 // before volatile-loads. 2013 void TemplateTable::volatile_barrier( ) { 2014 // Helper function to insert a is-volatile test and memory barrier 2015 if( !os::is_MP() ) return; // Not needed on single CPU 2016 __ membar(); 2017 } 2018 2019 void TemplateTable::resolve_cache_and_index(int byte_no, Register Rcache, Register index) { 2020 assert(byte_no == 1 || byte_no == 2, "byte_no out of range"); 2021 2022 Register temp = rbx; 2023 2024 assert_different_registers(Rcache, index, temp); 2025 2026 const int shift_count = (1 + byte_no)*BitsPerByte; 2027 Label resolved; 2028 __ get_cache_and_index_at_bcp(Rcache, index, 1); 2029 __ movl(temp, Address(Rcache, index, Address::times_4, constantPoolCacheOopDesc::base_offset() + ConstantPoolCacheEntry::indices_offset())); 2030 __ shrl(temp, shift_count); 2031 // have we resolved this bytecode? 2032 __ andl(temp, 0xFF); 2033 __ cmpl(temp, (int)bytecode()); 2034 __ jcc(Assembler::equal, resolved); 2035 2036 // resolve first time through 2037 address entry; 2038 switch (bytecode()) { 2039 case Bytecodes::_getstatic : // fall through 2040 case Bytecodes::_putstatic : // fall through 2041 case Bytecodes::_getfield : // fall through 2042 case Bytecodes::_putfield : entry = CAST_FROM_FN_PTR(address, InterpreterRuntime::resolve_get_put); break; 2043 case Bytecodes::_invokevirtual : // fall through 2044 case Bytecodes::_invokespecial : // fall through 2045 case Bytecodes::_invokestatic : // fall through 2046 case Bytecodes::_invokeinterface: entry = CAST_FROM_FN_PTR(address, InterpreterRuntime::resolve_invoke); break; 2047 default : ShouldNotReachHere(); break; 2048 } 2049 __ movl(temp, (int)bytecode()); 2050 __ call_VM(noreg, entry, temp); 2051 // Update registers with resolved info 2052 __ get_cache_and_index_at_bcp(Rcache, index, 1); 2053 __ bind(resolved); 2054 } 2055 2056 2057 // The cache and index registers must be set before call 2058 void TemplateTable::load_field_cp_cache_entry(Register obj, 2059 Register cache, 2060 Register index, 2061 Register off, 2062 Register flags, 2063 bool is_static = false) { 2064 assert_different_registers(cache, index, flags, off); 2065 2066 ByteSize cp_base_offset = constantPoolCacheOopDesc::base_offset(); 2067 // Field offset 2068 __ movl(off, Address(cache, index, Address::times_4, 2069 in_bytes(cp_base_offset + ConstantPoolCacheEntry::f2_offset()))); 2070 // Flags 2071 __ movl(flags, Address(cache, index, Address::times_4, 2072 in_bytes(cp_base_offset + ConstantPoolCacheEntry::flags_offset()))); 2073 2074 // klass overwrite register 2075 if (is_static) { 2076 __ movl(obj, Address(cache, index, Address::times_4, 2077 in_bytes(cp_base_offset + ConstantPoolCacheEntry::f1_offset()))); 2078 } 2079 } 2080 2081 void TemplateTable::load_invoke_cp_cache_entry(int byte_no, 2082 Register method, 2083 Register itable_index, 2084 Register flags, 2085 bool is_invokevirtual, 2086 bool is_invokevfinal /*unused*/) { 2087 // setup registers 2088 const Register cache = rcx; 2089 const Register index = rdx; 2090 assert_different_registers(method, flags); 2091 assert_different_registers(method, cache, index); 2092 assert_different_registers(itable_index, flags); 2093 assert_different_registers(itable_index, cache, index); 2094 // determine constant pool cache field offsets 2095 const int method_offset = in_bytes( 2096 constantPoolCacheOopDesc::base_offset() + 2097 (is_invokevirtual 2098 ? ConstantPoolCacheEntry::f2_offset() 2099 : ConstantPoolCacheEntry::f1_offset() 2100 ) 2101 ); 2102 const int flags_offset = in_bytes(constantPoolCacheOopDesc::base_offset() + 2103 ConstantPoolCacheEntry::flags_offset()); 2104 // access constant pool cache fields 2105 const int index_offset = in_bytes(constantPoolCacheOopDesc::base_offset() + 2106 ConstantPoolCacheEntry::f2_offset()); 2107 2108 resolve_cache_and_index(byte_no, cache, index); 2109 2110 assert(wordSize == 4, "adjust code below"); 2111 __ movl(method, Address(cache, index, Address::times_4, method_offset)); 2112 if (itable_index != noreg) { 2113 __ movl(itable_index, Address(cache, index, Address::times_4, index_offset)); 2114 } 2115 __ movl(flags , Address(cache, index, Address::times_4, flags_offset )); 2116 } 2117 2118 2119 // The registers cache and index expected to be set before call. 2120 // Correct values of the cache and index registers are preserved. 2121 void TemplateTable::jvmti_post_field_access(Register cache, 2122 Register index, 2123 bool is_static, 2124 bool has_tos) { 2125 if (JvmtiExport::can_post_field_access()) { 2126 // Check to see if a field access watch has been set before we take 2127 // the time to call into the VM. 2128 Label L1; 2129 assert_different_registers(cache, index, rax); 2130 __ mov32(rax, ExternalAddress((address) JvmtiExport::get_field_access_count_addr())); 2131 __ testl(rax,rax); 2132 __ jcc(Assembler::zero, L1); 2133 2134 // cache entry pointer 2135 __ addl(cache, in_bytes(constantPoolCacheOopDesc::base_offset())); 2136 __ shll(index, LogBytesPerWord); 2137 __ addl(cache, index); 2138 if (is_static) { 2139 __ movl(rax, 0); // NULL object reference 2140 } else { 2141 __ pop(atos); // Get the object 2142 __ verify_oop(rax); 2143 __ push(atos); // Restore stack state 2144 } 2145 // rax,: object pointer or NULL 2146 // cache: cache entry pointer 2147 __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::post_field_access), 2148 rax, cache); 2149 __ get_cache_and_index_at_bcp(cache, index, 1); 2150 __ bind(L1); 2151 } 2152 } 2153 2154 void TemplateTable::pop_and_check_object(Register r) { 2155 __ pop_ptr(r); 2156 __ null_check(r); // for field access must check obj. 2157 __ verify_oop(r); 2158 } 2159 2160 void TemplateTable::getfield_or_static(int byte_no, bool is_static) { 2161 transition(vtos, vtos); 2162 2163 const Register cache = rcx; 2164 const Register index = rdx; 2165 const Register obj = rcx; 2166 const Register off = rbx; 2167 const Register flags = rax; 2168 2169 resolve_cache_and_index(byte_no, cache, index); 2170 jvmti_post_field_access(cache, index, is_static, false); 2171 load_field_cp_cache_entry(obj, cache, index, off, flags, is_static); 2172 2173 if (!is_static) pop_and_check_object(obj); 2174 2175 const Address lo(obj, off, Address::times_1, 0*wordSize); 2176 const Address hi(obj, off, Address::times_1, 1*wordSize); 2177 2178 Label Done, notByte, notInt, notShort, notChar, notLong, notFloat, notObj, notDouble; 2179 2180 __ shrl(flags, ConstantPoolCacheEntry::tosBits); 2181 assert(btos == 0, "change code, btos != 0"); 2182 // btos 2183 __ andl(flags, 0x0f); 2184 __ jcc(Assembler::notZero, notByte); 2185 2186 __ load_signed_byte(rax, lo ); 2187 __ push(btos); 2188 // Rewrite bytecode to be faster 2189 if (!is_static) { 2190 patch_bytecode(Bytecodes::_fast_bgetfield, rcx, rbx); 2191 } 2192 __ jmp(Done); 2193 2194 __ bind(notByte); 2195 // itos 2196 __ cmpl(flags, itos ); 2197 __ jcc(Assembler::notEqual, notInt); 2198 2199 __ movl(rax, lo ); 2200 __ push(itos); 2201 // Rewrite bytecode to be faster 2202 if (!is_static) { 2203 patch_bytecode(Bytecodes::_fast_igetfield, rcx, rbx); 2204 } 2205 __ jmp(Done); 2206 2207 __ bind(notInt); 2208 // atos 2209 __ cmpl(flags, atos ); 2210 __ jcc(Assembler::notEqual, notObj); 2211 2212 __ movl(rax, lo ); 2213 __ push(atos); 2214 if (!is_static) { 2215 patch_bytecode(Bytecodes::_fast_agetfield, rcx, rbx); 2216 } 2217 __ jmp(Done); 2218 2219 __ bind(notObj); 2220 // ctos 2221 __ cmpl(flags, ctos ); 2222 __ jcc(Assembler::notEqual, notChar); 2223 2224 __ load_unsigned_word(rax, lo ); 2225 __ push(ctos); 2226 if (!is_static) { 2227 patch_bytecode(Bytecodes::_fast_cgetfield, rcx, rbx); 2228 } 2229 __ jmp(Done); 2230 2231 __ bind(notChar); 2232 // stos 2233 __ cmpl(flags, stos ); 2234 __ jcc(Assembler::notEqual, notShort); 2235 2236 __ load_signed_word(rax, lo ); 2237 __ push(stos); 2238 if (!is_static) { 2239 patch_bytecode(Bytecodes::_fast_sgetfield, rcx, rbx); 2240 } 2241 __ jmp(Done); 2242 2243 __ bind(notShort); 2244 // ltos 2245 __ cmpl(flags, ltos ); 2246 __ jcc(Assembler::notEqual, notLong); 2247 2248 // Generate code as if volatile. There just aren't enough registers to 2249 // save that information and this code is faster than the test. 2250 __ fild_d(lo); // Must load atomically 2251 __ subl(rsp,2*wordSize); // Make space for store 2252 __ fistp_d(Address(rsp,0)); 2253 __ popl(rax); 2254 __ popl(rdx); 2255 2256 __ push(ltos); 2257 // Don't rewrite to _fast_lgetfield for potential volatile case. 2258 __ jmp(Done); 2259 2260 __ bind(notLong); 2261 // ftos 2262 __ cmpl(flags, ftos ); 2263 __ jcc(Assembler::notEqual, notFloat); 2264 2265 __ fld_s(lo); 2266 __ push(ftos); 2267 if (!is_static) { 2268 patch_bytecode(Bytecodes::_fast_fgetfield, rcx, rbx); 2269 } 2270 __ jmp(Done); 2271 2272 __ bind(notFloat); 2273 // dtos 2274 __ cmpl(flags, dtos ); 2275 __ jcc(Assembler::notEqual, notDouble); 2276 2277 __ fld_d(lo); 2278 __ push(dtos); 2279 if (!is_static) { 2280 patch_bytecode(Bytecodes::_fast_dgetfield, rcx, rbx); 2281 } 2282 __ jmpb(Done); 2283 2284 __ bind(notDouble); 2285 2286 __ stop("Bad state"); 2287 2288 __ bind(Done); 2289 // Doug Lea believes this is not needed with current Sparcs (TSO) and Intel (PSO). 2290 // volatile_barrier( ); 2291 } 2292 2293 2294 void TemplateTable::getfield(int byte_no) { 2295 getfield_or_static(byte_no, false); 2296 } 2297 2298 2299 void TemplateTable::getstatic(int byte_no) { 2300 getfield_or_static(byte_no, true); 2301 } 2302 2303 // The registers cache and index expected to be set before call. 2304 // The function may destroy various registers, just not the cache and index registers. 2305 void TemplateTable::jvmti_post_field_mod(Register cache, Register index, bool is_static) { 2306 2307 ByteSize cp_base_offset = constantPoolCacheOopDesc::base_offset(); 2308 2309 if (JvmtiExport::can_post_field_modification()) { 2310 // Check to see if a field modification watch has been set before we take 2311 // the time to call into the VM. 2312 Label L1; 2313 assert_different_registers(cache, index, rax); 2314 __ mov32(rax, ExternalAddress((address)JvmtiExport::get_field_modification_count_addr())); 2315 __ testl(rax, rax); 2316 __ jcc(Assembler::zero, L1); 2317 2318 // The cache and index registers have been already set. 2319 // This allows to eliminate this call but the cache and index 2320 // registers have to be correspondingly used after this line. 2321 __ get_cache_and_index_at_bcp(rax, rdx, 1); 2322 2323 if (is_static) { 2324 // Life is simple. Null out the object pointer. 2325 __ xorl(rbx, rbx); 2326 } else { 2327 // Life is harder. The stack holds the value on top, followed by the object. 2328 // We don't know the size of the value, though; it could be one or two words 2329 // depending on its type. As a result, we must find the type to determine where 2330 // the object is. 2331 Label two_word, valsize_known; 2332 __ movl(rcx, Address(rax, rdx, Address::times_4, in_bytes(cp_base_offset + 2333 ConstantPoolCacheEntry::flags_offset()))); 2334 __ movl(rbx, rsp); 2335 __ shrl(rcx, ConstantPoolCacheEntry::tosBits); 2336 // Make sure we don't need to mask rcx for tosBits after the above shift 2337 ConstantPoolCacheEntry::verify_tosBits(); 2338 __ cmpl(rcx, ltos); 2339 __ jccb(Assembler::equal, two_word); 2340 __ cmpl(rcx, dtos); 2341 __ jccb(Assembler::equal, two_word); 2342 __ addl(rbx, Interpreter::expr_offset_in_bytes(1)); // one word jvalue (not ltos, dtos) 2343 __ jmpb(valsize_known); 2344 2345 __ bind(two_word); 2346 __ addl(rbx, Interpreter::expr_offset_in_bytes(2)); // two words jvalue 2347 2348 __ bind(valsize_known); 2349 // setup object pointer 2350 __ movl(rbx, Address(rbx, 0)); 2351 } 2352 // cache entry pointer 2353 __ addl(rax, in_bytes(cp_base_offset)); 2354 __ shll(rdx, LogBytesPerWord); 2355 __ addl(rax, rdx); 2356 // object (tos) 2357 __ movl(rcx, rsp); 2358 // rbx,: object pointer set up above (NULL if static) 2359 // rax,: cache entry pointer 2360 // rcx: jvalue object on the stack 2361 __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::post_field_modification), 2362 rbx, rax, rcx); 2363 __ get_cache_and_index_at_bcp(cache, index, 1); 2364 __ bind(L1); 2365 } 2366 } 2367 2368 2369 void TemplateTable::putfield_or_static(int byte_no, bool is_static) { 2370 transition(vtos, vtos); 2371 2372 const Register cache = rcx; 2373 const Register index = rdx; 2374 const Register obj = rcx; 2375 const Register off = rbx; 2376 const Register flags = rax; 2377 2378 resolve_cache_and_index(byte_no, cache, index); 2379 jvmti_post_field_mod(cache, index, is_static); 2380 load_field_cp_cache_entry(obj, cache, index, off, flags, is_static); 2381 2382 // Doug Lea believes this is not needed with current Sparcs (TSO) and Intel (PSO). 2383 // volatile_barrier( ); 2384 2385 Label notVolatile, Done; 2386 __ movl(rdx, flags); 2387 __ shrl(rdx, ConstantPoolCacheEntry::volatileField); 2388 __ andl(rdx, 0x1); 2389 2390 // field addresses 2391 const Address lo(obj, off, Address::times_1, 0*wordSize); 2392 const Address hi(obj, off, Address::times_1, 1*wordSize); 2393 2394 Label notByte, notInt, notShort, notChar, notLong, notFloat, notObj, notDouble; 2395 2396 __ shrl(flags, ConstantPoolCacheEntry::tosBits); 2397 assert(btos == 0, "change code, btos != 0"); 2398 // btos 2399 __ andl(flags, 0x0f); 2400 __ jcc(Assembler::notZero, notByte); 2401 2402 __ pop(btos); 2403 if (!is_static) pop_and_check_object(obj); 2404 __ movb(lo, rax ); 2405 if (!is_static) { 2406 patch_bytecode(Bytecodes::_fast_bputfield, rcx, rbx); 2407 } 2408 __ jmp(Done); 2409 2410 __ bind(notByte); 2411 // itos 2412 __ cmpl(flags, itos ); 2413 __ jcc(Assembler::notEqual, notInt); 2414 2415 __ pop(itos); 2416 if (!is_static) pop_and_check_object(obj); 2417 2418 __ movl(lo, rax ); 2419 if (!is_static) { 2420 patch_bytecode(Bytecodes::_fast_iputfield, rcx, rbx); 2421 } 2422 __ jmp(Done); 2423 2424 __ bind(notInt); 2425 // atos 2426 __ cmpl(flags, atos ); 2427 __ jcc(Assembler::notEqual, notObj); 2428 2429 __ pop(atos); 2430 if (!is_static) pop_and_check_object(obj); 2431 2432 __ movl(lo, rax ); 2433 __ store_check(obj, lo); // Need to mark card 2434 if (!is_static) { 2435 patch_bytecode(Bytecodes::_fast_aputfield, rcx, rbx); 2436 } 2437 __ jmp(Done); 2438 2439 __ bind(notObj); 2440 // ctos 2441 __ cmpl(flags, ctos ); 2442 __ jcc(Assembler::notEqual, notChar); 2443 2444 __ pop(ctos); 2445 if (!is_static) pop_and_check_object(obj); 2446 __ movw(lo, rax ); 2447 if (!is_static) { 2448 patch_bytecode(Bytecodes::_fast_cputfield, rcx, rbx); 2449 } 2450 __ jmp(Done); 2451 2452 __ bind(notChar); 2453 // stos 2454 __ cmpl(flags, stos ); 2455 __ jcc(Assembler::notEqual, notShort); 2456 2457 __ pop(stos); 2458 if (!is_static) pop_and_check_object(obj); 2459 __ movw(lo, rax ); 2460 if (!is_static) { 2461 patch_bytecode(Bytecodes::_fast_sputfield, rcx, rbx); 2462 } 2463 __ jmp(Done); 2464 2465 __ bind(notShort); 2466 // ltos 2467 __ cmpl(flags, ltos ); 2468 __ jcc(Assembler::notEqual, notLong); 2469 2470 Label notVolatileLong; 2471 __ testl(rdx, rdx); 2472 __ jcc(Assembler::zero, notVolatileLong); 2473 2474 __ pop(ltos); // overwrites rdx, do this after testing volatile. 2475 if (!is_static) pop_and_check_object(obj); 2476 2477 // Replace with real volatile test 2478 __ pushl(rdx); 2479 __ pushl(rax); // Must update atomically with FIST 2480 __ fild_d(Address(rsp,0)); // So load into FPU register 2481 __ fistp_d(lo); // and put into memory atomically 2482 __ addl(rsp,2*wordSize); 2483 volatile_barrier(); 2484 // Don't rewrite volatile version 2485 __ jmp(notVolatile); 2486 2487 __ bind(notVolatileLong); 2488 2489 __ pop(ltos); // overwrites rdx 2490 if (!is_static) pop_and_check_object(obj); 2491 __ movl(hi, rdx); 2492 __ movl(lo, rax); 2493 if (!is_static) { 2494 patch_bytecode(Bytecodes::_fast_lputfield, rcx, rbx); 2495 } 2496 __ jmp(notVolatile); 2497 2498 __ bind(notLong); 2499 // ftos 2500 __ cmpl(flags, ftos ); 2501 __ jcc(Assembler::notEqual, notFloat); 2502 2503 __ pop(ftos); 2504 if (!is_static) pop_and_check_object(obj); 2505 __ fstp_s(lo); 2506 if (!is_static) { 2507 patch_bytecode(Bytecodes::_fast_fputfield, rcx, rbx); 2508 } 2509 __ jmp(Done); 2510 2511 __ bind(notFloat); 2512 // dtos 2513 __ cmpl(flags, dtos ); 2514 __ jcc(Assembler::notEqual, notDouble); 2515 2516 __ pop(dtos); 2517 if (!is_static) pop_and_check_object(obj); 2518 __ fstp_d(lo); 2519 if (!is_static) { 2520 patch_bytecode(Bytecodes::_fast_dputfield, rcx, rbx); 2521 } 2522 __ jmp(Done); 2523 2524 __ bind(notDouble); 2525 2526 __ stop("Bad state"); 2527 2528 __ bind(Done); 2529 2530 // Check for volatile store 2531 __ testl(rdx, rdx); 2532 __ jcc(Assembler::zero, notVolatile); 2533 volatile_barrier( ); 2534 __ bind(notVolatile); 2535 } 2536 2537 2538 void TemplateTable::putfield(int byte_no) { 2539 putfield_or_static(byte_no, false); 2540 } 2541 2542 2543 void TemplateTable::putstatic(int byte_no) { 2544 putfield_or_static(byte_no, true); 2545 } 2546 2547 void TemplateTable::jvmti_post_fast_field_mod() { 2548 if (JvmtiExport::can_post_field_modification()) { 2549 // Check to see if a field modification watch has been set before we take 2550 // the time to call into the VM. 2551 Label L2; 2552 __ mov32(rcx, ExternalAddress((address)JvmtiExport::get_field_modification_count_addr())); 2553 __ testl(rcx,rcx); 2554 __ jcc(Assembler::zero, L2); 2555 __ pop_ptr(rbx); // copy the object pointer from tos 2556 __ verify_oop(rbx); 2557 __ push_ptr(rbx); // put the object pointer back on tos 2558 __ subl(rsp, sizeof(jvalue)); // add space for a jvalue object 2559 __ movl(rcx, rsp); 2560 __ push_ptr(rbx); // save object pointer so we can steal rbx, 2561 __ movl(rbx, 0); 2562 const Address lo_value(rcx, rbx, Address::times_1, 0*wordSize); 2563 const Address hi_value(rcx, rbx, Address::times_1, 1*wordSize); 2564 switch (bytecode()) { // load values into the jvalue object 2565 case Bytecodes::_fast_bputfield: __ movb(lo_value, rax); break; 2566 case Bytecodes::_fast_sputfield: __ movw(lo_value, rax); break; 2567 case Bytecodes::_fast_cputfield: __ movw(lo_value, rax); break; 2568 case Bytecodes::_fast_iputfield: __ movl(lo_value, rax); break; 2569 case Bytecodes::_fast_lputfield: __ movl(hi_value, rdx); __ movl(lo_value, rax); break; 2570 // need to call fld_s() after fstp_s() to restore the value for below 2571 case Bytecodes::_fast_fputfield: __ fstp_s(lo_value); __ fld_s(lo_value); break; 2572 // need to call fld_d() after fstp_d() to restore the value for below 2573 case Bytecodes::_fast_dputfield: __ fstp_d(lo_value); __ fld_d(lo_value); break; 2574 // since rcx is not an object we don't call store_check() here 2575 case Bytecodes::_fast_aputfield: __ movl(lo_value, rax); break; 2576 default: ShouldNotReachHere(); 2577 } 2578 __ pop_ptr(rbx); // restore copy of object pointer 2579 2580 // Save rax, and sometimes rdx because call_VM() will clobber them, 2581 // then use them for JVM/DI purposes 2582 __ pushl(rax); 2583 if (bytecode() == Bytecodes::_fast_lputfield) __ pushl(rdx); 2584 // access constant pool cache entry 2585 __ get_cache_entry_pointer_at_bcp(rax, rdx, 1); 2586 __ verify_oop(rbx); 2587 // rbx,: object pointer copied above 2588 // rax,: cache entry pointer 2589 // rcx: jvalue object on the stack 2590 __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::post_field_modification), rbx, rax, rcx); 2591 if (bytecode() == Bytecodes::_fast_lputfield) __ popl(rdx); // restore high value 2592 __ popl(rax); // restore lower value 2593 __ addl(rsp, sizeof(jvalue)); // release jvalue object space 2594 __ bind(L2); 2595 } 2596 } 2597 2598 void TemplateTable::fast_storefield(TosState state) { 2599 transition(state, vtos); 2600 2601 ByteSize base = constantPoolCacheOopDesc::base_offset(); 2602 2603 jvmti_post_fast_field_mod(); 2604 2605 // access constant pool cache 2606 __ get_cache_and_index_at_bcp(rcx, rbx, 1); 2607 2608 // test for volatile with rdx but rdx is tos register for lputfield. 2609 if (bytecode() == Bytecodes::_fast_lputfield) __ pushl(rdx); 2610 __ movl(rdx, Address(rcx, rbx, Address::times_4, in_bytes(base + 2611 ConstantPoolCacheEntry::flags_offset()))); 2612 2613 // replace index with field offset from cache entry 2614 __ movl(rbx, Address(rcx, rbx, Address::times_4, in_bytes(base + ConstantPoolCacheEntry::f2_offset()))); 2615 2616 // Doug Lea believes this is not needed with current Sparcs (TSO) and Intel (PSO). 2617 // volatile_barrier( ); 2618 2619 Label notVolatile, Done; 2620 __ shrl(rdx, ConstantPoolCacheEntry::volatileField); 2621 __ andl(rdx, 0x1); 2622 // Check for volatile store 2623 __ testl(rdx, rdx); 2624 __ jcc(Assembler::zero, notVolatile); 2625 2626 if (bytecode() == Bytecodes::_fast_lputfield) __ popl(rdx); 2627 2628 // Get object from stack 2629 pop_and_check_object(rcx); 2630 2631 // field addresses 2632 const Address lo(rcx, rbx, Address::times_1, 0*wordSize); 2633 const Address hi(rcx, rbx, Address::times_1, 1*wordSize); 2634 2635 // access field 2636 switch (bytecode()) { 2637 case Bytecodes::_fast_bputfield: __ movb(lo, rax); break; 2638 case Bytecodes::_fast_sputfield: // fall through 2639 case Bytecodes::_fast_cputfield: __ movw(lo, rax); break; 2640 case Bytecodes::_fast_iputfield: __ movl(lo, rax); break; 2641 case Bytecodes::_fast_lputfield: __ movl(hi, rdx); __ movl(lo, rax); break; 2642 case Bytecodes::_fast_fputfield: __ fstp_s(lo); break; 2643 case Bytecodes::_fast_dputfield: __ fstp_d(lo); break; 2644 case Bytecodes::_fast_aputfield: __ movl(lo, rax); __ store_check(rcx, lo); break; 2645 default: 2646 ShouldNotReachHere(); 2647 } 2648 2649 Label done; 2650 volatile_barrier( ); 2651 __ jmpb(done); 2652 2653 // Same code as above, but don't need rdx to test for volatile. 2654 __ bind(notVolatile); 2655 2656 if (bytecode() == Bytecodes::_fast_lputfield) __ popl(rdx); 2657 2658 // Get object from stack 2659 pop_and_check_object(rcx); 2660 2661 // access field 2662 switch (bytecode()) { 2663 case Bytecodes::_fast_bputfield: __ movb(lo, rax); break; 2664 case Bytecodes::_fast_sputfield: // fall through 2665 case Bytecodes::_fast_cputfield: __ movw(lo, rax); break; 2666 case Bytecodes::_fast_iputfield: __ movl(lo, rax); break; 2667 case Bytecodes::_fast_lputfield: __ movl(hi, rdx); __ movl(lo, rax); break; 2668 case Bytecodes::_fast_fputfield: __ fstp_s(lo); break; 2669 case Bytecodes::_fast_dputfield: __ fstp_d(lo); break; 2670 case Bytecodes::_fast_aputfield: __ movl(lo, rax); __ store_check(rcx, lo); break; 2671 default: 2672 ShouldNotReachHere(); 2673 } 2674 __ bind(done); 2675 } 2676 2677 2678 void TemplateTable::fast_accessfield(TosState state) { 2679 transition(atos, state); 2680 2681 // do the JVMTI work here to avoid disturbing the register state below 2682 if (JvmtiExport::can_post_field_access()) { 2683 // Check to see if a field access watch has been set before we take 2684 // the time to call into the VM. 2685 Label L1; 2686 __ mov32(rcx, ExternalAddress((address) JvmtiExport::get_field_access_count_addr())); 2687 __ testl(rcx,rcx); 2688 __ jcc(Assembler::zero, L1); 2689 // access constant pool cache entry 2690 __ get_cache_entry_pointer_at_bcp(rcx, rdx, 1); 2691 __ push_ptr(rax); // save object pointer before call_VM() clobbers it 2692 __ verify_oop(rax); 2693 // rax,: object pointer copied above 2694 // rcx: cache entry pointer 2695 __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::post_field_access), rax, rcx); 2696 __ pop_ptr(rax); // restore object pointer 2697 __ bind(L1); 2698 } 2699 2700 // access constant pool cache 2701 __ get_cache_and_index_at_bcp(rcx, rbx, 1); 2702 // replace index with field offset from cache entry 2703 __ movl(rbx, Address(rcx, rbx, Address::times_4, in_bytes(constantPoolCacheOopDesc::base_offset() + ConstantPoolCacheEntry::f2_offset()))); 2704 2705 2706 // rax,: object 2707 __ verify_oop(rax); 2708 __ null_check(rax); 2709 // field addresses 2710 const Address lo = Address(rax, rbx, Address::times_1, 0*wordSize); 2711 const Address hi = Address(rax, rbx, Address::times_1, 1*wordSize); 2712 2713 // access field 2714 switch (bytecode()) { 2715 case Bytecodes::_fast_bgetfield: __ movsxb(rax, lo ); break; 2716 case Bytecodes::_fast_sgetfield: __ load_signed_word(rax, lo ); break; 2717 case Bytecodes::_fast_cgetfield: __ load_unsigned_word(rax, lo ); break; 2718 case Bytecodes::_fast_igetfield: __ movl(rax, lo); break; 2719 case Bytecodes::_fast_lgetfield: __ stop("should not be rewritten"); break; 2720 case Bytecodes::_fast_fgetfield: __ fld_s(lo); break; 2721 case Bytecodes::_fast_dgetfield: __ fld_d(lo); break; 2722 case Bytecodes::_fast_agetfield: __ movl(rax, lo); __ verify_oop(rax); break; 2723 default: 2724 ShouldNotReachHere(); 2725 } 2726 2727 // Doug Lea believes this is not needed with current Sparcs(TSO) and Intel(PSO) 2728 // volatile_barrier( ); 2729 } 2730 2731 void TemplateTable::fast_xaccess(TosState state) { 2732 transition(vtos, state); 2733 // get receiver 2734 __ movl(rax, aaddress(0)); 2735 debug_only(__ verify_local_tag(frame::TagReference, 0)); 2736 // access constant pool cache 2737 __ get_cache_and_index_at_bcp(rcx, rdx, 2); 2738 __ movl(rbx, Address(rcx, rdx, Address::times_4, in_bytes(constantPoolCacheOopDesc::base_offset() + ConstantPoolCacheEntry::f2_offset()))); 2739 // make sure exception is reported in correct bcp range (getfield is next instruction) 2740 __ increment(rsi); 2741 __ null_check(rax); 2742 const Address lo = Address(rax, rbx, Address::times_1, 0*wordSize); 2743 if (state == itos) { 2744 __ movl(rax, lo); 2745 } else if (state == atos) { 2746 __ movl(rax, lo); 2747 __ verify_oop(rax); 2748 } else if (state == ftos) { 2749 __ fld_s(lo); 2750 } else { 2751 ShouldNotReachHere(); 2752 } 2753 __ decrement(rsi); 2754 } 2755 2756 2757 2758 //---------------------------------------------------------------------------------------------------- 2759 // Calls 2760 2761 void TemplateTable::count_calls(Register method, Register temp) { 2762 // implemented elsewhere 2763 ShouldNotReachHere(); 2764 } 2765 2766 2767 void TemplateTable::prepare_invoke(Register method, Register index, int byte_no, Bytecodes::Code code) { 2768 // determine flags 2769 const bool is_invokeinterface = code == Bytecodes::_invokeinterface; 2770 const bool is_invokevirtual = code == Bytecodes::_invokevirtual; 2771 const bool is_invokespecial = code == Bytecodes::_invokespecial; 2772 const bool load_receiver = code != Bytecodes::_invokestatic; 2773 const bool receiver_null_check = is_invokespecial; 2774 const bool save_flags = is_invokeinterface || is_invokevirtual; 2775 // setup registers & access constant pool cache 2776 const Register recv = rcx; 2777 const Register flags = rdx; 2778 assert_different_registers(method, index, recv, flags); 2779 2780 // save 'interpreter return address' 2781 __ save_bcp(); 2782 2783 load_invoke_cp_cache_entry(byte_no, method, index, flags, is_invokevirtual); 2784 2785 // load receiver if needed (note: no return address pushed yet) 2786 if (load_receiver) { 2787 __ movl(recv, flags); 2788 __ andl(recv, 0xFF); 2789 // recv count is 0 based? 2790 __ movl(recv, Address(rsp, recv, Interpreter::stackElementScale(), -Interpreter::expr_offset_in_bytes(1))); 2791 __ verify_oop(recv); 2792 } 2793 2794 // do null check if needed 2795 if (receiver_null_check) { 2796 __ null_check(recv); 2797 } 2798 2799 if (save_flags) { 2800 __ movl(rsi, flags); 2801 } 2802 2803 // compute return type 2804 __ shrl(flags, ConstantPoolCacheEntry::tosBits); 2805 // Make sure we don't need to mask flags for tosBits after the above shift 2806 ConstantPoolCacheEntry::verify_tosBits(); 2807 // load return address 2808 { const int table = 2809 is_invokeinterface 2810 ? (int)Interpreter::return_5_addrs_by_index_table() 2811 : (int)Interpreter::return_3_addrs_by_index_table(); 2812 __ movl(flags, Address(noreg, flags, Address::times_4, table)); 2813 } 2814 2815 // push return address 2816 __ pushl(flags); 2817 2818 // Restore flag value from the constant pool cache, and restore rsi 2819 // for later null checks. rsi is the bytecode pointer 2820 if (save_flags) { 2821 __ movl(flags, rsi); 2822 __ restore_bcp(); 2823 } 2824 } 2825 2826 2827 void TemplateTable::invokevirtual_helper(Register index, Register recv, 2828 Register flags) { 2829 2830 // Uses temporary registers rax, rdx 2831 assert_different_registers(index, recv, rax, rdx); 2832 2833 // Test for an invoke of a final method 2834 Label notFinal; 2835 __ movl(rax, flags); 2836 __ andl(rax, (1 << ConstantPoolCacheEntry::vfinalMethod)); 2837 __ jcc(Assembler::zero, notFinal); 2838 2839 Register method = index; // method must be rbx, 2840 assert(method == rbx, "methodOop must be rbx, for interpreter calling convention"); 2841 2842 // do the call - the index is actually the method to call 2843 __ verify_oop(method); 2844 2845 // It's final, need a null check here! 2846 __ null_check(recv); 2847 2848 // profile this call 2849 __ profile_final_call(rax); 2850 2851 __ jump_from_interpreted(method, rax); 2852 2853 __ bind(notFinal); 2854 2855 // get receiver klass 2856 __ null_check(recv, oopDesc::klass_offset_in_bytes()); 2857 // Keep recv in rcx for callee expects it there 2858 __ movl(rax, Address(recv, oopDesc::klass_offset_in_bytes())); 2859 __ verify_oop(rax); 2860 2861 // profile this call 2862 __ profile_virtual_call(rax, rdi, rdx); 2863 2864 // get target methodOop & entry point 2865 const int base = instanceKlass::vtable_start_offset() * wordSize; 2866 assert(vtableEntry::size() * wordSize == 4, "adjust the scaling in the code below"); 2867 __ movl(method, Address(rax, index, Address::times_4, base + vtableEntry::method_offset_in_bytes())); 2868 __ jump_from_interpreted(method, rdx); 2869 } 2870 2871 2872 void TemplateTable::invokevirtual(int byte_no) { 2873 transition(vtos, vtos); 2874 prepare_invoke(rbx, noreg, byte_no, bytecode()); 2875 2876 // rbx,: index 2877 // rcx: receiver 2878 // rdx: flags 2879 2880 invokevirtual_helper(rbx, rcx, rdx); 2881 } 2882 2883 2884 void TemplateTable::invokespecial(int byte_no) { 2885 transition(vtos, vtos); 2886 prepare_invoke(rbx, noreg, byte_no, bytecode()); 2887 // do the call 2888 __ verify_oop(rbx); 2889 __ profile_call(rax); 2890 __ jump_from_interpreted(rbx, rax); 2891 } 2892 2893 2894 void TemplateTable::invokestatic(int byte_no) { 2895 transition(vtos, vtos); 2896 prepare_invoke(rbx, noreg, byte_no, bytecode()); 2897 // do the call 2898 __ verify_oop(rbx); 2899 __ profile_call(rax); 2900 __ jump_from_interpreted(rbx, rax); 2901 } 2902 2903 2904 void TemplateTable::fast_invokevfinal(int byte_no) { 2905 transition(vtos, vtos); 2906 __ stop("fast_invokevfinal not used on x86"); 2907 } 2908 2909 2910 void TemplateTable::invokeinterface(int byte_no) { 2911 transition(vtos, vtos); 2912 prepare_invoke(rax, rbx, byte_no, bytecode()); 2913 2914 // rax,: Interface 2915 // rbx,: index 2916 // rcx: receiver 2917 // rdx: flags 2918 2919 // Special case of invokeinterface called for virtual method of 2920 // java.lang.Object. See cpCacheOop.cpp for details. 2921 // This code isn't produced by javac, but could be produced by 2922 // another compliant java compiler. 2923 Label notMethod; 2924 __ movl(rdi, rdx); 2925 __ andl(rdi, (1 << ConstantPoolCacheEntry::methodInterface)); 2926 __ jcc(Assembler::zero, notMethod); 2927 2928 invokevirtual_helper(rbx, rcx, rdx); 2929 __ bind(notMethod); 2930 2931 // Get receiver klass into rdx - also a null check 2932 __ restore_locals(); // restore rdi 2933 __ movl(rdx, Address(rcx, oopDesc::klass_offset_in_bytes())); 2934 __ verify_oop(rdx); 2935 2936 // profile this call 2937 __ profile_virtual_call(rdx, rsi, rdi); 2938 2939 __ movl(rdi, rdx); // Save klassOop in rdi 2940 2941 // Compute start of first itableOffsetEntry (which is at the end of the vtable) 2942 const int base = instanceKlass::vtable_start_offset() * wordSize; 2943 assert(vtableEntry::size() * wordSize == 4, "adjust the scaling in the code below"); 2944 __ movl(rsi, Address(rdx, instanceKlass::vtable_length_offset() * wordSize)); // Get length of vtable 2945 __ leal(rdx, Address(rdx, rsi, Address::times_4, base)); 2946 if (HeapWordsPerLong > 1) { 2947 // Round up to align_object_offset boundary 2948 __ round_to(rdx, BytesPerLong); 2949 } 2950 2951 Label entry, search, interface_ok; 2952 2953 __ jmpb(entry); 2954 __ bind(search); 2955 __ addl(rdx, itableOffsetEntry::size() * wordSize); 2956 2957 __ bind(entry); 2958 2959 // Check that the entry is non-null. A null entry means that the receiver 2960 // class doesn't implement the interface, and wasn't the same as the 2961 // receiver class checked when the interface was resolved. 2962 __ pushl(rdx); 2963 __ movl(rdx, Address(rdx, itableOffsetEntry::interface_offset_in_bytes())); 2964 __ testl(rdx, rdx); 2965 __ jcc(Assembler::notZero, interface_ok); 2966 // throw exception 2967 __ popl(rdx); // pop saved register first. 2968 __ popl(rbx); // pop return address (pushed by prepare_invoke) 2969 __ restore_bcp(); // rsi must be correct for exception handler (was destroyed) 2970 __ restore_locals(); // make sure locals pointer is correct as well (was destroyed) 2971 __ call_VM(noreg, CAST_FROM_FN_PTR(address, 2972 InterpreterRuntime::throw_IncompatibleClassChangeError)); 2973 // the call_VM checks for exception, so we should never return here. 2974 __ should_not_reach_here(); 2975 __ bind(interface_ok); 2976 2977 __ popl(rdx); 2978 2979 __ cmpl(rax, Address(rdx, itableOffsetEntry::interface_offset_in_bytes())); 2980 __ jcc(Assembler::notEqual, search); 2981 2982 __ movl(rdx, Address(rdx, itableOffsetEntry::offset_offset_in_bytes())); 2983 __ addl(rdx, rdi); // Add offset to klassOop 2984 assert(itableMethodEntry::size() * wordSize == 4, "adjust the scaling in the code below"); 2985 __ movl(rbx, Address(rdx, rbx, Address::times_4)); 2986 // rbx,: methodOop to call 2987 // rcx: receiver 2988 // Check for abstract method error 2989 // Note: This should be done more efficiently via a throw_abstract_method_error 2990 // interpreter entry point and a conditional jump to it in case of a null 2991 // method. 2992 { Label L; 2993 __ testl(rbx, rbx); 2994 __ jcc(Assembler::notZero, L); 2995 // throw exception 2996 // note: must restore interpreter registers to canonical 2997 // state for exception handling to work correctly! 2998 __ popl(rbx); // pop return address (pushed by prepare_invoke) 2999 __ restore_bcp(); // rsi must be correct for exception handler (was destroyed) 3000 __ restore_locals(); // make sure locals pointer is correct as well (was destroyed) 3001 __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::throw_AbstractMethodError)); 3002 // the call_VM checks for exception, so we should never return here. 3003 __ should_not_reach_here(); 3004 __ bind(L); 3005 } 3006 3007 // do the call 3008 // rcx: receiver 3009 // rbx,: methodOop 3010 __ jump_from_interpreted(rbx, rdx); 3011 } 3012 3013 //---------------------------------------------------------------------------------------------------- 3014 // Allocation 3015 3016 void TemplateTable::_new() { 3017 transition(vtos, atos); 3018 __ get_unsigned_2_byte_index_at_bcp(rdx, 1); 3019 Label slow_case; 3020 Label done; 3021 Label initialize_header; 3022 Label initialize_object; // including clearing the fields 3023 Label allocate_shared; 3024 3025 ExternalAddress heap_top((address)Universe::heap()->top_addr()); 3026 3027 __ get_cpool_and_tags(rcx, rax); 3028 // get instanceKlass 3029 __ movl(rcx, Address(rcx, rdx, Address::times_4, sizeof(constantPoolOopDesc))); 3030 __ pushl(rcx); // save the contexts of klass for initializing the header 3031 3032 // make sure the class we're about to instantiate has been resolved. 3033 // Note: slow_case does a pop of stack, which is why we loaded class/pushed above 3034 const int tags_offset = typeArrayOopDesc::header_size(T_BYTE) * wordSize; 3035 __ cmpb(Address(rax, rdx, Address::times_1, tags_offset), JVM_CONSTANT_Class); 3036 __ jcc(Assembler::notEqual, slow_case); 3037 3038 // make sure klass is initialized & doesn't have finalizer 3039 // make sure klass is fully initialized 3040 __ cmpl(Address(rcx, instanceKlass::init_state_offset_in_bytes() + sizeof(oopDesc)), instanceKlass::fully_initialized); 3041 __ jcc(Assembler::notEqual, slow_case); 3042 3043 // get instance_size in instanceKlass (scaled to a count of bytes) 3044 __ movl(rdx, Address(rcx, Klass::layout_helper_offset_in_bytes() + sizeof(oopDesc))); 3045 // test to see if it has a finalizer or is malformed in some way 3046 __ testl(rdx, Klass::_lh_instance_slow_path_bit); 3047 __ jcc(Assembler::notZero, slow_case); 3048 3049 // 3050 // Allocate the instance 3051 // 1) Try to allocate in the TLAB 3052 // 2) if fail and the object is large allocate in the shared Eden 3053 // 3) if the above fails (or is not applicable), go to a slow case 3054 // (creates a new TLAB, etc.) 3055 3056 const bool allow_shared_alloc = 3057 Universe::heap()->supports_inline_contig_alloc() && !CMSIncrementalMode; 3058 3059 if (UseTLAB) { 3060 const Register thread = rcx; 3061 3062 __ get_thread(thread); 3063 __ movl(rax, Address(thread, in_bytes(JavaThread::tlab_top_offset()))); 3064 __ leal(rbx, Address(rax, rdx, Address::times_1)); 3065 __ cmpl(rbx, Address(thread, in_bytes(JavaThread::tlab_end_offset()))); 3066 __ jcc(Assembler::above, allow_shared_alloc ? allocate_shared : slow_case); 3067 __ movl(Address(thread, in_bytes(JavaThread::tlab_top_offset())), rbx); 3068 if (ZeroTLAB) { 3069 // the fields have been already cleared 3070 __ jmp(initialize_header); 3071 } else { 3072 // initialize both the header and fields 3073 __ jmp(initialize_object); 3074 } 3075 } 3076 3077 // Allocation in the shared Eden, if allowed. 3078 // 3079 // rdx: instance size in bytes 3080 if (allow_shared_alloc) { 3081 __ bind(allocate_shared); 3082 3083 Label retry; 3084 __ bind(retry); 3085 __ mov32(rax, heap_top); 3086 __ leal(rbx, Address(rax, rdx, Address::times_1)); 3087 __ cmp32(rbx, ExternalAddress((address)Universe::heap()->end_addr())); 3088 __ jcc(Assembler::above, slow_case); 3089 3090 // Compare rax, with the top addr, and if still equal, store the new 3091 // top addr in rbx, at the address of the top addr pointer. Sets ZF if was 3092 // equal, and clears it otherwise. Use lock prefix for atomicity on MPs. 3093 // 3094 // rax,: object begin 3095 // rbx,: object end 3096 // rdx: instance size in bytes 3097 if (os::is_MP()) __ lock(); 3098 __ cmpxchgptr(rbx, heap_top); 3099 3100 // if someone beat us on the allocation, try again, otherwise continue 3101 __ jcc(Assembler::notEqual, retry); 3102 } 3103 3104 if (UseTLAB || Universe::heap()->supports_inline_contig_alloc()) { 3105 // The object is initialized before the header. If the object size is 3106 // zero, go directly to the header initialization. 3107 __ bind(initialize_object); 3108 __ decrement(rdx, sizeof(oopDesc)); 3109 __ jcc(Assembler::zero, initialize_header); 3110 3111 // Initialize topmost object field, divide rdx by 8, check if odd and 3112 // test if zero. 3113 __ xorl(rcx, rcx); // use zero reg to clear memory (shorter code) 3114 __ shrl(rdx, LogBytesPerLong); // divide by 2*oopSize and set carry flag if odd 3115 3116 // rdx must have been multiple of 8 3117 #ifdef ASSERT 3118 // make sure rdx was multiple of 8 3119 Label L; 3120 // Ignore partial flag stall after shrl() since it is debug VM 3121 __ jccb(Assembler::carryClear, L); 3122 __ stop("object size is not multiple of 2 - adjust this code"); 3123 __ bind(L); 3124 // rdx must be > 0, no extra check needed here 3125 #endif 3126 3127 // initialize remaining object fields: rdx was a multiple of 8 3128 { Label loop; 3129 __ bind(loop); 3130 __ movl(Address(rax, rdx, Address::times_8, sizeof(oopDesc) - 1*oopSize), rcx); 3131 __ movl(Address(rax, rdx, Address::times_8, sizeof(oopDesc) - 2*oopSize), rcx); 3132 __ decrement(rdx); 3133 __ jcc(Assembler::notZero, loop); 3134 } 3135 3136 // initialize object header only. 3137 __ bind(initialize_header); 3138 if (UseBiasedLocking) { 3139 __ popl(rcx); // get saved klass back in the register. 3140 __ movl(rbx, Address(rcx, Klass::prototype_header_offset_in_bytes() + klassOopDesc::klass_part_offset_in_bytes())); 3141 __ movl(Address(rax, oopDesc::mark_offset_in_bytes ()), rbx); 3142 } else { 3143 __ movl(Address(rax, oopDesc::mark_offset_in_bytes ()), 3144 (int)markOopDesc::prototype()); // header 3145 __ popl(rcx); // get saved klass back in the register. 3146 } 3147 __ movl(Address(rax, oopDesc::klass_offset_in_bytes()), rcx); // klass 3148 3149 { 3150 SkipIfEqual skip_if(_masm, &DTraceAllocProbes, 0); 3151 // Trigger dtrace event for fastpath 3152 __ push(atos); 3153 __ call_VM_leaf( 3154 CAST_FROM_FN_PTR(address, SharedRuntime::dtrace_object_alloc), rax); 3155 __ pop(atos); 3156 } 3157 3158 __ jmp(done); 3159 } 3160 3161 // slow case 3162 __ bind(slow_case); 3163 __ popl(rcx); // restore stack pointer to what it was when we came in. 3164 __ get_constant_pool(rax); 3165 __ get_unsigned_2_byte_index_at_bcp(rdx, 1); 3166 call_VM(rax, CAST_FROM_FN_PTR(address, InterpreterRuntime::_new), rax, rdx); 3167 3168 // continue 3169 __ bind(done); 3170 } 3171 3172 3173 void TemplateTable::newarray() { 3174 transition(itos, atos); 3175 __ push_i(rax); // make sure everything is on the stack 3176 __ load_unsigned_byte(rdx, at_bcp(1)); 3177 call_VM(rax, CAST_FROM_FN_PTR(address, InterpreterRuntime::newarray), rdx, rax); 3178 __ pop_i(rdx); // discard size 3179 } 3180 3181 3182 void TemplateTable::anewarray() { 3183 transition(itos, atos); 3184 __ get_unsigned_2_byte_index_at_bcp(rdx, 1); 3185 __ get_constant_pool(rcx); 3186 call_VM(rax, CAST_FROM_FN_PTR(address, InterpreterRuntime::anewarray), rcx, rdx, rax); 3187 } 3188 3189 3190 void TemplateTable::arraylength() { 3191 transition(atos, itos); 3192 __ null_check(rax, arrayOopDesc::length_offset_in_bytes()); 3193 __ movl(rax, Address(rax, arrayOopDesc::length_offset_in_bytes())); 3194 } 3195 3196 3197 void TemplateTable::checkcast() { 3198 transition(atos, atos); 3199 Label done, is_null, ok_is_subtype, quicked, resolved; 3200 __ testl(rax, rax); // Object is in EAX 3201 __ jcc(Assembler::zero, is_null); 3202 3203 // Get cpool & tags index 3204 __ get_cpool_and_tags(rcx, rdx); // ECX=cpool, EDX=tags array 3205 __ get_unsigned_2_byte_index_at_bcp(rbx, 1); // EBX=index 3206 // See if bytecode has already been quicked 3207 __ cmpb(Address(rdx, rbx, Address::times_1, typeArrayOopDesc::header_size(T_BYTE) * wordSize), JVM_CONSTANT_Class); 3208 __ jcc(Assembler::equal, quicked); 3209 3210 __ push(atos); 3211 call_VM(rax, CAST_FROM_FN_PTR(address, InterpreterRuntime::quicken_io_cc) ); 3212 __ pop_ptr(rdx); 3213 __ jmpb(resolved); 3214 3215 // Get superklass in EAX and subklass in EBX 3216 __ bind(quicked); 3217 __ movl(rdx, rax); // Save object in EDX; EAX needed for subtype check 3218 __ movl(rax, Address(rcx, rbx, Address::times_4, sizeof(constantPoolOopDesc))); 3219 3220 __ bind(resolved); 3221 __ movl(rbx, Address(rdx, oopDesc::klass_offset_in_bytes())); 3222 3223 // Generate subtype check. Blows ECX. Resets EDI. Object in EDX. 3224 // Superklass in EAX. Subklass in EBX. 3225 __ gen_subtype_check( rbx, ok_is_subtype ); 3226 3227 // Come here on failure 3228 __ pushl(rdx); 3229 // object is at TOS 3230 __ jump(ExternalAddress(Interpreter::_throw_ClassCastException_entry)); 3231 3232 // Come here on success 3233 __ bind(ok_is_subtype); 3234 __ movl(rax,rdx); // Restore object in EDX 3235 3236 // Collect counts on whether this check-cast sees NULLs a lot or not. 3237 if (ProfileInterpreter) { 3238 __ jmp(done); 3239 __ bind(is_null); 3240 __ profile_null_seen(rcx); 3241 } else { 3242 __ bind(is_null); // same as 'done' 3243 } 3244 __ bind(done); 3245 } 3246 3247 3248 void TemplateTable::instanceof() { 3249 transition(atos, itos); 3250 Label done, is_null, ok_is_subtype, quicked, resolved; 3251 __ testl(rax, rax); 3252 __ jcc(Assembler::zero, is_null); 3253 3254 // Get cpool & tags index 3255 __ get_cpool_and_tags(rcx, rdx); // ECX=cpool, EDX=tags array 3256 __ get_unsigned_2_byte_index_at_bcp(rbx, 1); // EBX=index 3257 // See if bytecode has already been quicked 3258 __ cmpb(Address(rdx, rbx, Address::times_1, typeArrayOopDesc::header_size(T_BYTE) * wordSize), JVM_CONSTANT_Class); 3259 __ jcc(Assembler::equal, quicked); 3260 3261 __ push(atos); 3262 call_VM(rax, CAST_FROM_FN_PTR(address, InterpreterRuntime::quicken_io_cc) ); 3263 __ pop_ptr(rdx); 3264 __ movl(rdx, Address(rdx, oopDesc::klass_offset_in_bytes())); 3265 __ jmp(resolved); 3266 3267 // Get superklass in EAX and subklass in EDX 3268 __ bind(quicked); 3269 __ movl(rdx, Address(rax, oopDesc::klass_offset_in_bytes())); 3270 __ movl(rax, Address(rcx, rbx, Address::times_4, sizeof(constantPoolOopDesc))); 3271 3272 __ bind(resolved); 3273 3274 // Generate subtype check. Blows ECX. Resets EDI. 3275 // Superklass in EAX. Subklass in EDX. 3276 __ gen_subtype_check( rdx, ok_is_subtype ); 3277 3278 // Come here on failure 3279 __ xorl(rax,rax); 3280 __ jmpb(done); 3281 // Come here on success 3282 __ bind(ok_is_subtype); 3283 __ movl(rax, 1); 3284 3285 // Collect counts on whether this test sees NULLs a lot or not. 3286 if (ProfileInterpreter) { 3287 __ jmp(done); 3288 __ bind(is_null); 3289 __ profile_null_seen(rcx); 3290 } else { 3291 __ bind(is_null); // same as 'done' 3292 } 3293 __ bind(done); 3294 // rax, = 0: obj == NULL or obj is not an instanceof the specified klass 3295 // rax, = 1: obj != NULL and obj is an instanceof the specified klass 3296 } 3297 3298 3299 //---------------------------------------------------------------------------------------------------- 3300 // Breakpoints 3301 void TemplateTable::_breakpoint() { 3302 3303 // Note: We get here even if we are single stepping.. 3304 // jbug inists on setting breakpoints at every bytecode 3305 // even if we are in single step mode. 3306 3307 transition(vtos, vtos); 3308 3309 // get the unpatched byte code 3310 __ get_method(rcx); 3311 __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::get_original_bytecode_at), rcx, rsi); 3312 __ movl(rbx, rax); 3313 3314 // post the breakpoint event 3315 __ get_method(rcx); 3316 __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::_breakpoint), rcx, rsi); 3317 3318 // complete the execution of original bytecode 3319 __ dispatch_only_normal(vtos); 3320 } 3321 3322 3323 //---------------------------------------------------------------------------------------------------- 3324 // Exceptions 3325 3326 void TemplateTable::athrow() { 3327 transition(atos, vtos); 3328 __ null_check(rax); 3329 __ jump(ExternalAddress(Interpreter::throw_exception_entry())); 3330 } 3331 3332 3333 //---------------------------------------------------------------------------------------------------- 3334 // Synchronization 3335 // 3336 // Note: monitorenter & exit are symmetric routines; which is reflected 3337 // in the assembly code structure as well 3338 // 3339 // Stack layout: 3340 // 3341 // [expressions ] <--- rsp = expression stack top 3342 // .. 3343 // [expressions ] 3344 // [monitor entry] <--- monitor block top = expression stack bot 3345 // .. 3346 // [monitor entry] 3347 // [frame data ] <--- monitor block bot 3348 // ... 3349 // [saved rbp, ] <--- rbp, 3350 3351 3352 void TemplateTable::monitorenter() { 3353 transition(atos, vtos); 3354 3355 // check for NULL object 3356 __ null_check(rax); 3357 3358 const Address monitor_block_top(rbp, frame::interpreter_frame_monitor_block_top_offset * wordSize); 3359 const Address monitor_block_bot(rbp, frame::interpreter_frame_initial_sp_offset * wordSize); 3360 const int entry_size = ( frame::interpreter_frame_monitor_size() * wordSize); 3361 Label allocated; 3362 3363 // initialize entry pointer 3364 __ xorl(rdx, rdx); // points to free slot or NULL 3365 3366 // find a free slot in the monitor block (result in rdx) 3367 { Label entry, loop, exit; 3368 __ movl(rcx, monitor_block_top); // points to current entry, starting with top-most entry 3369 __ leal(rbx, monitor_block_bot); // points to word before bottom of monitor block 3370 __ jmpb(entry); 3371 3372 __ bind(loop); 3373 __ cmpl(Address(rcx, BasicObjectLock::obj_offset_in_bytes()), NULL_WORD); // check if current entry is used 3374 3375 // TODO - need new func here - kbt 3376 if (VM_Version::supports_cmov()) { 3377 __ cmovl(Assembler::equal, rdx, rcx); // if not used then remember entry in rdx 3378 } else { 3379 Label L; 3380 __ jccb(Assembler::notEqual, L); 3381 __ movl(rdx, rcx); // if not used then remember entry in rdx 3382 __ bind(L); 3383 } 3384 __ cmpl(rax, Address(rcx, BasicObjectLock::obj_offset_in_bytes())); // check if current entry is for same object 3385 __ jccb(Assembler::equal, exit); // if same object then stop searching 3386 __ addl(rcx, entry_size); // otherwise advance to next entry 3387 __ bind(entry); 3388 __ cmpl(rcx, rbx); // check if bottom reached 3389 __ jcc(Assembler::notEqual, loop); // if not at bottom then check this entry 3390 __ bind(exit); 3391 } 3392 3393 __ testl(rdx, rdx); // check if a slot has been found 3394 __ jccb(Assembler::notZero, allocated); // if found, continue with that one 3395 3396 // allocate one if there's no free slot 3397 { Label entry, loop; 3398 // 1. compute new pointers // rsp: old expression stack top 3399 __ movl(rdx, monitor_block_bot); // rdx: old expression stack bottom 3400 __ subl(rsp, entry_size); // move expression stack top 3401 __ subl(rdx, entry_size); // move expression stack bottom 3402 __ movl(rcx, rsp); // set start value for copy loop 3403 __ movl(monitor_block_bot, rdx); // set new monitor block top 3404 __ jmp(entry); 3405 // 2. move expression stack contents 3406 __ bind(loop); 3407 __ movl(rbx, Address(rcx, entry_size)); // load expression stack word from old location 3408 __ movl(Address(rcx, 0), rbx); // and store it at new location 3409 __ addl(rcx, wordSize); // advance to next word 3410 __ bind(entry); 3411 __ cmpl(rcx, rdx); // check if bottom reached 3412 __ jcc(Assembler::notEqual, loop); // if not at bottom then copy next word 3413 } 3414 3415 // call run-time routine 3416 // rdx: points to monitor entry 3417 __ bind(allocated); 3418 3419 // Increment bcp to point to the next bytecode, so exception handling for async. exceptions work correctly. 3420 // The object has already been poped from the stack, so the expression stack looks correct. 3421 __ increment(rsi); 3422 3423 __ movl(Address(rdx, BasicObjectLock::obj_offset_in_bytes()), rax); // store object 3424 __ lock_object(rdx); 3425 3426 // check to make sure this monitor doesn't cause stack overflow after locking 3427 __ save_bcp(); // in case of exception 3428 __ generate_stack_overflow_check(0); 3429 3430 // The bcp has already been incremented. Just need to dispatch to next instruction. 3431 __ dispatch_next(vtos); 3432 } 3433 3434 3435 void TemplateTable::monitorexit() { 3436 transition(atos, vtos); 3437 3438 // check for NULL object 3439 __ null_check(rax); 3440 3441 const Address monitor_block_top(rbp, frame::interpreter_frame_monitor_block_top_offset * wordSize); 3442 const Address monitor_block_bot(rbp, frame::interpreter_frame_initial_sp_offset * wordSize); 3443 const int entry_size = ( frame::interpreter_frame_monitor_size() * wordSize); 3444 Label found; 3445 3446 // find matching slot 3447 { Label entry, loop; 3448 __ movl(rdx, monitor_block_top); // points to current entry, starting with top-most entry 3449 __ leal(rbx, monitor_block_bot); // points to word before bottom of monitor block 3450 __ jmpb(entry); 3451 3452 __ bind(loop); 3453 __ cmpl(rax, Address(rdx, BasicObjectLock::obj_offset_in_bytes())); // check if current entry is for same object 3454 __ jcc(Assembler::equal, found); // if same object then stop searching 3455 __ addl(rdx, entry_size); // otherwise advance to next entry 3456 __ bind(entry); 3457 __ cmpl(rdx, rbx); // check if bottom reached 3458 __ jcc(Assembler::notEqual, loop); // if not at bottom then check this entry 3459 } 3460 3461 // error handling. Unlocking was not block-structured 3462 Label end; 3463 __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::throw_illegal_monitor_state_exception)); 3464 __ should_not_reach_here(); 3465 3466 // call run-time routine 3467 // rcx: points to monitor entry 3468 __ bind(found); 3469 __ push_ptr(rax); // make sure object is on stack (contract with oopMaps) 3470 __ unlock_object(rdx); 3471 __ pop_ptr(rax); // discard object 3472 __ bind(end); 3473 } 3474 3475 3476 //---------------------------------------------------------------------------------------------------- 3477 // Wide instructions 3478 3479 void TemplateTable::wide() { 3480 transition(vtos, vtos); 3481 __ load_unsigned_byte(rbx, at_bcp(1)); 3482 __ jmp(Address(noreg, rbx, Address::times_4, int(Interpreter::_wentry_point))); 3483 // Note: the rsi increment step is part of the individual wide bytecode implementations 3484 } 3485 3486 3487 //---------------------------------------------------------------------------------------------------- 3488 // Multi arrays 3489 3490 void TemplateTable::multianewarray() { 3491 transition(vtos, atos); 3492 __ load_unsigned_byte(rax, at_bcp(3)); // get number of dimensions 3493 // last dim is on top of stack; we want address of first one: 3494 // first_addr = last_addr + (ndims - 1) * stackElementSize - 1*wordsize 3495 // the latter wordSize to point to the beginning of the array. 3496 __ leal( rax, Address(rsp, rax, Interpreter::stackElementScale(), -wordSize)); 3497 call_VM(rax, CAST_FROM_FN_PTR(address, InterpreterRuntime::multianewarray), rax); // pass in rax, 3498 __ load_unsigned_byte(rbx, at_bcp(3)); 3499 __ leal(rsp, Address(rsp, rbx, Interpreter::stackElementScale())); // get rid of counts 3500 } 3501 3502 #endif /* !CC_INTERP */