1/* -*-c-*- */
2
3#undef NEW
4#define NEW 3
5
6__attribute__ ((noinline))
7int FN(_bo)(TYPE *mem, TYPE *old_ret, TYPE old)
8{
9  *old_ret = old;
10  return __atomic_compare_exchange_n (mem, (void *)old_ret, NEW, 1, 2, 0);
11}
12
13__attribute__ ((noinline))
14void FN(_o)(TYPE *mem, TYPE *old_ret, TYPE old)
15{
16  *old_ret = old;
17  __atomic_compare_exchange_n (mem, (void *)old_ret, NEW, 1, 2, 0);
18  return;
19}
20
21__attribute__ ((noinline))
22int FN(_b)(TYPE *mem, TYPE old)
23{
24  return __atomic_compare_exchange_n (mem, (void *)&old, NEW, 1, 2, 0);
25}
26
27__attribute__ ((noinline))
28void FN()(TYPE *mem, TYPE old)
29{
30  __atomic_compare_exchange_n (mem, (void *)&old, NEW, 1, 2, 0);
31  return;
32}
33
34/* Const != 0 old value.  */
35__attribute__ ((noinline))
36int FN(_c1_bo)(TYPE *mem, TYPE *old_ret)
37{
38  *old_ret = 1;
39  return __atomic_compare_exchange_n (mem, (void *)old_ret, NEW, 1, 2, 0);
40}
41
42__attribute__ ((noinline))
43void FN(_c1_o)(TYPE *mem, TYPE *old_ret)
44{
45  *old_ret = 1;
46  __atomic_compare_exchange_n (mem, (void *)old_ret, NEW, 1, 2, 0);
47  return;
48}
49
50__attribute__ ((noinline))
51int FN(_c1_b)(TYPE *mem)
52{
53  TYPE old = 1;
54  return __atomic_compare_exchange_n (mem, (void *)&old, NEW, 1, 2, 0);
55}
56
57__attribute__ ((noinline))
58void FN(_c1)(TYPE *mem)
59{
60  TYPE old = 1;
61  __atomic_compare_exchange_n (mem, (void *)&old, NEW, 1, 2, 0);
62  return;
63}
64
65/* Const == 0 old value.  */
66__attribute__ ((noinline))
67int FN(_c0_bo)(TYPE *mem, TYPE *old_ret)
68{
69  *old_ret = 0;
70  return __atomic_compare_exchange_n (mem, (void *)old_ret, NEW, 1, 2, 0);
71}
72
73__attribute__ ((noinline))
74void FN(_c0_o)(TYPE *mem, TYPE *old_ret)
75{
76  *old_ret = 0;
77  __atomic_compare_exchange_n (mem, (void *)old_ret, NEW, 1, 2, 0);
78  return;
79}
80
81__attribute__ ((noinline))
82int FN(_c0_b)(TYPE *mem)
83{
84  TYPE old = 0;
85  return __atomic_compare_exchange_n (mem, (void *)&old, NEW, 1, 2, 0);
86}
87
88__attribute__ ((noinline))
89void FN(_c0)(TYPE *mem)
90{
91  TYPE old = 0;
92  __atomic_compare_exchange_n (mem, (void *)&old, NEW, 1, 2, 0);
93  return;
94}
95
96int FN(_validate_mem)(TYPE *mem, TYPE expected_mem)
97{
98  if (*mem != expected_mem)
99    {
100      fprintf(stderr, "  BAD: mem %d != expected mem %d\n",
101	      *mem, expected_mem);
102      return 1;
103    }
104
105  return 0;
106}
107
108int FN(_validate_rc)(int rc, int expected_rc)
109{
110  if (rc != expected_rc)
111    {
112      fprintf(stderr, "  BAD: rc %d != expected rc %d\n",
113	      rc, expected_rc);
114      return 1;
115    }
116
117  return 0;
118}
119
120int FN(_validate_old_ret)(int old_ret, int expected_old_ret)
121{
122  if (old_ret != expected_old_ret)
123    {
124      fprintf(stderr, "  BAD: old_ret %d != expected old_ret %d\n",
125	      old_ret, expected_old_ret);
126      return 1;
127    }
128
129  return 0;
130}
131
132int FN(_validate)(TYPE *mem, TYPE init_mem, TYPE old)
133{
134  int err_count = 0;
135  int rc;
136  TYPE expected_mem;
137  int expected_rc;
138  TYPE old_ret;
139  int failed;
140  const char *fname;
141
142  fprintf(stderr, "%s: init_mem %d @ %p\n", __FUNCTION__, init_mem, mem);
143  {
144    failed = 0;
145    old = 1;
146    *mem = init_mem;
147    expected_mem = (init_mem == old) ? NEW : *mem;
148    expected_rc = (init_mem == old);
149    fname = FNS(_bo);
150    rc = FN(_bo)(mem, &old_ret, old);
151    failed |= FN(_validate_rc)(rc, expected_rc);
152    failed |= FN(_validate_old_ret)(old_ret, init_mem);
153    failed |= FN(_validate_mem)(mem, expected_mem);
154    if (failed)
155      {
156	fprintf(stderr, "  FAIL: %s: near line %d\n", fname, __LINE__ - 3);
157	err_count++;
158      }
159  }
160  {
161    failed = 0;
162    old = 1;
163    *mem = init_mem;
164    expected_mem = (init_mem == old) ? NEW : *mem;
165    fname = FNS(_o);
166    FN(_o)(mem, &old_ret, old);
167    failed |= FN(_validate_old_ret)(old_ret, init_mem);
168    failed |= FN(_validate_mem)(mem, expected_mem);
169    if (failed)
170      {
171	fprintf(stderr, "  FAIL: %s: near line %d\n", fname, __LINE__ - 3);
172	err_count++;
173      }
174  }
175  {
176    failed = 0;
177    old = 1;
178    *mem = init_mem;
179    expected_mem = (init_mem == old) ? NEW : *mem;
180    expected_rc = (init_mem == old);
181    fname = FNS(_b);
182    rc = FN(_b)(mem, old);
183    failed |= FN(_validate_rc)(rc, expected_rc);
184    failed |= FN(_validate_mem)(mem, expected_mem);
185    if (failed)
186      {
187	fprintf(stderr, "  FAIL: %s: near line %d\n", fname, __LINE__ - 3);
188	err_count++;
189      }
190  }
191  {
192    failed = 0;
193    old = 1;
194    *mem = init_mem;
195    expected_mem = (init_mem == old) ? NEW : *mem;
196    fname = FNS();
197    FN()(mem, old);
198    failed |= FN(_validate_mem)(mem, expected_mem);
199    if (failed)
200      {
201	fprintf(stderr, "  FAIL: %s: near line %d\n", fname, __LINE__ - 3);
202	err_count++;
203      }
204  }
205  {
206    failed = 0;
207    old = 1;
208    *mem = init_mem;
209    expected_mem = (init_mem == old) ? NEW : *mem;
210    expected_rc = (init_mem == old);
211    fname = FNS(_c1_bo);
212    rc = FN(_c1_bo)(mem, &old_ret);
213    failed |= FN(_validate_rc)(rc, expected_rc);
214    failed |= FN(_validate_old_ret)(old_ret, init_mem);
215    failed |= FN(_validate_mem)(mem, expected_mem);
216    if (failed)
217      {
218	fprintf(stderr, "  FAIL: %s: near line %d\n", fname, __LINE__ - 3);
219	err_count++;
220      }
221  }
222  {
223    failed = 0;
224    old = 1;
225    *mem = init_mem;
226    expected_mem = (init_mem == old) ? NEW : *mem;
227    fname = FNS(_c1_o);
228    FN(_c1_o)(mem, &old_ret);
229    failed |= FN(_validate_old_ret)(old_ret, init_mem);
230    failed |= FN(_validate_mem)(mem, expected_mem);
231    if (failed)
232      {
233	fprintf(stderr, "  FAIL: %s: near line %d\n", fname, __LINE__ - 3);
234	err_count++;
235      }
236  }
237  {
238    failed = 0;
239    old = 1;
240    *mem = init_mem;
241    expected_mem = (init_mem == old) ? NEW : *mem;
242    expected_rc = (init_mem == old);
243    fname = FNS(_c1_b);
244    rc = FN(_c1_b)(mem);
245    failed |= FN(_validate_rc)(rc, expected_rc);
246    failed |= FN(_validate_mem)(mem, expected_mem);
247    if (failed)
248      {
249	fprintf(stderr, "  FAIL: %s: near line %d\n", fname, __LINE__ - 3);
250	err_count++;
251      }
252  }
253  {
254    failed = 0;
255    old = 1;
256    *mem = init_mem;
257    expected_mem = (init_mem == old) ? NEW : *mem;
258    fname = FNS(_c1);
259    FN(_c1)(mem);
260    failed |= FN(_validate_mem)(mem, expected_mem);
261    if (failed)
262      {
263	fprintf(stderr, "  FAIL: %s: near line %d\n", fname, __LINE__ - 3);
264	err_count++;
265      }
266  }
267  {
268    failed = 0;
269    old = 0;
270    *mem = init_mem;
271    expected_mem = (init_mem == old) ? NEW : *mem;
272    expected_rc = (init_mem == old);
273    fname = FNS(_c0_bo);
274    rc = FN(_c0_bo)(mem, &old_ret);
275    failed |= FN(_validate_rc)(rc, expected_rc);
276    failed |= FN(_validate_old_ret)(old_ret, init_mem);
277    failed |= FN(_validate_mem)(mem, expected_mem);
278    if (failed)
279      {
280	fprintf(stderr, "  FAIL: %s: near line %d\n", fname, __LINE__ - 3);
281	err_count++;
282      }
283  }
284  {
285    failed = 0;
286    old = 0;
287    *mem = init_mem;
288    expected_mem = (init_mem == old) ? NEW : *mem;
289    fname = FNS(_c0_o);
290    FN(_c0_o)(mem, &old_ret);
291    failed |= FN(_validate_old_ret)(old_ret, init_mem);
292    failed |= FN(_validate_mem)(mem, expected_mem);
293    if (failed)
294      {
295	fprintf(stderr, "  FAIL: %s: near line %d\n", fname, __LINE__ - 3);
296	err_count++;
297      }
298  }
299  {
300    failed = 0;
301    old = 0;
302    *mem = init_mem;
303    expected_mem = (init_mem == old) ? NEW : *mem;
304    expected_rc = (init_mem == old);
305    fname = FNS(_c0_b);
306    rc = FN(_c0_b)(mem);
307    failed |= FN(_validate_rc)(rc, expected_rc);
308    failed |= FN(_validate_mem)(mem, expected_mem);
309    if (failed)
310      {
311	fprintf(stderr, "  FAIL: %s: near line %d\n", fname, __LINE__ - 3);
312	err_count++;
313      }
314  }
315  {
316    failed = 0;
317    old = 0;
318    *mem = init_mem;
319    expected_mem = (init_mem == old) ? NEW : *mem;
320    fname = FNS(_c0);
321    FN(_c0)(mem);
322    failed |= FN(_validate_mem)(mem, expected_mem);
323    if (failed)
324      {
325	fprintf(stderr, "  FAIL: %s: near line %d\n", fname, __LINE__ - 3);
326	err_count++;
327      }
328  }
329
330  return err_count;
331}
332
333#undef TYPE
334#undef MEM
335#undef FN
336#undef FNS
337