260 }
261
262
263 __ pop(rax);
264 __ mov(rsp, r13);
265 __ jmp(rax);
266
267 return entry_point;
268 }
269
270
271 // Abstract method entry
272 // Attempt to execute abstract method. Throw exception
273 address InterpreterGenerator::generate_abstract_entry(void) {
274 // rbx: methodOop
275 // r13: sender SP
276
277 address entry_point = __ pc();
278
279 // abstract method entry
280 // remove return address. Not really needed, since exception
281 // handling throws away expression stack
282 __ pop(rbx);
283
284 // adjust stack to what a normal return would do
285 __ mov(rsp, r13);
286
287 // throw exception
288 __ call_VM(noreg, CAST_FROM_FN_PTR(address,
289 InterpreterRuntime::throw_AbstractMethodError));
290 // the call_VM checks for exception, so we should never return here.
291 __ should_not_reach_here();
292
293 return entry_point;
294 }
295
296
297 // Method handle invoker
298 // Dispatch a method of the form java.dyn.MethodHandles::invoke(...)
299 address InterpreterGenerator::generate_method_handle_entry(void) {
300 if (!EnableMethodHandles) {
301 return generate_abstract_entry();
302 }
303 return generate_abstract_entry(); //6815692//
304 }
305
306
307 // Empty method, generate a very fast return.
308
309 address InterpreterGenerator::generate_empty_entry(void) {
310 // rbx: methodOop
311 // r13: sender sp must set sp to this value on return
312
313 if (!UseFastEmptyMethods) {
314 return NULL;
315 }
316
317 address entry_point = __ pc();
318
319 // If we need a safepoint check, generate full interpreter entry.
320 Label slow_path;
321 __ cmp32(ExternalAddress(SafepointSynchronize::address_of_state()),
322 SafepointSynchronize::_not_synchronized);
323 __ jcc(Assembler::notEqual, slow_path);
|
260 }
261
262
263 __ pop(rax);
264 __ mov(rsp, r13);
265 __ jmp(rax);
266
267 return entry_point;
268 }
269
270
271 // Abstract method entry
272 // Attempt to execute abstract method. Throw exception
273 address InterpreterGenerator::generate_abstract_entry(void) {
274 // rbx: methodOop
275 // r13: sender SP
276
277 address entry_point = __ pc();
278
279 // abstract method entry
280
281 // pop return address, reset last_sp to NULL
282 __ empty_expression_stack();
283 __ restore_bcp(); // rsi must be correct for exception handler (was destroyed)
284 __ restore_locals(); // make sure locals pointer is correct as well (was destroyed)
285
286 // throw exception
287 __ call_VM(noreg, CAST_FROM_FN_PTR(address,
288 InterpreterRuntime::throw_AbstractMethodError));
289 // the call_VM checks for exception, so we should never return here.
290 __ should_not_reach_here();
291
292 return entry_point;
293 }
294
295
296 // Method handle invoker
297 // Dispatch a method of the form java.dyn.MethodHandles::invoke(...)
298 address InterpreterGenerator::generate_method_handle_entry(void) {
299 if (!EnableMethodHandles) {
300 return generate_abstract_entry();
301 }
302
303 address entry_point = MethodHandles::generate_method_handle_interpreter_entry(_masm);
304
305 return entry_point;
306 }
307
308
309 // Empty method, generate a very fast return.
310
311 address InterpreterGenerator::generate_empty_entry(void) {
312 // rbx: methodOop
313 // r13: sender sp must set sp to this value on return
314
315 if (!UseFastEmptyMethods) {
316 return NULL;
317 }
318
319 address entry_point = __ pc();
320
321 // If we need a safepoint check, generate full interpreter entry.
322 Label slow_path;
323 __ cmp32(ExternalAddress(SafepointSynchronize::address_of_state()),
324 SafepointSynchronize::_not_synchronized);
325 __ jcc(Assembler::notEqual, slow_path);
|