1 /*
   2  * Copyright (c) 1997, 2011, 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 "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 
  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 
 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.
 118   int offset() const          { return _offset; }
 119   void set_offset(int offset) { _offset = offset; }
 120 
 121   // Number of oops in this block.
 122   uint count() const         { return _count; }
 123   void set_count(uint count) { _count = count; }
 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:
 132   int  _offset;
 133   uint _count;
 134 };
 135 
 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;
 184   // Host class, which grants its access privileges to this class also.
 185   // This is only non-null for an anonymous class (JSR 292 enabled).
 186   // The host class is either named, or a previously loaded anonymous class.
 187   klassOop        _host_klass;
 188   // Class signers.
 189   objArrayOop     _signers;
 190   // inner_classes attribute.
 191   typeArrayOop    _inner_classes;
 192   // Implementors of this interface (not valid if it overflows)
 193   klassOop        _implementors[implementors_limit];
 194   // Annotations for this class, or null if none.
 195   typeArrayOop    _class_annotations;
 196   // Annotation objects (byte arrays) for fields, or null if no annotations.
 197   // Indices correspond to entries (not indices) in fields array.
 198   objArrayOop     _fields_annotations;
 199   // Annotation objects (byte arrays) for methods, or null if no annotations.
 200   // Index is the idnum, which is initially the same as the methods array index.
 201   objArrayOop     _methods_annotations;
 202   // Annotation objects (byte arrays) for methods' parameters, or null if no
 203   // such annotations.
 204   // Index is the idnum, which is initially the same as the methods array index.
 205   objArrayOop     _methods_parameter_annotations;
 206   // Annotation objects (byte arrays) for methods' default values, or null if no
 207   // such annotations.
 208   // Index is the idnum, which is initially the same as the methods array index.
 209   objArrayOop     _methods_default_annotations;
 210 
 211   //
 212   // End of the oop block.
 213   //
 214 
 215   // Name of source file containing this klass, NULL if not specified.
 216   Symbol*         _source_file_name;
 217   // the source debug extension for this klass, NULL if not specified.
 218   Symbol*         _source_debug_extension;
 219   // Generic signature, or null if none.
 220   Symbol*         _generic_signature;
 221   // Array name derived from this class which needs unreferencing
 222   // if this class is unloaded.
 223   Symbol*         _array_name;
 224 
 225   // Number of heapOopSize words used by non-static fields in this klass
 226   // (including inherited fields but after header_size()).
 227   int             _nonstatic_field_size;
 228   int             _static_field_size;    // number words used by static fields (oop and non-oop) in this klass
 229   int             _static_oop_field_count;// number of static oop fields in this klass
 230   int             _nonstatic_oop_map_size;// size in words of nonstatic oop map blocks
 231   bool            _is_marked_dependent;  // used for marking during flushing and deoptimization
 232   bool            _rewritten;            // methods rewritten.
 233   bool            _has_nonstatic_fields; // for sizing with UseCompressedOops
 234   bool            _should_verify_class;  // allow caching of preverification
 235   u2              _minor_version;        // minor version number of class file
 236   u2              _major_version;        // major version number of class file
 237   ClassState      _init_state;           // state of class
 238   Thread*         _init_thread;          // Pointer to current thread doing initialization (to handle recusive initialization)
 239   int             _vtable_len;           // length of Java vtable (in words)
 240   int             _itable_len;           // length of Java itable (in words)
 241   ReferenceType   _reference_type;       // reference type
 242   OopMapCache*    volatile _oop_map_cache;   // OopMapCache for all methods in the klass (allocated lazily)
 243   JNIid*          _jni_ids;              // First JNI identifier for static fields in this class
 244   jmethodID*      _methods_jmethod_ids;  // jmethodIDs corresponding to method_idnum, or NULL if none
 245   int*            _methods_cached_itable_indices;  // itable_index cache for JNI invoke corresponding to methods idnum, or NULL
 246   nmethodBucket*  _dependencies;         // list of dependent nmethods
 247   nmethod*        _osr_nmethods_head;    // Head of list of on-stack replacement nmethods for this class
 248   BreakpointInfo* _breakpoints;          // bpt lists, managed by methodOop
 249   int             _nof_implementors;     // No of implementors of this interface (zero if not an interface)
 250   // Array of interesting part(s) of the previous version(s) of this
 251   // instanceKlass. See PreviousVersionWalker below.
 252   GrowableArray<PreviousVersionNode *>* _previous_versions;
 253   u2              _enclosing_method_class_index;  // Constant pool index for class of enclosing method, or 0 if none
 254   u2              _enclosing_method_method_index; // Constant pool index for name and type of enclosing method, or 0 if none
 255   // JVMTI fields can be moved to their own structure - see 6315920
 256   unsigned char * _cached_class_file_bytes;       // JVMTI: cached class file, before retransformable agent modified it in CFLH
 257   jint            _cached_class_file_len;         // JVMTI: length of above
 258   JvmtiCachedClassFieldMap* _jvmti_cached_class_field_map;  // JVMTI: used during heap iteration
 259   volatile u2     _idnum_allocated_count;         // JNI/JVMTI: increments with the addition of methods, old ids don't change
 260 
 261   // embedded Java vtable follows here
 262   // embedded Java itables follows here
 263   // embedded static fields follows here
 264   // embedded nonstatic oop-map blocks follows here
 265 
 266   friend class instanceKlassKlass;
 267   friend class SystemDictionary;
 268 
 269  public:
 270   bool has_nonstatic_fields() const        { return _has_nonstatic_fields; }
 271   void set_has_nonstatic_fields(bool b)    { _has_nonstatic_fields = b; }
 272 
 273   // field sizes
 274   int nonstatic_field_size() const         { return _nonstatic_field_size; }
 275   void set_nonstatic_field_size(int size)  { _nonstatic_field_size = size; }
 276 
 277   int static_field_size() const            { return _static_field_size; }
 278   void set_static_field_size(int size)     { _static_field_size = size; }
 279 
 280   int static_oop_field_count() const        { return _static_oop_field_count; }
 281   void set_static_oop_field_count(int size) { _static_oop_field_count = size; }
 282 
 283   // Java vtable
 284   int  vtable_length() const               { return _vtable_len; }
 285   void set_vtable_length(int len)          { _vtable_len = len; }
 286 
 287   // Java itable
 288   int  itable_length() const               { return _itable_len; }
 289   void set_itable_length(int len)          { _itable_len = len; }
 290 
 291   // array klasses
 292   klassOop array_klasses() const           { return _array_klasses; }
 293   void set_array_klasses(klassOop k)       { oop_store_without_check((oop*) &_array_klasses, (oop) k); }
 294 
 295   // methods
 296   objArrayOop methods() const              { return _methods; }
 297   void set_methods(objArrayOop a)          { oop_store_without_check((oop*) &_methods, (oop) a); }
 298   methodOop method_with_idnum(int idnum);
 299 
 300   // method ordering
 301   typeArrayOop method_ordering() const     { return _method_ordering; }
 302   void set_method_ordering(typeArrayOop m) { oop_store_without_check((oop*) &_method_ordering, (oop) m); }
 303 
 304   // interfaces
 305   objArrayOop local_interfaces() const          { return _local_interfaces; }
 306   void set_local_interfaces(objArrayOop a)      { oop_store_without_check((oop*) &_local_interfaces, (oop) a); }
 307   objArrayOop transitive_interfaces() const     { return _transitive_interfaces; }
 308   void set_transitive_interfaces(objArrayOop a) { oop_store_without_check((oop*) &_transitive_interfaces, (oop) a); }
 309 
 310   // fields
 311   // Field info extracted from the class file and stored
 312   // as an array of 7 shorts
 313   enum FieldOffset {
 314     access_flags_offset    = 0,
 315     name_index_offset      = 1,
 316     signature_index_offset = 2,
 317     initval_index_offset   = 3,
 318     low_offset             = 4,
 319     high_offset            = 5,
 320     generic_signature_offset = 6,
 321     next_offset            = 7
 322   };
 323 
 324   typeArrayOop fields() const              { return _fields; }
 325   int offset_from_fields( int index ) const {
 326     return build_int_from_shorts( fields()->ushort_at(index + low_offset),
 327                                   fields()->ushort_at(index + high_offset) );
 328   }
 329 
 330   void set_fields(typeArrayOop f)          { oop_store_without_check((oop*) &_fields, (oop) f); }
 331 
 332   // inner classes
 333   typeArrayOop inner_classes() const       { return _inner_classes; }
 334   void set_inner_classes(typeArrayOop f)   { oop_store_without_check((oop*) &_inner_classes, (oop) f); }
 335 
 336   enum InnerClassAttributeOffset {
 337     // From http://mirror.eng/products/jdk/1.1/docs/guide/innerclasses/spec/innerclasses.doc10.html#18814
 338     inner_class_inner_class_info_offset = 0,
 339     inner_class_outer_class_info_offset = 1,
 340     inner_class_inner_name_offset = 2,
 341     inner_class_access_flags_offset = 3,
 342     inner_class_next_offset = 4
 343   };
 344 
 345   // method override check
 346   bool is_override(methodHandle super_method, Handle targetclassloader, Symbol* targetclassname, TRAPS);
 347 
 348   // package
 349   bool is_same_class_package(klassOop class2);
 350   bool is_same_class_package(oop classloader2, Symbol* classname2);
 351   static bool is_same_class_package(oop class_loader1, Symbol* class_name1, oop class_loader2, Symbol* class_name2);
 352 
 353   // find an enclosing class (defined where original code was, in jvm.cpp!)
 354   klassOop compute_enclosing_class(bool* inner_is_member, TRAPS) {
 355     instanceKlassHandle self(THREAD, this->as_klassOop());
 356     return compute_enclosing_class_impl(self, inner_is_member, THREAD);
 357   }
 358   static klassOop compute_enclosing_class_impl(instanceKlassHandle self,
 359                                                bool* inner_is_member, TRAPS);
 360 
 361   // tell if two classes have the same enclosing class (at package level)
 362   bool is_same_package_member(klassOop class2, TRAPS) {
 363     instanceKlassHandle self(THREAD, this->as_klassOop());
 364     return is_same_package_member_impl(self, class2, THREAD);
 365   }
 366   static bool is_same_package_member_impl(instanceKlassHandle self,
 367                                           klassOop class2, TRAPS);
 368 
 369   // initialization state
 370   bool is_loaded() const                   { return _init_state >= loaded; }
 371   bool is_linked() const                   { return _init_state >= linked; }
 372   bool is_initialized() const              { return _init_state == fully_initialized; }
 373   bool is_not_initialized() const          { return _init_state <  being_initialized; }
 374   bool is_being_initialized() const        { return _init_state == being_initialized; }
 375   bool is_in_error_state() const           { return _init_state == initialization_error; }
 376   bool is_reentrant_initialization(Thread *thread)  { return thread == _init_thread; }
 377   int  get_init_state()                    { return _init_state; } // Useful for debugging
 378   bool is_rewritten() const                { return _rewritten; }
 379 
 380   // defineClass specified verification
 381   bool should_verify_class() const         { return _should_verify_class; }
 382   void set_should_verify_class(bool value) { _should_verify_class = value; }
 383 
 384   // marking
 385   bool is_marked_dependent() const         { return _is_marked_dependent; }
 386   void set_is_marked_dependent(bool value) { _is_marked_dependent = value; }
 387 
 388   // initialization (virtuals from Klass)
 389   bool should_be_initialized() const;  // means that initialize should be called
 390   void initialize(TRAPS);
 391   void link_class(TRAPS);
 392   bool link_class_or_fail(TRAPS); // returns false on failure
 393   void unlink_class();
 394   void rewrite_class(TRAPS);
 395   void relocate_and_link_methods(TRAPS);
 396   methodOop class_initializer();
 397 
 398   // set the class to initialized if no static initializer is present
 399   void eager_initialize(Thread *thread);
 400 
 401   // reference type
 402   ReferenceType reference_type() const     { return _reference_type; }
 403   void set_reference_type(ReferenceType t) { _reference_type = t; }
 404 
 405   static int reference_type_offset_in_bytes() { return offset_of(instanceKlass, _reference_type); }
 406 
 407   // find local field, returns true if found
 408   bool find_local_field(Symbol* name, Symbol* sig, fieldDescriptor* fd) const;
 409   // find field in direct superinterfaces, returns the interface in which the field is defined
 410   klassOop find_interface_field(Symbol* name, Symbol* sig, fieldDescriptor* fd) const;
 411   // find field according to JVM spec 5.4.3.2, returns the klass in which the field is defined
 412   klassOop find_field(Symbol* name, Symbol* sig, fieldDescriptor* fd) const;
 413   // find instance or static fields according to JVM spec 5.4.3.2, returns the klass in which the field is defined
 414   klassOop find_field(Symbol* name, Symbol* sig, bool is_static, fieldDescriptor* fd) const;
 415 
 416   // find a non-static or static field given its offset within the class.
 417   bool contains_field_offset(int offset) {
 418     return instanceOopDesc::contains_field_offset(offset, nonstatic_field_size());
 419   }
 420 
 421   bool find_local_field_from_offset(int offset, bool is_static, fieldDescriptor* fd) const;
 422   bool find_field_from_offset(int offset, bool is_static, fieldDescriptor* fd) const;
 423 
 424   // find a local method (returns NULL if not found)
 425   methodOop find_method(Symbol* name, Symbol* signature) const;
 426   static methodOop find_method(objArrayOop methods, Symbol* name, Symbol* signature);
 427 
 428   // lookup operation (returns NULL if not found)
 429   methodOop uncached_lookup_method(Symbol* name, Symbol* signature) const;
 430 
 431   // lookup a method in all the interfaces that this class implements
 432   // (returns NULL if not found)
 433   methodOop lookup_method_in_all_interfaces(Symbol* name, Symbol* signature) const;
 434 
 435   // constant pool
 436   constantPoolOop constants() const        { return _constants; }
 437   void set_constants(constantPoolOop c)    { oop_store_without_check((oop*) &_constants, (oop) c); }
 438 
 439   // class loader
 440   oop class_loader() const                 { return _class_loader; }
 441   void set_class_loader(oop l)             { oop_store((oop*) &_class_loader, l); }
 442 
 443   // protection domain
 444   oop protection_domain()                  { return _protection_domain; }
 445   void set_protection_domain(oop pd)       { oop_store((oop*) &_protection_domain, pd); }
 446 
 447   // host class
 448   oop host_klass() const                   { return _host_klass; }
 449   void set_host_klass(oop host)            { oop_store((oop*) &_host_klass, host); }
 450   bool is_anonymous() const                { return _host_klass != NULL; }
 451 
 452   // signers
 453   objArrayOop signers() const              { return _signers; }
 454   void set_signers(objArrayOop s)          { oop_store((oop*) &_signers, oop(s)); }
 455 
 456   // source file name
 457   Symbol* source_file_name() const         { return _source_file_name; }
 458   void set_source_file_name(Symbol* n);
 459 
 460   // minor and major version numbers of class file
 461   u2 minor_version() const                 { return _minor_version; }
 462   void set_minor_version(u2 minor_version) { _minor_version = minor_version; }
 463   u2 major_version() const                 { return _major_version; }
 464   void set_major_version(u2 major_version) { _major_version = major_version; }
 465 
 466   // source debug extension
 467   Symbol* source_debug_extension() const   { return _source_debug_extension; }
 468   void set_source_debug_extension(Symbol* n);
 469 
 470   // symbol unloading support (refcount already added)
 471   Symbol* array_name()                     { return _array_name; }
 472   void set_array_name(Symbol* name)        { assert(_array_name == NULL, "name already created"); _array_name = name; }
 473 
 474   // nonstatic oop-map blocks
 475   static int nonstatic_oop_map_size(unsigned int oop_map_count) {
 476     return oop_map_count * OopMapBlock::size_in_words();
 477   }
 478   unsigned int nonstatic_oop_map_count() const {
 479     return _nonstatic_oop_map_size / OopMapBlock::size_in_words();
 480   }
 481   int nonstatic_oop_map_size() const { return _nonstatic_oop_map_size; }
 482   void set_nonstatic_oop_map_size(int words) {
 483     _nonstatic_oop_map_size = words;
 484   }
 485 
 486   // RedefineClasses() support for previous versions:
 487   void add_previous_version(instanceKlassHandle ikh, BitMap *emcp_methods,
 488          int emcp_method_count);
 489   // If the _previous_versions array is non-NULL, then this klass
 490   // has been redefined at least once even if we aren't currently
 491   // tracking a previous version.
 492   bool has_been_redefined() const { return _previous_versions != NULL; }
 493   bool has_previous_version() const;
 494   void init_previous_versions() {
 495     _previous_versions = NULL;
 496   }
 497   GrowableArray<PreviousVersionNode *>* previous_versions() const {
 498     return _previous_versions;
 499   }
 500 
 501   // JVMTI: Support for caching a class file before it is modified by an agent that can do retransformation
 502   void set_cached_class_file(unsigned char *class_file_bytes,
 503                              jint class_file_len)     { _cached_class_file_len = class_file_len;
 504                                                         _cached_class_file_bytes = class_file_bytes; }
 505   jint get_cached_class_file_len()                    { return _cached_class_file_len; }
 506   unsigned char * get_cached_class_file_bytes()       { return _cached_class_file_bytes; }
 507 
 508   // JVMTI: Support for caching of field indices, types, and offsets
 509   void set_jvmti_cached_class_field_map(JvmtiCachedClassFieldMap* descriptor) {
 510     _jvmti_cached_class_field_map = descriptor;
 511   }
 512   JvmtiCachedClassFieldMap* jvmti_cached_class_field_map() const {
 513     return _jvmti_cached_class_field_map;
 514   }
 515 
 516   // for adding methods, constMethodOopDesc::UNSET_IDNUM means no more ids available
 517   inline u2 next_method_idnum();
 518   void set_initial_method_idnum(u2 value)             { _idnum_allocated_count = value; }
 519 
 520   // generics support
 521   Symbol* generic_signature() const                   { return _generic_signature; }
 522   void set_generic_signature(Symbol* sig)             { _generic_signature = sig; }
 523 
 524   u2 enclosing_method_class_index() const             { return _enclosing_method_class_index; }
 525   u2 enclosing_method_method_index() const            { return _enclosing_method_method_index; }
 526   void set_enclosing_method_indices(u2 class_index,
 527                                     u2 method_index)  { _enclosing_method_class_index  = class_index;
 528                                                         _enclosing_method_method_index = method_index; }
 529 
 530   // jmethodID support
 531   static jmethodID get_jmethod_id(instanceKlassHandle ik_h,
 532                      methodHandle method_h);
 533   static jmethodID get_jmethod_id_fetch_or_update(instanceKlassHandle ik_h,
 534                      size_t idnum, jmethodID new_id, jmethodID* new_jmeths,
 535                      jmethodID* to_dealloc_id_p,
 536                      jmethodID** to_dealloc_jmeths_p);
 537   static void get_jmethod_id_length_value(jmethodID* cache, size_t idnum,
 538                 size_t *length_p, jmethodID* id_p);
 539   jmethodID jmethod_id_or_null(methodOop method);
 540 
 541   // cached itable index support
 542   void set_cached_itable_index(size_t idnum, int index);
 543   int cached_itable_index(size_t idnum);
 544 
 545   // annotations support
 546   typeArrayOop class_annotations() const              { return _class_annotations; }
 547   objArrayOop fields_annotations() const              { return _fields_annotations; }
 548   objArrayOop methods_annotations() const             { return _methods_annotations; }
 549   objArrayOop methods_parameter_annotations() const   { return _methods_parameter_annotations; }
 550   objArrayOop methods_default_annotations() const     { return _methods_default_annotations; }
 551   void set_class_annotations(typeArrayOop md)            { oop_store_without_check((oop*)&_class_annotations, (oop)md); }
 552   void set_fields_annotations(objArrayOop md)            { set_annotations(md, &_fields_annotations); }
 553   void set_methods_annotations(objArrayOop md)           { set_annotations(md, &_methods_annotations); }
 554   void set_methods_parameter_annotations(objArrayOop md) { set_annotations(md, &_methods_parameter_annotations); }
 555   void set_methods_default_annotations(objArrayOop md)   { set_annotations(md, &_methods_default_annotations); }
 556   typeArrayOop get_method_annotations_of(int idnum)
 557                                                 { return get_method_annotations_from(idnum, _methods_annotations); }
 558   typeArrayOop get_method_parameter_annotations_of(int idnum)
 559                                                 { return get_method_annotations_from(idnum, _methods_parameter_annotations); }
 560   typeArrayOop get_method_default_annotations_of(int idnum)
 561                                                 { return get_method_annotations_from(idnum, _methods_default_annotations); }
 562   void set_method_annotations_of(int idnum, typeArrayOop anno)
 563                                                 { set_methods_annotations_of(idnum, anno, &_methods_annotations); }
 564   void set_method_parameter_annotations_of(int idnum, typeArrayOop anno)
 565                                                 { set_methods_annotations_of(idnum, anno, &_methods_annotations); }
 566   void set_method_default_annotations_of(int idnum, typeArrayOop anno)
 567                                                 { set_methods_annotations_of(idnum, anno, &_methods_annotations); }
 568 
 569   // allocation
 570   DEFINE_ALLOCATE_PERMANENT(instanceKlass);
 571   instanceOop allocate_instance(TRAPS);
 572   instanceOop allocate_permanent_instance(TRAPS);
 573 
 574   // additional member function to return a handle
 575   instanceHandle allocate_instance_handle(TRAPS)      { return instanceHandle(THREAD, allocate_instance(THREAD)); }
 576 
 577   objArrayOop allocate_objArray(int n, int length, TRAPS);
 578   // Helper function
 579   static instanceOop register_finalizer(instanceOop i, TRAPS);
 580 
 581   // Check whether reflection/jni/jvm code is allowed to instantiate this class;
 582   // if not, throw either an Error or an Exception.
 583   virtual void check_valid_for_instantiation(bool throwError, TRAPS);
 584 
 585   // initialization
 586   void call_class_initializer(TRAPS);
 587   void set_initialization_state_and_notify(ClassState state, TRAPS);
 588 
 589   // OopMapCache support
 590   OopMapCache* oop_map_cache()               { return _oop_map_cache; }
 591   void set_oop_map_cache(OopMapCache *cache) { _oop_map_cache = cache; }
 592   void mask_for(methodHandle method, int bci, InterpreterOopMap* entry);
 593 
 594   // JNI identifier support (for static fields - for jni performance)
 595   JNIid* jni_ids()                               { return _jni_ids; }
 596   void set_jni_ids(JNIid* ids)                   { _jni_ids = ids; }
 597   JNIid* jni_id_for(int offset);
 598 
 599   // maintenance of deoptimization dependencies
 600   int mark_dependent_nmethods(DepChange& changes);
 601   void add_dependent_nmethod(nmethod* nm);
 602   void remove_dependent_nmethod(nmethod* nm);
 603 
 604   // On-stack replacement support
 605   nmethod* osr_nmethods_head() const         { return _osr_nmethods_head; };
 606   void set_osr_nmethods_head(nmethod* h)     { _osr_nmethods_head = h; };
 607   void add_osr_nmethod(nmethod* n);
 608   void remove_osr_nmethod(nmethod* n);
 609   nmethod* lookup_osr_nmethod(const methodOop m, int bci, int level, bool match_level) const;
 610 
 611   // Breakpoint support (see methods on methodOop for details)
 612   BreakpointInfo* breakpoints() const       { return _breakpoints; };
 613   void set_breakpoints(BreakpointInfo* bps) { _breakpoints = bps; };
 614 
 615   // support for stub routines
 616   static int init_state_offset_in_bytes()    { return offset_of(instanceKlass, _init_state); }
 617   static int init_thread_offset_in_bytes()   { return offset_of(instanceKlass, _init_thread); }
 618 
 619   // subclass/subinterface checks
 620   bool implements_interface(klassOop k) const;
 621 
 622   // Access to implementors of an interface. We only store the count
 623   // of implementors, and in case, there are only a few
 624   // implementors, we store them in a short list.
 625   // This accessor returns NULL if we walk off the end of the list.
 626   klassOop implementor(int i) const {
 627     return (i < implementors_limit)? _implementors[i]: (klassOop) NULL;
 628   }
 629   int  nof_implementors() const       { return _nof_implementors; }
 630   void add_implementor(klassOop k);  // k is a new class that implements this interface
 631   void init_implementor();           // initialize
 632 
 633   // link this class into the implementors list of every interface it implements
 634   void process_interfaces(Thread *thread);
 635 
 636   // virtual operations from Klass
 637   bool is_leaf_class() const               { return _subklass == NULL; }
 638   objArrayOop compute_secondary_supers(int num_extra_slots, TRAPS);
 639   bool compute_is_subtype_of(klassOop k);
 640   bool can_be_primary_super_slow() const;
 641   klassOop java_super() const              { return super(); }
 642   int oop_size(oop obj)  const             { return size_helper(); }
 643   int klass_oop_size() const               { return object_size(); }
 644   bool oop_is_instance_slow() const        { return true; }
 645 
 646   // Iterators
 647   void do_local_static_fields(FieldClosure* cl);
 648   void do_nonstatic_fields(FieldClosure* cl); // including inherited fields
 649   void do_local_static_fields(void f(fieldDescriptor*, TRAPS), TRAPS);
 650 
 651   void methods_do(void f(methodOop method));
 652   void array_klasses_do(void f(klassOop k));
 653   void with_array_klasses_do(void f(klassOop k));
 654   bool super_types_do(SuperTypeClosure* blk);
 655 
 656   // Casting from klassOop
 657   static instanceKlass* cast(klassOop k) {
 658     assert(k->is_klass(), "must be");
 659     Klass* kp = k->klass_part();
 660     assert(kp->null_vtbl() || kp->oop_is_instance_slow(), "cast to instanceKlass");
 661     return (instanceKlass*) kp;
 662   }
 663 
 664   // Sizing (in words)
 665   static int header_size()            { return align_object_offset(oopDesc::header_size() + sizeof(instanceKlass)/HeapWordSize); }
 666   int object_size() const             { return object_size(align_object_offset(vtable_length()) + align_object_offset(itable_length()) + nonstatic_oop_map_size()); }
 667   static int vtable_start_offset()    { return header_size(); }
 668   static int vtable_length_offset()   { return oopDesc::header_size() + offset_of(instanceKlass, _vtable_len) / HeapWordSize; }
 669   static int object_size(int extra)   { return align_object_size(header_size() + extra); }
 670 
 671   intptr_t* start_of_vtable() const        { return ((intptr_t*)as_klassOop()) + vtable_start_offset(); }
 672   intptr_t* start_of_itable() const        { return start_of_vtable() + align_object_offset(vtable_length()); }
 673   int  itable_offset_in_words() const { return start_of_itable() - (intptr_t*)as_klassOop(); }
 674 
 675   intptr_t* end_of_itable() const          { return start_of_itable() + itable_length(); }
 676 
 677   address static_field_addr(int offset);
 678 
 679   OopMapBlock* start_of_nonstatic_oop_maps() const {
 680     return (OopMapBlock*)(start_of_itable() + align_object_offset(itable_length()));
 681   }
 682 
 683   // Allocation profiling support
 684   juint alloc_size() const            { return _alloc_count * size_helper(); }
 685   void set_alloc_size(juint n)        {}
 686 
 687   // Use this to return the size of an instance in heap words:
 688   int size_helper() const {
 689     return layout_helper_to_size_helper(layout_helper());
 690   }
 691 
 692   // This bit is initialized in classFileParser.cpp.
 693   // It is false under any of the following conditions:
 694   //  - the class is abstract (including any interface)
 695   //  - the class has a finalizer (if !RegisterFinalizersAtInit)
 696   //  - the class size is larger than FastAllocateSizeLimit
 697   //  - the class is java/lang/Class, which cannot be allocated directly
 698   bool can_be_fastpath_allocated() const {
 699     return !layout_helper_needs_slow_path(layout_helper());
 700   }
 701 
 702   // Java vtable/itable
 703   klassVtable* vtable() const;        // return new klassVtable wrapper
 704   inline methodOop method_at_vtable(int index);
 705   klassItable* itable() const;        // return new klassItable wrapper
 706   methodOop method_at_itable(klassOop holder, int index, TRAPS);
 707 
 708   // Garbage collection
 709   void oop_follow_contents(oop obj);
 710   int  oop_adjust_pointers(oop obj);
 711   bool object_is_parsable() const { return _init_state != unparsable_by_gc; }
 712        // Value of _init_state must be zero (unparsable_by_gc) when klass field is set.
 713 
 714   void follow_weak_klass_links(
 715     BoolObjectClosure* is_alive, OopClosure* keep_alive);
 716   void release_C_heap_structures();
 717 
 718   // Parallel Scavenge and Parallel Old
 719   PARALLEL_GC_DECLS
 720 
 721   // Naming
 722   const char* signature_name() const;
 723 
 724   // Iterators
 725   int oop_oop_iterate(oop obj, OopClosure* blk) {
 726     return oop_oop_iterate_v(obj, blk);
 727   }
 728 
 729   int oop_oop_iterate_m(oop obj, OopClosure* blk, MemRegion mr) {
 730     return oop_oop_iterate_v_m(obj, blk, mr);
 731   }
 732 
 733 #define InstanceKlass_OOP_OOP_ITERATE_DECL(OopClosureType, nv_suffix)      \
 734   int  oop_oop_iterate##nv_suffix(oop obj, OopClosureType* blk);           \
 735   int  oop_oop_iterate##nv_suffix##_m(oop obj, OopClosureType* blk,        \
 736                                       MemRegion mr);
 737 
 738   ALL_OOP_OOP_ITERATE_CLOSURES_1(InstanceKlass_OOP_OOP_ITERATE_DECL)
 739   ALL_OOP_OOP_ITERATE_CLOSURES_2(InstanceKlass_OOP_OOP_ITERATE_DECL)
 740 
 741 #ifndef SERIALGC
 742 #define InstanceKlass_OOP_OOP_ITERATE_BACKWARDS_DECL(OopClosureType, nv_suffix) \
 743   int  oop_oop_iterate_backwards##nv_suffix(oop obj, OopClosureType* blk);
 744 
 745   ALL_OOP_OOP_ITERATE_CLOSURES_1(InstanceKlass_OOP_OOP_ITERATE_BACKWARDS_DECL)
 746   ALL_OOP_OOP_ITERATE_CLOSURES_2(InstanceKlass_OOP_OOP_ITERATE_BACKWARDS_DECL)
 747 #endif // !SERIALGC
 748 
 749 private:
 750   // initialization state
 751 #ifdef ASSERT
 752   void set_init_state(ClassState state);
 753 #else
 754   void set_init_state(ClassState state) { _init_state = state; }
 755 #endif
 756   void set_rewritten()                  { _rewritten = true; }
 757   void set_init_thread(Thread *thread)  { _init_thread = thread; }
 758 
 759   u2 idnum_allocated_count() const      { return _idnum_allocated_count; }
 760   // The RedefineClasses() API can cause new method idnums to be needed
 761   // which will cause the caches to grow. Safety requires different
 762   // cache management logic if the caches can grow instead of just
 763   // going from NULL to non-NULL.
 764   bool idnum_can_increment() const      { return has_been_redefined(); }
 765   jmethodID* methods_jmethod_ids_acquire() const
 766          { return (jmethodID*)OrderAccess::load_ptr_acquire(&_methods_jmethod_ids); }
 767   void release_set_methods_jmethod_ids(jmethodID* jmeths)
 768          { OrderAccess::release_store_ptr(&_methods_jmethod_ids, jmeths); }
 769 
 770   int* methods_cached_itable_indices_acquire() const
 771          { return (int*)OrderAccess::load_ptr_acquire(&_methods_cached_itable_indices); }
 772   void release_set_methods_cached_itable_indices(int* indices)
 773          { OrderAccess::release_store_ptr(&_methods_cached_itable_indices, indices); }
 774 
 775   inline typeArrayOop get_method_annotations_from(int idnum, objArrayOop annos);
 776   void set_annotations(objArrayOop md, objArrayOop* md_p)  { oop_store_without_check((oop*)md_p, (oop)md); }
 777   void set_methods_annotations_of(int idnum, typeArrayOop anno, objArrayOop* md_p);
 778 
 779   // Offsets for memory management
 780   oop* adr_array_klasses() const     { return (oop*)&this->_array_klasses;}
 781   oop* adr_methods() const           { return (oop*)&this->_methods;}
 782   oop* adr_method_ordering() const   { return (oop*)&this->_method_ordering;}
 783   oop* adr_local_interfaces() const  { return (oop*)&this->_local_interfaces;}
 784   oop* adr_transitive_interfaces() const  { return (oop*)&this->_transitive_interfaces;}
 785   oop* adr_fields() const            { return (oop*)&this->_fields;}
 786   oop* adr_constants() const         { return (oop*)&this->_constants;}
 787   oop* adr_class_loader() const      { return (oop*)&this->_class_loader;}
 788   oop* adr_protection_domain() const { return (oop*)&this->_protection_domain;}
 789   oop* adr_host_klass() const        { return (oop*)&this->_host_klass;}
 790   oop* adr_signers() const           { return (oop*)&this->_signers;}
 791   oop* adr_inner_classes() const     { return (oop*)&this->_inner_classes;}
 792   oop* adr_implementors() const      { return (oop*)&this->_implementors[0];}
 793   oop* adr_methods_jmethod_ids() const             { return (oop*)&this->_methods_jmethod_ids;}
 794   oop* adr_methods_cached_itable_indices() const   { return (oop*)&this->_methods_cached_itable_indices;}
 795   oop* adr_class_annotations() const   { return (oop*)&this->_class_annotations;}
 796   oop* adr_fields_annotations() const  { return (oop*)&this->_fields_annotations;}
 797   oop* adr_methods_annotations() const { return (oop*)&this->_methods_annotations;}
 798   oop* adr_methods_parameter_annotations() const { return (oop*)&this->_methods_parameter_annotations;}
 799   oop* adr_methods_default_annotations() const { return (oop*)&this->_methods_default_annotations;}
 800 
 801   // Static methods that are used to implement member methods where an exposed this pointer
 802   // is needed due to possible GCs
 803   static bool link_class_impl                           (instanceKlassHandle this_oop, bool throw_verifyerror, TRAPS);
 804   static bool verify_code                               (instanceKlassHandle this_oop, bool throw_verifyerror, TRAPS);
 805   static void initialize_impl                           (instanceKlassHandle this_oop, TRAPS);
 806   static void eager_initialize_impl                     (instanceKlassHandle this_oop);
 807   static void set_initialization_state_and_notify_impl  (instanceKlassHandle this_oop, ClassState state, TRAPS);
 808   static void call_class_initializer_impl               (instanceKlassHandle this_oop, TRAPS);
 809   static klassOop array_klass_impl                      (instanceKlassHandle this_oop, bool or_null, int n, TRAPS);
 810   static void do_local_static_fields_impl               (instanceKlassHandle this_oop, void f(fieldDescriptor* fd, TRAPS), TRAPS);
 811   /* jni_id_for_impl for jfieldID only */
 812   static JNIid* jni_id_for_impl                         (instanceKlassHandle this_oop, int offset);
 813 
 814   // Returns the array class for the n'th dimension
 815   klassOop array_klass_impl(bool or_null, int n, TRAPS);
 816 
 817   // Returns the array class with this class as element type
 818   klassOop array_klass_impl(bool or_null, TRAPS);
 819 
 820 public:
 821   // sharing support
 822   virtual void remove_unshareable_info();
 823   virtual void shared_symbols_iterate(SymbolClosure* closure);
 824 
 825   // jvm support
 826   jint compute_modifier_flags(TRAPS) const;
 827 
 828 public:
 829   // JVMTI support
 830   jint jvmti_class_status() const;
 831 
 832  public:
 833   // Printing
 834   void oop_print_value_on(oop obj, outputStream* st);
 835 #ifndef PRODUCT
 836   void oop_print_on      (oop obj, outputStream* st);
 837 
 838   void print_dependent_nmethods(bool verbose = false);
 839   bool is_dependent_nmethod(nmethod* nm);
 840 #endif
 841 
 842   // Verification
 843   const char* internal_name() const;
 844   void oop_verify_on(oop obj, outputStream* st);
 845 
 846 #ifndef PRODUCT
 847   static void verify_class_klass_nonstatic_oop_maps(klassOop k) PRODUCT_RETURN;
 848 #endif
 849 };
 850 
 851 inline methodOop instanceKlass::method_at_vtable(int index)  {
 852 #ifndef PRODUCT
 853   assert(index >= 0, "valid vtable index");
 854   if (DebugVtables) {
 855     verify_vtable_index(index);
 856   }
 857 #endif
 858   vtableEntry* ve = (vtableEntry*)start_of_vtable();
 859   return ve[index].method();
 860 }
 861 
 862 inline typeArrayOop instanceKlass::get_method_annotations_from(int idnum, objArrayOop annos) {
 863   if (annos == NULL || annos->length() <= idnum) {
 864     return NULL;
 865   }
 866   return typeArrayOop(annos->obj_at(idnum));
 867 }
 868 
 869 // for adding methods
 870 // UNSET_IDNUM return means no more ids available
 871 inline u2 instanceKlass::next_method_idnum() {
 872   if (_idnum_allocated_count == constMethodOopDesc::MAX_IDNUM) {
 873     return constMethodOopDesc::UNSET_IDNUM; // no more ids available
 874   } else {
 875     return _idnum_allocated_count++;
 876   }
 877 }
 878 
 879 
 880 /* JNIid class for jfieldIDs only */
 881 class JNIid: public CHeapObj {
 882   friend class VMStructs;
 883  private:
 884   klassOop           _holder;
 885   JNIid*             _next;
 886   int                _offset;
 887 #ifdef ASSERT
 888   bool               _is_static_field_id;
 889 #endif
 890 
 891  public:
 892   // Accessors
 893   klassOop holder() const         { return _holder; }
 894   int offset() const              { return _offset; }
 895   JNIid* next()                   { return _next; }
 896   // Constructor
 897   JNIid(klassOop holder, int offset, JNIid* next);
 898   // Identifier lookup
 899   JNIid* find(int offset);
 900 
 901   bool find_local_field(fieldDescriptor* fd) {
 902     return instanceKlass::cast(holder())->find_local_field_from_offset(offset(), true, fd);
 903   }
 904 
 905   // Garbage collection support
 906   oop* holder_addr() { return (oop*)&_holder; }
 907   void oops_do(OopClosure* f);
 908   static void deallocate(JNIid* id);
 909   // Debugging
 910 #ifdef ASSERT
 911   bool is_static_field_id() const { return _is_static_field_id; }
 912   void set_is_static_field_id()   { _is_static_field_id = true; }
 913 #endif
 914   void verify(klassOop holder);
 915 };
 916 
 917 
 918 // If breakpoints are more numerous than just JVMTI breakpoints,
 919 // consider compressing this data structure.
 920 // It is currently a simple linked list defined in methodOop.hpp.
 921 
 922 class BreakpointInfo;
 923 
 924 
 925 // A collection point for interesting information about the previous
 926 // version(s) of an instanceKlass. This class uses weak references to
 927 // the information so that the information may be collected as needed
 928 // by the system. If the information is shared, then a regular
 929 // reference must be used because a weak reference would be seen as
 930 // collectible. A GrowableArray of PreviousVersionNodes is attached
 931 // to the instanceKlass as needed. See PreviousVersionWalker below.
 932 class PreviousVersionNode : public CHeapObj {
 933  private:
 934   // A shared ConstantPool is never collected so we'll always have
 935   // a reference to it so we can update items in the cache. We'll
 936   // have a weak reference to a non-shared ConstantPool until all
 937   // of the methods (EMCP or obsolete) have been collected; the
 938   // non-shared ConstantPool becomes collectible at that point.
 939   jobject _prev_constant_pool;  // regular or weak reference
 940   bool    _prev_cp_is_weak;     // true if not a shared ConstantPool
 941 
 942   // If the previous version of the instanceKlass doesn't have any
 943   // EMCP methods, then _prev_EMCP_methods will be NULL. If all the
 944   // EMCP methods have been collected, then _prev_EMCP_methods can
 945   // have a length of zero.
 946   GrowableArray<jweak>* _prev_EMCP_methods;
 947 
 948 public:
 949   PreviousVersionNode(jobject prev_constant_pool, bool prev_cp_is_weak,
 950     GrowableArray<jweak>* prev_EMCP_methods);
 951   ~PreviousVersionNode();
 952   jobject prev_constant_pool() const {
 953     return _prev_constant_pool;
 954   }
 955   GrowableArray<jweak>* prev_EMCP_methods() const {
 956     return _prev_EMCP_methods;
 957   }
 958 };
 959 
 960 
 961 // A Handle-ized version of PreviousVersionNode.
 962 class PreviousVersionInfo : public ResourceObj {
 963  private:
 964   constantPoolHandle   _prev_constant_pool_handle;
 965   // If the previous version of the instanceKlass doesn't have any
 966   // EMCP methods, then _prev_EMCP_methods will be NULL. Since the
 967   // methods cannot be collected while we hold a handle,
 968   // _prev_EMCP_methods should never have a length of zero.
 969   GrowableArray<methodHandle>* _prev_EMCP_method_handles;
 970 
 971 public:
 972   PreviousVersionInfo(PreviousVersionNode *pv_node);
 973   ~PreviousVersionInfo();
 974   constantPoolHandle prev_constant_pool_handle() const {
 975     return _prev_constant_pool_handle;
 976   }
 977   GrowableArray<methodHandle>* prev_EMCP_method_handles() const {
 978     return _prev_EMCP_method_handles;
 979   }
 980 };
 981 
 982 
 983 // Helper object for walking previous versions. This helper cleans up
 984 // the Handles that it allocates when the helper object is destroyed.
 985 // The PreviousVersionInfo object returned by next_previous_version()
 986 // is only valid until a subsequent call to next_previous_version() or
 987 // the helper object is destroyed.
 988 class PreviousVersionWalker : public StackObj {
 989  private:
 990   GrowableArray<PreviousVersionNode *>* _previous_versions;
 991   int                                   _current_index;
 992   // Fields for cleaning up when we are done walking the previous versions:
 993   // A HandleMark for the PreviousVersionInfo handles:
 994   HandleMark                            _hm;
 995 
 996   // It would be nice to have a ResourceMark field in this helper also,
 997   // but the ResourceMark code says to be careful to delete handles held
 998   // in GrowableArrays _before_ deleting the GrowableArray. Since we
 999   // can't guarantee the order in which the fields are destroyed, we
1000   // have to let the creator of the PreviousVersionWalker object do
1001   // the right thing. Also, adding a ResourceMark here causes an
1002   // include loop.
1003 
1004   // A pointer to the current info object so we can handle the deletes.
1005   PreviousVersionInfo *                 _current_p;
1006 
1007  public:
1008   PreviousVersionWalker(instanceKlass *ik);
1009   ~PreviousVersionWalker();
1010 
1011   // Return the interesting information for the next previous version
1012   // of the klass. Returns NULL if there are no more previous versions.
1013   PreviousVersionInfo* next_previous_version();
1014 };
1015 
































1016 #endif // SHARE_VM_OOPS_INSTANCEKLASS_HPP
--- EOF ---