projects / platform / upstream / libatomic_ops.git / commitdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | patch | inline | side by side (parent: 24410d7)
Place no_sanitize attributes in a GCC-compliant way
authorIvan Maidanski <ivmai@mail.ru>
Sun, 19 Nov 2017 07:41:30 +0000 (10:41 +0300)
committerIvan Maidanski <ivmai@mail.ru>
Thu, 30 Nov 2017 15:51:10 +0000 (18:51 +0300)
(fix commits 9020c5db, c058d9dc)

Now the attributes precede the function prototypes (the format is:
<attribute> void f(void) <body>).

* 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): Move
AO_ATTR_NO_SANITIZE_THREAD attribute to the beginning of the function
prototype (to be right before AO_INLINE).
* src/atomic_ops/generalize-small.template (AO_XSIZE_load_read,
AO_XSIZE_load_full, AO_XSIZE_load_acquire, AO_XSIZE_load,
AO_XSIZE_store_write, AO_XSIZE_store, AO_XSIZE_store_release,
AO_XSIZE_store_full): Likewise.
* src/atomic_ops_stack.c [AO_USE_ALMOST_LOCK_FREE]
(AO_stack_push_explicit_aux_release): Likewise.
* src/atomic_ops_stack.c [!USE_ALMOST_LOCK_FREE]
(AO_stack_push_release, AO_stack_pop_acquire): Likewise.
* tests/test_atomic.c [AO_HAVE_test_and_set_acquire] (do_junk):
Likewise.
* tests/test_malloc.c (cons): Likewise.
* src/atomic_ops/generalize-small.template (AO_XSIZE_store_write,
AO_XSIZE_store, AO_XSIZE_store_release, AO_XSIZE_store_full): Move
AO_ATTR_NO_SANITIZE_MEMORY attribute to the beginning of the function
prototype.
* src/atomic_ops/generalize-arithm.h: Regenerate.
* src/atomic_ops/generalize-small.h: Likewise.

src/atomic_ops/generalize-arithm.h patch | blob | history
src/atomic_ops/generalize-arithm.template patch | blob | history
src/atomic_ops/generalize-small.h patch | blob | history
src/atomic_ops/generalize-small.template patch | blob | history
src/atomic_ops_stack.c patch | blob | history
tests/test_atomic.c patch | blob | history
tests/test_malloc.c patch | blob | history

diff --git a/src/atomic_ops/generalize-arithm.h b/src/atomic_ops/generalize-arithm.h
index 27ccf9b..515f52e 100644 (file)
--- a/src/atomic_ops/generalize-arithm.h
+++ b/src/atomic_ops/generalize-arithm.h
@@ -133,9 +133,9 @@
 /* corresponding compare_and_swap variants to minimize adding barriers. */
 #if defined(AO_HAVE_char_compare_and_swap_full) \
     && !defined(AO_HAVE_char_fetch_and_add_full)
+  AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE unsigned/**/char
   AO_char_fetch_and_add_full(volatile unsigned/**/char *addr, unsigned/**/char incr)
