< prev index next >

src/cpu/ppc/vm/templateTable_ppc_64.cpp

Print this page
rev 8025 : 8076163: ppc: port "8074345: Enable RewriteBytecodes when VM runs with CDS"

*** 436,454 **** void TemplateTable::locals_index(Register Rdst, int offset) { __ lbz(Rdst, offset, R14_bcp); } void TemplateTable::iload() { transition(vtos, itos); // Get the local value into tos const Register Rindex = R22_tmp2; locals_index(Rindex); // Rewrite iload,iload pair into fast_iload2 // iload,caload pair into fast_icaload ! if (RewriteFrequentPairs) { Label Lrewrite, Ldone; Register Rnext_byte = R3_ARG1, Rrewrite_to = R6_ARG4, Rscratch = R11_scratch1; --- 436,462 ---- void TemplateTable::locals_index(Register Rdst, int offset) { __ lbz(Rdst, offset, R14_bcp); } void TemplateTable::iload() { + iload_internal(); + } + + void TemplateTable::nofast_iload() { + iload_internal(may_not_rewrite); + } + + void TemplateTable::iload_internal(RewriteControl rc) { transition(vtos, itos); // Get the local value into tos const Register Rindex = R22_tmp2; locals_index(Rindex); // Rewrite iload,iload pair into fast_iload2 // iload,caload pair into fast_icaload ! if (RewriteFrequentPairs && rc == may_rewrite) { Label Lrewrite, Ldone; Register Rnext_byte = R3_ARG1, Rrewrite_to = R6_ARG4, Rscratch = R11_scratch1;
*** 708,717 **** --- 716,733 ---- __ ld(R17_tos, Interpreter::local_offset_in_bytes(n), R18_locals); } void TemplateTable::aload_0() { + aload_0_internal(); + } + + void TemplateTable::nofast_aload_0() { + aload_0_internal(may_not_rewrite); + } + + void TemplateTable::aload_0_internal(RewriteControl rc) { transition(vtos, atos); // According to bytecode histograms, the pairs: // // _aload_0, _fast_igetfield // _aload_0, _fast_agetfield
*** 731,741 **** // aload_0, aload_1 // aload_0, iload_1 // These bytecodes with a small amount of code are most profitable // to rewrite. ! if (RewriteFrequentPairs) { Label Lrewrite, Ldont_rewrite; Register Rnext_byte = R3_ARG1, Rrewrite_to = R6_ARG4, Rscratch = R11_scratch1; --- 747,757 ---- // aload_0, aload_1 // aload_0, iload_1 // These bytecodes with a small amount of code are most profitable // to rewrite. ! if (RewriteFrequentPairs && rc == may_rewrite) { Label Lrewrite, Ldont_rewrite; Register Rnext_byte = R3_ARG1, Rrewrite_to = R6_ARG4, Rscratch = R11_scratch1;
*** 2143,2178 **** void TemplateTable::resolve_cache_and_index(int byte_no, Register Rcache, Register Rscratch, size_t index_size) { __ get_cache_and_index_at_bcp(Rcache, 1, index_size); Label Lresolved, Ldone; assert(byte_no == f1_byte || byte_no == f2_byte, "byte_no out of range"); // We are resolved if the indices offset contains the current bytecode. #if defined(VM_LITTLE_ENDIAN) __ lbz(Rscratch, in_bytes(ConstantPoolCache::base_offset() + ConstantPoolCacheEntry::indices_offset()) + byte_no + 1, Rcache); #else __ lbz(Rscratch, in_bytes(ConstantPoolCache::base_offset() + ConstantPoolCacheEntry::indices_offset()) + 7 - (byte_no + 1), Rcache); #endif // Acquire by cmp-br-isync (see below). ! __ cmpdi(CCR0, Rscratch, (int)bytecode()); __ beq(CCR0, Lresolved); address entry = NULL; ! switch (bytecode()) { case Bytecodes::_getstatic : // fall through case Bytecodes::_putstatic : // fall through case Bytecodes::_getfield : // fall through case Bytecodes::_putfield : entry = CAST_FROM_FN_PTR(address, InterpreterRuntime::resolve_get_put); break; case Bytecodes::_invokevirtual : // fall through case Bytecodes::_invokespecial : // fall through case Bytecodes::_invokestatic : // fall through case Bytecodes::_invokeinterface: entry = CAST_FROM_FN_PTR(address, InterpreterRuntime::resolve_invoke); break; case Bytecodes::_invokehandle : entry = CAST_FROM_FN_PTR(address, InterpreterRuntime::resolve_invokehandle); break; case Bytecodes::_invokedynamic : entry = CAST_FROM_FN_PTR(address, InterpreterRuntime::resolve_invokedynamic); break; ! default : ShouldNotReachHere(); break; } ! __ li(R4_ARG2, (int)bytecode()); __ call_VM(noreg, entry, R4_ARG2, true); // Update registers with resolved info. __ get_cache_and_index_at_bcp(Rcache, 1, index_size); __ b(Ldone); --- 2159,2202 ---- void TemplateTable::resolve_cache_and_index(int byte_no, Register Rcache, Register Rscratch, size_t index_size) { __ get_cache_and_index_at_bcp(Rcache, 1, index_size); Label Lresolved, Ldone; + Bytecodes::Code code = bytecode(); + switch (code) { + case Bytecodes::_nofast_getfield: code = Bytecodes::_getfield; break; + case Bytecodes::_nofast_putfield: code = Bytecodes::_putfield; break; + } + assert(byte_no == f1_byte || byte_no == f2_byte, "byte_no out of range"); // We are resolved if the indices offset contains the current bytecode. #if defined(VM_LITTLE_ENDIAN) __ lbz(Rscratch, in_bytes(ConstantPoolCache::base_offset() + ConstantPoolCacheEntry::indices_offset()) + byte_no + 1, Rcache); #else __ lbz(Rscratch, in_bytes(ConstantPoolCache::base_offset() + ConstantPoolCacheEntry::indices_offset()) + 7 - (byte_no + 1), Rcache); #endif // Acquire by cmp-br-isync (see below). ! __ cmpdi(CCR0, Rscratch, (int)code); __ beq(CCR0, Lresolved); address entry = NULL; ! switch (code) { case Bytecodes::_getstatic : // fall through case Bytecodes::_putstatic : // fall through case Bytecodes::_getfield : // fall through case Bytecodes::_putfield : entry = CAST_FROM_FN_PTR(address, InterpreterRuntime::resolve_get_put); break; case Bytecodes::_invokevirtual : // fall through case Bytecodes::_invokespecial : // fall through case Bytecodes::_invokestatic : // fall through case Bytecodes::_invokeinterface: entry = CAST_FROM_FN_PTR(address, InterpreterRuntime::resolve_invoke); break; case Bytecodes::_invokehandle : entry = CAST_FROM_FN_PTR(address, InterpreterRuntime::resolve_invokehandle); break; case Bytecodes::_invokedynamic : entry = CAST_FROM_FN_PTR(address, InterpreterRuntime::resolve_invokedynamic); break; ! default : ! fatal(err_msg("unexpected bytecode: %s", Bytecodes::name(code))); ! break; } ! __ li(R4_ARG2, code); __ call_VM(noreg, entry, R4_ARG2, true); // Update registers with resolved info. __ get_cache_and_index_at_bcp(Rcache, 1, index_size); __ b(Ldone);
*** 2349,2359 **** __ null_check_throw(Roop, -1, Rtmp); __ verify_oop(Roop); } // PPC64: implement volatile loads as fence-store-acquire. ! void TemplateTable::getfield_or_static(int byte_no, bool is_static) { transition(vtos, vtos); Label Lacquire, Lisync; const Register Rcache = R3_ARG1, --- 2373,2383 ---- __ null_check_throw(Roop, -1, Rtmp); __ verify_oop(Roop); } // PPC64: implement volatile loads as fence-store-acquire. ! void TemplateTable::getfield_or_static(int byte_no, bool is_static, RewriteControl rc) { transition(vtos, vtos); Label Lacquire, Lisync; const Register Rcache = R3_ARG1,
*** 2365,2375 **** Rscratch = R12_scratch2; static address field_branch_table[number_of_states], static_branch_table[number_of_states]; ! address* branch_table = is_static ? static_branch_table : field_branch_table; // Get field offset. resolve_cache_and_index(byte_no, Rcache, Rscratch, sizeof(u2)); // JVMTI support --- 2389,2399 ---- Rscratch = R12_scratch2; static address field_branch_table[number_of_states], static_branch_table[number_of_states]; ! address* branch_table = (is_static || rc == may_not_rewrite) ? static_branch_table : field_branch_table; // Get field offset. resolve_cache_and_index(byte_no, Rcache, Rscratch, sizeof(u2)); // JVMTI support
*** 2416,2426 **** --- 2440,2457 ---- __ bctr(); #ifdef ASSERT __ bind(LFlagInvalid); __ stop("got invalid flag", 0x654); + #endif + + if (!is_static && rc == may_not_rewrite) { + // We reuse the code from is_static. It's jumped to via the table above. + return; + } + #ifdef ASSERT // __ bind(Lvtos); address pc_before_fence = __ pc(); __ fence(); // Volatile entry point (one instruction before non-volatile_entry point). assert(__ pc() - pc_before_fence == (ptrdiff_t)BytesPerInstWord, "must be single instruction"); assert(branch_table[vtos] == 0, "can't compute twice");
*** 2433,2443 **** __ fence(); // Volatile entry point (one instruction before non-volatile_entry point). assert(branch_table[dtos] == 0, "can't compute twice"); branch_table[dtos] = __ pc(); // non-volatile_entry point __ lfdx(F15_ftos, Rclass_or_obj, Roffset); __ push(dtos); ! if (!is_static) patch_bytecode(Bytecodes::_fast_dgetfield, Rbc, Rscratch); { Label acquire_double; __ beq(CCR6, acquire_double); // Volatile? __ dispatch_epilog(vtos, Bytecodes::length_for(bytecode())); --- 2464,2476 ---- __ fence(); // Volatile entry point (one instruction before non-volatile_entry point). assert(branch_table[dtos] == 0, "can't compute twice"); branch_table[dtos] = __ pc(); // non-volatile_entry point __ lfdx(F15_ftos, Rclass_or_obj, Roffset); __ push(dtos); ! if (!is_static && rc == may_rewrite) { ! patch_bytecode(Bytecodes::_fast_dgetfield, Rbc, Rscratch); ! } { Label acquire_double; __ beq(CCR6, acquire_double); // Volatile? __ dispatch_epilog(vtos, Bytecodes::length_for(bytecode()));
*** 2452,2462 **** __ fence(); // Volatile entry point (one instruction before non-volatile_entry point). assert(branch_table[ftos] == 0, "can't compute twice"); branch_table[ftos] = __ pc(); // non-volatile_entry point __ lfsx(F15_ftos, Rclass_or_obj, Roffset); __ push(ftos); ! if (!is_static) { patch_bytecode(Bytecodes::_fast_fgetfield, Rbc, Rscratch); } { Label acquire_float; __ beq(CCR6, acquire_float); // Volatile? __ dispatch_epilog(vtos, Bytecodes::length_for(bytecode())); --- 2485,2497 ---- __ fence(); // Volatile entry point (one instruction before non-volatile_entry point). assert(branch_table[ftos] == 0, "can't compute twice"); branch_table[ftos] = __ pc(); // non-volatile_entry point __ lfsx(F15_ftos, Rclass_or_obj, Roffset); __ push(ftos); ! if (!is_static && rc == may_rewrite) { ! patch_bytecode(Bytecodes::_fast_fgetfield, Rbc, Rscratch); ! } { Label acquire_float; __ beq(CCR6, acquire_float); // Volatile? __ dispatch_epilog(vtos, Bytecodes::length_for(bytecode()));
*** 2471,2492 **** __ fence(); // Volatile entry point (one instruction before non-volatile_entry point). assert(branch_table[itos] == 0, "can't compute twice"); branch_table[itos] = __ pc(); // non-volatile_entry point __ lwax(R17_tos, Rclass_or_obj, Roffset); __ push(itos); ! if (!is_static) patch_bytecode(Bytecodes::_fast_igetfield, Rbc, Rscratch); __ beq(CCR6, Lacquire); // Volatile? __ dispatch_epilog(vtos, Bytecodes::length_for(bytecode())); __ align(32, 28, 28); // Align load. // __ bind(Lltos); __ fence(); // Volatile entry point (one instruction before non-volatile_entry point). assert(branch_table[ltos] == 0, "can't compute twice"); branch_table[ltos] = __ pc(); // non-volatile_entry point __ ldx(R17_tos, Rclass_or_obj, Roffset); __ push(ltos); ! if (!is_static) patch_bytecode(Bytecodes::_fast_lgetfield, Rbc, Rscratch); __ beq(CCR6, Lacquire); // Volatile? __ dispatch_epilog(vtos, Bytecodes::length_for(bytecode())); __ align(32, 28, 28); // Align load. // __ bind(Lbtos); --- 2506,2531 ---- __ fence(); // Volatile entry point (one instruction before non-volatile_entry point). assert(branch_table[itos] == 0, "can't compute twice"); branch_table[itos] = __ pc(); // non-volatile_entry point __ lwax(R17_tos, Rclass_or_obj, Roffset); __ push(itos); ! if (!is_static && rc == may_rewrite) { ! patch_bytecode(Bytecodes::_fast_igetfield, Rbc, Rscratch); ! } __ beq(CCR6, Lacquire); // Volatile? __ dispatch_epilog(vtos, Bytecodes::length_for(bytecode())); __ align(32, 28, 28); // Align load. // __ bind(Lltos); __ fence(); // Volatile entry point (one instruction before non-volatile_entry point). assert(branch_table[ltos] == 0, "can't compute twice"); branch_table[ltos] = __ pc(); // non-volatile_entry point __ ldx(R17_tos, Rclass_or_obj, Roffset); __ push(ltos); ! if (!is_static && rc == may_rewrite) { ! patch_bytecode(Bytecodes::_fast_lgetfield, Rbc, Rscratch); ! } __ beq(CCR6, Lacquire); // Volatile? __ dispatch_epilog(vtos, Bytecodes::length_for(bytecode())); __ align(32, 28, 28); // Align load. // __ bind(Lbtos);
*** 2494,2526 **** assert(branch_table[btos] == 0, "can't compute twice"); branch_table[btos] = __ pc(); // non-volatile_entry point __ lbzx(R17_tos, Rclass_or_obj, Roffset); __ extsb(R17_tos, R17_tos); __ push(btos); ! if (!is_static) patch_bytecode(Bytecodes::_fast_bgetfield, Rbc, Rscratch); __ beq(CCR6, Lacquire); // Volatile? __ dispatch_epilog(vtos, Bytecodes::length_for(bytecode())); __ align(32, 28, 28); // Align load. // __ bind(Lctos); __ fence(); // Volatile entry point (one instruction before non-volatile_entry point). assert(branch_table[ctos] == 0, "can't compute twice"); branch_table[ctos] = __ pc(); // non-volatile_entry point __ lhzx(R17_tos, Rclass_or_obj, Roffset); __ push(ctos); ! if (!is_static) patch_bytecode(Bytecodes::_fast_cgetfield, Rbc, Rscratch); __ beq(CCR6, Lacquire); // Volatile? __ dispatch_epilog(vtos, Bytecodes::length_for(bytecode())); __ align(32, 28, 28); // Align load. // __ bind(Lstos); __ fence(); // Volatile entry point (one instruction before non-volatile_entry point). assert(branch_table[stos] == 0, "can't compute twice"); branch_table[stos] = __ pc(); // non-volatile_entry point __ lhax(R17_tos, Rclass_or_obj, Roffset); __ push(stos); ! if (!is_static) patch_bytecode(Bytecodes::_fast_sgetfield, Rbc, Rscratch); __ beq(CCR6, Lacquire); // Volatile? __ dispatch_epilog(vtos, Bytecodes::length_for(bytecode())); __ align(32, 28, 28); // Align load. // __ bind(Latos); --- 2533,2571 ---- assert(branch_table[btos] == 0, "can't compute twice"); branch_table[btos] = __ pc(); // non-volatile_entry point __ lbzx(R17_tos, Rclass_or_obj, Roffset); __ extsb(R17_tos, R17_tos); __ push(btos); ! if (!is_static && rc == may_rewrite) { ! patch_bytecode(Bytecodes::_fast_bgetfield, Rbc, Rscratch); ! } __ beq(CCR6, Lacquire); // Volatile? __ dispatch_epilog(vtos, Bytecodes::length_for(bytecode())); __ align(32, 28, 28); // Align load. // __ bind(Lctos); __ fence(); // Volatile entry point (one instruction before non-volatile_entry point). assert(branch_table[ctos] == 0, "can't compute twice"); branch_table[ctos] = __ pc(); // non-volatile_entry point __ lhzx(R17_tos, Rclass_or_obj, Roffset); __ push(ctos); ! if (!is_static && rc == may_rewrite) { ! patch_bytecode(Bytecodes::_fast_cgetfield, Rbc, Rscratch); ! } __ beq(CCR6, Lacquire); // Volatile? __ dispatch_epilog(vtos, Bytecodes::length_for(bytecode())); __ align(32, 28, 28); // Align load. // __ bind(Lstos); __ fence(); // Volatile entry point (one instruction before non-volatile_entry point). assert(branch_table[stos] == 0, "can't compute twice"); branch_table[stos] = __ pc(); // non-volatile_entry point __ lhax(R17_tos, Rclass_or_obj, Roffset); __ push(stos); ! if (!is_static && rc == may_rewrite) { ! patch_bytecode(Bytecodes::_fast_sgetfield, Rbc, Rscratch); ! } __ beq(CCR6, Lacquire); // Volatile? __ dispatch_epilog(vtos, Bytecodes::length_for(bytecode())); __ align(32, 28, 28); // Align load. // __ bind(Latos);
*** 2529,2539 **** branch_table[atos] = __ pc(); // non-volatile_entry point __ load_heap_oop(R17_tos, (RegisterOrConstant)Roffset, Rclass_or_obj); __ verify_oop(R17_tos); __ push(atos); //__ dcbt(R17_tos); // prefetch ! if (!is_static) patch_bytecode(Bytecodes::_fast_agetfield, Rbc, Rscratch); __ beq(CCR6, Lacquire); // Volatile? __ dispatch_epilog(vtos, Bytecodes::length_for(bytecode())); __ align(32, 12); __ bind(Lacquire); --- 2574,2586 ---- branch_table[atos] = __ pc(); // non-volatile_entry point __ load_heap_oop(R17_tos, (RegisterOrConstant)Roffset, Rclass_or_obj); __ verify_oop(R17_tos); __ push(atos); //__ dcbt(R17_tos); // prefetch ! if (!is_static && rc == may_rewrite) { ! patch_bytecode(Bytecodes::_fast_agetfield, Rbc, Rscratch); ! } __ beq(CCR6, Lacquire); // Volatile? __ dispatch_epilog(vtos, Bytecodes::length_for(bytecode())); __ align(32, 12); __ bind(Lacquire);
*** 2552,2561 **** --- 2599,2612 ---- void TemplateTable::getfield(int byte_no) { getfield_or_static(byte_no, false); } + void TemplateTable::nofast_getfield(int byte_no) { + getfield_or_static(byte_no, false, may_not_rewrite); + } + void TemplateTable::getstatic(int byte_no) { getfield_or_static(byte_no, true); } // The registers cache and index expected to be set before call.
*** 2642,2652 **** __ bind(Lno_field_mod_post); } } // PPC64: implement volatile stores as release-store (return bytecode contains an additional release). ! void TemplateTable::putfield_or_static(int byte_no, bool is_static) { Label Lvolatile; const Register Rcache = R5_ARG3, // Do not use ARG1/2 (causes trouble in jvmti_post_field_mod). Rclass_or_obj = R31, // Needs to survive C call. Roffset = R22_tmp2, // Needs to survive C call. --- 2693,2703 ---- __ bind(Lno_field_mod_post); } } // PPC64: implement volatile stores as release-store (return bytecode contains an additional release). ! void TemplateTable::putfield_or_static(int byte_no, bool is_static, RewriteControl rc) { Label Lvolatile; const Register Rcache = R5_ARG3, // Do not use ARG1/2 (causes trouble in jvmti_post_field_mod). Rclass_or_obj = R31, // Needs to survive C call. Roffset = R22_tmp2, // Needs to survive C call.
*** 2656,2669 **** Rscratch2 = R12_scratch2, Rscratch3 = R6_ARG4, Rbc = Rscratch3; const ConditionRegister CR_is_vol = CCR2; // Non-volatile condition register (survives runtime call in do_oop_store). ! static address field_branch_table[number_of_states], static_branch_table[number_of_states]; ! address* branch_table = is_static ? static_branch_table : field_branch_table; // Stack (grows up): // value // obj --- 2707,2722 ---- Rscratch2 = R12_scratch2, Rscratch3 = R6_ARG4, Rbc = Rscratch3; const ConditionRegister CR_is_vol = CCR2; // Non-volatile condition register (survives runtime call in do_oop_store). ! static address field_rw_branch_table[number_of_states], ! field_norw_branch_table[number_of_states], static_branch_table[number_of_states]; ! address* branch_table = is_static ? static_branch_table : ! (rc == may_rewrite ? field_rw_branch_table : field_norw_branch_table); // Stack (grows up): // value // obj
*** 2687,2697 **** __ bge(CCR0, LFlagInvalid); #endif // Load from branch table and dispatch (volatile case: one instruction ahead). __ sldi(Rflags, Rflags, LogBytesPerWord); ! if (!support_IRIW_for_not_multiple_copy_atomic_cpu) { __ cmpwi(CR_is_vol, Rscratch, 1); } // Volatile? __ sldi(Rscratch, Rscratch, exact_log2(BytesPerInstWord)); // Volatile? size of instruction 1 : 0. __ ldx(Rbtable, Rbtable, Rflags); __ subf(Rbtable, Rscratch, Rbtable); // Point to volatile/non-volatile entry point. __ mtctr(Rbtable); --- 2740,2752 ---- __ bge(CCR0, LFlagInvalid); #endif // Load from branch table and dispatch (volatile case: one instruction ahead). __ sldi(Rflags, Rflags, LogBytesPerWord); ! if (!support_IRIW_for_not_multiple_copy_atomic_cpu) { ! __ cmpwi(CR_is_vol, Rscratch, 1); // Volatile? ! } __ sldi(Rscratch, Rscratch, exact_log2(BytesPerInstWord)); // Volatile? size of instruction 1 : 0. __ ldx(Rbtable, Rbtable, Rflags); __ subf(Rbtable, Rscratch, Rbtable); // Point to volatile/non-volatile entry point. __ mtctr(Rbtable);
*** 2714,2726 **** // __ bind(Ldtos); __ release(); // Volatile entry point (one instruction before non-volatile_entry point). assert(branch_table[dtos] == 0, "can't compute twice"); branch_table[dtos] = __ pc(); // non-volatile_entry point __ pop(dtos); ! if (!is_static) { pop_and_check_object(Rclass_or_obj); } // Kills R11_scratch1. __ stfdx(F15_ftos, Rclass_or_obj, Roffset); ! if (!is_static) { patch_bytecode(Bytecodes::_fast_dputfield, Rbc, Rscratch, true, byte_no); } if (!support_IRIW_for_not_multiple_copy_atomic_cpu) { __ beq(CR_is_vol, Lvolatile); // Volatile? } __ dispatch_epilog(vtos, Bytecodes::length_for(bytecode())); --- 2769,2785 ---- // __ bind(Ldtos); __ release(); // Volatile entry point (one instruction before non-volatile_entry point). assert(branch_table[dtos] == 0, "can't compute twice"); branch_table[dtos] = __ pc(); // non-volatile_entry point __ pop(dtos); ! if (!is_static) { ! pop_and_check_object(Rclass_or_obj); // Kills R11_scratch1. ! } __ stfdx(F15_ftos, Rclass_or_obj, Roffset); ! if (!is_static && rc == may_rewrite) { ! patch_bytecode(Bytecodes::_fast_dputfield, Rbc, Rscratch, true, byte_no); ! } if (!support_IRIW_for_not_multiple_copy_atomic_cpu) { __ beq(CR_is_vol, Lvolatile); // Volatile? } __ dispatch_epilog(vtos, Bytecodes::length_for(bytecode()));
*** 2730,2740 **** assert(branch_table[ftos] == 0, "can't compute twice"); branch_table[ftos] = __ pc(); // non-volatile_entry point __ pop(ftos); if (!is_static) { pop_and_check_object(Rclass_or_obj); } // Kills R11_scratch1. __ stfsx(F15_ftos, Rclass_or_obj, Roffset); ! if (!is_static) { patch_bytecode(Bytecodes::_fast_fputfield, Rbc, Rscratch, true, byte_no); } if (!support_IRIW_for_not_multiple_copy_atomic_cpu) { __ beq(CR_is_vol, Lvolatile); // Volatile? } __ dispatch_epilog(vtos, Bytecodes::length_for(bytecode())); --- 2789,2801 ---- assert(branch_table[ftos] == 0, "can't compute twice"); branch_table[ftos] = __ pc(); // non-volatile_entry point __ pop(ftos); if (!is_static) { pop_and_check_object(Rclass_or_obj); } // Kills R11_scratch1. __ stfsx(F15_ftos, Rclass_or_obj, Roffset); ! if (!is_static && rc == may_rewrite) { ! patch_bytecode(Bytecodes::_fast_fputfield, Rbc, Rscratch, true, byte_no); ! } if (!support_IRIW_for_not_multiple_copy_atomic_cpu) { __ beq(CR_is_vol, Lvolatile); // Volatile? } __ dispatch_epilog(vtos, Bytecodes::length_for(bytecode()));
*** 2744,2754 **** assert(branch_table[itos] == 0, "can't compute twice"); branch_table[itos] = __ pc(); // non-volatile_entry point __ pop(itos); if (!is_static) { pop_and_check_object(Rclass_or_obj); } // Kills R11_scratch1. __ stwx(R17_tos, Rclass_or_obj, Roffset); ! if (!is_static) { patch_bytecode(Bytecodes::_fast_iputfield, Rbc, Rscratch, true, byte_no); } if (!support_IRIW_for_not_multiple_copy_atomic_cpu) { __ beq(CR_is_vol, Lvolatile); // Volatile? } __ dispatch_epilog(vtos, Bytecodes::length_for(bytecode())); --- 2805,2817 ---- assert(branch_table[itos] == 0, "can't compute twice"); branch_table[itos] = __ pc(); // non-volatile_entry point __ pop(itos); if (!is_static) { pop_and_check_object(Rclass_or_obj); } // Kills R11_scratch1. __ stwx(R17_tos, Rclass_or_obj, Roffset); ! if (!is_static && rc == may_rewrite) { ! patch_bytecode(Bytecodes::_fast_iputfield, Rbc, Rscratch, true, byte_no); ! } if (!support_IRIW_for_not_multiple_copy_atomic_cpu) { __ beq(CR_is_vol, Lvolatile); // Volatile? } __ dispatch_epilog(vtos, Bytecodes::length_for(bytecode()));
*** 2758,2768 **** assert(branch_table[ltos] == 0, "can't compute twice"); branch_table[ltos] = __ pc(); // non-volatile_entry point __ pop(ltos); if (!is_static) { pop_and_check_object(Rclass_or_obj); } // Kills R11_scratch1. __ stdx(R17_tos, Rclass_or_obj, Roffset); ! if (!is_static) { patch_bytecode(Bytecodes::_fast_lputfield, Rbc, Rscratch, true, byte_no); } if (!support_IRIW_for_not_multiple_copy_atomic_cpu) { __ beq(CR_is_vol, Lvolatile); // Volatile? } __ dispatch_epilog(vtos, Bytecodes::length_for(bytecode())); --- 2821,2833 ---- assert(branch_table[ltos] == 0, "can't compute twice"); branch_table[ltos] = __ pc(); // non-volatile_entry point __ pop(ltos); if (!is_static) { pop_and_check_object(Rclass_or_obj); } // Kills R11_scratch1. __ stdx(R17_tos, Rclass_or_obj, Roffset); ! if (!is_static && rc == may_rewrite) { ! patch_bytecode(Bytecodes::_fast_lputfield, Rbc, Rscratch, true, byte_no); ! } if (!support_IRIW_for_not_multiple_copy_atomic_cpu) { __ beq(CR_is_vol, Lvolatile); // Volatile? } __ dispatch_epilog(vtos, Bytecodes::length_for(bytecode()));
*** 2772,2782 **** assert(branch_table[btos] == 0, "can't compute twice"); branch_table[btos] = __ pc(); // non-volatile_entry point __ pop(btos); if (!is_static) { pop_and_check_object(Rclass_or_obj); } // Kills R11_scratch1. __ stbx(R17_tos, Rclass_or_obj, Roffset); ! if (!is_static) { patch_bytecode(Bytecodes::_fast_bputfield, Rbc, Rscratch, true, byte_no); } if (!support_IRIW_for_not_multiple_copy_atomic_cpu) { __ beq(CR_is_vol, Lvolatile); // Volatile? } __ dispatch_epilog(vtos, Bytecodes::length_for(bytecode())); --- 2837,2849 ---- assert(branch_table[btos] == 0, "can't compute twice"); branch_table[btos] = __ pc(); // non-volatile_entry point __ pop(btos); if (!is_static) { pop_and_check_object(Rclass_or_obj); } // Kills R11_scratch1. __ stbx(R17_tos, Rclass_or_obj, Roffset); ! if (!is_static && rc == may_rewrite) { ! patch_bytecode(Bytecodes::_fast_bputfield, Rbc, Rscratch, true, byte_no); ! } if (!support_IRIW_for_not_multiple_copy_atomic_cpu) { __ beq(CR_is_vol, Lvolatile); // Volatile? } __ dispatch_epilog(vtos, Bytecodes::length_for(bytecode()));
*** 2786,2796 **** assert(branch_table[ctos] == 0, "can't compute twice"); branch_table[ctos] = __ pc(); // non-volatile_entry point __ pop(ctos); if (!is_static) { pop_and_check_object(Rclass_or_obj); } // Kills R11_scratch1.. __ sthx(R17_tos, Rclass_or_obj, Roffset); ! if (!is_static) { patch_bytecode(Bytecodes::_fast_cputfield, Rbc, Rscratch, true, byte_no); } if (!support_IRIW_for_not_multiple_copy_atomic_cpu) { __ beq(CR_is_vol, Lvolatile); // Volatile? } __ dispatch_epilog(vtos, Bytecodes::length_for(bytecode())); --- 2853,2865 ---- assert(branch_table[ctos] == 0, "can't compute twice"); branch_table[ctos] = __ pc(); // non-volatile_entry point __ pop(ctos); if (!is_static) { pop_and_check_object(Rclass_or_obj); } // Kills R11_scratch1.. __ sthx(R17_tos, Rclass_or_obj, Roffset); ! if (!is_static && rc == may_rewrite) { ! patch_bytecode(Bytecodes::_fast_cputfield, Rbc, Rscratch, true, byte_no); ! } if (!support_IRIW_for_not_multiple_copy_atomic_cpu) { __ beq(CR_is_vol, Lvolatile); // Volatile? } __ dispatch_epilog(vtos, Bytecodes::length_for(bytecode()));
*** 2800,2810 **** assert(branch_table[stos] == 0, "can't compute twice"); branch_table[stos] = __ pc(); // non-volatile_entry point __ pop(stos); if (!is_static) { pop_and_check_object(Rclass_or_obj); } // Kills R11_scratch1. __ sthx(R17_tos, Rclass_or_obj, Roffset); ! if (!is_static) { patch_bytecode(Bytecodes::_fast_sputfield, Rbc, Rscratch, true, byte_no); } if (!support_IRIW_for_not_multiple_copy_atomic_cpu) { __ beq(CR_is_vol, Lvolatile); // Volatile? } __ dispatch_epilog(vtos, Bytecodes::length_for(bytecode())); --- 2869,2881 ---- assert(branch_table[stos] == 0, "can't compute twice"); branch_table[stos] = __ pc(); // non-volatile_entry point __ pop(stos); if (!is_static) { pop_and_check_object(Rclass_or_obj); } // Kills R11_scratch1. __ sthx(R17_tos, Rclass_or_obj, Roffset); ! if (!is_static && rc == may_rewrite) { ! patch_bytecode(Bytecodes::_fast_sputfield, Rbc, Rscratch, true, byte_no); ! } if (!support_IRIW_for_not_multiple_copy_atomic_cpu) { __ beq(CR_is_vol, Lvolatile); // Volatile? } __ dispatch_epilog(vtos, Bytecodes::length_for(bytecode()));
*** 2814,2824 **** assert(branch_table[atos] == 0, "can't compute twice"); branch_table[atos] = __ pc(); // non-volatile_entry point __ pop(atos); if (!is_static) { pop_and_check_object(Rclass_or_obj); } // kills R11_scratch1 do_oop_store(_masm, Rclass_or_obj, Roffset, R17_tos, Rscratch, Rscratch2, Rscratch3, _bs->kind(), false /* precise */, true /* check null */); ! if (!is_static) { patch_bytecode(Bytecodes::_fast_aputfield, Rbc, Rscratch, true, byte_no); } if (!support_IRIW_for_not_multiple_copy_atomic_cpu) { __ beq(CR_is_vol, Lvolatile); // Volatile? __ dispatch_epilog(vtos, Bytecodes::length_for(bytecode())); __ align(32, 12); --- 2885,2897 ---- assert(branch_table[atos] == 0, "can't compute twice"); branch_table[atos] = __ pc(); // non-volatile_entry point __ pop(atos); if (!is_static) { pop_and_check_object(Rclass_or_obj); } // kills R11_scratch1 do_oop_store(_masm, Rclass_or_obj, Roffset, R17_tos, Rscratch, Rscratch2, Rscratch3, _bs->kind(), false /* precise */, true /* check null */); ! if (!is_static && rc == may_rewrite) { ! patch_bytecode(Bytecodes::_fast_aputfield, Rbc, Rscratch, true, byte_no); ! } if (!support_IRIW_for_not_multiple_copy_atomic_cpu) { __ beq(CR_is_vol, Lvolatile); // Volatile? __ dispatch_epilog(vtos, Bytecodes::length_for(bytecode())); __ align(32, 12);
*** 2838,2847 **** --- 2911,2924 ---- void TemplateTable::putfield(int byte_no) { putfield_or_static(byte_no, false); } + void TemplateTable::nofast_putfield(int byte_no) { + putfield_or_static(byte_no, false, may_not_rewrite); + } + void TemplateTable::putstatic(int byte_no) { putfield_or_static(byte_no, true); } // See SPARC. On PPC64, we have a different jvmti_post_field_mod which does the job.
*** 3258,3268 **** --- 3335,3347 ---- load_invoke_cp_cache_entry(byte_no, Rvtableindex_or_method, noreg, Rflags, /*virtual*/ true, false, false); __ testbitdi(CCR0, R0, Rflags, ConstantPoolCacheEntry::is_vfinal_shift); __ bfalse(CCR0, LnotFinal); + if (RewriteBytecodes && !UseSharedSpaces) { patch_bytecode(Bytecodes::_fast_invokevfinal, Rnew_bc, R12_scratch2); + } invokevfinal_helper(Rvtableindex_or_method, Rflags, R11_scratch1, R12_scratch2); __ align(32, 12); __ bind(LnotFinal); // Load "this" pointer (receiver).
< prev index next >