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, 2010, 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_MARKOOP_HPP
26 #define SHARE_VM_OOPS_MARKOOP_HPP
28 #include "oops/oop.hpp"
30 // The markOop describes the header of an object.
31 //
32 // Note that the mark is not a real oop but just a word.
33 // It is placed in the oop hierarchy for historical reasons.
34 //
35 // Bit-format of an object header (most significant first, big endian layout below):
36 //
37 // 32 bits:
38 // --------
39 // hash:25 ------------>| age:4 biased_lock:1 lock:2 (normal object)
40 // JavaThread*:23 epoch:2 age:4 biased_lock:1 lock:2 (biased object)
41 // size:32 ------------------------------------------>| (CMS free block)
42 // PromotedObject*:29 ---------->| promo_bits:3 ----->| (CMS promoted object)
43 //
44 // 64 bits:
45 // --------
46 // unused:25 hash:31 -->| unused:1 age:4 biased_lock:1 lock:2 (normal object)
47 // JavaThread*:54 epoch:2 unused:1 age:4 biased_lock:1 lock:2 (biased object)
48 // PromotedObject*:61 --------------------->| promo_bits:3 ----->| (CMS promoted object)
49 // size:64 ----------------------------------------------------->| (CMS free block)
50 //
51 // unused:25 hash:31 -->| cms_free:1 age:4 biased_lock:1 lock:2 (COOPs && normal object)
52 // JavaThread*:54 epoch:2 cms_free:1 age:4 biased_lock:1 lock:2 (COOPs && biased object)
53 // narrowOop:32 unused:24 cms_free:1 unused:4 promo_bits:3 ----->| (COOPs && CMS promoted object)
54 // unused:21 size:35 -->| cms_free:1 unused:7 ------------------>| (COOPs && CMS free block)
55 //
56 // - hash contains the identity hash value: largest value is
57 // 31 bits, see os::random(). Also, 64-bit vm's require
58 // a hash value no bigger than 32 bits because they will not
59 // properly generate a mask larger than that: see library_call.cpp
60 // and c1_CodePatterns_sparc.cpp.
61 //
62 // - the biased lock pattern is used to bias a lock toward a given
63 // thread. When this pattern is set in the low three bits, the lock
64 // is either biased toward a given thread or "anonymously" biased,
65 // indicating that it is possible for it to be biased. When the
66 // lock is biased toward a given thread, locking and unlocking can
67 // be performed by that thread without using atomic operations.
68 // When a lock's bias is revoked, it reverts back to the normal
69 // locking scheme described below.
70 //
71 // Note that we are overloading the meaning of the "unlocked" state
72 // of the header. Because we steal a bit from the age we can
73 // guarantee that the bias pattern will never be seen for a truly
74 // unlocked object.
75 //
76 // Note also that the biased state contains the age bits normally
77 // contained in the object header. Large increases in scavenge
78 // times were seen when these bits were absent and an arbitrary age
79 // assigned to all biased objects, because they tended to consume a
80 // significant fraction of the eden semispaces and were not
81 // promoted promptly, causing an increase in the amount of copying
82 // performed. The runtime system aligns all JavaThread* pointers to
83 // a very large value (currently 128 bytes (32bVM) or 256 bytes (64bVM))
84 // to make room for the age bits & the epoch bits (used in support of
85 // biased locking), and for the CMS "freeness" bit in the 64bVM (+COOPs).
86 //
87 // [JavaThread* | epoch | age | 1 | 01] lock is biased toward given thread
88 // [0 | epoch | age | 1 | 01] lock is anonymously biased
89 //
90 // - the two lock bits are used to describe three states: locked/unlocked and monitor.
91 //
92 // [ptr | 00] locked ptr points to real header on stack
93 // [header | 0 | 01] unlocked regular object header
94 // [ptr | 10] monitor inflated lock (header is wapped out)
95 // [ptr | 11] marked used by markSweep to mark an object
96 // not valid at any other time
97 //
98 // We assume that stack/thread pointers have the lowest two bits cleared.
100 class BasicLock;
101 class ObjectMonitor;
102 class JavaThread;
104 class markOopDesc: public oopDesc {
105 private:
106 // Conversion
107 uintptr_t value() const { return (uintptr_t) this; }
109 public:
110 // Constants
111 enum { age_bits = 4,
112 lock_bits = 2,
113 biased_lock_bits = 1,
114 max_hash_bits = BitsPerWord - age_bits - lock_bits - biased_lock_bits,
115 hash_bits = max_hash_bits > 31 ? 31 : max_hash_bits,
116 cms_bits = LP64_ONLY(1) NOT_LP64(0),
117 epoch_bits = 2
118 };
120 // The biased locking code currently requires that the age bits be
121 // contiguous to the lock bits.
122 enum { lock_shift = 0,
123 biased_lock_shift = lock_bits,
124 age_shift = lock_bits + biased_lock_bits,
125 cms_shift = age_shift + age_bits,
126 hash_shift = cms_shift + cms_bits,
127 epoch_shift = hash_shift
128 };
130 enum { lock_mask = right_n_bits(lock_bits),
131 lock_mask_in_place = lock_mask << lock_shift,
132 biased_lock_mask = right_n_bits(lock_bits + biased_lock_bits),
133 biased_lock_mask_in_place= biased_lock_mask << lock_shift,
134 biased_lock_bit_in_place = 1 << biased_lock_shift,
135 age_mask = right_n_bits(age_bits),
136 age_mask_in_place = age_mask << age_shift,
137 epoch_mask = right_n_bits(epoch_bits),
138 epoch_mask_in_place = epoch_mask << epoch_shift,
139 cms_mask = right_n_bits(cms_bits),
140 cms_mask_in_place = cms_mask << cms_shift
141 #ifndef _WIN64
142 ,hash_mask = right_n_bits(hash_bits),
143 hash_mask_in_place = (address_word)hash_mask << hash_shift
144 #endif
145 };
147 // Alignment of JavaThread pointers encoded in object header required by biased locking
148 enum { biased_lock_alignment = 2 << (epoch_shift + epoch_bits)
149 };
151 #ifdef _WIN64
152 // These values are too big for Win64
153 const static uintptr_t hash_mask = right_n_bits(hash_bits);
154 const static uintptr_t hash_mask_in_place =
155 (address_word)hash_mask << hash_shift;
156 #endif
158 enum { locked_value = 0,
159 unlocked_value = 1,
160 monitor_value = 2,
161 marked_value = 3,
162 biased_lock_pattern = 5
163 };
165 enum { no_hash = 0 }; // no hash value assigned
167 enum { no_hash_in_place = (address_word)no_hash << hash_shift,
168 no_lock_in_place = unlocked_value
169 };
171 enum { max_age = age_mask };
173 enum { max_bias_epoch = epoch_mask };
175 // Biased Locking accessors.
176 // These must be checked by all code which calls into the
177 // ObjectSynchronizer and other code. The biasing is not understood
178 // by the lower-level CAS-based locking code, although the runtime
179 // fixes up biased locks to be compatible with it when a bias is
180 // revoked.
181 bool has_bias_pattern() const {
182 return (mask_bits(value(), biased_lock_mask_in_place) == biased_lock_pattern);
183 }
184 JavaThread* biased_locker() const {
185 assert(has_bias_pattern(), "should not call this otherwise");
186 return (JavaThread*) ((intptr_t) (mask_bits(value(), ~(biased_lock_mask_in_place | age_mask_in_place | epoch_mask_in_place))));
187 }
188 // Indicates that the mark has the bias bit set but that it has not
189 // yet been biased toward a particular thread
190 bool is_biased_anonymously() const {
191 return (has_bias_pattern() && (biased_locker() == NULL));
192 }
193 // Indicates epoch in which this bias was acquired. If the epoch
194 // changes due to too many bias revocations occurring, the biases
195 // from the previous epochs are all considered invalid.
196 int bias_epoch() const {
197 assert(has_bias_pattern(), "should not call this otherwise");
198 return (mask_bits(value(), epoch_mask_in_place) >> epoch_shift);
199 }
200 markOop set_bias_epoch(int epoch) {
201 assert(has_bias_pattern(), "should not call this otherwise");
202 assert((epoch & (~epoch_mask)) == 0, "epoch overflow");
203 return markOop(mask_bits(value(), ~epoch_mask_in_place) | (epoch << epoch_shift));
204 }
205 markOop incr_bias_epoch() {
206 return set_bias_epoch((1 + bias_epoch()) & epoch_mask);
207 }
208 // Prototype mark for initialization
209 static markOop biased_locking_prototype() {
210 return markOop( biased_lock_pattern );
211 }
213 // lock accessors (note that these assume lock_shift == 0)
214 bool is_locked() const {
215 return (mask_bits(value(), lock_mask_in_place) != unlocked_value);
216 }
217 bool is_unlocked() const {
218 return (mask_bits(value(), biased_lock_mask_in_place) == unlocked_value);
219 }
220 bool is_marked() const {
221 return (mask_bits(value(), lock_mask_in_place) == marked_value);
222 }
223 bool is_neutral() const { return (mask_bits(value(), biased_lock_mask_in_place) == unlocked_value); }
225 // Special temporary state of the markOop while being inflated.
226 // Code that looks at mark outside a lock need to take this into account.
227 bool is_being_inflated() const { return (value() == 0); }
229 // Distinguished markword value - used when inflating over
230 // an existing stacklock. 0 indicates the markword is "BUSY".
231 // Lockword mutators that use a LD...CAS idiom should always
232 // check for and avoid overwriting a 0 value installed by some
233 // other thread. (They should spin or block instead. The 0 value
234 // is transient and *should* be short-lived).
235 static markOop INFLATING() { return (markOop) 0; } // inflate-in-progress
237 // Should this header be preserved during GC?
238 inline bool must_be_preserved(oop obj_containing_mark) const;
239 inline bool must_be_preserved_with_bias(oop obj_containing_mark) const;
241 // Should this header (including its age bits) be preserved in the
242 // case of a promotion failure during scavenge?
243 // Note that we special case this situation. We want to avoid
244 // calling BiasedLocking::preserve_marks()/restore_marks() (which
245 // decrease the number of mark words that need to be preserved
246 // during GC) during each scavenge. During scavenges in which there
247 // is no promotion failure, we actually don't need to call the above
248 // routines at all, since we don't mutate and re-initialize the
249 // marks of promoted objects using init_mark(). However, during
250 // scavenges which result in promotion failure, we do re-initialize
251 // the mark words of objects, meaning that we should have called
252 // these mark word preservation routines. Currently there's no good
253 // place in which to call them in any of the scavengers (although
254 // guarded by appropriate locks we could make one), but the
255 // observation is that promotion failures are quite rare and
256 // reducing the number of mark words preserved during them isn't a
257 // high priority.
258 inline bool must_be_preserved_for_promotion_failure(oop obj_containing_mark) const;
259 inline bool must_be_preserved_with_bias_for_promotion_failure(oop obj_containing_mark) const;
261 // Should this header be preserved during a scavenge where CMS is
262 // the old generation?
263 // (This is basically the same body as must_be_preserved_for_promotion_failure(),
264 // but takes the klassOop as argument instead)
265 inline bool must_be_preserved_for_cms_scavenge(klassOop klass_of_obj_containing_mark) const;
266 inline bool must_be_preserved_with_bias_for_cms_scavenge(klassOop klass_of_obj_containing_mark) const;
268 // WARNING: The following routines are used EXCLUSIVELY by
269 // synchronization functions. They are not really gc safe.
270 // They must get updated if markOop layout get changed.
271 markOop set_unlocked() const {
272 return markOop(value() | unlocked_value);
273 }
274 bool has_locker() const {
275 return ((value() & lock_mask_in_place) == locked_value);
276 }
277 BasicLock* locker() const {
278 assert(has_locker(), "check");
279 return (BasicLock*) value();
280 }
281 bool has_monitor() const {
282 return ((value() & monitor_value) != 0);
283 }
284 ObjectMonitor* monitor() const {
285 assert(has_monitor(), "check");
286 // Use xor instead of &~ to provide one extra tag-bit check.
287 return (ObjectMonitor*) (value() ^ monitor_value);
288 }
289 bool has_displaced_mark_helper() const {
290 return ((value() & unlocked_value) == 0);
291 }
292 markOop displaced_mark_helper() const {
293 assert(has_displaced_mark_helper(), "check");
294 intptr_t ptr = (value() & ~monitor_value);
295 return *(markOop*)ptr;
296 }
297 void set_displaced_mark_helper(markOop m) const {
298 assert(has_displaced_mark_helper(), "check");
299 intptr_t ptr = (value() & ~monitor_value);
300 *(markOop*)ptr = m;
301 }
302 markOop copy_set_hash(intptr_t hash) const {
303 intptr_t tmp = value() & (~hash_mask_in_place);
304 tmp |= ((hash & hash_mask) << hash_shift);
305 return (markOop)tmp;
306 }
307 // it is only used to be stored into BasicLock as the
308 // indicator that the lock is using heavyweight monitor
309 static markOop unused_mark() {
310 return (markOop) marked_value;
311 }
312 // the following two functions create the markOop to be
313 // stored into object header, it encodes monitor info
314 static markOop encode(BasicLock* lock) {
315 return (markOop) lock;
316 }
317 static markOop encode(ObjectMonitor* monitor) {
318 intptr_t tmp = (intptr_t) monitor;
319 return (markOop) (tmp | monitor_value);
320 }
321 static markOop encode(JavaThread* thread, int age, int bias_epoch) {
322 intptr_t tmp = (intptr_t) thread;
323 assert(UseBiasedLocking && ((tmp & (epoch_mask_in_place | age_mask_in_place | biased_lock_mask_in_place)) == 0), "misaligned JavaThread pointer");
324 assert(age <= max_age, "age too large");
325 assert(bias_epoch <= max_bias_epoch, "bias epoch too large");
326 return (markOop) (tmp | (bias_epoch << epoch_shift) | (age << age_shift) | biased_lock_pattern);
327 }
329 // used to encode pointers during GC
330 markOop clear_lock_bits() { return markOop(value() & ~lock_mask_in_place); }
332 // age operations
333 markOop set_marked() { return markOop((value() & ~lock_mask_in_place) | marked_value); }
335 int age() const { return mask_bits(value() >> age_shift, age_mask); }
336 markOop set_age(int v) const {
337 assert((v & ~age_mask) == 0, "shouldn't overflow age field");
338 return markOop((value() & ~age_mask_in_place) | (((intptr_t)v & age_mask) << age_shift));
339 }
340 markOop incr_age() const { return age() == max_age ? markOop(this) : set_age(age() + 1); }
342 // hash operations
343 intptr_t hash() const {
344 return mask_bits(value() >> hash_shift, hash_mask);
345 }
347 bool has_no_hash() const {
348 return hash() == no_hash;
349 }
351 // Prototype mark for initialization
352 static markOop prototype() {
353 return markOop( no_hash_in_place | no_lock_in_place );
354 }
356 // Helper function for restoration of unmarked mark oops during GC
357 static inline markOop prototype_for_object(oop obj);
359 // Debugging
360 void print_on(outputStream* st) const;
362 // Prepare address of oop for placement into mark
363 inline static markOop encode_pointer_as_mark(void* p) { return markOop(p)->set_marked(); }
365 // Recover address of oop from encoded form used in mark
366 inline void* decode_pointer() { if (UseBiasedLocking && has_bias_pattern()) return NULL; return clear_lock_bits(); }
368 // see the definition in markOop.cpp for the gory details
369 bool should_not_be_cached() const;
371 // These markOops indicate cms free chunk blocks and not objects.
372 // In 64 bit, the markOop is set to distinguish them from oops.
373 // These are defined in 32 bit mode for vmStructs.
374 const static uintptr_t cms_free_chunk_pattern = 0x1;
376 // Constants for the size field.
377 enum { size_shift = cms_shift + cms_bits,
378 size_bits = 35 // need for compressed oops 32G
379 };
380 // These values are too big for Win64
381 const static uintptr_t size_mask = LP64_ONLY(right_n_bits(size_bits))
382 NOT_LP64(0);
383 const static uintptr_t size_mask_in_place =
384 (address_word)size_mask << size_shift;
386 #ifdef _LP64
387 static markOop cms_free_prototype() {
388 return markOop(((intptr_t)prototype() & ~cms_mask_in_place) |
389 ((cms_free_chunk_pattern & cms_mask) << cms_shift));
390 }
391 uintptr_t cms_encoding() const {
392 return mask_bits(value() >> cms_shift, cms_mask);
393 }
394 bool is_cms_free_chunk() const {
395 return is_neutral() &&
396 (cms_encoding() & cms_free_chunk_pattern) == cms_free_chunk_pattern;
397 }
399 size_t get_size() const { return (size_t)(value() >> size_shift); }
400 static markOop set_size_and_free(size_t size) {
401 assert((size & ~size_mask) == 0, "shouldn't overflow size field");
402 return markOop(((intptr_t)cms_free_prototype() & ~size_mask_in_place) |
403 (((intptr_t)size & size_mask) << size_shift));
404 }
405 #endif // _LP64
406 };
408 #endif // SHARE_VM_OOPS_MARKOOP_HPP