Mercurial > hg > truffle
annotate src/share/vm/oops/instanceKlass.hpp @ 3249:e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
Summary: A referent object that is only weakly reachable at the start of concurrent marking but is re-attached to the strongly reachable object graph during marking may not be marked as live. This can cause the reference object to be processed prematurely and leave dangling pointers to the referent object. Implement a read barrier for the java.lang.ref.Reference::referent field by intrinsifying the Reference.get() method, and intercepting accesses though JNI, reflection, and Unsafe, so that when a non-null referent object is read it is also logged in an SATB buffer.
Reviewed-by: kvn, iveresov, never, tonyp, dholmes
| author | johnc |
|---|---|
| date | Thu, 07 Apr 2011 09:53:20 -0700 |
| parents | c7f3d0b4570f |
| children | 92add02409c9 |
| 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. |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
185 // This is only non-null for an anonymous class (AnonymousClasses enabled). |
|
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]; | |
|
2357
8033953d67ff
7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents:
2356
diff
changeset
|
194 // invokedynamic bootstrap method (a java.lang.invoke.MethodHandle) |
|
2356
72dee110246f
6839872: remove implementation inheritance from JSR 292 APIs
jrose
parents:
2227
diff
changeset
|
195 oop _bootstrap_method; // AllowTransitionalJSR292 ONLY |
| 0 | 196 // Annotations for this class, or null if none. |
| 197 typeArrayOop _class_annotations; | |
| 198 // Annotation objects (byte arrays) for fields, or null if no annotations. | |
| 199 // Indices correspond to entries (not indices) in fields array. | |
| 200 objArrayOop _fields_annotations; | |
| 201 // Annotation objects (byte arrays) for methods, or null if no annotations. | |
| 202 // Index is the idnum, which is initially the same as the methods array index. | |
| 203 objArrayOop _methods_annotations; | |
| 204 // Annotation objects (byte arrays) for methods' parameters, or null if no | |
| 205 // such annotations. | |
| 206 // Index is the idnum, which is initially the same as the methods array index. | |
| 207 objArrayOop _methods_parameter_annotations; | |
| 208 // Annotation objects (byte arrays) for methods' default values, or null if no | |
| 209 // such annotations. | |
| 210 // Index is the idnum, which is initially the same as the methods array index. | |
| 211 objArrayOop _methods_default_annotations; | |
| 212 | |
| 213 // | |
| 214 // End of the oop block. | |
| 215 // | |
| 216 | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
217 // 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
|
218 Symbol* _source_file_name; |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
219 // 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
|
220 Symbol* _source_debug_extension; |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
221 // Generic signature, or null if none. |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
222 Symbol* _generic_signature; |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
223 // 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
|
224 // if this class is unloaded. |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
225 Symbol* _array_name; |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
226 |
|
165
437d03ea40b1
6703888: Compressed Oops: use the 32-bits gap after klass in a object
kvn
parents:
113
diff
changeset
|
227 // 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
|
228 // (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
|
229 int _nonstatic_field_size; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
49
diff
changeset
|
230 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
|
231 int _static_oop_field_count;// number of static oop fields in this klass |
| 938 | 232 int _nonstatic_oop_map_size;// size in words of nonstatic oop map blocks |
| 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 | |
| 312 // fields | |
| 313 // Field info extracted from the class file and stored | |
| 314 // as an array of 7 shorts | |
| 315 enum FieldOffset { | |
| 316 access_flags_offset = 0, | |
| 317 name_index_offset = 1, | |
| 318 signature_index_offset = 2, | |
| 319 initval_index_offset = 3, | |
| 320 low_offset = 4, | |
| 321 high_offset = 5, | |
| 322 generic_signature_offset = 6, | |
| 323 next_offset = 7 | |
| 324 }; | |
| 325 | |
| 326 typeArrayOop fields() const { return _fields; } | |
| 327 int offset_from_fields( int index ) const { | |
| 328 return build_int_from_shorts( fields()->ushort_at(index + low_offset), | |
| 329 fields()->ushort_at(index + high_offset) ); | |
| 330 } | |
| 331 | |
| 332 void set_fields(typeArrayOop f) { oop_store_without_check((oop*) &_fields, (oop) f); } | |
| 333 | |
| 334 // inner classes | |
| 335 typeArrayOop inner_classes() const { return _inner_classes; } | |
| 336 void set_inner_classes(typeArrayOop f) { oop_store_without_check((oop*) &_inner_classes, (oop) f); } | |
| 337 | |
| 338 enum InnerClassAttributeOffset { | |
| 339 // From http://mirror.eng/products/jdk/1.1/docs/guide/innerclasses/spec/innerclasses.doc10.html#18814 | |
| 340 inner_class_inner_class_info_offset = 0, | |
| 341 inner_class_outer_class_info_offset = 1, | |
| 342 inner_class_inner_name_offset = 2, | |
| 343 inner_class_access_flags_offset = 3, | |
| 344 inner_class_next_offset = 4 | |
| 345 }; | |
| 346 | |
|
652
4aaa9f5e02a8
4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents:
431
diff
changeset
|
347 // method override check |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
348 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
|
349 |
| 0 | 350 // package |
| 351 bool is_same_class_package(klassOop class2); | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
352 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
|
353 static bool is_same_class_package(oop class_loader1, Symbol* class_name1, oop class_loader2, Symbol* class_name2); |
| 0 | 354 |
|
665
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
431
diff
changeset
|
355 // 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
|
356 klassOop compute_enclosing_class(bool* inner_is_member, TRAPS) { |
|
665
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
431
diff
changeset
|
357 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
|
358 return compute_enclosing_class_impl(self, inner_is_member, THREAD); |
|
665
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
431
diff
changeset
|
359 } |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
431
diff
changeset
|
360 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
|
361 bool* inner_is_member, TRAPS); |
|
665
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
431
diff
changeset
|
362 |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
431
diff
changeset
|
363 // 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
|
364 bool is_same_package_member(klassOop class2, TRAPS) { |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
431
diff
changeset
|
365 instanceKlassHandle self(THREAD, this->as_klassOop()); |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
431
diff
changeset
|
366 return is_same_package_member_impl(self, class2, THREAD); |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
431
diff
changeset
|
367 } |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
431
diff
changeset
|
368 static bool is_same_package_member_impl(instanceKlassHandle self, |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
431
diff
changeset
|
369 klassOop class2, TRAPS); |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
431
diff
changeset
|
370 |
| 0 | 371 // initialization state |
| 372 bool is_loaded() const { return _init_state >= loaded; } | |
| 373 bool is_linked() const { return _init_state >= linked; } | |
| 374 bool is_initialized() const { return _init_state == fully_initialized; } | |
| 375 bool is_not_initialized() const { return _init_state < being_initialized; } | |
| 376 bool is_being_initialized() const { return _init_state == being_initialized; } | |
| 377 bool is_in_error_state() const { return _init_state == initialization_error; } | |
| 378 bool is_reentrant_initialization(Thread *thread) { return thread == _init_thread; } | |
| 379 int get_init_state() { return _init_state; } // Useful for debugging | |
| 975 | 380 bool is_rewritten() const { return _rewritten; } |
|
973
ad6585fd4087
6830542: Performance: JVM_DefineClass already verified.
acorn
parents:
726
diff
changeset
|
381 |
|
ad6585fd4087
6830542: Performance: JVM_DefineClass already verified.
acorn
parents:
726
diff
changeset
|
382 // defineClass specified verification |
| 975 | 383 bool should_verify_class() const { return _should_verify_class; } |
| 384 void set_should_verify_class(bool value) { _should_verify_class = value; } | |
| 0 | 385 |
| 386 // marking | |
| 975 | 387 bool is_marked_dependent() const { return _is_marked_dependent; } |
| 388 void set_is_marked_dependent(bool value) { _is_marked_dependent = value; } | |
| 0 | 389 |
| 390 // initialization (virtuals from Klass) | |
| 391 bool should_be_initialized() const; // means that initialize should be called | |
| 392 void initialize(TRAPS); | |
| 393 void link_class(TRAPS); | |
| 394 bool link_class_or_fail(TRAPS); // returns false on failure | |
| 395 void unlink_class(); | |
| 396 void rewrite_class(TRAPS); | |
| 397 methodOop class_initializer(); | |
| 398 | |
| 399 // set the class to initialized if no static initializer is present | |
| 400 void eager_initialize(Thread *thread); | |
| 401 | |
| 402 // reference type | |
| 403 ReferenceType reference_type() const { return _reference_type; } | |
| 404 void set_reference_type(ReferenceType t) { _reference_type = t; } | |
| 405 | |
|
3249
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2376
diff
changeset
|
406 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
|
407 |
| 0 | 408 // find local field, returns true if found |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
409 bool find_local_field(Symbol* name, Symbol* sig, fieldDescriptor* fd) const; |
| 0 | 410 // 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
|
411 klassOop find_interface_field(Symbol* name, Symbol* sig, fieldDescriptor* fd) const; |
| 0 | 412 // 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
|
413 klassOop find_field(Symbol* name, Symbol* sig, fieldDescriptor* fd) const; |
| 0 | 414 // 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
|
415 klassOop find_field(Symbol* name, Symbol* sig, bool is_static, fieldDescriptor* fd) const; |
| 0 | 416 |
| 417 // find a non-static or static field given its offset within the class. | |
| 418 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
|
419 return instanceOopDesc::contains_field_offset(offset, nonstatic_field_size()); |
| 0 | 420 } |
| 421 | |
| 422 bool find_local_field_from_offset(int offset, bool is_static, fieldDescriptor* fd) const; | |
| 423 bool find_field_from_offset(int offset, bool is_static, fieldDescriptor* fd) const; | |
| 424 | |
| 425 // 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
|
426 methodOop find_method(Symbol* name, Symbol* signature) const; |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
427 static methodOop find_method(objArrayOop methods, Symbol* name, Symbol* signature); |
| 0 | 428 |
| 429 // lookup operation (returns NULL if not found) | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
430 methodOop uncached_lookup_method(Symbol* name, Symbol* signature) const; |
| 0 | 431 |
| 432 // lookup a method in all the interfaces that this class implements | |
| 433 // (returns NULL if not found) | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
434 methodOop lookup_method_in_all_interfaces(Symbol* name, Symbol* signature) const; |
| 0 | 435 |
| 436 // constant pool | |
| 437 constantPoolOop constants() const { return _constants; } | |
| 438 void set_constants(constantPoolOop c) { oop_store_without_check((oop*) &_constants, (oop) c); } | |
| 439 | |
| 440 // class loader | |
| 441 oop class_loader() const { return _class_loader; } | |
| 442 void set_class_loader(oop l) { oop_store((oop*) &_class_loader, l); } | |
| 443 | |
| 444 // protection domain | |
| 445 oop protection_domain() { return _protection_domain; } | |
| 446 void set_protection_domain(oop pd) { oop_store((oop*) &_protection_domain, pd); } | |
| 447 | |
|
431
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
448 // host class |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
449 oop host_klass() const { return _host_klass; } |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
450 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
|
451 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
|
452 |
| 0 | 453 // signers |
| 454 objArrayOop signers() const { return _signers; } | |
| 455 void set_signers(objArrayOop s) { oop_store((oop*) &_signers, oop(s)); } | |
| 456 | |
| 457 // source file name | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
458 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
|
459 void set_source_file_name(Symbol* n); |
| 0 | 460 |
| 461 // minor and major version numbers of class file | |
| 462 u2 minor_version() const { return _minor_version; } | |
| 463 void set_minor_version(u2 minor_version) { _minor_version = minor_version; } | |
| 464 u2 major_version() const { return _major_version; } | |
| 465 void set_major_version(u2 major_version) { _major_version = major_version; } | |
| 466 | |
| 467 // source debug extension | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
468 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
|
469 void set_source_debug_extension(Symbol* n); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
470 |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
471 // symbol unloading support (refcount already added) |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
472 Symbol* array_name() { return _array_name; } |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
473 void set_array_name(Symbol* name) { assert(_array_name == NULL, "name already created"); _array_name = name; } |
| 0 | 474 |
| 475 // nonstatic oop-map blocks | |
|
939
9eebd3ac74cf
6845368: large objects cause a crash or unexpected exception
jcoomes
parents:
938
diff
changeset
|
476 static int nonstatic_oop_map_size(unsigned int oop_map_count) { |
| 938 | 477 return oop_map_count * OopMapBlock::size_in_words(); |
| 478 } | |
|
939
9eebd3ac74cf
6845368: large objects cause a crash or unexpected exception
jcoomes
parents:
938
diff
changeset
|
479 unsigned int nonstatic_oop_map_count() const { |
| 938 | 480 return _nonstatic_oop_map_size / OopMapBlock::size_in_words(); |
| 481 } | |
| 482 int nonstatic_oop_map_size() const { return _nonstatic_oop_map_size; } | |
| 483 void set_nonstatic_oop_map_size(int words) { | |
| 484 _nonstatic_oop_map_size = words; | |
| 485 } | |
| 0 | 486 |
| 487 // RedefineClasses() support for previous versions: | |
| 488 void add_previous_version(instanceKlassHandle ikh, BitMap *emcp_methods, | |
| 489 int emcp_method_count); | |
|
977
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
975
diff
changeset
|
490 // 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
|
491 // 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
|
492 // tracking a previous version. |
|
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
975
diff
changeset
|
493 bool has_been_redefined() const { return _previous_versions != NULL; } |
| 0 | 494 bool has_previous_version() const; |
| 495 void init_previous_versions() { | |
| 496 _previous_versions = NULL; | |
| 497 } | |
| 498 GrowableArray<PreviousVersionNode *>* previous_versions() const { | |
| 499 return _previous_versions; | |
| 500 } | |
| 501 | |
| 502 // JVMTI: Support for caching a class file before it is modified by an agent that can do retransformation | |
| 503 void set_cached_class_file(unsigned char *class_file_bytes, | |
| 504 jint class_file_len) { _cached_class_file_len = class_file_len; | |
| 505 _cached_class_file_bytes = class_file_bytes; } | |
| 506 jint get_cached_class_file_len() { return _cached_class_file_len; } | |
| 507 unsigned char * get_cached_class_file_bytes() { return _cached_class_file_bytes; } | |
| 508 | |
| 509 // JVMTI: Support for caching of field indices, types, and offsets | |
| 510 void set_jvmti_cached_class_field_map(JvmtiCachedClassFieldMap* descriptor) { | |
| 511 _jvmti_cached_class_field_map = descriptor; | |
| 512 } | |
| 513 JvmtiCachedClassFieldMap* jvmti_cached_class_field_map() const { | |
| 514 return _jvmti_cached_class_field_map; | |
| 515 } | |
| 516 | |
| 517 // for adding methods, constMethodOopDesc::UNSET_IDNUM means no more ids available | |
| 518 inline u2 next_method_idnum(); | |
| 519 void set_initial_method_idnum(u2 value) { _idnum_allocated_count = value; } | |
| 520 | |
| 521 // generics support | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
522 Symbol* generic_signature() const { return _generic_signature; } |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
523 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
|
524 |
| 0 | 525 u2 enclosing_method_class_index() const { return _enclosing_method_class_index; } |
| 526 u2 enclosing_method_method_index() const { return _enclosing_method_method_index; } | |
| 527 void set_enclosing_method_indices(u2 class_index, | |
| 528 u2 method_index) { _enclosing_method_class_index = class_index; | |
| 529 _enclosing_method_method_index = method_index; } | |
| 530 | |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
676
diff
changeset
|
531 // JSR 292 support |
|
2356
72dee110246f
6839872: remove implementation inheritance from JSR 292 APIs
jrose
parents:
2227
diff
changeset
|
532 oop bootstrap_method() const { return _bootstrap_method; } // AllowTransitionalJSR292 ONLY |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
676
diff
changeset
|
533 void set_bootstrap_method(oop mh) { oop_store(&_bootstrap_method, mh); } |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
676
diff
changeset
|
534 |
| 0 | 535 // jmethodID support |
|
977
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
975
diff
changeset
|
536 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
|
537 methodHandle method_h); |
|
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
975
diff
changeset
|
538 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
|
539 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
|
540 jmethodID* to_dealloc_id_p, |
|
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
975
diff
changeset
|
541 jmethodID** to_dealloc_jmeths_p); |
|
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
975
diff
changeset
|
542 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
|
543 size_t *length_p, jmethodID* id_p); |
| 0 | 544 jmethodID jmethod_id_or_null(methodOop method); |
| 545 | |
| 546 // cached itable index support | |
| 547 void set_cached_itable_index(size_t idnum, int index); | |
| 548 int cached_itable_index(size_t idnum); | |
| 549 | |
| 550 // annotations support | |
| 551 typeArrayOop class_annotations() const { return _class_annotations; } | |
| 552 objArrayOop fields_annotations() const { return _fields_annotations; } | |
| 553 objArrayOop methods_annotations() const { return _methods_annotations; } | |
| 554 objArrayOop methods_parameter_annotations() const { return _methods_parameter_annotations; } | |
| 555 objArrayOop methods_default_annotations() const { return _methods_default_annotations; } | |
| 556 void set_class_annotations(typeArrayOop md) { oop_store_without_check((oop*)&_class_annotations, (oop)md); } | |
| 557 void set_fields_annotations(objArrayOop md) { set_annotations(md, &_fields_annotations); } | |
| 558 void set_methods_annotations(objArrayOop md) { set_annotations(md, &_methods_annotations); } | |
| 559 void set_methods_parameter_annotations(objArrayOop md) { set_annotations(md, &_methods_parameter_annotations); } | |
| 560 void set_methods_default_annotations(objArrayOop md) { set_annotations(md, &_methods_default_annotations); } | |
| 561 typeArrayOop get_method_annotations_of(int idnum) | |
| 562 { return get_method_annotations_from(idnum, _methods_annotations); } | |
| 563 typeArrayOop get_method_parameter_annotations_of(int idnum) | |
| 564 { return get_method_annotations_from(idnum, _methods_parameter_annotations); } | |
| 565 typeArrayOop get_method_default_annotations_of(int idnum) | |
| 566 { return get_method_annotations_from(idnum, _methods_default_annotations); } | |
| 567 void set_method_annotations_of(int idnum, typeArrayOop anno) | |
| 568 { set_methods_annotations_of(idnum, anno, &_methods_annotations); } | |
| 569 void set_method_parameter_annotations_of(int idnum, typeArrayOop anno) | |
| 570 { set_methods_annotations_of(idnum, anno, &_methods_annotations); } | |
| 571 void set_method_default_annotations_of(int idnum, typeArrayOop anno) | |
| 572 { set_methods_annotations_of(idnum, anno, &_methods_annotations); } | |
| 573 | |
| 574 // allocation | |
| 575 DEFINE_ALLOCATE_PERMANENT(instanceKlass); | |
| 576 instanceOop allocate_instance(TRAPS); | |
| 577 instanceOop allocate_permanent_instance(TRAPS); | |
| 578 | |
| 579 // additional member function to return a handle | |
| 580 instanceHandle allocate_instance_handle(TRAPS) { return instanceHandle(THREAD, allocate_instance(THREAD)); } | |
| 581 | |
| 582 objArrayOop allocate_objArray(int n, int length, TRAPS); | |
| 583 // Helper function | |
| 584 static instanceOop register_finalizer(instanceOop i, TRAPS); | |
| 585 | |
| 586 // Check whether reflection/jni/jvm code is allowed to instantiate this class; | |
| 587 // if not, throw either an Error or an Exception. | |
| 588 virtual void check_valid_for_instantiation(bool throwError, TRAPS); | |
| 589 | |
| 590 // initialization | |
| 591 void call_class_initializer(TRAPS); | |
| 592 void set_initialization_state_and_notify(ClassState state, TRAPS); | |
| 593 | |
| 594 // OopMapCache support | |
| 595 OopMapCache* oop_map_cache() { return _oop_map_cache; } | |
| 596 void set_oop_map_cache(OopMapCache *cache) { _oop_map_cache = cache; } | |
| 597 void mask_for(methodHandle method, int bci, InterpreterOopMap* entry); | |
| 598 | |
| 599 // JNI identifier support (for static fields - for jni performance) | |
| 600 JNIid* jni_ids() { return _jni_ids; } | |
| 601 void set_jni_ids(JNIid* ids) { _jni_ids = ids; } | |
| 602 JNIid* jni_id_for(int offset); | |
| 603 | |
| 604 // maintenance of deoptimization dependencies | |
| 605 int mark_dependent_nmethods(DepChange& changes); | |
| 606 void add_dependent_nmethod(nmethod* nm); | |
| 607 void remove_dependent_nmethod(nmethod* nm); | |
| 608 | |
| 609 // On-stack replacement support | |
| 610 nmethod* osr_nmethods_head() const { return _osr_nmethods_head; }; | |
| 611 void set_osr_nmethods_head(nmethod* h) { _osr_nmethods_head = h; }; | |
| 612 void add_osr_nmethod(nmethod* n); | |
| 613 void remove_osr_nmethod(nmethod* n); | |
| 1783 | 614 nmethod* lookup_osr_nmethod(const methodOop m, int bci, int level, bool match_level) const; |
| 0 | 615 |
| 616 // Breakpoint support (see methods on methodOop for details) | |
| 617 BreakpointInfo* breakpoints() const { return _breakpoints; }; | |
| 618 void set_breakpoints(BreakpointInfo* bps) { _breakpoints = bps; }; | |
| 619 | |
| 620 // support for stub routines | |
| 621 static int init_state_offset_in_bytes() { return offset_of(instanceKlass, _init_state); } | |
| 622 static int init_thread_offset_in_bytes() { return offset_of(instanceKlass, _init_thread); } | |
| 623 | |
| 624 // subclass/subinterface checks | |
| 625 bool implements_interface(klassOop k) const; | |
| 626 | |
| 627 // Access to implementors of an interface. We only store the count | |
| 628 // of implementors, and in case, there are only a few | |
| 629 // implementors, we store them in a short list. | |
| 630 // This accessor returns NULL if we walk off the end of the list. | |
| 631 klassOop implementor(int i) const { | |
| 632 return (i < implementors_limit)? _implementors[i]: (klassOop) NULL; | |
| 633 } | |
| 634 int nof_implementors() const { return _nof_implementors; } | |
| 635 void add_implementor(klassOop k); // k is a new class that implements this interface | |
| 636 void init_implementor(); // initialize | |
| 637 | |
| 638 // link this class into the implementors list of every interface it implements | |
| 639 void process_interfaces(Thread *thread); | |
| 640 | |
| 641 // virtual operations from Klass | |
| 642 bool is_leaf_class() const { return _subklass == NULL; } | |
| 643 objArrayOop compute_secondary_supers(int num_extra_slots, TRAPS); | |
| 644 bool compute_is_subtype_of(klassOop k); | |
| 645 bool can_be_primary_super_slow() const; | |
| 646 klassOop java_super() const { return super(); } | |
| 647 int oop_size(oop obj) const { return size_helper(); } | |
| 648 int klass_oop_size() const { return object_size(); } | |
| 649 bool oop_is_instance_slow() const { return true; } | |
| 650 | |
| 651 // Iterators | |
| 652 void do_local_static_fields(FieldClosure* cl); | |
| 653 void do_nonstatic_fields(FieldClosure* cl); // including inherited fields | |
| 654 void do_local_static_fields(void f(fieldDescriptor*, TRAPS), TRAPS); | |
| 655 | |
| 656 void methods_do(void f(methodOop method)); | |
| 657 void array_klasses_do(void f(klassOop k)); | |
| 658 void with_array_klasses_do(void f(klassOop k)); | |
| 659 bool super_types_do(SuperTypeClosure* blk); | |
| 660 | |
| 661 // Casting from klassOop | |
| 662 static instanceKlass* cast(klassOop k) { | |
|
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2357
diff
changeset
|
663 assert(k->is_klass(), "must be"); |
| 0 | 664 Klass* kp = k->klass_part(); |
| 665 assert(kp->null_vtbl() || kp->oop_is_instance_slow(), "cast to instanceKlass"); | |
| 666 return (instanceKlass*) kp; | |
| 667 } | |
| 668 | |
| 669 // Sizing (in words) | |
| 670 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
|
671 int object_size() const { return object_size(align_object_offset(vtable_length()) + align_object_offset(itable_length()) + nonstatic_oop_map_size()); } |
| 0 | 672 static int vtable_start_offset() { return header_size(); } |
| 673 static int vtable_length_offset() { return oopDesc::header_size() + offset_of(instanceKlass, _vtable_len) / HeapWordSize; } | |
| 674 static int object_size(int extra) { return align_object_size(header_size() + extra); } | |
| 675 | |
| 676 intptr_t* start_of_vtable() const { return ((intptr_t*)as_klassOop()) + vtable_start_offset(); } | |
| 677 intptr_t* start_of_itable() const { return start_of_vtable() + align_object_offset(vtable_length()); } | |
| 678 int itable_offset_in_words() const { return start_of_itable() - (intptr_t*)as_klassOop(); } | |
| 679 | |
| 680 intptr_t* end_of_itable() const { return start_of_itable() + itable_length(); } | |
| 681 | |
|
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2357
diff
changeset
|
682 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
|
683 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
49
diff
changeset
|
684 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
|
685 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
|
686 } |
| 0 | 687 |
| 688 // Allocation profiling support | |
| 689 juint alloc_size() const { return _alloc_count * size_helper(); } | |
| 690 void set_alloc_size(juint n) {} | |
| 691 | |
| 692 // Use this to return the size of an instance in heap words: | |
| 693 int size_helper() const { | |
| 694 return layout_helper_to_size_helper(layout_helper()); | |
| 695 } | |
| 696 | |
| 697 // This bit is initialized in classFileParser.cpp. | |
| 698 // It is false under any of the following conditions: | |
| 699 // - the class is abstract (including any interface) | |
| 700 // - the class has a finalizer (if !RegisterFinalizersAtInit) | |
| 701 // - the class size is larger than FastAllocateSizeLimit | |
| 702 // - the class is java/lang/Class, which cannot be allocated directly | |
| 703 bool can_be_fastpath_allocated() const { | |
| 704 return !layout_helper_needs_slow_path(layout_helper()); | |
| 705 } | |
| 706 | |
| 707 // Java vtable/itable | |
| 708 klassVtable* vtable() const; // return new klassVtable wrapper | |
| 709 inline methodOop method_at_vtable(int index); | |
| 710 klassItable* itable() const; // return new klassItable wrapper | |
| 711 methodOop method_at_itable(klassOop holder, int index, TRAPS); | |
| 712 | |
| 713 // Garbage collection | |
| 714 void oop_follow_contents(oop obj); | |
| 715 int oop_adjust_pointers(oop obj); | |
| 716 bool object_is_parsable() const { return _init_state != unparsable_by_gc; } | |
| 717 // Value of _init_state must be zero (unparsable_by_gc) when klass field is set. | |
| 718 | |
| 719 void follow_weak_klass_links( | |
| 720 BoolObjectClosure* is_alive, OopClosure* keep_alive); | |
| 721 void release_C_heap_structures(); | |
| 722 | |
| 723 // Parallel Scavenge and Parallel Old | |
| 724 PARALLEL_GC_DECLS | |
| 725 | |
| 726 // Naming | |
|
1039
987e948ebbc8
6815692: method handle code needs some cleanup (post-6655638)
jrose
parents:
977
diff
changeset
|
727 const char* signature_name() const; |
| 0 | 728 |
| 729 // Iterators | |
| 730 int oop_oop_iterate(oop obj, OopClosure* blk) { | |
| 731 return oop_oop_iterate_v(obj, blk); | |
| 732 } | |
| 733 | |
| 734 int oop_oop_iterate_m(oop obj, OopClosure* blk, MemRegion mr) { | |
| 735 return oop_oop_iterate_v_m(obj, blk, mr); | |
| 736 } | |
| 737 | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
738 #define InstanceKlass_OOP_OOP_ITERATE_DECL(OopClosureType, nv_suffix) \ |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
739 int oop_oop_iterate##nv_suffix(oop obj, OopClosureType* blk); \ |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
740 int oop_oop_iterate##nv_suffix##_m(oop obj, OopClosureType* blk, \ |
| 0 | 741 MemRegion mr); |
| 742 | |
| 743 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
|
744 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
|
745 |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
746 #ifndef SERIALGC |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
747 #define InstanceKlass_OOP_OOP_ITERATE_BACKWARDS_DECL(OopClosureType, nv_suffix) \ |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
748 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
|
749 |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
750 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
|
751 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
|
752 #endif // !SERIALGC |
| 0 | 753 |
| 754 private: | |
| 755 // initialization state | |
| 756 #ifdef ASSERT | |
| 757 void set_init_state(ClassState state); | |
| 758 #else | |
| 759 void set_init_state(ClassState state) { _init_state = state; } | |
| 760 #endif | |
| 975 | 761 void set_rewritten() { _rewritten = true; } |
| 0 | 762 void set_init_thread(Thread *thread) { _init_thread = thread; } |
| 763 | |
| 764 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
|
765 // 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
|
766 // 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
|
767 // 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
|
768 // going from NULL to non-NULL. |
|
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
975
diff
changeset
|
769 bool idnum_can_increment() const { return has_been_redefined(); } |
| 0 | 770 jmethodID* methods_jmethod_ids_acquire() const |
| 771 { return (jmethodID*)OrderAccess::load_ptr_acquire(&_methods_jmethod_ids); } | |
| 772 void release_set_methods_jmethod_ids(jmethodID* jmeths) | |
| 773 { OrderAccess::release_store_ptr(&_methods_jmethod_ids, jmeths); } | |
| 774 | |
| 775 int* methods_cached_itable_indices_acquire() const | |
| 776 { return (int*)OrderAccess::load_ptr_acquire(&_methods_cached_itable_indices); } | |
| 777 void release_set_methods_cached_itable_indices(int* indices) | |
| 778 { OrderAccess::release_store_ptr(&_methods_cached_itable_indices, indices); } | |
| 779 | |
| 780 inline typeArrayOop get_method_annotations_from(int idnum, objArrayOop annos); | |
| 781 void set_annotations(objArrayOop md, objArrayOop* md_p) { oop_store_without_check((oop*)md_p, (oop)md); } | |
| 782 void set_methods_annotations_of(int idnum, typeArrayOop anno, objArrayOop* md_p); | |
| 783 | |
| 784 // Offsets for memory management | |
| 785 oop* adr_array_klasses() const { return (oop*)&this->_array_klasses;} | |
| 786 oop* adr_methods() const { return (oop*)&this->_methods;} | |
| 787 oop* adr_method_ordering() const { return (oop*)&this->_method_ordering;} | |
| 788 oop* adr_local_interfaces() const { return (oop*)&this->_local_interfaces;} | |
| 789 oop* adr_transitive_interfaces() const { return (oop*)&this->_transitive_interfaces;} | |
| 790 oop* adr_fields() const { return (oop*)&this->_fields;} | |
| 791 oop* adr_constants() const { return (oop*)&this->_constants;} | |
| 792 oop* adr_class_loader() const { return (oop*)&this->_class_loader;} | |
| 793 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
|
794 oop* adr_host_klass() const { return (oop*)&this->_host_klass;} |
| 0 | 795 oop* adr_signers() const { return (oop*)&this->_signers;} |
| 796 oop* adr_inner_classes() const { return (oop*)&this->_inner_classes;} | |
| 797 oop* adr_implementors() const { return (oop*)&this->_implementors[0];} | |
|
2356
72dee110246f
6839872: remove implementation inheritance from JSR 292 APIs
jrose
parents:
2227
diff
changeset
|
798 oop* adr_bootstrap_method() const { return (oop*)&this->_bootstrap_method;} // AllowTransitionalJSR292 ONLY |
| 0 | 799 oop* adr_methods_jmethod_ids() const { return (oop*)&this->_methods_jmethod_ids;} |
| 800 oop* adr_methods_cached_itable_indices() const { return (oop*)&this->_methods_cached_itable_indices;} | |
| 801 oop* adr_class_annotations() const { return (oop*)&this->_class_annotations;} | |
| 802 oop* adr_fields_annotations() const { return (oop*)&this->_fields_annotations;} | |
| 803 oop* adr_methods_annotations() const { return (oop*)&this->_methods_annotations;} | |
| 804 oop* adr_methods_parameter_annotations() const { return (oop*)&this->_methods_parameter_annotations;} | |
| 805 oop* adr_methods_default_annotations() const { return (oop*)&this->_methods_default_annotations;} | |
| 806 | |
| 807 // Static methods that are used to implement member methods where an exposed this pointer | |
| 808 // is needed due to possible GCs | |
| 809 static bool link_class_impl (instanceKlassHandle this_oop, bool throw_verifyerror, TRAPS); | |
| 810 static bool verify_code (instanceKlassHandle this_oop, bool throw_verifyerror, TRAPS); | |
| 811 static void initialize_impl (instanceKlassHandle this_oop, TRAPS); | |
| 812 static void eager_initialize_impl (instanceKlassHandle this_oop); | |
| 813 static void set_initialization_state_and_notify_impl (instanceKlassHandle this_oop, ClassState state, TRAPS); | |
| 814 static void call_class_initializer_impl (instanceKlassHandle this_oop, TRAPS); | |
| 815 static klassOop array_klass_impl (instanceKlassHandle this_oop, bool or_null, int n, TRAPS); | |
| 816 static void do_local_static_fields_impl (instanceKlassHandle this_oop, void f(fieldDescriptor* fd, TRAPS), TRAPS); | |
| 817 /* jni_id_for_impl for jfieldID only */ | |
| 818 static JNIid* jni_id_for_impl (instanceKlassHandle this_oop, int offset); | |
| 819 | |
| 820 // Returns the array class for the n'th dimension | |
| 821 klassOop array_klass_impl(bool or_null, int n, TRAPS); | |
| 822 | |
| 823 // Returns the array class with this class as element type | |
| 824 klassOop array_klass_impl(bool or_null, TRAPS); | |
| 825 | |
| 826 public: | |
| 827 // sharing support | |
| 828 virtual void remove_unshareable_info(); | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
829 virtual void shared_symbols_iterate(SymbolClosure* closure); |
| 0 | 830 |
| 831 // jvm support | |
| 832 jint compute_modifier_flags(TRAPS) const; | |
| 833 | |
| 834 public: | |
| 835 // JVMTI support | |
| 836 jint jvmti_class_status() const; | |
| 837 | |
| 838 public: | |
| 839 // Printing | |
|
1155
4e6abf09f540
6912062: disassembler plugin needs to produce symbolic information in product mode
jrose
parents:
1126
diff
changeset
|
840 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
|
841 #ifndef PRODUCT |
| 0 | 842 void oop_print_on (oop obj, outputStream* st); |
| 843 | |
| 844 void print_dependent_nmethods(bool verbose = false); | |
| 845 bool is_dependent_nmethod(nmethod* nm); | |
| 846 #endif | |
| 847 | |
| 848 // Verification | |
| 849 const char* internal_name() const; | |
| 850 void oop_verify_on(oop obj, outputStream* st); | |
| 851 | |
| 852 #ifndef PRODUCT | |
| 853 static void verify_class_klass_nonstatic_oop_maps(klassOop k) PRODUCT_RETURN; | |
| 854 #endif | |
| 855 }; | |
| 856 | |
| 857 inline methodOop instanceKlass::method_at_vtable(int index) { | |
| 858 #ifndef PRODUCT | |
| 859 assert(index >= 0, "valid vtable index"); | |
| 860 if (DebugVtables) { | |
| 861 verify_vtable_index(index); | |
| 862 } | |
| 863 #endif | |
| 864 vtableEntry* ve = (vtableEntry*)start_of_vtable(); | |
| 865 return ve[index].method(); | |
| 866 } | |
| 867 | |
| 868 inline typeArrayOop instanceKlass::get_method_annotations_from(int idnum, objArrayOop annos) { | |
| 869 if (annos == NULL || annos->length() <= idnum) { | |
| 870 return NULL; | |
| 871 } | |
| 872 return typeArrayOop(annos->obj_at(idnum)); | |
| 873 } | |
| 874 | |
| 875 // for adding methods | |
| 876 // UNSET_IDNUM return means no more ids available | |
| 877 inline u2 instanceKlass::next_method_idnum() { | |
| 878 if (_idnum_allocated_count == constMethodOopDesc::MAX_IDNUM) { | |
| 879 return constMethodOopDesc::UNSET_IDNUM; // no more ids available | |
| 880 } else { | |
| 881 return _idnum_allocated_count++; | |
| 882 } | |
| 883 } | |
| 884 | |
| 885 | |
| 886 /* JNIid class for jfieldIDs only */ | |
| 887 class JNIid: public CHeapObj { | |
| 888 friend class VMStructs; | |
| 889 private: | |
| 890 klassOop _holder; | |
| 891 JNIid* _next; | |
| 892 int _offset; | |
| 893 #ifdef ASSERT | |
| 894 bool _is_static_field_id; | |
| 895 #endif | |
| 896 | |
| 897 public: | |
| 898 // Accessors | |
| 899 klassOop holder() const { return _holder; } | |
| 900 int offset() const { return _offset; } | |
| 901 JNIid* next() { return _next; } | |
| 902 // Constructor | |
| 903 JNIid(klassOop holder, int offset, JNIid* next); | |
| 904 // Identifier lookup | |
| 905 JNIid* find(int offset); | |
| 906 | |
|
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2357
diff
changeset
|
907 bool find_local_field(fieldDescriptor* fd) { |
|
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2357
diff
changeset
|
908 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
|
909 } |
|
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2357
diff
changeset
|
910 |
| 0 | 911 // Garbage collection support |
| 912 oop* holder_addr() { return (oop*)&_holder; } | |
| 913 void oops_do(OopClosure* f); | |
| 914 static void deallocate(JNIid* id); | |
| 915 // Debugging | |
| 916 #ifdef ASSERT | |
| 917 bool is_static_field_id() const { return _is_static_field_id; } | |
| 918 void set_is_static_field_id() { _is_static_field_id = true; } | |
| 919 #endif | |
| 920 void verify(klassOop holder); | |
| 921 }; | |
| 922 | |
| 923 | |
| 924 // If breakpoints are more numerous than just JVMTI breakpoints, | |
| 925 // consider compressing this data structure. | |
| 926 // It is currently a simple linked list defined in methodOop.hpp. | |
| 927 | |
| 928 class BreakpointInfo; | |
| 929 | |
| 930 | |
| 931 // A collection point for interesting information about the previous | |
| 932 // version(s) of an instanceKlass. This class uses weak references to | |
| 933 // 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
|
934 // 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
|
935 // 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
|
936 // collectible. A GrowableArray of PreviousVersionNodes is attached |
| 0 | 937 // to the instanceKlass as needed. See PreviousVersionWalker below. |
| 938 class PreviousVersionNode : public CHeapObj { | |
| 939 private: | |
|
47
2c106685d6d0
6497639: 4/3 Profiling Swing application caused JVM crash
dcubed
parents:
0
diff
changeset
|
940 // 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
|
941 // 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
|
942 // 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
|
943 // 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
|
944 // non-shared ConstantPool becomes collectible at that point. |
|
2c106685d6d0
6497639: 4/3 Profiling Swing application caused JVM crash
dcubed
parents:
0
diff
changeset
|
945 jobject _prev_constant_pool; // regular or weak reference |
|
2c106685d6d0
6497639: 4/3 Profiling Swing application caused JVM crash
dcubed
parents:
0
diff
changeset
|
946 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
|
947 |
| 0 | 948 // If the previous version of the instanceKlass doesn't have any |
| 949 // EMCP methods, then _prev_EMCP_methods will be NULL. If all the | |
| 950 // EMCP methods have been collected, then _prev_EMCP_methods can | |
| 951 // have a length of zero. | |
| 952 GrowableArray<jweak>* _prev_EMCP_methods; | |
| 953 | |
| 954 public: | |
|
47
2c106685d6d0
6497639: 4/3 Profiling Swing application caused JVM crash
dcubed
parents:
0
diff
changeset
|
955 PreviousVersionNode(jobject prev_constant_pool, bool prev_cp_is_weak, |
| 0 | 956 GrowableArray<jweak>* prev_EMCP_methods); |
| 957 ~PreviousVersionNode(); | |
|
47
2c106685d6d0
6497639: 4/3 Profiling Swing application caused JVM crash
dcubed
parents:
0
diff
changeset
|
958 jobject prev_constant_pool() const { |
| 0 | 959 return _prev_constant_pool; |
| 960 } | |
| 961 GrowableArray<jweak>* prev_EMCP_methods() const { | |
| 962 return _prev_EMCP_methods; | |
| 963 } | |
| 964 }; | |
| 965 | |
| 966 | |
| 967 // A Handle-ized version of PreviousVersionNode. | |
| 968 class PreviousVersionInfo : public ResourceObj { | |
| 969 private: | |
| 970 constantPoolHandle _prev_constant_pool_handle; | |
| 971 // If the previous version of the instanceKlass doesn't have any | |
| 972 // EMCP methods, then _prev_EMCP_methods will be NULL. Since the | |
| 973 // methods cannot be collected while we hold a handle, | |
| 974 // _prev_EMCP_methods should never have a length of zero. | |
| 975 GrowableArray<methodHandle>* _prev_EMCP_method_handles; | |
| 976 | |
| 977 public: | |
| 978 PreviousVersionInfo(PreviousVersionNode *pv_node); | |
| 979 ~PreviousVersionInfo(); | |
| 980 constantPoolHandle prev_constant_pool_handle() const { | |
| 981 return _prev_constant_pool_handle; | |
| 982 } | |
| 983 GrowableArray<methodHandle>* prev_EMCP_method_handles() const { | |
| 984 return _prev_EMCP_method_handles; | |
| 985 } | |
| 986 }; | |
| 987 | |
| 988 | |
| 989 // Helper object for walking previous versions. This helper cleans up | |
| 990 // the Handles that it allocates when the helper object is destroyed. | |
| 991 // The PreviousVersionInfo object returned by next_previous_version() | |
| 992 // is only valid until a subsequent call to next_previous_version() or | |
| 993 // the helper object is destroyed. | |
| 994 class PreviousVersionWalker : public StackObj { | |
| 995 private: | |
| 996 GrowableArray<PreviousVersionNode *>* _previous_versions; | |
| 997 int _current_index; | |
| 998 // Fields for cleaning up when we are done walking the previous versions: | |
| 999 // A HandleMark for the PreviousVersionInfo handles: | |
| 1000 HandleMark _hm; | |
| 1001 | |
| 1002 // It would be nice to have a ResourceMark field in this helper also, | |
| 1003 // but the ResourceMark code says to be careful to delete handles held | |
| 1004 // in GrowableArrays _before_ deleting the GrowableArray. Since we | |
| 1005 // can't guarantee the order in which the fields are destroyed, we | |
| 1006 // have to let the creator of the PreviousVersionWalker object do | |
| 1007 // the right thing. Also, adding a ResourceMark here causes an | |
| 1008 // include loop. | |
| 1009 | |
| 1010 // A pointer to the current info object so we can handle the deletes. | |
| 1011 PreviousVersionInfo * _current_p; | |
| 1012 | |
| 1013 public: | |
| 1014 PreviousVersionWalker(instanceKlass *ik); | |
| 1015 ~PreviousVersionWalker(); | |
| 1016 | |
| 1017 // Return the interesting information for the next previous version | |
| 1018 // of the klass. Returns NULL if there are no more previous versions. | |
| 1019 PreviousVersionInfo* next_previous_version(); | |
| 1020 }; | |
| 1972 | 1021 |
| 1022 #endif // SHARE_VM_OOPS_INSTANCEKLASS_HPP |