1 /*
   2  * Copyright (c) 2017, 2019, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #ifndef SHARE_VM_OOPS_VALUEKLASS_HPP
  26 #define SHARE_VM_OOPS_VALUEKLASS_HPP
  27 
  28 #include "classfile/javaClasses.hpp"
  29 #include "oops/instanceKlass.hpp"
  30 #include "oops/method.hpp"
  31 //#include "oops/oop.inline.hpp"
  32 
  33 // A ValueKlass is a specialized InstanceKlass for value types.
  34 
  35 
  36 class ValueKlass: public InstanceKlass {
  37   friend class VMStructs;
  38   friend class InstanceKlass;
  39 
  40  private:
  41 
  42   // Constructor
  43   ValueKlass(const ClassFileParser& parser);
  44 
  45   ValueKlassFixedBlock* valueklass_static_block() const {
  46     address adr_jf = adr_value_fields_klasses();
  47     if (adr_jf != NULL) {
  48       return (ValueKlassFixedBlock*)(adr_jf + this->java_fields_count() * sizeof(Klass*));
  49     }
  50 
  51     address adr_fing = adr_fingerprint();
  52     if (adr_fing != NULL) {
  53       return (ValueKlassFixedBlock*)(adr_fingerprint() + sizeof(u8));
  54     }
  55 
  56     InstanceKlass** adr_host = adr_unsafe_anonymous_host();
  57     if (adr_host != NULL) {
  58       return (ValueKlassFixedBlock*)(adr_host + 1);
  59     }
  60 
  61     Klass* volatile* adr_impl = adr_implementor();
  62     if (adr_impl != NULL) {
  63       return (ValueKlassFixedBlock*)(adr_impl + 1);
  64     }
  65 
  66     return (ValueKlassFixedBlock*)end_of_nonstatic_oop_maps();
  67   }
  68 
  69   address adr_extended_sig() const {
  70     assert(_adr_valueklass_fixed_block != NULL, "Should have been initialized");
  71     return ((address)_adr_valueklass_fixed_block) + in_bytes(byte_offset_of(ValueKlassFixedBlock, _extended_sig));
  72   }
  73 
  74   address adr_return_regs() const {
  75     ValueKlassFixedBlock* vkst = valueklass_static_block();
  76     return ((address)_adr_valueklass_fixed_block) + in_bytes(byte_offset_of(ValueKlassFixedBlock, _return_regs));
  77   }
  78 
  79   // pack and unpack handlers for value types return
  80   address adr_pack_handler() const {
  81     assert(_adr_valueklass_fixed_block != NULL, "Should have been initialized");
  82     return ((address)_adr_valueklass_fixed_block) + in_bytes(byte_offset_of(ValueKlassFixedBlock, _pack_handler));
  83   }
  84 
  85   address adr_unpack_handler() const {
  86     assert(_adr_valueklass_fixed_block != NULL, "Should have been initialized");
  87     return ((address)_adr_valueklass_fixed_block) + in_bytes(byte_offset_of(ValueKlassFixedBlock, _unpack_handler));
  88   }
  89 
  90   address adr_default_value_offset() const {
  91     assert(_adr_valueklass_fixed_block != NULL, "Should have been initialized");
  92     return ((address)_adr_valueklass_fixed_block) + in_bytes(default_value_offset_offset());
  93   }
  94 
  95   address adr_value_array_klass() 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, _value_array_klass));
  98   }
  99 
 100   Klass* get_value_array_klass() const {
 101     return *(Klass**)adr_value_array_klass();
 102   }
 103 
 104   Klass* acquire_value_array_klass() const {
 105     return OrderAccess::load_acquire((Klass**)adr_value_array_klass());
 106   }
 107 
 108   Klass* allocate_value_array_klass(TRAPS);
 109 
 110   address adr_alignment() const {
 111     assert(_adr_valueklass_fixed_block != NULL, "Should have been initialized");
 112     return ((address)_adr_valueklass_fixed_block) + in_bytes(byte_offset_of(ValueKlassFixedBlock, _alignment));
 113   }
 114 
 115   address adr_first_field_offset() const {
 116     assert(_adr_valueklass_fixed_block != NULL, "Should have been initialized");
 117     return ((address)_adr_valueklass_fixed_block) + in_bytes(byte_offset_of(ValueKlassFixedBlock, _first_field_offset));
 118   }
 119 
 120   address adr_exact_size_in_bytes() const {
 121     assert(_adr_valueklass_fixed_block != NULL, "Should have been initialized");
 122     return ((address)_adr_valueklass_fixed_block) + in_bytes(byte_offset_of(ValueKlassFixedBlock, _exact_size_in_bytes));
 123   }
 124 
 125  public:
 126   int get_alignment() const {
 127     return *(int*)adr_alignment();
 128   }
 129 
 130   void set_alignment(int alignment) {
 131     *(int*)adr_alignment() = alignment;
 132   }
 133 
 134   int first_field_offset() const {
 135     int offset = *(int*)adr_first_field_offset();
 136     assert(offset != 0, "Must be initialized before use");
 137     return *(int*)adr_first_field_offset();
 138   }
 139 
 140   void set_first_field_offset(int offset) {
 141     *(int*)adr_first_field_offset() = offset;
 142   }
 143 
 144   int get_exact_size_in_bytes() const {
 145     return *(int*)adr_exact_size_in_bytes();
 146   }
 147 
 148   void set_exact_size_in_bytes(int exact_size) {
 149     *(int*)adr_exact_size_in_bytes() = exact_size;
 150   }
 151 
 152   int first_field_offset_old();
 153 
 154  private:
 155   int collect_fields(GrowableArray<SigEntry>* sig, int base_off = 0);
 156 
 157   void cleanup_blobs();
 158 
 159 
 160  protected:
 161   // Returns the array class for the n'th dimension
 162   Klass* array_klass_impl(ArrayStorageProperties storage_props, bool or_null, int n, TRAPS);
 163 
 164   // Returns the array class with this class as element type
 165   Klass* array_klass_impl(ArrayStorageProperties storage_props, bool or_null, TRAPS);
 166 
 167   // Specifically flat array klass
 168   Klass* value_array_klass(ArrayStorageProperties storage_props, bool or_null, int rank, TRAPS);
 169 
 170  public:
 171   // Type testing
 172   bool is_value_slow() const        { return true; }
 173 
 174   // value_mirror is the primary mirror
 175   oop value_mirror() const    { return java_lang_Class::inline_type_mirror(java_mirror()); }
 176   oop indirect_mirror() const { return java_lang_Class::indirect_type_mirror(java_mirror()); }
 177 
 178   // Casting from Klass*
 179   static ValueKlass* cast(Klass* k);
 180 
 181   // Use this to return the size of an instance in heap words
 182   // Implementation is currently simple because all value types are allocated
 183   // in Java heap like Java objects.
 184   virtual int size_helper() const {
 185     return layout_helper_to_size_helper(layout_helper());
 186   }
 187 
 188   // Metadata iterators
 189   void array_klasses_do(void f(Klass* k));
 190 
 191   // allocate_instance() allocates a stand alone value in the Java heap
 192   instanceOop allocate_instance(TRAPS);
 193 
 194   // minimum number of bytes occupied by nonstatic fields, HeapWord aligned or pow2
 195   int raw_value_byte_size();
 196 
 197   address data_for_oop(oop o) const;
 198   oop oop_for_data(address data) const;
 199 
 200   // Query if h/w provides atomic load/store
 201   bool is_atomic();
 202 
 203   bool flatten_array();
 204 
 205   bool contains_oops() const { return nonstatic_oop_map_count() > 0; }
 206   int nonstatic_oop_count();
 207 
 208   // General store methods
 209   //
 210   // Normally loads and store methods would be found in *Oops classes, but since values can be
 211   // "in-lined" (flattened) into containing oops, these methods reside here in ValueKlass.
 212   //
 213   // "value_copy_*_to_new_*" assume new memory (i.e. IS_DEST_UNINITIALIZED for write barriers)
 214 
 215   void value_copy_payload_to_new_oop(void* src, oop dst);
 216   void value_copy_oop_to_new_oop(oop src, oop dst);
 217   void value_copy_oop_to_new_payload(oop src, void* dst);
 218 
 219   void value_copy_oop_to_payload(oop src, void* dst);
 220 
 221   // oop iterate raw value type data pointer (where oop_addr may not be an oop, but backing/array-element)
 222   template <typename T, class OopClosureType>
 223   inline void oop_iterate_specialized(const address oop_addr, OopClosureType* closure);
 224 
 225   template <typename T, class OopClosureType>
 226   inline void oop_iterate_specialized_bounded(const address oop_addr, OopClosureType* closure, void* lo, void* hi);
 227 
 228   // calling convention support
 229   void initialize_calling_convention(TRAPS);
 230   Array<SigEntry>* extended_sig() const {
 231     return *((Array<SigEntry>**)adr_extended_sig());
 232   }
 233   Array<VMRegPair>* return_regs() const {
 234     return *((Array<VMRegPair>**)adr_return_regs());
 235   }
 236   bool is_scalarizable() const;
 237   bool can_be_returned_as_fields() const;
 238   void save_oop_fields(const RegisterMap& map, GrowableArray<Handle>& handles) const;
 239   void restore_oop_results(RegisterMap& map, GrowableArray<Handle>& handles) const;
 240   oop realloc_result(const RegisterMap& reg_map, const GrowableArray<Handle>& handles, TRAPS);
 241   static ValueKlass* returned_value_klass(const RegisterMap& reg_map);
 242 
 243   address pack_handler() const {
 244     return *(address*)adr_pack_handler();
 245   }
 246 
 247   address unpack_handler() const {
 248     return *(address*)adr_unpack_handler();
 249   }
 250 
 251   // pack and unpack handlers. Need to be loadable from generated code
 252   // so at a fixed offset from the base of the klass pointer.
 253   static ByteSize pack_handler_offset() {
 254     return byte_offset_of(ValueKlassFixedBlock, _pack_handler);
 255   }
 256 
 257   static ByteSize unpack_handler_offset() {
 258     return byte_offset_of(ValueKlassFixedBlock, _unpack_handler);
 259   }
 260 
 261   static ByteSize default_value_offset_offset() {
 262     return byte_offset_of(ValueKlassFixedBlock, _default_value_offset);
 263   }
 264 
 265   void set_default_value_offset(int offset) {
 266     *((int*)adr_default_value_offset()) = offset;
 267   }
 268 
 269   int default_value_offset() {
 270     int offset = *((int*)adr_default_value_offset());
 271     assert(offset != 0, "must not be called if not initialized");
 272     return offset;
 273   }
 274 
 275   void set_default_value(oop val) {
 276     java_mirror()->obj_field_put(default_value_offset(), val);
 277     indirect_mirror()->obj_field_put(default_value_offset(), val);
 278   }
 279 
 280   oop default_value();
 281   void deallocate_contents(ClassLoaderData* loader_data);
 282   static void cleanup(ValueKlass* ik) ;
 283 
 284   // Verification
 285   void verify_on(outputStream* st);
 286   void oop_verify_on(oop obj, outputStream* st);
 287 
 288 };
 289 
 290 #endif /* SHARE_VM_OOPS_VALUEKLASS_HPP */