< prev index next >

src/hotspot/share/oops/instanceKlass.hpp

Print this page

   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_OOPS_INSTANCEKLASS_HPP
  26 #define SHARE_OOPS_INSTANCEKLASS_HPP
  27 

  28 #include "memory/allocation.hpp"
  29 #include "memory/referenceType.hpp"
  30 #include "oops/annotations.hpp"
  31 #include "oops/constMethod.hpp"
  32 #include "oops/fieldInfo.hpp"
  33 #include "oops/instanceKlassFlags.hpp"
  34 #include "oops/instanceOop.hpp"

  35 #include "runtime/handles.hpp"
  36 #include "runtime/javaThread.hpp"
  37 #include "utilities/accessFlags.hpp"
  38 #include "utilities/align.hpp"
  39 #include "utilities/growableArray.hpp"
  40 #include "utilities/macros.hpp"
  41 #if INCLUDE_JFR
  42 #include "jfr/support/jfrKlassExtension.hpp"
  43 #endif
  44 
  45 class ConstantPool;
  46 class DeoptimizationScope;
  47 class klassItable;
  48 class RecordComponent;
  49 
  50 // An InstanceKlass is the VM level representation of a Java class.
  51 // It contains all information needed for at class at execution runtime.
  52 
  53 //  InstanceKlass embedded field layout (after declared fields):
  54 //    [EMBEDDED Java vtable             ] size in words = vtable_len
  55 //    [EMBEDDED nonstatic oop-map blocks] size in words = nonstatic_oop_map_size
  56 //      The embedded nonstatic oop-map blocks are short pairs (offset, length)
  57 //      indicating where oops are located in instances of this klass.
  58 //    [EMBEDDED implementor of the interface] only exist for interface

  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 ClassFileStream;
  67 class KlassDepChange;
  68 class DependencyContext;
  69 class fieldDescriptor;
  70 class JNIid;
  71 class JvmtiCachedClassFieldMap;
  72 class nmethodBucket;
  73 class OopMapCache;

  74 class InterpreterOopMap;
  75 class PackageEntry;
  76 class ModuleEntry;
  77 
  78 // This is used in iterators below.
  79 class FieldClosure: public StackObj {
  80 public:
  81   virtual void do_field(fieldDescriptor* fd) = 0;
  82 };
  83 
  84 // Print fields.
  85 // If "obj" argument to constructor is null, prints static fields, otherwise prints non-static fields.
  86 class FieldPrinter: public FieldClosure {
  87    oop _obj;
  88    outputStream* _st;


  89  public:
  90    FieldPrinter(outputStream* st, oop obj = nullptr) : _obj(obj), _st(st) {}

  91    void do_field(fieldDescriptor* fd);
  92 };
  93 
  94 // Describes where oops are located in instances of this klass.
  95 class OopMapBlock {
  96  public:
  97   // Byte offset of the first oop mapped by this block.
  98   int offset() const          { return _offset; }
  99   void set_offset(int offset) { _offset = offset; }
 100 
 101   // Number of oops in this block.
 102   uint count() const         { return _count; }
 103   void set_count(uint count) { _count = count; }
 104 
 105   void increment_count(int diff) { _count += diff; }
 106 
 107   int offset_span() const { return _count * heapOopSize; }
 108 
 109   int end_offset() const {
 110     return offset() + offset_span();

 114     return another_offset == end_offset();
 115   }
 116 
 117   // sizeof(OopMapBlock) in words.
 118   static int size_in_words() {
 119     return align_up((int)sizeof(OopMapBlock), wordSize) >>
 120       LogBytesPerWord;
 121   }
 122 
 123   static int compare_offset(const OopMapBlock* a, const OopMapBlock* b) {
 124     return a->offset() - b->offset();
 125   }
 126 
 127  private:
 128   int  _offset;
 129   uint _count;
 130 };
 131 
 132 struct JvmtiCachedClassFileData;
 133 






















































 134 class InstanceKlass: public Klass {
 135   friend class VMStructs;
 136   friend class JVMCIVMStructs;
 137   friend class ClassFileParser;
 138   friend class CompileReplay;

 139 
 140  public:
 141   static const KlassKind Kind = InstanceKlassKind;
 142 
 143  protected:
 144   InstanceKlass(const ClassFileParser& parser, KlassKind kind = Kind, ReferenceType reference_type = REF_NONE);
 145 
 146  public:
 147   InstanceKlass();
 148 
 149   // See "The Java Virtual Machine Specification" section 2.16.2-5 for a detailed description
 150   // of the class loading & initialization procedure, and the use of the states.
 151   enum ClassState : u1 {
 152     allocated,                          // allocated (but not yet linked)
 153     loaded,                             // loaded and inserted in class hierarchy (but not linked yet)
 154     linked,                             // successfully linked/verified (but not initialized yet)
 155     being_initialized,                  // currently running class initializer
 156     fully_initialized,                  // initialized (successful final state)
 157     initialization_error                // error happened during initialization
 158   };
 159 
 160  private:
 161   static InstanceKlass* allocate_instance_klass(const ClassFileParser& parser, TRAPS);
 162 
 163  protected:
 164   // If you add a new field that points to any metaspace object, you

 260 
 261   // Method array.
 262   Array<Method*>* _methods;
 263   // Default Method Array, concrete methods inherited from interfaces
 264   Array<Method*>* _default_methods;
 265   // Interfaces (InstanceKlass*s) this class declares locally to implement.
 266   Array<InstanceKlass*>* _local_interfaces;
 267   // Interfaces (InstanceKlass*s) this class implements transitively.
 268   Array<InstanceKlass*>* _transitive_interfaces;
 269   // Int array containing the original order of method in the class file (for JVMTI).
 270   Array<int>*     _method_ordering;
 271   // Int array containing the vtable_indices for default_methods
 272   // offset matches _default_methods offset
 273   Array<int>*     _default_vtable_indices;
 274 
 275   // Fields information is stored in an UNSIGNED5 encoded stream (see fieldInfo.hpp)
 276   Array<u1>*          _fieldinfo_stream;
 277   Array<u1>*          _fieldinfo_search_table;
 278   Array<FieldStatus>* _fields_status;
 279 




 280   // embedded Java vtable follows here
 281   // embedded Java itables follows here
 282   // embedded static fields follows here
 283   // embedded nonstatic oop-map blocks follows here
 284   // embedded implementor of this interface follows here
 285   //   The embedded implementor only exists if the current klass is an
 286   //   interface. The possible values of the implementor fall into following
 287   //   three cases:
 288   //     null: no implementor.
 289   //     A Klass* that's not itself: one implementor.
 290   //     Itself: more than one implementors.
 291   //
 292 
 293   friend class SystemDictionary;
 294 
 295   static bool _disable_method_binary_search;
 296 
 297   // Controls finalizer registration
 298   static bool _finalization_enabled;
 299 

 308   // Quick checks for the loader that defined this class (without switching on this->class_loader())
 309   bool defined_by_boot_loader() const      { return _misc_flags.defined_by_boot_loader(); }
 310   bool defined_by_platform_loader() const  { return _misc_flags.defined_by_platform_loader(); }
 311   bool defined_by_app_loader() const       { return _misc_flags.defined_by_app_loader(); }
 312   bool defined_by_other_loaders() const    { return _misc_flags.defined_by_other_loaders(); }
 313   void set_class_loader_type()             { _misc_flags.set_class_loader_type(_class_loader_data); }
 314 
 315   // Check if the class can be shared in CDS
 316   bool is_shareable() const;
 317 
 318   bool shared_loading_failed() const { return _misc_flags.shared_loading_failed(); }
 319 
 320   void set_shared_loading_failed() { _misc_flags.set_shared_loading_failed(true); }
 321 
 322   bool has_nonstatic_fields() const        { return _misc_flags.has_nonstatic_fields(); }
 323   void set_has_nonstatic_fields(bool b)    { _misc_flags.set_has_nonstatic_fields(b); }
 324 
 325   bool has_localvariable_table() const     { return _misc_flags.has_localvariable_table(); }
 326   void set_has_localvariable_table(bool b) { _misc_flags.set_has_localvariable_table(b); }
 327 















 328   // field sizes
 329   int nonstatic_field_size() const         { return _nonstatic_field_size; }
 330   void set_nonstatic_field_size(int size)  { _nonstatic_field_size = size; }
 331 
 332   int static_field_size() const            { return _static_field_size; }
 333   void set_static_field_size(int size)     { _static_field_size = size; }
 334 
 335   int static_oop_field_count() const       { return (int)_static_oop_field_count; }
 336   void set_static_oop_field_count(u2 size) { _static_oop_field_count = size; }
 337 
 338   // Java itable
 339   int  itable_length() const               { return _itable_len; }
 340   void set_itable_length(int len)          { _itable_len = len; }
 341 
 342   // array klasses
 343   ObjArrayKlass* array_klasses() const     { return _array_klasses; }
 344   inline ObjArrayKlass* array_klasses_acquire() const; // load with acquire semantics
 345   inline void release_set_array_klasses(ObjArrayKlass* k); // store with release semantics
 346   void set_array_klasses(ObjArrayKlass* k) { _array_klasses = k; }
 347 

 372     guarantee(_local_interfaces == nullptr || a == nullptr, "Just checking");
 373     _local_interfaces = a; }
 374 
 375   Array<InstanceKlass*>* transitive_interfaces() const     { return _transitive_interfaces; }
 376   void set_transitive_interfaces(Array<InstanceKlass*>* a) {
 377     guarantee(_transitive_interfaces == nullptr || a == nullptr, "Just checking");
 378     _transitive_interfaces = a;
 379   }
 380 
 381  private:
 382   friend class fieldDescriptor;
 383   FieldInfo field(int index) const;
 384 
 385  public:
 386   int     field_offset      (int index) const { return field(index).offset(); }
 387   int     field_access_flags(int index) const { return field(index).access_flags().as_field_flags(); }
 388   FieldInfo::FieldFlags field_flags(int index) const { return field(index).field_flags(); }
 389   FieldStatus field_status(int index)   const { return fields_status()->at(index); }
 390   inline Symbol* field_name        (int index) const;
 391   inline Symbol* field_signature   (int index) const;






 392 
 393   // Number of Java declared fields
 394   int java_fields_count() const;
 395   int total_fields_count() const;
 396 
 397   Array<u1>* fieldinfo_stream() const { return _fieldinfo_stream; }
 398   void set_fieldinfo_stream(Array<u1>* fis) { _fieldinfo_stream = fis; }
 399 
 400   Array<u1>* fieldinfo_search_table() const { return _fieldinfo_search_table; }
 401   void set_fieldinfo_search_table(Array<u1>* table) { _fieldinfo_search_table = table; }
 402 
 403   Array<FieldStatus>* fields_status() const {return _fields_status; }
 404   void set_fields_status(Array<FieldStatus>* array) { _fields_status = array; }
 405 



 406   // inner classes
 407   Array<u2>* inner_classes() const       { return _inner_classes; }
 408   void set_inner_classes(Array<u2>* f)   { _inner_classes = f; }
 409 
 410   // nest members
 411   Array<u2>* nest_members() const     { return _nest_members; }
 412   void set_nest_members(Array<u2>* m) { _nest_members = m; }
 413 
 414   // nest-host index
 415   jushort nest_host_index() const { return _nest_host_index; }
 416   void set_nest_host_index(u2 i)  { _nest_host_index = i; }
 417   // dynamic nest member support
 418   void set_nest_host(InstanceKlass* host);
 419 
 420   // record components
 421   Array<RecordComponent*>* record_components() const { return _record_components; }
 422   void set_record_components(Array<RecordComponent*>* record_components) {
 423     _record_components = record_components;
 424   }
 425   bool is_record() const;

 481   bool in_javabase_module() const;
 482   bool in_unnamed_package() const   { return (_package_entry == nullptr); }
 483   void set_package(ClassLoaderData* loader_data, PackageEntry* pkg_entry, TRAPS);
 484   // If the package for the InstanceKlass is in the boot loader's package entry
 485   // table then sets the classpath_index field so that
 486   // get_system_package() will know to return a non-null value for the
 487   // package's location.  And, so that the package will be added to the list of
 488   // packages returned by get_system_packages().
 489   // For packages whose classes are loaded from the boot loader class path, the
 490   // classpath_index indicates which entry on the boot loader class path.
 491   void set_classpath_index(s2 path_index);
 492   bool is_same_class_package(const Klass* class2) const;
 493   bool is_same_class_package(oop other_class_loader, const Symbol* other_class_name) const;
 494 
 495   // find an enclosing class
 496   InstanceKlass* compute_enclosing_class(bool* inner_is_member, TRAPS) const;
 497 
 498   // Find InnerClasses attribute and return outer_class_info_index & inner_name_index.
 499   bool find_inner_classes_attr(int* ooff, int* noff, TRAPS) const;
 500 



 501  private:
 502   // Check prohibited package ("java/" only loadable by boot or platform loaders)
 503   static void check_prohibited_package(Symbol* class_name,
 504                                        ClassLoaderData* loader_data,
 505                                        TRAPS);
 506 
 507   JavaThread* init_thread()  { return AtomicAccess::load(&_init_thread); }
 508   const char* init_thread_name() {
 509     return init_thread()->name_raw();
 510   }
 511 
 512  public:
 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() const           { return AtomicAccess::load_acquire(&_init_state); }
 522   const char* init_state_name() const;
 523   bool is_rewritten() const                { return _misc_flags.rewritten(); }
 524 
 525   // is this a sealed class
 526   bool is_sealed() const;
 527 
 528   // defineClass specified verification
 529   bool should_verify_class() const         { return _misc_flags.should_verify_class(); }
 530   void set_should_verify_class(bool value) { _misc_flags.set_should_verify_class(value); }
 531 
 532   // marking
 533   bool is_marked_dependent() const         { return _misc_flags.is_marked_dependent(); }
 534   void set_is_marked_dependent(bool value) { _misc_flags.set_is_marked_dependent(value); }
 535 



 536   // initialization (virtuals from Klass)
 537   bool should_be_initialized() const;  // means that initialize should be called
 538   void initialize_with_aot_initialized_mirror(TRAPS);
 539   void assert_no_clinit_will_run_for_aot_initialized_class() const NOT_DEBUG_RETURN;
 540   void initialize(TRAPS);
 541   void link_class(TRAPS);
 542   bool link_class_or_fail(TRAPS); // returns false on failure
 543   void rewrite_class(TRAPS);
 544   void link_methods(TRAPS);
 545   Method* class_initializer() const;
 546   bool interface_needs_clinit_execution_as_super(bool also_check_supers=true) const;
 547 
 548   // reference type
 549   ReferenceType reference_type() const     { return (ReferenceType)_reference_type; }
 550 
 551   // this class cp index
 552   u2 this_class_index() const             { return _this_class_index; }
 553   void set_this_class_index(u2 index)     { _this_class_index = index; }
 554 
 555   static ByteSize reference_type_offset() { return byte_offset_of(InstanceKlass, _reference_type); }

 643   // protection domain
 644   oop protection_domain() const;
 645 
 646   // signers
 647   objArrayOop signers() const;
 648 
 649   bool is_contended() const                { return _misc_flags.is_contended(); }
 650   void set_is_contended(bool value)        { _misc_flags.set_is_contended(value); }
 651 
 652   // source file name
 653   Symbol* source_file_name() const;
 654   u2 source_file_name_index() const;
 655   void set_source_file_name_index(u2 sourcefile_index);
 656 
 657   // minor and major version numbers of class file
 658   u2 minor_version() const;
 659   void set_minor_version(u2 minor_version);
 660   u2 major_version() const;
 661   void set_major_version(u2 major_version);
 662 


 663   // source debug extension
 664   const char* source_debug_extension() const { return _source_debug_extension; }
 665   void set_source_debug_extension(const char* array, int length);
 666 
 667   // nonstatic oop-map blocks
 668   static int nonstatic_oop_map_size(unsigned int oop_map_count) {
 669     return oop_map_count * OopMapBlock::size_in_words();
 670   }
 671   unsigned int nonstatic_oop_map_count() const {
 672     return _nonstatic_oop_map_size / OopMapBlock::size_in_words();
 673   }
 674   int nonstatic_oop_map_size() const { return _nonstatic_oop_map_size; }
 675   void set_nonstatic_oop_map_size(int words) {
 676     _nonstatic_oop_map_size = words;
 677   }
 678 
 679   bool has_contended_annotations() const { return _misc_flags.has_contended_annotations(); }
 680   void set_has_contended_annotations(bool value)  { _misc_flags.set_has_contended_annotations(value); }
 681 
 682 #if INCLUDE_JVMTI

 749   }
 750   JvmtiCachedClassFileData * get_cached_class_file() { return (JvmtiCachedClassFileData *)nullptr; }
 751 
 752 #endif // INCLUDE_JVMTI
 753 
 754   bool has_nonstatic_concrete_methods() const { return _misc_flags.has_nonstatic_concrete_methods(); }
 755   void set_has_nonstatic_concrete_methods(bool b) { _misc_flags.set_has_nonstatic_concrete_methods(b); }
 756 
 757   bool declares_nonstatic_concrete_methods() const { return _misc_flags.declares_nonstatic_concrete_methods(); }
 758   void set_declares_nonstatic_concrete_methods(bool b) { _misc_flags.set_declares_nonstatic_concrete_methods(b); }
 759 
 760   bool has_miranda_methods () const     { return _misc_flags.has_miranda_methods(); }
 761   void set_has_miranda_methods()        { _misc_flags.set_has_miranda_methods(true); }
 762   bool has_final_method() const         { return _misc_flags.has_final_method(); }
 763   void set_has_final_method()           { _misc_flags.set_has_final_method(true); }
 764 
 765   // for adding methods, ConstMethod::UNSET_IDNUM means no more ids available
 766   inline u2 next_method_idnum();
 767   void set_initial_method_idnum(u2 value)             { _idnum_allocated_count = value; }
 768 







 769   // generics support
 770   Symbol* generic_signature() const;
 771   u2 generic_signature_index() const;
 772   void set_generic_signature_index(u2 sig_index);
 773 
 774   u2 enclosing_method_data(int offset) const;
 775   u2 enclosing_method_class_index() const {
 776     return enclosing_method_data(enclosing_method_class_index_offset);
 777   }
 778   u2 enclosing_method_method_index() {
 779     return enclosing_method_data(enclosing_method_method_index_offset);
 780   }
 781   void set_enclosing_method_indices(u2 class_index,
 782                                     u2 method_index);
 783 
 784   // jmethodID support
 785   jmethodID get_jmethod_id(Method* method);
 786   void make_methods_jmethod_ids();
 787   jmethodID jmethod_id_or_null(Method* method);
 788   void update_methods_jmethod_cache();

 842 
 843   // On-stack replacement support
 844   nmethod* osr_nmethods_head() const         { return _osr_nmethods_head; };
 845   void set_osr_nmethods_head(nmethod* h)     { _osr_nmethods_head = h; };
 846   void add_osr_nmethod(nmethod* n);
 847   bool remove_osr_nmethod(nmethod* n);
 848   int mark_osr_nmethods(DeoptimizationScope* deopt_scope, const Method* m);
 849   nmethod* lookup_osr_nmethod(const Method* m, int bci, int level, bool match_level) const;
 850 
 851 #if INCLUDE_JVMTI
 852   // Breakpoint support (see methods on Method* for details)
 853   BreakpointInfo* breakpoints() const       { return _breakpoints; };
 854   void set_breakpoints(BreakpointInfo* bps) { _breakpoints = bps; };
 855 #endif
 856 
 857   // support for stub routines
 858   static ByteSize init_state_offset()  { return byte_offset_of(InstanceKlass, _init_state); }
 859   JFR_ONLY(DEFINE_KLASS_TRACE_ID_OFFSET;)
 860   static ByteSize init_thread_offset() { return byte_offset_of(InstanceKlass, _init_thread); }
 861 



 862   // subclass/subinterface checks
 863   bool implements_interface(Klass* k) const;
 864   bool is_same_or_direct_interface(Klass* k) const;
 865 
 866 #ifdef ASSERT
 867   // check whether this class or one of its superclasses was redefined
 868   bool has_redefined_this_or_super() const;
 869 #endif
 870 
 871   // Access to the implementor of an interface.
 872   InstanceKlass* implementor() const;
 873   void set_implementor(InstanceKlass* ik);
 874   int  nof_implementors() const;
 875   void add_implementor(InstanceKlass* ik);  // ik is a new class that implements this interface
 876   void init_implementor();           // initialize
 877 
 878  private:
 879   // link this class into the implementors list of every interface it implements
 880   void process_interfaces();
 881 

 905     assert(k != nullptr, "k should not be null");
 906     assert(k->is_instance_klass(), "cast to InstanceKlass");
 907     return static_cast<const InstanceKlass*>(k);
 908   }
 909 
 910   // This hides Klass::super(). The _super of an InstanceKlass is
 911   // always an InstanceKlass (or nullptr)
 912   InstanceKlass* super() const {
 913     return (Klass::super() == nullptr) ? nullptr : InstanceKlass::cast(Klass::super());
 914   }
 915 
 916   virtual InstanceKlass* java_super() const {
 917     return InstanceKlass::super();
 918   }
 919 
 920   // Sizing (in words)
 921   static int header_size()            { return sizeof(InstanceKlass)/wordSize; }
 922 
 923   static int size(int vtable_length, int itable_length,
 924                   int nonstatic_oop_map_size,
 925                   bool is_interface) {

 926     return align_metadata_size(header_size() +
 927            vtable_length +
 928            itable_length +
 929            nonstatic_oop_map_size +
 930            (is_interface ? (int)sizeof(Klass*)/wordSize : 0));

 931   }
 932 
 933   int size() const                    { return size(vtable_length(),
 934                                                itable_length(),
 935                                                nonstatic_oop_map_size(),
 936                                                is_interface());

 937   }
 938 
 939 
 940   inline intptr_t* start_of_itable() const;
 941   inline intptr_t* end_of_itable() const;
 942   inline oop static_field_base_raw();

 943 
 944   inline OopMapBlock* start_of_nonstatic_oop_maps() const;
 945   inline Klass** end_of_nonstatic_oop_maps() const;
 946 
 947   inline InstanceKlass* volatile* adr_implementor() const;
 948 


















 949   // Use this to return the size of an instance in heap words:
 950   int size_helper() const {
 951     return layout_helper_to_size_helper(layout_helper());
 952   }
 953 
 954   // This bit is initialized in classFileParser.cpp.
 955   // It is false under any of the following conditions:
 956   //  - the class is abstract (including any interface)
 957   //  - the class size is larger than FastAllocateSizeLimit
 958   //  - the class is java/lang/Class, which cannot be allocated directly
 959   bool can_be_fastpath_allocated() const {
 960     return !layout_helper_needs_slow_path(layout_helper());
 961   }
 962 
 963   // Java itable
 964   klassItable itable() const;        // return klassItable wrapper
 965   Method* method_at_itable(InstanceKlass* holder, int index, TRAPS);
 966   Method* method_at_itable_or_null(InstanceKlass* holder, int index, bool& itable_entry_found);
 967   int vtable_index_of_interface_method(Method* method);
 968 
 969 #if INCLUDE_JVMTI
 970   void adjust_default_methods(bool* trace_name_printed);

 981   // instanceKlasses and the metadata they point to.
 982   void deallocate_contents(ClassLoaderData* loader_data);
 983   static void deallocate_methods(ClassLoaderData* loader_data,
 984                                  Array<Method*>* methods);
 985   void static deallocate_interfaces(ClassLoaderData* loader_data,
 986                                     const InstanceKlass* super_klass,
 987                                     Array<InstanceKlass*>* local_interfaces,
 988                                     Array<InstanceKlass*>* transitive_interfaces);
 989   void static deallocate_record_components(ClassLoaderData* loader_data,
 990                                            Array<RecordComponent*>* record_component);
 991 
 992   virtual bool on_stack() const;
 993 
 994   // callbacks for actions during class unloading
 995   static void unload_class(InstanceKlass* ik);
 996 
 997   virtual void release_C_heap_structures(bool release_sub_metadata = true);
 998 
 999   // Naming
