< 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; }

 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;

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



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

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

 936     return align_metadata_size(header_size() +
 937            vtable_length +
 938            itable_length +
 939            nonstatic_oop_map_size +
 940            (is_interface ? (int)sizeof(Klass*)/wordSize : 0));


 941   }
 942 
 943   int size() const                    { return size(vtable_length(),
 944                                                itable_length(),
 945                                                nonstatic_oop_map_size(),
 946                                                is_interface());


 947   }
 948 
 949 
 950   inline intptr_t* start_of_itable() const;
 951   inline intptr_t* end_of_itable() const;
 952   inline oop static_field_base_raw();

 953 
 954   inline OopMapBlock* start_of_nonstatic_oop_maps() const;
 955   inline Klass** end_of_nonstatic_oop_maps() const;
 956 
 957   inline InstanceKlass* volatile* adr_implementor() const;
 958 






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

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

1012 
1013   // Oop fields (and metadata) iterators
1014   //
1015   // The InstanceKlass iterators also visits the Object's klass.
1016 
1017   // Forward iteration
1018  public:
1019   // Iterate over all oop fields in the oop maps.
1020   template <typename T, class OopClosureType>
1021   inline void oop_oop_iterate_oop_maps(oop obj, OopClosureType* closure);
1022 
1023   // Iterate over all oop fields and metadata.
1024   template <typename T, class OopClosureType>
1025   inline void oop_oop_iterate(oop obj, OopClosureType* closure);
1026 
1027   // Iterate over all oop fields in one oop map.
1028   template <typename T, class OopClosureType>
1029   inline void oop_oop_iterate_oop_map(OopMapBlock* map, oop obj, OopClosureType* closure);
1030 
1031 

