< prev index next >

src/share/vm/interpreter/templateInterpreter.cpp

Print this page




  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


 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));


 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


  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 #include "memory/resourceArea.hpp"
  34 
  35 #ifndef CC_INTERP
  36 
  37 # define __ _masm->
  38 
  39 void TemplateInterpreter::initialize() {
  40   if (_code != NULL) return;
  41   // assertions
  42   assert((int)Bytecodes::number_of_codes <= (int)DispatchTable::length,
  43          "dispatch table too small");
  44 
  45   AbstractInterpreter::initialize();
  46 
  47   TemplateTable::initialize();
  48 
  49   // generate interpreter
  50   { ResourceMark rm;
  51     TraceTime timer("Interpreter generation", TraceStartupTime);
  52     int code_size = InterpreterCodeSize;
  53     NOT_PRODUCT(code_size *= 4;)  // debug uses extra interpreter code space


 203 address    TemplateInterpreter::_throw_exception_entry                      = NULL;
 204 
 205 #ifndef PRODUCT
 206 EntryPoint TemplateInterpreter::_trace_code;
 207 #endif // !PRODUCT
 208 EntryPoint TemplateInterpreter::_return_entry[TemplateInterpreter::number_of_return_entries];
 209 EntryPoint TemplateInterpreter::_earlyret_entry;
 210 EntryPoint TemplateInterpreter::_deopt_entry [TemplateInterpreter::number_of_deopt_entries ];
 211 EntryPoint TemplateInterpreter::_continuation_entry;
 212 EntryPoint TemplateInterpreter::_safept_entry;
 213 
 214 address TemplateInterpreter::_invoke_return_entry[TemplateInterpreter::number_of_return_addrs];
 215 address TemplateInterpreter::_invokeinterface_return_entry[TemplateInterpreter::number_of_return_addrs];
 216 address TemplateInterpreter::_invokedynamic_return_entry[TemplateInterpreter::number_of_return_addrs];
 217 
 218 DispatchTable TemplateInterpreter::_active_table;
 219 DispatchTable TemplateInterpreter::_normal_table;
 220 DispatchTable TemplateInterpreter::_safept_table;
 221 address    TemplateInterpreter::_wentry_point[DispatchTable::length];
 222 


















































































































































































































































































































































































 223 
 224 //------------------------------------------------------------------------------------------------------------------------
 225 // Entry points
 226 
 227 /**
 228  * Returns the return entry table for the given invoke bytecode.
 229  */
 230 address* TemplateInterpreter::invoke_return_entry_table_for(Bytecodes::Code code) {
 231   switch (code) {
 232   case Bytecodes::_invokestatic:
 233   case Bytecodes::_invokespecial:
 234   case Bytecodes::_invokevirtual:
 235   case Bytecodes::_invokehandle:
 236     return Interpreter::invoke_return_entry_table();
 237   case Bytecodes::_invokeinterface:
 238     return Interpreter::invokeinterface_return_entry_table();
 239   case Bytecodes::_invokedynamic:
 240     return Interpreter::invokedynamic_return_entry_table();
 241   default:
 242     fatal("invalid bytecode: %s", Bytecodes::name(code));


 338   } else {
 339     return AbstractInterpreter::deopt_reexecute_entry(method, bcp);
 340   }
 341 }
 342 
 343 // If deoptimization happens, the interpreter should reexecute this bytecode.
 344 // This function mainly helps the compilers to set up the reexecute bit.
 345 bool TemplateInterpreter::bytecode_should_reexecute(Bytecodes::Code code) {
 346   if (code == Bytecodes::_return) {
 347     //Yes, we consider Bytecodes::_return as a special case of reexecution
 348     return true;
 349   } else {
 350     return AbstractInterpreter::bytecode_should_reexecute(code);
 351   }
 352 }
 353 
 354 InterpreterCodelet* TemplateInterpreter::codelet_containing(address pc) {
 355   return (InterpreterCodelet*)_code->stub_containing(pc);
 356 }
 357 

















































































 358 #endif // !CC_INTERP
< prev index next >