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_OOP_HPP
26 #define SHARE_VM_OOPS_OOP_HPP
28 #include "memory/iterator.hpp"
29 #include "memory/memRegion.hpp"
30 #include "memory/specialized_oop_closures.hpp"
31 #include "utilities/top.hpp"
33 // oopDesc is the top baseclass for objects classes. The {name}Desc classes describe
34 // the format of Java objects so the fields can be accessed from C++.
35 // oopDesc is abstract.
36 // (see oopHierarchy for complete oop class hierarchy)
37 //
38 // no virtual functions allowed
40 // store into oop with store check
41 template <class T> void oop_store(T* p, oop v);
42 template <class T> void oop_store(volatile T* p, oop v);
44 // store into oop without store check
45 template <class T> void oop_store_without_check(T* p, oop v);
46 template <class T> void oop_store_without_check(volatile T* p, oop v);
48 extern bool always_do_update_barrier;
50 // Forward declarations.
51 class OopClosure;
52 class ScanClosure;
53 class FastScanClosure;
54 class FilteringClosure;
55 class BarrierSet;
56 class CMSIsAliveClosure;
58 class PSPromotionManager;
59 class ParCompactionManager;
61 class oopDesc {
62 friend class VMStructs;
63 private:
64 volatile markOop _mark;
65 union _metadata {
66 wideKlassOop _klass;
67 narrowOop _compressed_klass;
68 } _metadata;
70 // Fast access to barrier set. Must be initialized.
71 static BarrierSet* _bs;
73 public:
74 enum ConcSafeType {
75 IsUnsafeConc = false,
76 IsSafeConc = true
77 };
79 markOop mark() const { return _mark; }
80 markOop* mark_addr() const { return (markOop*) &_mark; }
82 void set_mark(volatile markOop m) { _mark = m; }
84 void release_set_mark(markOop m);
85 markOop cas_set_mark(markOop new_mark, markOop old_mark);
87 // Used only to re-initialize the mark word (e.g., of promoted
88 // objects during a GC) -- requires a valid klass pointer
89 void init_mark();
91 klassOop klass() const;
92 klassOop klass_or_null() const volatile;
93 oop* klass_addr();
94 narrowOop* compressed_klass_addr();
96 void set_klass(klassOop k);
98 // For klass field compression
99 int klass_gap() const;
100 void set_klass_gap(int z);
101 // For when the klass pointer is being used as a linked list "next" field.
102 void set_klass_to_list_ptr(oop k);
104 // size of object header, aligned to platform wordSize
105 static int header_size() { return sizeof(oopDesc)/HeapWordSize; }
107 Klass* blueprint() const;
109 // Returns whether this is an instance of k or an instance of a subclass of k
110 bool is_a(klassOop k) const;
112 // Returns the actual oop size of the object
113 int size();
115 // Sometimes (for complicated concurrency-related reasons), it is useful
116 // to be able to figure out the size of an object knowing its klass.
117 int size_given_klass(Klass* klass);
119 // Some perm gen objects are not parseble immediately after
120 // installation of their klass pointer.
121 bool is_parsable();
123 // Some perm gen objects that have been allocated and initialized
124 // can be changed by the VM when not at a safe point (class rededfinition
125 // is an example). Such objects should not be examined by the
126 // concurrent processing of a garbage collector if is_conc_safe()
127 // returns false.
128 bool is_conc_safe();
130 // type test operations (inlined in oop.inline.h)
131 bool is_instance() const;
132 bool is_instanceMirror() const;
133 bool is_instanceRef() const;
134 bool is_array() const;
135 bool is_objArray() const;
136 bool is_klass() const;
137 bool is_thread() const;
138 bool is_method() const;
139 bool is_constMethod() const;
140 bool is_methodData() const;
141 bool is_constantPool() const;
142 bool is_constantPoolCache() const;
143 bool is_typeArray() const;
144 bool is_javaArray() const;
145 bool is_compiledICHolder() const;
147 private:
148 // field addresses in oop
149 void* field_base(int offset) const;
151 jbyte* byte_field_addr(int offset) const;
152 jchar* char_field_addr(int offset) const;
153 jboolean* bool_field_addr(int offset) const;
154 jint* int_field_addr(int offset) const;
155 jshort* short_field_addr(int offset) const;
156 jlong* long_field_addr(int offset) const;
157 jfloat* float_field_addr(int offset) const;
158 jdouble* double_field_addr(int offset) const;
159 address* address_field_addr(int offset) const;
161 public:
162 // Need this as public for garbage collection.
163 template <class T> T* obj_field_addr(int offset) const;
165 static bool is_null(oop obj);
166 static bool is_null(narrowOop obj);
168 // Decode an oop pointer from a narrowOop if compressed.
169 // These are overloaded for oop and narrowOop as are the other functions
170 // below so that they can be called in template functions.
171 static oop decode_heap_oop_not_null(oop v);
172 static oop decode_heap_oop_not_null(narrowOop v);
173 static oop decode_heap_oop(oop v);
174 static oop decode_heap_oop(narrowOop v);
176 // Encode an oop pointer to a narrow oop. The or_null versions accept
177 // null oop pointer, others do not in order to eliminate the
178 // null checking branches.
179 static narrowOop encode_heap_oop_not_null(oop v);
180 static narrowOop encode_heap_oop(oop v);
182 // Load an oop out of the Java heap
183 static narrowOop load_heap_oop(narrowOop* p);
184 static oop load_heap_oop(oop* p);
186 // Load an oop out of Java heap and decode it to an uncompressed oop.
187 static oop load_decode_heap_oop_not_null(narrowOop* p);
188 static oop load_decode_heap_oop_not_null(oop* p);
189 static oop load_decode_heap_oop(narrowOop* p);
190 static oop load_decode_heap_oop(oop* p);
192 // Store an oop into the heap.
193 static void store_heap_oop(narrowOop* p, narrowOop v);
194 static void store_heap_oop(oop* p, oop v);
196 // Encode oop if UseCompressedOops and store into the heap.
197 static void encode_store_heap_oop_not_null(narrowOop* p, oop v);
198 static void encode_store_heap_oop_not_null(oop* p, oop v);
199 static void encode_store_heap_oop(narrowOop* p, oop v);
200 static void encode_store_heap_oop(oop* p, oop v);
202 static void release_store_heap_oop(volatile narrowOop* p, narrowOop v);
203 static void release_store_heap_oop(volatile oop* p, oop v);
205 static void release_encode_store_heap_oop_not_null(volatile narrowOop* p, oop v);
206 static void release_encode_store_heap_oop_not_null(volatile oop* p, oop v);
207 static void release_encode_store_heap_oop(volatile narrowOop* p, oop v);
208 static void release_encode_store_heap_oop(volatile oop* p, oop v);
210 static oop atomic_exchange_oop(oop exchange_value, volatile HeapWord *dest);
211 static oop atomic_compare_exchange_oop(oop exchange_value,
212 volatile HeapWord *dest,
213 oop compare_value);
215 // Access to fields in a instanceOop through these methods.
216 oop obj_field(int offset) const;
217 void obj_field_put(int offset, oop value);
218 void obj_field_raw_put(int offset, oop value);
220 jbyte byte_field(int offset) const;
221 void byte_field_put(int offset, jbyte contents);
223 jchar char_field(int offset) const;
224 void char_field_put(int offset, jchar contents);
226 jboolean bool_field(int offset) const;
227 void bool_field_put(int offset, jboolean contents);
229 jint int_field(int offset) const;
230 void int_field_put(int offset, jint contents);
232 jshort short_field(int offset) const;
233 void short_field_put(int offset, jshort contents);
235 jlong long_field(int offset) const;
236 void long_field_put(int offset, jlong contents);
238 jfloat float_field(int offset) const;
239 void float_field_put(int offset, jfloat contents);
241 jdouble double_field(int offset) const;
242 void double_field_put(int offset, jdouble contents);
244 address address_field(int offset) const;
245 void address_field_put(int offset, address contents);
247 oop obj_field_acquire(int offset) const;
248 void release_obj_field_put(int offset, oop value);
250 jbyte byte_field_acquire(int offset) const;
251 void release_byte_field_put(int offset, jbyte contents);
253 jchar char_field_acquire(int offset) const;
254 void release_char_field_put(int offset, jchar contents);
256 jboolean bool_field_acquire(int offset) const;
257 void release_bool_field_put(int offset, jboolean contents);
259 jint int_field_acquire(int offset) const;
260 void release_int_field_put(int offset, jint contents);
262 jshort short_field_acquire(int offset) const;
263 void release_short_field_put(int offset, jshort contents);
265 jlong long_field_acquire(int offset) const;
266 void release_long_field_put(int offset, jlong contents);
268 jfloat float_field_acquire(int offset) const;
269 void release_float_field_put(int offset, jfloat contents);
271 jdouble double_field_acquire(int offset) const;
272 void release_double_field_put(int offset, jdouble contents);
274 address address_field_acquire(int offset) const;
275 void release_address_field_put(int offset, address contents);
277 // printing functions for VM debugging
278 void print_on(outputStream* st) const; // First level print
279 void print_value_on(outputStream* st) const; // Second level print.
280 void print_address_on(outputStream* st) const; // Address printing
282 // printing on default output stream
283 void print();
284 void print_value();
285 void print_address();
287 // return the print strings
288 char* print_string();
289 char* print_value_string();
291 // verification operations
292 void verify_on(outputStream* st);
293 void verify();
294 void verify_old_oop(oop* p, bool allow_dirty);
295 void verify_old_oop(narrowOop* p, bool allow_dirty);
297 // tells whether this oop is partially constructed (gc during class loading)
298 bool partially_loaded();
299 void set_partially_loaded();
301 // locking operations
302 bool is_locked() const;
303 bool is_unlocked() const;
304 bool has_bias_pattern() const;
306 // asserts
307 bool is_oop(bool ignore_mark_word = false) const;
308 bool is_oop_or_null(bool ignore_mark_word = false) const;
309 #ifndef PRODUCT
310 bool is_unlocked_oop() const;
311 #endif
313 // garbage collection
314 bool is_gc_marked() const;
315 // Apply "MarkSweep::mark_and_push" to (the address of) every non-NULL
316 // reference field in "this".
317 void follow_contents(void);
318 void follow_header(void);
320 #ifndef SERIALGC
321 // Parallel Scavenge
322 void push_contents(PSPromotionManager* pm);
324 // Parallel Old
325 void update_contents(ParCompactionManager* cm);
327 void follow_contents(ParCompactionManager* cm);
328 void follow_header(ParCompactionManager* cm);
329 #endif // SERIALGC
331 bool is_perm() const;
332 bool is_perm_or_null() const;
333 bool is_scavengable() const;
334 bool is_shared() const;
335 bool is_shared_readonly() const;
336 bool is_shared_readwrite() const;
338 // Forward pointer operations for scavenge
339 bool is_forwarded() const;
341 void forward_to(oop p);
342 bool cas_forward_to(oop p, markOop compare);
344 #ifndef SERIALGC
345 // Like "forward_to", but inserts the forwarding pointer atomically.
346 // Exactly one thread succeeds in inserting the forwarding pointer, and
347 // this call returns "NULL" for that thread; any other thread has the
348 // value of the forwarding pointer returned and does not modify "this".
349 oop forward_to_atomic(oop p);
350 #endif // SERIALGC
352 oop forwardee() const;
354 // Age of object during scavenge
355 int age() const;
356 void incr_age();
358 // Adjust all pointers in this object to point at it's forwarded location and
359 // return the size of this oop. This is used by the MarkSweep collector.
360 int adjust_pointers();
361 void adjust_header();
363 #ifndef SERIALGC
364 // Parallel old
365 void update_header();
366 #endif // SERIALGC
368 // mark-sweep support
369 void follow_body(int begin, int end);
371 // Fast access to barrier set
372 static BarrierSet* bs() { return _bs; }
373 static void set_bs(BarrierSet* bs) { _bs = bs; }
375 // iterators, returns size of object
376 #define OOP_ITERATE_DECL(OopClosureType, nv_suffix) \
377 int oop_iterate(OopClosureType* blk); \
378 int oop_iterate(OopClosureType* blk, MemRegion mr); // Only in mr.
380 ALL_OOP_OOP_ITERATE_CLOSURES_1(OOP_ITERATE_DECL)
381 ALL_OOP_OOP_ITERATE_CLOSURES_2(OOP_ITERATE_DECL)
383 #ifndef SERIALGC
385 #define OOP_ITERATE_BACKWARDS_DECL(OopClosureType, nv_suffix) \
386 int oop_iterate_backwards(OopClosureType* blk);
388 ALL_OOP_OOP_ITERATE_CLOSURES_1(OOP_ITERATE_BACKWARDS_DECL)
389 ALL_OOP_OOP_ITERATE_CLOSURES_2(OOP_ITERATE_BACKWARDS_DECL)
390 #endif
392 void oop_iterate_header(OopClosure* blk);
393 void oop_iterate_header(OopClosure* blk, MemRegion mr);
395 // identity hash; returns the identity hash key (computes it if necessary)
396 // NOTE with the introduction of UseBiasedLocking that identity_hash() might reach a
397 // safepoint if called on a biased object. Calling code must be aware of that.
398 intptr_t identity_hash();
399 intptr_t slow_identity_hash();
401 // marks are forwarded to stack when object is locked
402 bool has_displaced_mark() const;
403 markOop displaced_mark() const;
404 void set_displaced_mark(markOop m);
406 // for code generation
407 static int mark_offset_in_bytes() { return offset_of(oopDesc, _mark); }
408 static int klass_offset_in_bytes() { return offset_of(oopDesc, _metadata._klass); }
409 static int klass_gap_offset_in_bytes();
410 };
412 #endif // SHARE_VM_OOPS_OOP_HPP