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

rev 55008 : 8224667: Shenandoah: Post-LRB cleanup

@@ -197,14 +197,14 @@
 bool ShenandoahBarrierSet::arraycopy_loop_3(T* src, T* dst, size_t length, Klass* bound, bool disjoint,
                                             ShenandoahBarrierSet::ArrayCopyStoreValMode storeval_mode) {
   switch (storeval_mode) {
     case NONE:
       return arraycopy_loop<T, CHECKCAST, SATB, NONE>(src, dst, length, bound, disjoint);
-    case READ_BARRIER:
-      return arraycopy_loop<T, CHECKCAST, SATB, READ_BARRIER>(src, dst, length, bound, disjoint);
-    case WRITE_BARRIER:
-      return arraycopy_loop<T, CHECKCAST, SATB, WRITE_BARRIER>(src, dst, length, bound, disjoint);
+    case RESOLVE_BARRIER:
+      return arraycopy_loop<T, CHECKCAST, SATB, RESOLVE_BARRIER>(src, dst, length, bound, disjoint);
+    case EVAC_BARRIER:
+      return arraycopy_loop<T, CHECKCAST, SATB, EVAC_BARRIER>(src, dst, length, bound, disjoint);
     default:
       ShouldNotReachHere();
       return true; // happy compiler
   }
 }

@@ -266,14 +266,14 @@
     if (!CompressedOops::is_null(prev)) {
       oop prev_obj = CompressedOops::decode_not_null(prev);
       switch (STOREVAL_MODE) {
       case NONE:
         break;
-      case READ_BARRIER:
-      case WRITE_BARRIER:
-        // The write-barrier case cannot really happen. It's traversal-only and traversal
-        // doesn't currently use SATB. And even if it did, it would not be fatal to just do the normal RB here.
+      case RESOLVE_BARRIER:
+      case EVAC_BARRIER:
+        // The evac-barrier case cannot really happen. It's traversal-only and traversal
+        // doesn't currently use SATB. And even if it did, it would not be fatal to just do the normal resolve here.
         prev_obj = ShenandoahBarrierSet::resolve_forwarded_not_null(prev_obj);
       }
       if (!ctx->is_marked(prev_obj)) {
         ShenandoahThreadLocalData::satb_mark_queue(thread).enqueue_known_active(prev_obj);
       }

@@ -291,14 +291,14 @@
     }
 
     switch (STOREVAL_MODE) {
     case NONE:
       break;
-    case READ_BARRIER:
+    case RESOLVE_BARRIER:
       obj = ShenandoahBarrierSet::resolve_forwarded_not_null(obj);
       break;
-    case WRITE_BARRIER:
+    case EVAC_BARRIER:
       if (_heap->in_collection_set(obj)) {
         oop forw = ShenandoahBarrierSet::resolve_forwarded_not_null(obj);
         if (oopDesc::equals_raw(forw, obj)) {
           forw = _heap->evacuate_object(forw, thread);
         }

@@ -335,13 +335,13 @@
   bool checkcast = HasDecorator<decorators, ARRAYCOPY_CHECKCAST>::value;
   bool disjoint = HasDecorator<decorators, ARRAYCOPY_DISJOINT>::value;
   ArrayCopyStoreValMode storeval_mode;
   if (heap->has_forwarded_objects()) {
     if (heap->is_concurrent_traversal_in_progress()) {
-      storeval_mode = WRITE_BARRIER;
+      storeval_mode = EVAC_BARRIER;
     } else if (heap->is_update_refs_in_progress()) {
-      storeval_mode = READ_BARRIER;
+      storeval_mode = RESOLVE_BARRIER;
     } else {
       assert(heap->is_idle() || heap->is_evacuation_in_progress(), "must not have anything in progress");
       storeval_mode = NONE; // E.g. during evac or outside cycle
     }
   } else {