167 address TemplateInterpreter::_remove_activation_preserving_args_entry = NULL;
168
169
170 address TemplateInterpreter::_throw_ArrayIndexOutOfBoundsException_entry = NULL;
171 address TemplateInterpreter::_throw_ArrayStoreException_entry = NULL;
172 address TemplateInterpreter::_throw_ArithmeticException_entry = NULL;
173 address TemplateInterpreter::_throw_ClassCastException_entry = NULL;
174 address TemplateInterpreter::_throw_NullPointerException_entry = NULL;
175 address TemplateInterpreter::_throw_StackOverflowError_entry = NULL;
176 address TemplateInterpreter::_throw_exception_entry = NULL;
177
178 #ifndef PRODUCT
179 EntryPoint TemplateInterpreter::_trace_code;
180 #endif // !PRODUCT
181 EntryPoint TemplateInterpreter::_return_entry[TemplateInterpreter::number_of_return_entries];
182 EntryPoint TemplateInterpreter::_earlyret_entry;
183 EntryPoint TemplateInterpreter::_deopt_entry [TemplateInterpreter::number_of_deopt_entries ];
184 EntryPoint TemplateInterpreter::_continuation_entry;
185 EntryPoint TemplateInterpreter::_safept_entry;
186
187 address TemplateInterpreter::_return_3_addrs_by_index[TemplateInterpreter::number_of_return_addrs];
188 address TemplateInterpreter::_return_5_addrs_by_index[TemplateInterpreter::number_of_return_addrs];
189
190 DispatchTable TemplateInterpreter::_active_table;
191 DispatchTable TemplateInterpreter::_normal_table;
192 DispatchTable TemplateInterpreter::_safept_table;
193 address TemplateInterpreter::_wentry_point[DispatchTable::length];
194
195 TemplateInterpreterGenerator::TemplateInterpreterGenerator(StubQueue* _code): AbstractInterpreterGenerator(_code) {
196 _unimplemented_bytecode = NULL;
197 _illegal_bytecode_sequence = NULL;
198 }
199
200 static const BasicType types[Interpreter::number_of_result_handlers] = {
201 T_BOOLEAN,
202 T_CHAR ,
203 T_BYTE ,
204 T_SHORT ,
205 T_INT ,
206 T_LONG ,
207 T_VOID ,
208 T_FLOAT ,
220
221 #ifndef PRODUCT
222 if (TraceBytecodes) {
223 CodeletMark cm(_masm, "bytecode tracing support");
224 Interpreter::_trace_code =
225 EntryPoint(
226 generate_trace_code(btos),
227 generate_trace_code(ctos),
228 generate_trace_code(stos),
229 generate_trace_code(atos),
230 generate_trace_code(itos),
231 generate_trace_code(ltos),
232 generate_trace_code(ftos),
233 generate_trace_code(dtos),
234 generate_trace_code(vtos)
235 );
236 }
237 #endif // !PRODUCT
238
239 { CodeletMark cm(_masm, "return entry points");
240 for (int i = 0; i < Interpreter::number_of_return_entries; i++) {
241 Interpreter::_return_entry[i] =
242 EntryPoint(
243 generate_return_entry_for(itos, i),
244 generate_return_entry_for(itos, i),
245 generate_return_entry_for(itos, i),
246 generate_return_entry_for(atos, i),
247 generate_return_entry_for(itos, i),
248 generate_return_entry_for(ltos, i),
249 generate_return_entry_for(ftos, i),
250 generate_return_entry_for(dtos, i),
251 generate_return_entry_for(vtos, i)
252 );
253 }
254 }
255
256 { CodeletMark cm(_masm, "earlyret entry points");
257 Interpreter::_earlyret_entry =
258 EntryPoint(
259 generate_earlyret_entry_for(btos),
260 generate_earlyret_entry_for(ctos),
261 generate_earlyret_entry_for(stos),
262 generate_earlyret_entry_for(atos),
263 generate_earlyret_entry_for(itos),
264 generate_earlyret_entry_for(ltos),
265 generate_earlyret_entry_for(ftos),
266 generate_earlyret_entry_for(dtos),
267 generate_earlyret_entry_for(vtos)
268 );
269 }
270
271 { CodeletMark cm(_masm, "deoptimization entry points");
272 for (int i = 0; i < Interpreter::number_of_deopt_entries; i++) {
273 Interpreter::_deopt_entry[i] =
274 EntryPoint(
275 generate_deopt_entry_for(itos, i),
281 generate_deopt_entry_for(ftos, i),
282 generate_deopt_entry_for(dtos, i),
283 generate_deopt_entry_for(vtos, i)
284 );
285 }
286 }
287
288 { CodeletMark cm(_masm, "result handlers for native calls");
289 // The various result converter stublets.
290 int is_generated[Interpreter::number_of_result_handlers];
291 memset(is_generated, 0, sizeof(is_generated));
292
293 for (int i = 0; i < Interpreter::number_of_result_handlers; i++) {
294 BasicType type = types[i];
295 if (!is_generated[Interpreter::BasicType_as_index(type)]++) {
296 Interpreter::_native_abi_to_tosca[Interpreter::BasicType_as_index(type)] = generate_result_handler_for(type);
297 }
298 }
299 }
300
301 for (int j = 0; j < number_of_states; j++) {
302 const TosState states[] = {btos, ctos, stos, itos, ltos, ftos, dtos, atos, vtos};
303 int index = Interpreter::TosState_as_index(states[j]);
304 Interpreter::_return_3_addrs_by_index[index] = Interpreter::return_entry(states[j], 3);
305 Interpreter::_return_5_addrs_by_index[index] = Interpreter::return_entry(states[j], 5);
306 }
307
308 { CodeletMark cm(_masm, "continuation entry points");
309 Interpreter::_continuation_entry =
310 EntryPoint(
311 generate_continuation_for(btos),
312 generate_continuation_for(ctos),
313 generate_continuation_for(stos),
314 generate_continuation_for(atos),
315 generate_continuation_for(itos),
316 generate_continuation_for(ltos),
317 generate_continuation_for(ftos),
318 generate_continuation_for(dtos),
319 generate_continuation_for(vtos)
320 );
321 }
322
323 { CodeletMark cm(_masm, "safepoint entry points");
324 Interpreter::_safept_entry =
325 EntryPoint(
326 generate_safept_entry_for(btos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)),
327 generate_safept_entry_for(ctos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)),
517 }
518 __ dispatch_prolog(tos_out, step);
519 }
520 // generate template
521 t->generate(_masm);
522 // advance
523 if (t->does_dispatch()) {
524 #ifdef ASSERT
525 // make sure execution doesn't go beyond this point if code is broken
526 __ should_not_reach_here();
527 #endif // ASSERT
528 } else {
529 // dispatch to next bytecode
530 __ dispatch_epilog(tos_out, step);
531 }
532 }
533
534 //------------------------------------------------------------------------------------------------------------------------
535 // Entry points
536
537 address TemplateInterpreter::return_entry(TosState state, int length) {
538 guarantee(0 <= length && length < Interpreter::number_of_return_entries, "illegal length");
539 return _return_entry[length].entry(state);
540 }
541
542
543 address TemplateInterpreter::deopt_entry(TosState state, int length) {
544 guarantee(0 <= length && length < Interpreter::number_of_deopt_entries, "illegal length");
545 return _deopt_entry[length].entry(state);
546 }
547
548 //------------------------------------------------------------------------------------------------------------------------
549 // Suport for invokes
550
551 int TemplateInterpreter::TosState_as_index(TosState state) {
552 assert( state < number_of_states , "Invalid state in TosState_as_index");
553 assert(0 <= (int)state && (int)state < TemplateInterpreter::number_of_return_addrs, "index out of bounds");
554 return (int)state;
555 }
556
557
558 //------------------------------------------------------------------------------------------------------------------------
559 // Safepoint suppport
|
167 address TemplateInterpreter::_remove_activation_preserving_args_entry = NULL;
168
169
170 address TemplateInterpreter::_throw_ArrayIndexOutOfBoundsException_entry = NULL;
171 address TemplateInterpreter::_throw_ArrayStoreException_entry = NULL;
172 address TemplateInterpreter::_throw_ArithmeticException_entry = NULL;
173 address TemplateInterpreter::_throw_ClassCastException_entry = NULL;
174 address TemplateInterpreter::_throw_NullPointerException_entry = NULL;
175 address TemplateInterpreter::_throw_StackOverflowError_entry = NULL;
176 address TemplateInterpreter::_throw_exception_entry = NULL;
177
178 #ifndef PRODUCT
179 EntryPoint TemplateInterpreter::_trace_code;
180 #endif // !PRODUCT
181 EntryPoint TemplateInterpreter::_return_entry[TemplateInterpreter::number_of_return_entries];
182 EntryPoint TemplateInterpreter::_earlyret_entry;
183 EntryPoint TemplateInterpreter::_deopt_entry [TemplateInterpreter::number_of_deopt_entries ];
184 EntryPoint TemplateInterpreter::_continuation_entry;
185 EntryPoint TemplateInterpreter::_safept_entry;
186
187 address TemplateInterpreter::_invoke_return_entry[TemplateInterpreter::number_of_return_addrs];
188 address TemplateInterpreter::_invokeinterface_return_entry[TemplateInterpreter::number_of_return_addrs];
189 address TemplateInterpreter::_invokedynamic_return_entry[TemplateInterpreter::number_of_return_addrs];
190
191 DispatchTable TemplateInterpreter::_active_table;
192 DispatchTable TemplateInterpreter::_normal_table;
193 DispatchTable TemplateInterpreter::_safept_table;
194 address TemplateInterpreter::_wentry_point[DispatchTable::length];
195
196 TemplateInterpreterGenerator::TemplateInterpreterGenerator(StubQueue* _code): AbstractInterpreterGenerator(_code) {
197 _unimplemented_bytecode = NULL;
198 _illegal_bytecode_sequence = NULL;
199 }
200
201 static const BasicType types[Interpreter::number_of_result_handlers] = {
202 T_BOOLEAN,
203 T_CHAR ,
204 T_BYTE ,
205 T_SHORT ,
206 T_INT ,
207 T_LONG ,
208 T_VOID ,
209 T_FLOAT ,
221
222 #ifndef PRODUCT
223 if (TraceBytecodes) {
224 CodeletMark cm(_masm, "bytecode tracing support");
225 Interpreter::_trace_code =
226 EntryPoint(
227 generate_trace_code(btos),
228 generate_trace_code(ctos),
229 generate_trace_code(stos),
230 generate_trace_code(atos),
231 generate_trace_code(itos),
232 generate_trace_code(ltos),
233 generate_trace_code(ftos),
234 generate_trace_code(dtos),
235 generate_trace_code(vtos)
236 );
237 }
238 #endif // !PRODUCT
239
240 { CodeletMark cm(_masm, "return entry points");
241 const int index_size = sizeof(u2);
242 for (int i = 0; i < Interpreter::number_of_return_entries; i++) {
243 Interpreter::_return_entry[i] =
244 EntryPoint(
245 generate_return_entry_for(itos, i, index_size),
246 generate_return_entry_for(itos, i, index_size),
247 generate_return_entry_for(itos, i, index_size),
248 generate_return_entry_for(atos, i, index_size),
249 generate_return_entry_for(itos, i, index_size),
250 generate_return_entry_for(ltos, i, index_size),
251 generate_return_entry_for(ftos, i, index_size),
252 generate_return_entry_for(dtos, i, index_size),
253 generate_return_entry_for(vtos, i, index_size)
254 );
255 }
256 }
257
258 { CodeletMark cm(_masm, "invoke return entry points");
259 const TosState states[] = {itos, itos, itos, itos, ltos, ftos, dtos, atos, vtos};
260 const int invoke_length = Bytecodes::length_for(Bytecodes::_invokestatic);
261 const int invokeinterface_length = Bytecodes::length_for(Bytecodes::_invokeinterface);
262 const int invokedynamic_length = Bytecodes::length_for(Bytecodes::_invokedynamic);
263
264 for (int i = 0; i < Interpreter::number_of_return_addrs; i++) {
265 TosState state = states[i];
266 Interpreter::_invoke_return_entry[i] = generate_return_entry_for(state, invoke_length, sizeof(u2));
267 Interpreter::_invokeinterface_return_entry[i] = generate_return_entry_for(state, invokeinterface_length, sizeof(u2));
268 Interpreter::_invokedynamic_return_entry[i] = generate_return_entry_for(state, invokedynamic_length, sizeof(u4));
269 }
270 }
271
272 { CodeletMark cm(_masm, "earlyret entry points");
273 Interpreter::_earlyret_entry =
274 EntryPoint(
275 generate_earlyret_entry_for(btos),
276 generate_earlyret_entry_for(ctos),
277 generate_earlyret_entry_for(stos),
278 generate_earlyret_entry_for(atos),
279 generate_earlyret_entry_for(itos),
280 generate_earlyret_entry_for(ltos),
281 generate_earlyret_entry_for(ftos),
282 generate_earlyret_entry_for(dtos),
283 generate_earlyret_entry_for(vtos)
284 );
285 }
286
287 { CodeletMark cm(_masm, "deoptimization entry points");
288 for (int i = 0; i < Interpreter::number_of_deopt_entries; i++) {
289 Interpreter::_deopt_entry[i] =
290 EntryPoint(
291 generate_deopt_entry_for(itos, i),
297 generate_deopt_entry_for(ftos, i),
298 generate_deopt_entry_for(dtos, i),
299 generate_deopt_entry_for(vtos, i)
300 );
301 }
302 }
303
304 { CodeletMark cm(_masm, "result handlers for native calls");
305 // The various result converter stublets.
306 int is_generated[Interpreter::number_of_result_handlers];
307 memset(is_generated, 0, sizeof(is_generated));
308
309 for (int i = 0; i < Interpreter::number_of_result_handlers; i++) {
310 BasicType type = types[i];
311 if (!is_generated[Interpreter::BasicType_as_index(type)]++) {
312 Interpreter::_native_abi_to_tosca[Interpreter::BasicType_as_index(type)] = generate_result_handler_for(type);
313 }
314 }
315 }
316
317 { CodeletMark cm(_masm, "continuation entry points");
318 Interpreter::_continuation_entry =
319 EntryPoint(
320 generate_continuation_for(btos),
321 generate_continuation_for(ctos),
322 generate_continuation_for(stos),
323 generate_continuation_for(atos),
324 generate_continuation_for(itos),
325 generate_continuation_for(ltos),
326 generate_continuation_for(ftos),
327 generate_continuation_for(dtos),
328 generate_continuation_for(vtos)
329 );
330 }
331
332 { CodeletMark cm(_masm, "safepoint entry points");
333 Interpreter::_safept_entry =
334 EntryPoint(
335 generate_safept_entry_for(btos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)),
336 generate_safept_entry_for(ctos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)),
526 }
527 __ dispatch_prolog(tos_out, step);
528 }
529 // generate template
530 t->generate(_masm);
531 // advance
532 if (t->does_dispatch()) {
533 #ifdef ASSERT
534 // make sure execution doesn't go beyond this point if code is broken
535 __ should_not_reach_here();
536 #endif // ASSERT
537 } else {
538 // dispatch to next bytecode
539 __ dispatch_epilog(tos_out, step);
540 }
541 }
542
543 //------------------------------------------------------------------------------------------------------------------------
544 // Entry points
545
546 /**
547 * Returns the return entry table for the given invoke bytecode.
548 */
549 address* TemplateInterpreter::invoke_return_entry_table_for(Bytecodes::Code code) {
550 switch (code) {
551 case Bytecodes::_invokestatic:
552 case Bytecodes::_invokespecial:
553 case Bytecodes::_invokevirtual:
554 case Bytecodes::_invokehandle:
555 return Interpreter::invoke_return_entry_table();
556 case Bytecodes::_invokeinterface:
557 return Interpreter::invokeinterface_return_entry_table();
558 case Bytecodes::_invokedynamic:
559 return Interpreter::invokedynamic_return_entry_table();
560 default:
561 fatal(err_msg("invalid bytecode: %s", Bytecodes::name(code)));
562 return NULL;
563 }
564 }
565
566 /**
567 * Returns the return entry address for the given top-of-stack state and bytecode.
568 */
569 address TemplateInterpreter::return_entry(TosState state, int length, Bytecodes::Code code) {
570 guarantee(0 <= length && length < Interpreter::number_of_return_entries, "illegal length");
571 const int index = TosState_as_index(state);
572 switch (code) {
573 case Bytecodes::_invokestatic:
574 case Bytecodes::_invokespecial:
575 case Bytecodes::_invokevirtual:
576 return _invoke_return_entry[index];
577 case Bytecodes::_invokeinterface:
578 return _invokeinterface_return_entry[index];
579 case Bytecodes::_invokedynamic:
580 return _invokedynamic_return_entry[index];
581 default:
582 return _return_entry[length].entry(state);
583 }
584 }
585
586
587 address TemplateInterpreter::deopt_entry(TosState state, int length) {
588 guarantee(0 <= length && length < Interpreter::number_of_deopt_entries, "illegal length");
589 return _deopt_entry[length].entry(state);
590 }
591
592 //------------------------------------------------------------------------------------------------------------------------
593 // Suport for invokes
594
595 int TemplateInterpreter::TosState_as_index(TosState state) {
596 assert( state < number_of_states , "Invalid state in TosState_as_index");
597 assert(0 <= (int)state && (int)state < TemplateInterpreter::number_of_return_addrs, "index out of bounds");
598 return (int)state;
599 }
600
601
602 //------------------------------------------------------------------------------------------------------------------------
603 // Safepoint suppport
|