src/hotspot/share/gc/shenandoah/shenandoahSharedVariables.hpp

*** 45,67 ****
    ShenandoahSharedFlag() {
      unset();
    }
  
    void set() {
!     OrderAccess::release_store_fence(&value, (ShenandoahSharedValue)SET);
    }
  
    void unset() {
!     OrderAccess::release_store_fence(&value, (ShenandoahSharedValue)UNSET);
    }
  
    bool is_set() const {
!     return OrderAccess::load_acquire(&value) == SET;
    }
  
    bool is_unset() const {
!     return OrderAccess::load_acquire(&value) == UNSET;
    }
  
    void set_cond(bool val) {
      if (val) {
        set();
--- 45,67 ----
    ShenandoahSharedFlag() {
      unset();
    }
  
    void set() {
!     Atomic::release_store_fence(&value, (ShenandoahSharedValue)SET);
    }
  
    void unset() {
!     Atomic::release_store_fence(&value, (ShenandoahSharedValue)UNSET);
    }
  
    bool is_set() const {
!     return Atomic::load_acquire(&value) == SET;
    }
  
    bool is_unset() const {
!     return Atomic::load_acquire(&value) == UNSET;
    }
  
    void set_cond(bool val) {
      if (val) {
        set();
*** 116,126 ****
  
    void set(uint mask) {
      assert (mask < (sizeof(ShenandoahSharedValue) * CHAR_MAX), "sanity");
      ShenandoahSharedValue mask_val = (ShenandoahSharedValue) mask;
      while (true) {
!       ShenandoahSharedValue ov = OrderAccess::load_acquire(&value);
        if ((ov & mask_val) != 0) {
          // already set
          return;
        }
  
--- 116,126 ----
  
    void set(uint mask) {
      assert (mask < (sizeof(ShenandoahSharedValue) * CHAR_MAX), "sanity");
      ShenandoahSharedValue mask_val = (ShenandoahSharedValue) mask;
      while (true) {
!       ShenandoahSharedValue ov = Atomic::load_acquire(&value);
        if ((ov & mask_val) != 0) {
          // already set
          return;
        }
  
*** 134,144 ****
  
    void unset(uint mask) {
      assert (mask < (sizeof(ShenandoahSharedValue) * CHAR_MAX), "sanity");
      ShenandoahSharedValue mask_val = (ShenandoahSharedValue) mask;
      while (true) {
!       ShenandoahSharedValue ov = OrderAccess::load_acquire(&value);
        if ((ov & mask_val) == 0) {
          // already unset
          return;
        }
  
--- 134,144 ----
  
    void unset(uint mask) {
      assert (mask < (sizeof(ShenandoahSharedValue) * CHAR_MAX), "sanity");
      ShenandoahSharedValue mask_val = (ShenandoahSharedValue) mask;
      while (true) {
!       ShenandoahSharedValue ov = Atomic::load_acquire(&value);
        if ((ov & mask_val) == 0) {
          // already unset
          return;
        }
  
*** 149,172 ****
        }
      }
    }
  
    void clear() {
!     OrderAccess::release_store_fence(&value, (ShenandoahSharedValue)0);
    }
  
    bool is_set(uint mask) const {
      return !is_unset(mask);
    }
  
    bool is_unset(uint mask) const {
      assert (mask < (sizeof(ShenandoahSharedValue) * CHAR_MAX), "sanity");
!     return (OrderAccess::load_acquire(&value) & (ShenandoahSharedValue) mask) == 0;
    }
  
    bool is_clear() const {
!     return (OrderAccess::load_acquire(&value)) == 0;
    }
  
    void set_cond(uint mask, bool val) {
      if (val) {
        set(mask);
--- 149,172 ----
        }
      }
    }
  
    void clear() {
!     Atomic::release_store_fence(&value, (ShenandoahSharedValue)0);
    }
  
    bool is_set(uint mask) const {
      return !is_unset(mask);
    }
  
    bool is_unset(uint mask) const {
      assert (mask < (sizeof(ShenandoahSharedValue) * CHAR_MAX), "sanity");
!     return (Atomic::load_acquire(&value) & (ShenandoahSharedValue) mask) == 0;
    }
  
    bool is_clear() const {
!     return (Atomic::load_acquire(&value)) == 0;
    }
  
    void set_cond(uint mask, bool val) {
      if (val) {
        set(mask);
*** 209,223 ****
    }
  
    void set(T v) {
      assert (v >= 0, "sanity");
      assert (v < (sizeof(ShenandoahSharedValue) * CHAR_MAX), "sanity");
!     OrderAccess::release_store_fence(&value, (ShenandoahSharedValue)v);
    }
  
    T get() const {
!     return (T)OrderAccess::load_acquire(&value);
    }
  
    T cmpxchg(T new_value, T expected) {
      assert (new_value >= 0, "sanity");
      assert (new_value < (sizeof(ShenandoahSharedValue) * CHAR_MAX), "sanity");
--- 209,223 ----
    }
  
    void set(T v) {
      assert (v >= 0, "sanity");
      assert (v < (sizeof(ShenandoahSharedValue) * CHAR_MAX), "sanity");
!     Atomic::release_store_fence(&value, (ShenandoahSharedValue)v);
    }
  
    T get() const {
!     return (T)Atomic::load_acquire(&value);
    }
  
    T cmpxchg(T new_value, T expected) {
      assert (new_value >= 0, "sanity");
      assert (new_value < (sizeof(ShenandoahSharedValue) * CHAR_MAX), "sanity");