< prev index next >

src/hotspot/share/oops/oop.inline.hpp

Print this page

 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 
< prev index next >