< prev index next >

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

Print this page

 67   *(markWord*)(((char*)mem) + mark_offset_in_bytes()) = m;
 68 }
 69 
 70 void oopDesc::release_set_mark(HeapWord* mem, markWord m) {
 71   Atomic::release_store((markWord*)(((char*)mem) + mark_offset_in_bytes()), m);
 72 }
 73 
 74 void oopDesc::release_set_mark(markWord m) {
 75   Atomic::release_store(&_mark, m);
 76 }
 77 
 78 markWord oopDesc::cas_set_mark(markWord new_mark, markWord old_mark) {
 79   return Atomic::cmpxchg(&_mark, old_mark, new_mark);
 80 }
 81 
 82 markWord oopDesc::cas_set_mark(markWord new_mark, markWord old_mark, atomic_memory_order order) {
 83   return Atomic::cmpxchg(&_mark, old_mark, new_mark, order);
 84 }
 85 
 86 markWord oopDesc::prototype_mark() const {
 87   if (UseCompactObjectHeaders) {
 88     return klass()->prototype_header();
 89   } else {
 90     return markWord::prototype();
 91   }
 92 }
 93 
 94 void oopDesc::init_mark() {
 95   set_mark(prototype_mark());
 96 }
 97 











 98 Klass* oopDesc::klass() const {
 99   switch (ObjLayout::klass_mode()) {
100     case ObjLayout::Compact:
101       return mark().klass();
102     case ObjLayout::Compressed:
103       return CompressedKlassPointers::decode_not_null(_metadata._compressed_klass);
104     default:
105       return _metadata._klass;
106   }
107 }
108 
109 Klass* oopDesc::klass_or_null() const {
110   switch (ObjLayout::klass_mode()) {
111     case ObjLayout::Compact:
112       return mark().klass_or_null();
113     case ObjLayout::Compressed:
114       return CompressedKlassPointers::decode(_metadata._compressed_klass);
115     default:
116       return _metadata._klass;
117   }

224       // skipping the intermediate round to HeapWordSize.
225       s = align_up(size_in_bytes, MinObjAlignmentInBytes) / HeapWordSize;
226 
227       assert(s == klass->oop_size(this), "wrong array object size");
228     } else {
229       // Must be zero, so bite the bullet and take the virtual call.
230       s = klass->oop_size(this);
231     }
232   }
233 
234   assert(s > 0, "Oop size must be greater than zero, not %zu", s);
235   assert(is_object_aligned(s), "Oop size is not properly aligned: %zu", s);
236   return s;
237 }
238 
239 bool oopDesc::is_instance()    const { return klass()->is_instance_klass();             }
240 bool oopDesc::is_instanceRef() const { return klass()->is_reference_instance_klass();   }
241 bool oopDesc::is_stackChunk()  const { return klass()->is_stack_chunk_instance_klass(); }
242 bool oopDesc::is_array()       const { return klass()->is_array_klass();                }
243 bool oopDesc::is_objArray()    const { return klass()->is_objArray_klass();             }

244 bool oopDesc::is_typeArray()   const { return klass()->is_typeArray_klass();            }
















245 
246 template<typename T>
247 T*       oopDesc::field_addr(int offset)     const { return reinterpret_cast<T*>(cast_from_oop<intptr_t>(as_oop()) + offset); }
248 
249 template <typename T>
250 size_t   oopDesc::field_offset(T* p) const { return pointer_delta((void*)p, (void*)this, 1); }
251 
252 template <DecoratorSet decorators>
253 inline oop  oopDesc::obj_field_access(int offset) const             { return HeapAccess<decorators>::oop_load_at(as_oop(), offset); }
254 inline oop  oopDesc::obj_field(int offset) const                    { return HeapAccess<>::oop_load_at(as_oop(), offset);  }
255 
256 inline void oopDesc::obj_field_put(int offset, oop value)           { HeapAccess<>::oop_store_at(as_oop(), offset, value); }
257 template <DecoratorSet decorators>
258 inline void oopDesc::obj_field_put_access(int offset, oop value)    { HeapAccess<decorators>::oop_store_at(as_oop(), offset, value); }
259 
260 inline jbyte oopDesc::byte_field(int offset) const                  { return *field_addr<jbyte>(offset);  }
261 inline void  oopDesc::byte_field_put(int offset, jbyte value)       { *field_addr<jbyte>(offset) = value; }
262 
263 inline jchar oopDesc::char_field(int offset) const                  { return *field_addr<jchar>(offset);  }
264 inline void  oopDesc::char_field_put(int offset, jchar value)       { *field_addr<jchar>(offset) = value; }

 67   *(markWord*)(((char*)mem) + mark_offset_in_bytes()) = m;
 68 }
 69 
 70 void oopDesc::release_set_mark(HeapWord* mem, markWord m) {
 71   Atomic::release_store((markWord*)(((char*)mem) + mark_offset_in_bytes()), m);
 72 }
 73 
 74 void oopDesc::release_set_mark(markWord m) {
 75   Atomic::release_store(&_mark, m);
 76 }
 77 
 78 markWord oopDesc::cas_set_mark(markWord new_mark, markWord old_mark) {
 79   return Atomic::cmpxchg(&_mark, old_mark, new_mark);
 80 }
 81 
 82 markWord oopDesc::cas_set_mark(markWord new_mark, markWord old_mark, atomic_memory_order order) {
 83   return Atomic::cmpxchg(&_mark, old_mark, new_mark, order);
 84 }
 85 
 86 markWord oopDesc::prototype_mark() const {
 87   if (UseCompactObjectHeaders || EnableValhalla) {
 88     return klass()->prototype_header();
 89   } else {
 90     return markWord::prototype();
 91   }
 92 }
 93 
 94 void oopDesc::init_mark() {
 95   set_mark(prototype_mark());
 96 }
 97 
 98 // This is for parallel gc, which doesn't always have the klass.
 99 // markWord::must_be_preserved preserves the original prototype header bits for EnableValhalla,
