Thu, 07 Apr 2011 09:53:20 -0700
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
Summary: A referent object that is only weakly reachable at the start of concurrent marking but is re-attached to the strongly reachable object graph during marking may not be marked as live. This can cause the reference object to be processed prematurely and leave dangling pointers to the referent object. Implement a read barrier for the java.lang.ref.Reference::referent field by intrinsifying the Reference.get() method, and intercepting accesses though JNI, reflection, and Unsafe, so that when a non-null referent object is read it is also logged in an SATB buffer.
Reviewed-by: kvn, iveresov, never, tonyp, dholmes
1 /*
2 * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
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 */
25 #ifndef SHARE_VM_OOPS_KLASS_HPP
26 #define SHARE_VM_OOPS_KLASS_HPP
28 #include "memory/genOopClosures.hpp"
29 #include "memory/iterator.hpp"
30 #include "memory/memRegion.hpp"
31 #include "memory/specialized_oop_closures.hpp"
32 #include "oops/klassOop.hpp"
33 #include "oops/klassPS.hpp"
34 #include "oops/oop.hpp"
35 #include "runtime/orderAccess.hpp"
36 #include "utilities/accessFlags.hpp"
37 #ifndef SERIALGC
38 #include "gc_implementation/concurrentMarkSweep/cmsOopClosures.hpp"
39 #include "gc_implementation/g1/g1OopClosures.hpp"
40 #include "gc_implementation/parNew/parOopClosures.hpp"
41 #endif
43 // A Klass is the part of the klassOop that provides:
44 // 1: language level class object (method dictionary etc.)
45 // 2: provide vm dispatch behavior for the object
46 // Both functions are combined into one C++ class. The toplevel class "Klass"
47 // implements purpose 1 whereas all subclasses provide extra virtual functions
48 // for purpose 2.
50 // One reason for the oop/klass dichotomy in the implementation is
51 // that we don't want a C++ vtbl pointer in every object. Thus,
52 // normal oops don't have any virtual functions. Instead, they
53 // forward all "virtual" functions to their klass, which does have
54 // a vtbl and does the C++ dispatch depending on the object's
55 // actual type. (See oop.inline.hpp for some of the forwarding code.)
56 // ALL FUNCTIONS IMPLEMENTING THIS DISPATCH ARE PREFIXED WITH "oop_"!
58 // Klass layout:
59 // [header ] klassOop
60 // [klass pointer ] klassOop
61 // [C++ vtbl ptr ] (contained in Klass_vtbl)
62 // [layout_helper ]
63 // [super_check_offset ] for fast subtype checks
64 // [secondary_super_cache] for fast subtype checks
65 // [secondary_supers ] array of 2ndary supertypes
66 // [primary_supers 0]
67 // [primary_supers 1]
68 // [primary_supers 2]
69 // ...
70 // [primary_supers 7]
71 // [java_mirror ]
72 // [super ]
73 // [name ]
74 // [first subklass]
75 // [next_sibling ] link to chain additional subklasses
76 // [modifier_flags]
77 // [access_flags ]
78 // [verify_count ] - not in product
79 // [alloc_count ]
80 // [last_biased_lock_bulk_revocation_time] (64 bits)
81 // [prototype_header]
82 // [biased_lock_revocation_count]
85 // Forward declarations.
86 class klassVtable;
87 class KlassHandle;
88 class OrderAccess;
90 // Holder (or cage) for the C++ vtable of each kind of Klass.
91 // We want to tightly constrain the location of the C++ vtable in the overall layout.
92 class Klass_vtbl {
93 protected:
94 // The following virtual exists only to force creation of a C++ vtable,
95 // so that this class truly is the location of the vtable of all Klasses.
96 virtual void unused_initial_virtual() { }
98 public:
99 // The following virtual makes Klass_vtbl play a second role as a
100 // factory protocol for subclasses of Klass ("sub-Klasses").
101 // Here's how it works....
102 //
103 // This VM uses metaobjects as factories for their instances.
104 //
105 // In order to initialize the C++ vtable of a new instance, its
106 // metaobject is forced to use the C++ placed new operator to
107 // allocate the instance. In a typical C++-based system, each
108 // sub-class would have its own factory routine which
109 // directly uses the placed new operator on the desired class,
110 // and then calls the appropriate chain of C++ constructors.
111 //
112 // However, this system uses shared code to performs the first
113 // allocation and initialization steps for all sub-Klasses.
114 // (See base_create_klass() and base_create_array_klass().)
115 // This does not factor neatly into a hierarchy of C++ constructors.
116 // Each caller of these shared "base_create" routines knows
117 // exactly which sub-Klass it is creating, but the shared routine
118 // does not, even though it must perform the actual allocation.
119 //
120 // Therefore, the caller of the shared "base_create" must wrap
121 // the specific placed new call in a virtual function which
122 // performs the actual allocation and vtable set-up. That
123 // virtual function is here, Klass_vtbl::allocate_permanent.
124 //
125 // The arguments to Universe::allocate_permanent() are passed
126 // straight through the placed new operator, which in turn
127 // obtains them directly from this virtual call.
128 //
129 // This virtual is called on a temporary "example instance" of the
130 // sub-Klass being instantiated, a C++ auto variable. The "real"
131 // instance created by this virtual is on the VM heap, where it is
132 // equipped with a klassOopDesc header.
133 //
134 // It is merely an accident of implementation that we use "example
135 // instances", but that is why the virtual function which implements
136 // each sub-Klass factory happens to be defined by the same sub-Klass
137 // for which it creates instances.
138 //
139 // The vtbl_value() call (see below) is used to strip away the
140 // accidental Klass-ness from an "example instance" and present it as
141 // a factory. Think of each factory object as a mere container of the
142 // C++ vtable for the desired sub-Klass. Since C++ does not allow
143 // direct references to vtables, the factory must also be delegated
144 // the task of allocating the instance, but the essential point is
145 // that the factory knows how to initialize the C++ vtable with the
146 // right pointer value. All other common initializations are handled
147 // by the shared "base_create" subroutines.
148 //
149 virtual void* allocate_permanent(KlassHandle& klass, int size, TRAPS) const = 0;
150 void post_new_init_klass(KlassHandle& klass, klassOop obj, int size) const;
152 // Every subclass on which vtbl_value is called must include this macro.
153 // Delay the installation of the klassKlass pointer until after the
154 // the vtable for a new klass has been installed (after the call to new()).
155 #define DEFINE_ALLOCATE_PERMANENT(thisKlass) \
156 void* allocate_permanent(KlassHandle& klass_klass, int size, TRAPS) const { \
157 void* result = new(klass_klass, size, THREAD) thisKlass(); \
158 if (HAS_PENDING_EXCEPTION) return NULL; \
159 klassOop new_klass = ((Klass*) result)->as_klassOop(); \
160 OrderAccess::storestore(); \
161 post_new_init_klass(klass_klass, new_klass, size); \
162 return result; \
163 }
165 bool null_vtbl() { return *(intptr_t*)this == 0; }
167 protected:
168 void* operator new(size_t ignored, KlassHandle& klass, int size, TRAPS);
169 };
172 class Klass : public Klass_vtbl {
173 friend class VMStructs;
174 protected:
175 // note: put frequently-used fields together at start of klass structure
176 // for better cache behavior (may not make much of a difference but sure won't hurt)
177 enum { _primary_super_limit = 8 };
179 // The "layout helper" is a combined descriptor of object layout.
180 // For klasses which are neither instance nor array, the value is zero.
181 //
182 // For instances, layout helper is a positive number, the instance size.
183 // This size is already passed through align_object_size and scaled to bytes.
184 // The low order bit is set if instances of this class cannot be
185 // allocated using the fastpath.
186 //
187 // For arrays, layout helper is a negative number, containing four
188 // distinct bytes, as follows:
189 // MSB:[tag, hsz, ebt, log2(esz)]:LSB
190 // where:
191 // tag is 0x80 if the elements are oops, 0xC0 if non-oops
192 // hsz is array header size in bytes (i.e., offset of first element)
193 // ebt is the BasicType of the elements
194 // esz is the element size in bytes
195 // This packed word is arranged so as to be quickly unpacked by the
196 // various fast paths that use the various subfields.
197 //
198 // The esz bits can be used directly by a SLL instruction, without masking.
199 //
200 // Note that the array-kind tag looks like 0x00 for instance klasses,
201 // since their length in bytes is always less than 24Mb.
202 //
203 // Final note: This comes first, immediately after Klass_vtbl,
204 // because it is frequently queried.
205 jint _layout_helper;
207 // The fields _super_check_offset, _secondary_super_cache, _secondary_supers
208 // and _primary_supers all help make fast subtype checks. See big discussion
209 // in doc/server_compiler/checktype.txt
210 //
211 // Where to look to observe a supertype (it is &_secondary_super_cache for
212 // secondary supers, else is &_primary_supers[depth()].
213 juint _super_check_offset;
215 // Class name. Instance classes: java/lang/String, etc. Array classes: [I,
216 // [Ljava/lang/String;, etc. Set to zero for all other kinds of classes.
217 Symbol* _name;
219 public:
220 oop* oop_block_beg() const { return adr_secondary_super_cache(); }
221 oop* oop_block_end() const { return adr_next_sibling() + 1; }
223 protected:
224 //
225 // The oop block. All oop fields must be declared here and only oop fields
226 // may be declared here. In addition, the first and last fields in this block
227 // must remain first and last, unless oop_block_beg() and/or oop_block_end()
228 // are updated. Grouping the oop fields in a single block simplifies oop
229 // iteration.
230 //
232 // Cache of last observed secondary supertype
233 klassOop _secondary_super_cache;
234 // Array of all secondary supertypes
235 objArrayOop _secondary_supers;
236 // Ordered list of all primary supertypes
237 klassOop _primary_supers[_primary_super_limit];
238 // java/lang/Class instance mirroring this class
239 oop _java_mirror;
240 // Superclass
241 klassOop _super;
242 // First subclass (NULL if none); _subklass->next_sibling() is next one
243 klassOop _subklass;
244 // Sibling link (or NULL); links all subklasses of a klass
245 klassOop _next_sibling;
247 //
248 // End of the oop block.
249 //
251 jint _modifier_flags; // Processed access flags, for use by Class.getModifiers.
252 AccessFlags _access_flags; // Access flags. The class/interface distinction is stored here.
254 #ifndef PRODUCT
255 int _verify_count; // to avoid redundant verifies
256 #endif
258 juint _alloc_count; // allocation profiling support - update klass_size_in_bytes() if moved/deleted
260 // Biased locking implementation and statistics
261 // (the 64-bit chunk goes first, to avoid some fragmentation)
262 jlong _last_biased_lock_bulk_revocation_time;
263 markOop _prototype_header; // Used when biased locking is both enabled and disabled for this type
264 jint _biased_lock_revocation_count;
266 public:
268 // returns the enclosing klassOop
269 klassOop as_klassOop() const {
270 // see klassOop.hpp for layout.
271 return (klassOop) (((char*) this) - sizeof(klassOopDesc));
272 }
274 public:
275 // Allocation
276 const Klass_vtbl& vtbl_value() const { return *this; } // used only on "example instances"
277 static KlassHandle base_create_klass(KlassHandle& klass, int size, const Klass_vtbl& vtbl, TRAPS);
278 static klassOop base_create_klass_oop(KlassHandle& klass, int size, const Klass_vtbl& vtbl, TRAPS);
280 // super
281 klassOop super() const { return _super; }
282 void set_super(klassOop k) { oop_store_without_check((oop*) &_super, (oop) k); }
284 // initializes _super link, _primary_supers & _secondary_supers arrays
285 void initialize_supers(klassOop k, TRAPS);
286 void initialize_supers_impl1(klassOop k);
287 void initialize_supers_impl2(klassOop k);
289 // klass-specific helper for initializing _secondary_supers
290 virtual objArrayOop compute_secondary_supers(int num_extra_slots, TRAPS);
292 // java_super is the Java-level super type as specified by Class.getSuperClass.
293 virtual klassOop java_super() const { return NULL; }
295 juint super_check_offset() const { return _super_check_offset; }
296 void set_super_check_offset(juint o) { _super_check_offset = o; }
298 klassOop secondary_super_cache() const { return _secondary_super_cache; }
299 void set_secondary_super_cache(klassOop k) { oop_store_without_check((oop*) &_secondary_super_cache, (oop) k); }
301 objArrayOop secondary_supers() const { return _secondary_supers; }
302 void set_secondary_supers(objArrayOop k) { oop_store_without_check((oop*) &_secondary_supers, (oop) k); }
304 // Return the element of the _super chain of the given depth.
305 // If there is no such element, return either NULL or this.
306 klassOop primary_super_of_depth(juint i) const {
307 assert(i < primary_super_limit(), "oob");
308 klassOop super = _primary_supers[i];
309 assert(super == NULL || super->klass_part()->super_depth() == i, "correct display");
310 return super;
311 }
313 // Can this klass be a primary super? False for interfaces and arrays of
314 // interfaces. False also for arrays or classes with long super chains.
315 bool can_be_primary_super() const {
316 const juint secondary_offset = secondary_super_cache_offset_in_bytes() + sizeof(oopDesc);
317 return super_check_offset() != secondary_offset;
318 }
319 virtual bool can_be_primary_super_slow() const;
321 // Returns number of primary supers; may be a number in the inclusive range [0, primary_super_limit].
322 juint super_depth() const {
323 if (!can_be_primary_super()) {
324 return primary_super_limit();
325 } else {
326 juint d = (super_check_offset() - (primary_supers_offset_in_bytes() + sizeof(oopDesc))) / sizeof(klassOop);
327 assert(d < primary_super_limit(), "oob");
328 assert(_primary_supers[d] == as_klassOop(), "proper init");
329 return d;
330 }
331 }
333 // java mirror
334 oop java_mirror() const { return _java_mirror; }
335 void set_java_mirror(oop m) { oop_store((oop*) &_java_mirror, m); }
337 // modifier flags
338 jint modifier_flags() const { return _modifier_flags; }
339 void set_modifier_flags(jint flags) { _modifier_flags = flags; }
341 // size helper
342 int layout_helper() const { return _layout_helper; }
343 void set_layout_helper(int lh) { _layout_helper = lh; }
345 // Note: for instances layout_helper() may include padding.
346 // Use instanceKlass::contains_field_offset to classify field offsets.
348 // sub/superklass links
349 instanceKlass* superklass() const;
350 Klass* subklass() const;
351 Klass* next_sibling() const;
352 void append_to_sibling_list(); // add newly created receiver to superklass' subklass list
353 void remove_from_sibling_list(); // remove receiver from sibling list
354 protected: // internal accessors
355 klassOop subklass_oop() const { return _subklass; }
356 klassOop next_sibling_oop() const { return _next_sibling; }
357 void set_subklass(klassOop s);
358 void set_next_sibling(klassOop s);
360 oop* adr_super() const { return (oop*)&_super; }
361 oop* adr_primary_supers() const { return (oop*)&_primary_supers[0]; }
362 oop* adr_secondary_super_cache() const { return (oop*)&_secondary_super_cache; }
363 oop* adr_secondary_supers()const { return (oop*)&_secondary_supers; }
364 oop* adr_java_mirror() const { return (oop*)&_java_mirror; }
365 oop* adr_subklass() const { return (oop*)&_subklass; }
366 oop* adr_next_sibling() const { return (oop*)&_next_sibling; }
368 public:
369 // Allocation profiling support
370 juint alloc_count() const { return _alloc_count; }
371 void set_alloc_count(juint n) { _alloc_count = n; }
372 virtual juint alloc_size() const = 0;
373 virtual void set_alloc_size(juint n) = 0;
375 // Compiler support
376 static int super_offset_in_bytes() { return offset_of(Klass, _super); }
377 static int super_check_offset_offset_in_bytes() { return offset_of(Klass, _super_check_offset); }
378 static int primary_supers_offset_in_bytes(){ return offset_of(Klass, _primary_supers); }
379 static int secondary_super_cache_offset_in_bytes() { return offset_of(Klass, _secondary_super_cache); }
380 static int secondary_supers_offset_in_bytes() { return offset_of(Klass, _secondary_supers); }
381 static int java_mirror_offset_in_bytes() { return offset_of(Klass, _java_mirror); }
382 static int modifier_flags_offset_in_bytes(){ return offset_of(Klass, _modifier_flags); }
383 static int layout_helper_offset_in_bytes() { return offset_of(Klass, _layout_helper); }
384 static int access_flags_offset_in_bytes() { return offset_of(Klass, _access_flags); }
386 // Unpacking layout_helper:
387 enum {
388 _lh_neutral_value = 0, // neutral non-array non-instance value
389 _lh_instance_slow_path_bit = 0x01,
390 _lh_log2_element_size_shift = BitsPerByte*0,
391 _lh_log2_element_size_mask = BitsPerLong-1,
392 _lh_element_type_shift = BitsPerByte*1,
393 _lh_element_type_mask = right_n_bits(BitsPerByte), // shifted mask
394 _lh_header_size_shift = BitsPerByte*2,
395 _lh_header_size_mask = right_n_bits(BitsPerByte), // shifted mask
396 _lh_array_tag_bits = 2,
397 _lh_array_tag_shift = BitsPerInt - _lh_array_tag_bits,
398 _lh_array_tag_type_value = ~0x00, // 0xC0000000 >> 30
399 _lh_array_tag_obj_value = ~0x01 // 0x80000000 >> 30
400 };
402 static int layout_helper_size_in_bytes(jint lh) {
403 assert(lh > (jint)_lh_neutral_value, "must be instance");
404 return (int) lh & ~_lh_instance_slow_path_bit;
405 }
406 static bool layout_helper_needs_slow_path(jint lh) {
407 assert(lh > (jint)_lh_neutral_value, "must be instance");
408 return (lh & _lh_instance_slow_path_bit) != 0;
409 }
410 static bool layout_helper_is_instance(jint lh) {
411 return (jint)lh > (jint)_lh_neutral_value;
412 }
413 static bool layout_helper_is_javaArray(jint lh) {
414 return (jint)lh < (jint)_lh_neutral_value;
415 }
416 static bool layout_helper_is_typeArray(jint lh) {
417 // _lh_array_tag_type_value == (lh >> _lh_array_tag_shift);
418 return (juint)lh >= (juint)(_lh_array_tag_type_value << _lh_array_tag_shift);
419 }
420 static bool layout_helper_is_objArray(jint lh) {
421 // _lh_array_tag_obj_value == (lh >> _lh_array_tag_shift);
422 return (jint)lh < (jint)(_lh_array_tag_type_value << _lh_array_tag_shift);
423 }
424 static int layout_helper_header_size(jint lh) {
425 assert(lh < (jint)_lh_neutral_value, "must be array");
426 int hsize = (lh >> _lh_header_size_shift) & _lh_header_size_mask;
427 assert(hsize > 0 && hsize < (int)sizeof(oopDesc)*3, "sanity");
428 return hsize;
429 }
430 static BasicType layout_helper_element_type(jint lh) {
431 assert(lh < (jint)_lh_neutral_value, "must be array");
432 int btvalue = (lh >> _lh_element_type_shift) & _lh_element_type_mask;
433 assert(btvalue >= T_BOOLEAN && btvalue <= T_OBJECT, "sanity");
434 return (BasicType) btvalue;
435 }
436 static int layout_helper_log2_element_size(jint lh) {
437 assert(lh < (jint)_lh_neutral_value, "must be array");
438 int l2esz = (lh >> _lh_log2_element_size_shift) & _lh_log2_element_size_mask;
439 assert(l2esz <= LogBitsPerLong, "sanity");
440 return l2esz;
441 }
442 static jint array_layout_helper(jint tag, int hsize, BasicType etype, int log2_esize) {
443 return (tag << _lh_array_tag_shift)
444 | (hsize << _lh_header_size_shift)
445 | ((int)etype << _lh_element_type_shift)
446 | (log2_esize << _lh_log2_element_size_shift);
447 }
448 static jint instance_layout_helper(jint size, bool slow_path_flag) {
449 return (size << LogHeapWordSize)
450 | (slow_path_flag ? _lh_instance_slow_path_bit : 0);
451 }
452 static int layout_helper_to_size_helper(jint lh) {
453 assert(lh > (jint)_lh_neutral_value, "must be instance");
454 // Note that the following expression discards _lh_instance_slow_path_bit.
455 return lh >> LogHeapWordSize;
456 }
457 // Out-of-line version computes everything based on the etype:
458 static jint array_layout_helper(BasicType etype);
460 // What is the maximum number of primary superclasses any klass can have?
461 #ifdef PRODUCT
462 static juint primary_super_limit() { return _primary_super_limit; }
463 #else
464 static juint primary_super_limit() {
465 assert(FastSuperclassLimit <= _primary_super_limit, "parameter oob");
466 return FastSuperclassLimit;
467 }
468 #endif
470 // vtables
471 virtual klassVtable* vtable() const { return NULL; }
473 static int klass_size_in_bytes() { return offset_of(Klass, _alloc_count) + sizeof(juint); } // all "visible" fields
475 // subclass check
476 bool is_subclass_of(klassOop k) const;
477 // subtype check: true if is_subclass_of, or if k is interface and receiver implements it
478 bool is_subtype_of(klassOop k) const {
479 juint off = k->klass_part()->super_check_offset();
480 klassOop sup = *(klassOop*)( (address)as_klassOop() + off );
481 const juint secondary_offset = secondary_super_cache_offset_in_bytes() + sizeof(oopDesc);
482 if (sup == k) {
483 return true;
484 } else if (off != secondary_offset) {
485 return false;
486 } else {
487 return search_secondary_supers(k);
488 }
489 }
490 bool search_secondary_supers(klassOop k) const;
492 // Find LCA in class hierarchy
493 Klass *LCA( Klass *k );
495 // Check whether reflection/jni/jvm code is allowed to instantiate this class;
496 // if not, throw either an Error or an Exception.
497 virtual void check_valid_for_instantiation(bool throwError, TRAPS);
499 // Casting
500 static Klass* cast(klassOop k) {
501 assert(k->is_klass(), "cast to Klass");
502 return k->klass_part();
503 }
505 // array copying
506 virtual void copy_array(arrayOop s, int src_pos, arrayOop d, int dst_pos, int length, TRAPS);
508 // tells if the class should be initialized
509 virtual bool should_be_initialized() const { return false; }
510 // initializes the klass
511 virtual void initialize(TRAPS);
512 // lookup operation for MethodLookupCache
513 friend class MethodLookupCache;
514 virtual methodOop uncached_lookup_method(Symbol* name, Symbol* signature) const;
515 public:
516 methodOop lookup_method(Symbol* name, Symbol* signature) const {
517 return uncached_lookup_method(name, signature);
518 }
520 // array class with specific rank
521 klassOop array_klass(int rank, TRAPS) { return array_klass_impl(false, rank, THREAD); }
523 // array class with this klass as element type
524 klassOop array_klass(TRAPS) { return array_klass_impl(false, THREAD); }
526 // These will return NULL instead of allocating on the heap:
527 // NB: these can block for a mutex, like other functions with TRAPS arg.
528 klassOop array_klass_or_null(int rank);
529 klassOop array_klass_or_null();
531 virtual oop protection_domain() { return NULL; }
532 virtual oop class_loader() const { return NULL; }
534 protected:
535 virtual klassOop array_klass_impl(bool or_null, int rank, TRAPS);
536 virtual klassOop array_klass_impl(bool or_null, TRAPS);
538 public:
539 virtual void remove_unshareable_info();
540 virtual void shared_symbols_iterate(SymbolClosure* closure);
542 protected:
543 // computes the subtype relationship
544 virtual bool compute_is_subtype_of(klassOop k);
545 public:
546 // subclass accessor (here for convenience; undefined for non-klass objects)
547 virtual bool is_leaf_class() const { fatal("not a class"); return false; }
548 public:
549 // ALL FUNCTIONS BELOW THIS POINT ARE DISPATCHED FROM AN OOP
550 // These functions describe behavior for the oop not the KLASS.
552 // actual oop size of obj in memory
553 virtual int oop_size(oop obj) const = 0;
555 // actual oop size of this klass in memory
556 virtual int klass_oop_size() const = 0;
558 // Returns the Java name for a class (Resource allocated)
559 // For arrays, this returns the name of the element with a leading '['.
560 // For classes, this returns the name with the package separators
561 // turned into '.'s.
562 const char* external_name() const;
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;
570 // garbage collection support
571 virtual void oop_follow_contents(oop obj) = 0;
572 virtual int oop_adjust_pointers(oop obj) = 0;
574 // Parallel Scavenge and Parallel Old
575 PARALLEL_GC_DECLS_PV
577 public:
578 // type testing operations
579 virtual bool oop_is_instance_slow() const { return false; }
580 virtual bool oop_is_instanceMirror() const { return false; }
581 virtual bool oop_is_instanceRef() const { return false; }
582 virtual bool oop_is_array() const { return false; }
583 virtual bool oop_is_objArray_slow() const { return false; }
584 virtual bool oop_is_klass() const { return false; }
585 virtual bool oop_is_thread() const { return false; }
586 virtual bool oop_is_method() const { return false; }
587 virtual bool oop_is_constMethod() const { return false; }
588 virtual bool oop_is_methodData() const { return false; }
589 virtual bool oop_is_constantPool() const { return false; }
590 virtual bool oop_is_constantPoolCache() const { return false; }
591 virtual bool oop_is_typeArray_slow() const { return false; }
592 virtual bool oop_is_arrayKlass() const { return false; }
593 virtual bool oop_is_objArrayKlass() const { return false; }
594 virtual bool oop_is_typeArrayKlass() const { return false; }
595 virtual bool oop_is_compiledICHolder() const { return false; }
596 virtual bool oop_is_instanceKlass() const { return false; }
598 bool oop_is_javaArray_slow() const {
599 return oop_is_objArray_slow() || oop_is_typeArray_slow();
600 }
602 // Fast non-virtual versions, used by oop.inline.hpp and elsewhere:
603 #ifndef ASSERT
604 #define assert_same_query(xval, xcheck) xval
605 #else
606 private:
607 static bool assert_same_query(bool xval, bool xslow) {
608 assert(xval == xslow, "slow and fast queries agree");
609 return xval;
610 }
611 public:
612 #endif
613 inline bool oop_is_instance() const { return assert_same_query(
614 layout_helper_is_instance(layout_helper()),
615 oop_is_instance_slow()); }
616 inline bool oop_is_javaArray() const { return assert_same_query(
617 layout_helper_is_javaArray(layout_helper()),
618 oop_is_javaArray_slow()); }
619 inline bool oop_is_objArray() const { return assert_same_query(
620 layout_helper_is_objArray(layout_helper()),
621 oop_is_objArray_slow()); }
622 inline bool oop_is_typeArray() const { return assert_same_query(
623 layout_helper_is_typeArray(layout_helper()),
624 oop_is_typeArray_slow()); }
625 #undef assert_same_query
627 // Unless overridden, oop is parsable if it has a klass pointer.
628 // Parsability of an object is object specific.
629 virtual bool oop_is_parsable(oop obj) const { return true; }
631 // Unless overridden, oop is safe for concurrent GC processing
632 // after its allocation is complete. The exception to
633 // this is the case where objects are changed after allocation.
634 // Class redefinition is one of the known exceptions. During
635 // class redefinition, an allocated class can changed in order
636 // order to create a merged class (the combiniation of the
637 // old class definition that has to be perserved and the new class
638 // definition which is being created.
639 virtual bool oop_is_conc_safe(oop obj) const { return true; }
641 // Access flags
642 AccessFlags access_flags() const { return _access_flags; }
643 void set_access_flags(AccessFlags flags) { _access_flags = flags; }
645 bool is_public() const { return _access_flags.is_public(); }
646 bool is_final() const { return _access_flags.is_final(); }
647 bool is_interface() const { return _access_flags.is_interface(); }
648 bool is_abstract() const { return _access_flags.is_abstract(); }
649 bool is_super() const { return _access_flags.is_super(); }
650 bool is_synthetic() const { return _access_flags.is_synthetic(); }
651 void set_is_synthetic() { _access_flags.set_is_synthetic(); }
652 bool has_finalizer() const { return _access_flags.has_finalizer(); }
653 bool has_final_method() const { return _access_flags.has_final_method(); }
654 void set_has_finalizer() { _access_flags.set_has_finalizer(); }
655 void set_has_final_method() { _access_flags.set_has_final_method(); }
656 bool is_cloneable() const { return _access_flags.is_cloneable(); }
657 void set_is_cloneable() { _access_flags.set_is_cloneable(); }
658 bool has_vanilla_constructor() const { return _access_flags.has_vanilla_constructor(); }
659 void set_has_vanilla_constructor() { _access_flags.set_has_vanilla_constructor(); }
660 bool has_miranda_methods () const { return access_flags().has_miranda_methods(); }
661 void set_has_miranda_methods() { _access_flags.set_has_miranda_methods(); }
663 // Biased locking support
664 // Note: the prototype header is always set up to be at least the
665 // prototype markOop. If biased locking is enabled it may further be
666 // biasable and have an epoch.
667 markOop prototype_header() const { return _prototype_header; }
668 // NOTE: once instances of this klass are floating around in the
669 // system, this header must only be updated at a safepoint.
670 // NOTE 2: currently we only ever set the prototype header to the
671 // biasable prototype for instanceKlasses. There is no technical
672 // reason why it could not be done for arrayKlasses aside from
673 // wanting to reduce the initial scope of this optimization. There
674 // are potential problems in setting the bias pattern for
675 // JVM-internal oops.
676 inline void set_prototype_header(markOop header);
677 static int prototype_header_offset_in_bytes() { return offset_of(Klass, _prototype_header); }
679 int biased_lock_revocation_count() const { return (int) _biased_lock_revocation_count; }
680 // Atomically increments biased_lock_revocation_count and returns updated value
681 int atomic_incr_biased_lock_revocation_count();
682 void set_biased_lock_revocation_count(int val) { _biased_lock_revocation_count = (jint) val; }
683 jlong last_biased_lock_bulk_revocation_time() { return _last_biased_lock_bulk_revocation_time; }
684 void set_last_biased_lock_bulk_revocation_time(jlong cur_time) { _last_biased_lock_bulk_revocation_time = cur_time; }
687 // garbage collection support
688 virtual void follow_weak_klass_links(
689 BoolObjectClosure* is_alive, OopClosure* keep_alive);
691 // Prefetch within oop iterators. This is a macro because we
692 // can't guarantee that the compiler will inline it. In 64-bit
693 // it generally doesn't. Signature is
694 //
695 // static void prefetch_beyond(oop* const start,
696 // oop* const end,
697 // const intx foffset,
698 // const Prefetch::style pstyle);
699 #define prefetch_beyond(start, end, foffset, pstyle) { \
700 const intx foffset_ = (foffset); \
701 const Prefetch::style pstyle_ = (pstyle); \
702 assert(foffset_ > 0, "prefetch beyond, not behind"); \
703 if (pstyle_ != Prefetch::do_none) { \
704 oop* ref = (start); \
705 if (ref < (end)) { \
706 switch (pstyle_) { \
707 case Prefetch::do_read: \
708 Prefetch::read(*ref, foffset_); \
709 break; \
710 case Prefetch::do_write: \
711 Prefetch::write(*ref, foffset_); \
712 break; \
713 default: \
714 ShouldNotReachHere(); \
715 break; \
716 } \
717 } \
718 } \
719 }
721 // iterators
722 virtual int oop_oop_iterate(oop obj, OopClosure* blk) = 0;
723 virtual int oop_oop_iterate_v(oop obj, OopClosure* blk) {
724 return oop_oop_iterate(obj, blk);
725 }
727 #ifndef SERIALGC
728 // In case we don't have a specialized backward scanner use forward
729 // iteration.
730 virtual int oop_oop_iterate_backwards_v(oop obj, OopClosure* blk) {
731 return oop_oop_iterate_v(obj, blk);
732 }
733 #endif // !SERIALGC
735 // Iterates "blk" over all the oops in "obj" (of type "this") within "mr".
736 // (I don't see why the _m should be required, but without it the Solaris
737 // C++ gives warning messages about overridings of the "oop_oop_iterate"
738 // defined above "hiding" this virtual function. (DLD, 6/20/00)) */
739 virtual int oop_oop_iterate_m(oop obj, OopClosure* blk, MemRegion mr) = 0;
740 virtual int oop_oop_iterate_v_m(oop obj, OopClosure* blk, MemRegion mr) {
741 return oop_oop_iterate_m(obj, blk, mr);
742 }
744 // Versions of the above iterators specialized to particular subtypes
745 // of OopClosure, to avoid closure virtual calls.
746 #define Klass_OOP_OOP_ITERATE_DECL(OopClosureType, nv_suffix) \
747 virtual int oop_oop_iterate##nv_suffix(oop obj, OopClosureType* blk) { \
748 /* Default implementation reverts to general version. */ \
749 return oop_oop_iterate(obj, blk); \
750 } \
751 \
752 /* Iterates "blk" over all the oops in "obj" (of type "this") within "mr". \
753 (I don't see why the _m should be required, but without it the Solaris \
754 C++ gives warning messages about overridings of the "oop_oop_iterate" \
755 defined above "hiding" this virtual function. (DLD, 6/20/00)) */ \
756 virtual int oop_oop_iterate##nv_suffix##_m(oop obj, \
757 OopClosureType* blk, \
758 MemRegion mr) { \
759 return oop_oop_iterate_m(obj, blk, mr); \
760 }
762 SPECIALIZED_OOP_OOP_ITERATE_CLOSURES_1(Klass_OOP_OOP_ITERATE_DECL)
763 SPECIALIZED_OOP_OOP_ITERATE_CLOSURES_2(Klass_OOP_OOP_ITERATE_DECL)
765 #ifndef SERIALGC
766 #define Klass_OOP_OOP_ITERATE_BACKWARDS_DECL(OopClosureType, nv_suffix) \
767 virtual int oop_oop_iterate_backwards##nv_suffix(oop obj, \
768 OopClosureType* blk) { \
769 /* Default implementation reverts to general version. */ \
770 return oop_oop_iterate_backwards_v(obj, blk); \
771 }
773 SPECIALIZED_OOP_OOP_ITERATE_CLOSURES_1(Klass_OOP_OOP_ITERATE_BACKWARDS_DECL)
774 SPECIALIZED_OOP_OOP_ITERATE_CLOSURES_2(Klass_OOP_OOP_ITERATE_BACKWARDS_DECL)
775 #endif // !SERIALGC
777 virtual void array_klasses_do(void f(klassOop k)) {}
778 virtual void with_array_klasses_do(void f(klassOop k));
780 // Return self, except for abstract classes with exactly 1
781 // implementor. Then return the 1 concrete implementation.
782 Klass *up_cast_abstract();
784 // klass name
785 Symbol* name() const { return _name; }
786 void set_name(Symbol* n);
788 friend class klassKlass;
790 public:
791 // jvm support
792 virtual jint compute_modifier_flags(TRAPS) const;
794 // JVMTI support
795 virtual jint jvmti_class_status() const;
797 // Printing
798 virtual void oop_print_value_on(oop obj, outputStream* st);
799 virtual void oop_print_on (oop obj, outputStream* st);
801 // Verification
802 virtual const char* internal_name() const = 0;
803 virtual void oop_verify_on(oop obj, outputStream* st);
804 virtual void oop_verify_old_oop(oop obj, oop* p, bool allow_dirty);
805 virtual void oop_verify_old_oop(oop obj, narrowOop* p, bool allow_dirty);
806 // tells whether obj is partially constructed (gc during class loading)
807 virtual bool oop_partially_loaded(oop obj) const { return false; }
808 virtual void oop_set_partially_loaded(oop obj) {};
810 #ifndef PRODUCT
811 void verify_vtable_index(int index);
812 #endif
813 };
816 inline oop klassOopDesc::java_mirror() const { return klass_part()->java_mirror(); }
819 #endif // SHARE_VM_OOPS_KLASS_HPP