templateInterpreterGenerator.cpp revision 12887:dedf248e8e3e
1/* 2 * Copyright (c) 1997, 2016, 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 "interpreter/interpreter.hpp" 27#include "interpreter/interpreterRuntime.hpp" 28#include "interpreter/interp_masm.hpp" 29#include "interpreter/templateInterpreter.hpp" 30#include "interpreter/templateInterpreterGenerator.hpp" 31#include "interpreter/templateTable.hpp" 32 33#ifndef CC_INTERP 34 35# define __ _masm-> 36 37TemplateInterpreterGenerator::TemplateInterpreterGenerator(StubQueue* _code): AbstractInterpreterGenerator(_code) { 38 _unimplemented_bytecode = NULL; 39 _illegal_bytecode_sequence = NULL; 40 generate_all(); 41} 42 43static const BasicType types[Interpreter::number_of_result_handlers] = { 44 T_BOOLEAN, 45 T_CHAR , 46 T_BYTE , 47 T_SHORT , 48 T_INT , 49 T_LONG , 50 T_VOID , 51 T_FLOAT , 52 T_DOUBLE , 53 T_OBJECT 54}; 55 56void TemplateInterpreterGenerator::generate_all() { 57 { CodeletMark cm(_masm, "slow signature handler"); 58 AbstractInterpreter::_slow_signature_handler = generate_slow_signature_handler(); 59 } 60 61 { CodeletMark cm(_masm, "error exits"); 62 _unimplemented_bytecode = generate_error_exit("unimplemented bytecode"); 63 _illegal_bytecode_sequence = generate_error_exit("illegal bytecode sequence - method not verified"); 64 } 65 66#ifndef PRODUCT 67 if (TraceBytecodes) { 68 CodeletMark cm(_masm, "bytecode tracing support"); 69 Interpreter::_trace_code = 70 EntryPoint( 71 generate_trace_code(btos), 72 generate_trace_code(ztos), 73 generate_trace_code(ctos), 74 generate_trace_code(stos), 75 generate_trace_code(atos), 76 generate_trace_code(itos), 77 generate_trace_code(ltos), 78 generate_trace_code(ftos), 79 generate_trace_code(dtos), 80 generate_trace_code(vtos) 81 ); 82 } 83#endif // !PRODUCT 84 85 { CodeletMark cm(_masm, "return entry points"); 86 const int index_size = sizeof(u2); 87 for (int i = 0; i < Interpreter::number_of_return_entries; i++) { 88 Interpreter::_return_entry[i] = 89 EntryPoint( 90 generate_return_entry_for(itos, i, index_size), 91 generate_return_entry_for(itos, i, index_size), 92 generate_return_entry_for(itos, i, index_size), 93 generate_return_entry_for(itos, i, index_size), 94 generate_return_entry_for(atos, i, index_size), 95 generate_return_entry_for(itos, i, index_size), 96 generate_return_entry_for(ltos, i, index_size), 97 generate_return_entry_for(ftos, i, index_size), 98 generate_return_entry_for(dtos, i, index_size), 99 generate_return_entry_for(vtos, i, index_size) 100 ); 101 } 102 } 103 104 { CodeletMark cm(_masm, "invoke return entry points"); 105 // These states are in order specified in TosState, except btos/ztos/ctos/stos are 106 // really the same as itos since there is no top of stack optimization for these types 107 const TosState states[] = {itos, itos, itos, itos, itos, ltos, ftos, dtos, atos, vtos, ilgl}; 108 const int invoke_length = Bytecodes::length_for(Bytecodes::_invokestatic); 109 const int invokeinterface_length = Bytecodes::length_for(Bytecodes::_invokeinterface); 110 const int invokedynamic_length = Bytecodes::length_for(Bytecodes::_invokedynamic); 111 112 for (int i = 0; i < Interpreter::number_of_return_addrs; i++) { 113 TosState state = states[i]; 114 assert(state != ilgl, "states array is wrong above"); 115 Interpreter::_invoke_return_entry[i] = generate_return_entry_for(state, invoke_length, sizeof(u2)); 116 Interpreter::_invokeinterface_return_entry[i] = generate_return_entry_for(state, invokeinterface_length, sizeof(u2)); 117 Interpreter::_invokedynamic_return_entry[i] = generate_return_entry_for(state, invokedynamic_length, sizeof(u4)); 118 } 119 } 120 121 { CodeletMark cm(_masm, "earlyret entry points"); 122 Interpreter::_earlyret_entry = 123 EntryPoint( 124 generate_earlyret_entry_for(btos), 125 generate_earlyret_entry_for(ztos), 126 generate_earlyret_entry_for(ctos), 127 generate_earlyret_entry_for(stos), 128 generate_earlyret_entry_for(atos), 129 generate_earlyret_entry_for(itos), 130 generate_earlyret_entry_for(ltos), 131 generate_earlyret_entry_for(ftos), 132 generate_earlyret_entry_for(dtos), 133 generate_earlyret_entry_for(vtos) 134 ); 135 } 136 137 { CodeletMark cm(_masm, "deoptimization entry points"); 138 for (int i = 0; i < Interpreter::number_of_deopt_entries; i++) { 139 Interpreter::_deopt_entry[i] = 140 EntryPoint( 141 generate_deopt_entry_for(itos, i), 142 generate_deopt_entry_for(itos, i), 143 generate_deopt_entry_for(itos, i), 144 generate_deopt_entry_for(itos, i), 145 generate_deopt_entry_for(atos, i), 146 generate_deopt_entry_for(itos, i), 147 generate_deopt_entry_for(ltos, i), 148 generate_deopt_entry_for(ftos, i), 149 generate_deopt_entry_for(dtos, i), 150 generate_deopt_entry_for(vtos, i) 151 ); 152 } 153 } 154 155 { CodeletMark cm(_masm, "result handlers for native calls"); 156 // The various result converter stublets. 157 int is_generated[Interpreter::number_of_result_handlers]; 158 memset(is_generated, 0, sizeof(is_generated)); 159 160 for (int i = 0; i < Interpreter::number_of_result_handlers; i++) { 161 BasicType type = types[i]; 162 if (!is_generated[Interpreter::BasicType_as_index(type)]++) { 163 Interpreter::_native_abi_to_tosca[Interpreter::BasicType_as_index(type)] = generate_result_handler_for(type); 164 } 165 } 166 } 167 168 169 { CodeletMark cm(_masm, "safepoint entry points"); 170 Interpreter::_safept_entry = 171 EntryPoint( 172 generate_safept_entry_for(btos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)), 173 generate_safept_entry_for(ztos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)), 174 generate_safept_entry_for(ctos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)), 175 generate_safept_entry_for(stos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)), 176 generate_safept_entry_for(atos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)), 177 generate_safept_entry_for(itos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)), 178 generate_safept_entry_for(ltos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)), 179 generate_safept_entry_for(ftos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)), 180 generate_safept_entry_for(dtos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)), 181 generate_safept_entry_for(vtos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)) 182 ); 183 } 184 185 { CodeletMark cm(_masm, "exception handling"); 186 // (Note: this is not safepoint safe because thread may return to compiled code) 187 generate_throw_exception(); 188 } 189 190 { CodeletMark cm(_masm, "throw exception entrypoints"); 191 Interpreter::_throw_ArrayIndexOutOfBoundsException_entry = generate_ArrayIndexOutOfBounds_handler("java/lang/ArrayIndexOutOfBoundsException"); 192 Interpreter::_throw_ArrayStoreException_entry = generate_klass_exception_handler("java/lang/ArrayStoreException" ); 193 Interpreter::_throw_ArithmeticException_entry = generate_exception_handler("java/lang/ArithmeticException" , "/ by zero"); 194 Interpreter::_throw_ClassCastException_entry = generate_ClassCastException_handler(); 195 Interpreter::_throw_NullPointerException_entry = generate_exception_handler("java/lang/NullPointerException" , NULL ); 196 Interpreter::_throw_StackOverflowError_entry = generate_StackOverflowError_handler(); 197 } 198 199 200 201#define method_entry(kind) \ 202 { CodeletMark cm(_masm, "method entry point (kind = " #kind ")"); \ 203 Interpreter::_entry_table[Interpreter::kind] = generate_method_entry(Interpreter::kind); \ 204 Interpreter::update_cds_entry_table(Interpreter::kind); \ 205 } 206 207 // all non-native method kinds 208 method_entry(zerolocals) 209 method_entry(zerolocals_synchronized) 210 method_entry(empty) 211 method_entry(accessor) 212 method_entry(abstract) 213 method_entry(java_lang_math_sin ) 214 method_entry(java_lang_math_cos ) 215 method_entry(java_lang_math_tan ) 216 method_entry(java_lang_math_abs ) 217 method_entry(java_lang_math_sqrt ) 218 method_entry(java_lang_math_log ) 219 method_entry(java_lang_math_log10) 220 method_entry(java_lang_math_exp ) 221 method_entry(java_lang_math_pow ) 222 method_entry(java_lang_math_fmaF ) 223 method_entry(java_lang_math_fmaD ) 224 method_entry(java_lang_ref_reference_get) 225 226 AbstractInterpreter::initialize_method_handle_entries(); 227 228 // all native method kinds (must be one contiguous block) 229 Interpreter::_native_entry_begin = Interpreter::code()->code_end(); 230 method_entry(native) 231 method_entry(native_synchronized) 232 Interpreter::_native_entry_end = Interpreter::code()->code_end(); 233 234 method_entry(java_util_zip_CRC32_update) 235 method_entry(java_util_zip_CRC32_updateBytes) 236 method_entry(java_util_zip_CRC32_updateByteBuffer) 237 method_entry(java_util_zip_CRC32C_updateBytes) 238 method_entry(java_util_zip_CRC32C_updateDirectByteBuffer) 239 240 method_entry(java_lang_Float_intBitsToFloat); 241 method_entry(java_lang_Float_floatToRawIntBits); 242 method_entry(java_lang_Double_longBitsToDouble); 243 method_entry(java_lang_Double_doubleToRawLongBits); 244 245#undef method_entry 246 247 // Bytecodes 248 set_entry_points_for_all_bytes(); 249 250 // installation of code in other places in the runtime 251 // (ExcutableCodeManager calls not needed to copy the entries) 252 set_safepoints_for_all_bytes(); 253} 254 255//------------------------------------------------------------------------------------------------------------------------ 256 257address TemplateInterpreterGenerator::generate_error_exit(const char* msg) { 258 address entry = __ pc(); 259 __ stop(msg); 260 return entry; 261} 262 263 264//------------------------------------------------------------------------------------------------------------------------ 265 266void TemplateInterpreterGenerator::set_entry_points_for_all_bytes() { 267 for (int i = 0; i < DispatchTable::length; i++) { 268 Bytecodes::Code code = (Bytecodes::Code)i; 269 if (Bytecodes::is_defined(code)) { 270 set_entry_points(code); 271 } else { 272 set_unimplemented(i); 273 } 274 } 275} 276 277 278void TemplateInterpreterGenerator::set_safepoints_for_all_bytes() { 279 for (int i = 0; i < DispatchTable::length; i++) { 280 Bytecodes::Code code = (Bytecodes::Code)i; 281 if (Bytecodes::is_defined(code)) Interpreter::_safept_table.set_entry(code, Interpreter::_safept_entry); 282 } 283} 284 285 286void TemplateInterpreterGenerator::set_unimplemented(int i) { 287 address e = _unimplemented_bytecode; 288 EntryPoint entry(e, e, e, e, e, e, e, e, e, e); 289 Interpreter::_normal_table.set_entry(i, entry); 290 Interpreter::_wentry_point[i] = _unimplemented_bytecode; 291} 292 293 294void TemplateInterpreterGenerator::set_entry_points(Bytecodes::Code code) { 295 CodeletMark cm(_masm, Bytecodes::name(code), code); 296 // initialize entry points 297 assert(_unimplemented_bytecode != NULL, "should have been generated before"); 298 assert(_illegal_bytecode_sequence != NULL, "should have been generated before"); 299 address bep = _illegal_bytecode_sequence; 300 address zep = _illegal_bytecode_sequence; 301 address cep = _illegal_bytecode_sequence; 302 address sep = _illegal_bytecode_sequence; 303 address aep = _illegal_bytecode_sequence; 304 address iep = _illegal_bytecode_sequence; 305 address lep = _illegal_bytecode_sequence; 306 address fep = _illegal_bytecode_sequence; 307 address dep = _illegal_bytecode_sequence; 308 address vep = _unimplemented_bytecode; 309 address wep = _unimplemented_bytecode; 310 // code for short & wide version of bytecode 311 if (Bytecodes::is_defined(code)) { 312 Template* t = TemplateTable::template_for(code); 313 assert(t->is_valid(), "just checking"); 314 set_short_entry_points(t, bep, cep, sep, aep, iep, lep, fep, dep, vep); 315 } 316 if (Bytecodes::wide_is_defined(code)) { 317 Template* t = TemplateTable::template_for_wide(code); 318 assert(t->is_valid(), "just checking"); 319 set_wide_entry_point(t, wep); 320 } 321 // set entry points 322 EntryPoint entry(bep, zep, cep, sep, aep, iep, lep, fep, dep, vep); 323 Interpreter::_normal_table.set_entry(code, entry); 324 Interpreter::_wentry_point[code] = wep; 325} 326 327 328void TemplateInterpreterGenerator::set_wide_entry_point(Template* t, address& wep) { 329 assert(t->is_valid(), "template must exist"); 330 assert(t->tos_in() == vtos, "only vtos tos_in supported for wide instructions"); 331 wep = __ pc(); generate_and_dispatch(t); 332} 333 334 335void 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) { 336 assert(t->is_valid(), "template must exist"); 337 switch (t->tos_in()) { 338 case btos: 339 case ztos: 340 case ctos: 341 case stos: 342 ShouldNotReachHere(); // btos/ctos/stos should use itos. 343 break; 344 case atos: vep = __ pc(); __ pop(atos); aep = __ pc(); generate_and_dispatch(t); break; 345 case itos: vep = __ pc(); __ pop(itos); iep = __ pc(); generate_and_dispatch(t); break; 346 case ltos: vep = __ pc(); __ pop(ltos); lep = __ pc(); generate_and_dispatch(t); break; 347 case ftos: vep = __ pc(); __ pop(ftos); fep = __ pc(); generate_and_dispatch(t); break; 348 case dtos: vep = __ pc(); __ pop(dtos); dep = __ pc(); generate_and_dispatch(t); break; 349 case vtos: set_vtos_entry_points(t, bep, cep, sep, aep, iep, lep, fep, dep, vep); break; 350 default : ShouldNotReachHere(); break; 351 } 352} 353 354 355//------------------------------------------------------------------------------------------------------------------------ 356 357void TemplateInterpreterGenerator::generate_and_dispatch(Template* t, TosState tos_out) { 358 if (PrintBytecodeHistogram) histogram_bytecode(t); 359#ifndef PRODUCT 360 // debugging code 361 if (CountBytecodes || TraceBytecodes || StopInterpreterAt > 0) count_bytecode(); 362 if (PrintBytecodePairHistogram) histogram_bytecode_pair(t); 363 if (TraceBytecodes) trace_bytecode(t); 364 if (StopInterpreterAt > 0) stop_interpreter_at(); 365 __ verify_FPU(1, t->tos_in()); 366#endif // !PRODUCT 367 int step = 0; 368 if (!t->does_dispatch()) { 369 step = t->is_wide() ? Bytecodes::wide_length_for(t->bytecode()) : Bytecodes::length_for(t->bytecode()); 370 if (tos_out == ilgl) tos_out = t->tos_out(); 371 // compute bytecode size 372 assert(step > 0, "just checkin'"); 373 // setup stuff for dispatching next bytecode 374 if (ProfileInterpreter && VerifyDataPointer 375 && MethodData::bytecode_has_profile(t->bytecode())) { 376 __ verify_method_data_pointer(); 377 } 378 __ dispatch_prolog(tos_out, step); 379 } 380 // generate template 381 t->generate(_masm); 382 // advance 383 if (t->does_dispatch()) { 384#ifdef ASSERT 385 // make sure execution doesn't go beyond this point if code is broken 386 __ should_not_reach_here(); 387#endif // ASSERT 388 } else { 389 // dispatch to next bytecode 390 __ dispatch_epilog(tos_out, step); 391 } 392} 393 394// Generate method entries 395address TemplateInterpreterGenerator::generate_method_entry( 396 AbstractInterpreter::MethodKind kind) { 397 // determine code generation flags 398 bool native = false; 399 bool synchronized = false; 400 address entry_point = NULL; 401 402 switch (kind) { 403 case Interpreter::zerolocals : break; 404 case Interpreter::zerolocals_synchronized: synchronized = true; break; 405 case Interpreter::native : native = true; break; 406 case Interpreter::native_synchronized : native = true; synchronized = true; break; 407 case Interpreter::empty : break; 408 case Interpreter::accessor : break; 409 case Interpreter::abstract : entry_point = generate_abstract_entry(); break; 410 411 case Interpreter::java_lang_math_sin : // fall thru 412 case Interpreter::java_lang_math_cos : // fall thru 413 case Interpreter::java_lang_math_tan : // fall thru 414 case Interpreter::java_lang_math_abs : // fall thru 415 case Interpreter::java_lang_math_log : // fall thru 416 case Interpreter::java_lang_math_log10 : // fall thru 417 case Interpreter::java_lang_math_sqrt : // fall thru 418 case Interpreter::java_lang_math_pow : // fall thru 419 case Interpreter::java_lang_math_exp : // fall thru 420 case Interpreter::java_lang_math_fmaD : // fall thru 421 case Interpreter::java_lang_math_fmaF : entry_point = generate_math_entry(kind); break; 422 case Interpreter::java_lang_ref_reference_get 423 : entry_point = generate_Reference_get_entry(); break; 424 case Interpreter::java_util_zip_CRC32_update 425 : native = true; entry_point = generate_CRC32_update_entry(); break; 426 case Interpreter::java_util_zip_CRC32_updateBytes 427 : // fall thru 428 case Interpreter::java_util_zip_CRC32_updateByteBuffer 429 : native = true; entry_point = generate_CRC32_updateBytes_entry(kind); break; 430 case Interpreter::java_util_zip_CRC32C_updateBytes 431 : // fall thru 432 case Interpreter::java_util_zip_CRC32C_updateDirectByteBuffer 433 : entry_point = generate_CRC32C_updateBytes_entry(kind); break; 434#ifdef IA32 435 // On x86_32 platforms, a special entry is generated for the following four methods. 436 // On other platforms the normal entry is used to enter these methods. 437 case Interpreter::java_lang_Float_intBitsToFloat 438 : native = true; entry_point = generate_Float_intBitsToFloat_entry(); break; 439 case Interpreter::java_lang_Float_floatToRawIntBits 440 : native = true; entry_point = generate_Float_floatToRawIntBits_entry(); break; 441 case Interpreter::java_lang_Double_longBitsToDouble 442 : native = true; entry_point = generate_Double_longBitsToDouble_entry(); break; 443 case Interpreter::java_lang_Double_doubleToRawLongBits 444 : native = true; entry_point = generate_Double_doubleToRawLongBits_entry(); break; 445#else 446 case Interpreter::java_lang_Float_intBitsToFloat: 447 case Interpreter::java_lang_Float_floatToRawIntBits: 448 case Interpreter::java_lang_Double_longBitsToDouble: 449 case Interpreter::java_lang_Double_doubleToRawLongBits: 450 native = true; 451 break; 452#endif // !IA32 453 default: 454 fatal("unexpected method kind: %d", kind); 455 break; 456 } 457 458 if (entry_point) { 459 return entry_point; 460 } 461 462 // We expect the normal and native entry points to be generated first so we can reuse them. 463 if (native) { 464 entry_point = Interpreter::entry_for_kind(synchronized ? Interpreter::native_synchronized : Interpreter::native); 465 if (entry_point == NULL) { 466 entry_point = generate_native_entry(synchronized); 467 } 468 } else { 469 entry_point = Interpreter::entry_for_kind(synchronized ? Interpreter::zerolocals_synchronized : Interpreter::zerolocals); 470 if (entry_point == NULL) { 471 entry_point = generate_normal_entry(synchronized); 472 } 473 } 474 475 return entry_point; 476} 477#endif // !CC_INTERP 478