< 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() { assert(DumpSharedSpaces || UseSharedSpaces, "only for CDS"); }
 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 
 351   // methods
 352   Array<Method*>* methods() const          { return _methods; }
 353   void set_methods(Array<Method*>* a)      { _methods = a; }
 354   Method* method_with_idnum(int idnum);
 355   Method* method_with_orig_idnum(int idnum);
 356   Method* method_with_orig_idnum(int idnum, int version);
 357 
 358   // method ordering
 359   Array<int>* method_ordering() const     { return _method_ordering; }
 360   void set_method_ordering(Array<int>* m) { _method_ordering = m; }
 361   void copy_method_ordering(const intArray* m, TRAPS);
 362 
 363   // default_methods
 364   Array<Method*>* default_methods() const  { return _default_methods; }
 365   void set_default_methods(Array<Method*>* a) { _default_methods = a; }
 366 
 367   // default method vtable_indices
 368   Array<int>* default_vtable_indices() const { return _default_vtable_indices; }
 369   void set_default_vtable_indices(Array<int>* v) { _default_vtable_indices = v; }

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


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



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

 517     }
 518     ~LockLinkState() {
 519       if (!_ik->is_linked()) {
 520         // Reset to loaded if linking failed.
 521         _ik->set_initialization_state_and_notify(loaded, _current);
 522       }
 523     }
 524   };
 525 
 526   // is this a sealed class
 527   bool is_sealed() const;
 528 
 529   // defineClass specified verification
 530   bool should_verify_class() const         { return _misc_flags.should_verify_class(); }
 531   void set_should_verify_class(bool value) { _misc_flags.set_should_verify_class(value); }
 532 
 533   // marking
 534   bool is_marked_dependent() const         { return _misc_flags.is_marked_dependent(); }
 535   void set_is_marked_dependent(bool value) { _misc_flags.set_is_marked_dependent(value); }
 536 



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

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



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

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

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


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


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

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






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

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

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

1106                                   const Symbol* name,
1107                                   const Symbol* signature,
1108                                   OverpassLookupMode overpass_mode,
1109                                   StaticLookupMode static_mode,
1110                                   PrivateLookupMode private_mode);
1111 
1112 #if INCLUDE_JVMTI
1113   // RedefineClasses support
1114   void link_previous_versions(InstanceKlass* pv) { _previous_versions = pv; }
1115   void mark_newly_obsolete_methods(Array<Method*>* old_methods, int emcp_method_count);
1116 #endif
1117   // log class name to classlist
1118   void log_to_classlist() const;
1119 public:
1120 
1121 #if INCLUDE_CDS
1122   // CDS support - remove and restore oops from metadata. Oops are not shared.
1123   virtual void remove_unshareable_info();
1124   void remove_unshareable_flags();
1125   virtual void remove_java_mirror();
1126   void restore_unshareable_info(ClassLoaderData* loader_data, Handle protection_domain, PackageEntry* pkg_entry, TRAPS);
1127   void init_shared_package_entry();
1128   bool can_be_verified_at_dumptime() const;
1129   bool methods_contain_jsr_bytecode() const;
1130   void compute_has_loops_flag_for_methods();
1131 #endif
1132 
1133   jint compute_modifier_flags() const;
1134 
1135 public:
1136   // JVMTI support
1137   jint jvmti_class_status() const;
1138 
1139   virtual void metaspace_pointers_do(MetaspaceClosure* iter);
1140 
1141  public:
1142   // Printing
1143   void print_on(outputStream* st) const;
1144   void print_value_on(outputStream* st) const;
1145 
1146   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() { assert(DumpSharedSpaces || UseSharedSpaces, "only for CDS"); }
 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 is_declared_atomic() const { return _misc_flags.is_declared_atomic(); }
 378   void set_is_declared_atomic()   { _misc_flags.set_is_declared_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   // field sizes
 387   int nonstatic_field_size() const         { return _nonstatic_field_size; }
 388   void set_nonstatic_field_size(int size)  { _nonstatic_field_size = size; }
 389 
 390   int static_field_size() const            { return _static_field_size; }
 391   void set_static_field_size(int size)     { _static_field_size = size; }
 392 
 393   int static_oop_field_count() const       { return (int)_static_oop_field_count; }
 394   void set_static_oop_field_count(u2 size) { _static_oop_field_count = size; }
 395 
 396   // Java itable
 397   int  itable_length() const               { return _itable_len; }
 398   void set_itable_length(int len)          { _itable_len = len; }
 399 
 400   // array klasses
 401   ArrayKlass* array_klasses() const     { return _array_klasses; }
 402   inline ArrayKlass* array_klasses_acquire() const; // load with acquire semantics
 403   inline void release_set_array_klasses(ArrayKlass* k); // store with release semantics
 404 
 405   // methods
 406   Array<Method*>* methods() const          { return _methods; }
 407   void set_methods(Array<Method*>* a)      { _methods = a; }
 408   Method* method_with_idnum(int idnum);
 409   Method* method_with_orig_idnum(int idnum);
 410   Method* method_with_orig_idnum(int idnum, int version);
 411 
 412   // method ordering
 413   Array<int>* method_ordering() const     { return _method_ordering; }
 414   void set_method_ordering(Array<int>* m) { _method_ordering = m; }
 415   void copy_method_ordering(const intArray* m, TRAPS);
 416 
 417   // default_methods
 418   Array<Method*>* default_methods() const  { return _default_methods; }
 419   void set_default_methods(Array<Method*>* a) { _default_methods = a; }
 420 
 421   // default method vtable_indices
 422   Array<int>* default_vtable_indices() const { return _default_vtable_indices; }
 423   void set_default_vtable_indices(Array<int>* v) { _default_vtable_indices = v; }

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

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

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

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

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

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