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