Cast away volatile on dereference in CAS-based generalization primitives
authorIvan Maidanski <ivmai@mail.ru>
Sat, 12 Jan 2013 16:36:34 +0000 (20:36 +0400)
committerIvan Maidanski <ivmai@mail.ru>
Sat, 12 Jan 2013 16:36:34 +0000 (20:36 +0400)
* src/atomic_ops/generalize-arithm.template
(AO_XSIZE_fetch_and_add_full, AO_XSIZE_fetch_and_add_acquire,
AO_XSIZE_fetch_and_add_release, AO_XSIZE_fetch_and_add,
AO_XSIZE_and_full, AO_XSIZE_or_full, AO_XSIZE_xor_full): Cast away the
volatile (when reading old value before CAS) for architectures like
IA64 (where volatile adds barrier semantics).
* src/atomic_ops/generalize-small.template (AO_XSIZE_load_read,
AO_XSIZE_load_full, AO_XSIZE_load_acquire, AO_XSIZE_load): Likewise.
* src/atomic_ops/generalize-arithm.h: Regenerate.
* src/atomic_ops/generalize-small.h: Likewise.

src/atomic_ops/generalize-arithm.h
src/atomic_ops/generalize-arithm.template
src/atomic_ops/generalize-small.h
src/atomic_ops/generalize-small.template

