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