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 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 TemplateInterpreterGenerator 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 generate_all(); 226 } 227 228 static const BasicType types[Interpreter::number_of_result_handlers] = { 229 T_BOOLEAN, 230 T_CHAR , 231 T_BYTE , 232 T_SHORT , 233 T_INT , 234 T_LONG , 235 T_VOID , 236 T_FLOAT , 237 T_DOUBLE , 238 T_OBJECT 239 }; 240 241 void TemplateInterpreterGenerator::generate_all() { 242 // Loop, in case we need several variants of the interpreter entries 243 do { 244 if (!CodeCacheExtensions::skip_code_generation()) { 245 // bypass code generation when useless 246 AbstractInterpreterGenerator::generate_all(); 247 248 { CodeletMark cm(_masm, "error exits"); 249 _unimplemented_bytecode = generate_error_exit("unimplemented bytecode"); 250 _illegal_bytecode_sequence = generate_error_exit("illegal bytecode sequence - method not verified"); 251 } 252 253 #ifndef PRODUCT 254 if (TraceBytecodes) { 255 CodeletMark cm(_masm, "bytecode tracing support"); 256 Interpreter::_trace_code = 257 EntryPoint( 258 generate_trace_code(btos), 259 generate_trace_code(ctos), 260 generate_trace_code(stos), 261 generate_trace_code(atos), 262 generate_trace_code(itos), 263 generate_trace_code(ltos), 264 generate_trace_code(ftos), 265 generate_trace_code(dtos), 266 generate_trace_code(vtos) 267 ); 268 } 269 #endif // !PRODUCT 270 271 { CodeletMark cm(_masm, "return entry points"); 272 const int index_size = sizeof(u2); 273 for (int i = 0; i < Interpreter::number_of_return_entries; i++) { 274 Interpreter::_return_entry[i] = 275 EntryPoint( 276 generate_return_entry_for(itos, i, index_size), 277 generate_return_entry_for(itos, i, index_size), 278 generate_return_entry_for(itos, i, index_size), 279 generate_return_entry_for(atos, i, index_size), 280 generate_return_entry_for(itos, i, index_size), 281 generate_return_entry_for(ltos, i, index_size), 282 generate_return_entry_for(ftos, i, index_size), 283 generate_return_entry_for(dtos, i, index_size), 284 generate_return_entry_for(vtos, i, index_size) 285 ); 286 } 287 } 288 289 { CodeletMark cm(_masm, "invoke return entry points"); 290 const TosState states[] = {itos, itos, itos, itos, ltos, ftos, dtos, atos, vtos}; 291 const int invoke_length = Bytecodes::length_for(Bytecodes::_invokestatic); 292 const int invokeinterface_length = Bytecodes::length_for(Bytecodes::_invokeinterface); 293 const int invokedynamic_length = Bytecodes::length_for(Bytecodes::_invokedynamic); 294 295 for (int i = 0; i < Interpreter::number_of_return_addrs; i++) { 296 TosState state = states[i]; 297 Interpreter::_invoke_return_entry[i] = generate_return_entry_for(state, invoke_length, sizeof(u2)); 298 Interpreter::_invokeinterface_return_entry[i] = generate_return_entry_for(state, invokeinterface_length, sizeof(u2)); 299 Interpreter::_invokedynamic_return_entry[i] = generate_return_entry_for(state, invokedynamic_length, sizeof(u4)); 300 } 301 } 302 303 { CodeletMark cm(_masm, "earlyret entry points"); 304 Interpreter::_earlyret_entry = 305 EntryPoint( 306 generate_earlyret_entry_for(btos), 307 generate_earlyret_entry_for(ctos), 308 generate_earlyret_entry_for(stos), 309 generate_earlyret_entry_for(atos), 310 generate_earlyret_entry_for(itos), 311 generate_earlyret_entry_for(ltos), 312 generate_earlyret_entry_for(ftos), 313 generate_earlyret_entry_for(dtos), 314 generate_earlyret_entry_for(vtos) 315 ); 316 } 317 318 { CodeletMark cm(_masm, "deoptimization entry points"); 319 for (int i = 0; i < Interpreter::number_of_deopt_entries; i++) { 320 Interpreter::_deopt_entry[i] = 321 EntryPoint( 322 generate_deopt_entry_for(itos, i), 323 generate_deopt_entry_for(itos, i), 324 generate_deopt_entry_for(itos, i), 325 generate_deopt_entry_for(atos, i), 326 generate_deopt_entry_for(itos, i), 327 generate_deopt_entry_for(ltos, i), 328 generate_deopt_entry_for(ftos, i), 329 generate_deopt_entry_for(dtos, i), 330 generate_deopt_entry_for(vtos, i) 331 ); 332 } 333 } 334 335 { CodeletMark cm(_masm, "result handlers for native calls"); 336 // The various result converter stublets. 337 int is_generated[Interpreter::number_of_result_handlers]; 338 memset(is_generated, 0, sizeof(is_generated)); 339 340 for (int i = 0; i < Interpreter::number_of_result_handlers; i++) { 341 BasicType type = types[i]; 342 if (!is_generated[Interpreter::BasicType_as_index(type)]++) { 343 Interpreter::_native_abi_to_tosca[Interpreter::BasicType_as_index(type)] = generate_result_handler_for(type); 344 } 345 } 346 } 347 348 { CodeletMark cm(_masm, "continuation entry points"); 349 Interpreter::_continuation_entry = 350 EntryPoint( 351 generate_continuation_for(btos), 352 generate_continuation_for(ctos), 353 generate_continuation_for(stos), 354 generate_continuation_for(atos), 355 generate_continuation_for(itos), 356 generate_continuation_for(ltos), 357 generate_continuation_for(ftos), 358 generate_continuation_for(dtos), 359 generate_continuation_for(vtos) 360 ); 361 } 362 363 { CodeletMark cm(_masm, "safepoint entry points"); 364 Interpreter::_safept_entry = 365 EntryPoint( 366 generate_safept_entry_for(btos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)), 367 generate_safept_entry_for(ctos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)), 368 generate_safept_entry_for(stos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)), 369 generate_safept_entry_for(atos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)), 370 generate_safept_entry_for(itos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)), 371 generate_safept_entry_for(ltos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)), 372 generate_safept_entry_for(ftos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)), 373 generate_safept_entry_for(dtos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)), 374 generate_safept_entry_for(vtos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)) 375 ); 376 } 377 378 { CodeletMark cm(_masm, "exception handling"); 379 // (Note: this is not safepoint safe because thread may return to compiled code) 380 generate_throw_exception(); 381 } 382 383 { CodeletMark cm(_masm, "throw exception entrypoints"); 384 Interpreter::_throw_ArrayIndexOutOfBoundsException_entry = generate_ArrayIndexOutOfBounds_handler("java/lang/ArrayIndexOutOfBoundsException"); 385 Interpreter::_throw_ArrayStoreException_entry = generate_klass_exception_handler("java/lang/ArrayStoreException" ); 386 Interpreter::_throw_ArithmeticException_entry = generate_exception_handler("java/lang/ArithmeticException" , "/ by zero"); 387 Interpreter::_throw_ClassCastException_entry = generate_ClassCastException_handler(); 388 Interpreter::_throw_NullPointerException_entry = generate_exception_handler("java/lang/NullPointerException" , NULL ); 389 Interpreter::_throw_StackOverflowError_entry = generate_StackOverflowError_handler(); 390 } 391 392 393 394 #define method_entry(kind) \ 395 { CodeletMark cm(_masm, "method entry point (kind = " #kind ")"); \ 396 Interpreter::_entry_table[Interpreter::kind] = generate_method_entry(Interpreter::kind); \ 397 } 398 399 // all non-native method kinds 400 method_entry(zerolocals) 401 method_entry(zerolocals_synchronized) 402 method_entry(empty) 403 method_entry(accessor) 404 method_entry(abstract) 405 method_entry(java_lang_math_sin ) 406 method_entry(java_lang_math_cos ) 407 method_entry(java_lang_math_tan ) 408 method_entry(java_lang_math_abs ) 409 method_entry(java_lang_math_sqrt ) 410 method_entry(java_lang_math_log ) 411 method_entry(java_lang_math_log10) 412 method_entry(java_lang_math_exp ) 413 method_entry(java_lang_math_pow ) 414 method_entry(java_lang_ref_reference_get) 415 416 initialize_method_handle_entries(); 417 418 // all native method kinds (must be one contiguous block) 419 Interpreter::_native_entry_begin = Interpreter::code()->code_end(); 420 method_entry(native) 421 method_entry(native_synchronized) 422 Interpreter::_native_entry_end = Interpreter::code()->code_end(); 423 424 if (UseCRC32Intrinsics) { 425 method_entry(java_util_zip_CRC32_update) 426 method_entry(java_util_zip_CRC32_updateBytes) 427 method_entry(java_util_zip_CRC32_updateByteBuffer) 428 } 429 430 if (UseCRC32CIntrinsics) { 431 method_entry(java_util_zip_CRC32C_updateBytes) 432 method_entry(java_util_zip_CRC32C_updateDirectByteBuffer) 433 } 434 435 method_entry(java_lang_Float_intBitsToFloat); 436 method_entry(java_lang_Float_floatToRawIntBits); 437 method_entry(java_lang_Double_longBitsToDouble); 438 method_entry(java_lang_Double_doubleToRawLongBits); 439 440 #undef method_entry 441 442 // Bytecodes 443 set_entry_points_for_all_bytes(); 444 } 445 } while (CodeCacheExtensions::needs_other_interpreter_variant()); 446 447 // installation of code in other places in the runtime 448 // (ExcutableCodeManager calls not needed to copy the entries) 449 set_safepoints_for_all_bytes(); 450 } 451 452 //------------------------------------------------------------------------------------------------------------------------ 453 454 address TemplateInterpreterGenerator::generate_error_exit(const char* msg) { 455 address entry = __ pc(); 456 __ stop(msg); 457 return entry; 458 } 459 460 461 //------------------------------------------------------------------------------------------------------------------------ 462 463 void TemplateInterpreterGenerator::set_entry_points_for_all_bytes() { 464 for (int i = 0; i < DispatchTable::length; i++) { 465 Bytecodes::Code code = (Bytecodes::Code)i; 466 if (Bytecodes::is_defined(code)) { 467 set_entry_points(code); 468 } else { 469 set_unimplemented(i); 470 } 471 } 472 } 473 474 475 void TemplateInterpreterGenerator::set_safepoints_for_all_bytes() { 476 for (int i = 0; i < DispatchTable::length; i++) { 477 Bytecodes::Code code = (Bytecodes::Code)i; 478 if (Bytecodes::is_defined(code)) Interpreter::_safept_table.set_entry(code, Interpreter::_safept_entry); 479 } 480 } 481 482 483 void TemplateInterpreterGenerator::set_unimplemented(int i) { 484 address e = _unimplemented_bytecode; 485 EntryPoint entry(e, e, e, e, e, e, e, e, e); 486 Interpreter::_normal_table.set_entry(i, entry); 487 Interpreter::_wentry_point[i] = _unimplemented_bytecode; 488 } 489 490 491 void TemplateInterpreterGenerator::set_entry_points(Bytecodes::Code code) { 492 if (CodeCacheExtensions::skip_template_interpreter_entries(code)) { 493 return; 494 } 495 CodeletMark cm(_masm, Bytecodes::name(code), code); 496 // initialize entry points 497 assert(_unimplemented_bytecode != NULL, "should have been generated before"); 498 assert(_illegal_bytecode_sequence != NULL, "should have been generated before"); 499 address bep = _illegal_bytecode_sequence; 500 address cep = _illegal_bytecode_sequence; 501 address sep = _illegal_bytecode_sequence; 502 address aep = _illegal_bytecode_sequence; 503 address iep = _illegal_bytecode_sequence; 504 address lep = _illegal_bytecode_sequence; 505 address fep = _illegal_bytecode_sequence; 506 address dep = _illegal_bytecode_sequence; 507 address vep = _unimplemented_bytecode; 508 address wep = _unimplemented_bytecode; 509 // code for short & wide version of bytecode 510 if (Bytecodes::is_defined(code)) { 511 Template* t = TemplateTable::template_for(code); 512 assert(t->is_valid(), "just checking"); 513 set_short_entry_points(t, bep, cep, sep, aep, iep, lep, fep, dep, vep); 514 } 515 if (Bytecodes::wide_is_defined(code)) { 516 Template* t = TemplateTable::template_for_wide(code); 517 assert(t->is_valid(), "just checking"); 518 set_wide_entry_point(t, wep); 519 } 520 // set entry points 521 EntryPoint entry(bep, cep, sep, aep, iep, lep, fep, dep, vep); 522 Interpreter::_normal_table.set_entry(code, entry); 523 Interpreter::_wentry_point[code] = wep; 524 CodeCacheExtensions::completed_template_interpreter_entries(_masm, code); 525 } 526 527 528 void TemplateInterpreterGenerator::set_wide_entry_point(Template* t, address& wep) { 529 assert(t->is_valid(), "template must exist"); 530 assert(t->tos_in() == vtos, "only vtos tos_in supported for wide instructions"); 531 wep = __ pc(); generate_and_dispatch(t); 532 } 533 534 535 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) { 536 assert(t->is_valid(), "template must exist"); 537 switch (t->tos_in()) { 538 case btos: 539 case ctos: 540 case stos: 541 ShouldNotReachHere(); // btos/ctos/stos should use itos. 542 break; 543 case atos: vep = __ pc(); __ pop(atos); aep = __ pc(); generate_and_dispatch(t); break; 544 case itos: vep = __ pc(); __ pop(itos); iep = __ pc(); generate_and_dispatch(t); break; 545 case ltos: vep = __ pc(); __ pop(ltos); lep = __ pc(); generate_and_dispatch(t); break; 546 case ftos: vep = __ pc(); __ pop(ftos); fep = __ pc(); generate_and_dispatch(t); break; 547 case dtos: vep = __ pc(); __ pop(dtos); dep = __ pc(); generate_and_dispatch(t); break; 548 case vtos: set_vtos_entry_points(t, bep, cep, sep, aep, iep, lep, fep, dep, vep); break; 549 default : ShouldNotReachHere(); break; 550 } 551 } 552 553 554 //------------------------------------------------------------------------------------------------------------------------ 555 556 void TemplateInterpreterGenerator::generate_and_dispatch(Template* t, TosState tos_out) { 557 if (PrintBytecodeHistogram) histogram_bytecode(t); 558 #ifndef PRODUCT 559 // debugging code 560 if (CountBytecodes || TraceBytecodes || StopInterpreterAt > 0) count_bytecode(); 561 if (PrintBytecodePairHistogram) histogram_bytecode_pair(t); 562 if (TraceBytecodes) trace_bytecode(t); 563 if (StopInterpreterAt > 0) stop_interpreter_at(); 564 __ verify_FPU(1, t->tos_in()); 565 #endif // !PRODUCT 566 int step = 0; 567 if (!t->does_dispatch()) { 568 step = t->is_wide() ? Bytecodes::wide_length_for(t->bytecode()) : Bytecodes::length_for(t->bytecode()); 569 if (tos_out == ilgl) tos_out = t->tos_out(); 570 // compute bytecode size 571 assert(step > 0, "just checkin'"); 572 // setup stuff for dispatching next bytecode 573 if (ProfileInterpreter && VerifyDataPointer 574 && MethodData::bytecode_has_profile(t->bytecode())) { 575 __ verify_method_data_pointer(); 576 } 577 __ dispatch_prolog(tos_out, step); 578 } 579 // generate template 580 t->generate(_masm); 581 // advance 582 if (t->does_dispatch()) { 583 #ifdef ASSERT 584 // make sure execution doesn't go beyond this point if code is broken 585 __ should_not_reach_here(); 586 #endif // ASSERT 587 } else { 588 // dispatch to next bytecode 589 __ dispatch_epilog(tos_out, step); 590 } 591 } 592 593 //------------------------------------------------------------------------------------------------------------------------ 594 // Entry points 595 596 /** 597 * Returns the return entry table for the given invoke bytecode. 598 */ 599 address* TemplateInterpreter::invoke_return_entry_table_for(Bytecodes::Code code) { 600 switch (code) { 601 case Bytecodes::_invokestatic: 602 case Bytecodes::_invokespecial: 603 case Bytecodes::_invokevirtual: 604 case Bytecodes::_invokehandle: 605 return Interpreter::invoke_return_entry_table(); 606 case Bytecodes::_invokeinterface: 607 return Interpreter::invokeinterface_return_entry_table(); 608 case Bytecodes::_invokedynamic: 609 return Interpreter::invokedynamic_return_entry_table(); 610 default: 611 fatal("invalid bytecode: %s", Bytecodes::name(code)); 612 return NULL; 613 } 614 } 615 616 /** 617 * Returns the return entry address for the given top-of-stack state and bytecode. 618 */ 619 address TemplateInterpreter::return_entry(TosState state, int length, Bytecodes::Code code) { 620 guarantee(0 <= length && length < Interpreter::number_of_return_entries, "illegal length"); 621 const int index = TosState_as_index(state); 622 switch (code) { 623 case Bytecodes::_invokestatic: 624 case Bytecodes::_invokespecial: 625 case Bytecodes::_invokevirtual: 626 case Bytecodes::_invokehandle: 627 return _invoke_return_entry[index]; 628 case Bytecodes::_invokeinterface: 629 return _invokeinterface_return_entry[index]; 630 case Bytecodes::_invokedynamic: 631 return _invokedynamic_return_entry[index]; 632 default: 633 assert(!Bytecodes::is_invoke(code), "invoke instructions should be handled separately: %s", Bytecodes::name(code)); 634 return _return_entry[length].entry(state); 635 } 636 } 637 638 639 address TemplateInterpreter::deopt_entry(TosState state, int length) { 640 guarantee(0 <= length && length < Interpreter::number_of_deopt_entries, "illegal length"); 641 return _deopt_entry[length].entry(state); 642 } 643 644 //------------------------------------------------------------------------------------------------------------------------ 645 // Suport for invokes 646 647 int TemplateInterpreter::TosState_as_index(TosState state) { 648 assert( state < number_of_states , "Invalid state in TosState_as_index"); 649 assert(0 <= (int)state && (int)state < TemplateInterpreter::number_of_return_addrs, "index out of bounds"); 650 return (int)state; 651 } 652 653 654 //------------------------------------------------------------------------------------------------------------------------ 655 // Safepoint suppport 656 657 static inline void copy_table(address* from, address* to, int size) { 658 // Copy non-overlapping tables. The copy has to occur word wise for MT safety. 659 while (size-- > 0) *to++ = *from++; 660 } 661 662 void TemplateInterpreter::notice_safepoints() { 663 if (!_notice_safepoints) { 664 // switch to safepoint dispatch table 665 _notice_safepoints = true; 666 copy_table((address*)&_safept_table, (address*)&_active_table, sizeof(_active_table) / sizeof(address)); 667 } 668 } 669 670 // switch from the dispatch table which notices safepoints back to the 671 // normal dispatch table. So that we can notice single stepping points, 672 // keep the safepoint dispatch table if we are single stepping in JVMTI. 673 // Note that the should_post_single_step test is exactly as fast as the 674 // JvmtiExport::_enabled test and covers both cases. 675 void TemplateInterpreter::ignore_safepoints() { 676 if (_notice_safepoints) { 677 if (!JvmtiExport::should_post_single_step()) { 678 // switch to normal dispatch table 679 _notice_safepoints = false; 680 copy_table((address*)&_normal_table, (address*)&_active_table, sizeof(_active_table) / sizeof(address)); 681 } 682 } 683 } 684 685 //------------------------------------------------------------------------------------------------------------------------ 686 // Deoptimization support 687 688 // If deoptimization happens, this function returns the point of next bytecode to continue execution 689 address TemplateInterpreter::deopt_continue_after_entry(Method* method, address bcp, int callee_parameters, bool is_top_frame) { 690 return AbstractInterpreter::deopt_continue_after_entry(method, bcp, callee_parameters, is_top_frame); 691 } 692 693 // If deoptimization happens, this function returns the point where the interpreter reexecutes 694 // the bytecode. 695 // Note: Bytecodes::_athrow (C1 only) and Bytecodes::_return are the special cases 696 // that do not return "Interpreter::deopt_entry(vtos, 0)" 697 address TemplateInterpreter::deopt_reexecute_entry(Method* method, address bcp) { 698 assert(method->contains(bcp), "just checkin'"); 699 Bytecodes::Code code = Bytecodes::java_code_at(method, bcp); 700 if (code == Bytecodes::_return) { 701 // This is used for deopt during registration of finalizers 702 // during Object.<init>. We simply need to resume execution at 703 // the standard return vtos bytecode to pop the frame normally. 704 // reexecuting the real bytecode would cause double registration 705 // of the finalizable object. 706 return _normal_table.entry(Bytecodes::_return).entry(vtos); 707 } else { 708 return AbstractInterpreter::deopt_reexecute_entry(method, bcp); 709 } 710 } 711 712 // If deoptimization happens, the interpreter should reexecute this bytecode. 713 // This function mainly helps the compilers to set up the reexecute bit. 714 bool TemplateInterpreter::bytecode_should_reexecute(Bytecodes::Code code) { 715 if (code == Bytecodes::_return) { 716 //Yes, we consider Bytecodes::_return as a special case of reexecution 717 return true; 718 } else { 719 return AbstractInterpreter::bytecode_should_reexecute(code); 720 } 721 } 722 723 InterpreterCodelet* TemplateInterpreter::codelet_containing(address pc) { 724 return (InterpreterCodelet*)_code->stub_containing(pc); 725 } 726 727 // Generate method entries 728 address TemplateInterpreterGenerator::generate_method_entry( 729 AbstractInterpreter::MethodKind kind) { 730 // determine code generation flags 731 bool native = false; 732 bool synchronized = false; 733 address entry_point = NULL; 734 735 switch (kind) { 736 case Interpreter::zerolocals : break; 737 case Interpreter::zerolocals_synchronized: synchronized = true; break; 738 case Interpreter::native : native = true; break; 739 case Interpreter::native_synchronized : native = true; synchronized = true; break; 740 case Interpreter::empty : break; 741 case Interpreter::accessor : break; 742 case Interpreter::abstract : entry_point = generate_abstract_entry(); break; 743 744 case Interpreter::java_lang_math_sin : // fall thru 745 case Interpreter::java_lang_math_cos : // fall thru 746 case Interpreter::java_lang_math_tan : // fall thru 747 case Interpreter::java_lang_math_abs : // fall thru 748 case Interpreter::java_lang_math_log : // fall thru 749 case Interpreter::java_lang_math_log10 : // fall thru 750 case Interpreter::java_lang_math_sqrt : // fall thru 751 case Interpreter::java_lang_math_pow : // fall thru 752 case Interpreter::java_lang_math_exp : entry_point = generate_math_entry(kind); break; 753 case Interpreter::java_lang_ref_reference_get 754 : entry_point = generate_Reference_get_entry(); break; 755 case Interpreter::java_util_zip_CRC32_update 756 : native = true; entry_point = generate_CRC32_update_entry(); break; 757 case Interpreter::java_util_zip_CRC32_updateBytes 758 : // fall thru 759 case Interpreter::java_util_zip_CRC32_updateByteBuffer 760 : native = true; entry_point = generate_CRC32_updateBytes_entry(kind); break; 761 case Interpreter::java_util_zip_CRC32C_updateBytes 762 : // fall thru 763 case Interpreter::java_util_zip_CRC32C_updateDirectByteBuffer 764 : entry_point = generate_CRC32C_updateBytes_entry(kind); break; 765 #ifdef IA32 766 // On x86_32 platforms, a special entry is generated for the following four methods. 767 // On other platforms the normal entry is used to enter these methods. 768 case Interpreter::java_lang_Float_intBitsToFloat 769 : native = true; entry_point = generate_Float_intBitsToFloat_entry(); break; 770 case Interpreter::java_lang_Float_floatToRawIntBits 771 : native = true; entry_point = generate_Float_floatToRawIntBits_entry(); break; 772 case Interpreter::java_lang_Double_longBitsToDouble 773 : native = true; entry_point = generate_Double_longBitsToDouble_entry(); break; 774 case Interpreter::java_lang_Double_doubleToRawLongBits 775 : native = true; entry_point = generate_Double_doubleToRawLongBits_entry(); break; 776 #else 777 case Interpreter::java_lang_Float_intBitsToFloat: 778 case Interpreter::java_lang_Float_floatToRawIntBits: 779 case Interpreter::java_lang_Double_longBitsToDouble: 780 case Interpreter::java_lang_Double_doubleToRawLongBits: 781 native = true; 782 break; 783 #endif // defined(TARGET_ARCH_x86) && !defined(_LP64) 784 default: 785 fatal("unexpected method kind: %d", kind); 786 break; 787 } 788 789 if (entry_point) { 790 return entry_point; 791 } 792 793 // We expect the normal and native entry points to be generated first so we can reuse them. 794 if (native) { 795 entry_point = Interpreter::entry_for_kind(synchronized ? Interpreter::native_synchronized : Interpreter::native); 796 if (entry_point == NULL) { 797 entry_point = generate_native_entry(synchronized); 798 } 799 } else { 800 entry_point = Interpreter::entry_for_kind(synchronized ? Interpreter::zerolocals_synchronized : Interpreter::zerolocals); 801 if (entry_point == NULL) { 802 entry_point = generate_normal_entry(synchronized); 803 } 804 } 805 806 return entry_point; 807 } 808 #endif // !CC_INTERP