1 /*
2 * Copyright (c) 2008, 2020, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #include "precompiled.hpp"
26 #include "asm/macroAssembler.hpp"
27 #include "assembler_arm.inline.hpp"
28 #include "memory/resourceArea.hpp"
29 #include "prims/jniFastGetField.hpp"
30 #include "prims/jvm_misc.hpp"
31 #include "prims/jvmtiExport.hpp"
32 #include "runtime/safepoint.hpp"
33
34 #define __ masm->
35
36 #define BUFFER_SIZE 120
37
generate_fast_get_int_field0(BasicType type)38 address JNI_FastGetField::generate_fast_get_int_field0(BasicType type) {
39 const char* name = NULL;
40 address slow_case_addr = NULL;
41 switch (type) {
42 case T_BOOLEAN:
43 name = "jni_fast_GetBooleanField";
44 slow_case_addr = jni_GetBooleanField_addr();
45 break;
46 case T_BYTE:
47 name = "jni_fast_GetByteField";
48 slow_case_addr = jni_GetByteField_addr();
49 break;
50 case T_CHAR:
51 name = "jni_fast_GetCharField";
52 slow_case_addr = jni_GetCharField_addr();
53 break;
54 case T_SHORT:
55 name = "jni_fast_GetShortField";
56 slow_case_addr = jni_GetShortField_addr();
57 break;
58 case T_INT:
59 name = "jni_fast_GetIntField";
60 slow_case_addr = jni_GetIntField_addr();
61 break;
62 case T_LONG:
63 name = "jni_fast_GetLongField";
64 slow_case_addr = jni_GetLongField_addr();
65 break;
66 case T_FLOAT:
67 name = "jni_fast_GetFloatField";
68 slow_case_addr = jni_GetFloatField_addr();
69 break;
70 case T_DOUBLE:
71 name = "jni_fast_GetDoubleField";
72 slow_case_addr = jni_GetDoubleField_addr();
73 break;
74 default:
75 ShouldNotReachHere();
76 }
77
78 // R0 - jni env
79 // R1 - object handle
80 // R2 - jfieldID
81
82 const Register Rsafepoint_counter_addr = R3;
83 const Register Robj = R1;
84 const Register Rres = R0;
85 const Register Rres_hi = R1;
86 const Register Rsafept_cnt = Rtemp;
87 const Register Rsafept_cnt2 = Rsafepoint_counter_addr;
88 const Register Rtmp1 = R3; // same as Rsafepoint_counter_addr
89 const Register Rtmp2 = R2; // same as jfieldID
90
91 assert_different_registers(Rsafepoint_counter_addr, Rsafept_cnt, Robj, Rres, LR);
92 assert_different_registers(Rsafept_cnt, R1, R2, Rtmp1, LR);
93 assert_different_registers(Rsafepoint_counter_addr, Rsafept_cnt, Rres, Rres_hi, Rtmp2, LR);
94 assert_different_registers(Rsafept_cnt2, Rsafept_cnt, Rres, Rres_hi, LR);
95
96 address fast_entry;
97
98 ResourceMark rm;
99 BufferBlob* blob = BufferBlob::create(name, BUFFER_SIZE);
100 CodeBuffer cbuf(blob);
101 MacroAssembler* masm = new MacroAssembler(&cbuf);
102 fast_entry = __ pc();
103 Label slow_case;
104
105 // Safepoint check
106 InlinedAddress safepoint_counter_addr(SafepointSynchronize::safepoint_counter_addr());
107 __ ldr_literal(Rsafepoint_counter_addr, safepoint_counter_addr);
108
109 __ push(RegisterSet(R0, R3)); // save incoming arguments for slow case
110
111 __ ldr_s32(Rsafept_cnt, Address(Rsafepoint_counter_addr));
112 __ tbnz(Rsafept_cnt, 0, slow_case);
113
114 __ bic(R1, R1, JNIHandles::weak_tag_mask);
115
116 if (JvmtiExport::can_post_field_access()) {
117 // Using barrier to order wrt. JVMTI check and load of result.
118 __ membar(MacroAssembler::Membar_mask_bits(MacroAssembler::LoadLoad), Rtmp1);
119
120 // Check to see if a field access watch has been set before we
121 // take the fast path.
122 __ ldr_global_s32(Rtmp1, (address)JvmtiExport::get_field_access_count_addr());
123 __ cbnz(Rtmp1, slow_case);
124
125 __ ldr(Robj, Address(R1));
126 } else {
127 // Address dependency restricts memory access ordering. It's cheaper than explicit LoadLoad barrier
128 __ andr(Rtmp1, Rsafept_cnt, (unsigned)1);
129 __ ldr(Robj, Address(R1, Rtmp1));
130 }
131
132 Address field_addr;
133 if (type != T_BOOLEAN
134 && type != T_INT
135 #ifndef __ABI_HARD__
136 && type != T_FLOAT
137 #endif // !__ABI_HARD__
138 ) {
139 // Only ldr and ldrb support embedded shift, other loads do not
140 __ add(Robj, Robj, AsmOperand(R2, lsr, 2));
141 field_addr = Address(Robj);
142 } else {
143 field_addr = Address(Robj, R2, lsr, 2);
144 }
145 assert(count < LIST_CAPACITY, "LIST_CAPACITY too small");
146 speculative_load_pclist[count] = __ pc();
147
148 switch (type) {
149 case T_BOOLEAN:
150 __ ldrb(Rres, field_addr);
151 break;
152 case T_BYTE:
153 __ ldrsb(Rres, field_addr);
154 break;
155 case T_CHAR:
156 __ ldrh(Rres, field_addr);
157 break;
158 case T_SHORT:
159 __ ldrsh(Rres, field_addr);
160 break;
161 case T_INT:
162 #ifndef __ABI_HARD__
163 case T_FLOAT:
164 #endif
165 __ ldr_s32(Rres, field_addr);
166 break;
167 case T_LONG:
168 #ifndef __ABI_HARD__
169 case T_DOUBLE:
170 #endif
171 // Safe to use ldrd since long and double fields are 8-byte aligned
172 __ ldrd(Rres, field_addr);
173 break;
174 #ifdef __ABI_HARD__
175 case T_FLOAT:
176 __ ldr_float(S0, field_addr);
177 break;
178 case T_DOUBLE:
179 __ ldr_double(D0, field_addr);
180 break;
181 #endif // __ABI_HARD__
182 default:
183 ShouldNotReachHere();
184 }
185
186 __ ldr_literal(Rsafepoint_counter_addr, safepoint_counter_addr);
187 #ifdef __ABI_HARD__
188 if (type == T_FLOAT || type == T_DOUBLE) {
189 __ fmrrd(Rres, Rres_hi, D0);
190 }
191 #endif // __ABI_HARD__
192
193 // Order JVMTI check and load of result wrt. succeeding check
194 // (LoadStore for volatile field).
195 __ membar(MacroAssembler::Membar_mask_bits(MacroAssembler::LoadLoad | MacroAssembler::LoadStore), Rtmp2);
196
197 __ ldr_s32(Rsafept_cnt2, Address(Rsafepoint_counter_addr));
198 __ cmp(Rsafept_cnt2, Rsafept_cnt);
199 // discards saved R0 R1 R2 R3
200 __ add(SP, SP, 4 * wordSize, eq);
201 __ bx(LR, eq);
202
203 slowcase_entry_pclist[count++] = __ pc();
204
205 __ bind(slow_case);
206 __ pop(RegisterSet(R0, R3));
207 // thumb mode switch handled by MacroAssembler::jump if needed
208 __ jump(slow_case_addr, relocInfo::none, Rtemp);
209
210 __ bind_literal(safepoint_counter_addr);
211
212 __ flush();
213
214 guarantee((__ pc() - fast_entry) <= BUFFER_SIZE, "BUFFER_SIZE too small");
215
216 return fast_entry;
217 }
218
generate_fast_get_float_field0(BasicType type)219 address JNI_FastGetField::generate_fast_get_float_field0(BasicType type) {
220 ShouldNotReachHere();
221 return NULL;
222 }
223
generate_fast_get_boolean_field()224 address JNI_FastGetField::generate_fast_get_boolean_field() {
225 return generate_fast_get_int_field0(T_BOOLEAN);
226 }
227
generate_fast_get_byte_field()228 address JNI_FastGetField::generate_fast_get_byte_field() {
229 return generate_fast_get_int_field0(T_BYTE);
230 }
231
generate_fast_get_char_field()232 address JNI_FastGetField::generate_fast_get_char_field() {
233 return generate_fast_get_int_field0(T_CHAR);
234 }
235
generate_fast_get_short_field()236 address JNI_FastGetField::generate_fast_get_short_field() {
237 return generate_fast_get_int_field0(T_SHORT);
238 }
239
generate_fast_get_int_field()240 address JNI_FastGetField::generate_fast_get_int_field() {
241 return generate_fast_get_int_field0(T_INT);
242 }
243
generate_fast_get_long_field()244 address JNI_FastGetField::generate_fast_get_long_field() {
245 return generate_fast_get_int_field0(T_LONG);
246 }
247
generate_fast_get_float_field()248 address JNI_FastGetField::generate_fast_get_float_field() {
249 return generate_fast_get_int_field0(T_FLOAT);
250 }
251
generate_fast_get_double_field()252 address JNI_FastGetField::generate_fast_get_double_field() {
253 return generate_fast_get_int_field0(T_DOUBLE);
254 }
255