8270911: Don't use Access API to access object header word

src/hotspot/share/cds/heapShared.cpp

@@ -412,17 +412,18 @@ void HeapShared::copy_roots() {
   HeapWord* mem = G1CollectedHeap::heap()->archive_mem_allocate(size);
 
   memset(mem, 0, size * BytesPerWord);
+  oop obj = cast_to_oop(mem);
   {
     // This is copied from MemAllocator::finish
-    oopDesc::set_mark(mem, markWord::prototype());
+    obj->set_mark(markWord::prototype());
-    oopDesc::release_set_klass(mem, k);
+    obj->release_set_klass(k);
   }
   {
     // This is copied from ObjArrayAllocator::initialize
-    arrayOopDesc::set_length(mem, length);
+    arrayOop(obj)->set_length(length);
   }
 
-  _roots = OopHandle(Universe::vm_global(), cast_to_oop(mem));
+  _roots = OopHandle(Universe::vm_global(), obj);
   for (int i = 0; i < length; i++) {
     roots()->obj_at_put(i, _pending_roots->at(i));
   }

src/hotspot/share/gc/shared/memAllocator.cpp

@@ -383,12 +383,13 @@ void MemAllocator::mem_clear(HeapWord* mem) const {
 oop MemAllocator::finish(HeapWord* mem) const {
   assert(mem != NULL, "NULL object pointer");
   // May be bootstrapping
-  oopDesc::set_mark(mem, markWord::prototype());
+  oop obj = cast_to_oop(mem);
+  obj->set_mark(markWord::prototype());
   // Need a release store to ensure array/class length, mark word, and
   // object zeroing are visible before setting the klass non-NULL, for
   // concurrent collectors.
-  oopDesc::release_set_klass(mem, _klass);
+  obj->release_set_klass(_klass);
-  return cast_to_oop(mem);
+  return obj;
 }
 
 oop ObjAllocator::initialize(HeapWord* mem) const {
@@ -413,7 +414,7 @@ oop ObjArrayAllocator::initialize(HeapWord* mem) const {
   if (_do_zero) {
     mem_clear(mem);
   }
-  arrayOopDesc::set_length(mem, _length);
+  arrayOop(cast_to_oop(mem))->set_length(_length);
   return finish(mem);
 }
 

src/hotspot/share/oops/arrayOop.hpp

@@ -118,10 +118,6 @@ class arrayOopDesc : public oopDesc {
     return length_addr_impl(this);
   }
 
-  static void set_length(HeapWord* mem, int length) {
-    *length_addr_impl(mem) = length;
-  }
-
   // Should only be called with constants as argument
   // (will not constant fold otherwise)
   // Returns the header size in words aligned to the requirements of the

src/hotspot/share/oops/oop.hpp

@@ -62,11 +62,8 @@ class oopDesc {
   inline markWord* mark_addr() const;
 
   inline void set_mark(markWord m);
-  static inline void set_mark(HeapWord* mem, markWord m);
-
   inline void release_set_mark(markWord m);
-  inline markWord cas_set_mark(markWord new_mark, markWord old_mark);
+  inline markWord cas_set_mark(markWord new_mark, markWord old_mark, atomic_memory_order order = memory_order_conservative);
-  inline markWord cas_set_mark(markWord new_mark, markWord old_mark, atomic_memory_order order);
 
   // Used only to re-initialize the mark word (e.g., of promoted
   // objects during a GC) -- requires a valid klass pointer
@@ -78,7 +75,7 @@ class oopDesc {
 
   void set_narrow_klass(narrowKlass nk) NOT_CDS_JAVA_HEAP_RETURN;
   inline void set_klass(Klass* k);
-  static inline void release_set_klass(HeapWord* mem, Klass* k);
+  inline void release_set_klass(Klass* k);
 
   // For klass field compression
   inline int klass_gap() const;

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

@@ -45,29 +45,19 @@
 // We need a separate file to avoid circular references
 
 markWord oopDesc::mark() const {
-  uintptr_t v = HeapAccess<MO_RELAXED>::load_at(as_oop(), mark_offset_in_bytes());
+  return *const_cast<markWord*>(&_mark);
-  return markWord(v);
 }
 
 markWord* oopDesc::mark_addr() const {
-  return (markWord*) &_mark;
+  return const_cast<markWord*>(&_mark);
 }
 
 void oopDesc::set_mark(markWord m) {
-  HeapAccess<MO_RELAXED>::store_at(as_oop(), mark_offset_in_bytes(), m.value());
+  *const_cast<markWord*>(&_mark) = m;
-}
-
-void oopDesc::set_mark(HeapWord* mem, markWord m) {
-  *(markWord*)(((char*)mem) + mark_offset_in_bytes()) = m;
 }
 
 void oopDesc::release_set_mark(markWord m) {
-  HeapAccess<MO_RELEASE>::store_at(as_oop(), mark_offset_in_bytes(), m.value());
+  Atomic::release_store(&_mark, m);
-}
-
-markWord oopDesc::cas_set_mark(markWord new_mark, markWord old_mark) {
-  uintptr_t v = HeapAccess<>::atomic_cmpxchg_at(as_oop(), mark_offset_in_bytes(), old_mark.value(), new_mark.value());
-  return markWord(v);
 }
 
 markWord oopDesc::cas_set_mark(markWord new_mark, markWord old_mark, atomic_memory_order order) {
@@ -112,14 +102,13 @@ void oopDesc::set_klass(Klass* k) {
   }
 }
 
-void oopDesc::release_set_klass(HeapWord* mem, Klass* k) {
+void oopDesc::release_set_klass(Klass* k) {
   assert(Universe::is_bootstrapping() || (k != NULL && k->is_klass()), "incorrect Klass");
-  char* raw_mem = ((char*)mem + klass_offset_in_bytes());
   if (UseCompressedClassPointers) {
-    Atomic::release_store((narrowKlass*)raw_mem,
+    Atomic::release_store(&_metadata._compressed_klass,
                           CompressedKlassPointers::encode_not_null(k));
   } else {
-    Atomic::release_store((Klass**)raw_mem, k);
+    Atomic::release_store(&_metadata._klass, k);
   }
 }