< 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/referenceType.hpp"
  29 #include "oops/annotations.hpp"
  30 #include "oops/constMethod.hpp"
  31 #include "oops/fieldInfo.hpp"
  32 #include "oops/instanceKlassFlags.hpp"
  33 #include "oops/instanceOop.hpp"
  34 #include "runtime/handles.hpp"
  35 #include "runtime/javaThread.hpp"
  36 #include "utilities/accessFlags.hpp"
  37 #include "utilities/align.hpp"
  38 #include "utilities/growableArray.hpp"
  39 #include "utilities/macros.hpp"
  40 #if INCLUDE_JFR
  41 #include "jfr/support/jfrKlassExtension.hpp"
  42 #endif
  43 
  44 class ConstantPool;
  45 class DeoptimizationScope;
  46 class klassItable;
  47 class Monitor;
  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 jniIdMapBase;
  71 class JNIid;
  72 class JvmtiCachedClassFieldMap;
  73 class nmethodBucket;
  74 class OopMapCache;

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

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


















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

 140 
 141  public:
 142   static const KlassKind Kind = InstanceKlassKind;
 143 
 144  protected:
 145   InstanceKlass(const ClassFileParser& parser, KlassKind kind = Kind, ReferenceType reference_type = REF_NONE);
 146 
 147  public:
 148   InstanceKlass();
 149 
 150   // See "The Java Virtual Machine Specification" section 2.16.2-5 for a detailed description
 151   // of the class loading & initialization procedure, and the use of the states.
 152   enum ClassState : u1 {
 153     allocated,                          // allocated (but not yet linked)
 154     loaded,                             // loaded and inserted in class hierarchy (but not linked yet)
 155     being_linked,                       // currently running verifier and rewriter
 156     linked,                             // successfully linked/verified (but not initialized yet)
 157     being_initialized,                  // currently running class initializer
 158     fully_initialized,                  // initialized (successful final state)
 159     initialization_error                // error happened during initialization
 160   };
 161 
 162  private:
 163   static InstanceKlass* allocate_instance_klass(const ClassFileParser& parser, TRAPS);
 164 
 165  protected:
 166   // If you add a new field that points to any metaspace object, you
 167   // must add this field to InstanceKlass::metaspace_pointers_do().
 168 
 169   // Annotations for this class
 170   Annotations*    _annotations;
 171   // Package this class is defined in
 172   PackageEntry*   _package_entry;
 173   // Array classes holding elements of this class.
 174   ObjArrayKlass* volatile _array_klasses;
 175   // Constant pool for this class.
 176   ConstantPool* _constants;
 177   // The InnerClasses attribute and EnclosingMethod attribute. The
 178   // _inner_classes is an array of shorts. If the class has InnerClasses
 179   // attribute, then the _inner_classes array begins with 4-tuples of shorts
 180   // [inner_class_info_index, outer_class_info_index,
 181   // inner_name_index, inner_class_access_flags] for the InnerClasses
 182   // attribute. If the EnclosingMethod attribute exists, it occupies the
 183   // last two shorts [class_index, method_index] of the array. If only
 184   // the InnerClasses attribute exists, the _inner_classes array length is
 185   // number_of_inner_classes * 4. If the class has both InnerClasses
 186   // and EnclosingMethod attributes the _inner_classes array length is
 187   // number_of_inner_classes * 4 + enclosing_method_attribute_size.
 188   Array<jushort>* _inner_classes;
 189 
 190   // The NestMembers attribute. An array of shorts, where each is a
 191   // class info index for the class that is a nest member. This data
 192   // has not been validated.
 193   Array<jushort>* _nest_members;
 194 

 259   NOT_PRODUCT(volatile int _shared_class_load_count;) // ensure a shared class is loaded only once
 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<FieldStatus>* _fields_status;
 278 





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

 312   bool is_shared_unregistered_class() const { return _misc_flags.is_shared_unregistered_class(); }
 313 
 314   // Check if the class can be shared in CDS
 315   bool is_shareable() const;
 316 
 317   bool shared_loading_failed() const { return _misc_flags.shared_loading_failed(); }
 318 
 319   void set_shared_loading_failed() { _misc_flags.set_shared_loading_failed(true); }
 320 
 321 #if INCLUDE_CDS
 322   void set_shared_class_loader_type(s2 loader_type) { _misc_flags.set_shared_class_loader_type(loader_type); }
 323   void assign_class_loader_type() { _misc_flags.assign_class_loader_type(_class_loader_data); }
 324 #endif
 325 
 326   bool has_nonstatic_fields() const        { return _misc_flags.has_nonstatic_fields(); }
 327   void set_has_nonstatic_fields(bool b)    { _misc_flags.set_has_nonstatic_fields(b); }
 328 
 329   bool has_localvariable_table() const     { return _misc_flags.has_localvariable_table(); }
 330   void set_has_localvariable_table(bool b) { _misc_flags.set_has_localvariable_table(b); }
 331 
























 332   // field sizes
 333   int nonstatic_field_size() const         { return _nonstatic_field_size; }
 334   void set_nonstatic_field_size(int size)  { _nonstatic_field_size = size; }
 335 
 336   int static_field_size() const            { return _static_field_size; }
 337   void set_static_field_size(int size)     { _static_field_size = size; }
 338 
 339   int static_oop_field_count() const       { return (int)_static_oop_field_count; }
 340   void set_static_oop_field_count(u2 size) { _static_oop_field_count = size; }
 341 
 342   // Java itable
 343   int  itable_length() const               { return _itable_len; }
 344   void set_itable_length(int len)          { _itable_len = len; }
 345 
 346   // array klasses
 347   ObjArrayKlass* array_klasses() const     { return _array_klasses; }
 348   inline ObjArrayKlass* array_klasses_acquire() const; // load with acquire semantics
 349   inline void release_set_array_klasses(ObjArrayKlass* k); // store with release semantics
 350   void set_array_klasses(ObjArrayKlass* k) { _array_klasses = k; }
 351 
 352   // methods
 353   Array<Method*>* methods() const          { return _methods; }
 354   void set_methods(Array<Method*>* a)      { _methods = a; }
 355   Method* method_with_idnum(int idnum);
 356   Method* method_with_orig_idnum(int idnum);
 357   Method* method_with_orig_idnum(int idnum, int version);
 358 
 359   // method ordering
 360   Array<int>* method_ordering() const     { return _method_ordering; }
 361   void set_method_ordering(Array<int>* m) { _method_ordering = m; }
 362   void copy_method_ordering(const intArray* m, TRAPS);
 363 
 364   // default_methods
 365   Array<Method*>* default_methods() const  { return _default_methods; }
 366   void set_default_methods(Array<Method*>* a) { _default_methods = a; }
 367 
 368   // default method vtable_indices
 369   Array<int>* default_vtable_indices() const { return _default_vtable_indices; }
 370   void set_default_vtable_indices(Array<int>* v) { _default_vtable_indices = v; }
 371   Array<int>* create_new_default_vtable_indices(int len, TRAPS);
 372 
 373   // interfaces
 374   Array<InstanceKlass*>* local_interfaces() const          { return _local_interfaces; }
 375   void set_local_interfaces(Array<InstanceKlass*>* a)      {
 376     guarantee(_local_interfaces == nullptr || a == nullptr, "Just checking");
 377     _local_interfaces = a; }
 378 
 379   Array<InstanceKlass*>* transitive_interfaces() const     { return _transitive_interfaces; }
 380   void set_transitive_interfaces(Array<InstanceKlass*>* a) {
 381     guarantee(_transitive_interfaces == nullptr || a == nullptr, "Just checking");
 382     _transitive_interfaces = a;
 383   }
 384 
 385  private:
 386   friend class fieldDescriptor;
 387   FieldInfo field(int index) const;
 388 
 389  public:
 390   int     field_offset      (int index) const { return field(index).offset(); }
 391   int     field_access_flags(int index) const { return field(index).access_flags().as_int(); }
 392   FieldInfo::FieldFlags field_flags(int index) const { return field(index).field_flags(); }
 393   FieldStatus field_status(int index)   const { return fields_status()->at(index); }
 394   inline Symbol* field_name        (int index) const;
 395   inline Symbol* field_signature   (int index) const;




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



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

 526     }
 527     ~LockLinkState() {
 528       if (!_ik->is_linked()) {
 529         // Reset to loaded if linking failed.
 530         _ik->set_initialization_state_and_notify(loaded, _current);
 531       }
 532     }
 533   };
 534 
 535   // is this a sealed class
 536   bool is_sealed() const;
 537 
 538   // defineClass specified verification
 539   bool should_verify_class() const         { return _misc_flags.should_verify_class(); }
 540   void set_should_verify_class(bool value) { _misc_flags.set_should_verify_class(value); }
 541 
 542   // marking
 543   bool is_marked_dependent() const         { return _misc_flags.is_marked_dependent(); }
 544   void set_is_marked_dependent(bool value) { _misc_flags.set_is_marked_dependent(value); }
 545 



 546   // initialization (virtuals from Klass)
 547   bool should_be_initialized() const;  // means that initialize should be called
 548   void initialize(TRAPS);
 549   void link_class(TRAPS);
 550   bool link_class_or_fail(TRAPS); // returns false on failure
 551   void rewrite_class(TRAPS);
 552   void link_methods(TRAPS);
 553   Method* class_initializer() const;
 554 
 555   // reference type
 556   ReferenceType reference_type() const     { return (ReferenceType)_reference_type; }
 557 
 558   // this class cp index
 559   u2 this_class_index() const             { return _this_class_index; }
 560   void set_this_class_index(u2 index)     { _this_class_index = index; }
 561 
 562   static ByteSize reference_type_offset() { return byte_offset_of(InstanceKlass, _reference_type); }
 563 
 564   // find local field, returns true if found
 565   bool find_local_field(Symbol* name, Symbol* sig, fieldDescriptor* fd) const;

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




 871   // subclass/subinterface checks
 872   bool implements_interface(Klass* k) const;
 873   bool is_same_or_direct_interface(Klass* k) const;
 874 
 875 #ifdef ASSERT
 876   // check whether this class or one of its superclasses was redefined
 877   bool has_redefined_this_or_super() const;
 878 #endif
 879 
 880   // Access to the implementor of an interface.
 881   InstanceKlass* implementor() const;
 882   void set_implementor(InstanceKlass* ik);
 883   int  nof_implementors() const;
 884   void add_implementor(InstanceKlass* ik);  // ik is a new class that implements this interface
 885   void init_implementor();           // initialize
 886 
 887  private:
 888   // link this class into the implementors list of every interface it implements
 889   void process_interfaces();
 890 

 908 
 909   static InstanceKlass* cast(Klass* k) {
 910     return const_cast<InstanceKlass*>(cast(const_cast<const Klass*>(k)));
 911   }
 912 
 913   static const InstanceKlass* cast(const Klass* k) {
 914     assert(k != nullptr, "k should not be null");
 915     assert(k->is_instance_klass(), "cast to InstanceKlass");
 916     return static_cast<const InstanceKlass*>(k);
 917   }
 918 
 919   virtual InstanceKlass* java_super() const {
 920     return (super() == nullptr) ? nullptr : cast(super());
 921   }
 922 
 923   // Sizing (in words)
 924   static int header_size()            { return sizeof(InstanceKlass)/wordSize; }
 925 
 926   static int size(int vtable_length, int itable_length,
 927                   int nonstatic_oop_map_size,
 928                   bool is_interface) {

 929     return align_metadata_size(header_size() +
 930            vtable_length +
 931            itable_length +
 932            nonstatic_oop_map_size +
 933            (is_interface ? (int)sizeof(Klass*)/wordSize : 0));

 934   }
 935 
 936   int size() const                    { return size(vtable_length(),
 937                                                itable_length(),
 938                                                nonstatic_oop_map_size(),
 939                                                is_interface());

 940   }
 941 
 942 
 943   inline intptr_t* start_of_itable() const;
 944   inline intptr_t* end_of_itable() const;
 945   inline oop static_field_base_raw();

 946 
 947   inline OopMapBlock* start_of_nonstatic_oop_maps() const;
 948   inline Klass** end_of_nonstatic_oop_maps() const;
 949 
 950   inline InstanceKlass* volatile* adr_implementor() const;
 951 











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

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

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

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

   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/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 Monitor;
  49 class RecordComponent;
  50 
  51 // An InstanceKlass is the VM level representation of a Java class.
  52 // It contains all information needed for at class at execution runtime.
  53 
  54 //  InstanceKlass embedded field layout (after declared fields):
  55 //    [EMBEDDED Java vtable             ] size in words = vtable_len
  56 //    [EMBEDDED nonstatic oop-map blocks] size in words = nonstatic_oop_map_size
  57 //      The embedded nonstatic oop-map blocks are short pairs (offset, length)
  58 //      indicating where oops are located in instances of this klass.
  59 //    [EMBEDDED implementor of the interface] only exist for interface
  60 //    [EMBEDDED InlineKlassFixedBlock] only if is an InlineKlass instance
  61 
  62 
  63 // forward declaration for class -- see below for definition
  64 #if INCLUDE_JVMTI
  65 class BreakpointInfo;
  66 #endif
  67 class ClassFileParser;
  68 class ClassFileStream;
  69 class KlassDepChange;
  70 class DependencyContext;
  71 class fieldDescriptor;
  72 class jniIdMapBase;
  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  public:
  94    FieldPrinter(outputStream* st, oop obj = nullptr) : _obj(obj), _st(st) {}
  95    void do_field(fieldDescriptor* fd);
  96 };
  97 

 118     return another_offset == end_offset();
 119   }
 120 
 121   // sizeof(OopMapBlock) in words.
 122   static int size_in_words() {
 123     return align_up((int)sizeof(OopMapBlock), wordSize) >>
 124       LogBytesPerWord;
 125   }
 126 
 127   static int compare_offset(const OopMapBlock* a, const OopMapBlock* b) {
 128     return a->offset() - b->offset();
 129   }
 130 
 131  private:
 132   int  _offset;
 133   uint _count;
 134 };
 135 
 136 struct JvmtiCachedClassFileData;
 137 
 138 class SigEntry;
 139 
 140 class InlineKlassFixedBlock {
 141   Array<SigEntry>** _extended_sig;
 142   Array<VMRegPair>** _return_regs;
 143   address* _pack_handler;
 144   address* _pack_handler_jobject;
 145   address* _unpack_handler;
 146   int* _default_value_offset;
 147   ArrayKlass** _null_free_inline_array_klasses;
 148   int _alignment;
 149   int _first_field_offset;
 150   int _payload_size_in_bytes;
 151   int _internal_null_marker_offset; // -1 if none
 152 
 153   friend class InlineKlass;
 154 };
 155 
 156 class InstanceKlass: public Klass {
 157   friend class VMStructs;
 158   friend class JVMCIVMStructs;
 159   friend class ClassFileParser;
 160   friend class CompileReplay;
 161   friend class TemplateTable;
 162 
 163  public:
 164   static const KlassKind Kind = InstanceKlassKind;
 165 
 166  protected:
 167   InstanceKlass(const ClassFileParser& parser, KlassKind kind = Kind, ReferenceType reference_type = REF_NONE);
 168 
 169  public:
 170   InstanceKlass();
 171 
 172   // See "The Java Virtual Machine Specification" section 2.16.2-5 for a detailed description
 173   // of the class loading & initialization procedure, and the use of the states.
 174   enum ClassState : u1 {
 175     allocated,                          // allocated (but not yet linked)
 176     loaded,                             // loaded and inserted in class hierarchy (but not linked yet)
 177     being_linked,                       // currently running verifier and rewriter
 178     linked,                             // successfully linked/verified (but not initialized yet)
 179     being_initialized,                  // currently running class initializer
 180     fully_initialized,                  // initialized (successful final state)
 181     initialization_error                // error happened during initialization
 182   };
 183 
 184  private:
 185   static InstanceKlass* allocate_instance_klass(const ClassFileParser& parser, TRAPS);
 186 
 187  protected:
 188   // If you add a new field that points to any metaspace object, you
 189   // must add this field to InstanceKlass::metaspace_pointers_do().
 190 
 191   // Annotations for this class
 192   Annotations*    _annotations;
 193   // Package this class is defined in
 194   PackageEntry*   _package_entry;
 195   // Array classes holding elements of this class.
 196   ArrayKlass* volatile _array_klasses;
 197   // Constant pool for this class.
 198   ConstantPool* _constants;
 199   // The InnerClasses attribute and EnclosingMethod attribute. The
 200   // _inner_classes is an array of shorts. If the class has InnerClasses
 201   // attribute, then the _inner_classes array begins with 4-tuples of shorts
 202   // [inner_class_info_index, outer_class_info_index,
 203   // inner_name_index, inner_class_access_flags] for the InnerClasses
 204   // attribute. If the EnclosingMethod attribute exists, it occupies the
 205   // last two shorts [class_index, method_index] of the array. If only
 206   // the InnerClasses attribute exists, the _inner_classes array length is
 207   // number_of_inner_classes * 4. If the class has both InnerClasses
 208   // and EnclosingMethod attributes the _inner_classes array length is
 209   // number_of_inner_classes * 4 + enclosing_method_attribute_size.
 210   Array<jushort>* _inner_classes;
 211 
 212   // The NestMembers attribute. An array of shorts, where each is a
 213   // class info index for the class that is a nest member. This data
 214   // has not been validated.
 215   Array<jushort>* _nest_members;
 216 

 281   NOT_PRODUCT(volatile int _shared_class_load_count;) // ensure a shared class is loaded only once
 282 
 283   // Method array.
 284   Array<Method*>* _methods;
 285   // Default Method Array, concrete methods inherited from interfaces
 286   Array<Method*>* _default_methods;
 287   // Interfaces (InstanceKlass*s) this class declares locally to implement.
 288   Array<InstanceKlass*>* _local_interfaces;
 289   // Interfaces (InstanceKlass*s) this class implements transitively.
 290   Array<InstanceKlass*>* _transitive_interfaces;
 291   // Int array containing the original order of method in the class file (for JVMTI).
 292   Array<int>*     _method_ordering;
 293   // Int array containing the vtable_indices for default_methods
 294   // offset matches _default_methods offset
 295   Array<int>*     _default_vtable_indices;
 296 
 297   // Fields information is stored in an UNSIGNED5 encoded stream (see fieldInfo.hpp)
 298   Array<u1>*          _fieldinfo_stream;
 299   Array<FieldStatus>* _fields_status;
 300 
 301   Array<InlineKlass*>* _inline_type_field_klasses; // For "inline class" fields, null if none present
 302   Array<int>* _null_marker_offsets; // for flat fields with a null marker
 303   Array<u2>* _loadable_descriptors;
 304   const InlineKlassFixedBlock* _adr_inlineklass_fixed_block;
 305 
 306   // embedded Java vtable follows here
 307   // embedded Java itables follows here
 308   // embedded static fields follows here
 309   // embedded nonstatic oop-map blocks follows here
 310   // embedded implementor of this interface follows here
 311   //   The embedded implementor only exists if the current klass is an
 312   //   interface. The possible values of the implementor fall into following
 313   //   three cases:
 314   //     null: no implementor.
 315   //     A Klass* that's not itself: one implementor.
 316   //     Itself: more than one implementors.
 317   //
 318 
 319   friend class SystemDictionary;
 320 
 321   static bool _disable_method_binary_search;
 322 
 323   // Controls finalizer registration
 324   static bool _finalization_enabled;
 325 

 339   bool is_shared_unregistered_class() const { return _misc_flags.is_shared_unregistered_class(); }
 340 
 341   // Check if the class can be shared in CDS
 342   bool is_shareable() const;
 343 
 344   bool shared_loading_failed() const { return _misc_flags.shared_loading_failed(); }
 345 
 346   void set_shared_loading_failed() { _misc_flags.set_shared_loading_failed(true); }
 347 
 348 #if INCLUDE_CDS
 349   void set_shared_class_loader_type(s2 loader_type) { _misc_flags.set_shared_class_loader_type(loader_type); }
 350   void assign_class_loader_type() { _misc_flags.assign_class_loader_type(_class_loader_data); }
 351 #endif
 352 
 353   bool has_nonstatic_fields() const        { return _misc_flags.has_nonstatic_fields(); }
 354   void set_has_nonstatic_fields(bool b)    { _misc_flags.set_has_nonstatic_fields(b); }
 355 
 356   bool has_localvariable_table() const     { return _misc_flags.has_localvariable_table(); }
 357   void set_has_localvariable_table(bool b) { _misc_flags.set_has_localvariable_table(b); }
 358 
 359   bool has_inline_type_fields() const { return _misc_flags.has_inline_type_fields(); }
 360   void set_has_inline_type_fields()   { _misc_flags.set_has_inline_type_fields(true); }
 361 
 362   bool is_empty_inline_type() const   { return _misc_flags.is_empty_inline_type(); }
 363   void set_is_empty_inline_type()     { _misc_flags.set_is_empty_inline_type(true); }
 364 
 365   // Note:  The naturally_atomic property only applies to
 366   // inline classes; it is never true on identity classes.
 367   // The bit is placed on instanceKlass for convenience.
 368 
 369   // Query if h/w provides atomic load/store for instances.
 370   bool is_naturally_atomic() const  { return _misc_flags.is_naturally_atomic(); }
 371   void set_is_naturally_atomic()    { _misc_flags.set_is_naturally_atomic(true); }
 372 
 373   // Query if this class is mentioned in the JVM option ForceNonTearable.
 374   // This bit can occur anywhere, but is only significant
 375   // for inline classes *and* their super types.
 376   // It inherits from supers.
 377   bool must_be_atomic() const { return _misc_flags.must_be_atomic(); }
 378   void set_must_be_atomic()   { _misc_flags.set_must_be_atomic(true); }
 379 
 380   bool is_implicitly_constructible() const { return _misc_flags.is_implicitly_constructible(); }
 381   void set_is_implicitly_constructible()   { _misc_flags.set_is_implicitly_constructible(true); }
 382 
 383   // field sizes
 384   int nonstatic_field_size() const         { return _nonstatic_field_size; }
 385   void set_nonstatic_field_size(int size)  { _nonstatic_field_size = size; }
 386 
 387   int static_field_size() const            { return _static_field_size; }
 388   void set_static_field_size(int size)     { _static_field_size = size; }
 389 
 390   int static_oop_field_count() const       { return (int)_static_oop_field_count; }
 391   void set_static_oop_field_count(u2 size) { _static_oop_field_count = size; }
 392 
 393   // Java itable
 394   int  itable_length() const               { return _itable_len; }
 395   void set_itable_length(int len)          { _itable_len = len; }
 396 
 397   // array klasses
 398   ArrayKlass* array_klasses() const     { return _array_klasses; }
 399   inline ArrayKlass* array_klasses_acquire() const; // load with acquire semantics
 400   inline void release_set_array_klasses(ArrayKlass* k); // store with release semantics
 401   void set_array_klasses(ArrayKlass* k) { _array_klasses = k; }
 402 
 403   // methods
 404   Array<Method*>* methods() const          { return _methods; }
 405   void set_methods(Array<Method*>* a)      { _methods = a; }
 406   Method* method_with_idnum(int idnum);
 407   Method* method_with_orig_idnum(int idnum);
 408   Method* method_with_orig_idnum(int idnum, int version);
 409 
 410   // method ordering
 411   Array<int>* method_ordering() const     { return _method_ordering; }
 412   void set_method_ordering(Array<int>* m) { _method_ordering = m; }
 413   void copy_method_ordering(const intArray* m, TRAPS);
 414 
 415   // default_methods
 416   Array<Method*>* default_methods() const  { return _default_methods; }
 417   void set_default_methods(Array<Method*>* a) { _default_methods = a; }
 418 
 419   // default method vtable_indices
 420   Array<int>* default_vtable_indices() const { return _default_vtable_indices; }
 421   void set_default_vtable_indices(Array<int>* v) { _default_vtable_indices = v; }
 422   Array<int>* create_new_default_vtable_indices(int len, TRAPS);
 423 
 424   // interfaces
 425   Array<InstanceKlass*>* local_interfaces() const          { return _local_interfaces; }
 426   void set_local_interfaces(Array<InstanceKlass*>* a)      {
 427     guarantee(_local_interfaces == nullptr || a == nullptr, "Just checking");
 428     _local_interfaces = a; }
 429 
 430   Array<InstanceKlass*>* transitive_interfaces() const     { return _transitive_interfaces; }
 431   void set_transitive_interfaces(Array<InstanceKlass*>* a) {
 432     guarantee(_transitive_interfaces == nullptr || a == nullptr, "Just checking");
 433     _transitive_interfaces = a;
 434   }
 435 
 436  private:
 437   friend class fieldDescriptor;
 438   FieldInfo field(int index) const;
 439 
 440  public:
 441   int field_offset      (int index) const { return field(index).offset(); }
 442   int field_access_flags(int index) const { return field(index).access_flags().as_int(); }
 443   FieldInfo::FieldFlags field_flags(int index) const { return field(index).field_flags(); }
 444   FieldStatus field_status(int index)   const { return fields_status()->at(index); }
 445   inline Symbol* field_name        (int index) const;
 446   inline Symbol* field_signature   (int index) const;
 447   bool field_is_flat(int index) const { return field_flags(index).is_flat(); }
 448   bool field_has_null_marker(int index) const { return field_flags(index).has_null_marker(); }
 449   bool field_is_null_free_inline_type(int index) const;
 450   bool is_class_in_loadable_descriptors_attribute(Symbol* name) const;
 451 
 452   // Number of Java declared fields
 453   int java_fields_count() const;
 454   int total_fields_count() const;
 455 
 456   Array<u1>* fieldinfo_stream() const { return _fieldinfo_stream; }
 457   void set_fieldinfo_stream(Array<u1>* fis) { _fieldinfo_stream = fis; }
 458 
 459   Array<FieldStatus>* fields_status() const {return _fields_status; }
 460   void set_fields_status(Array<FieldStatus>* array) { _fields_status = array; }
 461 
 462   Array<u2>* loadable_descriptors() const { return _loadable_descriptors; }
 463   void set_loadable_descriptors(Array<u2>* c) { _loadable_descriptors = c; }
 464 
 465   // inner classes
 466   Array<u2>* inner_classes() const       { return _inner_classes; }
 467   void set_inner_classes(Array<u2>* f)   { _inner_classes = f; }
 468 
 469   // nest members
 470   Array<u2>* nest_members() const     { return _nest_members; }
 471   void set_nest_members(Array<u2>* m) { _nest_members = m; }
 472 
 473   // nest-host index
 474   jushort nest_host_index() const { return _nest_host_index; }
 475   void set_nest_host_index(u2 i)  { _nest_host_index = i; }
 476   // dynamic nest member support
 477   void set_nest_host(InstanceKlass* host);
 478 
 479   // record components
 480   Array<RecordComponent*>* record_components() const { return _record_components; }
 481   void set_record_components(Array<RecordComponent*>* record_components) {
 482     _record_components = record_components;
 483   }
 484   bool is_record() const;

 584     }
 585     ~LockLinkState() {
 586       if (!_ik->is_linked()) {
 587         // Reset to loaded if linking failed.
 588         _ik->set_initialization_state_and_notify(loaded, _current);
 589       }
 590     }
 591   };
 592 
 593   // is this a sealed class
 594   bool is_sealed() const;
 595 
 596   // defineClass specified verification
 597   bool should_verify_class() const         { return _misc_flags.should_verify_class(); }
 598   void set_should_verify_class(bool value) { _misc_flags.set_should_verify_class(value); }
 599 
 600   // marking
 601   bool is_marked_dependent() const         { return _misc_flags.is_marked_dependent(); }
 602   void set_is_marked_dependent(bool value) { _misc_flags.set_is_marked_dependent(value); }
 603 
 604   static ByteSize kind_offset() { return in_ByteSize(offset_of(InstanceKlass, _kind)); }
 605   static ByteSize misc_flags_offset() { return in_ByteSize(offset_of(InstanceKlass, _misc_flags)); }
 606 
 607   // initialization (virtuals from Klass)
 608   bool should_be_initialized() const;  // means that initialize should be called
 609   void initialize(TRAPS);
 610   void link_class(TRAPS);
 611   bool link_class_or_fail(TRAPS); // returns false on failure
 612   void rewrite_class(TRAPS);
 613   void link_methods(TRAPS);
 614   Method* class_initializer() const;
 615 
 616   // reference type
 617   ReferenceType reference_type() const     { return (ReferenceType)_reference_type; }
 618 
 619   // this class cp index
 620   u2 this_class_index() const             { return _this_class_index; }
 621   void set_this_class_index(u2 index)     { _this_class_index = index; }
 622 
 623   static ByteSize reference_type_offset() { return byte_offset_of(InstanceKlass, _reference_type); }
 624 
 625   // find local field, returns true if found
 626   bool find_local_field(Symbol* name, Symbol* sig, fieldDescriptor* fd) const;

 912 
 913   // On-stack replacement support
 914   nmethod* osr_nmethods_head() const         { return _osr_nmethods_head; };
 915   void set_osr_nmethods_head(nmethod* h)     { _osr_nmethods_head = h; };
 916   void add_osr_nmethod(nmethod* n);
 917   bool remove_osr_nmethod(nmethod* n);
 918   int mark_osr_nmethods(DeoptimizationScope* deopt_scope, const Method* m);
 919   nmethod* lookup_osr_nmethod(const Method* m, int bci, int level, bool match_level) const;
 920 
 921 #if INCLUDE_JVMTI
 922   // Breakpoint support (see methods on Method* for details)
 923   BreakpointInfo* breakpoints() const       { return _breakpoints; };
 924   void set_breakpoints(BreakpointInfo* bps) { _breakpoints = bps; };
 925 #endif
 926 
 927   // support for stub routines
 928   static ByteSize init_state_offset()  { return byte_offset_of(InstanceKlass, _init_state); }
 929   JFR_ONLY(DEFINE_KLASS_TRACE_ID_OFFSET;)
 930   static ByteSize init_thread_offset() { return byte_offset_of(InstanceKlass, _init_thread); }
 931 
 932   static ByteSize inline_type_field_klasses_offset() { return in_ByteSize(offset_of(InstanceKlass, _inline_type_field_klasses)); }
 933   static ByteSize null_marker_array_offset() { return in_ByteSize(offset_of(InstanceKlass, _null_marker_offsets)); }
 934   static ByteSize adr_inlineklass_fixed_block_offset() { return in_ByteSize(offset_of(InstanceKlass, _adr_inlineklass_fixed_block)); }
 935 
 936   // subclass/subinterface checks
 937   bool implements_interface(Klass* k) const;
 938   bool is_same_or_direct_interface(Klass* k) const;
 939 
 940 #ifdef ASSERT
 941   // check whether this class or one of its superclasses was redefined
 942   bool has_redefined_this_or_super() const;
 943 #endif
 944 
 945   // Access to the implementor of an interface.
 946   InstanceKlass* implementor() const;
 947   void set_implementor(InstanceKlass* ik);
 948   int  nof_implementors() const;
 949   void add_implementor(InstanceKlass* ik);  // ik is a new class that implements this interface
 950   void init_implementor();           // initialize
 951 
 952  private:
 953   // link this class into the implementors list of every interface it implements
 954   void process_interfaces();
 955 

 973 
 974   static InstanceKlass* cast(Klass* k) {
 975     return const_cast<InstanceKlass*>(cast(const_cast<const Klass*>(k)));
 976   }
 977 
 978   static const InstanceKlass* cast(const Klass* k) {
 979     assert(k != nullptr, "k should not be null");
 980     assert(k->is_instance_klass(), "cast to InstanceKlass");
 981     return static_cast<const InstanceKlass*>(k);
 982   }
 983 
 984   virtual InstanceKlass* java_super() const {
 985     return (super() == nullptr) ? nullptr : cast(super());
 986   }
 987 
 988   // Sizing (in words)
 989   static int header_size()            { return sizeof(InstanceKlass)/wordSize; }
 990 
 991   static int size(int vtable_length, int itable_length,
 992                   int nonstatic_oop_map_size,
 993                   bool is_interface,
 994                   bool is_inline_type) {
 995     return align_metadata_size(header_size() +
 996            vtable_length +
 997            itable_length +
 998            nonstatic_oop_map_size +
 999            (is_interface ? (int)sizeof(Klass*)/wordSize : 0) +
1000            (is_inline_type ? (int)sizeof(InlineKlassFixedBlock) : 0));
1001   }
1002 
1003   int size() const                    { return size(vtable_length(),
1004                                                itable_length(),
1005                                                nonstatic_oop_map_size(),
1006                                                is_interface(),
1007                                                is_inline_klass());
1008   }
1009 
1010 
1011   inline intptr_t* start_of_itable() const;
1012   inline intptr_t* end_of_itable() const;
1013   inline oop static_field_base_raw();
1014   bool bounds_check(address addr, bool edge_ok = false, intptr_t size_in_bytes = -1) const PRODUCT_RETURN0;
1015 
1016   inline OopMapBlock* start_of_nonstatic_oop_maps() const;
1017   inline Klass** end_of_nonstatic_oop_maps() const;
1018 
1019   inline InstanceKlass* volatile* adr_implementor() const;
1020 
1021   Array<InlineKlass*>* inline_type_field_klasses_array() const { return _inline_type_field_klasses; }
1022   void set_inline_type_field_klasses_array(Array<InlineKlass*>* array) { _inline_type_field_klasses = array; }
1023 
1024   Array<int>* null_marker_offsets_array() const { return _null_marker_offsets; }
1025   void set_null_marker_offsets_array(Array<int>* array) { _null_marker_offsets = array; }
1026 
1027   inline InlineKlass* get_inline_type_field_klass(int idx) const;
1028   inline InlineKlass* get_inline_type_field_klass_or_null(int idx) const;
1029   inline void set_inline_type_field_klass(int idx, InlineKlass* k);
1030   inline void reset_inline_type_field_klass(int idx);
1031 
1032   // Use this to return the size of an instance in heap words:
1033   virtual int size_helper() const {
1034     return layout_helper_to_size_helper(layout_helper());
1035   }
1036 
1037   // This bit is initialized in classFileParser.cpp.
1038   // It is false under any of the following conditions:
1039   //  - the class is abstract (including any interface)
1040   //  - the class size is larger than FastAllocateSizeLimit
1041   //  - the class is java/lang/Class, which cannot be allocated directly
1042   bool can_be_fastpath_allocated() const {
1043     return !layout_helper_needs_slow_path(layout_helper());
1044   }
1045 
1046   // Java itable
1047   klassItable itable() const;        // return klassItable wrapper
1048   Method* method_at_itable(InstanceKlass* holder, int index, TRAPS);
1049   Method* method_at_itable_or_null(InstanceKlass* holder, int index, bool& itable_entry_found);
1050   int vtable_index_of_interface_method(Method* method);
1051 
1052 #if INCLUDE_JVMTI
1053   void adjust_default_methods(bool* trace_name_printed);