1000   const char* signature_name() const;

1001 
1002   // Oop fields (and metadata) iterators
1003   //
1004   // The InstanceKlass iterators also visits the Object's klass.
1005 
1006   // Forward iteration
1007  public:
1008   // Iterate over all oop fields in the oop maps.
1009   template <typename T, class OopClosureType>
1010   inline void oop_oop_iterate_oop_maps(oop obj, OopClosureType* closure);
1011 
1012   // Iterate over all oop fields and metadata.
1013   template <typename T, class OopClosureType>
1014   inline void oop_oop_iterate(oop obj, OopClosureType* closure);
1015 
1016   // Iterate over all oop fields in one oop map.
1017   template <typename T, class OopClosureType>
1018   inline void oop_oop_iterate_oop_map(OopMapBlock* map, oop obj, OopClosureType* closure);
1019 
1020 

1106                                   const Symbol* name,
1107                                   const Symbol* signature,
1108                                   OverpassLookupMode overpass_mode,
1109                                   StaticLookupMode static_mode,
1110                                   PrivateLookupMode private_mode);
1111 
1112 #if INCLUDE_JVMTI
1113   // RedefineClasses support
1114   void link_previous_versions(InstanceKlass* pv) { _previous_versions = pv; }
1115   void mark_newly_obsolete_methods(Array<Method*>* old_methods, int emcp_method_count);
1116 #endif
1117   // log class name to classlist
1118   void log_to_classlist() const;
1119 public:
1120 
1121 #if INCLUDE_CDS
1122   // CDS support - remove and restore oops from metadata. Oops are not shared.
1123   virtual void remove_unshareable_info();
1124   void remove_unshareable_flags();
1125   virtual void remove_java_mirror();
1126   void restore_unshareable_info(ClassLoaderData* loader_data, Handle protection_domain, PackageEntry* pkg_entry, TRAPS);
1127   void init_shared_package_entry();
1128   bool can_be_verified_at_dumptime() const;
1129   void compute_has_loops_flag_for_methods();
1130 #endif
1131   bool     has_init_deps_processed() const { return _misc_flags.has_init_deps_processed(); }
1132   void set_has_init_deps_processed() {
1133     assert(is_initialized(), "");
1134     assert(!has_init_deps_processed(), "already set"); // one-off action
1135     _misc_flags.set_has_init_deps_processed(true);
1136   }
1137 
1138   u2 compute_modifier_flags() const;
1139 
1140 public:
1141   // JVMTI support
1142   jint jvmti_class_status() const;
1143 
1144   virtual void metaspace_pointers_do(MetaspaceClosure* iter);
1145 
1146  public:
1147   // Printing
1148   void print_on(outputStream* st) const;
1149   void print_value_on(outputStream* st) const;
1150 
1151   void oop_print_value_on(oop obj, outputStream* st);
1152 
1153   void oop_print_on      (oop obj, outputStream* st);

