218
219 // End of helpers
220
221 // Various method entries
222
223 // Abstract method entry
224 // Attempt to execute abstract method. Throw exception
225 //
226 address InterpreterGenerator::generate_abstract_entry(void) {
227 address entry = __ pc();
228 // abstract method entry
229 // throw exception
230 __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::throw_AbstractMethodError));
231 // the call_VM checks for exception, so we should never return here.
232 __ should_not_reach_here();
233 return entry;
234
235 }
236
237
238 //----------------------------------------------------------------------------------------------------
239 // Entry points & stack frame layout
240 //
241 // Here we generate the various kind of entries into the interpreter.
242 // The two main entry type are generic bytecode methods and native call method.
243 // These both come in synchronized and non-synchronized versions but the
244 // frame layout they create is very similar. The other method entry
245 // types are really just special purpose entries that are really entry
246 // and interpretation all in one. These are for trivial methods like
247 // accessor, empty, or special math methods.
248 //
249 // When control flow reaches any of the entry types for the interpreter
250 // the following holds ->
251 //
252 // C2 Calling Conventions:
253 //
254 // The entry code below assumes that the following registers are set
255 // when coming in:
256 // G5_method: holds the methodOop of the method to call
257 // Lesp: points to the TOS of the callers expression stack
347 // +---------------+
348 // | |
349 // : arguments :
350 // | | <--- Llocals
351 // +---------------+ <--- Gargs
352 // | |
353
354 address AbstractInterpreterGenerator::generate_method_entry(AbstractInterpreter::MethodKind kind) {
355 // determine code generation flags
356 bool synchronized = false;
357 address entry_point = NULL;
358
359 switch (kind) {
360 case Interpreter::zerolocals : break;
361 case Interpreter::zerolocals_synchronized: synchronized = true; break;
362 case Interpreter::native : entry_point = ((InterpreterGenerator*)this)->generate_native_entry(false); break;
363 case Interpreter::native_synchronized : entry_point = ((InterpreterGenerator*)this)->generate_native_entry(true); break;
364 case Interpreter::empty : entry_point = ((InterpreterGenerator*)this)->generate_empty_entry(); break;
365 case Interpreter::accessor : entry_point = ((InterpreterGenerator*)this)->generate_accessor_entry(); break;
366 case Interpreter::abstract : entry_point = ((InterpreterGenerator*)this)->generate_abstract_entry(); break;
367 case Interpreter::java_lang_math_sin : break;
368 case Interpreter::java_lang_math_cos : break;
369 case Interpreter::java_lang_math_tan : break;
370 case Interpreter::java_lang_math_sqrt : break;
371 case Interpreter::java_lang_math_abs : break;
372 case Interpreter::java_lang_math_log : break;
373 case Interpreter::java_lang_math_log10 : break;
374 default : ShouldNotReachHere(); break;
375 }
376
377 if (entry_point) return entry_point;
378
379 return ((InterpreterGenerator*)this)->generate_normal_entry(synchronized);
380 }
381
382
383 // This method tells the deoptimizer how big an interpreted frame must be:
384 int AbstractInterpreter::size_activation(methodOop method,
385 int tempcount,
386 int popframe_extra_args,
|
218
219 // End of helpers
220
221 // Various method entries
222
223 // Abstract method entry
224 // Attempt to execute abstract method. Throw exception
225 //
226 address InterpreterGenerator::generate_abstract_entry(void) {
227 address entry = __ pc();
228 // abstract method entry
229 // throw exception
230 __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::throw_AbstractMethodError));
231 // the call_VM checks for exception, so we should never return here.
232 __ should_not_reach_here();
233 return entry;
234
235 }
236
237
238 #ifdef ASSERT
239 address last_WrongMethodType_caller;
240 #endif //ASSERT
241
242
243 // Method handle invoker
244 // Dispatch a method of the form java.dyn.MethodHandles::invoke(...)
245 address InterpreterGenerator::generate_method_handle_entry(void) {
246 if (!MethodHandleSupport) {
247 return generate_abstract_entry();
248 }
249
250 // incoming registers: O0 (mh), G5 (mtype), O1... (args)
251 Register G5_mtype = G5_inline_cache_reg;
252 Register O0_recv = O0;
253
254 Label wrong_method_type;
255 address entry_point = MethodHandles::generate_method_handle_interpreter_entry(_masm, wrong_method_type);
256
257 __ bind(wrong_method_type);
258 __ mov(O0_recv, O1); // bad mh (actual)
259 __ mov(G5_mtype, O0); // missed mtype (required)
260 DEBUG_ONLY(__ get_pc(O2));
261 __ throw_if_not_x(Assembler::never, Interpreter::_throw_WrongMethodType_entry, G3_scratch);
262
263 return entry_point;
264 }
265
266
267
268
269 //----------------------------------------------------------------------------------------------------
270 // Entry points & stack frame layout
271 //
272 // Here we generate the various kind of entries into the interpreter.
273 // The two main entry type are generic bytecode methods and native call method.
274 // These both come in synchronized and non-synchronized versions but the
275 // frame layout they create is very similar. The other method entry
276 // types are really just special purpose entries that are really entry
277 // and interpretation all in one. These are for trivial methods like
278 // accessor, empty, or special math methods.
279 //
280 // When control flow reaches any of the entry types for the interpreter
281 // the following holds ->
282 //
283 // C2 Calling Conventions:
284 //
285 // The entry code below assumes that the following registers are set
286 // when coming in:
287 // G5_method: holds the methodOop of the method to call
288 // Lesp: points to the TOS of the callers expression stack
378 // +---------------+
379 // | |
380 // : arguments :
381 // | | <--- Llocals
382 // +---------------+ <--- Gargs
383 // | |
384
385 address AbstractInterpreterGenerator::generate_method_entry(AbstractInterpreter::MethodKind kind) {
386 // determine code generation flags
387 bool synchronized = false;
388 address entry_point = NULL;
389
390 switch (kind) {
391 case Interpreter::zerolocals : break;
392 case Interpreter::zerolocals_synchronized: synchronized = true; break;
393 case Interpreter::native : entry_point = ((InterpreterGenerator*)this)->generate_native_entry(false); break;
394 case Interpreter::native_synchronized : entry_point = ((InterpreterGenerator*)this)->generate_native_entry(true); break;
395 case Interpreter::empty : entry_point = ((InterpreterGenerator*)this)->generate_empty_entry(); break;
396 case Interpreter::accessor : entry_point = ((InterpreterGenerator*)this)->generate_accessor_entry(); break;
397 case Interpreter::abstract : entry_point = ((InterpreterGenerator*)this)->generate_abstract_entry(); break;
398 case Interpreter::method_handle : entry_point = ((InterpreterGenerator*)this)->generate_method_handle_entry(); break;
399 case Interpreter::java_lang_math_sin : break;
400 case Interpreter::java_lang_math_cos : break;
401 case Interpreter::java_lang_math_tan : break;
402 case Interpreter::java_lang_math_sqrt : break;
403 case Interpreter::java_lang_math_abs : break;
404 case Interpreter::java_lang_math_log : break;
405 case Interpreter::java_lang_math_log10 : break;
406 default : ShouldNotReachHere(); break;
407 }
408
409 if (entry_point) return entry_point;
410
411 return ((InterpreterGenerator*)this)->generate_normal_entry(synchronized);
412 }
413
414
415 // This method tells the deoptimizer how big an interpreted frame must be:
416 int AbstractInterpreter::size_activation(methodOop method,
417 int tempcount,
418 int popframe_extra_args,
|