1064   // instanceKlasses and the metadata they point to.
1065   void deallocate_contents(ClassLoaderData* loader_data);
1066   static void deallocate_methods(ClassLoaderData* loader_data,
1067                                  Array<Method*>* methods);
1068   void static deallocate_interfaces(ClassLoaderData* loader_data,
1069                                     const Klass* super_klass,
1070                                     Array<InstanceKlass*>* local_interfaces,
1071                                     Array<InstanceKlass*>* transitive_interfaces);
1072   void static deallocate_record_components(ClassLoaderData* loader_data,
1073                                            Array<RecordComponent*>* record_component);
1074 
1075   virtual bool on_stack() const;
1076 
1077   // callbacks for actions during class unloading
1078   static void unload_class(InstanceKlass* ik);
1079 
1080   virtual void release_C_heap_structures(bool release_sub_metadata = true);
1081 
1082   // Naming
1083   const char* signature_name() const;
1084   const char* signature_name_of_carrier(char c) const;
1085 
1086   // Oop fields (and metadata) iterators
1087   //
1088   // The InstanceKlass iterators also visits the Object's klass.
1089 
1090   // Forward iteration
1091  public:
1092   // Iterate over all oop fields in the oop maps.
1093   template <typename T, class OopClosureType>
1094   inline void oop_oop_iterate_oop_maps(oop obj, OopClosureType* closure);
1095 
1096   // Iterate over all oop fields and metadata.
1097   template <typename T, class OopClosureType>
1098   inline void oop_oop_iterate(oop obj, OopClosureType* closure);
1099 
1100   // Iterate over all oop fields in one oop map.
1101   template <typename T, class OopClosureType>
1102   inline void oop_oop_iterate_oop_map(OopMapBlock* map, oop obj, OopClosureType* closure);
1103 
1104 

