| Quellcodebibliothek Statistik Leitseite products/Sources/formale Sprachen/Java/Openjdk/src/hotspot/cpu/s390/ (Sun/Oracle ©) Datei vom 13.11.2022 mit Größe 135 kB |
|
Quelle templateTable_s390.cpp Sprache: C |
|||||||||
|
/*
* Copyright (c) 2016, 2022, Oracle and/or its affiliates. All rights reserved. * Copyright (c) 2016, 2020 SAP SE. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. * */ #include "precompiled.hpp" #include "asm/macroAssembler.inline.hpp" #include "gc/shared/barrierSetAssembler.hpp" #include "gc/shared/tlab_globals.hpp" #include "interpreter/interpreter.hpp" #include "interpreter/interpreterRuntime.hpp" #include "interpreter/interp_masm.hpp" #include "interpreter/templateTable.hpp" #include "memory/universe.hpp" #include "oops/klass.inline.hpp" #include "oops/methodData.hpp" #include "oops/objArrayKlass.hpp" #include "oops/oop.inline.hpp" #include "prims/jvmtiExport.hpp" #include "prims/methodHandles.hpp" #include "runtime/frame.inline.hpp" #include "runtime/safepointMechanism.hpp" #include "runtime/sharedRuntime.hpp" #include "runtime/stubRoutines.hpp" #include "runtime/synchronizer.hpp" #include "utilities/macros.hpp" #include "utilities/powerOfTwo.hpp" #ifdef PRODUCT #define __ _masm-> #define BLOCK_COMMENT(str) #define BIND(label) __ bind(label); #else #define __ (PRODUCT_ONLY(false&&)Verbose ? (_masm->block_comment(FILE_AND_LINE),_masm): #define BLOCK_COMMENT(str) __ block_comment(str) #define BIND(label) __ bind(label); BLOCK_COMMENT(#label ":") #endif // The assumed minimum size of a BranchTableBlock. // The actual size of each block heavily depends on the CPU capabilities and, // of course, on the logic implemented in each block. #ifdef ASSERT #define BTB_MINSIZE 256 #else #define BTB_MINSIZE 64 #endif #ifdef ASSERT // Macro to open a BranchTableBlock (a piece of code that is branched to by a calculated branch). #define BTB_BEGIN(lbl, alignment, name) \ __ align_address(alignment); \ __ bind(lbl); \ { unsigned int b_off = __ offset(); \ uintptr_t b_addr = (uintptr_t)__ pc(); \ __ z_larl(Z_R0, (int64_t)0); /* Check current address alignment. */ \ __ z_slgr(Z_R0, br_tab); /* Current Address must be equal */ \ __ z_slgr(Z_R0, flags); /* to calculated branch target. */ \ __ z_brc(Assembler::bcondLogZero, 3); /* skip trap if ok. */ \ __ z_illtrap(0x55); \ guarantee(b_addr%alignment == 0, "bad alignment at begin of block" name); // Macro to close a BranchTableBlock (a piece of code that is branched to by a calculated branch) #define BTB_END(lbl, alignment, name) \ uintptr_t e_addr = (uintptr_t)__ pc(); \ unsigned int e_off = __ offset(); \ unsigned int len = e_off-b_off; \ if (len > alignment) { \ tty->print_cr("%4d of %4d @ " INTPTR_FORMAT ": Block len for %s", \ len, alignment, e_addr-len, name); \ guarantee(len <= alignment, "block too large"); \ } \ guarantee(len == e_addr-b_addr, "block len mismatch"); \ } #else // Macro to open a BranchTableBlock (a piece of code that is branched to by a calculated branch). #define BTB_BEGIN(lbl, alignment, name) \ __ align_address(alignment); \ __ bind(lbl); \ { unsigned int b_off = __ offset(); \ uintptr_t b_addr = (uintptr_t)__ pc(); \ guarantee(b_addr%alignment == 0, "bad alignment at begin of block" name); // Macro to close a BranchTableBlock (a piece of code that is branched to by a calculated branch) #define BTB_END(lbl, alignment, name) \ uintptr_t e_addr = (uintptr_t)__ pc(); \ unsigned int e_off = __ offset(); \ unsigned int len = e_off-b_off; \ if (len > alignment) { \ tty->print_cr("%4d of %4d @ " INTPTR_FORMAT ": Block len for %s", \ len, alignment, e_addr-len, name); \ guarantee(len <= alignment, "block too large"); \ } \ guarantee(len == e_addr-b_addr, "block len mismatch"); \ } #endif // ASSERT // Address computation: local variables static inline Address iaddress(int n) { return Address(Z_locals, Interpreter::local_offset_in_bytes(n)); } static inline Address laddress(int n) { return iaddress(n + 1); } static inline Address faddress(int n) { return iaddress(n); } static inline Address daddress(int n) { return laddress(n); } static inline Address aaddress(int n) { return iaddress(n); } // Pass NULL, if no shift instruction should be emitted. static inline Address iaddress(InterpreterMacroAssembler *masm, Register r) { if (masm) { masm->z_sllg(r, r, LogBytesPerWord); // index2bytes } return Address(Z_locals, r, Interpreter::local_offset_in_bytes(0)); } // Pass NULL, if no shift instruction should be emitted. static inline Address laddress(InterpreterMacroAssembler *masm, Register r) { if (masm) { masm->z_sllg(r, r, LogBytesPerWord); // index2bytes } return Address(Z_locals, r, Interpreter::local_offset_in_bytes(1) ); } static inline Address faddress(InterpreterMacroAssembler *masm, Register r) { return iaddress(masm, r); } static inline Address daddress(InterpreterMacroAssembler *masm, Register r) { return laddress(masm, r); } static inline Address aaddress(InterpreterMacroAssembler *masm, Register r) { return iaddress(masm, r); } // At top of Java expression stack which may be different than esp(). It // isn't for category 1 objects. static inline Address at_tos(int slot = 0) { return Address(Z_esp, Interpreter::expr_offset_in_bytes(slot)); } // Condition conversion static Assembler::branch_condition j_not(TemplateTable::Condition cc) { switch (cc) { case TemplateTable::equal : return Assembler::bcondNotEqual; case TemplateTable::not_equal : return Assembler::bcondEqual; case TemplateTable::less : return Assembler::bcondNotLow; case TemplateTable::less_equal : return Assembler::bcondHigh; case TemplateTable::greater : return Assembler::bcondNotHigh; case TemplateTable::greater_equal: return Assembler::bcondLow; } ShouldNotReachHere(); return Assembler::bcondZero; } // Do an oop store like *(base + offset) = val // offset can be a register or a constant. static void do_oop_store(InterpreterMacroAssembler* _masm, const Address& addr, Register val, // Noreg means always null. Register tmp1, Register tmp2, Register tmp3, DecoratorSet decorators) { assert_different_registers(tmp1, tmp2, tmp3, val, addr.base()); __ store_heap_oop(val, addr, tmp1, tmp2, tmp3, decorators); } static void do_oop_load(InterpreterMacroAssembler* _masm, const Address& addr, Register dst, Register tmp1, Register tmp2, DecoratorSet decorators) { assert_different_registers(addr.base(), tmp1, tmp2); assert_different_registers(dst, tmp1, tmp2); __ load_heap_oop(dst, addr, tmp1, tmp2, decorators); } Address TemplateTable::at_bcp(int offset) { assert(_desc->uses_bcp(), "inconsistent uses_bcp information"); return Address(Z_bcp, offset); } void TemplateTable::patch_bytecode(Bytecodes::Code bc, Register bc_reg, Register temp_reg, bool load_bc_into_bc_reg, // = true int byte_no) { if (!RewriteBytecodes) { return; } NearLabel L_patch_done; BLOCK_COMMENT("patch_bytecode {"); switch (bc) { case Bytecodes::_fast_aputfield: case Bytecodes::_fast_bputfield: case Bytecodes::_fast_zputfield: case Bytecodes::_fast_cputfield: case Bytecodes::_fast_dputfield: case Bytecodes::_fast_fputfield: case Bytecodes::_fast_iputfield: case Bytecodes::_fast_lputfield: case Bytecodes::_fast_sputfield: { // We skip bytecode quickening for putfield instructions when // the put_code written to the constant pool cache is zero. // This is required so that every execution of this instruction // calls out to InterpreterRuntime::resolve_get_put to do // additional, required work. assert(byte_no == f1_byte || byte_no == f2_byte, "byte_no out of range"); assert(load_bc_into_bc_reg, "we use bc_reg as temp"); __ get_cache_and_index_and_bytecode_at_bcp(Z_R1_scratch, bc_reg, temp_reg, byte_no, 1); __ load_const_optimized(bc_reg, bc); __ compareU32_and_branch(temp_reg, (intptr_t)0, Assembler::bcondZero, L_patch_done); } break; default: assert(byte_no == -1, "sanity"); // The pair bytecodes have already done the load. if (load_bc_into_bc_reg) { __ load_const_optimized(bc_reg, bc); } break; } if (JvmtiExport::can_post_breakpoint()) { Label L_fast_patch; // If a breakpoint is present we can't rewrite the stream directly. __ z_cli(at_bcp(0), Bytecodes::_breakpoint); __ z_brne(L_fast_patch); __ get_method(temp_reg); // Let breakpoint table handling rewrite to quicker bytecode. __ call_VM_static(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::set_original_bytecode_at), temp_reg, Z_R13, bc_reg); __ z_bru(L_patch_done); __ bind(L_fast_patch); } #ifdef ASSERT NearLabel L_okay; // We load into 64 bits, since this works on any CPU. __ z_llgc(temp_reg, at_bcp(0)); __ compareU32_and_branch(temp_reg, Bytecodes::java_code(bc), Assembler::bcondEqual, L_okay ); __ compareU32_and_branch(temp_reg, bc_reg, Assembler::bcondEqual, L_okay); __ stop_static("patching the wrong bytecode"); __ bind(L_okay); #endif // Patch bytecode. __ z_stc(bc_reg, at_bcp(0)); __ bind(L_patch_done); BLOCK_COMMENT("} patch_bytecode"); } // Individual instructions void TemplateTable::nop() { transition(vtos, vtos); } void TemplateTable::shouldnotreachhere() { transition(vtos, vtos); __ stop("shouldnotreachhere bytecode"); } void TemplateTable::aconst_null() { transition(vtos, atos); __ clear_reg(Z_tos, true, false); } void TemplateTable::iconst(int value) { transition(vtos, itos); // Zero extension of the iconst makes zero extension at runtime obsolete. __ load_const_optimized(Z_tos, ((unsigned long)(unsigned int)value)); } void TemplateTable::lconst(int value) { transition(vtos, ltos); __ load_const_optimized(Z_tos, value); } // No pc-relative load/store for floats. void TemplateTable::fconst(int value) { transition(vtos, ftos); static float one = 1.0f, two = 2.0f; switch (value) { case 0: __ z_lzer(Z_ftos); return; case 1: __ load_absolute_address(Z_R1_scratch, (address) &one); __ mem2freg_opt(Z_ftos, Address(Z_R1_scratch), false); return; case 2: __ load_absolute_address(Z_R1_scratch, (address) &two); __ mem2freg_opt(Z_ftos, Address(Z_R1_scratch), false); return; default: ShouldNotReachHere(); return; } } void TemplateTable::dconst(int value) { transition(vtos, dtos); static double one = 1.0; switch (value) { case 0: __ z_lzdr(Z_ftos); return; case 1: __ load_absolute_address(Z_R1_scratch, (address) &one); __ mem2freg_opt(Z_ftos, Address(Z_R1_scratch)); return; default: ShouldNotReachHere(); return; } } void TemplateTable::bipush() { transition(vtos, itos); __ z_lb(Z_tos, at_bcp(1)); } void TemplateTable::sipush() { transition(vtos, itos); __ get_2_byte_integer_at_bcp(Z_tos, 1, InterpreterMacroAssembler::Signed); } void TemplateTable::ldc(LdcType type) { transition(vtos, vtos); Label call_ldc, notFloat, notClass, notInt, Done; const Register RcpIndex = Z_tmp_1; const Register Rtags = Z_ARG2; if (is_ldc_wide(type)) { __ get_2_byte_integer_at_bcp(RcpIndex, 1, InterpreterMacroAssembler::Unsigned); } else { __ z_llgc(RcpIndex, at_bcp(1)); } __ get_cpool_and_tags(Z_tmp_2, Rtags); const int base_offset = ConstantPool::header_size() * wordSize; const int tags_offset = Array<u1>::base_offset_in_bytes(); const Register Raddr_type = Rtags; // Get address of type. __ add2reg_with_index(Raddr_type, tags_offset, RcpIndex, Rtags); __ z_cli(0, Raddr_type, JVM_CONSTANT_UnresolvedClass); __ z_bre(call_ldc); // Unresolved class - get the resolved class. __ z_cli(0, Raddr_type, JVM_CONSTANT_UnresolvedClassInError); __ z_bre(call_ldc); // Unresolved class in error state - call into runtime // to throw the error from the first resolution attempt. __ z_cli(0, Raddr_type, JVM_CONSTANT_Class); __ z_brne(notClass); // Resolved class - need to call vm to get java // mirror of the class. // We deal with a class. Call vm to do the appropriate. __ bind(call_ldc); __ load_const_optimized(Z_ARG2, is_ldc_wide(type) ? 1 : 0); call_VM(Z_RET, CAST_FROM_FN_PTR(address, InterpreterRuntime::ldc), Z_ARG2); __ push_ptr(Z_RET); __ z_bru(Done); // Not a class. __ bind(notClass); Register RcpOffset = RcpIndex; __ z_sllg(RcpOffset, RcpIndex, LogBytesPerWord); // Convert index to offset. __ z_cli(0, Raddr_type, JVM_CONSTANT_Float); __ z_brne(notFloat); // ftos __ mem2freg_opt(Z_ftos, Address(Z_tmp_2, RcpOffset, base_offset), false); __ push_f(); __ z_bru(Done); __ bind(notFloat); __ z_cli(0, Raddr_type, JVM_CONSTANT_Integer); __ z_brne(notInt); // itos __ mem2reg_opt(Z_tos, Address(Z_tmp_2, RcpOffset, base_offset), false); __ push_i(Z_tos); __ z_bru(Done); // assume the tag is for condy; if not, the VM runtime will tell us __ bind(notInt); condy_helper(Done); __ bind(Done); } // Fast path for caching oop constants. // %%% We should use this to handle Class and String constants also. // %%% It will simplify the ldc/primitive path considerably. void TemplateTable::fast_aldc(LdcType type) { transition(vtos, atos); const Register index = Z_tmp_2; int index_size = is_ldc_wide(type) ? sizeof(u2) : sizeof(u1); Label L_do_resolve, L_resolved; // We are resolved if the resolved reference cache entry contains a // non-null object (CallSite, etc.). __ get_cache_index_at_bcp(index, 1, index_size); // Load index. __ load_resolved_reference_at_index(Z_tos, index); __ z_ltgr(Z_tos, Z_tos); __ z_bre(L_do_resolve); // Convert null sentinel to NULL. __ load_const_optimized(Z_R1_scratch, (intptr_t)Universe::the_null_sentinel_addr() __ resolve_oop_handle(Z_R1_scratch); __ z_cg(Z_tos, Address(Z_R1_scratch)); __ z_brne(L_resolved); __ clear_reg(Z_tos); __ z_bru(L_resolved); __ bind(L_do_resolve); // First time invocation - must resolve first. address entry = CAST_FROM_FN_PTR(address, InterpreterRuntime::resolve_ldc); __ load_const_optimized(Z_ARG1, (int)bytecode()); __ call_VM(Z_tos, entry, Z_ARG1); __ bind(L_resolved); __ verify_oop(Z_tos); } void TemplateTable::ldc2_w() { transition(vtos, vtos); Label notDouble, notLong, Done; // Z_tmp_1 = index of cp entry __ get_2_byte_integer_at_bcp(Z_tmp_1, 1, InterpreterMacroAssembler::Unsigned); __ get_cpool_and_tags(Z_tmp_2, Z_tos); const int base_offset = ConstantPool::header_size() * wordSize; const int tags_offset = Array<u1>::base_offset_in_bytes(); // Get address of type. __ add2reg_with_index(Z_tos, tags_offset, Z_tos, Z_tmp_1); // Index needed in both branches, so calculate here. __ z_sllg(Z_tmp_1, Z_tmp_1, LogBytesPerWord); // index2bytes // Check type. __ z_cli(0, Z_tos, JVM_CONSTANT_Double); __ z_brne(notDouble); // dtos __ mem2freg_opt(Z_ftos, Address(Z_tmp_2, Z_tmp_1, base_offset)); __ push_d(); __ z_bru(Done); __ bind(notDouble); __ z_cli(0, Z_tos, JVM_CONSTANT_Long); __ z_brne(notLong); // ltos __ mem2reg_opt(Z_tos, Address(Z_tmp_2, Z_tmp_1, base_offset)); __ push_l(); __ z_bru(Done); __ bind(notLong); condy_helper(Done); __ bind(Done); } void TemplateTable::condy_helper(Label& Done) { const Register obj = Z_tmp_1; const Register off = Z_tmp_2; const Register flags = Z_ARG1; const Register rarg = Z_ARG2; __ load_const_optimized(rarg, (int)bytecode()); call_VM(obj, CAST_FROM_FN_PTR(address, InterpreterRuntime::resolve_ldc), rarg); __ get_vm_result_2(flags); // VMr = obj = base address to find primitive value to push // VMr2 = flags = (tos, off) using format of CPCE::_flags assert(ConstantPoolCacheEntry::field_index_mask == 0xffff, "or use other instructio __ z_llghr(off, flags); const Address field(obj, off); // What sort of thing are we loading? __ z_srl(flags, ConstantPoolCacheEntry::tos_state_shift); // Make sure we don't need to mask flags for tos_state after the above shift. ConstantPoolCacheEntry::verify_tos_state_shift(); switch (bytecode()) { case Bytecodes::_ldc: case Bytecodes::_ldc_w: { // tos in (itos, ftos, stos, btos, ctos, ztos) Label notInt, notFloat, notShort, notByte, notChar, notBool; __ z_cghi(flags, itos); __ z_brne(notInt); // itos __ z_l(Z_tos, field); __ push(itos); __ z_bru(Done); __ bind(notInt); __ z_cghi(flags, ftos); __ z_brne(notFloat); // ftos __ z_le(Z_ftos, field); __ push(ftos); __ z_bru(Done); __ bind(notFloat); __ z_cghi(flags, stos); __ z_brne(notShort); // stos __ z_lh(Z_tos, field); __ push(stos); __ z_bru(Done); __ bind(notShort); __ z_cghi(flags, btos); __ z_brne(notByte); // btos __ z_lb(Z_tos, field); __ push(btos); __ z_bru(Done); __ bind(notByte); __ z_cghi(flags, ctos); __ z_brne(notChar); // ctos __ z_llh(Z_tos, field); __ push(ctos); __ z_bru(Done); __ bind(notChar); __ z_cghi(flags, ztos); __ z_brne(notBool); // ztos __ z_lb(Z_tos, field); __ push(ztos); __ z_bru(Done); __ bind(notBool); break; } case Bytecodes::_ldc2_w: { Label notLong, notDouble; __ z_cghi(flags, ltos); __ z_brne(notLong); // ltos __ z_lg(Z_tos, field); __ push(ltos); __ z_bru(Done); __ bind(notLong); __ z_cghi(flags, dtos); __ z_brne(notDouble); // dtos __ z_ld(Z_ftos, field); __ push(dtos); __ z_bru(Done); __ bind(notDouble); break; } default: ShouldNotReachHere(); } __ stop("bad ldc/condy"); } void TemplateTable::locals_index(Register reg, int offset) { __ z_llgc(reg, at_bcp(offset)); __ z_lcgr(reg); } void TemplateTable::iload() { iload_internal(); } void TemplateTable::nofast_iload() { iload_internal(may_not_rewrite); } void TemplateTable::iload_internal(RewriteControl rc) { transition(vtos, itos); if (RewriteFrequentPairs && rc == may_rewrite) { NearLabel rewrite, done; const Register bc = Z_ARG4; assert(Z_R1_scratch != bc, "register damaged"); // Get next byte. __ z_llgc(Z_R1_scratch, at_bcp(Bytecodes::length_for (Bytecodes::_iload))); // If _iload, wait to rewrite to iload2. We only want to rewrite the // last two iloads in a pair. Comparing against fast_iload means that // the next bytecode is neither an iload or a caload, and therefore // an iload pair. __ compareU32_and_branch(Z_R1_scratch, Bytecodes::_iload, Assembler::bcondEqual, done); __ load_const_optimized(bc, Bytecodes::_fast_iload2); __ compareU32_and_branch(Z_R1_scratch, Bytecodes::_fast_iload, Assembler::bcondEqual, rewrite); // If _caload, rewrite to fast_icaload. __ load_const_optimized(bc, Bytecodes::_fast_icaload); __ compareU32_and_branch(Z_R1_scratch, Bytecodes::_caload, Assembler::bcondEqual, rewrite); // Rewrite so iload doesn't check again. __ load_const_optimized(bc, Bytecodes::_fast_iload); // rewrite // bc: fast bytecode __ bind(rewrite); patch_bytecode(Bytecodes::_iload, bc, Z_R1_scratch, false); __ bind(done); } // Get the local value into tos. locals_index(Z_R1_scratch); __ mem2reg_opt(Z_tos, iaddress(_masm, Z_R1_scratch), false); } void TemplateTable::fast_iload2() { transition(vtos, itos); locals_index(Z_R1_scratch); __ mem2reg_opt(Z_tos, iaddress(_masm, Z_R1_scratch), false); __ push_i(Z_tos); locals_index(Z_R1_scratch, 3); __ mem2reg_opt(Z_tos, iaddress(_masm, Z_R1_scratch), false); } void TemplateTable::fast_iload() { transition(vtos, itos); locals_index(Z_R1_scratch); __ mem2reg_opt(Z_tos, iaddress(_masm, Z_R1_scratch), false); } void TemplateTable::lload() { transition(vtos, ltos); locals_index(Z_R1_scratch); __ mem2reg_opt(Z_tos, laddress(_masm, Z_R1_scratch)); } void TemplateTable::fload() { transition(vtos, ftos); locals_index(Z_R1_scratch); __ mem2freg_opt(Z_ftos, faddress(_masm, Z_R1_scratch), false); } void TemplateTable::dload() { transition(vtos, dtos); locals_index(Z_R1_scratch); __ mem2freg_opt(Z_ftos, daddress(_masm, Z_R1_scratch)); } void TemplateTable::aload() { transition(vtos, atos); locals_index(Z_R1_scratch); __ mem2reg_opt(Z_tos, aaddress(_masm, Z_R1_scratch)); } void TemplateTable::locals_index_wide(Register reg) { __ get_2_byte_integer_at_bcp(reg, 2, InterpreterMacroAssembler::Unsigned); __ z_lcgr(reg); } void TemplateTable::wide_iload() { transition(vtos, itos); locals_index_wide(Z_tmp_1); __ mem2reg_opt(Z_tos, iaddress(_masm, Z_tmp_1), false); } void TemplateTable::wide_lload() { transition(vtos, ltos); locals_index_wide(Z_tmp_1); __ mem2reg_opt(Z_tos, laddress(_masm, Z_tmp_1)); } void TemplateTable::wide_fload() { transition(vtos, ftos); locals_index_wide(Z_tmp_1); __ mem2freg_opt(Z_ftos, faddress(_masm, Z_tmp_1), false); } void TemplateTable::wide_dload() { transition(vtos, dtos); locals_index_wide(Z_tmp_1); __ mem2freg_opt(Z_ftos, daddress(_masm, Z_tmp_1)); } void TemplateTable::wide_aload() { transition(vtos, atos); locals_index_wide(Z_tmp_1); __ mem2reg_opt(Z_tos, aaddress(_masm, Z_tmp_1)); } void TemplateTable::index_check(Register array, Register index, unsigned int shift) { assert_different_registers(Z_R1_scratch, array, index); // Check array. __ null_check(array, Z_R0_scratch, arrayOopDesc::length_offset_in_bytes()); // Sign extend index for use by indexed load. __ z_lgfr(index, index); // Check index. Label index_ok; __ z_cl(index, Address(array, arrayOopDesc::length_offset_in_bytes())); __ z_brl(index_ok); __ lgr_if_needed(Z_ARG3, index); // See generate_ArrayIndexOutOfBounds_handler(). // Pass the array to create more detailed exceptions. __ lgr_if_needed(Z_ARG2, array); // See generate_ArrayIndexOutOfBounds_handler(). __ load_absolute_address(Z_R1_scratch, Interpreter::_throw_ArrayIndexOutOfBoundsException_entry); __ z_bcr(Assembler::bcondAlways, Z_R1_scratch); __ bind(index_ok); if (shift > 0) __ z_sllg(index, index, shift); } void TemplateTable::iaload() { transition(itos, itos); __ pop_ptr(Z_tmp_1); // array // Index is in Z_tos. Register index = Z_tos; index_check(Z_tmp_1, index, LogBytesPerInt); // Kills Z_ARG3. // Load the value. __ mem2reg_opt(Z_tos, Address(Z_tmp_1, index, arrayOopDesc::base_offset_in_bytes(T_INT)), false); } void TemplateTable::laload() { transition(itos, ltos); __ pop_ptr(Z_tmp_2); // Z_tos : index // Z_tmp_2 : array Register index = Z_tos; index_check(Z_tmp_2, index, LogBytesPerLong); __ mem2reg_opt(Z_tos, Address(Z_tmp_2, index, arrayOopDesc::base_offset_in_bytes(T_LONG))); } void TemplateTable::faload() { transition(itos, ftos); __ pop_ptr(Z_tmp_2); // Z_tos : index // Z_tmp_2 : array Register index = Z_tos; index_check(Z_tmp_2, index, LogBytesPerInt); __ mem2freg_opt(Z_ftos, Address(Z_tmp_2, index, arrayOopDesc::base_offset_in_bytes(T_FLOAT)), false); } void TemplateTable::daload() { transition(itos, dtos); __ pop_ptr(Z_tmp_2); // Z_tos : index // Z_tmp_2 : array Register index = Z_tos; index_check(Z_tmp_2, index, LogBytesPerLong); __ mem2freg_opt(Z_ftos, Address(Z_tmp_2, index, arrayOopDesc::base_offset_in_bytes(T_DOUBLE))); } void TemplateTable::aaload() { transition(itos, atos); unsigned const int shift = LogBytesPerHeapOop; __ pop_ptr(Z_tmp_1); // array // Index is in Z_tos. Register index = Z_tos; index_check(Z_tmp_1, index, shift); // Now load array element. do_oop_load(_masm, Address(Z_tmp_1, index, arrayOopDesc::base_offset_in_bytes(T_OBJ Z_tmp_2, Z_tmp_3, IS_ARRAY); __ verify_oop(Z_tos); } void TemplateTable::baload() { transition(itos, itos); __ pop_ptr(Z_tmp_1); // Z_tos : index // Z_tmp_1 : array Register index = Z_tos; index_check(Z_tmp_1, index, 0); __ z_lb(Z_tos, Address(Z_tmp_1, index, arrayOopDesc::base_offset_in_bytes(T_BYTE))); } void TemplateTable::caload() { transition(itos, itos); __ pop_ptr(Z_tmp_2); // Z_tos : index // Z_tmp_2 : array Register index = Z_tos; index_check(Z_tmp_2, index, LogBytesPerShort); // Load into 64 bits, works on all CPUs. __ z_llgh(Z_tos, Address(Z_tmp_2, index, arrayOopDesc::base_offset_in_bytes(T_CHAR))); } // Iload followed by caload frequent pair. void TemplateTable::fast_icaload() { transition(vtos, itos); // Load index out of locals. locals_index(Z_R1_scratch); __ mem2reg_opt(Z_ARG3, iaddress(_masm, Z_R1_scratch), false); // Z_ARG3 : index // Z_tmp_2 : array __ pop_ptr(Z_tmp_2); index_check(Z_tmp_2, Z_ARG3, LogBytesPerShort); // Load into 64 bits, works on all CPUs. __ z_llgh(Z_tos, Address(Z_tmp_2, Z_ARG3, arrayOopDesc::base_offset_in_bytes(T_CHAR))); } void TemplateTable::saload() { transition(itos, itos); __ pop_ptr(Z_tmp_2); // Z_tos : index // Z_tmp_2 : array Register index = Z_tos; index_check(Z_tmp_2, index, LogBytesPerShort); __ z_lh(Z_tos, Address(Z_tmp_2, index, arrayOopDesc::base_offset_in_bytes(T_SHORT))); } void TemplateTable::iload(int n) { transition(vtos, itos); __ z_ly(Z_tos, iaddress(n)); } void TemplateTable::lload(int n) { transition(vtos, ltos); __ z_lg(Z_tos, laddress(n)); } void TemplateTable::fload(int n) { transition(vtos, ftos); __ mem2freg_opt(Z_ftos, faddress(n), false); } void TemplateTable::dload(int n) { transition(vtos, dtos); __ mem2freg_opt(Z_ftos, daddress(n)); } void TemplateTable::aload(int n) { transition(vtos, atos); __ mem2reg_opt(Z_tos, aaddress(n)); } 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 // _aload_0, _fast_fgetfield // // occur frequently. If RewriteFrequentPairs is set, the (slow) // _aload_0 bytecode checks if the next bytecode is either // _fast_igetfield, _fast_agetfield or _fast_fgetfield and then // rewrites the current bytecode into a pair bytecode; otherwise it // rewrites the current bytecode into _fast_aload_0 that doesn't do // the pair check anymore. // // Note: If the next bytecode is _getfield, the rewrite must be // delayed, otherwise we may miss an opportunity for a pair. // // Also rewrite frequent pairs // 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))) { aload(0); return; } NearLabel rewrite, done; const Register bc = Z_ARG4; assert(Z_R1_scratch != bc, "register damaged"); // Get next byte. __ z_llgc(Z_R1_scratch, at_bcp(Bytecodes::length_for (Bytecodes::_aload_0))); // Do actual aload_0. aload(0); // If _getfield then wait with rewrite. __ compareU32_and_branch(Z_R1_scratch, Bytecodes::_getfield, Assembler::bcondEqual, done); // If _igetfield then rewrite to _fast_iaccess_0. assert(Bytecodes::java_code(Bytecodes::_fast_iaccess_0) == Bytecodes::_aload_0, "fix bytecode definition"); __ load_const_optimized(bc, Bytecodes::_fast_iaccess_0); __ compareU32_and_branch(Z_R1_scratch, Bytecodes::_fast_igetfield, Assembler::bcondEqual, rewrite); // If _agetfield then rewrite to _fast_aaccess_0. assert(Bytecodes::java_code(Bytecodes::_fast_aaccess_0) == Bytecodes::_aload_0, "fix bytecode definition"); __ load_const_optimized(bc, Bytecodes::_fast_aaccess_0); __ compareU32_and_branch(Z_R1_scratch, Bytecodes::_fast_agetfield, Assembler::bcondEqual, rewrite); // If _fgetfield then rewrite to _fast_faccess_0. assert(Bytecodes::java_code(Bytecodes::_fast_faccess_0) == Bytecodes::_aload_0, "fix bytecode definition"); __ load_const_optimized(bc, Bytecodes::_fast_faccess_0); __ compareU32_and_branch(Z_R1_scratch, Bytecodes::_fast_fgetfield, Assembler::bcondEqual, rewrite); // Else rewrite to _fast_aload0. assert(Bytecodes::java_code(Bytecodes::_fast_aload_0) == Bytecodes::_aload_0, "fix bytecode definition"); __ load_const_optimized(bc, Bytecodes::_fast_aload_0); // rewrite // bc: fast bytecode __ bind(rewrite); patch_bytecode(Bytecodes::_aload_0, bc, Z_R1_scratch, false); // Reload local 0 because of VM call inside patch_bytecode(). // this may trigger GC and thus change the oop. aload(0); __ bind(done); } void TemplateTable::istore() { transition(itos, vtos); locals_index(Z_R1_scratch); __ reg2mem_opt(Z_tos, iaddress(_masm, Z_R1_scratch), false); } void TemplateTable::lstore() { transition(ltos, vtos); locals_index(Z_R1_scratch); __ reg2mem_opt(Z_tos, laddress(_masm, Z_R1_scratch)); } void TemplateTable::fstore() { transition(ftos, vtos); locals_index(Z_R1_scratch); __ freg2mem_opt(Z_ftos, faddress(_masm, Z_R1_scratch)); } void TemplateTable::dstore() { transition(dtos, vtos); locals_index(Z_R1_scratch); __ freg2mem_opt(Z_ftos, daddress(_masm, Z_R1_scratch)); } void TemplateTable::astore() { transition(vtos, vtos); __ pop_ptr(Z_tos); locals_index(Z_R1_scratch); __ reg2mem_opt(Z_tos, aaddress(_masm, Z_R1_scratch)); } void TemplateTable::wide_istore() { transition(vtos, vtos); __ pop_i(Z_tos); locals_index_wide(Z_tmp_1); __ reg2mem_opt(Z_tos, iaddress(_masm, Z_tmp_1), false); } void TemplateTable::wide_lstore() { transition(vtos, vtos); __ pop_l(Z_tos); locals_index_wide(Z_tmp_1); __ reg2mem_opt(Z_tos, laddress(_masm, Z_tmp_1)); } void TemplateTable::wide_fstore() { transition(vtos, vtos); __ pop_f(Z_ftos); locals_index_wide(Z_tmp_1); __ freg2mem_opt(Z_ftos, faddress(_masm, Z_tmp_1), false); } void TemplateTable::wide_dstore() { transition(vtos, vtos); __ pop_d(Z_ftos); locals_index_wide(Z_tmp_1); __ freg2mem_opt(Z_ftos, daddress(_masm, Z_tmp_1)); } void TemplateTable::wide_astore() { transition(vtos, vtos); __ pop_ptr(Z_tos); locals_index_wide(Z_tmp_1); __ reg2mem_opt(Z_tos, aaddress(_masm, Z_tmp_1)); } void TemplateTable::iastore() { transition(itos, vtos); Register index = Z_ARG3; // Index_check expects index in Z_ARG3. // Value is in Z_tos ... __ pop_i(index); // index __ pop_ptr(Z_tmp_1); // array index_check(Z_tmp_1, index, LogBytesPerInt); // ... and then move the value. __ reg2mem_opt(Z_tos, Address(Z_tmp_1, index, arrayOopDesc::base_offset_in_bytes(T_INT)), false); } void TemplateTable::lastore() { transition(ltos, vtos); __ pop_i(Z_ARG3); __ pop_ptr(Z_tmp_2); // Z_tos : value // Z_ARG3 : index // Z_tmp_2 : array index_check(Z_tmp_2, Z_ARG3, LogBytesPerLong); // Prefer index in Z_ARG3. __ reg2mem_opt(Z_tos, Address(Z_tmp_2, Z_ARG3, arrayOopDesc::base_offset_in_bytes(T_LONG))); } void TemplateTable::fastore() { transition(ftos, vtos); __ pop_i(Z_ARG3); __ pop_ptr(Z_tmp_2); // Z_ftos : value // Z_ARG3 : index // Z_tmp_2 : array index_check(Z_tmp_2, Z_ARG3, LogBytesPerInt); // Prefer index in Z_ARG3. __ freg2mem_opt(Z_ftos, Address(Z_tmp_2, Z_ARG3, arrayOopDesc::base_offset_in_bytes(T_FLOAT)), false); } void TemplateTable::dastore() { transition(dtos, vtos); __ pop_i(Z_ARG3); __ pop_ptr(Z_tmp_2); // Z_ftos : value // Z_ARG3 : index // Z_tmp_2 : array index_check(Z_tmp_2, Z_ARG3, LogBytesPerLong); // Prefer index in Z_ARG3. __ freg2mem_opt(Z_ftos, Address(Z_tmp_2, Z_ARG3, arrayOopDesc::base_offset_in_bytes(T_DOUBLE))); } void TemplateTable::aastore() { NearLabel is_null, ok_is_subtype, done; transition(vtos, vtos); // stack: ..., array, index, value Register Rvalue = Z_tos; Register Rarray = Z_ARG2; Register Rindex = Z_ARG3; // Convention for index_check(). __ load_ptr(0, Rvalue); __ z_l(Rindex, Address(Z_esp, Interpreter::expr_offset_in_bytes(1))); __ load_ptr(2, Rarray); unsigned const int shift = LogBytesPerHeapOop; index_check(Rarray, Rindex, shift); // side effect: Rindex = Rindex << shift Register Rstore_addr = Rindex; // Address where the store goes to, i.e. &(Rarry[index]) __ load_address(Rstore_addr, Address(Rarray, Rindex, arrayOopDesc::base_offset_in_by // do array store check - check for NULL value first. __ compareU64_and_branch(Rvalue, (intptr_t)0, Assembler::bcondEqual, is_null); Register Rsub_klass = Z_ARG4; Register Rsuper_klass = Z_ARG5; __ load_klass(Rsub_klass, Rvalue); // Load superklass. __ load_klass(Rsuper_klass, Rarray); __ z_lg(Rsuper_klass, Address(Rsuper_klass, ObjArrayKlass::element_klass_offset())) // Generate a fast subtype check. Branch to ok_is_subtype if no failure. // Throw if failure. Register tmp1 = Z_tmp_1; Register tmp2 = Z_tmp_2; __ gen_subtype_check(Rsub_klass, Rsuper_klass, tmp1, tmp2, ok_is_subtype); // Fall through on failure. // Object is in Rvalue == Z_tos. assert(Rvalue == Z_tos, "that's the expected location"); __ load_absolute_address(tmp1, Interpreter::_throw_ArrayStoreException_entry); __ z_br(tmp1); Register tmp3 = Rsub_klass; // Have a NULL in Rvalue. __ bind(is_null); __ profile_null_seen(tmp1); // Store a NULL. do_oop_store(_masm, Address(Rstore_addr, (intptr_t)0), noreg, tmp3, tmp2, tmp1, IS_ARRAY); __ z_bru(done); // Come here on success. __ bind(ok_is_subtype); // Now store using the appropriate barrier. do_oop_store(_masm, Address(Rstore_addr, (intptr_t)0), Rvalue, tmp3, tmp2, tmp1, IS_ARRAY | IS_NOT_NULL); // Pop stack arguments. __ bind(done); __ add2reg(Z_esp, 3 * Interpreter::stackElementSize); } void TemplateTable::bastore() { transition(itos, vtos); __ pop_i(Z_ARG3); __ pop_ptr(Z_tmp_2); // Z_tos : value // Z_ARG3 : index // Z_tmp_2 : array // Need to check whether array is boolean or byte // since both types share the bastore bytecode. __ load_klass(Z_tmp_1, Z_tmp_2); __ z_llgf(Z_tmp_1, Address(Z_tmp_1, Klass::layout_helper_offset())); __ z_tmll(Z_tmp_1, Klass::layout_helper_boolean_diffbit()); Label L_skip; __ z_bfalse(L_skip); // if it is a T_BOOLEAN array, mask the stored value to 0/1 __ z_nilf(Z_tos, 0x1); __ bind(L_skip); // No index shift necessary - pass 0. index_check(Z_tmp_2, Z_ARG3, 0); // Prefer index in Z_ARG3. __ z_stc(Z_tos, Address(Z_tmp_2, Z_ARG3, arrayOopDesc::base_offset_in_bytes(T_BYTE))); } void TemplateTable::castore() { transition(itos, vtos); __ pop_i(Z_ARG3); __ pop_ptr(Z_tmp_2); // Z_tos : value // Z_ARG3 : index // Z_tmp_2 : array Register index = Z_ARG3; // prefer index in Z_ARG3 index_check(Z_tmp_2, index, LogBytesPerShort); __ z_sth(Z_tos, Address(Z_tmp_2, index, arrayOopDesc::base_offset_in_bytes(T_CHAR))); } void TemplateTable::sastore() { castore(); } void TemplateTable::istore(int n) { transition(itos, vtos); __ reg2mem_opt(Z_tos, iaddress(n), false); } void TemplateTable::lstore(int n) { transition(ltos, vtos); __ reg2mem_opt(Z_tos, laddress(n)); } void TemplateTable::fstore(int n) { transition(ftos, vtos); __ freg2mem_opt(Z_ftos, faddress(n), false); } void TemplateTable::dstore(int n) { transition(dtos, vtos); __ freg2mem_opt(Z_ftos, daddress(n)); } void TemplateTable::astore(int n) { transition(vtos, vtos); __ pop_ptr(Z_tos); __ reg2mem_opt(Z_tos, aaddress(n)); } void TemplateTable::pop() { transition(vtos, vtos); __ add2reg(Z_esp, Interpreter::stackElementSize); } void TemplateTable::pop2() { transition(vtos, vtos); __ add2reg(Z_esp, 2 * Interpreter::stackElementSize); } void TemplateTable::dup() { transition(vtos, vtos); __ load_ptr(0, Z_tos); __ push_ptr(Z_tos); // stack: ..., a, a } void TemplateTable::dup_x1() { transition(vtos, vtos); // stack: ..., a, b __ load_ptr(0, Z_tos); // load b __ load_ptr(1, Z_R0_scratch); // load a __ store_ptr(1, Z_tos); // store b __ store_ptr(0, Z_R0_scratch); // store a __ push_ptr(Z_tos); // push b // stack: ..., b, a, b } void TemplateTable::dup_x2() { transition(vtos, vtos); // stack: ..., a, b, c __ load_ptr(0, Z_R0_scratch); // load c __ load_ptr(2, Z_R1_scratch); // load a __ store_ptr(2, Z_R0_scratch); // store c in a __ push_ptr(Z_R0_scratch); // push c // stack: ..., c, b, c, c __ load_ptr(2, Z_R0_scratch); // load b __ store_ptr(2, Z_R1_scratch); // store a in b // stack: ..., c, a, c, c __ store_ptr(1, Z_R0_scratch); // store b in c // stack: ..., c, a, b, c } void TemplateTable::dup2() { transition(vtos, vtos); // stack: ..., a, b __ load_ptr(1, Z_R0_scratch); // load a __ push_ptr(Z_R0_scratch); // push a __ load_ptr(1, Z_R0_scratch); // load b __ push_ptr(Z_R0_scratch); // push b // stack: ..., a, b, a, b } void TemplateTable::dup2_x1() { transition(vtos, vtos); // stack: ..., a, b, c __ load_ptr(0, Z_R0_scratch); // load c __ load_ptr(1, Z_R1_scratch); // load b __ push_ptr(Z_R1_scratch); // push b __ push_ptr(Z_R0_scratch); // push c // stack: ..., a, b, c, b, c __ store_ptr(3, Z_R0_scratch); // store c in b // stack: ..., a, c, c, b, c __ load_ptr( 4, Z_R0_scratch); // load a __ store_ptr(2, Z_R0_scratch); // store a in 2nd c // stack: ..., a, c, a, b, c __ store_ptr(4, Z_R1_scratch); // store b in a // stack: ..., b, c, a, b, c } void TemplateTable::dup2_x2() { transition(vtos, vtos); // stack: ..., a, b, c, d __ load_ptr(0, Z_R0_scratch); // load d __ load_ptr(1, Z_R1_scratch); // load c __ push_ptr(Z_R1_scratch); // push c __ push_ptr(Z_R0_scratch); // push d // stack: ..., a, b, c, d, c, d __ load_ptr(4, Z_R1_scratch); // load b __ store_ptr(2, Z_R1_scratch); // store b in d __ store_ptr(4, Z_R0_scratch); // store d in b // stack: ..., a, d, c, b, c, d __ load_ptr(5, Z_R0_scratch); // load a __ load_ptr(3, Z_R1_scratch); // load c __ store_ptr(3, Z_R0_scratch); // store a in c __ store_ptr(5, Z_R1_scratch); // store c in a // stack: ..., c, d, a, b, c, d } void TemplateTable::swap() { transition(vtos, vtos); // stack: ..., a, b __ load_ptr(1, Z_R0_scratch); // load a __ load_ptr(0, Z_R1_scratch); // load b __ store_ptr(0, Z_R0_scratch); // store a in b __ store_ptr(1, Z_R1_scratch); // store b in a // stack: ..., b, a } void TemplateTable::iop2(Operation op) { transition(itos, itos); switch (op) { case add : __ z_ay(Z_tos, __ stackTop()); __ pop_i(); break; case sub : __ z_sy(Z_tos, __ stackTop()); __ pop_i(); __ z_lcr(Z_tos, Z_tos); break; case mul : __ z_msy(Z_tos, __ stackTop()); __ pop_i(); break; case _and : __ z_ny(Z_tos, __ stackTop()); __ pop_i(); break; case _or : __ z_oy(Z_tos, __ stackTop()); __ pop_i(); break; case _xor : __ z_xy(Z_tos, __ stackTop()); __ pop_i(); break; case shl : __ z_lr(Z_tmp_1, Z_tos); __ z_nill(Z_tmp_1, 31); // Lowest 5 bits are shiftamount. __ pop_i(Z_tos); __ z_sll(Z_tos, 0, Z_tmp_1); break; case shr : __ z_lr(Z_tmp_1, Z_tos); __ z_nill(Z_tmp_1, 31); // Lowest 5 bits are shiftamount. __ pop_i(Z_tos); __ z_sra(Z_tos, 0, Z_tmp_1); break; case ushr : __ z_lr(Z_tmp_1, Z_tos); __ z_nill(Z_tmp_1, 31); // Lowest 5 bits are shiftamount. __ pop_i(Z_tos); __ z_srl(Z_tos, 0, Z_tmp_1); break; default : ShouldNotReachHere(); break; } return; } void TemplateTable::lop2(Operation op) { transition(ltos, ltos); switch (op) { case add : __ z_ag(Z_tos, __ stackTop()); __ pop_l(); break; case sub : __ z_sg(Z_tos, __ stackTop()); __ pop_l(); __ z_lcgr(Z_tos, Z_tos); break; case mul : __ z_msg(Z_tos, __ stackTop()); __ pop_l(); break; case _and : __ z_ng(Z_tos, __ stackTop()); __ pop_l(); break; case _or : __ z_og(Z_tos, __ stackTop()); __ pop_l(); break; case _xor : __ z_xg(Z_tos, __ stackTop()); __ pop_l(); break; default : ShouldNotReachHere(); break; } return; } // Common part of idiv/irem. static void idiv_helper(InterpreterMacroAssembler * _masm, address exception) { NearLabel not_null; // Use register pair Z_tmp_1, Z_tmp_2 for DIVIDE SINGLE. assert(Z_tmp_1->successor() == Z_tmp_2, " need even/odd register pair for idiv/irem" // Get dividend. __ pop_i(Z_tmp_2); // If divisor == 0 throw exception. __ compare32_and_branch(Z_tos, (intptr_t) 0, Assembler::bcondNotEqual, not_null ); __ load_absolute_address(Z_R1_scratch, exception); __ z_br(Z_R1_scratch); __ bind(not_null); __ z_lgfr(Z_tmp_2, Z_tmp_2); // Sign extend dividend. __ z_dsgfr(Z_tmp_1, Z_tos); // Do it. } void TemplateTable::idiv() { transition(itos, itos); idiv_helper(_masm, Interpreter::_throw_ArithmeticException_entry); __ z_llgfr(Z_tos, Z_tmp_2); // Result is in Z_tmp_2. } void TemplateTable::irem() { transition(itos, itos); idiv_helper(_masm, Interpreter::_throw_ArithmeticException_entry); __ z_llgfr(Z_tos, Z_tmp_1); // Result is in Z_tmp_1. } void TemplateTable::lmul() { transition(ltos, ltos); // Multiply with memory operand. __ z_msg(Z_tos, __ stackTop()); __ pop_l(); // Pop operand. } // Common part of ldiv/lrem. // // Input: // Z_tos := the divisor (dividend still on stack) // // Updated registers: // Z_tmp_1 := pop_l() % Z_tos ; if is_ldiv == false // Z_tmp_2 := pop_l() / Z_tos ; if is_ldiv == true // static void ldiv_helper(InterpreterMacroAssembler * _masm, address exception, bool is_ld NearLabel not_null, done; // Use register pair Z_tmp_1, Z_tmp_2 for DIVIDE SINGLE. assert(Z_tmp_1->successor() == Z_tmp_2, " need even/odd register pair for idiv/irem"); // Get dividend. __ pop_l(Z_tmp_2); // If divisor == 0 throw exception. __ compare64_and_branch(Z_tos, (intptr_t)0, Assembler::bcondNotEqual, not_null); __ load_absolute_address(Z_R1_scratch, exception); __ z_br(Z_R1_scratch); __ bind(not_null); // Special case for dividend == 0x8000 and divisor == -1. if (is_ldiv) { // result := Z_tmp_2 := - dividend __ z_lcgr(Z_tmp_2, Z_tmp_2); } else { // result remainder := Z_tmp_1 := 0 __ clear_reg(Z_tmp_1, true, false); // Don't set CC. } // if divisor == -1 goto done __ compare64_and_branch(Z_tos, -1, Assembler::bcondEqual, done); if (is_ldiv) // Restore sign, because divisor != -1. __ z_lcgr(Z_tmp_2, Z_tmp_2); __ z_dsgr(Z_tmp_1, Z_tos); // Do it. __ bind(done); } void TemplateTable::ldiv() { transition(ltos, ltos); ldiv_helper(_masm, Interpreter::_throw_ArithmeticException_entry, true /*is_ldiv*/) __ z_lgr(Z_tos, Z_tmp_2); // Result is in Z_tmp_2. } void TemplateTable::lrem() { transition(ltos, ltos); ldiv_helper(_masm, Interpreter::_throw_ArithmeticException_entry, false /*is_ldiv*/ __ z_lgr(Z_tos, Z_tmp_1); // Result is in Z_tmp_1. } void TemplateTable::lshl() { transition(itos, ltos); // Z_tos: shift amount __ pop_l(Z_tmp_1); // Get shift value. __ z_sllg(Z_tos, Z_tmp_1, 0, Z_tos); } void TemplateTable::lshr() { transition(itos, ltos); // Z_tos: shift amount __ pop_l(Z_tmp_1); // Get shift value. __ z_srag(Z_tos, Z_tmp_1, 0, Z_tos); } void TemplateTable::lushr() { transition(itos, ltos); // Z_tos: shift amount __ pop_l(Z_tmp_1); // Get shift value. __ z_srlg(Z_tos, Z_tmp_1, 0, Z_tos); } void TemplateTable::fop2(Operation op) { transition(ftos, ftos); switch (op) { case add: // Add memory operand. __ z_aeb(Z_ftos, __ stackTop()); __ pop_f(); return; case sub: // Sub memory operand. __ z_ler(Z_F1, Z_ftos); // first operand __ pop_f(Z_ftos); // second operand from stack __ z_sebr(Z_ftos, Z_F1); return; case mul: // Multiply with memory operand. __ z_meeb(Z_ftos, __ stackTop()); __ pop_f(); return; case div: __ z_ler(Z_F1, Z_ftos); // first operand __ pop_f(Z_ftos); // second operand from stack __ z_debr(Z_ftos, Z_F1); return; case rem: // Do runtime call. __ z_ler(Z_FARG2, Z_ftos); // divisor __ pop_f(Z_FARG1); // dividend __ call_VM_leaf(CAST_FROM_FN_PTR(address, SharedRuntime::frem)); // Result should be in the right place (Z_ftos == Z_FRET). return; default: ShouldNotReachHere(); return; } } void TemplateTable::dop2(Operation op) { transition(dtos, dtos); switch (op) { case add: // Add memory operand. __ z_adb(Z_ftos, __ stackTop()); __ pop_d(); return; case sub: // Sub memory operand. __ z_ldr(Z_F1, Z_ftos); // first operand __ pop_d(Z_ftos); // second operand from stack __ z_sdbr(Z_ftos, Z_F1); return; case mul: // Multiply with memory operand. __ z_mdb(Z_ftos, __ stackTop()); __ pop_d(); return; case div: __ z_ldr(Z_F1, Z_ftos); // first operand __ pop_d(Z_ftos); // second operand from stack __ z_ddbr(Z_ftos, Z_F1); return; case rem: // Do runtime call. __ z_ldr(Z_FARG2, Z_ftos); // divisor __ pop_d(Z_FARG1); // dividend __ call_VM_leaf(CAST_FROM_FN_PTR(address, SharedRuntime::drem)); // Result should be in the right place (Z_ftos == Z_FRET). return; default: ShouldNotReachHere(); return; } } void TemplateTable::ineg() { transition(itos, itos); __ z_lcr(Z_tos); } void TemplateTable::lneg() { transition(ltos, ltos); __ z_lcgr(Z_tos); } void TemplateTable::fneg() { transition(ftos, ftos); __ z_lcebr(Z_ftos, Z_ftos); } void TemplateTable::dneg() { transition(dtos, dtos); __ z_lcdbr(Z_ftos, Z_ftos); } void TemplateTable::iinc() { transition(vtos, vtos); Address local; __ z_lb(Z_R0_scratch, at_bcp(2)); // Get constant. locals_index(Z_R1_scratch); local = iaddress(_masm, Z_R1_scratch); __ z_a(Z_R0_scratch, local); __ reg2mem_opt(Z_R0_scratch, local, false); } void TemplateTable::wide_iinc() { transition(vtos, vtos); // Z_tmp_1 := increment __ get_2_byte_integer_at_bcp(Z_tmp_1, 4, InterpreterMacroAssembler::Signed); // Z_R1_scratch := index of local to increment locals_index_wide(Z_tmp_2); // Load, increment, and store. __ access_local_int(Z_tmp_2, Z_tos); __ z_agr(Z_tos, Z_tmp_1); // Shifted index is still in Z_tmp_2. __ reg2mem_opt(Z_tos, Address(Z_locals, Z_tmp_2), false); } void TemplateTable::convert() { // Checking #ifdef ASSERT TosState tos_in = ilgl; TosState tos_out = ilgl; switch (bytecode()) { case Bytecodes::_i2l: case Bytecodes::_i2f: case Bytecodes::_i2d: case Bytecodes::_i2b: case Bytecodes::_i2c: case Bytecodes::_i2s: tos_in = itos; break; case Bytecodes::_l2i: case Bytecodes::_l2f: case Bytecodes::_l2d: tos_in = ltos; break; case Bytecodes::_f2i: case Bytecodes::_f2l: case Bytecodes::_f2d: tos_in = ftos; break; case Bytecodes::_d2i: case Bytecodes::_d2l: case Bytecodes::_d2f: tos_in = dtos; break; default : ShouldNotReachHere(); } switch (bytecode()) { case Bytecodes::_l2i: case Bytecodes::_f2i: case Bytecodes::_d2i: case Bytecodes::_i2b: case Bytecodes::_i2c: case Bytecodes::_i2s: tos_out = itos; break; case Bytecodes::_i2l: case Bytecodes::_f2l: case Bytecodes::_d2l: tos_out = ltos; break; case Bytecodes::_i2f: case Bytecodes::_l2f: case Bytecodes::_d2f: tos_out = ftos; break; case Bytecodes::_i2d: case Bytecodes::_l2d: case Bytecodes::_f2d: tos_out = dtos; break; default : ShouldNotReachHere(); } transition(tos_in, tos_out); #endif // ASSERT // Conversion Label done; switch (bytecode()) { case Bytecodes::_i2l: __ z_lgfr(Z_tos, Z_tos); return; case Bytecodes::_i2f: __ z_cefbr(Z_ftos, Z_tos); return; case Bytecodes::_i2d: __ z_cdfbr(Z_ftos, Z_tos); return; case Bytecodes::_i2b: // Sign extend least significant byte. __ move_reg_if_needed(Z_tos, T_BYTE, Z_tos, T_INT); return; case Bytecodes::_i2c: // Zero extend 2 least significant bytes. __ move_reg_if_needed(Z_tos, T_CHAR, Z_tos, T_INT); return; case Bytecodes::_i2s: // Sign extend 2 least significant bytes. __ move_reg_if_needed(Z_tos, T_SHORT, Z_tos, T_INT); return; case Bytecodes::_l2i: // Sign-extend not needed here, upper 4 bytes of int value in register are ignored. return; case Bytecodes::_l2f: __ z_cegbr(Z_ftos, Z_tos); return; case Bytecodes::_l2d: __ z_cdgbr(Z_ftos, Z_tos); return; case Bytecodes::_f2i: case Bytecodes::_f2l: __ clear_reg(Z_tos, true, false); // Don't set CC. __ z_cebr(Z_ftos, Z_ftos); __ z_brno(done); // NaN -> 0 if (bytecode() == Bytecodes::_f2i) __ z_cfebr(Z_tos, Z_ftos, Assembler::to_zero); else // bytecode() == Bytecodes::_f2l __ z_cgebr(Z_tos, Z_ftos, Assembler::to_zero); break; case Bytecodes::_f2d: __ move_freg_if_needed(Z_ftos, T_DOUBLE, Z_ftos, T_FLOAT); return; case Bytecodes::_d2i: case Bytecodes::_d2l: __ clear_reg(Z_tos, true, false); // Ddon't set CC. __ z_cdbr(Z_ftos, Z_ftos); __ z_brno(done); // NaN -> 0 if (bytecode() == Bytecodes::_d2i) __ z_cfdbr(Z_tos, Z_ftos, Assembler::to_zero); else // Bytecodes::_d2l __ z_cgdbr(Z_tos, Z_ftos, Assembler::to_zero); break; case Bytecodes::_d2f: __ move_freg_if_needed(Z_ftos, T_FLOAT, Z_ftos, T_DOUBLE); return; default: ShouldNotReachHere(); } __ bind(done); } void TemplateTable::lcmp() { transition(ltos, itos); Label done; Register val1 = Z_R0_scratch; Register val2 = Z_R1_scratch; if (VM_Version::has_LoadStoreConditional()) { __ pop_l(val1); // pop value 1. __ z_lghi(val2, -1); // lt value __ z_cgr(val1, Z_tos); // Compare with Z_tos (value 2). Protect CC under all circumstances. __ z_lghi(val1, 1); // gt value __ z_lghi(Z_tos, 0); // eq value __ z_locgr(Z_tos, val1, Assembler::bcondHigh); __ z_locgr(Z_tos, val2, Assembler::bcondLow); } else { __ pop_l(val1); // Pop value 1. __ z_cgr(val1, Z_tos); // Compare with Z_tos (value 2). Protect CC under all circumstances. __ z_lghi(Z_tos, 0); // eq value __ z_bre(done); __ z_lghi(Z_tos, 1); // gt value __ z_brh(done); __ z_lghi(Z_tos, -1); // lt value } __ bind(done); } void TemplateTable::float_cmp(bool is_float, int unordered_result) { Label done; if (is_float) { __ pop_f(Z_FARG2); __ z_cebr(Z_FARG2, Z_ftos); } else { __ pop_d(Z_FARG2); __ z_cdbr(Z_FARG2, Z_ftos); } if (VM_Version::has_LoadStoreConditional()) { Register one = Z_R0_scratch; Register minus_one = Z_R1_scratch; __ z_lghi(minus_one, -1); __ z_lghi(one, 1); __ z_lghi(Z_tos, 0); __ z_locgr(Z_tos, one, unordered_result == 1 ? Assembler::bcondHighOrNotOrdered : Assembl __ z_locgr(Z_tos, minus_one, unordered_result == 1 ? Assembler::bcondLow : Assembler::bco } else { // Z_FARG2 == Z_ftos __ clear_reg(Z_tos, false, false); __ z_bre(done); // F_ARG2 > Z_Ftos, or unordered __ z_lhi(Z_tos, 1); __ z_brc(unordered_result == 1 ? Assembler::bcondHighOrNotOrdered : Assembler::bcondHig // F_ARG2 < Z_FTOS, or unordered __ z_lhi(Z_tos, -1); __ bind(done); } } void TemplateTable::branch(bool is_jsr, bool is_wide) { const Register bumped_count = Z_tmp_1; const Register method = Z_tmp_2; const Register m_counters = Z_R1_scratch; const Register mdo = Z_tos; BLOCK_COMMENT("TemplateTable::branch {"); __ get_method(method); __ profile_taken_branch(mdo, bumped_count); const ByteSize ctr_offset = InvocationCounter::counter_offset(); const ByteSize be_offset = MethodCounters::backedge_counter_offset() + ctr_offset; const ByteSize inv_offset = MethodCounters::invocation_counter_offset() + ctr_offset; // Get (wide) offset to disp. const Register disp = Z_ARG5; if (is_wide) { __ get_4_byte_integer_at_bcp(disp, 1); } else { __ get_2_byte_integer_at_bcp(disp, 1, InterpreterMacroAssembler::Signed); } // Handle all the JSR stuff here, then exit. // It's much shorter and cleaner than intermingling with the // non-JSR normal-branch stuff occurring below. if (is_jsr) { // Compute return address as bci in Z_tos. __ z_lgr(Z_R1_scratch, Z_bcp); __ z_sg(Z_R1_scratch, Address(method, Method::const_offset())); __ add2reg(Z_tos, (is_wide ? 5 : 3) - in_bytes(ConstMethod::codes_offset()), Z_R1_scratch // Bump bcp to target of JSR. __ z_agr(Z_bcp, disp); // Push return address for "ret" on stack. __ push_ptr(Z_tos); // And away we go! __ dispatch_next(vtos, 0 , true); return; } // Normal (non-jsr) branch handling. // Bump bytecode pointer by displacement (take the branch). __ z_agr(Z_bcp, disp); assert(UseLoopCounter || !UseOnStackReplacement, "on-stack-replacement requires loop counters"); NearLabel backedge_counter_overflow; NearLabel dispatch; int increment = InvocationCounter::count_increment; if (UseLoopCounter) { // Increment backedge counter for backward branches. // disp: target offset // Z_bcp: target bcp // Z_locals: locals pointer // // Count only if backward branch. __ compare32_and_branch(disp, (intptr_t)0, Assembler::bcondHigh, dispatch); if (ProfileInterpreter) { NearLabel no_mdo; // Are we profiling? __ load_and_test_long(mdo, Address(method, Method::method_data_offset())); __ branch_optimized(Assembler::bcondZero, no_mdo); // Increment the MDO backedge counter. const Address mdo_backedge_counter(mdo, MethodData::backedge_counter_offset() + Invoc const Address mask(mdo, MethodData::backedge_mask_offset()); __ increment_mask_and_jump(mdo_backedge_counter, increment, mask, Z_ARG2, false, Assembler::bcondZero, UseOnStackReplacement ? &backedge_counter_overflow : NULL); __ z_bru(dispatch); __ bind(no_mdo); } // Increment backedge counter in MethodCounters*. __ get_method_counters(method, m_counters, dispatch); const Address mask(m_counters, MethodCounters::backedge_mask_offset()); __ increment_mask_and_jump(Address(m_counters, be_offset), increment, mask, Z_ARG2, false, Assembler::bcondZero, UseOnStackReplacement ? &backedge_counter_overflow : NULL); __ bind(dispatch); } // Pre-load the next target bytecode into rbx. __ z_llgc(Z_bytecode, Address(Z_bcp, (intptr_t) 0)); // Continue with the bytecode @ target. // Z_tos: Return bci for jsr's, unused otherwise. // Z_bytecode: target bytecode // Z_bcp: target bcp __ dispatch_only(vtos, true); // Out-of-line code runtime calls. if (UseLoopCounter && UseOnStackReplacement) { // invocation counter overflow __ bind(backedge_counter_overflow); __ z_lcgr(Z_ARG2, disp); // Z_ARG2 := -disp __ z_agr(Z_ARG2, Z_bcp); // Z_ARG2 := branch target bcp - disp == branch bcp __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::frequency_counter_overflow), Z_ARG2); // Z_RET: osr nmethod (osr ok) or NULL (osr not possible). __ compare64_and_branch(Z_RET, (intptr_t) 0, Assembler::bcondEqual, dispatch); // Nmethod may have been invalidated (VM may block upon call_VM return). __ z_cliy(nmethod::state_offset(), Z_RET, nmethod::in_use); __ z_brne(dispatch); // Migrate the interpreter frame off of the stack. __ z_lgr(Z_tmp_1, Z_RET); // Save the nmethod. call_VM(noreg, CAST_FROM_FN_PTR(address, SharedRuntime::OSR_migration_begin)); // Z_RET is OSR buffer, move it to expected parameter location. __ lgr_if_needed(Z_ARG1, Z_RET); // Pop the interpreter frame ... __ pop_interpreter_frame(Z_R14, Z_ARG2/*tmp1*/, Z_ARG3/*tmp2*/); // ... and begin the OSR nmethod. __ z_lg(Z_R1_scratch, Address(Z_tmp_1, nmethod::osr_entry_point_offset())); __ z_br(Z_R1_scratch); } BLOCK_COMMENT("} TemplateTable::branch"); } void TemplateTable::if_0cmp(Condition cc) { transition(itos, vtos); // Assume branch is more often taken than not (loops use backward branches). NearLabel not_taken; __ compare32_and_branch(Z_tos, (intptr_t) 0, j_not(cc), not_taken); branch(false, false); __ bind(not_taken); __ profile_not_taken_branch(Z_tos); } void TemplateTable::if_icmp(Condition cc) { transition(itos, vtos); // Assume branch is more often taken than not (loops use backward branches). NearLabel not_taken; __ pop_i(Z_R0_scratch); __ compare32_and_branch(Z_R0_scratch, Z_tos, j_not(cc), not_taken); branch(false, false); __ bind(not_taken); __ profile_not_taken_branch(Z_tos); } void TemplateTable::if_nullcmp(Condition cc) { transition(atos, vtos); // Assume branch is more often taken than not (loops use backward branches) . NearLabel not_taken; __ compare64_and_branch(Z_tos, (intptr_t) 0, j_not(cc), not_taken); branch(false, false); __ bind(not_taken); __ profile_not_taken_branch(Z_tos); } void TemplateTable::if_acmp(Condition cc) { transition(atos, vtos); // Assume branch is more often taken than not (loops use backward branches). NearLabel not_taken; __ pop_ptr(Z_ARG2); __ verify_oop(Z_ARG2); __ verify_oop(Z_tos); __ compareU64_and_branch(Z_tos, Z_ARG2, j_not(cc), not_taken); branch(false, false); __ bind(not_taken); __ profile_not_taken_branch(Z_ARG3); } void TemplateTable::ret() { transition(vtos, vtos); locals_index(Z_tmp_1); // Get return bci, compute return bcp. Must load 64 bits. __ mem2reg_opt(Z_tmp_1, iaddress(_masm, Z_tmp_1)); __ profile_ret(Z_tmp_1, Z_tmp_2); __ get_method(Z_tos); __ mem2reg_opt(Z_R1_scratch, Address(Z_tos, Method::const_offset())); __ load_address(Z_bcp, Address(Z_R1_scratch, Z_tmp_1, ConstMethod::codes_offset())); __ dispatch_next(vtos, 0 , true); } void TemplateTable::wide_ret() { transition(vtos, vtos); locals_index_wide(Z_tmp_1); // Get return bci, compute return bcp. __ mem2reg_opt(Z_tmp_1, aaddress(_masm, Z_tmp_1)); __ profile_ret(Z_tmp_1, Z_tmp_2); __ get_method(Z_tos); __ mem2reg_opt(Z_R1_scratch, Address(Z_tos, Method::const_offset())); __ load_address(Z_bcp, Address(Z_R1_scratch, Z_tmp_1, ConstMethod::codes_offset())); __ dispatch_next(vtos, 0, true); } void TemplateTable::tableswitch () { transition(itos, vtos); NearLabel default_case, continue_execution; Register bcp = Z_ARG5; // Align bcp. __ load_address(bcp, at_bcp(BytesPerInt)); __ z_nill(bcp, (-BytesPerInt) & 0xffff); // Load lo & hi. Register low = Z_tmp_1; Register high = Z_tmp_2; // Load low into 64 bits, since used for address calculation. __ mem2reg_signed_opt(low, Address(bcp, BytesPerInt)); __ mem2reg_opt(high, Address(bcp, 2 * BytesPerInt), false); // Sign extend "label" value for address calculation. __ z_lgfr(Z_tos, Z_tos); // Check against lo & hi. __ compare32_and_branch(Z_tos, low, Assembler::bcondLow, default_case); __ compare32_and_branch(Z_tos, high, Assembler::bcondHigh, default_case); // Lookup dispatch offset. __ z_sgr(Z_tos, low); Register jump_table_offset = Z_ARG3; // Index2offset; index in Z_tos is killed by profile_switch_case. __ z_sllg(jump_table_offset, Z_tos, LogBytesPerInt); __ profile_switch_case(Z_tos, Z_ARG4 /*tmp for mdp*/, low/*tmp*/, Z_bytecode/*tmp*/); Register index = Z_tmp_2; // Load index sign extended for addressing. __ mem2reg_signed_opt(index, Address(bcp, jump_table_offset, 3 * BytesPerInt)); // Continue execution. __ bind(continue_execution); // Load next bytecode. __ z_llgc(Z_bytecode, Address(Z_bcp, index)); __ z_agr(Z_bcp, index); // Advance bcp. __ dispatch_only(vtos, true); // Handle default. __ bind(default_case); __ profile_switch_default(Z_tos); __ mem2reg_signed_opt(index, Address(bcp)); __ z_bru(continue_execution); } void TemplateTable::lookupswitch () { transition(itos, itos); __ stop("lookupswitch bytecode should have been rewritten"); } void TemplateTable::fast_linearswitch () { transition(itos, vtos); Label loop_entry, loop, found, continue_execution; Register bcp = Z_ARG5; // Align bcp. __ load_address(bcp, at_bcp(BytesPerInt)); __ z_nill(bcp, (-BytesPerInt) & 0xffff); // Start search with last case. --> -------------------- --> maximum size reached --> -------------------- ¤ Dauer der Verarbeitung: 0.13 Sekunden (vorverarbeitet) ¤*© Formatika GbR, Deutschland |
|
2026-03-28