src/share/vm/oops/valueKlass.hpp

*** 75,88 ****
--- 75,107 ----
  
    address adr_return_regs() const {
      return adr_extended_sig() + sizeof(intptr_t);
    }
  
+   // pack and unpack handlers for value types return
+   address adr_pack_handler() const {
+     return (address)this + in_bytes(pack_handler_offset());
+   }
+ 
+   address adr_unpack_handler() const {
+     return (address)this + in_bytes(unpack_handler_offset());
+   }
+ 
+   address pack_handler() const {
+     return *(address*)adr_pack_handler();
+   }
+ 
+   address unpack_handler() const {
+     return *(address*)adr_unpack_handler();
+   }
+ 
    // static Klass* array_klass_impl(InstanceKlass* this_k, bool or_null, int n, TRAPS);
  
    GrowableArray<SigEntry> collect_fields(int base_off = 0) const;
  
+   void cleanup_blobs();
+ 
   protected:
    // Returns the array class for the n'th dimension
    Klass* array_klass_impl(bool or_null, int n, TRAPS);
  
    // Returns the array class with this class as element type
*** 180,200 ****
    template <bool nv, typename T, class OopClosureType>
    inline void oop_iterate_specialized_bounded(const address oop_addr, OopClosureType* closure, void* lo, void* hi);
  
    // calling convention support
    void initialize_calling_convention();
!   const Array<SigEntry>* extended_sig() const {
      assert(this != SystemDictionary::___Value_klass(), "make no sense for __Value");
      return *((Array<SigEntry>**)adr_extended_sig());
    }
!   const Array<VMRegPair>* return_regs() const {
      assert(this != SystemDictionary::___Value_klass(), "make no sense for __Value");
      return *((Array<VMRegPair>**)adr_return_regs());
    }
    void save_oop_fields(const RegisterMap& map, GrowableArray<Handle>& handles) const;
    bool save_oop_results(RegisterMap& map, GrowableArray<Handle>& handles) const;
    void restore_oop_results(RegisterMap& map, GrowableArray<Handle>& handles) const;
!   oop realloc_result(const RegisterMap& reg_map, const GrowableArray<Handle>& handles, TRAPS);
    static ValueKlass* returned_value_type(const RegisterMap& reg_map);
  };
  
  #endif /* SHARE_VM_OOPS_VALUEKLASS_HPP */
--- 199,232 ----
    template <bool nv, typename T, class OopClosureType>
    inline void oop_iterate_specialized_bounded(const address oop_addr, OopClosureType* closure, void* lo, void* hi);
  
    // calling convention support
    void initialize_calling_convention();
!   Array<SigEntry>* extended_sig() const {
      assert(this != SystemDictionary::___Value_klass(), "make no sense for __Value");
      return *((Array<SigEntry>**)adr_extended_sig());
    }
!   Array<VMRegPair>* return_regs() const {
      assert(this != SystemDictionary::___Value_klass(), "make no sense for __Value");
      return *((Array<VMRegPair>**)adr_return_regs());
    }
    void save_oop_fields(const RegisterMap& map, GrowableArray<Handle>& handles) const;
    bool save_oop_results(RegisterMap& map, GrowableArray<Handle>& handles) const;
    void restore_oop_results(RegisterMap& map, GrowableArray<Handle>& handles) const;
!   oop realloc_result(const RegisterMap& reg_map, const GrowableArray<Handle>& handles, bool buffered, TRAPS);
    static ValueKlass* returned_value_type(const RegisterMap& reg_map);
+ 
+   // pack and unpack handlers. Need to be loadable from generated code
+   // so at a fixed offset from the base of the klass pointer.
+   static ByteSize pack_handler_offset() {
+     return in_ByteSize(InstanceKlass::header_size() * wordSize);
+   }
+ 
+   static ByteSize unpack_handler_offset() {
+     return in_ByteSize((InstanceKlass::header_size()+1) * wordSize);
+   }
+ 
+   void deallocate_contents(ClassLoaderData* loader_data);
+   static void cleanup(ValueKlass* ik) ;
  };
  
  #endif /* SHARE_VM_OOPS_VALUEKLASS_HPP */