< prev index next >

src/hotspot/share/oops/valueKlass.hpp

Print this page




  24 
  25 #ifndef SHARE_VM_OOPS_VALUEKLASS_HPP
  26 #define SHARE_VM_OOPS_VALUEKLASS_HPP
  27 
  28 #include "oops/instanceKlass.hpp"
  29 #include "oops/method.hpp"
  30 #include "oops/oop.inline.hpp"
  31 
  32 // A ValueKlass is a specialized InstanceKlass for value types.
  33 
  34 
  35 class ValueKlass: public InstanceKlass {
  36   friend class VMStructs;
  37   friend class InstanceKlass;
  38 
  39  private:
  40 
  41   // Constructor
  42   ValueKlass(const ClassFileParser& parser)
  43     : InstanceKlass(parser, InstanceKlass::_misc_kind_value_type) {
  44     set_has_vcc_klass();
  45     // Addresses used for value type calling convention
  46     *((Array<SigEntry>**)adr_extended_sig()) = NULL;
  47     *((Array<VMRegPair>**)adr_return_regs()) = NULL;
  48     *((address*)adr_pack_handler()) = NULL;
  49     *((address*)adr_unpack_handler()) = NULL;
  50     assert(pack_handler() == NULL, "pack handler not null");
  51     *((int*)adr_default_value_offset()) = 0;

  52   }
  53 
  54   address adr_extended_sig() const {
  55     address adr_vcc = adr_vcc_klass();
  56     if (adr_vcc == NULL) {
  57       address adr_jf = adr_value_fields_klasses();
  58       if (adr_jf != NULL) {
  59         return adr_jf + this->java_fields_count() * sizeof(Klass*);
  60       }
  61 
  62       address adr_fing = adr_fingerprint();
  63       if (adr_fing != NULL) {
  64         return adr_fingerprint() + sizeof(u8);
  65       }
  66 
  67       InstanceKlass** adr_host = adr_host_klass();
  68       if (adr_host != NULL) {
  69         return (address)(adr_host + 1);
  70       }
  71 
  72       Klass** adr_impl = adr_implementor();
  73       if (adr_impl != NULL) {
  74         return (address)(adr_impl + 1);
  75       }
  76 
  77       return (address)end_of_nonstatic_oop_maps();
  78     } else {
  79       return adr_vcc + sizeof(Klass*);
  80     }




  81   }
  82 
  83   address adr_return_regs() const {
  84     return adr_extended_sig() + sizeof(intptr_t);

  85   }
  86 
  87   // pack and unpack handlers for value types return
  88   address adr_pack_handler() const {
  89     return (address)this + in_bytes(pack_handler_offset());

  90   }
  91 
  92   address adr_unpack_handler() const {
  93     return (address)this + in_bytes(unpack_handler_offset());

  94   }
  95 
  96   address pack_handler() const {
  97     return *(address*)adr_pack_handler();
  98   }
  99 
 100   address unpack_handler() const {
 101     return *(address*)adr_unpack_handler();
 102   }
 103 
 104   address adr_default_value_offset() const {
 105     return (address)this + in_bytes(default_value_offset_offset());

 106   }
 107 
 108   // static Klass* array_klass_impl(InstanceKlass* this_k, bool or_null, int n, TRAPS);
 109 
 110   GrowableArray<SigEntry> collect_fields(int base_off = 0) const;
 111 
 112   void cleanup_blobs();
 113 
 114  protected:
 115   // Returns the array class for the n'th dimension
 116   Klass* array_klass_impl(bool or_null, int n, TRAPS);
 117 
 118   // Returns the array class with this class as element type
 119   Klass* array_klass_impl(bool or_null, TRAPS);
 120 
 121  public:
 122   // Type testing
 123   bool is_value_slow() const        { return true; }
 124   bool is__Value() const { return (this == SystemDictionary::___Value_klass()); }
 125 
 126   // Casting from Klass*
 127   static ValueKlass* cast(Klass* k) {
 128     assert(k->is_value(), "cast to ValueKlass");
 129     return (ValueKlass*) k;
 130   }
 131 
 132   // Use this to return the size of an instance in heap words
 133   // Implementation is currently simple because all value types are allocated
 134   // in Java heap like Java objects.
 135   virtual int size_helper() const {
 136     return layout_helper_to_size_helper(layout_helper());
 137   }
 138 
 139   // allocate_instance() allocates a stand alone value in the Java heap
 140   instanceOop allocate_instance(TRAPS);
 141   // allocate_buffered_or_heap_instance() tries to allocate a value in the
 142   // thread local value buffer, if allocation fails, it allocates it in the
 143   // Java heap
 144   instanceOop allocate_buffered_or_heap_instance(bool* in_heap, TRAPS);
 145 
 146   // minimum number of bytes occupied by nonstatic fields, HeapWord aligned or pow2
 147   int raw_value_byte_size() const;
 148 
 149   int first_field_offset() const;
 150 
 151   address data_for_oop(oop o) const {
 152     return ((address) (void*) o) + first_field_offset();
 153   }
 154 
 155   oop oop_for_data(address data) const {
 156     oop o = (oop) (data - first_field_offset());
 157     assert(oopDesc::is_oop(o, false), "Not an oop");
 158     return o;
 159   }
 160 
 161   void set_if_bufferable() {
 162     bool bufferable;
 163 
 164     int size_in_heap_words = size_helper();
 165     int base_offset = instanceOopDesc::base_offset_in_bytes();
 166     size_t size_in_bytes = size_in_heap_words * HeapWordSize - base_offset;
 167     bufferable = size_in_bytes <= BigValueTypeThreshold;
 168     if (size_in_bytes > VTBufferChunk::max_alloc_size()) bufferable = false;
 169     if (ValueTypesBufferMaxMemory == 0) bufferable = false;


 170     if (bufferable) {
 171       _extra_flags |= _extra_is_bufferable;
 172     } else {
 173       _extra_flags &= ~_extra_is_bufferable;
 174     }
 175   }
 176 
 177   bool is_bufferable() const          {
 178     return (_extra_flags & _extra_is_bufferable) != 0;
 179   }
 180 
 181   // Query if h/w provides atomic load/store
 182   bool is_atomic();
 183 
 184   bool flatten_array();
 185 
 186   bool contains_oops() const { return nonstatic_oop_map_count() > 0; }
 187   int nonstatic_oop_count();
 188 
 189   // Prototype general store methods...
 190 
 191   // copy the fields, with no concern for GC barriers
 192   void raw_field_copy(void* src, void* dst, size_t raw_byte_size);
 193 
 194   void value_store(void* src, void* dst, bool dst_is_heap, bool dst_uninitialized) {
 195     value_store(src, dst, nonstatic_field_size() << LogBytesPerHeapOop, dst_is_heap, dst_uninitialized);
 196   }
 197 
 198   // store the value of this klass contained with src into dst, raw data ptr
 199   void value_store(void* src, void* dst, size_t raw_byte_size, bool dst_is_heap, bool dst_uninitialized);
 200 
 201   oop unbox(Handle src, InstanceKlass* target_klass, TRAPS);
 202   oop box(Handle src, InstanceKlass* target_klass, TRAPS);
 203 
 204   // GC support...
 205 
 206   void iterate_over_inside_oops(OopClosure* f, oop value);
 207 
 208   // oop iterate raw value type data pointer (where oop_addr may not be an oop, but backing/array-element)
 209   template <bool nv, typename T, class OopClosureType>
 210   inline void oop_iterate_specialized(const address oop_addr, OopClosureType* closure);
 211 
 212   template <bool nv, typename T, class OopClosureType>
 213   inline void oop_iterate_specialized_bounded(const address oop_addr, OopClosureType* closure, void* lo, void* hi);
 214 
 215   // calling convention support
 216   void initialize_calling_convention();
 217   Array<SigEntry>* extended_sig() const {
 218     assert(!is__Value(), "make no sense for __Value");
 219     return *((Array<SigEntry>**)adr_extended_sig());
 220   }
 221   Array<VMRegPair>* return_regs() const {
 222     assert(!is__Value(), "make no sense for __Value");
 223     return *((Array<VMRegPair>**)adr_return_regs());
 224   }
 225   bool can_be_returned_as_fields() const;
 226   void save_oop_fields(const RegisterMap& map, GrowableArray<Handle>& handles) const;
 227   void restore_oop_results(RegisterMap& map, GrowableArray<Handle>& handles) const;
 228   oop realloc_result(const RegisterMap& reg_map, const GrowableArray<Handle>& handles, bool buffered, TRAPS);
 229   static ValueKlass* returned_value_klass(const RegisterMap& reg_map);
 230 
 231   // pack and unpack handlers. Need to be loadable from generated code
 232   // so at a fixed offset from the base of the klass pointer.
 233   static ByteSize pack_handler_offset() {

 234     return in_ByteSize(InstanceKlass::header_size() * wordSize);
 235   }
 236 
 237   static ByteSize unpack_handler_offset() {

 238     return in_ByteSize((InstanceKlass::header_size()+1) * wordSize);
 239   }
 240 
 241   static ByteSize default_value_offset_offset() {

 242     return in_ByteSize((InstanceKlass::header_size()+2) * wordSize);
 243   }
 244 
 245   void set_default_value_offset(int offset) {
 246     *((int*)adr_default_value_offset()) = offset;
 247   }
 248 
 249   int default_value_offset() {
 250     int offset = *((int*)adr_default_value_offset());
 251     assert(offset != 0, "must not be called if not initialized");
 252     return offset;
 253   }
 254 
 255   void set_default_value(oop val) {
 256     java_mirror()->obj_field_put(default_value_offset(), val);
 257   }
 258 
 259   oop default_value() {
 260     oop val = java_mirror()->obj_field_acquire(default_value_offset());
 261     assert(oopDesc::is_oop(val), "Sanity check");


  24 
  25 #ifndef SHARE_VM_OOPS_VALUEKLASS_HPP
  26 #define SHARE_VM_OOPS_VALUEKLASS_HPP
  27 
  28 #include "oops/instanceKlass.hpp"
  29 #include "oops/method.hpp"
  30 #include "oops/oop.inline.hpp"
  31 
  32 // A ValueKlass is a specialized InstanceKlass for value types.
  33 
  34 
  35 class ValueKlass: public InstanceKlass {
  36   friend class VMStructs;
  37   friend class InstanceKlass;
  38 
  39  private:
  40 
  41   // Constructor
  42   ValueKlass(const ClassFileParser& parser)
  43     : InstanceKlass(parser, InstanceKlass::_misc_kind_value_type) {
  44     _adr_valueklass_fixed_block = valueklass_static_bloc();
  45     // Addresses used for value type calling convention
  46     *((Array<SigEntry>**)adr_extended_sig()) = NULL;
  47     *((Array<VMRegPair>**)adr_return_regs()) = NULL;
  48     *((address*)adr_pack_handler()) = NULL;
  49     *((address*)adr_unpack_handler()) = NULL;
  50     assert(pack_handler() == NULL, "pack handler not null");
  51     *((int*)adr_default_value_offset()) = 0;
  52 
  53   }
  54 
  55   ValueKlassFixedBlock* valueklass_static_bloc() const {


  56     address adr_jf = adr_value_fields_klasses();
  57     if (adr_jf != NULL) {
  58       return (ValueKlassFixedBlock*)(adr_jf + this->java_fields_count() * sizeof(Klass*));
  59     }
  60 
  61     address adr_fing = adr_fingerprint();
  62     if (adr_fing != NULL) {
  63       return (ValueKlassFixedBlock*)(adr_fingerprint() + sizeof(u8));
  64     }
  65 
  66     InstanceKlass** adr_host = adr_host_klass();
  67     if (adr_host != NULL) {
  68       return (ValueKlassFixedBlock*)(adr_host + 1);
  69     }
  70 
  71     Klass** adr_impl = adr_implementor();
  72     if (adr_impl != NULL) {
  73       return (ValueKlassFixedBlock*)(adr_impl + 1);
  74     }
  75 
  76     return (ValueKlassFixedBlock*)end_of_nonstatic_oop_maps();


  77   }
  78 
  79   address adr_extended_sig() const {
  80     assert(_adr_valueklass_fixed_block != NULL, "Should have been initialized");
  81     return ((address)_adr_valueklass_fixed_block) + in_bytes(byte_offset_of(ValueKlassFixedBlock, _extended_sig));
  82   }
  83 
  84   address adr_return_regs() const {
  85     ValueKlassFixedBlock* vkst = valueklass_static_bloc();
  86     return ((address)_adr_valueklass_fixed_block) + in_bytes(byte_offset_of(ValueKlassFixedBlock, _return_regs));
  87   }
  88 
  89   // pack and unpack handlers for value types return
  90   address adr_pack_handler() const {
  91     assert(_adr_valueklass_fixed_block != NULL, "Should have been initialized");
  92     return ((address)_adr_valueklass_fixed_block) + in_bytes(byte_offset_of(ValueKlassFixedBlock, _pack_handler));
  93   }
  94 
  95   address adr_unpack_handler() const {
  96     assert(_adr_valueklass_fixed_block != NULL, "Should have been initialized");
  97     return ((address)_adr_valueklass_fixed_block) + in_bytes(byte_offset_of(ValueKlassFixedBlock, _unpack_handler));
  98   }
  99 
 100   address pack_handler() const {
 101     return *(address*)adr_pack_handler();
 102   }
 103 
 104   address unpack_handler() const {
 105     return *(address*)adr_unpack_handler();
 106   }
 107 
 108   address adr_default_value_offset() const {
 109     assert(_adr_valueklass_fixed_block != NULL, "Should have been initialized");
 110     return ((address)_adr_valueklass_fixed_block) + in_bytes(byte_offset_of(ValueKlassFixedBlock, _default_value_offset));
 111   }
 112 
 113   // static Klass* array_klass_impl(InstanceKlass* this_k, bool or_null, int n, TRAPS);
 114 
 115   GrowableArray<SigEntry> collect_fields(int base_off = 0) const;
 116 
 117   void cleanup_blobs();
 118 
 119  protected:
 120   // Returns the array class for the n'th dimension
 121   Klass* array_klass_impl(bool or_null, int n, TRAPS);
 122 
 123   // Returns the array class with this class as element type
 124   Klass* array_klass_impl(bool or_null, TRAPS);
 125 
 126  public:
 127   // Type testing
 128   bool is_value_slow() const        { return true; }

 129 
 130   // Casting from Klass*
 131   static ValueKlass* cast(Klass* k) {
 132     assert(k->is_value(), "cast to ValueKlass");
 133     return (ValueKlass*) k;
 134   }
 135 
 136   // Use this to return the size of an instance in heap words
 137   // Implementation is currently simple because all value types are allocated
 138   // in Java heap like Java objects.
 139   virtual int size_helper() const {
 140     return layout_helper_to_size_helper(layout_helper());
 141   }
 142 
 143   // allocate_instance() allocates a stand alone value in the Java heap
 144   instanceOop allocate_instance(TRAPS);
 145   // allocate_buffered_or_heap_instance() tries to allocate a value in the
 146   // thread local value buffer, if allocation fails, it allocates it in the
 147   // Java heap
 148   instanceOop allocate_buffered_or_heap_instance(bool* in_heap, TRAPS);
 149 
 150   // minimum number of bytes occupied by nonstatic fields, HeapWord aligned or pow2
 151   int raw_value_byte_size() const;
 152 
 153   int first_field_offset() const;
 154 
 155   address data_for_oop(oop o) const {
 156     return ((address) (void*) o) + first_field_offset();
 157   }
 158 
 159   oop oop_for_data(address data) const {
 160     oop o = (oop) (data - first_field_offset());
 161     assert(oopDesc::is_oop(o, false), "Not an oop");
 162     return o;
 163   }
 164 
 165   void set_if_bufferable() {
 166     bool bufferable;
 167 
 168 //    int size_in_heap_words = size_helper();
 169 //    int base_offset = instanceOopDesc::base_offset_in_bytes();
 170 //    size_t size_in_bytes = size_in_heap_words * HeapWordSize - base_offset;
 171 //    bufferable = size_in_bytes <= BigValueTypeThreshold;
 172 //    if (size_in_bytes > VTBufferChunk::max_alloc_size()) bufferable = false;
 173 //    if (ValueTypesBufferMaxMemory == 0) bufferable = false;
 174 
 175     bufferable = false;
 176     if (bufferable) {
 177       _extra_flags |= _extra_is_bufferable;
 178     } else {
 179       _extra_flags &= ~_extra_is_bufferable;
 180     }
 181   }
 182 
 183   bool is_bufferable() const          {
 184     return (_extra_flags & _extra_is_bufferable) != 0;
 185   }
 186 
 187   // Query if h/w provides atomic load/store
 188   bool is_atomic();
 189 
 190   bool flatten_array();
 191 
 192   bool contains_oops() const { return nonstatic_oop_map_count() > 0; }
 193   int nonstatic_oop_count();
 194 
 195   // Prototype general store methods...
 196 
 197   // copy the fields, with no concern for GC barriers
 198   void raw_field_copy(void* src, void* dst, size_t raw_byte_size);
 199 
 200   void value_store(void* src, void* dst, bool dst_is_heap, bool dst_uninitialized) {
 201     value_store(src, dst, nonstatic_field_size() << LogBytesPerHeapOop, dst_is_heap, dst_uninitialized);
 202   }
 203 
 204   // store the value of this klass contained with src into dst, raw data ptr
 205   void value_store(void* src, void* dst, size_t raw_byte_size, bool dst_is_heap, bool dst_uninitialized);
 206 



 207   // GC support...
 208 
 209   void iterate_over_inside_oops(OopClosure* f, oop value);
 210 
 211   // oop iterate raw value type data pointer (where oop_addr may not be an oop, but backing/array-element)
 212   template <bool nv, typename T, class OopClosureType>
 213   inline void oop_iterate_specialized(const address oop_addr, OopClosureType* closure);
 214 
 215   template <bool nv, typename T, class OopClosureType>
 216   inline void oop_iterate_specialized_bounded(const address oop_addr, OopClosureType* closure, void* lo, void* hi);
 217 
 218   // calling convention support
 219   void initialize_calling_convention();
 220   Array<SigEntry>* extended_sig() const {

 221     return *((Array<SigEntry>**)adr_extended_sig());
 222   }
 223   Array<VMRegPair>* return_regs() const {

 224     return *((Array<VMRegPair>**)adr_return_regs());
 225   }
 226   bool can_be_returned_as_fields() const;
 227   void save_oop_fields(const RegisterMap& map, GrowableArray<Handle>& handles) const;
 228   void restore_oop_results(RegisterMap& map, GrowableArray<Handle>& handles) const;
 229   oop realloc_result(const RegisterMap& reg_map, const GrowableArray<Handle>& handles, bool buffered, TRAPS);
 230   static ValueKlass* returned_value_klass(const RegisterMap& reg_map);
 231 
 232   // pack and unpack handlers. Need to be loadable from generated code
 233   // so at a fixed offset from the base of the klass pointer.
 234   static ByteSize pack_handler_offset() {
 235     fatal("Should be re-implemented using the ValueKlassStaticBlock indirection");
 236     return in_ByteSize(InstanceKlass::header_size() * wordSize);
 237   }
 238 
 239   static ByteSize unpack_handler_offset() {
 240     fatal("Should be re-implemented using the ValueKlassStaticBlock indirection");
 241     return in_ByteSize((InstanceKlass::header_size()+1) * wordSize);
 242   }
 243 
 244   static ByteSize default_value_offset_offset() {
 245     fatal("Should be re-implemented using the ValueKlassStaticBlock indirection");
 246     return in_ByteSize((InstanceKlass::header_size()+2) * wordSize);
 247   }
 248 
 249   void set_default_value_offset(int offset) {
 250     *((int*)adr_default_value_offset()) = offset;
 251   }
 252 
 253   int default_value_offset() {
 254     int offset = *((int*)adr_default_value_offset());
 255     assert(offset != 0, "must not be called if not initialized");
 256     return offset;
 257   }
 258 
 259   void set_default_value(oop val) {
 260     java_mirror()->obj_field_put(default_value_offset(), val);
 261   }
 262 
 263   oop default_value() {
 264     oop val = java_mirror()->obj_field_acquire(default_value_offset());
 265     assert(oopDesc::is_oop(val), "Sanity check");
< prev index next >