1 /*
2 * Copyright (c) 2004, 2019, 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.inline.hpp"
27 #include "gc/shared/barrierSet.hpp"
28 #include "gc/shared/barrierSetAssembler.hpp"
29 #include "memory/resourceArea.hpp"
30 #include "prims/jniFastGetField.hpp"
31 #include "prims/jvm_misc.hpp"
32 #include "runtime/safepoint.hpp"
33
34 // TSO ensures that loads are blocking and ordered with respect to
35 // to earlier loads, so we don't need LoadLoad membars.
36
37 #define __ masm->
38
39 #define BUFFER_SIZE 30*sizeof(jint)
40
41 // Common register usage:
42 // O0: env
43 // O1: obj
44 // O2: jfieldID
45 // O4: offset (O2 >> 2)
46 // G4: old safepoint counter
47
48 address JNI_FastGetField::generate_fast_get_int_field0(BasicType type) {
49 const char *name;
50 switch (type) {
51 case T_BOOLEAN: name = "jni_fast_GetBooleanField"; break;
52 case T_BYTE: name = "jni_fast_GetByteField"; break;
53 case T_CHAR: name = "jni_fast_GetCharField"; break;
54 case T_SHORT: name = "jni_fast_GetShortField"; break;
55 case T_INT: name = "jni_fast_GetIntField"; break;
56 default: ShouldNotReachHere();
57 }
58 ResourceMark rm;
59 BufferBlob* blob = BufferBlob::create(name, BUFFER_SIZE*wordSize);
60 CodeBuffer cbuf(blob);
61 MacroAssembler* masm = new MacroAssembler(&cbuf);
62 address fast_entry = __ pc();
63
64 Label label1, label2;
65
66 AddressLiteral cnt_addrlit(SafepointSynchronize::safepoint_counter_addr());
67 __ sethi (cnt_addrlit, O3);
68 Address cnt_addr(O3, cnt_addrlit.low10());
69 __ ld (cnt_addr, G4);
70 __ andcc (G4, 1, G0);
71 __ br (Assembler::notZero, false, Assembler::pn, label1);
72 __ delayed()->srl (O2, 2, O4);
73
74 if (JvmtiExport::can_post_field_access()) {
75 // Check to see if a field access watch has been set before we
76 // take the fast path.
77 AddressLiteral get_field_access_count_addr(JvmtiExport::get_field_access_count_addr());
78 __ load_contents(get_field_access_count_addr, O5);
79 __ cmp_and_br_short(O5, 0, Assembler::notEqual, Assembler::pn, label1);
80 }
81
82 __ mov(O1, O5);
83
84 // Both O5 and G3 are clobbered by try_resolve_jobject_in_native.
85 BarrierSetAssembler *bs = BarrierSet::barrier_set()->barrier_set_assembler();
86 bs->try_resolve_jobject_in_native(masm, /* jni_env */ O0, /* obj */ O5, /* tmp */ G3, label1);
87
88 assert(count < LIST_CAPACITY, "LIST_CAPACITY too small");
89 speculative_load_pclist[count] = __ pc();
90 switch (type) {
91 case T_BOOLEAN: __ ldub (O5, O4, G3); break;
92 case T_BYTE: __ ldsb (O5, O4, G3); break;
93 case T_CHAR: __ lduh (O5, O4, G3); break;
94 case T_SHORT: __ ldsh (O5, O4, G3); break;
95 case T_INT: __ ld (O5, O4, G3); break;
96 default: ShouldNotReachHere();
97 }
98
99 __ ld (cnt_addr, O5);
100 __ cmp (O5, G4);
101 __ br (Assembler::notEqual, false, Assembler::pn, label2);
102 __ delayed()->mov (O7, G1);
103 __ retl ();
104 __ delayed()->mov (G3, O0);
105
106 slowcase_entry_pclist[count++] = __ pc();
107 __ bind (label1);
108 __ mov (O7, G1);
109
110 address slow_case_addr;
111 switch (type) {
112 case T_BOOLEAN: slow_case_addr = jni_GetBooleanField_addr(); break;
113 case T_BYTE: slow_case_addr = jni_GetByteField_addr(); break;
114 case T_CHAR: slow_case_addr = jni_GetCharField_addr(); break;
115 case T_SHORT: slow_case_addr = jni_GetShortField_addr(); break;
116 case T_INT: slow_case_addr = jni_GetIntField_addr(); break;
117 default: ShouldNotReachHere();
118 }
119 __ bind (label2);
120 __ call (slow_case_addr, relocInfo::none);
121 __ delayed()->mov (G1, O7);
122
123 __ flush ();
124
125 return fast_entry;
126 }
127
128 address JNI_FastGetField::generate_fast_get_boolean_field() {
129 return generate_fast_get_int_field0(T_BOOLEAN);
130 }
131
132 address JNI_FastGetField::generate_fast_get_byte_field() {
133 return generate_fast_get_int_field0(T_BYTE);
134 }
135
136 address JNI_FastGetField::generate_fast_get_char_field() {
137 return generate_fast_get_int_field0(T_CHAR);
138 }
139
140 address JNI_FastGetField::generate_fast_get_short_field() {
141 return generate_fast_get_int_field0(T_SHORT);
142 }
143
144 address JNI_FastGetField::generate_fast_get_int_field() {
145 return generate_fast_get_int_field0(T_INT);
146 }
147
148 address JNI_FastGetField::generate_fast_get_long_field() {
149 const char *name = "jni_fast_GetLongField";
150 ResourceMark rm;
151 BufferBlob* blob = BufferBlob::create(name, BUFFER_SIZE*wordSize);
152 CodeBuffer cbuf(blob);
153 MacroAssembler* masm = new MacroAssembler(&cbuf);
154 address fast_entry = __ pc();
155
156 Label label1, label2;
157
158 AddressLiteral cnt_addrlit(SafepointSynchronize::safepoint_counter_addr());
159 __ sethi (cnt_addrlit, G3);
160 Address cnt_addr(G3, cnt_addrlit.low10());
161 __ ld (cnt_addr, G4);
162 __ andcc (G4, 1, G0);
163 __ br (Assembler::notZero, false, Assembler::pn, label1);
164 __ delayed()->srl (O2, 2, O4);
165
166 if (JvmtiExport::can_post_field_access()) {
167 // Check to see if a field access watch has been set before we
168 // take the fast path.
169 AddressLiteral get_field_access_count_addr(JvmtiExport::get_field_access_count_addr());
170 __ load_contents(get_field_access_count_addr, O5);
171 __ cmp_and_br_short(O5, 0, Assembler::notEqual, Assembler::pn, label1);
172 }
173
174 __ mov(O1, O5);
175
176 // Both O5 and G1 are clobbered by try_resolve_jobject_in_native.
177 BarrierSetAssembler *bs = BarrierSet::barrier_set()->barrier_set_assembler();
178 bs->try_resolve_jobject_in_native(masm, /* jni_env */ O0, /* obj */ O5, /* tmp */ G1, label1);
179 DEBUG_ONLY(__ set(0xDEADC0DE, G1);)
180
181 __ add (O5, O4, O5);
182
183 assert(count < LIST_CAPACITY, "LIST_CAPACITY too small");
184 speculative_load_pclist[count] = __ pc();
185 __ ldx (O5, 0, O3);
186
187 __ ld (cnt_addr, G1);
188 __ cmp (G1, G4);
189 __ br (Assembler::notEqual, false, Assembler::pn, label2);
190 __ delayed()->mov (O7, G1);
191
192 __ retl ();
193 __ delayed()->mov (O3, O0);
194
195 slowcase_entry_pclist[count++] = __ pc();
196
197 __ bind (label1);
198 __ mov (O7, G1);
199
200 address slow_case_addr = jni_GetLongField_addr();
201 __ bind (label2);
202 __ call (slow_case_addr, relocInfo::none);
203 __ delayed()->mov (G1, O7);
204
205 __ flush ();
206
207 return fast_entry;
208 }
209
210 address JNI_FastGetField::generate_fast_get_float_field0(BasicType type) {
211 const char *name;
212 switch (type) {
213 case T_FLOAT: name = "jni_fast_GetFloatField"; break;
214 case T_DOUBLE: name = "jni_fast_GetDoubleField"; break;
215 default: ShouldNotReachHere();
216 }
217 ResourceMark rm;
218 BufferBlob* blob = BufferBlob::create(name, BUFFER_SIZE*wordSize);
219 CodeBuffer cbuf(blob);
220 MacroAssembler* masm = new MacroAssembler(&cbuf);
221 address fast_entry = __ pc();
222
223 Label label1, label2;
224
225 AddressLiteral cnt_addrlit(SafepointSynchronize::safepoint_counter_addr());
226 __ sethi (cnt_addrlit, O3);
227 Address cnt_addr(O3, cnt_addrlit.low10());
228 __ ld (cnt_addr, G4);
229 __ andcc (G4, 1, G0);
230 __ br (Assembler::notZero, false, Assembler::pn, label1);
231 __ delayed()->srl (O2, 2, O4);
232
233 if (JvmtiExport::can_post_field_access()) {
234 // Check to see if a field access watch has been set before we
235 // take the fast path.
236 AddressLiteral get_field_access_count_addr(JvmtiExport::get_field_access_count_addr());
237 __ load_contents(get_field_access_count_addr, O5);
238 __ cmp_and_br_short(O5, 0, Assembler::notEqual, Assembler::pn, label1);
239 }
240
241 __ mov(O1, O5);
242
243 // Both O5 and G3 are clobbered by try_resolve_jobject_in_native.
244 BarrierSetAssembler *bs = BarrierSet::barrier_set()->barrier_set_assembler();
245 bs->try_resolve_jobject_in_native(masm, /* jni_env */ O0, /* obj */ O5, /* tmp */ G3, label1);
246 DEBUG_ONLY(__ set(0xDEADC0DE, G3);)
247
248 assert(count < LIST_CAPACITY, "LIST_CAPACITY too small");
249 speculative_load_pclist[count] = __ pc();
250 switch (type) {
251 case T_FLOAT: __ ldf (FloatRegisterImpl::S, O5, O4, F0); break;
252 case T_DOUBLE: __ ldf (FloatRegisterImpl::D, O5, O4, F0); break;
253 default: ShouldNotReachHere();
254 }
255
256 __ ld (cnt_addr, O5);
257 __ cmp (O5, G4);
258 __ br (Assembler::notEqual, false, Assembler::pn, label2);
259 __ delayed()->mov (O7, G1);
260
261 __ retl ();
262 __ delayed()-> nop ();
263
264 slowcase_entry_pclist[count++] = __ pc();
265 __ bind (label1);
266 __ mov (O7, G1);
267
268 address slow_case_addr;
269 switch (type) {
270 case T_FLOAT: slow_case_addr = jni_GetFloatField_addr(); break;
271 case T_DOUBLE: slow_case_addr = jni_GetDoubleField_addr(); break;
272 default: ShouldNotReachHere();
273 }
274 __ bind (label2);
275 __ call (slow_case_addr, relocInfo::none);
276 __ delayed()->mov (G1, O7);
277
278 __ flush ();
279
280 return fast_entry;
281 }
282
283 address JNI_FastGetField::generate_fast_get_float_field() {
284 return generate_fast_get_float_field0(T_FLOAT);
285 }
286
287 address JNI_FastGetField::generate_fast_get_double_field() {
288 return generate_fast_get_float_field0(T_DOUBLE);
289 }