1154 
1155 #ifndef PRODUCT
1156   void print_dependent_nmethods(bool verbose = false);
1157   bool is_dependent_nmethod(nmethod* nm);
1158   bool verify_itable_index(int index);
1159 #endif
1160 
1161   const char* internal_name() const;
1162 
1163   // Verification
1164   void verify_on(outputStream* st);
1165 
1166   void oop_verify_on(oop obj, outputStream* st);
1167 
1168   // Logging
1169   void print_class_load_logging(ClassLoaderData* loader_data,
1170                                 const ModuleEntry* module_entry,
1171                                 const ClassFileStream* cfs) const;
1172  private:
1173   void print_class_load_cause_logging() const;

   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_OOPS_INSTANCEKLASS_HPP
  26 #define SHARE_OOPS_INSTANCEKLASS_HPP
  27 
  28 #include "code/vmreg.hpp"
  29 #include "memory/allocation.hpp"
  30 #include "memory/referenceType.hpp"
  31 #include "oops/annotations.hpp"
  32 #include "oops/constMethod.hpp"
  33 #include "oops/fieldInfo.hpp"
  34 #include "oops/instanceKlassFlags.hpp"
  35 #include "oops/instanceOop.hpp"
  36 #include "oops/refArrayKlass.hpp"
  37 #include "runtime/handles.hpp"
  38 #include "runtime/javaThread.hpp"
  39 #include "utilities/accessFlags.hpp"
  40 #include "utilities/align.hpp"
  41 #include "utilities/growableArray.hpp"
  42 #include "utilities/macros.hpp"
  43 #if INCLUDE_JFR
  44 #include "jfr/support/jfrKlassExtension.hpp"
  45 #endif
  46 
  47 class ConstantPool;
  48 class DeoptimizationScope;
  49 class klassItable;
  50 class RecordComponent;
  51 
  52 // An InstanceKlass is the VM level representation of a Java class.
  53 // It contains all information needed for at class at execution runtime.
  54 
  55 //  InstanceKlass embedded field layout (after declared fields):
  56 //    [EMBEDDED Java vtable             ] size in words = vtable_len
  57 //    [EMBEDDED nonstatic oop-map blocks] size in words = nonstatic_oop_map_size
  58 //      The embedded nonstatic oop-map blocks are short pairs (offset, length)
  59 //      indicating where oops are located in instances of this klass.
  60 //    [EMBEDDED implementor of the interface] only exist for interface
  61 //    [EMBEDDED InlineKlassFixedBlock] only if is an InlineKlass instance
  62 
  63 
  64 // forward declaration for class -- see below for definition
  65 #if INCLUDE_JVMTI
  66 class BreakpointInfo;
  67 #endif
  68 class ClassFileParser;
  69 class ClassFileStream;
  70 class KlassDepChange;
  71 class DependencyContext;
  72 class fieldDescriptor;
  73 class JNIid;
  74 class JvmtiCachedClassFieldMap;
  75 class nmethodBucket;
  76 class OopMapCache;
  77 class BufferedInlineTypeBlob;
  78 class InterpreterOopMap;
  79 class PackageEntry;
  80 class ModuleEntry;
  81 
  82 // This is used in iterators below.
  83 class FieldClosure: public StackObj {
  84 public:
  85   virtual void do_field(fieldDescriptor* fd) = 0;
  86 };
  87 
  88 // Print fields.
  89 // If "obj" argument to constructor is null, prints static fields, otherwise prints non-static fields.
  90 class FieldPrinter: public FieldClosure {
  91    oop _obj;
  92    outputStream* _st;
  93    int _indent;
  94    int _base_offset;
  95  public:
  96    FieldPrinter(outputStream* st, oop obj = nullptr, int indent = 0, int base_offset = 0) :
  97                  _obj(obj), _st(st), _indent(indent), _base_offset(base_offset) {}
  98    void do_field(fieldDescriptor* fd);
  99 };
 100 
 101 // Describes where oops are located in instances of this klass.
 102 class OopMapBlock {
 103  public:
 104   // Byte offset of the first oop mapped by this block.
 105   int offset() const          { return _offset; }
 106   void set_offset(int offset) { _offset = offset; }
 107 
 108   // Number of oops in this block.
 109   uint count() const         { return _count; }
 110   void set_count(uint count) { _count = count; }
 111 
 112   void increment_count(int diff) { _count += diff; }
 113 
 114   int offset_span() const { return _count * heapOopSize; }
 115 
 116   int end_offset() const {
 117     return offset() + offset_span();

 121     return another_offset == end_offset();
 122   }
 123 
 124   // sizeof(OopMapBlock) in words.
 125   static int size_in_words() {
 126     return align_up((int)sizeof(OopMapBlock), wordSize) >>
 127       LogBytesPerWord;
 128   }
 129 
 130   static int compare_offset(const OopMapBlock* a, const OopMapBlock* b) {
 131     return a->offset() - b->offset();
 132   }
 133 
 134  private:
 135   int  _offset;
 136   uint _count;
 137 };
 138 
 139 struct JvmtiCachedClassFileData;
 140 
 141 class SigEntry;
 142 
 143 class InlineKlassFixedBlock {
 144   Array<SigEntry>** _extended_sig;
 145   Array<VMRegPair>** _return_regs;
 146   address* _pack_handler;
 147   address* _pack_handler_jobject;
 148   address* _unpack_handler;
 149   int* _null_reset_value_offset;
 150   int _payload_offset;          // offset of the begining of the payload in a heap buffered instance
 151   int _payload_size_in_bytes;   // size of payload layout
 152   int _payload_alignment;       // alignment required for payload
 153   int _non_atomic_size_in_bytes; // size of null-free non-atomic flat layout
 154   int _non_atomic_alignment;    // alignment requirement for null-free non-atomic layout
 155   int _atomic_size_in_bytes;    // size and alignment requirement for a null-free atomic layout, -1 if no atomic flat layout is possible
 156   int _nullable_size_in_bytes;  // size and alignment requirement for a nullable layout (always atomic), -1 if no nullable flat layout is possible
 157   int _null_marker_offset;      // expressed as an offset from the beginning of the object for a heap buffered value
 158                                 // payload_offset must be subtracted to get the offset from the beginning of the payload
 159 
 160   friend class InlineKlass;
 161 };
 162 
 163 class InlineLayoutInfo : public MetaspaceObj {
 164   InlineKlass* _klass;
 165   LayoutKind _kind;
 166   int _null_marker_offset; // null marker offset for this field, relative to the beginning of the current container
 167 
 168  public:
 169   InlineLayoutInfo(): _klass(nullptr), _kind(LayoutKind::UNKNOWN), _null_marker_offset(-1)  {}
 170   InlineLayoutInfo(InlineKlass* ik, LayoutKind kind, int size, int nm_offset):
 171     _klass(ik), _kind(kind), _null_marker_offset(nm_offset) {}
 172 
 173   InlineKlass* klass() const { return _klass; }
 174   void set_klass(InlineKlass* k) { _klass = k; }
 175 
 176   LayoutKind kind() const {
 177     assert(_kind != LayoutKind::UNKNOWN, "Not set");
 178     return _kind;
 179   }
 180   void set_kind(LayoutKind lk) { _kind = lk; }
 181 
 182   int null_marker_offset() const {
 183     assert(_null_marker_offset != -1, "Not set");
 184     return _null_marker_offset;
 185   }
 186   void set_null_marker_offset(int o) { _null_marker_offset = o; }
 187 
 188   void metaspace_pointers_do(MetaspaceClosure* it);
 189   MetaspaceObj::Type type() const { return InlineLayoutInfoType; }
 190 
 191   static ByteSize klass_offset() { return in_ByteSize(offset_of(InlineLayoutInfo, _klass)); }
 192   static ByteSize null_marker_offset_offset() { return in_ByteSize(offset_of(InlineLayoutInfo, _null_marker_offset)); }
 193 };
 194 
 195 class InstanceKlass: public Klass {
 196   friend class VMStructs;
 197   friend class JVMCIVMStructs;
 198   friend class ClassFileParser;
 199   friend class CompileReplay;
 200   friend class TemplateTable;
 201 
 202  public:
 203   static const KlassKind Kind = InstanceKlassKind;
 204 
 205  protected:
 206   InstanceKlass(const ClassFileParser& parser, KlassKind kind = Kind, markWord prototype = markWord::prototype(), ReferenceType reference_type = REF_NONE);
 207 
 208  public:
 209   InstanceKlass();
 210 
 211   // See "The Java Virtual Machine Specification" section 2.16.2-5 for a detailed description
 212   // of the class loading & initialization procedure, and the use of the states.
 213   enum ClassState : u1 {
 214     allocated,                          // allocated (but not yet linked)
 215     loaded,                             // loaded and inserted in class hierarchy (but not linked yet)
 216     linked,                             // successfully linked/verified (but not initialized yet)
 217     being_initialized,                  // currently running class initializer
 218     fully_initialized,                  // initialized (successful final state)
 219     initialization_error                // error happened during initialization
 220   };
 221 
 222  private:
 223   static InstanceKlass* allocate_instance_klass(const ClassFileParser& parser, TRAPS);
 224 
 225  protected:
 226   // If you add a new field that points to any metaspace object, you

 322 
 323   // Method array.
 324   Array<Method*>* _methods;
 325   // Default Method Array, concrete methods inherited from interfaces
 326   Array<Method*>* _default_methods;
 327   // Interfaces (InstanceKlass*s) this class declares locally to implement.
 328   Array<InstanceKlass*>* _local_interfaces;
 329   // Interfaces (InstanceKlass*s) this class implements transitively.
 330   Array<InstanceKlass*>* _transitive_interfaces;
 331   // Int array containing the original order of method in the class file (for JVMTI).
 332   Array<int>*     _method_ordering;
 333   // Int array containing the vtable_indices for default_methods
 334   // offset matches _default_methods offset
 335   Array<int>*     _default_vtable_indices;
 336 
 337   // Fields information is stored in an UNSIGNED5 encoded stream (see fieldInfo.hpp)
 338   Array<u1>*          _fieldinfo_stream;
 339   Array<u1>*          _fieldinfo_search_table;
 340   Array<FieldStatus>* _fields_status;
 341 
 342   Array<InlineLayoutInfo>* _inline_layout_info_array;
 343   Array<u2>* _loadable_descriptors;
 344   const InlineKlassFixedBlock* _adr_inlineklass_fixed_block;
 345 
 346   // embedded Java vtable follows here
 347   // embedded Java itables follows here
 348   // embedded static fields follows here
 349   // embedded nonstatic oop-map blocks follows here
 350   // embedded implementor of this interface follows here
 351   //   The embedded implementor only exists if the current klass is an
 352   //   interface. The possible values of the implementor fall into following
 353   //   three cases:
 354   //     null: no implementor.
 355   //     A Klass* that's not itself: one implementor.
 356   //     Itself: more than one implementors.
 357   //
 358 
 359   friend class SystemDictionary;
 360 
 361   static bool _disable_method_binary_search;
 362 
 363   // Controls finalizer registration
 364   static bool _finalization_enabled;
 365 

 374   // Quick checks for the loader that defined this class (without switching on this->class_loader())
 375   bool defined_by_boot_loader() const      { return _misc_flags.defined_by_boot_loader(); }
 376   bool defined_by_platform_loader() const  { return _misc_flags.defined_by_platform_loader(); }
 377   bool defined_by_app_loader() const       { return _misc_flags.defined_by_app_loader(); }
 378   bool defined_by_other_loaders() const    { return _misc_flags.defined_by_other_loaders(); }
 379   void set_class_loader_type()             { _misc_flags.set_class_loader_type(_class_loader_data); }
 380 
 381   // Check if the class can be shared in CDS
 382   bool is_shareable() const;
 383 
 384   bool shared_loading_failed() const { return _misc_flags.shared_loading_failed(); }
 385 
 386   void set_shared_loading_failed() { _misc_flags.set_shared_loading_failed(true); }
 387 
 388   bool has_nonstatic_fields() const        { return _misc_flags.has_nonstatic_fields(); }
 389   void set_has_nonstatic_fields(bool b)    { _misc_flags.set_has_nonstatic_fields(b); }
 390 
 391   bool has_localvariable_table() const     { return _misc_flags.has_localvariable_table(); }
 392   void set_has_localvariable_table(bool b) { _misc_flags.set_has_localvariable_table(b); }
 393 
 394   bool has_inline_type_fields() const { return _misc_flags.has_inline_type_fields(); }
 395   void set_has_inline_type_fields()   { _misc_flags.set_has_inline_type_fields(true); }
 396 
 397   bool is_naturally_atomic() const  { return _misc_flags.is_naturally_atomic(); }
 398   void set_is_naturally_atomic()    { _misc_flags.set_is_naturally_atomic(true); }
 399 
 400   // Query if this class has atomicity requirements (default is yes)
 401   // This bit can occur anywhere, but is only significant
 402   // for inline classes *and* their super types.
 403   // It inherits from supers.
 404   // Its value depends on the ForceNonTearable VM option, the LooselyConsistentValue annotation
 405   // and the presence of flat fields with atomicity requirements
 406   bool must_be_atomic() const { return _misc_flags.must_be_atomic(); }
 407   void set_must_be_atomic()   { _misc_flags.set_must_be_atomic(true); }
 408 
 409   // field sizes
 410   int nonstatic_field_size() const         { return _nonstatic_field_size; }
 411   void set_nonstatic_field_size(int size)  { _nonstatic_field_size = size; }
 412 
 413   int static_field_size() const            { return _static_field_size; }
 414   void set_static_field_size(int size)     { _static_field_size = size; }
 415 
 416   int static_oop_field_count() const       { return (int)_static_oop_field_count; }
 417   void set_static_oop_field_count(u2 size) { _static_oop_field_count = size; }
 418 
 419   // Java itable
 420   int  itable_length() const               { return _itable_len; }
 421   void set_itable_length(int len)          { _itable_len = len; }
 422 
 423   // array klasses
 424   ObjArrayKlass* array_klasses() const     { return _array_klasses; }
 425   inline ObjArrayKlass* array_klasses_acquire() const; // load with acquire semantics
 426   inline void release_set_array_klasses(ObjArrayKlass* k); // store with release semantics
 427   void set_array_klasses(ObjArrayKlass* k) { _array_klasses = k; }
 428 

 453     guarantee(_local_interfaces == nullptr || a == nullptr, "Just checking");
 454     _local_interfaces = a; }
 455 
 456   Array<InstanceKlass*>* transitive_interfaces() const     { return _transitive_interfaces; }
 457   void set_transitive_interfaces(Array<InstanceKlass*>* a) {
 458     guarantee(_transitive_interfaces == nullptr || a == nullptr, "Just checking");
 459     _transitive_interfaces = a;
 460   }
 461 
 462  private:
 463   friend class fieldDescriptor;
 464   FieldInfo field(int index) const;
 465 
 466  public:
 467   int     field_offset      (int index) const { return field(index).offset(); }
 468   int     field_access_flags(int index) const { return field(index).access_flags().as_field_flags(); }
 469   FieldInfo::FieldFlags field_flags(int index) const { return field(index).field_flags(); }
 470   FieldStatus field_status(int index)   const { return fields_status()->at(index); }
 471   inline Symbol* field_name        (int index) const;
 472   inline Symbol* field_signature   (int index) const;
 473   bool field_is_flat(int index) const { return field_flags(index).is_flat(); }
 474   bool field_has_null_marker(int index) const { return field_flags(index).has_null_marker(); }
 475   bool field_is_null_free_inline_type(int index) const;
 476   bool is_class_in_loadable_descriptors_attribute(Symbol* name) const;
 477 
 478   int null_marker_offset(int index) const { return inline_layout_info(index).null_marker_offset(); }
 479 
 480   // Number of Java declared fields
 481   int java_fields_count() const;
 482   int total_fields_count() const;
 483 
 484   Array<u1>* fieldinfo_stream() const { return _fieldinfo_stream; }
 485   void set_fieldinfo_stream(Array<u1>* fis) { _fieldinfo_stream = fis; }
 486 
 487   Array<u1>* fieldinfo_search_table() const { return _fieldinfo_search_table; }
 488   void set_fieldinfo_search_table(Array<u1>* table) { _fieldinfo_search_table = table; }
 489 
 490   Array<FieldStatus>* fields_status() const {return _fields_status; }
 491   void set_fields_status(Array<FieldStatus>* array) { _fields_status = array; }
 492 
 493   Array<u2>* loadable_descriptors() const { return _loadable_descriptors; }
 494   void set_loadable_descriptors(Array<u2>* c) { _loadable_descriptors = c; }
 495 
 496   // inner classes
 497   Array<u2>* inner_classes() const       { return _inner_classes; }
 498   void set_inner_classes(Array<u2>* f)   { _inner_classes = f; }
 499 
 500   // nest members
 501   Array<u2>* nest_members() const     { return _nest_members; }
 502   void set_nest_members(Array<u2>* m) { _nest_members = m; }
 503 
 504   // nest-host index
 505   jushort nest_host_index() const { return _nest_host_index; }
 506   void set_nest_host_index(u2 i)  { _nest_host_index = i; }
 507   // dynamic nest member support
 508   void set_nest_host(InstanceKlass* host);
 509 
 510   // record components
 511   Array<RecordComponent*>* record_components() const { return _record_components; }
 512   void set_record_components(Array<RecordComponent*>* record_components) {
 513     _record_components = record_components;
 514   }
 515   bool is_record() const;

 571   bool in_javabase_module() const;
 572   bool in_unnamed_package() const   { return (_package_entry == nullptr); }
 573   void set_package(ClassLoaderData* loader_data, PackageEntry* pkg_entry, TRAPS);
 574   // If the package for the InstanceKlass is in the boot loader's package entry
 575   // table then sets the classpath_index field so that
 576   // get_system_package() will know to return a non-null value for the
 577   // package's location.  And, so that the package will be added to the list of
 578   // packages returned by get_system_packages().
 579   // For packages whose classes are loaded from the boot loader class path, the
 580   // classpath_index indicates which entry on the boot loader class path.
 581   void set_classpath_index(s2 path_index);
 582   bool is_same_class_package(const Klass* class2) const;
 583   bool is_same_class_package(oop other_class_loader, const Symbol* other_class_name) const;
 584 
 585   // find an enclosing class
 586   InstanceKlass* compute_enclosing_class(bool* inner_is_member, TRAPS) const;
 587 
 588   // Find InnerClasses attribute and return outer_class_info_index & inner_name_index.
 589   bool find_inner_classes_attr(int* ooff, int* noff, TRAPS) const;
 590 
 591   // Check if this klass can be null-free
 592   static void check_can_be_annotated_with_NullRestricted(InstanceKlass* type, Symbol* container_klass_name, TRAPS);
 593 
 594  private:
 595   // Check prohibited package ("java/" only loadable by boot or platform loaders)
 596   static void check_prohibited_package(Symbol* class_name,
 597                                        ClassLoaderData* loader_data,
 598                                        TRAPS);
 599 
 600   JavaThread* init_thread()  { return AtomicAccess::load(&_init_thread); }
 601   const char* init_thread_name() {
 602     return init_thread()->name_raw();
 603   }
 604 
 605  public:
 606   // initialization state
 607   bool is_loaded() const                   { return init_state() >= loaded; }
 608   bool is_linked() const                   { return init_state() >= linked; }
 609   bool is_initialized() const              { return init_state() == fully_initialized; }
 610   bool is_not_initialized() const          { return init_state() <  being_initialized; }
 611   bool is_being_initialized() const        { return init_state() == being_initialized; }
 612   bool is_in_error_state() const           { return init_state() == initialization_error; }
 613   bool is_reentrant_initialization(Thread *thread)  { return thread == _init_thread; }
 614   ClassState  init_state() const           { return AtomicAccess::load_acquire(&_init_state); }
 615   const char* init_state_name() const;
 616   bool is_rewritten() const                { return _misc_flags.rewritten(); }
 617 
 618   // is this a sealed class
 619   bool is_sealed() const;
 620 
 621   // defineClass specified verification
 622   bool should_verify_class() const         { return _misc_flags.should_verify_class(); }
 623   void set_should_verify_class(bool value) { _misc_flags.set_should_verify_class(value); }
 624 
 625   // marking
 626   bool is_marked_dependent() const         { return _misc_flags.is_marked_dependent(); }
 627   void set_is_marked_dependent(bool value) { _misc_flags.set_is_marked_dependent(value); }
 628 
 629   static ByteSize kind_offset() { return in_ByteSize(offset_of(InstanceKlass, _kind)); }
 630   static ByteSize misc_flags_offset() { return in_ByteSize(offset_of(InstanceKlass, _misc_flags)); }
 631 
 632   // initialization (virtuals from Klass)
 633   bool should_be_initialized() const;  // means that initialize should be called
 634   void initialize_with_aot_initialized_mirror(TRAPS);
 635   void assert_no_clinit_will_run_for_aot_initialized_class() const NOT_DEBUG_RETURN;
 636   void initialize(TRAPS);
 637   void link_class(TRAPS);
 638   bool link_class_or_fail(TRAPS); // returns false on failure
 639   void rewrite_class(TRAPS);
 640   void link_methods(TRAPS);
 641   Method* class_initializer() const;
 642   bool interface_needs_clinit_execution_as_super(bool also_check_supers=true) const;
 643 
 644   // reference type
 645   ReferenceType reference_type() const     { return (ReferenceType)_reference_type; }
 646 
 647   // this class cp index
 648   u2 this_class_index() const             { return _this_class_index; }
 649   void set_this_class_index(u2 index)     { _this_class_index = index; }
 650 
 651   static ByteSize reference_type_offset() { return byte_offset_of(InstanceKlass, _reference_type); }

 739   // protection domain
 740   oop protection_domain() const;
 741 
 742   // signers
 743   objArrayOop signers() const;
 744 
 745   bool is_contended() const                { return _misc_flags.is_contended(); }
 746   void set_is_contended(bool value)        { _misc_flags.set_is_contended(value); }
 747 
 748   // source file name
 749   Symbol* source_file_name() const;
 750   u2 source_file_name_index() const;
 751   void set_source_file_name_index(u2 sourcefile_index);
 752 
 753   // minor and major version numbers of class file
 754   u2 minor_version() const;
 755   void set_minor_version(u2 minor_version);
 756   u2 major_version() const;
 757   void set_major_version(u2 major_version);
 758 
 759   bool supports_inline_types() const;
 760 
 761   // source debug extension
 762   const char* source_debug_extension() const { return _source_debug_extension; }
 763   void set_source_debug_extension(const char* array, int length);
 764 
 765   // nonstatic oop-map blocks
 766   static int nonstatic_oop_map_size(unsigned int oop_map_count) {
 767     return oop_map_count * OopMapBlock::size_in_words();
 768   }
 769   unsigned int nonstatic_oop_map_count() const {
 770     return _nonstatic_oop_map_size / OopMapBlock::size_in_words();
 771   }
 772   int nonstatic_oop_map_size() const { return _nonstatic_oop_map_size; }
 773   void set_nonstatic_oop_map_size(int words) {
 774     _nonstatic_oop_map_size = words;
 775   }
 776 
 777   bool has_contended_annotations() const { return _misc_flags.has_contended_annotations(); }
 778   void set_has_contended_annotations(bool value)  { _misc_flags.set_has_contended_annotations(value); }
 779 
 780 #if INCLUDE_JVMTI

 847   }
 848   JvmtiCachedClassFileData * get_cached_class_file() { return (JvmtiCachedClassFileData *)nullptr; }
 849 
 850 #endif // INCLUDE_JVMTI
 851 
 852   bool has_nonstatic_concrete_methods() const { return _misc_flags.has_nonstatic_concrete_methods(); }
 853   void set_has_nonstatic_concrete_methods(bool b) { _misc_flags.set_has_nonstatic_concrete_methods(b); }
 854 
 855   bool declares_nonstatic_concrete_methods() const { return _misc_flags.declares_nonstatic_concrete_methods(); }
 856   void set_declares_nonstatic_concrete_methods(bool b) { _misc_flags.set_declares_nonstatic_concrete_methods(b); }
 857 
 858   bool has_miranda_methods () const     { return _misc_flags.has_miranda_methods(); }
 859   void set_has_miranda_methods()        { _misc_flags.set_has_miranda_methods(true); }
 860   bool has_final_method() const         { return _misc_flags.has_final_method(); }
 861   void set_has_final_method()           { _misc_flags.set_has_final_method(true); }
 862 
 863   // for adding methods, ConstMethod::UNSET_IDNUM means no more ids available
 864   inline u2 next_method_idnum();
 865   void set_initial_method_idnum(u2 value)             { _idnum_allocated_count = value; }
 866 
 867   // runtime support for strict statics
 868   bool has_strict_static_fields() const     { return _misc_flags.has_strict_static_fields(); }
 869   void set_has_strict_static_fields(bool b) { _misc_flags.set_has_strict_static_fields(b); }
 870   void notify_strict_static_access(int field_index, bool is_writing, TRAPS);
 871   const char* format_strict_static_message(Symbol* field_name, const char* doing_what = nullptr);
 872   void throw_strict_static_exception(Symbol* field_name, const char* when, TRAPS);
 873 
 874   // generics support
 875   Symbol* generic_signature() const;
 876   u2 generic_signature_index() const;
 877   void set_generic_signature_index(u2 sig_index);
 878 
 879   u2 enclosing_method_data(int offset) const;
 880   u2 enclosing_method_class_index() const {
 881     return enclosing_method_data(enclosing_method_class_index_offset);
 882   }
 883   u2 enclosing_method_method_index() {
 884     return enclosing_method_data(enclosing_method_method_index_offset);
 885   }
 886   void set_enclosing_method_indices(u2 class_index,
 887                                     u2 method_index);
 888 
 889   // jmethodID support
 890   jmethodID get_jmethod_id(Method* method);
 891   void make_methods_jmethod_ids();
 892   jmethodID jmethod_id_or_null(Method* method);
 893   void update_methods_jmethod_cache();

 947 
 948   // On-stack replacement support
 949   nmethod* osr_nmethods_head() const         { return _osr_nmethods_head; };
 950   void set_osr_nmethods_head(nmethod* h)     { _osr_nmethods_head = h; };
 951   void add_osr_nmethod(nmethod* n);
 952   bool remove_osr_nmethod(nmethod* n);
 953   int mark_osr_nmethods(DeoptimizationScope* deopt_scope, const Method* m);
 954   nmethod* lookup_osr_nmethod(const Method* m, int bci, int level, bool match_level) const;
 955 
 956 #if INCLUDE_JVMTI
 957   // Breakpoint support (see methods on Method* for details)
 958   BreakpointInfo* breakpoints() const       { return _breakpoints; };
 959   void set_breakpoints(BreakpointInfo* bps) { _breakpoints = bps; };
 960 #endif
 961 
 962   // support for stub routines
 963   static ByteSize init_state_offset()  { return byte_offset_of(InstanceKlass, _init_state); }
 964   JFR_ONLY(DEFINE_KLASS_TRACE_ID_OFFSET;)
 965   static ByteSize init_thread_offset() { return byte_offset_of(InstanceKlass, _init_thread); }
 966 
 967   static ByteSize inline_layout_info_array_offset() { return in_ByteSize(offset_of(InstanceKlass, _inline_layout_info_array)); }
 968   static ByteSize adr_inlineklass_fixed_block_offset() { return in_ByteSize(offset_of(InstanceKlass, _adr_inlineklass_fixed_block)); }
 969 
 970   // subclass/subinterface checks
 971   bool implements_interface(Klass* k) const;
 972   bool is_same_or_direct_interface(Klass* k) const;
 973 
 974 #ifdef ASSERT
 975   // check whether this class or one of its superclasses was redefined
 976   bool has_redefined_this_or_super() const;
 977 #endif
 978 
 979   // Access to the implementor of an interface.
 980   InstanceKlass* implementor() const;
 981   void set_implementor(InstanceKlass* ik);
 982   int  nof_implementors() const;
 983   void add_implementor(InstanceKlass* ik);  // ik is a new class that implements this interface
 984   void init_implementor();           // initialize
 985 
 986  private:
 987   // link this class into the implementors list of every interface it implements
 988   void process_interfaces();
 989 

