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

*** 119,18 ***
    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;
        }
  
        ShenandoahSharedValue nv = ov | mask_val;
        if (Atomic::cmpxchg(&value, ov, nv) == ov) {
!         // successfully set
          return;
        }
      }
    }
  
--- 119,19 ---
    void set(uint mask) {
      assert (mask < (sizeof(ShenandoahSharedValue) * CHAR_MAX), "sanity");
      ShenandoahSharedValue mask_val = (ShenandoahSharedValue) mask;
      while (true) {
        ShenandoahSharedValue ov = Atomic::load_acquire(&value);
!       // We require all bits of mask_val to be set
+       if ((ov & mask_val) == mask_val) {
          // already set
          return;
        }
  
        ShenandoahSharedValue nv = ov | mask_val;
        if (Atomic::cmpxchg(&value, ov, nv) == ov) {
!         // successfully set: if value returned from cmpxchg equals ov, then nv has overwritten value.
          return;
        }
      }
    }
  

*** 154,14 ***
--- 155,23 ---
  
    void clear() {
      Atomic::release_store_fence(&value, (ShenandoahSharedValue)0);
    }
  
+   // Returns true iff any bit set in mask is set in this.value.
    bool is_set(uint mask) const {
      return !is_unset(mask);
    }
  
+   // Returns true iff all bits set in mask are set in this.value.
+   bool is_set_exactly(uint mask) const {
+     assert (mask < (sizeof(ShenandoahSharedValue) * CHAR_MAX), "sanity");
+     uint uvalue = Atomic::load_acquire(&value);
+     return (uvalue & mask) == mask;
+   }
+ 
+   // Returns true iff all bits set in mask are unset in this.value.
    bool is_unset(uint mask) const {
      assert (mask < (sizeof(ShenandoahSharedValue) * CHAR_MAX), "sanity");
      return (Atomic::load_acquire(&value) & (ShenandoahSharedValue) mask) == 0;
    }
  

*** 200,35 ***
  
  } ShenandoahSharedBitmap;
  
  template<class T>
  struct ShenandoahSharedEnumFlag {
    shenandoah_padding(0);
!   volatile ShenandoahSharedValue value;
    shenandoah_padding(1);
  
    ShenandoahSharedEnumFlag() {
      value = 0;
    }
  
    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");
!     return (T)Atomic::cmpxchg(&value, (ShenandoahSharedValue)expected, (ShenandoahSharedValue)new_value);
    }
  
!   volatile ShenandoahSharedValue* addr_of() {
      return &value;
    }
  
  private:
    volatile T* operator&() {
--- 210,42 ---
  
  } ShenandoahSharedBitmap;
  
  template<class T>
  struct ShenandoahSharedEnumFlag {
+   typedef uint32_t EnumValueType;
    shenandoah_padding(0);
!   volatile EnumValueType value;
    shenandoah_padding(1);
  
    ShenandoahSharedEnumFlag() {
      value = 0;
    }
  
    void set(T v) {
      assert (v >= 0, "sanity");
!     assert (v < (sizeof(EnumValueType) * CHAR_MAX), "sanity");
!     Atomic::release_store_fence(&value, (EnumValueType)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(EnumValueType) * CHAR_MAX), "sanity");
!     return (T)Atomic::cmpxchg(&value, (EnumValueType)expected, (EnumValueType)new_value);
    }
  
!   T xchg(T new_value) {
+     assert (new_value >= 0, "sanity");
+     assert (new_value < (sizeof(EnumValueType) * CHAR_MAX), "sanity");
+     return (T)Atomic::xchg(&value, (EnumValueType)new_value);
+   }
+ 
+   volatile EnumValueType* addr_of() {
      return &value;
    }
  
  private:
    volatile T* operator&() {