((cite: hotspot/src/share/vm/oops/instanceKlass.hpp))
    // An instanceKlass is the VM level representation of a Java class.
    // It contains all information needed for at class at execution runtime.

    ((cite: hotspot/src/share/vm/oops/instanceKlass.hpp))
    class instanceKlass: public Klass {

    ((cite: hotspot/src/share/vm/oops/instanceKlass.hpp))
      //
      // The oop block.  See comment in klass.hpp before making changes.
      //

      // Array classes holding elements of this class.
      klassOop        _array_klasses;
      // Method array.
      objArrayOop     _methods;
      // Int array containing the original order of method in the class file (for
      // JVMTI).
      typeArrayOop    _method_ordering;
      // Interface (klassOops) this class declares locally to implement.
      objArrayOop     _local_interfaces;
      // Interface (klassOops) this class implements transitively.
      objArrayOop     _transitive_interfaces;
      // Instance and static variable information, 5-tuples of shorts [access, name
      // index, sig index, initval index, offset].
      typeArrayOop    _fields;
      // Constant pool for this class.
      constantPoolOop _constants;
      // Class loader used to load this class, NULL if VM loader used.
      oop             _class_loader;
      // Protection domain.
      oop             _protection_domain;
      // Host class, which grants its access privileges to this class also.
      // This is only non-null for an anonymous class (JSR 292 enabled).
      // The host class is either named, or a previously loaded anonymous class.
      klassOop        _host_klass;
      // Class signers.
      objArrayOop     _signers;
      // inner_classes attribute.
      typeArrayOop    _inner_classes;
      // Implementors of this interface (not valid if it overflows)
      klassOop        _implementors[implementors_limit];
      // Annotations for this class, or null if none.
      typeArrayOop    _class_annotations;
      // Annotation objects (byte arrays) for fields, or null if no annotations.
      // Indices correspond to entries (not indices) in fields array.
      objArrayOop     _fields_annotations;
      // Annotation objects (byte arrays) for methods, or null if no annotations.
      // Index is the idnum, which is initially the same as the methods array index.
      objArrayOop     _methods_annotations;
      // Annotation objects (byte arrays) for methods' parameters, or null if no
      // such annotations.
      // Index is the idnum, which is initially the same as the methods array index.
      objArrayOop     _methods_parameter_annotations;
      // Annotation objects (byte arrays) for methods' default values, or null if no
      // such annotations.
      // Index is the idnum, which is initially the same as the methods array index.
      objArrayOop     _methods_default_annotations;

      //
      // End of the oop block.
      //

      // Name of source file containing this klass, NULL if not specified.
      Symbol*         _source_file_name;
      // the source debug extension for this klass, NULL if not specified.
      Symbol*         _source_debug_extension;
      // Generic signature, or null if none.
      Symbol*         _generic_signature;
      // Array name derived from this class which needs unreferencing
      // if this class is unloaded.
      Symbol*         _array_name;

      // Number of heapOopSize words used by non-static fields in this klass
      // (including inherited fields but after header_size()).
      int             _nonstatic_field_size;
      int             _static_field_size;    // number words used by static fields (oop and non-oop) in this klass
      int             _static_oop_field_count;// number of static oop fields in this klass
      int             _nonstatic_oop_map_size;// size in words of nonstatic oop map blocks
      bool            _is_marked_dependent;  // used for marking during flushing and deoptimization
      bool            _rewritten;            // methods rewritten.
      bool            _has_nonstatic_fields; // for sizing with UseCompressedOops
      bool            _should_verify_class;  // allow caching of preverification
      u2              _minor_version;        // minor version number of class file
      u2              _major_version;        // major version number of class file
      ClassState      _init_state;           // state of class
      Thread*         _init_thread;          // Pointer to current thread doing initialization (to handle recusive initialization)
      int             _vtable_len;           // length of Java vtable (in words)
      int             _itable_len;           // length of Java itable (in words)
      ReferenceType   _reference_type;       // reference type
      OopMapCache*    volatile _oop_map_cache;   // OopMapCache for all methods in the klass (allocated lazily)
      JNIid*          _jni_ids;              // First JNI identifier for static fields in this class
      jmethodID*      _methods_jmethod_ids;  // jmethodIDs corresponding to method_idnum, or NULL if none
      int*            _methods_cached_itable_indices;  // itable_index cache for JNI invoke corresponding to methods idnum, or NULL
      nmethodBucket*  _dependencies;         // list of dependent nmethods
      nmethod*        _osr_nmethods_head;    // Head of list of on-stack replacement nmethods for this class
      BreakpointInfo* _breakpoints;          // bpt lists, managed by methodOop
      int             _nof_implementors;     // No of implementors of this interface (zero if not an interface)
      // Array of interesting part(s) of the previous version(s) of this
      // instanceKlass. See PreviousVersionWalker below.
      GrowableArray<PreviousVersionNode *>* _previous_versions;
      u2              _enclosing_method_class_index;  // Constant pool index for class of enclosing method, or 0 if none
      u2              _enclosing_method_method_index; // Constant pool index for name and type of enclosing method, or 0 if none
      // JVMTI fields can be moved to their own structure - see 6315920
      unsigned char * _cached_class_file_bytes;       // JVMTI: cached class file, before retransformable agent modified it in CFLH
      jint            _cached_class_file_len;         // JVMTI: length of above
      JvmtiCachedClassFieldMap* _jvmti_cached_class_field_map;  // JVMTI: used during heap iteration
      volatile u2     _idnum_allocated_count;         // JNI/JVMTI: increments with the addition of methods, old ids don't change

      // embedded Java vtable follows here
      // embedded Java itables follows here
      // embedded static fields follows here
      // embedded nonstatic oop-map blocks follows here

    ((cite: hotspot/src/share/vm/oops/instanceKlass.hpp))
    //  instanceKlass layout:
    //    [header                     ] klassOop
    //    [klass pointer              ] klassOop
    //    [C++ vtbl pointer           ] Klass
    //    [subtype cache              ] Klass
    //    [instance size              ] Klass
    //    [java mirror                ] Klass
    //    [super                      ] Klass
    //    [access_flags               ] Klass
    //    [name                       ] Klass
    //    [first subklass             ] Klass
    //    [next sibling               ] Klass
    //    [array klasses              ]
    //    [methods                    ]
    //    [local interfaces           ]
    //    [transitive interfaces      ]
    //    [number of implementors     ]
    //    [implementors               ] klassOop[2]
    //    [fields                     ]
    //    [constants                  ]
    //    [class loader               ]
    //    [protection domain          ]
    //    [signers                    ]
    //    [source file name           ]
    //    [inner classes              ]
    //    [static field size          ]
    //    [nonstatic field size       ]
    //    [static oop fields size     ]
    //    [nonstatic oop maps size    ]
    //    [has finalize method        ]
    //    [deoptimization mark bit    ]
    //    [initialization state       ]
    //    [initializing thread        ]
    //    [Java vtable length         ]
    //    [oop map cache (stack maps) ]
    //    [EMBEDDED Java vtable             ] size in words = vtable_len
    //    [EMBEDDED nonstatic oop-map blocks] size in words = nonstatic_oop_map_size
    //
    //    The embedded nonstatic oop-map blocks are short pairs (offset, length) indicating
    //    where oops are located in instances of this klass.

    ((cite: hotspot/src/share/vm/oops/instanceKlass.hpp))
    // ValueObjs embedded in klass. Describes where oops are located in instances of
    // this klass.
    class OopMapBlock VALUE_OBJ_CLASS_SPEC {

    ((cite: hotspot/src/share/vm/oops/instanceKlass.hpp))
      int  _offset;
      uint _count;

    ((cite: hotspot/src/share/vm/oops/instanceKlass.hpp))
    // This is used in iterators below.
    class FieldClosure: public StackObj {

    ((cite: hotspot/src/share/vm/oops/instanceKlass.hpp))
      virtual void do_field(fieldDescriptor* fd) = 0;

    ((cite: hotspot/src/share/vm/oops/instanceKlass.hpp))
    #ifndef PRODUCT
    // Print fields.
    // If "obj" argument to constructor is NULL, prints static fields, otherwise prints non-static fields.
    class FieldPrinter: public FieldClosure {

    ((cite: hotspot/src/share/vm/oops/instanceKlass.hpp))
      // JNI identifier support (for static fields - for jni performance)

    ((cite: hotspot/src/share/vm/oops/instanceKlass.hpp))
    /* JNIid class for jfieldIDs only */
    class JNIid: public CHeapObj {

    ((cite: hotspot/src/share/vm/oops/instanceKlass.hpp))
    // A collection point for interesting information about the previous
    // version(s) of an instanceKlass. This class uses weak references to
    // the information so that the information may be collected as needed
    // by the system. If the information is shared, then a regular
    // reference must be used because a weak reference would be seen as
    // collectible. A GrowableArray of PreviousVersionNodes is attached
    // to the instanceKlass as needed. See PreviousVersionWalker below.
    class PreviousVersionNode : public CHeapObj {

    ((cite: hotspot/src/share/vm/oops/instanceKlass.hpp))
    // A Handle-ized version of PreviousVersionNode.
    class PreviousVersionInfo : public ResourceObj {

    ((cite: hotspot/src/share/vm/oops/instanceKlass.hpp))
    // Helper object for walking previous versions. This helper cleans up
    // the Handles that it allocates when the helper object is destroyed.
    // The PreviousVersionInfo object returned by next_previous_version()
    // is only valid until a subsequent call to next_previous_version() or
    // the helper object is destroyed.
    class PreviousVersionWalker : public StackObj {

    ((cite: hotspot/src/share/vm/oops/instanceKlass.cpp))
    //
    // nmethodBucket is used to record dependent nmethods for
    // deoptimization.  nmethod dependencies are actually <klass, method>
    // pairs but we really only care about the klass part for purposes of
    // finding nmethods which might need to be deoptimized.  Instead of
    // recording the method, a count of how many times a particular nmethod
    // was recorded is kept.  This ensures that any recording errors are
    // noticed since an nmethod should be removed as many times are it's
    // added.
    //
    class nmethodBucket {

    ((cite: hotspot/src/share/vm/oops/instanceKlass.cpp))
    // Verification

    class VerifyFieldClosure: public OopClosure {