src/share/vm/runtime/sharedRuntime.hpp

*** 36,45 ****
--- 36,87 ----
  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, "");
+       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
  // information, etc.
*** 429,448 ****
    // stack pointer in the interpreter frame. On return it will restore the stack
    // pointer as needed. This means the i2c adapter code doesn't need any special
    // handshaking path with compiled code to keep the stack walking correct.
  
    static AdapterHandlerEntry* generate_i2c2i_adapters(MacroAssembler *_masm,
!                                                       int total_args_passed,
!                                                       int max_arg,
!                                                       const BasicType *sig_bt,
                                                        const VMRegPair *regs,
!                                                       AdapterFingerPrint* fingerprint);
  
    static void gen_i2c_adapter(MacroAssembler *_masm,
-                               int total_args_passed,
                                int comp_args_on_stack,
!                               const BasicType *sig_bt,
                                const VMRegPair *regs);
  
    // OSR support
  
    // OSR_migration_begin will extract the jvm state from an interpreter
--- 471,489 ----
    // stack pointer in the interpreter frame. On return it will restore the stack
    // pointer as needed. This means the i2c adapter code doesn't need any special
    // handshaking path with compiled code to keep the stack walking correct.
  
    static AdapterHandlerEntry* generate_i2c2i_adapters(MacroAssembler *_masm,
!                                                       int comp_args_on_stack,
!                                                       const GrowableArray<SigEntry>& sig,
                                                        const VMRegPair *regs,
!                                                       AdapterFingerPrint* fingerprint,
!                                                       AdapterBlob*& new_adapter);
  
    static void gen_i2c_adapter(MacroAssembler *_masm,
                                int comp_args_on_stack,
!                               const GrowableArray<SigEntry>& sig,
                                const VMRegPair *regs);
  
    // OSR support
  
    // OSR_migration_begin will extract the jvm state from an interpreter
*** 520,529 ****
--- 561,571 ----
    // handle ic miss with caller being compiled code
    // wrong method handling (inline cache misses, zombie methods)
    static address handle_wrong_method(JavaThread* thread);
    static address handle_wrong_method_abstract(JavaThread* thread);
    static address handle_wrong_method_ic_miss(JavaThread* thread);
+   static void allocate_value_types(JavaThread* thread);
  
  #ifndef PRODUCT
  
    // Collect and print inline cache miss statistics
   private: