src/share/vm/runtime/sharedRuntime.hpp

*** 35,86 ****
  
  class AdapterHandlerEntry;
  class AdapterHandlerTable;
  class AdapterFingerPrint;
  class vframeStream;
! 
! // Used for adapter generation. One SigEntry is used per element of
! // the signature of the method. Value type arguments are treated
! // specially. See comment for collect_fields().
! class SigEntry VALUE_OBJ_CLASS_SPEC {
!  public:
!   BasicType _bt;
!   int _offset;
! 
!   SigEntry()
!     : _bt(T_ILLEGAL), _offset(-1) {
!   }
!   SigEntry(BasicType bt, int offset)
!     : _bt(bt), _offset(offset) {}
! 
!   SigEntry(BasicType bt)
!     : _bt(bt), _offset(-1) {}
! 
!   static int compare(SigEntry* e1, SigEntry* e2) {
!     if (e1->_offset != e2->_offset) {
!       return e1->_offset - e2->_offset;
!     }
!     assert((e1->_bt == T_LONG && (e2->_bt == T_LONG || e2->_bt == T_VOID)) ||
!            (e1->_bt == T_DOUBLE && (e2->_bt == T_DOUBLE || e2->_bt == T_VOID)) ||
!            e1->_bt == T_VALUETYPE || e2->_bt == T_VALUETYPE || e1->_bt == T_VOID || e2->_bt == T_VOID, "bad bt");
!     if (e1->_bt == e2->_bt) {
!       assert(e1->_bt == T_VALUETYPE || e1->_bt == T_VOID, "only ones with duplicate offsets");
!       return 0;
!     }
!     if (e1->_bt == T_VOID ||
!         e2->_bt == T_VALUETYPE) {
!       return 1;
!     }
!     if (e1->_bt == T_VALUETYPE ||
!         e2->_bt == T_VOID) {
!       return -1;
!     }
!     ShouldNotReachHere();
!     return 0;
!   }
! };
! 
  
  // Runtime is the base class for various runtime interfaces
  // (InterpreterRuntime, CompilerRuntime, etc.). It provides
  // shared functionality such as exception forwarding (C++ to
  // Java exceptions), locking/unlocking mechanisms, statistical
--- 35,45 ----
  
  class AdapterHandlerEntry;
  class AdapterHandlerTable;
  class AdapterFingerPrint;
  class vframeStream;
! class SigEntry;
  
  // Runtime is the base class for various runtime interfaces
  // (InterpreterRuntime, CompilerRuntime, etc.). It provides
  // shared functionality such as exception forwarding (C++ to
  // Java exceptions), locking/unlocking mechanisms, statistical
*** 121,131 ****
  
   private:
    enum { POLL_AT_RETURN,  POLL_AT_LOOP, POLL_AT_VECTOR_LOOP };
    static SafepointBlob* generate_handler_blob(address call_ptr, int poll_type);
    static RuntimeStub*   generate_resolve_blob(address destination, const char* name);
! 
   public:
    static void generate_stubs(void);
  
    // max bytes for each dtrace string parameter
    enum { max_dtrace_string_size = 256 };
--- 80,90 ----
  
   private:
    enum { POLL_AT_RETURN,  POLL_AT_LOOP, POLL_AT_VECTOR_LOOP };
    static SafepointBlob* generate_handler_blob(address call_ptr, int poll_type);
    static RuntimeStub*   generate_resolve_blob(address destination, const char* name);
!   static RuntimeStub*   generate_return_value_blob(address destination, const char* name);
   public:
    static void generate_stubs(void);
  
    // max bytes for each dtrace string parameter
    enum { max_dtrace_string_size = 256 };
*** 413,422 ****
--- 372,384 ----
    // 4-bytes higher. So for sparc because the register window save area is at
    // the bottom of the frame the first 16 words will be skipped and SharedInfo::stack0
    // will be just above it. (
    // return value is the maximum number of VMReg stack slots the convention will use.
    static int java_calling_convention(const BasicType* sig_bt, VMRegPair* regs, int total_args_passed, int is_outgoing);
+   static int java_return_convention(const BasicType* sig_bt, VMRegPair* regs, int total_args_passed);
+   static const uint java_return_convention_max_int;
+   static const uint java_return_convention_max_float;
  
    static void check_member_name_argument_is_last_argument(const methodHandle& method,
                                                            const BasicType* sig_bt,
                                                            const VMRegPair* regs) NOT_DEBUG_RETURN;
  
*** 541,550 ****
--- 503,515 ----
    // Resolving of calls
    static address resolve_static_call_C     (JavaThread *thread);
    static address resolve_virtual_call_C    (JavaThread *thread);
    static address resolve_opt_virtual_call_C(JavaThread *thread);
  
+   static void load_value_type_fields_in_regs(JavaThread *thread, oopDesc* res);
+   static void store_value_type_fields_to_buf(JavaThread *thread, intptr_t res);
+ 
    // arraycopy, the non-leaf version.  (See StubRoutines for all the leaf calls.)
    static void slow_arraycopy_C(oopDesc* src,  jint src_pos,
                                 oopDesc* dest, jint dest_pos,
                                 jint length, JavaThread* thread);