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