1 /* 2 * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. 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 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 * 23 */ 24 25 #ifndef SHARE_VM_OOPS_INSTANCEKLASS_HPP 26 #define SHARE_VM_OOPS_INSTANCEKLASS_HPP 27 28 #include "classfile/classLoaderData.hpp" 29 #include "oops/annotations.hpp" 30 #include "oops/constMethod.hpp" 31 #include "oops/fieldInfo.hpp" 32 #include "oops/instanceOop.hpp" 33 #include "oops/klassVtable.hpp" 34 #include "runtime/atomic.hpp" 35 #include "runtime/handles.hpp" 36 #include "runtime/os.hpp" 37 #include "utilities/accessFlags.hpp" 38 #include "utilities/bitMap.inline.hpp" 39 40 // An InstanceKlass is the VM level representation of a Java class. 41 // It contains all information needed for at class at execution runtime. 42 43 // InstanceKlass layout: 44 // [C++ vtbl pointer ] Klass 45 // [subtype cache ] Klass 46 // [instance size ] Klass 47 // [java mirror ] Klass 48 // [super ] Klass 49 // [access_flags ] Klass 50 // [name ] Klass 51 // [first subklass ] Klass 52 // [next sibling ] Klass 53 // [array klasses ] 54 // [methods ] 55 // [local interfaces ] 56 // [transitive interfaces ] 57 // [fields ] 58 // [constants ] 59 // [class loader ] 60 // [protection domain ] 61 // [signers ] 62 // [source file name ] 63 // [inner classes ] 64 // [static field size ] 65 // [nonstatic field size ] 66 // [static oop fields size ] 67 // [nonstatic oop maps size ] 68 // [has finalize method ] 69 // [deoptimization mark bit ] 70 // [initialization state ] 71 // [initializing thread ] 72 // [Java vtable length ] 73 // [oop map cache (stack maps) ] 74 // [EMBEDDED Java vtable ] size in words = vtable_len 75 // [EMBEDDED nonstatic oop-map blocks] size in words = nonstatic_oop_map_size 76 // The embedded nonstatic oop-map blocks are short pairs (offset, length) 77 // indicating where oops are located in instances of this klass. 78 // [EMBEDDED implementor of the interface] only exist for interface 79 // [EMBEDDED host klass ] only exist for an anonymous class (JSR 292 enabled) 80 81 82 // forward declaration for class -- see below for definition 83 class SuperTypeClosure; 84 class JNIid; 85 class jniIdMapBase; 86 class BreakpointInfo; 87 class fieldDescriptor; 88 class DepChange; 89 class nmethodBucket; 90 class PreviousVersionNode; 91 class JvmtiCachedClassFieldMap; 92 93 // This is used in iterators below. 94 class FieldClosure: public StackObj { 95 public: 96 virtual void do_field(fieldDescriptor* fd) = 0; 97 }; 98 99 #ifndef PRODUCT 100 // Print fields. 101 // If "obj" argument to constructor is NULL, prints static fields, otherwise prints non-static fields. 102 class FieldPrinter: public FieldClosure { 103 oop _obj; 104 outputStream* _st; 105 public: 106 FieldPrinter(outputStream* st, oop obj = NULL) : _obj(obj), _st(st) {} 107 void do_field(fieldDescriptor* fd); 108 }; 109 #endif // !PRODUCT 110 111 // ValueObjs embedded in klass. Describes where oops are located in instances of 112 // this klass. 113 class OopMapBlock VALUE_OBJ_CLASS_SPEC { 114 public: 115 // Byte offset of the first oop mapped by this block. 116 int offset() const { return _offset; } 117 void set_offset(int offset) { _offset = offset; } 118 119 // Number of oops in this block. 120 uint count() const { return _count; } 121 void set_count(uint count) { _count = count; } 122 123 // sizeof(OopMapBlock) in HeapWords. 124 static const int size_in_words() { 125 return align_size_up(int(sizeof(OopMapBlock)), HeapWordSize) >> 126 LogHeapWordSize; 127 } 128 129 private: 130 int _offset; 131 uint _count; 132 }; 133 134 class InstanceKlass: public Klass { 135 friend class VMStructs; 136 friend class ClassFileParser; 137 friend class CompileReplay; 138 139 protected: 140 // Constructor 141 InstanceKlass(int vtable_len, 142 int itable_len, 143 int static_field_size, 144 int nonstatic_oop_map_size, 145 ReferenceType rt, 146 AccessFlags access_flags, 147 bool is_anonymous); 148 public: 149 static Klass* allocate_instance_klass(ClassLoaderData* loader_data, 150 int vtable_len, 151 int itable_len, 152 int static_field_size, 153 int nonstatic_oop_map_size, 154 ReferenceType rt, 155 AccessFlags access_flags, 156 Symbol* name, 157 Klass* super_klass, 158 KlassHandle host_klass, 159 TRAPS); 160 161 InstanceKlass() { assert(DumpSharedSpaces || UseSharedSpaces, "only for CDS"); } 162 163 // See "The Java Virtual Machine Specification" section 2.16.2-5 for a detailed description 164 // of the class loading & initialization procedure, and the use of the states. 165 enum ClassState { 166 allocated, // allocated (but not yet linked) 167 loaded, // loaded and inserted in class hierarchy (but not linked yet) 168 linked, // successfully linked/verified (but not initialized yet) 169 being_initialized, // currently running class initializer 170 fully_initialized, // initialized (successfull final state) 171 initialization_error // error happened during initialization 172 }; 173 174 static int number_of_instance_classes() { return _total_instanceKlass_count; } 175 176 private: 177 static volatile int _total_instanceKlass_count; 178 179 protected: 180 // Protection domain. 181 oop _protection_domain; 182 // Class signers. 183 objArrayOop _signers; 184 // Initialization lock. Must be one per class and it has to be a VM internal 185 // object so java code cannot lock it (like the mirror) 186 // It has to be an object not a Mutex because it's held through java calls. 187 volatile oop _init_lock; 188 189 // Annotations for this class 190 Annotations* _annotations; 191 // Array classes holding elements of this class. 192 Klass* _array_klasses; 193 // Constant pool for this class. 194 ConstantPool* _constants; 195 // The InnerClasses attribute and EnclosingMethod attribute. The 196 // _inner_classes is an array of shorts. If the class has InnerClasses 197 // attribute, then the _inner_classes array begins with 4-tuples of shorts 198 // [inner_class_info_index, outer_class_info_index, 199 // inner_name_index, inner_class_access_flags] for the InnerClasses 200 // attribute. If the EnclosingMethod attribute exists, it occupies the 201 // last two shorts [class_index, method_index] of the array. If only 202 // the InnerClasses attribute exists, the _inner_classes array length is 203 // number_of_inner_classes * 4. If the class has both InnerClasses 204 // and EnclosingMethod attributes the _inner_classes array length is 205 // number_of_inner_classes * 4 + enclosing_method_attribute_size. 206 Array<jushort>* _inner_classes; 207 208 // Name of source file containing this klass, NULL if not specified. 209 Symbol* _source_file_name; 210 // the source debug extension for this klass, NULL if not specified. 211 // Specified as UTF-8 string without terminating zero byte in the classfile, 212 // it is stored in the instanceklass as a NULL-terminated UTF-8 string 213 char* _source_debug_extension; 214 // Generic signature, or null if none. 215 Symbol* _generic_signature; 216 // Array name derived from this class which needs unreferencing 217 // if this class is unloaded. 218 Symbol* _array_name; 219 220 // Number of heapOopSize words used by non-static fields in this klass 221 // (including inherited fields but after header_size()). 222 int _nonstatic_field_size; 223 int _static_field_size; // number words used by static fields (oop and non-oop) in this klass 224 u2 _static_oop_field_count;// number of static oop fields in this klass 225 u2 _java_fields_count; // The number of declared Java fields 226 int _nonstatic_oop_map_size;// size in words of nonstatic oop map blocks 227 228 // _is_marked_dependent can be set concurrently, thus cannot be part of the 229 // _misc_flags. 230 bool _is_marked_dependent; // used for marking during flushing and deoptimization 231 232 enum { 233 _misc_rewritten = 1 << 0, // methods rewritten. 234 _misc_has_nonstatic_fields = 1 << 1, // for sizing with UseCompressedOops 235 _misc_should_verify_class = 1 << 2, // allow caching of preverification 236 _misc_is_anonymous = 1 << 3, // has embedded _inner_classes field 237 _misc_is_contended = 1 << 4, // marked with contended annotation 238 _misc_has_default_methods = 1 << 5 // class/superclass/implemented interfaces has default methods 239 }; 240 u2 _misc_flags; 241 u2 _minor_version; // minor version number of class file 242 u2 _major_version; // major version number of class file 243 Thread* _init_thread; // Pointer to current thread doing initialization (to handle recusive initialization) 244 int _vtable_len; // length of Java vtable (in words) 245 int _itable_len; // length of Java itable (in words) 246 OopMapCache* volatile _oop_map_cache; // OopMapCache for all methods in the klass (allocated lazily) 247 JNIid* _jni_ids; // First JNI identifier for static fields in this class 248 jmethodID* _methods_jmethod_ids; // jmethodIDs corresponding to method_idnum, or NULL if none 249 int* _methods_cached_itable_indices; // itable_index cache for JNI invoke corresponding to methods idnum, or NULL 250 nmethodBucket* _dependencies; // list of dependent nmethods 251 nmethod* _osr_nmethods_head; // Head of list of on-stack replacement nmethods for this class 252 BreakpointInfo* _breakpoints; // bpt lists, managed by Method* 253 // Array of interesting part(s) of the previous version(s) of this 254 // InstanceKlass. See PreviousVersionWalker below. 255 GrowableArray<PreviousVersionNode *>* _previous_versions; 256 // JVMTI fields can be moved to their own structure - see 6315920 257 unsigned char * _cached_class_file_bytes; // JVMTI: cached class file, before retransformable agent modified it in CFLH 258 jint _cached_class_file_len; // JVMTI: length of above 259 JvmtiCachedClassFieldMap* _jvmti_cached_class_field_map; // JVMTI: used during heap iteration 260 261 // Method array. 262 Array<Method*>* _methods; 263 // Interface (Klass*s) this class declares locally to implement. 264 Array<Klass*>* _local_interfaces; 265 // Interface (Klass*s) this class implements transitively. 266 Array<Klass*>* _transitive_interfaces; 267 // Int array containing the original order of method in the class file (for JVMTI). 268 Array<int>* _method_ordering; 269 // Instance and static variable information, starts with 6-tuples of shorts 270 // [access, name index, sig index, initval index, low_offset, high_offset] 271 // for all fields, followed by the generic signature data at the end of 272 // the array. Only fields with generic signature attributes have the generic 273 // signature data set in the array. The fields array looks like following: 274 // 275 // f1: [access, name index, sig index, initial value index, low_offset, high_offset] 276 // f2: [access, name index, sig index, initial value index, low_offset, high_offset] 277 // ... 278 // fn: [access, name index, sig index, initial value index, low_offset, high_offset] 279 // [generic signature index] 280 // [generic signature index] 281 // ... 282 Array<u2>* _fields; 283 284 volatile u2 _idnum_allocated_count; // JNI/JVMTI: increments with the addition of methods, old ids don't change 285 286 // Class states are defined as ClassState (see above). 287 // Place the _init_state here to utilize the unused 2-byte after 288 // _idnum_allocated_count. 289 u1 _init_state; // state of class 290 291 u1 _reference_type; // reference type 292 293 // embedded Java vtable follows here 294 // embedded Java itables follows here 295 // embedded static fields follows here 296 // embedded nonstatic oop-map blocks follows here 297 // embedded implementor of this interface follows here 298 // The embedded implementor only exists if the current klass is an 299 // iterface. The possible values of the implementor fall into following 300 // three cases: 301 // NULL: no implementor. 302 // A Klass* that's not itself: one implementor. 303 // Itsef: more than one implementors. 304 // embedded host klass follows here 305 // The embedded host klass only exists in an anonymous class for 306 // dynamic language support (JSR 292 enabled). The host class grants 307 // its access privileges to this class also. The host class is either 308 // named, or a previously loaded anonymous class. A non-anonymous class 309 // or an anonymous class loaded through normal classloading does not 310 // have this embedded field. 311 // 312 313 friend class SystemDictionary; 314 315 public: 316 bool has_nonstatic_fields() const { 317 return (_misc_flags & _misc_has_nonstatic_fields) != 0; 318 } 319 void set_has_nonstatic_fields(bool b) { 320 if (b) { 321 _misc_flags |= _misc_has_nonstatic_fields; 322 } else { 323 _misc_flags &= ~_misc_has_nonstatic_fields; 324 } 325 } 326 327 // field sizes 328 int nonstatic_field_size() const { return _nonstatic_field_size; } 329 void set_nonstatic_field_size(int size) { _nonstatic_field_size = size; } 330 331 int static_field_size() const { return _static_field_size; } 332 void set_static_field_size(int size) { _static_field_size = size; } 333 334 int static_oop_field_count() const { return (int)_static_oop_field_count; } 335 void set_static_oop_field_count(u2 size) { _static_oop_field_count = size; } 336 337 // Java vtable 338 int vtable_length() const { return _vtable_len; } 339 void set_vtable_length(int len) { _vtable_len = len; } 340 341 // Java itable 342 int itable_length() const { return _itable_len; } 343 void set_itable_length(int len) { _itable_len = len; } 344 345 // array klasses 346 Klass* array_klasses() const { return _array_klasses; } 347 void set_array_klasses(Klass* k) { _array_klasses = k; } 348 349 // methods 350 Array<Method*>* methods() const { return _methods; } 351 void set_methods(Array<Method*>* a) { _methods = a; } 352 Method* method_with_idnum(int idnum); 353 354 // method ordering 355 Array<int>* method_ordering() const { return _method_ordering; } 356 void set_method_ordering(Array<int>* m) { _method_ordering = m; } 357 358 // interfaces 359 Array<Klass*>* local_interfaces() const { return _local_interfaces; } 360 void set_local_interfaces(Array<Klass*>* a) { 361 guarantee(_local_interfaces == NULL || a == NULL, "Just checking"); 362 _local_interfaces = a; } 363 Array<Klass*>* transitive_interfaces() const { return _transitive_interfaces; } 364 void set_transitive_interfaces(Array<Klass*>* a) { 365 guarantee(_transitive_interfaces == NULL || a == NULL, "Just checking"); 366 _transitive_interfaces = a; } 367 368 private: 369 friend class fieldDescriptor; 370 FieldInfo* field(int index) const { return FieldInfo::from_field_array(_fields, index); } 371 372 public: 373 int field_offset (int index) const { return field(index)->offset(); } 374 int field_access_flags(int index) const { return field(index)->access_flags(); } 375 Symbol* field_name (int index) const { return field(index)->name(constants()); } 376 Symbol* field_signature (int index) const { return field(index)->signature(constants()); } 377 378 // Number of Java declared fields 379 int java_fields_count() const { return (int)_java_fields_count; } 380 381 Array<u2>* fields() const { return _fields; } 382 383 void set_fields(Array<u2>* f, u2 java_fields_count) { 384 guarantee(_fields == NULL || f == NULL, "Just checking"); 385 _fields = f; 386 _java_fields_count = java_fields_count; 387 } 388 389 // inner classes 390 Array<u2>* inner_classes() const { return _inner_classes; } 391 void set_inner_classes(Array<u2>* f) { _inner_classes = f; } 392 393 enum InnerClassAttributeOffset { 394 // From http://mirror.eng/products/jdk/1.1/docs/guide/innerclasses/spec/innerclasses.doc10.html#18814 395 inner_class_inner_class_info_offset = 0, 396 inner_class_outer_class_info_offset = 1, 397 inner_class_inner_name_offset = 2, 398 inner_class_access_flags_offset = 3, 399 inner_class_next_offset = 4 400 }; 401 402 enum EnclosingMethodAttributeOffset { 403 enclosing_method_class_index_offset = 0, 404 enclosing_method_method_index_offset = 1, 405 enclosing_method_attribute_size = 2 406 }; 407 408 // method override check 409 bool is_override(methodHandle super_method, Handle targetclassloader, Symbol* targetclassname, TRAPS); 410 411 // package 412 bool is_same_class_package(Klass* class2); 413 bool is_same_class_package(oop classloader2, Symbol* classname2); 414 static bool is_same_class_package(oop class_loader1, Symbol* class_name1, oop class_loader2, Symbol* class_name2); 415 416 // find an enclosing class (defined where original code was, in jvm.cpp!) 417 Klass* compute_enclosing_class(bool* inner_is_member, TRAPS) { 418 instanceKlassHandle self(THREAD, this); 419 return compute_enclosing_class_impl(self, inner_is_member, THREAD); 420 } 421 static Klass* compute_enclosing_class_impl(instanceKlassHandle self, 422 bool* inner_is_member, TRAPS); 423 424 // tell if two classes have the same enclosing class (at package level) 425 bool is_same_package_member(Klass* class2, TRAPS) { 426 instanceKlassHandle self(THREAD, this); 427 return is_same_package_member_impl(self, class2, THREAD); 428 } 429 static bool is_same_package_member_impl(instanceKlassHandle self, 430 Klass* class2, TRAPS); 431 432 // initialization state 433 bool is_loaded() const { return _init_state >= loaded; } 434 bool is_linked() const { return _init_state >= linked; } 435 bool is_initialized() const { return _init_state == fully_initialized; } 436 bool is_not_initialized() const { return _init_state < being_initialized; } 437 bool is_being_initialized() const { return _init_state == being_initialized; } 438 bool is_in_error_state() const { return _init_state == initialization_error; } 439 bool is_reentrant_initialization(Thread *thread) { return thread == _init_thread; } 440 ClassState init_state() { return (ClassState)_init_state; } 441 bool is_rewritten() const { return (_misc_flags & _misc_rewritten) != 0; } 442 443 // defineClass specified verification 444 bool should_verify_class() const { 445 return (_misc_flags & _misc_should_verify_class) != 0; 446 } 447 void set_should_verify_class(bool value) { 448 if (value) { 449 _misc_flags |= _misc_should_verify_class; 450 } else { 451 _misc_flags &= ~_misc_should_verify_class; 452 } 453 } 454 455 // marking 456 bool is_marked_dependent() const { return _is_marked_dependent; } 457 void set_is_marked_dependent(bool value) { _is_marked_dependent = value; } 458 459 // initialization (virtuals from Klass) 460 bool should_be_initialized() const; // means that initialize should be called 461 void initialize(TRAPS); 462 void link_class(TRAPS); 463 bool link_class_or_fail(TRAPS); // returns false on failure 464 void unlink_class(); 465 void rewrite_class(TRAPS); 466 void link_methods(TRAPS); 467 Method* class_initializer(); 468 469 // set the class to initialized if no static initializer is present 470 void eager_initialize(Thread *thread); 471 472 // reference type 473 ReferenceType reference_type() const { return (ReferenceType)_reference_type; } 474 void set_reference_type(ReferenceType t) { 475 assert(t == (u1)t, "overflow"); 476 _reference_type = (u1)t; 477 } 478 479 static ByteSize reference_type_offset() { return in_ByteSize(offset_of(InstanceKlass, _reference_type)); } 480 481 // find local field, returns true if found 482 bool find_local_field(Symbol* name, Symbol* sig, fieldDescriptor* fd) const; 483 // find field in direct superinterfaces, returns the interface in which the field is defined 484 Klass* find_interface_field(Symbol* name, Symbol* sig, fieldDescriptor* fd) const; 485 // find field according to JVM spec 5.4.3.2, returns the klass in which the field is defined 486 Klass* find_field(Symbol* name, Symbol* sig, fieldDescriptor* fd) const; 487 // find instance or static fields according to JVM spec 5.4.3.2, returns the klass in which the field is defined 488 Klass* find_field(Symbol* name, Symbol* sig, bool is_static, fieldDescriptor* fd) const; 489 490 // find a non-static or static field given its offset within the class. 491 bool contains_field_offset(int offset) { 492 return instanceOopDesc::contains_field_offset(offset, nonstatic_field_size()); 493 } 494 495 bool find_local_field_from_offset(int offset, bool is_static, fieldDescriptor* fd) const; 496 bool find_field_from_offset(int offset, bool is_static, fieldDescriptor* fd) const; 497 498 // find a local method (returns NULL if not found) 499 Method* find_method(Symbol* name, Symbol* signature) const; 500 static Method* find_method(Array<Method*>* methods, Symbol* name, Symbol* signature); 501 502 // lookup operation (returns NULL if not found) 503 Method* uncached_lookup_method(Symbol* name, Symbol* signature) const; 504 505 // lookup a method in all the interfaces that this class implements 506 // (returns NULL if not found) 507 Method* lookup_method_in_all_interfaces(Symbol* name, Symbol* signature) const; 508 509 // Find method indices by name. If a method with the specified name is 510 // found the index to the first method is returned, and 'end' is filled in 511 // with the index of first non-name-matching method. If no method is found 512 // -1 is returned. 513 int find_method_by_name(Symbol* name, int* end); 514 static int find_method_by_name(Array<Method*>* methods, Symbol* name, int* end); 515 516 // constant pool 517 ConstantPool* constants() const { return _constants; } 518 void set_constants(ConstantPool* c) { _constants = c; } 519 520 // protection domain 521 oop protection_domain() { return _protection_domain; } 522 void set_protection_domain(oop pd) { klass_oop_store(&_protection_domain, pd); } 523 524 // host class 525 Klass* host_klass() const { 526 Klass** hk = (Klass**)adr_host_klass(); 527 if (hk == NULL) { 528 return NULL; 529 } else { 530 return *hk; 531 } 532 } 533 void set_host_klass(Klass* host) { 534 assert(is_anonymous(), "not anonymous"); 535 Klass** addr = (Klass**)adr_host_klass(); 536 assert(addr != NULL, "no reversed space"); 537 *addr = host; 538 } 539 bool is_anonymous() const { 540 return (_misc_flags & _misc_is_anonymous) != 0; 541 } 542 void set_is_anonymous(bool value) { 543 if (value) { 544 _misc_flags |= _misc_is_anonymous; 545 } else { 546 _misc_flags &= ~_misc_is_anonymous; 547 } 548 } 549 550 // Oop that keeps the metadata for this class from being unloaded 551 // in places where the metadata is stored in other places, like nmethods 552 oop klass_holder() const { 553 return is_anonymous() ? java_mirror() : class_loader(); 554 } 555 556 bool is_contended() const { 557 return (_misc_flags & _misc_is_contended) != 0; 558 } 559 void set_is_contended(bool value) { 560 if (value) { 561 _misc_flags |= _misc_is_contended; 562 } else { 563 _misc_flags &= ~_misc_is_contended; 564 } 565 } 566 567 // signers 568 objArrayOop signers() const { return _signers; } 569 void set_signers(objArrayOop s) { klass_oop_store((oop*)&_signers, s); } 570 571 // source file name 572 Symbol* source_file_name() const { return _source_file_name; } 573 void set_source_file_name(Symbol* n); 574 575 // minor and major version numbers of class file 576 u2 minor_version() const { return _minor_version; } 577 void set_minor_version(u2 minor_version) { _minor_version = minor_version; } 578 u2 major_version() const { return _major_version; } 579 void set_major_version(u2 major_version) { _major_version = major_version; } 580 581 // source debug extension 582 char* source_debug_extension() const { return _source_debug_extension; } 583 void set_source_debug_extension(char* array, int length); 584 585 // symbol unloading support (refcount already added) 586 Symbol* array_name() { return _array_name; } 587 void set_array_name(Symbol* name) { assert(_array_name == NULL, "name already created"); _array_name = name; } 588 589 // nonstatic oop-map blocks 590 static int nonstatic_oop_map_size(unsigned int oop_map_count) { 591 return oop_map_count * OopMapBlock::size_in_words(); 592 } 593 unsigned int nonstatic_oop_map_count() const { 594 return _nonstatic_oop_map_size / OopMapBlock::size_in_words(); 595 } 596 int nonstatic_oop_map_size() const { return _nonstatic_oop_map_size; } 597 void set_nonstatic_oop_map_size(int words) { 598 _nonstatic_oop_map_size = words; 599 } 600 601 // RedefineClasses() support for previous versions: 602 void add_previous_version(instanceKlassHandle ikh, BitMap *emcp_methods, 603 int emcp_method_count); 604 // If the _previous_versions array is non-NULL, then this klass 605 // has been redefined at least once even if we aren't currently 606 // tracking a previous version. 607 bool has_been_redefined() const { return _previous_versions != NULL; } 608 bool has_previous_version() const; 609 void init_previous_versions() { 610 _previous_versions = NULL; 611 } 612 GrowableArray<PreviousVersionNode *>* previous_versions() const { 613 return _previous_versions; 614 } 615 616 static void purge_previous_versions(InstanceKlass* ik); 617 618 // JVMTI: Support for caching a class file before it is modified by an agent that can do retransformation 619 void set_cached_class_file(unsigned char *class_file_bytes, 620 jint class_file_len) { _cached_class_file_len = class_file_len; 621 _cached_class_file_bytes = class_file_bytes; } 622 jint get_cached_class_file_len() { return _cached_class_file_len; } 623 unsigned char * get_cached_class_file_bytes() { return _cached_class_file_bytes; } 624 625 // JVMTI: Support for caching of field indices, types, and offsets 626 void set_jvmti_cached_class_field_map(JvmtiCachedClassFieldMap* descriptor) { 627 _jvmti_cached_class_field_map = descriptor; 628 } 629 JvmtiCachedClassFieldMap* jvmti_cached_class_field_map() const { 630 return _jvmti_cached_class_field_map; 631 } 632 633 bool has_default_methods() const { 634 return (_misc_flags & _misc_has_default_methods) != 0; 635 } 636 void set_has_default_methods(bool b) { 637 if (b) { 638 _misc_flags |= _misc_has_default_methods; 639 } else { 640 _misc_flags &= ~_misc_has_default_methods; 641 } 642 } 643 644 // for adding methods, ConstMethod::UNSET_IDNUM means no more ids available 645 inline u2 next_method_idnum(); 646 void set_initial_method_idnum(u2 value) { _idnum_allocated_count = value; } 647 648 // generics support 649 Symbol* generic_signature() const { return _generic_signature; } 650 void set_generic_signature(Symbol* sig) { _generic_signature = sig; } 651 652 u2 enclosing_method_data(int offset); 653 u2 enclosing_method_class_index() { 654 return enclosing_method_data(enclosing_method_class_index_offset); 655 } 656 u2 enclosing_method_method_index() { 657 return enclosing_method_data(enclosing_method_method_index_offset); 658 } 659 void set_enclosing_method_indices(u2 class_index, 660 u2 method_index); 661 662 // jmethodID support 663 static jmethodID get_jmethod_id(instanceKlassHandle ik_h, 664 methodHandle method_h); 665 static jmethodID get_jmethod_id_fetch_or_update(instanceKlassHandle ik_h, 666 size_t idnum, jmethodID new_id, jmethodID* new_jmeths, 667 jmethodID* to_dealloc_id_p, 668 jmethodID** to_dealloc_jmeths_p); 669 static void get_jmethod_id_length_value(jmethodID* cache, size_t idnum, 670 size_t *length_p, jmethodID* id_p); 671 jmethodID jmethod_id_or_null(Method* method); 672 673 // cached itable index support 674 void set_cached_itable_index(size_t idnum, int index); 675 int cached_itable_index(size_t idnum); 676 677 // annotations support 678 Annotations* annotations() const { return _annotations; } 679 void set_annotations(Annotations* anno) { _annotations = anno; } 680 AnnotationArray* class_annotations() const { 681 if (annotations() == NULL) return NULL; 682 return annotations()->class_annotations(); 683 } 684 Array<AnnotationArray*>* fields_annotations() const { 685 if (annotations() == NULL) return NULL; 686 return annotations()->fields_annotations(); 687 } 688 Annotations* type_annotations() const { 689 if (annotations() == NULL) return NULL; 690 return annotations()->type_annotations(); 691 } 692 693 // allocation 694 instanceOop allocate_instance(TRAPS); 695 696 // additional member function to return a handle 697 instanceHandle allocate_instance_handle(TRAPS) { return instanceHandle(THREAD, allocate_instance(THREAD)); } 698 699 objArrayOop allocate_objArray(int n, int length, TRAPS); 700 // Helper function 701 static instanceOop register_finalizer(instanceOop i, TRAPS); 702 703 // Check whether reflection/jni/jvm code is allowed to instantiate this class; 704 // if not, throw either an Error or an Exception. 705 virtual void check_valid_for_instantiation(bool throwError, TRAPS); 706 707 // initialization 708 void call_class_initializer(TRAPS); 709 void set_initialization_state_and_notify(ClassState state, TRAPS); 710 711 // OopMapCache support 712 OopMapCache* oop_map_cache() { return _oop_map_cache; } 713 void set_oop_map_cache(OopMapCache *cache) { _oop_map_cache = cache; } 714 void mask_for(methodHandle method, int bci, InterpreterOopMap* entry); 715 716 // JNI identifier support (for static fields - for jni performance) 717 JNIid* jni_ids() { return _jni_ids; } 718 void set_jni_ids(JNIid* ids) { _jni_ids = ids; } 719 JNIid* jni_id_for(int offset); 720 721 // maintenance of deoptimization dependencies 722 int mark_dependent_nmethods(DepChange& changes); 723 void add_dependent_nmethod(nmethod* nm); 724 void remove_dependent_nmethod(nmethod* nm); 725 726 // On-stack replacement support 727 nmethod* osr_nmethods_head() const { return _osr_nmethods_head; }; 728 void set_osr_nmethods_head(nmethod* h) { _osr_nmethods_head = h; }; 729 void add_osr_nmethod(nmethod* n); 730 void remove_osr_nmethod(nmethod* n); 731 nmethod* lookup_osr_nmethod(Method* const m, int bci, int level, bool match_level) const; 732 733 // Breakpoint support (see methods on Method* for details) 734 BreakpointInfo* breakpoints() const { return _breakpoints; }; 735 void set_breakpoints(BreakpointInfo* bps) { _breakpoints = bps; }; 736 737 // support for stub routines 738 static ByteSize init_state_offset() { return in_ByteSize(offset_of(InstanceKlass, _init_state)); } 739 TRACE_DEFINE_OFFSET; 740 static ByteSize init_thread_offset() { return in_ByteSize(offset_of(InstanceKlass, _init_thread)); } 741 742 // subclass/subinterface checks 743 bool implements_interface(Klass* k) const; 744 745 // Access to the implementor of an interface. 746 Klass* implementor() const 747 { 748 Klass** k = adr_implementor(); 749 if (k == NULL) { 750 return NULL; 751 } else { 752 return *k; 753 } 754 } 755 756 void set_implementor(Klass* k) { 757 assert(is_interface(), "not interface"); 758 Klass** addr = adr_implementor(); 759 *addr = k; 760 } 761 762 int nof_implementors() const { 763 Klass* k = implementor(); 764 if (k == NULL) { 765 return 0; 766 } else if (k != this) { 767 return 1; 768 } else { 769 return 2; 770 } 771 } 772 773 void add_implementor(Klass* k); // k is a new class that implements this interface 774 void init_implementor(); // initialize 775 776 // link this class into the implementors list of every interface it implements 777 void process_interfaces(Thread *thread); 778 779 // virtual operations from Klass 780 bool is_leaf_class() const { return _subklass == NULL; } 781 GrowableArray<Klass*>* compute_secondary_supers(int num_extra_slots); 782 bool compute_is_subtype_of(Klass* k); 783 bool can_be_primary_super_slow() const; 784 int oop_size(oop obj) const { return size_helper(); } 785 bool oop_is_instance_slow() const { return true; } 786 787 // Iterators 788 void do_local_static_fields(FieldClosure* cl); 789 void do_nonstatic_fields(FieldClosure* cl); // including inherited fields 790 void do_local_static_fields(void f(fieldDescriptor*, TRAPS), TRAPS); 791 792 void methods_do(void f(Method* method)); 793 void array_klasses_do(void f(Klass* k)); 794 void array_klasses_do(void f(Klass* k, TRAPS), TRAPS); 795 void with_array_klasses_do(void f(Klass* k)); 796 bool super_types_do(SuperTypeClosure* blk); 797 798 // Casting from Klass* 799 static InstanceKlass* cast(Klass* k) { 800 assert(k->is_klass(), "must be"); 801 assert(k->oop_is_instance(), "cast to InstanceKlass"); 802 return (InstanceKlass*) k; 803 } 804 805 InstanceKlass* java_super() const { 806 return (super() == NULL) ? NULL : cast(super()); 807 } 808 809 // Sizing (in words) 810 static int header_size() { return align_object_offset(sizeof(InstanceKlass)/HeapWordSize); } 811 static int size(int vtable_length, int itable_length, 812 int nonstatic_oop_map_size, 813 bool is_interface, bool is_anonymous) { 814 return align_object_size(header_size() + 815 align_object_offset(vtable_length) + 816 align_object_offset(itable_length) + 817 ((is_interface || is_anonymous) ? 818 align_object_offset(nonstatic_oop_map_size) : 819 nonstatic_oop_map_size) + 820 (is_interface ? (int)sizeof(Klass*)/HeapWordSize : 0) + 821 (is_anonymous ? (int)sizeof(Klass*)/HeapWordSize : 0)); 822 } 823 int size() const { return size(vtable_length(), 824 itable_length(), 825 nonstatic_oop_map_size(), 826 is_interface(), 827 is_anonymous()); 828 } 829 830 static int vtable_start_offset() { return header_size(); } 831 static int vtable_length_offset() { return offset_of(InstanceKlass, _vtable_len) / HeapWordSize; } 832 833 intptr_t* start_of_vtable() const { return ((intptr_t*)this) + vtable_start_offset(); } 834 intptr_t* start_of_itable() const { return start_of_vtable() + align_object_offset(vtable_length()); } 835 int itable_offset_in_words() const { return start_of_itable() - (intptr_t*)this; } 836 837 intptr_t* end_of_itable() const { return start_of_itable() + itable_length(); } 838 839 address static_field_addr(int offset); 840 841 OopMapBlock* start_of_nonstatic_oop_maps() const { 842 return (OopMapBlock*)(start_of_itable() + align_object_offset(itable_length())); 843 } 844 845 Klass** adr_implementor() const { 846 if (is_interface()) { 847 return (Klass**)(start_of_nonstatic_oop_maps() + 848 nonstatic_oop_map_count()); 849 } else { 850 return NULL; 851 } 852 }; 853 854 Klass** adr_host_klass() const { 855 if (is_anonymous()) { 856 Klass** adr_impl = adr_implementor(); 857 if (adr_impl != NULL) { 858 return adr_impl + 1; 859 } else { 860 return (Klass**)(start_of_nonstatic_oop_maps() + 861 nonstatic_oop_map_count()); 862 } 863 } else { 864 return NULL; 865 } 866 } 867 868 // Allocation profiling support 869 juint alloc_size() const { return _alloc_count * size_helper(); } 870 void set_alloc_size(juint n) {} 871 872 // Use this to return the size of an instance in heap words: 873 int size_helper() const { 874 return layout_helper_to_size_helper(layout_helper()); 875 } 876 877 // This bit is initialized in classFileParser.cpp. 878 // It is false under any of the following conditions: 879 // - the class is abstract (including any interface) 880 // - the class has a finalizer (if !RegisterFinalizersAtInit) 881 // - the class size is larger than FastAllocateSizeLimit 882 // - the class is java/lang/Class, which cannot be allocated directly 883 bool can_be_fastpath_allocated() const { 884 return !layout_helper_needs_slow_path(layout_helper()); 885 } 886 887 // Java vtable/itable 888 klassVtable* vtable() const; // return new klassVtable wrapper 889 inline Method* method_at_vtable(int index); 890 klassItable* itable() const; // return new klassItable wrapper 891 Method* method_at_itable(Klass* holder, int index, TRAPS); 892 893 // Garbage collection 894 virtual void oops_do(OopClosure* cl); 895 896 void oop_follow_contents(oop obj); 897 int oop_adjust_pointers(oop obj); 898 899 void clean_implementors_list(BoolObjectClosure* is_alive); 900 void clean_method_data(BoolObjectClosure* is_alive); 901 902 // Explicit metaspace deallocation of fields 903 // For RedefineClasses, we need to deallocate instanceKlasses 904 void deallocate_contents(ClassLoaderData* loader_data); 905 906 // The constant pool is on stack if any of the methods are executing or 907 // referenced by handles. 908 bool on_stack() const { return _constants->on_stack(); } 909 910 void release_C_heap_structures(); 911 912 // Parallel Scavenge and Parallel Old 913 PARALLEL_GC_DECLS 914 915 // Naming 916 const char* signature_name() const; 917 918 // Iterators 919 int oop_oop_iterate(oop obj, ExtendedOopClosure* blk) { 920 return oop_oop_iterate_v(obj, blk); 921 } 922 923 int oop_oop_iterate_m(oop obj, ExtendedOopClosure* blk, MemRegion mr) { 924 return oop_oop_iterate_v_m(obj, blk, mr); 925 } 926 927 #define InstanceKlass_OOP_OOP_ITERATE_DECL(OopClosureType, nv_suffix) \ 928 int oop_oop_iterate##nv_suffix(oop obj, OopClosureType* blk); \ 929 int oop_oop_iterate##nv_suffix##_m(oop obj, OopClosureType* blk, \ 930 MemRegion mr); 931 932 ALL_OOP_OOP_ITERATE_CLOSURES_1(InstanceKlass_OOP_OOP_ITERATE_DECL) 933 ALL_OOP_OOP_ITERATE_CLOSURES_2(InstanceKlass_OOP_OOP_ITERATE_DECL) 934 935 #ifndef SERIALGC 936 #define InstanceKlass_OOP_OOP_ITERATE_BACKWARDS_DECL(OopClosureType, nv_suffix) \ 937 int oop_oop_iterate_backwards##nv_suffix(oop obj, OopClosureType* blk); 938 939 ALL_OOP_OOP_ITERATE_CLOSURES_1(InstanceKlass_OOP_OOP_ITERATE_BACKWARDS_DECL) 940 ALL_OOP_OOP_ITERATE_CLOSURES_2(InstanceKlass_OOP_OOP_ITERATE_BACKWARDS_DECL) 941 #endif // !SERIALGC 942 943 u2 idnum_allocated_count() const { return _idnum_allocated_count; } 944 private: 945 // initialization state 946 #ifdef ASSERT 947 void set_init_state(ClassState state); 948 #else 949 void set_init_state(ClassState state) { _init_state = (u1)state; } 950 #endif 951 void set_rewritten() { _misc_flags |= _misc_rewritten; } 952 void set_init_thread(Thread *thread) { _init_thread = thread; } 953 954 // The RedefineClasses() API can cause new method idnums to be needed 955 // which will cause the caches to grow. Safety requires different 956 // cache management logic if the caches can grow instead of just 957 // going from NULL to non-NULL. 958 bool idnum_can_increment() const { return has_been_redefined(); } 959 jmethodID* methods_jmethod_ids_acquire() const 960 { return (jmethodID*)OrderAccess::load_ptr_acquire(&_methods_jmethod_ids); } 961 void release_set_methods_jmethod_ids(jmethodID* jmeths) 962 { OrderAccess::release_store_ptr(&_methods_jmethod_ids, jmeths); } 963 964 int* methods_cached_itable_indices_acquire() const 965 { return (int*)OrderAccess::load_ptr_acquire(&_methods_cached_itable_indices); } 966 void release_set_methods_cached_itable_indices(int* indices) 967 { OrderAccess::release_store_ptr(&_methods_cached_itable_indices, indices); } 968 969 // Lock during initialization 970 volatile oop init_lock() const; 971 void set_init_lock(oop value) { klass_oop_store(&_init_lock, value); } 972 void fence_and_clear_init_lock(); // after fully_initialized 973 974 // Offsets for memory management 975 oop* adr_protection_domain() const { return (oop*)&this->_protection_domain;} 976 oop* adr_signers() const { return (oop*)&this->_signers;} 977 oop* adr_init_lock() const { return (oop*)&this->_init_lock;} 978 979 // Static methods that are used to implement member methods where an exposed this pointer 980 // is needed due to possible GCs 981 static bool link_class_impl (instanceKlassHandle this_oop, bool throw_verifyerror, TRAPS); 982 static bool verify_code (instanceKlassHandle this_oop, bool throw_verifyerror, TRAPS); 983 static void initialize_impl (instanceKlassHandle this_oop, TRAPS); 984 static void eager_initialize_impl (instanceKlassHandle this_oop); 985 static void set_initialization_state_and_notify_impl (instanceKlassHandle this_oop, ClassState state, TRAPS); 986 static void call_class_initializer_impl (instanceKlassHandle this_oop, TRAPS); 987 static Klass* array_klass_impl (instanceKlassHandle this_oop, bool or_null, int n, TRAPS); 988 static void do_local_static_fields_impl (instanceKlassHandle this_oop, void f(fieldDescriptor* fd, TRAPS), TRAPS); 989 /* jni_id_for_impl for jfieldID only */ 990 static JNIid* jni_id_for_impl (instanceKlassHandle this_oop, int offset); 991 992 // Returns the array class for the n'th dimension 993 Klass* array_klass_impl(bool or_null, int n, TRAPS); 994 995 // Returns the array class with this class as element type 996 Klass* array_klass_impl(bool or_null, TRAPS); 997 998 public: 999 // CDS support - remove and restore oops from metadata. Oops are not shared. 1000 virtual void remove_unshareable_info(); 1001 virtual void restore_unshareable_info(TRAPS); 1002 1003 // jvm support 1004 jint compute_modifier_flags(TRAPS) const; 1005 1006 public: 1007 // JVMTI support 1008 jint jvmti_class_status() const; 1009 1010 public: 1011 // Printing 1012 #ifndef PRODUCT 1013 void print_on(outputStream* st) const; 1014 #endif 1015 void print_value_on(outputStream* st) const; 1016 1017 void oop_print_value_on(oop obj, outputStream* st); 1018 1019 #ifndef PRODUCT 1020 void oop_print_on (oop obj, outputStream* st); 1021 1022 void print_dependent_nmethods(bool verbose = false); 1023 bool is_dependent_nmethod(nmethod* nm); 1024 #endif 1025 1026 const char* internal_name() const; 1027 1028 // Verification 1029 void verify_on(outputStream* st); 1030 1031 void oop_verify_on(oop obj, outputStream* st); 1032 }; 1033 1034 inline Method* InstanceKlass::method_at_vtable(int index) { 1035 #ifndef PRODUCT 1036 assert(index >= 0, "valid vtable index"); 1037 if (DebugVtables) { 1038 verify_vtable_index(index); 1039 } 1040 #endif 1041 vtableEntry* ve = (vtableEntry*)start_of_vtable(); 1042 return ve[index].method(); 1043 } 1044 1045 // for adding methods 1046 // UNSET_IDNUM return means no more ids available 1047 inline u2 InstanceKlass::next_method_idnum() { 1048 if (_idnum_allocated_count == ConstMethod::MAX_IDNUM) { 1049 return ConstMethod::UNSET_IDNUM; // no more ids available 1050 } else { 1051 return _idnum_allocated_count++; 1052 } 1053 } 1054 1055 1056 /* JNIid class for jfieldIDs only */ 1057 class JNIid: public CHeapObj<mtClass> { 1058 friend class VMStructs; 1059 private: 1060 Klass* _holder; 1061 JNIid* _next; 1062 int _offset; 1063 #ifdef ASSERT 1064 bool _is_static_field_id; 1065 #endif 1066 1067 public: 1068 // Accessors 1069 Klass* holder() const { return _holder; } 1070 int offset() const { return _offset; } 1071 JNIid* next() { return _next; } 1072 // Constructor 1073 JNIid(Klass* holder, int offset, JNIid* next); 1074 // Identifier lookup 1075 JNIid* find(int offset); 1076 1077 bool find_local_field(fieldDescriptor* fd) { 1078 return InstanceKlass::cast(holder())->find_local_field_from_offset(offset(), true, fd); 1079 } 1080 1081 static void deallocate(JNIid* id); 1082 // Debugging 1083 #ifdef ASSERT 1084 bool is_static_field_id() const { return _is_static_field_id; } 1085 void set_is_static_field_id() { _is_static_field_id = true; } 1086 #endif 1087 void verify(Klass* holder); 1088 }; 1089 1090 1091 // If breakpoints are more numerous than just JVMTI breakpoints, 1092 // consider compressing this data structure. 1093 // It is currently a simple linked list defined in method.hpp. 1094 1095 class BreakpointInfo; 1096 1097 1098 // A collection point for interesting information about the previous 1099 // version(s) of an InstanceKlass. This class uses weak references to 1100 // the information so that the information may be collected as needed 1101 // by the system. If the information is shared, then a regular 1102 // reference must be used because a weak reference would be seen as 1103 // collectible. A GrowableArray of PreviousVersionNodes is attached 1104 // to the InstanceKlass as needed. See PreviousVersionWalker below. 1105 class PreviousVersionNode : public CHeapObj<mtClass> { 1106 private: 1107 // A shared ConstantPool is never collected so we'll always have 1108 // a reference to it so we can update items in the cache. We'll 1109 // have a weak reference to a non-shared ConstantPool until all 1110 // of the methods (EMCP or obsolete) have been collected; the 1111 // non-shared ConstantPool becomes collectible at that point. 1112 ConstantPool* _prev_constant_pool; // regular or weak reference 1113 bool _prev_cp_is_weak; // true if not a shared ConstantPool 1114 1115 // If the previous version of the InstanceKlass doesn't have any 1116 // EMCP methods, then _prev_EMCP_methods will be NULL. If all the 1117 // EMCP methods have been collected, then _prev_EMCP_methods can 1118 // have a length of zero. 1119 GrowableArray<Method*>* _prev_EMCP_methods; 1120 1121 public: 1122 PreviousVersionNode(ConstantPool* prev_constant_pool, bool prev_cp_is_weak, 1123 GrowableArray<Method*>* prev_EMCP_methods); 1124 ~PreviousVersionNode(); 1125 ConstantPool* prev_constant_pool() const { 1126 return _prev_constant_pool; 1127 } 1128 GrowableArray<Method*>* prev_EMCP_methods() const { 1129 return _prev_EMCP_methods; 1130 } 1131 }; 1132 1133 1134 // A Handle-ized version of PreviousVersionNode. 1135 class PreviousVersionInfo : public ResourceObj { 1136 private: 1137 constantPoolHandle _prev_constant_pool_handle; 1138 // If the previous version of the InstanceKlass doesn't have any 1139 // EMCP methods, then _prev_EMCP_methods will be NULL. Since the 1140 // methods cannot be collected while we hold a handle, 1141 // _prev_EMCP_methods should never have a length of zero. 1142 GrowableArray<methodHandle>* _prev_EMCP_method_handles; 1143 1144 public: 1145 PreviousVersionInfo(PreviousVersionNode *pv_node); 1146 ~PreviousVersionInfo(); 1147 constantPoolHandle prev_constant_pool_handle() const { 1148 return _prev_constant_pool_handle; 1149 } 1150 GrowableArray<methodHandle>* prev_EMCP_method_handles() const { 1151 return _prev_EMCP_method_handles; 1152 } 1153 }; 1154 1155 1156 // Helper object for walking previous versions. This helper cleans up 1157 // the Handles that it allocates when the helper object is destroyed. 1158 // The PreviousVersionInfo object returned by next_previous_version() 1159 // is only valid until a subsequent call to next_previous_version() or 1160 // the helper object is destroyed. 1161 class PreviousVersionWalker : public StackObj { 1162 private: 1163 GrowableArray<PreviousVersionNode *>* _previous_versions; 1164 int _current_index; 1165 // Fields for cleaning up when we are done walking the previous versions: 1166 // A HandleMark for the PreviousVersionInfo handles: 1167 HandleMark _hm; 1168 1169 // It would be nice to have a ResourceMark field in this helper also, 1170 // but the ResourceMark code says to be careful to delete handles held 1171 // in GrowableArrays _before_ deleting the GrowableArray. Since we 1172 // can't guarantee the order in which the fields are destroyed, we 1173 // have to let the creator of the PreviousVersionWalker object do 1174 // the right thing. Also, adding a ResourceMark here causes an 1175 // include loop. 1176 1177 // A pointer to the current info object so we can handle the deletes. 1178 PreviousVersionInfo * _current_p; 1179 1180 public: 1181 PreviousVersionWalker(InstanceKlass *ik); 1182 ~PreviousVersionWalker(); 1183 1184 // Return the interesting information for the next previous version 1185 // of the klass. Returns NULL if there are no more previous versions. 1186 PreviousVersionInfo* next_previous_version(); 1187 }; 1188 1189 1190 // 1191 // nmethodBucket is used to record dependent nmethods for 1192 // deoptimization. nmethod dependencies are actually <klass, method> 1193 // pairs but we really only care about the klass part for purposes of 1194 // finding nmethods which might need to be deoptimized. Instead of 1195 // recording the method, a count of how many times a particular nmethod 1196 // was recorded is kept. This ensures that any recording errors are 1197 // noticed since an nmethod should be removed as many times are it's 1198 // added. 1199 // 1200 class nmethodBucket: public CHeapObj<mtClass> { 1201 friend class VMStructs; 1202 private: 1203 nmethod* _nmethod; 1204 int _count; 1205 nmethodBucket* _next; 1206 1207 public: 1208 nmethodBucket(nmethod* nmethod, nmethodBucket* next) { 1209 _nmethod = nmethod; 1210 _next = next; 1211 _count = 1; 1212 } 1213 int count() { return _count; } 1214 int increment() { _count += 1; return _count; } 1215 int decrement() { _count -= 1; assert(_count >= 0, "don't underflow"); return _count; } 1216 nmethodBucket* next() { return _next; } 1217 void set_next(nmethodBucket* b) { _next = b; } 1218 nmethod* get_nmethod() { return _nmethod; } 1219 }; 1220 1221 // An iterator that's used to access the inner classes indices in the 1222 // InstanceKlass::_inner_classes array. 1223 class InnerClassesIterator : public StackObj { 1224 private: 1225 Array<jushort>* _inner_classes; 1226 int _length; 1227 int _idx; 1228 public: 1229 1230 InnerClassesIterator(instanceKlassHandle k) { 1231 _inner_classes = k->inner_classes(); 1232 if (k->inner_classes() != NULL) { 1233 _length = _inner_classes->length(); 1234 // The inner class array's length should be the multiple of 1235 // inner_class_next_offset if it only contains the InnerClasses 1236 // attribute data, or it should be 1237 // n*inner_class_next_offset+enclosing_method_attribute_size 1238 // if it also contains the EnclosingMethod data. 1239 assert((_length % InstanceKlass::inner_class_next_offset == 0 || 1240 _length % InstanceKlass::inner_class_next_offset == InstanceKlass::enclosing_method_attribute_size), 1241 "just checking"); 1242 // Remove the enclosing_method portion if exists. 1243 if (_length % InstanceKlass::inner_class_next_offset == InstanceKlass::enclosing_method_attribute_size) { 1244 _length -= InstanceKlass::enclosing_method_attribute_size; 1245 } 1246 } else { 1247 _length = 0; 1248 } 1249 _idx = 0; 1250 } 1251 1252 int length() const { 1253 return _length; 1254 } 1255 1256 void next() { 1257 _idx += InstanceKlass::inner_class_next_offset; 1258 } 1259 1260 bool done() const { 1261 return (_idx >= _length); 1262 } 1263 1264 u2 inner_class_info_index() const { 1265 return _inner_classes->at( 1266 _idx + InstanceKlass::inner_class_inner_class_info_offset); 1267 } 1268 1269 void set_inner_class_info_index(u2 index) { 1270 _inner_classes->at_put( 1271 _idx + InstanceKlass::inner_class_inner_class_info_offset, index); 1272 } 1273 1274 u2 outer_class_info_index() const { 1275 return _inner_classes->at( 1276 _idx + InstanceKlass::inner_class_outer_class_info_offset); 1277 } 1278 1279 void set_outer_class_info_index(u2 index) { 1280 _inner_classes->at_put( 1281 _idx + InstanceKlass::inner_class_outer_class_info_offset, index); 1282 } 1283 1284 u2 inner_name_index() const { 1285 return _inner_classes->at( 1286 _idx + InstanceKlass::inner_class_inner_name_offset); 1287 } 1288 1289 void set_inner_name_index(u2 index) { 1290 _inner_classes->at_put( 1291 _idx + InstanceKlass::inner_class_inner_name_offset, index); 1292 } 1293 1294 u2 inner_access_flags() const { 1295 return _inner_classes->at( 1296 _idx + InstanceKlass::inner_class_access_flags_offset); 1297 } 1298 }; 1299 1300 #endif // SHARE_VM_OOPS_INSTANCEKLASS_HPP