8251358: Clean up Access configuration after Shenandoah barrier change

src/hotspot/share/classfile/javaClasses.inline.hpp

@@ -101,7 +101,7 @@ void java_lang_ref_Reference::set_referent_raw(oop ref, oop value) {
   ref->obj_field_put_raw(referent_offset, value);
 }
 HeapWord* java_lang_ref_Reference::referent_addr_raw(oop ref) {
-  return ref->obj_field_addr_raw<HeapWord>(referent_offset);
+  return ref->obj_field_addr<HeapWord>(referent_offset);
 }
 oop java_lang_ref_Reference::next(oop ref) {
   return ref->obj_field(next_offset);
@@ -113,7 +113,7 @@ void java_lang_ref_Reference::set_next_raw(oop ref, oop value) {
   ref->obj_field_put_raw(next_offset, value);
 }
 HeapWord* java_lang_ref_Reference::next_addr_raw(oop ref) {
-  return ref->obj_field_addr_raw<HeapWord>(next_offset);
+  return ref->obj_field_addr<HeapWord>(next_offset);
 }
 oop java_lang_ref_Reference::discovered(oop ref) {
   return ref->obj_field(discovered_offset);
@@ -125,7 +125,7 @@ void java_lang_ref_Reference::set_discovered_raw(oop ref, oop value) {
   ref->obj_field_put_raw(discovered_offset, value);
 }
 HeapWord* java_lang_ref_Reference::discovered_addr_raw(oop ref) {
-  return ref->obj_field_addr_raw<HeapWord>(discovered_offset);
+  return ref->obj_field_addr<HeapWord>(discovered_offset);
 }
 bool java_lang_ref_Reference::is_phantom(oop ref) {
   return InstanceKlass::cast(ref->klass())->reference_type() == REF_PHANTOM;

src/hotspot/share/gc/cms/compactibleFreeListSpace.cpp

@@ -424,7 +424,7 @@ HeapWord* CompactibleFreeListSpace::forward(oop q, size_t size,
   } else {
     // if the object isn't moving we can just set the mark to the default
     // mark and handle it specially later on.
-    q->init_mark_raw();
+    q->init_mark();
     assert(q->forwardee() == NULL, "should be forwarded to NULL");
   }
 

src/hotspot/share/gc/cms/concurrentMarkSweepGeneration.cpp

@@ -1053,7 +1053,7 @@ ConcurrentMarkSweepGeneration::par_promote(int thread_num,
   // Except with compressed oops it's the mark word.
   HeapWord* old_ptr = (HeapWord*)old;
   // Restore the mark word copied above.
-  obj->set_mark_raw(m);
+  obj->set_mark(m);
   assert(obj->klass_or_null() == NULL, "Object should be uninitialized here.");
   assert(!((FreeChunk*)obj_ptr)->is_free(), "Error, block will look free but show wrong size");
   OrderAccess::storestore();
@@ -7758,8 +7758,8 @@ bool CMSCollector::take_from_overflow_list(size_t num, CMSMarkStack* stack) {
   const markOop proto = markOopDesc::prototype();
   NOT_PRODUCT(ssize_t n = 0;)
   for (oop next; i > 0 && cur != NULL; cur = next, i--) {
-    next = oop(cur->mark_raw());
-    cur->set_mark_raw(proto);   // until proven otherwise
+    next = oop(cur->mark());
+    cur->set_mark(proto);   // until proven otherwise
     assert(oopDesc::is_oop(cur), "Should be an oop");
     bool res = stack->push(cur);
     assert(res, "Bit off more than can chew?");
@@ -7842,8 +7842,8 @@ bool CMSCollector::par_take_from_overflow_list(size_t num,
   size_t i = num;
   oop cur = prefix;
   // Walk down the first "num" objects, unless we reach the end.
-  for (; i > 1 && cur->mark_raw() != NULL; cur = oop(cur->mark_raw()), i--);
-  if (cur->mark_raw() == NULL) {
+  for (; i > 1 && cur->mark() != NULL; cur = oop(cur->mark()), i--);
+  if (cur->mark() == NULL) {
     // We have "num" or fewer elements in the list, so there
     // is nothing to return to the global list.
     // Write back the NULL in lieu of the BUSY we wrote
@@ -7853,9 +7853,9 @@ bool CMSCollector::par_take_from_overflow_list(size_t num,
     }
   } else {
     // Chop off the suffix and return it to the global list.
-    assert(cur->mark_raw() != BUSY, "Error");
-    oop suffix_head = cur->mark_raw(); // suffix will be put back on global list
-    cur->set_mark_raw(NULL);           // break off suffix
+    assert(cur->mark() != BUSY, "Error");
+    oop suffix_head = cur->mark(); // suffix will be put back on global list
+    cur->set_mark(NULL);           // break off suffix
     // It's possible that the list is still in the empty(busy) state
     // we left it in a short while ago; in that case we may be
     // able to place back the suffix without incurring the cost
@@ -7875,18 +7875,18 @@ bool CMSCollector::par_take_from_overflow_list(size_t num,
       // Too bad, someone else sneaked in (at least) an element; we'll need
       // to do a splice. Find tail of suffix so we can prepend suffix to global
       // list.
-      for (cur = suffix_head; cur->mark_raw() != NULL; cur = (oop)(cur->mark_raw()));
+      for (cur = suffix_head; cur->mark() != NULL; cur = (oop)(cur->mark()));
       oop suffix_tail = cur;
-      assert(suffix_tail != NULL && suffix_tail->mark_raw() == NULL,
+      assert(suffix_tail != NULL && suffix_tail->mark() == NULL,
              "Tautology");
       observed_overflow_list = _overflow_list;
       do {
         cur_overflow_list = observed_overflow_list;
         if (cur_overflow_list != BUSY) {
           // Do the splice ...
-          suffix_tail->set_mark_raw(markOop(cur_overflow_list));
+          suffix_tail->set_mark(markOop(cur_overflow_list));
         } else { // cur_overflow_list == BUSY
-          suffix_tail->set_mark_raw(NULL);
+          suffix_tail->set_mark(NULL);
         }
         // ... and try to place spliced list back on overflow_list ...
         observed_overflow_list =
@@ -7902,8 +7902,8 @@ bool CMSCollector::par_take_from_overflow_list(size_t num,
   oop next;
   NOT_PRODUCT(ssize_t n = 0;)
   for (cur = prefix; cur != NULL; cur = next) {
-    next = oop(cur->mark_raw());
-    cur->set_mark_raw(proto);   // until proven otherwise
+    next = oop(cur->mark());
+    cur->set_mark(proto);   // until proven otherwise
     assert(oopDesc::is_oop(cur), "Should be an oop");
     bool res = work_q->push(cur);
     assert(res, "Bit off more than we can chew?");
@@ -7921,7 +7921,7 @@ void CMSCollector::push_on_overflow_list(oop p) {
   NOT_PRODUCT(_num_par_pushes++;)
   assert(oopDesc::is_oop(p), "Not an oop");
   preserve_mark_if_necessary(p);
-  p->set_mark_raw((markOop)_overflow_list);
+  p->set_mark((markOop)_overflow_list);
   _overflow_list = p;
 }
 
@@ -7935,9 +7935,9 @@ void CMSCollector::par_push_on_overflow_list(oop p) {
   do {
     cur_overflow_list = observed_overflow_list;
     if (cur_overflow_list != BUSY) {
-      p->set_mark_raw(markOop(cur_overflow_list));
+      p->set_mark(markOop(cur_overflow_list));
     } else {
-      p->set_mark_raw(NULL);
+      p->set_mark(NULL);
     }
     observed_overflow_list =
       Atomic::cmpxchg((oopDesc*)p, &_overflow_list, (oopDesc*)cur_overflow_list);
@@ -7962,29 +7962,29 @@ void CMSCollector::par_push_on_overflow_list(oop p) {
 void CMSCollector::preserve_mark_work(oop p, markOop m) {
   _preserved_oop_stack.push(p);
   _preserved_mark_stack.push(m);
-  assert(m == p->mark_raw(), "Mark word changed");
+  assert(m == p->mark(), "Mark word changed");
   assert(_preserved_oop_stack.size() == _preserved_mark_stack.size(),
          "bijection");
 }
 
 // Single threaded
 void CMSCollector::preserve_mark_if_necessary(oop p) {
-  markOop m = p->mark_raw();
+  markOop m = p->mark();
   if (m->must_be_preserved(p)) {
     preserve_mark_work(p, m);
   }
 }
 
 void CMSCollector::par_preserve_mark_if_necessary(oop p) {
-  markOop m = p->mark_raw();
+  markOop m = p->mark();
   if (m->must_be_preserved(p)) {
     MutexLockerEx x(ParGCRareEvent_lock, Mutex::_no_safepoint_check_flag);
     // Even though we read the mark word without holding
     // the lock, we are assured that it will not change
     // because we "own" this oop, so no other thread can
     // be trying to push it on the overflow list; see
     // the assertion in preserve_mark_work() that checks
-    // that m == p->mark_raw().
+    // that m == p->mark().
     preserve_mark_work(p, m);
   }
 }
@@ -8017,10 +8017,10 @@ void CMSCollector::restore_preserved_marks_if_any() {
     oop p = _preserved_oop_stack.pop();
     assert(oopDesc::is_oop(p), "Should be an oop");
     assert(_span.contains(p), "oop should be in _span");
-    assert(p->mark_raw() == markOopDesc::prototype(),
+    assert(p->mark() == markOopDesc::prototype(),
            "Set when taken from overflow list");
     markOop m = _preserved_mark_stack.pop();
-    p->set_mark_raw(m);
+    p->set_mark(m);
   }
   assert(_preserved_mark_stack.is_empty() && _preserved_oop_stack.is_empty(),
          "stacks were cleared above");

src/hotspot/share/gc/cms/parNewGeneration.cpp

@@ -1099,7 +1099,7 @@ oop ParNewGeneration::copy_to_survivor_space(ParScanThreadState* par_scan_state,
   // a forwarding pointer by a parallel thread.  So we must save the mark
   // word in a local and then analyze it.
   oopDesc dummyOld;
-  dummyOld.set_mark_raw(m);
+  dummyOld.set_mark(m);
   assert(!dummyOld.is_forwarded(),
          "should not be called with forwarding pointer mark word.");
 
@@ -1147,7 +1147,7 @@ oop ParNewGeneration::copy_to_survivor_space(ParScanThreadState* par_scan_state,
     assert(CMSHeap::heap()->is_in_reserved(new_obj), "illegal forwarding pointer value.");
     forward_ptr = old->forward_to_atomic(new_obj);
     // Restore the mark word copied above.
-    new_obj->set_mark_raw(m);
+    new_obj->set_mark(m);
     // Increment age if obj still in new generation
     new_obj->incr_age();
     par_scan_state->age_table()->add(new_obj, sz);

src/hotspot/share/gc/cms/parOopClosures.inline.hpp

@@ -45,7 +45,7 @@ template <class T> inline void ParScanWeakRefClosure::do_oop_work(T* p) {
     // ParScanClosure::do_oop_work).
     Klass* objK = obj->klass();
     OrderAccess::loadload();
-    markOop m = obj->mark_raw();
+    markOop m = obj->mark();
     oop new_obj;
     if (m->is_marked()) { // Contains forwarding pointer.
       new_obj = ParNewGeneration::real_forwardee(obj);
@@ -110,7 +110,7 @@ inline void ParScanClosure::do_oop_work(T* p,
       // forwarded.
       Klass* objK = obj->klass();
       OrderAccess::loadload();
-      markOop m = obj->mark_raw();
+      markOop m = obj->mark();
       oop new_obj;
       if (m->is_marked()) { // Contains forwarding pointer.
         new_obj = ParNewGeneration::real_forwardee(obj);

src/hotspot/share/gc/cms/promotionInfo.cpp

@@ -93,7 +93,7 @@ void PromotionInfo::track(PromotedObject* trackOop) {
 
 void PromotionInfo::track(PromotedObject* trackOop, Klass* klassOfOop) {
   // make a copy of header as it may need to be spooled
-  markOop mark = oop(trackOop)->mark_raw();
+  markOop mark = oop(trackOop)->mark();
   trackOop->clear_next();
   if (mark->must_be_preserved_for_cms_scavenge(klassOfOop)) {
     // save non-prototypical header, and mark oop
@@ -233,7 +233,7 @@ void PromotionInfo::verify() const {
   // 2. each promoted object lies in this space
   debug_only(
     PromotedObject* junk = NULL;
-    assert(junk->next_addr() == (void*)(oop(junk)->mark_addr_raw()),
+    assert(junk->next_addr() == (void*)(oop(junk)->mark_addr()),
            "Offset of PromotedObject::_next is expected to align with "
            "  the OopDesc::_mark within OopDesc");
   )

src/hotspot/share/gc/cms/promotionInfo.inline.hpp

@@ -54,10 +54,10 @@ void PromotionInfo::promoted_oops_iterate(OopClosureType* cl) {
     }
     if (curObj->hasDisplacedMark()) {
       /* restore displaced header */
-      oop(curObj)->set_mark_raw(nextDisplacedHeader());
+      oop(curObj)->set_mark(nextDisplacedHeader());
     } else {
       /* restore prototypical header */
-      oop(curObj)->init_mark_raw();
+      oop(curObj)->init_mark();
     }
     /* The "promoted_mark" should now not be set */
     assert(!curObj->hasPromotedMark(),

src/hotspot/share/gc/g1/g1FullGCCompactTask.cpp

@@ -48,7 +48,7 @@ class G1ResetHumongousClosure : public HeapRegionClosure {
         if (_bitmap->is_marked(obj)) {
           // Clear bitmap and fix mark word.
           _bitmap->clear(obj);
-          obj->init_mark_raw();
+          obj->init_mark();
         } else {
           assert(current->is_empty(), "Should have been cleared in phase 2.");
         }
@@ -71,7 +71,7 @@ size_t G1FullGCCompactTask::G1CompactRegionClosure::apply(oop obj) {
   HeapWord* obj_addr = (HeapWord*) obj;
   assert(obj_addr != destination, "everything in this pass should be moving");
   Copy::aligned_conjoint_words(obj_addr, destination, size);
-  oop(destination)->init_mark_raw();
+  oop(destination)->init_mark();
   assert(oop(destination)->klass() != NULL, "should have a class");
 
   return size;

src/hotspot/share/gc/g1/g1FullGCCompactionPoint.cpp

@@ -112,15 +112,15 @@ void G1FullGCCompactionPoint::forward(oop object, size_t size) {
       // with BiasedLocking, in this case forwardee() will return NULL
       // even if the mark-word is used. This is no problem since
       // forwardee() will return NULL in the compaction phase as well.
-      object->init_mark_raw();
+      object->init_mark();
     } else {
       // Make sure object has the correct mark-word set or that it will be
       // fixed when restoring the preserved marks.
-      assert(object->mark_raw() == markOopDesc::prototype_for_object(object) || // Correct mark
-             object->mark_raw()->must_be_preserved(object) || // Will be restored by PreservedMarksSet
-             (UseBiasedLocking && object->has_bias_pattern_raw()), // Will be restored by BiasedLocking
+      assert(object->mark() == markOopDesc::prototype_for_object(object) || // Correct mark
+             object->mark()->must_be_preserved(object) || // Will be restored by PreservedMarksSet
+             (UseBiasedLocking && object->has_bias_pattern()), // Will be restored by BiasedLocking
              "should have correct prototype obj: " PTR_FORMAT " mark: " PTR_FORMAT " prototype: " PTR_FORMAT,
-             p2i(object), p2i(object->mark_raw()), p2i(markOopDesc::prototype_for_object(object)));
+             p2i(object), p2i(object->mark()), p2i(markOopDesc::prototype_for_object(object)));
     }
     assert(object->forwardee() == NULL, "should be forwarded to NULL");
   }

src/hotspot/share/gc/g1/g1FullGCMarker.inline.hpp

@@ -50,7 +50,7 @@ inline bool G1FullGCMarker::mark_object(oop obj) {
   }
 
   // Marked by us, preserve if needed.
-  markOop mark = obj->mark_raw();
+  markOop mark = obj->mark();
   if (mark->must_be_preserved(obj) &&
       !G1ArchiveAllocator::is_open_archive_object(obj)) {
     preserved_stack()->push(obj, mark);

src/hotspot/share/gc/g1/g1FullGCOopClosures.inline.hpp

@@ -76,11 +76,11 @@ template <class T> inline void G1AdjustClosure::adjust_pointer(T* p) {
   oop forwardee = obj->forwardee();
   if (forwardee == NULL) {
     // Not forwarded, return current reference.
-    assert(obj->mark_raw() == markOopDesc::prototype_for_object(obj) || // Correct mark
-           obj->mark_raw()->must_be_preserved(obj) || // Will be restored by PreservedMarksSet
-           (UseBiasedLocking && obj->has_bias_pattern_raw()), // Will be restored by BiasedLocking
+    assert(obj->mark() == markOopDesc::prototype_for_object(obj) || // Correct mark
+           obj->mark()->must_be_preserved(obj) || // Will be restored by PreservedMarksSet
+           (UseBiasedLocking && obj->has_bias_pattern()), // Will be restored by BiasedLocking
            "Must have correct prototype or be preserved, obj: " PTR_FORMAT ", mark: " PTR_FORMAT ", prototype: " PTR_FORMAT,
-           p2i(obj), p2i(obj->mark_raw()), p2i(markOopDesc::prototype_for_object(obj)));
+           p2i(obj), p2i(obj->mark()), p2i(markOopDesc::prototype_for_object(obj)));
     return;
   }
 

src/hotspot/share/gc/g1/g1OopClosures.inline.hpp

@@ -46,8 +46,8 @@ inline void G1ScanClosureBase::prefetch_and_push(T* p, const oop obj) {
   // stall. We'll try to prefetch the object (for write, given that
   // we might need to install the forwarding reference) and we'll
   // get back to it when pop it from the queue
-  Prefetch::write(obj->mark_addr_raw(), 0);
-  Prefetch::read(obj->mark_addr_raw(), (HeapWordSize*2));
+  Prefetch::write(obj->mark_addr(), 0);
+  Prefetch::read(obj->mark_addr(), (HeapWordSize*2));
 
   // slightly paranoid test; I'm trying to catch potential
   // problems before we go into push_on_queue to know where the
@@ -249,7 +249,7 @@ void G1ParCopyClosure<barrier, do_mark_object>::do_oop_work(T* p) {
   const InCSetState state = _g1h->in_cset_state(obj);
   if (state.is_in_cset()) {
     oop forwardee;
-    markOop m = obj->mark_raw();
+    markOop m = obj->mark();
     if (m->is_marked()) {
       forwardee = (oop) m->decode_pointer();
     } else {

src/hotspot/share/gc/g1/g1ParScanThreadState.cpp

@@ -278,15 +278,15 @@ oop G1ParScanThreadState::copy_to_survivor_space(InCSetState const state,
         // In this case, we have to install the mark word first,
         // otherwise obj looks to be forwarded (the old mark word,
         // which contains the forward pointer, was copied)
-        obj->set_mark_raw(old_mark);
+        obj->set_mark(old_mark);
         markOop new_mark = old_mark->displaced_mark_helper()->set_age(age);
         old_mark->set_displaced_mark_helper(new_mark);
       } else {
-        obj->set_mark_raw(old_mark->set_age(age));
+        obj->set_mark(old_mark->set_age(age));
       }
       _age_table.add(age, word_sz);
     } else {
-      obj->set_mark_raw(old_mark);
+      obj->set_mark(old_mark);
     }
 
     if (G1StringDedup::is_enabled()) {

src/hotspot/share/gc/g1/g1ParScanThreadState.inline.hpp

@@ -41,7 +41,7 @@ template <class T> void G1ParScanThreadState::do_oop_evac(T* p) {
   // So we need to redo this check.
   const InCSetState in_cset_state = _g1h->in_cset_state(obj);
   if (in_cset_state.is_in_cset()) {
-    markOop m = obj->mark_raw();
+    markOop m = obj->mark();
     if (m->is_marked()) {
       obj = (oop) m->decode_pointer();
     } else {

src/hotspot/share/gc/parallel/psCompactionManager.inline.hpp

@@ -120,7 +120,7 @@ inline void oop_pc_follow_contents_specialized(objArrayOop obj, int index, ParCo
 
   const size_t stride = MIN2(len - beg_index, (size_t)ObjArrayMarkingStride);
   const size_t end_index = beg_index + stride;
-  T* const base = (T*)obj->base_raw();
+  T* const base = (T*)obj->base();
   T* const beg = base + beg_index;
   T* const end = base + end_index;
 

src/hotspot/share/gc/parallel/psMarkSweepDecorator.cpp

@@ -113,8 +113,8 @@ void PSMarkSweepDecorator::precompact() {
   const intx interval = PrefetchScanIntervalInBytes;
 
   while (q < t) {
-    assert(oop(q)->mark_raw()->is_marked() || oop(q)->mark_raw()->is_unlocked() ||
-           oop(q)->mark_raw()->has_bias_pattern(),
+    assert(oop(q)->mark()->is_marked() || oop(q)->mark()->is_unlocked() ||
+           oop(q)->mark()->has_bias_pattern(),
            "these are the only valid states during a mark sweep");
     if (oop(q)->is_gc_marked()) {
       /* prefetch beyond q */
@@ -151,7 +151,7 @@ void PSMarkSweepDecorator::precompact() {
       } else {
         // if the object isn't moving we can just set the mark to the default
         // mark and handle it specially later on.
-        oop(q)->init_mark_raw();
+        oop(q)->init_mark();
         assert(oop(q)->forwardee() == NULL, "should be forwarded to NULL");
       }
 
@@ -211,7 +211,7 @@ void PSMarkSweepDecorator::precompact() {
           } else {
             // if the object isn't moving we can just set the mark to the default
             // mark and handle it specially later on.
-            oop(q)->init_mark_raw();
+            oop(q)->init_mark();
             assert(oop(q)->forwardee() == NULL, "should be forwarded to NULL");
           }
 
@@ -259,7 +259,7 @@ bool PSMarkSweepDecorator::insert_deadspace(size_t& allowed_deadspace_words,
   if (allowed_deadspace_words >= deadlength) {
     allowed_deadspace_words -= deadlength;
     CollectedHeap::fill_with_object(q, deadlength);
-    oop(q)->set_mark_raw(oop(q)->mark_raw()->set_marked());
+    oop(q)->set_mark(oop(q)->mark()->set_marked());
     assert((int) deadlength == oop(q)->size(), "bad filler object size");
     // Recall that we required "q == compaction_top".
     return true;
@@ -350,7 +350,7 @@ void PSMarkSweepDecorator::compact(bool mangle_free_space ) {
       q = t;
     } else {
       // $$$ Funky
-      q = (HeapWord*) oop(_first_dead)->mark_raw()->decode_pointer();
+      q = (HeapWord*) oop(_first_dead)->mark()->decode_pointer();
     }
   }
 
@@ -361,7 +361,7 @@ void PSMarkSweepDecorator::compact(bool mangle_free_space ) {
     if (!oop(q)->is_gc_marked()) {
       // mark is pointer to next marked oop
       debug_only(prev_q = q);
-      q = (HeapWord*) oop(q)->mark_raw()->decode_pointer();
+      q = (HeapWord*) oop(q)->mark()->decode_pointer();
       assert(q > prev_q, "we should be moving forward through memory");
     } else {
       // prefetch beyond q
@@ -377,7 +377,7 @@ void PSMarkSweepDecorator::compact(bool mangle_free_space ) {
       // copy object and reinit its mark
       assert(q != compaction_top, "everything in this pass should be moving");
       Copy::aligned_conjoint_words(q, compaction_top, size);
-      oop(compaction_top)->init_mark_raw();
+      oop(compaction_top)->init_mark();
       assert(oop(compaction_top)->klass() != NULL, "should have a class");
 
       debug_only(prev_q = q);

src/hotspot/share/gc/parallel/psPromotionLAB.cpp

@@ -82,7 +82,7 @@ void PSPromotionLAB::flush() {
   // so they can always fill with an array.
   HeapWord* tlab_end = end() + filler_header_size;
   typeArrayOop filler_oop = (typeArrayOop) top();
-  filler_oop->set_mark_raw(markOopDesc::prototype());
+  filler_oop->set_mark(markOopDesc::prototype());
   filler_oop->set_klass(Universe::intArrayKlassObj());
   const size_t array_length =
     pointer_delta(tlab_end, top()) - typeArrayOopDesc::header_size(T_INT);

src/hotspot/share/gc/parallel/psPromotionManager.inline.hpp

@@ -116,7 +116,7 @@ inline oop PSPromotionManager::copy_to_survivor_space(oop o) {
   // NOTE! We must be very careful with any methods that access the mark
   // in o. There may be multiple threads racing on it, and it may be forwarded
   // at any time. Do not use oop methods for accessing the mark!
-  markOop test_mark = o->mark_raw();
+  markOop test_mark = o->mark();
 
   // The same test as "o->is_forwarded()"
   if (!test_mark->is_marked()) {

src/hotspot/share/gc/serial/defNewGeneration.cpp

@@ -725,7 +725,7 @@ void DefNewGeneration::handle_promotion_failure(oop old) {
 
   _promotion_failed = true;
   _promotion_failed_info.register_copy_failure(old->size());
-  _preserved_marks_set.get()->push_if_necessary(old, old->mark_raw());
+  _preserved_marks_set.get()->push_if_necessary(old, old->mark());
   // forward to self
   old->forward_to(old);
 

src/hotspot/share/gc/serial/markSweep.cpp

@@ -131,7 +131,7 @@ template <class T> inline void MarkSweep::follow_root(T* p) {
   T heap_oop = RawAccess<>::oop_load(p);
   if (!CompressedOops::is_null(heap_oop)) {
     oop obj = CompressedOops::decode_not_null(heap_oop);
-    if (!obj->mark_raw()->is_marked()) {
+    if (!obj->mark()->is_marked()) {
       mark_object(obj);
       follow_object(obj);
     }
@@ -147,7 +147,7 @@ void PreservedMark::adjust_pointer() {
 }
 
 void PreservedMark::restore() {
-  _obj->set_mark_raw(_mark);
+  _obj->set_mark(_mark);
 }
 
 // We preserve the mark which should be replaced at the end and the location
@@ -204,7 +204,7 @@ void MarkSweep::restore_marks() {
   while (!_preserved_oop_stack.is_empty()) {
     oop obj       = _preserved_oop_stack.pop();
     markOop mark  = _preserved_mark_stack.pop();
-    obj->set_mark_raw(mark);
+    obj->set_mark(mark);
   }
 }
 

src/hotspot/share/gc/serial/markSweep.inline.hpp

@@ -38,8 +38,8 @@
 inline void MarkSweep::mark_object(oop obj) {
   // some marks may contain information we need to preserve so we store them away
   // and overwrite the mark.  We'll restore it at the end of markSweep.
-  markOop mark = obj->mark_raw();
-  obj->set_mark_raw(markOopDesc::prototype()->set_marked());
+  markOop mark = obj->mark();
+  obj->set_mark(markOopDesc::prototype()->set_marked());
 
   if (mark->must_be_preserved(obj)) {
     preserve_mark(obj, mark);
@@ -50,7 +50,7 @@ template <class T> inline void MarkSweep::mark_and_push(T* p) {
   T heap_oop = RawAccess<>::oop_load(p);
   if (!CompressedOops::is_null(heap_oop)) {
     oop obj = CompressedOops::decode_not_null(heap_oop);
-    if (!obj->mark_raw()->is_marked()) {
+    if (!obj->mark()->is_marked()) {
       mark_object(obj);
       _marking_stack.push(obj);
     }
@@ -79,11 +79,11 @@ template <class T> inline void MarkSweep::adjust_pointer(T* p) {
     oop obj = CompressedOops::decode_not_null(heap_oop);
     assert(Universe::heap()->is_in(obj), "should be in heap");
 
-    oop new_obj = oop(obj->mark_raw()->decode_pointer());
+    oop new_obj = oop(obj->mark()->decode_pointer());
 
     assert(new_obj != NULL ||                         // is forwarding ptr?
-           obj->mark_raw() == markOopDesc::prototype() || // not gc marked?
-           (UseBiasedLocking && obj->mark_raw()->has_bias_pattern()),
+           obj->mark() == markOopDesc::prototype() || // not gc marked?
+           (UseBiasedLocking && obj->mark()->has_bias_pattern()),
            // not gc marked?
            "should be forwarded");
 

src/hotspot/share/gc/shared/barrierSetConfig.hpp

@@ -43,20 +43,4 @@
   FOR_EACH_ABSTRACT_BARRIER_SET_DO(f) \
   FOR_EACH_CONCRETE_BARRIER_SET_DO(f)
 
-// To enable runtime-resolution of GC barriers on primitives, please
-// define SUPPORT_BARRIER_ON_PRIMITIVES.
-#ifdef SUPPORT_BARRIER_ON_PRIMITIVES
-#define ACCESS_PRIMITIVE_SUPPORT INTERNAL_BT_BARRIER_ON_PRIMITIVES
-#else
-#define ACCESS_PRIMITIVE_SUPPORT INTERNAL_EMPTY
-#endif
-
-#ifdef SUPPORT_NOT_TO_SPACE_INVARIANT
-#define ACCESS_TO_SPACE_INVARIANT_SUPPORT INTERNAL_EMPTY
-#else
-#define ACCESS_TO_SPACE_INVARIANT_SUPPORT INTERNAL_BT_TO_SPACE_INVARIANT
-#endif
-
-#define BT_BUILDTIME_DECORATORS (ACCESS_PRIMITIVE_SUPPORT | ACCESS_TO_SPACE_INVARIANT_SUPPORT)
-
 #endif // SHARE_VM_GC_SHARED_BARRIERSETCONFIG_HPP

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

@@ -397,10 +397,10 @@ void MemAllocator::mem_clear(HeapWord* mem) const {
 oop MemAllocator::finish(HeapWord* mem) const {
   assert(mem != NULL, "NULL object pointer");
   if (UseBiasedLocking) {
-    oopDesc::set_mark_raw(mem, _klass->prototype_header());
+    oopDesc::set_mark(mem, _klass->prototype_header());
   } else {
     // May be bootstrapping
-    oopDesc::set_mark_raw(mem, markOopDesc::prototype());
+    oopDesc::set_mark(mem, markOopDesc::prototype());
   }
   // Need a release store to ensure array/class length, mark word, and
   // object zeroing are visible before setting the klass non-NULL, for

src/hotspot/share/gc/shared/preservedMarks.inline.hpp

@@ -47,7 +47,7 @@ inline void PreservedMarks::push_if_necessary(oop obj, markOop m) {
 }
 
 inline void PreservedMarks::init_forwarded_mark(oop obj) {
-  obj->init_mark_raw();
+  obj->init_mark();
 }
 
 inline void PreservedMarksSet::restore(RestorePreservedMarksTaskExecutor* executor) {
@@ -80,7 +80,7 @@ inline PreservedMarks::PreservedMarks()
              0 /* max_cache_size */) { }
 
 void PreservedMarks::OopAndMarkOop::set_mark() const {
-  _o->set_mark_raw(_m);
+  _o->set_mark(_m);
 }
 
 #endif // SHARE_VM_GC_SHARED_PRESERVEDMARKS_INLINE_HPP

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

@@ -392,7 +392,7 @@ HeapWord* CompactibleSpace::forward(oop q, size_t size,
   } else {
     // if the object isn't moving we can just set the mark to the default
     // mark and handle it specially later on.
-    q->init_mark_raw();
+    q->init_mark();
     assert(q->forwardee() == NULL, "should be forwarded to NULL");
   }
 
@@ -651,14 +651,14 @@ void ContiguousSpace::allocate_temporary_filler(int factor) {
     // allocate uninitialized int array
     typeArrayOop t = (typeArrayOop) allocate(size);
     assert(t != NULL, "allocation should succeed");
-    t->set_mark_raw(markOopDesc::prototype());
+    t->set_mark(markOopDesc::prototype());
     t->set_klass(Universe::intArrayKlassObj());
     t->set_length((int)length);
   } else {
     assert(size == CollectedHeap::min_fill_size(),
            "size for smallest fake object doesn't match");
     instanceOop obj = (instanceOop) allocate(size);
-    obj->set_mark_raw(markOopDesc::prototype());
+    obj->set_mark(markOopDesc::prototype());
     obj->set_klass_gap(0);
     obj->set_klass(SystemDictionary::Object_klass());
   }

src/hotspot/share/gc/shared/space.inline.hpp

@@ -118,7 +118,7 @@ class DeadSpacer : StackObj {
       _allowed_deadspace_words -= dead_length;
       CollectedHeap::fill_with_object(dead_start, dead_length);
       oop obj = oop(dead_start);
-      obj->set_mark_raw(obj->mark_raw()->set_marked());
+      obj->set_mark(obj->mark()->set_marked());
 
       assert(dead_length == (size_t)obj->size(), "bad filler object size");
       log_develop_trace(gc, compaction)("Inserting object to dead space: " PTR_FORMAT ", " PTR_FORMAT ", " SIZE_FORMAT "b",
@@ -165,8 +165,8 @@ inline void CompactibleSpace::scan_and_forward(SpaceType* space, CompactPoint* c
 
   while (cur_obj < scan_limit) {
     assert(!space->scanned_block_is_obj(cur_obj) ||
-           oop(cur_obj)->mark_raw()->is_marked() || oop(cur_obj)->mark_raw()->is_unlocked() ||
-           oop(cur_obj)->mark_raw()->has_bias_pattern(),
+           oop(cur_obj)->mark()->is_marked() || oop(cur_obj)->mark()->is_unlocked() ||
+           oop(cur_obj)->mark()->has_bias_pattern(),
            "these are the only valid states during a mark sweep");
     if (space->scanned_block_is_obj(cur_obj) && oop(cur_obj)->is_gc_marked()) {
       // prefetch beyond cur_obj
@@ -341,7 +341,7 @@ inline void CompactibleSpace::scan_and_compact(SpaceType* space) {
       // copy object and reinit its mark
       assert(cur_obj != compaction_top, "everything in this pass should be moving");
       Copy::aligned_conjoint_words(cur_obj, compaction_top, size);
-      oop(compaction_top)->init_mark_raw();
+      oop(compaction_top)->init_mark();
       assert(oop(compaction_top)->klass() != NULL, "should have a class");
 
       debug_only(prev_obj = cur_obj);

src/hotspot/share/gc/shenandoah/shenandoahForwarding.inline.hpp

@@ -39,7 +39,7 @@ inline HeapWord* ShenandoahForwarding::get_forwardee_raw_unchecked(oop obj) {
   // On this path, we can encounter the "marked" object, but with NULL
   // fwdptr. That object is still not forwarded, and we need to return
   // the object itself.
-  markOop mark = obj->mark_raw();
+  markOop mark = obj->mark();
   if (mark->is_marked()) {
     HeapWord* fwdptr = (HeapWord*) mark->clear_lock_bits();
     if (fwdptr != NULL) {
@@ -54,7 +54,7 @@ inline oop ShenandoahForwarding::get_forwardee_mutator(oop obj) {
   shenandoah_assert_correct(NULL, obj);
   assert(Thread::current()->is_Java_thread(), "Must be a mutator thread");
 
-  markOop mark = obj->mark_raw();
+  markOop mark = obj->mark();
   if (mark->is_marked()) {
     HeapWord* fwdptr = (HeapWord*)mark->clear_lock_bits();
     assert(fwdptr != NULL, "Forwarding pointer is never null here");
@@ -70,17 +70,17 @@ inline oop ShenandoahForwarding::get_forwardee(oop obj) {
 }
 
 inline bool ShenandoahForwarding::is_forwarded(oop obj) {
-  return obj->mark_raw()->is_marked();
+  return obj->mark()->is_marked();
 }
 
 inline oop ShenandoahForwarding::try_update_forwardee(oop obj, oop update) {
-  markOop old_mark = obj->mark_raw();
+  markOop old_mark = obj->mark();
   if (old_mark->is_marked()) {
     return (oop) old_mark->clear_lock_bits();
   }
 
   markOop new_mark = markOopDesc::encode_pointer_as_mark(update);
-  markOop prev_mark = obj->cas_set_mark_raw(new_mark, old_mark);
+  markOop prev_mark = obj->cas_set_mark(new_mark, old_mark, memory_order_conservative);
   if (prev_mark == old_mark) {
     return update;
   } else {

src/hotspot/share/gc/shenandoah/shenandoahMarkCompact.cpp

@@ -313,7 +313,7 @@ class ShenandoahPrepareForCompactionObjectClosure : public ObjectClosure {
     // Object fits into current region, record new location:
     assert(_compact_point + obj_size <= _to_region->end(), "must fit");
     shenandoah_assert_not_forwarded(NULL, p);
-    _preserved_marks->push_if_necessary(p, p->mark_raw());
+    _preserved_marks->push_if_necessary(p, p->mark());
     p->forward_to(oop(_compact_point));
     _compact_point += obj_size;
   }
@@ -420,7 +420,7 @@ void ShenandoahMarkCompact::calculate_target_humongous_objects() {
 
       if (start >= to_begin && start != r->index()) {
         // Fits into current window, and the move is non-trivial. Record the move then, and continue scan.
-        _preserved_marks->get(0)->push_if_necessary(old_obj, old_obj->mark_raw());
+        _preserved_marks->get(0)->push_if_necessary(old_obj, old_obj->mark());
         old_obj->forward_to(oop(heap->get_region(start)->bottom()));
         to_end = start;
         continue;
@@ -793,7 +793,7 @@ class ShenandoahCompactObjectsClosure : public ObjectClosure {
       HeapWord* compact_to = (HeapWord*) p->forwardee();
       Copy::aligned_conjoint_words(compact_from, compact_to, size);
       oop new_obj = oop(compact_to);
-      new_obj->init_mark_raw();
+      new_obj->init_mark();
     }
   }
 };
@@ -908,7 +908,7 @@ void ShenandoahMarkCompact::compact_humongous_objects() {
                                    words_size);
 
       oop new_obj = oop(heap->get_region(new_start)->bottom());
-      new_obj->init_mark_raw();
+      new_obj->init_mark();
 
       {
         for (size_t c = old_start; c <= old_end; c++) {

src/hotspot/share/oops/access.hpp

@@ -269,11 +269,6 @@ class Access: public AllStatic {
     OopType new_oop_value = new_value;
     return AccessInternal::atomic_xchg<decorators | INTERNAL_VALUE_IS_OOP>(new_oop_value, addr);
   }
-
-  static oop resolve(oop obj) {
-    verify_decorators<INTERNAL_EMPTY>();
-    return AccessInternal::resolve<decorators>(obj);
-  }
 };
 
 // Helper for performing raw accesses (knows only of memory ordering

src/hotspot/share/oops/accessBackend.hpp

@@ -662,8 +662,7 @@ namespace AccessInternal {
 
     template<DecoratorSet decorators>
     static bool is_hardwired_primitive() {
-      return !HasDecorator<decorators, INTERNAL_BT_BARRIER_ON_PRIMITIVES>::value &&
-             !HasDecorator<decorators, INTERNAL_VALUE_IS_OOP>::value;
+      return !HasDecorator<decorators, INTERNAL_VALUE_IS_OOP>::value;
     }
 
     template <DecoratorSet decorators, typename T>
@@ -959,21 +958,6 @@ namespace AccessInternal {
     clone(oop src, oop dst, size_t size) {
       RuntimeDispatch<decorators, oop, BARRIER_CLONE>::clone(src, dst, size);
     }
-
-    template <DecoratorSet decorators>
-    inline static typename EnableIf<
-      HasDecorator<decorators, INTERNAL_BT_TO_SPACE_INVARIANT>::value, oop>::type
-    resolve(oop obj) {
-      typedef RawAccessBarrier<decorators & RAW_DECORATOR_MASK> Raw;
-      return Raw::resolve(obj);
-    }
-
-    template <DecoratorSet decorators>
-    inline static typename EnableIf<
-      !HasDecorator<decorators, INTERNAL_BT_TO_SPACE_INVARIANT>::value, oop>::type
-    resolve(oop obj) {
-      return RuntimeDispatch<decorators, oop, BARRIER_RESOLVE>::resolve(obj);
-    }
   };
 
   // Step 2: Reduce types.
@@ -1266,12 +1250,6 @@ namespace AccessInternal {
     PreRuntimeDispatch::clone<expanded_decorators>(src, dst, size);
   }
 
-  template <DecoratorSet decorators>
-  inline oop resolve(oop obj) {
-    const DecoratorSet expanded_decorators = DecoratorFixup<decorators>::value;
-    return PreRuntimeDispatch::resolve<expanded_decorators>(obj);
-  }
-
   // Infer the type that should be returned from an Access::oop_load.
   template <typename P, DecoratorSet decorators>
   class OopLoadProxy: public StackObj {

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

@@ -360,7 +360,7 @@ inline void RawAccessBarrier<decorators>::clone(oop src, oop dst, size_t size) {
                                             reinterpret_cast<jlong*>((oopDesc*)dst),
                                             align_object_size(size) / HeapWordsPerLong);
   // Clear the header
-  dst->init_mark_raw();
+  dst->init_mark();
 }
 
 #endif // SHARE_VM_RUNTIME_ACCESSBACKEND_INLINE_HPP

src/hotspot/share/oops/accessDecorators.hpp

@@ -52,20 +52,13 @@ const DecoratorSet INTERNAL_EMPTY                    = UCONST64(0);
 const DecoratorSet INTERNAL_CONVERT_COMPRESSED_OOP   = UCONST64(1) << 1;
 const DecoratorSet INTERNAL_VALUE_IS_OOP             = UCONST64(1) << 2;
 
-// == Internal build-time Decorators ==
-// * INTERNAL_BT_BARRIER_ON_PRIMITIVES: This is set in the barrierSetConfig.hpp file.
-// * INTERNAL_BT_TO_SPACE_INVARIANT: This is set in the barrierSetConfig.hpp file iff
-//   no GC is bundled in the build that is to-space invariant.
-const DecoratorSet INTERNAL_BT_BARRIER_ON_PRIMITIVES = UCONST64(1) << 3;
-const DecoratorSet INTERNAL_BT_TO_SPACE_INVARIANT    = UCONST64(1) << 4;
-
 // == Internal run-time Decorators ==
 // * INTERNAL_RT_USE_COMPRESSED_OOPS: This decorator will be set in runtime resolved
 //   access backends iff UseCompressedOops is true.
 const DecoratorSet INTERNAL_RT_USE_COMPRESSED_OOPS   = UCONST64(1) << 5;
 
 const DecoratorSet INTERNAL_DECORATOR_MASK           = INTERNAL_CONVERT_COMPRESSED_OOP | INTERNAL_VALUE_IS_OOP |
-                                                       INTERNAL_BT_BARRIER_ON_PRIMITIVES | INTERNAL_RT_USE_COMPRESSED_OOPS;
+                                                       INTERNAL_RT_USE_COMPRESSED_OOPS;
 
 // == Memory Ordering Decorators ==
 // The memory ordering decorators can be described in the following way:
@@ -231,7 +224,7 @@ namespace AccessInternal {
     // If no barrier strength has been picked, normal will be used
     static const DecoratorSet barrier_strength_default = memory_ordering_default |
       ((AS_DECORATOR_MASK & memory_ordering_default) == 0 ? AS_NORMAL : INTERNAL_EMPTY);
-    static const DecoratorSet value = barrier_strength_default | BT_BUILDTIME_DECORATORS;
+    static const DecoratorSet value = barrier_strength_default;
   };
 
   // This function implements the above DecoratorFixup rules, but without meta
@@ -247,8 +240,7 @@ namespace AccessInternal {
     // If no barrier strength has been picked, normal will be used
     DecoratorSet barrier_strength_default = memory_ordering_default |
       ((AS_DECORATOR_MASK & memory_ordering_default) == 0 ? AS_NORMAL : INTERNAL_EMPTY);
-    DecoratorSet value = barrier_strength_default | BT_BUILDTIME_DECORATORS;
-    return value;
+    return barrier_strength_default;
   }
 }
 

src/hotspot/share/oops/arrayOop.hpp

@@ -86,7 +86,6 @@ class arrayOopDesc : public oopDesc {
   // Returns the address of the first element. The elements in the array will not
   // relocate from this address until a subsequent thread transition.
   inline void* base(BasicType type) const;
-  inline void* base_raw(BasicType type) const; // GC barrier invariant
 
   template <typename T>
   static T* obj_offset_to_raw(arrayOop obj, size_t offset_in_bytes, T* raw) {

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

@@ -29,11 +29,6 @@
 #include "oops/arrayOop.hpp"
 
 void* arrayOopDesc::base(BasicType type) const {
-  oop resolved_obj = Access<>::resolve(as_oop());
-  return arrayOop(resolved_obj)->base_raw(type);
-}
-
-void* arrayOopDesc::base_raw(BasicType type) const {
   return reinterpret_cast<void*>(cast_from_oop<intptr_t>(as_oop()) + base_offset_in_bytes(type));
 }
 

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

@@ -56,7 +56,7 @@ inline void InstanceKlass::release_set_methods_jmethod_ids(jmethodID* jmeths) {
 
 template <typename T, class OopClosureType>
 ALWAYSINLINE void InstanceKlass::oop_oop_iterate_oop_map(OopMapBlock* map, oop obj, OopClosureType* closure) {
-  T* p         = (T*)obj->obj_field_addr_raw<T>(map->offset());
+  T* p         = (T*)obj->obj_field_addr<T>(map->offset());
   T* const end = p + map->count();
 
   for (; p < end; ++p) {
@@ -66,7 +66,7 @@ ALWAYSINLINE void InstanceKlass::oop_oop_iterate_oop_map(OopMapBlock* map, oop o
 
 template <typename T, class OopClosureType>
 ALWAYSINLINE void InstanceKlass::oop_oop_iterate_oop_map_reverse(OopMapBlock* map, oop obj, OopClosureType* closure) {
-  T* const start = (T*)obj->obj_field_addr_raw<T>(map->offset());
+  T* const start = (T*)obj->obj_field_addr<T>(map->offset());
   T*       p     = start + map->count();
 
   while (start < p) {
@@ -77,7 +77,7 @@ ALWAYSINLINE void InstanceKlass::oop_oop_iterate_oop_map_reverse(OopMapBlock* ma
 
 template <typename T, class OopClosureType>
 ALWAYSINLINE void InstanceKlass::oop_oop_iterate_oop_map_bounded(OopMapBlock* map, oop obj, OopClosureType* closure, MemRegion mr) {
-  T* p   = (T*)obj->obj_field_addr_raw<T>(map->offset());
+  T* p   = (T*)obj->obj_field_addr<T>(map->offset());
   T* end = p + map->count();
 
   T* const l   = (T*)mr.start();

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

@@ -37,7 +37,7 @@
 
 template <typename T, class OopClosureType>
 void ObjArrayKlass::oop_oop_iterate_elements(objArrayOop a, OopClosureType* closure) {
-  T* p         = (T*)a->base_raw();
+  T* p         = (T*)a->base();
   T* const end = p + a->length();
 
   for (;p < end; p++) {
@@ -52,7 +52,7 @@ void ObjArrayKlass::oop_oop_iterate_elements_bounded(
   T* const l = (T*)low;
   T* const h = (T*)high;
 
-  T* p   = (T*)a->base_raw();
+  T* p   = (T*)a->base();
   T* end = p + a->length();
 
   if (p < l) {
@@ -101,8 +101,8 @@ void ObjArrayKlass::oop_oop_iterate_bounded(oop obj, OopClosureType* closure, Me
 // for objArrayOops.
 template <typename T, class OopClosureType>
 void ObjArrayKlass::oop_oop_iterate_range(objArrayOop a, OopClosureType* closure, int start, int end) {
-  T* low = start == 0 ? cast_from_oop<T*>(a) : a->obj_at_addr_raw<T>(start);
-  T* high = (T*)a->base_raw() + end;
+  T* low = start == 0 ? cast_from_oop<T*>(a) : a->obj_at_addr<T>(start);
+  T* high = (T*)a->base() + end;
 
   oop_oop_iterate_elements_bounded<T>(a, closure, low, high);
 }

src/hotspot/share/oops/objArrayOop.hpp

@@ -41,7 +41,6 @@ class objArrayOopDesc : public arrayOopDesc {
   friend class G1ParScanPartialArrayClosure;
 
   template <class T> T* obj_at_addr(int index) const;
-  template <class T> T* obj_at_addr_raw(int index) const;
 
   template <class T>
   static ptrdiff_t obj_at_offset(int index) {
@@ -82,7 +81,6 @@ class objArrayOopDesc : public arrayOopDesc {
 
   // base is the address following the header.
   HeapWord* base() const;
-  HeapWord* base_raw() const;
 
   // Accessing
   oop obj_at(int index) const;

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

@@ -32,18 +32,12 @@
 #include "runtime/globals.hpp"
 
 inline HeapWord* objArrayOopDesc::base() const { return (HeapWord*) arrayOopDesc::base(T_OBJECT); }
-inline HeapWord* objArrayOopDesc::base_raw() const { return (HeapWord*) arrayOopDesc::base_raw(T_OBJECT); }
 
 template <class T> T* objArrayOopDesc::obj_at_addr(int index) const {
   assert(is_within_bounds(index), "index %d out of bounds %d", index, length());
   return &((T*)base())[index];
 }
 
-template <class T> T* objArrayOopDesc::obj_at_addr_raw(int index) const {
-  assert(is_within_bounds(index), "index %d out of bounds %d", index, length());
-  return &((T*)base_raw())[index];
-}
-
 inline oop objArrayOopDesc::obj_at(int index) const {
   assert(is_within_bounds(index), "index %d out of bounds %d", index, length());
   ptrdiff_t offset = UseCompressedOops ? obj_at_offset<narrowOop>(index) : obj_at_offset<oop>(index);

src/hotspot/share/oops/oop.cpp

@@ -130,7 +130,7 @@ bool oopDesc::is_oop(oop obj, bool ignore_mark_word) {
   if (ignore_mark_word) {
     return true;
   }
-  if (obj->mark_raw() != NULL) {
+  if (obj->mark() != NULL) {
     return true;
   }
   return !SafepointSynchronize::is_at_safepoint();

src/hotspot/share/oops/oop.hpp

@@ -64,21 +64,18 @@ class oopDesc {
 
  public:
   inline markOop  mark()          const;
-  inline markOop  mark_raw()      const;
-  inline markOop* mark_addr_raw() const;
+  inline markOop* mark_addr() const;
 
   inline void set_mark(volatile markOop m);
-  inline void set_mark_raw(volatile markOop m);
-  static inline void set_mark_raw(HeapWord* mem, markOop m);
+  static inline void set_mark(HeapWord* mem, markOop m);
 
   inline void release_set_mark(markOop m);
   inline markOop cas_set_mark(markOop new_mark, markOop old_mark);
-  inline markOop cas_set_mark_raw(markOop new_mark, markOop old_mark, atomic_memory_order order = memory_order_conservative);
+  inline markOop cas_set_mark(markOop new_mark, markOop 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
   inline void init_mark();
-  inline void init_mark_raw();
 
   inline Klass* klass() const;
   inline Klass* klass_or_null() const volatile;
@@ -129,11 +126,10 @@ class oopDesc {
 
  public:
   // field addresses in oop
-  inline void* field_addr(int offset)     const;
-  inline void* field_addr_raw(int offset) const;
+  inline void* field_addr(int offset) const;
 
   // Need this as public for garbage collection.
-  template <class T> inline T* obj_field_addr_raw(int offset) const;
+  template <class T> inline T* obj_field_addr(int offset) const;
 
   template <typename T> inline size_t field_offset(T* p) const;
 
@@ -245,7 +241,6 @@ class oopDesc {
   inline bool is_locked()   const;
   inline bool is_unlocked() const;
   inline bool has_bias_pattern() const;
-  inline bool has_bias_pattern_raw() const;
 
   // asserts and guarantees
   static bool is_oop(oop obj, bool ignore_mark_word = false);
@@ -316,9 +311,9 @@ class oopDesc {
   unsigned int new_hash(juint seed);
 
   // marks are forwarded to stack when object is locked
-  inline bool    has_displaced_mark_raw() const;
-  inline markOop displaced_mark_raw() const;
-  inline void    set_displaced_mark_raw(markOop m);
+  inline bool    has_displaced_mark() const;
+  inline markOop displaced_mark() const;
+  inline void    set_displaced_mark(markOop m);
 
   static bool has_klass_gap();
 

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

@@ -47,23 +47,15 @@ markOop  oopDesc::mark()      const {
   return HeapAccess<MO_VOLATILE>::load_at(as_oop(), mark_offset_in_bytes());
 }
 
-markOop  oopDesc::mark_raw()  const {
-  return _mark;
-}
-
-markOop* oopDesc::mark_addr_raw() const {
+markOop* oopDesc::mark_addr() const {
   return (markOop*) &_mark;
 }
 
 void oopDesc::set_mark(volatile markOop m) {
   HeapAccess<MO_VOLATILE>::store_at(as_oop(), mark_offset_in_bytes(), m);
 }
 
-void oopDesc::set_mark_raw(volatile markOop m) {
-  _mark = m;
-}
-
-void oopDesc::set_mark_raw(HeapWord* mem, markOop m) {
+void oopDesc::set_mark(HeapWord* mem, markOop m) {
   *(markOop*)(((char*)mem) + mark_offset_in_bytes()) = m;
 }
 
@@ -75,18 +67,14 @@ markOop oopDesc::cas_set_mark(markOop new_mark, markOop old_mark) {
   return HeapAccess<>::atomic_cmpxchg_at(new_mark, as_oop(), mark_offset_in_bytes(), old_mark);
 }
 
-markOop oopDesc::cas_set_mark_raw(markOop new_mark, markOop old_mark, atomic_memory_order order) {
+markOop oopDesc::cas_set_mark(markOop new_mark, markOop old_mark, atomic_memory_order order) {
   return Atomic::cmpxchg(new_mark, &_mark, old_mark, order);
 }
 
 void oopDesc::init_mark() {
   set_mark(markOopDesc::prototype_for_object(this));
 }
 
-void oopDesc::init_mark_raw() {
-  set_mark_raw(markOopDesc::prototype_for_object(this));
-}
-
 Klass* oopDesc::klass() const {
   if (UseCompressedClassPointers) {
     return Klass::decode_klass_not_null(_metadata._compressed_klass);
@@ -278,11 +266,10 @@ bool oopDesc::is_array()     const { return klass()->is_array_klass();     }
 bool oopDesc::is_objArray()  const { return klass()->is_objArray_klass();  }
 bool oopDesc::is_typeArray() const { return klass()->is_typeArray_klass(); }
 
-void*    oopDesc::field_addr_raw(int offset)     const { return reinterpret_cast<void*>(cast_from_oop<intptr_t>(as_oop()) + offset); }
-void*    oopDesc::field_addr(int offset)         const { return Access<>::resolve(as_oop())->field_addr_raw(offset); }
+void*    oopDesc::field_addr(int offset)     const { return reinterpret_cast<void*>(cast_from_oop<intptr_t>(as_oop()) + offset); }
 
 template <class T>
-T*       oopDesc::obj_field_addr_raw(int offset) const { return (T*) field_addr_raw(offset); }
+T*       oopDesc::obj_field_addr(int offset) const { return (T*) field_addr(offset); }
 
 template <typename T>
 size_t   oopDesc::field_offset(T* p) const { return pointer_delta((void*)p, (void*)this, 1); }
@@ -329,20 +316,16 @@ bool oopDesc::has_bias_pattern() const {
   return mark()->has_bias_pattern();
 }
 
-bool oopDesc::has_bias_pattern_raw() const {
-  return mark_raw()->has_bias_pattern();
-}
-
 // Used only for markSweep, scavenging
 bool oopDesc::is_gc_marked() const {
-  return mark_raw()->is_marked();
+  return mark()->is_marked();
 }
 
 // Used by scavengers
 bool oopDesc::is_forwarded() const {
   // The extra heap check is needed since the obj might be locked, in which case the
   // mark would point to a stack location and have the sentinel bit cleared
-  return mark_raw()->is_marked();
+  return mark()->is_marked();
 }
 
 // Used by scavengers
@@ -356,7 +339,7 @@ void oopDesc::forward_to(oop p) {
          "forwarding archive object");
   markOop m = markOopDesc::encode_pointer_as_mark(p);
   assert(m->decode_pointer() == p, "encoding must be reversable");
-  set_mark_raw(m);
+  set_mark(m);
 }
 
 // Used by parallel scavengers
@@ -367,19 +350,19 @@ bool oopDesc::cas_forward_to(oop p, markOop compare, atomic_memory_order order)
          "forwarding to something not in heap");
   markOop m = markOopDesc::encode_pointer_as_mark(p);
   assert(m->decode_pointer() == p, "encoding must be reversable");
-  return cas_set_mark_raw(m, compare, order) == compare;
+  return cas_set_mark(m, compare, order) == compare;
 }
 
 oop oopDesc::forward_to_atomic(oop p, atomic_memory_order order) {
-  markOop oldMark = mark_raw();
+  markOop oldMark = mark();
   markOop forwardPtrMark = markOopDesc::encode_pointer_as_mark(p);
   markOop curMark;
 
   assert(forwardPtrMark->decode_pointer() == p, "encoding must be reversable");
   assert(sizeof(markOop) == sizeof(intptr_t), "CAS below requires this.");
 
   while (!oldMark->is_marked()) {
-    curMark = cas_set_mark_raw(forwardPtrMark, oldMark, order);
+    curMark = cas_set_mark(forwardPtrMark, oldMark, order);
     assert(is_forwarded(), "object should have been forwarded");
     if (curMark == oldMark) {
       return NULL;
@@ -396,7 +379,7 @@ oop oopDesc::forward_to_atomic(oop p, atomic_memory_order order) {
 // The forwardee is used when copying during scavenge and mark-sweep.
 // It does need to clear the low two locking- and GC-related bits.
 oop oopDesc::forwardee() const {
-  return (oop) mark_raw()->decode_pointer();
+  return (oop) mark()->decode_pointer();
 }
 
 // Note that the forwardee is not the same thing as the displaced_mark.
@@ -410,19 +393,19 @@ oop oopDesc::forwardee_acquire() const {
 // The following method needs to be MT safe.
 uint oopDesc::age() const {
   assert(!is_forwarded(), "Attempt to read age from forwarded mark");
-  if (has_displaced_mark_raw()) {
-    return displaced_mark_raw()->age();
+  if (has_displaced_mark()) {
+    return displaced_mark()->age();
   } else {
-    return mark_raw()->age();
+    return mark()->age();
   }
 }
 
 void oopDesc::incr_age() {
   assert(!is_forwarded(), "Attempt to increment age of forwarded mark");
-  if (has_displaced_mark_raw()) {
-    set_displaced_mark_raw(displaced_mark_raw()->incr_age());
+  if (has_displaced_mark()) {
+    set_displaced_mark(displaced_mark()->incr_age());
   } else {
-    set_mark_raw(mark_raw()->incr_age());
+    set_mark(mark()->incr_age());
   }
 }
 
@@ -498,16 +481,16 @@ intptr_t oopDesc::identity_hash() {
   }
 }
 
-bool oopDesc::has_displaced_mark_raw() const {
-  return mark_raw()->has_displaced_mark_helper();
+bool oopDesc::has_displaced_mark() const {
+  return mark()->has_displaced_mark_helper();
 }
 
-markOop oopDesc::displaced_mark_raw() const {
-  return mark_raw()->displaced_mark_helper();
+markOop oopDesc::displaced_mark() const {
+  return mark()->displaced_mark_helper();
 }
 
-void oopDesc::set_displaced_mark_raw(markOop m) {
-  mark_raw()->set_displaced_mark_helper(m);
+void oopDesc::set_displaced_mark(markOop m) {
+  mark()->set_displaced_mark_helper(m);
 }
 
 #endif // SHARE_VM_OOPS_OOP_INLINE_HPP

src/hotspot/share/prims/unsafe.cpp

@@ -110,8 +110,8 @@ static inline void assert_field_offset_sane(oop p, jlong field_offset) {
     assert(byte_offset >= 0 && byte_offset <= (jlong)MAX_OBJECT_SIZE, "sane offset");
     if (byte_offset == (jint)byte_offset) {
       void* ptr_plus_disp = (address)p + byte_offset;
-      assert(p->field_addr_raw((jint)byte_offset) == ptr_plus_disp,
-             "raw [ptr+disp] must be consistent with oop::field_addr_raw");
+      assert(p->field_addr((jint)byte_offset) == ptr_plus_disp,
+             "raw [ptr+disp] must be consistent with oop::field_addr");
     }
     jlong p_size = HeapWordSize * (jlong)(p->size());
     assert(byte_offset < p_size, "Unsafe access: offset " INT64_FORMAT " > object's size " INT64_FORMAT, (int64_t)byte_offset, (int64_t)p_size);
@@ -123,10 +123,6 @@ static inline void* index_oop_from_field_offset_long(oop p, jlong field_offset)
   assert_field_offset_sane(p, field_offset);
   jlong byte_offset = field_offset_to_byte_offset(field_offset);
 
-  if (p != NULL) {
-    p = Access<>::resolve(p);
-  }
-
   if (sizeof(char*) == sizeof(jint)) {   // (this constant folds!)
     return (address)p + (jint) byte_offset;
   } else {

test/hotspot/gtest/gc/shared/test_preservedMarks.cpp

@@ -39,14 +39,15 @@ class FakeOop {
   oopDesc _oop;
 
 public:
-  FakeOop() : _oop() { _oop.set_mark_raw(originalMark()); }
+  FakeOop() : _oop() { _oop.set_mark(originalMark()); }
 
   oop get_oop() { return &_oop; }
-  markOop mark() { return _oop.mark_raw(); }
-  void set_mark(markOop m) { _oop.set_mark_raw(m); }
+
+  markOop mark() { return _oop.mark(); }
+  void set_mark(markOop m) { _oop.set_mark(m); }
   void forward_to(oop obj) {
     markOop m = markOopDesc::encode_pointer_as_mark(obj);
-    _oop.set_mark_raw(m);
+    _oop.set_mark(m);
   }
 
   static markOop originalMark() { return markOop(markOopDesc::lock_mask_in_place); }