53
54 // Forward declarations.
55 template <class T> class Array;
56 template <class T> class GrowableArray;
57 class ClassLoaderData;
58 class fieldDescriptor;
59 class klassVtable;
60 class ModuleEntry;
61 class PackageEntry;
62 class ParCompactionManager;
63 class PSPromotionManager;
64 class vtableEntry;
65
66 class Klass : public Metadata {
67 friend class VMStructs;
68 friend class JVMCIVMStructs;
69 public:
70 // Klass Kinds for all subclasses of Klass
71 enum KlassKind {
72 InstanceKlassKind,
73 InstanceRefKlassKind,
74 InstanceMirrorKlassKind,
75 InstanceClassLoaderKlassKind,
76 InstanceStackChunkKlassKind,
77 TypeArrayKlassKind,
78 ObjArrayKlassKind,
79 UnknownKlassKind
80 };
81
82 static const uint KLASS_KIND_COUNT = ObjArrayKlassKind + 1;
83 protected:
84
85 // If you add a new field that points to any metaspace object, you
86 // must add this field to Klass::metaspace_pointers_do().
87
88 // note: put frequently-used fields together at start of klass structure
89 // for better cache behavior (may not make much of a difference but sure won't hurt)
90 enum { _primary_super_limit = 8 };
91
92 // The "layout helper" is a combined descriptor of object layout.
93 // For klasses which are neither instance nor array, the value is zero.
94 //
95 // For instances, layout helper is a positive number, the instance size.
96 // This size is already passed through align_object_size and scaled to bytes.
97 // The low order bit is set if instances of this class cannot be
98 // allocated using the fastpath.
99 //
100 // For arrays, layout helper is a negative number, containing four
101 // distinct bytes, as follows:
102 // MSB:[tag, hsz, ebt, log2(esz)]:LSB
103 // where:
104 // tag is 0x80 if the elements are oops, 0xC0 if non-oops
105 // hsz is array header size in bytes (i.e., offset of first element)
106 // ebt is the BasicType of the elements
107 // esz is the element size in bytes
108 // This packed word is arranged so as to be quickly unpacked by the
109 // various fast paths that use the various subfields.
110 //
111 // The esz bits can be used directly by a SLL instruction, without masking.
112 //
113 // Note that the array-kind tag looks like 0x00 for instance klasses,
114 // since their length in bytes is always less than 24Mb.
115 //
116 // Final note: This comes first, immediately after C++ vtable,
117 // because it is frequently queried.
118 jint _layout_helper;
119
120 // Klass kind used to resolve the runtime type of the instance.
121 // - Used to implement devirtualized oop closure dispatching.
122 // - Various type checking in the JVM
123 const KlassKind _kind;
124
150 // First subclass (null if none); _subklass->next_sibling() is next one
151 Klass* volatile _subklass;
152 // Sibling link (or null); links all subklasses of a klass
153 Klass* volatile _next_sibling;
154
155 // All klasses loaded by a class loader are chained through these links
156 Klass* _next_link;
157
158 // The VM's representation of the ClassLoader used to load this class.
159 // Provide access the corresponding instance java.lang.ClassLoader.
160 ClassLoaderData* _class_loader_data;
161
162 int _vtable_len; // vtable length. This field may be read very often when we
163 // have lots of itable dispatches (e.g., lambdas and streams).
164 // Keep it away from the beginning of a Klass to avoid cacheline
165 // contention that may happen when a nearby object is modified.
166 AccessFlags _access_flags; // Access flags. The class/interface distinction is stored here.
167
168 JFR_ONLY(DEFINE_TRACE_ID_FIELD;)
169
170 private:
171 // This is an index into FileMapHeader::_shared_path_table[], to
172 // associate this class with the JAR file where it's loaded from during
173 // dump time. If a class is not loaded from the shared archive, this field is
174 // -1.
175 s2 _shared_class_path_index;
176
177 #if INCLUDE_CDS
178 // Various attributes for shared classes. Should be zero for a non-shared class.
179 u2 _shared_class_flags;
180 enum CDSSharedClassFlags {
181 _is_shared_class = 1 << 0, // shadows MetaspaceObj::is_shared
182 _archived_lambda_proxy_is_available = 1 << 1,
183 _has_value_based_class_annotation = 1 << 2,
184 _verified_at_dump_time = 1 << 3,
185 _has_archived_enum_objs = 1 << 4,
186 // This class was not loaded from a classfile in the module image
187 // or classpath.
188 _is_generated_shared_class = 1 << 5
189 };
392 static ByteSize secondary_supers_offset() { return byte_offset_of(Klass, _secondary_supers); }
393 static ByteSize java_mirror_offset() { return byte_offset_of(Klass, _java_mirror); }
394 static ByteSize class_loader_data_offset() { return byte_offset_of(Klass, _class_loader_data); }
395 static ByteSize modifier_flags_offset() { return byte_offset_of(Klass, _modifier_flags); }
396 static ByteSize layout_helper_offset() { return byte_offset_of(Klass, _layout_helper); }
397 static ByteSize access_flags_offset() { return byte_offset_of(Klass, _access_flags); }
398 #if INCLUDE_JVMCI
399 static ByteSize subklass_offset() { return byte_offset_of(Klass, _subklass); }
400 static ByteSize next_sibling_offset() { return byte_offset_of(Klass, _next_sibling); }
401 #endif
402
403 // Unpacking layout_helper:
404 static const int _lh_neutral_value = 0; // neutral non-array non-instance value
405 static const int _lh_instance_slow_path_bit = 0x01;
406 static const int _lh_log2_element_size_shift = BitsPerByte*0;
407 static const int _lh_log2_element_size_mask = BitsPerLong-1;
408 static const int _lh_element_type_shift = BitsPerByte*1;
409 static const int _lh_element_type_mask = right_n_bits(BitsPerByte); // shifted mask
410 static const int _lh_header_size_shift = BitsPerByte*2;
411 static const int _lh_header_size_mask = right_n_bits(BitsPerByte); // shifted mask
412 static const int _lh_array_tag_bits = 2;
413 static const int _lh_array_tag_shift = BitsPerInt - _lh_array_tag_bits;
414 static const int _lh_array_tag_obj_value = ~0x01; // 0x80000000 >> 30
415
416 static const unsigned int _lh_array_tag_type_value = 0Xffffffff; // ~0x00, // 0xC0000000 >> 30
417
418 static int layout_helper_size_in_bytes(jint lh) {
419 assert(lh > (jint)_lh_neutral_value, "must be instance");
420 return (int) lh & ~_lh_instance_slow_path_bit;
421 }
422 static bool layout_helper_needs_slow_path(jint lh) {
423 assert(lh > (jint)_lh_neutral_value, "must be instance");
424 return (lh & _lh_instance_slow_path_bit) != 0;
425 }
426 static bool layout_helper_is_instance(jint lh) {
427 return (jint)lh > (jint)_lh_neutral_value;
428 }
429 static bool layout_helper_is_array(jint lh) {
430 return (jint)lh < (jint)_lh_neutral_value;
431 }
432 static bool layout_helper_is_typeArray(jint lh) {
433 // _lh_array_tag_type_value == (lh >> _lh_array_tag_shift);
434 return (juint)lh >= (juint)(_lh_array_tag_type_value << _lh_array_tag_shift);
435 }
436 static bool layout_helper_is_objArray(jint lh) {
437 // _lh_array_tag_obj_value == (lh >> _lh_array_tag_shift);
438 return (jint)lh < (jint)(_lh_array_tag_type_value << _lh_array_tag_shift);
439 }
440 static int layout_helper_header_size(jint lh) {
441 assert(lh < (jint)_lh_neutral_value, "must be array");
442 int hsize = (lh >> _lh_header_size_shift) & _lh_header_size_mask;
443 assert(hsize > 0 && hsize < (int)sizeof(oopDesc)*3, "sanity");
444 return hsize;
445 }
446 static BasicType layout_helper_element_type(jint lh) {
447 assert(lh < (jint)_lh_neutral_value, "must be array");
448 int btvalue = (lh >> _lh_element_type_shift) & _lh_element_type_mask;
449 assert(btvalue >= T_BOOLEAN && btvalue <= T_OBJECT, "sanity");
450 return (BasicType) btvalue;
451 }
452
453 // Want a pattern to quickly diff against layout header in register
454 // find something less clever!
455 static int layout_helper_boolean_diffbit() {
456 jint zlh = array_layout_helper(T_BOOLEAN);
457 jint blh = array_layout_helper(T_BYTE);
458 assert(zlh != blh, "array layout helpers must differ");
459 int diffbit = 1;
460 while ((diffbit & (zlh ^ blh)) == 0 && (diffbit & zlh) == 0) {
461 diffbit <<= 1;
462 assert(diffbit != 0, "make sure T_BOOLEAN has a different bit than T_BYTE");
463 }
464 return diffbit;
465 }
466
467 static int layout_helper_log2_element_size(jint lh) {
468 assert(lh < (jint)_lh_neutral_value, "must be array");
469 int l2esz = (lh >> _lh_log2_element_size_shift) & _lh_log2_element_size_mask;
470 assert(l2esz <= LogBytesPerLong,
471 "sanity. l2esz: 0x%x for lh: 0x%x", (uint)l2esz, (uint)lh);
472 return l2esz;
473 }
474 static jint array_layout_helper(jint tag, int hsize, BasicType etype, int log2_esize) {
475 return (tag << _lh_array_tag_shift)
476 | (hsize << _lh_header_size_shift)
477 | ((int)etype << _lh_element_type_shift)
478 | (log2_esize << _lh_log2_element_size_shift);
479 }
480 static jint instance_layout_helper(jint size, bool slow_path_flag) {
481 return (size << LogBytesPerWord)
482 | (slow_path_flag ? _lh_instance_slow_path_bit : 0);
483 }
484 static int layout_helper_to_size_helper(jint lh) {
485 assert(lh > (jint)_lh_neutral_value, "must be instance");
486 // Note that the following expression discards _lh_instance_slow_path_bit.
487 return lh >> LogBytesPerWord;
488 }
489 // Out-of-line version computes everything based on the etype:
490 static jint array_layout_helper(BasicType etype);
491
492 // What is the maximum number of primary superclasses any klass can have?
493 static juint primary_super_limit() { return _primary_super_limit; }
494
495 // vtables
608 // Returns the name for a class (Resource allocated) as the class
609 // would appear in a signature.
610 // For arrays, this returns the name of the element with a leading '['.
611 // For classes, this returns the name with a leading 'L' and a trailing ';'
612 // and the package separators as '/'.
613 virtual const char* signature_name() const;
614
615 const char* joint_in_module_of_loader(const Klass* class2, bool include_parent_loader = false) const;
616 const char* class_in_module_of_loader(bool use_are = false, bool include_parent_loader = false) const;
617
618 // Returns "interface", "abstract class" or "class".
619 const char* external_kind() const;
620
621 // type testing operations
622 #ifdef ASSERT
623 protected:
624 virtual bool is_instance_klass_slow() const { return false; }
625 virtual bool is_array_klass_slow() const { return false; }
626 virtual bool is_objArray_klass_slow() const { return false; }
627 virtual bool is_typeArray_klass_slow() const { return false; }
628 #endif // ASSERT
629 public:
630
631 // Fast non-virtual versions
632 #ifndef ASSERT
633 #define assert_same_query(xval, xcheck) xval
634 #else
635 private:
636 static bool assert_same_query(bool xval, bool xslow) {
637 assert(xval == xslow, "slow and fast queries agree");
638 return xval;
639 }
640 public:
641 #endif
642
643 bool is_instance_klass() const { return assert_same_query(_kind <= InstanceStackChunkKlassKind, is_instance_klass_slow()); }
644 // Other is anything that is not one of the more specialized kinds of InstanceKlass.
645 bool is_other_instance_klass() const { return _kind == InstanceKlassKind; }
646 bool is_reference_instance_klass() const { return _kind == InstanceRefKlassKind; }
647 bool is_mirror_instance_klass() const { return _kind == InstanceMirrorKlassKind; }
648 bool is_class_loader_instance_klass() const { return _kind == InstanceClassLoaderKlassKind; }
649 bool is_array_klass() const { return assert_same_query( _kind >= TypeArrayKlassKind, is_array_klass_slow()); }
650 bool is_stack_chunk_instance_klass() const { return _kind == InstanceStackChunkKlassKind; }
651 bool is_objArray_klass() const { return assert_same_query( _kind == ObjArrayKlassKind, is_objArray_klass_slow()); }
652 bool is_typeArray_klass() const { return assert_same_query( _kind == TypeArrayKlassKind, is_typeArray_klass_slow()); }
653 #undef assert_same_query
654
655 // Access flags
656 AccessFlags access_flags() const { return _access_flags; }
657 void set_access_flags(AccessFlags flags) { _access_flags = flags; }
658
659 bool is_public() const { return _access_flags.is_public(); }
660 bool is_final() const { return _access_flags.is_final(); }
661 bool is_interface() const { return _access_flags.is_interface(); }
662 bool is_abstract() const { return _access_flags.is_abstract(); }
663 bool is_super() const { return _access_flags.is_super(); }
664 bool is_synthetic() const { return _access_flags.is_synthetic(); }
665 void set_is_synthetic() { _access_flags.set_is_synthetic(); }
666 bool has_finalizer() const { return _access_flags.has_finalizer(); }
667 void set_has_finalizer() { _access_flags.set_has_finalizer(); }
668 bool is_hidden() const { return access_flags().is_hidden_class(); }
669 void set_is_hidden() { _access_flags.set_is_hidden_class(); }
670 bool is_value_based() { return _access_flags.is_value_based_class(); }
671 void set_is_value_based() { _access_flags.set_is_value_based_class(); }
672
673 inline bool is_non_strong_hidden() const;
674
675 bool is_cloneable() const;
676 void set_is_cloneable();
677
678 JFR_ONLY(DEFINE_TRACE_ID_METHODS;)
679
680 virtual void metaspace_pointers_do(MetaspaceClosure* iter);
681 virtual MetaspaceObj::Type type() const { return ClassType; }
682
683 inline bool is_loader_alive() const;
684
685 void clean_subklass();
686
687 static void clean_weak_klass_links(bool unloading_occurred, bool clean_alive_klasses = true);
688 static void clean_subklass_tree() {
689 clean_weak_klass_links(/*unloading_occurred*/ true , /* clean_alive_klasses */ false);
690 }
691
692 // Return self, except for abstract classes with exactly 1
693 // implementor. Then return the 1 concrete implementation.
694 Klass *up_cast_abstract();
695
696 // klass name
697 Symbol* name() const { return _name; }
|
53
54 // Forward declarations.
55 template <class T> class Array;
56 template <class T> class GrowableArray;
57 class ClassLoaderData;
58 class fieldDescriptor;
59 class klassVtable;
60 class ModuleEntry;
61 class PackageEntry;
62 class ParCompactionManager;
63 class PSPromotionManager;
64 class vtableEntry;
65
66 class Klass : public Metadata {
67 friend class VMStructs;
68 friend class JVMCIVMStructs;
69 public:
70 // Klass Kinds for all subclasses of Klass
71 enum KlassKind {
72 InstanceKlassKind,
73 InlineKlassKind,
74 InstanceRefKlassKind,
75 InstanceMirrorKlassKind,
76 InstanceClassLoaderKlassKind,
77 InstanceStackChunkKlassKind,
78 TypeArrayKlassKind,
79 FlatArrayKlassKind,
80 ObjArrayKlassKind,
81 UnknownKlassKind
82 };
83
84 static const uint KLASS_KIND_COUNT = ObjArrayKlassKind + 1;
85 protected:
86
87 // If you add a new field that points to any metaspace object, you
88 // must add this field to Klass::metaspace_pointers_do().
89
90 // note: put frequently-used fields together at start of klass structure
91 // for better cache behavior (may not make much of a difference but sure won't hurt)
92 enum { _primary_super_limit = 8 };
93
94 // The "layout helper" is a combined descriptor of object layout.
95 // For klasses which are neither instance nor array, the value is zero.
96 //
97 // For instances, layout helper is a positive number, the instance size.
98 // This size is already passed through align_object_size and scaled to bytes.
99 // The low order bit is set if instances of this class cannot be
100 // allocated using the fastpath.
101 //
102 // For arrays, layout helper is a negative number, containing four
103 // distinct bytes, as follows:
104 // MSB:[tag, hsz, ebt, log2(esz)]:LSB
105 // where:
106 // tag is 0x80 if the elements are oops, 0xC0 if non-oops, 0xA0 if value types
107 // hsz is array header size in bytes (i.e., offset of first element)
108 // ebt is the BasicType of the elements
109 // esz is the element size in bytes
110 // This packed word is arranged so as to be quickly unpacked by the
111 // various fast paths that use the various subfields.
112 //
113 // The esz bits can be used directly by a SLL instruction, without masking.
114 //
115 // Note that the array-kind tag looks like 0x00 for instance klasses,
116 // since their length in bytes is always less than 24Mb.
117 //
118 // Final note: This comes first, immediately after C++ vtable,
119 // because it is frequently queried.
120 jint _layout_helper;
121
122 // Klass kind used to resolve the runtime type of the instance.
123 // - Used to implement devirtualized oop closure dispatching.
124 // - Various type checking in the JVM
125 const KlassKind _kind;
126
152 // First subclass (null if none); _subklass->next_sibling() is next one
153 Klass* volatile _subklass;
154 // Sibling link (or null); links all subklasses of a klass
155 Klass* volatile _next_sibling;
156
157 // All klasses loaded by a class loader are chained through these links
158 Klass* _next_link;
159
160 // The VM's representation of the ClassLoader used to load this class.
161 // Provide access the corresponding instance java.lang.ClassLoader.
162 ClassLoaderData* _class_loader_data;
163
164 int _vtable_len; // vtable length. This field may be read very often when we
165 // have lots of itable dispatches (e.g., lambdas and streams).
166 // Keep it away from the beginning of a Klass to avoid cacheline
167 // contention that may happen when a nearby object is modified.
168 AccessFlags _access_flags; // Access flags. The class/interface distinction is stored here.
169
170 JFR_ONLY(DEFINE_TRACE_ID_FIELD;)
171
172 markWord _prototype_header; // inline type and inline array mark patterns
173 private:
174 // This is an index into FileMapHeader::_shared_path_table[], to
175 // associate this class with the JAR file where it's loaded from during
176 // dump time. If a class is not loaded from the shared archive, this field is
177 // -1.
178 s2 _shared_class_path_index;
179
180 #if INCLUDE_CDS
181 // Various attributes for shared classes. Should be zero for a non-shared class.
182 u2 _shared_class_flags;
183 enum CDSSharedClassFlags {
184 _is_shared_class = 1 << 0, // shadows MetaspaceObj::is_shared
185 _archived_lambda_proxy_is_available = 1 << 1,
186 _has_value_based_class_annotation = 1 << 2,
187 _verified_at_dump_time = 1 << 3,
188 _has_archived_enum_objs = 1 << 4,
189 // This class was not loaded from a classfile in the module image
190 // or classpath.
191 _is_generated_shared_class = 1 << 5
192 };
395 static ByteSize secondary_supers_offset() { return byte_offset_of(Klass, _secondary_supers); }
396 static ByteSize java_mirror_offset() { return byte_offset_of(Klass, _java_mirror); }
397 static ByteSize class_loader_data_offset() { return byte_offset_of(Klass, _class_loader_data); }
398 static ByteSize modifier_flags_offset() { return byte_offset_of(Klass, _modifier_flags); }
399 static ByteSize layout_helper_offset() { return byte_offset_of(Klass, _layout_helper); }
400 static ByteSize access_flags_offset() { return byte_offset_of(Klass, _access_flags); }
401 #if INCLUDE_JVMCI
402 static ByteSize subklass_offset() { return byte_offset_of(Klass, _subklass); }
403 static ByteSize next_sibling_offset() { return byte_offset_of(Klass, _next_sibling); }
404 #endif
405
406 // Unpacking layout_helper:
407 static const int _lh_neutral_value = 0; // neutral non-array non-instance value
408 static const int _lh_instance_slow_path_bit = 0x01;
409 static const int _lh_log2_element_size_shift = BitsPerByte*0;
410 static const int _lh_log2_element_size_mask = BitsPerLong-1;
411 static const int _lh_element_type_shift = BitsPerByte*1;
412 static const int _lh_element_type_mask = right_n_bits(BitsPerByte); // shifted mask
413 static const int _lh_header_size_shift = BitsPerByte*2;
414 static const int _lh_header_size_mask = right_n_bits(BitsPerByte); // shifted mask
415 static const int _lh_array_tag_bits = 3;
416 static const int _lh_array_tag_shift = BitsPerInt - _lh_array_tag_bits;
417
418 static const unsigned int _lh_array_tag_type_value = 0Xfffffffc;
419 static const unsigned int _lh_array_tag_vt_value = 0Xfffffffd;
420 static const unsigned int _lh_array_tag_obj_value = 0Xfffffffe;
421
422 // null-free array flag bit under the array tag bits, shift one more to get array tag value
423 static const int _lh_null_free_shift = _lh_array_tag_shift - 1;
424 static const int _lh_null_free_mask = 1;
425
426 static const jint _lh_array_tag_flat_value_bit_inplace = (jint) (1 << _lh_array_tag_shift);
427
428 static int layout_helper_size_in_bytes(jint lh) {
429 assert(lh > (jint)_lh_neutral_value, "must be instance");
430 return (int) lh & ~_lh_instance_slow_path_bit;
431 }
432 static bool layout_helper_needs_slow_path(jint lh) {
433 assert(lh > (jint)_lh_neutral_value, "must be instance");
434 return (lh & _lh_instance_slow_path_bit) != 0;
435 }
436 static bool layout_helper_is_instance(jint lh) {
437 return (jint)lh > (jint)_lh_neutral_value;
438 }
439 static bool layout_helper_is_array(jint lh) {
440 return (jint)lh < (jint)_lh_neutral_value;
441 }
442 static bool layout_helper_is_typeArray(jint lh) {
443 return (juint) _lh_array_tag_type_value == (juint)(lh >> _lh_array_tag_shift);
444 }
445 static bool layout_helper_is_objArray(jint lh) {
446 return (juint)_lh_array_tag_obj_value == (juint)(lh >> _lh_array_tag_shift);
447 }
448 static bool layout_helper_is_flatArray(jint lh) {
449 return (juint)_lh_array_tag_vt_value == (juint)(lh >> _lh_array_tag_shift);
450 }
451 static bool layout_helper_is_null_free(jint lh) {
452 assert(layout_helper_is_flatArray(lh) || layout_helper_is_objArray(lh), "must be array of inline types");
453 return ((lh >> _lh_null_free_shift) & _lh_null_free_mask);
454 }
455 static jint layout_helper_set_null_free(jint lh) {
456 lh |= (_lh_null_free_mask << _lh_null_free_shift);
457 assert(layout_helper_is_null_free(lh), "Bad encoding");
458 return lh;
459 }
460 static int layout_helper_header_size(jint lh) {
461 assert(lh < (jint)_lh_neutral_value, "must be array");
462 int hsize = (lh >> _lh_header_size_shift) & _lh_header_size_mask;
463 assert(hsize > 0 && hsize < (int)sizeof(oopDesc)*3, "sanity");
464 return hsize;
465 }
466 static BasicType layout_helper_element_type(jint lh) {
467 assert(lh < (jint)_lh_neutral_value, "must be array");
468 int btvalue = (lh >> _lh_element_type_shift) & _lh_element_type_mask;
469 assert((btvalue >= T_BOOLEAN && btvalue <= T_OBJECT) || btvalue == T_PRIMITIVE_OBJECT, "sanity");
470 return (BasicType) btvalue;
471 }
472
473 // Want a pattern to quickly diff against layout header in register
474 // find something less clever!
475 static int layout_helper_boolean_diffbit() {
476 jint zlh = array_layout_helper(T_BOOLEAN);
477 jint blh = array_layout_helper(T_BYTE);
478 assert(zlh != blh, "array layout helpers must differ");
479 int diffbit = 1;
480 while ((diffbit & (zlh ^ blh)) == 0 && (diffbit & zlh) == 0) {
481 diffbit <<= 1;
482 assert(diffbit != 0, "make sure T_BOOLEAN has a different bit than T_BYTE");
483 }
484 return diffbit;
485 }
486
487 static int layout_helper_log2_element_size(jint lh) {
488 assert(lh < (jint)_lh_neutral_value, "must be array");
489 int l2esz = (lh >> _lh_log2_element_size_shift) & _lh_log2_element_size_mask;
490 assert(layout_helper_element_type(lh) == T_PRIMITIVE_OBJECT || l2esz <= LogBytesPerLong,
491 "sanity. l2esz: 0x%x for lh: 0x%x", (uint)l2esz, (uint)lh);
492 return l2esz;
493 }
494 static jint array_layout_helper(jint tag, bool null_free, int hsize, BasicType etype, int log2_esize) {
495 return (tag << _lh_array_tag_shift)
496 | ((null_free ? 1 : 0) << _lh_null_free_shift)
497 | (hsize << _lh_header_size_shift)
498 | ((int)etype << _lh_element_type_shift)
499 | (log2_esize << _lh_log2_element_size_shift);
500 }
501 static jint instance_layout_helper(jint size, bool slow_path_flag) {
502 return (size << LogBytesPerWord)
503 | (slow_path_flag ? _lh_instance_slow_path_bit : 0);
504 }
505 static int layout_helper_to_size_helper(jint lh) {
506 assert(lh > (jint)_lh_neutral_value, "must be instance");
507 // Note that the following expression discards _lh_instance_slow_path_bit.
508 return lh >> LogBytesPerWord;
509 }
510 // Out-of-line version computes everything based on the etype:
511 static jint array_layout_helper(BasicType etype);
512
513 // What is the maximum number of primary superclasses any klass can have?
514 static juint primary_super_limit() { return _primary_super_limit; }
515
516 // vtables
629 // Returns the name for a class (Resource allocated) as the class
630 // would appear in a signature.
631 // For arrays, this returns the name of the element with a leading '['.
632 // For classes, this returns the name with a leading 'L' and a trailing ';'
633 // and the package separators as '/'.
634 virtual const char* signature_name() const;
635
636 const char* joint_in_module_of_loader(const Klass* class2, bool include_parent_loader = false) const;
637 const char* class_in_module_of_loader(bool use_are = false, bool include_parent_loader = false) const;
638
639 // Returns "interface", "abstract class" or "class".
640 const char* external_kind() const;
641
642 // type testing operations
643 #ifdef ASSERT
644 protected:
645 virtual bool is_instance_klass_slow() const { return false; }
646 virtual bool is_array_klass_slow() const { return false; }
647 virtual bool is_objArray_klass_slow() const { return false; }
648 virtual bool is_typeArray_klass_slow() const { return false; }
649 virtual bool is_flatArray_klass_slow() const { return false; }
650 #endif // ASSERT
651 // current implementation uses this method even in non debug builds
652 virtual bool is_inline_klass_slow() const { return false; }
653 public:
654
655 // Fast non-virtual versions
656 #ifndef ASSERT
657 #define assert_same_query(xval, xcheck) xval
658 #else
659 private:
660 static bool assert_same_query(bool xval, bool xslow) {
661 assert(xval == xslow, "slow and fast queries agree");
662 return xval;
663 }
664 public:
665 #endif
666
667 bool is_instance_klass() const { return assert_same_query(_kind <= InstanceStackChunkKlassKind, is_instance_klass_slow()); }
668 bool is_inline_klass() const { return assert_same_query(_kind == InlineKlassKind, is_inline_klass_slow()); }
669 bool is_reference_instance_klass() const { return _kind == InstanceRefKlassKind; }
670 bool is_mirror_instance_klass() const { return _kind == InstanceMirrorKlassKind; }
671 bool is_class_loader_instance_klass() const { return _kind == InstanceClassLoaderKlassKind; }
672 bool is_array_klass() const { return assert_same_query( _kind >= TypeArrayKlassKind, is_array_klass_slow()); }
673 bool is_stack_chunk_instance_klass() const { return _kind == InstanceStackChunkKlassKind; }
674 bool is_flatArray_klass() const { return assert_same_query( _kind == FlatArrayKlassKind, is_flatArray_klass_slow()); }
675 bool is_objArray_klass() const { return assert_same_query( _kind == ObjArrayKlassKind, is_objArray_klass_slow()); }
676 bool is_typeArray_klass() const { return assert_same_query( _kind == TypeArrayKlassKind, is_typeArray_klass_slow()); }
677 #undef assert_same_query
678
679 inline bool is_null_free_array_klass() const { return layout_helper_is_null_free(layout_helper()); }
680
681 // Access flags
682 AccessFlags access_flags() const { return _access_flags; }
683 void set_access_flags(AccessFlags flags) { _access_flags = flags; }
684
685 bool is_public() const { return _access_flags.is_public(); }
686 bool is_final() const { return _access_flags.is_final(); }
687 bool is_interface() const { return _access_flags.is_interface(); }
688 bool is_abstract() const { return _access_flags.is_abstract(); }
689 bool is_synthetic() const { return _access_flags.is_synthetic(); }
690 bool is_identity_class() const { return _access_flags.is_identity_class(); }
691 void set_is_synthetic() { _access_flags.set_is_synthetic(); }
692 bool has_finalizer() const { return _access_flags.has_finalizer(); }
693 void set_has_finalizer() { _access_flags.set_has_finalizer(); }
694 bool is_hidden() const { return access_flags().is_hidden_class(); }
695 void set_is_hidden() { _access_flags.set_is_hidden_class(); }
696 bool is_value_based() { return _access_flags.is_value_based_class(); }
697 void set_is_value_based() { _access_flags.set_is_value_based_class(); }
698
699 inline bool is_non_strong_hidden() const;
700
701 bool is_cloneable() const;
702 void set_is_cloneable();
703
704 // inline types and inline type array patterns
705 markWord prototype_header() const {
706 return _prototype_header;
707 }
708 static inline markWord default_prototype_header(Klass* k) {
709 return (k == nullptr) ? markWord::prototype() : k->prototype_header();
710 }
711
712 inline void set_prototype_header(markWord header);
713 static ByteSize prototype_header_offset() { return in_ByteSize(offset_of(Klass, _prototype_header)); }
714
715 JFR_ONLY(DEFINE_TRACE_ID_METHODS;)
716
717 virtual void metaspace_pointers_do(MetaspaceClosure* iter);
718 virtual MetaspaceObj::Type type() const { return ClassType; }
719
720 inline bool is_loader_alive() const;
721
722 void clean_subklass();
723
724 static void clean_weak_klass_links(bool unloading_occurred, bool clean_alive_klasses = true);
725 static void clean_subklass_tree() {
726 clean_weak_klass_links(/*unloading_occurred*/ true , /* clean_alive_klasses */ false);
727 }
728
729 // Return self, except for abstract classes with exactly 1
730 // implementor. Then return the 1 concrete implementation.
731 Klass *up_cast_abstract();
732
733 // klass name
734 Symbol* name() const { return _name; }
|