1013     assert(k != nullptr, "k should not be null");
1014     assert(k->is_instance_klass(), "cast to InstanceKlass");
1015     return static_cast<const InstanceKlass*>(k);
1016   }
1017 
1018   // This hides Klass::super(). The _super of an InstanceKlass is
1019   // always an InstanceKlass (or nullptr)
1020   InstanceKlass* super() const {
1021     return (Klass::super() == nullptr) ? nullptr : InstanceKlass::cast(Klass::super());
1022   }
1023 
1024   virtual InstanceKlass* java_super() const {
1025     return InstanceKlass::super();
1026   }
1027 
1028   // Sizing (in words)
1029   static int header_size()            { return sizeof(InstanceKlass)/wordSize; }
1030 
1031   static int size(int vtable_length, int itable_length,
1032                   int nonstatic_oop_map_size,
1033                   bool is_interface,
1034                   bool is_inline_type) {
1035     return align_metadata_size(header_size() +
1036            vtable_length +
1037            itable_length +
1038            nonstatic_oop_map_size +
1039            (is_interface ? (int)sizeof(Klass*)/wordSize : 0) +
1040            (is_inline_type ? (int)sizeof(InlineKlassFixedBlock) : 0));
1041   }
1042 
1043   int size() const                    { return size(vtable_length(),
1044                                                itable_length(),
1045                                                nonstatic_oop_map_size(),
1046                                                is_interface(),
1047                                                is_inline_klass());
1048   }
1049 
1050 
1051   inline intptr_t* start_of_itable() const;
1052   inline intptr_t* end_of_itable() const;
1053   inline oop static_field_base_raw();
1054   bool bounds_check(address addr, bool edge_ok = false, intptr_t size_in_bytes = -1) const PRODUCT_RETURN0;
1055 
1056   inline OopMapBlock* start_of_nonstatic_oop_maps() const;
1057   inline Klass** end_of_nonstatic_oop_maps() const;
1058 
1059   inline InstanceKlass* volatile* adr_implementor() const;
1060 
1061   void set_inline_layout_info_array(Array<InlineLayoutInfo>* array) { _inline_layout_info_array = array; }
1062   Array<InlineLayoutInfo>* inline_layout_info_array() const { return _inline_layout_info_array; }
1063   void set_inline_layout_info(int index, InlineLayoutInfo *info) {
1064     assert(_inline_layout_info_array != nullptr ,"Array not created");
1065     _inline_layout_info_array->at_put(index, *info);
1066   }
1067   InlineLayoutInfo inline_layout_info(int index) const {
1068     assert(_inline_layout_info_array != nullptr ,"Array not created");
1069     return _inline_layout_info_array->at(index);
1070   }
1071   InlineLayoutInfo* inline_layout_info_adr(int index) {
1072     assert(_inline_layout_info_array != nullptr ,"Array not created");
1073     return _inline_layout_info_array->adr_at(index);
1074   }
1075 
1076   inline InlineKlass* get_inline_type_field_klass(int idx) const ;
1077   inline InlineKlass* get_inline_type_field_klass_or_null(int idx) const;
1078 
1079   // Use this to return the size of an instance in heap words:
1080   virtual int size_helper() const {
1081     return layout_helper_to_size_helper(layout_helper());
1082   }
1083 
1084   // This bit is initialized in classFileParser.cpp.
1085   // It is false under any of the following conditions:
1086   //  - the class is abstract (including any interface)
1087   //  - the class size is larger than FastAllocateSizeLimit
1088   //  - the class is java/lang/Class, which cannot be allocated directly
1089   bool can_be_fastpath_allocated() const {
1090     return !layout_helper_needs_slow_path(layout_helper());
1091   }
1092 
1093   // Java itable
1094   klassItable itable() const;        // return klassItable wrapper
1095   Method* method_at_itable(InstanceKlass* holder, int index, TRAPS);
1096   Method* method_at_itable_or_null(InstanceKlass* holder, int index, bool& itable_entry_found);
1097   int vtable_index_of_interface_method(Method* method);
1098 
1099 #if INCLUDE_JVMTI
1100   void adjust_default_methods(bool* trace_name_printed);

