1 /*
2  * Copyright (c) 1997, 2013, 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  private:
37   jint _max_length;            // maximum number of elements allowed in an array
38 
39   // Constructor
40   TypeArrayKlass(BasicType type, Symbol* name);
41   static TypeArrayKlass* allocate(ClassLoaderData* loader_data, BasicType type, Symbol* name, TRAPS);
42  public:
TypeArrayKlass()43   TypeArrayKlass() {} // For dummy objects.
44 
45   // instance variables
max_length()46   jint max_length()                     { return _max_length; }
set_max_length(jint m)47   void set_max_length(jint m)           { _max_length = m;    }
48 
49   // testers
oop_is_typeArray_slow() const50   bool oop_is_typeArray_slow() const    { return true; }
51 
52   // klass allocation
53   static TypeArrayKlass* create_klass(BasicType type, const char* name_str,
54                                TRAPS);
create_klass(BasicType type,int scale,TRAPS)55   static inline Klass* create_klass(BasicType type, int scale, TRAPS) {
56     TypeArrayKlass* tak = create_klass(type, external_name(type), CHECK_NULL);
57     assert(scale == (1 << tak->log2_element_size()), "scale must check out");
58     return tak;
59   }
60 
61   int oop_size(oop obj) const;
62 
63   bool compute_is_subtype_of(Klass* k);
64 
65   // Allocation
66   typeArrayOop allocate_common(int length, bool do_zero, TRAPS);
allocate(int length,TRAPS)67   typeArrayOop allocate(int length, TRAPS) { return allocate_common(length, true, THREAD); }
68   oop multi_allocate(int rank, jint* sizes, TRAPS);
69 
protection_domain() const70   oop protection_domain() const { return NULL; }
71 
72   // Copying
73   void  copy_array(arrayOop s, int src_pos, arrayOop d, int dst_pos, int length, TRAPS);
74 
75   // Iteration
76   int oop_oop_iterate(oop obj, ExtendedOopClosure* blk);
77   int oop_oop_iterate_m(oop obj, ExtendedOopClosure* blk, MemRegion mr);
78 
79   // Garbage collection
80   void oop_follow_contents(oop obj);
81   int  oop_adjust_pointers(oop obj);
82 
83   // Parallel Scavenge and Parallel Old
84   PARALLEL_GC_DECLS
85 
86  protected:
87   // Find n'th dimensional array
88   virtual Klass* array_klass_impl(bool or_null, int n, TRAPS);
89 
90   // Returns the array class with this class as element type
91   virtual Klass* array_klass_impl(bool or_null, TRAPS);
92 
93  public:
94   // Casting from Klass*
cast(Klass * k)95   static TypeArrayKlass* cast(Klass* k) {
96     assert(k->oop_is_typeArray(), "cast to TypeArrayKlass");
97     return (TypeArrayKlass*) k;
98   }
99 
100   // Naming
101   static const char* external_name(BasicType type);
102 
103   // Sizing
header_size()104   static int header_size()  { return sizeof(TypeArrayKlass)/HeapWordSize; }
size() const105   int size() const          { return ArrayKlass::static_size(header_size()); }
106 
107   // Initialization (virtual from Klass)
108   void initialize(TRAPS);
109 
110  public:
111   // Printing
112 #ifndef PRODUCT
113   void oop_print_on(oop obj, outputStream* st);
114 #endif
115 
116   void print_on(outputStream* st) const;
117   void print_value_on(outputStream* st) const;
118 
119  public:
120   const char* internal_name() const;
121 };
122 
123 #endif // SHARE_VM_OOPS_TYPEARRAYKLASS_HPP
124