1115                                   const Symbol* name,
1116                                   const Symbol* signature,
1117                                   OverpassLookupMode overpass_mode,
1118                                   StaticLookupMode static_mode,
1119                                   PrivateLookupMode private_mode);
1120 
1121 #if INCLUDE_JVMTI
1122   // RedefineClasses support
1123   void link_previous_versions(InstanceKlass* pv) { _previous_versions = pv; }
1124   void mark_newly_obsolete_methods(Array<Method*>* old_methods, int emcp_method_count);
1125 #endif
1126   // log class name to classlist
1127   void log_to_classlist() const;
1128 public:
1129 
1130 #if INCLUDE_CDS
1131   // CDS support - remove and restore oops from metadata. Oops are not shared.
1132   virtual void remove_unshareable_info();
1133   void remove_unshareable_flags();
1134   virtual void remove_java_mirror();
1135   void restore_unshareable_info(ClassLoaderData* loader_data, Handle protection_domain, PackageEntry* pkg_entry, TRAPS);
1136   void init_shared_package_entry();
1137   bool can_be_verified_at_dumptime() const;
1138   bool methods_contain_jsr_bytecode() const;
1139   void compute_has_loops_flag_for_methods();
1140 #endif
1141 
1142   jint compute_modifier_flags() const;
1143 
1144 public:
1145   // JVMTI support
1146   jint jvmti_class_status() const;
1147 
1148   virtual void metaspace_pointers_do(MetaspaceClosure* iter);
1149 
1150  public:
1151   // Printing
1152   void print_on(outputStream* st) const;
1153   void print_value_on(outputStream* st) const;
1154 
1155   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 inline_type_field_klasses] only if has_inline_fields() == true
  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 jniIdMapBase;
  74 class JNIid;
  75 class JvmtiCachedClassFieldMap;
  76 class nmethodBucket;
  77 class OopMapCache;
  78 class BufferedInlineTypeBlob;
  79 class InterpreterOopMap;
  80 class PackageEntry;
  81 class ModuleEntry;
  82 
  83 // This is used in iterators below.
  84 class FieldClosure: public StackObj {
  85 public:
  86   virtual void do_field(fieldDescriptor* fd) = 0;
  87 };
  88 
  89 // Print fields.
  90 // If "obj" argument to constructor is null, prints static fields, otherwise prints non-static fields.
  91 class FieldPrinter: public FieldClosure {
  92    oop _obj;
  93    outputStream* _st;
  94  public:
  95    FieldPrinter(outputStream* st, oop obj = nullptr) : _obj(obj), _st(st) {}
  96    void do_field(fieldDescriptor* fd);
  97 };
  98 

 119     return another_offset == end_offset();
 120   }
 121 
 122   // sizeof(OopMapBlock) in words.
 123   static int size_in_words() {
 124     return align_up((int)sizeof(OopMapBlock), wordSize) >>
 125       LogBytesPerWord;
 126   }
 127 
 128   static int compare_offset(const OopMapBlock* a, const OopMapBlock* b) {
 129     return a->offset() - b->offset();
 130   }
 131 
 132  private:
 133   int  _offset;
 134   uint _count;
 135 };
 136 
 137 struct JvmtiCachedClassFileData;
 138 
 139 class SigEntry;
 140 
 141 class InlineKlassFixedBlock {
 142   Array<SigEntry>** _extended_sig;
 143   Array<VMRegPair>** _return_regs;
 144   address* _pack_handler;
 145   address* _pack_handler_jobject;
 146   address* _unpack_handler;
 147   int* _default_value_offset;
 148   ArrayKlass** _null_free_inline_array_klasses;
 149   int _alignment;
 150   int _first_field_offset;
 151   int _exact_size_in_bytes;
 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   const Klass**   _inline_type_field_klasses; // For "inline class" fields, null if none present
 302   Array<u2>* _preload_classes;
 303   const InlineKlassFixedBlock* _adr_inlineklass_fixed_block;
 304 
 305   // embedded Java vtable follows here
 306   // embedded Java itables follows here
 307   // embedded static fields follows here
 308   // embedded nonstatic oop-map blocks follows here
 309   // embedded implementor of this interface follows here
 310   //   The embedded implementor only exists if the current klass is an
 311   //   interface. The possible values of the implementor fall into following
 312   //   three cases:
 313   //     null: no implementor.
 314   //     A Klass* that's not itself: one implementor.
 315   //     Itself: more than one implementors.
 316   //
 317 
 318   friend class SystemDictionary;
 319 
 320   static bool _disable_method_binary_search;
 321 
 322   // Controls finalizer registration
 323   static bool _finalization_enabled;
 324 

 338   bool is_shared_unregistered_class() const { return _misc_flags.is_shared_unregistered_class(); }
 339 
 340   // Check if the class can be shared in CDS
 341   bool is_shareable() const;
 342 
 343   bool shared_loading_failed() const { return _misc_flags.shared_loading_failed(); }
 344 
 345   void set_shared_loading_failed() { _misc_flags.set_shared_loading_failed(true); }
 346 
 347 #if INCLUDE_CDS
 348   void set_shared_class_loader_type(s2 loader_type) { _misc_flags.set_shared_class_loader_type(loader_type); }
 349   void assign_class_loader_type() { _misc_flags.assign_class_loader_type(_class_loader_data); }
 350 #endif
 351 
 352   bool has_nonstatic_fields() const        { return _misc_flags.has_nonstatic_fields(); }
 353   void set_has_nonstatic_fields(bool b)    { _misc_flags.set_has_nonstatic_fields(b); }
 354 
 355   bool has_localvariable_table() const     { return _misc_flags.has_localvariable_table(); }
 356   void set_has_localvariable_table(bool b) { _misc_flags.set_has_localvariable_table(b); }
 357 
 358   bool has_inline_type_fields() const { return _misc_flags.has_inline_type_fields(); }
 359   void set_has_inline_type_fields()   { _misc_flags.set_has_inline_type_fields(true); }
 360 
 361   bool is_empty_inline_type() const   { return _misc_flags.is_empty_inline_type(); }
 362   void set_is_empty_inline_type()     { _misc_flags.set_is_empty_inline_type(true); }
 363 
 364   // Note:  The naturally_atomic property only applies to
 365   // inline classes; it is never true on identity classes.
 366   // The bit is placed on instanceKlass for convenience.
 367 
 368   // Query if h/w provides atomic load/store for instances.
 369   bool is_naturally_atomic() const  { return _misc_flags.is_naturally_atomic(); }
 370   void set_is_naturally_atomic()    { _misc_flags.set_is_naturally_atomic(true); }
 371 
 372   // Query if this class implements jl.NonTearable or was
 373   // 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 along with NonTearable.
 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 carries_value_modifier() const { return _misc_flags.carries_value_modifier(); }
 381   void set_carries_value_modifier()   { _misc_flags.set_carries_value_modifier(true); }
 382 
 383   bool carries_identity_modifier() const  { return _misc_flags.carries_identity_modifier(); }
 384   void set_carries_identity_modifier()    { _misc_flags.set_carries_identity_modifier(true); }
 385 
 386   bool is_implicitly_constructible() const { return _misc_flags.is_implicitly_constructible(); }
 387   void set_is_implicitly_constructible()   { _misc_flags.set_is_implicitly_constructible(true); }
 388 
 389   // field sizes
 390   int nonstatic_field_size() const         { return _nonstatic_field_size; }
 391   void set_nonstatic_field_size(int size)  { _nonstatic_field_size = size; }
 392 
 393   int static_field_size() const            { return _static_field_size; }
 394   void set_static_field_size(int size)     { _static_field_size = size; }
 395 
 396   int static_oop_field_count() const       { return (int)_static_oop_field_count; }
 397   void set_static_oop_field_count(u2 size) { _static_oop_field_count = size; }
 398 
 399   // Java itable
 400   int  itable_length() const               { return _itable_len; }
 401   void set_itable_length(int len)          { _itable_len = len; }
 402 
 403   // array klasses
 404   ArrayKlass* array_klasses() const     { return _array_klasses; }
 405   inline ArrayKlass* array_klasses_acquire() const; // load with acquire semantics
 406   inline void release_set_array_klasses(ArrayKlass* k); // store with release semantics
 407   void set_array_klasses(ArrayKlass* k) { _array_klasses = k; }
 408 
 409   // methods
 410   Array<Method*>* methods() const          { return _methods; }
 411   void set_methods(Array<Method*>* a)      { _methods = a; }
 412   Method* method_with_idnum(int idnum);
 413   Method* method_with_orig_idnum(int idnum);
 414   Method* method_with_orig_idnum(int idnum, int version);
 415 
 416   // method ordering
 417   Array<int>* method_ordering() const     { return _method_ordering; }
 418   void set_method_ordering(Array<int>* m) { _method_ordering = m; }
 419   void copy_method_ordering(const intArray* m, TRAPS);
 420 
 421   // default_methods
 422   Array<Method*>* default_methods() const  { return _default_methods; }
 423   void set_default_methods(Array<Method*>* a) { _default_methods = a; }
 424 
 425   // default method vtable_indices
 426   Array<int>* default_vtable_indices() const { return _default_vtable_indices; }
 427   void set_default_vtable_indices(Array<int>* v) { _default_vtable_indices = v; }

 433     guarantee(_local_interfaces == nullptr || a == nullptr, "Just checking");
 434     _local_interfaces = a; }
 435 
 436   Array<InstanceKlass*>* transitive_interfaces() const     { return _transitive_interfaces; }
 437   void set_transitive_interfaces(Array<InstanceKlass*>* a) {
 438     guarantee(_transitive_interfaces == nullptr || a == nullptr, "Just checking");
 439     _transitive_interfaces = a;
 440   }
 441 
 442  private:
 443   friend class fieldDescriptor;
 444   FieldInfo field(int index) const;
 445 
 446  public:
 447   int     field_offset      (int index) const { return field(index).offset(); }
 448   int     field_access_flags(int index) const { return field(index).access_flags().as_int(); }
 449   FieldInfo::FieldFlags field_flags(int index) const { return field(index).field_flags(); }
 450   FieldStatus field_status(int index)   const { return fields_status()->at(index); }
 451   inline Symbol* field_name        (int index) const;
 452   inline Symbol* field_signature   (int index) const;
 453   bool    field_is_flat(int index) const { return field_flags(index).is_flat(); }
 454   bool    field_is_null_free_inline_type(int index) const;
 455 
 456   // Number of Java declared fields
 457   int java_fields_count() const;
 458   int total_fields_count() const;
 459 
 460   Array<u1>* fieldinfo_stream() const { return _fieldinfo_stream; }
 461   void set_fieldinfo_stream(Array<u1>* fis) { _fieldinfo_stream = fis; }
 462 
 463   Array<FieldStatus>* fields_status() const {return _fields_status; }
 464   void set_fields_status(Array<FieldStatus>* array) { _fields_status = array; }
 465 
 466   Array<u2>* preload_classes() const { return _preload_classes; }
 467   void set_preload_classes(Array<u2>* c) { _preload_classes = c; }
 468 
 469   // inner classes
 470   Array<u2>* inner_classes() const       { return _inner_classes; }
 471   void set_inner_classes(Array<u2>* f)   { _inner_classes = f; }
 472 
 473   // nest members
 474   Array<u2>* nest_members() const     { return _nest_members; }
 475   void set_nest_members(Array<u2>* m) { _nest_members = m; }
 476 
 477   // nest-host index
 478   jushort nest_host_index() const { return _nest_host_index; }
 479   void set_nest_host_index(u2 i)  { _nest_host_index = i; }
 480   // dynamic nest member support
 481   void set_nest_host(InstanceKlass* host);
 482 
 483   // record components
 484   Array<RecordComponent*>* record_components() const { return _record_components; }
 485   void set_record_components(Array<RecordComponent*>* record_components) {
 486     _record_components = record_components;
 487   }
 488   bool is_record() const;

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

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

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

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

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