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

rev 55008 : 8224667: Shenandoah: Post-LRB cleanup

*** 197,210 ****
  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);
      default:
        ShouldNotReachHere();
        return true; // happy compiler
    }
  }
--- 197,210 ----
  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 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,279 ****
      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.
          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);
        }
--- 266,279 ----
      if (!CompressedOops::is_null(prev)) {
        oop prev_obj = CompressedOops::decode_not_null(prev);
        switch (STOREVAL_MODE) {
        case NONE:
          break;
!       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,304 ****
      }
  
      switch (STOREVAL_MODE) {
      case NONE:
        break;
!     case READ_BARRIER:
        obj = ShenandoahBarrierSet::resolve_forwarded_not_null(obj);
        break;
!     case WRITE_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);
          }
--- 291,304 ----
      }
  
      switch (STOREVAL_MODE) {
      case NONE:
        break;
!     case RESOLVE_BARRIER:
        obj = ShenandoahBarrierSet::resolve_forwarded_not_null(obj);
        break;
!     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,347 ****
    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;
      } else if (heap->is_update_refs_in_progress()) {
!       storeval_mode = READ_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 {
--- 335,347 ----
    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 = EVAC_BARRIER;
      } else if (heap->is_update_refs_in_progress()) {
!       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 {