1 /*
   2  * Copyright (c) 1997, 2018, 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/classLoader.hpp"
  29 #include "classfile/classLoaderData.hpp"
  30 #include "classfile/moduleEntry.hpp"
  31 #include "classfile/packageEntry.hpp"
  32 #include "memory/referenceType.hpp"
  33 #include "oops/annotations.hpp"
  34 #include "oops/constMethod.hpp"
  35 #include "oops/fieldInfo.hpp"
  36 #include "oops/instanceOop.hpp"
  37 #include "oops/klassVtable.hpp"
  38 #include "runtime/handles.hpp"
  39 #include "runtime/os.hpp"
  40 #include "utilities/accessFlags.hpp"
  41 #include "utilities/align.hpp"
  42 #include "utilities/macros.hpp"
  43 #if INCLUDE_JFR
  44 #include "jfr/support/jfrKlassExtension.hpp"
  45 #endif
  46 
  47 
  48 // An InstanceKlass is the VM level representation of a Java class.
  49 // It contains all information needed for at class at execution runtime.
  50 
  51 //  InstanceKlass embedded field layout (after declared fields):
  52 //    [EMBEDDED Java vtable             ] size in words = vtable_len
  53 //    [EMBEDDED nonstatic oop-map blocks] size in words = nonstatic_oop_map_size
  54 //      The embedded nonstatic oop-map blocks are short pairs (offset, length)
  55 //      indicating where oops are located in instances of this klass.
  56 //    [EMBEDDED implementor of the interface] only exist for interface
  57 //    [EMBEDDED unsafe_anonymous_host klass] only exist for an unsafe anonymous class (JSR 292 enabled)
  58 //    [EMBEDDED fingerprint       ] only if should_store_fingerprint()==true
  59 
  60 
  61 // forward declaration for class -- see below for definition
  62 #if INCLUDE_JVMTI
  63 class BreakpointInfo;
  64 #endif
  65 class ClassFileParser;
  66 class KlassDepChange;
  67 class DependencyContext;
  68 class fieldDescriptor;
  69 class jniIdMapBase;
  70 class JNIid;
  71 class JvmtiCachedClassFieldMap;
  72 class SuperTypeClosure;
  73 
  74 // This is used in iterators below.
  75 class FieldClosure: public StackObj {
  76 public:
  77   virtual void do_field(fieldDescriptor* fd) = 0;
  78 };
  79 
  80 #ifndef PRODUCT
  81 // Print fields.
  82 // If "obj" argument to constructor is NULL, prints static fields, otherwise prints non-static fields.
  83 class FieldPrinter: public FieldClosure {
  84    oop _obj;
  85    outputStream* _st;
  86  public:
  87    FieldPrinter(outputStream* st, oop obj = NULL) : _obj(obj), _st(st) {}
  88    void do_field(fieldDescriptor* fd);
  89 };
  90 #endif  // !PRODUCT
  91 
  92 // Describes where oops are located in instances of this klass.
  93 class OopMapBlock {
  94  public:
  95   // Byte offset of the first oop mapped by this block.
  96   int offset() const          { return _offset; }
  97   void set_offset(int offset) { _offset = offset; }
  98 
  99   // Number of oops in this block.
 100   uint count() const         { return _count; }
 101   void set_count(uint count) { _count = count; }
 102 
 103   // sizeof(OopMapBlock) in words.
 104   static const int size_in_words() {
 105     return align_up((int)sizeof(OopMapBlock), wordSize) >>
 106       LogBytesPerWord;
 107   }
 108 
 109  private:
 110   int  _offset;
 111   uint _count;
 112 };
 113 
 114 struct JvmtiCachedClassFileData;
 115 
 116 class InstanceKlass: public Klass {
 117   friend class VMStructs;
 118   friend class JVMCIVMStructs;
 119   friend class ClassFileParser;
 120   friend class CompileReplay;
 121 
 122  public:
 123   static const KlassID ID = InstanceKlassID;
 124 
 125  protected:
 126   InstanceKlass(const ClassFileParser& parser, unsigned kind, KlassID id = ID);
 127 
 128  public:
 129   InstanceKlass() { assert(DumpSharedSpaces || UseSharedSpaces, "only for CDS"); }
 130 
 131   // See "The Java Virtual Machine Specification" section 2.16.2-5 for a detailed description
 132   // of the class loading & initialization procedure, and the use of the states.
 133   enum ClassState {
 134     allocated,                          // allocated (but not yet linked)
 135     loaded,                             // loaded and inserted in class hierarchy (but not linked yet)
 136     linked,                             // successfully linked/verified (but not initialized yet)
 137     being_initialized,                  // currently running class initializer
 138     fully_initialized,                  // initialized (successfull final state)
 139     initialization_error                // error happened during initialization
 140   };
 141 
 142  private:
 143   static InstanceKlass* allocate_instance_klass(const ClassFileParser& parser, TRAPS);
 144 
 145  protected:
 146   // If you add a new field that points to any metaspace object, you
 147   // must add this field to InstanceKlass::metaspace_pointers_do().
 148 
 149   // Annotations for this class
 150   Annotations*    _annotations;
 151   // Package this class is defined in
 152   PackageEntry*   _package_entry;
 153   // Array classes holding elements of this class.
 154   Klass* volatile _array_klasses;
 155   // Constant pool for this class.
 156   ConstantPool* _constants;
 157   // The InnerClasses attribute and EnclosingMethod attribute. The
 158   // _inner_classes is an array of shorts. If the class has InnerClasses
 159   // attribute, then the _inner_classes array begins with 4-tuples of shorts
 160   // [inner_class_info_index, outer_class_info_index,
 161   // inner_name_index, inner_class_access_flags] for the InnerClasses
 162   // attribute. If the EnclosingMethod attribute exists, it occupies the
 163   // last two shorts [class_index, method_index] of the array. If only
 164   // the InnerClasses attribute exists, the _inner_classes array length is
 165   // number_of_inner_classes * 4. If the class has both InnerClasses
 166   // and EnclosingMethod attributes the _inner_classes array length is
 167   // number_of_inner_classes * 4 + enclosing_method_attribute_size.
 168   Array<jushort>* _inner_classes;
 169 
 170   // The NestMembers attribute. An array of shorts, where each is a
 171   // class info index for the class that is a nest member. This data
 172   // has not been validated.
 173   Array<jushort>* _nest_members;
 174 
 175   // The NestHost attribute. The class info index for the class
 176   // that is the nest-host of this class. This data has not been validated.
 177   jushort _nest_host_index;
 178 
 179   // Resolved nest-host klass: either true nest-host or self if we are not nested.
 180   // By always being set it makes nest-member access checks simpler.
 181   InstanceKlass* _nest_host;
 182 
 183   // the source debug extension for this klass, NULL if not specified.
 184   // Specified as UTF-8 string without terminating zero byte in the classfile,
 185   // it is stored in the instanceklass as a NULL-terminated UTF-8 string
 186   const char*     _source_debug_extension;
 187   // Array name derived from this class which needs unreferencing
 188   // if this class is unloaded.
 189   Symbol*         _array_name;
 190 
 191   // Number of heapOopSize words used by non-static fields in this klass
 192   // (including inherited fields but after header_size()).
 193   int             _nonstatic_field_size;
 194   int             _static_field_size;    // number words used by static fields (oop and non-oop) in this klass
 195   // Constant pool index to the utf8 entry of the Generic signature,
 196   // or 0 if none.
 197   u2              _generic_signature_index;
 198   // Constant pool index to the utf8 entry for the name of source file
 199   // containing this klass, 0 if not specified.
 200   u2              _source_file_name_index;
 201   u2              _static_oop_field_count;// number of static oop fields in this klass
 202   u2              _java_fields_count;    // The number of declared Java fields
 203   int             _nonstatic_oop_map_size;// size in words of nonstatic oop map blocks
 204 
 205   int             _itable_len;           // length of Java itable (in words)
 206   // _is_marked_dependent can be set concurrently, thus cannot be part of the
 207   // _misc_flags.
 208   bool            _is_marked_dependent;  // used for marking during flushing and deoptimization
 209   bool            _is_being_redefined;   // used for locking redefinition
 210 
 211   // The low two bits of _misc_flags contains the kind field.
 212   // This can be used to quickly discriminate among the four kinds of
 213   // InstanceKlass.
 214 
 215   static const unsigned _misc_kind_field_size = 2;
 216   static const unsigned _misc_kind_field_pos  = 0;
 217   static const unsigned _misc_kind_field_mask = (1u << _misc_kind_field_size) - 1u;
 218 
 219   static const unsigned _misc_kind_other        = 0; // concrete InstanceKlass
 220   static const unsigned _misc_kind_reference    = 1; // InstanceRefKlass
 221   static const unsigned _misc_kind_class_loader = 2; // InstanceClassLoaderKlass
 222   static const unsigned _misc_kind_mirror       = 3; // InstanceMirrorKlass
 223 
 224   // Start after _misc_kind field.
 225   enum {
 226     _misc_rewritten                           = 1 << 2,  // methods rewritten.
 227     _misc_has_nonstatic_fields                = 1 << 3,  // for sizing with UseCompressedOops
 228     _misc_should_verify_class                 = 1 << 4,  // allow caching of preverification
 229     _misc_is_unsafe_anonymous                 = 1 << 5,  // has embedded _unsafe_anonymous_host field
 230     _misc_is_contended                        = 1 << 6,  // marked with contended annotation
 231     _misc_has_nonstatic_concrete_methods      = 1 << 7,  // class/superclass/implemented interfaces has non-static, concrete methods
 232     _misc_declares_nonstatic_concrete_methods = 1 << 8,  // directly declares non-static, concrete methods
 233     _misc_has_been_redefined                  = 1 << 9,  // class has been redefined
 234     _misc_has_passed_fingerprint_check        = 1 << 10, // when this class was loaded, the fingerprint computed from its
 235                                                          // code source was found to be matching the value recorded by AOT.
 236     _misc_is_scratch_class                    = 1 << 11, // class is the redefined scratch class
 237     _misc_is_shared_boot_class                = 1 << 12, // defining class loader is boot class loader
 238     _misc_is_shared_platform_class            = 1 << 13, // defining class loader is platform class loader
 239     _misc_is_shared_app_class                 = 1 << 14, // defining class loader is app class loader
 240     _misc_has_resolved_methods                = 1 << 15  // resolved methods table entries added for this class
 241   };
 242   u2 loader_type_bits() {
 243     return _misc_is_shared_boot_class|_misc_is_shared_platform_class|_misc_is_shared_app_class;
 244   }
 245   u2              _misc_flags;
 246   u2              _minor_version;        // minor version number of class file
 247   u2              _major_version;        // major version number of class file
 248   Thread*         _init_thread;          // Pointer to current thread doing initialization (to handle recusive initialization)
 249   OopMapCache*    volatile _oop_map_cache;   // OopMapCache for all methods in the klass (allocated lazily)
 250   JNIid*          _jni_ids;              // First JNI identifier for static fields in this class
 251   jmethodID*      volatile _methods_jmethod_ids;  // jmethodIDs corresponding to method_idnum, or NULL if none
 252   intptr_t        _dep_context;          // packed DependencyContext structure
 253   nmethod*        _osr_nmethods_head;    // Head of list of on-stack replacement nmethods for this class
 254 #if INCLUDE_JVMTI
 255   BreakpointInfo* _breakpoints;          // bpt lists, managed by Method*
 256   // Linked instanceKlasses of previous versions
 257   InstanceKlass* _previous_versions;
 258   // JVMTI fields can be moved to their own structure - see 6315920
 259   // JVMTI: cached class file, before retransformable agent modified it in CFLH
 260   JvmtiCachedClassFileData* _cached_class_file;
 261 #endif
 262 
 263   volatile u2     _idnum_allocated_count;         // JNI/JVMTI: increments with the addition of methods, old ids don't change
 264 
 265   // Class states are defined as ClassState (see above).
 266   // Place the _init_state here to utilize the unused 2-byte after
 267   // _idnum_allocated_count.
 268   u1              _init_state;                    // state of class
 269   u1              _reference_type;                // reference type
 270 
 271   u2              _this_class_index;              // constant pool entry
 272 #if INCLUDE_JVMTI
 273   JvmtiCachedClassFieldMap* _jvmti_cached_class_field_map;  // JVMTI: used during heap iteration
 274 #endif
 275 
 276   NOT_PRODUCT(int _verify_count;)  // to avoid redundant verifies
 277 
 278   // Method array.
 279   Array<Method*>* _methods;
 280   // Default Method Array, concrete methods inherited from interfaces
 281   Array<Method*>* _default_methods;
 282   // Interfaces (InstanceKlass*s) this class declares locally to implement.
 283   Array<InstanceKlass*>* _local_interfaces;
 284   // Interfaces (InstanceKlass*s) this class implements transitively.
 285   Array<InstanceKlass*>* _transitive_interfaces;
 286   // Int array containing the original order of method in the class file (for JVMTI).
 287   Array<int>*     _method_ordering;
 288   // Int array containing the vtable_indices for default_methods
 289   // offset matches _default_methods offset
 290   Array<int>*     _default_vtable_indices;
 291 
 292   // Instance and static variable information, starts with 6-tuples of shorts
 293   // [access, name index, sig index, initval index, low_offset, high_offset]
 294   // for all fields, followed by the generic signature data at the end of
 295   // the array. Only fields with generic signature attributes have the generic
 296   // signature data set in the array. The fields array looks like following:
 297   //
 298   // f1: [access, name index, sig index, initial value index, low_offset, high_offset]
 299   // f2: [access, name index, sig index, initial value index, low_offset, high_offset]
 300   //      ...
 301   // fn: [access, name index, sig index, initial value index, low_offset, high_offset]
 302   //     [generic signature index]
 303   //     [generic signature index]
 304   //     ...
 305   Array<u2>*      _fields;
 306 
 307   // embedded Java vtable follows here
 308   // embedded Java itables follows here
 309   // embedded static fields follows here
 310   // embedded nonstatic oop-map blocks follows here
 311   // embedded implementor of this interface follows here
 312   //   The embedded implementor only exists if the current klass is an
 313   //   iterface. The possible values of the implementor fall into following
 314   //   three cases:
 315   //     NULL: no implementor.
 316   //     A Klass* that's not itself: one implementor.
 317   //     Itself: more than one implementors.
 318   // embedded unsafe_anonymous_host klass follows here
 319   //   The embedded host klass only exists in an unsafe anonymous class for
 320   //   dynamic language support (JSR 292 enabled). The host class grants
 321   //   its access privileges to this class also. The host class is either
 322   //   named, or a previously loaded unsafe anonymous class. A non-anonymous class
 323   //   or an anonymous class loaded through normal classloading does not
 324   //   have this embedded field.
 325   //
 326 
 327   friend class SystemDictionary;
 328 
 329  public:
 330   u2 loader_type() {
 331     return _misc_flags & loader_type_bits();
 332   }
 333 
 334   bool is_shared_boot_class() const {
 335     return (_misc_flags & _misc_is_shared_boot_class) != 0;
 336   }
 337   bool is_shared_platform_class() const {
 338     return (_misc_flags & _misc_is_shared_platform_class) != 0;
 339   }
 340   bool is_shared_app_class() const {
 341     return (_misc_flags & _misc_is_shared_app_class) != 0;
 342   }
 343 
 344   void clear_class_loader_type() {
 345     _misc_flags &= ~loader_type_bits();
 346   }
 347 
 348   void set_class_loader_type(s2 loader_type) {
 349     switch (loader_type) {
 350     case ClassLoader::BOOT_LOADER:
 351       _misc_flags |= _misc_is_shared_boot_class;
 352        break;
 353     case ClassLoader::PLATFORM_LOADER:
 354       _misc_flags |= _misc_is_shared_platform_class;
 355       break;
 356     case ClassLoader::APP_LOADER:
 357       _misc_flags |= _misc_is_shared_app_class;
 358       break;
 359     default:
 360       ShouldNotReachHere();
 361       break;
 362     }
 363   }
 364 
 365   bool has_nonstatic_fields() const        {
 366     return (_misc_flags & _misc_has_nonstatic_fields) != 0;
 367   }
 368   void set_has_nonstatic_fields(bool b)    {
 369     if (b) {
 370       _misc_flags |= _misc_has_nonstatic_fields;
 371     } else {
 372       _misc_flags &= ~_misc_has_nonstatic_fields;
 373     }
 374   }
 375 
 376   // field sizes
 377   int nonstatic_field_size() const         { return _nonstatic_field_size; }
 378   void set_nonstatic_field_size(int size)  { _nonstatic_field_size = size; }
 379 
 380   int static_field_size() const            { return _static_field_size; }
 381   void set_static_field_size(int size)     { _static_field_size = size; }
 382 
 383   int static_oop_field_count() const       { return (int)_static_oop_field_count; }
 384   void set_static_oop_field_count(u2 size) { _static_oop_field_count = size; }
 385 
 386   // Java itable
 387   int  itable_length() const               { return _itable_len; }
 388   void set_itable_length(int len)          { _itable_len = len; }
 389 
 390   // array klasses
 391   Klass* array_klasses() const             { return _array_klasses; }
 392   inline Klass* array_klasses_acquire() const; // load with acquire semantics
 393   void set_array_klasses(Klass* k)         { _array_klasses = k; }
 394   inline void release_set_array_klasses(Klass* k); // store with release semantics
 395 
 396   // methods
 397   Array<Method*>* methods() const          { return _methods; }
 398   void set_methods(Array<Method*>* a)      { _methods = a; }
 399   Method* method_with_idnum(int idnum);
 400   Method* method_with_orig_idnum(int idnum);
 401   Method* method_with_orig_idnum(int idnum, int version);
 402 
 403   // method ordering
 404   Array<int>* method_ordering() const     { return _method_ordering; }
 405   void set_method_ordering(Array<int>* m) { _method_ordering = m; }
 406   void copy_method_ordering(const intArray* m, TRAPS);
 407 
 408   // default_methods
 409   Array<Method*>* default_methods() const  { return _default_methods; }
 410   void set_default_methods(Array<Method*>* a) { _default_methods = a; }
 411 
 412   // default method vtable_indices
 413   Array<int>* default_vtable_indices() const { return _default_vtable_indices; }
 414   void set_default_vtable_indices(Array<int>* v) { _default_vtable_indices = v; }
 415   Array<int>* create_new_default_vtable_indices(int len, TRAPS);
 416 
 417   // interfaces
 418   Array<InstanceKlass*>* local_interfaces() const          { return _local_interfaces; }
 419   void set_local_interfaces(Array<InstanceKlass*>* a)      {
 420     guarantee(_local_interfaces == NULL || a == NULL, "Just checking");
 421     _local_interfaces = a; }
 422 
 423   Array<InstanceKlass*>* transitive_interfaces() const     { return _transitive_interfaces; }
 424   void set_transitive_interfaces(Array<InstanceKlass*>* a) {
 425     guarantee(_transitive_interfaces == NULL || a == NULL, "Just checking");
 426     _transitive_interfaces = a;
 427   }
 428 
 429  private:
 430   friend class fieldDescriptor;
 431   FieldInfo* field(int index) const { return FieldInfo::from_field_array(_fields, index); }
 432 
 433  public:
 434   int     field_offset      (int index) const { return field(index)->offset(); }
 435   int     field_access_flags(int index) const { return field(index)->access_flags(); }
 436   Symbol* field_name        (int index) const { return field(index)->name(constants()); }
 437   Symbol* field_signature   (int index) const { return field(index)->signature(constants()); }
 438 
 439   // Number of Java declared fields
 440   int java_fields_count() const           { return (int)_java_fields_count; }
 441 
 442   Array<u2>* fields() const            { return _fields; }
 443   void set_fields(Array<u2>* f, u2 java_fields_count) {
 444     guarantee(_fields == NULL || f == NULL, "Just checking");
 445     _fields = f;
 446     _java_fields_count = java_fields_count;
 447   }
 448 
 449   // inner classes
 450   Array<u2>* inner_classes() const       { return _inner_classes; }
 451   void set_inner_classes(Array<u2>* f)   { _inner_classes = f; }
 452 
 453   // nest members
 454   Array<u2>* nest_members() const     { return _nest_members; }
 455   void set_nest_members(Array<u2>* m) { _nest_members = m; }
 456 
 457   // nest-host index
 458   jushort nest_host_index() const { return _nest_host_index; }
 459   void set_nest_host_index(u2 i)  { _nest_host_index = i; }
 460 
 461 private:
 462   // Called to verify that k is a member of this nest - does not look at k's nest-host
 463   bool has_nest_member(InstanceKlass* k, TRAPS) const;
 464 public:
 465   // Returns nest-host class, resolving and validating it if needed
 466   // Returns NULL if an exception occurs during loading, or validation fails
 467   InstanceKlass* nest_host(Symbol* validationException, TRAPS);
 468   // Check if this klass is a nestmate of k - resolves this nest-host and k's
 469   bool has_nestmate_access_to(InstanceKlass* k, TRAPS);
 470 
 471   enum InnerClassAttributeOffset {
 472     // From http://mirror.eng/products/jdk/1.1/docs/guide/innerclasses/spec/innerclasses.doc10.html#18814
 473     inner_class_inner_class_info_offset = 0,
 474     inner_class_outer_class_info_offset = 1,
 475     inner_class_inner_name_offset = 2,
 476     inner_class_access_flags_offset = 3,
 477     inner_class_next_offset = 4
 478   };
 479 
 480   enum EnclosingMethodAttributeOffset {
 481     enclosing_method_class_index_offset = 0,
 482     enclosing_method_method_index_offset = 1,
 483     enclosing_method_attribute_size = 2
 484   };
 485 
 486   // method override check
 487   bool is_override(const methodHandle& super_method, Handle targetclassloader, Symbol* targetclassname, TRAPS);
 488 
 489   // package
 490   PackageEntry* package() const     { return _package_entry; }
 491   ModuleEntry* module() const;
 492   bool in_unnamed_package() const   { return (_package_entry == NULL); }
 493   void set_package(PackageEntry* p) { _package_entry = p; }
 494   void set_package(ClassLoaderData* loader_data, TRAPS);
 495   bool is_same_class_package(const Klass* class2) const;
 496   bool is_same_class_package(oop other_class_loader, const Symbol* other_class_name) const;
 497 
 498   // find an enclosing class
 499   InstanceKlass* compute_enclosing_class(bool* inner_is_member, TRAPS) const;
 500 
 501   // Find InnerClasses attribute and return outer_class_info_index & inner_name_index.
 502   bool find_inner_classes_attr(int* ooff, int* noff, TRAPS) const;
 503 
 504  private:
 505   // Check prohibited package ("java/" only loadable by boot or platform loaders)
 506   static void check_prohibited_package(Symbol* class_name,
 507                                        ClassLoaderData* loader_data,
 508                                        TRAPS);
 509  public:
 510   // tell if two classes have the same enclosing class (at package level)
 511   bool is_same_package_member(const Klass* class2, TRAPS) const;
 512 
 513   // initialization state
 514   bool is_loaded() const                   { return _init_state >= loaded; }
 515   bool is_linked() const                   { return _init_state >= linked; }
 516   bool is_initialized() const              { return _init_state == fully_initialized; }
 517   bool is_not_initialized() const          { return _init_state <  being_initialized; }
 518   bool is_being_initialized() const        { return _init_state == being_initialized; }
 519   bool is_in_error_state() const           { return _init_state == initialization_error; }
 520   bool is_reentrant_initialization(Thread *thread)  { return thread == _init_thread; }
 521   ClassState  init_state()                 { return (ClassState)_init_state; }
 522   bool is_rewritten() const                { return (_misc_flags & _misc_rewritten) != 0; }
 523 
 524   // defineClass specified verification
 525   bool should_verify_class() const         {
 526     return (_misc_flags & _misc_should_verify_class) != 0;
 527   }
 528   void set_should_verify_class(bool value) {
 529     if (value) {
 530       _misc_flags |= _misc_should_verify_class;
 531     } else {
 532       _misc_flags &= ~_misc_should_verify_class;
 533     }
 534   }
 535 
 536   // marking
 537   bool is_marked_dependent() const         { return _is_marked_dependent; }
 538   void set_is_marked_dependent(bool value) { _is_marked_dependent = value; }
 539 
 540   // initialization (virtuals from Klass)
 541   bool should_be_initialized() const;  // means that initialize should be called
 542   void initialize(TRAPS);
 543   void link_class(TRAPS);
 544   bool link_class_or_fail(TRAPS); // returns false on failure
 545   void unlink_class();
 546   void rewrite_class(TRAPS);
 547   void link_methods(TRAPS);
 548   Method* class_initializer() const;
 549 
 550   // set the class to initialized if no static initializer is present
 551   void eager_initialize(Thread *thread);
 552 
 553   // reference type
 554   ReferenceType reference_type() const     { return (ReferenceType)_reference_type; }
 555   void set_reference_type(ReferenceType t) {
 556     assert(t == (u1)t, "overflow");
 557     _reference_type = (u1)t;
 558   }
 559 
 560   // this class cp index
 561   u2 this_class_index() const             { return _this_class_index; }
 562   void set_this_class_index(u2 index)     { _this_class_index = index; }
 563 
 564   static ByteSize reference_type_offset() { return in_ByteSize(offset_of(InstanceKlass, _reference_type)); }
 565 
 566   // find local field, returns true if found
 567   bool find_local_field(Symbol* name, Symbol* sig, fieldDescriptor* fd) const;
 568   // find field in direct superinterfaces, returns the interface in which the field is defined
 569   Klass* find_interface_field(Symbol* name, Symbol* sig, fieldDescriptor* fd) const;
 570   // find field according to JVM spec 5.4.3.2, returns the klass in which the field is defined
 571   Klass* find_field(Symbol* name, Symbol* sig, fieldDescriptor* fd) const;
 572   // find instance or static fields according to JVM spec 5.4.3.2, returns the klass in which the field is defined
 573   Klass* find_field(Symbol* name, Symbol* sig, bool is_static, fieldDescriptor* fd) const;
 574 
 575   // find a non-static or static field given its offset within the class.
 576   bool contains_field_offset(int offset) {
 577     return instanceOopDesc::contains_field_offset(offset, nonstatic_field_size());
 578   }
 579 
 580   bool find_local_field_from_offset(int offset, bool is_static, fieldDescriptor* fd) const;
 581   bool find_field_from_offset(int offset, bool is_static, fieldDescriptor* fd) const;
 582 
 583   // find a local method (returns NULL if not found)
 584   Method* find_method(const Symbol* name, const Symbol* signature) const;
 585   static Method* find_method(const Array<Method*>* methods,
 586                              const Symbol* name,
 587                              const Symbol* signature);
 588 
 589   // find a local method, but skip static methods
 590   Method* find_instance_method(const Symbol* name, const Symbol* signature,
 591                                PrivateLookupMode private_mode = find_private) const;
 592   static Method* find_instance_method(const Array<Method*>* methods,
 593                                       const Symbol* name,
 594                                       const Symbol* signature,
 595                                       PrivateLookupMode private_mode = find_private);
 596 
 597   // find a local method (returns NULL if not found)
 598   Method* find_local_method(const Symbol* name,
 599                             const Symbol* signature,
 600                             OverpassLookupMode overpass_mode,
 601                             StaticLookupMode static_mode,
 602                             PrivateLookupMode private_mode) const;
 603 
 604   // find a local method from given methods array (returns NULL if not found)
 605   static Method* find_local_method(const Array<Method*>* methods,
 606                                    const Symbol* name,
 607                                    const Symbol* signature,
 608                                    OverpassLookupMode overpass_mode,
 609                                    StaticLookupMode static_mode,
 610                                    PrivateLookupMode private_mode);
 611 
 612   // find a local method index in methods or default_methods (returns -1 if not found)
 613   static int find_method_index(const Array<Method*>* methods,
 614                                const Symbol* name,
 615                                const Symbol* signature,
 616                                OverpassLookupMode overpass_mode,
 617                                StaticLookupMode static_mode,
 618                                PrivateLookupMode private_mode);
 619 
 620   // lookup operation (returns NULL if not found)
 621   Method* uncached_lookup_method(const Symbol* name,
 622                                  const Symbol* signature,
 623                                  OverpassLookupMode overpass_mode,
 624                                  PrivateLookupMode private_mode = find_private) const;
 625 
 626   // lookup a method in all the interfaces that this class implements
 627   // (returns NULL if not found)
 628   Method* lookup_method_in_all_interfaces(Symbol* name, Symbol* signature, DefaultsLookupMode defaults_mode) const;
 629 
 630   // lookup a method in local defaults then in all interfaces
 631   // (returns NULL if not found)
 632   Method* lookup_method_in_ordered_interfaces(Symbol* name, Symbol* signature) const;
 633 
 634   // Find method indices by name.  If a method with the specified name is
 635   // found the index to the first method is returned, and 'end' is filled in
 636   // with the index of first non-name-matching method.  If no method is found
 637   // -1 is returned.
 638   int find_method_by_name(const Symbol* name, int* end) const;
 639   static int find_method_by_name(const Array<Method*>* methods,
 640                                  const Symbol* name, int* end);
 641 
 642   // constant pool
 643   ConstantPool* constants() const        { return _constants; }
 644   void set_constants(ConstantPool* c)    { _constants = c; }
 645 
 646   // protection domain
 647   oop protection_domain() const;
 648 
 649   // signers
 650   objArrayOop signers() const;
 651 
 652   // host class
 653   InstanceKlass* unsafe_anonymous_host() const {
 654     InstanceKlass** hk = adr_unsafe_anonymous_host();
 655     if (hk == NULL) {
 656       assert(!is_unsafe_anonymous(), "Unsafe anonymous classes have host klasses");
 657       return NULL;
 658     } else {
 659       assert(*hk != NULL, "host klass should always be set if the address is not null");
 660       assert(is_unsafe_anonymous(), "Only unsafe anonymous classes have host klasses");
 661       return *hk;
 662     }
 663   }
 664   void set_unsafe_anonymous_host(const InstanceKlass* host) {
 665     assert(is_unsafe_anonymous(), "not unsafe anonymous");
 666     const InstanceKlass** addr = (const InstanceKlass **)adr_unsafe_anonymous_host();
 667     assert(addr != NULL, "no reversed space");
 668     if (addr != NULL) {
 669       *addr = host;
 670     }
 671   }
 672   bool is_unsafe_anonymous() const                {
 673     return (_misc_flags & _misc_is_unsafe_anonymous) != 0;
 674   }
 675   void set_is_unsafe_anonymous(bool value)        {
 676     if (value) {
 677       _misc_flags |= _misc_is_unsafe_anonymous;
 678     } else {
 679       _misc_flags &= ~_misc_is_unsafe_anonymous;
 680     }
 681   }
 682 
 683   // Oop that keeps the metadata for this class from being unloaded
 684   // in places where the metadata is stored in other places, like nmethods
 685   oop klass_holder() const {
 686     return (is_unsafe_anonymous()) ? java_mirror() : class_loader();
 687   }
 688 
 689   bool is_contended() const                {
 690     return (_misc_flags & _misc_is_contended) != 0;
 691   }
 692   void set_is_contended(bool value)        {
 693     if (value) {
 694       _misc_flags |= _misc_is_contended;
 695     } else {
 696       _misc_flags &= ~_misc_is_contended;
 697     }
 698   }
 699 
 700   // source file name
 701   Symbol* source_file_name() const               {
 702     return (_source_file_name_index == 0) ?
 703       (Symbol*)NULL : _constants->symbol_at(_source_file_name_index);
 704   }
 705   u2 source_file_name_index() const              {
 706     return _source_file_name_index;
 707   }
 708   void set_source_file_name_index(u2 sourcefile_index) {
 709     _source_file_name_index = sourcefile_index;
 710   }
 711 
 712   // minor and major version numbers of class file
 713   u2 minor_version() const                 { return _minor_version; }
 714   void set_minor_version(u2 minor_version) { _minor_version = minor_version; }
 715   u2 major_version() const                 { return _major_version; }
 716   void set_major_version(u2 major_version) { _major_version = major_version; }
 717 
 718   // source debug extension
 719   const char* source_debug_extension() const { return _source_debug_extension; }
 720   void set_source_debug_extension(const char* array, int length);
 721 
 722   // symbol unloading support (refcount already added)
 723   Symbol* array_name()                     { return _array_name; }
 724   void set_array_name(Symbol* name)        { assert(_array_name == NULL  || name == NULL, "name already created"); _array_name = name; }
 725 
 726   // nonstatic oop-map blocks
 727   static int nonstatic_oop_map_size(unsigned int oop_map_count) {
 728     return oop_map_count * OopMapBlock::size_in_words();
 729   }
 730   unsigned int nonstatic_oop_map_count() const {
 731     return _nonstatic_oop_map_size / OopMapBlock::size_in_words();
 732   }
 733   int nonstatic_oop_map_size() const { return _nonstatic_oop_map_size; }
 734   void set_nonstatic_oop_map_size(int words) {
 735     _nonstatic_oop_map_size = words;
 736   }
 737 
 738 #if INCLUDE_JVMTI
 739   // Redefinition locking.  Class can only be redefined by one thread at a time.
 740   bool is_being_redefined() const          { return _is_being_redefined; }
 741   void set_is_being_redefined(bool value)  { _is_being_redefined = value; }
 742 
 743   // RedefineClasses() support for previous versions:
 744   void add_previous_version(InstanceKlass* ik, int emcp_method_count);
 745   void purge_previous_version_list();
 746 
 747   InstanceKlass* previous_versions() const { return _previous_versions; }
 748 #else
 749   InstanceKlass* previous_versions() const { return NULL; }
 750 #endif
 751 
 752   InstanceKlass* get_klass_version(int version) {
 753     for (InstanceKlass* ik = this; ik != NULL; ik = ik->previous_versions()) {
 754       if (ik->constants()->version() == version) {
 755         return ik;
 756       }
 757     }
 758     return NULL;
 759   }
 760 
 761   bool has_been_redefined() const {
 762     return (_misc_flags & _misc_has_been_redefined) != 0;
 763   }
 764   void set_has_been_redefined() {
 765     _misc_flags |= _misc_has_been_redefined;
 766   }
 767 
 768   bool has_passed_fingerprint_check() const {
 769     return (_misc_flags & _misc_has_passed_fingerprint_check) != 0;
 770   }
 771   void set_has_passed_fingerprint_check(bool b) {
 772     if (b) {
 773       _misc_flags |= _misc_has_passed_fingerprint_check;
 774     } else {
 775       _misc_flags &= ~_misc_has_passed_fingerprint_check;
 776     }
 777   }
 778   bool supers_have_passed_fingerprint_checks();
 779 
 780   static bool should_store_fingerprint(bool is_unsafe_anonymous);
 781   bool should_store_fingerprint() const { return should_store_fingerprint(is_unsafe_anonymous()); }
 782   bool has_stored_fingerprint() const;
 783   uint64_t get_stored_fingerprint() const;
 784   void store_fingerprint(uint64_t fingerprint);
 785 
 786   bool is_scratch_class() const {
 787     return (_misc_flags & _misc_is_scratch_class) != 0;
 788   }
 789 
 790   void set_is_scratch_class() {
 791     _misc_flags |= _misc_is_scratch_class;
 792   }
 793 
 794   bool has_resolved_methods() const {
 795     return (_misc_flags & _misc_has_resolved_methods) != 0;
 796   }
 797 
 798   void set_has_resolved_methods() {
 799     _misc_flags |= _misc_has_resolved_methods;
 800   }
 801 private:
 802 
 803   void set_kind(unsigned kind) {
 804     assert(kind <= _misc_kind_field_mask, "Invalid InstanceKlass kind");
 805     unsigned fmask = _misc_kind_field_mask << _misc_kind_field_pos;
 806     unsigned flags = _misc_flags & ~fmask;
 807     _misc_flags = (flags | (kind << _misc_kind_field_pos));
 808   }
 809 
 810   bool is_kind(unsigned desired) const {
 811     unsigned kind = (_misc_flags >> _misc_kind_field_pos) & _misc_kind_field_mask;
 812     return kind == desired;
 813   }
 814 
 815 public:
 816 
 817   // Other is anything that is not one of the more specialized kinds of InstanceKlass.
 818   bool is_other_instance_klass() const        { return is_kind(_misc_kind_other); }
 819   bool is_reference_instance_klass() const    { return is_kind(_misc_kind_reference); }
 820   bool is_mirror_instance_klass() const       { return is_kind(_misc_kind_mirror); }
 821   bool is_class_loader_instance_klass() const { return is_kind(_misc_kind_class_loader); }
 822 
 823 #if INCLUDE_JVMTI
 824 
 825   void init_previous_versions() {
 826     _previous_versions = NULL;
 827   }
 828 
 829  private:
 830   static bool  _has_previous_versions;
 831  public:
 832   static void purge_previous_versions(InstanceKlass* ik) {
 833     if (ik->has_been_redefined()) {
 834       ik->purge_previous_version_list();
 835     }
 836   }
 837 
 838   static bool has_previous_versions_and_reset();
 839   static bool has_previous_versions() { return _has_previous_versions; }
 840 
 841   // JVMTI: Support for caching a class file before it is modified by an agent that can do retransformation
 842   void set_cached_class_file(JvmtiCachedClassFileData *data) {
 843     _cached_class_file = data;
 844   }
 845   JvmtiCachedClassFileData * get_cached_class_file();
 846   jint get_cached_class_file_len();
 847   unsigned char * get_cached_class_file_bytes();
 848 
 849   // JVMTI: Support for caching of field indices, types, and offsets
 850   void set_jvmti_cached_class_field_map(JvmtiCachedClassFieldMap* descriptor) {
 851     _jvmti_cached_class_field_map = descriptor;
 852   }
 853   JvmtiCachedClassFieldMap* jvmti_cached_class_field_map() const {
 854     return _jvmti_cached_class_field_map;
 855   }
 856 
 857 #if INCLUDE_CDS
 858   void set_archived_class_data(JvmtiCachedClassFileData* data) {
 859     _cached_class_file = data;
 860   }
 861 
 862   JvmtiCachedClassFileData * get_archived_class_data();
 863 #endif // INCLUDE_CDS
 864 #else // INCLUDE_JVMTI
 865 
 866   static void purge_previous_versions(InstanceKlass* ik) { return; };
 867   static bool has_previous_versions_and_reset() { return false; }
 868 
 869   void set_cached_class_file(JvmtiCachedClassFileData *data) {
 870     assert(data == NULL, "unexpected call with JVMTI disabled");
 871   }
 872   JvmtiCachedClassFileData * get_cached_class_file() { return (JvmtiCachedClassFileData *)NULL; }
 873 
 874 #endif // INCLUDE_JVMTI
 875 
 876   bool has_nonstatic_concrete_methods() const {
 877     return (_misc_flags & _misc_has_nonstatic_concrete_methods) != 0;
 878   }
 879   void set_has_nonstatic_concrete_methods(bool b) {
 880     if (b) {
 881       _misc_flags |= _misc_has_nonstatic_concrete_methods;
 882     } else {
 883       _misc_flags &= ~_misc_has_nonstatic_concrete_methods;
 884     }
 885   }
 886 
 887   bool declares_nonstatic_concrete_methods() const {
 888     return (_misc_flags & _misc_declares_nonstatic_concrete_methods) != 0;
 889   }
 890   void set_declares_nonstatic_concrete_methods(bool b) {
 891     if (b) {
 892       _misc_flags |= _misc_declares_nonstatic_concrete_methods;
 893     } else {
 894       _misc_flags &= ~_misc_declares_nonstatic_concrete_methods;
 895     }
 896   }
 897 
 898   // for adding methods, ConstMethod::UNSET_IDNUM means no more ids available
 899   inline u2 next_method_idnum();
 900   void set_initial_method_idnum(u2 value)             { _idnum_allocated_count = value; }
 901 
 902   // generics support
 903   Symbol* generic_signature() const                   {
 904     return (_generic_signature_index == 0) ?
 905       (Symbol*)NULL : _constants->symbol_at(_generic_signature_index);
 906   }
 907   u2 generic_signature_index() const                  {
 908     return _generic_signature_index;
 909   }
 910   void set_generic_signature_index(u2 sig_index)      {
 911     _generic_signature_index = sig_index;
 912   }
 913 
 914   u2 enclosing_method_data(int offset) const;
 915   u2 enclosing_method_class_index() const {
 916     return enclosing_method_data(enclosing_method_class_index_offset);
 917   }
 918   u2 enclosing_method_method_index() {
 919     return enclosing_method_data(enclosing_method_method_index_offset);
 920   }
 921   void set_enclosing_method_indices(u2 class_index,
 922                                     u2 method_index);
 923 
 924   // jmethodID support
 925   jmethodID get_jmethod_id(const methodHandle& method_h);
 926   jmethodID get_jmethod_id_fetch_or_update(size_t idnum,
 927                      jmethodID new_id, jmethodID* new_jmeths,
 928                      jmethodID* to_dealloc_id_p,
 929                      jmethodID** to_dealloc_jmeths_p);
 930   static void get_jmethod_id_length_value(jmethodID* cache, size_t idnum,
 931                 size_t *length_p, jmethodID* id_p);
 932   void ensure_space_for_methodids(int start_offset = 0);
 933   jmethodID jmethod_id_or_null(Method* method);
 934 
 935   // annotations support
 936   Annotations* annotations() const          { return _annotations; }
 937   void set_annotations(Annotations* anno)   { _annotations = anno; }
 938 
 939   AnnotationArray* class_annotations() const {
 940     return (_annotations != NULL) ? _annotations->class_annotations() : NULL;
 941   }
 942   Array<AnnotationArray*>* fields_annotations() const {
 943     return (_annotations != NULL) ? _annotations->fields_annotations() : NULL;
 944   }
 945   AnnotationArray* class_type_annotations() const {
 946     return (_annotations != NULL) ? _annotations->class_type_annotations() : NULL;
 947   }
 948   Array<AnnotationArray*>* fields_type_annotations() const {
 949     return (_annotations != NULL) ? _annotations->fields_type_annotations() : NULL;
 950   }
 951   // allocation
 952   instanceOop allocate_instance(TRAPS);
 953 
 954   // additional member function to return a handle
 955   instanceHandle allocate_instance_handle(TRAPS);
 956 
 957   objArrayOop allocate_objArray(int n, int length, TRAPS);
 958   // Helper function
 959   static instanceOop register_finalizer(instanceOop i, TRAPS);
 960 
 961   // Check whether reflection/jni/jvm code is allowed to instantiate this class;
 962   // if not, throw either an Error or an Exception.
 963   virtual void check_valid_for_instantiation(bool throwError, TRAPS);
 964 
 965   // initialization
 966   void call_class_initializer(TRAPS);
 967   void set_initialization_state_and_notify(ClassState state, TRAPS);
 968 
 969   // OopMapCache support
 970   OopMapCache* oop_map_cache()               { return _oop_map_cache; }
 971   void set_oop_map_cache(OopMapCache *cache) { _oop_map_cache = cache; }
 972   void mask_for(const methodHandle& method, int bci, InterpreterOopMap* entry);
 973 
 974   // JNI identifier support (for static fields - for jni performance)
 975   JNIid* jni_ids()                               { return _jni_ids; }
 976   void set_jni_ids(JNIid* ids)                   { _jni_ids = ids; }
 977   JNIid* jni_id_for(int offset);
 978 
 979   // maintenance of deoptimization dependencies
 980   inline DependencyContext dependencies();
 981   int  mark_dependent_nmethods(KlassDepChange& changes);
 982   void add_dependent_nmethod(nmethod* nm);
 983   void remove_dependent_nmethod(nmethod* nm, bool delete_immediately);
 984 
 985   // On-stack replacement support
 986   nmethod* osr_nmethods_head() const         { return _osr_nmethods_head; };
 987   void set_osr_nmethods_head(nmethod* h)     { _osr_nmethods_head = h; };
 988   void add_osr_nmethod(nmethod* n);
 989   bool remove_osr_nmethod(nmethod* n);
 990   int mark_osr_nmethods(const Method* m);
 991   nmethod* lookup_osr_nmethod(const Method* m, int bci, int level, bool match_level) const;
 992 
 993 #if INCLUDE_JVMTI
 994   // Breakpoint support (see methods on Method* for details)
 995   BreakpointInfo* breakpoints() const       { return _breakpoints; };
 996   void set_breakpoints(BreakpointInfo* bps) { _breakpoints = bps; };
 997 #endif
 998 
 999   // support for stub routines
1000   static ByteSize init_state_offset()  { return in_ByteSize(offset_of(InstanceKlass, _init_state)); }
1001   JFR_ONLY(DEFINE_KLASS_TRACE_ID_OFFSET;)
1002   static ByteSize init_thread_offset() { return in_ByteSize(offset_of(InstanceKlass, _init_thread)); }
1003 
1004   // subclass/subinterface checks
1005   bool implements_interface(Klass* k) const;
1006   bool is_same_or_direct_interface(Klass* k) const;
1007 
1008 #ifdef ASSERT
1009   // check whether this class or one of its superclasses was redefined
1010   bool has_redefined_this_or_super() const;
1011 #endif
1012 
1013   // Access to the implementor of an interface.
1014   Klass* implementor() const;
1015   void set_implementor(Klass* k);
1016   int  nof_implementors() const;
1017   void add_implementor(Klass* k);  // k is a new class that implements this interface
1018   void init_implementor();           // initialize
1019 
1020   // link this class into the implementors list of every interface it implements
1021   void process_interfaces(Thread *thread);
1022 
1023   // virtual operations from Klass
1024   bool is_leaf_class() const               { return _subklass == NULL; }
1025   GrowableArray<Klass*>* compute_secondary_supers(int num_extra_slots,
1026                                                   Array<InstanceKlass*>* transitive_interfaces);
1027   bool compute_is_subtype_of(Klass* k);
1028   bool can_be_primary_super_slow() const;
1029   int oop_size(oop obj)  const             { return size_helper(); }
1030   // slow because it's a virtual call and used for verifying the layout_helper.
1031   // Using the layout_helper bits, we can call is_instance_klass without a virtual call.
1032   DEBUG_ONLY(bool is_instance_klass_slow() const      { return true; })
1033 
1034   // Iterators
1035   void do_local_static_fields(FieldClosure* cl);
1036   void do_nonstatic_fields(FieldClosure* cl); // including inherited fields
1037   void do_local_static_fields(void f(fieldDescriptor*, Handle, TRAPS), Handle, TRAPS);
1038 
1039   void methods_do(void f(Method* method));
1040   void array_klasses_do(void f(Klass* k));
1041   void array_klasses_do(void f(Klass* k, TRAPS), TRAPS);
1042   bool super_types_do(SuperTypeClosure* blk);
1043 
1044   static InstanceKlass* cast(Klass* k) {
1045     return const_cast<InstanceKlass*>(cast(const_cast<const Klass*>(k)));
1046   }
1047 
1048   static const InstanceKlass* cast(const Klass* k) {
1049     assert(k != NULL, "k should not be null");
1050     assert(k->is_instance_klass(), "cast to InstanceKlass");
1051     return static_cast<const InstanceKlass*>(k);
1052   }
1053 
1054   virtual InstanceKlass* java_super() const {
1055     return (super() == NULL) ? NULL : cast(super());
1056   }
1057 
1058   // Sizing (in words)
1059   static int header_size()            { return sizeof(InstanceKlass)/wordSize; }
1060 
1061   static int size(int vtable_length, int itable_length,
1062                   int nonstatic_oop_map_size,
1063                   bool is_interface, bool is_unsafe_anonymous, bool has_stored_fingerprint) {
1064     return align_metadata_size(header_size() +
1065            vtable_length +
1066            itable_length +
1067            nonstatic_oop_map_size +
1068            (is_interface ? (int)sizeof(Klass*)/wordSize : 0) +
1069            (is_unsafe_anonymous ? (int)sizeof(Klass*)/wordSize : 0) +
1070            (has_stored_fingerprint ? (int)sizeof(uint64_t*)/wordSize : 0));
1071   }
1072   int size() const                    { return size(vtable_length(),
1073                                                itable_length(),
1074                                                nonstatic_oop_map_size(),
1075                                                is_interface(),
1076                                                is_unsafe_anonymous(),
1077                                                has_stored_fingerprint());
1078   }
1079 #if INCLUDE_SERVICES
1080   virtual void collect_statistics(KlassSizeStats *sz) const;
1081 #endif
1082 
1083   intptr_t* start_of_itable()   const { return (intptr_t*)start_of_vtable() + vtable_length(); }
1084   intptr_t* end_of_itable()     const { return start_of_itable() + itable_length(); }
1085 
1086   int  itable_offset_in_words() const { return start_of_itable() - (intptr_t*)this; }
1087 
1088   oop static_field_base_raw() { return java_mirror(); }
1089 
1090   OopMapBlock* start_of_nonstatic_oop_maps() const {
1091     return (OopMapBlock*)(start_of_itable() + itable_length());
1092   }
1093 
1094   Klass** end_of_nonstatic_oop_maps() const {
1095     return (Klass**)(start_of_nonstatic_oop_maps() +
1096                      nonstatic_oop_map_count());
1097   }
1098 
1099   Klass** adr_implementor() const {
1100     if (is_interface()) {
1101       return (Klass**)end_of_nonstatic_oop_maps();
1102     } else {
1103       return NULL;
1104     }
1105   };
1106 
1107   InstanceKlass** adr_unsafe_anonymous_host() const {
1108     if (is_unsafe_anonymous()) {
1109       InstanceKlass** adr_impl = (InstanceKlass **)adr_implementor();
1110       if (adr_impl != NULL) {
1111         return adr_impl + 1;
1112       } else {
1113         return (InstanceKlass **)end_of_nonstatic_oop_maps();
1114       }
1115     } else {
1116       return NULL;
1117     }
1118   }
1119 
1120   address adr_fingerprint() const {
1121     if (has_stored_fingerprint()) {
1122       InstanceKlass** adr_host = adr_unsafe_anonymous_host();
1123       if (adr_host != NULL) {
1124         return (address)(adr_host + 1);
1125       }
1126 
1127       Klass** adr_impl = adr_implementor();
1128       if (adr_impl != NULL) {
1129         return (address)(adr_impl + 1);
1130       }
1131 
1132       return (address)end_of_nonstatic_oop_maps();
1133     } else {
1134       return NULL;
1135     }
1136   }
1137 
1138   // Use this to return the size of an instance in heap words:
1139   int size_helper() const {
1140     return layout_helper_to_size_helper(layout_helper());
1141   }
1142 
1143   // This bit is initialized in classFileParser.cpp.
1144   // It is false under any of the following conditions:
1145   //  - the class is abstract (including any interface)
1146   //  - the class has a finalizer (if !RegisterFinalizersAtInit)
1147   //  - the class size is larger than FastAllocateSizeLimit
1148   //  - the class is java/lang/Class, which cannot be allocated directly
1149   bool can_be_fastpath_allocated() const {
1150     return !layout_helper_needs_slow_path(layout_helper());
1151   }
1152 
1153   // Java itable
1154   klassItable itable() const;        // return klassItable wrapper
1155   Method* method_at_itable(Klass* holder, int index, TRAPS);
1156 
1157 #if INCLUDE_JVMTI
1158   void adjust_default_methods(InstanceKlass* holder, bool* trace_name_printed);
1159 #endif // INCLUDE_JVMTI
1160 
1161   void clean_weak_instanceklass_links();
1162  private:
1163   void clean_implementors_list();
1164   void clean_method_data();
1165 
1166  public:
1167   // Explicit metaspace deallocation of fields
1168   // For RedefineClasses and class file parsing errors, we need to deallocate
1169   // instanceKlasses and the metadata they point to.
1170   void deallocate_contents(ClassLoaderData* loader_data);
1171   static void deallocate_methods(ClassLoaderData* loader_data,
1172                                  Array<Method*>* methods);
1173   void static deallocate_interfaces(ClassLoaderData* loader_data,
1174                                     const Klass* super_klass,
1175                                     Array<InstanceKlass*>* local_interfaces,
1176                                     Array<InstanceKlass*>* transitive_interfaces);
1177 
1178   // The constant pool is on stack if any of the methods are executing or
1179   // referenced by handles.
1180   bool on_stack() const { return _constants->on_stack(); }
1181 
1182   // callbacks for actions during class unloading
1183   static void unload_class(InstanceKlass* ik);
1184   static void release_C_heap_structures(InstanceKlass* ik);
1185 
1186   // Naming
1187   const char* signature_name() const;
1188   static Symbol* package_from_name(const Symbol* name, TRAPS);
1189 
1190   // GC specific object visitors
1191   //
1192 #if INCLUDE_PARALLELGC
1193   // Parallel Scavenge
1194   void oop_ps_push_contents(  oop obj, PSPromotionManager* pm);
1195   // Parallel Compact
1196   void oop_pc_follow_contents(oop obj, ParCompactionManager* cm);
1197   void oop_pc_update_pointers(oop obj, ParCompactionManager* cm);
1198 #endif
1199 
1200   // Oop fields (and metadata) iterators
1201   //
1202   // The InstanceKlass iterators also visits the Object's klass.
1203 
1204   // Forward iteration
1205  public:
1206   // Iterate over all oop fields in the oop maps.
1207   template <typename T, class OopClosureType>
1208   inline void oop_oop_iterate_oop_maps(oop obj, OopClosureType* closure);
1209 
1210   // Iterate over all oop fields and metadata.
1211   template <typename T, class OopClosureType>
1212   inline int oop_oop_iterate(oop obj, OopClosureType* closure);
1213 
1214   // Iterate over all oop fields in one oop map.
1215   template <typename T, class OopClosureType>
1216   inline void oop_oop_iterate_oop_map(OopMapBlock* map, oop obj, OopClosureType* closure);
1217 
1218 
1219   // Reverse iteration
1220   // Iterate over all oop fields and metadata.
1221   template <typename T, class OopClosureType>
1222   inline int oop_oop_iterate_reverse(oop obj, OopClosureType* closure);
1223 
1224  private:
1225   // Iterate over all oop fields in the oop maps.
1226   template <typename T, class OopClosureType>
1227   inline void oop_oop_iterate_oop_maps_reverse(oop obj, OopClosureType* closure);
1228 
1229   // Iterate over all oop fields in one oop map.
1230   template <typename T, class OopClosureType>
1231   inline void oop_oop_iterate_oop_map_reverse(OopMapBlock* map, oop obj, OopClosureType* closure);
1232 
1233 
1234   // Bounded range iteration
1235  public:
1236   // Iterate over all oop fields in the oop maps.
1237   template <typename T, class OopClosureType>
1238   inline void oop_oop_iterate_oop_maps_bounded(oop obj, OopClosureType* closure, MemRegion mr);
1239 
1240   // Iterate over all oop fields and metadata.
1241   template <typename T, class OopClosureType>
1242   inline int oop_oop_iterate_bounded(oop obj, OopClosureType* closure, MemRegion mr);
1243 
1244  private:
1245   // Iterate over all oop fields in one oop map.
1246   template <typename T, class OopClosureType>
1247   inline void oop_oop_iterate_oop_map_bounded(OopMapBlock* map, oop obj, OopClosureType* closure, MemRegion mr);
1248 
1249 
1250  public:
1251   u2 idnum_allocated_count() const      { return _idnum_allocated_count; }
1252 
1253 public:
1254   void set_in_error_state() {
1255     assert(DumpSharedSpaces, "only call this when dumping archive");
1256     _init_state = initialization_error;
1257   }
1258   bool check_sharing_error_state();
1259 
1260 private:
1261   // initialization state
1262 #ifdef ASSERT
1263   void set_init_state(ClassState state);
1264 #else
1265   void set_init_state(ClassState state) { _init_state = (u1)state; }
1266 #endif
1267   void set_rewritten()                  { _misc_flags |= _misc_rewritten; }
1268   void set_init_thread(Thread *thread)  { _init_thread = thread; }
1269 
1270   // The RedefineClasses() API can cause new method idnums to be needed
1271   // which will cause the caches to grow. Safety requires different
1272   // cache management logic if the caches can grow instead of just
1273   // going from NULL to non-NULL.
1274   bool idnum_can_increment() const      { return has_been_redefined(); }
1275   inline jmethodID* methods_jmethod_ids_acquire() const;
1276   inline void release_set_methods_jmethod_ids(jmethodID* jmeths);
1277 
1278   // Lock during initialization
1279 public:
1280   // Lock for (1) initialization; (2) access to the ConstantPool of this class.
1281   // Must be one per class and it has to be a VM internal object so java code
1282   // cannot lock it (like the mirror).
1283   // It has to be an object not a Mutex because it's held through java calls.
1284   oop init_lock() const;
1285 private:
1286   void fence_and_clear_init_lock();
1287 
1288   bool link_class_impl                           (TRAPS);
1289   bool verify_code                               (TRAPS);
1290   void initialize_impl                           (TRAPS);
1291   void initialize_super_interfaces               (TRAPS);
1292   void eager_initialize_impl                     ();
1293   /* jni_id_for_impl for jfieldID only */
1294   JNIid* jni_id_for_impl                         (int offset);
1295 
1296   // Returns the array class for the n'th dimension
1297   Klass* array_klass_impl(bool or_null, int n, TRAPS);
1298 
1299   // Returns the array class with this class as element type
1300   Klass* array_klass_impl(bool or_null, TRAPS);
1301 
1302   // find a local method (returns NULL if not found)
1303   Method* find_method_impl(const Symbol* name,
1304                            const Symbol* signature,
1305                            OverpassLookupMode overpass_mode,
1306                            StaticLookupMode static_mode,
1307                            PrivateLookupMode private_mode) const;
1308 
1309   static Method* find_method_impl(const Array<Method*>* methods,
1310                                   const Symbol* name,
1311                                   const Symbol* signature,
1312                                   OverpassLookupMode overpass_mode,
1313                                   StaticLookupMode static_mode,
1314                                   PrivateLookupMode private_mode);
1315 
1316   // Free CHeap allocated fields.
1317   void release_C_heap_structures();
1318 
1319 #if INCLUDE_JVMTI
1320   // RedefineClasses support
1321   void link_previous_versions(InstanceKlass* pv) { _previous_versions = pv; }
1322   void mark_newly_obsolete_methods(Array<Method*>* old_methods, int emcp_method_count);
1323 #endif
1324 public:
1325   // CDS support - remove and restore oops from metadata. Oops are not shared.
1326   virtual void remove_unshareable_info();
1327   virtual void remove_java_mirror();
1328   virtual void restore_unshareable_info(ClassLoaderData* loader_data, Handle protection_domain, TRAPS);
1329 
1330   // jvm support
1331   jint compute_modifier_flags(TRAPS) const;
1332 
1333 public:
1334   // JVMTI support
1335   jint jvmti_class_status() const;
1336 
1337   virtual void metaspace_pointers_do(MetaspaceClosure* iter);
1338 
1339  public:
1340   // Printing
1341 #ifndef PRODUCT
1342   void print_on(outputStream* st) const;
1343 #endif
1344   void print_value_on(outputStream* st) const;
1345 
1346   void oop_print_value_on(oop obj, outputStream* st);
1347 
1348 #ifndef PRODUCT
1349   void oop_print_on      (oop obj, outputStream* st);
1350 
1351   void print_dependent_nmethods(bool verbose = false);
1352   bool is_dependent_nmethod(nmethod* nm);
1353   bool verify_itable_index(int index);
1354 #endif
1355 
1356   const char* internal_name() const;
1357 
1358   // Verification
1359   void verify_on(outputStream* st);
1360 
1361   void oop_verify_on(oop obj, outputStream* st);
1362 
1363   // Logging
1364   void print_class_load_logging(ClassLoaderData* loader_data,
1365                                 const char* module_name,
1366                                 const ClassFileStream* cfs) const;
1367 };
1368 
1369 // for adding methods
1370 // UNSET_IDNUM return means no more ids available
1371 inline u2 InstanceKlass::next_method_idnum() {
1372   if (_idnum_allocated_count == ConstMethod::MAX_IDNUM) {
1373     return ConstMethod::UNSET_IDNUM; // no more ids available
1374   } else {
1375     return _idnum_allocated_count++;
1376   }
1377 }
1378 
1379 
1380 /* JNIid class for jfieldIDs only */
1381 class JNIid: public CHeapObj<mtClass> {
1382   friend class VMStructs;
1383  private:
1384   Klass*             _holder;
1385   JNIid*             _next;
1386   int                _offset;
1387 #ifdef ASSERT
1388   bool               _is_static_field_id;
1389 #endif
1390 
1391  public:
1392   // Accessors
1393   Klass* holder() const           { return _holder; }
1394   int offset() const              { return _offset; }
1395   JNIid* next()                   { return _next; }
1396   // Constructor
1397   JNIid(Klass* holder, int offset, JNIid* next);
1398   // Identifier lookup
1399   JNIid* find(int offset);
1400 
1401   bool find_local_field(fieldDescriptor* fd) {
1402     return InstanceKlass::cast(holder())->find_local_field_from_offset(offset(), true, fd);
1403   }
1404 
1405   static void deallocate(JNIid* id);
1406   // Debugging
1407 #ifdef ASSERT
1408   bool is_static_field_id() const { return _is_static_field_id; }
1409   void set_is_static_field_id()   { _is_static_field_id = true; }
1410 #endif
1411   void verify(Klass* holder);
1412 };
1413 
1414 // An iterator that's used to access the inner classes indices in the
1415 // InstanceKlass::_inner_classes array.
1416 class InnerClassesIterator : public StackObj {
1417  private:
1418   Array<jushort>* _inner_classes;
1419   int _length;
1420   int _idx;
1421  public:
1422 
1423   InnerClassesIterator(const InstanceKlass* k) {
1424     _inner_classes = k->inner_classes();
1425     if (k->inner_classes() != NULL) {
1426       _length = _inner_classes->length();
1427       // The inner class array's length should be the multiple of
1428       // inner_class_next_offset if it only contains the InnerClasses
1429       // attribute data, or it should be
1430       // n*inner_class_next_offset+enclosing_method_attribute_size
1431       // if it also contains the EnclosingMethod data.
1432       assert((_length % InstanceKlass::inner_class_next_offset == 0 ||
1433               _length % InstanceKlass::inner_class_next_offset == InstanceKlass::enclosing_method_attribute_size),
1434              "just checking");
1435       // Remove the enclosing_method portion if exists.
1436       if (_length % InstanceKlass::inner_class_next_offset == InstanceKlass::enclosing_method_attribute_size) {
1437         _length -= InstanceKlass::enclosing_method_attribute_size;
1438       }
1439     } else {
1440       _length = 0;
1441     }
1442     _idx = 0;
1443   }
1444 
1445   int length() const {
1446     return _length;
1447   }
1448 
1449   void next() {
1450     _idx += InstanceKlass::inner_class_next_offset;
1451   }
1452 
1453   bool done() const {
1454     return (_idx >= _length);
1455   }
1456 
1457   u2 inner_class_info_index() const {
1458     return _inner_classes->at(
1459                _idx + InstanceKlass::inner_class_inner_class_info_offset);
1460   }
1461 
1462   void set_inner_class_info_index(u2 index) {
1463     _inner_classes->at_put(
1464                _idx + InstanceKlass::inner_class_inner_class_info_offset, index);
1465   }
1466 
1467   u2 outer_class_info_index() const {
1468     return _inner_classes->at(
1469                _idx + InstanceKlass::inner_class_outer_class_info_offset);
1470   }
1471 
1472   void set_outer_class_info_index(u2 index) {
1473     _inner_classes->at_put(
1474                _idx + InstanceKlass::inner_class_outer_class_info_offset, index);
1475   }
1476 
1477   u2 inner_name_index() const {
1478     return _inner_classes->at(
1479                _idx + InstanceKlass::inner_class_inner_name_offset);
1480   }
1481 
1482   void set_inner_name_index(u2 index) {
1483     _inner_classes->at_put(
1484                _idx + InstanceKlass::inner_class_inner_name_offset, index);
1485   }
1486 
1487   u2 inner_access_flags() const {
1488     return _inner_classes->at(
1489                _idx + InstanceKlass::inner_class_access_flags_offset);
1490   }
1491 };
1492 
1493 #endif // SHARE_VM_OOPS_INSTANCEKLASS_HPP