index a50c697..2607d6e 100644 (file)
 
     do
       {
-        old = *addr;
+        old = *(unsigned/**/char *)addr;
       }
     while (AO_EXPECT_FALSE(!AO_char_compare_and_swap_full(addr, old,
                                                            old + incr)));
 
     do
       {
-        old = *addr;
+        old = *(unsigned/**/char *)addr;
       }
     while (AO_EXPECT_FALSE(!AO_char_compare_and_swap_acquire(addr, old,
                                                               old + incr)));
 
     do
       {
-        old = *addr;
+        old = *(unsigned/**/char *)addr;
       }
     while (AO_EXPECT_FALSE(!AO_char_compare_and_swap_release(addr, old,
                                                               old + incr)));
 
     do
       {
-        old = *addr;
+        old = *(unsigned/**/char *)addr;
       }
     while (AO_EXPECT_FALSE(!AO_char_compare_and_swap(addr, old,
                                                       old + incr)));
 
     do
       {
-        old = *addr;
+        old = *(unsigned/**/char *)addr;
       }
     while (AO_EXPECT_FALSE(!AO_char_compare_and_swap_full(addr, old,
                                                            old & value)));
 
     do
       {
-        old = *addr;
+        old = *(unsigned/**/char *)addr;
       }
     while (AO_EXPECT_FALSE(!AO_char_compare_and_swap_full(addr, old,
                                                            old | value)));
 
     do
       {
-        old = *addr;
+        old = *(unsigned/**/char *)addr;
       }
     while (AO_EXPECT_FALSE(!AO_char_compare_and_swap_full(addr, old,
                                                            old ^ value)));
 
     do
       {
-        old = *addr;
+        old = *(unsigned/**/short *)addr;
       }
     while (AO_EXPECT_FALSE(!AO_short_compare_and_swap_full(addr, old,
                                                            old + incr)));
 
     do
       {
-        old = *addr;
+        old = *(unsigned/**/short *)addr;
       }
     while (AO_EXPECT_FALSE(!AO_short_compare_and_swap_acquire(addr, old,
                                                               old + incr)));
 
     do
       {
-        old = *addr;
+        old = *(unsigned/**/short *)addr;
       }
     while (AO_EXPECT_FALSE(!AO_short_compare_and_swap_release(addr, old,
                                                               old + incr)));
 
     do
       {
-        old = *addr;
+        old = *(unsigned/**/short *)addr;
       }
     while (AO_EXPECT_FALSE(!AO_short_compare_and_swap(addr, old,
                                                       old + incr)));
 
     do
       {
-        old = *addr;
+        old = *(unsigned/**/short *)addr;
       }
     while (AO_EXPECT_FALSE(!AO_short_compare_and_swap_full(addr, old,
                                                            old & value)));
 
     do
       {
-        old = *addr;
+        old = *(unsigned/**/short *)addr;
       }
     while (AO_EXPECT_FALSE(!AO_short_compare_and_swap_full(addr, old,
                                                            old | value)));
 
     do
       {
-        old = *addr;
+        old = *(unsigned/**/short *)addr;
       }
     while (AO_EXPECT_FALSE(!AO_short_compare_and_swap_full(addr, old,
                                                            old ^ value)));
 
     do
       {
-        old = *addr;
+        old = *(unsigned *)addr;
       }
     while (AO_EXPECT_FALSE(!AO_int_compare_and_swap_full(addr, old,
                                                            old + incr)));
 
     do
       {
-        old = *addr;
+        old = *(unsigned *)addr;
       }
     while (AO_EXPECT_FALSE(!AO_int_compare_and_swap_acquire(addr, old,
                                                               old + incr)));
 
     do
       {
-        old = *addr;
+        old = *(unsigned *)addr;
       }
     while (AO_EXPECT_FALSE(!AO_int_compare_and_swap_release(addr, old,
                                                               old + incr)));
 
     do
       {
-        old = *addr;
+        old = *(unsigned *)addr;
       }
     while (AO_EXPECT_FALSE(!AO_int_compare_and_swap(addr, old,
                                                       old + incr)));
 
     do
       {
-        old = *addr;
+        old = *(unsigned *)addr;
       }
     while (AO_EXPECT_FALSE(!AO_int_compare_and_swap_full(addr, old,
                                                            old & value)));
 
     do
       {
-        old = *addr;
+        old = *(unsigned *)addr;
       }
     while (AO_EXPECT_FALSE(!AO_int_compare_and_swap_full(addr, old,
                                                            old | value)));
 
     do
       {
-        old = *addr;
+        old = *(unsigned *)addr;
       }
     while (AO_EXPECT_FALSE(!AO_int_compare_and_swap_full(addr, old,
                                                            old ^ value)));
 
     do
       {
-        old = *addr;
+        old = *(AO_t *)addr;
       }
     while (AO_EXPECT_FALSE(!AO_compare_and_swap_full(addr, old,
                                                            old + incr)));
 
     do
       {
-        old = *addr;
+        old = *(AO_t *)addr;
       }
     while (AO_EXPECT_FALSE(!AO_compare_and_swap_acquire(addr, old,
                                                               old + incr)));
 
     do
       {
-        old = *addr;
+        old = *(AO_t *)addr;
       }
     while (AO_EXPECT_FALSE(!AO_compare_and_swap_release(addr, old,
                                                               old + incr)));
 
     do
       {
-        old = *addr;
+        old = *(AO_t *)addr;
       }
     while (AO_EXPECT_FALSE(!AO_compare_and_swap(addr, old,
                                                       old + incr)));
 
     do
       {
-        old = *addr;
+        old = *(AO_t *)addr;
       }
     while (AO_EXPECT_FALSE(!AO_compare_and_swap_full(addr, old,
                                                            old & value)));
 
     do
       {
-        old = *addr;
+        old = *(AO_t *)addr;
       }
     while (AO_EXPECT_FALSE(!AO_compare_and_swap_full(addr, old,
                                                            old | value)));
 
     do
       {
-        old = *addr;
+        old = *(AO_t *)addr;
       }
     while (AO_EXPECT_FALSE(!AO_compare_and_swap_full(addr, old,
                                                            old ^ value)));