1111   // instanceKlasses and the metadata they point to.
1112   void deallocate_contents(ClassLoaderData* loader_data);
1113   static void deallocate_methods(ClassLoaderData* loader_data,
1114                                  Array<Method*>* methods);
1115   void static deallocate_interfaces(ClassLoaderData* loader_data,
1116                                     const InstanceKlass* super_klass,
1117                                     Array<InstanceKlass*>* local_interfaces,
1118                                     Array<InstanceKlass*>* transitive_interfaces);
1119   void static deallocate_record_components(ClassLoaderData* loader_data,
1120                                            Array<RecordComponent*>* record_component);
1121 
1122   virtual bool on_stack() const;
1123 
1124   // callbacks for actions during class unloading
1125   static void unload_class(InstanceKlass* ik);
1126 
1127   virtual void release_C_heap_structures(bool release_sub_metadata = true);
1128 
1129   // Naming
1130   const char* signature_name() const;
1131   const char* signature_name_of_carrier(char c) const;
1132 
1133   // Oop fields (and metadata) iterators
1134   //
1135   // The InstanceKlass iterators also visits the Object's klass.
1136 
1137   // Forward iteration
1138  public:
1139   // Iterate over all oop fields in the oop maps.
1140   template <typename T, class OopClosureType>
1141   inline void oop_oop_iterate_oop_maps(oop obj, OopClosureType* closure);
1142 
1143   // Iterate over all oop fields and metadata.
1144   template <typename T, class OopClosureType>
1145   inline void oop_oop_iterate(oop obj, OopClosureType* closure);
1146 
1147   // Iterate over all oop fields in one oop map.
1148   template <typename T, class OopClosureType>
1149   inline void oop_oop_iterate_oop_map(OopMapBlock* map, oop obj, OopClosureType* closure);
1150 
1151 

