< prev index next >

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

Print this page
rev 12906 : [mq]: gc_interface

*** 24,92 **** #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/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); --- 24,47 ---- #ifndef SHARE_VM_OOPS_OOP_INLINE_HPP #define SHARE_VM_OOPS_OOP_INLINE_HPP #include "gc/shared/ageTable.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" // 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,535 **** narrowOop oopDesc::encode_heap_oop(oop v) { return (is_null(v)) ? (narrowOop)0 : encode_heap_oop_not_null(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); } // Load and decode an oop out of the heap accepting null oop oopDesc::load_decode_heap_oop(narrowOop* p) { ! return decode_heap_oop(*p); } // 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); } ! 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); } ! 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)); } ! 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); } ! 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); } ! 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); } ! 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); } ! 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); } ! 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); } bool oopDesc::is_locked() const { return mark()->is_locked(); } --- 308,375 ---- 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(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(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); } ! 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); } ! 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); } ! 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); } ! 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)); } ! 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); } ! 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); } ! 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); } ! 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); } ! 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 >