index 93750c8..3696782 100644 (file)
 
     do
       {
-        old = *addr;
+        old = *(XCTYPE *)addr;
       }
     while (AO_EXPECT_FALSE(!AO_XSIZE_compare_and_swap_full(addr, old,
                                                            old + incr)));
 
     do
       {
-        old = *addr;
+        old = *(XCTYPE *)addr;
       }
     while (AO_EXPECT_FALSE(!AO_XSIZE_compare_and_swap_acquire(addr, old,
                                                               old + incr)));
 
     do
       {
-        old = *addr;
+        old = *(XCTYPE *)addr;
       }
     while (AO_EXPECT_FALSE(!AO_XSIZE_compare_and_swap_release(addr, old,
                                                               old + incr)));
 
     do
       {
-        old = *addr;
+        old = *(XCTYPE *)addr;
       }
     while (AO_EXPECT_FALSE(!AO_XSIZE_compare_and_swap(addr, old,
                                                       old + incr)));
 
     do
       {
-        old = *addr;
+        old = *(XCTYPE *)addr;
       }
     while (AO_EXPECT_FALSE(!AO_XSIZE_compare_and_swap_full(addr, old,
                                                            old & value)));
 
     do
       {
-        old = *addr;
+        old = *(XCTYPE *)addr;
       }
     while (AO_EXPECT_FALSE(!AO_XSIZE_compare_and_swap_full(addr, old,
                                                            old | value)));
 
     do
       {
-        old = *addr;
+        old = *(XCTYPE *)addr;
       }
     while (AO_EXPECT_FALSE(!AO_XSIZE_compare_and_swap_full(addr, old,
                                                            old ^ value)));
