< prev index next >

src/hotspot/share/oops/arrayKlass.hpp

Print this page

 26 #define SHARE_OOPS_ARRAYKLASS_HPP
 27 
 28 #include "oops/klass.hpp"
 29 
 30 class fieldDescriptor;
 31 class klassVtable;
 32 class ObjArrayKlass;
 33 
 34 // ArrayKlass is the abstract baseclass for all array classes
 35 
 36 class ArrayKlass: public Klass {
 37   friend class VMStructs;
 38  private:
 39   // If you add a new field that points to any metaspace object, you
 40   // must add this field to ArrayKlass::metaspace_pointers_do().
 41   int      _dimension;         // This is n'th-dimensional array.
 42   ObjArrayKlass* volatile _higher_dimension;  // Refers the (n+1)'th-dimensional array (if present).
 43   ArrayKlass* volatile    _lower_dimension;   // Refers the (n-1)'th-dimensional array (if present).
 44 
 45  protected:







 46   // Constructors
 47   // The constructor with the Symbol argument does the real array
 48   // initialization, the other is a dummy
 49   ArrayKlass(Symbol* name, KlassKind kind);
 50   ArrayKlass();
 51 



 52   void* operator new(size_t size, ClassLoaderData* loader_data, size_t word_size, TRAPS) throw();
 53 
 54  public:







 55   // Testing operation
 56   DEBUG_ONLY(bool is_array_klass_slow() const { return true; })
 57 
 58   // Returns the ObjArrayKlass for n'th dimension.
 59   ArrayKlass* array_klass(int n, TRAPS);
 60   ArrayKlass* array_klass_or_null(int n);
 61 
 62   // Returns the array class with this class as element type.
 63   ArrayKlass* array_klass(TRAPS);
 64   ArrayKlass* array_klass_or_null();
 65 
 66   // Instance variables
 67   int dimension() const                 { return _dimension;      }
 68   void set_dimension(int dimension)     { _dimension = dimension; }
 69 
 70   ObjArrayKlass* higher_dimension() const     { return _higher_dimension; }
 71   inline ObjArrayKlass* higher_dimension_acquire() const; // load with acquire semantics
 72   void set_higher_dimension(ObjArrayKlass* k) { _higher_dimension = k; }
 73   inline void release_set_higher_dimension(ObjArrayKlass* k); // store with release semantics
 74 

 93   Klass* find_field(Symbol* name, Symbol* sig, fieldDescriptor* fd) const;
 94 
 95   // Lookup operations
 96   Method* uncached_lookup_method(const Symbol* name,
 97                                  const Symbol* signature,
 98                                  OverpassLookupMode overpass_mode,
 99                                  PrivateLookupMode private_mode = PrivateLookupMode::find) const;
100 
101   static ArrayKlass* cast(Klass* k) {
102     return const_cast<ArrayKlass*>(cast(const_cast<const Klass*>(k)));
103   }
104 
105   static const ArrayKlass* cast(const Klass* k) {
106     assert(k->is_array_klass(), "cast to ArrayKlass");
107     return static_cast<const ArrayKlass*>(k);
108   }
109 
110   GrowableArray<Klass*>* compute_secondary_supers(int num_extra_slots,
111                                                   Array<InstanceKlass*>* transitive_interfaces);
112 


113   // Sizing
114   static int static_size(int header_size);
115 
116   virtual void metaspace_pointers_do(MetaspaceClosure* iter);
117 
118   // Return a handle.
119   static void     complete_create_array_klass(ArrayKlass* k, Klass* super_klass, ModuleEntry* module, TRAPS);
120 
121   // JVMTI support
122   jint jvmti_class_status() const;
123 
124 #if INCLUDE_CDS
125   // CDS support - remove and restore oops from metadata. Oops are not shared.
126   virtual void remove_unshareable_info();
127   virtual void remove_java_mirror();
128   void restore_unshareable_info(ClassLoaderData* loader_data, Handle protection_domain, TRAPS);
129   void cds_print_value_on(outputStream* st) const;
130 #endif
131 
132   void log_array_class_load(Klass* k);

 26 #define SHARE_OOPS_ARRAYKLASS_HPP
 27 
 28 #include "oops/klass.hpp"
 29 
 30 class fieldDescriptor;
 31 class klassVtable;
 32 class ObjArrayKlass;
 33 
 34 // ArrayKlass is the abstract baseclass for all array classes
 35 
 36 class ArrayKlass: public Klass {
 37   friend class VMStructs;
 38  private:
 39   // If you add a new field that points to any metaspace object, you
 40   // must add this field to ArrayKlass::metaspace_pointers_do().
 41   int      _dimension;         // This is n'th-dimensional array.
 42   ObjArrayKlass* volatile _higher_dimension;  // Refers the (n+1)'th-dimensional array (if present).
 43   ArrayKlass* volatile    _lower_dimension;   // Refers the (n-1)'th-dimensional array (if present).
 44 
 45  protected:
 46   Klass* _element_klass;            // The klass of the elements of this array type
 47                                     // The element type must be registered for both object arrays
 48                                     // (incl. object arrays with value type elements) and value type
 49                                     // arrays containing flat value types. However, the element
 50                                     // type must not be registered for arrays of primitive types.
 51                                     // TODO: Update the class hierarchy so that element klass appears
 52                                     // only in array that contain non-primitive types.
 53   // Constructors
 54   // The constructor with the Symbol argument does the real array
 55   // initialization, the other is a dummy
 56   ArrayKlass(Symbol* name, KlassKind kind, markWord prototype_header = markWord::prototype());
 57   ArrayKlass();
 58 
 59   // Create array_name for element klass
 60   static Symbol* create_element_klass_array_name(Klass* element_klass, TRAPS);
 61 
 62   void* operator new(size_t size, ClassLoaderData* loader_data, size_t word_size, TRAPS) throw();
 63 
 64  public:
 65   // Instance variables
 66   virtual Klass* element_klass() const      { return _element_klass; }
 67   virtual void set_element_klass(Klass* k)  { _element_klass = k; }
 68 
 69   // Compiler/Interpreter offset
 70   static ByteSize element_klass_offset() { return in_ByteSize(offset_of(ArrayKlass, _element_klass)); }
 71 
 72   // Testing operation
 73   DEBUG_ONLY(bool is_array_klass_slow() const { return true; })
 74 
 75   // Returns the ObjArrayKlass for n'th dimension.
 76   ArrayKlass* array_klass(int n, TRAPS);
 77   ArrayKlass* array_klass_or_null(int n);
 78 
 79   // Returns the array class with this class as element type.
 80   ArrayKlass* array_klass(TRAPS);
 81   ArrayKlass* array_klass_or_null();
 82 
 83   // Instance variables
 84   int dimension() const                 { return _dimension;      }
 85   void set_dimension(int dimension)     { _dimension = dimension; }
 86 
 87   ObjArrayKlass* higher_dimension() const     { return _higher_dimension; }
 88   inline ObjArrayKlass* higher_dimension_acquire() const; // load with acquire semantics
 89   void set_higher_dimension(ObjArrayKlass* k) { _higher_dimension = k; }
 90   inline void release_set_higher_dimension(ObjArrayKlass* k); // store with release semantics
 91 

110   Klass* find_field(Symbol* name, Symbol* sig, fieldDescriptor* fd) const;
111 
112   // Lookup operations
113   Method* uncached_lookup_method(const Symbol* name,
114                                  const Symbol* signature,
115                                  OverpassLookupMode overpass_mode,
116                                  PrivateLookupMode private_mode = PrivateLookupMode::find) const;
117 
118   static ArrayKlass* cast(Klass* k) {
119     return const_cast<ArrayKlass*>(cast(const_cast<const Klass*>(k)));
120   }
121 
122   static const ArrayKlass* cast(const Klass* k) {
123     assert(k->is_array_klass(), "cast to ArrayKlass");
124     return static_cast<const ArrayKlass*>(k);
125   }
126 
127   GrowableArray<Klass*>* compute_secondary_supers(int num_extra_slots,
128                                                   Array<InstanceKlass*>* transitive_interfaces);
129 
130   oop component_mirror() const;
131 
132   // Sizing
133   static int static_size(int header_size);
134 
135   virtual void metaspace_pointers_do(MetaspaceClosure* iter);
136 
137   // Return a handle.
138   static void     complete_create_array_klass(ArrayKlass* k, Klass* super_klass, ModuleEntry* module, TRAPS);
139 
140   // JVMTI support
141   jint jvmti_class_status() const;
142 
143 #if INCLUDE_CDS
144   // CDS support - remove and restore oops from metadata. Oops are not shared.
145   virtual void remove_unshareable_info();
146   virtual void remove_java_mirror();
147   void restore_unshareable_info(ClassLoaderData* loader_data, Handle protection_domain, TRAPS);
148   void cds_print_value_on(outputStream* st) const;
149 #endif
150 
151   void log_array_class_load(Klass* k);
< prev index next >