Mercurial > hg > truffle
annotate src/share/vm/oops/instanceKlass.hpp @ 4710:41406797186b
7113012: G1: rename not-fully-young GCs as "mixed"
Summary: Renamed partially-young GCs as mixed and fully-young GCs as young. Change all external output that includes those terms (GC log and GC ergo log) as well as any comments, fields, methods, etc. The changeset also includes very minor code tidying up (added some curly brackets).
Reviewed-by: johnc, brutisso
author | tonyp |
---|---|
date | Fri, 16 Dec 2011 02:14:27 -0500 |
parents | f6f3bb0ee072 |
children | 04b9a2566eec 75c0a73eee98 069ab3f976d3 |
rev | line source |
---|---|
0 | 1 /* |
2227 | 2 * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved. |
0 | 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 * | |
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1155
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1155
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1155
diff
changeset
|
21 * questions. |
0 | 22 * |
23 */ | |
24 | |
1972 | 25 #ifndef SHARE_VM_OOPS_INSTANCEKLASS_HPP |
26 #define SHARE_VM_OOPS_INSTANCEKLASS_HPP | |
27 | |
28 #include "oops/constMethodOop.hpp" | |
29 #include "oops/constantPoolOop.hpp" | |
3938 | 30 #include "oops/fieldInfo.hpp" |
1972 | 31 #include "oops/instanceOop.hpp" |
32 #include "oops/klassOop.hpp" | |
33 #include "oops/klassVtable.hpp" | |
34 #include "oops/objArrayOop.hpp" | |
35 #include "runtime/handles.hpp" | |
36 #include "runtime/os.hpp" | |
37 #include "utilities/accessFlags.hpp" | |
38 #include "utilities/bitMap.inline.hpp" | |
39 | |
0 | 40 // An instanceKlass is the VM level representation of a Java class. |
41 // It contains all information needed for at class at execution runtime. | |
42 | |
43 // instanceKlass layout: | |
44 // [header ] klassOop | |
45 // [klass pointer ] klassOop | |
46 // [C++ vtbl pointer ] Klass | |
47 // [subtype cache ] Klass | |
48 // [instance size ] Klass | |
49 // [java mirror ] Klass | |
50 // [super ] Klass | |
51 // [access_flags ] Klass | |
52 // [name ] Klass | |
53 // [first subklass ] Klass | |
54 // [next sibling ] Klass | |
55 // [array klasses ] | |
56 // [methods ] | |
57 // [local interfaces ] | |
58 // [transitive interfaces ] | |
59 // [number of implementors ] | |
60 // [implementors ] klassOop[2] | |
61 // [fields ] | |
62 // [constants ] | |
63 // [class loader ] | |
64 // [protection domain ] | |
65 // [signers ] | |
66 // [source file name ] | |
67 // [inner classes ] | |
68 // [static field size ] | |
69 // [nonstatic field size ] | |
70 // [static oop fields size ] | |
71 // [nonstatic oop maps size ] | |
72 // [has finalize method ] | |
73 // [deoptimization mark bit ] | |
74 // [initialization state ] | |
75 // [initializing thread ] | |
76 // [Java vtable length ] | |
77 // [oop map cache (stack maps) ] | |
78 // [EMBEDDED Java vtable ] size in words = vtable_len | |
79 // [EMBEDDED nonstatic oop-map blocks] size in words = nonstatic_oop_map_size | |
80 // | |
81 // The embedded nonstatic oop-map blocks are short pairs (offset, length) indicating | |
82 // where oops are located in instances of this klass. | |
83 | |
84 | |
85 // forward declaration for class -- see below for definition | |
86 class SuperTypeClosure; | |
87 class JNIid; | |
88 class jniIdMapBase; | |
89 class BreakpointInfo; | |
90 class fieldDescriptor; | |
91 class DepChange; | |
92 class nmethodBucket; | |
93 class PreviousVersionNode; | |
94 class JvmtiCachedClassFieldMap; | |
95 | |
96 // This is used in iterators below. | |
97 class FieldClosure: public StackObj { | |
98 public: | |
99 virtual void do_field(fieldDescriptor* fd) = 0; | |
100 }; | |
101 | |
102 #ifndef PRODUCT | |
103 // Print fields. | |
104 // If "obj" argument to constructor is NULL, prints static fields, otherwise prints non-static fields. | |
105 class FieldPrinter: public FieldClosure { | |
106 oop _obj; | |
107 outputStream* _st; | |
108 public: | |
109 FieldPrinter(outputStream* st, oop obj = NULL) : _obj(obj), _st(st) {} | |
110 void do_field(fieldDescriptor* fd); | |
111 }; | |
112 #endif // !PRODUCT | |
113 | |
938 | 114 // ValueObjs embedded in klass. Describes where oops are located in instances of |
115 // this klass. | |
116 class OopMapBlock VALUE_OBJ_CLASS_SPEC { | |
117 public: | |
118 // Byte offset of the first oop mapped by this block. | |
939
9eebd3ac74cf
6845368: large objects cause a crash or unexpected exception
jcoomes
parents:
938
diff
changeset
|
119 int offset() const { return _offset; } |
9eebd3ac74cf
6845368: large objects cause a crash or unexpected exception
jcoomes
parents:
938
diff
changeset
|
120 void set_offset(int offset) { _offset = offset; } |
938 | 121 |
122 // Number of oops in this block. | |
939
9eebd3ac74cf
6845368: large objects cause a crash or unexpected exception
jcoomes
parents:
938
diff
changeset
|
123 uint count() const { return _count; } |
9eebd3ac74cf
6845368: large objects cause a crash or unexpected exception
jcoomes
parents:
938
diff
changeset
|
124 void set_count(uint count) { _count = count; } |
938 | 125 |
126 // sizeof(OopMapBlock) in HeapWords. | |
127 static const int size_in_words() { | |
128 return align_size_up(int(sizeof(OopMapBlock)), HeapWordSize) >> | |
129 LogHeapWordSize; | |
130 } | |
131 | |
132 private: | |
939
9eebd3ac74cf
6845368: large objects cause a crash or unexpected exception
jcoomes
parents:
938
diff
changeset
|
133 int _offset; |
9eebd3ac74cf
6845368: large objects cause a crash or unexpected exception
jcoomes
parents:
938
diff
changeset
|
134 uint _count; |
938 | 135 }; |
136 | |
0 | 137 class instanceKlass: public Klass { |
138 friend class VMStructs; | |
139 public: | |
140 // See "The Java Virtual Machine Specification" section 2.16.2-5 for a detailed description | |
141 // of the class loading & initialization procedure, and the use of the states. | |
142 enum ClassState { | |
143 unparsable_by_gc = 0, // object is not yet parsable by gc. Value of _init_state at object allocation. | |
144 allocated, // allocated (but not yet linked) | |
145 loaded, // loaded and inserted in class hierarchy (but not linked yet) | |
146 linked, // successfully linked/verified (but not initialized yet) | |
147 being_initialized, // currently running class initializer | |
148 fully_initialized, // initialized (successfull final state) | |
149 initialization_error // error happened during initialization | |
150 }; | |
151 | |
152 public: | |
153 oop* oop_block_beg() const { return adr_array_klasses(); } | |
154 oop* oop_block_end() const { return adr_methods_default_annotations() + 1; } | |
155 | |
156 enum { | |
157 implementors_limit = 2 // how many implems can we track? | |
158 }; | |
159 | |
160 protected: | |
161 // | |
162 // The oop block. See comment in klass.hpp before making changes. | |
163 // | |
164 | |
165 // Array classes holding elements of this class. | |
166 klassOop _array_klasses; | |
167 // Method array. | |
168 objArrayOop _methods; | |
169 // Int array containing the original order of method in the class file (for | |
170 // JVMTI). | |
171 typeArrayOop _method_ordering; | |
172 // Interface (klassOops) this class declares locally to implement. | |
173 objArrayOop _local_interfaces; | |
174 // Interface (klassOops) this class implements transitively. | |
175 objArrayOop _transitive_interfaces; | |
176 // Instance and static variable information, 5-tuples of shorts [access, name | |
177 // index, sig index, initval index, offset]. | |
178 typeArrayOop _fields; | |
179 // Constant pool for this class. | |
180 constantPoolOop _constants; | |
181 // Class loader used to load this class, NULL if VM loader used. | |
182 oop _class_loader; | |
183 // Protection domain. | |
184 oop _protection_domain; | |
431
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
185 // Host class, which grants its access privileges to this class also. |
2416
38fea01eb669
6817525: turn on method handle functionality by default for JSR 292
twisti
parents:
2376
diff
changeset
|
186 // This is only non-null for an anonymous class (JSR 292 enabled). |
431
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
187 // The host class is either named, or a previously loaded anonymous class. |
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
188 klassOop _host_klass; |
0 | 189 // Class signers. |
190 objArrayOop _signers; | |
191 // inner_classes attribute. | |
192 typeArrayOop _inner_classes; | |
193 // Implementors of this interface (not valid if it overflows) | |
194 klassOop _implementors[implementors_limit]; | |
195 // Annotations for this class, or null if none. | |
196 typeArrayOop _class_annotations; | |
197 // Annotation objects (byte arrays) for fields, or null if no annotations. | |
198 // Indices correspond to entries (not indices) in fields array. | |
199 objArrayOop _fields_annotations; | |
200 // Annotation objects (byte arrays) for methods, or null if no annotations. | |
201 // Index is the idnum, which is initially the same as the methods array index. | |
202 objArrayOop _methods_annotations; | |
203 // Annotation objects (byte arrays) for methods' parameters, or null if no | |
204 // such annotations. | |
205 // Index is the idnum, which is initially the same as the methods array index. | |
206 objArrayOop _methods_parameter_annotations; | |
207 // Annotation objects (byte arrays) for methods' default values, or null if no | |
208 // such annotations. | |
209 // Index is the idnum, which is initially the same as the methods array index. | |
210 objArrayOop _methods_default_annotations; | |
211 | |
212 // | |
213 // End of the oop block. | |
214 // | |
215 | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
216 // Name of source file containing this klass, NULL if not specified. |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
217 Symbol* _source_file_name; |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
218 // the source debug extension for this klass, NULL if not specified. |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
219 Symbol* _source_debug_extension; |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
220 // Generic signature, or null if none. |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
221 Symbol* _generic_signature; |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
222 // Array name derived from this class which needs unreferencing |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
223 // if this class is unloaded. |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
224 Symbol* _array_name; |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
225 |
165
437d03ea40b1
6703888: Compressed Oops: use the 32-bits gap after klass in a object
kvn
parents:
113
diff
changeset
|
226 // Number of heapOopSize words used by non-static fields in this klass |
437d03ea40b1
6703888: Compressed Oops: use the 32-bits gap after klass in a object
kvn
parents:
113
diff
changeset
|
227 // (including inherited fields but after header_size()). |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
49
diff
changeset
|
228 int _nonstatic_field_size; |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
49
diff
changeset
|
229 int _static_field_size; // number words used by static fields (oop and non-oop) in this klass |
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2357
diff
changeset
|
230 int _static_oop_field_count;// number of static oop fields in this klass |
938 | 231 int _nonstatic_oop_map_size;// size in words of nonstatic oop map blocks |
3938 | 232 int _java_fields_count; // The number of declared Java fields |
975 | 233 bool _is_marked_dependent; // used for marking during flushing and deoptimization |
234 bool _rewritten; // methods rewritten. | |
235 bool _has_nonstatic_fields; // for sizing with UseCompressedOops | |
236 bool _should_verify_class; // allow caching of preverification | |
0 | 237 u2 _minor_version; // minor version number of class file |
238 u2 _major_version; // major version number of class file | |
239 ClassState _init_state; // state of class | |
240 Thread* _init_thread; // Pointer to current thread doing initialization (to handle recusive initialization) | |
241 int _vtable_len; // length of Java vtable (in words) | |
242 int _itable_len; // length of Java itable (in words) | |
243 ReferenceType _reference_type; // reference type | |
244 OopMapCache* volatile _oop_map_cache; // OopMapCache for all methods in the klass (allocated lazily) | |
245 JNIid* _jni_ids; // First JNI identifier for static fields in this class | |
246 jmethodID* _methods_jmethod_ids; // jmethodIDs corresponding to method_idnum, or NULL if none | |
247 int* _methods_cached_itable_indices; // itable_index cache for JNI invoke corresponding to methods idnum, or NULL | |
248 nmethodBucket* _dependencies; // list of dependent nmethods | |
249 nmethod* _osr_nmethods_head; // Head of list of on-stack replacement nmethods for this class | |
250 BreakpointInfo* _breakpoints; // bpt lists, managed by methodOop | |
251 int _nof_implementors; // No of implementors of this interface (zero if not an interface) | |
252 // Array of interesting part(s) of the previous version(s) of this | |
253 // instanceKlass. See PreviousVersionWalker below. | |
254 GrowableArray<PreviousVersionNode *>* _previous_versions; | |
255 u2 _enclosing_method_class_index; // Constant pool index for class of enclosing method, or 0 if none | |
256 u2 _enclosing_method_method_index; // Constant pool index for name and type of enclosing method, or 0 if none | |
257 // JVMTI fields can be moved to their own structure - see 6315920 | |
258 unsigned char * _cached_class_file_bytes; // JVMTI: cached class file, before retransformable agent modified it in CFLH | |
259 jint _cached_class_file_len; // JVMTI: length of above | |
260 JvmtiCachedClassFieldMap* _jvmti_cached_class_field_map; // JVMTI: used during heap iteration | |
261 volatile u2 _idnum_allocated_count; // JNI/JVMTI: increments with the addition of methods, old ids don't change | |
262 | |
263 // embedded Java vtable follows here | |
264 // embedded Java itables follows here | |
265 // embedded static fields follows here | |
266 // embedded nonstatic oop-map blocks follows here | |
267 | |
268 friend class instanceKlassKlass; | |
269 friend class SystemDictionary; | |
270 | |
271 public: | |
975 | 272 bool has_nonstatic_fields() const { return _has_nonstatic_fields; } |
273 void set_has_nonstatic_fields(bool b) { _has_nonstatic_fields = b; } | |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
49
diff
changeset
|
274 |
0 | 275 // field sizes |
276 int nonstatic_field_size() const { return _nonstatic_field_size; } | |
277 void set_nonstatic_field_size(int size) { _nonstatic_field_size = size; } | |
278 | |
279 int static_field_size() const { return _static_field_size; } | |
280 void set_static_field_size(int size) { _static_field_size = size; } | |
281 | |
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2357
diff
changeset
|
282 int static_oop_field_count() const { return _static_oop_field_count; } |
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2357
diff
changeset
|
283 void set_static_oop_field_count(int size) { _static_oop_field_count = size; } |
0 | 284 |
285 // Java vtable | |
286 int vtable_length() const { return _vtable_len; } | |
287 void set_vtable_length(int len) { _vtable_len = len; } | |
288 | |
289 // Java itable | |
290 int itable_length() const { return _itable_len; } | |
291 void set_itable_length(int len) { _itable_len = len; } | |
292 | |
293 // array klasses | |
294 klassOop array_klasses() const { return _array_klasses; } | |
295 void set_array_klasses(klassOop k) { oop_store_without_check((oop*) &_array_klasses, (oop) k); } | |
296 | |
297 // methods | |
298 objArrayOop methods() const { return _methods; } | |
299 void set_methods(objArrayOop a) { oop_store_without_check((oop*) &_methods, (oop) a); } | |
300 methodOop method_with_idnum(int idnum); | |
301 | |
302 // method ordering | |
303 typeArrayOop method_ordering() const { return _method_ordering; } | |
304 void set_method_ordering(typeArrayOop m) { oop_store_without_check((oop*) &_method_ordering, (oop) m); } | |
305 | |
306 // interfaces | |
307 objArrayOop local_interfaces() const { return _local_interfaces; } | |
308 void set_local_interfaces(objArrayOop a) { oop_store_without_check((oop*) &_local_interfaces, (oop) a); } | |
309 objArrayOop transitive_interfaces() const { return _transitive_interfaces; } | |
310 void set_transitive_interfaces(objArrayOop a) { oop_store_without_check((oop*) &_transitive_interfaces, (oop) a); } | |
311 | |
3938 | 312 private: |
313 friend class fieldDescriptor; | |
314 FieldInfo* field(int index) const { return FieldInfo::from_field_array(_fields, index); } | |
315 | |
316 public: | |
317 int field_offset (int index) const { return field(index)->offset(); } | |
318 int field_access_flags(int index) const { return field(index)->access_flags(); } | |
319 Symbol* field_name (int index) const { return field(index)->name(constants()); } | |
320 Symbol* field_signature (int index) const { return field(index)->signature(constants()); } | |
321 | |
322 // Number of Java declared fields | |
323 int java_fields_count() const { return _java_fields_count; } | |
324 | |
325 // Number of fields including any injected fields | |
326 int all_fields_count() const { return _fields->length() / sizeof(FieldInfo::field_slots); } | |
0 | 327 |
328 typeArrayOop fields() const { return _fields; } | |
3938 | 329 |
330 void set_fields(typeArrayOop f, int java_fields_count) { | |
331 oop_store_without_check((oop*) &_fields, (oop) f); | |
332 _java_fields_count = java_fields_count; | |
0 | 333 } |
334 | |
335 // inner classes | |
336 typeArrayOop inner_classes() const { return _inner_classes; } | |
337 void set_inner_classes(typeArrayOop f) { oop_store_without_check((oop*) &_inner_classes, (oop) f); } | |
338 | |
339 enum InnerClassAttributeOffset { | |
340 // From http://mirror.eng/products/jdk/1.1/docs/guide/innerclasses/spec/innerclasses.doc10.html#18814 | |
341 inner_class_inner_class_info_offset = 0, | |
342 inner_class_outer_class_info_offset = 1, | |
343 inner_class_inner_name_offset = 2, | |
344 inner_class_access_flags_offset = 3, | |
345 inner_class_next_offset = 4 | |
346 }; | |
347 | |
652
4aaa9f5e02a8
4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents:
431
diff
changeset
|
348 // method override check |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
349 bool is_override(methodHandle super_method, Handle targetclassloader, Symbol* targetclassname, TRAPS); |
652
4aaa9f5e02a8
4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents:
431
diff
changeset
|
350 |
0 | 351 // package |
352 bool is_same_class_package(klassOop class2); | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
353 bool is_same_class_package(oop classloader2, Symbol* classname2); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
354 static bool is_same_class_package(oop class_loader1, Symbol* class_name1, oop class_loader2, Symbol* class_name2); |
0 | 355 |
665
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
431
diff
changeset
|
356 // find an enclosing class (defined where original code was, in jvm.cpp!) |
1126
933a3e806ce6
6895168: JCK api/signaturetest/sigtest.basic.html#basic test fails for jdk 5.0 with HS 16 in nightly build
xlu
parents:
1039
diff
changeset
|
357 klassOop compute_enclosing_class(bool* inner_is_member, TRAPS) { |
665
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
431
diff
changeset
|
358 instanceKlassHandle self(THREAD, this->as_klassOop()); |
1126
933a3e806ce6
6895168: JCK api/signaturetest/sigtest.basic.html#basic test fails for jdk 5.0 with HS 16 in nightly build
xlu
parents:
1039
diff
changeset
|
359 return compute_enclosing_class_impl(self, inner_is_member, THREAD); |
665
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
431
diff
changeset
|
360 } |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
431
diff
changeset
|
361 static klassOop compute_enclosing_class_impl(instanceKlassHandle self, |
1126
933a3e806ce6
6895168: JCK api/signaturetest/sigtest.basic.html#basic test fails for jdk 5.0 with HS 16 in nightly build
xlu
parents:
1039
diff
changeset
|
362 bool* inner_is_member, TRAPS); |
665
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
431
diff
changeset
|
363 |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
431
diff
changeset
|
364 // tell if two classes have the same enclosing class (at package level) |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
431
diff
changeset
|
365 bool is_same_package_member(klassOop class2, TRAPS) { |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
431
diff
changeset
|
366 instanceKlassHandle self(THREAD, this->as_klassOop()); |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
431
diff
changeset
|
367 return is_same_package_member_impl(self, class2, THREAD); |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
431
diff
changeset
|
368 } |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
431
diff
changeset
|
369 static bool is_same_package_member_impl(instanceKlassHandle self, |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
431
diff
changeset
|
370 klassOop class2, TRAPS); |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
431
diff
changeset
|
371 |
0 | 372 // initialization state |
373 bool is_loaded() const { return _init_state >= loaded; } | |
374 bool is_linked() const { return _init_state >= linked; } | |
375 bool is_initialized() const { return _init_state == fully_initialized; } | |
376 bool is_not_initialized() const { return _init_state < being_initialized; } | |
377 bool is_being_initialized() const { return _init_state == being_initialized; } | |
378 bool is_in_error_state() const { return _init_state == initialization_error; } | |
379 bool is_reentrant_initialization(Thread *thread) { return thread == _init_thread; } | |
380 int get_init_state() { return _init_state; } // Useful for debugging | |
975 | 381 bool is_rewritten() const { return _rewritten; } |
973
ad6585fd4087
6830542: Performance: JVM_DefineClass already verified.
acorn
parents:
726
diff
changeset
|
382 |
ad6585fd4087
6830542: Performance: JVM_DefineClass already verified.
acorn
parents:
726
diff
changeset
|
383 // defineClass specified verification |
975 | 384 bool should_verify_class() const { return _should_verify_class; } |
385 void set_should_verify_class(bool value) { _should_verify_class = value; } | |
0 | 386 |
387 // marking | |
975 | 388 bool is_marked_dependent() const { return _is_marked_dependent; } |
389 void set_is_marked_dependent(bool value) { _is_marked_dependent = value; } | |
0 | 390 |
391 // initialization (virtuals from Klass) | |
392 bool should_be_initialized() const; // means that initialize should be called | |
393 void initialize(TRAPS); | |
394 void link_class(TRAPS); | |
395 bool link_class_or_fail(TRAPS); // returns false on failure | |
396 void unlink_class(); | |
397 void rewrite_class(TRAPS); | |
3748 | 398 void relocate_and_link_methods(TRAPS); |
0 | 399 methodOop class_initializer(); |
400 | |
401 // set the class to initialized if no static initializer is present | |
402 void eager_initialize(Thread *thread); | |
403 | |
404 // reference type | |
405 ReferenceType reference_type() const { return _reference_type; } | |
406 void set_reference_type(ReferenceType t) { _reference_type = t; } | |
407 | |
3249
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2376
diff
changeset
|
408 static int reference_type_offset_in_bytes() { return offset_of(instanceKlass, _reference_type); } |
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2376
diff
changeset
|
409 |
0 | 410 // find local field, returns true if found |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
411 bool find_local_field(Symbol* name, Symbol* sig, fieldDescriptor* fd) const; |
0 | 412 // find field in direct superinterfaces, returns the interface in which the field is defined |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
413 klassOop find_interface_field(Symbol* name, Symbol* sig, fieldDescriptor* fd) const; |
0 | 414 // find field according to JVM spec 5.4.3.2, returns the klass in which the field is defined |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
415 klassOop find_field(Symbol* name, Symbol* sig, fieldDescriptor* fd) const; |
0 | 416 // find instance or static fields according to JVM spec 5.4.3.2, returns the klass in which the field is defined |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
417 klassOop find_field(Symbol* name, Symbol* sig, bool is_static, fieldDescriptor* fd) const; |
0 | 418 |
419 // find a non-static or static field given its offset within the class. | |
420 bool contains_field_offset(int offset) { | |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
49
diff
changeset
|
421 return instanceOopDesc::contains_field_offset(offset, nonstatic_field_size()); |
0 | 422 } |
423 | |
424 bool find_local_field_from_offset(int offset, bool is_static, fieldDescriptor* fd) const; | |
425 bool find_field_from_offset(int offset, bool is_static, fieldDescriptor* fd) const; | |
426 | |
427 // find a local method (returns NULL if not found) | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
428 methodOop find_method(Symbol* name, Symbol* signature) const; |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
429 static methodOop find_method(objArrayOop methods, Symbol* name, Symbol* signature); |
0 | 430 |
431 // lookup operation (returns NULL if not found) | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
432 methodOop uncached_lookup_method(Symbol* name, Symbol* signature) const; |
0 | 433 |
434 // lookup a method in all the interfaces that this class implements | |
435 // (returns NULL if not found) | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
436 methodOop lookup_method_in_all_interfaces(Symbol* name, Symbol* signature) const; |
0 | 437 |
438 // constant pool | |
439 constantPoolOop constants() const { return _constants; } | |
440 void set_constants(constantPoolOop c) { oop_store_without_check((oop*) &_constants, (oop) c); } | |
441 | |
442 // class loader | |
443 oop class_loader() const { return _class_loader; } | |
444 void set_class_loader(oop l) { oop_store((oop*) &_class_loader, l); } | |
445 | |
446 // protection domain | |
447 oop protection_domain() { return _protection_domain; } | |
448 void set_protection_domain(oop pd) { oop_store((oop*) &_protection_domain, pd); } | |
449 | |
431
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
450 // host class |
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
451 oop host_klass() const { return _host_klass; } |
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
452 void set_host_klass(oop host) { oop_store((oop*) &_host_klass, host); } |
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
453 bool is_anonymous() const { return _host_klass != NULL; } |
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
454 |
0 | 455 // signers |
456 objArrayOop signers() const { return _signers; } | |
457 void set_signers(objArrayOop s) { oop_store((oop*) &_signers, oop(s)); } | |
458 | |
459 // source file name | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
460 Symbol* source_file_name() const { return _source_file_name; } |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
461 void set_source_file_name(Symbol* n); |
0 | 462 |
463 // minor and major version numbers of class file | |
464 u2 minor_version() const { return _minor_version; } | |
465 void set_minor_version(u2 minor_version) { _minor_version = minor_version; } | |
466 u2 major_version() const { return _major_version; } | |
467 void set_major_version(u2 major_version) { _major_version = major_version; } | |
468 | |
469 // source debug extension | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
470 Symbol* source_debug_extension() const { return _source_debug_extension; } |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
471 void set_source_debug_extension(Symbol* n); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
472 |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
473 // symbol unloading support (refcount already added) |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
474 Symbol* array_name() { return _array_name; } |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
475 void set_array_name(Symbol* name) { assert(_array_name == NULL, "name already created"); _array_name = name; } |
0 | 476 |
477 // nonstatic oop-map blocks | |
939
9eebd3ac74cf
6845368: large objects cause a crash or unexpected exception
jcoomes
parents:
938
diff
changeset
|
478 static int nonstatic_oop_map_size(unsigned int oop_map_count) { |
938 | 479 return oop_map_count * OopMapBlock::size_in_words(); |
480 } | |
939
9eebd3ac74cf
6845368: large objects cause a crash or unexpected exception
jcoomes
parents:
938
diff
changeset
|
481 unsigned int nonstatic_oop_map_count() const { |
938 | 482 return _nonstatic_oop_map_size / OopMapBlock::size_in_words(); |
483 } | |
484 int nonstatic_oop_map_size() const { return _nonstatic_oop_map_size; } | |
485 void set_nonstatic_oop_map_size(int words) { | |
486 _nonstatic_oop_map_size = words; | |
487 } | |
0 | 488 |
489 // RedefineClasses() support for previous versions: | |
490 void add_previous_version(instanceKlassHandle ikh, BitMap *emcp_methods, | |
491 int emcp_method_count); | |
977
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
975
diff
changeset
|
492 // If the _previous_versions array is non-NULL, then this klass |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
975
diff
changeset
|
493 // has been redefined at least once even if we aren't currently |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
975
diff
changeset
|
494 // tracking a previous version. |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
975
diff
changeset
|
495 bool has_been_redefined() const { return _previous_versions != NULL; } |
0 | 496 bool has_previous_version() const; |
497 void init_previous_versions() { | |
498 _previous_versions = NULL; | |
499 } | |
500 GrowableArray<PreviousVersionNode *>* previous_versions() const { | |
501 return _previous_versions; | |
502 } | |
503 | |
504 // JVMTI: Support for caching a class file before it is modified by an agent that can do retransformation | |
505 void set_cached_class_file(unsigned char *class_file_bytes, | |
506 jint class_file_len) { _cached_class_file_len = class_file_len; | |
507 _cached_class_file_bytes = class_file_bytes; } | |
508 jint get_cached_class_file_len() { return _cached_class_file_len; } | |
509 unsigned char * get_cached_class_file_bytes() { return _cached_class_file_bytes; } | |
510 | |
511 // JVMTI: Support for caching of field indices, types, and offsets | |
512 void set_jvmti_cached_class_field_map(JvmtiCachedClassFieldMap* descriptor) { | |
513 _jvmti_cached_class_field_map = descriptor; | |
514 } | |
515 JvmtiCachedClassFieldMap* jvmti_cached_class_field_map() const { | |
516 return _jvmti_cached_class_field_map; | |
517 } | |
518 | |
519 // for adding methods, constMethodOopDesc::UNSET_IDNUM means no more ids available | |
520 inline u2 next_method_idnum(); | |
521 void set_initial_method_idnum(u2 value) { _idnum_allocated_count = value; } | |
522 | |
523 // generics support | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
524 Symbol* generic_signature() const { return _generic_signature; } |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
525 void set_generic_signature(Symbol* sig) { _generic_signature = sig; } |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
526 |
0 | 527 u2 enclosing_method_class_index() const { return _enclosing_method_class_index; } |
528 u2 enclosing_method_method_index() const { return _enclosing_method_method_index; } | |
529 void set_enclosing_method_indices(u2 class_index, | |
530 u2 method_index) { _enclosing_method_class_index = class_index; | |
531 _enclosing_method_method_index = method_index; } | |
532 | |
533 // jmethodID support | |
977
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
975
diff
changeset
|
534 static jmethodID get_jmethod_id(instanceKlassHandle ik_h, |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
975
diff
changeset
|
535 methodHandle method_h); |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
975
diff
changeset
|
536 static jmethodID get_jmethod_id_fetch_or_update(instanceKlassHandle ik_h, |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
975
diff
changeset
|
537 size_t idnum, jmethodID new_id, jmethodID* new_jmeths, |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
975
diff
changeset
|
538 jmethodID* to_dealloc_id_p, |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
975
diff
changeset
|
539 jmethodID** to_dealloc_jmeths_p); |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
975
diff
changeset
|
540 static void get_jmethod_id_length_value(jmethodID* cache, size_t idnum, |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
975
diff
changeset
|
541 size_t *length_p, jmethodID* id_p); |
0 | 542 jmethodID jmethod_id_or_null(methodOop method); |
543 | |
544 // cached itable index support | |
545 void set_cached_itable_index(size_t idnum, int index); | |
546 int cached_itable_index(size_t idnum); | |
547 | |
548 // annotations support | |
549 typeArrayOop class_annotations() const { return _class_annotations; } | |
550 objArrayOop fields_annotations() const { return _fields_annotations; } | |
551 objArrayOop methods_annotations() const { return _methods_annotations; } | |
552 objArrayOop methods_parameter_annotations() const { return _methods_parameter_annotations; } | |
553 objArrayOop methods_default_annotations() const { return _methods_default_annotations; } | |
554 void set_class_annotations(typeArrayOop md) { oop_store_without_check((oop*)&_class_annotations, (oop)md); } | |
555 void set_fields_annotations(objArrayOop md) { set_annotations(md, &_fields_annotations); } | |
556 void set_methods_annotations(objArrayOop md) { set_annotations(md, &_methods_annotations); } | |
557 void set_methods_parameter_annotations(objArrayOop md) { set_annotations(md, &_methods_parameter_annotations); } | |
558 void set_methods_default_annotations(objArrayOop md) { set_annotations(md, &_methods_default_annotations); } | |
559 typeArrayOop get_method_annotations_of(int idnum) | |
560 { return get_method_annotations_from(idnum, _methods_annotations); } | |
561 typeArrayOop get_method_parameter_annotations_of(int idnum) | |
562 { return get_method_annotations_from(idnum, _methods_parameter_annotations); } | |
563 typeArrayOop get_method_default_annotations_of(int idnum) | |
564 { return get_method_annotations_from(idnum, _methods_default_annotations); } | |
565 void set_method_annotations_of(int idnum, typeArrayOop anno) | |
566 { set_methods_annotations_of(idnum, anno, &_methods_annotations); } | |
567 void set_method_parameter_annotations_of(int idnum, typeArrayOop anno) | |
568 { set_methods_annotations_of(idnum, anno, &_methods_annotations); } | |
569 void set_method_default_annotations_of(int idnum, typeArrayOop anno) | |
570 { set_methods_annotations_of(idnum, anno, &_methods_annotations); } | |
571 | |
572 // allocation | |
573 DEFINE_ALLOCATE_PERMANENT(instanceKlass); | |
574 instanceOop allocate_instance(TRAPS); | |
575 instanceOop allocate_permanent_instance(TRAPS); | |
576 | |
577 // additional member function to return a handle | |
578 instanceHandle allocate_instance_handle(TRAPS) { return instanceHandle(THREAD, allocate_instance(THREAD)); } | |
579 | |
580 objArrayOop allocate_objArray(int n, int length, TRAPS); | |
581 // Helper function | |
582 static instanceOop register_finalizer(instanceOop i, TRAPS); | |
583 | |
584 // Check whether reflection/jni/jvm code is allowed to instantiate this class; | |
585 // if not, throw either an Error or an Exception. | |
586 virtual void check_valid_for_instantiation(bool throwError, TRAPS); | |
587 | |
588 // initialization | |
589 void call_class_initializer(TRAPS); | |
590 void set_initialization_state_and_notify(ClassState state, TRAPS); | |
591 | |
592 // OopMapCache support | |
593 OopMapCache* oop_map_cache() { return _oop_map_cache; } | |
594 void set_oop_map_cache(OopMapCache *cache) { _oop_map_cache = cache; } | |
595 void mask_for(methodHandle method, int bci, InterpreterOopMap* entry); | |
596 | |
597 // JNI identifier support (for static fields - for jni performance) | |
598 JNIid* jni_ids() { return _jni_ids; } | |
599 void set_jni_ids(JNIid* ids) { _jni_ids = ids; } | |
600 JNIid* jni_id_for(int offset); | |
601 | |
602 // maintenance of deoptimization dependencies | |
603 int mark_dependent_nmethods(DepChange& changes); | |
604 void add_dependent_nmethod(nmethod* nm); | |
605 void remove_dependent_nmethod(nmethod* nm); | |
606 | |
607 // On-stack replacement support | |
608 nmethod* osr_nmethods_head() const { return _osr_nmethods_head; }; | |
609 void set_osr_nmethods_head(nmethod* h) { _osr_nmethods_head = h; }; | |
610 void add_osr_nmethod(nmethod* n); | |
611 void remove_osr_nmethod(nmethod* n); | |
1783 | 612 nmethod* lookup_osr_nmethod(const methodOop m, int bci, int level, bool match_level) const; |
0 | 613 |
614 // Breakpoint support (see methods on methodOop for details) | |
615 BreakpointInfo* breakpoints() const { return _breakpoints; }; | |
616 void set_breakpoints(BreakpointInfo* bps) { _breakpoints = bps; }; | |
617 | |
618 // support for stub routines | |
619 static int init_state_offset_in_bytes() { return offset_of(instanceKlass, _init_state); } | |
620 static int init_thread_offset_in_bytes() { return offset_of(instanceKlass, _init_thread); } | |
621 | |
622 // subclass/subinterface checks | |
623 bool implements_interface(klassOop k) const; | |
624 | |
625 // Access to implementors of an interface. We only store the count | |
626 // of implementors, and in case, there are only a few | |
627 // implementors, we store them in a short list. | |
628 // This accessor returns NULL if we walk off the end of the list. | |
629 klassOop implementor(int i) const { | |
630 return (i < implementors_limit)? _implementors[i]: (klassOop) NULL; | |
631 } | |
632 int nof_implementors() const { return _nof_implementors; } | |
633 void add_implementor(klassOop k); // k is a new class that implements this interface | |
634 void init_implementor(); // initialize | |
635 | |
636 // link this class into the implementors list of every interface it implements | |
637 void process_interfaces(Thread *thread); | |
638 | |
639 // virtual operations from Klass | |
640 bool is_leaf_class() const { return _subklass == NULL; } | |
641 objArrayOop compute_secondary_supers(int num_extra_slots, TRAPS); | |
642 bool compute_is_subtype_of(klassOop k); | |
643 bool can_be_primary_super_slow() const; | |
644 klassOop java_super() const { return super(); } | |
645 int oop_size(oop obj) const { return size_helper(); } | |
646 int klass_oop_size() const { return object_size(); } | |
647 bool oop_is_instance_slow() const { return true; } | |
648 | |
649 // Iterators | |
650 void do_local_static_fields(FieldClosure* cl); | |
651 void do_nonstatic_fields(FieldClosure* cl); // including inherited fields | |
652 void do_local_static_fields(void f(fieldDescriptor*, TRAPS), TRAPS); | |
653 | |
654 void methods_do(void f(methodOop method)); | |
655 void array_klasses_do(void f(klassOop k)); | |
656 void with_array_klasses_do(void f(klassOop k)); | |
657 bool super_types_do(SuperTypeClosure* blk); | |
658 | |
659 // Casting from klassOop | |
660 static instanceKlass* cast(klassOop k) { | |
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2357
diff
changeset
|
661 assert(k->is_klass(), "must be"); |
0 | 662 Klass* kp = k->klass_part(); |
663 assert(kp->null_vtbl() || kp->oop_is_instance_slow(), "cast to instanceKlass"); | |
664 return (instanceKlass*) kp; | |
665 } | |
666 | |
667 // Sizing (in words) | |
668 static int header_size() { return align_object_offset(oopDesc::header_size() + sizeof(instanceKlass)/HeapWordSize); } | |
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2357
diff
changeset
|
669 int object_size() const { return object_size(align_object_offset(vtable_length()) + align_object_offset(itable_length()) + nonstatic_oop_map_size()); } |
0 | 670 static int vtable_start_offset() { return header_size(); } |
671 static int vtable_length_offset() { return oopDesc::header_size() + offset_of(instanceKlass, _vtable_len) / HeapWordSize; } | |
672 static int object_size(int extra) { return align_object_size(header_size() + extra); } | |
673 | |
674 intptr_t* start_of_vtable() const { return ((intptr_t*)as_klassOop()) + vtable_start_offset(); } | |
675 intptr_t* start_of_itable() const { return start_of_vtable() + align_object_offset(vtable_length()); } | |
676 int itable_offset_in_words() const { return start_of_itable() - (intptr_t*)as_klassOop(); } | |
677 | |
678 intptr_t* end_of_itable() const { return start_of_itable() + itable_length(); } | |
679 | |
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2357
diff
changeset
|
680 address static_field_addr(int offset); |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
49
diff
changeset
|
681 |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
49
diff
changeset
|
682 OopMapBlock* start_of_nonstatic_oop_maps() const { |
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2357
diff
changeset
|
683 return (OopMapBlock*)(start_of_itable() + align_object_offset(itable_length())); |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
49
diff
changeset
|
684 } |
0 | 685 |
686 // Allocation profiling support | |
687 juint alloc_size() const { return _alloc_count * size_helper(); } | |
688 void set_alloc_size(juint n) {} | |
689 | |
690 // Use this to return the size of an instance in heap words: | |
691 int size_helper() const { | |
692 return layout_helper_to_size_helper(layout_helper()); | |
693 } | |
694 | |
695 // This bit is initialized in classFileParser.cpp. | |
696 // It is false under any of the following conditions: | |
697 // - the class is abstract (including any interface) | |
698 // - the class has a finalizer (if !RegisterFinalizersAtInit) | |
699 // - the class size is larger than FastAllocateSizeLimit | |
700 // - the class is java/lang/Class, which cannot be allocated directly | |
701 bool can_be_fastpath_allocated() const { | |
702 return !layout_helper_needs_slow_path(layout_helper()); | |
703 } | |
704 | |
705 // Java vtable/itable | |
706 klassVtable* vtable() const; // return new klassVtable wrapper | |
707 inline methodOop method_at_vtable(int index); | |
708 klassItable* itable() const; // return new klassItable wrapper | |
709 methodOop method_at_itable(klassOop holder, int index, TRAPS); | |
710 | |
711 // Garbage collection | |
712 void oop_follow_contents(oop obj); | |
713 int oop_adjust_pointers(oop obj); | |
714 bool object_is_parsable() const { return _init_state != unparsable_by_gc; } | |
715 // Value of _init_state must be zero (unparsable_by_gc) when klass field is set. | |
716 | |
717 void follow_weak_klass_links( | |
718 BoolObjectClosure* is_alive, OopClosure* keep_alive); | |
719 void release_C_heap_structures(); | |
720 | |
721 // Parallel Scavenge and Parallel Old | |
722 PARALLEL_GC_DECLS | |
723 | |
724 // Naming | |
1039
987e948ebbc8
6815692: method handle code needs some cleanup (post-6655638)
jrose
parents:
977
diff
changeset
|
725 const char* signature_name() const; |
0 | 726 |
727 // Iterators | |
728 int oop_oop_iterate(oop obj, OopClosure* blk) { | |
729 return oop_oop_iterate_v(obj, blk); | |
730 } | |
731 | |
732 int oop_oop_iterate_m(oop obj, OopClosure* blk, MemRegion mr) { | |
733 return oop_oop_iterate_v_m(obj, blk, mr); | |
734 } | |
735 | |
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
736 #define InstanceKlass_OOP_OOP_ITERATE_DECL(OopClosureType, nv_suffix) \ |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
737 int oop_oop_iterate##nv_suffix(oop obj, OopClosureType* blk); \ |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
738 int oop_oop_iterate##nv_suffix##_m(oop obj, OopClosureType* blk, \ |
0 | 739 MemRegion mr); |
740 | |
741 ALL_OOP_OOP_ITERATE_CLOSURES_1(InstanceKlass_OOP_OOP_ITERATE_DECL) | |
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
742 ALL_OOP_OOP_ITERATE_CLOSURES_2(InstanceKlass_OOP_OOP_ITERATE_DECL) |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
743 |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
744 #ifndef SERIALGC |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
745 #define InstanceKlass_OOP_OOP_ITERATE_BACKWARDS_DECL(OopClosureType, nv_suffix) \ |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
746 int oop_oop_iterate_backwards##nv_suffix(oop obj, OopClosureType* blk); |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
747 |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
748 ALL_OOP_OOP_ITERATE_CLOSURES_1(InstanceKlass_OOP_OOP_ITERATE_BACKWARDS_DECL) |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
749 ALL_OOP_OOP_ITERATE_CLOSURES_2(InstanceKlass_OOP_OOP_ITERATE_BACKWARDS_DECL) |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
750 #endif // !SERIALGC |
0 | 751 |
752 private: | |
753 // initialization state | |
754 #ifdef ASSERT | |
755 void set_init_state(ClassState state); | |
756 #else | |
757 void set_init_state(ClassState state) { _init_state = state; } | |
758 #endif | |
975 | 759 void set_rewritten() { _rewritten = true; } |
0 | 760 void set_init_thread(Thread *thread) { _init_thread = thread; } |
761 | |
762 u2 idnum_allocated_count() const { return _idnum_allocated_count; } | |
977
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
975
diff
changeset
|
763 // The RedefineClasses() API can cause new method idnums to be needed |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
975
diff
changeset
|
764 // which will cause the caches to grow. Safety requires different |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
975
diff
changeset
|
765 // cache management logic if the caches can grow instead of just |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
975
diff
changeset
|
766 // going from NULL to non-NULL. |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
975
diff
changeset
|
767 bool idnum_can_increment() const { return has_been_redefined(); } |
0 | 768 jmethodID* methods_jmethod_ids_acquire() const |
769 { return (jmethodID*)OrderAccess::load_ptr_acquire(&_methods_jmethod_ids); } | |
770 void release_set_methods_jmethod_ids(jmethodID* jmeths) | |
771 { OrderAccess::release_store_ptr(&_methods_jmethod_ids, jmeths); } | |
772 | |
773 int* methods_cached_itable_indices_acquire() const | |
774 { return (int*)OrderAccess::load_ptr_acquire(&_methods_cached_itable_indices); } | |
775 void release_set_methods_cached_itable_indices(int* indices) | |
776 { OrderAccess::release_store_ptr(&_methods_cached_itable_indices, indices); } | |
777 | |
778 inline typeArrayOop get_method_annotations_from(int idnum, objArrayOop annos); | |
779 void set_annotations(objArrayOop md, objArrayOop* md_p) { oop_store_without_check((oop*)md_p, (oop)md); } | |
780 void set_methods_annotations_of(int idnum, typeArrayOop anno, objArrayOop* md_p); | |
781 | |
782 // Offsets for memory management | |
783 oop* adr_array_klasses() const { return (oop*)&this->_array_klasses;} | |
784 oop* adr_methods() const { return (oop*)&this->_methods;} | |
785 oop* adr_method_ordering() const { return (oop*)&this->_method_ordering;} | |
786 oop* adr_local_interfaces() const { return (oop*)&this->_local_interfaces;} | |
787 oop* adr_transitive_interfaces() const { return (oop*)&this->_transitive_interfaces;} | |
788 oop* adr_fields() const { return (oop*)&this->_fields;} | |
789 oop* adr_constants() const { return (oop*)&this->_constants;} | |
790 oop* adr_class_loader() const { return (oop*)&this->_class_loader;} | |
791 oop* adr_protection_domain() const { return (oop*)&this->_protection_domain;} | |
431
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
792 oop* adr_host_klass() const { return (oop*)&this->_host_klass;} |
0 | 793 oop* adr_signers() const { return (oop*)&this->_signers;} |
794 oop* adr_inner_classes() const { return (oop*)&this->_inner_classes;} | |
795 oop* adr_implementors() const { return (oop*)&this->_implementors[0];} | |
796 oop* adr_methods_jmethod_ids() const { return (oop*)&this->_methods_jmethod_ids;} | |
797 oop* adr_methods_cached_itable_indices() const { return (oop*)&this->_methods_cached_itable_indices;} | |
798 oop* adr_class_annotations() const { return (oop*)&this->_class_annotations;} | |
799 oop* adr_fields_annotations() const { return (oop*)&this->_fields_annotations;} | |
800 oop* adr_methods_annotations() const { return (oop*)&this->_methods_annotations;} | |
801 oop* adr_methods_parameter_annotations() const { return (oop*)&this->_methods_parameter_annotations;} | |
802 oop* adr_methods_default_annotations() const { return (oop*)&this->_methods_default_annotations;} | |
803 | |
804 // Static methods that are used to implement member methods where an exposed this pointer | |
805 // is needed due to possible GCs | |
806 static bool link_class_impl (instanceKlassHandle this_oop, bool throw_verifyerror, TRAPS); | |
807 static bool verify_code (instanceKlassHandle this_oop, bool throw_verifyerror, TRAPS); | |
808 static void initialize_impl (instanceKlassHandle this_oop, TRAPS); | |
809 static void eager_initialize_impl (instanceKlassHandle this_oop); | |
810 static void set_initialization_state_and_notify_impl (instanceKlassHandle this_oop, ClassState state, TRAPS); | |
811 static void call_class_initializer_impl (instanceKlassHandle this_oop, TRAPS); | |
812 static klassOop array_klass_impl (instanceKlassHandle this_oop, bool or_null, int n, TRAPS); | |
813 static void do_local_static_fields_impl (instanceKlassHandle this_oop, void f(fieldDescriptor* fd, TRAPS), TRAPS); | |
814 /* jni_id_for_impl for jfieldID only */ | |
815 static JNIid* jni_id_for_impl (instanceKlassHandle this_oop, int offset); | |
816 | |
817 // Returns the array class for the n'th dimension | |
818 klassOop array_klass_impl(bool or_null, int n, TRAPS); | |
819 | |
820 // Returns the array class with this class as element type | |
821 klassOop array_klass_impl(bool or_null, TRAPS); | |
822 | |
823 public: | |
824 // sharing support | |
825 virtual void remove_unshareable_info(); | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
826 virtual void shared_symbols_iterate(SymbolClosure* closure); |
0 | 827 |
828 // jvm support | |
829 jint compute_modifier_flags(TRAPS) const; | |
830 | |
831 public: | |
832 // JVMTI support | |
833 jint jvmti_class_status() const; | |
834 | |
835 public: | |
836 // Printing | |
1155
4e6abf09f540
6912062: disassembler plugin needs to produce symbolic information in product mode
jrose
parents:
1126
diff
changeset
|
837 void oop_print_value_on(oop obj, outputStream* st); |
4e6abf09f540
6912062: disassembler plugin needs to produce symbolic information in product mode
jrose
parents:
1126
diff
changeset
|
838 #ifndef PRODUCT |
0 | 839 void oop_print_on (oop obj, outputStream* st); |
840 | |
841 void print_dependent_nmethods(bool verbose = false); | |
842 bool is_dependent_nmethod(nmethod* nm); | |
843 #endif | |
844 | |
845 // Verification | |
846 const char* internal_name() const; | |
847 void oop_verify_on(oop obj, outputStream* st); | |
848 }; | |
849 | |
850 inline methodOop instanceKlass::method_at_vtable(int index) { | |
851 #ifndef PRODUCT | |
852 assert(index >= 0, "valid vtable index"); | |
853 if (DebugVtables) { | |
854 verify_vtable_index(index); | |
855 } | |
856 #endif | |
857 vtableEntry* ve = (vtableEntry*)start_of_vtable(); | |
858 return ve[index].method(); | |
859 } | |
860 | |
861 inline typeArrayOop instanceKlass::get_method_annotations_from(int idnum, objArrayOop annos) { | |
862 if (annos == NULL || annos->length() <= idnum) { | |
863 return NULL; | |
864 } | |
865 return typeArrayOop(annos->obj_at(idnum)); | |
866 } | |
867 | |
868 // for adding methods | |
869 // UNSET_IDNUM return means no more ids available | |
870 inline u2 instanceKlass::next_method_idnum() { | |
871 if (_idnum_allocated_count == constMethodOopDesc::MAX_IDNUM) { | |
872 return constMethodOopDesc::UNSET_IDNUM; // no more ids available | |
873 } else { | |
874 return _idnum_allocated_count++; | |
875 } | |
876 } | |
877 | |
878 | |
879 /* JNIid class for jfieldIDs only */ | |
880 class JNIid: public CHeapObj { | |
881 friend class VMStructs; | |
882 private: | |
883 klassOop _holder; | |
884 JNIid* _next; | |
885 int _offset; | |
886 #ifdef ASSERT | |
887 bool _is_static_field_id; | |
888 #endif | |
889 | |
890 public: | |
891 // Accessors | |
892 klassOop holder() const { return _holder; } | |
893 int offset() const { return _offset; } | |
894 JNIid* next() { return _next; } | |
895 // Constructor | |
896 JNIid(klassOop holder, int offset, JNIid* next); | |
897 // Identifier lookup | |
898 JNIid* find(int offset); | |
899 | |
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2357
diff
changeset
|
900 bool find_local_field(fieldDescriptor* fd) { |
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2357
diff
changeset
|
901 return instanceKlass::cast(holder())->find_local_field_from_offset(offset(), true, fd); |
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2357
diff
changeset
|
902 } |
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2357
diff
changeset
|
903 |
0 | 904 // Garbage collection support |
905 oop* holder_addr() { return (oop*)&_holder; } | |
906 void oops_do(OopClosure* f); | |
907 static void deallocate(JNIid* id); | |
908 // Debugging | |
909 #ifdef ASSERT | |
910 bool is_static_field_id() const { return _is_static_field_id; } | |
911 void set_is_static_field_id() { _is_static_field_id = true; } | |
912 #endif | |
913 void verify(klassOop holder); | |
914 }; | |
915 | |
916 | |
917 // If breakpoints are more numerous than just JVMTI breakpoints, | |
918 // consider compressing this data structure. | |
919 // It is currently a simple linked list defined in methodOop.hpp. | |
920 | |
921 class BreakpointInfo; | |
922 | |
923 | |
924 // A collection point for interesting information about the previous | |
925 // version(s) of an instanceKlass. This class uses weak references to | |
926 // the information so that the information may be collected as needed | |
47
2c106685d6d0
6497639: 4/3 Profiling Swing application caused JVM crash
dcubed
parents:
0
diff
changeset
|
927 // by the system. If the information is shared, then a regular |
2c106685d6d0
6497639: 4/3 Profiling Swing application caused JVM crash
dcubed
parents:
0
diff
changeset
|
928 // reference must be used because a weak reference would be seen as |
2c106685d6d0
6497639: 4/3 Profiling Swing application caused JVM crash
dcubed
parents:
0
diff
changeset
|
929 // collectible. A GrowableArray of PreviousVersionNodes is attached |
0 | 930 // to the instanceKlass as needed. See PreviousVersionWalker below. |
931 class PreviousVersionNode : public CHeapObj { | |
932 private: | |
47
2c106685d6d0
6497639: 4/3 Profiling Swing application caused JVM crash
dcubed
parents:
0
diff
changeset
|
933 // A shared ConstantPool is never collected so we'll always have |
2c106685d6d0
6497639: 4/3 Profiling Swing application caused JVM crash
dcubed
parents:
0
diff
changeset
|
934 // a reference to it so we can update items in the cache. We'll |
2c106685d6d0
6497639: 4/3 Profiling Swing application caused JVM crash
dcubed
parents:
0
diff
changeset
|
935 // have a weak reference to a non-shared ConstantPool until all |
2c106685d6d0
6497639: 4/3 Profiling Swing application caused JVM crash
dcubed
parents:
0
diff
changeset
|
936 // of the methods (EMCP or obsolete) have been collected; the |
2c106685d6d0
6497639: 4/3 Profiling Swing application caused JVM crash
dcubed
parents:
0
diff
changeset
|
937 // non-shared ConstantPool becomes collectible at that point. |
2c106685d6d0
6497639: 4/3 Profiling Swing application caused JVM crash
dcubed
parents:
0
diff
changeset
|
938 jobject _prev_constant_pool; // regular or weak reference |
2c106685d6d0
6497639: 4/3 Profiling Swing application caused JVM crash
dcubed
parents:
0
diff
changeset
|
939 bool _prev_cp_is_weak; // true if not a shared ConstantPool |
2c106685d6d0
6497639: 4/3 Profiling Swing application caused JVM crash
dcubed
parents:
0
diff
changeset
|
940 |
0 | 941 // If the previous version of the instanceKlass doesn't have any |
942 // EMCP methods, then _prev_EMCP_methods will be NULL. If all the | |
943 // EMCP methods have been collected, then _prev_EMCP_methods can | |
944 // have a length of zero. | |
945 GrowableArray<jweak>* _prev_EMCP_methods; | |
946 | |
947 public: | |
47
2c106685d6d0
6497639: 4/3 Profiling Swing application caused JVM crash
dcubed
parents:
0
diff
changeset
|
948 PreviousVersionNode(jobject prev_constant_pool, bool prev_cp_is_weak, |
0 | 949 GrowableArray<jweak>* prev_EMCP_methods); |
950 ~PreviousVersionNode(); | |
47
2c106685d6d0
6497639: 4/3 Profiling Swing application caused JVM crash
dcubed
parents:
0
diff
changeset
|
951 jobject prev_constant_pool() const { |
0 | 952 return _prev_constant_pool; |
953 } | |
954 GrowableArray<jweak>* prev_EMCP_methods() const { | |
955 return _prev_EMCP_methods; | |
956 } | |
957 }; | |
958 | |
959 | |
960 // A Handle-ized version of PreviousVersionNode. | |
961 class PreviousVersionInfo : public ResourceObj { | |
962 private: | |
963 constantPoolHandle _prev_constant_pool_handle; | |
964 // If the previous version of the instanceKlass doesn't have any | |
965 // EMCP methods, then _prev_EMCP_methods will be NULL. Since the | |
966 // methods cannot be collected while we hold a handle, | |
967 // _prev_EMCP_methods should never have a length of zero. | |
968 GrowableArray<methodHandle>* _prev_EMCP_method_handles; | |
969 | |
970 public: | |
971 PreviousVersionInfo(PreviousVersionNode *pv_node); | |
972 ~PreviousVersionInfo(); | |
973 constantPoolHandle prev_constant_pool_handle() const { | |
974 return _prev_constant_pool_handle; | |
975 } | |
976 GrowableArray<methodHandle>* prev_EMCP_method_handles() const { | |
977 return _prev_EMCP_method_handles; | |
978 } | |
979 }; | |
980 | |
981 | |
982 // Helper object for walking previous versions. This helper cleans up | |
983 // the Handles that it allocates when the helper object is destroyed. | |
984 // The PreviousVersionInfo object returned by next_previous_version() | |
985 // is only valid until a subsequent call to next_previous_version() or | |
986 // the helper object is destroyed. | |
987 class PreviousVersionWalker : public StackObj { | |
988 private: | |
989 GrowableArray<PreviousVersionNode *>* _previous_versions; | |
990 int _current_index; | |
991 // Fields for cleaning up when we are done walking the previous versions: | |
992 // A HandleMark for the PreviousVersionInfo handles: | |
993 HandleMark _hm; | |
994 | |
995 // It would be nice to have a ResourceMark field in this helper also, | |
996 // but the ResourceMark code says to be careful to delete handles held | |
997 // in GrowableArrays _before_ deleting the GrowableArray. Since we | |
998 // can't guarantee the order in which the fields are destroyed, we | |
999 // have to let the creator of the PreviousVersionWalker object do | |
1000 // the right thing. Also, adding a ResourceMark here causes an | |
1001 // include loop. | |
1002 | |
1003 // A pointer to the current info object so we can handle the deletes. | |
1004 PreviousVersionInfo * _current_p; | |
1005 | |
1006 public: | |
1007 PreviousVersionWalker(instanceKlass *ik); | |
1008 ~PreviousVersionWalker(); | |
1009 | |
1010 // Return the interesting information for the next previous version | |
1011 // of the klass. Returns NULL if there are no more previous versions. | |
1012 PreviousVersionInfo* next_previous_version(); | |
1013 }; | |
1972 | 1014 |
3939 | 1015 |
1016 // | |
1017 // nmethodBucket is used to record dependent nmethods for | |
1018 // deoptimization. nmethod dependencies are actually <klass, method> | |
1019 // pairs but we really only care about the klass part for purposes of | |
1020 // finding nmethods which might need to be deoptimized. Instead of | |
1021 // recording the method, a count of how many times a particular nmethod | |
1022 // was recorded is kept. This ensures that any recording errors are | |
1023 // noticed since an nmethod should be removed as many times are it's | |
1024 // added. | |
1025 // | |
1026 class nmethodBucket: public CHeapObj { | |
1027 friend class VMStructs; | |
1028 private: | |
1029 nmethod* _nmethod; | |
1030 int _count; | |
1031 nmethodBucket* _next; | |
1032 | |
1033 public: | |
1034 nmethodBucket(nmethod* nmethod, nmethodBucket* next) { | |
1035 _nmethod = nmethod; | |
1036 _next = next; | |
1037 _count = 1; | |
1038 } | |
1039 int count() { return _count; } | |
1040 int increment() { _count += 1; return _count; } | |
1041 int decrement() { _count -= 1; assert(_count >= 0, "don't underflow"); return _count; } | |
1042 nmethodBucket* next() { return _next; } | |
1043 void set_next(nmethodBucket* b) { _next = b; } | |
1044 nmethod* get_nmethod() { return _nmethod; } | |
1045 }; | |
1046 | |
1972 | 1047 #endif // SHARE_VM_OOPS_INSTANCEKLASS_HPP |