1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
|
/*
* Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*
*/
#ifndef SHARE_VM_OOPS_TYPEARRAYKLASS_HPP
#define SHARE_VM_OOPS_TYPEARRAYKLASS_HPP
#include "oops/arrayKlass.hpp"
// A typeArrayKlass is the klass of a typeArray
// It contains the type and size of the elements
class typeArrayKlass : public arrayKlass {
friend class VMStructs;
private:
jint _max_length; // maximum number of elements allowed in an array
public:
// instance variables
jint max_length() { return _max_length; }
void set_max_length(jint m) { _max_length = m; }
// testers
bool oop_is_typeArray_slow() const { return true; }
// klass allocation
DEFINE_ALLOCATE_PERMANENT(typeArrayKlass);
static klassOop create_klass(BasicType type, int scale, const char* name_str,
TRAPS);
static inline klassOop create_klass(BasicType type, int scale, TRAPS) {
return create_klass(type, scale, external_name(type), CHECK_NULL);
}
int oop_size(oop obj) const;
int klass_oop_size() const { return object_size(); }
bool compute_is_subtype_of(klassOop k);
// Allocation
typeArrayOop allocate(int length, TRAPS);
typeArrayOop allocate_permanent(int length, TRAPS); // used for class file structures
oop multi_allocate(int rank, jint* sizes, TRAPS);
// Copying
void copy_array(arrayOop s, int src_pos, arrayOop d, int dst_pos, int length, TRAPS);
// Iteration
int oop_oop_iterate(oop obj, OopClosure* blk);
int oop_oop_iterate_m(oop obj, OopClosure* blk, MemRegion mr);
// Garbage collection
void oop_follow_contents(oop obj);
int oop_adjust_pointers(oop obj);
// Parallel Scavenge and Parallel Old
PARALLEL_GC_DECLS
protected:
// Find n'th dimensional array
virtual klassOop array_klass_impl(bool or_null, int n, TRAPS);
// Returns the array class with this class as element type
virtual klassOop array_klass_impl(bool or_null, TRAPS);
public:
// Casting from klassOop
static typeArrayKlass* cast(klassOop k) {
assert(k->klass_part()->oop_is_typeArray_slow(), "cast to typeArrayKlass");
return (typeArrayKlass*) k->klass_part();
}
// Naming
static const char* external_name(BasicType type);
// Sizing
static int header_size() { return oopDesc::header_size() + sizeof(typeArrayKlass)/HeapWordSize; }
int object_size() const { return arrayKlass::object_size(header_size()); }
// Initialization (virtual from Klass)
void initialize(TRAPS);
private:
// Helpers
static klassOop array_klass_impl(typeArrayKlassHandle h_this, bool or_null, int n, TRAPS);
#ifndef PRODUCT
public:
// Printing
void oop_print_on(oop obj, outputStream* st);
#endif
public:
const char* internal_name() const;
};
#endif // SHARE_VM_OOPS_TYPEARRAYKLASS_HPP
|