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

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

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

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

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

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

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

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

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