< prev index next >
src/share/vm/oops/oop.inline.hpp
Print this page
rev 12906 : [mq]: gc_interface
@@ -24,69 +24,24 @@
#ifndef SHARE_VM_OOPS_OOP_INLINE_HPP
#define SHARE_VM_OOPS_OOP_INLINE_HPP
#include "gc/shared/ageTable.hpp"
-#include "gc/shared/barrierSet.inline.hpp"
-#include "gc/shared/cardTableModRefBS.hpp"
#include "gc/shared/collectedHeap.inline.hpp"
#include "gc/shared/genCollectedHeap.hpp"
#include "gc/shared/generation.hpp"
#include "oops/arrayKlass.hpp"
#include "oops/arrayOop.hpp"
#include "oops/klass.inline.hpp"
#include "oops/markOop.inline.hpp"
#include "oops/oop.hpp"
+#include "runtime/access.hpp"
#include "runtime/atomic.hpp"
#include "runtime/orderAccess.inline.hpp"
#include "runtime/os.hpp"
#include "utilities/macros.hpp"
-inline void update_barrier_set(void* p, oop v, bool release = false) {
- assert(oopDesc::bs() != NULL, "Uninitialized bs in oop!");
- oopDesc::bs()->write_ref_field(p, v, release);
-}
-
-template <class T> inline void update_barrier_set_pre(T* p, oop v) {
- oopDesc::bs()->write_ref_field_pre(p, v);
-}
-
-template <class T> void oop_store(T* p, oop v) {
- if (always_do_update_barrier) {
- oop_store((volatile T*)p, v);
- } else {
- update_barrier_set_pre(p, v);
- oopDesc::encode_store_heap_oop(p, v);
- // always_do_update_barrier == false =>
- // Either we are at a safepoint (in GC) or CMS is not used. In both
- // cases it's unnecessary to mark the card as dirty with release sematics.
- update_barrier_set((void*)p, v, false /* release */); // cast away type
- }
-}
-
-template <class T> void oop_store(volatile T* p, oop v) {
- update_barrier_set_pre((T*)p, v); // cast away volatile
- // Used by release_obj_field_put, so use release_store_ptr.
- oopDesc::release_encode_store_heap_oop(p, v);
- // When using CMS we must mark the card corresponding to p as dirty
- // with release sematics to prevent that CMS sees the dirty card but
- // not the new value v at p due to reordering of the two
- // stores. Note that CMS has a concurrent precleaning phase, where
- // it reads the card table while the Java threads are running.
- update_barrier_set((void*)p, v, true /* release */); // cast away type
-}
-
-// Should replace *addr = oop assignments where addr type depends on UseCompressedOops
-// (without having to remember the function name this calls).
-inline void oop_store_raw(HeapWord* addr, oop value) {
- if (UseCompressedOops) {
- oopDesc::encode_store_heap_oop((narrowOop*)addr, value);
- } else {
- oopDesc::encode_store_heap_oop((oop*)addr, value);
- }
-}
-
// Implementation of all inlined member functions defined in oop.hpp
// We need a separate file to avoid circular references
void oopDesc::release_set_mark(markOop m) {
OrderAccess::release_store_ptr(&_mark, m);
@@ -353,183 +308,68 @@
narrowOop oopDesc::encode_heap_oop(oop v) {
return (is_null(v)) ? (narrowOop)0 : encode_heap_oop_not_null(v);
}
+narrowOop oopDesc::load_heap_oop(narrowOop* p) { return *p; }
+oop oopDesc::load_heap_oop(oop* p) { return *p; }
+
+void oopDesc::store_heap_oop(narrowOop* p, narrowOop v) { *p = v; }
+void oopDesc::store_heap_oop(oop* p, oop v) { *p = v; }
+
// Load and decode an oop out of the Java heap into a wide oop.
oop oopDesc::load_decode_heap_oop_not_null(narrowOop* p) {
- return decode_heap_oop_not_null(*p);
+ return decode_heap_oop_not_null(load_heap_oop(p));
}
// Load and decode an oop out of the heap accepting null
oop oopDesc::load_decode_heap_oop(narrowOop* p) {
- return decode_heap_oop(*p);
+ return decode_heap_oop(load_heap_oop(p));
}
+oop oopDesc::load_decode_heap_oop_not_null(oop* p) { return *p; }
+oop oopDesc::load_decode_heap_oop(oop* p) { return *p; }
+
+void oopDesc::encode_store_heap_oop_not_null(oop* p, oop v) { *p = v; }
+void oopDesc::encode_store_heap_oop(oop* p, oop v) { *p = v; }
+
// Encode and store a heap oop.
void oopDesc::encode_store_heap_oop_not_null(narrowOop* p, oop v) {
*p = encode_heap_oop_not_null(v);
}
// Encode and store a heap oop allowing for null.
void oopDesc::encode_store_heap_oop(narrowOop* p, oop v) {
*p = encode_heap_oop(v);
}
-// Store heap oop as is for volatile fields.
-void oopDesc::release_store_heap_oop(volatile oop* p, oop v) {
- OrderAccess::release_store_ptr(p, v);
-}
-void oopDesc::release_store_heap_oop(volatile narrowOop* p, narrowOop v) {
- OrderAccess::release_store(p, v);
-}
-
-void oopDesc::release_encode_store_heap_oop_not_null(volatile narrowOop* p, oop v) {
- // heap oop is not pointer sized.
- OrderAccess::release_store(p, encode_heap_oop_not_null(v));
-}
-void oopDesc::release_encode_store_heap_oop_not_null(volatile oop* p, oop v) {
- OrderAccess::release_store_ptr(p, v);
-}
-
-void oopDesc::release_encode_store_heap_oop(volatile oop* p, oop v) {
- OrderAccess::release_store_ptr(p, v);
-}
-void oopDesc::release_encode_store_heap_oop(volatile narrowOop* p, oop v) {
- OrderAccess::release_store(p, encode_heap_oop(v));
-}
-
-// These functions are only used to exchange oop fields in instances,
-// not headers.
-oop oopDesc::atomic_exchange_oop(oop exchange_value, volatile HeapWord *dest) {
- if (UseCompressedOops) {
- // encode exchange value from oop to T
- narrowOop val = encode_heap_oop(exchange_value);
- narrowOop old = (narrowOop)Atomic::xchg(val, (narrowOop*)dest);
- // decode old from T to oop
- return decode_heap_oop(old);
- } else {
- return (oop)Atomic::xchg_ptr(exchange_value, (oop*)dest);
- }
-}
-
-oop oopDesc::atomic_compare_exchange_oop(oop exchange_value,
- volatile HeapWord *dest,
- oop compare_value,
- bool prebarrier) {
- if (UseCompressedOops) {
- if (prebarrier) {
- update_barrier_set_pre((narrowOop*)dest, exchange_value);
- }
- // encode exchange and compare value from oop to T
- narrowOop val = encode_heap_oop(exchange_value);
- narrowOop cmp = encode_heap_oop(compare_value);
-
- narrowOop old = (narrowOop) Atomic::cmpxchg(val, (narrowOop*)dest, cmp);
- // decode old from T to oop
- return decode_heap_oop(old);
- } else {
- if (prebarrier) {
- update_barrier_set_pre((oop*)dest, exchange_value);
- }
- return (oop)Atomic::cmpxchg_ptr(exchange_value, (oop*)dest, compare_value);
- }
-}
-
-// In order to put or get a field out of an instance, must first check
-// if the field has been compressed and uncompress it.
-oop oopDesc::obj_field(int offset) const {
- return UseCompressedOops ?
- load_decode_heap_oop(obj_field_addr<narrowOop>(offset)) :
- load_decode_heap_oop(obj_field_addr<oop>(offset));
-}
-
-void oopDesc::obj_field_put(int offset, oop value) {
- UseCompressedOops ? oop_store(obj_field_addr<narrowOop>(offset), value) :
- oop_store(obj_field_addr<oop>(offset), value);
-}
-
-void oopDesc::obj_field_put_raw(int offset, oop value) {
- UseCompressedOops ?
- encode_store_heap_oop(obj_field_addr<narrowOop>(offset), value) :
- encode_store_heap_oop(obj_field_addr<oop>(offset), value);
-}
-void oopDesc::obj_field_put_volatile(int offset, oop value) {
- OrderAccess::release();
- obj_field_put(offset, value);
- OrderAccess::fence();
-}
-
-Metadata* oopDesc::metadata_field(int offset) const { return *metadata_field_addr(offset); }
-void oopDesc::metadata_field_put(int offset, Metadata* value) { *metadata_field_addr(offset) = value; }
-
-jbyte oopDesc::byte_field(int offset) const { return (jbyte) *byte_field_addr(offset); }
-void oopDesc::byte_field_put(int offset, jbyte contents) { *byte_field_addr(offset) = (jint) contents; }
-
-jchar oopDesc::char_field(int offset) const { return (jchar) *char_field_addr(offset); }
-void oopDesc::char_field_put(int offset, jchar contents) { *char_field_addr(offset) = (jint) contents; }
-
-jboolean oopDesc::bool_field(int offset) const { return (jboolean) *bool_field_addr(offset); }
-void oopDesc::bool_field_put(int offset, jboolean contents) { *bool_field_addr(offset) = (((jint) contents) & 1); }
-
-jint oopDesc::int_field(int offset) const { return *int_field_addr(offset); }
-void oopDesc::int_field_put(int offset, jint contents) { *int_field_addr(offset) = contents; }
-
-jshort oopDesc::short_field(int offset) const { return (jshort) *short_field_addr(offset); }
-void oopDesc::short_field_put(int offset, jshort contents) { *short_field_addr(offset) = (jint) contents;}
-
-jlong oopDesc::long_field(int offset) const { return *long_field_addr(offset); }
-void oopDesc::long_field_put(int offset, jlong contents) { *long_field_addr(offset) = contents; }
-
-jfloat oopDesc::float_field(int offset) const { return *float_field_addr(offset); }
-void oopDesc::float_field_put(int offset, jfloat contents) { *float_field_addr(offset) = contents; }
-
-jdouble oopDesc::double_field(int offset) const { return *double_field_addr(offset); }
-void oopDesc::double_field_put(int offset, jdouble contents) { *double_field_addr(offset) = contents; }
-
-address oopDesc::address_field(int offset) const { return *address_field_addr(offset); }
-void oopDesc::address_field_put(int offset, address contents) { *address_field_addr(offset) = contents; }
-
-oop oopDesc::obj_field_acquire(int offset) const {
- return UseCompressedOops ?
- decode_heap_oop((narrowOop)
- OrderAccess::load_acquire(obj_field_addr<narrowOop>(offset)))
- : decode_heap_oop((oop)
- OrderAccess::load_ptr_acquire(obj_field_addr<oop>(offset)));
-}
-void oopDesc::release_obj_field_put(int offset, oop value) {
- UseCompressedOops ?
- oop_store((volatile narrowOop*)obj_field_addr<narrowOop>(offset), value) :
- oop_store((volatile oop*) obj_field_addr<oop>(offset), value);
-}
-
-jbyte oopDesc::byte_field_acquire(int offset) const { return OrderAccess::load_acquire(byte_field_addr(offset)); }
-void oopDesc::release_byte_field_put(int offset, jbyte contents) { OrderAccess::release_store(byte_field_addr(offset), contents); }
+inline oop oopDesc::obj_field(int offset) const { return HeapAccess<>::oop_load_at(oop_base(), offset); }
+inline void oopDesc::obj_field_put(int offset, oop value) { HeapAccess<>::oop_store_at(oop_base(), offset, value); }
-jchar oopDesc::char_field_acquire(int offset) const { return OrderAccess::load_acquire(char_field_addr(offset)); }
-void oopDesc::release_char_field_put(int offset, jchar contents) { OrderAccess::release_store(char_field_addr(offset), contents); }
+inline jbyte oopDesc::byte_field(int offset) const { return HeapAccess<>::load_at(oop_base(), offset); }
+inline void oopDesc::byte_field_put(int offset, jbyte value) { HeapAccess<>::store_at(oop_base(), offset, value); }
-jboolean oopDesc::bool_field_acquire(int offset) const { return OrderAccess::load_acquire(bool_field_addr(offset)); }
-void oopDesc::release_bool_field_put(int offset, jboolean contents) { OrderAccess::release_store(bool_field_addr(offset), (contents & 1)); }
+inline jchar oopDesc::char_field(int offset) const { return HeapAccess<>::load_at(oop_base(), offset); }
+inline void oopDesc::char_field_put(int offset, jchar value) { HeapAccess<>::store_at(oop_base(), offset, value); }
-jint oopDesc::int_field_acquire(int offset) const { return OrderAccess::load_acquire(int_field_addr(offset)); }
-void oopDesc::release_int_field_put(int offset, jint contents) { OrderAccess::release_store(int_field_addr(offset), contents); }
+inline jboolean oopDesc::bool_field(int offset) const { return HeapAccess<>::load_at(oop_base(), offset); }
+inline void oopDesc::bool_field_put(int offset, jboolean value) { HeapAccess<>::store_at(oop_base(), offset, jboolean(value & 1)); }
-jshort oopDesc::short_field_acquire(int offset) const { return (jshort)OrderAccess::load_acquire(short_field_addr(offset)); }
-void oopDesc::release_short_field_put(int offset, jshort contents) { OrderAccess::release_store(short_field_addr(offset), contents); }
+inline jint oopDesc::int_field(int offset) const { return HeapAccess<>::load_at(oop_base(), offset); }
+inline void oopDesc::int_field_put(int offset, jint value) { HeapAccess<>::store_at(oop_base(), offset, value); }
-jlong oopDesc::long_field_acquire(int offset) const { return OrderAccess::load_acquire(long_field_addr(offset)); }
-void oopDesc::release_long_field_put(int offset, jlong contents) { OrderAccess::release_store(long_field_addr(offset), contents); }
+inline jshort oopDesc::short_field(int offset) const { return HeapAccess<>::load_at(oop_base(), offset); }
+inline void oopDesc::short_field_put(int offset, jshort value) { HeapAccess<>::store_at(oop_base(), offset, value); }
-jfloat oopDesc::float_field_acquire(int offset) const { return OrderAccess::load_acquire(float_field_addr(offset)); }
-void oopDesc::release_float_field_put(int offset, jfloat contents) { OrderAccess::release_store(float_field_addr(offset), contents); }
+inline jlong oopDesc::long_field(int offset) const { return HeapAccess<>::load_at(oop_base(), offset); }
+inline void oopDesc::long_field_put(int offset, jlong value) { HeapAccess<>::store_at(oop_base(), offset, value); }
-jdouble oopDesc::double_field_acquire(int offset) const { return OrderAccess::load_acquire(double_field_addr(offset)); }
-void oopDesc::release_double_field_put(int offset, jdouble contents) { OrderAccess::release_store(double_field_addr(offset), contents); }
+inline jfloat oopDesc::float_field(int offset) const { return HeapAccess<>::load_at(oop_base(), offset); }
+inline void oopDesc::float_field_put(int offset, jfloat value) { HeapAccess<>::store_at(oop_base(), offset, value); }
-address oopDesc::address_field_acquire(int offset) const { return (address) OrderAccess::load_ptr_acquire(address_field_addr(offset)); }
-void oopDesc::release_address_field_put(int offset, address contents) { OrderAccess::release_store_ptr(address_field_addr(offset), contents); }
+inline jdouble oopDesc::double_field(int offset) const { return HeapAccess<>::load_at(oop_base(), offset); }
+inline void oopDesc::double_field_put(int offset, jdouble value) { HeapAccess<>::store_at(oop_base(), offset, value); }
bool oopDesc::is_locked() const {
return mark()->is_locked();
}
< prev index next >