Merge pull request #3109 from kinke/atomic

Fix Issue 20844 - Insufficient alignment check for 16-bytes CAS on x86_64
merged-on-behalf-of: Nicholas Wilson <thewilsonator@users.noreply.github.com>

Author: dlang-bot

src/core/atomic.d

@@ -593,14 +593,12 @@ in (atomicValueIsProperlyAligned(val))
 
 version (D_InlineAsm_X86)
 {
-    version = AsmX86;
     enum has64BitXCHG = false;
     enum has64BitCAS = true;
     enum has128BitCAS = false;
 }
 else version (D_InlineAsm_X86_64)
 {
-    version = AsmX86;
     enum has64BitXCHG = true;
     enum has64BitCAS = true;
     enum has128BitCAS = true;
@@ -621,36 +619,32 @@ else
 
 private
 {
-    version (AsmX86)
+    bool atomicValueIsProperlyAligned(T)(ref T val) pure nothrow @nogc @trusted
+    {
+        return atomicPtrIsProperlyAligned(&val);
+    }
+
+    bool atomicPtrIsProperlyAligned(T)(T* ptr) pure nothrow @nogc @safe
     {
         // NOTE: Strictly speaking, the x86 supports atomic operations on
         //       unaligned values.  However, this is far slower than the
         //       common case, so such behavior should be prohibited.
-        bool atomicValueIsProperlyAligned(T)(ref T val) pure nothrow @nogc @trusted
-        {
-            return atomicPtrIsProperlyAligned(&val);
-        }
-
-        bool atomicPtrIsProperlyAligned(T)(T* ptr) pure nothrow @nogc @safe
+        static if (T.sizeof > size_t.sizeof)
         {
-            // NOTE: 32 bit x86 systems support 8 byte CAS, which only requires
-            //       4 byte alignment, so use size_t as the align type here.
-            static if (T.sizeof > size_t.sizeof)
+            version (X86)
+            {
+                // cmpxchg8b only requires 4-bytes alignment
                 return cast(size_t)ptr % size_t.sizeof == 0;
+            }
             else
+            {
+                // e.g., x86_64 cmpxchg16b requires 16-bytes alignment
                 return cast(size_t)ptr % T.sizeof == 0;
+            }
         }
-    }
-    else
-    {
-        bool atomicValueIsProperlyAligned(T)(ref T val) pure nothrow @nogc @trusted
-        {
-            return true;
-        }
-
-        bool atomicPtrIsProperlyAligned(T)(T*) pure nothrow @nogc @safe
+        else
         {
-            return true;
+            return cast(size_t)ptr % T.sizeof == 0;
         }
     }
 
@@ -824,6 +818,15 @@ private
 
 version (CoreUnittest)
 {
+    version (D_LP64)
+    {
+        enum hasDWCAS = has128BitCAS;
+    }
+    else
+    {
+        enum hasDWCAS = has64BitCAS;
+    }
+
     void testXCHG(T)(T val) pure nothrow @nogc @trusted
     in
     {
@@ -1003,15 +1006,6 @@ version (CoreUnittest)
             assert(b.value1 == 3 && b.value2 ==4);
         }
 
-        version (D_LP64)
-        {
-            enum hasDWCAS = has128BitCAS;
-        }
-        else
-        {
-            enum hasDWCAS = has64BitCAS;
-        }
-
         static if (hasDWCAS)
         {
             static struct List { size_t gen; List* next; }
@@ -1032,6 +1026,28 @@ version (CoreUnittest)
         assert(cast(uint) s1.b == 4);
     }
 
+    // https://issues.dlang.org/show_bug.cgi?id=20844
+    static if (hasDWCAS)
+    {
+        debug: // tests CAS in-contract
+
+        pure nothrow unittest
+        {
+            import core.exception : AssertError;
+
+            align(16) shared ubyte[2 * size_t.sizeof + 1] data;
+            auto misalignedPointer = cast(size_t[2]*) &data[1];
+            size_t[2] x;
+
+            try
+                cas(misalignedPointer, x, x);
+            catch (AssertError)
+                return;
+
+            assert(0, "should have failed");
+        }
+    }
+
     @betterC pure nothrow unittest
     {
         static struct S { int val; }