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 initialize_method_handle_entries(); 416 417 // all native method kinds (must be one contiguous block) 418 Interpreter::_native_entry_begin = Interpreter::code()->code_end(); 419 method_entry(native) 420 method_entry(native_synchronized) 421 Interpreter::_native_entry_end = Interpreter::code()->code_end(); 422 423 if (UseCRC32Intrinsics) { 424 method_entry(java_util_zip_CRC32_update) 425 method_entry(java_util_zip_CRC32_updateBytes) 426 method_entry(java_util_zip_CRC32_updateByteBuffer) 427 } 428 429 if (UseCRC32CIntrinsics) { 430 method_entry(java_util_zip_CRC32C_updateBytes) 431 method_entry(java_util_zip_CRC32C_updateDirectByteBuffer) 432 } 433 434 method_entry(java_lang_Float_intBitsToFloat); 435 method_entry(java_lang_Float_floatToRawIntBits); 436 method_entry(java_lang_Double_longBitsToDouble); 437 method_entry(java_lang_Double_doubleToRawLongBits); 438 439 #undef method_entry 440 441 // Bytecodes 442 set_entry_points_for_all_bytes(); 443 } 444 } while (CodeCacheExtensions::needs_other_interpreter_variant()); 445 446 // installation of code in other places in the runtime 447 // (ExcutableCodeManager calls not needed to copy the entries) 448 set_safepoints_for_all_bytes(); 449 } 450 451 //------------------------------------------------------------------------------------------------------------------------ 452 453 address TemplateInterpreterGenerator::generate_error_exit(const char* msg) { 454 address entry = __ pc(); 455 __ stop(msg); 456 return entry; 457 } 458 459 460 //------------------------------------------------------------------------------------------------------------------------ 461 462 void TemplateInterpreterGenerator::set_entry_points_for_all_bytes() { 463 for (int i = 0; i < DispatchTable::length; i++) { 464 Bytecodes::Code code = (Bytecodes::Code)i; 465 if (Bytecodes::is_defined(code)) { 466 set_entry_points(code); 467 } else { 468 set_unimplemented(i); 469 } 470 } 471 } 472 473 474 void TemplateInterpreterGenerator::set_safepoints_for_all_bytes() { 475 for (int i = 0; i < DispatchTable::length; i++) { 476 Bytecodes::Code code = (Bytecodes::Code)i; 477 if (Bytecodes::is_defined(code)) Interpreter::_safept_table.set_entry(code, Interpreter::_safept_entry); 478 } 479 } 480 481 482 void TemplateInterpreterGenerator::set_unimplemented(int i) { 483 address e = _unimplemented_bytecode; 484 EntryPoint entry(e, e, e, e, e, e, e, e, e); 485 Interpreter::_normal_table.set_entry(i, entry); 486 Interpreter::_wentry_point[i] = _unimplemented_bytecode; 487 } 488 489 490 void TemplateInterpreterGenerator::set_entry_points(Bytecodes::Code code) { 491 if (CodeCacheExtensions::skip_template_interpreter_entries(code)) { 492 return; 493 } 494 CodeletMark cm(_masm, Bytecodes::name(code), code); 495 // initialize entry points 496 assert(_unimplemented_bytecode != NULL, "should have been generated before"); 497 assert(_illegal_bytecode_sequence != NULL, "should have been generated before"); 498 address bep = _illegal_bytecode_sequence; 499 address cep = _illegal_bytecode_sequence; 500 address sep = _illegal_bytecode_sequence; 501 address aep = _illegal_bytecode_sequence; 502 address iep = _illegal_bytecode_sequence; 503 address lep = _illegal_bytecode_sequence; 504 address fep = _illegal_bytecode_sequence; 505 address dep = _illegal_bytecode_sequence; 506 address vep = _unimplemented_bytecode; 507 address wep = _unimplemented_bytecode; 508 // code for short & wide version of bytecode 509 if (Bytecodes::is_defined(code)) { 510 Template* t = TemplateTable::template_for(code); 511 assert(t->is_valid(), "just checking"); 512 set_short_entry_points(t, bep, cep, sep, aep, iep, lep, fep, dep, vep); 513 } 514 if (Bytecodes::wide_is_defined(code)) { 515 Template* t = TemplateTable::template_for_wide(code); 516 assert(t->is_valid(), "just checking"); 517 set_wide_entry_point(t, wep); 518 } 519 // set entry points 520 EntryPoint entry(bep, cep, sep, aep, iep, lep, fep, dep, vep); 521 Interpreter::_normal_table.set_entry(code, entry); 522 Interpreter::_wentry_point[code] = wep; 523 CodeCacheExtensions::completed_template_interpreter_entries(_masm, code); 524 } 525 526 527 void TemplateInterpreterGenerator::set_wide_entry_point(Template* t, address& wep) { 528 assert(t->is_valid(), "template must exist"); 529 assert(t->tos_in() == vtos, "only vtos tos_in supported for wide instructions"); 530 wep = __ pc(); generate_and_dispatch(t); 531 } 532 533 534 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) { 535 assert(t->is_valid(), "template must exist"); 536 switch (t->tos_in()) { 537 case btos: 538 case ctos: 539 case stos: 540 ShouldNotReachHere(); // btos/ctos/stos should use itos. 541 break; 542 case atos: vep = __ pc(); __ pop(atos); aep = __ pc(); generate_and_dispatch(t); break; 543 case itos: vep = __ pc(); __ pop(itos); iep = __ pc(); generate_and_dispatch(t); break; 544 case ltos: vep = __ pc(); __ pop(ltos); lep = __ pc(); generate_and_dispatch(t); break; 545 case ftos: vep = __ pc(); __ pop(ftos); fep = __ pc(); generate_and_dispatch(t); break; 546 case dtos: vep = __ pc(); __ pop(dtos); dep = __ pc(); generate_and_dispatch(t); break; 547 case vtos: set_vtos_entry_points(t, bep, cep, sep, aep, iep, lep, fep, dep, vep); break; 548 default : ShouldNotReachHere(); break; 549 } 550 } 551 552 553 //------------------------------------------------------------------------------------------------------------------------ 554 555 void TemplateInterpreterGenerator::generate_and_dispatch(Template* t, TosState tos_out) { 556 if (PrintBytecodeHistogram) histogram_bytecode(t); 557 #ifndef PRODUCT 558 // debugging code 559 if (CountBytecodes || TraceBytecodes || StopInterpreterAt > 0) count_bytecode(); 560 if (PrintBytecodePairHistogram) histogram_bytecode_pair(t); 561 if (TraceBytecodes) trace_bytecode(t); 562 if (StopInterpreterAt > 0) stop_interpreter_at(); 563 __ verify_FPU(1, t->tos_in()); 564 #endif // !PRODUCT 565 int step = 0; 566 if (!t->does_dispatch()) { 567 step = t->is_wide() ? Bytecodes::wide_length_for(t->bytecode()) : Bytecodes::length_for(t->bytecode()); 568 if (tos_out == ilgl) tos_out = t->tos_out(); 569 // compute bytecode size 570 assert(step > 0, "just checkin'"); 571 // setup stuff for dispatching next bytecode 572 if (ProfileInterpreter && VerifyDataPointer 573 && MethodData::bytecode_has_profile(t->bytecode())) { 574 __ verify_method_data_pointer(); 575 } 576 __ dispatch_prolog(tos_out, step); 577 } 578 // generate template 579 t->generate(_masm); 580 // advance 581 if (t->does_dispatch()) { 582 #ifdef ASSERT 583 // make sure execution doesn't go beyond this point if code is broken 584 __ should_not_reach_here(); 585 #endif // ASSERT 586 } else { 587 // dispatch to next bytecode 588 __ dispatch_epilog(tos_out, step); 589 } 590 } 591 592 //------------------------------------------------------------------------------------------------------------------------ 593 // Entry points 594 595 /** 596 * Returns the return entry table for the given invoke bytecode. 597 */ 598 address* TemplateInterpreter::invoke_return_entry_table_for(Bytecodes::Code code) { 599 switch (code) { 600 case Bytecodes::_invokestatic: 601 case Bytecodes::_invokespecial: 602 case Bytecodes::_invokevirtual: 603 case Bytecodes::_invokehandle: 604 return Interpreter::invoke_return_entry_table(); 605 case Bytecodes::_invokeinterface: 606 return Interpreter::invokeinterface_return_entry_table(); 607 case Bytecodes::_invokedynamic: 608 return Interpreter::invokedynamic_return_entry_table(); 609 default: 610 fatal("invalid bytecode: %s", Bytecodes::name(code)); 611 return NULL; 612 } 613 } 614 615 /** 616 * Returns the return entry address for the given top-of-stack state and bytecode. 617 */ 618 address TemplateInterpreter::return_entry(TosState state, int length, Bytecodes::Code code) { 619 guarantee(0 <= length && length < Interpreter::number_of_return_entries, "illegal length"); 620 const int index = TosState_as_index(state); 621 switch (code) { 622 case Bytecodes::_invokestatic: 623 case Bytecodes::_invokespecial: 624 case Bytecodes::_invokevirtual: 625 case Bytecodes::_invokehandle: 626 return _invoke_return_entry[index]; 627 case Bytecodes::_invokeinterface: 628 return _invokeinterface_return_entry[index]; 629 case Bytecodes::_invokedynamic: 630 return _invokedynamic_return_entry[index]; 631 default: 632 assert(!Bytecodes::is_invoke(code), "invoke instructions should be handled separately: %s", Bytecodes::name(code)); 633 return _return_entry[length].entry(state); 634 } 635 } 636 637 638 address TemplateInterpreter::deopt_entry(TosState state, int length) { 639 guarantee(0 <= length && length < Interpreter::number_of_deopt_entries, "illegal length"); 640 return _deopt_entry[length].entry(state); 641 } 642 643 //------------------------------------------------------------------------------------------------------------------------ 644 // Suport for invokes 645 646 int TemplateInterpreter::TosState_as_index(TosState state) { 647 assert( state < number_of_states , "Invalid state in TosState_as_index"); 648 assert(0 <= (int)state && (int)state < TemplateInterpreter::number_of_return_addrs, "index out of bounds"); 649 return (int)state; 650 } 651 652 653 //------------------------------------------------------------------------------------------------------------------------ 654 // Safepoint suppport 655 656 static inline void copy_table(address* from, address* to, int size) { 657 // Copy non-overlapping tables. The copy has to occur word wise for MT safety. 658 while (size-- > 0) *to++ = *from++; 659 } 660 661 void TemplateInterpreter::notice_safepoints() { 662 if (!_notice_safepoints) { 663 // switch to safepoint dispatch table 664 _notice_safepoints = true; 665 copy_table((address*)&_safept_table, (address*)&_active_table, sizeof(_active_table) / sizeof(address)); 666 } 667 } 668 669 // switch from the dispatch table which notices safepoints back to the 670 // normal dispatch table. So that we can notice single stepping points, 671 // keep the safepoint dispatch table if we are single stepping in JVMTI. 672 // Note that the should_post_single_step test is exactly as fast as the 673 // JvmtiExport::_enabled test and covers both cases. 674 void TemplateInterpreter::ignore_safepoints() { 675 if (_notice_safepoints) { 676 if (!JvmtiExport::should_post_single_step()) { 677 // switch to normal dispatch table 678 _notice_safepoints = false; 679 copy_table((address*)&_normal_table, (address*)&_active_table, sizeof(_active_table) / sizeof(address)); 680 } 681 } 682 } 683 684 //------------------------------------------------------------------------------------------------------------------------ 685 // Deoptimization support 686 687 // If deoptimization happens, this function returns the point of next bytecode to continue execution 688 address TemplateInterpreter::deopt_continue_after_entry(Method* method, address bcp, int callee_parameters, bool is_top_frame) { 689 return AbstractInterpreter::deopt_continue_after_entry(method, bcp, callee_parameters, is_top_frame); 690 } 691 692 // If deoptimization happens, this function returns the point where the interpreter reexecutes 693 // the bytecode. 694 // Note: Bytecodes::_athrow (C1 only) and Bytecodes::_return are the special cases 695 // that do not return "Interpreter::deopt_entry(vtos, 0)" 696 address TemplateInterpreter::deopt_reexecute_entry(Method* method, address bcp) { 697 assert(method->contains(bcp), "just checkin'"); 698 Bytecodes::Code code = Bytecodes::java_code_at(method, bcp); 699 if (code == Bytecodes::_return) { 700 // This is used for deopt during registration of finalizers 701 // during Object.<init>. We simply need to resume execution at 702 // the standard return vtos bytecode to pop the frame normally. 703 // reexecuting the real bytecode would cause double registration 704 // of the finalizable object. 705 return _normal_table.entry(Bytecodes::_return).entry(vtos); 706 } else { 707 return AbstractInterpreter::deopt_reexecute_entry(method, bcp); 708 } 709 } 710 711 // If deoptimization happens, the interpreter should reexecute this bytecode. 712 // This function mainly helps the compilers to set up the reexecute bit. 713 bool TemplateInterpreter::bytecode_should_reexecute(Bytecodes::Code code) { 714 if (code == Bytecodes::_return) { 715 //Yes, we consider Bytecodes::_return as a special case of reexecution 716 return true; 717 } else { 718 return AbstractInterpreter::bytecode_should_reexecute(code); 719 } 720 } 721 722 #endif // !CC_INTERP