< prev index next >

src/hotspot/share/oops/objArrayKlass.hpp

Print this page

 27 
 28 #include "oops/arrayKlass.hpp"
 29 #include "utilities/macros.hpp"
 30 
 31 class ClassLoaderData;
 32 
 33 // ObjArrayKlass is the klass for objArrays
 34 
 35 class ObjArrayKlass : public ArrayKlass {
 36   friend class Deoptimization;
 37   friend class JVMCIVMStructs;
 38   friend class oopFactory;
 39   friend class VMStructs;
 40 
 41  public:
 42   static const KlassKind Kind = ObjArrayKlassKind;
 43 
 44  private:
 45   // If you add a new field that points to any metaspace object, you
 46   // must add this field to ObjArrayKlass::metaspace_pointers_do().
 47   Klass* _element_klass;            // The klass of the elements of this array type
 48   Klass* _bottom_klass;             // The one-dimensional type (InstanceKlass or TypeArrayKlass)



 49 

 50   // Constructor
 51   ObjArrayKlass(int n, Klass* element_klass, Symbol* name);
 52   static ObjArrayKlass* allocate_klass(ClassLoaderData* loader_data, int n, Klass* k, Symbol* name, TRAPS);
 53 
 54   objArrayOop allocate_instance(int length, TRAPS);
 55  public:
 56   // For dummy objects
 57   ObjArrayKlass() {}
 58 
 59   // Instance variables
 60   Klass* element_klass() const      { return _element_klass; }
 61   void set_element_klass(Klass* k)  { _element_klass = k; }
 62   Klass** element_klass_addr()      { return &_element_klass; }








 63 
 64   Klass* bottom_klass() const       { return _bottom_klass; }
 65   void set_bottom_klass(Klass* k)   { _bottom_klass = k; }
 66   Klass** bottom_klass_addr()       { return &_bottom_klass; }
 67 
 68   ModuleEntry* module() const;
 69   PackageEntry* package() const;
 70 
 71   // Compiler/Interpreter offset
 72   static ByteSize element_klass_offset() { return byte_offset_of(ObjArrayKlass, _element_klass); }
 73 
 74   // Dispatched operation
 75   bool can_be_primary_super_slow() const;
 76   GrowableArray<Klass*>* compute_secondary_supers(int num_extra_slots,
 77                                                   Array<InstanceKlass*>* transitive_interfaces);
 78   DEBUG_ONLY(bool is_objArray_klass_slow()  const  { return true; })
 79   size_t oop_size(oop obj) const;
 80 
 81   // Allocation
 82   static ObjArrayKlass* allocate_objArray_klass(ClassLoaderData* loader_data,
 83                                                 int n, Klass* element_klass, TRAPS);
 84 



 85   oop multi_allocate(int rank, jint* sizes, TRAPS);
 86 
 87   // Copying
 88   void  copy_array(arrayOop s, int src_pos, arrayOop d, int dst_pos, int length, TRAPS);
 89 
 90   // Compute protection domain
 91   oop protection_domain() const { return bottom_klass()->protection_domain(); }
 92 
 93   virtual void metaspace_pointers_do(MetaspaceClosure* iter);



 94 
 95  private:
 96   // Either oop or narrowOop depending on UseCompressedOops.
 97   // must be called from within ObjArrayKlass.cpp
 98   void do_copy(arrayOop s, size_t src_offset,
 99                arrayOop d, size_t dst_offset,
100                int length, TRAPS);
101  public:
102   static ObjArrayKlass* cast(Klass* k) {
103     return const_cast<ObjArrayKlass*>(cast(const_cast<const Klass*>(k)));
104   }
105 
106   static const ObjArrayKlass* cast(const Klass* k) {
107     assert(k->is_objArray_klass(), "cast to ObjArrayKlass");
108     return static_cast<const ObjArrayKlass*>(k);
109   }
110 
111   // Sizing
112   static int header_size()                { return sizeof(ObjArrayKlass)/wordSize; }
113   int size() const                        { return ArrayKlass::static_size(header_size()); }
114 
115   // Initialization (virtual from Klass)
116   void initialize(TRAPS);
117 
118   // Oop fields (and metadata) iterators
119   //
120   // The ObjArrayKlass iterators also visits the Object's klass.

136   inline void oop_oop_iterate_range(objArrayOop a, OopClosureType* closure, int start, int end);
137 
138  public:
139   // Iterate over all oop elements.
140   template <typename T, class OopClosureType>
141   inline void oop_oop_iterate_elements(objArrayOop a, OopClosureType* closure);
142 
143  private:
144   // Iterate over all oop elements with indices within mr.
145   template <typename T, class OopClosureType>
146   inline void oop_oop_iterate_elements_bounded(objArrayOop a, OopClosureType* closure, void* low, void* high);
147 
148  public:
149   u2 compute_modifier_flags() const;
150 
151  public:
152   // Printing
153   void print_on(outputStream* st) const;
154   void print_value_on(outputStream* st) const;
155 
156   void oop_print_value_on(oop obj, outputStream* st);
157 #ifndef PRODUCT
158   void oop_print_on      (oop obj, outputStream* st);
159 #endif //PRODUCT
160 
161   const char* internal_name() const;
162 
163   // Verification
164   void verify_on(outputStream* st);
165 
166   void oop_verify_on(oop obj, outputStream* st);
167 };
168 
169 #endif // SHARE_OOPS_OBJARRAYKLASS_HPP

 27 
 28 #include "oops/arrayKlass.hpp"
 29 #include "utilities/macros.hpp"
 30 
 31 class ClassLoaderData;
 32 
 33 // ObjArrayKlass is the klass for objArrays
 34 
 35 class ObjArrayKlass : public ArrayKlass {
 36   friend class Deoptimization;
 37   friend class JVMCIVMStructs;
 38   friend class oopFactory;
 39   friend class VMStructs;
 40 
 41  public:
 42   static const KlassKind Kind = ObjArrayKlassKind;
 43 
 44  private:
 45   // If you add a new field that points to any metaspace object, you
 46   // must add this field to ObjArrayKlass::metaspace_pointers_do().

 47   Klass* _bottom_klass;             // The one-dimensional type (InstanceKlass or TypeArrayKlass)
 48  protected:
 49   Klass* _element_klass;            // The klass of the elements of this array type
 50   ObjArrayKlass* _next_refined_array_klass;
 51 
 52  protected:
 53   // Constructor
 54   ObjArrayKlass(int n, Klass* element_klass, Symbol* name, KlassKind kind, ArrayKlass::ArrayProperties props, markWord mw);
 55   static ObjArrayKlass* allocate_klass(ClassLoaderData* loader_data, int n, Klass* k, Symbol* name, ArrayKlass::ArrayProperties props, TRAPS);
 56 

 57  public:
 58   // For dummy objects
 59   ObjArrayKlass() {}
 60 
 61   // Compiler/Interpreter offset
 62   static ByteSize element_klass_offset() { return in_ByteSize(offset_of(ObjArrayKlass, _element_klass)); }
 63 
 64   virtual Klass* element_klass() const      { return _element_klass; }
 65   virtual void set_element_klass(Klass* k)  { _element_klass = k; }
 66 
 67   ObjArrayKlass* next_refined_array_klass() const      { return _next_refined_array_klass; }
 68   inline ObjArrayKlass* next_refined_array_klass_acquire() const;
 69   void set_next_refined_klass_klass(ObjArrayKlass* ak) { _next_refined_array_klass = ak; }
 70   inline void release_set_next_refined_klass(ObjArrayKlass* ak);
 71   ObjArrayKlass* klass_with_properties(ArrayKlass::ArrayProperties properties, TRAPS);
 72   static ByteSize next_refined_array_klass_offset() { return byte_offset_of(ObjArrayKlass, _next_refined_array_klass); }
 73 
 74   Klass* bottom_klass() const       { return _bottom_klass; }
 75   void set_bottom_klass(Klass* k)   { _bottom_klass = k; }
 76   Klass** bottom_klass_addr()       { return &_bottom_klass; }
 77 
 78   ModuleEntry* module() const;
 79   PackageEntry* package() const;
 80 



 81   // Dispatched operation
 82   bool can_be_primary_super_slow() const;
 83   GrowableArray<Klass*>* compute_secondary_supers(int num_extra_slots,
 84                                                   Array<InstanceKlass*>* transitive_interfaces);
 85   DEBUG_ONLY(bool is_objArray_klass_slow()  const  { return true; })
 86   size_t oop_size(oop obj) const;
 87 
 88   // Allocation
 89   static ObjArrayKlass* allocate_objArray_klass(ClassLoaderData* loader_data,
 90                                                 int n, Klass* element_klass, TRAPS);
 91 
 92   static ArrayDescription array_layout_selection(Klass* element, ArrayProperties properties);
 93 
 94   virtual objArrayOop allocate_instance(int length, ArrayProperties props, TRAPS);
 95   oop multi_allocate(int rank, jint* sizes, TRAPS);
 96 
 97   // Copying
 98   void  copy_array(arrayOop s, int src_pos, arrayOop d, int dst_pos, int length, TRAPS);
 99 
100   // Compute protection domain
101   oop protection_domain() const { return bottom_klass()->protection_domain(); }
102 
103   virtual void metaspace_pointers_do(MetaspaceClosure* iter);
104   virtual void remove_unshareable_info();
105   virtual void remove_java_mirror();
106   void restore_unshareable_info(ClassLoaderData* loader_data, Handle protection_domain, TRAPS);
107 






108  public:
109   static ObjArrayKlass* cast(Klass* k) {
110     return const_cast<ObjArrayKlass*>(cast(const_cast<const Klass*>(k)));
111   }
112 
113   static const ObjArrayKlass* cast(const Klass* k) {
114     assert(k->is_objArray_klass(), "cast to ObjArrayKlass");
115     return static_cast<const ObjArrayKlass*>(k);
116   }
117 
118   // Sizing
119   static int header_size()                { return sizeof(ObjArrayKlass)/wordSize; }
120   int size() const                        { return ArrayKlass::static_size(header_size()); }
121 
122   // Initialization (virtual from Klass)
123   void initialize(TRAPS);
124 
125   // Oop fields (and metadata) iterators
126   //
127   // The ObjArrayKlass iterators also visits the Object's klass.

143   inline void oop_oop_iterate_range(objArrayOop a, OopClosureType* closure, int start, int end);
144 
145  public:
146   // Iterate over all oop elements.
147   template <typename T, class OopClosureType>
148   inline void oop_oop_iterate_elements(objArrayOop a, OopClosureType* closure);
149 
150  private:
151   // Iterate over all oop elements with indices within mr.
152   template <typename T, class OopClosureType>
153   inline void oop_oop_iterate_elements_bounded(objArrayOop a, OopClosureType* closure, void* low, void* high);
154 
155  public:
156   u2 compute_modifier_flags() const;
157 
158  public:
159   // Printing
160   void print_on(outputStream* st) const;
161   void print_value_on(outputStream* st) const;
162 
163   virtual void oop_print_value_on(oop obj, outputStream* st);
164 #ifndef PRODUCT
165   virtual void oop_print_on      (oop obj, outputStream* st);
166 #endif //PRODUCT
167 
168   const char* internal_name() const;
169 
170   // Verification
171   void verify_on(outputStream* st);
172 
173   void oop_verify_on(oop obj, outputStream* st);
174 };
175 
176 #endif // SHARE_OOPS_OBJARRAYKLASS_HPP
< prev index next >