index 79a0210..dfc3c8c 100644 (file)
     unsigned/**/char result;
 
     do {
-      result = *addr;
+      result = *(const unsigned/**/char *)addr;
     } while (AO_EXPECT_FALSE(!AO_char_compare_and_swap_read(
                                                 (volatile unsigned/**/char *)addr,
                                                 result, result)));
     unsigned/**/char result;
 
     do {
-      result = *addr;
+      result = *(const unsigned/**/char *)addr;
     } while (AO_EXPECT_FALSE(!AO_char_compare_and_swap_full(
                                                 (volatile unsigned/**/char *)addr,
                                                 result, result)));
     unsigned/**/char result;
 
     do {
-      result = *addr;
+      result = *(const unsigned/**/char *)addr;
     } while (AO_EXPECT_FALSE(!AO_char_compare_and_swap_acquire(
                                                 (volatile unsigned/**/char *)addr,
                                                 result, result)));
     unsigned/**/char result;
 
     do {
-      result = *addr;
+      result = *(const unsigned/**/char *)addr;
     } while (AO_EXPECT_FALSE(!AO_char_compare_and_swap(
                                                 (volatile unsigned/**/char *)addr,
                                                 result, result)));
     unsigned/**/short result;
 
     do {
-      result = *addr;
+      result = *(const unsigned/**/short *)addr;
     } while (AO_EXPECT_FALSE(!AO_short_compare_and_swap_read(
                                                 (volatile unsigned/**/short *)addr,
                                                 result, result)));
     unsigned/**/short result;
 
     do {
-      result = *addr;
+      result = *(const unsigned/**/short *)addr;
     } while (AO_EXPECT_FALSE(!AO_short_compare_and_swap_full(
                                                 (volatile unsigned/**/short *)addr,
                                                 result, result)));
     unsigned/**/short result;
 
     do {
-      result = *addr;
+      result = *(const unsigned/**/short *)addr;
     } while (AO_EXPECT_FALSE(!AO_short_compare_and_swap_acquire(
                                                 (volatile unsigned/**/short *)addr,
                                                 result, result)));
     unsigned/**/short result;
 
     do {
-      result = *addr;
+      result = *(const unsigned/**/short *)addr;
     } while (AO_EXPECT_FALSE(!AO_short_compare_and_swap(
                                                 (volatile unsigned/**/short *)addr,
                                                 result, result)));
     unsigned result;
 
     do {
-      result = *addr;
+      result = *(const unsigned *)addr;
     } while (AO_EXPECT_FALSE(!AO_int_compare_and_swap_read(
                                                 (volatile unsigned *)addr,
                                                 result, result)));
     unsigned result;
 
     do {
-      result = *addr;
+      result = *(const unsigned *)addr;
     } while (AO_EXPECT_FALSE(!AO_int_compare_and_swap_full(
                                                 (volatile unsigned *)addr,
                                                 result, result)));
     unsigned result;
 
     do {
-      result = *addr;
+      result = *(const unsigned *)addr;
     } while (AO_EXPECT_FALSE(!AO_int_compare_and_swap_acquire(
                                                 (volatile unsigned *)addr,
                                                 result, result)));
     unsigned result;
 
     do {
-      result = *addr;
+      result = *(const unsigned *)addr;
     } while (AO_EXPECT_FALSE(!AO_int_compare_and_swap(
                                                 (volatile unsigned *)addr,
                                                 result, result)));
     AO_t result;
 
     do {
-      result = *addr;
+      result = *(const AO_t *)addr;
     } while (AO_EXPECT_FALSE(!AO_compare_and_swap_read(
                                                 (volatile AO_t *)addr,
                                                 result, result)));
     AO_t result;
 
     do {
-      result = *addr;
+      result = *(const AO_t *)addr;
     } while (AO_EXPECT_FALSE(!AO_compare_and_swap_full(
                                                 (volatile AO_t *)addr,
                                                 result, result)));
     AO_t result;
 
     do {
-      result = *addr;
+      result = *(const AO_t *)addr;
     } while (AO_EXPECT_FALSE(!AO_compare_and_swap_acquire(
                                                 (volatile AO_t *)addr,
                                                 result, result)));
     AO_t result;
 
     do {
-      result = *addr;
+      result = *(const AO_t *)addr;
     } while (AO_EXPECT_FALSE(!AO_compare_and_swap(
                                                 (volatile AO_t *)addr,
                                                 result, result)));
     AO_double_t result;
 
     do {
-      result = *addr;
+      result = *(const AO_double_t *)addr;
     } while (AO_EXPECT_FALSE(!AO_double_compare_and_swap_read(
                                                 (volatile AO_double_t *)addr,
                                                 result, result)));
     AO_double_t result;
 
     do {
-      result = *addr;
+      result = *(const AO_double_t *)addr;
     } while (AO_EXPECT_FALSE(!AO_double_compare_and_swap_full(
                                                 (volatile AO_double_t *)addr,
                                                 result, result)));
     AO_double_t result;
 
     do {
-      result = *addr;
+      result = *(const AO_double_t *)addr;
     } while (AO_EXPECT_FALSE(!AO_double_compare_and_swap_acquire(
                                                 (volatile AO_double_t *)addr,
                                                 result, result)));
     AO_double_t result;
 
     do {
-      result = *addr;
+      result = *(const AO_double_t *)addr;
     } while (AO_EXPECT_FALSE(!AO_double_compare_and_swap(
                                                 (volatile AO_double_t *)addr,
                                                 result, result)));
index ae06901..b8ab439 100644 (file)
     XCTYPE result;
 
     do {
-      result = *addr;
+      result = *(const XCTYPE *)addr;
     } while (AO_EXPECT_FALSE(!AO_XSIZE_compare_and_swap_read(
                                                 (volatile XCTYPE *)addr,
                                                 result, result)));
     XCTYPE result;
 
     do {
-      result = *addr;
+      result = *(const XCTYPE *)addr;
     } while (AO_EXPECT_FALSE(!AO_XSIZE_compare_and_swap_full(
                                                 (volatile XCTYPE *)addr,
                                                 result, result)));
     XCTYPE result;
 
     do {
-      result = *addr;
+      result = *(const XCTYPE *)addr;
     } while (AO_EXPECT_FALSE(!AO_XSIZE_compare_and_swap_acquire(
                                                 (volatile XCTYPE *)addr,
                                                 result, result)));
     XCTYPE result;
 
     do {
-      result = *addr;
+      result = *(const XCTYPE *)addr;
     } while (AO_EXPECT_FALSE(!AO_XSIZE_compare_and_swap(
                                                 (volatile XCTYPE *)addr,
                                                 result, result)));