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