* [cxx-mem-model] __sync_mem builtin support patch 3/3 - testcases
@ 2011-07-27 6:33 Andrew MacLeod
2011-07-27 16:18 ` Richard Henderson
0 siblings, 1 reply; 2+ messages in thread
From: Andrew MacLeod @ 2011-07-27 6:33 UTC (permalink / raw)
To: gcc-patches; +Cc: Richard Henderson, Aldy Hernandez
[-- Attachment #1: Type: text/plain, Size: 1582 bytes --]
This is a set of tests to verify the basic functionality of the new
__sync_mem builtin functions.
I've removed the older tests I created for __sync_mem_exchange and
replaced them with tests following a different format.
sync-mem-invalid.c tests for an error for each invalid memory model
combination.
There is a different test file for each __sync_mem builtin function.
They each test the basic functionality with each valid memory model.
Note they don't test the effeciveness any fences required by the memory
model, that is beyond the scope of these tests. It does test that
expected results are returned.
Any of the builtins which work on more than one size have test names
ending in -{1-5}, representing a different size object it can represent:
1, 2, 4, 8, or 16 byte values. Each of these are identical except for
the data size. I elected to have these all separate since different
architectures have different levels of support for each these sizes, and
this will make it easier to either XFAIL a size that is known not to
work, or detect one which is not working but should be...
sync-mem-compare-exchange-[1-5].c all fail currently, which is expected
since compare_exchange is going to finshed later as noted in the patch
with the code. The tests will likely change a bit as well to take into
account the weak/strong variations that have not been added yet either.
Probalby just one or two of them will be converted to the weak version.
The rest of these tests all pass with the code patch on
x86_64-unknown-linux-gnu. OK for the branch?
Andrew
[-- Attachment #2: test.patch --]
[-- Type: text/plain, Size: 61931 bytes --]
* gcc.dg/sync-mem-{1-5}.c: Remove.
* gcc.dg/sync-mem.h: Remove.
* gcc.dg/sync-mem-compare-exchange-{1-5}.c: New functional tests.
* gcc.dg/sync-mem-exchange-{1-5}.c: New functional tests.
* gcc.dg/sync-mem-fence.c: New functional tests.
* gcc.dg/sync-mem-fetch-*-{1-5}.c: New functional tests.
* gcc.dg/sync-mem-flag.c: New functional tests.
* gcc.dg/sync-mem-invalid.c: Add new invalid combinations.
* gcc.dg/sync-mem-load-{1-5}.c: New functional tests.
* gcc.dg/sync-mem-store-{1-5}.c: New functional tests.
Index: sync-mem-1.c
===================================================================
*** sync-mem-1.c (revision 175331)
--- sync-mem-1.c (working copy)
***************
*** 1,8 ****
- /* Test __sync_mem routines for existence and proper execution on 1 byte
- values with each valid memory model. */
- /* { dg-do run } */
- /* { dg-require-effective-target sync_char_short } */
-
- #define TYPE char
-
- #include "sync-mem.h"
--- 0 ----
Index: sync-mem-5.c
===================================================================
*** sync-mem-5.c (revision 175331)
--- sync-mem-5.c (working copy)
***************
*** 1,9 ****
- /* Test __sync_mem routines for existence and proper execution on 16 byte
- values with each valid memory model. */
- /* { dg-do run } */
- /* { dg-require-effective-target sync_int_128 } */
- /* { dg-options "-mcx16" { target { x86_64-*-* } } } */
-
- #define TYPE __int128_t
-
- #include "sync-mem.h"
--- 0 ----
Index: sync-mem-2.c
===================================================================
*** sync-mem-2.c (revision 175331)
--- sync-mem-2.c (working copy)
***************
*** 1,9 ****
- /* Test __sync_mem routines for existence and proper execution on 2 byte
- values with each valid memory model. */
- /* { dg-do run } */
- /* { dg-require-effective-target sync_char_short } */
-
- #define TYPE short
-
- #include "sync-mem.h"
-
--- 0 ----
Index: sync-mem-3.c
===================================================================
*** sync-mem-3.c (revision 175331)
--- sync-mem-3.c (working copy)
***************
*** 1,8 ****
- /* Test __sync_mem routines for existence and proper execution on 4 byte
- values with each valid memory model. */
- /* { dg-do run } */
- /* { dg-require-effective-target sync_int_long } */
-
- #define TYPE long
-
- #include "sync-mem.h"
--- 0 ----
Index: sync-mem.h
===================================================================
*** sync-mem.h (revision 175331)
--- sync-mem.h (working copy)
***************
*** 1,27 ****
- /* Define all the __sync verifications here. Each size variation to be tested
- will define 'TYPE' and then include this file. */
-
- extern void abort(void);
-
- TYPE v, count;
-
- #define EXCHANGE(VAR, MODE) if (__sync_mem_exchange (&VAR, count + 1, MODE) \
- != count++) abort()
- void test_exchange()
- {
- v = 0;
- count = 0;
- EXCHANGE (v, __SYNC_MEM_RELAXED);
- EXCHANGE (v, __SYNC_MEM_ACQUIRE);
- EXCHANGE (v, __SYNC_MEM_RELEASE);
- EXCHANGE (v, __SYNC_MEM_ACQ_REL);
- EXCHANGE (v, __SYNC_MEM_SEQ_CST);
- }
-
-
-
- main ()
- {
- test_exchange();
- return 0;
- }
--- 0 ----
Index: sync-mem-4.c
===================================================================
*** sync-mem-4.c (revision 175331)
--- sync-mem-4.c (working copy)
***************
*** 1,9 ****
- /* Test __sync_mem routines for existence and proper execution on 8 byte
- values with each valid memory model. */
- /* { dg-do run } */
- /* { dg-require-effective-target sync_long_long } */
- /* { dg-options "" } */
-
- #define TYPE long long
-
- #include "sync-mem.h"
--- 0 ----
Index: sync-mem-compare-exchange-1.c
===================================================================
*** sync-mem-compare-exchange-1.c (revision 0)
--- sync-mem-compare-exchange-1.c (revision 0)
***************
*** 0 ****
--- 1,77 ----
+ /* Test __sync_mem routines for existence and proper execution on 1 byte
+ values with each valid memory model. */
+ /* { dg-do run } */
+ /* { dg-require-effective-target sync_char_short } */
+
+ /* Test the execution of the __sync_mem_compare_exchange builtin for char. */
+
+ extern void abort(void);
+
+ char v, count, value;
+
+ main ()
+ {
+ v = 0;
+ count = 0;
+
+ if (__sync_mem_compare_exchange (&v, &value, count + 1, __SYNC_MEM_RELAXED,
+ __SYNC_MEM_RELAXED))
+ {
+ if (value != count)
+ abort();
+ count++;
+ }
+ else
+ abort();
+
+ if (__sync_mem_compare_exchange (&v, &value, count + 1, __SYNC_MEM_ACQUIRE,
+ __SYNC_MEM_ACQUIRE))
+ {
+ if (value != count)
+ abort();
+ count++;
+ }
+ else
+ abort();
+
+ if (__sync_mem_compare_exchange (&v, &value, count + 1, __SYNC_MEM_CONSUME,
+ __SYNC_MEM_CONSUME))
+ {
+ if (value != count)
+ abort();
+ count++;
+ }
+ else
+ abort();
+
+ if (__sync_mem_compare_exchange (&v, &value, count + 1, __SYNC_MEM_RELEASE,
+ __SYNC_MEM_RELAXED))
+ {
+ if (value != count)
+ abort();
+ count++;
+ }
+ else
+ abort();
+
+ if (__sync_mem_compare_exchange (&v, &value, count + 1, __SYNC_MEM_ACQ_REL,
+ __SYNC_MEM_ACQUIRE))
+ {
+ if (value != count)
+ abort();
+ count++;
+ }
+ else
+ abort();
+
+ /* test for failure. */
+ value = 100;
+ if (__sync_mem_compare_exchange (&v, &value, count + 1, __SYNC_MEM_SEQ_CST,
+ __SYNC_MEM_SEQ_CST))
+ abort();
+ else
+ if (value != v)
+ abort();
+
+ return 0;
+ }
Index: sync-mem-compare-exchange-2.c
===================================================================
*** sync-mem-compare-exchange-2.c (revision 0)
--- sync-mem-compare-exchange-2.c (revision 0)
***************
*** 0 ****
--- 1,77 ----
+ /* Test __sync_mem routines for existence and proper execution on 2 byte
+ values with each valid memory model. */
+ /* { dg-do run } */
+ /* { dg-require-effective-target sync_char_short } */
+
+ /* Test the execution of the __sync_mem_compare_exchange builtin for short. */
+
+ extern void abort(void);
+
+ short v, value, count;
+
+ main ()
+ {
+ v = 0;
+ count = 0;
+
+ if (__sync_mem_compare_exchange (&v, &value, count + 1, __SYNC_MEM_RELAXED,
+ __SYNC_MEM_RELAXED))
+ {
+ if (value != count)
+ abort();
+ count++;
+ }
+ else
+ abort();
+
+ if (__sync_mem_compare_exchange (&v, &value, count + 1, __SYNC_MEM_ACQUIRE,
+ __SYNC_MEM_ACQUIRE))
+ {
+ if (value != count)
+ abort();
+ count++;
+ }
+ else
+ abort();
+
+ if (__sync_mem_compare_exchange (&v, &value, count + 1, __SYNC_MEM_CONSUME,
+ __SYNC_MEM_CONSUME))
+ {
+ if (value != count)
+ abort();
+ count++;
+ }
+ else
+ abort();
+
+ if (__sync_mem_compare_exchange (&v, &value, count + 1, __SYNC_MEM_RELEASE,
+ __SYNC_MEM_RELAXED))
+ {
+ if (value != count)
+ abort();
+ count++;
+ }
+ else
+ abort();
+
+ if (__sync_mem_compare_exchange (&v, &value, count + 1, __SYNC_MEM_ACQ_REL,
+ __SYNC_MEM_ACQUIRE))
+ {
+ if (value != count)
+ abort();
+ count++;
+ }
+ else
+ abort();
+
+ /* test for failure. */
+ value = 100;
+ if (__sync_mem_compare_exchange (&v, &value, count + 1, __SYNC_MEM_SEQ_CST,
+ __SYNC_MEM_SEQ_CST))
+ abort();
+ else
+ if (value != v)
+ abort();
+
+ return 0;
+ }
Index: sync-mem-compare-exchange-3.c
===================================================================
*** sync-mem-compare-exchange-3.c (revision 0)
--- sync-mem-compare-exchange-3.c (revision 0)
***************
*** 0 ****
--- 1,77 ----
+ /* Test __sync_mem routines for existence and proper execution on 4 byte
+ values with each valid memory model. */
+ /* { dg-do run } */
+ /* { dg-require-effective-target sync_int_long } */
+
+ /* Test the execution of the __sync_mem_compare_exchange builtin for int. */
+
+ extern void abort(void);
+
+ int v, value, count;
+
+ main ()
+ {
+ v = 0;
+ count = 0;
+
+ if (__sync_mem_compare_exchange (&v, &value, count + 1, __SYNC_MEM_RELAXED,
+ __SYNC_MEM_RELAXED))
+ {
+ if (value != count)
+ abort();
+ count++;
+ }
+ else
+ abort();
+
+ if (__sync_mem_compare_exchange (&v, &value, count + 1, __SYNC_MEM_ACQUIRE,
+ __SYNC_MEM_ACQUIRE))
+ {
+ if (value != count)
+ abort();
+ count++;
+ }
+ else
+ abort();
+
+ if (__sync_mem_compare_exchange (&v, &value, count + 1, __SYNC_MEM_CONSUME,
+ __SYNC_MEM_CONSUME))
+ {
+ if (value != count)
+ abort();
+ count++;
+ }
+ else
+ abort();
+
+ if (__sync_mem_compare_exchange (&v, &value, count + 1, __SYNC_MEM_RELEASE,
+ __SYNC_MEM_RELAXED))
+ {
+ if (value != count)
+ abort();
+ count++;
+ }
+ else
+ abort();
+
+ if (__sync_mem_compare_exchange (&v, &value, count + 1, __SYNC_MEM_ACQ_REL,
+ __SYNC_MEM_ACQUIRE))
+ {
+ if (value != count)
+ abort();
+ count++;
+ }
+ else
+ abort();
+
+ /* test for failure. */
+ value = 100;
+ if (__sync_mem_compare_exchange (&v, &value, count + 1, __SYNC_MEM_SEQ_CST,
+ __SYNC_MEM_SEQ_CST))
+ abort();
+ else
+ if (value != v)
+ abort();
+
+ return 0;
+ }
Index: sync-mem-compare-exchange-4.c
===================================================================
*** sync-mem-compare-exchange-4.c (revision 0)
--- sync-mem-compare-exchange-4.c (revision 0)
***************
*** 0 ****
--- 1,78 ----
+ /* Test __sync_mem routines for existence and proper execution on 8 byte
+ values with each valid memory model. */
+ /* { dg-do run } */
+ /* { dg-require-effective-target sync_long_long } */
+ /* { dg-options "" } */
+
+ /* Test the execution of __sync_mem_compare_exchange builtin for long_long. */
+
+ extern void abort(void);
+
+ long long v, value, count;
+
+ main ()
+ {
+ v = 0;
+ count = 0;
+
+ if (__sync_mem_compare_exchange (&v, &value, count + 1, __SYNC_MEM_RELAXED,
+ __SYNC_MEM_RELAXED))
+ {
+ if (value != count)
+ abort();
+ count++;
+ }
+ else
+ abort();
+
+ if (__sync_mem_compare_exchange (&v, &value, count + 1, __SYNC_MEM_ACQUIRE,
+ __SYNC_MEM_ACQUIRE))
+ {
+ if (value != count)
+ abort();
+ count++;
+ }
+ else
+ abort();
+
+ if (__sync_mem_compare_exchange (&v, &value, count + 1, __SYNC_MEM_CONSUME,
+ __SYNC_MEM_CONSUME))
+ {
+ if (value != count)
+ abort();
+ count++;
+ }
+ else
+ abort();
+
+ if (__sync_mem_compare_exchange (&v, &value, count + 1, __SYNC_MEM_RELEASE,
+ __SYNC_MEM_RELAXED))
+ {
+ if (value != count)
+ abort();
+ count++;
+ }
+ else
+ abort();
+
+ if (__sync_mem_compare_exchange (&v, &value, count + 1, __SYNC_MEM_ACQ_REL,
+ __SYNC_MEM_ACQUIRE))
+ {
+ if (value != count)
+ abort();
+ count++;
+ }
+ else
+ abort();
+
+ /* test for failure. */
+ value = 100;
+ if (__sync_mem_compare_exchange (&v, &value, count + 1, __SYNC_MEM_SEQ_CST,
+ __SYNC_MEM_SEQ_CST))
+ abort();
+ else
+ if (value != v)
+ abort();
+
+ return 0;
+ }
Index: sync-mem-compare-exchange-5.c
===================================================================
*** sync-mem-compare-exchange-5.c (revision 0)
--- sync-mem-compare-exchange-5.c (revision 0)
***************
*** 0 ****
--- 1,78 ----
+ /* Test __sync_mem routines for existence and proper execution on 16 byte
+ values with each valid memory model. */
+ /* { dg-do run } */
+ /* { dg-require-effective-target sync_int_128 } */
+ /* { dg-options "-mcx16" { target { x86_64-*-* } } } */
+
+ /* Test execution of __sync_mem_compare_exchange builtin for 16 byte values. */
+
+ extern void abort(void);
+
+ __int128_t v, value, count;
+
+ main ()
+ {
+ v = 0;
+ count = 0;
+
+ if (__sync_mem_compare_exchange (&v, &value, count + 1, __SYNC_MEM_RELAXED,
+ __SYNC_MEM_RELAXED))
+ {
+ if (value != count)
+ abort();
+ count++;
+ }
+ else
+ abort();
+
+ if (__sync_mem_compare_exchange (&v, &value, count + 1, __SYNC_MEM_ACQUIRE,
+ __SYNC_MEM_ACQUIRE))
+ {
+ if (value != count)
+ abort();
+ count++;
+ }
+ else
+ abort();
+
+ if (__sync_mem_compare_exchange (&v, &value, count + 1, __SYNC_MEM_CONSUME,
+ __SYNC_MEM_CONSUME))
+ {
+ if (value != count)
+ abort();
+ count++;
+ }
+ else
+ abort();
+
+ if (__sync_mem_compare_exchange (&v, &value, count + 1, __SYNC_MEM_RELEASE,
+ __SYNC_MEM_RELAXED))
+ {
+ if (value != count)
+ abort();
+ count++;
+ }
+ else
+ abort();
+
+ if (__sync_mem_compare_exchange (&v, &value, count + 1, __SYNC_MEM_ACQ_REL,
+ __SYNC_MEM_ACQUIRE))
+ {
+ if (value != count)
+ abort();
+ count++;
+ }
+ else
+ abort();
+
+ /* test for failure. */
+ value = 100;
+ if (__sync_mem_compare_exchange (&v, &value, count + 1, __SYNC_MEM_SEQ_CST,
+ __SYNC_MEM_SEQ_CST))
+ abort();
+ else
+ if (value != v)
+ abort();
+
+ return 0;
+ }
Index: sync-mem-exchange-1.c
===================================================================
*** sync-mem-exchange-1.c (revision 0)
--- sync-mem-exchange-1.c (revision 0)
***************
*** 0 ****
--- 1,33 ----
+ /* Test __sync_mem routines for existence and proper execution on 1 byte
+ values with each valid memory model. */
+ /* { dg-do run } */
+ /* { dg-require-effective-target sync_char_short } */
+
+ /* Test the execution of the __sync_mem_exchange builtin for a char. */
+
+ extern void abort(void);
+
+ char v, count;
+
+ main ()
+ {
+ v = 0;
+ count = 0;
+
+ if (__sync_mem_exchange (&v, count + 1, __SYNC_MEM_RELAXED) != count++)
+ abort ();
+
+ if (__sync_mem_exchange (&v, count + 1, __SYNC_MEM_ACQUIRE) != count++)
+ abort ();
+
+ if (__sync_mem_exchange (&v, count + 1, __SYNC_MEM_RELEASE) != count++)
+ abort ();
+
+ if (__sync_mem_exchange (&v, count + 1, __SYNC_MEM_ACQ_REL) != count++)
+ abort ();
+
+ if (__sync_mem_exchange (&v, count + 1, __SYNC_MEM_SEQ_CST) != count++)
+ abort ();
+
+ return 0;
+ }
Index: sync-mem-exchange-2.c
===================================================================
*** sync-mem-exchange-2.c (revision 0)
--- sync-mem-exchange-2.c (revision 0)
***************
*** 0 ****
--- 1,33 ----
+ /* Test __sync_mem routines for existence and proper execution on 2 byte
+ values with each valid memory model. */
+ /* { dg-do run } */
+ /* { dg-require-effective-target sync_char_short } */
+
+ /* Test the execution of the __sync_mem_X builtin for a short. */
+
+ extern void abort(void);
+
+ short v, count;
+
+ main ()
+ {
+ v = 0;
+ count = 0;
+
+ if (__sync_mem_exchange (&v, count + 1, __SYNC_MEM_RELAXED) != count++)
+ abort ();
+
+ if (__sync_mem_exchange (&v, count + 1, __SYNC_MEM_ACQUIRE) != count++)
+ abort ();
+
+ if (__sync_mem_exchange (&v, count + 1, __SYNC_MEM_RELEASE) != count++)
+ abort ();
+
+ if (__sync_mem_exchange (&v, count + 1, __SYNC_MEM_ACQ_REL) != count++)
+ abort ();
+
+ if (__sync_mem_exchange (&v, count + 1, __SYNC_MEM_SEQ_CST) != count++)
+ abort ();
+
+ return 0;
+ }
Index: sync-mem-exchange-3.c
===================================================================
*** sync-mem-exchange-3.c (revision 0)
--- sync-mem-exchange-3.c (revision 0)
***************
*** 0 ****
--- 1,33 ----
+ /* Test __sync_mem routines for existence and proper execution on 4 byte
+ values with each valid memory model. */
+ /* { dg-do run } */
+ /* { dg-require-effective-target sync_int_long } */
+
+ /* Test the execution of the __sync_mem_X builtin for an int. */
+
+ extern void abort(void);
+
+ int v, count;
+
+ main ()
+ {
+ v = 0;
+ count = 0;
+
+ if (__sync_mem_exchange (&v, count + 1, __SYNC_MEM_RELAXED) != count++)
+ abort ();
+
+ if (__sync_mem_exchange (&v, count + 1, __SYNC_MEM_ACQUIRE) != count++)
+ abort ();
+
+ if (__sync_mem_exchange (&v, count + 1, __SYNC_MEM_RELEASE) != count++)
+ abort ();
+
+ if (__sync_mem_exchange (&v, count + 1, __SYNC_MEM_ACQ_REL) != count++)
+ abort ();
+
+ if (__sync_mem_exchange (&v, count + 1, __SYNC_MEM_SEQ_CST) != count++)
+ abort ();
+
+ return 0;
+ }
Index: sync-mem-exchange-4.c
===================================================================
*** sync-mem-exchange-4.c (revision 0)
--- sync-mem-exchange-4.c (revision 0)
***************
*** 0 ****
--- 1,34 ----
+ /* Test __sync_mem routines for existence and proper execution on 8 byte
+ values with each valid memory model. */
+ /* { dg-do run } */
+ /* { dg-require-effective-target sync_long_long } */
+ /* { dg-options "" } */
+
+ /* Test the execution of the __sync_mem_X builtin for a long_long. */
+
+ extern void abort(void);
+
+ long long v, count;
+
+ main ()
+ {
+ v = 0;
+ count = 0;
+
+ if (__sync_mem_exchange (&v, count + 1, __SYNC_MEM_RELAXED) != count++)
+ abort ();
+
+ if (__sync_mem_exchange (&v, count + 1, __SYNC_MEM_ACQUIRE) != count++)
+ abort ();
+
+ if (__sync_mem_exchange (&v, count + 1, __SYNC_MEM_RELEASE) != count++)
+ abort ();
+
+ if (__sync_mem_exchange (&v, count + 1, __SYNC_MEM_ACQ_REL) != count++)
+ abort ();
+
+ if (__sync_mem_exchange (&v, count + 1, __SYNC_MEM_SEQ_CST) != count++)
+ abort ();
+
+ return 0;
+ }
Index: sync-mem-exchange-5.c
===================================================================
*** sync-mem-exchange-5.c (revision 0)
--- sync-mem-exchange-5.c (revision 0)
***************
*** 0 ****
--- 1,34 ----
+ /* Test __sync_mem routines for existence and proper execution on 16 byte
+ values with each valid memory model. */
+ /* { dg-do run } */
+ /* { dg-require-effective-target sync_int_128 } */
+ /* { dg-options "-mcx16" { target { x86_64-*-* } } } */
+
+ /* Test the execution of the __sync_mem_X builtin for a 16 byte value. */
+
+ extern void abort(void);
+
+ __int128_t v, count;
+
+ main ()
+ {
+ v = 0;
+ count = 0;
+
+ if (__sync_mem_exchange (&v, count + 1, __SYNC_MEM_RELAXED) != count++)
+ abort ();
+
+ if (__sync_mem_exchange (&v, count + 1, __SYNC_MEM_ACQUIRE) != count++)
+ abort ();
+
+ if (__sync_mem_exchange (&v, count + 1, __SYNC_MEM_RELEASE) != count++)
+ abort ();
+
+ if (__sync_mem_exchange (&v, count + 1, __SYNC_MEM_ACQ_REL) != count++)
+ abort ();
+
+ if (__sync_mem_exchange (&v, count + 1, __SYNC_MEM_SEQ_CST) != count++)
+ abort ();
+
+ return 0;
+ }
Index: sync-mem-fence.c
===================================================================
*** sync-mem-fence.c (revision 0)
--- sync-mem-fence.c (revision 0)
***************
*** 0 ****
--- 1,27 ----
+ /* Test __sync_mem routines for existence and execution with each valid
+ memory model. */
+ /* { dg-do run } */
+ /* { dg-require-effective-target sync_char_short } */
+
+
+ /* Test that __sync_mem_{thread,signal}_fence builtins execute. */
+
+ main ()
+ {
+ __sync_mem_thread_fence (__SYNC_MEM_RELAXED);
+ __sync_mem_thread_fence (__SYNC_MEM_CONSUME);
+ __sync_mem_thread_fence (__SYNC_MEM_ACQUIRE);
+ __sync_mem_thread_fence (__SYNC_MEM_RELEASE);
+ __sync_mem_thread_fence (__SYNC_MEM_ACQ_REL);
+ __sync_mem_thread_fence (__SYNC_MEM_SEQ_CST);
+
+ __sync_mem_signal_fence (__SYNC_MEM_RELAXED);
+ __sync_mem_signal_fence (__SYNC_MEM_CONSUME);
+ __sync_mem_signal_fence (__SYNC_MEM_ACQUIRE);
+ __sync_mem_signal_fence (__SYNC_MEM_RELEASE);
+ __sync_mem_signal_fence (__SYNC_MEM_ACQ_REL);
+ __sync_mem_signal_fence (__SYNC_MEM_SEQ_CST);
+
+ return 0;
+ }
+
Index: sync-mem-fetch-add-1.c
===================================================================
*** sync-mem-fetch-add-1.c (revision 0)
--- sync-mem-fetch-add-1.c (revision 0)
***************
*** 0 ****
--- 1,36 ----
+ /* Test __sync_mem routines for existence and proper execution on 1 byte
+ values with each valid memory model. */
+ /* { dg-do run } */
+ /* { dg-require-effective-target sync_char_short } */
+
+ /* Test the execution of the __sync_mem_fetch_add builtin for a char. */
+
+ extern void abort(void);
+
+ char v, count;
+
+ main ()
+ {
+ v = 0;
+ count = 1;
+
+ if (__sync_mem_fetch_add (&v, count, __SYNC_MEM_RELAXED) != 0)
+ abort ();
+
+ if (__sync_mem_fetch_add (&v, count, __SYNC_MEM_CONSUME) != 1)
+ abort ();
+
+ if (__sync_mem_fetch_add (&v, count, __SYNC_MEM_ACQUIRE) != 2)
+ abort ();
+
+ if (__sync_mem_fetch_add (&v, count, __SYNC_MEM_RELEASE) != 3)
+ abort ();
+
+ if (__sync_mem_fetch_add (&v, count, __SYNC_MEM_ACQ_REL) != 4)
+ abort ();
+
+ if (__sync_mem_fetch_add (&v, count, __SYNC_MEM_SEQ_CST) != 5)
+ abort ();
+
+ return 0;
+ }
Index: sync-mem-fetch-add-2.c
===================================================================
*** sync-mem-fetch-add-2.c (revision 0)
--- sync-mem-fetch-add-2.c (revision 0)
***************
*** 0 ****
--- 1,36 ----
+ /* Test __sync_mem routines for existence and proper execution on 2 byte
+ values with each valid memory model. */
+ /* { dg-do run } */
+ /* { dg-require-effective-target sync_char_short } */
+
+ /* Test the execution of the __sync_mem_fetch_add builtin for a short. */
+
+ extern void abort(void);
+
+ short v, count;
+
+ main ()
+ {
+ v = 0;
+ count = 1;
+
+ if (__sync_mem_fetch_add (&v, count, __SYNC_MEM_RELAXED) != 0)
+ abort ();
+
+ if (__sync_mem_fetch_add (&v, count, __SYNC_MEM_CONSUME) != 1)
+ abort ();
+
+ if (__sync_mem_fetch_add (&v, count, __SYNC_MEM_ACQUIRE) != 2)
+ abort ();
+
+ if (__sync_mem_fetch_add (&v, count, __SYNC_MEM_RELEASE) != 3)
+ abort ();
+
+ if (__sync_mem_fetch_add (&v, count, __SYNC_MEM_ACQ_REL) != 4)
+ abort ();
+
+ if (__sync_mem_fetch_add (&v, count, __SYNC_MEM_SEQ_CST) != 5)
+ abort ();
+
+ return 0;
+ }
Index: sync-mem-fetch-add-3.c
===================================================================
*** sync-mem-fetch-add-3.c (revision 0)
--- sync-mem-fetch-add-3.c (revision 0)
***************
*** 0 ****
--- 1,36 ----
+ /* Test __sync_mem routines for existence and proper execution on 4 byte
+ values with each valid memory model. */
+ /* { dg-do run } */
+ /* { dg-require-effective-target sync_int_long } */
+
+ /* Test the execution of the __sync_mem_fetch_add builtin for an int. */
+
+ extern void abort(void);
+
+ int v, count;
+
+ main ()
+ {
+ v = 0;
+ count = 1;
+
+ if (__sync_mem_fetch_add (&v, count, __SYNC_MEM_RELAXED) != 0)
+ abort ();
+
+ if (__sync_mem_fetch_add (&v, count, __SYNC_MEM_CONSUME) != 1)
+ abort ();
+
+ if (__sync_mem_fetch_add (&v, count, __SYNC_MEM_ACQUIRE) != 2)
+ abort ();
+
+ if (__sync_mem_fetch_add (&v, count, __SYNC_MEM_RELEASE) != 3)
+ abort ();
+
+ if (__sync_mem_fetch_add (&v, count, __SYNC_MEM_ACQ_REL) != 4)
+ abort ();
+
+ if (__sync_mem_fetch_add (&v, count, __SYNC_MEM_SEQ_CST) != 5)
+ abort ();
+
+ return 0;
+ }
Index: sync-mem-fetch-add-4.c
===================================================================
*** sync-mem-fetch-add-4.c (revision 0)
--- sync-mem-fetch-add-4.c (revision 0)
***************
*** 0 ****
--- 1,37 ----
+ /* Test __sync_mem routines for existence and proper execution on 8 byte
+ values with each valid memory model. */
+ /* { dg-do run } */
+ /* { dg-require-effective-target sync_long_long } */
+ /* { dg-options "" } */
+
+ /* Test the execution of the __sync_mem_fetch_add builtin for a long_long. */
+
+ extern void abort(void);
+
+ long long v, count;
+
+ main ()
+ {
+ v = 0;
+ count = 1;
+
+ if (__sync_mem_fetch_add (&v, count, __SYNC_MEM_RELAXED) != 0)
+ abort ();
+
+ if (__sync_mem_fetch_add (&v, count, __SYNC_MEM_CONSUME) != 1)
+ abort ();
+
+ if (__sync_mem_fetch_add (&v, count, __SYNC_MEM_ACQUIRE) != 2)
+ abort ();
+
+ if (__sync_mem_fetch_add (&v, count, __SYNC_MEM_RELEASE) != 3)
+ abort ();
+
+ if (__sync_mem_fetch_add (&v, count, __SYNC_MEM_ACQ_REL) != 4)
+ abort ();
+
+ if (__sync_mem_fetch_add (&v, count, __SYNC_MEM_SEQ_CST) != 5)
+ abort ();
+
+ return 0;
+ }
Index: sync-mem-fetch-add-5.c
===================================================================
*** sync-mem-fetch-add-5.c (revision 0)
--- sync-mem-fetch-add-5.c (revision 0)
***************
*** 0 ****
--- 1,38 ----
+ /* Test __sync_mem routines for existence and proper execution on 16 byte
+ values with each valid memory model. */
+ /* { dg-do run } */
+ /* { dg-require-effective-target sync_int_128 } */
+ /* { dg-options "-mcx16" { target { x86_64-*-* } } } */
+
+
+ /* Test the execution of __sync_mem_fetch_add builtin for 16 byte values. */
+
+ extern void abort(void);
+
+ __int128_t v, count;
+
+ main ()
+ {
+ v = 0;
+ count = 1;
+
+ if (__sync_mem_fetch_add (&v, count, __SYNC_MEM_RELAXED) != 0)
+ abort ();
+
+ if (__sync_mem_fetch_add (&v, count, __SYNC_MEM_CONSUME) != 1)
+ abort ();
+
+ if (__sync_mem_fetch_add (&v, count, __SYNC_MEM_ACQUIRE) != 2)
+ abort ();
+
+ if (__sync_mem_fetch_add (&v, count, __SYNC_MEM_RELEASE) != 3)
+ abort ();
+
+ if (__sync_mem_fetch_add (&v, count, __SYNC_MEM_ACQ_REL) != 4)
+ abort ();
+
+ if (__sync_mem_fetch_add (&v, count, __SYNC_MEM_SEQ_CST) != 5)
+ abort ();
+
+ return 0;
+ }
Index: sync-mem-fetch-and-1.c
===================================================================
*** sync-mem-fetch-and-1.c (revision 0)
--- sync-mem-fetch-and-1.c (revision 0)
***************
*** 0 ****
--- 1,37 ----
+ /* Test __sync_mem routines for existence and proper execution on 1 byte
+ values with each valid memory model. */
+ /* { dg-do run } */
+ /* { dg-require-effective-target sync_char_short } */
+
+ /* Test the execution of the __sync_mem_fetch_and builtin for a char. */
+
+ extern void abort(void);
+
+ char v;
+ #define INIT (char)0xff
+
+ main ()
+ {
+ v = INIT;
+
+ if (__sync_mem_fetch_and (&v, 0, __SYNC_MEM_RELAXED) != INIT)
+ abort ();
+
+ if (__sync_mem_fetch_and (&v, INIT, __SYNC_MEM_CONSUME) != 0)
+ abort ();
+
+ if (__sync_mem_fetch_and (&v, 0, __SYNC_MEM_ACQUIRE) != 0 )
+ abort ();
+
+ v = ~v;
+ if (__sync_mem_fetch_and (&v, INIT, __SYNC_MEM_RELEASE) != INIT)
+ abort ();
+
+ if (__sync_mem_fetch_and (&v, 0, __SYNC_MEM_ACQ_REL) != INIT)
+ abort ();
+
+ if (__sync_mem_fetch_and (&v, 0, __SYNC_MEM_SEQ_CST) != 0)
+ abort ();
+
+ return 0;
+ }
Index: sync-mem-fetch-and-2.c
===================================================================
*** sync-mem-fetch-and-2.c (revision 0)
--- sync-mem-fetch-and-2.c (revision 0)
***************
*** 0 ****
--- 1,37 ----
+ /* Test __sync_mem routines for existence and proper execution on 2 byte
+ values with each valid memory model. */
+ /* { dg-do run } */
+ /* { dg-require-effective-target sync_char_short } */
+
+ /* Test the execution of the __sync_mem_fetch_and builtin for a short. */
+
+ extern void abort(void);
+
+ short v;
+ #define INIT (short)0xffff
+
+ main ()
+ {
+ v = INIT;
+
+ if (__sync_mem_fetch_and (&v, 0, __SYNC_MEM_RELAXED) != INIT)
+ abort ();
+
+ if (__sync_mem_fetch_and (&v, INIT, __SYNC_MEM_CONSUME) != 0)
+ abort ();
+
+ if (__sync_mem_fetch_and (&v, 0, __SYNC_MEM_ACQUIRE) != 0 )
+ abort ();
+
+ v = ~v;
+ if (__sync_mem_fetch_and (&v, INIT, __SYNC_MEM_RELEASE) != INIT)
+ abort ();
+
+ if (__sync_mem_fetch_and (&v, 0, __SYNC_MEM_ACQ_REL) != INIT)
+ abort ();
+
+ if (__sync_mem_fetch_and (&v, 0, __SYNC_MEM_SEQ_CST) != 0)
+ abort ();
+
+ return 0;
+ }
Index: sync-mem-fetch-and-3.c
===================================================================
*** sync-mem-fetch-and-3.c (revision 0)
--- sync-mem-fetch-and-3.c (revision 0)
***************
*** 0 ****
--- 1,37 ----
+ /* Test __sync_mem routines for existence and proper execution on 4 byte
+ values with each valid memory model. */
+ /* { dg-do run } */
+ /* { dg-require-effective-target sync_int_long } */
+
+ /* Test the execution of the __sync_mem_fetch_and builtin for an int. */
+
+ extern void abort(void);
+
+ int v;
+ #define INIT (int)0xffffffff
+
+ main ()
+ {
+ v = INIT;
+
+ if (__sync_mem_fetch_and (&v, 0, __SYNC_MEM_RELAXED) != INIT)
+ abort ();
+
+ if (__sync_mem_fetch_and (&v, INIT, __SYNC_MEM_CONSUME) != 0)
+ abort ();
+
+ if (__sync_mem_fetch_and (&v, 0, __SYNC_MEM_ACQUIRE) != 0)
+ abort ();
+
+ v = ~v;
+ if (__sync_mem_fetch_and (&v, INIT, __SYNC_MEM_RELEASE) != INIT)
+ abort ();
+
+ if (__sync_mem_fetch_and (&v, 0, __SYNC_MEM_ACQ_REL) != INIT)
+ abort ();
+
+ if (__sync_mem_fetch_and (&v, 0, __SYNC_MEM_SEQ_CST) != 0)
+ abort ();
+
+ return 0;
+ }
Index: sync-mem-fetch-and-4.c
===================================================================
*** sync-mem-fetch-and-4.c (revision 0)
--- sync-mem-fetch-and-4.c (revision 0)
***************
*** 0 ****
--- 1,39 ----
+ /* Test __sync_mem routines for existence and proper execution on 8 byte
+ values with each valid memory model. */
+ /* { dg-do run } */
+ /* { dg-require-effective-target sync_long_long} */
+ /* { dg-options "" } */
+
+
+ /* Test the execution of the __sync_mem_fetch_and builtin for a long long. */
+
+ extern void abort(void);
+
+ long long v;
+ #define INIT (long long)0xffffffffffffffff
+
+ main ()
+ {
+ v = INIT;
+
+ if (__sync_mem_fetch_and (&v, 0, __SYNC_MEM_RELAXED) != INIT)
+ abort ();
+
+ if (__sync_mem_fetch_and (&v, INIT, __SYNC_MEM_CONSUME) != 0)
+ abort ();
+
+ if (__sync_mem_fetch_and (&v, 0, __SYNC_MEM_ACQUIRE) != 0 )
+ abort ();
+
+ v = ~v;
+ if (__sync_mem_fetch_and (&v, INIT, __SYNC_MEM_RELEASE) != INIT)
+ abort ();
+
+ if (__sync_mem_fetch_and (&v, 0, __SYNC_MEM_ACQ_REL) != INIT)
+ abort ();
+
+ if (__sync_mem_fetch_and (&v, 0, __SYNC_MEM_SEQ_CST) != 0)
+ abort ();
+
+ return 0;
+ }
Index: sync-mem-fetch-and-5.c
===================================================================
*** sync-mem-fetch-and-5.c (revision 0)
--- sync-mem-fetch-and-5.c (revision 0)
***************
*** 0 ****
--- 1,38 ----
+ /* Test __sync_mem routines for existence and proper execution on 16 byte
+ values with each valid memory model. */
+ /* { dg-do run } */
+ /* { dg-require-effective-target sync_int_128 } */
+ /* { dg-options "-mcx16" { target { x86_64-*-* } } } */
+
+ /* Test execution of the __sync_mem_fetch_and builtin for a 16 byte value. */
+
+ extern void abort(void);
+
+ __int128_t v;
+ __int128_t init = ~0;
+
+ main ()
+ {
+ v = init;
+
+ if (__sync_mem_fetch_and (&v, 0, __SYNC_MEM_RELAXED) != init)
+ abort ();
+
+ if (__sync_mem_fetch_and (&v, init, __SYNC_MEM_CONSUME) != 0)
+ abort ();
+
+ if (__sync_mem_fetch_and (&v, 0, __SYNC_MEM_ACQUIRE) != 0 )
+ abort ();
+
+ v = ~v;
+ if (__sync_mem_fetch_and (&v, init, __SYNC_MEM_RELEASE) != init)
+ abort ();
+
+ if (__sync_mem_fetch_and (&v, 0, __SYNC_MEM_ACQ_REL) != init)
+ abort ();
+
+ if (__sync_mem_fetch_and (&v, 0, __SYNC_MEM_SEQ_CST) != 0)
+ abort ();
+
+ return 0;
+ }
Index: sync-mem-fetch-or-1.c
===================================================================
*** sync-mem-fetch-or-1.c (revision 0)
--- sync-mem-fetch-or-1.c (revision 0)
***************
*** 0 ****
--- 1,41 ----
+ /* Test __sync_mem routines for existence and proper execution on 1 byte
+ values with each valid memory model. */
+ /* { dg-do run } */
+ /* { dg-require-effective-target sync_char_short } */
+
+ /* Test the execution of the __sync_mem_fetch_or builtin for a char. */
+
+ extern void abort(void);
+
+ char v, count;
+
+ main ()
+ {
+ v = 0;
+ count = 1;
+
+ if (__sync_mem_fetch_or (&v, count, __SYNC_MEM_RELAXED) != 0)
+ abort ();
+
+ count *= 2;
+ if (__sync_mem_fetch_or (&v, count, __SYNC_MEM_CONSUME) != 1)
+ abort ();
+
+ count *= 2;
+ if (__sync_mem_fetch_or (&v, count, __SYNC_MEM_ACQUIRE) != 3)
+ abort ();
+
+ count *= 2;
+ if (__sync_mem_fetch_or (&v, count, __SYNC_MEM_RELEASE) != 7)
+ abort ();
+
+ count *= 2;
+ if (__sync_mem_fetch_or (&v, count, __SYNC_MEM_ACQ_REL) != 15)
+ abort ();
+
+ count *= 2;
+ if (__sync_mem_fetch_or (&v, count, __SYNC_MEM_SEQ_CST) != 31)
+ abort ();
+
+ return 0;
+ }
Index: sync-mem-fetch-or-2.c
===================================================================
*** sync-mem-fetch-or-2.c (revision 0)
--- sync-mem-fetch-or-2.c (revision 0)
***************
*** 0 ****
--- 1,41 ----
+ /* Test __sync_mem routines for existence and proper execution on 2 byte
+ values with each valid memory model. */
+ /* { dg-do run } */
+ /* { dg-require-effective-target sync_char_short } */
+
+ /* Test the execution of the __sync_mem_fetch_or builtin for a short. */
+
+ extern void abort(void);
+
+ short v, count;
+
+ main ()
+ {
+ v = 0;
+ count = 1;
+
+ if (__sync_mem_fetch_or (&v, count, __SYNC_MEM_RELAXED) != 0)
+ abort ();
+
+ count *= 2;
+ if (__sync_mem_fetch_or (&v, count, __SYNC_MEM_CONSUME) != 1)
+ abort ();
+
+ count *= 2;
+ if (__sync_mem_fetch_or (&v, count, __SYNC_MEM_ACQUIRE) != 3)
+ abort ();
+
+ count *= 2;
+ if (__sync_mem_fetch_or (&v, count, __SYNC_MEM_RELEASE) != 7)
+ abort ();
+
+ count *= 2;
+ if (__sync_mem_fetch_or (&v, count, __SYNC_MEM_ACQ_REL) != 15)
+ abort ();
+
+ count *= 2;
+ if (__sync_mem_fetch_or (&v, count, __SYNC_MEM_SEQ_CST) != 31)
+ abort ();
+
+ return 0;
+ }
Index: sync-mem-fetch-or-3.c
===================================================================
*** sync-mem-fetch-or-3.c (revision 0)
--- sync-mem-fetch-or-3.c (revision 0)
***************
*** 0 ****
--- 1,41 ----
+ /* Test __sync_mem routines for existence and proper execution on 4 byte
+ values with each valid memory model. */
+ /* { dg-do run } */
+ /* { dg-require-effective-target sync_int_long } */
+
+ /* Test the execution of the __sync_mem_fetch_or builtin for an int. */
+
+ extern void abort(void);
+
+ int v, count;
+
+ main ()
+ {
+ v = 0;
+ count = 1;
+
+ if (__sync_mem_fetch_or (&v, count, __SYNC_MEM_RELAXED) != 0)
+ abort ();
+
+ count *= 2;
+ if (__sync_mem_fetch_or (&v, count, __SYNC_MEM_CONSUME) != 1)
+ abort ();
+
+ count *= 2;
+ if (__sync_mem_fetch_or (&v, count, __SYNC_MEM_ACQUIRE) != 3)
+ abort ();
+
+ count *= 2;
+ if (__sync_mem_fetch_or (&v, count, __SYNC_MEM_RELEASE) != 7)
+ abort ();
+
+ count *= 2;
+ if (__sync_mem_fetch_or (&v, count, __SYNC_MEM_ACQ_REL) != 15)
+ abort ();
+
+ count *= 2;
+ if (__sync_mem_fetch_or (&v, count, __SYNC_MEM_SEQ_CST) != 31)
+ abort ();
+
+ return 0;
+ }
Index: sync-mem-fetch-or-4.c
===================================================================
*** sync-mem-fetch-or-4.c (revision 0)
--- sync-mem-fetch-or-4.c (revision 0)
***************
*** 0 ****
--- 1,42 ----
+ /* Test __sync_mem routines for existence and proper execution on 8 byte
+ values with each valid memory model. */
+ /* { dg-do run } */
+ /* { dg-require-effective-target sync_long_long } */
+ /* { dg-options "" } */
+
+ /* Test the execution of the __sync_mem_fetch_or builtin for a long long. */
+
+ extern void abort(void);
+
+ long long v, count;
+
+ main ()
+ {
+ v = 0;
+ count = 1;
+
+ if (__sync_mem_fetch_or (&v, count, __SYNC_MEM_RELAXED) != 0)
+ abort ();
+
+ count *= 2;
+ if (__sync_mem_fetch_or (&v, count, __SYNC_MEM_CONSUME) != 1)
+ abort ();
+
+ count *= 2;
+ if (__sync_mem_fetch_or (&v, count, __SYNC_MEM_ACQUIRE) != 3)
+ abort ();
+
+ count *= 2;
+ if (__sync_mem_fetch_or (&v, count, __SYNC_MEM_RELEASE) != 7)
+ abort ();
+
+ count *= 2;
+ if (__sync_mem_fetch_or (&v, count, __SYNC_MEM_ACQ_REL) != 15)
+ abort ();
+
+ count *= 2;
+ if (__sync_mem_fetch_or (&v, count, __SYNC_MEM_SEQ_CST) != 31)
+ abort ();
+
+ return 0;
+ }
Index: sync-mem-fetch-or-5.c
===================================================================
*** sync-mem-fetch-or-5.c (revision 0)
--- sync-mem-fetch-or-5.c (revision 0)
***************
*** 0 ****
--- 1,42 ----
+ /* Test __sync_mem routines for existence and proper execution on 16 byte
+ values with each valid memory model. */
+ /* { dg-do run } */
+ /* { dg-require-effective-target sync_int_128} */
+ /* { dg-options "-mcx16" { target { x86_64-*-* } } } */
+
+ /* Test execution of the __sync_mem_fetch_or builtin for a 16 byte value. */
+
+ extern void abort(void);
+
+ __int128_t v, count;
+
+ main ()
+ {
+ v = 0;
+ count = 1;
+
+ if (__sync_mem_fetch_or (&v, count, __SYNC_MEM_RELAXED) != 0)
+ abort ();
+
+ count *= 2;
+ if (__sync_mem_fetch_or (&v, count, __SYNC_MEM_CONSUME) != 1)
+ abort ();
+
+ count *= 2;
+ if (__sync_mem_fetch_or (&v, count, __SYNC_MEM_ACQUIRE) != 3)
+ abort ();
+
+ count *= 2;
+ if (__sync_mem_fetch_or (&v, count, __SYNC_MEM_RELEASE) != 7)
+ abort ();
+
+ count *= 2;
+ if (__sync_mem_fetch_or (&v, count, __SYNC_MEM_ACQ_REL) != 15)
+ abort ();
+
+ count *= 2;
+ if (__sync_mem_fetch_or (&v, count, __SYNC_MEM_SEQ_CST) != 31)
+ abort ();
+
+ return 0;
+ }
Index: sync-mem-fetch-sub-1.c
===================================================================
*** sync-mem-fetch-sub-1.c (revision 0)
--- sync-mem-fetch-sub-1.c (revision 0)
***************
*** 0 ****
--- 1,36 ----
+ /* Test __sync_mem routines for existence and proper execution on 1 byte
+ values with each valid memory model. */
+ /* { dg-do run } */
+ /* { dg-require-effective-target sync_char_short } */
+
+ /* Test the execution of the __sync_mem_fetch_sub builtin for a char. */
+
+ extern void abort(void);
+
+ char v, count, res;
+
+ main ()
+ {
+ v = res = 20;
+ count = 0;
+
+ if (__sync_mem_fetch_sub (&v, count + 1, __SYNC_MEM_RELAXED) != res--)
+ abort ();
+
+ if (__sync_mem_fetch_sub (&v, count + 1, __SYNC_MEM_CONSUME) != res--)
+ abort ();
+
+ if (__sync_mem_fetch_sub (&v, count + 1, __SYNC_MEM_ACQUIRE) != res--)
+ abort ();
+
+ if (__sync_mem_fetch_sub (&v, count + 1, __SYNC_MEM_RELEASE) != res--)
+ abort ();
+
+ if (__sync_mem_fetch_sub (&v, count + 1, __SYNC_MEM_ACQ_REL) != res--)
+ abort ();
+
+ if (__sync_mem_fetch_sub (&v, count + 1, __SYNC_MEM_SEQ_CST) != res--)
+ abort ();
+
+ return 0;
+ }
Index: sync-mem-fetch-sub-2.c
===================================================================
*** sync-mem-fetch-sub-2.c (revision 0)
--- sync-mem-fetch-sub-2.c (revision 0)
***************
*** 0 ****
--- 1,36 ----
+ /* Test __sync_mem routines for existence and proper execution on 2 byte
+ values with each valid memory model. */
+ /* { dg-do run } */
+ /* { dg-require-effective-target sync_char_short } */
+
+ /* Test the execution of the __sync_mem_fetch_sub builtin for a short. */
+
+ extern void abort(void);
+
+ short v, count, res;
+
+ main ()
+ {
+ v = res = 20;
+ count = 0;
+
+ if (__sync_mem_fetch_sub (&v, count + 1, __SYNC_MEM_RELAXED) != res--)
+ abort ();
+
+ if (__sync_mem_fetch_sub (&v, count + 1, __SYNC_MEM_CONSUME) != res--)
+ abort ();
+
+ if (__sync_mem_fetch_sub (&v, count + 1, __SYNC_MEM_ACQUIRE) != res--)
+ abort ();
+
+ if (__sync_mem_fetch_sub (&v, count + 1, __SYNC_MEM_RELEASE) != res--)
+ abort ();
+
+ if (__sync_mem_fetch_sub (&v, count + 1, __SYNC_MEM_ACQ_REL) != res--)
+ abort ();
+
+ if (__sync_mem_fetch_sub (&v, count + 1, __SYNC_MEM_SEQ_CST) != res--)
+ abort ();
+
+ return 0;
+ }
Index: sync-mem-fetch-sub-3.c
===================================================================
*** sync-mem-fetch-sub-3.c (revision 0)
--- sync-mem-fetch-sub-3.c (revision 0)
***************
*** 0 ****
--- 1,36 ----
+ /* Test __sync_mem routines for existence and proper execution on 4 byte
+ values with each valid memory model. */
+ /* { dg-do run } */
+ /* { dg-require-effective-target sync_int_long } */
+
+ /* Test the execution of the __sync_mem_fetch_sub builtin for an int. */
+
+ extern void abort(void);
+
+ int v, count, res;
+
+ main ()
+ {
+ v = res = 20;
+ count = 0;
+
+ if (__sync_mem_fetch_sub (&v, count + 1, __SYNC_MEM_RELAXED) != res--)
+ abort ();
+
+ if (__sync_mem_fetch_sub (&v, count + 1, __SYNC_MEM_CONSUME) != res--)
+ abort ();
+
+ if (__sync_mem_fetch_sub (&v, count + 1, __SYNC_MEM_ACQUIRE) != res--)
+ abort ();
+
+ if (__sync_mem_fetch_sub (&v, count + 1, __SYNC_MEM_RELEASE) != res--)
+ abort ();
+
+ if (__sync_mem_fetch_sub (&v, count + 1, __SYNC_MEM_ACQ_REL) != res--)
+ abort ();
+
+ if (__sync_mem_fetch_sub (&v, count + 1, __SYNC_MEM_SEQ_CST) != res--)
+ abort ();
+
+ return 0;
+ }
Index: sync-mem-fetch-sub-4.c
===================================================================
*** sync-mem-fetch-sub-4.c (revision 0)
--- sync-mem-fetch-sub-4.c (revision 0)
***************
*** 0 ****
--- 1,37 ----
+ /* Test __sync_mem routines for existence and proper execution on 8 byte
+ values with each valid memory model. */
+ /* { dg-do run } */
+ /* { dg-require-effective-target sync_long_long } */
+ /* { dg-options "" } */
+
+ /* Test the execution of the __sync_mem_fetch_sub builtin for a long long. */
+
+ extern void abort(void);
+
+ long long v, count, res;
+
+ main ()
+ {
+ v = res = 20;
+ count = 0;
+
+ if (__sync_mem_fetch_sub (&v, count + 1, __SYNC_MEM_RELAXED) != res--)
+ abort ();
+
+ if (__sync_mem_fetch_sub (&v, count + 1, __SYNC_MEM_CONSUME) != res--)
+ abort ();
+
+ if (__sync_mem_fetch_sub (&v, count + 1, __SYNC_MEM_ACQUIRE) != res--)
+ abort ();
+
+ if (__sync_mem_fetch_sub (&v, count + 1, __SYNC_MEM_RELEASE) != res--)
+ abort ();
+
+ if (__sync_mem_fetch_sub (&v, count + 1, __SYNC_MEM_ACQ_REL) != res--)
+ abort ();
+
+ if (__sync_mem_fetch_sub (&v, count + 1, __SYNC_MEM_SEQ_CST) != res--)
+ abort ();
+
+ return 0;
+ }
Index: sync-mem-fetch-sub-5.c
===================================================================
*** sync-mem-fetch-sub-5.c (revision 0)
--- sync-mem-fetch-sub-5.c (revision 0)
***************
*** 0 ****
--- 1,37 ----
+ /* Test __sync_mem routines for existence and proper execution on 16 byte
+ values with each valid memory model. */
+ /* { dg-do run } */
+ /* { dg-require-effective-target sync_int_128 } */
+ /* { dg-options "-mcx16" { target { x86_64-*-* } } } */
+
+ /* Test execution of the __sync_mem_fetch_sub builtin for a 16 byte value. */
+
+ extern void abort(void);
+
+ __int128_t v, count, res;
+
+ main ()
+ {
+ v = res = 20;
+ count = 0;
+
+ if (__sync_mem_fetch_sub (&v, count + 1, __SYNC_MEM_RELAXED) != res--)
+ abort ();
+
+ if (__sync_mem_fetch_sub (&v, count + 1, __SYNC_MEM_CONSUME) != res--)
+ abort ();
+
+ if (__sync_mem_fetch_sub (&v, count + 1, __SYNC_MEM_ACQUIRE) != res--)
+ abort ();
+
+ if (__sync_mem_fetch_sub (&v, count + 1, __SYNC_MEM_RELEASE) != res--)
+ abort ();
+
+ if (__sync_mem_fetch_sub (&v, count + 1, __SYNC_MEM_ACQ_REL) != res--)
+ abort ();
+
+ if (__sync_mem_fetch_sub (&v, count + 1, __SYNC_MEM_SEQ_CST) != res--)
+ abort ();
+
+ return 0;
+ }
Index: sync-mem-fetch-xor-1.c
===================================================================
*** sync-mem-fetch-xor-1.c (revision 0)
--- sync-mem-fetch-xor-1.c (revision 0)
***************
*** 0 ****
--- 1,37 ----
+ /* Test __sync_mem routines for existence and proper execution on 1 byte
+ values with each valid memory model. */
+ /* { dg-do run } */
+ /* { dg-require-effective-target sync_char_short } */
+
+ /* Test the execution of the __sync_mem_fetch_xor builtin for a char. */
+
+ extern void abort(void);
+
+
+ char v, count, init = ~0;
+
+ main ()
+ {
+ v = init;
+ count = 0;
+
+ if (__sync_mem_fetch_xor (&v, count, __SYNC_MEM_RELAXED) != init)
+ abort ();
+
+ if (__sync_mem_fetch_xor (&v, ~count, __SYNC_MEM_CONSUME) != init)
+ abort ();
+
+ if (__sync_mem_fetch_xor (&v, count, __SYNC_MEM_ACQUIRE) != 0)
+ abort ();
+
+ if (__sync_mem_fetch_xor (&v, ~count, __SYNC_MEM_RELEASE) != 0)
+ abort ();
+
+ if (__sync_mem_fetch_xor (&v, count, __SYNC_MEM_ACQ_REL) != init)
+ abort ();
+
+ if (__sync_mem_fetch_xor (&v, ~count, __SYNC_MEM_SEQ_CST) != init)
+ abort ();
+
+ return 0;
+ }
Index: sync-mem-fetch-xor-2.c
===================================================================
*** sync-mem-fetch-xor-2.c (revision 0)
--- sync-mem-fetch-xor-2.c (revision 0)
***************
*** 0 ****
--- 1,36 ----
+ /* Test __sync_mem routines for existence and proper execution on 2 byte
+ values with each valid memory model. */
+ /* { dg-do run } */
+ /* { dg-require-effective-target sync_char_short } */
+
+ /* Test the execution of the __sync_mem_fetch_xor builtin for a short. */
+
+ extern void abort(void);
+
+ short v, count, init = ~0;
+
+ main ()
+ {
+ v = init;
+ count = 0;
+
+ if (__sync_mem_fetch_xor (&v, count, __SYNC_MEM_RELAXED) != init)
+ abort ();
+
+ if (__sync_mem_fetch_xor (&v, ~count, __SYNC_MEM_CONSUME) != init)
+ abort ();
+
+ if (__sync_mem_fetch_xor (&v, count, __SYNC_MEM_ACQUIRE) != 0)
+ abort ();
+
+ if (__sync_mem_fetch_xor (&v, ~count, __SYNC_MEM_RELEASE) != 0)
+ abort ();
+
+ if (__sync_mem_fetch_xor (&v, count, __SYNC_MEM_ACQ_REL) != init)
+ abort ();
+
+ if (__sync_mem_fetch_xor (&v, ~count, __SYNC_MEM_SEQ_CST) != init)
+ abort ();
+
+ return 0;
+ }
Index: sync-mem-fetch-xor-3.c
===================================================================
*** sync-mem-fetch-xor-3.c (revision 0)
--- sync-mem-fetch-xor-3.c (revision 0)
***************
*** 0 ****
--- 1,36 ----
+ /* Test __sync_mem routines for existence and proper execution on 4 byte
+ values with each valid memory model. */
+ /* { dg-do run } */
+ /* { dg-require-effective-target sync_int_long } */
+
+ /* Test the execution of the __sync_mem_fetch_xor builtin for an int. */
+
+ extern void abort(void);
+
+ int v, count, init = ~0;
+
+ main ()
+ {
+ v = init;
+ count = 0;
+
+ if (__sync_mem_fetch_xor (&v, count, __SYNC_MEM_RELAXED) != init)
+ abort ();
+
+ if (__sync_mem_fetch_xor (&v, ~count, __SYNC_MEM_CONSUME) != init)
+ abort ();
+
+ if (__sync_mem_fetch_xor (&v, count, __SYNC_MEM_ACQUIRE) != 0)
+ abort ();
+
+ if (__sync_mem_fetch_xor (&v, ~count, __SYNC_MEM_RELEASE) != 0)
+ abort ();
+
+ if (__sync_mem_fetch_xor (&v, count, __SYNC_MEM_ACQ_REL) != init)
+ abort ();
+
+ if (__sync_mem_fetch_xor (&v, ~count, __SYNC_MEM_SEQ_CST) != init)
+ abort ();
+
+ return 0;
+ }
Index: sync-mem-fetch-xor-4.c
===================================================================
*** sync-mem-fetch-xor-4.c (revision 0)
--- sync-mem-fetch-xor-4.c (revision 0)
***************
*** 0 ****
--- 1,37 ----
+ /* Test __sync_mem routines for existence and proper execution on 8 byte
+ values with each valid memory model. */
+ /* { dg-do run } */
+ /* { dg-require-effective-target sync_long_long } */
+ /* { dg-options "" } */
+
+ /* Test the execution of the __sync_mem_fetch_xor builtin for a long long . */
+
+ extern void abort(void);
+
+ long long v, count, init = ~0;
+
+ main ()
+ {
+ v = init;
+ count = 0;
+
+ if (__sync_mem_fetch_xor (&v, count, __SYNC_MEM_RELAXED) != init)
+ abort ();
+
+ if (__sync_mem_fetch_xor (&v, ~count, __SYNC_MEM_CONSUME) != init)
+ abort ();
+
+ if (__sync_mem_fetch_xor (&v, count, __SYNC_MEM_ACQUIRE) != 0)
+ abort ();
+
+ if (__sync_mem_fetch_xor (&v, ~count, __SYNC_MEM_RELEASE) != 0)
+ abort ();
+
+ if (__sync_mem_fetch_xor (&v, count, __SYNC_MEM_ACQ_REL) != init)
+ abort ();
+
+ if (__sync_mem_fetch_xor (&v, ~count, __SYNC_MEM_SEQ_CST) != init)
+ abort ();
+
+ return 0;
+ }
Index: sync-mem-fetch-xor-5.c
===================================================================
*** sync-mem-fetch-xor-5.c (revision 0)
--- sync-mem-fetch-xor-5.c (revision 0)
***************
*** 0 ****
--- 1,37 ----
+ /* Test __sync_mem routines for existence and proper execution on 16 byte
+ values with each valid memory model. */
+ /* { dg-do run } */
+ /* { dg-require-effective-target sync_int_128 } */
+ /* { dg-options "-mcx16" { target { x86_64-*-* } } } */
+
+ /* Test execution of the __sync_mem_fetch_xor builtin for a 16 byte value. */
+
+ extern void abort(void);
+
+ __int128_t v, count, init = ~0;
+
+ main ()
+ {
+ v = init;
+ count = 0;
+
+ if (__sync_mem_fetch_xor (&v, count, __SYNC_MEM_RELAXED) != init)
+ abort ();
+
+ if (__sync_mem_fetch_xor (&v, ~count, __SYNC_MEM_CONSUME) != init)
+ abort ();
+
+ if (__sync_mem_fetch_xor (&v, count, __SYNC_MEM_ACQUIRE) != 0)
+ abort ();
+
+ if (__sync_mem_fetch_xor (&v, ~count, __SYNC_MEM_RELEASE) != 0)
+ abort ();
+
+ if (__sync_mem_fetch_xor (&v, count, __SYNC_MEM_ACQ_REL) != init)
+ abort ();
+
+ if (__sync_mem_fetch_xor (&v, ~count, __SYNC_MEM_SEQ_CST) != init)
+ abort ();
+
+ return 0;
+ }
Index: sync-mem-flag.c
===================================================================
*** sync-mem-flag.c (revision 0)
--- sync-mem-flag.c (revision 0)
***************
*** 0 ****
--- 1,37 ----
+ /* Test __sync_mem routines for existence and proper execution with each valid
+ memory model. */
+ /* { dg-do run } */
+ /* { dg-require-effective-target sync_char_short } */
+
+
+ /* Test the execution of __sync_mem_flag_{test_and_set,clear} builtins. */
+
+ extern void abort(void);
+
+ char v;
+
+ main ()
+ {
+ v = 0;
+
+ if (__sync_mem_flag_test_and_set (&v, __SYNC_MEM_RELAXED) != 0)
+ abort();
+ if (v != 1)
+ abort();
+ __sync_mem_flag_clear (&v, __SYNC_MEM_RELAXED);
+
+ if (__sync_mem_flag_test_and_set (&v, __SYNC_MEM_RELEASE) != 0)
+ abort();
+ if (v != 1)
+ abort();
+ __sync_mem_flag_clear (&v, __SYNC_MEM_RELEASE);
+
+ if (__sync_mem_flag_test_and_set (&v, __SYNC_MEM_SEQ_CST) != 0)
+ abort();
+ if (v != 1)
+ abort();
+ __sync_mem_flag_clear (&v, __SYNC_MEM_SEQ_CST);
+
+ return 0;
+ }
+
Index: sync-mem-invalid.c
===================================================================
*** sync-mem-invalid.c (revision 175331)
--- sync-mem-invalid.c (working copy)
*************** int i;
*** 8,11 ****
--- 8,26 ----
main ()
{
__sync_mem_exchange (&i, 1, __SYNC_MEM_CONSUME); /* { dg-error "invalid memory model" } */
+
+ __sync_mem_compare_exchange (&i, 1, 2, __SYNC_MEM_SEQ_CST, __SYNC_MEM_RELEASE); /* { dg-error "invalid failure memory model" } */
+ __sync_mem_compare_exchange (&i, 1, 2, __SYNC_MEM_SEQ_CST, __SYNC_MEM_ACQ_REL); /* { dg-error "invalid failure memory model" } */
+ __sync_mem_compare_exchange (&i, 1, 2, __SYNC_MEM_ACQUIRE, __SYNC_MEM_SEQ_CST); /* { dg-error "failure memory model" } */
+ __sync_mem_compare_exchange (&i, 1, 2, __SYNC_MEM_RELAXED, __SYNC_MEM_ACQUIRE); /* { dg-error "failure memory model" } */
+
+ __sync_mem_load (&i, __SYNC_MEM_RELEASE); /* { dg-error "invalid memory model" } */
+ __sync_mem_load (&i, __SYNC_MEM_ACQ_REL); /* { dg-error "invalid memory model" } */
+
+ __sync_mem_store (&i, 1, __SYNC_MEM_ACQUIRE); /* { dg-error "invalid memory model" } */
+ __sync_mem_store (&i, 1, __SYNC_MEM_CONSUME); /* { dg-error "invalid memory model" } */
+ __sync_mem_store (&i, 1, __SYNC_MEM_ACQ_REL); /* { dg-error "invalid memory model" } */
+
+ __sync_mem_flag_clear (&i, __SYNC_MEM_ACQUIRE); /* { dg-error "invalid memory model" } */
+ __sync_mem_flag_clear (&i, __SYNC_MEM_ACQ_REL); /* { dg-error "invalid memory model" } */
}
Index: sync-mem-load-1.c
===================================================================
*** sync-mem-load-1.c (revision 0)
--- sync-mem-load-1.c (revision 0)
***************
*** 0 ****
--- 1,40 ----
+ /* Test __sync_mem routines for existence and proper execution on 1 byte
+ values with each valid memory model. */
+ /* { dg-do run } */
+ /* { dg-require-effective-target sync_char_short } */
+
+
+ /* Test the execution of the __sync_mem_load builtin for a char. */
+
+ extern void abort(void);
+
+ char v, count;
+
+ main ()
+ {
+ v = 0;
+ count = 0;
+
+ if (__sync_mem_load (&v, __SYNC_MEM_RELAXED) != count++)
+ abort();
+ else
+ v++;
+
+ if (__sync_mem_load (&v, __SYNC_MEM_ACQUIRE) != count++)
+ abort();
+ else
+ v++;
+
+ if (__sync_mem_load (&v, __SYNC_MEM_CONSUME) != count++)
+ abort();
+ else
+ v++;
+
+ if (__sync_mem_load (&v, __SYNC_MEM_SEQ_CST) != count++)
+ abort();
+ else
+ v++;
+
+ return 0;
+ }
+
Index: sync-mem-load-2.c
===================================================================
*** sync-mem-load-2.c (revision 0)
--- sync-mem-load-2.c (revision 0)
***************
*** 0 ****
--- 1,41 ----
+ /* Test __sync_mem routines for existence and proper execution on 2 byte
+ values with each valid memory model. */
+ /* { dg-do run } */
+ /* { dg-require-effective-target sync_char_short } */
+
+
+ /* Test the execution of the __sync_mem_load builtin for a short. */
+
+ extern void abort(void);
+
+ short v, count;
+
+
+ main ()
+ {
+ v = 0;
+ count = 0;
+
+ if (__sync_mem_load (&v, __SYNC_MEM_RELAXED) != count++)
+ abort();
+ else
+ v++;
+
+ if (__sync_mem_load (&v, __SYNC_MEM_ACQUIRE) != count++)
+ abort();
+ else
+ v++;
+
+ if (__sync_mem_load (&v, __SYNC_MEM_CONSUME) != count++)
+ abort();
+ else
+ v++;
+
+ if (__sync_mem_load (&v, __SYNC_MEM_SEQ_CST) != count++)
+ abort();
+ else
+ v++;
+
+ return 0;
+ }
+
Index: sync-mem-load-3.c
===================================================================
*** sync-mem-load-3.c (revision 0)
--- sync-mem-load-3.c (revision 0)
***************
*** 0 ****
--- 1,38 ----
+ /* Test __sync_mem routines for existence and proper execution on 4 byte
+ values with each valid memory model. */
+ /* { dg-do run } */
+ /* { dg-require-effective-target sync_int_long } */
+
+ extern void abort(void);
+
+ int v, count;
+
+
+ main ()
+ {
+ v = 0;
+ count = 0;
+
+ if (__sync_mem_load (&v, __SYNC_MEM_RELAXED) != count++)
+ abort();
+ else
+ v++;
+
+ if (__sync_mem_load (&v, __SYNC_MEM_ACQUIRE) != count++)
+ abort();
+ else
+ v++;
+
+ if (__sync_mem_load (&v, __SYNC_MEM_CONSUME) != count++)
+ abort();
+ else
+ v++;
+
+ if (__sync_mem_load (&v, __SYNC_MEM_SEQ_CST) != count++)
+ abort();
+ else
+ v++;
+
+ return 0;
+ }
+
Index: sync-mem-load-4.c
===================================================================
*** sync-mem-load-4.c (revision 0)
--- sync-mem-load-4.c (revision 0)
***************
*** 0 ****
--- 1,38 ----
+ /* Test __sync_mem routines for existence and proper execution on 8 byte
+ values with each valid memory model. */
+ /* { dg-do run } */
+ /* { dg-require-effective-target sync_long_long } */
+ /* { dg-options "" } */
+
+ extern void abort(void);
+
+ long long v, count;
+
+ main ()
+ {
+ v = 0;
+ count = 0;
+
+ if (__sync_mem_load (&v, __SYNC_MEM_RELAXED) != count++)
+ abort();
+ else
+ v++;
+
+ if (__sync_mem_load (&v, __SYNC_MEM_ACQUIRE) != count++)
+ abort();
+ else
+ v++;
+
+ if (__sync_mem_load (&v, __SYNC_MEM_CONSUME) != count++)
+ abort();
+ else
+ v++;
+
+ if (__sync_mem_load (&v, __SYNC_MEM_SEQ_CST) != count++)
+ abort();
+ else
+ v++;
+
+ return 0;
+ }
+
Index: sync-mem-load-5.c
===================================================================
*** sync-mem-load-5.c (revision 0)
--- sync-mem-load-5.c (revision 0)
***************
*** 0 ****
--- 1,38 ----
+ /* Test __sync_mem routines for existence and proper execution on 16 byte
+ values with each valid memory model. */
+ /* { dg-do run } */
+ /* { dg-require-effective-target sync_int_128 } */
+ /* { dg-options "-mcx16" { target { x86_64-*-* } } } */
+
+ extern void abort(void);
+
+ __int128_t v, count;
+
+ main ()
+ {
+ v = 0;
+ count = 0;
+
+ if (__sync_mem_load (&v, __SYNC_MEM_RELAXED) != count++)
+ abort();
+ else
+ v++;
+
+ if (__sync_mem_load (&v, __SYNC_MEM_ACQUIRE) != count++)
+ abort();
+ else
+ v++;
+
+ if (__sync_mem_load (&v, __SYNC_MEM_CONSUME) != count++)
+ abort();
+ else
+ v++;
+
+ if (__sync_mem_load (&v, __SYNC_MEM_SEQ_CST) != count++)
+ abort();
+ else
+ v++;
+
+ return 0;
+ }
+
Index: sync-mem-store-1.c
===================================================================
*** sync-mem-store-1.c (revision 0)
--- sync-mem-store-1.c (revision 0)
***************
*** 0 ****
--- 1,31 ----
+ /* Test __sync_mem routines for existence and proper execution on 1 byte
+ values with each valid memory model. */
+ /* { dg-do run } */
+ /* { dg-require-effective-target sync_char_short } */
+
+ /* Test the execution of the __sync_mem_store builtin for a char. */
+
+ extern void abort(void);
+
+ char v, count;
+
+ main ()
+ {
+ v = 0;
+ count = 0;
+
+ __sync_mem_store (&v, count + 1, __SYNC_MEM_RELAXED);
+ if (v != ++count)
+ abort ();
+
+ __sync_mem_store (&v, count + 1, __SYNC_MEM_RELEASE);
+ if (v != ++count)
+ abort ();
+
+ __sync_mem_store (&v, count + 1, __SYNC_MEM_SEQ_CST);
+ if (v != ++count)
+ abort ();
+
+ return 0;
+ }
+
Index: sync-mem-store-2.c
===================================================================
*** sync-mem-store-2.c (revision 0)
--- sync-mem-store-2.c (revision 0)
***************
*** 0 ****
--- 1,31 ----
+ /* Test __sync_mem routines for existence and proper execution on 2 byte
+ values with each valid memory model. */
+ /* { dg-do run } */
+ /* { dg-require-effective-target sync_char_short } */
+
+ /* Test the execution of the __sync_mem_store builtin for a short. */
+
+ extern void abort(void);
+
+ short v, count;
+
+ main ()
+ {
+ v = 0;
+ count = 0;
+
+ __sync_mem_store (&v, count + 1, __SYNC_MEM_RELAXED);
+ if (v != ++count)
+ abort ();
+
+ __sync_mem_store (&v, count + 1, __SYNC_MEM_RELEASE);
+ if (v != ++count)
+ abort ();
+
+ __sync_mem_store (&v, count + 1, __SYNC_MEM_SEQ_CST);
+ if (v != ++count)
+ abort ();
+
+ return 0;
+ }
+
Index: sync-mem-store-3.c
===================================================================
*** sync-mem-store-3.c (revision 0)
--- sync-mem-store-3.c (revision 0)
***************
*** 0 ****
--- 1,31 ----
+ /* Test __sync_mem routines for existence and proper execution on 4 byte
+ values with each valid memory model. */
+ /* { dg-do run } */
+ /* { dg-require-effective-target sync_int_long } */
+
+ /* Test the execution of the __sync_mem_store builtin for an int. */
+
+ extern void abort(void);
+
+ int v, count;
+
+ main ()
+ {
+ v = 0;
+ count = 0;
+
+ __sync_mem_store (&v, count + 1, __SYNC_MEM_RELAXED);
+ if (v != ++count)
+ abort ();
+
+ __sync_mem_store (&v, count + 1, __SYNC_MEM_RELEASE);
+ if (v != ++count)
+ abort ();
+
+ __sync_mem_store (&v, count + 1, __SYNC_MEM_SEQ_CST);
+ if (v != ++count)
+ abort ();
+
+ return 0;
+ }
+
Index: sync-mem-store-4.c
===================================================================
*** sync-mem-store-4.c (revision 0)
--- sync-mem-store-4.c (revision 0)
***************
*** 0 ****
--- 1,32 ----
+ /* Test __sync_mem routines for existence and proper execution on 8 byte
+ values with each valid memory model. */
+ /* { dg-do run } */
+ /* { dg-require-effective-target sync_long_long } */
+ /* { dg-options "" } */
+
+ /* Test the execution of the __sync_mem_store builtin for a long long. */
+
+ extern void abort(void);
+
+ long long v, count;
+
+ main ()
+ {
+ v = 0;
+ count = 0;
+
+ __sync_mem_store (&v, count + 1, __SYNC_MEM_RELAXED);
+ if (v != ++count)
+ abort ();
+
+ __sync_mem_store (&v, count + 1, __SYNC_MEM_RELEASE);
+ if (v != ++count)
+ abort ();
+
+ __sync_mem_store (&v, count + 1, __SYNC_MEM_SEQ_CST);
+ if (v != ++count)
+ abort ();
+
+ return 0;
+ }
+
Index: sync-mem-store-5.c
===================================================================
*** sync-mem-store-5.c (revision 0)
--- sync-mem-store-5.c (revision 0)
***************
*** 0 ****
--- 1,32 ----
+ /* Test __sync_mem routines for existence and proper execution on 16 byte
+ values with each valid memory model. */
+ /* { dg-do run } */
+ /* { dg-require-effective-target sync_int_128 } */
+ /* { dg-options "-mcx16" { target { x86_64-*-* } } } */
+
+ /* Test the execution of the __sync_mem_store builtin for a 16 byte value. */
+
+ extern void abort(void);
+
+ __int128_t v, count;
+
+ main ()
+ {
+ v = 0;
+ count = 0;
+
+ __sync_mem_store (&v, count + 1, __SYNC_MEM_RELAXED);
+ if (v != ++count)
+ abort ();
+
+ __sync_mem_store (&v, count + 1, __SYNC_MEM_RELEASE);
+ if (v != ++count)
+ abort ();
+
+ __sync_mem_store (&v, count + 1, __SYNC_MEM_SEQ_CST);
+ if (v != ++count)
+ abort ();
+
+ return 0;
+ }
+
^ permalink raw reply [flat|nested] 2+ messages in thread
* Re: [cxx-mem-model] __sync_mem builtin support patch 3/3 - testcases
2011-07-27 6:33 [cxx-mem-model] __sync_mem builtin support patch 3/3 - testcases Andrew MacLeod
@ 2011-07-27 16:18 ` Richard Henderson
0 siblings, 0 replies; 2+ messages in thread
From: Richard Henderson @ 2011-07-27 16:18 UTC (permalink / raw)
To: Andrew MacLeod; +Cc: gcc-patches, Aldy Hernandez
On 07/26/2011 06:20 PM, Andrew MacLeod wrote:
> * gcc.dg/sync-mem-{1-5}.c: Remove.
> * gcc.dg/sync-mem.h: Remove.
> * gcc.dg/sync-mem-compare-exchange-{1-5}.c: New functional tests.
> * gcc.dg/sync-mem-exchange-{1-5}.c: New functional tests.
> * gcc.dg/sync-mem-fence.c: New functional tests.
> * gcc.dg/sync-mem-fetch-*-{1-5}.c: New functional tests.
> * gcc.dg/sync-mem-flag.c: New functional tests.
> * gcc.dg/sync-mem-invalid.c: Add new invalid combinations.
> * gcc.dg/sync-mem-load-{1-5}.c: New functional tests.
> * gcc.dg/sync-mem-store-{1-5}.c: New functional tests.
Ok, but as said earlier, don't commit the compare-exchange tests
until we fix the code.
r~
^ permalink raw reply [flat|nested] 2+ messages in thread
end of thread, other threads:[~2011-07-27 16:06 UTC | newest]
Thread overview: 2+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2011-07-27 6:33 [cxx-mem-model] __sync_mem builtin support patch 3/3 - testcases Andrew MacLeod
2011-07-27 16:18 ` Richard Henderson
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).