< prev index next >

src/hotspot/share/oops/instanceKlass.hpp

Print this page

   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #ifndef SHARE_OOPS_INSTANCEKLASS_HPP
  26 #define SHARE_OOPS_INSTANCEKLASS_HPP
  27 

  28 #include "memory/allocation.hpp"
  29 #include "memory/referenceType.hpp"
  30 #include "oops/annotations.hpp"
  31 #include "oops/constMethod.hpp"
  32 #include "oops/fieldInfo.hpp"
  33 #include "oops/instanceKlassFlags.hpp"
  34 #include "oops/instanceOop.hpp"
  35 #include "runtime/handles.hpp"
  36 #include "runtime/javaThread.hpp"
  37 #include "utilities/accessFlags.hpp"
  38 #include "utilities/align.hpp"
  39 #include "utilities/growableArray.hpp"
  40 #include "utilities/macros.hpp"
  41 #if INCLUDE_JFR
  42 #include "jfr/support/jfrKlassExtension.hpp"
  43 #endif
  44 
  45 class ConstantPool;
  46 class DeoptimizationScope;
  47 class klassItable;
  48 class 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 
  61 
  62 // forward declaration for class -- see below for definition
  63 #if INCLUDE_JVMTI
  64 class BreakpointInfo;
  65 #endif
  66 class ClassFileParser;
  67 class ClassFileStream;
  68 class KlassDepChange;
  69 class DependencyContext;
  70 class fieldDescriptor;
  71 class jniIdMapBase;
  72 class JNIid;
  73 class JvmtiCachedClassFieldMap;
  74 class nmethodBucket;
  75 class OopMapCache;

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

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























































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

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

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




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

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





















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






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



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

 512   bool is_initialized() const              { return init_state() == fully_initialized; }
 513   bool is_not_initialized() const          { return init_state() <  being_initialized; }
 514   bool is_being_initialized() const        { return init_state() == being_initialized; }
 515   bool is_in_error_state() const           { return init_state() == initialization_error; }
 516   bool is_reentrant_initialization(Thread *thread)  { return thread == _init_thread; }
 517   ClassState  init_state() const           { return Atomic::load_acquire(&_init_state); }
 518   const char* init_state_name() const;
 519   bool is_rewritten() const                { return _misc_flags.rewritten(); }
 520 
 521   // is this a sealed class
 522   bool is_sealed() const;
 523 
 524   // defineClass specified verification
 525   bool should_verify_class() const         { return _misc_flags.should_verify_class(); }
 526   void set_should_verify_class(bool value) { _misc_flags.set_should_verify_class(value); }
 527 
 528   // marking
 529   bool is_marked_dependent() const         { return _misc_flags.is_marked_dependent(); }
 530   void set_is_marked_dependent(bool value) { _misc_flags.set_is_marked_dependent(value); }
 531 



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

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



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

 895 
 896   static InstanceKlass* cast(Klass* k) {
 897     return const_cast<InstanceKlass*>(cast(const_cast<const Klass*>(k)));
 898   }
 899 
 900   static const InstanceKlass* cast(const Klass* k) {
 901     assert(k != nullptr, "k should not be null");
 902     assert(k->is_instance_klass(), "cast to InstanceKlass");
 903     return static_cast<const InstanceKlass*>(k);
 904   }
 905 
 906   virtual InstanceKlass* java_super() const {
 907     return (super() == nullptr) ? nullptr : cast(super());
 908   }
 909 
 910   // Sizing (in words)
 911   static int header_size()            { return sizeof(InstanceKlass)/wordSize; }
 912 
 913   static int size(int vtable_length, int itable_length,
 914                   int nonstatic_oop_map_size,
 915                   bool is_interface) {

 916     return align_metadata_size(header_size() +
 917            vtable_length +
 918            itable_length +
 919            nonstatic_oop_map_size +
 920            (is_interface ? (int)sizeof(Klass*)/wordSize : 0));

 921   }
 922 
 923   int size() const                    { return size(vtable_length(),
 924                                                itable_length(),
 925                                                nonstatic_oop_map_size(),
 926                                                is_interface());

 927   }
 928 
 929 
 930   inline intptr_t* start_of_itable() const;
 931   inline intptr_t* end_of_itable() const;
 932   inline oop static_field_base_raw();

 933 
 934   inline OopMapBlock* start_of_nonstatic_oop_maps() const;
 935   inline Klass** end_of_nonstatic_oop_maps() const;
 936 
 937   inline InstanceKlass* volatile* adr_implementor() const;
 938 


















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

 971   // instanceKlasses and the metadata they point to.
 972   void deallocate_contents(ClassLoaderData* loader_data);
 973   static void deallocate_methods(ClassLoaderData* loader_data,
 974                                  Array<Method*>* methods);
 975   void static deallocate_interfaces(ClassLoaderData* loader_data,
 976                                     const Klass* super_klass,
 977                                     Array<InstanceKlass*>* local_interfaces,
 978                                     Array<InstanceKlass*>* transitive_interfaces);
 979   void static deallocate_record_components(ClassLoaderData* loader_data,
 980                                            Array<RecordComponent*>* record_component);
 981 
 982   virtual bool on_stack() const;
 983 
 984   // callbacks for actions during class unloading
 985   static void unload_class(InstanceKlass* ik);
 986 
 987   virtual void release_C_heap_structures(bool release_sub_metadata = true);
 988 
 989   // Naming
 990   const char* signature_name() const;

 991 
 992   // Oop fields (and metadata) iterators
 993   //
 994   // The InstanceKlass iterators also visits the Object's klass.
 995 
 996   // Forward iteration
 997  public:
 998   // Iterate over all oop fields in the oop maps.
 999   template <typename T, class OopClosureType>
