1 /* 2 * Copyright (c) 1997, 2015, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 * 23 */ 24 25 #include "precompiled.hpp" 26 #include "interpreter/interpreter.hpp" 27 #include "interpreter/interpreterRuntime.hpp" 28 #include "interpreter/interp_masm.hpp" 29 #include "interpreter/templateTable.hpp" 30 #include "memory/universe.inline.hpp" 31 #include "oops/methodData.hpp" 32 #include "oops/objArrayKlass.hpp" 33 #include "oops/oop.inline.hpp" 34 #include "prims/methodHandles.hpp" 35 #include "runtime/sharedRuntime.hpp" 36 #include "runtime/stubRoutines.hpp" 37 #include "runtime/synchronizer.hpp" 38 #include "utilities/macros.hpp" 39 40 #ifndef CC_INTERP 41 #define __ _masm-> 42 43 // Misc helpers 44 45 // Do an oop store like *(base + index + offset) = val 46 // index can be noreg, 47 static void do_oop_store(InterpreterMacroAssembler* _masm, 48 Register base, 49 Register index, 50 int offset, 51 Register val, 52 Register tmp, 53 BarrierSet::Name barrier, 54 bool precise) { 55 assert(tmp != val && tmp != base && tmp != index, "register collision"); 56 assert(index == noreg || offset == 0, "only one offset"); 57 switch (barrier) { 58 #if INCLUDE_ALL_GCS 59 case BarrierSet::G1SATBCTLogging: 60 { 61 // Load and record the previous value. 62 __ g1_write_barrier_pre(base, index, offset, 63 noreg /* pre_val */, 64 tmp, true /*preserve_o_regs*/); 65 66 // G1 barrier needs uncompressed oop for region cross check. 67 Register new_val = val; 68 if (UseCompressedOops && val != G0) { 69 new_val = tmp; 70 __ mov(val, new_val); 71 } 72 73 if (index == noreg ) { 74 assert(Assembler::is_simm13(offset), "fix this code"); 75 __ store_heap_oop(val, base, offset); 76 } else { 77 __ store_heap_oop(val, base, index); 78 } 79 80 // No need for post barrier if storing NULL 81 if (val != G0) { 82 if (precise) { 83 if (index == noreg) { 84 __ add(base, offset, base); 85 } else { 86 __ add(base, index, base); 87 } 88 } 89 __ g1_write_barrier_post(base, new_val, tmp); 90 } 91 } 92 break; 93 #endif // INCLUDE_ALL_GCS 94 case BarrierSet::CardTableForRS: 95 case BarrierSet::CardTableExtension: 96 { 97 if (index == noreg ) { 98 assert(Assembler::is_simm13(offset), "fix this code"); 99 __ store_heap_oop(val, base, offset); 100 } else { 101 __ store_heap_oop(val, base, index); 102 } 103 // No need for post barrier if storing NULL 104 if (val != G0) { 105 if (precise) { 106 if (index == noreg) { 107 __ add(base, offset, base); 108 } else { 109 __ add(base, index, base); 110 } 111 } 112 __ card_write_barrier_post(base, val, tmp); 113 } 114 } 115 break; 116 case BarrierSet::ModRef: 117 ShouldNotReachHere(); 118 break; 119 default : 120 ShouldNotReachHere(); 121 122 } 123 } 124 125 126 //---------------------------------------------------------------------------------------------------- 127 // Platform-dependent initialization 128 129 void TemplateTable::pd_initialize() { 130 // (none) 131 } 132 133 134 //---------------------------------------------------------------------------------------------------- 135 // Condition conversion 136 Assembler::Condition ccNot(TemplateTable::Condition cc) { 137 switch (cc) { 138 case TemplateTable::equal : return Assembler::notEqual; 139 case TemplateTable::not_equal : return Assembler::equal; 140 case TemplateTable::less : return Assembler::greaterEqual; 141 case TemplateTable::less_equal : return Assembler::greater; 142 case TemplateTable::greater : return Assembler::lessEqual; 143 case TemplateTable::greater_equal: return Assembler::less; 144 } 145 ShouldNotReachHere(); 146 return Assembler::zero; 147 } 148 149 //---------------------------------------------------------------------------------------------------- 150 // Miscelaneous helper routines 151 152 153 Address TemplateTable::at_bcp(int offset) { 154 assert(_desc->uses_bcp(), "inconsistent uses_bcp information"); 155 return Address(Lbcp, offset); 156 } 157 158 159 void TemplateTable::patch_bytecode(Bytecodes::Code bc, Register bc_reg, 160 Register temp_reg, bool load_bc_into_bc_reg/*=true*/, 161 int byte_no) { 162 // With sharing on, may need to test Method* flag. 163 if (!RewriteBytecodes) return; 164 Label L_patch_done; 165 166 switch (bc) { 167 case Bytecodes::_fast_aputfield: 168 case Bytecodes::_fast_bputfield: 169 case Bytecodes::_fast_cputfield: 170 case Bytecodes::_fast_dputfield: 171 case Bytecodes::_fast_fputfield: 172 case Bytecodes::_fast_iputfield: 173 case Bytecodes::_fast_lputfield: 174 case Bytecodes::_fast_sputfield: 175 { 176 // We skip bytecode quickening for putfield instructions when 177 // the put_code written to the constant pool cache is zero. 178 // This is required so that every execution of this instruction 179 // calls out to InterpreterRuntime::resolve_get_put to do 180 // additional, required work. 181 assert(byte_no == f1_byte || byte_no == f2_byte, "byte_no out of range"); 182 assert(load_bc_into_bc_reg, "we use bc_reg as temp"); 183 __ get_cache_and_index_and_bytecode_at_bcp(bc_reg, temp_reg, temp_reg, byte_no, 1); 184 __ set(bc, bc_reg); 185 __ cmp_and_br_short(temp_reg, 0, Assembler::equal, Assembler::pn, L_patch_done); // don't patch 186 } 187 break; 188 default: 189 assert(byte_no == -1, "sanity"); 190 if (load_bc_into_bc_reg) { 191 __ set(bc, bc_reg); 192 } 193 } 194 195 if (JvmtiExport::can_post_breakpoint()) { 196 Label L_fast_patch; 197 __ ldub(at_bcp(0), temp_reg); 198 __ cmp_and_br_short(temp_reg, Bytecodes::_breakpoint, Assembler::notEqual, Assembler::pt, L_fast_patch); 199 // perform the quickening, slowly, in the bowels of the breakpoint table 200 __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::set_original_bytecode_at), Lmethod, Lbcp, bc_reg); 201 __ ba_short(L_patch_done); 202 __ bind(L_fast_patch); 203 } 204 205 #ifdef ASSERT 206 Bytecodes::Code orig_bytecode = Bytecodes::java_code(bc); 207 Label L_okay; 208 __ ldub(at_bcp(0), temp_reg); 209 __ cmp(temp_reg, orig_bytecode); 210 __ br(Assembler::equal, false, Assembler::pt, L_okay); 211 __ delayed()->cmp(temp_reg, bc_reg); 212 __ br(Assembler::equal, false, Assembler::pt, L_okay); 213 __ delayed()->nop(); 214 __ stop("patching the wrong bytecode"); 215 __ bind(L_okay); 216 #endif 217 218 // patch bytecode 219 __ stb(bc_reg, at_bcp(0)); 220 __ bind(L_patch_done); 221 } 222 223 //---------------------------------------------------------------------------------------------------- 224 // Individual instructions 225 226 void TemplateTable::nop() { 227 transition(vtos, vtos); 228 // nothing to do 229 } 230 231 void TemplateTable::shouldnotreachhere() { 232 transition(vtos, vtos); 233 __ stop("shouldnotreachhere bytecode"); 234 } 235 236 void TemplateTable::aconst_null() { 237 transition(vtos, atos); 238 __ clr(Otos_i); 239 } 240 241 242 void TemplateTable::iconst(int value) { 243 transition(vtos, itos); 244 __ set(value, Otos_i); 245 } 246 247 248 void TemplateTable::lconst(int value) { 249 transition(vtos, ltos); 250 assert(value >= 0, "check this code"); 251 #ifdef _LP64 252 __ set(value, Otos_l); 253 #else 254 __ set(value, Otos_l2); 255 __ clr( Otos_l1); 256 #endif 257 } 258 259 260 void TemplateTable::fconst(int value) { 261 transition(vtos, ftos); 262 static float zero = 0.0, one = 1.0, two = 2.0; 263 float* p; 264 switch( value ) { 265 default: ShouldNotReachHere(); 266 case 0: p = &zero; break; 267 case 1: p = &one; break; 268 case 2: p = &two; break; 269 } 270 AddressLiteral a(p); 271 __ sethi(a, G3_scratch); 272 __ ldf(FloatRegisterImpl::S, G3_scratch, a.low10(), Ftos_f); 273 } 274 275 276 void TemplateTable::dconst(int value) { 277 transition(vtos, dtos); 278 static double zero = 0.0, one = 1.0; 279 double* p; 280 switch( value ) { 281 default: ShouldNotReachHere(); 282 case 0: p = &zero; break; 283 case 1: p = &one; break; 284 } 285 AddressLiteral a(p); 286 __ sethi(a, G3_scratch); 287 __ ldf(FloatRegisterImpl::D, G3_scratch, a.low10(), Ftos_d); 288 } 289 290 291 // %%%%% Should factore most snippet templates across platforms 292 293 void TemplateTable::bipush() { 294 transition(vtos, itos); 295 __ ldsb( at_bcp(1), Otos_i ); 296 } 297 298 void TemplateTable::sipush() { 299 transition(vtos, itos); 300 __ get_2_byte_integer_at_bcp(1, G3_scratch, Otos_i, InterpreterMacroAssembler::Signed); 301 } 302 303 void TemplateTable::ldc(bool wide) { 304 transition(vtos, vtos); 305 Label call_ldc, notInt, isString, notString, notClass, exit; 306 307 if (wide) { 308 __ get_2_byte_integer_at_bcp(1, G3_scratch, O1, InterpreterMacroAssembler::Unsigned); 309 } else { 310 __ ldub(Lbcp, 1, O1); 311 } 312 __ get_cpool_and_tags(O0, O2); 313 314 const int base_offset = ConstantPool::header_size() * wordSize; 315 const int tags_offset = Array<u1>::base_offset_in_bytes(); 316 317 // get type from tags 318 __ add(O2, tags_offset, O2); 319 __ ldub(O2, O1, O2); 320 321 // unresolved class? If so, must resolve 322 __ cmp_and_brx_short(O2, JVM_CONSTANT_UnresolvedClass, Assembler::equal, Assembler::pt, call_ldc); 323 324 // unresolved class in error state 325 __ cmp_and_brx_short(O2, JVM_CONSTANT_UnresolvedClassInError, Assembler::equal, Assembler::pn, call_ldc); 326 327 __ cmp(O2, JVM_CONSTANT_Class); // need to call vm to get java mirror of the class 328 __ brx(Assembler::notEqual, true, Assembler::pt, notClass); 329 __ delayed()->add(O0, base_offset, O0); 330 331 __ bind(call_ldc); 332 __ set(wide, O1); 333 call_VM(Otos_i, CAST_FROM_FN_PTR(address, InterpreterRuntime::ldc), O1); 334 __ push(atos); 335 __ ba_short(exit); 336 337 __ bind(notClass); 338 // __ add(O0, base_offset, O0); 339 __ sll(O1, LogBytesPerWord, O1); 340 __ cmp(O2, JVM_CONSTANT_Integer); 341 __ brx(Assembler::notEqual, true, Assembler::pt, notInt); 342 __ delayed()->cmp(O2, JVM_CONSTANT_String); 343 __ ld(O0, O1, Otos_i); 344 __ push(itos); 345 __ ba_short(exit); 346 347 __ bind(notInt); 348 // __ cmp(O2, JVM_CONSTANT_String); 349 __ brx(Assembler::notEqual, true, Assembler::pt, notString); 350 __ delayed()->ldf(FloatRegisterImpl::S, O0, O1, Ftos_f); 351 __ bind(isString); 352 __ stop("string should be rewritten to fast_aldc"); 353 __ ba_short(exit); 354 355 __ bind(notString); 356 // __ ldf(FloatRegisterImpl::S, O0, O1, Ftos_f); 357 __ push(ftos); 358 359 __ bind(exit); 360 } 361 362 // Fast path for caching oop constants. 363 // %%% We should use this to handle Class and String constants also. 364 // %%% It will simplify the ldc/primitive path considerably. 365 void TemplateTable::fast_aldc(bool wide) { 366 transition(vtos, atos); 367 368 int index_size = wide ? sizeof(u2) : sizeof(u1); 369 Label resolved; 370 371 // We are resolved if the resolved reference cache entry contains a 372 // non-null object (CallSite, etc.) 373 assert_different_registers(Otos_i, G3_scratch); 374 __ get_cache_index_at_bcp(Otos_i, G3_scratch, 1, index_size); // load index => G3_scratch 375 __ load_resolved_reference_at_index(Otos_i, G3_scratch); 376 __ tst(Otos_i); 377 __ br(Assembler::notEqual, false, Assembler::pt, resolved); 378 __ delayed()->set((int)bytecode(), O1); 379 380 address entry = CAST_FROM_FN_PTR(address, InterpreterRuntime::resolve_ldc); 381 382 // first time invocation - must resolve first 383 __ call_VM(Otos_i, entry, O1); 384 __ bind(resolved); 385 __ verify_oop(Otos_i); 386 } 387 388 void TemplateTable::ldc2_w() { 389 transition(vtos, vtos); 390 Label Long, exit; 391 392 __ get_2_byte_integer_at_bcp(1, G3_scratch, O1, InterpreterMacroAssembler::Unsigned); 393 __ get_cpool_and_tags(O0, O2); 394 395 const int base_offset = ConstantPool::header_size() * wordSize; 396 const int tags_offset = Array<u1>::base_offset_in_bytes(); 397 // get type from tags 398 __ add(O2, tags_offset, O2); 399 __ ldub(O2, O1, O2); 400 401 __ sll(O1, LogBytesPerWord, O1); 402 __ add(O0, O1, G3_scratch); 403 404 __ cmp_and_brx_short(O2, JVM_CONSTANT_Double, Assembler::notEqual, Assembler::pt, Long); 405 // A double can be placed at word-aligned locations in the constant pool. 406 // Check out Conversions.java for an example. 407 // Also ConstantPool::header_size() is 20, which makes it very difficult 408 // to double-align double on the constant pool. SG, 11/7/97 409 #ifdef _LP64 410 __ ldf(FloatRegisterImpl::D, G3_scratch, base_offset, Ftos_d); 411 #else 412 FloatRegister f = Ftos_d; 413 __ ldf(FloatRegisterImpl::S, G3_scratch, base_offset, f); 414 __ ldf(FloatRegisterImpl::S, G3_scratch, base_offset + sizeof(jdouble)/2, 415 f->successor()); 416 #endif 417 __ push(dtos); 418 __ ba_short(exit); 419 420 __ bind(Long); 421 #ifdef _LP64 422 __ ldx(G3_scratch, base_offset, Otos_l); 423 #else 424 __ ld(G3_scratch, base_offset, Otos_l); 425 __ ld(G3_scratch, base_offset + sizeof(jlong)/2, Otos_l->successor()); 426 #endif 427 __ push(ltos); 428 429 __ bind(exit); 430 } 431 432 void TemplateTable::locals_index(Register reg, int offset) { 433 __ ldub( at_bcp(offset), reg ); 434 } 435 436 void TemplateTable::locals_index_wide(Register reg) { 437 // offset is 2, not 1, because Lbcp points to wide prefix code 438 __ get_2_byte_integer_at_bcp(2, G4_scratch, reg, InterpreterMacroAssembler::Unsigned); 439 } 440 441 void TemplateTable::iload() { 442 iload_internal(); 443 } 444 445 void TemplateTable::nofast_iload() { 446 iload_internal(may_not_rewrite); 447 } 448 449 void TemplateTable::iload_internal(RewriteControl rc) { 450 transition(vtos, itos); 451 // Rewrite iload,iload pair into fast_iload2 452 // iload,caload pair into fast_icaload 453 if (RewriteFrequentPairs && rc == may_rewrite) { 454 Label rewrite, done; 455 456 // get next byte 457 __ ldub(at_bcp(Bytecodes::length_for(Bytecodes::_iload)), G3_scratch); 458 459 // if _iload, wait to rewrite to iload2. We only want to rewrite the 460 // last two iloads in a pair. Comparing against fast_iload means that 461 // the next bytecode is neither an iload or a caload, and therefore 462 // an iload pair. 463 __ cmp_and_br_short(G3_scratch, (int)Bytecodes::_iload, Assembler::equal, Assembler::pn, done); 464 465 __ cmp(G3_scratch, (int)Bytecodes::_fast_iload); 466 __ br(Assembler::equal, false, Assembler::pn, rewrite); 467 __ delayed()->set(Bytecodes::_fast_iload2, G4_scratch); 468 469 __ cmp(G3_scratch, (int)Bytecodes::_caload); 470 __ br(Assembler::equal, false, Assembler::pn, rewrite); 471 __ delayed()->set(Bytecodes::_fast_icaload, G4_scratch); 472 473 __ set(Bytecodes::_fast_iload, G4_scratch); // don't check again 474 // rewrite 475 // G4_scratch: fast bytecode 476 __ bind(rewrite); 477 patch_bytecode(Bytecodes::_iload, G4_scratch, G3_scratch, false); 478 __ bind(done); 479 } 480 481 // Get the local value into tos 482 locals_index(G3_scratch); 483 __ access_local_int( G3_scratch, Otos_i ); 484 } 485 486 void TemplateTable::fast_iload2() { 487 transition(vtos, itos); 488 locals_index(G3_scratch); 489 __ access_local_int( G3_scratch, Otos_i ); 490 __ push_i(); 491 locals_index(G3_scratch, 3); // get next bytecode's local index. 492 __ access_local_int( G3_scratch, Otos_i ); 493 } 494 495 void TemplateTable::fast_iload() { 496 transition(vtos, itos); 497 locals_index(G3_scratch); 498 __ access_local_int( G3_scratch, Otos_i ); 499 } 500 501 void TemplateTable::lload() { 502 transition(vtos, ltos); 503 locals_index(G3_scratch); 504 __ access_local_long( G3_scratch, Otos_l ); 505 } 506 507 508 void TemplateTable::fload() { 509 transition(vtos, ftos); 510 locals_index(G3_scratch); 511 __ access_local_float( G3_scratch, Ftos_f ); 512 } 513 514 515 void TemplateTable::dload() { 516 transition(vtos, dtos); 517 locals_index(G3_scratch); 518 __ access_local_double( G3_scratch, Ftos_d ); 519 } 520 521 522 void TemplateTable::aload() { 523 transition(vtos, atos); 524 locals_index(G3_scratch); 525 __ access_local_ptr( G3_scratch, Otos_i); 526 } 527 528 529 void TemplateTable::wide_iload() { 530 transition(vtos, itos); 531 locals_index_wide(G3_scratch); 532 __ access_local_int( G3_scratch, Otos_i ); 533 } 534 535 536 void TemplateTable::wide_lload() { 537 transition(vtos, ltos); 538 locals_index_wide(G3_scratch); 539 __ access_local_long( G3_scratch, Otos_l ); 540 } 541 542 543 void TemplateTable::wide_fload() { 544 transition(vtos, ftos); 545 locals_index_wide(G3_scratch); 546 __ access_local_float( G3_scratch, Ftos_f ); 547 } 548 549 550 void TemplateTable::wide_dload() { 551 transition(vtos, dtos); 552 locals_index_wide(G3_scratch); 553 __ access_local_double( G3_scratch, Ftos_d ); 554 } 555 556 557 void TemplateTable::wide_aload() { 558 transition(vtos, atos); 559 locals_index_wide(G3_scratch); 560 __ access_local_ptr( G3_scratch, Otos_i ); 561 __ verify_oop(Otos_i); 562 } 563 564 565 void TemplateTable::iaload() { 566 transition(itos, itos); 567 // Otos_i: index 568 // tos: array 569 __ index_check(O2, Otos_i, LogBytesPerInt, G3_scratch, O3); 570 __ ld(O3, arrayOopDesc::base_offset_in_bytes(T_INT), Otos_i); 571 } 572 573 574 void TemplateTable::laload() { 575 transition(itos, ltos); 576 // Otos_i: index 577 // O2: array 578 __ index_check(O2, Otos_i, LogBytesPerLong, G3_scratch, O3); 579 __ ld_long(O3, arrayOopDesc::base_offset_in_bytes(T_LONG), Otos_l); 580 } 581 582 583 void TemplateTable::faload() { 584 transition(itos, ftos); 585 // Otos_i: index 586 // O2: array 587 __ index_check(O2, Otos_i, LogBytesPerInt, G3_scratch, O3); 588 __ ldf(FloatRegisterImpl::S, O3, arrayOopDesc::base_offset_in_bytes(T_FLOAT), Ftos_f); 589 } 590 591 592 void TemplateTable::daload() { 593 transition(itos, dtos); 594 // Otos_i: index 595 // O2: array 596 __ index_check(O2, Otos_i, LogBytesPerLong, G3_scratch, O3); 597 __ ldf(FloatRegisterImpl::D, O3, arrayOopDesc::base_offset_in_bytes(T_DOUBLE), Ftos_d); 598 } 599 600 601 void TemplateTable::aaload() { 602 transition(itos, atos); 603 // Otos_i: index 604 // tos: array 605 __ index_check(O2, Otos_i, UseCompressedOops ? 2 : LogBytesPerWord, G3_scratch, O3); 606 __ load_heap_oop(O3, arrayOopDesc::base_offset_in_bytes(T_OBJECT), Otos_i); 607 __ verify_oop(Otos_i); 608 } 609 610 611 void TemplateTable::baload() { 612 transition(itos, itos); 613 // Otos_i: index 614 // tos: array 615 __ index_check(O2, Otos_i, 0, G3_scratch, O3); 616 __ ldsb(O3, arrayOopDesc::base_offset_in_bytes(T_BYTE), Otos_i); 617 } 618 619 620 void TemplateTable::caload() { 621 transition(itos, itos); 622 // Otos_i: index 623 // tos: array 624 __ index_check(O2, Otos_i, LogBytesPerShort, G3_scratch, O3); 625 __ lduh(O3, arrayOopDesc::base_offset_in_bytes(T_CHAR), Otos_i); 626 } 627 628 void TemplateTable::fast_icaload() { 629 transition(vtos, itos); 630 // Otos_i: index 631 // tos: array 632 locals_index(G3_scratch); 633 __ access_local_int( G3_scratch, Otos_i ); 634 __ index_check(O2, Otos_i, LogBytesPerShort, G3_scratch, O3); 635 __ lduh(O3, arrayOopDesc::base_offset_in_bytes(T_CHAR), Otos_i); 636 } 637 638 639 void TemplateTable::saload() { 640 transition(itos, itos); 641 // Otos_i: index 642 // tos: array 643 __ index_check(O2, Otos_i, LogBytesPerShort, G3_scratch, O3); 644 __ ldsh(O3, arrayOopDesc::base_offset_in_bytes(T_SHORT), Otos_i); 645 } 646 647 648 void TemplateTable::iload(int n) { 649 transition(vtos, itos); 650 __ ld( Llocals, Interpreter::local_offset_in_bytes(n), Otos_i ); 651 } 652 653 654 void TemplateTable::lload(int n) { 655 transition(vtos, ltos); 656 assert(n+1 < Argument::n_register_parameters, "would need more code"); 657 __ load_unaligned_long(Llocals, Interpreter::local_offset_in_bytes(n+1), Otos_l); 658 } 659 660 661 void TemplateTable::fload(int n) { 662 transition(vtos, ftos); 663 assert(n < Argument::n_register_parameters, "would need more code"); 664 __ ldf( FloatRegisterImpl::S, Llocals, Interpreter::local_offset_in_bytes(n), Ftos_f ); 665 } 666 667 668 void TemplateTable::dload(int n) { 669 transition(vtos, dtos); 670 FloatRegister dst = Ftos_d; 671 __ load_unaligned_double(Llocals, Interpreter::local_offset_in_bytes(n+1), dst); 672 } 673 674 675 void TemplateTable::aload(int n) { 676 transition(vtos, atos); 677 __ ld_ptr( Llocals, Interpreter::local_offset_in_bytes(n), Otos_i ); 678 } 679 680 void TemplateTable::aload_0() { 681 aload_0_internal(); 682 } 683 684 void TemplateTable::nofast_aload_0() { 685 aload_0_internal(may_not_rewrite); 686 } 687 688 void TemplateTable::aload_0_internal(RewriteControl rc) { 689 transition(vtos, atos); 690 691 // According to bytecode histograms, the pairs: 692 // 693 // _aload_0, _fast_igetfield (itos) 694 // _aload_0, _fast_agetfield (atos) 695 // _aload_0, _fast_fgetfield (ftos) 696 // 697 // occur frequently. If RewriteFrequentPairs is set, the (slow) _aload_0 698 // bytecode checks the next bytecode and then rewrites the current 699 // bytecode into a pair bytecode; otherwise it rewrites the current 700 // bytecode into _fast_aload_0 that doesn't do the pair check anymore. 701 // 702 if (RewriteFrequentPairs && rc == may_rewrite) { 703 Label rewrite, done; 704 705 // get next byte 706 __ ldub(at_bcp(Bytecodes::length_for(Bytecodes::_aload_0)), G3_scratch); 707 708 // do actual aload_0 709 aload(0); 710 711 // if _getfield then wait with rewrite 712 __ cmp_and_br_short(G3_scratch, (int)Bytecodes::_getfield, Assembler::equal, Assembler::pn, done); 713 714 // if _igetfield then rewrite to _fast_iaccess_0 715 assert(Bytecodes::java_code(Bytecodes::_fast_iaccess_0) == Bytecodes::_aload_0, "adjust fast bytecode def"); 716 __ cmp(G3_scratch, (int)Bytecodes::_fast_igetfield); 717 __ br(Assembler::equal, false, Assembler::pn, rewrite); 718 __ delayed()->set(Bytecodes::_fast_iaccess_0, G4_scratch); 719 720 // if _agetfield then rewrite to _fast_aaccess_0 721 assert(Bytecodes::java_code(Bytecodes::_fast_aaccess_0) == Bytecodes::_aload_0, "adjust fast bytecode def"); 722 __ cmp(G3_scratch, (int)Bytecodes::_fast_agetfield); 723 __ br(Assembler::equal, false, Assembler::pn, rewrite); 724 __ delayed()->set(Bytecodes::_fast_aaccess_0, G4_scratch); 725 726 // if _fgetfield then rewrite to _fast_faccess_0 727 assert(Bytecodes::java_code(Bytecodes::_fast_faccess_0) == Bytecodes::_aload_0, "adjust fast bytecode def"); 728 __ cmp(G3_scratch, (int)Bytecodes::_fast_fgetfield); 729 __ br(Assembler::equal, false, Assembler::pn, rewrite); 730 __ delayed()->set(Bytecodes::_fast_faccess_0, G4_scratch); 731 732 // else rewrite to _fast_aload0 733 assert(Bytecodes::java_code(Bytecodes::_fast_aload_0) == Bytecodes::_aload_0, "adjust fast bytecode def"); 734 __ set(Bytecodes::_fast_aload_0, G4_scratch); 735 736 // rewrite 737 // G4_scratch: fast bytecode 738 __ bind(rewrite); 739 patch_bytecode(Bytecodes::_aload_0, G4_scratch, G3_scratch, false); 740 __ bind(done); 741 } else { 742 aload(0); 743 } 744 } 745 746 void TemplateTable::istore() { 747 transition(itos, vtos); 748 locals_index(G3_scratch); 749 __ store_local_int( G3_scratch, Otos_i ); 750 } 751 752 753 void TemplateTable::lstore() { 754 transition(ltos, vtos); 755 locals_index(G3_scratch); 756 __ store_local_long( G3_scratch, Otos_l ); 757 } 758 759 760 void TemplateTable::fstore() { 761 transition(ftos, vtos); 762 locals_index(G3_scratch); 763 __ store_local_float( G3_scratch, Ftos_f ); 764 } 765 766 767 void TemplateTable::dstore() { 768 transition(dtos, vtos); 769 locals_index(G3_scratch); 770 __ store_local_double( G3_scratch, Ftos_d ); 771 } 772 773 774 void TemplateTable::astore() { 775 transition(vtos, vtos); 776 __ load_ptr(0, Otos_i); 777 __ inc(Lesp, Interpreter::stackElementSize); 778 __ verify_oop_or_return_address(Otos_i, G3_scratch); 779 locals_index(G3_scratch); 780 __ store_local_ptr(G3_scratch, Otos_i); 781 } 782 783 784 void TemplateTable::wide_istore() { 785 transition(vtos, vtos); 786 __ pop_i(); 787 locals_index_wide(G3_scratch); 788 __ store_local_int( G3_scratch, Otos_i ); 789 } 790 791 792 void TemplateTable::wide_lstore() { 793 transition(vtos, vtos); 794 __ pop_l(); 795 locals_index_wide(G3_scratch); 796 __ store_local_long( G3_scratch, Otos_l ); 797 } 798 799 800 void TemplateTable::wide_fstore() { 801 transition(vtos, vtos); 802 __ pop_f(); 803 locals_index_wide(G3_scratch); 804 __ store_local_float( G3_scratch, Ftos_f ); 805 } 806 807 808 void TemplateTable::wide_dstore() { 809 transition(vtos, vtos); 810 __ pop_d(); 811 locals_index_wide(G3_scratch); 812 __ store_local_double( G3_scratch, Ftos_d ); 813 } 814 815 816 void TemplateTable::wide_astore() { 817 transition(vtos, vtos); 818 __ load_ptr(0, Otos_i); 819 __ inc(Lesp, Interpreter::stackElementSize); 820 __ verify_oop_or_return_address(Otos_i, G3_scratch); 821 locals_index_wide(G3_scratch); 822 __ store_local_ptr(G3_scratch, Otos_i); 823 } 824 825 826 void TemplateTable::iastore() { 827 transition(itos, vtos); 828 __ pop_i(O2); // index 829 // Otos_i: val 830 // O3: array 831 __ index_check(O3, O2, LogBytesPerInt, G3_scratch, O2); 832 __ st(Otos_i, O2, arrayOopDesc::base_offset_in_bytes(T_INT)); 833 } 834 835 836 void TemplateTable::lastore() { 837 transition(ltos, vtos); 838 __ pop_i(O2); // index 839 // Otos_l: val 840 // O3: array 841 __ index_check(O3, O2, LogBytesPerLong, G3_scratch, O2); 842 __ st_long(Otos_l, O2, arrayOopDesc::base_offset_in_bytes(T_LONG)); 843 } 844 845 846 void TemplateTable::fastore() { 847 transition(ftos, vtos); 848 __ pop_i(O2); // index 849 // Ftos_f: val 850 // O3: array 851 __ index_check(O3, O2, LogBytesPerInt, G3_scratch, O2); 852 __ stf(FloatRegisterImpl::S, Ftos_f, O2, arrayOopDesc::base_offset_in_bytes(T_FLOAT)); 853 } 854 855 856 void TemplateTable::dastore() { 857 transition(dtos, vtos); 858 __ pop_i(O2); // index 859 // Fos_d: val 860 // O3: array 861 __ index_check(O3, O2, LogBytesPerLong, G3_scratch, O2); 862 __ stf(FloatRegisterImpl::D, Ftos_d, O2, arrayOopDesc::base_offset_in_bytes(T_DOUBLE)); 863 } 864 865 866 void TemplateTable::aastore() { 867 Label store_ok, is_null, done; 868 transition(vtos, vtos); 869 __ ld_ptr(Lesp, Interpreter::expr_offset_in_bytes(0), Otos_i); 870 __ ld(Lesp, Interpreter::expr_offset_in_bytes(1), O2); // get index 871 __ ld_ptr(Lesp, Interpreter::expr_offset_in_bytes(2), O3); // get array 872 // Otos_i: val 873 // O2: index 874 // O3: array 875 __ verify_oop(Otos_i); 876 __ index_check_without_pop(O3, O2, UseCompressedOops ? 2 : LogBytesPerWord, G3_scratch, O1); 877 878 // do array store check - check for NULL value first 879 __ br_null_short( Otos_i, Assembler::pn, is_null ); 880 881 __ load_klass(O3, O4); // get array klass 882 __ load_klass(Otos_i, O5); // get value klass 883 884 // do fast instanceof cache test 885 886 __ ld_ptr(O4, in_bytes(ObjArrayKlass::element_klass_offset()), O4); 887 888 assert(Otos_i == O0, "just checking"); 889 890 // Otos_i: value 891 // O1: addr - offset 892 // O2: index 893 // O3: array 894 // O4: array element klass 895 // O5: value klass 896 897 // Address element(O1, 0, arrayOopDesc::base_offset_in_bytes(T_OBJECT)); 898 899 // Generate a fast subtype check. Branch to store_ok if no 900 // failure. Throw if failure. 901 __ gen_subtype_check( O5, O4, G3_scratch, G4_scratch, G1_scratch, store_ok ); 902 903 // Not a subtype; so must throw exception 904 __ throw_if_not_x( Assembler::never, Interpreter::_throw_ArrayStoreException_entry, G3_scratch ); 905 906 // Store is OK. 907 __ bind(store_ok); 908 do_oop_store(_masm, O1, noreg, arrayOopDesc::base_offset_in_bytes(T_OBJECT), Otos_i, G3_scratch, _bs->kind(), true); 909 910 __ ba(done); 911 __ delayed()->inc(Lesp, 3* Interpreter::stackElementSize); // adj sp (pops array, index and value) 912 913 __ bind(is_null); 914 do_oop_store(_masm, O1, noreg, arrayOopDesc::base_offset_in_bytes(T_OBJECT), G0, G4_scratch, _bs->kind(), true); 915 916 __ profile_null_seen(G3_scratch); 917 __ inc(Lesp, 3* Interpreter::stackElementSize); // adj sp (pops array, index and value) 918 __ bind(done); 919 } 920 921 922 void TemplateTable::bastore() { 923 transition(itos, vtos); 924 __ pop_i(O2); // index 925 // Otos_i: val 926 // O3: array 927 __ index_check(O3, O2, 0, G3_scratch, O2); 928 __ stb(Otos_i, O2, arrayOopDesc::base_offset_in_bytes(T_BYTE)); 929 } 930 931 932 void TemplateTable::castore() { 933 transition(itos, vtos); 934 __ pop_i(O2); // index 935 // Otos_i: val 936 // O3: array 937 __ index_check(O3, O2, LogBytesPerShort, G3_scratch, O2); 938 __ sth(Otos_i, O2, arrayOopDesc::base_offset_in_bytes(T_CHAR)); 939 } 940 941 942 void TemplateTable::sastore() { 943 // %%%%% Factor across platform 944 castore(); 945 } 946 947 948 void TemplateTable::istore(int n) { 949 transition(itos, vtos); 950 __ st(Otos_i, Llocals, Interpreter::local_offset_in_bytes(n)); 951 } 952 953 954 void TemplateTable::lstore(int n) { 955 transition(ltos, vtos); 956 assert(n+1 < Argument::n_register_parameters, "only handle register cases"); 957 __ store_unaligned_long(Otos_l, Llocals, Interpreter::local_offset_in_bytes(n+1)); 958 959 } 960 961 962 void TemplateTable::fstore(int n) { 963 transition(ftos, vtos); 964 assert(n < Argument::n_register_parameters, "only handle register cases"); 965 __ stf(FloatRegisterImpl::S, Ftos_f, Llocals, Interpreter::local_offset_in_bytes(n)); 966 } 967 968 969 void TemplateTable::dstore(int n) { 970 transition(dtos, vtos); 971 FloatRegister src = Ftos_d; 972 __ store_unaligned_double(src, Llocals, Interpreter::local_offset_in_bytes(n+1)); 973 } 974 975 976 void TemplateTable::astore(int n) { 977 transition(vtos, vtos); 978 __ load_ptr(0, Otos_i); 979 __ inc(Lesp, Interpreter::stackElementSize); 980 __ verify_oop_or_return_address(Otos_i, G3_scratch); 981 __ store_local_ptr(n, Otos_i); 982 } 983 984 985 void TemplateTable::pop() { 986 transition(vtos, vtos); 987 __ inc(Lesp, Interpreter::stackElementSize); 988 } 989 990 991 void TemplateTable::pop2() { 992 transition(vtos, vtos); 993 __ inc(Lesp, 2 * Interpreter::stackElementSize); 994 } 995 996 997 void TemplateTable::dup() { 998 transition(vtos, vtos); 999 // stack: ..., a 1000 // load a and tag 1001 __ load_ptr(0, Otos_i); 1002 __ push_ptr(Otos_i); 1003 // stack: ..., a, a 1004 } 1005 1006 1007 void TemplateTable::dup_x1() { 1008 transition(vtos, vtos); 1009 // stack: ..., a, b 1010 __ load_ptr( 1, G3_scratch); // get a 1011 __ load_ptr( 0, Otos_l1); // get b 1012 __ store_ptr(1, Otos_l1); // put b 1013 __ store_ptr(0, G3_scratch); // put a - like swap 1014 __ push_ptr(Otos_l1); // push b 1015 // stack: ..., b, a, b 1016 } 1017 1018 1019 void TemplateTable::dup_x2() { 1020 transition(vtos, vtos); 1021 // stack: ..., a, b, c 1022 // get c and push on stack, reuse registers 1023 __ load_ptr( 0, G3_scratch); // get c 1024 __ push_ptr(G3_scratch); // push c with tag 1025 // stack: ..., a, b, c, c (c in reg) (Lesp - 4) 1026 // (stack offsets n+1 now) 1027 __ load_ptr( 3, Otos_l1); // get a 1028 __ store_ptr(3, G3_scratch); // put c at 3 1029 // stack: ..., c, b, c, c (a in reg) 1030 __ load_ptr( 2, G3_scratch); // get b 1031 __ store_ptr(2, Otos_l1); // put a at 2 1032 // stack: ..., c, a, c, c (b in reg) 1033 __ store_ptr(1, G3_scratch); // put b at 1 1034 // stack: ..., c, a, b, c 1035 } 1036 1037 1038 void TemplateTable::dup2() { 1039 transition(vtos, vtos); 1040 __ load_ptr(1, G3_scratch); // get a 1041 __ load_ptr(0, Otos_l1); // get b 1042 __ push_ptr(G3_scratch); // push a 1043 __ push_ptr(Otos_l1); // push b 1044 // stack: ..., a, b, a, b 1045 } 1046 1047 1048 void TemplateTable::dup2_x1() { 1049 transition(vtos, vtos); 1050 // stack: ..., a, b, c 1051 __ load_ptr( 1, Lscratch); // get b 1052 __ load_ptr( 2, Otos_l1); // get a 1053 __ store_ptr(2, Lscratch); // put b at a 1054 // stack: ..., b, b, c 1055 __ load_ptr( 0, G3_scratch); // get c 1056 __ store_ptr(1, G3_scratch); // put c at b 1057 // stack: ..., b, c, c 1058 __ store_ptr(0, Otos_l1); // put a at c 1059 // stack: ..., b, c, a 1060 __ push_ptr(Lscratch); // push b 1061 __ push_ptr(G3_scratch); // push c 1062 // stack: ..., b, c, a, b, c 1063 } 1064 1065 1066 // The spec says that these types can be a mixture of category 1 (1 word) 1067 // types and/or category 2 types (long and doubles) 1068 void TemplateTable::dup2_x2() { 1069 transition(vtos, vtos); 1070 // stack: ..., a, b, c, d 1071 __ load_ptr( 1, Lscratch); // get c 1072 __ load_ptr( 3, Otos_l1); // get a 1073 __ store_ptr(3, Lscratch); // put c at 3 1074 __ store_ptr(1, Otos_l1); // put a at 1 1075 // stack: ..., c, b, a, d 1076 __ load_ptr( 2, G3_scratch); // get b 1077 __ load_ptr( 0, Otos_l1); // get d 1078 __ store_ptr(0, G3_scratch); // put b at 0 1079 __ store_ptr(2, Otos_l1); // put d at 2 1080 // stack: ..., c, d, a, b 1081 __ push_ptr(Lscratch); // push c 1082 __ push_ptr(Otos_l1); // push d 1083 // stack: ..., c, d, a, b, c, d 1084 } 1085 1086 1087 void TemplateTable::swap() { 1088 transition(vtos, vtos); 1089 // stack: ..., a, b 1090 __ load_ptr( 1, G3_scratch); // get a 1091 __ load_ptr( 0, Otos_l1); // get b 1092 __ store_ptr(0, G3_scratch); // put b 1093 __ store_ptr(1, Otos_l1); // put a 1094 // stack: ..., b, a 1095 } 1096 1097 1098 void TemplateTable::iop2(Operation op) { 1099 transition(itos, itos); 1100 __ pop_i(O1); 1101 switch (op) { 1102 case add: __ add(O1, Otos_i, Otos_i); break; 1103 case sub: __ sub(O1, Otos_i, Otos_i); break; 1104 // %%%%% Mul may not exist: better to call .mul? 1105 case mul: __ smul(O1, Otos_i, Otos_i); break; 1106 case _and: __ and3(O1, Otos_i, Otos_i); break; 1107 case _or: __ or3(O1, Otos_i, Otos_i); break; 1108 case _xor: __ xor3(O1, Otos_i, Otos_i); break; 1109 case shl: __ sll(O1, Otos_i, Otos_i); break; 1110 case shr: __ sra(O1, Otos_i, Otos_i); break; 1111 case ushr: __ srl(O1, Otos_i, Otos_i); break; 1112 default: ShouldNotReachHere(); 1113 } 1114 } 1115 1116 1117 void TemplateTable::lop2(Operation op) { 1118 transition(ltos, ltos); 1119 __ pop_l(O2); 1120 switch (op) { 1121 #ifdef _LP64 1122 case add: __ add(O2, Otos_l, Otos_l); break; 1123 case sub: __ sub(O2, Otos_l, Otos_l); break; 1124 case _and: __ and3(O2, Otos_l, Otos_l); break; 1125 case _or: __ or3(O2, Otos_l, Otos_l); break; 1126 case _xor: __ xor3(O2, Otos_l, Otos_l); break; 1127 #else 1128 case add: __ addcc(O3, Otos_l2, Otos_l2); __ addc(O2, Otos_l1, Otos_l1); break; 1129 case sub: __ subcc(O3, Otos_l2, Otos_l2); __ subc(O2, Otos_l1, Otos_l1); break; 1130 case _and: __ and3(O3, Otos_l2, Otos_l2); __ and3(O2, Otos_l1, Otos_l1); break; 1131 case _or: __ or3(O3, Otos_l2, Otos_l2); __ or3(O2, Otos_l1, Otos_l1); break; 1132 case _xor: __ xor3(O3, Otos_l2, Otos_l2); __ xor3(O2, Otos_l1, Otos_l1); break; 1133 #endif 1134 default: ShouldNotReachHere(); 1135 } 1136 } 1137 1138 1139 void TemplateTable::idiv() { 1140 // %%%%% Later: ForSPARC/V7 call .sdiv library routine, 1141 // %%%%% Use ldsw...sdivx on pure V9 ABI. 64 bit safe. 1142 1143 transition(itos, itos); 1144 __ pop_i(O1); // get 1st op 1145 1146 // Y contains upper 32 bits of result, set it to 0 or all ones 1147 __ wry(G0); 1148 __ mov(~0, G3_scratch); 1149 1150 __ tst(O1); 1151 Label neg; 1152 __ br(Assembler::negative, true, Assembler::pn, neg); 1153 __ delayed()->wry(G3_scratch); 1154 __ bind(neg); 1155 1156 Label ok; 1157 __ tst(Otos_i); 1158 __ throw_if_not_icc( Assembler::notZero, Interpreter::_throw_ArithmeticException_entry, G3_scratch ); 1159 1160 const int min_int = 0x80000000; 1161 Label regular; 1162 __ cmp(Otos_i, -1); 1163 __ br(Assembler::notEqual, false, Assembler::pt, regular); 1164 #ifdef _LP64 1165 // Don't put set in delay slot 1166 // Set will turn into multiple instructions in 64 bit mode 1167 __ delayed()->nop(); 1168 __ set(min_int, G4_scratch); 1169 #else 1170 __ delayed()->set(min_int, G4_scratch); 1171 #endif 1172 Label done; 1173 __ cmp(O1, G4_scratch); 1174 __ br(Assembler::equal, true, Assembler::pt, done); 1175 __ delayed()->mov(O1, Otos_i); // (mov only executed if branch taken) 1176 1177 __ bind(regular); 1178 __ sdiv(O1, Otos_i, Otos_i); // note: irem uses O1 after this instruction! 1179 __ bind(done); 1180 } 1181 1182 1183 void TemplateTable::irem() { 1184 transition(itos, itos); 1185 __ mov(Otos_i, O2); // save divisor 1186 idiv(); // %%%% Hack: exploits fact that idiv leaves dividend in O1 1187 __ smul(Otos_i, O2, Otos_i); 1188 __ sub(O1, Otos_i, Otos_i); 1189 } 1190 1191 1192 void TemplateTable::lmul() { 1193 transition(ltos, ltos); 1194 __ pop_l(O2); 1195 #ifdef _LP64 1196 __ mulx(Otos_l, O2, Otos_l); 1197 #else 1198 __ call_VM_leaf(Lscratch, CAST_FROM_FN_PTR(address, SharedRuntime::lmul)); 1199 #endif 1200 1201 } 1202 1203 1204 void TemplateTable::ldiv() { 1205 transition(ltos, ltos); 1206 1207 // check for zero 1208 __ pop_l(O2); 1209 #ifdef _LP64 1210 __ tst(Otos_l); 1211 __ throw_if_not_xcc( Assembler::notZero, Interpreter::_throw_ArithmeticException_entry, G3_scratch); 1212 __ sdivx(O2, Otos_l, Otos_l); 1213 #else 1214 __ orcc(Otos_l1, Otos_l2, G0); 1215 __ throw_if_not_icc( Assembler::notZero, Interpreter::_throw_ArithmeticException_entry, G3_scratch); 1216 __ call_VM_leaf(Lscratch, CAST_FROM_FN_PTR(address, SharedRuntime::ldiv)); 1217 #endif 1218 } 1219 1220 1221 void TemplateTable::lrem() { 1222 transition(ltos, ltos); 1223 1224 // check for zero 1225 __ pop_l(O2); 1226 #ifdef _LP64 1227 __ tst(Otos_l); 1228 __ throw_if_not_xcc( Assembler::notZero, Interpreter::_throw_ArithmeticException_entry, G3_scratch); 1229 __ sdivx(O2, Otos_l, Otos_l2); 1230 __ mulx (Otos_l2, Otos_l, Otos_l2); 1231 __ sub (O2, Otos_l2, Otos_l); 1232 #else 1233 __ orcc(Otos_l1, Otos_l2, G0); 1234 __ throw_if_not_icc(Assembler::notZero, Interpreter::_throw_ArithmeticException_entry, G3_scratch); 1235 __ call_VM_leaf(Lscratch, CAST_FROM_FN_PTR(address, SharedRuntime::lrem)); 1236 #endif 1237 } 1238 1239 1240 void TemplateTable::lshl() { 1241 transition(itos, ltos); // %%%% could optimize, fill delay slot or opt for ultra 1242 1243 __ pop_l(O2); // shift value in O2, O3 1244 #ifdef _LP64 1245 __ sllx(O2, Otos_i, Otos_l); 1246 #else 1247 __ lshl(O2, O3, Otos_i, Otos_l1, Otos_l2, O4); 1248 #endif 1249 } 1250 1251 1252 void TemplateTable::lshr() { 1253 transition(itos, ltos); // %%%% see lshl comment 1254 1255 __ pop_l(O2); // shift value in O2, O3 1256 #ifdef _LP64 1257 __ srax(O2, Otos_i, Otos_l); 1258 #else 1259 __ lshr(O2, O3, Otos_i, Otos_l1, Otos_l2, O4); 1260 #endif 1261 } 1262 1263 1264 1265 void TemplateTable::lushr() { 1266 transition(itos, ltos); // %%%% see lshl comment 1267 1268 __ pop_l(O2); // shift value in O2, O3 1269 #ifdef _LP64 1270 __ srlx(O2, Otos_i, Otos_l); 1271 #else 1272 __ lushr(O2, O3, Otos_i, Otos_l1, Otos_l2, O4); 1273 #endif 1274 } 1275 1276 1277 void TemplateTable::fop2(Operation op) { 1278 transition(ftos, ftos); 1279 switch (op) { 1280 case add: __ pop_f(F4); __ fadd(FloatRegisterImpl::S, F4, Ftos_f, Ftos_f); break; 1281 case sub: __ pop_f(F4); __ fsub(FloatRegisterImpl::S, F4, Ftos_f, Ftos_f); break; 1282 case mul: __ pop_f(F4); __ fmul(FloatRegisterImpl::S, F4, Ftos_f, Ftos_f); break; 1283 case div: __ pop_f(F4); __ fdiv(FloatRegisterImpl::S, F4, Ftos_f, Ftos_f); break; 1284 case rem: 1285 assert(Ftos_f == F0, "just checking"); 1286 #ifdef _LP64 1287 // LP64 calling conventions use F1, F3 for passing 2 floats 1288 __ pop_f(F1); 1289 __ fmov(FloatRegisterImpl::S, Ftos_f, F3); 1290 #else 1291 __ pop_i(O0); 1292 __ stf(FloatRegisterImpl::S, Ftos_f, __ d_tmp); 1293 __ ld( __ d_tmp, O1 ); 1294 #endif 1295 __ call_VM_leaf(Lscratch, CAST_FROM_FN_PTR(address, SharedRuntime::frem)); 1296 assert( Ftos_f == F0, "fix this code" ); 1297 break; 1298 1299 default: ShouldNotReachHere(); 1300 } 1301 } 1302 1303 1304 void TemplateTable::dop2(Operation op) { 1305 transition(dtos, dtos); 1306 switch (op) { 1307 case add: __ pop_d(F4); __ fadd(FloatRegisterImpl::D, F4, Ftos_d, Ftos_d); break; 1308 case sub: __ pop_d(F4); __ fsub(FloatRegisterImpl::D, F4, Ftos_d, Ftos_d); break; 1309 case mul: __ pop_d(F4); __ fmul(FloatRegisterImpl::D, F4, Ftos_d, Ftos_d); break; 1310 case div: __ pop_d(F4); __ fdiv(FloatRegisterImpl::D, F4, Ftos_d, Ftos_d); break; 1311 case rem: 1312 #ifdef _LP64 1313 // Pass arguments in D0, D2 1314 __ fmov(FloatRegisterImpl::D, Ftos_f, F2 ); 1315 __ pop_d( F0 ); 1316 #else 1317 // Pass arguments in O0O1, O2O3 1318 __ stf(FloatRegisterImpl::D, Ftos_f, __ d_tmp); 1319 __ ldd( __ d_tmp, O2 ); 1320 __ pop_d(Ftos_f); 1321 __ stf(FloatRegisterImpl::D, Ftos_f, __ d_tmp); 1322 __ ldd( __ d_tmp, O0 ); 1323 #endif 1324 __ call_VM_leaf(Lscratch, CAST_FROM_FN_PTR(address, SharedRuntime::drem)); 1325 assert( Ftos_d == F0, "fix this code" ); 1326 break; 1327 1328 default: ShouldNotReachHere(); 1329 } 1330 } 1331 1332 1333 void TemplateTable::ineg() { 1334 transition(itos, itos); 1335 __ neg(Otos_i); 1336 } 1337 1338 1339 void TemplateTable::lneg() { 1340 transition(ltos, ltos); 1341 #ifdef _LP64 1342 __ sub(G0, Otos_l, Otos_l); 1343 #else 1344 __ lneg(Otos_l1, Otos_l2); 1345 #endif 1346 } 1347 1348 1349 void TemplateTable::fneg() { 1350 transition(ftos, ftos); 1351 __ fneg(FloatRegisterImpl::S, Ftos_f, Ftos_f); 1352 } 1353 1354 1355 void TemplateTable::dneg() { 1356 transition(dtos, dtos); 1357 __ fneg(FloatRegisterImpl::D, Ftos_f, Ftos_f); 1358 } 1359 1360 1361 void TemplateTable::iinc() { 1362 transition(vtos, vtos); 1363 locals_index(G3_scratch); 1364 __ ldsb(Lbcp, 2, O2); // load constant 1365 __ access_local_int(G3_scratch, Otos_i); 1366 __ add(Otos_i, O2, Otos_i); 1367 __ st(Otos_i, G3_scratch, 0); // access_local_int puts E.A. in G3_scratch 1368 } 1369 1370 1371 void TemplateTable::wide_iinc() { 1372 transition(vtos, vtos); 1373 locals_index_wide(G3_scratch); 1374 __ get_2_byte_integer_at_bcp( 4, O2, O3, InterpreterMacroAssembler::Signed); 1375 __ access_local_int(G3_scratch, Otos_i); 1376 __ add(Otos_i, O3, Otos_i); 1377 __ st(Otos_i, G3_scratch, 0); // access_local_int puts E.A. in G3_scratch 1378 } 1379 1380 1381 void TemplateTable::convert() { 1382 // %%%%% Factor this first part accross platforms 1383 #ifdef ASSERT 1384 TosState tos_in = ilgl; 1385 TosState tos_out = ilgl; 1386 switch (bytecode()) { 1387 case Bytecodes::_i2l: // fall through 1388 case Bytecodes::_i2f: // fall through 1389 case Bytecodes::_i2d: // fall through 1390 case Bytecodes::_i2b: // fall through 1391 case Bytecodes::_i2c: // fall through 1392 case Bytecodes::_i2s: tos_in = itos; break; 1393 case Bytecodes::_l2i: // fall through 1394 case Bytecodes::_l2f: // fall through 1395 case Bytecodes::_l2d: tos_in = ltos; break; 1396 case Bytecodes::_f2i: // fall through 1397 case Bytecodes::_f2l: // fall through 1398 case Bytecodes::_f2d: tos_in = ftos; break; 1399 case Bytecodes::_d2i: // fall through 1400 case Bytecodes::_d2l: // fall through 1401 case Bytecodes::_d2f: tos_in = dtos; break; 1402 default : ShouldNotReachHere(); 1403 } 1404 switch (bytecode()) { 1405 case Bytecodes::_l2i: // fall through 1406 case Bytecodes::_f2i: // fall through 1407 case Bytecodes::_d2i: // fall through 1408 case Bytecodes::_i2b: // fall through 1409 case Bytecodes::_i2c: // fall through 1410 case Bytecodes::_i2s: tos_out = itos; break; 1411 case Bytecodes::_i2l: // fall through 1412 case Bytecodes::_f2l: // fall through 1413 case Bytecodes::_d2l: tos_out = ltos; break; 1414 case Bytecodes::_i2f: // fall through 1415 case Bytecodes::_l2f: // fall through 1416 case Bytecodes::_d2f: tos_out = ftos; break; 1417 case Bytecodes::_i2d: // fall through 1418 case Bytecodes::_l2d: // fall through 1419 case Bytecodes::_f2d: tos_out = dtos; break; 1420 default : ShouldNotReachHere(); 1421 } 1422 transition(tos_in, tos_out); 1423 #endif 1424 1425 1426 // Conversion 1427 Label done; 1428 switch (bytecode()) { 1429 case Bytecodes::_i2l: 1430 #ifdef _LP64 1431 // Sign extend the 32 bits 1432 __ sra ( Otos_i, 0, Otos_l ); 1433 #else 1434 __ addcc(Otos_i, 0, Otos_l2); 1435 __ br(Assembler::greaterEqual, true, Assembler::pt, done); 1436 __ delayed()->clr(Otos_l1); 1437 __ set(~0, Otos_l1); 1438 #endif 1439 break; 1440 1441 case Bytecodes::_i2f: 1442 __ st(Otos_i, __ d_tmp ); 1443 __ ldf(FloatRegisterImpl::S, __ d_tmp, F0); 1444 __ fitof(FloatRegisterImpl::S, F0, Ftos_f); 1445 break; 1446 1447 case Bytecodes::_i2d: 1448 __ st(Otos_i, __ d_tmp); 1449 __ ldf(FloatRegisterImpl::S, __ d_tmp, F0); 1450 __ fitof(FloatRegisterImpl::D, F0, Ftos_f); 1451 break; 1452 1453 case Bytecodes::_i2b: 1454 __ sll(Otos_i, 24, Otos_i); 1455 __ sra(Otos_i, 24, Otos_i); 1456 break; 1457 1458 case Bytecodes::_i2c: 1459 __ sll(Otos_i, 16, Otos_i); 1460 __ srl(Otos_i, 16, Otos_i); 1461 break; 1462 1463 case Bytecodes::_i2s: 1464 __ sll(Otos_i, 16, Otos_i); 1465 __ sra(Otos_i, 16, Otos_i); 1466 break; 1467 1468 case Bytecodes::_l2i: 1469 #ifndef _LP64 1470 __ mov(Otos_l2, Otos_i); 1471 #else 1472 // Sign-extend into the high 32 bits 1473 __ sra(Otos_l, 0, Otos_i); 1474 #endif 1475 break; 1476 1477 case Bytecodes::_l2f: 1478 case Bytecodes::_l2d: 1479 __ st_long(Otos_l, __ d_tmp); 1480 __ ldf(FloatRegisterImpl::D, __ d_tmp, Ftos_d); 1481 1482 if (bytecode() == Bytecodes::_l2f) { 1483 __ fxtof(FloatRegisterImpl::S, Ftos_d, Ftos_f); 1484 } else { 1485 __ fxtof(FloatRegisterImpl::D, Ftos_d, Ftos_d); 1486 } 1487 break; 1488 1489 case Bytecodes::_f2i: { 1490 Label isNaN; 1491 // result must be 0 if value is NaN; test by comparing value to itself 1492 __ fcmp(FloatRegisterImpl::S, Assembler::fcc0, Ftos_f, Ftos_f); 1493 __ fb(Assembler::f_unordered, true, Assembler::pn, isNaN); 1494 __ delayed()->clr(Otos_i); // NaN 1495 __ ftoi(FloatRegisterImpl::S, Ftos_f, F30); 1496 __ stf(FloatRegisterImpl::S, F30, __ d_tmp); 1497 __ ld(__ d_tmp, Otos_i); 1498 __ bind(isNaN); 1499 } 1500 break; 1501 1502 case Bytecodes::_f2l: 1503 // must uncache tos 1504 __ push_f(); 1505 #ifdef _LP64 1506 __ pop_f(F1); 1507 #else 1508 __ pop_i(O0); 1509 #endif 1510 __ call_VM_leaf(Lscratch, CAST_FROM_FN_PTR(address, SharedRuntime::f2l)); 1511 break; 1512 1513 case Bytecodes::_f2d: 1514 __ ftof( FloatRegisterImpl::S, FloatRegisterImpl::D, Ftos_f, Ftos_f); 1515 break; 1516 1517 case Bytecodes::_d2i: 1518 case Bytecodes::_d2l: 1519 // must uncache tos 1520 __ push_d(); 1521 #ifdef _LP64 1522 // LP64 calling conventions pass first double arg in D0 1523 __ pop_d( Ftos_d ); 1524 #else 1525 __ pop_i( O0 ); 1526 __ pop_i( O1 ); 1527 #endif 1528 __ call_VM_leaf(Lscratch, 1529 bytecode() == Bytecodes::_d2i 1530 ? CAST_FROM_FN_PTR(address, SharedRuntime::d2i) 1531 : CAST_FROM_FN_PTR(address, SharedRuntime::d2l)); 1532 break; 1533 1534 case Bytecodes::_d2f: 1535 __ ftof( FloatRegisterImpl::D, FloatRegisterImpl::S, Ftos_d, Ftos_f); 1536 break; 1537 1538 default: ShouldNotReachHere(); 1539 } 1540 __ bind(done); 1541 } 1542 1543 1544 void TemplateTable::lcmp() { 1545 transition(ltos, itos); 1546 1547 #ifdef _LP64 1548 __ pop_l(O1); // pop off value 1, value 2 is in O0 1549 __ lcmp( O1, Otos_l, Otos_i ); 1550 #else 1551 __ pop_l(O2); // cmp O2,3 to O0,1 1552 __ lcmp( O2, O3, Otos_l1, Otos_l2, Otos_i ); 1553 #endif 1554 } 1555 1556 1557 void TemplateTable::float_cmp(bool is_float, int unordered_result) { 1558 1559 if (is_float) __ pop_f(F2); 1560 else __ pop_d(F2); 1561 1562 assert(Ftos_f == F0 && Ftos_d == F0, "alias checking:"); 1563 1564 __ float_cmp( is_float, unordered_result, F2, F0, Otos_i ); 1565 } 1566 1567 void TemplateTable::branch(bool is_jsr, bool is_wide) { 1568 // Note: on SPARC, we use InterpreterMacroAssembler::if_cmp also. 1569 __ verify_thread(); 1570 1571 const Register O2_bumped_count = O2; 1572 __ profile_taken_branch(G3_scratch, O2_bumped_count); 1573 1574 // get (wide) offset to O1_disp 1575 const Register O1_disp = O1; 1576 if (is_wide) __ get_4_byte_integer_at_bcp( 1, G4_scratch, O1_disp, InterpreterMacroAssembler::set_CC); 1577 else __ get_2_byte_integer_at_bcp( 1, G4_scratch, O1_disp, InterpreterMacroAssembler::Signed, InterpreterMacroAssembler::set_CC); 1578 1579 // Handle all the JSR stuff here, then exit. 1580 // It's much shorter and cleaner than intermingling with the 1581 // non-JSR normal-branch stuff occurring below. 1582 if( is_jsr ) { 1583 // compute return address as bci in Otos_i 1584 __ ld_ptr(Lmethod, Method::const_offset(), G3_scratch); 1585 __ sub(Lbcp, G3_scratch, G3_scratch); 1586 __ sub(G3_scratch, in_bytes(ConstMethod::codes_offset()) - (is_wide ? 5 : 3), Otos_i); 1587 1588 // Bump Lbcp to target of JSR 1589 __ add(Lbcp, O1_disp, Lbcp); 1590 // Push returnAddress for "ret" on stack 1591 __ push_ptr(Otos_i); 1592 // And away we go! 1593 __ dispatch_next(vtos); 1594 return; 1595 } 1596 1597 // Normal (non-jsr) branch handling 1598 1599 // Save the current Lbcp 1600 const Register l_cur_bcp = Lscratch; 1601 __ mov( Lbcp, l_cur_bcp ); 1602 1603 bool increment_invocation_counter_for_backward_branches = UseCompiler && UseLoopCounter; 1604 if ( increment_invocation_counter_for_backward_branches ) { 1605 Label Lforward; 1606 // check branch direction 1607 __ br( Assembler::positive, false, Assembler::pn, Lforward ); 1608 // Bump bytecode pointer by displacement (take the branch) 1609 __ delayed()->add( O1_disp, Lbcp, Lbcp ); // add to bc addr 1610 1611 const Register G3_method_counters = G3_scratch; 1612 __ get_method_counters(Lmethod, G3_method_counters, Lforward); 1613 1614 if (TieredCompilation) { 1615 Label Lno_mdo, Loverflow; 1616 int increment = InvocationCounter::count_increment; 1617 if (ProfileInterpreter) { 1618 // If no method data exists, go to profile_continue. 1619 __ ld_ptr(Lmethod, Method::method_data_offset(), G4_scratch); 1620 __ br_null_short(G4_scratch, Assembler::pn, Lno_mdo); 1621 1622 // Increment backedge counter in the MDO 1623 Address mdo_backedge_counter(G4_scratch, in_bytes(MethodData::backedge_counter_offset()) + 1624 in_bytes(InvocationCounter::counter_offset())); 1625 Address mask(G4_scratch, in_bytes(MethodData::backedge_mask_offset())); 1626 __ increment_mask_and_jump(mdo_backedge_counter, increment, mask, G3_scratch, O0, 1627 Assembler::notZero, &Lforward); 1628 __ ba_short(Loverflow); 1629 } 1630 1631 // If there's no MDO, increment counter in MethodCounters* 1632 __ bind(Lno_mdo); 1633 Address backedge_counter(G3_method_counters, 1634 in_bytes(MethodCounters::backedge_counter_offset()) + 1635 in_bytes(InvocationCounter::counter_offset())); 1636 Address mask(G3_method_counters, in_bytes(MethodCounters::backedge_mask_offset())); 1637 __ increment_mask_and_jump(backedge_counter, increment, mask, G4_scratch, O0, 1638 Assembler::notZero, &Lforward); 1639 __ bind(Loverflow); 1640 1641 // notify point for loop, pass branch bytecode 1642 __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::frequency_counter_overflow), l_cur_bcp); 1643 1644 // Was an OSR adapter generated? 1645 // O0 = osr nmethod 1646 __ br_null_short(O0, Assembler::pn, Lforward); 1647 1648 // Has the nmethod been invalidated already? 1649 __ ldub(O0, nmethod::state_offset(), O2); 1650 __ cmp_and_br_short(O2, nmethod::in_use, Assembler::notEqual, Assembler::pn, Lforward); 1651 1652 // migrate the interpreter frame off of the stack 1653 1654 __ mov(G2_thread, L7); 1655 // save nmethod 1656 __ mov(O0, L6); 1657 __ set_last_Java_frame(SP, noreg); 1658 __ call_VM_leaf(noreg, CAST_FROM_FN_PTR(address, SharedRuntime::OSR_migration_begin), L7); 1659 __ reset_last_Java_frame(); 1660 __ mov(L7, G2_thread); 1661 1662 // move OSR nmethod to I1 1663 __ mov(L6, I1); 1664 1665 // OSR buffer to I0 1666 __ mov(O0, I0); 1667 1668 // remove the interpreter frame 1669 __ restore(I5_savedSP, 0, SP); 1670 1671 // Jump to the osr code. 1672 __ ld_ptr(O1, nmethod::osr_entry_point_offset(), O2); 1673 __ jmp(O2, G0); 1674 __ delayed()->nop(); 1675 1676 } else { // not TieredCompilation 1677 // Update Backedge branch separately from invocations 1678 const Register G4_invoke_ctr = G4; 1679 __ increment_backedge_counter(G3_method_counters, G4_invoke_ctr, G1_scratch); 1680 if (ProfileInterpreter) { 1681 __ test_invocation_counter_for_mdp(G4_invoke_ctr, G3_method_counters, G1_scratch, Lforward); 1682 if (UseOnStackReplacement) { 1683 1684 __ test_backedge_count_for_osr(O2_bumped_count, G3_method_counters, l_cur_bcp, G1_scratch); 1685 } 1686 } else { 1687 if (UseOnStackReplacement) { 1688 __ test_backedge_count_for_osr(G4_invoke_ctr, G3_method_counters, l_cur_bcp, G1_scratch); 1689 } 1690 } 1691 } 1692 1693 __ bind(Lforward); 1694 } else 1695 // Bump bytecode pointer by displacement (take the branch) 1696 __ add( O1_disp, Lbcp, Lbcp );// add to bc addr 1697 1698 // continue with bytecode @ target 1699 // %%%%% Like Intel, could speed things up by moving bytecode fetch to code above, 1700 // %%%%% and changing dispatch_next to dispatch_only 1701 __ dispatch_next(vtos); 1702 } 1703 1704 1705 // Note Condition in argument is TemplateTable::Condition 1706 // arg scope is within class scope 1707 1708 void TemplateTable::if_0cmp(Condition cc) { 1709 // no pointers, integer only! 1710 transition(itos, vtos); 1711 // assume branch is more often taken than not (loops use backward branches) 1712 __ cmp( Otos_i, 0); 1713 __ if_cmp(ccNot(cc), false); 1714 } 1715 1716 1717 void TemplateTable::if_icmp(Condition cc) { 1718 transition(itos, vtos); 1719 __ pop_i(O1); 1720 __ cmp(O1, Otos_i); 1721 __ if_cmp(ccNot(cc), false); 1722 } 1723 1724 1725 void TemplateTable::if_nullcmp(Condition cc) { 1726 transition(atos, vtos); 1727 __ tst(Otos_i); 1728 __ if_cmp(ccNot(cc), true); 1729 } 1730 1731 1732 void TemplateTable::if_acmp(Condition cc) { 1733 transition(atos, vtos); 1734 __ pop_ptr(O1); 1735 __ verify_oop(O1); 1736 __ verify_oop(Otos_i); 1737 __ cmp(O1, Otos_i); 1738 __ if_cmp(ccNot(cc), true); 1739 } 1740 1741 1742 1743 void TemplateTable::ret() { 1744 transition(vtos, vtos); 1745 locals_index(G3_scratch); 1746 __ access_local_returnAddress(G3_scratch, Otos_i); 1747 // Otos_i contains the bci, compute the bcp from that 1748 1749 #ifdef _LP64 1750 #ifdef ASSERT 1751 // jsr result was labeled as an 'itos' not an 'atos' because we cannot GC 1752 // the result. The return address (really a BCI) was stored with an 1753 // 'astore' because JVM specs claim it's a pointer-sized thing. Hence in 1754 // the 64-bit build the 32-bit BCI is actually in the low bits of a 64-bit 1755 // loaded value. 1756 { Label zzz ; 1757 __ set (65536, G3_scratch) ; 1758 __ cmp (Otos_i, G3_scratch) ; 1759 __ bp( Assembler::lessEqualUnsigned, false, Assembler::xcc, Assembler::pn, zzz); 1760 __ delayed()->nop(); 1761 __ stop("BCI is in the wrong register half?"); 1762 __ bind (zzz) ; 1763 } 1764 #endif 1765 #endif 1766 1767 __ profile_ret(vtos, Otos_i, G4_scratch); 1768 1769 __ ld_ptr(Lmethod, Method::const_offset(), G3_scratch); 1770 __ add(G3_scratch, Otos_i, G3_scratch); 1771 __ add(G3_scratch, in_bytes(ConstMethod::codes_offset()), Lbcp); 1772 __ dispatch_next(vtos); 1773 } 1774 1775 1776 void TemplateTable::wide_ret() { 1777 transition(vtos, vtos); 1778 locals_index_wide(G3_scratch); 1779 __ access_local_returnAddress(G3_scratch, Otos_i); 1780 // Otos_i contains the bci, compute the bcp from that 1781 1782 __ profile_ret(vtos, Otos_i, G4_scratch); 1783 1784 __ ld_ptr(Lmethod, Method::const_offset(), G3_scratch); 1785 __ add(G3_scratch, Otos_i, G3_scratch); 1786 __ add(G3_scratch, in_bytes(ConstMethod::codes_offset()), Lbcp); 1787 __ dispatch_next(vtos); 1788 } 1789 1790 1791 void TemplateTable::tableswitch() { 1792 transition(itos, vtos); 1793 Label default_case, continue_execution; 1794 1795 // align bcp 1796 __ add(Lbcp, BytesPerInt, O1); 1797 __ and3(O1, -BytesPerInt, O1); 1798 // load lo, hi 1799 __ ld(O1, 1 * BytesPerInt, O2); // Low Byte 1800 __ ld(O1, 2 * BytesPerInt, O3); // High Byte 1801 #ifdef _LP64 1802 // Sign extend the 32 bits 1803 __ sra ( Otos_i, 0, Otos_i ); 1804 #endif /* _LP64 */ 1805 1806 // check against lo & hi 1807 __ cmp( Otos_i, O2); 1808 __ br( Assembler::less, false, Assembler::pn, default_case); 1809 __ delayed()->cmp( Otos_i, O3 ); 1810 __ br( Assembler::greater, false, Assembler::pn, default_case); 1811 // lookup dispatch offset 1812 __ delayed()->sub(Otos_i, O2, O2); 1813 __ profile_switch_case(O2, O3, G3_scratch, G4_scratch); 1814 __ sll(O2, LogBytesPerInt, O2); 1815 __ add(O2, 3 * BytesPerInt, O2); 1816 __ ba(continue_execution); 1817 __ delayed()->ld(O1, O2, O2); 1818 // handle default 1819 __ bind(default_case); 1820 __ profile_switch_default(O3); 1821 __ ld(O1, 0, O2); // get default offset 1822 // continue execution 1823 __ bind(continue_execution); 1824 __ add(Lbcp, O2, Lbcp); 1825 __ dispatch_next(vtos); 1826 } 1827 1828 1829 void TemplateTable::lookupswitch() { 1830 transition(itos, itos); 1831 __ stop("lookupswitch bytecode should have been rewritten"); 1832 } 1833 1834 void TemplateTable::fast_linearswitch() { 1835 transition(itos, vtos); 1836 Label loop_entry, loop, found, continue_execution; 1837 // align bcp 1838 __ add(Lbcp, BytesPerInt, O1); 1839 __ and3(O1, -BytesPerInt, O1); 1840 // set counter 1841 __ ld(O1, BytesPerInt, O2); 1842 __ sll(O2, LogBytesPerInt + 1, O2); // in word-pairs 1843 __ add(O1, 2 * BytesPerInt, O3); // set first pair addr 1844 __ ba(loop_entry); 1845 __ delayed()->add(O3, O2, O2); // counter now points past last pair 1846 1847 // table search 1848 __ bind(loop); 1849 __ cmp(O4, Otos_i); 1850 __ br(Assembler::equal, true, Assembler::pn, found); 1851 __ delayed()->ld(O3, BytesPerInt, O4); // offset -> O4 1852 __ inc(O3, 2 * BytesPerInt); 1853 1854 __ bind(loop_entry); 1855 __ cmp(O2, O3); 1856 __ brx(Assembler::greaterUnsigned, true, Assembler::pt, loop); 1857 __ delayed()->ld(O3, 0, O4); 1858 1859 // default case 1860 __ ld(O1, 0, O4); // get default offset 1861 if (ProfileInterpreter) { 1862 __ profile_switch_default(O3); 1863 __ ba_short(continue_execution); 1864 } 1865 1866 // entry found -> get offset 1867 __ bind(found); 1868 if (ProfileInterpreter) { 1869 __ sub(O3, O1, O3); 1870 __ sub(O3, 2*BytesPerInt, O3); 1871 __ srl(O3, LogBytesPerInt + 1, O3); // in word-pairs 1872 __ profile_switch_case(O3, O1, O2, G3_scratch); 1873 1874 __ bind(continue_execution); 1875 } 1876 __ add(Lbcp, O4, Lbcp); 1877 __ dispatch_next(vtos); 1878 } 1879 1880 1881 void TemplateTable::fast_binaryswitch() { 1882 transition(itos, vtos); 1883 // Implementation using the following core algorithm: (copied from Intel) 1884 // 1885 // int binary_search(int key, LookupswitchPair* array, int n) { 1886 // // Binary search according to "Methodik des Programmierens" by 1887 // // Edsger W. Dijkstra and W.H.J. Feijen, Addison Wesley Germany 1985. 1888 // int i = 0; 1889 // int j = n; 1890 // while (i+1 < j) { 1891 // // invariant P: 0 <= i < j <= n and (a[i] <= key < a[j] or Q) 1892 // // with Q: for all i: 0 <= i < n: key < a[i] 1893 // // where a stands for the array and assuming that the (inexisting) 1894 // // element a[n] is infinitely big. 1895 // int h = (i + j) >> 1; 1896 // // i < h < j 1897 // if (key < array[h].fast_match()) { 1898 // j = h; 1899 // } else { 1900 // i = h; 1901 // } 1902 // } 1903 // // R: a[i] <= key < a[i+1] or Q 1904 // // (i.e., if key is within array, i is the correct index) 1905 // return i; 1906 // } 1907 1908 // register allocation 1909 assert(Otos_i == O0, "alias checking"); 1910 const Register Rkey = Otos_i; // already set (tosca) 1911 const Register Rarray = O1; 1912 const Register Ri = O2; 1913 const Register Rj = O3; 1914 const Register Rh = O4; 1915 const Register Rscratch = O5; 1916 1917 const int log_entry_size = 3; 1918 const int entry_size = 1 << log_entry_size; 1919 1920 Label found; 1921 // Find Array start 1922 __ add(Lbcp, 3 * BytesPerInt, Rarray); 1923 __ and3(Rarray, -BytesPerInt, Rarray); 1924 // initialize i & j (in delay slot) 1925 __ clr( Ri ); 1926 1927 // and start 1928 Label entry; 1929 __ ba(entry); 1930 __ delayed()->ld( Rarray, -BytesPerInt, Rj); 1931 // (Rj is already in the native byte-ordering.) 1932 1933 // binary search loop 1934 { Label loop; 1935 __ bind( loop ); 1936 // int h = (i + j) >> 1; 1937 __ sra( Rh, 1, Rh ); 1938 // if (key < array[h].fast_match()) { 1939 // j = h; 1940 // } else { 1941 // i = h; 1942 // } 1943 __ sll( Rh, log_entry_size, Rscratch ); 1944 __ ld( Rarray, Rscratch, Rscratch ); 1945 // (Rscratch is already in the native byte-ordering.) 1946 __ cmp( Rkey, Rscratch ); 1947 __ movcc( Assembler::less, false, Assembler::icc, Rh, Rj ); // j = h if (key < array[h].fast_match()) 1948 __ movcc( Assembler::greaterEqual, false, Assembler::icc, Rh, Ri ); // i = h if (key >= array[h].fast_match()) 1949 1950 // while (i+1 < j) 1951 __ bind( entry ); 1952 __ add( Ri, 1, Rscratch ); 1953 __ cmp(Rscratch, Rj); 1954 __ br( Assembler::less, true, Assembler::pt, loop ); 1955 __ delayed()->add( Ri, Rj, Rh ); // start h = i + j >> 1; 1956 } 1957 1958 // end of binary search, result index is i (must check again!) 1959 Label default_case; 1960 Label continue_execution; 1961 if (ProfileInterpreter) { 1962 __ mov( Ri, Rh ); // Save index in i for profiling 1963 } 1964 __ sll( Ri, log_entry_size, Ri ); 1965 __ ld( Rarray, Ri, Rscratch ); 1966 // (Rscratch is already in the native byte-ordering.) 1967 __ cmp( Rkey, Rscratch ); 1968 __ br( Assembler::notEqual, true, Assembler::pn, default_case ); 1969 __ delayed()->ld( Rarray, -2 * BytesPerInt, Rj ); // load default offset -> j 1970 1971 // entry found -> j = offset 1972 __ inc( Ri, BytesPerInt ); 1973 __ profile_switch_case(Rh, Rj, Rscratch, Rkey); 1974 __ ld( Rarray, Ri, Rj ); 1975 // (Rj is already in the native byte-ordering.) 1976 1977 if (ProfileInterpreter) { 1978 __ ba_short(continue_execution); 1979 } 1980 1981 __ bind(default_case); // fall through (if not profiling) 1982 __ profile_switch_default(Ri); 1983 1984 __ bind(continue_execution); 1985 __ add( Lbcp, Rj, Lbcp ); 1986 __ dispatch_next( vtos ); 1987 } 1988 1989 1990 void TemplateTable::_return(TosState state) { 1991 transition(state, state); 1992 assert(_desc->calls_vm(), "inconsistent calls_vm information"); 1993 1994 if (_desc->bytecode() == Bytecodes::_return_register_finalizer) { 1995 assert(state == vtos, "only valid state"); 1996 __ mov(G0, G3_scratch); 1997 __ access_local_ptr(G3_scratch, Otos_i); 1998 __ load_klass(Otos_i, O2); 1999 __ set(JVM_ACC_HAS_FINALIZER, G3); 2000 __ ld(O2, in_bytes(Klass::access_flags_offset()), O2); 2001 __ andcc(G3, O2, G0); 2002 Label skip_register_finalizer; 2003 __ br(Assembler::zero, false, Assembler::pn, skip_register_finalizer); 2004 __ delayed()->nop(); 2005 2006 // Call out to do finalizer registration 2007 __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::register_finalizer), Otos_i); 2008 2009 __ bind(skip_register_finalizer); 2010 } 2011 2012 __ remove_activation(state, /* throw_monitor_exception */ true); 2013 2014 // The caller's SP was adjusted upon method entry to accomodate 2015 // the callee's non-argument locals. Undo that adjustment. 2016 __ ret(); // return to caller 2017 __ delayed()->restore(I5_savedSP, G0, SP); 2018 } 2019 2020 2021 // ---------------------------------------------------------------------------- 2022 // Volatile variables demand their effects be made known to all CPU's in 2023 // order. Store buffers on most chips allow reads & writes to reorder; the 2024 // JMM's ReadAfterWrite.java test fails in -Xint mode without some kind of 2025 // memory barrier (i.e., it's not sufficient that the interpreter does not 2026 // reorder volatile references, the hardware also must not reorder them). 2027 // 2028 // According to the new Java Memory Model (JMM): 2029 // (1) All volatiles are serialized wrt to each other. 2030 // ALSO reads & writes act as aquire & release, so: 2031 // (2) A read cannot let unrelated NON-volatile memory refs that happen after 2032 // the read float up to before the read. It's OK for non-volatile memory refs 2033 // that happen before the volatile read to float down below it. 2034 // (3) Similar a volatile write cannot let unrelated NON-volatile memory refs 2035 // that happen BEFORE the write float down to after the write. It's OK for 2036 // non-volatile memory refs that happen after the volatile write to float up 2037 // before it. 2038 // 2039 // We only put in barriers around volatile refs (they are expensive), not 2040 // _between_ memory refs (that would require us to track the flavor of the 2041 // previous memory refs). Requirements (2) and (3) require some barriers 2042 // before volatile stores and after volatile loads. These nearly cover 2043 // requirement (1) but miss the volatile-store-volatile-load case. This final 2044 // case is placed after volatile-stores although it could just as well go 2045 // before volatile-loads. 2046 void TemplateTable::volatile_barrier(Assembler::Membar_mask_bits order_constraint) { 2047 // Helper function to insert a is-volatile test and memory barrier 2048 // All current sparc implementations run in TSO, needing only StoreLoad 2049 if ((order_constraint & Assembler::StoreLoad) == 0) return; 2050 __ membar( order_constraint ); 2051 } 2052 2053 // ---------------------------------------------------------------------------- 2054 void TemplateTable::resolve_cache_and_index(int byte_no, 2055 Register Rcache, 2056 Register index, 2057 size_t index_size) { 2058 // Depends on cpCacheOop layout! 2059 2060 Label resolved; 2061 Bytecodes::Code code = bytecode(); 2062 switch (code) { 2063 case Bytecodes::_nofast_getfield: code = Bytecodes::_getfield; break; 2064 case Bytecodes::_nofast_putfield: code = Bytecodes::_putfield; break; 2065 } 2066 2067 assert(byte_no == f1_byte || byte_no == f2_byte, "byte_no out of range"); 2068 __ get_cache_and_index_and_bytecode_at_bcp(Rcache, index, Lbyte_code, byte_no, 1, index_size); 2069 __ cmp(Lbyte_code, code); // have we resolved this bytecode? 2070 __ br(Assembler::equal, false, Assembler::pt, resolved); 2071 __ delayed()->set(code, O1); 2072 2073 address entry = CAST_FROM_FN_PTR(address, InterpreterRuntime::resolve_from_cache); 2074 // first time invocation - must resolve first 2075 __ call_VM(noreg, entry, O1); 2076 // Update registers with resolved info 2077 __ get_cache_and_index_at_bcp(Rcache, index, 1, index_size); 2078 __ bind(resolved); 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, 2087 bool is_invokedynamic) { 2088 // Uses both G3_scratch and G4_scratch 2089 Register cache = G3_scratch; 2090 Register index = G4_scratch; 2091 assert_different_registers(cache, method, itable_index); 2092 2093 // determine constant pool cache field offsets 2094 assert(is_invokevirtual == (byte_no == f2_byte), "is_invokevirtual flag redundant"); 2095 const int method_offset = in_bytes( 2096 ConstantPoolCache::base_offset() + 2097 ((byte_no == f2_byte) 2098 ? ConstantPoolCacheEntry::f2_offset() 2099 : ConstantPoolCacheEntry::f1_offset() 2100 ) 2101 ); 2102 const int flags_offset = in_bytes(ConstantPoolCache::base_offset() + 2103 ConstantPoolCacheEntry::flags_offset()); 2104 // access constant pool cache fields 2105 const int index_offset = in_bytes(ConstantPoolCache::base_offset() + 2106 ConstantPoolCacheEntry::f2_offset()); 2107 2108 if (is_invokevfinal) { 2109 __ get_cache_and_index_at_bcp(cache, index, 1); 2110 __ ld_ptr(Address(cache, method_offset), method); 2111 } else { 2112 size_t index_size = (is_invokedynamic ? sizeof(u4) : sizeof(u2)); 2113 resolve_cache_and_index(byte_no, cache, index, index_size); 2114 __ ld_ptr(Address(cache, method_offset), method); 2115 } 2116 2117 if (itable_index != noreg) { 2118 // pick up itable or appendix index from f2 also: 2119 __ ld_ptr(Address(cache, index_offset), itable_index); 2120 } 2121 __ ld_ptr(Address(cache, flags_offset), flags); 2122 } 2123 2124 // The Rcache register must be set before call 2125 void TemplateTable::load_field_cp_cache_entry(Register Robj, 2126 Register Rcache, 2127 Register index, 2128 Register Roffset, 2129 Register Rflags, 2130 bool is_static) { 2131 assert_different_registers(Rcache, Rflags, Roffset); 2132 2133 ByteSize cp_base_offset = ConstantPoolCache::base_offset(); 2134 2135 __ ld_ptr(Rcache, cp_base_offset + ConstantPoolCacheEntry::flags_offset(), Rflags); 2136 __ ld_ptr(Rcache, cp_base_offset + ConstantPoolCacheEntry::f2_offset(), Roffset); 2137 if (is_static) { 2138 __ ld_ptr(Rcache, cp_base_offset + ConstantPoolCacheEntry::f1_offset(), Robj); 2139 const int mirror_offset = in_bytes(Klass::java_mirror_offset()); 2140 __ ld_ptr( Robj, mirror_offset, Robj); 2141 } 2142 } 2143 2144 // The registers Rcache and index expected to be set before call. 2145 // Correct values of the Rcache and index registers are preserved. 2146 void TemplateTable::jvmti_post_field_access(Register Rcache, 2147 Register index, 2148 bool is_static, 2149 bool has_tos) { 2150 ByteSize cp_base_offset = ConstantPoolCache::base_offset(); 2151 2152 if (JvmtiExport::can_post_field_access()) { 2153 // Check to see if a field access watch has been set before we take 2154 // the time to call into the VM. 2155 Label Label1; 2156 assert_different_registers(Rcache, index, G1_scratch); 2157 AddressLiteral get_field_access_count_addr(JvmtiExport::get_field_access_count_addr()); 2158 __ load_contents(get_field_access_count_addr, G1_scratch); 2159 __ cmp_and_br_short(G1_scratch, 0, Assembler::equal, Assembler::pt, Label1); 2160 2161 __ add(Rcache, in_bytes(cp_base_offset), Rcache); 2162 2163 if (is_static) { 2164 __ clr(Otos_i); 2165 } else { 2166 if (has_tos) { 2167 // save object pointer before call_VM() clobbers it 2168 __ push_ptr(Otos_i); // put object on tos where GC wants it. 2169 } else { 2170 // Load top of stack (do not pop the value off the stack); 2171 __ ld_ptr(Lesp, Interpreter::expr_offset_in_bytes(0), Otos_i); 2172 } 2173 __ verify_oop(Otos_i); 2174 } 2175 // Otos_i: object pointer or NULL if static 2176 // Rcache: cache entry pointer 2177 __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::post_field_access), 2178 Otos_i, Rcache); 2179 if (!is_static && has_tos) { 2180 __ pop_ptr(Otos_i); // restore object pointer 2181 __ verify_oop(Otos_i); 2182 } 2183 __ get_cache_and_index_at_bcp(Rcache, index, 1); 2184 __ bind(Label1); 2185 } 2186 } 2187 2188 void TemplateTable::getfield_or_static(int byte_no, bool is_static, RewriteControl rc) { 2189 transition(vtos, vtos); 2190 2191 Register Rcache = G3_scratch; 2192 Register index = G4_scratch; 2193 Register Rclass = Rcache; 2194 Register Roffset= G4_scratch; 2195 Register Rflags = G1_scratch; 2196 ByteSize cp_base_offset = ConstantPoolCache::base_offset(); 2197 2198 resolve_cache_and_index(byte_no, Rcache, index, sizeof(u2)); 2199 jvmti_post_field_access(Rcache, index, is_static, false); 2200 load_field_cp_cache_entry(Rclass, Rcache, index, Roffset, Rflags, is_static); 2201 2202 if (!is_static) { 2203 pop_and_check_object(Rclass); 2204 } else { 2205 __ verify_oop(Rclass); 2206 } 2207 2208 Label exit; 2209 2210 Assembler::Membar_mask_bits membar_bits = 2211 Assembler::Membar_mask_bits(Assembler::LoadLoad | Assembler::LoadStore); 2212 2213 if (__ membar_has_effect(membar_bits)) { 2214 // Get volatile flag 2215 __ set((1 << ConstantPoolCacheEntry::is_volatile_shift), Lscratch); 2216 __ and3(Rflags, Lscratch, Lscratch); 2217 } 2218 2219 Label checkVolatile; 2220 2221 // compute field type 2222 Label notByte, notInt, notShort, notChar, notLong, notFloat, notObj; 2223 __ srl(Rflags, ConstantPoolCacheEntry::tos_state_shift, Rflags); 2224 // Make sure we don't need to mask Rflags after the above shift 2225 ConstantPoolCacheEntry::verify_tos_state_shift(); 2226 2227 // Check atos before itos for getstatic, more likely (in Queens at least) 2228 __ cmp(Rflags, atos); 2229 __ br(Assembler::notEqual, false, Assembler::pt, notObj); 2230 __ delayed() ->cmp(Rflags, itos); 2231 2232 // atos 2233 __ load_heap_oop(Rclass, Roffset, Otos_i); 2234 __ verify_oop(Otos_i); 2235 __ push(atos); 2236 if (!is_static && rc == may_rewrite) { 2237 patch_bytecode(Bytecodes::_fast_agetfield, G3_scratch, G4_scratch); 2238 } 2239 __ ba(checkVolatile); 2240 __ delayed()->tst(Lscratch); 2241 2242 __ bind(notObj); 2243 2244 // cmp(Rflags, itos); 2245 __ br(Assembler::notEqual, false, Assembler::pt, notInt); 2246 __ delayed() ->cmp(Rflags, ltos); 2247 2248 // itos 2249 __ ld(Rclass, Roffset, Otos_i); 2250 __ push(itos); 2251 if (!is_static && rc == may_rewrite) { 2252 patch_bytecode(Bytecodes::_fast_igetfield, G3_scratch, G4_scratch); 2253 } 2254 __ ba(checkVolatile); 2255 __ delayed()->tst(Lscratch); 2256 2257 __ bind(notInt); 2258 2259 // cmp(Rflags, ltos); 2260 __ br(Assembler::notEqual, false, Assembler::pt, notLong); 2261 __ delayed() ->cmp(Rflags, btos); 2262 2263 // ltos 2264 // load must be atomic 2265 __ ld_long(Rclass, Roffset, Otos_l); 2266 __ push(ltos); 2267 if (!is_static && rc == may_rewrite) { 2268 patch_bytecode(Bytecodes::_fast_lgetfield, G3_scratch, G4_scratch); 2269 } 2270 __ ba(checkVolatile); 2271 __ delayed()->tst(Lscratch); 2272 2273 __ bind(notLong); 2274 2275 // cmp(Rflags, btos); 2276 __ br(Assembler::notEqual, false, Assembler::pt, notByte); 2277 __ delayed() ->cmp(Rflags, ctos); 2278 2279 // btos 2280 __ ldsb(Rclass, Roffset, Otos_i); 2281 __ push(itos); 2282 if (!is_static && rc == may_rewrite) { 2283 patch_bytecode(Bytecodes::_fast_bgetfield, G3_scratch, G4_scratch); 2284 } 2285 __ ba(checkVolatile); 2286 __ delayed()->tst(Lscratch); 2287 2288 __ bind(notByte); 2289 2290 // cmp(Rflags, ctos); 2291 __ br(Assembler::notEqual, false, Assembler::pt, notChar); 2292 __ delayed() ->cmp(Rflags, stos); 2293 2294 // ctos 2295 __ lduh(Rclass, Roffset, Otos_i); 2296 __ push(itos); 2297 if (!is_static && rc == may_rewrite) { 2298 patch_bytecode(Bytecodes::_fast_cgetfield, G3_scratch, G4_scratch); 2299 } 2300 __ ba(checkVolatile); 2301 __ delayed()->tst(Lscratch); 2302 2303 __ bind(notChar); 2304 2305 // cmp(Rflags, stos); 2306 __ br(Assembler::notEqual, false, Assembler::pt, notShort); 2307 __ delayed() ->cmp(Rflags, ftos); 2308 2309 // stos 2310 __ ldsh(Rclass, Roffset, Otos_i); 2311 __ push(itos); 2312 if (!is_static && rc == may_rewrite) { 2313 patch_bytecode(Bytecodes::_fast_sgetfield, G3_scratch, G4_scratch); 2314 } 2315 __ ba(checkVolatile); 2316 __ delayed()->tst(Lscratch); 2317 2318 __ bind(notShort); 2319 2320 2321 // cmp(Rflags, ftos); 2322 __ br(Assembler::notEqual, false, Assembler::pt, notFloat); 2323 __ delayed() ->tst(Lscratch); 2324 2325 // ftos 2326 __ ldf(FloatRegisterImpl::S, Rclass, Roffset, Ftos_f); 2327 __ push(ftos); 2328 if (!is_static && rc == may_rewrite) { 2329 patch_bytecode(Bytecodes::_fast_fgetfield, G3_scratch, G4_scratch); 2330 } 2331 __ ba(checkVolatile); 2332 __ delayed()->tst(Lscratch); 2333 2334 __ bind(notFloat); 2335 2336 2337 // dtos 2338 __ ldf(FloatRegisterImpl::D, Rclass, Roffset, Ftos_d); 2339 __ push(dtos); 2340 if (!is_static && rc == may_rewrite) { 2341 patch_bytecode(Bytecodes::_fast_dgetfield, G3_scratch, G4_scratch); 2342 } 2343 2344 __ bind(checkVolatile); 2345 if (__ membar_has_effect(membar_bits)) { 2346 // __ tst(Lscratch); executed in delay slot 2347 __ br(Assembler::zero, false, Assembler::pt, exit); 2348 __ delayed()->nop(); 2349 volatile_barrier(membar_bits); 2350 } 2351 2352 __ bind(exit); 2353 } 2354 2355 void TemplateTable::getfield(int byte_no) { 2356 getfield_or_static(byte_no, false); 2357 } 2358 2359 void TemplateTable::nofast_getfield(int byte_no) { 2360 getfield_or_static(byte_no, false, may_not_rewrite); 2361 } 2362 2363 void TemplateTable::getstatic(int byte_no) { 2364 getfield_or_static(byte_no, true); 2365 } 2366 2367 void TemplateTable::fast_accessfield(TosState state) { 2368 transition(atos, state); 2369 Register Rcache = G3_scratch; 2370 Register index = G4_scratch; 2371 Register Roffset = G4_scratch; 2372 Register Rflags = Rcache; 2373 ByteSize cp_base_offset = ConstantPoolCache::base_offset(); 2374 2375 __ get_cache_and_index_at_bcp(Rcache, index, 1); 2376 jvmti_post_field_access(Rcache, index, /*is_static*/false, /*has_tos*/true); 2377 2378 __ ld_ptr(Rcache, cp_base_offset + ConstantPoolCacheEntry::f2_offset(), Roffset); 2379 2380 __ null_check(Otos_i); 2381 __ verify_oop(Otos_i); 2382 2383 Label exit; 2384 2385 Assembler::Membar_mask_bits membar_bits = 2386 Assembler::Membar_mask_bits(Assembler::LoadLoad | Assembler::LoadStore); 2387 if (__ membar_has_effect(membar_bits)) { 2388 // Get volatile flag 2389 __ ld_ptr(Rcache, cp_base_offset + ConstantPoolCacheEntry::f2_offset(), Rflags); 2390 __ set((1 << ConstantPoolCacheEntry::is_volatile_shift), Lscratch); 2391 } 2392 2393 switch (bytecode()) { 2394 case Bytecodes::_fast_bgetfield: 2395 __ ldsb(Otos_i, Roffset, Otos_i); 2396 break; 2397 case Bytecodes::_fast_cgetfield: 2398 __ lduh(Otos_i, Roffset, Otos_i); 2399 break; 2400 case Bytecodes::_fast_sgetfield: 2401 __ ldsh(Otos_i, Roffset, Otos_i); 2402 break; 2403 case Bytecodes::_fast_igetfield: 2404 __ ld(Otos_i, Roffset, Otos_i); 2405 break; 2406 case Bytecodes::_fast_lgetfield: 2407 __ ld_long(Otos_i, Roffset, Otos_l); 2408 break; 2409 case Bytecodes::_fast_fgetfield: 2410 __ ldf(FloatRegisterImpl::S, Otos_i, Roffset, Ftos_f); 2411 break; 2412 case Bytecodes::_fast_dgetfield: 2413 __ ldf(FloatRegisterImpl::D, Otos_i, Roffset, Ftos_d); 2414 break; 2415 case Bytecodes::_fast_agetfield: 2416 __ load_heap_oop(Otos_i, Roffset, Otos_i); 2417 break; 2418 default: 2419 ShouldNotReachHere(); 2420 } 2421 2422 if (__ membar_has_effect(membar_bits)) { 2423 __ btst(Lscratch, Rflags); 2424 __ br(Assembler::zero, false, Assembler::pt, exit); 2425 __ delayed()->nop(); 2426 volatile_barrier(membar_bits); 2427 __ bind(exit); 2428 } 2429 2430 if (state == atos) { 2431 __ verify_oop(Otos_i); // does not blow flags! 2432 } 2433 } 2434 2435 void TemplateTable::jvmti_post_fast_field_mod() { 2436 if (JvmtiExport::can_post_field_modification()) { 2437 // Check to see if a field modification watch has been set before we take 2438 // the time to call into the VM. 2439 Label done; 2440 AddressLiteral get_field_modification_count_addr(JvmtiExport::get_field_modification_count_addr()); 2441 __ load_contents(get_field_modification_count_addr, G4_scratch); 2442 __ cmp_and_br_short(G4_scratch, 0, Assembler::equal, Assembler::pt, done); 2443 __ pop_ptr(G4_scratch); // copy the object pointer from tos 2444 __ verify_oop(G4_scratch); 2445 __ push_ptr(G4_scratch); // put the object pointer back on tos 2446 __ get_cache_entry_pointer_at_bcp(G1_scratch, G3_scratch, 1); 2447 // Save tos values before call_VM() clobbers them. Since we have 2448 // to do it for every data type, we use the saved values as the 2449 // jvalue object. 2450 switch (bytecode()) { // save tos values before call_VM() clobbers them 2451 case Bytecodes::_fast_aputfield: __ push_ptr(Otos_i); break; 2452 case Bytecodes::_fast_bputfield: // fall through 2453 case Bytecodes::_fast_sputfield: // fall through 2454 case Bytecodes::_fast_cputfield: // fall through 2455 case Bytecodes::_fast_iputfield: __ push_i(Otos_i); break; 2456 case Bytecodes::_fast_dputfield: __ push_d(Ftos_d); break; 2457 case Bytecodes::_fast_fputfield: __ push_f(Ftos_f); break; 2458 // get words in right order for use as jvalue object 2459 case Bytecodes::_fast_lputfield: __ push_l(Otos_l); break; 2460 } 2461 // setup pointer to jvalue object 2462 __ mov(Lesp, G3_scratch); __ inc(G3_scratch, wordSize); 2463 // G4_scratch: object pointer 2464 // G1_scratch: cache entry pointer 2465 // G3_scratch: jvalue object on the stack 2466 __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::post_field_modification), G4_scratch, G1_scratch, G3_scratch); 2467 switch (bytecode()) { // restore tos values 2468 case Bytecodes::_fast_aputfield: __ pop_ptr(Otos_i); break; 2469 case Bytecodes::_fast_bputfield: // fall through 2470 case Bytecodes::_fast_sputfield: // fall through 2471 case Bytecodes::_fast_cputfield: // fall through 2472 case Bytecodes::_fast_iputfield: __ pop_i(Otos_i); break; 2473 case Bytecodes::_fast_dputfield: __ pop_d(Ftos_d); break; 2474 case Bytecodes::_fast_fputfield: __ pop_f(Ftos_f); break; 2475 case Bytecodes::_fast_lputfield: __ pop_l(Otos_l); break; 2476 } 2477 __ bind(done); 2478 } 2479 } 2480 2481 // The registers Rcache and index expected to be set before call. 2482 // The function may destroy various registers, just not the Rcache and index registers. 2483 void TemplateTable::jvmti_post_field_mod(Register Rcache, Register index, bool is_static) { 2484 ByteSize cp_base_offset = ConstantPoolCache::base_offset(); 2485 2486 if (JvmtiExport::can_post_field_modification()) { 2487 // Check to see if a field modification watch has been set before we take 2488 // the time to call into the VM. 2489 Label Label1; 2490 assert_different_registers(Rcache, index, G1_scratch); 2491 AddressLiteral get_field_modification_count_addr(JvmtiExport::get_field_modification_count_addr()); 2492 __ load_contents(get_field_modification_count_addr, G1_scratch); 2493 __ cmp_and_br_short(G1_scratch, 0, Assembler::zero, Assembler::pt, Label1); 2494 2495 // The Rcache and index registers have been already set. 2496 // This allows to eliminate this call but the Rcache and index 2497 // registers must be correspondingly used after this line. 2498 __ get_cache_and_index_at_bcp(G1_scratch, G4_scratch, 1); 2499 2500 __ add(G1_scratch, in_bytes(cp_base_offset), G3_scratch); 2501 if (is_static) { 2502 // Life is simple. Null out the object pointer. 2503 __ clr(G4_scratch); 2504 } else { 2505 Register Rflags = G1_scratch; 2506 // Life is harder. The stack holds the value on top, followed by the 2507 // object. We don't know the size of the value, though; it could be 2508 // one or two words depending on its type. As a result, we must find 2509 // the type to determine where the object is. 2510 2511 Label two_word, valsizeknown; 2512 __ ld_ptr(G1_scratch, cp_base_offset + ConstantPoolCacheEntry::flags_offset(), Rflags); 2513 __ mov(Lesp, G4_scratch); 2514 __ srl(Rflags, ConstantPoolCacheEntry::tos_state_shift, Rflags); 2515 // Make sure we don't need to mask Rflags after the above shift 2516 ConstantPoolCacheEntry::verify_tos_state_shift(); 2517 __ cmp(Rflags, ltos); 2518 __ br(Assembler::equal, false, Assembler::pt, two_word); 2519 __ delayed()->cmp(Rflags, dtos); 2520 __ br(Assembler::equal, false, Assembler::pt, two_word); 2521 __ delayed()->nop(); 2522 __ inc(G4_scratch, Interpreter::expr_offset_in_bytes(1)); 2523 __ ba_short(valsizeknown); 2524 __ bind(two_word); 2525 2526 __ inc(G4_scratch, Interpreter::expr_offset_in_bytes(2)); 2527 2528 __ bind(valsizeknown); 2529 // setup object pointer 2530 __ ld_ptr(G4_scratch, 0, G4_scratch); 2531 __ verify_oop(G4_scratch); 2532 } 2533 // setup pointer to jvalue object 2534 __ mov(Lesp, G1_scratch); __ inc(G1_scratch, wordSize); 2535 // G4_scratch: object pointer or NULL if static 2536 // G3_scratch: cache entry pointer 2537 // G1_scratch: jvalue object on the stack 2538 __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::post_field_modification), 2539 G4_scratch, G3_scratch, G1_scratch); 2540 __ get_cache_and_index_at_bcp(Rcache, index, 1); 2541 __ bind(Label1); 2542 } 2543 } 2544 2545 void TemplateTable::pop_and_check_object(Register r) { 2546 __ pop_ptr(r); 2547 __ null_check(r); // for field access must check obj. 2548 __ verify_oop(r); 2549 } 2550 2551 void TemplateTable::putfield_or_static(int byte_no, bool is_static, RewriteControl rc) { 2552 transition(vtos, vtos); 2553 Register Rcache = G3_scratch; 2554 Register index = G4_scratch; 2555 Register Rclass = Rcache; 2556 Register Roffset= G4_scratch; 2557 Register Rflags = G1_scratch; 2558 ByteSize cp_base_offset = ConstantPoolCache::base_offset(); 2559 2560 resolve_cache_and_index(byte_no, Rcache, index, sizeof(u2)); 2561 jvmti_post_field_mod(Rcache, index, is_static); 2562 load_field_cp_cache_entry(Rclass, Rcache, index, Roffset, Rflags, is_static); 2563 2564 Assembler::Membar_mask_bits read_bits = 2565 Assembler::Membar_mask_bits(Assembler::LoadStore | Assembler::StoreStore); 2566 Assembler::Membar_mask_bits write_bits = Assembler::StoreLoad; 2567 2568 Label notVolatile, checkVolatile, exit; 2569 if (__ membar_has_effect(read_bits) || __ membar_has_effect(write_bits)) { 2570 __ set((1 << ConstantPoolCacheEntry::is_volatile_shift), Lscratch); 2571 __ and3(Rflags, Lscratch, Lscratch); 2572 2573 if (__ membar_has_effect(read_bits)) { 2574 __ cmp_and_br_short(Lscratch, 0, Assembler::equal, Assembler::pt, notVolatile); 2575 volatile_barrier(read_bits); 2576 __ bind(notVolatile); 2577 } 2578 } 2579 2580 __ srl(Rflags, ConstantPoolCacheEntry::tos_state_shift, Rflags); 2581 // Make sure we don't need to mask Rflags after the above shift 2582 ConstantPoolCacheEntry::verify_tos_state_shift(); 2583 2584 // compute field type 2585 Label notInt, notShort, notChar, notObj, notByte, notLong, notFloat; 2586 2587 if (is_static) { 2588 // putstatic with object type most likely, check that first 2589 __ cmp(Rflags, atos); 2590 __ br(Assembler::notEqual, false, Assembler::pt, notObj); 2591 __ delayed()->cmp(Rflags, itos); 2592 2593 // atos 2594 { 2595 __ pop_ptr(); 2596 __ verify_oop(Otos_i); 2597 do_oop_store(_masm, Rclass, Roffset, 0, Otos_i, G1_scratch, _bs->kind(), false); 2598 __ ba(checkVolatile); 2599 __ delayed()->tst(Lscratch); 2600 } 2601 2602 __ bind(notObj); 2603 // cmp(Rflags, itos); 2604 __ br(Assembler::notEqual, false, Assembler::pt, notInt); 2605 __ delayed()->cmp(Rflags, btos); 2606 2607 // itos 2608 { 2609 __ pop_i(); 2610 __ st(Otos_i, Rclass, Roffset); 2611 __ ba(checkVolatile); 2612 __ delayed()->tst(Lscratch); 2613 } 2614 2615 __ bind(notInt); 2616 } else { 2617 // putfield with int type most likely, check that first 2618 __ cmp(Rflags, itos); 2619 __ br(Assembler::notEqual, false, Assembler::pt, notInt); 2620 __ delayed()->cmp(Rflags, atos); 2621 2622 // itos 2623 { 2624 __ pop_i(); 2625 pop_and_check_object(Rclass); 2626 __ st(Otos_i, Rclass, Roffset); 2627 if (rc == may_rewrite) patch_bytecode(Bytecodes::_fast_iputfield, G3_scratch, G4_scratch, true, byte_no); 2628 __ ba(checkVolatile); 2629 __ delayed()->tst(Lscratch); 2630 } 2631 2632 __ bind(notInt); 2633 // cmp(Rflags, atos); 2634 __ br(Assembler::notEqual, false, Assembler::pt, notObj); 2635 __ delayed()->cmp(Rflags, btos); 2636 2637 // atos 2638 { 2639 __ pop_ptr(); 2640 pop_and_check_object(Rclass); 2641 __ verify_oop(Otos_i); 2642 do_oop_store(_masm, Rclass, Roffset, 0, Otos_i, G1_scratch, _bs->kind(), false); 2643 if (rc == may_rewrite) patch_bytecode(Bytecodes::_fast_aputfield, G3_scratch, G4_scratch, true, byte_no); 2644 __ ba(checkVolatile); 2645 __ delayed()->tst(Lscratch); 2646 } 2647 2648 __ bind(notObj); 2649 } 2650 2651 // cmp(Rflags, btos); 2652 __ br(Assembler::notEqual, false, Assembler::pt, notByte); 2653 __ delayed()->cmp(Rflags, ltos); 2654 2655 // btos 2656 { 2657 __ pop_i(); 2658 if (!is_static) pop_and_check_object(Rclass); 2659 __ stb(Otos_i, Rclass, Roffset); 2660 if (!is_static && rc == may_rewrite) { 2661 patch_bytecode(Bytecodes::_fast_bputfield, G3_scratch, G4_scratch, true, byte_no); 2662 } 2663 __ ba(checkVolatile); 2664 __ delayed()->tst(Lscratch); 2665 } 2666 2667 __ bind(notByte); 2668 // cmp(Rflags, ltos); 2669 __ br(Assembler::notEqual, false, Assembler::pt, notLong); 2670 __ delayed()->cmp(Rflags, ctos); 2671 2672 // ltos 2673 { 2674 __ pop_l(); 2675 if (!is_static) pop_and_check_object(Rclass); 2676 __ st_long(Otos_l, Rclass, Roffset); 2677 if (!is_static && rc == may_rewrite) { 2678 patch_bytecode(Bytecodes::_fast_lputfield, G3_scratch, G4_scratch, true, byte_no); 2679 } 2680 __ ba(checkVolatile); 2681 __ delayed()->tst(Lscratch); 2682 } 2683 2684 __ bind(notLong); 2685 // cmp(Rflags, ctos); 2686 __ br(Assembler::notEqual, false, Assembler::pt, notChar); 2687 __ delayed()->cmp(Rflags, stos); 2688 2689 // ctos (char) 2690 { 2691 __ pop_i(); 2692 if (!is_static) pop_and_check_object(Rclass); 2693 __ sth(Otos_i, Rclass, Roffset); 2694 if (!is_static && rc == may_rewrite) { 2695 patch_bytecode(Bytecodes::_fast_cputfield, G3_scratch, G4_scratch, true, byte_no); 2696 } 2697 __ ba(checkVolatile); 2698 __ delayed()->tst(Lscratch); 2699 } 2700 2701 __ bind(notChar); 2702 // cmp(Rflags, stos); 2703 __ br(Assembler::notEqual, false, Assembler::pt, notShort); 2704 __ delayed()->cmp(Rflags, ftos); 2705 2706 // stos (short) 2707 { 2708 __ pop_i(); 2709 if (!is_static) pop_and_check_object(Rclass); 2710 __ sth(Otos_i, Rclass, Roffset); 2711 if (!is_static && rc == may_rewrite) { 2712 patch_bytecode(Bytecodes::_fast_sputfield, G3_scratch, G4_scratch, true, byte_no); 2713 } 2714 __ ba(checkVolatile); 2715 __ delayed()->tst(Lscratch); 2716 } 2717 2718 __ bind(notShort); 2719 // cmp(Rflags, ftos); 2720 __ br(Assembler::notZero, false, Assembler::pt, notFloat); 2721 __ delayed()->nop(); 2722 2723 // ftos 2724 { 2725 __ pop_f(); 2726 if (!is_static) pop_and_check_object(Rclass); 2727 __ stf(FloatRegisterImpl::S, Ftos_f, Rclass, Roffset); 2728 if (!is_static && rc == may_rewrite) { 2729 patch_bytecode(Bytecodes::_fast_fputfield, G3_scratch, G4_scratch, true, byte_no); 2730 } 2731 __ ba(checkVolatile); 2732 __ delayed()->tst(Lscratch); 2733 } 2734 2735 __ bind(notFloat); 2736 2737 // dtos 2738 { 2739 __ pop_d(); 2740 if (!is_static) pop_and_check_object(Rclass); 2741 __ stf(FloatRegisterImpl::D, Ftos_d, Rclass, Roffset); 2742 if (!is_static && rc == may_rewrite) { 2743 patch_bytecode(Bytecodes::_fast_dputfield, G3_scratch, G4_scratch, true, byte_no); 2744 } 2745 } 2746 2747 __ bind(checkVolatile); 2748 __ tst(Lscratch); 2749 2750 if (__ membar_has_effect(write_bits)) { 2751 // __ tst(Lscratch); in delay slot 2752 __ br(Assembler::zero, false, Assembler::pt, exit); 2753 __ delayed()->nop(); 2754 volatile_barrier(Assembler::StoreLoad); 2755 __ bind(exit); 2756 } 2757 } 2758 2759 void TemplateTable::fast_storefield(TosState state) { 2760 transition(state, vtos); 2761 Register Rcache = G3_scratch; 2762 Register Rclass = Rcache; 2763 Register Roffset= G4_scratch; 2764 Register Rflags = G1_scratch; 2765 ByteSize cp_base_offset = ConstantPoolCache::base_offset(); 2766 2767 jvmti_post_fast_field_mod(); 2768 2769 __ get_cache_and_index_at_bcp(Rcache, G4_scratch, 1); 2770 2771 Assembler::Membar_mask_bits read_bits = 2772 Assembler::Membar_mask_bits(Assembler::LoadStore | Assembler::StoreStore); 2773 Assembler::Membar_mask_bits write_bits = Assembler::StoreLoad; 2774 2775 Label notVolatile, checkVolatile, exit; 2776 if (__ membar_has_effect(read_bits) || __ membar_has_effect(write_bits)) { 2777 __ ld_ptr(Rcache, cp_base_offset + ConstantPoolCacheEntry::flags_offset(), Rflags); 2778 __ set((1 << ConstantPoolCacheEntry::is_volatile_shift), Lscratch); 2779 __ and3(Rflags, Lscratch, Lscratch); 2780 if (__ membar_has_effect(read_bits)) { 2781 __ cmp_and_br_short(Lscratch, 0, Assembler::equal, Assembler::pt, notVolatile); 2782 volatile_barrier(read_bits); 2783 __ bind(notVolatile); 2784 } 2785 } 2786 2787 __ ld_ptr(Rcache, cp_base_offset + ConstantPoolCacheEntry::f2_offset(), Roffset); 2788 pop_and_check_object(Rclass); 2789 2790 switch (bytecode()) { 2791 case Bytecodes::_fast_bputfield: __ stb(Otos_i, Rclass, Roffset); break; 2792 case Bytecodes::_fast_cputfield: /* fall through */ 2793 case Bytecodes::_fast_sputfield: __ sth(Otos_i, Rclass, Roffset); break; 2794 case Bytecodes::_fast_iputfield: __ st(Otos_i, Rclass, Roffset); break; 2795 case Bytecodes::_fast_lputfield: __ st_long(Otos_l, Rclass, Roffset); break; 2796 case Bytecodes::_fast_fputfield: 2797 __ stf(FloatRegisterImpl::S, Ftos_f, Rclass, Roffset); 2798 break; 2799 case Bytecodes::_fast_dputfield: 2800 __ stf(FloatRegisterImpl::D, Ftos_d, Rclass, Roffset); 2801 break; 2802 case Bytecodes::_fast_aputfield: 2803 do_oop_store(_masm, Rclass, Roffset, 0, Otos_i, G1_scratch, _bs->kind(), false); 2804 break; 2805 default: 2806 ShouldNotReachHere(); 2807 } 2808 2809 if (__ membar_has_effect(write_bits)) { 2810 __ cmp_and_br_short(Lscratch, 0, Assembler::equal, Assembler::pt, exit); 2811 volatile_barrier(Assembler::StoreLoad); 2812 __ bind(exit); 2813 } 2814 } 2815 2816 void TemplateTable::putfield(int byte_no) { 2817 putfield_or_static(byte_no, false); 2818 } 2819 2820 void TemplateTable::nofast_putfield(int byte_no) { 2821 putfield_or_static(byte_no, false, may_not_rewrite); 2822 } 2823 2824 void TemplateTable::putstatic(int byte_no) { 2825 putfield_or_static(byte_no, true); 2826 } 2827 2828 void TemplateTable::fast_xaccess(TosState state) { 2829 transition(vtos, state); 2830 Register Rcache = G3_scratch; 2831 Register Roffset = G4_scratch; 2832 Register Rflags = G4_scratch; 2833 Register Rreceiver = Lscratch; 2834 2835 __ ld_ptr(Llocals, 0, Rreceiver); 2836 2837 // access constant pool cache (is resolved) 2838 __ get_cache_and_index_at_bcp(Rcache, G4_scratch, 2); 2839 __ ld_ptr(Rcache, ConstantPoolCache::base_offset() + ConstantPoolCacheEntry::f2_offset(), Roffset); 2840 __ add(Lbcp, 1, Lbcp); // needed to report exception at the correct bcp 2841 2842 __ verify_oop(Rreceiver); 2843 __ null_check(Rreceiver); 2844 if (state == atos) { 2845 __ load_heap_oop(Rreceiver, Roffset, Otos_i); 2846 } else if (state == itos) { 2847 __ ld (Rreceiver, Roffset, Otos_i) ; 2848 } else if (state == ftos) { 2849 __ ldf(FloatRegisterImpl::S, Rreceiver, Roffset, Ftos_f); 2850 } else { 2851 ShouldNotReachHere(); 2852 } 2853 2854 Assembler::Membar_mask_bits membar_bits = 2855 Assembler::Membar_mask_bits(Assembler::LoadLoad | Assembler::LoadStore); 2856 if (__ membar_has_effect(membar_bits)) { 2857 2858 // Get is_volatile value in Rflags and check if membar is needed 2859 __ ld_ptr(Rcache, ConstantPoolCache::base_offset() + ConstantPoolCacheEntry::flags_offset(), Rflags); 2860 2861 // Test volatile 2862 Label notVolatile; 2863 __ set((1 << ConstantPoolCacheEntry::is_volatile_shift), Lscratch); 2864 __ btst(Rflags, Lscratch); 2865 __ br(Assembler::zero, false, Assembler::pt, notVolatile); 2866 __ delayed()->nop(); 2867 volatile_barrier(membar_bits); 2868 __ bind(notVolatile); 2869 } 2870 2871 __ interp_verify_oop(Otos_i, state, __FILE__, __LINE__); 2872 __ sub(Lbcp, 1, Lbcp); 2873 } 2874 2875 //---------------------------------------------------------------------------------------------------- 2876 // Calls 2877 2878 void TemplateTable::count_calls(Register method, Register temp) { 2879 // implemented elsewhere 2880 ShouldNotReachHere(); 2881 } 2882 2883 void TemplateTable::prepare_invoke(int byte_no, 2884 Register method, // linked method (or i-klass) 2885 Register ra, // return address 2886 Register index, // itable index, MethodType, etc. 2887 Register recv, // if caller wants to see it 2888 Register flags // if caller wants to test it 2889 ) { 2890 // determine flags 2891 const Bytecodes::Code code = bytecode(); 2892 const bool is_invokeinterface = code == Bytecodes::_invokeinterface; 2893 const bool is_invokedynamic = code == Bytecodes::_invokedynamic; 2894 const bool is_invokehandle = code == Bytecodes::_invokehandle; 2895 const bool is_invokevirtual = code == Bytecodes::_invokevirtual; 2896 const bool is_invokespecial = code == Bytecodes::_invokespecial; 2897 const bool load_receiver = (recv != noreg); 2898 assert(load_receiver == (code != Bytecodes::_invokestatic && code != Bytecodes::_invokedynamic), ""); 2899 assert(recv == noreg || recv == O0, ""); 2900 assert(flags == noreg || flags == O1, ""); 2901 2902 // setup registers & access constant pool cache 2903 if (recv == noreg) recv = O0; 2904 if (flags == noreg) flags = O1; 2905 const Register temp = O2; 2906 assert_different_registers(method, ra, index, recv, flags, temp); 2907 2908 load_invoke_cp_cache_entry(byte_no, method, index, flags, is_invokevirtual, false, is_invokedynamic); 2909 2910 __ mov(SP, O5_savedSP); // record SP that we wanted the callee to restore 2911 2912 // maybe push appendix to arguments 2913 if (is_invokedynamic || is_invokehandle) { 2914 Label L_no_push; 2915 __ set((1 << ConstantPoolCacheEntry::has_appendix_shift), temp); 2916 __ btst(flags, temp); 2917 __ br(Assembler::zero, false, Assembler::pt, L_no_push); 2918 __ delayed()->nop(); 2919 // Push the appendix as a trailing parameter. 2920 // This must be done before we get the receiver, 2921 // since the parameter_size includes it. 2922 assert(ConstantPoolCacheEntry::_indy_resolved_references_appendix_offset == 0, "appendix expected at index+0"); 2923 __ load_resolved_reference_at_index(temp, index); 2924 __ verify_oop(temp); 2925 __ push_ptr(temp); // push appendix (MethodType, CallSite, etc.) 2926 __ bind(L_no_push); 2927 } 2928 2929 // load receiver if needed (after appendix is pushed so parameter size is correct) 2930 if (load_receiver) { 2931 __ and3(flags, ConstantPoolCacheEntry::parameter_size_mask, temp); // get parameter size 2932 __ load_receiver(temp, recv); // __ argument_address uses Gargs but we need Lesp 2933 __ verify_oop(recv); 2934 } 2935 2936 // compute return type 2937 __ srl(flags, ConstantPoolCacheEntry::tos_state_shift, ra); 2938 // Make sure we don't need to mask flags after the above shift 2939 ConstantPoolCacheEntry::verify_tos_state_shift(); 2940 // load return address 2941 { 2942 const address table_addr = (address) Interpreter::invoke_return_entry_table_for(code); 2943 AddressLiteral table(table_addr); 2944 __ set(table, temp); 2945 __ sll(ra, LogBytesPerWord, ra); 2946 __ ld_ptr(Address(temp, ra), ra); 2947 } 2948 } 2949 2950 2951 void TemplateTable::generate_vtable_call(Register Rrecv, Register Rindex, Register Rret) { 2952 Register Rcall = Rindex; 2953 assert_different_registers(Rcall, G5_method, Gargs, Rret); 2954 2955 // get target Method* & entry point 2956 __ lookup_virtual_method(Rrecv, Rindex, G5_method); 2957 __ profile_arguments_type(G5_method, Rcall, Gargs, true); 2958 __ call_from_interpreter(Rcall, Gargs, Rret); 2959 } 2960 2961 void TemplateTable::invokevirtual(int byte_no) { 2962 transition(vtos, vtos); 2963 assert(byte_no == f2_byte, "use this argument"); 2964 2965 Register Rscratch = G3_scratch; 2966 Register Rtemp = G4_scratch; 2967 Register Rret = Lscratch; 2968 Register O0_recv = O0; 2969 Label notFinal; 2970 2971 load_invoke_cp_cache_entry(byte_no, G5_method, noreg, Rret, true, false, false); 2972 __ mov(SP, O5_savedSP); // record SP that we wanted the callee to restore 2973 2974 // Check for vfinal 2975 __ set((1 << ConstantPoolCacheEntry::is_vfinal_shift), G4_scratch); 2976 __ btst(Rret, G4_scratch); 2977 __ br(Assembler::zero, false, Assembler::pt, notFinal); 2978 __ delayed()->and3(Rret, 0xFF, G4_scratch); // gets number of parameters 2979 2980 if (RewriteBytecodes && !UseSharedSpaces) { 2981 patch_bytecode(Bytecodes::_fast_invokevfinal, Rscratch, Rtemp); 2982 } 2983 2984 invokevfinal_helper(Rscratch, Rret); 2985 2986 __ bind(notFinal); 2987 2988 __ mov(G5_method, Rscratch); // better scratch register 2989 __ load_receiver(G4_scratch, O0_recv); // gets receiverOop 2990 // receiver is in O0_recv 2991 __ verify_oop(O0_recv); 2992 2993 // get return address 2994 AddressLiteral table(Interpreter::invoke_return_entry_table()); 2995 __ set(table, Rtemp); 2996 __ srl(Rret, ConstantPoolCacheEntry::tos_state_shift, Rret); // get return type 2997 // Make sure we don't need to mask Rret after the above shift 2998 ConstantPoolCacheEntry::verify_tos_state_shift(); 2999 __ sll(Rret, LogBytesPerWord, Rret); 3000 __ ld_ptr(Rtemp, Rret, Rret); // get return address 3001 3002 // get receiver klass 3003 __ null_check(O0_recv, oopDesc::klass_offset_in_bytes()); 3004 __ load_klass(O0_recv, O0_recv); 3005 __ verify_klass_ptr(O0_recv); 3006 3007 __ profile_virtual_call(O0_recv, O4); 3008 3009 generate_vtable_call(O0_recv, Rscratch, Rret); 3010 } 3011 3012 void TemplateTable::fast_invokevfinal(int byte_no) { 3013 transition(vtos, vtos); 3014 assert(byte_no == f2_byte, "use this argument"); 3015 3016 load_invoke_cp_cache_entry(byte_no, G5_method, noreg, Lscratch, true, 3017 /*is_invokevfinal*/true, false); 3018 __ mov(SP, O5_savedSP); // record SP that we wanted the callee to restore 3019 invokevfinal_helper(G3_scratch, Lscratch); 3020 } 3021 3022 void TemplateTable::invokevfinal_helper(Register Rscratch, Register Rret) { 3023 Register Rtemp = G4_scratch; 3024 3025 // Load receiver from stack slot 3026 __ ld_ptr(G5_method, in_bytes(Method::const_offset()), G4_scratch); 3027 __ lduh(G4_scratch, in_bytes(ConstMethod::size_of_parameters_offset()), G4_scratch); 3028 __ load_receiver(G4_scratch, O0); 3029 3030 // receiver NULL check 3031 __ null_check(O0); 3032 3033 __ profile_final_call(O4); 3034 __ profile_arguments_type(G5_method, Rscratch, Gargs, true); 3035 3036 // get return address 3037 AddressLiteral table(Interpreter::invoke_return_entry_table()); 3038 __ set(table, Rtemp); 3039 __ srl(Rret, ConstantPoolCacheEntry::tos_state_shift, Rret); // get return type 3040 // Make sure we don't need to mask Rret after the above shift 3041 ConstantPoolCacheEntry::verify_tos_state_shift(); 3042 __ sll(Rret, LogBytesPerWord, Rret); 3043 __ ld_ptr(Rtemp, Rret, Rret); // get return address 3044 3045 3046 // do the call 3047 __ call_from_interpreter(Rscratch, Gargs, Rret); 3048 } 3049 3050 3051 void TemplateTable::invokespecial(int byte_no) { 3052 transition(vtos, vtos); 3053 assert(byte_no == f1_byte, "use this argument"); 3054 3055 const Register Rret = Lscratch; 3056 const Register O0_recv = O0; 3057 const Register Rscratch = G3_scratch; 3058 3059 prepare_invoke(byte_no, G5_method, Rret, noreg, O0_recv); // get receiver also for null check 3060 __ null_check(O0_recv); 3061 3062 // do the call 3063 __ profile_call(O4); 3064 __ profile_arguments_type(G5_method, Rscratch, Gargs, false); 3065 __ call_from_interpreter(Rscratch, Gargs, Rret); 3066 } 3067 3068 3069 void TemplateTable::invokestatic(int byte_no) { 3070 transition(vtos, vtos); 3071 assert(byte_no == f1_byte, "use this argument"); 3072 3073 const Register Rret = Lscratch; 3074 const Register Rscratch = G3_scratch; 3075 3076 prepare_invoke(byte_no, G5_method, Rret); // get f1 Method* 3077 3078 // do the call 3079 __ profile_call(O4); 3080 __ profile_arguments_type(G5_method, Rscratch, Gargs, false); 3081 __ call_from_interpreter(Rscratch, Gargs, Rret); 3082 } 3083 3084 void TemplateTable::invokeinterface_object_method(Register RKlass, 3085 Register Rcall, 3086 Register Rret, 3087 Register Rflags) { 3088 Register Rscratch = G4_scratch; 3089 Register Rindex = Lscratch; 3090 3091 assert_different_registers(Rscratch, Rindex, Rret); 3092 3093 Label notFinal; 3094 3095 // Check for vfinal 3096 __ set((1 << ConstantPoolCacheEntry::is_vfinal_shift), Rscratch); 3097 __ btst(Rflags, Rscratch); 3098 __ br(Assembler::zero, false, Assembler::pt, notFinal); 3099 __ delayed()->nop(); 3100 3101 __ profile_final_call(O4); 3102 3103 // do the call - the index (f2) contains the Method* 3104 assert_different_registers(G5_method, Gargs, Rcall); 3105 __ mov(Rindex, G5_method); 3106 __ profile_arguments_type(G5_method, Rcall, Gargs, true); 3107 __ call_from_interpreter(Rcall, Gargs, Rret); 3108 __ bind(notFinal); 3109 3110 __ profile_virtual_call(RKlass, O4); 3111 generate_vtable_call(RKlass, Rindex, Rret); 3112 } 3113 3114 3115 void TemplateTable::invokeinterface(int byte_no) { 3116 transition(vtos, vtos); 3117 assert(byte_no == f1_byte, "use this argument"); 3118 3119 const Register Rinterface = G1_scratch; 3120 const Register Rret = G3_scratch; 3121 const Register Rindex = Lscratch; 3122 const Register O0_recv = O0; 3123 const Register O1_flags = O1; 3124 const Register O2_Klass = O2; 3125 const Register Rscratch = G4_scratch; 3126 assert_different_registers(Rscratch, G5_method); 3127 3128 prepare_invoke(byte_no, Rinterface, Rret, Rindex, O0_recv, O1_flags); 3129 3130 // get receiver klass 3131 __ null_check(O0_recv, oopDesc::klass_offset_in_bytes()); 3132 __ load_klass(O0_recv, O2_Klass); 3133 3134 // Special case of invokeinterface called for virtual method of 3135 // java.lang.Object. See cpCacheOop.cpp for details. 3136 // This code isn't produced by javac, but could be produced by 3137 // another compliant java compiler. 3138 Label notMethod; 3139 __ set((1 << ConstantPoolCacheEntry::is_forced_virtual_shift), Rscratch); 3140 __ btst(O1_flags, Rscratch); 3141 __ br(Assembler::zero, false, Assembler::pt, notMethod); 3142 __ delayed()->nop(); 3143 3144 invokeinterface_object_method(O2_Klass, Rinterface, Rret, O1_flags); 3145 3146 __ bind(notMethod); 3147 3148 __ profile_virtual_call(O2_Klass, O4); 3149 3150 // 3151 // find entry point to call 3152 // 3153 3154 // compute start of first itableOffsetEntry (which is at end of vtable) 3155 const int base = InstanceKlass::vtable_start_offset() * wordSize; 3156 Label search; 3157 Register Rtemp = O1_flags; 3158 3159 __ ld(O2_Klass, InstanceKlass::vtable_length_offset() * wordSize, Rtemp); 3160 if (align_object_offset(1) > 1) { 3161 __ round_to(Rtemp, align_object_offset(1)); 3162 } 3163 __ sll(Rtemp, LogBytesPerWord, Rtemp); // Rscratch *= 4; 3164 if (Assembler::is_simm13(base)) { 3165 __ add(Rtemp, base, Rtemp); 3166 } else { 3167 __ set(base, Rscratch); 3168 __ add(Rscratch, Rtemp, Rtemp); 3169 } 3170 __ add(O2_Klass, Rtemp, Rscratch); 3171 3172 __ bind(search); 3173 3174 __ ld_ptr(Rscratch, itableOffsetEntry::interface_offset_in_bytes(), Rtemp); 3175 { 3176 Label ok; 3177 3178 // Check that entry is non-null. Null entries are probably a bytecode 3179 // problem. If the interface isn't implemented by the receiver class, 3180 // the VM should throw IncompatibleClassChangeError. linkResolver checks 3181 // this too but that's only if the entry isn't already resolved, so we 3182 // need to check again. 3183 __ br_notnull_short( Rtemp, Assembler::pt, ok); 3184 call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::throw_IncompatibleClassChangeError)); 3185 __ should_not_reach_here(); 3186 __ bind(ok); 3187 } 3188 3189 __ cmp(Rinterface, Rtemp); 3190 __ brx(Assembler::notEqual, true, Assembler::pn, search); 3191 __ delayed()->add(Rscratch, itableOffsetEntry::size() * wordSize, Rscratch); 3192 3193 // entry found and Rscratch points to it 3194 __ ld(Rscratch, itableOffsetEntry::offset_offset_in_bytes(), Rscratch); 3195 3196 assert(itableMethodEntry::method_offset_in_bytes() == 0, "adjust instruction below"); 3197 __ sll(Rindex, exact_log2(itableMethodEntry::size() * wordSize), Rindex); // Rindex *= 8; 3198 __ add(Rscratch, Rindex, Rscratch); 3199 __ ld_ptr(O2_Klass, Rscratch, G5_method); 3200 3201 // Check for abstract method error. 3202 { 3203 Label ok; 3204 __ br_notnull_short(G5_method, Assembler::pt, ok); 3205 call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::throw_AbstractMethodError)); 3206 __ should_not_reach_here(); 3207 __ bind(ok); 3208 } 3209 3210 Register Rcall = Rinterface; 3211 assert_different_registers(Rcall, G5_method, Gargs, Rret); 3212 3213 __ profile_arguments_type(G5_method, Rcall, Gargs, true); 3214 __ call_from_interpreter(Rcall, Gargs, Rret); 3215 } 3216 3217 void TemplateTable::invokehandle(int byte_no) { 3218 transition(vtos, vtos); 3219 assert(byte_no == f1_byte, "use this argument"); 3220 3221 const Register Rret = Lscratch; 3222 const Register G4_mtype = G4_scratch; 3223 const Register O0_recv = O0; 3224 const Register Rscratch = G3_scratch; 3225 3226 prepare_invoke(byte_no, G5_method, Rret, G4_mtype, O0_recv); 3227 __ null_check(O0_recv); 3228 3229 // G4: MethodType object (from cpool->resolved_references[f1], if necessary) 3230 // G5: MH.invokeExact_MT method (from f2) 3231 3232 // Note: G4_mtype is already pushed (if necessary) by prepare_invoke 3233 3234 // do the call 3235 __ verify_oop(G4_mtype); 3236 __ profile_final_call(O4); // FIXME: profile the LambdaForm also 3237 __ profile_arguments_type(G5_method, Rscratch, Gargs, true); 3238 __ call_from_interpreter(Rscratch, Gargs, Rret); 3239 } 3240 3241 3242 void TemplateTable::invokedynamic(int byte_no) { 3243 transition(vtos, vtos); 3244 assert(byte_no == f1_byte, "use this argument"); 3245 3246 const Register Rret = Lscratch; 3247 const Register G4_callsite = G4_scratch; 3248 const Register Rscratch = G3_scratch; 3249 3250 prepare_invoke(byte_no, G5_method, Rret, G4_callsite); 3251 3252 // G4: CallSite object (from cpool->resolved_references[f1]) 3253 // G5: MH.linkToCallSite method (from f2) 3254 3255 // Note: G4_callsite is already pushed by prepare_invoke 3256 3257 // %%% should make a type profile for any invokedynamic that takes a ref argument 3258 // profile this call 3259 __ profile_call(O4); 3260 3261 // do the call 3262 __ verify_oop(G4_callsite); 3263 __ profile_arguments_type(G5_method, Rscratch, Gargs, false); 3264 __ call_from_interpreter(Rscratch, Gargs, Rret); 3265 } 3266 3267 3268 //---------------------------------------------------------------------------------------------------- 3269 // Allocation 3270 3271 void TemplateTable::_new() { 3272 transition(vtos, atos); 3273 3274 Label slow_case; 3275 Label done; 3276 Label initialize_header; 3277 Label initialize_object; // including clearing the fields 3278 3279 Register RallocatedObject = Otos_i; 3280 Register RinstanceKlass = O1; 3281 Register Roffset = O3; 3282 Register Rscratch = O4; 3283 3284 __ get_2_byte_integer_at_bcp(1, Rscratch, Roffset, InterpreterMacroAssembler::Unsigned); 3285 __ get_cpool_and_tags(Rscratch, G3_scratch); 3286 // make sure the class we're about to instantiate has been resolved 3287 // This is done before loading InstanceKlass to be consistent with the order 3288 // how Constant Pool is updated (see ConstantPool::klass_at_put) 3289 __ add(G3_scratch, Array<u1>::base_offset_in_bytes(), G3_scratch); 3290 __ ldub(G3_scratch, Roffset, G3_scratch); 3291 __ cmp(G3_scratch, JVM_CONSTANT_Class); 3292 __ br(Assembler::notEqual, false, Assembler::pn, slow_case); 3293 __ delayed()->sll(Roffset, LogBytesPerWord, Roffset); 3294 // get InstanceKlass 3295 //__ sll(Roffset, LogBytesPerWord, Roffset); // executed in delay slot 3296 __ add(Roffset, sizeof(ConstantPool), Roffset); 3297 __ ld_ptr(Rscratch, Roffset, RinstanceKlass); 3298 3299 // make sure klass is fully initialized: 3300 __ ldub(RinstanceKlass, in_bytes(InstanceKlass::init_state_offset()), G3_scratch); 3301 __ cmp(G3_scratch, InstanceKlass::fully_initialized); 3302 __ br(Assembler::notEqual, false, Assembler::pn, slow_case); 3303 __ delayed()->ld(RinstanceKlass, in_bytes(Klass::layout_helper_offset()), Roffset); 3304 3305 // get instance_size in InstanceKlass (already aligned) 3306 //__ ld(RinstanceKlass, in_bytes(Klass::layout_helper_offset()), Roffset); 3307 3308 // make sure klass does not have has_finalizer, or is abstract, or interface or java/lang/Class 3309 __ btst(Klass::_lh_instance_slow_path_bit, Roffset); 3310 __ br(Assembler::notZero, false, Assembler::pn, slow_case); 3311 __ delayed()->nop(); 3312 3313 // allocate the instance 3314 // 1) Try to allocate in the TLAB 3315 // 2) if fail, and the TLAB is not full enough to discard, allocate in the shared Eden 3316 // 3) if the above fails (or is not applicable), go to a slow case 3317 // (creates a new TLAB, etc.) 3318 3319 const bool allow_shared_alloc = 3320 Universe::heap()->supports_inline_contig_alloc(); 3321 3322 if(UseTLAB) { 3323 Register RoldTopValue = RallocatedObject; 3324 Register RtlabWasteLimitValue = G3_scratch; 3325 Register RnewTopValue = G1_scratch; 3326 Register RendValue = Rscratch; 3327 Register RfreeValue = RnewTopValue; 3328 3329 // check if we can allocate in the TLAB 3330 __ ld_ptr(G2_thread, in_bytes(JavaThread::tlab_top_offset()), RoldTopValue); // sets up RalocatedObject 3331 __ ld_ptr(G2_thread, in_bytes(JavaThread::tlab_end_offset()), RendValue); 3332 __ add(RoldTopValue, Roffset, RnewTopValue); 3333 3334 // if there is enough space, we do not CAS and do not clear 3335 __ cmp(RnewTopValue, RendValue); 3336 if(ZeroTLAB) { 3337 // the fields have already been cleared 3338 __ brx(Assembler::lessEqualUnsigned, true, Assembler::pt, initialize_header); 3339 } else { 3340 // initialize both the header and fields 3341 __ brx(Assembler::lessEqualUnsigned, true, Assembler::pt, initialize_object); 3342 } 3343 __ delayed()->st_ptr(RnewTopValue, G2_thread, in_bytes(JavaThread::tlab_top_offset())); 3344 3345 if (allow_shared_alloc) { 3346 // Check if tlab should be discarded (refill_waste_limit >= free) 3347 __ ld_ptr(G2_thread, in_bytes(JavaThread::tlab_refill_waste_limit_offset()), RtlabWasteLimitValue); 3348 __ sub(RendValue, RoldTopValue, RfreeValue); 3349 #ifdef _LP64 3350 __ srlx(RfreeValue, LogHeapWordSize, RfreeValue); 3351 #else 3352 __ srl(RfreeValue, LogHeapWordSize, RfreeValue); 3353 #endif 3354 __ cmp_and_brx_short(RtlabWasteLimitValue, RfreeValue, Assembler::greaterEqualUnsigned, Assembler::pt, slow_case); // tlab waste is small 3355 3356 // increment waste limit to prevent getting stuck on this slow path 3357 __ add(RtlabWasteLimitValue, ThreadLocalAllocBuffer::refill_waste_limit_increment(), RtlabWasteLimitValue); 3358 __ st_ptr(RtlabWasteLimitValue, G2_thread, in_bytes(JavaThread::tlab_refill_waste_limit_offset())); 3359 } else { 3360 // No allocation in the shared eden. 3361 __ ba_short(slow_case); 3362 } 3363 } 3364 3365 // Allocation in the shared Eden 3366 if (allow_shared_alloc) { 3367 Register RoldTopValue = G1_scratch; 3368 Register RtopAddr = G3_scratch; 3369 Register RnewTopValue = RallocatedObject; 3370 Register RendValue = Rscratch; 3371 3372 __ set((intptr_t)Universe::heap()->top_addr(), RtopAddr); 3373 3374 Label retry; 3375 __ bind(retry); 3376 __ set((intptr_t)Universe::heap()->end_addr(), RendValue); 3377 __ ld_ptr(RendValue, 0, RendValue); 3378 __ ld_ptr(RtopAddr, 0, RoldTopValue); 3379 __ add(RoldTopValue, Roffset, RnewTopValue); 3380 3381 // RnewTopValue contains the top address after the new object 3382 // has been allocated. 3383 __ cmp_and_brx_short(RnewTopValue, RendValue, Assembler::greaterUnsigned, Assembler::pn, slow_case); 3384 3385 __ cas_ptr(RtopAddr, RoldTopValue, RnewTopValue); 3386 3387 // if someone beat us on the allocation, try again, otherwise continue 3388 __ cmp_and_brx_short(RoldTopValue, RnewTopValue, Assembler::notEqual, Assembler::pn, retry); 3389 3390 // bump total bytes allocated by this thread 3391 // RoldTopValue and RtopAddr are dead, so can use G1 and G3 3392 __ incr_allocated_bytes(Roffset, G1_scratch, G3_scratch); 3393 } 3394 3395 if (UseTLAB || Universe::heap()->supports_inline_contig_alloc()) { 3396 // clear object fields 3397 __ bind(initialize_object); 3398 __ deccc(Roffset, sizeof(oopDesc)); 3399 __ br(Assembler::zero, false, Assembler::pt, initialize_header); 3400 __ delayed()->add(RallocatedObject, sizeof(oopDesc), G3_scratch); 3401 3402 // initialize remaining object fields 3403 if (UseBlockZeroing) { 3404 // Use BIS for zeroing 3405 __ bis_zeroing(G3_scratch, Roffset, G1_scratch, initialize_header); 3406 } else { 3407 Label loop; 3408 __ subcc(Roffset, wordSize, Roffset); 3409 __ bind(loop); 3410 //__ subcc(Roffset, wordSize, Roffset); // executed above loop or in delay slot 3411 __ st_ptr(G0, G3_scratch, Roffset); 3412 __ br(Assembler::notEqual, false, Assembler::pt, loop); 3413 __ delayed()->subcc(Roffset, wordSize, Roffset); 3414 } 3415 __ ba_short(initialize_header); 3416 } 3417 3418 // slow case 3419 __ bind(slow_case); 3420 __ get_2_byte_integer_at_bcp(1, G3_scratch, O2, InterpreterMacroAssembler::Unsigned); 3421 __ get_constant_pool(O1); 3422 3423 call_VM(Otos_i, CAST_FROM_FN_PTR(address, InterpreterRuntime::_new), O1, O2); 3424 3425 __ ba_short(done); 3426 3427 // Initialize the header: mark, klass 3428 __ bind(initialize_header); 3429 3430 if (UseBiasedLocking) { 3431 __ ld_ptr(RinstanceKlass, in_bytes(Klass::prototype_header_offset()), G4_scratch); 3432 } else { 3433 __ set((intptr_t)markOopDesc::prototype(), G4_scratch); 3434 } 3435 __ st_ptr(G4_scratch, RallocatedObject, oopDesc::mark_offset_in_bytes()); // mark 3436 __ store_klass_gap(G0, RallocatedObject); // klass gap if compressed 3437 __ store_klass(RinstanceKlass, RallocatedObject); // klass (last for cms) 3438 3439 { 3440 SkipIfEqual skip_if( 3441 _masm, G4_scratch, &DTraceAllocProbes, Assembler::zero); 3442 // Trigger dtrace event 3443 __ push(atos); 3444 __ call_VM_leaf(noreg, 3445 CAST_FROM_FN_PTR(address, SharedRuntime::dtrace_object_alloc), O0); 3446 __ pop(atos); 3447 } 3448 3449 // continue 3450 __ bind(done); 3451 } 3452 3453 3454 3455 void TemplateTable::newarray() { 3456 transition(itos, atos); 3457 __ ldub(Lbcp, 1, O1); 3458 call_VM(Otos_i, CAST_FROM_FN_PTR(address, InterpreterRuntime::newarray), O1, Otos_i); 3459 } 3460 3461 3462 void TemplateTable::anewarray() { 3463 transition(itos, atos); 3464 __ get_constant_pool(O1); 3465 __ get_2_byte_integer_at_bcp(1, G4_scratch, O2, InterpreterMacroAssembler::Unsigned); 3466 call_VM(Otos_i, CAST_FROM_FN_PTR(address, InterpreterRuntime::anewarray), O1, O2, Otos_i); 3467 } 3468 3469 3470 void TemplateTable::arraylength() { 3471 transition(atos, itos); 3472 Label ok; 3473 __ verify_oop(Otos_i); 3474 __ tst(Otos_i); 3475 __ throw_if_not_1_x( Assembler::notZero, ok ); 3476 __ delayed()->ld(Otos_i, arrayOopDesc::length_offset_in_bytes(), Otos_i); 3477 __ throw_if_not_2( Interpreter::_throw_NullPointerException_entry, G3_scratch, ok); 3478 } 3479 3480 3481 void TemplateTable::checkcast() { 3482 transition(atos, atos); 3483 Label done, is_null, quicked, cast_ok, resolved; 3484 Register Roffset = G1_scratch; 3485 Register RobjKlass = O5; 3486 Register RspecifiedKlass = O4; 3487 3488 // Check for casting a NULL 3489 __ br_null_short(Otos_i, Assembler::pn, is_null); 3490 3491 // Get value klass in RobjKlass 3492 __ load_klass(Otos_i, RobjKlass); // get value klass 3493 3494 // Get constant pool tag 3495 __ get_2_byte_integer_at_bcp(1, Lscratch, Roffset, InterpreterMacroAssembler::Unsigned); 3496 3497 // See if the checkcast has been quickened 3498 __ get_cpool_and_tags(Lscratch, G3_scratch); 3499 __ add(G3_scratch, Array<u1>::base_offset_in_bytes(), G3_scratch); 3500 __ ldub(G3_scratch, Roffset, G3_scratch); 3501 __ cmp(G3_scratch, JVM_CONSTANT_Class); 3502 __ br(Assembler::equal, true, Assembler::pt, quicked); 3503 __ delayed()->sll(Roffset, LogBytesPerWord, Roffset); 3504 3505 __ push_ptr(); // save receiver for result, and for GC 3506 call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::quicken_io_cc) ); 3507 __ get_vm_result_2(RspecifiedKlass); 3508 __ pop_ptr(Otos_i, G3_scratch); // restore receiver 3509 3510 __ ba_short(resolved); 3511 3512 // Extract target class from constant pool 3513 __ bind(quicked); 3514 __ add(Roffset, sizeof(ConstantPool), Roffset); 3515 __ ld_ptr(Lscratch, Roffset, RspecifiedKlass); 3516 __ bind(resolved); 3517 __ load_klass(Otos_i, RobjKlass); // get value klass 3518 3519 // Generate a fast subtype check. Branch to cast_ok if no 3520 // failure. Throw exception if failure. 3521 __ gen_subtype_check( RobjKlass, RspecifiedKlass, G3_scratch, G4_scratch, G1_scratch, cast_ok ); 3522 3523 // Not a subtype; so must throw exception 3524 __ throw_if_not_x( Assembler::never, Interpreter::_throw_ClassCastException_entry, G3_scratch ); 3525 3526 __ bind(cast_ok); 3527 3528 if (ProfileInterpreter) { 3529 __ ba_short(done); 3530 } 3531 __ bind(is_null); 3532 __ profile_null_seen(G3_scratch); 3533 __ bind(done); 3534 } 3535 3536 3537 void TemplateTable::instanceof() { 3538 Label done, is_null, quicked, resolved; 3539 transition(atos, itos); 3540 Register Roffset = G1_scratch; 3541 Register RobjKlass = O5; 3542 Register RspecifiedKlass = O4; 3543 3544 // Check for casting a NULL 3545 __ br_null_short(Otos_i, Assembler::pt, is_null); 3546 3547 // Get value klass in RobjKlass 3548 __ load_klass(Otos_i, RobjKlass); // get value klass 3549 3550 // Get constant pool tag 3551 __ get_2_byte_integer_at_bcp(1, Lscratch, Roffset, InterpreterMacroAssembler::Unsigned); 3552 3553 // See if the checkcast has been quickened 3554 __ get_cpool_and_tags(Lscratch, G3_scratch); 3555 __ add(G3_scratch, Array<u1>::base_offset_in_bytes(), G3_scratch); 3556 __ ldub(G3_scratch, Roffset, G3_scratch); 3557 __ cmp(G3_scratch, JVM_CONSTANT_Class); 3558 __ br(Assembler::equal, true, Assembler::pt, quicked); 3559 __ delayed()->sll(Roffset, LogBytesPerWord, Roffset); 3560 3561 __ push_ptr(); // save receiver for result, and for GC 3562 call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::quicken_io_cc) ); 3563 __ get_vm_result_2(RspecifiedKlass); 3564 __ pop_ptr(Otos_i, G3_scratch); // restore receiver 3565 3566 __ ba_short(resolved); 3567 3568 // Extract target class from constant pool 3569 __ bind(quicked); 3570 __ add(Roffset, sizeof(ConstantPool), Roffset); 3571 __ get_constant_pool(Lscratch); 3572 __ ld_ptr(Lscratch, Roffset, RspecifiedKlass); 3573 __ bind(resolved); 3574 __ load_klass(Otos_i, RobjKlass); // get value klass 3575 3576 // Generate a fast subtype check. Branch to cast_ok if no 3577 // failure. Return 0 if failure. 3578 __ or3(G0, 1, Otos_i); // set result assuming quick tests succeed 3579 __ gen_subtype_check( RobjKlass, RspecifiedKlass, G3_scratch, G4_scratch, G1_scratch, done ); 3580 // Not a subtype; return 0; 3581 __ clr( Otos_i ); 3582 3583 if (ProfileInterpreter) { 3584 __ ba_short(done); 3585 } 3586 __ bind(is_null); 3587 __ profile_null_seen(G3_scratch); 3588 __ bind(done); 3589 } 3590 3591 void TemplateTable::_breakpoint() { 3592 3593 // Note: We get here even if we are single stepping.. 3594 // jbug inists on setting breakpoints at every bytecode 3595 // even if we are in single step mode. 3596 3597 transition(vtos, vtos); 3598 // get the unpatched byte code 3599 __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::get_original_bytecode_at), Lmethod, Lbcp); 3600 __ mov(O0, Lbyte_code); 3601 3602 // post the breakpoint event 3603 __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::_breakpoint), Lmethod, Lbcp); 3604 3605 // complete the execution of original bytecode 3606 __ dispatch_normal(vtos); 3607 } 3608 3609 3610 //---------------------------------------------------------------------------------------------------- 3611 // Exceptions 3612 3613 void TemplateTable::athrow() { 3614 transition(atos, vtos); 3615 3616 // This works because exception is cached in Otos_i which is same as O0, 3617 // which is same as what throw_exception_entry_expects 3618 assert(Otos_i == Oexception, "see explanation above"); 3619 3620 __ verify_oop(Otos_i); 3621 __ null_check(Otos_i); 3622 __ throw_if_not_x(Assembler::never, Interpreter::throw_exception_entry(), G3_scratch); 3623 } 3624 3625 3626 //---------------------------------------------------------------------------------------------------- 3627 // Synchronization 3628 3629 3630 // See frame_sparc.hpp for monitor block layout. 3631 // Monitor elements are dynamically allocated by growing stack as needed. 3632 3633 void TemplateTable::monitorenter() { 3634 transition(atos, vtos); 3635 __ verify_oop(Otos_i); 3636 // Try to acquire a lock on the object 3637 // Repeat until succeeded (i.e., until 3638 // monitorenter returns true). 3639 3640 { Label ok; 3641 __ tst(Otos_i); 3642 __ throw_if_not_1_x( Assembler::notZero, ok); 3643 __ delayed()->mov(Otos_i, Lscratch); // save obj 3644 __ throw_if_not_2( Interpreter::_throw_NullPointerException_entry, G3_scratch, ok); 3645 } 3646 3647 assert(O0 == Otos_i, "Be sure where the object to lock is"); 3648 3649 // find a free slot in the monitor block 3650 3651 3652 // initialize entry pointer 3653 __ clr(O1); // points to free slot or NULL 3654 3655 { 3656 Label entry, loop, exit; 3657 __ add( __ top_most_monitor(), O2 ); // last one to check 3658 __ ba( entry ); 3659 __ delayed()->mov( Lmonitors, O3 ); // first one to check 3660 3661 3662 __ bind( loop ); 3663 3664 __ verify_oop(O4); // verify each monitor's oop 3665 __ tst(O4); // is this entry unused? 3666 __ movcc( Assembler::zero, false, Assembler::ptr_cc, O3, O1); 3667 3668 __ cmp(O4, O0); // check if current entry is for same object 3669 __ brx( Assembler::equal, false, Assembler::pn, exit ); 3670 __ delayed()->inc( O3, frame::interpreter_frame_monitor_size() * wordSize ); // check next one 3671 3672 __ bind( entry ); 3673 3674 __ cmp( O3, O2 ); 3675 __ brx( Assembler::lessEqualUnsigned, true, Assembler::pt, loop ); 3676 __ delayed()->ld_ptr(O3, BasicObjectLock::obj_offset_in_bytes(), O4); 3677 3678 __ bind( exit ); 3679 } 3680 3681 { Label allocated; 3682 3683 // found free slot? 3684 __ br_notnull_short(O1, Assembler::pn, allocated); 3685 3686 __ add_monitor_to_stack( false, O2, O3 ); 3687 __ mov(Lmonitors, O1); 3688 3689 __ bind(allocated); 3690 } 3691 3692 // Increment bcp to point to the next bytecode, so exception handling for async. exceptions work correctly. 3693 // The object has already been poped from the stack, so the expression stack looks correct. 3694 __ inc(Lbcp); 3695 3696 __ st_ptr(O0, O1, BasicObjectLock::obj_offset_in_bytes()); // store object 3697 __ lock_object(O1, O0); 3698 3699 // check if there's enough space on the stack for the monitors after locking 3700 __ generate_stack_overflow_check(0); 3701 3702 // The bcp has already been incremented. Just need to dispatch to next instruction. 3703 __ dispatch_next(vtos); 3704 } 3705 3706 3707 void TemplateTable::monitorexit() { 3708 transition(atos, vtos); 3709 __ verify_oop(Otos_i); 3710 __ tst(Otos_i); 3711 __ throw_if_not_x( Assembler::notZero, Interpreter::_throw_NullPointerException_entry, G3_scratch ); 3712 3713 assert(O0 == Otos_i, "just checking"); 3714 3715 { Label entry, loop, found; 3716 __ add( __ top_most_monitor(), O2 ); // last one to check 3717 __ ba(entry); 3718 // use Lscratch to hold monitor elem to check, start with most recent monitor, 3719 // By using a local it survives the call to the C routine. 3720 __ delayed()->mov( Lmonitors, Lscratch ); 3721 3722 __ bind( loop ); 3723 3724 __ verify_oop(O4); // verify each monitor's oop 3725 __ cmp(O4, O0); // check if current entry is for desired object 3726 __ brx( Assembler::equal, true, Assembler::pt, found ); 3727 __ delayed()->mov(Lscratch, O1); // pass found entry as argument to monitorexit 3728 3729 __ inc( Lscratch, frame::interpreter_frame_monitor_size() * wordSize ); // advance to next 3730 3731 __ bind( entry ); 3732 3733 __ cmp( Lscratch, O2 ); 3734 __ brx( Assembler::lessEqualUnsigned, true, Assembler::pt, loop ); 3735 __ delayed()->ld_ptr(Lscratch, BasicObjectLock::obj_offset_in_bytes(), O4); 3736 3737 call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::throw_illegal_monitor_state_exception)); 3738 __ should_not_reach_here(); 3739 3740 __ bind(found); 3741 } 3742 __ unlock_object(O1); 3743 } 3744 3745 3746 //---------------------------------------------------------------------------------------------------- 3747 // Wide instructions 3748 3749 void TemplateTable::wide() { 3750 transition(vtos, vtos); 3751 __ ldub(Lbcp, 1, G3_scratch);// get next bc 3752 __ sll(G3_scratch, LogBytesPerWord, G3_scratch); 3753 AddressLiteral ep(Interpreter::_wentry_point); 3754 __ set(ep, G4_scratch); 3755 __ ld_ptr(G4_scratch, G3_scratch, G3_scratch); 3756 __ jmp(G3_scratch, G0); 3757 __ delayed()->nop(); 3758 // Note: the Lbcp increment step is part of the individual wide bytecode implementations 3759 } 3760 3761 3762 //---------------------------------------------------------------------------------------------------- 3763 // Multi arrays 3764 3765 void TemplateTable::multianewarray() { 3766 transition(vtos, atos); 3767 // put ndims * wordSize into Lscratch 3768 __ ldub( Lbcp, 3, Lscratch); 3769 __ sll( Lscratch, Interpreter::logStackElementSize, Lscratch); 3770 // Lesp points past last_dim, so set to O1 to first_dim address 3771 __ add( Lesp, Lscratch, O1); 3772 call_VM(Otos_i, CAST_FROM_FN_PTR(address, InterpreterRuntime::multianewarray), O1); 3773 __ add( Lesp, Lscratch, Lesp); // pop all dimensions off the stack 3774 } 3775 #endif /* !CC_INTERP */