1185                                   const Symbol* name,
1186                                   const Symbol* signature,
1187                                   OverpassLookupMode overpass_mode,
1188                                   StaticLookupMode static_mode,
1189                                   PrivateLookupMode private_mode);
1190 
1191 #if INCLUDE_JVMTI
1192   // RedefineClasses support
1193   void link_previous_versions(InstanceKlass* pv) { _previous_versions = pv; }
1194   void mark_newly_obsolete_methods(Array<Method*>* old_methods, int emcp_method_count);
1195 #endif
1196   // log class name to classlist
1197   void log_to_classlist() const;
1198 public:
1199 
1200 #if INCLUDE_CDS
1201   // CDS support - remove and restore oops from metadata. Oops are not shared.
1202   virtual void remove_unshareable_info();
1203   void remove_unshareable_flags();
1204   virtual void remove_java_mirror();
1205   virtual void restore_unshareable_info(ClassLoaderData* loader_data, Handle protection_domain, PackageEntry* pkg_entry, TRAPS);
1206   void init_shared_package_entry();
1207   bool can_be_verified_at_dumptime() const;
1208   bool methods_contain_jsr_bytecode() const;
1209   void compute_has_loops_flag_for_methods();
1210 #endif
1211 
1212   jint compute_modifier_flags() const;
1213 
1214 public:
1215   // JVMTI support
1216   jint jvmti_class_status() const;
1217 
1218   virtual void metaspace_pointers_do(MetaspaceClosure* iter);
1219 
1220  public:
1221   // Printing
1222   void print_on(outputStream* st) const;
1223   void print_value_on(outputStream* st) const;
1224 
1225   void oop_print_value_on(oop obj, outputStream* st);
< prev index next >