100 // I don't know why serial gc doesn't work the same.
101 void oopDesc::reinit_mark() {
102   if (UseCompactObjectHeaders) {
103     set_mark(klass()->prototype_header());
104   } else {
105     set_mark(markWord::prototype());
106   }
107 }
108 
109 Klass* oopDesc::klass() const {
110   switch (ObjLayout::klass_mode()) {
111     case ObjLayout::Compact:
112       return mark().klass();
113     case ObjLayout::Compressed:
114       return CompressedKlassPointers::decode_not_null(_metadata._compressed_klass);
115     default:
116       return _metadata._klass;
117   }
118 }
119 
120 Klass* oopDesc::klass_or_null() const {
121   switch (ObjLayout::klass_mode()) {
122     case ObjLayout::Compact:
123       return mark().klass_or_null();
124     case ObjLayout::Compressed:
125       return CompressedKlassPointers::decode(_metadata._compressed_klass);
126     default:
127       return _metadata._klass;
128   }

235       // skipping the intermediate round to HeapWordSize.
236       s = align_up(size_in_bytes, MinObjAlignmentInBytes) / HeapWordSize;
237 
238       assert(s == klass->oop_size(this), "wrong array object size");
239     } else {
240       // Must be zero, so bite the bullet and take the virtual call.
241       s = klass->oop_size(this);
242     }
243   }
244 
245   assert(s > 0, "Oop size must be greater than zero, not %zu", s);
246   assert(is_object_aligned(s), "Oop size is not properly aligned: %zu", s);
247   return s;
248 }
249 
250 bool oopDesc::is_instance()    const { return klass()->is_instance_klass();             }
251 bool oopDesc::is_instanceRef() const { return klass()->is_reference_instance_klass();   }
252 bool oopDesc::is_stackChunk()  const { return klass()->is_stack_chunk_instance_klass(); }
253 bool oopDesc::is_array()       const { return klass()->is_array_klass();                }
254 bool oopDesc::is_objArray()    const { return klass()->is_objArray_klass();             }
255 bool oopDesc::is_refArray()    const { return klass()->is_refArray_klass();             }
256 bool oopDesc::is_typeArray()   const { return klass()->is_typeArray_klass();            }
257 bool oopDesc::is_refined_objArray() const { return klass()->is_refined_objArray_klass(); }
258 
259 bool oopDesc::is_inline_type() const { return mark().is_inline_type(); }
260 #ifdef _LP64
261 bool oopDesc::is_flatArray() const {
262   markWord mrk = mark();
263   return (mrk.is_unlocked()) ? mrk.is_flat_array() : klass()->is_flatArray_klass();
264 }
265 bool oopDesc::is_null_free_array() const {
266   markWord mrk = mark();
267   return (mrk.is_unlocked()) ? mrk.is_null_free_array() : klass()->is_null_free_array_klass();
268 }
269 #else
270 bool oopDesc::is_flatArray()       const { return klass()->is_flatArray_klass(); }
271 bool oopDesc::is_null_free_array() const { return klass()->is_null_free_array_klass(); }
272 #endif
273 
274 template<typename T>
275 T*       oopDesc::field_addr(int offset)     const { return reinterpret_cast<T*>(cast_from_oop<intptr_t>(as_oop()) + offset); }
276 
277 template <typename T>
278 size_t   oopDesc::field_offset(T* p) const { return pointer_delta((void*)p, (void*)this, 1); }
279 
280 template <DecoratorSet decorators>
281 inline oop  oopDesc::obj_field_access(int offset) const             { return HeapAccess<decorators>::oop_load_at(as_oop(), offset); }
282 inline oop  oopDesc::obj_field(int offset) const                    { return HeapAccess<>::oop_load_at(as_oop(), offset);  }
283 
284 inline void oopDesc::obj_field_put(int offset, oop value)           { HeapAccess<>::oop_store_at(as_oop(), offset, value); }
285 template <DecoratorSet decorators>
286 inline void oopDesc::obj_field_put_access(int offset, oop value)    { HeapAccess<decorators>::oop_store_at(as_oop(), offset, value); }
287 
288 inline jbyte oopDesc::byte_field(int offset) const                  { return *field_addr<jbyte>(offset);  }
289 inline void  oopDesc::byte_field_put(int offset, jbyte value)       { *field_addr<jbyte>(offset) = value; }
290 
291 inline jchar oopDesc::char_field(int offset) const                  { return *field_addr<jchar>(offset);  }
292 inline void  oopDesc::char_field_put(int offset, jchar value)       { *field_addr<jchar>(offset) = value; }
< prev index next >