1 /*
2 * Copyright (c) 1997, 2015, 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 "code/codeCacheExtensions.hpp"
27 #include "interpreter/interpreter.hpp"
28 #include "interpreter/interpreterRuntime.hpp"
29 #include "interpreter/interp_masm.hpp"
30 #include "interpreter/templateInterpreter.hpp"
31 #include "interpreter/templateInterpreterGenerator.hpp"
32 #include "interpreter/templateTable.hpp"
33
34 #ifndef CC_INTERP
35
36 # define __ _masm->
37
38 TemplateInterpreterGenerator::TemplateInterpreterGenerator(StubQueue* _code): AbstractInterpreterGenerator(_code) {
39 _unimplemented_bytecode = NULL;
40 _illegal_bytecode_sequence = NULL;
41 generate_all();
42 }
43
44 static const BasicType types[Interpreter::number_of_result_handlers] = {
45 T_BOOLEAN,
46 T_CHAR ,
47 T_BYTE ,
48 T_SHORT ,
49 T_INT ,
50 T_LONG ,
51 T_VOID ,
52 T_FLOAT ,
53 T_DOUBLE ,
54 T_OBJECT
55 };
56
57 void TemplateInterpreterGenerator::generate_all() {
58 // Loop, in case we need several variants of the interpreter entries
59 do {
60 if (!CodeCacheExtensions::skip_code_generation()) {
61 // bypass code generation when useless
62 { CodeletMark cm(_masm, "slow signature handler");
63 AbstractInterpreter::_slow_signature_handler = generate_slow_signature_handler();
64 }
65
66 { CodeletMark cm(_masm, "error exits");
67 _unimplemented_bytecode = generate_error_exit("unimplemented bytecode");
68 _illegal_bytecode_sequence = generate_error_exit("illegal bytecode sequence - method not verified");
69 }
70
71 #ifndef PRODUCT
72 if (TraceBytecodes) {
73 CodeletMark cm(_masm, "bytecode tracing support");
74 Interpreter::_trace_code =
75 EntryPoint(
76 generate_trace_code(btos),
77 generate_trace_code(ctos),
78 generate_trace_code(stos),
79 generate_trace_code(atos),
80 generate_trace_code(itos),
81 generate_trace_code(ltos),
82 generate_trace_code(ftos),
83 generate_trace_code(dtos),
84 generate_trace_code(vtos)
85 );
86 }
87 #endif // !PRODUCT
88
89 { CodeletMark cm(_masm, "return entry points");
90 const int index_size = sizeof(u2);
91 for (int i = 0; i < Interpreter::number_of_return_entries; i++) {
92 Interpreter::_return_entry[i] =
93 EntryPoint(
94 generate_return_entry_for(itos, i, index_size),
95 generate_return_entry_for(itos, i, index_size),
96 generate_return_entry_for(itos, i, index_size),
97 generate_return_entry_for(atos, i, index_size),
98 generate_return_entry_for(itos, i, index_size),
99 generate_return_entry_for(ltos, i, index_size),
100 generate_return_entry_for(ftos, i, index_size),
101 generate_return_entry_for(dtos, i, index_size),
102 generate_return_entry_for(vtos, i, index_size)
103 );
104 }
105 }
106
107 { CodeletMark cm(_masm, "invoke return entry points");
108 const TosState states[] = {itos, itos, itos, itos, ltos, ftos, dtos, atos, vtos};
109 const int invoke_length = Bytecodes::length_for(Bytecodes::_invokestatic);
110 const int invokeinterface_length = Bytecodes::length_for(Bytecodes::_invokeinterface);
111 const int invokedynamic_length = Bytecodes::length_for(Bytecodes::_invokedynamic);
112
113 for (int i = 0; i < Interpreter::number_of_return_addrs; i++) {
114 TosState state = states[i];
115 Interpreter::_invoke_return_entry[i] = generate_return_entry_for(state, invoke_length, sizeof(u2));
116 Interpreter::_invokeinterface_return_entry[i] = generate_return_entry_for(state, invokeinterface_length, sizeof(u2));
117 Interpreter::_invokedynamic_return_entry[i] = generate_return_entry_for(state, invokedynamic_length, sizeof(u4));
118 }
119 }
120
121 { CodeletMark cm(_masm, "earlyret entry points");
122 Interpreter::_earlyret_entry =
123 EntryPoint(
124 generate_earlyret_entry_for(btos),
125 generate_earlyret_entry_for(ctos),
126 generate_earlyret_entry_for(stos),
127 generate_earlyret_entry_for(atos),
128 generate_earlyret_entry_for(itos),
129 generate_earlyret_entry_for(ltos),
130 generate_earlyret_entry_for(ftos),
131 generate_earlyret_entry_for(dtos),
132 generate_earlyret_entry_for(vtos)
133 );
134 }
135
136 { CodeletMark cm(_masm, "deoptimization entry points");
137 for (int i = 0; i < Interpreter::number_of_deopt_entries; i++) {
138 Interpreter::_deopt_entry[i] =
139 EntryPoint(
140 generate_deopt_entry_for(itos, i),
141 generate_deopt_entry_for(itos, i),
142 generate_deopt_entry_for(itos, i),
143 generate_deopt_entry_for(atos, i),
144 generate_deopt_entry_for(itos, i),
145 generate_deopt_entry_for(ltos, i),
146 generate_deopt_entry_for(ftos, i),
147 generate_deopt_entry_for(dtos, i),
148 generate_deopt_entry_for(vtos, i)
149 );
150 }
151 }
152
153 { CodeletMark cm(_masm, "result handlers for native calls");
154 // The various result converter stublets.
155 int is_generated[Interpreter::number_of_result_handlers];
156 memset(is_generated, 0, sizeof(is_generated));
157
158 for (int i = 0; i < Interpreter::number_of_result_handlers; i++) {
159 BasicType type = types[i];
160 if (!is_generated[Interpreter::BasicType_as_index(type)]++) {
161 Interpreter::_native_abi_to_tosca[Interpreter::BasicType_as_index(type)] = generate_result_handler_for(type);
162 }
163 }
164 }
165
166 { CodeletMark cm(_masm, "continuation entry points");
167 Interpreter::_continuation_entry =
168 EntryPoint(
169 generate_continuation_for(btos),
170 generate_continuation_for(ctos),
171 generate_continuation_for(stos),
172 generate_continuation_for(atos),
173 generate_continuation_for(itos),
174 generate_continuation_for(ltos),
175 generate_continuation_for(ftos),
176 generate_continuation_for(dtos),
177 generate_continuation_for(vtos)
178 );
179 }
180
181 { CodeletMark cm(_masm, "safepoint entry points");
182 Interpreter::_safept_entry =
183 EntryPoint(
184 generate_safept_entry_for(btos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)),
185 generate_safept_entry_for(ctos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)),
186 generate_safept_entry_for(stos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)),
187 generate_safept_entry_for(atos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)),
188 generate_safept_entry_for(itos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)),
189 generate_safept_entry_for(ltos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)),
190 generate_safept_entry_for(ftos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)),
191 generate_safept_entry_for(dtos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)),
192 generate_safept_entry_for(vtos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint))
193 );
194 }
195
196 { CodeletMark cm(_masm, "exception handling");
197 // (Note: this is not safepoint safe because thread may return to compiled code)
198 generate_throw_exception();
199 }
200
201 { CodeletMark cm(_masm, "throw exception entrypoints");
202 Interpreter::_throw_ArrayIndexOutOfBoundsException_entry = generate_ArrayIndexOutOfBounds_handler("java/lang/ArrayIndexOutOfBoundsException");
203 Interpreter::_throw_ArrayStoreException_entry = generate_klass_exception_handler("java/lang/ArrayStoreException" );
204 Interpreter::_throw_ArithmeticException_entry = generate_exception_handler("java/lang/ArithmeticException" , "/ by zero");
205 Interpreter::_throw_ClassCastException_entry = generate_ClassCastException_handler();
206 Interpreter::_throw_NullPointerException_entry = generate_exception_handler("java/lang/NullPointerException" , NULL );
207 Interpreter::_throw_StackOverflowError_entry = generate_StackOverflowError_handler();
208 }
209
210
211
212 #define method_entry(kind) \
213 { CodeletMark cm(_masm, "method entry point (kind = " #kind ")"); \
214 Interpreter::_entry_table[Interpreter::kind] = generate_method_entry(Interpreter::kind); \
215 Interpreter::update_cds_entry_table(Interpreter::kind); \
216 }
217
218 // all non-native method kinds
219 method_entry(zerolocals)
220 method_entry(zerolocals_synchronized)
221 method_entry(empty)
222 method_entry(accessor)
223 method_entry(abstract)
224 method_entry(java_lang_math_sin )
225 method_entry(java_lang_math_cos )
226 method_entry(java_lang_math_tan )
227 method_entry(java_lang_math_abs )
228 method_entry(java_lang_math_sqrt )
229 method_entry(java_lang_math_log )
230 method_entry(java_lang_math_log10)
231 method_entry(java_lang_math_exp )
232 method_entry(java_lang_math_pow )
233 method_entry(java_lang_ref_reference_get)
234
235 AbstractInterpreter::initialize_method_handle_entries();
236
237 // all native method kinds (must be one contiguous block)
238 Interpreter::_native_entry_begin = Interpreter::code()->code_end();
239 method_entry(native)
240 method_entry(native_synchronized)
241 Interpreter::_native_entry_end = Interpreter::code()->code_end();
242
243 if (UseCRC32Intrinsics) {
244 method_entry(java_util_zip_CRC32_update)
245 method_entry(java_util_zip_CRC32_updateBytes)
246 method_entry(java_util_zip_CRC32_updateByteBuffer)
247 }
248
249 if (UseCRC32CIntrinsics) {
250 method_entry(java_util_zip_CRC32C_updateBytes)
251 method_entry(java_util_zip_CRC32C_updateDirectByteBuffer)
252 }
253
254 method_entry(java_lang_Float_intBitsToFloat);
255 method_entry(java_lang_Float_floatToRawIntBits);
256 method_entry(java_lang_Double_longBitsToDouble);
257 method_entry(java_lang_Double_doubleToRawLongBits);
258
259 #undef method_entry
260
261 // Bytecodes
262 set_entry_points_for_all_bytes();
263 }
264 } while (CodeCacheExtensions::needs_other_interpreter_variant());
265
266 // installation of code in other places in the runtime
267 // (ExcutableCodeManager calls not needed to copy the entries)
268 set_safepoints_for_all_bytes();
269 }
270
271 //------------------------------------------------------------------------------------------------------------------------
272
273 address TemplateInterpreterGenerator::generate_error_exit(const char* msg) {
274 address entry = __ pc();
275 __ stop(msg);
276 return entry;
277 }
278
279
280 //------------------------------------------------------------------------------------------------------------------------
281
282 void TemplateInterpreterGenerator::set_entry_points_for_all_bytes() {
283 for (int i = 0; i < DispatchTable::length; i++) {
284 Bytecodes::Code code = (Bytecodes::Code)i;
285 if (Bytecodes::is_defined(code)) {
286 set_entry_points(code);
287 } else {
288 set_unimplemented(i);
289 }
290 }
291 }
292
293
294 void TemplateInterpreterGenerator::set_safepoints_for_all_bytes() {
295 for (int i = 0; i < DispatchTable::length; i++) {
296 Bytecodes::Code code = (Bytecodes::Code)i;
297 if (Bytecodes::is_defined(code)) Interpreter::_safept_table.set_entry(code, Interpreter::_safept_entry);
298 }
299 }
300
301
302 void TemplateInterpreterGenerator::set_unimplemented(int i) {
303 address e = _unimplemented_bytecode;
304 EntryPoint entry(e, e, e, e, e, e, e, e, e);
305 Interpreter::_normal_table.set_entry(i, entry);
306 Interpreter::_wentry_point[i] = _unimplemented_bytecode;
307 }
308
309
310 void TemplateInterpreterGenerator::set_entry_points(Bytecodes::Code code) {
311 if (CodeCacheExtensions::skip_template_interpreter_entries(code)) {
312 return;
313 }
314 CodeletMark cm(_masm, Bytecodes::name(code), code);
315 // initialize entry points
316 assert(_unimplemented_bytecode != NULL, "should have been generated before");
317 assert(_illegal_bytecode_sequence != NULL, "should have been generated before");
318 address bep = _illegal_bytecode_sequence;
319 address cep = _illegal_bytecode_sequence;
320 address sep = _illegal_bytecode_sequence;
321 address aep = _illegal_bytecode_sequence;
322 address iep = _illegal_bytecode_sequence;
323 address lep = _illegal_bytecode_sequence;
324 address fep = _illegal_bytecode_sequence;
325 address dep = _illegal_bytecode_sequence;
326 address vep = _unimplemented_bytecode;
327 address wep = _unimplemented_bytecode;
328 // code for short & wide version of bytecode
329 if (Bytecodes::is_defined(code)) {
330 Template* t = TemplateTable::template_for(code);
331 assert(t->is_valid(), "just checking");
332 set_short_entry_points(t, bep, cep, sep, aep, iep, lep, fep, dep, vep);
333 }
334 if (Bytecodes::wide_is_defined(code)) {
335 Template* t = TemplateTable::template_for_wide(code);
336 assert(t->is_valid(), "just checking");
337 set_wide_entry_point(t, wep);
338 }
339 // set entry points
340 EntryPoint entry(bep, cep, sep, aep, iep, lep, fep, dep, vep);
341 Interpreter::_normal_table.set_entry(code, entry);
342 Interpreter::_wentry_point[code] = wep;
343 CodeCacheExtensions::completed_template_interpreter_entries(_masm, code);
344 }
345
346
347 void TemplateInterpreterGenerator::set_wide_entry_point(Template* t, address& wep) {
348 assert(t->is_valid(), "template must exist");
349 assert(t->tos_in() == vtos, "only vtos tos_in supported for wide instructions");
350 wep = __ pc(); generate_and_dispatch(t);
351 }
352
353
354 void TemplateInterpreterGenerator::set_short_entry_points(Template* t, address& bep, address& cep, address& sep, address& aep, address& iep, address& lep, address& fep, address& dep, address& vep) {
355 assert(t->is_valid(), "template must exist");
356 switch (t->tos_in()) {
357 case btos:
358 case ctos:
359 case stos:
360 ShouldNotReachHere(); // btos/ctos/stos should use itos.
361 break;
362 case atos: vep = __ pc(); __ pop(atos); aep = __ pc(); generate_and_dispatch(t); break;
363 case itos: vep = __ pc(); __ pop(itos); iep = __ pc(); generate_and_dispatch(t); break;
364 case ltos: vep = __ pc(); __ pop(ltos); lep = __ pc(); generate_and_dispatch(t); break;
365 case ftos: vep = __ pc(); __ pop(ftos); fep = __ pc(); generate_and_dispatch(t); break;
366 case dtos: vep = __ pc(); __ pop(dtos); dep = __ pc(); generate_and_dispatch(t); break;
367 case vtos: set_vtos_entry_points(t, bep, cep, sep, aep, iep, lep, fep, dep, vep); break;
368 default : ShouldNotReachHere(); break;
369 }
370 }
371
372
373 //------------------------------------------------------------------------------------------------------------------------
374
375 void TemplateInterpreterGenerator::generate_and_dispatch(Template* t, TosState tos_out) {
376 if (PrintBytecodeHistogram) histogram_bytecode(t);
377 #ifndef PRODUCT
378 // debugging code
379 if (CountBytecodes || TraceBytecodes || StopInterpreterAt > 0) count_bytecode();
380 if (PrintBytecodePairHistogram) histogram_bytecode_pair(t);
381 if (TraceBytecodes) trace_bytecode(t);
382 if (StopInterpreterAt > 0) stop_interpreter_at();
383 __ verify_FPU(1, t->tos_in());
384 #endif // !PRODUCT
385 int step = 0;
386 if (!t->does_dispatch()) {
387 step = t->is_wide() ? Bytecodes::wide_length_for(t->bytecode()) : Bytecodes::length_for(t->bytecode());
388 if (tos_out == ilgl) tos_out = t->tos_out();
389 // compute bytecode size
390 assert(step > 0, "just checkin'");
391 // setup stuff for dispatching next bytecode
392 if (ProfileInterpreter && VerifyDataPointer
393 && MethodData::bytecode_has_profile(t->bytecode())) {
394 __ verify_method_data_pointer();
395 }
396 __ dispatch_prolog(tos_out, step);
397 }
398 // generate template
399 t->generate(_masm);
400 // advance
401 if (t->does_dispatch()) {
402 #ifdef ASSERT
403 // make sure execution doesn't go beyond this point if code is broken
404 __ should_not_reach_here();
405 #endif // ASSERT
406 } else {
407 // dispatch to next bytecode
408 __ dispatch_epilog(tos_out, step);
409 }
410 }
411
412 // Generate method entries
413 address TemplateInterpreterGenerator::generate_method_entry(
414 AbstractInterpreter::MethodKind kind) {
415 // determine code generation flags
416 bool native = false;
417 bool synchronized = false;
418 address entry_point = NULL;
419
420 switch (kind) {
421 case Interpreter::zerolocals : break;
422 case Interpreter::zerolocals_synchronized: synchronized = true; break;
423 case Interpreter::native : native = true; break;
424 case Interpreter::native_synchronized : native = true; synchronized = true; break;
425 case Interpreter::empty : break;
426 case Interpreter::accessor : break;
427 case Interpreter::abstract : entry_point = generate_abstract_entry(); break;
428
429 case Interpreter::java_lang_math_sin : // fall thru
430 case Interpreter::java_lang_math_cos : // fall thru
431 case Interpreter::java_lang_math_tan : // fall thru
432 case Interpreter::java_lang_math_abs : // fall thru
433 case Interpreter::java_lang_math_log : // fall thru
434 case Interpreter::java_lang_math_log10 : // fall thru
435 case Interpreter::java_lang_math_sqrt : // fall thru
436 case Interpreter::java_lang_math_pow : // fall thru
437 case Interpreter::java_lang_math_exp : entry_point = generate_math_entry(kind); break;
438 case Interpreter::java_lang_ref_reference_get
439 : entry_point = generate_Reference_get_entry(); break;
440 case Interpreter::java_util_zip_CRC32_update
441 : native = true; entry_point = generate_CRC32_update_entry(); break;
442 case Interpreter::java_util_zip_CRC32_updateBytes
443 : // fall thru
444 case Interpreter::java_util_zip_CRC32_updateByteBuffer
445 : native = true; entry_point = generate_CRC32_updateBytes_entry(kind); break;
446 case Interpreter::java_util_zip_CRC32C_updateBytes
447 : // fall thru
448 case Interpreter::java_util_zip_CRC32C_updateDirectByteBuffer
449 : entry_point = generate_CRC32C_updateBytes_entry(kind); break;
450 #ifdef IA32
451 // On x86_32 platforms, a special entry is generated for the following four methods.
452 // On other platforms the normal entry is used to enter these methods.
453 case Interpreter::java_lang_Float_intBitsToFloat
454 : native = true; entry_point = generate_Float_intBitsToFloat_entry(); break;
455 case Interpreter::java_lang_Float_floatToRawIntBits
456 : native = true; entry_point = generate_Float_floatToRawIntBits_entry(); break;
457 case Interpreter::java_lang_Double_longBitsToDouble
458 : native = true; entry_point = generate_Double_longBitsToDouble_entry(); break;
459 case Interpreter::java_lang_Double_doubleToRawLongBits
460 : native = true; entry_point = generate_Double_doubleToRawLongBits_entry(); break;
461 #else
462 case Interpreter::java_lang_Float_intBitsToFloat:
463 case Interpreter::java_lang_Float_floatToRawIntBits:
464 case Interpreter::java_lang_Double_longBitsToDouble:
465 case Interpreter::java_lang_Double_doubleToRawLongBits:
466 native = true;
467 break;
468 #endif // defined(TARGET_ARCH_x86) && !defined(_LP64)
469 default:
470 fatal("unexpected method kind: %d", kind);
471 break;
472 }
473
474 if (entry_point) {
475 return entry_point;
476 }
477
478 // We expect the normal and native entry points to be generated first so we can reuse them.
479 if (native) {
480 entry_point = Interpreter::entry_for_kind(synchronized ? Interpreter::native_synchronized : Interpreter::native);
481 if (entry_point == NULL) {
482 entry_point = generate_native_entry(synchronized);
483 }
484 } else {
485 entry_point = Interpreter::entry_for_kind(synchronized ? Interpreter::zerolocals_synchronized : Interpreter::zerolocals);
486 if (entry_point == NULL) {
487 entry_point = generate_normal_entry(synchronized);
488 }
489 }
490
491 return entry_point;
492 }
493 #endif // !CC_INTERP