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 */
24
25 #ifndef SHARE_OOPS_OOP_INLINE_HPP
26 #define SHARE_OOPS_OOP_INLINE_HPP
27
28 #include "oops/oop.hpp"
29
30 #include "memory/universe.hpp"
31 #include "memory/iterator.inline.hpp"
32 #include "oops/access.inline.hpp"
33 #include "oops/arrayKlass.hpp"
34 #include "oops/arrayOop.hpp"
35 #include "oops/compressedOops.inline.hpp"
36 #include "oops/instanceKlass.hpp"
37 #include "oops/markWord.hpp"
38 #include "oops/oopsHierarchy.hpp"
39 #include "runtime/atomic.hpp"
40 #include "runtime/globals.hpp"
41 #include "utilities/align.hpp"
42 #include "utilities/debug.hpp"
43 #include "utilities/macros.hpp"
44 #include "utilities/globalDefinitions.hpp"
45
46 // Implementation of all inlined member functions defined in oop.hpp
47 // We need a separate file to avoid circular references
48
49 markWord oopDesc::mark() const {
50 return Atomic::load(&_mark);
51 }
52
53 markWord oopDesc::mark_acquire() const {
54 return Atomic::load_acquire(&_mark);
55 }
56
57 markWord* oopDesc::mark_addr() const {
58 return (markWord*) &_mark;
59 }
60
61 void oopDesc::set_mark(markWord m) {
62 Atomic::store(&_mark, m);
63 }
64
65 void oopDesc::set_mark(HeapWord* mem, markWord m) {
66 *(markWord*)(((char*)mem) + mark_offset_in_bytes()) = m;
67 }
68
69 void oopDesc::release_set_mark(markWord m) {
70 Atomic::release_store(&_mark, m);
71 }
72
73 markWord oopDesc::cas_set_mark(markWord new_mark, markWord old_mark) {
74 return Atomic::cmpxchg(&_mark, old_mark, new_mark);
75 }
76
77 markWord oopDesc::cas_set_mark(markWord new_mark, markWord old_mark, atomic_memory_order order) {
78 return Atomic::cmpxchg(&_mark, old_mark, new_mark, order);
79 }
80
81 void oopDesc::init_mark() {
82 set_mark(markWord::prototype());
83 }
84
85 Klass* oopDesc::klass() const {
86 if (UseCompressedClassPointers) {
87 return CompressedKlassPointers::decode_not_null(_metadata._compressed_klass);
88 } else {
89 return _metadata._klass;
90 }
91 }
92
93 Klass* oopDesc::klass_or_null() const {
94 if (UseCompressedClassPointers) {
95 return CompressedKlassPointers::decode(_metadata._compressed_klass);
96 } else {
97 return _metadata._klass;
98 }
99 }
100
101 Klass* oopDesc::klass_or_null_acquire() const {
102 if (UseCompressedClassPointers) {
103 narrowKlass nklass = Atomic::load_acquire(&_metadata._compressed_klass);
104 return CompressedKlassPointers::decode(nklass);
105 } else {
106 return Atomic::load_acquire(&_metadata._klass);
107 }
108 }
109
110 Klass* oopDesc::klass_raw() const {
111 if (UseCompressedClassPointers) {
112 return CompressedKlassPointers::decode_raw(_metadata._compressed_klass);
113 } else {
114 return _metadata._klass;
115 }
116 }
117
118 void oopDesc::set_klass(Klass* k) {
119 assert(Universe::is_bootstrapping() || (k != nullptr && k->is_klass()), "incorrect Klass");
120 if (UseCompressedClassPointers) {
121 _metadata._compressed_klass = CompressedKlassPointers::encode_not_null(k);
122 } else {
123 _metadata._klass = k;
124 }
125 }
126
127 void oopDesc::release_set_klass(HeapWord* mem, Klass* k) {
128 assert(Universe::is_bootstrapping() || (k != nullptr && k->is_klass()), "incorrect Klass");
129 char* raw_mem = ((char*)mem + klass_offset_in_bytes());
130 if (UseCompressedClassPointers) {
131 Atomic::release_store((narrowKlass*)raw_mem,
132 CompressedKlassPointers::encode_not_null(k));
133 } else {
134 Atomic::release_store((Klass**)raw_mem, k);
135 }
136 }
137
138 void oopDesc::set_klass_gap(HeapWord* mem, int v) {
139 if (UseCompressedClassPointers) {
140 *(int*)(((char*)mem) + klass_gap_offset_in_bytes()) = v;
141 }
142 }
143
144 bool oopDesc::is_a(Klass* k) const {
145 return klass()->is_subtype_of(k);
146 }
147
148 size_t oopDesc::size() {
149 return size_given_klass(klass());
150 }
151
152 size_t oopDesc::size_given_klass(Klass* klass) {
153 int lh = klass->layout_helper();
154 size_t s;
155
156 // lh is now a value computed at class initialization that may hint
157 // at the size. For instances, this is positive and equal to the
158 // size. For arrays, this is negative and provides log2 of the
251 bool oopDesc::is_unlocked() const {
252 return mark().is_unlocked();
253 }
254
255 // Used only for markSweep, scavenging
256 bool oopDesc::is_gc_marked() const {
257 return mark().is_marked();
258 }
259
260 // Used by scavengers
261 bool oopDesc::is_forwarded() const {
262 // The extra heap check is needed since the obj might be locked, in which case the
263 // mark would point to a stack location and have the sentinel bit cleared
264 return mark().is_marked();
265 }
266
267 // Used by scavengers
268 void oopDesc::forward_to(oop p) {
269 verify_forwardee(p);
270 markWord m = markWord::encode_pointer_as_mark(p);
271 assert(m.decode_pointer() == p, "encoding must be reversible");
272 set_mark(m);
273 }
274
275 oop oopDesc::forward_to_atomic(oop p, markWord compare, atomic_memory_order order) {
276 verify_forwardee(p);
277 markWord m = markWord::encode_pointer_as_mark(p);
278 assert(m.decode_pointer() == p, "encoding must be reversible");
279 markWord old_mark = cas_set_mark(m, compare, order);
280 if (old_mark == compare) {
281 return nullptr;
282 } else {
283 return cast_to_oop(old_mark.decode_pointer());
284 }
285 }
286
287 // Note that the forwardee is not the same thing as the displaced_mark.
288 // The forwardee is used when copying during scavenge and mark-sweep.
289 // It does need to clear the low two locking- and GC-related bits.
290 oop oopDesc::forwardee() const {
291 assert(is_forwarded(), "only decode when actually forwarded");
292 return cast_to_oop(mark().decode_pointer());
293 }
294
295 // The following method needs to be MT safe.
296 uint oopDesc::age() const {
297 assert(!mark().is_marked(), "Attempt to read age from forwarded mark");
298 if (has_displaced_mark()) {
299 return displaced_mark().age();
300 } else {
301 return mark().age();
302 }
303 }
304
305 void oopDesc::incr_age() {
306 assert(!mark().is_marked(), "Attempt to increment age of forwarded mark");
307 if (has_displaced_mark()) {
308 set_displaced_mark(displaced_mark().incr_age());
309 } else {
310 set_mark(mark().incr_age());
311 }
312 }
327 size_t size = size_given_klass(k);
328 OopIteratorClosureDispatch::oop_oop_iterate(cl, this, k);
329 return size;
330 }
331
332 template <typename OopClosureType>
333 size_t oopDesc::oop_iterate_size(OopClosureType* cl, MemRegion mr) {
334 Klass* k = klass();
335 size_t size = size_given_klass(k);
336 OopIteratorClosureDispatch::oop_oop_iterate(cl, this, k, mr);
337 return size;
338 }
339
340 template <typename OopClosureType>
341 void oopDesc::oop_iterate_backwards(OopClosureType* cl) {
342 oop_iterate_backwards(cl, klass());
343 }
344
345 template <typename OopClosureType>
346 void oopDesc::oop_iterate_backwards(OopClosureType* cl, Klass* k) {
347 assert(k == klass(), "wrong klass");
348 OopIteratorClosureDispatch::oop_oop_iterate_backwards(cl, this, k);
349 }
350
351 bool oopDesc::is_instanceof_or_null(oop obj, Klass* klass) {
352 return obj == nullptr || obj->klass()->is_subtype_of(klass);
353 }
354
355 intptr_t oopDesc::identity_hash() {
356 // Fast case; if the object is unlocked and the hash value is set, no locking is needed
357 // Note: The mark must be read into local variable to avoid concurrent updates.
358 markWord mrk = mark();
359 if (mrk.is_unlocked() && !mrk.has_no_hash()) {
360 return mrk.hash();
361 } else if (mrk.is_marked()) {
362 return mrk.hash();
363 } else {
364 return slow_identity_hash();
365 }
366 }
367
|
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 */
24
25 #ifndef SHARE_OOPS_OOP_INLINE_HPP
26 #define SHARE_OOPS_OOP_INLINE_HPP
27
28 #include "oops/oop.hpp"
29
30 #include "memory/universe.hpp"
31 #include "memory/iterator.inline.hpp"
32 #include "oops/access.inline.hpp"
33 #include "oops/arrayKlass.hpp"
34 #include "oops/arrayOop.hpp"
35 #include "oops/compressedKlass.inline.hpp"
36 #include "oops/compressedOops.inline.hpp"
37 #include "oops/instanceKlass.hpp"
38 #include "oops/markWord.inline.hpp"
39 #include "oops/oopsHierarchy.hpp"
40 #include "runtime/atomic.hpp"
41 #include "runtime/globals.hpp"
42 #include "runtime/objectMonitor.inline.hpp"
43 #include "runtime/safepoint.hpp"
44 #include "runtime/synchronizer.hpp"
45 #include "utilities/align.hpp"
46 #include "utilities/debug.hpp"
47 #include "utilities/macros.hpp"
48 #include "utilities/globalDefinitions.hpp"
49
50 // Implementation of all inlined member functions defined in oop.hpp
51 // We need a separate file to avoid circular references
52
53 markWord oopDesc::mark() const {
54 return Atomic::load(&_mark);
55 }
56
57 markWord oopDesc::mark_acquire() const {
58 return Atomic::load_acquire(&_mark);
59 }
60
61 markWord* oopDesc::mark_addr() const {
62 return (markWord*) &_mark;
63 }
64
65 void oopDesc::set_mark(markWord m) {
66 Atomic::store(&_mark, m);
67 }
68
69 void oopDesc::set_mark(HeapWord* mem, markWord m) {
70 *(markWord*)(((char*)mem) + mark_offset_in_bytes()) = m;
71 }
72
73 void oopDesc::release_set_mark(markWord m) {
74 Atomic::release_store(&_mark, m);
75 }
76
77 void oopDesc::release_set_mark(HeapWord* mem, markWord m) {
78 Atomic::release_store((markWord*)(((char*)mem) + mark_offset_in_bytes()), m);
79 }
80
81 markWord oopDesc::cas_set_mark(markWord new_mark, markWord old_mark) {
82 return Atomic::cmpxchg(&_mark, old_mark, new_mark);
83 }
84
85 markWord oopDesc::cas_set_mark(markWord new_mark, markWord old_mark, atomic_memory_order order) {
86 return Atomic::cmpxchg(&_mark, old_mark, new_mark, order);
87 }
88
89 markWord oopDesc::resolve_mark() const {
90 assert(UseFastLocking, "Only safe with fast-locking");
91 markWord hdr = mark();
92 if (hdr.has_monitor()) {
93 ObjectMonitor* monitor = hdr.monitor();
94 return monitor->header();
95 }
96 return hdr;
97 }
98
99 void oopDesc::init_mark() {
100 #ifdef _LP64
101 if (UseCompactObjectHeaders) {
102 markWord header = resolve_mark();
103 assert(UseCompressedClassPointers, "expect compressed klass pointers");
104 set_mark(markWord((header.value() & markWord::klass_mask_in_place) | markWord::prototype().value()));
105 } else
106 #endif
107 set_mark(markWord::prototype());
108 }
109
110 Klass* oopDesc::klass() const {
111 #ifdef _LP64
112 if (UseCompactObjectHeaders) {
113 assert(UseCompressedClassPointers, "only with compressed class pointers");
114 markWord header = resolve_mark();
115 return header.klass();
116 } else if (UseCompressedClassPointers) {
117 return CompressedKlassPointers::decode_not_null(_metadata._compressed_klass);
118 } else
119 #endif
120 return _metadata._klass;
121 }
122
123 Klass* oopDesc::klass_or_null() const {
124 #ifdef _LP64
125 if (UseCompactObjectHeaders) {
126 assert(UseCompressedClassPointers, "only with compressed class pointers");
127 markWord header = resolve_mark();
128 return header.klass_or_null();
129 } else if (UseCompressedClassPointers) {
130 return CompressedKlassPointers::decode(_metadata._compressed_klass);
131 } else
132 #endif
133 return _metadata._klass;
134 }
135
136 Klass* oopDesc::klass_or_null_acquire() const {
137 #ifdef _LP64
138 if (UseCompactObjectHeaders) {
139 assert(UseCompressedClassPointers, "only with compressed class pointers");
140 markWord header = mark_acquire();
141 if (header.has_monitor()) {
142 header = header.monitor()->header();
143 }
144 return header.klass_or_null();
145 } else if (UseCompressedClassPointers) {
146 narrowKlass nklass = Atomic::load_acquire(&_metadata._compressed_klass);
147 return CompressedKlassPointers::decode(nklass);
148 } else
149 #endif
150 return Atomic::load_acquire(&_metadata._klass);
151 }
152
153 Klass* oopDesc::klass_raw() const {
154 return klass();
155 }
156
157 void oopDesc::set_klass(Klass* k) {
158 assert(Universe::is_bootstrapping() || (k != NULL && k->is_klass()), "incorrect Klass");
159 assert(!UseCompactObjectHeaders, "don't set Klass* with compact headers");
160 if (UseCompressedClassPointers) {
161 _metadata._compressed_klass = CompressedKlassPointers::encode_not_null(k);
162 } else {
163 _metadata._klass = k;
164 }
165 }
166
167 void oopDesc::release_set_klass(HeapWord* mem, Klass* k) {
168 assert(Universe::is_bootstrapping() || (k != NULL && k->is_klass()), "incorrect Klass");
169 assert(!UseCompactObjectHeaders, "don't set Klass* with compact headers");
170 char* raw_mem = ((char*)mem + klass_offset_in_bytes());
171 if (UseCompressedClassPointers) {
172 Atomic::release_store((narrowKlass*)raw_mem,
173 CompressedKlassPointers::encode_not_null(k));
174 } else {
175 Atomic::release_store((Klass**)raw_mem, k);
176 }
177 }
178
179 void oopDesc::set_klass_gap(HeapWord* mem, int v) {
180 assert(!UseCompactObjectHeaders, "don't set Klass* gap with compact headers");
181 if (UseCompressedClassPointers) {
182 *(int*)(((char*)mem) + klass_gap_offset_in_bytes()) = v;
183 }
184 }
185
186 bool oopDesc::is_a(Klass* k) const {
187 return klass()->is_subtype_of(k);
188 }
189
190 size_t oopDesc::size() {
191 return size_given_klass(klass());
192 }
193
194 size_t oopDesc::size_given_klass(Klass* klass) {
195 int lh = klass->layout_helper();
196 size_t s;
197
198 // lh is now a value computed at class initialization that may hint
199 // at the size. For instances, this is positive and equal to the
200 // size. For arrays, this is negative and provides log2 of the
293 bool oopDesc::is_unlocked() const {
294 return mark().is_unlocked();
295 }
296
297 // Used only for markSweep, scavenging
298 bool oopDesc::is_gc_marked() const {
299 return mark().is_marked();
300 }
301
302 // Used by scavengers
303 bool oopDesc::is_forwarded() const {
304 // The extra heap check is needed since the obj might be locked, in which case the
305 // mark would point to a stack location and have the sentinel bit cleared
306 return mark().is_marked();
307 }
308
309 // Used by scavengers
310 void oopDesc::forward_to(oop p) {
311 verify_forwardee(p);
312 markWord m = markWord::encode_pointer_as_mark(p);
313 assert(forwardee(m) == p, "encoding must be reversable");
314 set_mark(m);
315 }
316
317 void oopDesc::forward_to_self() {
318 #ifdef _LP64
319 verify_forwardee(this);
320 markWord m = mark();
321 // If mark is displaced, we need to preserve the Klass* from real header.
322 assert(SafepointSynchronize::is_at_safepoint(), "we can only safely fetch the displaced header at safepoint");
323 if (m.has_displaced_mark_helper()) {
324 m = m.displaced_mark_helper();
325 }
326 m = m.set_self_forwarded();
327 assert(forwardee(m) == cast_to_oop(this), "encoding must be reversable");
328 set_mark(m);
329 #else
330 forward_to(oop(this));
331 #endif
332 }
333
334 oop oopDesc::forward_to_atomic(oop p, markWord compare, atomic_memory_order order) {
335 verify_forwardee(p);
336 markWord m = markWord::encode_pointer_as_mark(p);
337 assert(forwardee(m) == p, "encoding must be reversable");
338 markWord old_mark = cas_set_mark(m, compare, order);
339 if (old_mark == compare) {
340 return nullptr;
341 } else {
342 return forwardee(old_mark);
343 }
344 }
345
346 oop oopDesc::forward_to_self_atomic(markWord compare, atomic_memory_order order) {
347 #ifdef _LP64
348 verify_forwardee(this);
349 markWord m = compare;
350 // If mark is displaced, we need to preserve the Klass* from real header.
351 assert(SafepointSynchronize::is_at_safepoint(), "we can only safely fetch the displaced header at safepoint");
352 if (m.has_displaced_mark_helper()) {
353 m = m.displaced_mark_helper();
354 }
355 m = m.set_self_forwarded();
356 assert(forwardee(m) == cast_to_oop(this), "encoding must be reversable");
357 markWord old_mark = cas_set_mark(m, compare, order);
358 if (old_mark == compare) {
359 return NULL;
360 } else {
361 assert(old_mark.is_marked(), "must be marked here");
362 return forwardee(old_mark);
363 }
364 #else
365 return forward_to_atomic(oop(this), compare, order);
366 #endif
367 }
368
369 // Note that the forwardee is not the same thing as the displaced_mark.
370 // The forwardee is used when copying during scavenge and mark-sweep.
371 // It does need to clear the low two locking- and GC-related bits.
372 oop oopDesc::forwardee() const {
373 return forwardee(mark());
374 }
375
376 oop oopDesc::forwardee(markWord header) const {
377 assert(header.is_marked(), "must be forwarded");
378 #ifdef _LP64
379 if (header.self_forwarded()) {
380 return cast_to_oop(this);
381 } else
382 #endif
383 {
384 assert(header.is_marked(), "only decode when actually forwarded");
385 return cast_to_oop(header.decode_pointer());
386 }
387 }
388
389 // The following method needs to be MT safe.
390 uint oopDesc::age() const {
391 assert(!mark().is_marked(), "Attempt to read age from forwarded mark");
392 if (has_displaced_mark()) {
393 return displaced_mark().age();
394 } else {
395 return mark().age();
396 }
397 }
398
399 void oopDesc::incr_age() {
400 assert(!mark().is_marked(), "Attempt to increment age of forwarded mark");
401 if (has_displaced_mark()) {
402 set_displaced_mark(displaced_mark().incr_age());
403 } else {
404 set_mark(mark().incr_age());
405 }
406 }
421 size_t size = size_given_klass(k);
422 OopIteratorClosureDispatch::oop_oop_iterate(cl, this, k);
423 return size;
424 }
425
426 template <typename OopClosureType>
427 size_t oopDesc::oop_iterate_size(OopClosureType* cl, MemRegion mr) {
428 Klass* k = klass();
429 size_t size = size_given_klass(k);
430 OopIteratorClosureDispatch::oop_oop_iterate(cl, this, k, mr);
431 return size;
432 }
433
434 template <typename OopClosureType>
435 void oopDesc::oop_iterate_backwards(OopClosureType* cl) {
436 oop_iterate_backwards(cl, klass());
437 }
438
439 template <typename OopClosureType>
440 void oopDesc::oop_iterate_backwards(OopClosureType* cl, Klass* k) {
441 OopIteratorClosureDispatch::oop_oop_iterate_backwards(cl, this, k);
442 }
443
444 bool oopDesc::is_instanceof_or_null(oop obj, Klass* klass) {
445 return obj == nullptr || obj->klass()->is_subtype_of(klass);
446 }
447
448 intptr_t oopDesc::identity_hash() {
449 // Fast case; if the object is unlocked and the hash value is set, no locking is needed
450 // Note: The mark must be read into local variable to avoid concurrent updates.
451 markWord mrk = mark();
452 if (mrk.is_unlocked() && !mrk.has_no_hash()) {
453 return mrk.hash();
454 } else if (mrk.is_marked()) {
455 return mrk.hash();
456 } else {
457 return slow_identity_hash();
458 }
459 }
460
|