1 /*
2  * Copyright (c) 1997, 2017, 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_TYPEARRAYKLASS_HPP
26 #define SHARE_VM_OOPS_TYPEARRAYKLASS_HPP
27 
28 #include "classfile/classLoaderData.hpp"
29 #include "oops/arrayKlass.hpp"
30 
31 // A TypeArrayKlass is the klass of a typeArray
32 // It contains the type and size of the elements
33 
34 class TypeArrayKlass : public ArrayKlass {
35   friend class VMStructs;
36 
37  public:
38   static const KlassID ID = TypeArrayKlassID;
39 
40  private:
41   jint _max_length;            // maximum number of elements allowed in an array
42 
43   // Constructor
44   TypeArrayKlass(BasicType type, Symbol* name);
45   static TypeArrayKlass* allocate(ClassLoaderData* loader_data, BasicType type, Symbol* name, TRAPS);
46  public:
TypeArrayKlass()47   TypeArrayKlass() {} // For dummy objects.
48 
49   // instance variables
max_length()50   jint max_length()                     { return _max_length; }
set_max_length(jint m)51   void set_max_length(jint m)           { _max_length = m;    }
52 
53   // testers
54   DEBUG_ONLY(bool is_typeArray_klass_slow() const  { return true; })
55 
56   // klass allocation
57   static TypeArrayKlass* create_klass(BasicType type, const char* name_str,
58                                TRAPS);
create_klass(BasicType type,int scale,TRAPS)59   static inline Klass* create_klass(BasicType type, int scale, TRAPS) {
60     TypeArrayKlass* tak = create_klass(type, external_name(type), CHECK_NULL);
61     assert(scale == (1 << tak->log2_element_size()), "scale must check out");
62     return tak;
63   }
64 
65   int oop_size(oop obj) const;
66 
67   bool compute_is_subtype_of(Klass* k);
68 
69   // Allocation
70   typeArrayOop allocate_common(int length, bool do_zero, TRAPS);
allocate(int length,TRAPS)71   typeArrayOop allocate(int length, TRAPS) { return allocate_common(length, true, THREAD); }
72   oop multi_allocate(int rank, jint* sizes, TRAPS);
73 
protection_domain() const74   oop protection_domain() const { return NULL; }
75 
76   // Copying
77   void  copy_array(arrayOop s, int src_pos, arrayOop d, int dst_pos, int length, TRAPS);
78 
79   // GC specific object visitors
80   //
81 #if INCLUDE_PARALLELGC
82   // Parallel Scavenge
83   void oop_ps_push_contents(  oop obj, PSPromotionManager* pm);
84   // Parallel Compact
85   void oop_pc_follow_contents(oop obj, ParCompactionManager* cm);
86   void oop_pc_update_pointers(oop obj, ParCompactionManager* cm);
87 #endif
88 
89   // Oop iterators. Since there are no oops in TypeArrayKlasses,
90   // these functions only return the size of the object.
91 
92  private:
93   // The implementation used by all oop_oop_iterate functions in TypeArrayKlasses.
94   inline void oop_oop_iterate_impl(oop obj, OopIterateClosure* closure);
95 
96  public:
97   // Wraps oop_oop_iterate_impl to conform to macros.
98   template <typename T, typename OopClosureType>
99   inline void oop_oop_iterate(oop obj, OopClosureType* closure);
100 
101   // Wraps oop_oop_iterate_impl to conform to macros.
102   template <typename T, typename OopClosureType>
103   inline void oop_oop_iterate_bounded(oop obj, OopClosureType* closure, MemRegion mr);
104 
105   // Wraps oop_oop_iterate_impl to conform to macros.
106   template <typename T, typename OopClosureType>
107   inline void oop_oop_iterate_reverse(oop obj, OopClosureType* closure);
108 
109  protected:
110   // Find n'th dimensional array
111   virtual Klass* array_klass_impl(bool or_null, int n, TRAPS);
112 
113   // Returns the array class with this class as element type
114   virtual Klass* array_klass_impl(bool or_null, TRAPS);
115 
116  public:
cast(Klass * k)117   static TypeArrayKlass* cast(Klass* k) {
118     return const_cast<TypeArrayKlass*>(cast(const_cast<const Klass*>(k)));
119   }
120 
cast(const Klass * k)121   static const TypeArrayKlass* cast(const Klass* k) {
122     assert(k->is_typeArray_klass(), "cast to TypeArrayKlass");
123     return static_cast<const TypeArrayKlass*>(k);
124   }
125 
126   // Naming
127   static const char* external_name(BasicType type);
128 
129   // Sizing
header_size()130   static int header_size()  { return sizeof(TypeArrayKlass)/wordSize; }
size() const131   int size() const          { return ArrayKlass::static_size(header_size()); }
132 
133   // Initialization (virtual from Klass)
134   void initialize(TRAPS);
135 
136  public:
137   // Printing
138 #ifndef PRODUCT
139   void oop_print_on(oop obj, outputStream* st);
140 #endif
141 
142   void print_on(outputStream* st) const;
143   void print_value_on(outputStream* st) const;
144 
145  public:
146   const char* internal_name() const;
147 
148   ModuleEntry* module() const;
149   PackageEntry* package() const;
150 };
151 
152 #endif // SHARE_VM_OOPS_TYPEARRAYKLASS_HPP
153