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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
|
/*
* Copyright 1999-2007 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
* CA 95054 USA or visit www.sun.com if you need additional information or
* have any questions.
*
*/
// ciInstanceKlass
//
// This class represents a klassOop in the HotSpot virtual machine
// whose Klass part is an instanceKlass. It may or may not
// be loaded.
class ciInstanceKlass : public ciKlass {
CI_PACKAGE_ACCESS
friend class ciEnv;
friend class ciMethod;
friend class ciField;
friend class ciBytecodeStream;
private:
bool _is_shared;
jobject _loader;
jobject _protection_domain;
bool _is_initialized;
bool _is_linked;
bool _has_finalizer;
bool _has_subklass;
ciFlags _flags;
jint _nonstatic_field_size;
jint _nonstatic_oop_map_size;
// Lazy fields get filled in only upon request.
ciInstanceKlass* _super;
ciInstance* _java_mirror;
ciConstantPoolCache* _field_cache; // cached map index->field
GrowableArray<ciField*>* _nonstatic_fields;
enum { implementors_limit = instanceKlass::implementors_limit };
ciInstanceKlass* _implementors[implementors_limit];
jint _nof_implementors;
GrowableArray<ciField*>* _non_static_fields;
protected:
ciInstanceKlass(KlassHandle h_k);
ciInstanceKlass(ciSymbol* name, jobject loader, jobject protection_domain);
instanceKlass* get_instanceKlass() const {
return (instanceKlass*)get_Klass();
}
oop loader();
jobject loader_handle();
oop protection_domain();
jobject protection_domain_handle();
const char* type_string() { return "ciInstanceKlass"; }
void print_impl(outputStream* st);
ciConstantPoolCache* field_cache();
bool is_shared() { return _is_shared; }
bool compute_shared_is_initialized();
bool compute_shared_is_linked();
bool compute_shared_has_subklass();
int compute_shared_nof_implementors();
int compute_nonstatic_fields();
GrowableArray<ciField*>* compute_nonstatic_fields_impl(GrowableArray<ciField*>* super_fields);
public:
// Has this klass been initialized?
bool is_initialized() {
if (_is_shared && !_is_initialized) {
return is_loaded() && compute_shared_is_initialized();
}
return _is_initialized;
}
// Has this klass been linked?
bool is_linked() {
if (_is_shared && !_is_linked) {
return is_loaded() && compute_shared_is_linked();
}
return _is_linked;
}
// General klass information.
ciFlags flags() {
assert(is_loaded(), "must be loaded");
return _flags;
}
bool has_finalizer() {
assert(is_loaded(), "must be loaded");
return _has_finalizer; }
bool has_subklass() {
assert(is_loaded(), "must be loaded");
if (_is_shared && !_has_subklass) {
if (flags().is_final()) {
return false;
} else {
return compute_shared_has_subklass();
}
}
return _has_subklass;
}
jint size_helper() {
return (Klass::layout_helper_size_in_bytes(layout_helper())
>> LogHeapWordSize);
}
jint nonstatic_field_size() {
assert(is_loaded(), "must be loaded");
return _nonstatic_field_size; }
jint nonstatic_oop_map_size() {
assert(is_loaded(), "must be loaded");
return _nonstatic_oop_map_size; }
ciInstanceKlass* super();
jint nof_implementors() {
assert(is_loaded(), "must be loaded");
if (_is_shared) return compute_shared_nof_implementors();
return _nof_implementors;
}
ciInstanceKlass* get_canonical_holder(int offset);
ciField* get_field_by_offset(int field_offset, bool is_static);
GrowableArray<ciField*>* non_static_fields();
// total number of nonstatic fields (including inherited):
int nof_nonstatic_fields() {
if (_nonstatic_fields == NULL)
return compute_nonstatic_fields();
else
return _nonstatic_fields->length();
}
// nth nonstatic field (presented by ascending address)
ciField* nonstatic_field_at(int i) {
assert(_nonstatic_fields != NULL, "");
return _nonstatic_fields->at(i);
}
ciInstanceKlass* unique_concrete_subklass();
bool has_finalizable_subclass();
bool contains_field_offset(int offset) {
return (offset/wordSize) >= instanceOopDesc::header_size()
&& (offset/wordSize)-instanceOopDesc::header_size() < nonstatic_field_size();
}
// Get the instance of java.lang.Class corresponding to
// this klass. This instance is used for locking of
// synchronized static methods of this klass.
ciInstance* java_mirror();
// Java access flags
bool is_public () { return flags().is_public(); }
bool is_final () { return flags().is_final(); }
bool is_super () { return flags().is_super(); }
bool is_interface () { return flags().is_interface(); }
bool is_abstract () { return flags().is_abstract(); }
ciMethod* find_method(ciSymbol* name, ciSymbol* signature);
// Note: To find a method from name and type strings, use ciSymbol::make,
// but consider adding to vmSymbols.hpp instead.
bool is_leaf_type();
ciInstanceKlass* implementor(int n);
// Is the defining class loader of this class the default loader?
bool uses_default_loader();
bool is_java_lang_Object();
// What kind of ciObject is this?
bool is_instance_klass() { return true; }
bool is_java_klass() { return true; }
};
|