1237                                   const Symbol* name,
1238                                   const Symbol* signature,
1239                                   OverpassLookupMode overpass_mode,
1240                                   StaticLookupMode static_mode,
1241                                   PrivateLookupMode private_mode);
1242 
1243 #if INCLUDE_JVMTI
1244   // RedefineClasses support
1245   void link_previous_versions(InstanceKlass* pv) { _previous_versions = pv; }
1246   void mark_newly_obsolete_methods(Array<Method*>* old_methods, int emcp_method_count);
1247 #endif
1248   // log class name to classlist
1249   void log_to_classlist() const;
1250 public:
1251 
1252 #if INCLUDE_CDS
1253   // CDS support - remove and restore oops from metadata. Oops are not shared.
1254   virtual void remove_unshareable_info();
1255   void remove_unshareable_flags();
1256   virtual void remove_java_mirror();
1257   virtual void restore_unshareable_info(ClassLoaderData* loader_data, Handle protection_domain, PackageEntry* pkg_entry, TRAPS);
1258   void init_shared_package_entry();
1259   bool can_be_verified_at_dumptime() const;
1260   void compute_has_loops_flag_for_methods();
1261 #endif
1262   bool     has_init_deps_processed() const { return _misc_flags.has_init_deps_processed(); }
1263   void set_has_init_deps_processed() {
1264     assert(is_initialized(), "");
1265     assert(!has_init_deps_processed(), "already set"); // one-off action
1266     _misc_flags.set_has_init_deps_processed(true);
1267   }
1268 
1269   u2 compute_modifier_flags() const;
1270 
1271 public:
1272   // JVMTI support
1273   jint jvmti_class_status() const;
1274 
1275   virtual void metaspace_pointers_do(MetaspaceClosure* iter);
1276 
1277  public:
1278   // Printing
1279   void print_on(outputStream* st) const;
1280   void print_value_on(outputStream* st) const;
1281 
1282   void oop_print_value_on(oop obj, outputStream* st);
1283 
1284   void oop_print_on      (oop obj, outputStream* st) { oop_print_on(obj, st, 0, 0); }
1285   void oop_print_on      (oop obj, outputStream* st, int indent = 0, int base_offset = 0);
1286 
1287 #ifndef PRODUCT
1288   void print_dependent_nmethods(bool verbose = false);
1289   bool is_dependent_nmethod(nmethod* nm);
1290   bool verify_itable_index(int index);
1291 #endif
1292 
1293   const char* internal_name() const;
1294 
1295   // Verification
1296   void verify_on(outputStream* st);
1297 
1298   void oop_verify_on(oop obj, outputStream* st);
1299 
1300   // Logging
1301   void print_class_load_logging(ClassLoaderData* loader_data,
1302                                 const ModuleEntry* module_entry,
1303                                 const ClassFileStream* cfs) const;
1304  private:
1305   void print_class_load_cause_logging() const;
< prev index next >