1 /*
2 * Copyright (c) 1997, 2014, 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 "interpreter/interpreter.hpp"
27 #include "interpreter/interpreterGenerator.hpp"
28 #include "interpreter/interpreterRuntime.hpp"
29 #include "interpreter/interp_masm.hpp"
30 #include "interpreter/templateInterpreter.hpp"
31 #include "interpreter/templateTable.hpp"
32
33 #ifndef CC_INTERP
34
35 # define __ _masm->
36
37 void TemplateInterpreter::initialize() {
38 if (_code != NULL) return;
39 // assertions
40 assert((int)Bytecodes::number_of_codes <= (int)DispatchTable::length,
41 "dispatch table too small");
42
43 AbstractInterpreter::initialize();
44
45 TemplateTable::initialize();
46
47 // generate interpreter
48 { ResourceMark rm;
49 TraceTime timer("Interpreter generation", TraceStartupTime);
50 int code_size = InterpreterCodeSize;
51 NOT_PRODUCT(code_size *= 4;) // debug uses extra interpreter code space
52 _code = new StubQueue(new InterpreterCodeletInterface, code_size, NULL,
53 "Interpreter");
54 InterpreterGenerator g(_code);
55 if (PrintInterpreter) print();
56 }
57
58 // initialize dispatch table
59 _active_table = _normal_table;
60 }
61
62 //------------------------------------------------------------------------------------------------------------------------
63 // Implementation of EntryPoint
64
65 EntryPoint::EntryPoint() {
66 assert(number_of_states == 9, "check the code below");
67 _entry[btos] = NULL;
68 _entry[ctos] = NULL;
69 _entry[stos] = NULL;
70 _entry[atos] = NULL;
71 _entry[itos] = NULL;
72 _entry[ltos] = NULL;
73 _entry[ftos] = NULL;
74 _entry[dtos] = NULL;
75 _entry[vtos] = NULL;
76 }
77
78
79 EntryPoint::EntryPoint(address bentry, address centry, address sentry, address aentry, address ientry, address lentry, address fentry, address dentry, address ventry) {
80 assert(number_of_states == 9, "check the code below");
81 _entry[btos] = bentry;
82 _entry[ctos] = centry;
83 _entry[stos] = sentry;
84 _entry[atos] = aentry;
85 _entry[itos] = ientry;
86 _entry[ltos] = lentry;
87 _entry[ftos] = fentry;
88 _entry[dtos] = dentry;
89 _entry[vtos] = ventry;
90 }
91
92
93 void EntryPoint::set_entry(TosState state, address entry) {
94 assert(0 <= state && state < number_of_states, "state out of bounds");
95 _entry[state] = entry;
96 }
97
98
99 address EntryPoint::entry(TosState state) const {
100 assert(0 <= state && state < number_of_states, "state out of bounds");
101 return _entry[state];
102 }
103
104
105 void EntryPoint::print() {
106 tty->print("[");
107 for (int i = 0; i < number_of_states; i++) {
108 if (i > 0) tty->print(", ");
109 tty->print(INTPTR_FORMAT, p2i(_entry[i]));
110 }
111 tty->print("]");
112 }
113
114
115 bool EntryPoint::operator == (const EntryPoint& y) {
116 int i = number_of_states;
117 while (i-- > 0) {
118 if (_entry[i] != y._entry[i]) return false;
119 }
120 return true;
121 }
122
123
124 //------------------------------------------------------------------------------------------------------------------------
125 // Implementation of DispatchTable
126
127 EntryPoint DispatchTable::entry(int i) const {
128 assert(0 <= i && i < length, "index out of bounds");
129 return
130 EntryPoint(
131 _table[btos][i],
132 _table[ctos][i],
133 _table[stos][i],
134 _table[atos][i],
135 _table[itos][i],
136 _table[ltos][i],
137 _table[ftos][i],
138 _table[dtos][i],
139 _table[vtos][i]
140 );
141 }
142
143
144 void DispatchTable::set_entry(int i, EntryPoint& entry) {
145 assert(0 <= i && i < length, "index out of bounds");
146 assert(number_of_states == 9, "check the code below");
147 _table[btos][i] = entry.entry(btos);
148 _table[ctos][i] = entry.entry(ctos);
149 _table[stos][i] = entry.entry(stos);
150 _table[atos][i] = entry.entry(atos);
151 _table[itos][i] = entry.entry(itos);
152 _table[ltos][i] = entry.entry(ltos);
153 _table[ftos][i] = entry.entry(ftos);
154 _table[dtos][i] = entry.entry(dtos);
155 _table[vtos][i] = entry.entry(vtos);
156 }
157
158
159 bool DispatchTable::operator == (DispatchTable& y) {
160 int i = length;
161 while (i-- > 0) {
162 EntryPoint t = y.entry(i); // for compiler compatibility (BugId 4150096)
163 if (!(entry(i) == t)) return false;
164 }
165 return true;
166 }
167
168 address TemplateInterpreter::_remove_activation_entry = NULL;
169 address TemplateInterpreter::_remove_activation_preserving_args_entry = NULL;
170
171
172 address TemplateInterpreter::_throw_ArrayIndexOutOfBoundsException_entry = NULL;
173 address TemplateInterpreter::_throw_ArrayStoreException_entry = NULL;
174 address TemplateInterpreter::_throw_ArithmeticException_entry = NULL;
175 address TemplateInterpreter::_throw_ClassCastException_entry = NULL;
176 address TemplateInterpreter::_throw_NullPointerException_entry = NULL;
177 address TemplateInterpreter::_throw_StackOverflowError_entry = NULL;
178 address TemplateInterpreter::_throw_exception_entry = NULL;
179
180 #ifndef PRODUCT
181 EntryPoint TemplateInterpreter::_trace_code;
182 #endif // !PRODUCT
183 EntryPoint TemplateInterpreter::_return_entry[TemplateInterpreter::number_of_return_entries];
184 EntryPoint TemplateInterpreter::_earlyret_entry;
185 EntryPoint TemplateInterpreter::_deopt_entry [TemplateInterpreter::number_of_deopt_entries ];
186 EntryPoint TemplateInterpreter::_continuation_entry;
187 EntryPoint TemplateInterpreter::_safept_entry;
188
189 address TemplateInterpreter::_invoke_return_entry[TemplateInterpreter::number_of_return_addrs];
190 address TemplateInterpreter::_invokeinterface_return_entry[TemplateInterpreter::number_of_return_addrs];
191 address TemplateInterpreter::_invokedynamic_return_entry[TemplateInterpreter::number_of_return_addrs];
192
193 DispatchTable TemplateInterpreter::_active_table;
194 DispatchTable TemplateInterpreter::_normal_table;
195 DispatchTable TemplateInterpreter::_safept_table;
196 address TemplateInterpreter::_wentry_point[DispatchTable::length];
197
198 TemplateInterpreterGenerator::TemplateInterpreterGenerator(StubQueue* _code): AbstractInterpreterGenerator(_code) {
199 _unimplemented_bytecode = NULL;
200 _illegal_bytecode_sequence = NULL;
201 }
202
203 static const BasicType types[Interpreter::number_of_result_handlers] = {
204 T_BOOLEAN,
205 T_CHAR ,
206 T_BYTE ,
207 T_SHORT ,
208 T_INT ,
209 T_LONG ,
210 T_VOID ,
211 T_FLOAT ,
212 T_DOUBLE ,
213 T_OBJECT
214 };
215
216 void TemplateInterpreterGenerator::generate_all() {
217 AbstractInterpreterGenerator::generate_all();
218
219 { CodeletMark cm(_masm, "error exits");
220 _unimplemented_bytecode = generate_error_exit("unimplemented bytecode");
221 _illegal_bytecode_sequence = generate_error_exit("illegal bytecode sequence - method not verified");
222 }
223
224 #ifndef PRODUCT
225 if (TraceBytecodes) {
226 CodeletMark cm(_masm, "bytecode tracing support");
227 Interpreter::_trace_code =
228 EntryPoint(
229 generate_trace_code(btos),
230 generate_trace_code(ctos),
231 generate_trace_code(stos),
232 generate_trace_code(atos),
233 generate_trace_code(itos),
234 generate_trace_code(ltos),
235 generate_trace_code(ftos),
236 generate_trace_code(dtos),
237 generate_trace_code(vtos)
238 );
239 }
240 #endif // !PRODUCT
241
242 { CodeletMark cm(_masm, "return entry points");
243 const int index_size = sizeof(u2);
244 for (int i = 0; i < Interpreter::number_of_return_entries; i++) {
245 Interpreter::_return_entry[i] =
246 EntryPoint(
247 generate_return_entry_for(itos, i, index_size),
248 generate_return_entry_for(itos, i, index_size),
249 generate_return_entry_for(itos, i, index_size),
250 generate_return_entry_for(atos, i, index_size),
251 generate_return_entry_for(itos, i, index_size),
252 generate_return_entry_for(ltos, i, index_size),
253 generate_return_entry_for(ftos, i, index_size),
254 generate_return_entry_for(dtos, i, index_size),
255 generate_return_entry_for(vtos, i, index_size)
256 );
257 }
258 }
259
260 { CodeletMark cm(_masm, "invoke return entry points");
261 const TosState states[] = {itos, itos, itos, itos, ltos, ftos, dtos, atos, vtos};
262 const int invoke_length = Bytecodes::length_for(Bytecodes::_invokestatic);
263 const int invokeinterface_length = Bytecodes::length_for(Bytecodes::_invokeinterface);
264 const int invokedynamic_length = Bytecodes::length_for(Bytecodes::_invokedynamic);
265
266 for (int i = 0; i < Interpreter::number_of_return_addrs; i++) {
267 TosState state = states[i];
268 Interpreter::_invoke_return_entry[i] = generate_return_entry_for(state, invoke_length, sizeof(u2));
269 Interpreter::_invokeinterface_return_entry[i] = generate_return_entry_for(state, invokeinterface_length, sizeof(u2));
270 Interpreter::_invokedynamic_return_entry[i] = generate_return_entry_for(state, invokedynamic_length, sizeof(u4));
271 }
272 }
273
274 { CodeletMark cm(_masm, "earlyret entry points");
275 Interpreter::_earlyret_entry =
276 EntryPoint(
277 generate_earlyret_entry_for(btos),
278 generate_earlyret_entry_for(ctos),
279 generate_earlyret_entry_for(stos),
280 generate_earlyret_entry_for(atos),
281 generate_earlyret_entry_for(itos),
282 generate_earlyret_entry_for(ltos),
283 generate_earlyret_entry_for(ftos),
284 generate_earlyret_entry_for(dtos),
285 generate_earlyret_entry_for(vtos)
286 );
287 }
288
289 { CodeletMark cm(_masm, "deoptimization entry points");
290 for (int i = 0; i < Interpreter::number_of_deopt_entries; i++) {
291 Interpreter::_deopt_entry[i] =
292 EntryPoint(
293 generate_deopt_entry_for(itos, i),
294 generate_deopt_entry_for(itos, i),
295 generate_deopt_entry_for(itos, i),
296 generate_deopt_entry_for(atos, i),
297 generate_deopt_entry_for(itos, i),
298 generate_deopt_entry_for(ltos, i),
299 generate_deopt_entry_for(ftos, i),
300 generate_deopt_entry_for(dtos, i),
301 generate_deopt_entry_for(vtos, i)
302 );
303 }
304 }
305
306 { CodeletMark cm(_masm, "result handlers for native calls");
307 // The various result converter stublets.
308 int is_generated[Interpreter::number_of_result_handlers];
309 memset(is_generated, 0, sizeof(is_generated));
310
311 for (int i = 0; i < Interpreter::number_of_result_handlers; i++) {
312 BasicType type = types[i];
313 if (!is_generated[Interpreter::BasicType_as_index(type)]++) {
314 Interpreter::_native_abi_to_tosca[Interpreter::BasicType_as_index(type)] = generate_result_handler_for(type);
315 }
316 }
317 }
318
319 { CodeletMark cm(_masm, "continuation entry points");
320 Interpreter::_continuation_entry =
321 EntryPoint(
322 generate_continuation_for(btos),
323 generate_continuation_for(ctos),
324 generate_continuation_for(stos),
325 generate_continuation_for(atos),
326 generate_continuation_for(itos),
327 generate_continuation_for(ltos),
328 generate_continuation_for(ftos),
329 generate_continuation_for(dtos),
330 generate_continuation_for(vtos)
331 );
332 }
333
334 { CodeletMark cm(_masm, "safepoint entry points");
335 Interpreter::_safept_entry =
336 EntryPoint(
337 generate_safept_entry_for(btos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)),
338 generate_safept_entry_for(ctos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)),
339 generate_safept_entry_for(stos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)),
340 generate_safept_entry_for(atos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)),
341 generate_safept_entry_for(itos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)),
342 generate_safept_entry_for(ltos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)),
343 generate_safept_entry_for(ftos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)),
344 generate_safept_entry_for(dtos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)),
345 generate_safept_entry_for(vtos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint))
346 );
347 }
348
349 { CodeletMark cm(_masm, "exception handling");
350 // (Note: this is not safepoint safe because thread may return to compiled code)
351 generate_throw_exception();
352 }
353
354 { CodeletMark cm(_masm, "throw exception entrypoints");
355 Interpreter::_throw_ArrayIndexOutOfBoundsException_entry = generate_ArrayIndexOutOfBounds_handler("java/lang/ArrayIndexOutOfBoundsException");
356 Interpreter::_throw_ArrayStoreException_entry = generate_klass_exception_handler("java/lang/ArrayStoreException" );
357 Interpreter::_throw_ArithmeticException_entry = generate_exception_handler("java/lang/ArithmeticException" , "/ by zero");
358 Interpreter::_throw_ClassCastException_entry = generate_ClassCastException_handler();
359 Interpreter::_throw_NullPointerException_entry = generate_exception_handler("java/lang/NullPointerException" , NULL );
360 Interpreter::_throw_StackOverflowError_entry = generate_StackOverflowError_handler();
361 }
362
363
364
365 #define method_entry(kind) \
366 { CodeletMark cm(_masm, "method entry point (kind = " #kind ")"); \
367 Interpreter::_entry_table[Interpreter::kind] = generate_method_entry(Interpreter::kind); \
368 }
369
370 // all non-native method kinds
371 method_entry(zerolocals)
372 method_entry(zerolocals_synchronized)
373 method_entry(empty)
374 method_entry(accessor)
375 method_entry(abstract)
376 method_entry(java_lang_math_sin )
377 method_entry(java_lang_math_cos )
378 method_entry(java_lang_math_tan )
379 method_entry(java_lang_math_abs )
380 method_entry(java_lang_math_sqrt )
381 method_entry(java_lang_math_log )
382 method_entry(java_lang_math_log10)
383 method_entry(java_lang_math_exp )
384 method_entry(java_lang_math_pow )
385 method_entry(java_lang_ref_reference_get)
386
387 if (UseCRC32Intrinsics) {
388 method_entry(java_util_zip_CRC32_update)
389 method_entry(java_util_zip_CRC32_updateBytes)
390 method_entry(java_util_zip_CRC32_updateByteBuffer)
391 }
392
393 initialize_method_handle_entries();
394
395 // all native method kinds (must be one contiguous block)
396 Interpreter::_native_entry_begin = Interpreter::code()->code_end();
397 method_entry(native)
398 method_entry(native_synchronized)
399 Interpreter::_native_entry_end = Interpreter::code()->code_end();
400
401 #undef method_entry
402
403 // Bytecodes
404 set_entry_points_for_all_bytes();
405 set_safepoints_for_all_bytes();
406 }
407
408 //------------------------------------------------------------------------------------------------------------------------
409
410 address TemplateInterpreterGenerator::generate_error_exit(const char* msg) {
411 address entry = __ pc();
412 __ stop(msg);
413 return entry;
414 }
415
416
417 //------------------------------------------------------------------------------------------------------------------------
418
419 void TemplateInterpreterGenerator::set_entry_points_for_all_bytes() {
420 for (int i = 0; i < DispatchTable::length; i++) {
421 Bytecodes::Code code = (Bytecodes::Code)i;
422 if (Bytecodes::is_defined(code)) {
423 set_entry_points(code);
424 } else {
425 set_unimplemented(i);
426 }
427 }
428 }
429
430
431 void TemplateInterpreterGenerator::set_safepoints_for_all_bytes() {
432 for (int i = 0; i < DispatchTable::length; i++) {
433 Bytecodes::Code code = (Bytecodes::Code)i;
434 if (Bytecodes::is_defined(code)) Interpreter::_safept_table.set_entry(code, Interpreter::_safept_entry);
435 }
436 }
437
438
439 void TemplateInterpreterGenerator::set_unimplemented(int i) {
440 address e = _unimplemented_bytecode;
441 EntryPoint entry(e, e, e, e, e, e, e, e, e);
442 Interpreter::_normal_table.set_entry(i, entry);
443 Interpreter::_wentry_point[i] = _unimplemented_bytecode;
444 }
445
446
447 void TemplateInterpreterGenerator::set_entry_points(Bytecodes::Code code) {
448 CodeletMark cm(_masm, Bytecodes::name(code), code);
449 // initialize entry points
450 assert(_unimplemented_bytecode != NULL, "should have been generated before");
451 assert(_illegal_bytecode_sequence != NULL, "should have been generated before");
452 address bep = _illegal_bytecode_sequence;
453 address cep = _illegal_bytecode_sequence;
454 address sep = _illegal_bytecode_sequence;
455 address aep = _illegal_bytecode_sequence;
456 address iep = _illegal_bytecode_sequence;
457 address lep = _illegal_bytecode_sequence;
458 address fep = _illegal_bytecode_sequence;
459 address dep = _illegal_bytecode_sequence;
460 address vep = _unimplemented_bytecode;
461 address wep = _unimplemented_bytecode;
462 // code for short & wide version of bytecode
463 if (Bytecodes::is_defined(code)) {
464 Template* t = TemplateTable::template_for(code);
465 assert(t->is_valid(), "just checking");
466 set_short_entry_points(t, bep, cep, sep, aep, iep, lep, fep, dep, vep);
467 }
468 if (Bytecodes::wide_is_defined(code)) {
469 Template* t = TemplateTable::template_for_wide(code);
470 assert(t->is_valid(), "just checking");
471 set_wide_entry_point(t, wep);
472 }
473 // set entry points
474 EntryPoint entry(bep, cep, sep, aep, iep, lep, fep, dep, vep);
475 Interpreter::_normal_table.set_entry(code, entry);
476 Interpreter::_wentry_point[code] = wep;
477 }
478
479
480 void TemplateInterpreterGenerator::set_wide_entry_point(Template* t, address& wep) {
481 assert(t->is_valid(), "template must exist");
482 assert(t->tos_in() == vtos, "only vtos tos_in supported for wide instructions");
483 wep = __ pc(); generate_and_dispatch(t);
484 }
485
486
487 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) {
488 assert(t->is_valid(), "template must exist");
489 switch (t->tos_in()) {
490 case btos:
491 case ctos:
492 case stos:
493 ShouldNotReachHere(); // btos/ctos/stos should use itos.
494 break;
495 case atos: vep = __ pc(); __ pop(atos); aep = __ pc(); generate_and_dispatch(t); break;
496 case itos: vep = __ pc(); __ pop(itos); iep = __ pc(); generate_and_dispatch(t); break;
497 case ltos: vep = __ pc(); __ pop(ltos); lep = __ pc(); generate_and_dispatch(t); break;
498 case ftos: vep = __ pc(); __ pop(ftos); fep = __ pc(); generate_and_dispatch(t); break;
499 case dtos: vep = __ pc(); __ pop(dtos); dep = __ pc(); generate_and_dispatch(t); break;
500 case vtos: set_vtos_entry_points(t, bep, cep, sep, aep, iep, lep, fep, dep, vep); break;
501 default : ShouldNotReachHere(); break;
502 }
503 }
504
505
506 //------------------------------------------------------------------------------------------------------------------------
507
508 void TemplateInterpreterGenerator::generate_and_dispatch(Template* t, TosState tos_out) {
509 if (PrintBytecodeHistogram) histogram_bytecode(t);
510 #ifndef PRODUCT
511 // debugging code
512 if (CountBytecodes || TraceBytecodes || StopInterpreterAt > 0) count_bytecode();
513 if (PrintBytecodePairHistogram) histogram_bytecode_pair(t);
514 if (TraceBytecodes) trace_bytecode(t);
515 if (StopInterpreterAt > 0) stop_interpreter_at();
516 __ verify_FPU(1, t->tos_in());
517 #endif // !PRODUCT
518 int step;
519 if (!t->does_dispatch()) {
520 step = t->is_wide() ? Bytecodes::wide_length_for(t->bytecode()) : Bytecodes::length_for(t->bytecode());
521 if (tos_out == ilgl) tos_out = t->tos_out();
522 // compute bytecode size
523 assert(step > 0, "just checkin'");
524 // setup stuff for dispatching next bytecode
525 if (ProfileInterpreter && VerifyDataPointer
526 && MethodData::bytecode_has_profile(t->bytecode())) {
527 __ verify_method_data_pointer();
528 }
529 __ dispatch_prolog(tos_out, step);
530 }
531 // generate template
532 t->generate(_masm);
533 // advance
534 if (t->does_dispatch()) {
535 #ifdef ASSERT
536 // make sure execution doesn't go beyond this point if code is broken
537 __ should_not_reach_here();
538 #endif // ASSERT
539 } else {
540 // dispatch to next bytecode
541 __ dispatch_epilog(tos_out, step);
542 }
543 }
544
545 //------------------------------------------------------------------------------------------------------------------------
546 // Entry points
547
548 /**
549 * Returns the return entry table for the given invoke bytecode.
550 */
551 address* TemplateInterpreter::invoke_return_entry_table_for(Bytecodes::Code code) {
552 switch (code) {
553 case Bytecodes::_invokestatic:
554 case Bytecodes::_invokespecial:
555 case Bytecodes::_invokevirtual:
556 case Bytecodes::_invokehandle:
557 return Interpreter::invoke_return_entry_table();
558 case Bytecodes::_invokeinterface:
559 return Interpreter::invokeinterface_return_entry_table();
560 case Bytecodes::_invokedynamic:
561 return Interpreter::invokedynamic_return_entry_table();
562 default:
563 fatal(err_msg("invalid bytecode: %s", Bytecodes::name(code)));
564 return NULL;
565 }
566 }
567
568 /**
569 * Returns the return entry address for the given top-of-stack state and bytecode.
570 */
571 address TemplateInterpreter::return_entry(TosState state, int length, Bytecodes::Code code) {
572 guarantee(0 <= length && length < Interpreter::number_of_return_entries, "illegal length");
573 const int index = TosState_as_index(state);
574 switch (code) {
575 case Bytecodes::_invokestatic:
576 case Bytecodes::_invokespecial:
577 case Bytecodes::_invokevirtual:
578 case Bytecodes::_invokehandle:
579 return _invoke_return_entry[index];
580 case Bytecodes::_invokeinterface:
581 return _invokeinterface_return_entry[index];
582 case Bytecodes::_invokedynamic:
583 return _invokedynamic_return_entry[index];
584 default:
585 assert(!Bytecodes::is_invoke(code), err_msg("invoke instructions should be handled separately: %s", Bytecodes::name(code)));
586 return _return_entry[length].entry(state);
587 }
588 }
589
590
591 address TemplateInterpreter::deopt_entry(TosState state, int length) {
592 guarantee(0 <= length && length < Interpreter::number_of_deopt_entries, "illegal length");
593 return _deopt_entry[length].entry(state);
594 }
595
596 //------------------------------------------------------------------------------------------------------------------------
597 // Suport for invokes
598
599 int TemplateInterpreter::TosState_as_index(TosState state) {
600 assert( state < number_of_states , "Invalid state in TosState_as_index");
601 assert(0 <= (int)state && (int)state < TemplateInterpreter::number_of_return_addrs, "index out of bounds");
602 return (int)state;
603 }
604
605
606 //------------------------------------------------------------------------------------------------------------------------
607 // Safepoint suppport
608
609 static inline void copy_table(address* from, address* to, int size) {
610 // Copy non-overlapping tables. The copy has to occur word wise for MT safety.
611 while (size-- > 0) *to++ = *from++;
612 }
613
614 void TemplateInterpreter::notice_safepoints() {
615 if (!_notice_safepoints) {
616 // switch to safepoint dispatch table
617 _notice_safepoints = true;
618 copy_table((address*)&_safept_table, (address*)&_active_table, sizeof(_active_table) / sizeof(address));
619 }
620 }
621
622 // switch from the dispatch table which notices safepoints back to the
623 // normal dispatch table. So that we can notice single stepping points,
624 // keep the safepoint dispatch table if we are single stepping in JVMTI.
625 // Note that the should_post_single_step test is exactly as fast as the
626 // JvmtiExport::_enabled test and covers both cases.
627 void TemplateInterpreter::ignore_safepoints() {
628 if (_notice_safepoints) {
629 if (!JvmtiExport::should_post_single_step()) {
630 // switch to normal dispatch table
631 _notice_safepoints = false;
632 copy_table((address*)&_normal_table, (address*)&_active_table, sizeof(_active_table) / sizeof(address));
633 }
634 }
635 }
636
637 //------------------------------------------------------------------------------------------------------------------------
638 // Deoptimization support
639
640 // If deoptimization happens, this function returns the point of next bytecode to continue execution
641 address TemplateInterpreter::deopt_continue_after_entry(Method* method, address bcp, int callee_parameters, bool is_top_frame) {
642 return AbstractInterpreter::deopt_continue_after_entry(method, bcp, callee_parameters, is_top_frame);
643 }
644
645 // If deoptimization happens, this function returns the point where the interpreter reexecutes
646 // the bytecode.
647 // Note: Bytecodes::_athrow (C1 only) and Bytecodes::_return are the special cases
648 // that do not return "Interpreter::deopt_entry(vtos, 0)"
649 address TemplateInterpreter::deopt_reexecute_entry(Method* method, address bcp) {
650 assert(method->contains(bcp), "just checkin'");
651 Bytecodes::Code code = Bytecodes::java_code_at(method, bcp);
652 if (code == Bytecodes::_return) {
653 // This is used for deopt during registration of finalizers
654 // during Object.<init>. We simply need to resume execution at
655 // the standard return vtos bytecode to pop the frame normally.
656 // reexecuting the real bytecode would cause double registration
657 // of the finalizable object.
658 return _normal_table.entry(Bytecodes::_return).entry(vtos);
659 } else {
660 return AbstractInterpreter::deopt_reexecute_entry(method, bcp);
661 }
662 }
663
664 // If deoptimization happens, the interpreter should reexecute this bytecode.
665 // This function mainly helps the compilers to set up the reexecute bit.
666 bool TemplateInterpreter::bytecode_should_reexecute(Bytecodes::Code code) {
667 if (code == Bytecodes::_return) {
668 //Yes, we consider Bytecodes::_return as a special case of reexecution
669 return true;
670 } else {
671 return AbstractInterpreter::bytecode_should_reexecute(code);
672 }
673 }
674
675 #endif // !CC_INTERP