27
28 #include "memory/iterator.hpp"
29 #include "memory/memRegion.hpp"
30 #include "oops/markWord.hpp"
31 #include "oops/metadata.hpp"
32 #include "oops/oop.hpp"
33 #include "oops/oopHandle.hpp"
34 #include "utilities/accessFlags.hpp"
35 #include "utilities/macros.hpp"
36 #if INCLUDE_JFR
37 #include "jfr/support/jfrTraceIdExtension.hpp"
38 #endif
39
40 // Klass IDs for all subclasses of Klass
41 enum KlassID {
42 InstanceKlassID,
43 InstanceRefKlassID,
44 InstanceMirrorKlassID,
45 InstanceClassLoaderKlassID,
46 TypeArrayKlassID,
47 ObjArrayKlassID
48 };
49
50 const uint KLASS_ID_COUNT = 6;
51
52 //
53 // A Klass provides:
54 // 1: language level class object (method dictionary etc.)
55 // 2: provide vm dispatch behavior for the object
56 // Both functions are combined into one C++ class.
57
58 // One reason for the oop/klass dichotomy in the implementation is
59 // that we don't want a C++ vtbl pointer in every object. Thus,
60 // normal oops don't have any virtual functions. Instead, they
61 // forward all "virtual" functions to their klass, which does have
62 // a vtbl and does the C++ dispatch depending on the object's
63 // actual type. (See oop.inline.hpp for some of the forwarding code.)
64 // ALL FUNCTIONS IMPLEMENTING THIS DISPATCH ARE PREFIXED WITH "oop_"!
65
66 // Forward declarations.
67 template <class T> class Array;
68 template <class T> class GrowableArray;
69 class ClassLoaderData;
70 class fieldDescriptor;
81 protected:
82 // If you add a new field that points to any metaspace object, you
83 // must add this field to Klass::metaspace_pointers_do().
84
85 // note: put frequently-used fields together at start of klass structure
86 // for better cache behavior (may not make much of a difference but sure won't hurt)
87 enum { _primary_super_limit = 8 };
88
89 // The "layout helper" is a combined descriptor of object layout.
90 // For klasses which are neither instance nor array, the value is zero.
91 //
92 // For instances, layout helper is a positive number, the instance size.
93 // This size is already passed through align_object_size and scaled to bytes.
94 // The low order bit is set if instances of this class cannot be
95 // allocated using the fastpath.
96 //
97 // For arrays, layout helper is a negative number, containing four
98 // distinct bytes, as follows:
99 // MSB:[tag, hsz, ebt, log2(esz)]:LSB
100 // where:
101 // tag is 0x80 if the elements are oops, 0xC0 if non-oops
102 // hsz is array header size in bytes (i.e., offset of first element)
103 // ebt is the BasicType of the elements
104 // esz is the element size in bytes
105 // This packed word is arranged so as to be quickly unpacked by the
106 // various fast paths that use the various subfields.
107 //
108 // The esz bits can be used directly by a SLL instruction, without masking.
109 //
110 // Note that the array-kind tag looks like 0x00 for instance klasses,
111 // since their length in bytes is always less than 24Mb.
112 //
113 // Final note: This comes first, immediately after C++ vtable,
114 // because it is frequently queried.
115 jint _layout_helper;
116
117 // Klass identifier used to implement devirtualized oop closure dispatching.
118 const KlassID _id;
119
120 // vtable length
121 int _vtable_len;
142 OopHandle _java_mirror;
143 // Superclass
144 Klass* _super;
145 // First subclass (NULL if none); _subklass->next_sibling() is next one
146 Klass* volatile _subklass;
147 // Sibling link (or NULL); links all subklasses of a klass
148 Klass* volatile _next_sibling;
149
150 // All klasses loaded by a class loader are chained through these links
151 Klass* _next_link;
152
153 // The VM's representation of the ClassLoader used to load this class.
154 // Provide access the corresponding instance java.lang.ClassLoader.
155 ClassLoaderData* _class_loader_data;
156
157 jint _modifier_flags; // Processed access flags, for use by Class.getModifiers.
158 AccessFlags _access_flags; // Access flags. The class/interface distinction is stored here.
159
160 JFR_ONLY(DEFINE_TRACE_ID_FIELD;)
161
162 private:
163 // This is an index into FileMapHeader::_shared_path_table[], to
164 // associate this class with the JAR file where it's loaded from during
165 // dump time. If a class is not loaded from the shared archive, this field is
166 // -1.
167 jshort _shared_class_path_index;
168
169 #if INCLUDE_CDS
170 // Flags of the current shared class.
171 u2 _shared_class_flags;
172 enum {
173 _archived_lambda_proxy_is_available = 2,
174 _has_value_based_class_annotation = 4,
175 _verified_at_dump_time = 8
176 };
177 #endif
178
179 CDS_JAVA_HEAP_ONLY(int _archived_mirror_index;)
180
181 protected:
351 static ByteSize super_offset() { return in_ByteSize(offset_of(Klass, _super)); }
352 static ByteSize super_check_offset_offset() { return in_ByteSize(offset_of(Klass, _super_check_offset)); }
353 static ByteSize primary_supers_offset() { return in_ByteSize(offset_of(Klass, _primary_supers)); }
354 static ByteSize secondary_super_cache_offset() { return in_ByteSize(offset_of(Klass, _secondary_super_cache)); }
355 static ByteSize secondary_supers_offset() { return in_ByteSize(offset_of(Klass, _secondary_supers)); }
356 static ByteSize java_mirror_offset() { return in_ByteSize(offset_of(Klass, _java_mirror)); }
357 static ByteSize class_loader_data_offset() { return in_ByteSize(offset_of(Klass, _class_loader_data)); }
358 static ByteSize modifier_flags_offset() { return in_ByteSize(offset_of(Klass, _modifier_flags)); }
359 static ByteSize layout_helper_offset() { return in_ByteSize(offset_of(Klass, _layout_helper)); }
360 static ByteSize access_flags_offset() { return in_ByteSize(offset_of(Klass, _access_flags)); }
361
362 // Unpacking layout_helper:
363 static const int _lh_neutral_value = 0; // neutral non-array non-instance value
364 static const int _lh_instance_slow_path_bit = 0x01;
365 static const int _lh_log2_element_size_shift = BitsPerByte*0;
366 static const int _lh_log2_element_size_mask = BitsPerLong-1;
367 static const int _lh_element_type_shift = BitsPerByte*1;
368 static const int _lh_element_type_mask = right_n_bits(BitsPerByte); // shifted mask
369 static const int _lh_header_size_shift = BitsPerByte*2;
370 static const int _lh_header_size_mask = right_n_bits(BitsPerByte); // shifted mask
371 static const int _lh_array_tag_bits = 2;
372 static const int _lh_array_tag_shift = BitsPerInt - _lh_array_tag_bits;
373 static const int _lh_array_tag_obj_value = ~0x01; // 0x80000000 >> 30
374
375 static const unsigned int _lh_array_tag_type_value = 0Xffffffff; // ~0x00, // 0xC0000000 >> 30
376
377 static int layout_helper_size_in_bytes(jint lh) {
378 assert(lh > (jint)_lh_neutral_value, "must be instance");
379 return (int) lh & ~_lh_instance_slow_path_bit;
380 }
381 static bool layout_helper_needs_slow_path(jint lh) {
382 assert(lh > (jint)_lh_neutral_value, "must be instance");
383 return (lh & _lh_instance_slow_path_bit) != 0;
384 }
385 static bool layout_helper_is_instance(jint lh) {
386 return (jint)lh > (jint)_lh_neutral_value;
387 }
388 static bool layout_helper_is_array(jint lh) {
389 return (jint)lh < (jint)_lh_neutral_value;
390 }
391 static bool layout_helper_is_typeArray(jint lh) {
392 // _lh_array_tag_type_value == (lh >> _lh_array_tag_shift);
393 return (juint)lh >= (juint)(_lh_array_tag_type_value << _lh_array_tag_shift);
394 }
395 static bool layout_helper_is_objArray(jint lh) {
396 // _lh_array_tag_obj_value == (lh >> _lh_array_tag_shift);
397 return (jint)lh < (jint)(_lh_array_tag_type_value << _lh_array_tag_shift);
398 }
399 static int layout_helper_header_size(jint lh) {
400 assert(lh < (jint)_lh_neutral_value, "must be array");
401 int hsize = (lh >> _lh_header_size_shift) & _lh_header_size_mask;
402 assert(hsize > 0 && hsize < (int)sizeof(oopDesc)*3, "sanity");
403 return hsize;
404 }
405 static BasicType layout_helper_element_type(jint lh) {
406 assert(lh < (jint)_lh_neutral_value, "must be array");
407 int btvalue = (lh >> _lh_element_type_shift) & _lh_element_type_mask;
408 assert(btvalue >= T_BOOLEAN && btvalue <= T_OBJECT, "sanity");
409 return (BasicType) btvalue;
410 }
411
412 // Want a pattern to quickly diff against layout header in register
413 // find something less clever!
414 static int layout_helper_boolean_diffbit() {
415 jint zlh = array_layout_helper(T_BOOLEAN);
416 jint blh = array_layout_helper(T_BYTE);
417 assert(zlh != blh, "array layout helpers must differ");
418 int diffbit = 1;
419 while ((diffbit & (zlh ^ blh)) == 0 && (diffbit & zlh) == 0) {
420 diffbit <<= 1;
421 assert(diffbit != 0, "make sure T_BOOLEAN has a different bit than T_BYTE");
422 }
423 return diffbit;
424 }
425
426 static int layout_helper_log2_element_size(jint lh) {
427 assert(lh < (jint)_lh_neutral_value, "must be array");
428 int l2esz = (lh >> _lh_log2_element_size_shift) & _lh_log2_element_size_mask;
429 assert(l2esz <= LogBytesPerLong,
430 "sanity. l2esz: 0x%x for lh: 0x%x", (uint)l2esz, (uint)lh);
431 return l2esz;
432 }
433 static jint array_layout_helper(jint tag, int hsize, BasicType etype, int log2_esize) {
434 return (tag << _lh_array_tag_shift)
435 | (hsize << _lh_header_size_shift)
436 | ((int)etype << _lh_element_type_shift)
437 | (log2_esize << _lh_log2_element_size_shift);
438 }
439 static jint instance_layout_helper(jint size, bool slow_path_flag) {
440 return (size << LogBytesPerWord)
441 | (slow_path_flag ? _lh_instance_slow_path_bit : 0);
442 }
443 static int layout_helper_to_size_helper(jint lh) {
444 assert(lh > (jint)_lh_neutral_value, "must be instance");
445 // Note that the following expression discards _lh_instance_slow_path_bit.
446 return lh >> LogBytesPerWord;
447 }
448 // Out-of-line version computes everything based on the etype:
449 static jint array_layout_helper(BasicType etype);
450
451 // What is the maximum number of primary superclasses any klass can have?
452 static juint primary_super_limit() { return _primary_super_limit; }
453
454 // vtables
563 // Returns the name for a class (Resource allocated) as the class
564 // would appear in a signature.
565 // For arrays, this returns the name of the element with a leading '['.
566 // For classes, this returns the name with a leading 'L' and a trailing ';'
567 // and the package separators as '/'.
568 virtual const char* signature_name() const;
569
570 const char* joint_in_module_of_loader(const Klass* class2, bool include_parent_loader = false) const;
571 const char* class_in_module_of_loader(bool use_are = false, bool include_parent_loader = false) const;
572
573 // Returns "interface", "abstract class" or "class".
574 const char* external_kind() const;
575
576 // type testing operations
577 #ifdef ASSERT
578 protected:
579 virtual bool is_instance_klass_slow() const { return false; }
580 virtual bool is_array_klass_slow() const { return false; }
581 virtual bool is_objArray_klass_slow() const { return false; }
582 virtual bool is_typeArray_klass_slow() const { return false; }
583 #endif // ASSERT
584 public:
585
586 // Fast non-virtual versions
587 #ifndef ASSERT
588 #define assert_same_query(xval, xcheck) xval
589 #else
590 private:
591 static bool assert_same_query(bool xval, bool xslow) {
592 assert(xval == xslow, "slow and fast queries agree");
593 return xval;
594 }
595 public:
596 #endif
597 inline bool is_instance_klass() const { return assert_same_query(
598 layout_helper_is_instance(layout_helper()),
599 is_instance_klass_slow()); }
600 inline bool is_array_klass() const { return assert_same_query(
601 layout_helper_is_array(layout_helper()),
602 is_array_klass_slow()); }
603 inline bool is_objArray_klass() const { return assert_same_query(
604 layout_helper_is_objArray(layout_helper()),
605 is_objArray_klass_slow()); }
606 inline bool is_typeArray_klass() const { return assert_same_query(
607 layout_helper_is_typeArray(layout_helper()),
608 is_typeArray_klass_slow()); }
609 #undef assert_same_query
610
611 // Access flags
612 AccessFlags access_flags() const { return _access_flags; }
613 void set_access_flags(AccessFlags flags) { _access_flags = flags; }
614
615 bool is_public() const { return _access_flags.is_public(); }
616 bool is_final() const { return _access_flags.is_final(); }
617 bool is_interface() const { return _access_flags.is_interface(); }
618 bool is_abstract() const { return _access_flags.is_abstract(); }
619 bool is_super() const { return _access_flags.is_super(); }
620 bool is_synthetic() const { return _access_flags.is_synthetic(); }
621 void set_is_synthetic() { _access_flags.set_is_synthetic(); }
622 bool has_finalizer() const { return _access_flags.has_finalizer(); }
623 bool has_final_method() const { return _access_flags.has_final_method(); }
624 void set_has_finalizer() { _access_flags.set_has_finalizer(); }
625 void set_has_final_method() { _access_flags.set_has_final_method(); }
626 bool has_vanilla_constructor() const { return _access_flags.has_vanilla_constructor(); }
627 void set_has_vanilla_constructor() { _access_flags.set_has_vanilla_constructor(); }
628 bool has_miranda_methods () const { return access_flags().has_miranda_methods(); }
629 void set_has_miranda_methods() { _access_flags.set_has_miranda_methods(); }
630 bool is_shared() const { return access_flags().is_shared_class(); } // shadows MetaspaceObj::is_shared)()
631 void set_is_shared() { _access_flags.set_is_shared_class(); }
632 bool is_hidden() const { return access_flags().is_hidden_class(); }
633 void set_is_hidden() { _access_flags.set_is_hidden_class(); }
634 bool is_value_based() { return _access_flags.is_value_based_class(); }
635 void set_is_value_based() { _access_flags.set_is_value_based_class(); }
636
637 inline bool is_non_strong_hidden() const;
638
639 bool is_cloneable() const;
640 void set_is_cloneable();
641
642 JFR_ONLY(DEFINE_TRACE_ID_METHODS;)
643
644 virtual void metaspace_pointers_do(MetaspaceClosure* iter);
645 virtual MetaspaceObj::Type type() const { return ClassType; }
646
647 inline bool is_loader_alive() const;
648
649 void clean_subklass();
650
651 static void clean_weak_klass_links(bool unloading_occurred, bool clean_alive_klasses = true);
652 static void clean_subklass_tree() {
653 clean_weak_klass_links(/*unloading_occurred*/ true , /* clean_alive_klasses */ false);
654 }
655
656 virtual void array_klasses_do(void f(Klass* k)) {}
657
658 // Return self, except for abstract classes with exactly 1
659 // implementor. Then return the 1 concrete implementation.
660 Klass *up_cast_abstract();
661
|
27
28 #include "memory/iterator.hpp"
29 #include "memory/memRegion.hpp"
30 #include "oops/markWord.hpp"
31 #include "oops/metadata.hpp"
32 #include "oops/oop.hpp"
33 #include "oops/oopHandle.hpp"
34 #include "utilities/accessFlags.hpp"
35 #include "utilities/macros.hpp"
36 #if INCLUDE_JFR
37 #include "jfr/support/jfrTraceIdExtension.hpp"
38 #endif
39
40 // Klass IDs for all subclasses of Klass
41 enum KlassID {
42 InstanceKlassID,
43 InstanceRefKlassID,
44 InstanceMirrorKlassID,
45 InstanceClassLoaderKlassID,
46 TypeArrayKlassID,
47 FlatArrayKlassID,
48 ObjArrayKlassID
49 };
50
51 const uint KLASS_ID_COUNT = 7;
52
53 //
54 // A Klass provides:
55 // 1: language level class object (method dictionary etc.)
56 // 2: provide vm dispatch behavior for the object
57 // Both functions are combined into one C++ class.
58
59 // One reason for the oop/klass dichotomy in the implementation is
60 // that we don't want a C++ vtbl pointer in every object. Thus,
61 // normal oops don't have any virtual functions. Instead, they
62 // forward all "virtual" functions to their klass, which does have
63 // a vtbl and does the C++ dispatch depending on the object's
64 // actual type. (See oop.inline.hpp for some of the forwarding code.)
65 // ALL FUNCTIONS IMPLEMENTING THIS DISPATCH ARE PREFIXED WITH "oop_"!
66
67 // Forward declarations.
68 template <class T> class Array;
69 template <class T> class GrowableArray;
70 class ClassLoaderData;
71 class fieldDescriptor;
82 protected:
83 // If you add a new field that points to any metaspace object, you
84 // must add this field to Klass::metaspace_pointers_do().
85
86 // note: put frequently-used fields together at start of klass structure
87 // for better cache behavior (may not make much of a difference but sure won't hurt)
88 enum { _primary_super_limit = 8 };
89
90 // The "layout helper" is a combined descriptor of object layout.
91 // For klasses which are neither instance nor array, the value is zero.
92 //
93 // For instances, layout helper is a positive number, the instance size.
94 // This size is already passed through align_object_size and scaled to bytes.
95 // The low order bit is set if instances of this class cannot be
96 // allocated using the fastpath.
97 //
98 // For arrays, layout helper is a negative number, containing four
99 // distinct bytes, as follows:
100 // MSB:[tag, hsz, ebt, log2(esz)]:LSB
101 // where:
102 // tag is 0x80 if the elements are oops, 0xC0 if non-oops, 0xA0 if value types
103 // hsz is array header size in bytes (i.e., offset of first element)
104 // ebt is the BasicType of the elements
105 // esz is the element size in bytes
106 // This packed word is arranged so as to be quickly unpacked by the
107 // various fast paths that use the various subfields.
108 //
109 // The esz bits can be used directly by a SLL instruction, without masking.
110 //
111 // Note that the array-kind tag looks like 0x00 for instance klasses,
112 // since their length in bytes is always less than 24Mb.
113 //
114 // Final note: This comes first, immediately after C++ vtable,
115 // because it is frequently queried.
116 jint _layout_helper;
117
118 // Klass identifier used to implement devirtualized oop closure dispatching.
119 const KlassID _id;
120
121 // vtable length
122 int _vtable_len;
143 OopHandle _java_mirror;
144 // Superclass
145 Klass* _super;
146 // First subclass (NULL if none); _subklass->next_sibling() is next one
147 Klass* volatile _subklass;
148 // Sibling link (or NULL); links all subklasses of a klass
149 Klass* volatile _next_sibling;
150
151 // All klasses loaded by a class loader are chained through these links
152 Klass* _next_link;
153
154 // The VM's representation of the ClassLoader used to load this class.
155 // Provide access the corresponding instance java.lang.ClassLoader.
156 ClassLoaderData* _class_loader_data;
157
158 jint _modifier_flags; // Processed access flags, for use by Class.getModifiers.
159 AccessFlags _access_flags; // Access flags. The class/interface distinction is stored here.
160
161 JFR_ONLY(DEFINE_TRACE_ID_FIELD;)
162
163 markWord _prototype_header; // inline type and inline array mark patterns
164 private:
165 // This is an index into FileMapHeader::_shared_path_table[], to
166 // associate this class with the JAR file where it's loaded from during
167 // dump time. If a class is not loaded from the shared archive, this field is
168 // -1.
169 jshort _shared_class_path_index;
170
171 #if INCLUDE_CDS
172 // Flags of the current shared class.
173 u2 _shared_class_flags;
174 enum {
175 _archived_lambda_proxy_is_available = 2,
176 _has_value_based_class_annotation = 4,
177 _verified_at_dump_time = 8
178 };
179 #endif
180
181 CDS_JAVA_HEAP_ONLY(int _archived_mirror_index;)
182
183 protected:
353 static ByteSize super_offset() { return in_ByteSize(offset_of(Klass, _super)); }
354 static ByteSize super_check_offset_offset() { return in_ByteSize(offset_of(Klass, _super_check_offset)); }
355 static ByteSize primary_supers_offset() { return in_ByteSize(offset_of(Klass, _primary_supers)); }
356 static ByteSize secondary_super_cache_offset() { return in_ByteSize(offset_of(Klass, _secondary_super_cache)); }
357 static ByteSize secondary_supers_offset() { return in_ByteSize(offset_of(Klass, _secondary_supers)); }
358 static ByteSize java_mirror_offset() { return in_ByteSize(offset_of(Klass, _java_mirror)); }
359 static ByteSize class_loader_data_offset() { return in_ByteSize(offset_of(Klass, _class_loader_data)); }
360 static ByteSize modifier_flags_offset() { return in_ByteSize(offset_of(Klass, _modifier_flags)); }
361 static ByteSize layout_helper_offset() { return in_ByteSize(offset_of(Klass, _layout_helper)); }
362 static ByteSize access_flags_offset() { return in_ByteSize(offset_of(Klass, _access_flags)); }
363
364 // Unpacking layout_helper:
365 static const int _lh_neutral_value = 0; // neutral non-array non-instance value
366 static const int _lh_instance_slow_path_bit = 0x01;
367 static const int _lh_log2_element_size_shift = BitsPerByte*0;
368 static const int _lh_log2_element_size_mask = BitsPerLong-1;
369 static const int _lh_element_type_shift = BitsPerByte*1;
370 static const int _lh_element_type_mask = right_n_bits(BitsPerByte); // shifted mask
371 static const int _lh_header_size_shift = BitsPerByte*2;
372 static const int _lh_header_size_mask = right_n_bits(BitsPerByte); // shifted mask
373 static const int _lh_array_tag_bits = 3;
374 static const int _lh_array_tag_shift = BitsPerInt - _lh_array_tag_bits;
375
376 static const unsigned int _lh_array_tag_type_value = 0Xfffffffc;
377 static const unsigned int _lh_array_tag_vt_value = 0Xfffffffd;
378 static const unsigned int _lh_array_tag_obj_value = 0Xfffffffe;
379
380 // null-free array flag bit under the array tag bits, shift one more to get array tag value
381 static const int _lh_null_free_shift = _lh_array_tag_shift - 1;
382 static const int _lh_null_free_mask = 1;
383
384 static const jint _lh_array_tag_vt_value_bit_inplace = (jint) (1 << _lh_array_tag_shift);
385 static const jint _lh_null_free_bit_inplace = (jint) (_lh_null_free_mask << _lh_null_free_shift);
386
387 static int layout_helper_size_in_bytes(jint lh) {
388 assert(lh > (jint)_lh_neutral_value, "must be instance");
389 return (int) lh & ~_lh_instance_slow_path_bit;
390 }
391 static bool layout_helper_needs_slow_path(jint lh) {
392 assert(lh > (jint)_lh_neutral_value, "must be instance");
393 return (lh & _lh_instance_slow_path_bit) != 0;
394 }
395 static bool layout_helper_is_instance(jint lh) {
396 return (jint)lh > (jint)_lh_neutral_value;
397 }
398 static bool layout_helper_is_array(jint lh) {
399 return (jint)lh < (jint)_lh_neutral_value;
400 }
401 static bool layout_helper_is_typeArray(jint lh) {
402 return (juint) _lh_array_tag_type_value == (juint)(lh >> _lh_array_tag_shift);
403 }
404 static bool layout_helper_is_objArray(jint lh) {
405 return (juint)_lh_array_tag_obj_value == (juint)(lh >> _lh_array_tag_shift);
406 }
407 static bool layout_helper_is_flatArray(jint lh) {
408 return (juint)_lh_array_tag_vt_value == (juint)(lh >> _lh_array_tag_shift);
409 }
410 static bool layout_helper_is_null_free(jint lh) {
411 assert(layout_helper_is_flatArray(lh) || layout_helper_is_objArray(lh), "must be array of inline types");
412 return ((lh >> _lh_null_free_shift) & _lh_null_free_mask);
413 }
414 static jint layout_helper_set_null_free(jint lh) {
415 lh |= (_lh_null_free_mask << _lh_null_free_shift);
416 assert(layout_helper_is_null_free(lh), "Bad encoding");
417 return lh;
418 }
419 static int layout_helper_header_size(jint lh) {
420 assert(lh < (jint)_lh_neutral_value, "must be array");
421 int hsize = (lh >> _lh_header_size_shift) & _lh_header_size_mask;
422 assert(hsize > 0 && hsize < (int)sizeof(oopDesc)*3, "sanity");
423 return hsize;
424 }
425 static BasicType layout_helper_element_type(jint lh) {
426 assert(lh < (jint)_lh_neutral_value, "must be array");
427 int btvalue = (lh >> _lh_element_type_shift) & _lh_element_type_mask;
428 assert((btvalue >= T_BOOLEAN && btvalue <= T_OBJECT) || btvalue == T_INLINE_TYPE, "sanity");
429 return (BasicType) btvalue;
430 }
431
432 // Want a pattern to quickly diff against layout header in register
433 // find something less clever!
434 static int layout_helper_boolean_diffbit() {
435 jint zlh = array_layout_helper(T_BOOLEAN);
436 jint blh = array_layout_helper(T_BYTE);
437 assert(zlh != blh, "array layout helpers must differ");
438 int diffbit = 1;
439 while ((diffbit & (zlh ^ blh)) == 0 && (diffbit & zlh) == 0) {
440 diffbit <<= 1;
441 assert(diffbit != 0, "make sure T_BOOLEAN has a different bit than T_BYTE");
442 }
443 return diffbit;
444 }
445
446 static int layout_helper_log2_element_size(jint lh) {
447 assert(lh < (jint)_lh_neutral_value, "must be array");
448 int l2esz = (lh >> _lh_log2_element_size_shift) & _lh_log2_element_size_mask;
449 assert(layout_helper_element_type(lh) == T_INLINE_TYPE || l2esz <= LogBytesPerLong,
450 "sanity. l2esz: 0x%x for lh: 0x%x", (uint)l2esz, (uint)lh);
451 return l2esz;
452 }
453 static jint array_layout_helper(jint tag, bool null_free, int hsize, BasicType etype, int log2_esize) {
454 return (tag << _lh_array_tag_shift)
455 | ((null_free ? 1 : 0) << _lh_null_free_shift)
456 | (hsize << _lh_header_size_shift)
457 | ((int)etype << _lh_element_type_shift)
458 | (log2_esize << _lh_log2_element_size_shift);
459 }
460 static jint instance_layout_helper(jint size, bool slow_path_flag) {
461 return (size << LogBytesPerWord)
462 | (slow_path_flag ? _lh_instance_slow_path_bit : 0);
463 }
464 static int layout_helper_to_size_helper(jint lh) {
465 assert(lh > (jint)_lh_neutral_value, "must be instance");
466 // Note that the following expression discards _lh_instance_slow_path_bit.
467 return lh >> LogBytesPerWord;
468 }
469 // Out-of-line version computes everything based on the etype:
470 static jint array_layout_helper(BasicType etype);
471
472 // What is the maximum number of primary superclasses any klass can have?
473 static juint primary_super_limit() { return _primary_super_limit; }
474
475 // vtables
584 // Returns the name for a class (Resource allocated) as the class
585 // would appear in a signature.
586 // For arrays, this returns the name of the element with a leading '['.
587 // For classes, this returns the name with a leading 'L' and a trailing ';'
588 // and the package separators as '/'.
589 virtual const char* signature_name() const;
590
591 const char* joint_in_module_of_loader(const Klass* class2, bool include_parent_loader = false) const;
592 const char* class_in_module_of_loader(bool use_are = false, bool include_parent_loader = false) const;
593
594 // Returns "interface", "abstract class" or "class".
595 const char* external_kind() const;
596
597 // type testing operations
598 #ifdef ASSERT
599 protected:
600 virtual bool is_instance_klass_slow() const { return false; }
601 virtual bool is_array_klass_slow() const { return false; }
602 virtual bool is_objArray_klass_slow() const { return false; }
603 virtual bool is_typeArray_klass_slow() const { return false; }
604 virtual bool is_flatArray_klass_slow() const { return false; }
605 #endif // ASSERT
606 // current implementation uses this method even in non debug builds
607 virtual bool is_inline_klass_slow() const { return false; }
608 public:
609
610 // Fast non-virtual versions
611 #ifndef ASSERT
612 #define assert_same_query(xval, xcheck) xval
613 #else
614 private:
615 static bool assert_same_query(bool xval, bool xslow) {
616 assert(xval == xslow, "slow and fast queries agree");
617 return xval;
618 }
619 public:
620 #endif
621 inline bool is_instance_klass() const { return assert_same_query(
622 layout_helper_is_instance(layout_helper()),
623 is_instance_klass_slow()); }
624 inline bool is_array_klass() const { return assert_same_query(
625 layout_helper_is_array(layout_helper()),
626 is_array_klass_slow()); }
627 inline bool is_objArray_klass() const { return assert_same_query(
628 layout_helper_is_objArray(layout_helper()),
629 is_objArray_klass_slow()); }
630 inline bool is_typeArray_klass() const { return assert_same_query(
631 layout_helper_is_typeArray(layout_helper()),
632 is_typeArray_klass_slow()); }
633 inline bool is_inline_klass() const { return is_inline_klass_slow(); } //temporary hack
634 inline bool is_flatArray_klass() const { return assert_same_query(
635 layout_helper_is_flatArray(layout_helper()),
636 is_flatArray_klass_slow()); }
637
638 #undef assert_same_query
639
640 inline bool is_null_free_array_klass() const { return layout_helper_is_null_free(layout_helper()); }
641
642 // Access flags
643 AccessFlags access_flags() const { return _access_flags; }
644 void set_access_flags(AccessFlags flags) { _access_flags = flags; }
645
646 bool is_public() const { return _access_flags.is_public(); }
647 bool is_final() const { return _access_flags.is_final(); }
648 bool is_interface() const { return _access_flags.is_interface(); }
649 bool is_abstract() const { return _access_flags.is_abstract(); }
650 bool is_super() const { return _access_flags.is_super(); }
651 bool is_synthetic() const { return _access_flags.is_synthetic(); }
652 void set_is_synthetic() { _access_flags.set_is_synthetic(); }
653 bool has_finalizer() const { return _access_flags.has_finalizer(); }
654 bool has_final_method() const { return _access_flags.has_final_method(); }
655 void set_has_finalizer() { _access_flags.set_has_finalizer(); }
656 void set_has_final_method() { _access_flags.set_has_final_method(); }
657 bool has_vanilla_constructor() const { return _access_flags.has_vanilla_constructor(); }
658 void set_has_vanilla_constructor() { _access_flags.set_has_vanilla_constructor(); }
659 bool has_miranda_methods () const { return access_flags().has_miranda_methods(); }
660 void set_has_miranda_methods() { _access_flags.set_has_miranda_methods(); }
661 bool is_shared() const { return access_flags().is_shared_class(); } // shadows MetaspaceObj::is_shared)()
662 void set_is_shared() { _access_flags.set_is_shared_class(); }
663 bool is_hidden() const { return access_flags().is_hidden_class(); }
664 void set_is_hidden() { _access_flags.set_is_hidden_class(); }
665 bool is_value_based() { return _access_flags.is_value_based_class(); }
666 void set_is_value_based() { _access_flags.set_is_value_based_class(); }
667
668 inline bool is_non_strong_hidden() const;
669
670 bool is_cloneable() const;
671 void set_is_cloneable();
672
673 // inline types and inline type array patterns
674 markWord prototype_header() const {
675 return _prototype_header;
676 }
677 static inline markWord default_prototype_header(Klass* k) {
678 return (k == NULL) ? markWord::prototype() : k->prototype_header();
679 }
680
681 inline void set_prototype_header(markWord header);
682 static ByteSize prototype_header_offset() { return in_ByteSize(offset_of(Klass, _prototype_header)); }
683
684 JFR_ONLY(DEFINE_TRACE_ID_METHODS;)
685
686 virtual void metaspace_pointers_do(MetaspaceClosure* iter);
687 virtual MetaspaceObj::Type type() const { return ClassType; }
688
689 inline bool is_loader_alive() const;
690
691 void clean_subklass();
692
693 static void clean_weak_klass_links(bool unloading_occurred, bool clean_alive_klasses = true);
694 static void clean_subklass_tree() {
695 clean_weak_klass_links(/*unloading_occurred*/ true , /* clean_alive_klasses */ false);
696 }
697
698 virtual void array_klasses_do(void f(Klass* k)) {}
699
700 // Return self, except for abstract classes with exactly 1
701 // implementor. Then return the 1 concrete implementation.
702 Klass *up_cast_abstract();
703
|