1000   inline void oop_oop_iterate_oop_maps(oop obj, OopClosureType* closure);
1001 
1002   // Iterate over all oop fields and metadata.
1003   template <typename T, class OopClosureType>
1004   inline void oop_oop_iterate(oop obj, OopClosureType* closure);
1005 
1006   // Iterate over all oop fields in one oop map.
1007   template <typename T, class OopClosureType>
1008   inline void oop_oop_iterate_oop_map(OopMapBlock* map, oop obj, OopClosureType* closure);
1009 
1010 

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

   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #ifndef SHARE_OOPS_INSTANCEKLASS_HPP
  26 #define SHARE_OOPS_INSTANCEKLASS_HPP
  27 
  28 #include "code/vmreg.hpp"
  29 #include "memory/allocation.hpp"
  30 #include "memory/referenceType.hpp"
  31 #include "oops/annotations.hpp"
  32 #include "oops/constMethod.hpp"
  33 #include "oops/fieldInfo.hpp"
  34 #include "oops/instanceKlassFlags.hpp"
  35 #include "oops/instanceOop.hpp"
  36 #include "runtime/handles.hpp"
  37 #include "runtime/javaThread.hpp"
  38 #include "utilities/accessFlags.hpp"
  39 #include "utilities/align.hpp"
  40 #include "utilities/growableArray.hpp"
  41 #include "utilities/macros.hpp"
  42 #if INCLUDE_JFR
  43 #include "jfr/support/jfrKlassExtension.hpp"
  44 #endif
  45 
  46 class ConstantPool;
  47 class DeoptimizationScope;
  48 class klassItable;
  49 class Monitor;
  50 class RecordComponent;
  51 
  52 // An InstanceKlass is the VM level representation of a Java class.
  53 // It contains all information needed for at class at execution runtime.
  54 
  55 //  InstanceKlass embedded field layout (after declared fields):
  56 //    [EMBEDDED Java vtable             ] size in words = vtable_len
  57 //    [EMBEDDED nonstatic oop-map blocks] size in words = nonstatic_oop_map_size
  58 //      The embedded nonstatic oop-map blocks are short pairs (offset, length)
  59 //      indicating where oops are located in instances of this klass.
  60 //    [EMBEDDED implementor of the interface] only exist for interface
  61 //    [EMBEDDED InlineKlassFixedBlock] only if is an InlineKlass instance
  62 
  63 
  64 // forward declaration for class -- see below for definition
  65 #if INCLUDE_JVMTI
  66 class BreakpointInfo;
  67 #endif
  68 class ClassFileParser;
  69 class ClassFileStream;
  70 class KlassDepChange;
  71 class DependencyContext;
  72 class fieldDescriptor;
  73 class 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   int* _null_reset_value_offset;
 149   ArrayKlass** _null_free_inline_array_klasses;
 150   int _first_field_offset;
 151   int _payload_size_in_bytes;   // size of payload layout
 152   int _payload_alignment;       // alignment required for payload
 153   int _non_atomic_size_in_bytes; // size of null-free non-atomic flat layout
 154   int _non_atomic_alignment;    // alignment requirement for null-free non-atomic layout
 155   int _atomic_size_in_bytes;    // size and alignment requirement for a null-free atomic layout, -1 if no atomic flat layout is possible
 156   int _nullable_size_in_bytes;  // size and alignment requirement for a nullable layout (always atomic), -1 if no nullable flat layout is possible
 157   int _null_marker_offset;
 158 
 159   friend class InlineKlass;
 160 };
 161 
 162 class InlineLayoutInfo : public MetaspaceObj {
 163   InlineKlass* _klass;
 164   LayoutKind _kind;
 165   int _null_marker_offset; // null marker offset for this field, relative to the beginning of the current container
 166 
 167  public:
 168   InlineLayoutInfo(): _klass(nullptr), _kind(LayoutKind::UNKNOWN), _null_marker_offset(-1)  {}
 169   InlineLayoutInfo(InlineKlass* ik, LayoutKind kind, int size, int nm_offset):
 170     _klass(ik), _kind(kind), _null_marker_offset(nm_offset) {}
 171 
 172   InlineKlass* klass() const { return _klass; }
 173   void set_klass(InlineKlass* k) { _klass = k; }
 174 
 175   LayoutKind kind() const {
 176     assert(_kind != LayoutKind::UNKNOWN, "Not set");
 177     return _kind;
 178   }
 179   void set_kind(LayoutKind lk) { _kind = lk; }
 180 
 181   int null_marker_offset() const {
 182     assert(_null_marker_offset != -1, "Not set");
 183     return _null_marker_offset;
 184   }
 185   void set_null_marker_offset(int o) { _null_marker_offset = o; }
 186 
 187   void metaspace_pointers_do(MetaspaceClosure* it);
 188   MetaspaceObj::Type type() const { return InlineLayoutInfoType; }
 189 
 190   static ByteSize klass_offset() { return in_ByteSize(offset_of(InlineLayoutInfo, _klass)); }
 191   static ByteSize null_marker_offset_offset() { return in_ByteSize(offset_of(InlineLayoutInfo, _null_marker_offset)); }
 192 };
 193 
 194 class InstanceKlass: public Klass {
 195   friend class VMStructs;
 196   friend class JVMCIVMStructs;
 197   friend class ClassFileParser;
 198   friend class CompileReplay;
 199   friend class TemplateTable;
 200 
 201  public:
 202   static const KlassKind Kind = InstanceKlassKind;
 203 
 204  protected:
 205   InstanceKlass(const ClassFileParser& parser, KlassKind kind = Kind, ReferenceType reference_type = REF_NONE);
 206 
 207   void* operator new(size_t size, ClassLoaderData* loader_data, size_t word_size, bool use_class_space, TRAPS) throw();
 208 
 209  public:
 210   InstanceKlass();
 211 
 212   // See "The Java Virtual Machine Specification" section 2.16.2-5 for a detailed description
 213   // of the class loading & initialization procedure, and the use of the states.
 214   enum ClassState : u1 {
 215     allocated,                          // allocated (but not yet linked)
 216     loaded,                             // loaded and inserted in class hierarchy (but not linked yet)
 217     linked,                             // successfully linked/verified (but not initialized yet)
 218     being_initialized,                  // currently running class initializer
 219     fully_initialized,                  // initialized (successful final state)
 220     initialization_error                // error happened during initialization
 221   };
 222 
 223  private:
 224   static InstanceKlass* allocate_instance_klass(const ClassFileParser& parser, TRAPS);
 225 
 226  protected:
 227   // If you add a new field that points to any metaspace object, you
 228   // must add this field to InstanceKlass::metaspace_pointers_do().
 229 
 230   // Annotations for this class
 231   Annotations*    _annotations;
 232   // Package this class is defined in
 233   PackageEntry*   _package_entry;
 234   // Array classes holding elements of this class.
 235   ArrayKlass* volatile _array_klasses;
 236   // Constant pool for this class.
 237   ConstantPool* _constants;
 238   // The InnerClasses attribute and EnclosingMethod attribute. The
 239   // _inner_classes is an array of shorts. If the class has InnerClasses
 240   // attribute, then the _inner_classes array begins with 4-tuples of shorts
 241   // [inner_class_info_index, outer_class_info_index,
 242   // inner_name_index, inner_class_access_flags] for the InnerClasses
 243   // attribute. If the EnclosingMethod attribute exists, it occupies the
 244   // last two shorts [class_index, method_index] of the array. If only
 245   // the InnerClasses attribute exists, the _inner_classes array length is
 246   // number_of_inner_classes * 4. If the class has both InnerClasses
 247   // and EnclosingMethod attributes the _inner_classes array length is
 248   // number_of_inner_classes * 4 + enclosing_method_attribute_size.
 249   Array<jushort>* _inner_classes;
 250 
 251   // The NestMembers attribute. An array of shorts, where each is a
 252   // class info index for the class that is a nest member. This data
 253   // has not been validated.
 254   Array<jushort>* _nest_members;
 255 

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

 379   bool is_shared_unregistered_class() const { return _misc_flags.is_shared_unregistered_class(); }
 380 
 381   // Check if the class can be shared in CDS
 382   bool is_shareable() const;
 383 
 384   bool shared_loading_failed() const { return _misc_flags.shared_loading_failed(); }
 385 
 386   void set_shared_loading_failed() { _misc_flags.set_shared_loading_failed(true); }
 387 
 388 #if INCLUDE_CDS
 389   void set_shared_class_loader_type(s2 loader_type) { _misc_flags.set_shared_class_loader_type(loader_type); }
 390   void assign_class_loader_type() { _misc_flags.assign_class_loader_type(_class_loader_data); }
 391 #endif
 392 
 393   bool has_nonstatic_fields() const        { return _misc_flags.has_nonstatic_fields(); }
 394   void set_has_nonstatic_fields(bool b)    { _misc_flags.set_has_nonstatic_fields(b); }
 395 
 396   bool has_localvariable_table() const     { return _misc_flags.has_localvariable_table(); }
 397   void set_has_localvariable_table(bool b) { _misc_flags.set_has_localvariable_table(b); }
 398 
 399   bool has_inline_type_fields() const { return _misc_flags.has_inline_type_fields(); }
 400   void set_has_inline_type_fields()   { _misc_flags.set_has_inline_type_fields(true); }
 401 
 402   bool is_naturally_atomic() const  { return _misc_flags.is_naturally_atomic(); }
 403   void set_is_naturally_atomic()    { _misc_flags.set_is_naturally_atomic(true); }
 404 
 405   // Query if this class has atomicity requirements (default is yes)
 406   // This bit can occur anywhere, but is only significant
 407   // for inline classes *and* their super types.
 408   // It inherits from supers.
 409   // Its value depends on the ForceNonTearable VM option, the LooselyConsistentValue annotation
 410   // and the presence of flat fields with atomicity requirements
 411   bool must_be_atomic() const { return _misc_flags.must_be_atomic(); }
 412   void set_must_be_atomic()   { _misc_flags.set_must_be_atomic(true); }
 413 
 414   // Query if this class can be implicitly constructed, meaning the VM is allowed
 415   // to create instances without calling a constructor
 416   // Applies to inline classes and their super types
 417   bool is_implicitly_constructible() const { return _misc_flags.is_implicitly_constructible(); }
 418   void set_is_implicitly_constructible()   { _misc_flags.set_is_implicitly_constructible(true); }
 419 
 420   // field sizes
 421   int nonstatic_field_size() const         { return _nonstatic_field_size; }
 422   void set_nonstatic_field_size(int size)  { _nonstatic_field_size = size; }
 423 
 424   int static_field_size() const            { return _static_field_size; }
 425   void set_static_field_size(int size)     { _static_field_size = size; }
 426 
 427   int static_oop_field_count() const       { return (int)_static_oop_field_count; }
 428   void set_static_oop_field_count(u2 size) { _static_oop_field_count = size; }
 429 
 430   // Java itable
 431   int  itable_length() const               { return _itable_len; }
 432   void set_itable_length(int len)          { _itable_len = len; }
 433 
 434   // array klasses
 435   ArrayKlass* array_klasses() const     { return _array_klasses; }
 436   inline ArrayKlass* array_klasses_acquire() const; // load with acquire semantics
 437   inline void release_set_array_klasses(ArrayKlass* k); // store with release semantics
 438   void set_array_klasses(ArrayKlass* k) { _array_klasses = k; }
 439 
 440   // methods
 441   Array<Method*>* methods() const          { return _methods; }
 442   void set_methods(Array<Method*>* a)      { _methods = a; }
 443   Method* method_with_idnum(int idnum);
 444   Method* method_with_orig_idnum(int idnum);
 445   Method* method_with_orig_idnum(int idnum, int version);
 446 
 447   // method ordering
 448   Array<int>* method_ordering() const     { return _method_ordering; }
 449   void set_method_ordering(Array<int>* m) { _method_ordering = m; }
 450   void copy_method_ordering(const intArray* m, TRAPS);
 451 
 452   // default_methods
 453   Array<Method*>* default_methods() const  { return _default_methods; }
 454   void set_default_methods(Array<Method*>* a) { _default_methods = a; }
 455 
 456   // default method vtable_indices
 457   Array<int>* default_vtable_indices() const { return _default_vtable_indices; }
 458   void set_default_vtable_indices(Array<int>* v) { _default_vtable_indices = v; }
 459   Array<int>* create_new_default_vtable_indices(int len, TRAPS);
 460 
 461   // interfaces
 462   Array<InstanceKlass*>* local_interfaces() const          { return _local_interfaces; }
 463   void set_local_interfaces(Array<InstanceKlass*>* a)      {
 464     guarantee(_local_interfaces == nullptr || a == nullptr, "Just checking");
 465     _local_interfaces = a; }
 466 
 467   Array<InstanceKlass*>* transitive_interfaces() const     { return _transitive_interfaces; }
 468   void set_transitive_interfaces(Array<InstanceKlass*>* a) {
 469     guarantee(_transitive_interfaces == nullptr || a == nullptr, "Just checking");
 470     _transitive_interfaces = a;
 471   }
 472 
 473  private:
 474   friend class fieldDescriptor;
 475   FieldInfo field(int index) const;
 476 
 477  public:
 478   int field_offset      (int index) const { return field(index).offset(); }
 479   int field_access_flags(int index) const { return field(index).access_flags().as_int(); }
 480   FieldInfo::FieldFlags field_flags(int index) const { return field(index).field_flags(); }
 481   FieldStatus field_status(int index)   const { return fields_status()->at(index); }
 482   inline Symbol* field_name        (int index) const;
 483   inline Symbol* field_signature   (int index) const;
 484   bool field_is_flat(int index) const { return field_flags(index).is_flat(); }
 485   bool field_has_null_marker(int index) const { return field_flags(index).has_null_marker(); }
 486   bool field_is_null_free_inline_type(int index) const;
 487   bool is_class_in_loadable_descriptors_attribute(Symbol* name) const;
 488 
 489   int null_marker_offset(int index) const { return inline_layout_info(index).null_marker_offset(); }
 490 
 491   // Number of Java declared fields
 492   int java_fields_count() const;
 493   int total_fields_count() const;
 494 
 495   Array<u1>* fieldinfo_stream() const { return _fieldinfo_stream; }
 496   void set_fieldinfo_stream(Array<u1>* fis) { _fieldinfo_stream = fis; }
 497 
 498   Array<FieldStatus>* fields_status() const {return _fields_status; }
 499   void set_fields_status(Array<FieldStatus>* array) { _fields_status = array; }
 500 
 501   Array<u2>* loadable_descriptors() const { return _loadable_descriptors; }
 502   void set_loadable_descriptors(Array<u2>* c) { _loadable_descriptors = c; }
 503 
 504   // inner classes
 505   Array<u2>* inner_classes() const       { return _inner_classes; }
 506   void set_inner_classes(Array<u2>* f)   { _inner_classes = f; }
 507 
 508   // nest members
 509   Array<u2>* nest_members() const     { return _nest_members; }
 510   void set_nest_members(Array<u2>* m) { _nest_members = m; }
 511 
 512   // nest-host index
 513   jushort nest_host_index() const { return _nest_host_index; }
 514   void set_nest_host_index(u2 i)  { _nest_host_index = i; }
 515   // dynamic nest member support
 516   void set_nest_host(InstanceKlass* host);
 517 
 518   // record components
 519   Array<RecordComponent*>* record_components() const { return _record_components; }
 520   void set_record_components(Array<RecordComponent*>* record_components) {
 521     _record_components = record_components;
 522   }
 523   bool is_record() const;

 605   bool is_initialized() const              { return init_state() == fully_initialized; }
 606   bool is_not_initialized() const          { return init_state() <  being_initialized; }
 607   bool is_being_initialized() const        { return init_state() == being_initialized; }
 608   bool is_in_error_state() const           { return init_state() == initialization_error; }
 609   bool is_reentrant_initialization(Thread *thread)  { return thread == _init_thread; }
 610   ClassState  init_state() const           { return Atomic::load_acquire(&_init_state); }
 611   const char* init_state_name() const;
 612   bool is_rewritten() const                { return _misc_flags.rewritten(); }
 613 
 614   // is this a sealed class
 615   bool is_sealed() const;
 616 
 617   // defineClass specified verification
 618   bool should_verify_class() const         { return _misc_flags.should_verify_class(); }
 619   void set_should_verify_class(bool value) { _misc_flags.set_should_verify_class(value); }
 620 
 621   // marking
 622   bool is_marked_dependent() const         { return _misc_flags.is_marked_dependent(); }
 623   void set_is_marked_dependent(bool value) { _misc_flags.set_is_marked_dependent(value); }
 624 
 625   static ByteSize kind_offset() { return in_ByteSize(offset_of(InstanceKlass, _kind)); }
 626   static ByteSize misc_flags_offset() { return in_ByteSize(offset_of(InstanceKlass, _misc_flags)); }
 627 
 628   // initialization (virtuals from Klass)
 629   bool should_be_initialized() const;  // means that initialize should be called
 630   void initialize(TRAPS);
 631   void link_class(TRAPS);
 632   bool link_class_or_fail(TRAPS); // returns false on failure
 633   void rewrite_class(TRAPS);
 634   void link_methods(TRAPS);
 635   Method* class_initializer() const;
 636 
 637   // reference type
 638   ReferenceType reference_type() const     { return (ReferenceType)_reference_type; }
 639 
 640   // this class cp index
 641   u2 this_class_index() const             { return _this_class_index; }
 642   void set_this_class_index(u2 index)     { _this_class_index = index; }
 643 
 644   static ByteSize reference_type_offset() { return byte_offset_of(InstanceKlass, _reference_type); }
 645 
 646   // find local field, returns true if found
 647   bool find_local_field(Symbol* name, Symbol* sig, fieldDescriptor* fd) const;

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

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

1092   // instanceKlasses and the metadata they point to.
1093   void deallocate_contents(ClassLoaderData* loader_data);
1094   static void deallocate_methods(ClassLoaderData* loader_data,
1095                                  Array<Method*>* methods);
1096   void static deallocate_interfaces(ClassLoaderData* loader_data,
1097                                     const Klass* super_klass,
1098                                     Array<InstanceKlass*>* local_interfaces,
1099                                     Array<InstanceKlass*>* transitive_interfaces);
1100   void static deallocate_record_components(ClassLoaderData* loader_data,
1101                                            Array<RecordComponent*>* record_component);
1102 
1103   virtual bool on_stack() const;
1104 
1105   // callbacks for actions during class unloading
1106   static void unload_class(InstanceKlass* ik);
1107 
1108   virtual void release_C_heap_structures(bool release_sub_metadata = true);
1109 
1110   // Naming
1111   const char* signature_name() const;
1112   const char* signature_name_of_carrier(char c) const;
1113 
1114   // Oop fields (and metadata) iterators
1115   //
1116   // The InstanceKlass iterators also visits the Object's klass.
1117 
1118   // Forward iteration
1119  public:
1120   // Iterate over all oop fields in the oop maps.
1121   template <typename T, class OopClosureType>
1122   inline void oop_oop_iterate_oop_maps(oop obj, OopClosureType* closure);
1123 
1124   // Iterate over all oop fields and metadata.
1125   template <typename T, class OopClosureType>
1126   inline void oop_oop_iterate(oop obj, OopClosureType* closure);
1127 
1128   // Iterate over all oop fields in one oop map.
1129   template <typename T, class OopClosureType>
1130   inline void oop_oop_iterate_oop_map(OopMapBlock* map, oop obj, OopClosureType* closure);
1131 
1132 

1218                                   const Symbol* name,
1219                                   const Symbol* signature,
1220                                   OverpassLookupMode overpass_mode,
1221                                   StaticLookupMode static_mode,
1222                                   PrivateLookupMode private_mode);
1223 
1224 #if INCLUDE_JVMTI
1225   // RedefineClasses support
1226   void link_previous_versions(InstanceKlass* pv) { _previous_versions = pv; }
1227   void mark_newly_obsolete_methods(Array<Method*>* old_methods, int emcp_method_count);
1228 #endif
1229   // log class name to classlist
1230   void log_to_classlist() const;
1231 public:
1232 
1233 #if INCLUDE_CDS
1234   // CDS support - remove and restore oops from metadata. Oops are not shared.
1235   virtual void remove_unshareable_info();
1236   void remove_unshareable_flags();
1237   virtual void remove_java_mirror();
1238   virtual void restore_unshareable_info(ClassLoaderData* loader_data, Handle protection_domain, PackageEntry* pkg_entry, TRAPS);
1239   void init_shared_package_entry();
1240   bool can_be_verified_at_dumptime() const;
1241   void compute_has_loops_flag_for_methods();
1242 #endif
1243 
1244   jint compute_modifier_flags() const;
1245 
1246 public:
1247   // JVMTI support
1248   jint jvmti_class_status() const;
1249 
1250   virtual void metaspace_pointers_do(MetaspaceClosure* iter);
1251 
1252  public:
1253   // Printing
1254   void print_on(outputStream* st) const;
1255   void print_value_on(outputStream* st) const;
1256 
1257   void oop_print_value_on(oop obj, outputStream* st);
1258 
< prev index next >