1 /* 2 * Copyright (c) 2004, 2025, Oracle and/or its affiliates. All rights reserved. 3 * Copyright (c) 2014, 2020, Red Hat Inc. All rights reserved. 4 * Copyright (c) 2020, 2023, Huawei Technologies Co., Ltd. All rights reserved. 5 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 6 * 7 * This code is free software; you can redistribute it and/or modify it 8 * under the terms of the GNU General Public License version 2 only, as 9 * published by the Free Software Foundation. 10 * 11 * This code is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 * version 2 for more details (a copy is included in the LICENSE file that 15 * accompanied this code). 16 * 17 * You should have received a copy of the GNU General Public License version 18 * 2 along with this work; if not, write to the Free Software Foundation, 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 * 21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 * or visit www.oracle.com if you need additional information or have any 23 * questions. 24 * 25 */ 26 27 #include "asm/macroAssembler.hpp" 28 #include "gc/shared/barrierSet.hpp" 29 #include "gc/shared/barrierSetAssembler.hpp" 30 #include "memory/resourceArea.hpp" 31 #include "prims/jniFastGetField.hpp" 32 #include "prims/jvm_misc.hpp" 33 #include "prims/jvmtiExport.hpp" 34 #include "runtime/safepoint.hpp" 35 36 #define __ masm-> 37 38 #define BUFFER_SIZE 30*wordSize 39 40 // Instead of issuing a LoadLoad barrier we create an address 41 // dependency between loads; this might be more efficient. 42 43 // Common register usage: 44 // x10/f10: result 45 // c_rarg0: jni env 46 // c_rarg1: obj 47 // c_rarg2: jfield id 48 49 static const Register robj = x13; 50 static const Register rcounter = x14; 51 static const Register roffset = x15; 52 static const Register rcounter_addr = x16; 53 static const Register result = x17; 54 55 address JNI_FastGetField::generate_fast_get_int_field0(BasicType type) { 56 const char *name; 57 switch (type) { 58 case T_BOOLEAN: name = "jni_fast_GetBooleanField"; break; 59 case T_BYTE: name = "jni_fast_GetByteField"; break; 60 case T_CHAR: name = "jni_fast_GetCharField"; break; 61 case T_SHORT: name = "jni_fast_GetShortField"; break; 62 case T_INT: name = "jni_fast_GetIntField"; break; 63 case T_LONG: name = "jni_fast_GetLongField"; break; 64 case T_FLOAT: name = "jni_fast_GetFloatField"; break; 65 case T_DOUBLE: name = "jni_fast_GetDoubleField"; break; 66 default: ShouldNotReachHere(); 67 name = nullptr; // unreachable 68 } 69 ResourceMark rm; 70 BufferBlob* blob = BufferBlob::create(name, BUFFER_SIZE); 71 CodeBuffer cbuf(blob); 72 MacroAssembler* masm = new MacroAssembler(&cbuf); 73 address fast_entry = __ pc(); 74 75 Label slow; 76 ExternalAddress counter(SafepointSynchronize::safepoint_counter_addr()); 77 __ la(rcounter_addr, counter); 78 __ lwu(rcounter, Address(rcounter_addr)); 79 // An even value means there are no ongoing safepoint operations 80 __ test_bit(t0, rcounter, 0); 81 __ bnez(t0, slow); 82 83 if (JvmtiExport::can_post_field_access()) { 84 // Using barrier to order wrt. JVMTI check and load of result. 85 __ membar(MacroAssembler::LoadLoad); 86 87 // Check to see if a field access watch has been set before we 88 // take the fast path. 89 __ lwu(result, ExternalAddress(JvmtiExport::get_field_access_count_addr())); 90 __ bnez(result, slow); 91 92 __ mv(robj, c_rarg1); 93 } else { 94 // Using address dependency to order wrt. load of result. 95 __ xorr(robj, c_rarg1, rcounter); 96 __ xorr(robj, robj, rcounter); // obj, since 97 // robj ^ rcounter ^ rcounter == robj 98 // robj is address dependent on rcounter. 99 } 100 101 // Both robj and t0 are clobbered by try_resolve_jobject_in_native. 102 BarrierSetAssembler* bs = BarrierSet::barrier_set()->barrier_set_assembler(); 103 assert_cond(bs != nullptr); 104 bs->try_resolve_jobject_in_native(masm, c_rarg0, robj, t0, slow); 105 106 __ srli(roffset, c_rarg2, 2); // offset 107 108 assert(count < LIST_CAPACITY, "LIST_CAPACITY too small"); 109 speculative_load_pclist[count] = __ pc(); // Used by the segfault handler 110 __ add(roffset, robj, roffset); 111 112 switch (type) { 113 case T_BOOLEAN: __ lbu(result, Address(roffset, 0)); break; 114 case T_BYTE: __ lb(result, Address(roffset, 0)); break; 115 case T_CHAR: __ lhu(result, Address(roffset, 0)); break; 116 case T_SHORT: __ lh(result, Address(roffset, 0)); break; 117 case T_INT: __ lw(result, Address(roffset, 0)); break; 118 case T_LONG: __ ld(result, Address(roffset, 0)); break; 119 case T_FLOAT: { 120 __ flw(f28, Address(roffset, 0)); // f28 as temporaries 121 __ fmv_x_w(result, f28); // f{31--0}-->x 122 break; 123 } 124 case T_DOUBLE: { 125 __ fld(f28, Address(roffset, 0)); // f28 as temporaries 126 __ fmv_x_d(result, f28); // d{63--0}-->x 127 break; 128 } 129 default: ShouldNotReachHere(); 130 } 131 132 // Using acquire: Order JVMTI check and load of result wrt. succeeding check 133 // (LoadStore for volatile field). 134 __ membar(MacroAssembler::LoadLoad | MacroAssembler::LoadStore); 135 136 __ lw(t0, Address(rcounter_addr)); 137 __ bne(rcounter, t0, slow); 138 139 switch (type) { 140 case T_FLOAT: __ fmv_w_x(f10, result); break; 141 case T_DOUBLE: __ fmv_d_x(f10, result); break; 142 default: __ mv(x10, result); break; 143 } 144 __ ret(); 145 146 slowcase_entry_pclist[count++] = __ pc(); 147 __ bind(slow); 148 address slow_case_addr; 149 switch (type) { 150 case T_BOOLEAN: slow_case_addr = jni_GetBooleanField_addr(); break; 151 case T_BYTE: slow_case_addr = jni_GetByteField_addr(); break; 152 case T_CHAR: slow_case_addr = jni_GetCharField_addr(); break; 153 case T_SHORT: slow_case_addr = jni_GetShortField_addr(); break; 154 case T_INT: slow_case_addr = jni_GetIntField_addr(); break; 155 case T_LONG: slow_case_addr = jni_GetLongField_addr(); break; 156 case T_FLOAT: slow_case_addr = jni_GetFloatField_addr(); break; 157 case T_DOUBLE: slow_case_addr = jni_GetDoubleField_addr(); break; 158 default: ShouldNotReachHere(); 159 slow_case_addr = nullptr; // unreachable 160 } 161 162 { 163 __ enter(); 164 __ rt_call(slow_case_addr); 165 __ leave(); 166 __ ret(); 167 } 168 __ flush(); 169 170 return fast_entry; 171 } 172 173 174 address JNI_FastGetField::generate_fast_get_boolean_field() { 175 return generate_fast_get_int_field0(T_BOOLEAN); 176 } 177 178 address JNI_FastGetField::generate_fast_get_byte_field() { 179 return generate_fast_get_int_field0(T_BYTE); 180 } 181 182 address JNI_FastGetField::generate_fast_get_char_field() { 183 return generate_fast_get_int_field0(T_CHAR); 184 } 185 186 address JNI_FastGetField::generate_fast_get_short_field() { 187 return generate_fast_get_int_field0(T_SHORT); 188 } 189 190 address JNI_FastGetField::generate_fast_get_int_field() { 191 return generate_fast_get_int_field0(T_INT); 192 } 193 194 address JNI_FastGetField::generate_fast_get_long_field() { 195 return generate_fast_get_int_field0(T_LONG); 196 } 197 198 address JNI_FastGetField::generate_fast_get_float_field() { 199 return generate_fast_get_int_field0(T_FLOAT); 200 } 201 202 address JNI_FastGetField::generate_fast_get_double_field() { 203 return generate_fast_get_int_field0(T_DOUBLE); 204 } --- EOF ---