1 /*
2  * Copyright (c) 1997, 2018, 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_ARRAYKLASS_HPP
26 #define SHARE_VM_OOPS_ARRAYKLASS_HPP
27 
28 #include "memory/universe.hpp"
29 #include "oops/klass.hpp"
30 
31 class fieldDescriptor;
32 class klassVtable;
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   Klass* volatile _higher_dimension;  // Refers the (n+1)'th-dimensional array (if present).
43   Klass* 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, KlassID id);
ArrayKlass()50   ArrayKlass() { assert(DumpSharedSpaces || UseSharedSpaces, "only for cds"); }
51 
52  public:
53   // Testing operation
DEBUG_ONLY(bool is_array_klass_slow ()const{ return true; })54   DEBUG_ONLY(bool is_array_klass_slow() const { return true; })
55 
56   // Instance variables
57   int dimension() const                 { return _dimension;      }
set_dimension(int dimension)58   void set_dimension(int dimension)     { _dimension = dimension; }
59 
higher_dimension() const60   Klass* higher_dimension() const     { return _higher_dimension; }
61   inline Klass* higher_dimension_acquire() const; // load with acquire semantics
set_higher_dimension(Klass * k)62   void set_higher_dimension(Klass* k) { _higher_dimension = k; }
63   inline void release_set_higher_dimension(Klass* k); // store with release semantics
adr_higher_dimension()64   Klass** adr_higher_dimension()      { return (Klass**)&this->_higher_dimension;}
65 
lower_dimension() const66   Klass* lower_dimension() const      { return _lower_dimension; }
set_lower_dimension(Klass * k)67   void set_lower_dimension(Klass* k)  { _lower_dimension = k; }
adr_lower_dimension()68   Klass** adr_lower_dimension()       { return (Klass**)&this->_lower_dimension;}
69 
70   // offset of first element, including any padding for the sake of alignment
array_header_in_bytes() const71   int  array_header_in_bytes() const    { return layout_helper_header_size(layout_helper()); }
log2_element_size() const72   int  log2_element_size() const        { return layout_helper_log2_element_size(layout_helper()); }
73   // type of elements (T_OBJECT for both oop arrays and array-arrays)
element_type() const74   BasicType element_type() const        { return layout_helper_element_type(layout_helper()); }
75 
76   virtual Klass* java_super() const;//{ return SystemDictionary::Object_klass(); }
77 
78   // Allocation
79   // Sizes points to the first dimension of the array, subsequent dimensions
80   // are always in higher memory.  The callers of these set that up.
81   virtual oop multi_allocate(int rank, jint* sizes, TRAPS);
82   objArrayOop allocate_arrayArray(int n, int length, TRAPS);
83 
84   // find field according to JVM spec 5.4.3.2, returns the klass in which the field is defined
85   Klass* find_field(Symbol* name, Symbol* sig, fieldDescriptor* fd) const;
86 
87   // Lookup operations
88   Method* uncached_lookup_method(const Symbol* name,
89                                  const Symbol* signature,
90                                  OverpassLookupMode overpass_mode,
91                                  PrivateLookupMode private_mode = find_private) const;
92 
cast(Klass * k)93   static ArrayKlass* cast(Klass* k) {
94     return const_cast<ArrayKlass*>(cast(const_cast<const Klass*>(k)));
95   }
96 
cast(const Klass * k)97   static const ArrayKlass* cast(const Klass* k) {
98     assert(k->is_array_klass(), "cast to ArrayKlass");
99     return static_cast<const ArrayKlass*>(k);
100   }
101 
102   GrowableArray<Klass*>* compute_secondary_supers(int num_extra_slots,
103                                                   Array<Klass*>* transitive_interfaces);
104   bool compute_is_subtype_of(Klass* k);
105 
106   // Sizing
107   static int static_size(int header_size);
108 
109   virtual void metaspace_pointers_do(MetaspaceClosure* iter);
110 
111 #if INCLUDE_SERVICES
collect_statistics(KlassSizeStats * sz) const112   virtual void collect_statistics(KlassSizeStats *sz) const {
113     Klass::collect_statistics(sz);
114     // Do nothing for now, but remember to modify if you add new
115     // stuff to ArrayKlass.
116   }
117 #endif
118 
119   // Iterators
120   void array_klasses_do(void f(Klass* k));
121   void array_klasses_do(void f(Klass* k, TRAPS), TRAPS);
122 
123   // Return a handle.
124   static void     complete_create_array_klass(ArrayKlass* k, Klass* super_klass, ModuleEntry* module, TRAPS);
125 
126 
127   // jvm support
128   jint compute_modifier_flags(TRAPS) const;
129 
130   // JVMTI support
131   jint jvmti_class_status() const;
132 
133   // CDS support - remove and restore oops from metadata. Oops are not shared.
134   virtual void remove_unshareable_info();
135   virtual void remove_java_mirror();
136   virtual void restore_unshareable_info(ClassLoaderData* loader_data, Handle protection_domain, TRAPS);
137 
138   // Printing
139   void print_on(outputStream* st) const;
140   void print_value_on(outputStream* st) const;
141 
142   void oop_print_on(oop obj, outputStream* st);
143 
144   // Verification
145   void verify_on(outputStream* st);
146 
147   void oop_verify_on(oop obj, outputStream* st);
148 };
149 
150 #endif // SHARE_VM_OOPS_ARRAYKLASS_HPP
151