-                                                AO_ATTR_NO_SANITIZE_THREAD
   {
     unsigned/**/char old;
 
@@ -152,9 +152,9 @@
 
 #if defined(AO_HAVE_char_compare_and_swap_acquire) \
     && !defined(AO_HAVE_char_fetch_and_add_acquire)
+  AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE unsigned/**/char
   AO_char_fetch_and_add_acquire(volatile unsigned/**/char *addr, unsigned/**/char incr)
-                                                AO_ATTR_NO_SANITIZE_THREAD
   {
     unsigned/**/char old;
 
@@ -171,9 +171,9 @@
 
 #if defined(AO_HAVE_char_compare_and_swap_release) \
     && !defined(AO_HAVE_char_fetch_and_add_release)
+  AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE unsigned/**/char
   AO_char_fetch_and_add_release(volatile unsigned/**/char *addr, unsigned/**/char incr)
-                                                AO_ATTR_NO_SANITIZE_THREAD
   {
     unsigned/**/char old;
 
@@ -190,9 +190,9 @@
 
 #if defined(AO_HAVE_char_compare_and_swap) \
     && !defined(AO_HAVE_char_fetch_and_add)
+  AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE unsigned/**/char
   AO_char_fetch_and_add(volatile unsigned/**/char *addr, unsigned/**/char incr)
-                                                AO_ATTR_NO_SANITIZE_THREAD
   {
     unsigned/**/char old;
 
@@ -604,9 +604,9 @@
 /* char_and */
 #if defined(AO_HAVE_char_compare_and_swap_full) \
     && !defined(AO_HAVE_char_and_full)
+  AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE void
   AO_char_and_full(volatile unsigned/**/char *addr, unsigned/**/char value)
-                                                AO_ATTR_NO_SANITIZE_THREAD
   {
     unsigned/**/char old;
 
@@ -687,9 +687,9 @@
 /* char_or */
 #if defined(AO_HAVE_char_compare_and_swap_full) \
     && !defined(AO_HAVE_char_or_full)
+  AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE void
   AO_char_or_full(volatile unsigned/**/char *addr, unsigned/**/char value)
-                                                AO_ATTR_NO_SANITIZE_THREAD
   {
     unsigned/**/char old;
 
@@ -769,9 +769,9 @@
 /* char_xor */
 #if defined(AO_HAVE_char_compare_and_swap_full) \
     && !defined(AO_HAVE_char_xor_full)
+  AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE void
   AO_char_xor_full(volatile unsigned/**/char *addr, unsigned/**/char value)
-                                                AO_ATTR_NO_SANITIZE_THREAD
   {
     unsigned/**/char old;
 
@@ -985,9 +985,9 @@
 /* corresponding compare_and_swap variants to minimize adding barriers. */
 #if defined(AO_HAVE_short_compare_and_swap_full) \
     && !defined(AO_HAVE_short_fetch_and_add_full)
+  AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE unsigned/**/short
   AO_short_fetch_and_add_full(volatile unsigned/**/short *addr, unsigned/**/short incr)
-                                                AO_ATTR_NO_SANITIZE_THREAD
   {
     unsigned/**/short old;
 
@@ -1004,9 +1004,9 @@
 
 #if defined(AO_HAVE_short_compare_and_swap_acquire) \
     && !defined(AO_HAVE_short_fetch_and_add_acquire)
+  AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE unsigned/**/short
   AO_short_fetch_and_add_acquire(volatile unsigned/**/short *addr, unsigned/**/short incr)
-                                                AO_ATTR_NO_SANITIZE_THREAD
   {
     unsigned/**/short old;
 
@@ -1023,9 +1023,9 @@
 
 #if defined(AO_HAVE_short_compare_and_swap_release) \
     && !defined(AO_HAVE_short_fetch_and_add_release)
+  AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE unsigned/**/short
   AO_short_fetch_and_add_release(volatile unsigned/**/short *addr, unsigned/**/short incr)
-                                                AO_ATTR_NO_SANITIZE_THREAD
   {
     unsigned/**/short old;
 
@@ -1042,9 +1042,9 @@
 
 #if defined(AO_HAVE_short_compare_and_swap) \
     && !defined(AO_HAVE_short_fetch_and_add)
+  AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE unsigned/**/short
   AO_short_fetch_and_add(volatile unsigned/**/short *addr, unsigned/**/short incr)
-                                                AO_ATTR_NO_SANITIZE_THREAD
   {
     unsigned/**/short old;
 
@@ -1456,9 +1456,9 @@
 /* short_and */
 #if defined(AO_HAVE_short_compare_and_swap_full) \
     && !defined(AO_HAVE_short_and_full)
+  AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE void
   AO_short_and_full(volatile unsigned/**/short *addr, unsigned/**/short value)
-                                                AO_ATTR_NO_SANITIZE_THREAD
   {
     unsigned/**/short old;
 
@@ -1539,9 +1539,9 @@
 /* short_or */
 #if defined(AO_HAVE_short_compare_and_swap_full) \
     && !defined(AO_HAVE_short_or_full)
+  AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE void
   AO_short_or_full(volatile unsigned/**/short *addr, unsigned/**/short value)
-                                                AO_ATTR_NO_SANITIZE_THREAD
   {
     unsigned/**/short old;
 
@@ -1621,9 +1621,9 @@
 /* short_xor */
 #if defined(AO_HAVE_short_compare_and_swap_full) \
     && !defined(AO_HAVE_short_xor_full)
+  AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE void
   AO_short_xor_full(volatile unsigned/**/short *addr, unsigned/**/short value)
-                                                AO_ATTR_NO_SANITIZE_THREAD
   {
     unsigned/**/short old;
 
@@ -1837,9 +1837,9 @@
 /* corresponding compare_and_swap variants to minimize adding barriers. */
 #if defined(AO_HAVE_int_compare_and_swap_full) \
     && !defined(AO_HAVE_int_fetch_and_add_full)
+  AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE unsigned
   AO_int_fetch_and_add_full(volatile unsigned *addr, unsigned incr)
-                                                AO_ATTR_NO_SANITIZE_THREAD
   {
     unsigned old;
 
@@ -1856,9 +1856,9 @@
 
 #if defined(AO_HAVE_int_compare_and_swap_acquire) \
     && !defined(AO_HAVE_int_fetch_and_add_acquire)
+  AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE unsigned
   AO_int_fetch_and_add_acquire(volatile unsigned *addr, unsigned incr)
-                                                AO_ATTR_NO_SANITIZE_THREAD
   {
     unsigned old;
 
@@ -1875,9 +1875,9 @@
 
 #if defined(AO_HAVE_int_compare_and_swap_release) \
     && !defined(AO_HAVE_int_fetch_and_add_release)
+  AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE unsigned
   AO_int_fetch_and_add_release(volatile unsigned *addr, unsigned incr)
-                                                AO_ATTR_NO_SANITIZE_THREAD
   {
     unsigned old;
 
@@ -1894,9 +1894,9 @@
 
 #if defined(AO_HAVE_int_compare_and_swap) \
     && !defined(AO_HAVE_int_fetch_and_add)
+  AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE unsigned
   AO_int_fetch_and_add(volatile unsigned *addr, unsigned incr)
-                                                AO_ATTR_NO_SANITIZE_THREAD
   {
     unsigned old;
 
@@ -2308,9 +2308,9 @@
 /* int_and */
 #if defined(AO_HAVE_int_compare_and_swap_full) \
     && !defined(AO_HAVE_int_and_full)
+  AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE void
   AO_int_and_full(volatile unsigned *addr, unsigned value)
-                                                AO_ATTR_NO_SANITIZE_THREAD
   {
     unsigned old;
 
@@ -2391,9 +2391,9 @@
 /* int_or */
 #if defined(AO_HAVE_int_compare_and_swap_full) \
     && !defined(AO_HAVE_int_or_full)
+  AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE void
   AO_int_or_full(volatile unsigned *addr, unsigned value)
-                                                AO_ATTR_NO_SANITIZE_THREAD
   {
     unsigned old;
 
@@ -2473,9 +2473,9 @@
 /* int_xor */
 #if defined(AO_HAVE_int_compare_and_swap_full) \
     && !defined(AO_HAVE_int_xor_full)
+  AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE void
   AO_int_xor_full(volatile unsigned *addr, unsigned value)
-                                                AO_ATTR_NO_SANITIZE_THREAD
   {
     unsigned old;
 
@@ -2689,9 +2689,9 @@
 /* corresponding compare_and_swap variants to minimize adding barriers. */
 #if defined(AO_HAVE_compare_and_swap_full) \
     && !defined(AO_HAVE_fetch_and_add_full)
+  AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE AO_t
   AO_fetch_and_add_full(volatile AO_t *addr, AO_t incr)
-                                                AO_ATTR_NO_SANITIZE_THREAD
   {
     AO_t old;
 
@@ -2708,9 +2708,9 @@
 
 #if defined(AO_HAVE_compare_and_swap_acquire) \
     && !defined(AO_HAVE_fetch_and_add_acquire)
+  AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE AO_t
   AO_fetch_and_add_acquire(volatile AO_t *addr, AO_t incr)
-                                                AO_ATTR_NO_SANITIZE_THREAD
   {
     AO_t old;
 
@@ -2727,9 +2727,9 @@
 
 #if defined(AO_HAVE_compare_and_swap_release) \
     && !defined(AO_HAVE_fetch_and_add_release)
+  AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE AO_t
   AO_fetch_and_add_release(volatile AO_t *addr, AO_t incr)
-                                                AO_ATTR_NO_SANITIZE_THREAD
   {
     AO_t old;
 
@@ -2746,9 +2746,9 @@
 
 #if defined(AO_HAVE_compare_and_swap) \
     && !defined(AO_HAVE_fetch_and_add)
+  AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE AO_t
   AO_fetch_and_add(volatile AO_t *addr, AO_t incr)
-                                                AO_ATTR_NO_SANITIZE_THREAD
   {
     AO_t old;
 
@@ -3160,9 +3160,9 @@
 /* and */
 #if defined(AO_HAVE_compare_and_swap_full) \
     && !defined(AO_HAVE_and_full)
+  AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE void
   AO_and_full(volatile AO_t *addr, AO_t value)
-                                                AO_ATTR_NO_SANITIZE_THREAD
   {
     AO_t old;
 
@@ -3243,9 +3243,9 @@
 /* or */
 #if defined(AO_HAVE_compare_and_swap_full) \
     && !defined(AO_HAVE_or_full)
+  AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE void
   AO_or_full(volatile AO_t *addr, AO_t value)
-                                                AO_ATTR_NO_SANITIZE_THREAD
   {
     AO_t old;
 
@@ -3325,9 +3325,9 @@
 /* xor */
 #if defined(AO_HAVE_compare_and_swap_full) \
     && !defined(AO_HAVE_xor_full)
+  AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE void
   AO_xor_full(volatile AO_t *addr, AO_t value)
-                                                AO_ATTR_NO_SANITIZE_THREAD
   {
     AO_t old;
 
diff --git a/src/atomic_ops/generalize-arithm.template b/src/atomic_ops/generalize-arithm.template
index 69735fd..0a21ec2 100644 (file)
--- a/src/atomic_ops/generalize-arithm.template
+++ b/src/atomic_ops/generalize-arithm.template
@@ -133,9 +133,9 @@
 /* corresponding compare_and_swap variants to minimize adding barriers. */
 #if defined(AO_HAVE_XSIZE_compare_and_swap_full) \
     && !defined(AO_HAVE_XSIZE_fetch_and_add_full)
+  AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE XCTYPE
   AO_XSIZE_fetch_and_add_full(volatile XCTYPE *addr, XCTYPE incr)
-                                                AO_ATTR_NO_SANITIZE_THREAD
   {
     XCTYPE old;
 
@@ -152,9 +152,9 @@
 
 #if defined(AO_HAVE_XSIZE_compare_and_swap_acquire) \
     && !defined(AO_HAVE_XSIZE_fetch_and_add_acquire)
+  AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE XCTYPE
   AO_XSIZE_fetch_and_add_acquire(volatile XCTYPE *addr, XCTYPE incr)
-                                                AO_ATTR_NO_SANITIZE_THREAD
   {
     XCTYPE old;
 
@@ -171,9 +171,9 @@
 
 #if defined(AO_HAVE_XSIZE_compare_and_swap_release) \
     && !defined(AO_HAVE_XSIZE_fetch_and_add_release)
+  AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE XCTYPE
   AO_XSIZE_fetch_and_add_release(volatile XCTYPE *addr, XCTYPE incr)
-                                                AO_ATTR_NO_SANITIZE_THREAD
   {
     XCTYPE old;
 
@@ -190,9 +190,9 @@
 
 #if defined(AO_HAVE_XSIZE_compare_and_swap) \
     && !defined(AO_HAVE_XSIZE_fetch_and_add)
+  AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE XCTYPE
   AO_XSIZE_fetch_and_add(volatile XCTYPE *addr, XCTYPE incr)
-                                                AO_ATTR_NO_SANITIZE_THREAD
   {
     XCTYPE old;
 
@@ -604,9 +604,9 @@
 /* XSIZE_and */
 #if defined(AO_HAVE_XSIZE_compare_and_swap_full) \
     && !defined(AO_HAVE_XSIZE_and_full)
+  AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE void
   AO_XSIZE_and_full(volatile XCTYPE *addr, XCTYPE value)
-                                                AO_ATTR_NO_SANITIZE_THREAD
   {
     XCTYPE old;
 
@@ -687,9 +687,9 @@
 /* XSIZE_or */
 #if defined(AO_HAVE_XSIZE_compare_and_swap_full) \
     && !defined(AO_HAVE_XSIZE_or_full)
+  AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE void
   AO_XSIZE_or_full(volatile XCTYPE *addr, XCTYPE value)
-                                                AO_ATTR_NO_SANITIZE_THREAD
   {
     XCTYPE old;
 
@@ -769,9 +769,9 @@
 /* XSIZE_xor */
 #if defined(AO_HAVE_XSIZE_compare_and_swap_full) \
     && !defined(AO_HAVE_XSIZE_xor_full)
+  AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE void
   AO_XSIZE_xor_full(volatile XCTYPE *addr, XCTYPE value)
-                                                AO_ATTR_NO_SANITIZE_THREAD
   {
     XCTYPE old;
 
diff --git a/src/atomic_ops/generalize-small.h b/src/atomic_ops/generalize-small.h
index 8e26abf..d93d0e8 100644 (file)
--- a/src/atomic_ops/generalize-small.h
+++ b/src/atomic_ops/generalize-small.h
@@ -312,8 +312,9 @@
 #if defined(AO_HAVE_char_compare_and_swap_read) \
     && !defined(AO_HAVE_char_load_read)
 # define AO_char_CAS_BASED_LOAD_READ
+  AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE unsigned/**/char
-  AO_char_load_read(const volatile unsigned/**/char *addr) AO_ATTR_NO_SANITIZE_THREAD
+  AO_char_load_read(const volatile unsigned/**/char *addr)
   {
     unsigned/**/char result;
 
@@ -342,8 +343,9 @@
 
 #if defined(AO_HAVE_char_compare_and_swap_full) \
     && !defined(AO_HAVE_char_load_full)
+  AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE unsigned/**/char
-  AO_char_load_full(const volatile unsigned/**/char *addr) AO_ATTR_NO_SANITIZE_THREAD
+  AO_char_load_full(const volatile unsigned/**/char *addr)
   {
     unsigned/**/char result;
 
@@ -359,9 +361,9 @@
 
 #if defined(AO_HAVE_char_compare_and_swap_acquire) \
     && !defined(AO_HAVE_char_load_acquire)
+  AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE unsigned/**/char
   AO_char_load_acquire(const volatile unsigned/**/char *addr)
-                                                AO_ATTR_NO_SANITIZE_THREAD
   {
     unsigned/**/char result;
 
@@ -376,8 +378,9 @@
 #endif
 
 #if defined(AO_HAVE_char_compare_and_swap) && !defined(AO_HAVE_char_load)
+  AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE unsigned/**/char
-  AO_char_load(const volatile unsigned/**/char *addr) AO_ATTR_NO_SANITIZE_THREAD
+  AO_char_load(const volatile unsigned/**/char *addr)
   {
     unsigned/**/char result;
 
@@ -448,9 +451,9 @@
 
 #if defined(AO_HAVE_char_compare_and_swap_write) \
     && !defined(AO_HAVE_char_store_write)
+  AO_ATTR_NO_SANITIZE_MEMORY AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE void
   AO_char_store_write(volatile unsigned/**/char *addr, unsigned/**/char new_val)
-                        AO_ATTR_NO_SANITIZE_MEMORY AO_ATTR_NO_SANITIZE_THREAD
   {
     unsigned/**/char old_val;
 
@@ -478,9 +481,9 @@
 #endif
 
 #if defined(AO_HAVE_char_compare_and_swap) && !defined(AO_HAVE_char_store)
+  AO_ATTR_NO_SANITIZE_MEMORY AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE void
   AO_char_store(volatile unsigned/**/char *addr, unsigned/**/char new_val)
-                        AO_ATTR_NO_SANITIZE_MEMORY AO_ATTR_NO_SANITIZE_THREAD
   {
     unsigned/**/char old_val;
 
@@ -494,9 +497,9 @@
 
 #if defined(AO_HAVE_char_compare_and_swap_release) \
     && !defined(AO_HAVE_char_store_release)
+  AO_ATTR_NO_SANITIZE_MEMORY AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE void
   AO_char_store_release(volatile unsigned/**/char *addr, unsigned/**/char new_val)
-                        AO_ATTR_NO_SANITIZE_MEMORY AO_ATTR_NO_SANITIZE_THREAD
   {
     unsigned/**/char old_val;
 
@@ -510,9 +513,9 @@
 
 #if defined(AO_HAVE_char_compare_and_swap_full) \
     && !defined(AO_HAVE_char_store_full)
+  AO_ATTR_NO_SANITIZE_MEMORY AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE void
   AO_char_store_full(volatile unsigned/**/char *addr, unsigned/**/char new_val)
-                        AO_ATTR_NO_SANITIZE_MEMORY AO_ATTR_NO_SANITIZE_THREAD
   {
     unsigned/**/char old_val;
 
@@ -837,8 +840,9 @@
 #if defined(AO_HAVE_short_compare_and_swap_read) \
     && !defined(AO_HAVE_short_load_read)
 # define AO_short_CAS_BASED_LOAD_READ
+  AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE unsigned/**/short
-  AO_short_load_read(const volatile unsigned/**/short *addr) AO_ATTR_NO_SANITIZE_THREAD
+  AO_short_load_read(const volatile unsigned/**/short *addr)
   {
     unsigned/**/short result;
 
@@ -867,8 +871,9 @@
 
 #if defined(AO_HAVE_short_compare_and_swap_full) \
     && !defined(AO_HAVE_short_load_full)
+  AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE unsigned/**/short
-  AO_short_load_full(const volatile unsigned/**/short *addr) AO_ATTR_NO_SANITIZE_THREAD
+  AO_short_load_full(const volatile unsigned/**/short *addr)
   {
     unsigned/**/short result;
 
@@ -884,9 +889,9 @@
 
 #if defined(AO_HAVE_short_compare_and_swap_acquire) \
     && !defined(AO_HAVE_short_load_acquire)
+  AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE unsigned/**/short
   AO_short_load_acquire(const volatile unsigned/**/short *addr)
-                                                AO_ATTR_NO_SANITIZE_THREAD
   {
     unsigned/**/short result;
 
@@ -901,8 +906,9 @@
 #endif
 
 #if defined(AO_HAVE_short_compare_and_swap) && !defined(AO_HAVE_short_load)
+  AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE unsigned/**/short
-  AO_short_load(const volatile unsigned/**/short *addr) AO_ATTR_NO_SANITIZE_THREAD
+  AO_short_load(const volatile unsigned/**/short *addr)
   {
     unsigned/**/short result;
 
@@ -973,9 +979,9 @@
 
 #if defined(AO_HAVE_short_compare_and_swap_write) \
     && !defined(AO_HAVE_short_store_write)
+  AO_ATTR_NO_SANITIZE_MEMORY AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE void
   AO_short_store_write(volatile unsigned/**/short *addr, unsigned/**/short new_val)
-                        AO_ATTR_NO_SANITIZE_MEMORY AO_ATTR_NO_SANITIZE_THREAD
   {
     unsigned/**/short old_val;
 
@@ -1003,9 +1009,9 @@
 #endif
 
 #if defined(AO_HAVE_short_compare_and_swap) && !defined(AO_HAVE_short_store)
+  AO_ATTR_NO_SANITIZE_MEMORY AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE void
   AO_short_store(volatile unsigned/**/short *addr, unsigned/**/short new_val)
-                        AO_ATTR_NO_SANITIZE_MEMORY AO_ATTR_NO_SANITIZE_THREAD
   {
     unsigned/**/short old_val;
 
@@ -1019,9 +1025,9 @@
 
 #if defined(AO_HAVE_short_compare_and_swap_release) \
     && !defined(AO_HAVE_short_store_release)
+  AO_ATTR_NO_SANITIZE_MEMORY AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE void
   AO_short_store_release(volatile unsigned/**/short *addr, unsigned/**/short new_val)
-                        AO_ATTR_NO_SANITIZE_MEMORY AO_ATTR_NO_SANITIZE_THREAD
   {
     unsigned/**/short old_val;
 
@@ -1035,9 +1041,9 @@
 
 #if defined(AO_HAVE_short_compare_and_swap_full) \
     && !defined(AO_HAVE_short_store_full)
+  AO_ATTR_NO_SANITIZE_MEMORY AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE void
   AO_short_store_full(volatile unsigned/**/short *addr, unsigned/**/short new_val)
-                        AO_ATTR_NO_SANITIZE_MEMORY AO_ATTR_NO_SANITIZE_THREAD
   {
     unsigned/**/short old_val;
 
@@ -1362,8 +1368,9 @@
 #if defined(AO_HAVE_int_compare_and_swap_read) \
     && !defined(AO_HAVE_int_load_read)
 # define AO_int_CAS_BASED_LOAD_READ
+  AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE unsigned
-  AO_int_load_read(const volatile unsigned *addr) AO_ATTR_NO_SANITIZE_THREAD
+  AO_int_load_read(const volatile unsigned *addr)
   {
     unsigned result;
 
@@ -1392,8 +1399,9 @@
 
 #if defined(AO_HAVE_int_compare_and_swap_full) \
     && !defined(AO_HAVE_int_load_full)
+  AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE unsigned
-  AO_int_load_full(const volatile unsigned *addr) AO_ATTR_NO_SANITIZE_THREAD
+  AO_int_load_full(const volatile unsigned *addr)
   {
     unsigned result;
 
@@ -1409,9 +1417,9 @@
 
 #if defined(AO_HAVE_int_compare_and_swap_acquire) \
     && !defined(AO_HAVE_int_load_acquire)
+  AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE unsigned
   AO_int_load_acquire(const volatile unsigned *addr)
-                                                AO_ATTR_NO_SANITIZE_THREAD
   {
     unsigned result;
 
@@ -1426,8 +1434,9 @@
 #endif
 
 #if defined(AO_HAVE_int_compare_and_swap) && !defined(AO_HAVE_int_load)
+  AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE unsigned
-  AO_int_load(const volatile unsigned *addr) AO_ATTR_NO_SANITIZE_THREAD
+  AO_int_load(const volatile unsigned *addr)
   {
     unsigned result;
 
@@ -1498,9 +1507,9 @@
 
 #if defined(AO_HAVE_int_compare_and_swap_write) \
     && !defined(AO_HAVE_int_store_write)
+  AO_ATTR_NO_SANITIZE_MEMORY AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE void
   AO_int_store_write(volatile unsigned *addr, unsigned new_val)
-                        AO_ATTR_NO_SANITIZE_MEMORY AO_ATTR_NO_SANITIZE_THREAD
   {
     unsigned old_val;
 
@@ -1528,9 +1537,9 @@
 #endif
 
 #if defined(AO_HAVE_int_compare_and_swap) && !defined(AO_HAVE_int_store)
+  AO_ATTR_NO_SANITIZE_MEMORY AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE void
   AO_int_store(volatile unsigned *addr, unsigned new_val)
-                        AO_ATTR_NO_SANITIZE_MEMORY AO_ATTR_NO_SANITIZE_THREAD
   {
     unsigned old_val;
 
@@ -1544,9 +1553,9 @@
 
 #if defined(AO_HAVE_int_compare_and_swap_release) \
     && !defined(AO_HAVE_int_store_release)
+  AO_ATTR_NO_SANITIZE_MEMORY AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE void
   AO_int_store_release(volatile unsigned *addr, unsigned new_val)
-                        AO_ATTR_NO_SANITIZE_MEMORY AO_ATTR_NO_SANITIZE_THREAD
   {
     unsigned old_val;
 
@@ -1560,9 +1569,9 @@
 
 #if defined(AO_HAVE_int_compare_and_swap_full) \
     && !defined(AO_HAVE_int_store_full)
+  AO_ATTR_NO_SANITIZE_MEMORY AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE void
   AO_int_store_full(volatile unsigned *addr, unsigned new_val)
-                        AO_ATTR_NO_SANITIZE_MEMORY AO_ATTR_NO_SANITIZE_THREAD
   {
     unsigned old_val;
 
@@ -1887,8 +1896,9 @@
 #if defined(AO_HAVE_compare_and_swap_read) \
     && !defined(AO_HAVE_load_read)
 # define AO_CAS_BASED_LOAD_READ
+  AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE AO_t
-  AO_load_read(const volatile AO_t *addr) AO_ATTR_NO_SANITIZE_THREAD
+  AO_load_read(const volatile AO_t *addr)
   {
     AO_t result;
 
@@ -1917,8 +1927,9 @@
 
 #if defined(AO_HAVE_compare_and_swap_full) \
     && !defined(AO_HAVE_load_full)
+  AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE AO_t
-  AO_load_full(const volatile AO_t *addr) AO_ATTR_NO_SANITIZE_THREAD
+  AO_load_full(const volatile AO_t *addr)
   {
     AO_t result;
 
@@ -1934,9 +1945,9 @@
 
 #if defined(AO_HAVE_compare_and_swap_acquire) \
     && !defined(AO_HAVE_load_acquire)
+  AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE AO_t
   AO_load_acquire(const volatile AO_t *addr)
-                                                AO_ATTR_NO_SANITIZE_THREAD
   {
     AO_t result;
 
@@ -1951,8 +1962,9 @@
 #endif
 
 #if defined(AO_HAVE_compare_and_swap) && !defined(AO_HAVE_load)
+  AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE AO_t
-  AO_load(const volatile AO_t *addr) AO_ATTR_NO_SANITIZE_THREAD
+  AO_load(const volatile AO_t *addr)
   {
     AO_t result;
 
@@ -2023,9 +2035,9 @@
 
 #if defined(AO_HAVE_compare_and_swap_write) \
     && !defined(AO_HAVE_store_write)
+  AO_ATTR_NO_SANITIZE_MEMORY AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE void
   AO_store_write(volatile AO_t *addr, AO_t new_val)
-                        AO_ATTR_NO_SANITIZE_MEMORY AO_ATTR_NO_SANITIZE_THREAD
   {
     AO_t old_val;
 
@@ -2053,9 +2065,9 @@
 #endif
 
 #if defined(AO_HAVE_compare_and_swap) && !defined(AO_HAVE_store)
+  AO_ATTR_NO_SANITIZE_MEMORY AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE void
   AO_store(volatile AO_t *addr, AO_t new_val)
-                        AO_ATTR_NO_SANITIZE_MEMORY AO_ATTR_NO_SANITIZE_THREAD
   {
     AO_t old_val;
 
@@ -2069,9 +2081,9 @@
 
 #if defined(AO_HAVE_compare_and_swap_release) \
     && !defined(AO_HAVE_store_release)
+  AO_ATTR_NO_SANITIZE_MEMORY AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE void
   AO_store_release(volatile AO_t *addr, AO_t new_val)
-                        AO_ATTR_NO_SANITIZE_MEMORY AO_ATTR_NO_SANITIZE_THREAD
   {
     AO_t old_val;
 
@@ -2085,9 +2097,9 @@
 
 #if defined(AO_HAVE_compare_and_swap_full) \
     && !defined(AO_HAVE_store_full)
+  AO_ATTR_NO_SANITIZE_MEMORY AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE void
   AO_store_full(volatile AO_t *addr, AO_t new_val)
-                        AO_ATTR_NO_SANITIZE_MEMORY AO_ATTR_NO_SANITIZE_THREAD
   {
     AO_t old_val;
 
@@ -2412,8 +2424,9 @@
 #if defined(AO_HAVE_double_compare_and_swap_read) \
     && !defined(AO_HAVE_double_load_read)
 # define AO_double_CAS_BASED_LOAD_READ
+  AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE AO_double_t
-  AO_double_load_read(const volatile AO_double_t *addr) AO_ATTR_NO_SANITIZE_THREAD
+  AO_double_load_read(const volatile AO_double_t *addr)
   {
     AO_double_t result;
 
@@ -2442,8 +2455,9 @@
 
 #if defined(AO_HAVE_double_compare_and_swap_full) \
     && !defined(AO_HAVE_double_load_full)
+  AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE AO_double_t
-  AO_double_load_full(const volatile AO_double_t *addr) AO_ATTR_NO_SANITIZE_THREAD
+  AO_double_load_full(const volatile AO_double_t *addr)
   {
     AO_double_t result;
 
@@ -2459,9 +2473,9 @@
 
 #if defined(AO_HAVE_double_compare_and_swap_acquire) \
     && !defined(AO_HAVE_double_load_acquire)
+  AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE AO_double_t
   AO_double_load_acquire(const volatile AO_double_t *addr)
-                                                AO_ATTR_NO_SANITIZE_THREAD
   {
     AO_double_t result;
 
@@ -2476,8 +2490,9 @@
 #endif
 
 #if defined(AO_HAVE_double_compare_and_swap) && !defined(AO_HAVE_double_load)
+  AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE AO_double_t
-  AO_double_load(const volatile AO_double_t *addr) AO_ATTR_NO_SANITIZE_THREAD
+  AO_double_load(const volatile AO_double_t *addr)
   {
     AO_double_t result;
 
@@ -2548,9 +2563,9 @@
 
 #if defined(AO_HAVE_double_compare_and_swap_write) \
     && !defined(AO_HAVE_double_store_write)
+  AO_ATTR_NO_SANITIZE_MEMORY AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE void
   AO_double_store_write(volatile AO_double_t *addr, AO_double_t new_val)
-                        AO_ATTR_NO_SANITIZE_MEMORY AO_ATTR_NO_SANITIZE_THREAD
   {
     AO_double_t old_val;
 
@@ -2578,9 +2593,9 @@
 #endif
 
 #if defined(AO_HAVE_double_compare_and_swap) && !defined(AO_HAVE_double_store)
+  AO_ATTR_NO_SANITIZE_MEMORY AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE void
   AO_double_store(volatile AO_double_t *addr, AO_double_t new_val)
-                        AO_ATTR_NO_SANITIZE_MEMORY AO_ATTR_NO_SANITIZE_THREAD
   {
     AO_double_t old_val;
 
@@ -2594,9 +2609,9 @@
 
 #if defined(AO_HAVE_double_compare_and_swap_release) \
     && !defined(AO_HAVE_double_store_release)
+  AO_ATTR_NO_SANITIZE_MEMORY AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE void
   AO_double_store_release(volatile AO_double_t *addr, AO_double_t new_val)
-                        AO_ATTR_NO_SANITIZE_MEMORY AO_ATTR_NO_SANITIZE_THREAD
   {
     AO_double_t old_val;
 
@@ -2610,9 +2625,9 @@
 
 #if defined(AO_HAVE_double_compare_and_swap_full) \
     && !defined(AO_HAVE_double_store_full)
+  AO_ATTR_NO_SANITIZE_MEMORY AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE void
   AO_double_store_full(volatile AO_double_t *addr, AO_double_t new_val)
-                        AO_ATTR_NO_SANITIZE_MEMORY AO_ATTR_NO_SANITIZE_THREAD
   {
     AO_double_t old_val;
 
diff --git a/src/atomic_ops/generalize-small.template b/src/atomic_ops/generalize-small.template
index 99e96a1..d3490f8 100644 (file)
--- a/src/atomic_ops/generalize-small.template
+++ b/src/atomic_ops/generalize-small.template
@@ -312,8 +312,9 @@
 #if defined(AO_HAVE_XSIZE_compare_and_swap_read) \
     && !defined(AO_HAVE_XSIZE_load_read)
 # define AO_XSIZE_CAS_BASED_LOAD_READ
+  AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE XCTYPE
-  AO_XSIZE_load_read(const volatile XCTYPE *addr) AO_ATTR_NO_SANITIZE_THREAD
+  AO_XSIZE_load_read(const volatile XCTYPE *addr)
   {
     XCTYPE result;
 
@@ -342,8 +343,9 @@
 
 #if defined(AO_HAVE_XSIZE_compare_and_swap_full) \
     && !defined(AO_HAVE_XSIZE_load_full)
+  AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE XCTYPE
-  AO_XSIZE_load_full(const volatile XCTYPE *addr) AO_ATTR_NO_SANITIZE_THREAD
+  AO_XSIZE_load_full(const volatile XCTYPE *addr)
   {
     XCTYPE result;
 
@@ -359,9 +361,9 @@
 
 #if defined(AO_HAVE_XSIZE_compare_and_swap_acquire) \
     && !defined(AO_HAVE_XSIZE_load_acquire)
+  AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE XCTYPE
   AO_XSIZE_load_acquire(const volatile XCTYPE *addr)
-                                                AO_ATTR_NO_SANITIZE_THREAD
   {
     XCTYPE result;
 
@@ -376,8 +378,9 @@
 #endif
 
 #if defined(AO_HAVE_XSIZE_compare_and_swap) && !defined(AO_HAVE_XSIZE_load)
+  AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE XCTYPE
-  AO_XSIZE_load(const volatile XCTYPE *addr) AO_ATTR_NO_SANITIZE_THREAD
+  AO_XSIZE_load(const volatile XCTYPE *addr)
   {
     XCTYPE result;
 
@@ -448,9 +451,9 @@
 
 #if defined(AO_HAVE_XSIZE_compare_and_swap_write) \
     && !defined(AO_HAVE_XSIZE_store_write)
+  AO_ATTR_NO_SANITIZE_MEMORY AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE void
   AO_XSIZE_store_write(volatile XCTYPE *addr, XCTYPE new_val)
-                        AO_ATTR_NO_SANITIZE_MEMORY AO_ATTR_NO_SANITIZE_THREAD
   {
     XCTYPE old_val;
 
@@ -478,9 +481,9 @@
 #endif
 
 #if defined(AO_HAVE_XSIZE_compare_and_swap) && !defined(AO_HAVE_XSIZE_store)
+  AO_ATTR_NO_SANITIZE_MEMORY AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE void
   AO_XSIZE_store(volatile XCTYPE *addr, XCTYPE new_val)
-                        AO_ATTR_NO_SANITIZE_MEMORY AO_ATTR_NO_SANITIZE_THREAD
   {
     XCTYPE old_val;
 
@@ -494,9 +497,9 @@
 
 #if defined(AO_HAVE_XSIZE_compare_and_swap_release) \
     && !defined(AO_HAVE_XSIZE_store_release)
+  AO_ATTR_NO_SANITIZE_MEMORY AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE void
   AO_XSIZE_store_release(volatile XCTYPE *addr, XCTYPE new_val)
-                        AO_ATTR_NO_SANITIZE_MEMORY AO_ATTR_NO_SANITIZE_THREAD
   {
     XCTYPE old_val;
 
@@ -510,9 +513,9 @@
 
 #if defined(AO_HAVE_XSIZE_compare_and_swap_full) \
     && !defined(AO_HAVE_XSIZE_store_full)
+  AO_ATTR_NO_SANITIZE_MEMORY AO_ATTR_NO_SANITIZE_THREAD
   AO_INLINE void
   AO_XSIZE_store_full(volatile XCTYPE *addr, XCTYPE new_val)
-                        AO_ATTR_NO_SANITIZE_MEMORY AO_ATTR_NO_SANITIZE_THREAD
   {
     XCTYPE old_val;
 
diff --git a/src/atomic_ops_stack.c b/src/atomic_ops_stack.c
index c66533d..b57ed85 100644 (file)
--- a/src/atomic_ops_stack.c
+++ b/src/atomic_ops_stack.c
@@ -46,9 +46,9 @@
 /* to be inserted.                                                      */
 /* Both list headers and link fields contain "perturbed" pointers, i.e. */
 /* pointers with extra bits "or"ed into the low order bits.             */
-void
-AO_stack_push_explicit_aux_release(volatile AO_t *list, AO_t *x,
-                                   AO_stack_aux *a) AO_ATTR_NO_SANITIZE_THREAD
+AO_ATTR_NO_SANITIZE_THREAD
+void AO_stack_push_explicit_aux_release(volatile AO_t *list, AO_t *x,
+                                        AO_stack_aux *a)
 {
   AO_t x_bits = (AO_t)x;
   AO_t next;
@@ -207,8 +207,8 @@ AO_stack_pop_explicit_aux_acquire(volatile AO_t *list, AO_stack_aux * a)
   volatile /* non-static */ AO_t AO_noop_sink;
 #endif
 
+AO_ATTR_NO_SANITIZE_THREAD
 void AO_stack_push_release(AO_stack_t *list, AO_t *element)
-                                                AO_ATTR_NO_SANITIZE_THREAD
 {
     AO_t next;
 
@@ -227,7 +227,8 @@ void AO_stack_push_release(AO_stack_t *list, AO_t *element)
 #   endif
 }
 
-AO_t *AO_stack_pop_acquire(AO_stack_t *list) AO_ATTR_NO_SANITIZE_THREAD
+AO_ATTR_NO_SANITIZE_THREAD
+AO_t *AO_stack_pop_acquire(AO_stack_t *list)
 {
 #   ifdef __clang__
       AO_t *volatile cptr;
diff --git a/tests/test_atomic.c b/tests/test_atomic.c
index 8b57bd6..e4a19a5 100644 (file)
--- a/tests/test_atomic.c
+++ b/tests/test_atomic.c
@@ -137,7 +137,8 @@ AO_TS_t lock = AO_TS_INITIALIZER;
 unsigned long locked_counter;
 volatile unsigned long junk = 13;
 
-void do_junk(void) AO_ATTR_NO_SANITIZE_THREAD
+AO_ATTR_NO_SANITIZE_THREAD
+void do_junk(void)
 {
   junk *= 17;
   junk *= 19;
diff --git a/tests/test_malloc.c b/tests/test_malloc.c
index b51d4fb..a322099 100644 (file)
--- a/tests/test_malloc.c
+++ b/tests/test_malloc.c
@@ -68,7 +68,8 @@ typedef struct list_node {
         int data;
 } ln;
 
-ln *cons(int d, ln *tail) AO_ATTR_NO_SANITIZE_THREAD
+AO_ATTR_NO_SANITIZE_THREAD
+ln *cons(int d, ln *tail)
 {
   static size_t extra = 0; /* data race in extra is OK */
   size_t my_extra = extra;
Domain: System / Toolchain;