src/share/vm/oops/oop.cpp

rev 12906 : [mq]: gc_interface

*** 26,35 ****
--- 26,36 ----
  #include "classfile/altHashing.hpp"
  #include "classfile/javaClasses.inline.hpp"
  #include "memory/resourceArea.hpp"
  #include "oops/oop.inline.hpp"
  #include "oops/verifyOopClosure.hpp"
+ #include "runtime/access.inline.hpp"
  #include "runtime/handles.inline.hpp"
  #include "runtime/thread.inline.hpp"
  #include "utilities/copy.hpp"
  
  bool always_do_update_barrier = false;
*** 136,140 ****
--- 137,192 ----
  
  bool oopDesc::has_klass_gap() {
    // Only has a klass gap when compressed class pointers are used.
    return UseCompressedClassPointers;
  }
+ 
+ oop oopDesc::obj_field_acquire(int offset) const                   { return HeapAccess<MO_ACQUIRE>::oop_load_at(oop_base(), offset); }
+ 
+ void oopDesc::obj_field_put_raw(int offset, oop value)             { BasicAccess<>::oop_store_at(oop_base(), offset, value); }
+ void oopDesc::release_obj_field_put(int offset, oop value)         { HeapAccess<MO_RELEASE>::oop_store_at(oop_base(), offset, value); }
+ void oopDesc::obj_field_put_volatile(int offset, oop value)        { HeapAccess<MO_SEQ_CST>::oop_store_at(oop_base(), offset, value); }
+ 
+ address oopDesc::address_field(int offset) const                   { return HeapAccess<>::load_at(oop_base(), offset); }
+ address oopDesc::address_field_acquire(int offset) const           { return HeapAccess<MO_ACQUIRE>::load_at(oop_base(), offset); }
+ 
+ void oopDesc::address_field_put(int offset, address value)         { HeapAccess<>::store_at(oop_base(), offset, value); }
+ void oopDesc::release_address_field_put(int offset, address value) { HeapAccess<MO_RELEASE>::store_at(oop_base(), offset, value); }
+ 
+ Metadata* oopDesc::metadata_field(int offset) const                { return HeapAccess<>::load_at(oop_base(), offset); }
+ void oopDesc::metadata_field_put(int offset, Metadata* value)      { HeapAccess<>::store_at(oop_base(), offset, value); }
+ 
+ jbyte oopDesc::byte_field_acquire(int offset) const                { return HeapAccess<MO_ACQUIRE>::load_at(oop_base(), offset); }
+ void oopDesc::release_byte_field_put(int offset, jbyte value)      { HeapAccess<MO_RELEASE>::store_at(oop_base(), offset, value); }
+ 
+ jchar oopDesc::char_field_acquire(int offset) const                { return HeapAccess<MO_ACQUIRE>::load_at(oop_base(), offset); }
+ void oopDesc::release_char_field_put(int offset, jchar value)      { HeapAccess<MO_RELEASE>::store_at(oop_base(), offset, value); }
+ 
+ jboolean oopDesc::bool_field_acquire(int offset) const             { return HeapAccess<MO_ACQUIRE>::load_at(oop_base(), offset); }
+ void oopDesc::release_bool_field_put(int offset, jboolean value)   { HeapAccess<MO_RELEASE>::store_at(oop_base(), offset, jboolean(value & 1)); }
+ 
+ jint oopDesc::int_field_acquire(int offset) const                  { return HeapAccess<MO_ACQUIRE>::load_at(oop_base(), offset); }
+ void oopDesc::release_int_field_put(int offset, jint value)        { HeapAccess<MO_RELEASE>::store_at(oop_base(), offset, value); }
+ 
+ jshort oopDesc::short_field_acquire(int offset) const              { return HeapAccess<MO_ACQUIRE>::load_at(oop_base(), offset); }
+ void oopDesc::release_short_field_put(int offset, jshort value)    { HeapAccess<MO_RELEASE>::store_at(oop_base(), offset, value); }
+ 
+ jlong oopDesc::long_field_acquire(int offset) const                { return HeapAccess<MO_ACQUIRE>::load_at(oop_base(), offset); }
+ void oopDesc::release_long_field_put(int offset, jlong value)      { HeapAccess<MO_RELEASE>::store_at(oop_base(), offset, value); }
+ 
+ jfloat oopDesc::float_field_acquire(int offset) const              { return HeapAccess<MO_ACQUIRE>::load_at(oop_base(), offset); }
+ void oopDesc::release_float_field_put(int offset, jfloat value)    { HeapAccess<MO_RELEASE>::store_at(oop_base(), offset, value); }
+ 
+ jdouble oopDesc::double_field_acquire(int offset) const            { return HeapAccess<MO_ACQUIRE>::load_at(oop_base(), offset); }
+ void oopDesc::release_double_field_put(int offset, jdouble value)  { HeapAccess<MO_RELEASE>::store_at(oop_base(), offset, value); }
+ 
+ // These functions are only used to exchange oop fields in instances,
+ // not headers.
+ oop oopDesc::atomic_exchange_oop(oop exchange_value, volatile HeapWord *dest) {
+   return HeapAccess<MO_SEQ_CST>::oop_swap(exchange_value, dest);
+ }
+ 
+ oop oopDesc::atomic_compare_exchange_oop(oop exchange_value,
+                                          volatile HeapWord *dest,
+                                          oop compare_value) {
+   return HeapAccess<MO_SEQ_CST>::oop_cas(exchange_value, dest, compare_value);
+ }