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

@@ -119,18 +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);
-       if ((ov & mask_val) != 0) {
+       // 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
+         // 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 +210,42 @@
  
  } ShenandoahSharedBitmap;
  
  template<class T>
  struct ShenandoahSharedEnumFlag {
+   typedef uint32_t EnumValueType;
    shenandoah_padding(0);
-   volatile ShenandoahSharedValue value;
+   volatile EnumValueType 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);
+     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(ShenandoahSharedValue) * CHAR_MAX), "sanity");
-     return (T)Atomic::cmpxchg(&value, (ShenandoahSharedValue)expected, (ShenandoahSharedValue)new_value);
+     assert (new_value < (sizeof(EnumValueType) * CHAR_MAX), "sanity");
+     return (T)Atomic::cmpxchg(&value, (EnumValueType)expected, (EnumValueType)new_value);
    }
  
-   volatile ShenandoahSharedValue* addr_of() {
+   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&() {