< prev index next >

src/hotspot/share/runtime/sharedRuntime.hpp

Print this page

449   // created. It's entire job is to simply free this storage.
450   static void OSR_migration_end(intptr_t* buf);
451 
452   // Convert a sig into a calling convention register layout
453   // and find interesting things about it.
454   static VMRegPair* find_callee_arguments(Symbol* sig, bool has_receiver, bool has_appendix, int *arg_size);
455   static VMReg name_for_receiver();
456 
457   // "Top of Stack" slots that may be unused by the calling convention but must
458   // otherwise be preserved.
459   // On Intel these are not necessary and the value can be zero.
460   // On Sparc this describes the words reserved for storing a register window
461   // when an interrupt occurs.
462   static uint out_preserve_stack_slots();
463 
464   // Stack slots that may be unused by the calling convention but must
465   // otherwise be preserved.  On Intel this includes the return address.
466   // On PowerPC it includes the 4 words holding the old TOC & LR glue.
467   static uint in_preserve_stack_slots();
468 




469   // Is vector's size (in bytes) bigger than a size saved by default?
470   // For example, on x86 16 bytes XMM registers are saved by default.
471   static bool is_wide_vector(int size);
472 
473   // Save and restore a native result
474   static void    save_native_result(MacroAssembler *_masm, BasicType ret_type, int frame_slots);
475   static void restore_native_result(MacroAssembler *_masm, BasicType ret_type, int frame_slots);
476 
477   // Generate a native wrapper for a given method.  The method takes arguments
478   // in the Java compiled code convention, marshals them to the native
479   // convention (handlizes oops, etc), transitions to native, makes the call,
480   // returns to java state (possibly blocking), unhandlizes any result and
481   // returns.
482   //
483   // The wrapper may contain special-case code if the given method
484   // is a compiled method handle adapter, such as _invokeBasic, _linkToVirtual, etc.
485   static nmethod* generate_native_wrapper(MacroAssembler* masm,
486                                           const methodHandle& method,
487                                           int compile_id,
488                                           BasicType* sig_bt,
489                                           VMRegPair* regs,
490                                           BasicType ret_type);
491 
492   // A compiled caller has just called the interpreter, but compiled code
493   // exists.  Patch the caller so he no longer calls into the interpreter.
494   static void fixup_callers_callsite(Method* moop, address ret_pc);
495   static bool should_fixup_call_destination(address destination, address entry_point, address caller_pc, Method* moop, CodeBlob* cb);
496 
497   // Slow-path Locking and Unlocking
498   static void complete_monitor_locking_C(oopDesc* obj, BasicLock* lock, JavaThread* current);
499   static void complete_monitor_unlocking_C(oopDesc* obj, BasicLock* lock, JavaThread* current);

500 
501   // Resolving of calls
502   static address resolve_static_call_C     (JavaThread* current);
503   static address resolve_virtual_call_C    (JavaThread* current);
504   static address resolve_opt_virtual_call_C(JavaThread* current);
505 
506   // arraycopy, the non-leaf version.  (See StubRoutines for all the leaf calls.)
507   static void slow_arraycopy_C(oopDesc* src,  jint src_pos,
508                                oopDesc* dest, jint dest_pos,
509                                jint length, JavaThread* thread);
510 
511   // handle ic miss with caller being compiled code
512   // wrong method handling (inline cache misses)
513   static address handle_wrong_method(JavaThread* current);
514   static address handle_wrong_method_abstract(JavaThread* current);
515   static address handle_wrong_method_ic_miss(JavaThread* current);
516 
517   static address handle_unsafe_access(JavaThread* thread, address next_pc);
518 
519 #ifndef PRODUCT

449   // created. It's entire job is to simply free this storage.
450   static void OSR_migration_end(intptr_t* buf);
451 
452   // Convert a sig into a calling convention register layout
453   // and find interesting things about it.
454   static VMRegPair* find_callee_arguments(Symbol* sig, bool has_receiver, bool has_appendix, int *arg_size);
455   static VMReg name_for_receiver();
456 
457   // "Top of Stack" slots that may be unused by the calling convention but must
458   // otherwise be preserved.
459   // On Intel these are not necessary and the value can be zero.
460   // On Sparc this describes the words reserved for storing a register window
461   // when an interrupt occurs.
462   static uint out_preserve_stack_slots();
463 
464   // Stack slots that may be unused by the calling convention but must
465   // otherwise be preserved.  On Intel this includes the return address.
466   // On PowerPC it includes the 4 words holding the old TOC & LR glue.
467   static uint in_preserve_stack_slots();
468 
469   static VMReg thread_register();
470 
471   static void continuation_enter_cleanup(MacroAssembler* masm);
472 
473   // Is vector's size (in bytes) bigger than a size saved by default?
474   // For example, on x86 16 bytes XMM registers are saved by default.
475   static bool is_wide_vector(int size);
476 
477   // Save and restore a native result
478   static void    save_native_result(MacroAssembler *_masm, BasicType ret_type, int frame_slots);
479   static void restore_native_result(MacroAssembler *_masm, BasicType ret_type, int frame_slots);
480 
481   // Generate a native wrapper for a given method.  The method takes arguments
482   // in the Java compiled code convention, marshals them to the native
483   // convention (handlizes oops, etc), transitions to native, makes the call,
484   // returns to java state (possibly blocking), unhandlizes any result and
485   // returns.
486   //
487   // The wrapper may contain special-case code if the given method
488   // is a compiled method handle adapter, such as _invokeBasic, _linkToVirtual, etc.
489   static nmethod* generate_native_wrapper(MacroAssembler* masm,
490                                           const methodHandle& method,
491                                           int compile_id,
492                                           BasicType* sig_bt,
493                                           VMRegPair* regs,
494                                           BasicType ret_type);
495 
496   // A compiled caller has just called the interpreter, but compiled code
497   // exists.  Patch the caller so he no longer calls into the interpreter.
498   static void fixup_callers_callsite(Method* moop, address ret_pc);
499   static bool should_fixup_call_destination(address destination, address entry_point, address caller_pc, Method* moop, CodeBlob* cb);
500 
501   // Slow-path Locking and Unlocking
502   static void complete_monitor_locking_C(oopDesc* obj, BasicLock* lock, JavaThread* current);
503   static void complete_monitor_unlocking_C(oopDesc* obj, BasicLock* lock, JavaThread* current);
504   static void redo_monitorenter(JavaThread* current, ObjectMonitor* monitor);
505 
506   // Resolving of calls
507   static address resolve_static_call_C     (JavaThread* current);
508   static address resolve_virtual_call_C    (JavaThread* current);
509   static address resolve_opt_virtual_call_C(JavaThread* current);
510 
511   // arraycopy, the non-leaf version.  (See StubRoutines for all the leaf calls.)
512   static void slow_arraycopy_C(oopDesc* src,  jint src_pos,
513                                oopDesc* dest, jint dest_pos,
514                                jint length, JavaThread* thread);
515 
516   // handle ic miss with caller being compiled code
517   // wrong method handling (inline cache misses)
518   static address handle_wrong_method(JavaThread* current);
519   static address handle_wrong_method_abstract(JavaThread* current);
520   static address handle_wrong_method_ic_miss(JavaThread* current);
521 
522   static address handle_unsafe_access(JavaThread* thread, address next_pc);
523 
524 #ifndef PRODUCT
< prev index next >