← Back to branch summary

~ubuntu-branches/ubuntu/quantal/libgc/quantal

« back to all changes in this revision

Viewing changes to libatomic_ops-1.2/tests/test_atomic_include.h

  • Committer: Bazaar Package Importer
  • Author(s): Christoph Egger
  • Date: 2011-02-19 12:19:56 UTC
  • mfrom: (1.3.2 upstream) (0.1.5 experimental)
  • mto: This revision was merged to the branch mainline in revision 14.
  • Revision ID: james.westby@ubuntu.com-20110219121956-67rb69xlt5nud3v2
Tags: 1:7.1-5
Upload to unstable

Show diffs side-by-side

added added

removed removed

Lines of Context:
libatomic_ops-1.2/tests/test_atomic_include.h
 
1
/*
 
2
 * Copyright (c) 2003 by Hewlett-Packard Company.  All rights reserved.
 
3
 *
 
4
 * This file is covered by the GNU general public license, version 2.
 
5
 * see doc/COPYING for details.
 
6
 */
 
7
 
 
8
void test_atomic(void);
 
9
void test_atomic_release(void);
 
10
void test_atomic_acquire(void);
 
11
void test_atomic_read(void);
 
12
void test_atomic_write(void);
 
13
void test_atomic_full(void);
 
14
void test_atomic_release_write(void);
 
15
void test_atomic_acquire_read(void);
 
16
 
 
17
/* Some basic sanity tests.  These do not test the barrier semantics. */
 
18
 
 
19
#undef TA_assert
 
20
#define TA_assert(e) \
 
21
  if (!(e)) { fprintf(stderr, "Assertion failed %s:%d (barrier: )\n", \
 
22
                    __FILE__, __LINE__), exit(1); }
 
23
 
 
24
#undef MISSING
 
25
#define MISSING(name) \
 
26
  fprintf(stderr, "Missing: %s\n", #name "")
 
27
 
 
28
void test_atomic(void)
 
29
{
 
30
  AO_t x;
 
31
  unsigned char b;
 
32
  unsigned short s;
 
33
  unsigned int zz;
 
34
# if defined(AO_HAVE_test_and_set)
 
35
    AO_TS_t z = AO_TS_INITIALIZER;
 
36
# endif
 
37
# if defined(AO_HAVE_double_t)
 
38
    AO_double_t w;
 
39
    w.AO_val1 = 0;
 
40
    w.AO_val2 = 0;
 
41
# endif
 
42
 
 
43
# if defined(AO_HAVE_nop)
 
44
    AO_nop();
 
45
# else
 
46
    MISSING(AO_nop);
 
47
# endif
 
48
# if defined(AO_HAVE_store)
 
49
    AO_store(&x, 13);
 
50
    TA_assert (x == 13);
 
51
# else
 
52
    MISSING(AO_store);
 
53
    x = 13;
 
54
# endif
 
55
# if defined(AO_HAVE_load)
 
56
    TA_assert(AO_load(&x) == 13);
 
57
# else
 
58
    MISSING(AO_load);
 
59
# endif
 
60
# if defined(AO_HAVE_test_and_set)
 
61
    assert(AO_test_and_set(&z) == AO_TS_CLEAR);
 
62
    assert(AO_test_and_set(&z) == AO_TS_SET);
 
63
    assert(AO_test_and_set(&z) == AO_TS_SET);
 
64
    AO_CLEAR(&z);
 
65
# else
 
66
    MISSING(AO_test_and_set);
 
67
# endif
 
68
# if defined(AO_HAVE_fetch_and_add)
 
69
    TA_assert(AO_fetch_and_add(&x, 42) == 13);
 
70
    TA_assert(AO_fetch_and_add(&x, -42) == 55);
 
71
# else
 
72
    MISSING(AO_fetch_and_add);
 
73
# endif
 
74
# if defined(AO_HAVE_fetch_and_add1)
 
75
    TA_assert(AO_fetch_and_add1(&x) == 13);
 
76
# else
 
77
    MISSING(AO_fetch_and_add1);
 
78
    ++x;
 
79
# endif
 
80
# if defined(AO_HAVE_fetch_and_sub1)
 
81
    TA_assert(AO_fetch_and_sub1(&x) == 14);
 
82
# else
 
83
    MISSING(AO_fetch_and_sub1);
 
84
    --x;
 
85
# endif
 
86
# if defined(AO_HAVE_short_store)
 
87
    AO_short_store(&s, 13);
 
88
# else
 
89
    MISSING(AO_short_store);
 
90
    s = 13;
 
91
# endif
 
92
# if defined(AO_HAVE_short_load)
 
93
    TA_assert(AO_short_load(&s) == 13);
 
94
# else
 
95
    MISSING(AO_short_load);
 
96
# endif
 
97
# if defined(AO_HAVE_short_fetch_and_add)
 
98
    TA_assert(AO_short_fetch_and_add(&s, 42) == 13);
 
99
    TA_assert(AO_short_fetch_and_add(&s, -42) == 55);
 
100
# else
 
101
    MISSING(AO_short_fetch_and_add);
 
102
# endif
 
103
# if defined(AO_HAVE_short_fetch_and_add1)
 
104
    TA_assert(AO_short_fetch_and_add1(&s) == 13);
 
105
# else
 
106
    MISSING(AO_short_fetch_and_add1);
 
107
    ++s;
 
108
# endif
 
109
# if defined(AO_HAVE_short_fetch_and_sub1)
 
110
    TA_assert(AO_short_fetch_and_sub1(&s) == 14);
 
111
# else
 
112
    MISSING(AO_short_fetch_and_sub1);
 
113
    --s;
 
114
# endif
 
115
# if defined(AO_HAVE_char_store)
 
116
    AO_char_store(&b, 13);
 
117
# else
 
118
    MISSING(AO_char_store);
 
119
    b = 13;
 
120
# endif
 
121
# if defined(AO_HAVE_char_load)
 
122
    TA_assert(AO_char_load(&b) == 13);
 
123
# else
 
124
    MISSING(AO_char_load);
 
125
# endif
 
126
# if defined(AO_HAVE_char_fetch_and_add)
 
127
    TA_assert(AO_char_fetch_and_add(&b, 42) == 13);
 
128
    TA_assert(AO_char_fetch_and_add(&b, -42) == 55);
 
129
# else
 
130
    MISSING(AO_char_fetch_and_add);
 
131
# endif
 
132
# if defined(AO_HAVE_char_fetch_and_add1)
 
133
    TA_assert(AO_char_fetch_and_add1(&b) == 13);
 
134
# else
 
135
    MISSING(AO_char_fetch_and_add1);
 
136
    ++b;
 
137
# endif
 
138
# if defined(AO_HAVE_char_fetch_and_sub1)
 
139
    TA_assert(AO_char_fetch_and_sub1(&b) == 14);
 
140
# else
 
141
    MISSING(AO_char_fetch_and_sub1);
 
142
    --b;
 
143
# endif
 
144
# if defined(AO_HAVE_int_store)
 
145
    AO_int_store(&zz, 13);
 
146
# else
 
147
    MISSING(AO_int_store);
 
148
    zz = 13;
 
149
# endif
 
150
# if defined(AO_HAVE_int_load)
 
151
    TA_assert(AO_int_load(&zz) == 13);
 
152
# else
 
153
    MISSING(AO_int_load);
 
154
# endif
 
155
# if defined(AO_HAVE_int_fetch_and_add)
 
156
    TA_assert(AO_int_fetch_and_add(&zz, 42) == 13);
 
157
    TA_assert(AO_int_fetch_and_add(&zz, -42) == 55);
 
158
# else
 
159
    MISSING(AO_int_fetch_and_add);
 
160
# endif
 
161
# if defined(AO_HAVE_int_fetch_and_add1)
 
162
    TA_assert(AO_int_fetch_and_add1(&zz) == 13);
 
163
# else
 
164
    MISSING(AO_int_fetch_and_add1);
 
165
    ++zz;
 
166
# endif
 
167
# if defined(AO_HAVE_int_fetch_and_sub1)
 
168
    TA_assert(AO_int_fetch_and_sub1(&zz) == 14);
 
169
# else
 
170
    MISSING(AO_int_fetch_and_sub1);
 
171
    --zz;
 
172
# endif
 
173
# if defined(AO_HAVE_compare_and_swap)
 
174
    TA_assert(!AO_compare_and_swap(&x, 14, 42));
 
175
    TA_assert(x == 13);
 
176
    TA_assert(AO_compare_and_swap(&x, 13, 42));
 
177
    TA_assert(x == 42);
 
178
# else
 
179
    MISSING(AO_compare_and_swap);
 
180
# endif
 
181
# if defined(AO_HAVE_or)
 
182
    AO_or(&x, 66);
 
183
    TA_assert(x == 106);
 
184
# else
 
185
    MISSING(AO_or);
 
186
    x |= 34;
 
187
# endif
 
188
# if defined(AO_HAVE_compare_double_and_swap_double)
 
189
    TA_assert(!AO_compare_double_and_swap_double(&w, 17, 42, 12, 13));
 
190
    TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
 
191
    TA_assert(AO_compare_double_and_swap_double(&w, 0, 0, 12, 13));
 
192
    TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
 
193
    TA_assert(AO_compare_double_and_swap_double(&w, 12, 13, 17, 42));
 
194
    TA_assert(w.AO_val1 == 17 && w.AO_val2 == 42);
 
195
    w.AO_val1 = 0; w.AO_val2 = 0;
 
196
# else
 
197
    MISSING(AO_compare_double_and_swap_double);
 
198
# endif
 
199
# if defined(AO_HAVE_compare_and_swap_double)
 
200
    TA_assert(!AO_compare_and_swap_double(&w, 17, 12, 13));
 
201
    TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
 
202
    TA_assert(AO_compare_and_swap_double(&w, 0, 12, 13));
 
203
    TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
 
204
    TA_assert(AO_compare_and_swap_double(&w, 12, 17, 42));
 
205
    TA_assert(w.AO_val1 == 17 && w.AO_val2 == 42);
 
206
# else
 
207
    MISSING(AO_compare_and_swap_double);
 
208
# endif
 
209
}
 
210
 
 
211
 
 
212
    
 
213
/*
 
214
 * Copyright (c) 2003 by Hewlett-Packard Company.  All rights reserved.
 
215
 *
 
216
 * This file is covered by the GNU general public license, version 2.
 
217
 * see doc/COPYING for details.
 
218
 */
 
219
 
 
220
/* Some basic sanity tests.  These do not test the barrier semantics. */
 
221
 
 
222
#undef TA_assert
 
223
#define TA_assert(e) \
 
224
  if (!(e)) { fprintf(stderr, "Assertion failed %s:%d (barrier: _release)\n", \
 
225
                    __FILE__, __LINE__), exit(1); }
 
226
 
 
227
#undef MISSING
 
228
#define MISSING(name) \
 
229
  fprintf(stderr, "Missing: %s\n", #name "_release")
 
230
 
 
231
void test_atomic_release(void)
 
232
{
 
233
  AO_t x;
 
234
  unsigned char b;
 
235
  unsigned short s;
 
236
  unsigned int zz;
 
237
# if defined(AO_HAVE_test_and_set_release)
 
238
    AO_TS_t z = AO_TS_INITIALIZER;
 
239
# endif
 
240
# if defined(AO_HAVE_double_t)
 
241
    AO_double_t w;
 
242
    w.AO_val1 = 0;
 
243
    w.AO_val2 = 0;
 
244
# endif
 
245
 
 
246
# if defined(AO_HAVE_nop_release)
 
247
    AO_nop_release();
 
248
# else
 
249
    MISSING(AO_nop);
 
250
# endif
 
251
# if defined(AO_HAVE_store_release)
 
252
    AO_store_release(&x, 13);
 
253
    TA_assert (x == 13);
 
254
# else
 
255
    MISSING(AO_store);
 
256
    x = 13;
 
257
# endif
 
258
# if defined(AO_HAVE_load_release)
 
259
    TA_assert(AO_load_release(&x) == 13);
 
260
# else
 
261
    MISSING(AO_load);
 
262
# endif
 
263
# if defined(AO_HAVE_test_and_set_release)
 
264
    assert(AO_test_and_set_release(&z) == AO_TS_CLEAR);
 
265
    assert(AO_test_and_set_release(&z) == AO_TS_SET);
 
266
    assert(AO_test_and_set_release(&z) == AO_TS_SET);
 
267
    AO_CLEAR(&z);
 
268
# else
 
269
    MISSING(AO_test_and_set);
 
270
# endif
 
271
# if defined(AO_HAVE_fetch_and_add_release)
 
272
    TA_assert(AO_fetch_and_add_release(&x, 42) == 13);
 
273
    TA_assert(AO_fetch_and_add_release(&x, -42) == 55);
 
274
# else
 
275
    MISSING(AO_fetch_and_add);
 
276
# endif
 
277
# if defined(AO_HAVE_fetch_and_add1_release)
 
278
    TA_assert(AO_fetch_and_add1_release(&x) == 13);
 
279
# else
 
280
    MISSING(AO_fetch_and_add1);
 
281
    ++x;
 
282
# endif
 
283
# if defined(AO_HAVE_fetch_and_sub1_release)
 
284
    TA_assert(AO_fetch_and_sub1_release(&x) == 14);
 
285
# else
 
286
    MISSING(AO_fetch_and_sub1);
 
287
    --x;
 
288
# endif
 
289
# if defined(AO_HAVE_short_store_release)
 
290
    AO_short_store_release(&s, 13);
 
291
# else
 
292
    MISSING(AO_short_store);
 
293
    s = 13;
 
294
# endif
 
295
# if defined(AO_HAVE_short_load_release)
 
296
    TA_assert(AO_short_load(&s) == 13);
 
297
# else
 
298
    MISSING(AO_short_load);
 
299
# endif
 
300
# if defined(AO_HAVE_short_fetch_and_add_release)
 
301
    TA_assert(AO_short_fetch_and_add_release(&s, 42) == 13);
 
302
    TA_assert(AO_short_fetch_and_add_release(&s, -42) == 55);
 
303
# else
 
304
    MISSING(AO_short_fetch_and_add);
 
305
# endif
 
306
# if defined(AO_HAVE_short_fetch_and_add1_release)
 
307
    TA_assert(AO_short_fetch_and_add1_release(&s) == 13);
 
308
# else
 
309
    MISSING(AO_short_fetch_and_add1);
 
310
    ++s;
 
311
# endif
 
312
# if defined(AO_HAVE_short_fetch_and_sub1_release)
 
313
    TA_assert(AO_short_fetch_and_sub1_release(&s) == 14);
 
314
# else
 
315
    MISSING(AO_short_fetch_and_sub1);
 
316
    --s;
 
317
# endif
 
318
# if defined(AO_HAVE_char_store_release)
 
319
    AO_char_store_release(&b, 13);
 
320
# else
 
321
    MISSING(AO_char_store);
 
322
    b = 13;
 
323
# endif
 
324
# if defined(AO_HAVE_char_load_release)
 
325
    TA_assert(AO_char_load(&b) == 13);
 
326
# else
 
327
    MISSING(AO_char_load);
 
328
# endif
 
329
# if defined(AO_HAVE_char_fetch_and_add_release)
 
330
    TA_assert(AO_char_fetch_and_add_release(&b, 42) == 13);
 
331
    TA_assert(AO_char_fetch_and_add_release(&b, -42) == 55);
 
332
# else
 
333
    MISSING(AO_char_fetch_and_add);
 
334
# endif
 
335
# if defined(AO_HAVE_char_fetch_and_add1_release)
 
336
    TA_assert(AO_char_fetch_and_add1_release(&b) == 13);
 
337
# else
 
338
    MISSING(AO_char_fetch_and_add1);
 
339
    ++b;
 
340
# endif
 
341
# if defined(AO_HAVE_char_fetch_and_sub1_release)
 
342
    TA_assert(AO_char_fetch_and_sub1_release(&b) == 14);
 
343
# else
 
344
    MISSING(AO_char_fetch_and_sub1);
 
345
    --b;
 
346
# endif
 
347
# if defined(AO_HAVE_int_store_release)
 
348
    AO_int_store_release(&zz, 13);
 
349
# else
 
350
    MISSING(AO_int_store);
 
351
    zz = 13;
 
352
# endif
 
353
# if defined(AO_HAVE_int_load_release)
 
354
    TA_assert(AO_int_load(&zz) == 13);
 
355
# else
 
356
    MISSING(AO_int_load);
 
357
# endif
 
358
# if defined(AO_HAVE_int_fetch_and_add_release)
 
359
    TA_assert(AO_int_fetch_and_add_release(&zz, 42) == 13);
 
360
    TA_assert(AO_int_fetch_and_add_release(&zz, -42) == 55);
 
361
# else
 
362
    MISSING(AO_int_fetch_and_add);
 
363
# endif
 
364
# if defined(AO_HAVE_int_fetch_and_add1_release)
 
365
    TA_assert(AO_int_fetch_and_add1_release(&zz) == 13);
 
366
# else
 
367
    MISSING(AO_int_fetch_and_add1);
 
368
    ++zz;
 
369
# endif
 
370
# if defined(AO_HAVE_int_fetch_and_sub1_release)
 
371
    TA_assert(AO_int_fetch_and_sub1_release(&zz) == 14);
 
372
# else
 
373
    MISSING(AO_int_fetch_and_sub1);
 
374
    --zz;
 
375
# endif
 
376
# if defined(AO_HAVE_compare_and_swap_release)
 
377
    TA_assert(!AO_compare_and_swap_release(&x, 14, 42));
 
378
    TA_assert(x == 13);
 
379
    TA_assert(AO_compare_and_swap_release(&x, 13, 42));
 
380
    TA_assert(x == 42);
 
381
# else
 
382
    MISSING(AO_compare_and_swap);
 
383
# endif
 
384
# if defined(AO_HAVE_or_release)
 
385
    AO_or_release(&x, 66);
 
386
    TA_assert(x == 106);
 
387
# else
 
388
    MISSING(AO_or);
 
389
    x |= 34;
 
390
# endif
 
391
# if defined(AO_HAVE_compare_double_and_swap_double_release)
 
392
    TA_assert(!AO_compare_double_and_swap_double_release(&w, 17, 42, 12, 13));
 
393
    TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
 
394
    TA_assert(AO_compare_double_and_swap_double_release(&w, 0, 0, 12, 13));
 
395
    TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
 
396
    TA_assert(AO_compare_double_and_swap_double_release(&w, 12, 13, 17, 42));
 
397
    TA_assert(w.AO_val1 == 17 && w.AO_val2 == 42);
 
398
    w.AO_val1 = 0; w.AO_val2 = 0;
 
399
# else
 
400
    MISSING(AO_compare_double_and_swap_double);
 
401
# endif
 
402
# if defined(AO_HAVE_compare_and_swap_double_release)
 
403
    TA_assert(!AO_compare_and_swap_double_release(&w, 17, 12, 13));
 
404
    TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
 
405
    TA_assert(AO_compare_and_swap_double_release(&w, 0, 12, 13));
 
406
    TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
 
407
    TA_assert(AO_compare_and_swap_double_release(&w, 12, 17, 42));
 
408
    TA_assert(w.AO_val1 == 17 && w.AO_val2 == 42);
 
409
# else
 
410
    MISSING(AO_compare_and_swap_double);
 
411
# endif
 
412
}
 
413
 
 
414
 
 
415
    
 
416
/*
 
417
 * Copyright (c) 2003 by Hewlett-Packard Company.  All rights reserved.
 
418
 *
 
419
 * This file is covered by the GNU general public license, version 2.
 
420
 * see doc/COPYING for details.
 
421
 */
 
422
 
 
423
/* Some basic sanity tests.  These do not test the barrier semantics. */
 
424
 
 
425
#undef TA_assert
 
426
#define TA_assert(e) \
 
427
  if (!(e)) { fprintf(stderr, "Assertion failed %s:%d (barrier: _acquire)\n", \
 
428
                    __FILE__, __LINE__), exit(1); }
 
429
 
 
430
#undef MISSING
 
431
#define MISSING(name) \
 
432
  fprintf(stderr, "Missing: %s\n", #name "_acquire")
 
433
 
 
434
void test_atomic_acquire(void)
 
435
{
 
436
  AO_t x;
 
437
  unsigned char b;
 
438
  unsigned short s;
 
439
  unsigned int zz;
 
440
# if defined(AO_HAVE_test_and_set_acquire)
 
441
    AO_TS_t z = AO_TS_INITIALIZER;
 
442
# endif
 
443
# if defined(AO_HAVE_double_t)
 
444
    AO_double_t w;
 
445
    w.AO_val1 = 0;
 
446
    w.AO_val2 = 0;
 
447
# endif
 
448
 
 
449
# if defined(AO_HAVE_nop_acquire)
 
450
    AO_nop_acquire();
 
451
# else
 
452
    MISSING(AO_nop);
 
453
# endif
 
454
# if defined(AO_HAVE_store_acquire)
 
455
    AO_store_acquire(&x, 13);
 
456
    TA_assert (x == 13);
 
457
# else
 
458
    MISSING(AO_store);
 
459
    x = 13;
 
460
# endif
 
461
# if defined(AO_HAVE_load_acquire)
 
462
    TA_assert(AO_load_acquire(&x) == 13);
 
463
# else
 
464
    MISSING(AO_load);
 
465
# endif
 
466
# if defined(AO_HAVE_test_and_set_acquire)
 
467
    assert(AO_test_and_set_acquire(&z) == AO_TS_CLEAR);
 
468
    assert(AO_test_and_set_acquire(&z) == AO_TS_SET);
 
469
    assert(AO_test_and_set_acquire(&z) == AO_TS_SET);
 
470
    AO_CLEAR(&z);
 
471
# else
 
472
    MISSING(AO_test_and_set);
 
473
# endif
 
474
# if defined(AO_HAVE_fetch_and_add_acquire)
 
475
    TA_assert(AO_fetch_and_add_acquire(&x, 42) == 13);
 
476
    TA_assert(AO_fetch_and_add_acquire(&x, -42) == 55);
 
477
# else
 
478
    MISSING(AO_fetch_and_add);
 
479
# endif
 
480
# if defined(AO_HAVE_fetch_and_add1_acquire)
 
481
    TA_assert(AO_fetch_and_add1_acquire(&x) == 13);
 
482
# else
 
483
    MISSING(AO_fetch_and_add1);
 
484
    ++x;
 
485
# endif
 
486
# if defined(AO_HAVE_fetch_and_sub1_acquire)
 
487
    TA_assert(AO_fetch_and_sub1_acquire(&x) == 14);
 
488
# else
 
489
    MISSING(AO_fetch_and_sub1);
 
490
    --x;
 
491
# endif
 
492
# if defined(AO_HAVE_short_store_acquire)
 
493
    AO_short_store_acquire(&s, 13);
 
494
# else
 
495
    MISSING(AO_short_store);
 
496
    s = 13;
 
497
# endif
 
498
# if defined(AO_HAVE_short_load_acquire)
 
499
    TA_assert(AO_short_load(&s) == 13);
 
500
# else
 
501
    MISSING(AO_short_load);
 
502
# endif
 
503
# if defined(AO_HAVE_short_fetch_and_add_acquire)
 
504
    TA_assert(AO_short_fetch_and_add_acquire(&s, 42) == 13);
 
505
    TA_assert(AO_short_fetch_and_add_acquire(&s, -42) == 55);
 
506
# else
 
507
    MISSING(AO_short_fetch_and_add);
 
508
# endif
 
509
# if defined(AO_HAVE_short_fetch_and_add1_acquire)
 
510
    TA_assert(AO_short_fetch_and_add1_acquire(&s) == 13);
 
511
# else
 
512
    MISSING(AO_short_fetch_and_add1);
 
513
    ++s;
 
514
# endif
 
515
# if defined(AO_HAVE_short_fetch_and_sub1_acquire)
 
516
    TA_assert(AO_short_fetch_and_sub1_acquire(&s) == 14);
 
517
# else
 
518
    MISSING(AO_short_fetch_and_sub1);
 
519
    --s;
 
520
# endif
 
521
# if defined(AO_HAVE_char_store_acquire)
 
522
    AO_char_store_acquire(&b, 13);
 
523
# else
 
524
    MISSING(AO_char_store);
 
525
    b = 13;
 
526
# endif
 
527
# if defined(AO_HAVE_char_load_acquire)
 
528
    TA_assert(AO_char_load(&b) == 13);
 
529
# else
 
530
    MISSING(AO_char_load);
 
531
# endif
 
532
# if defined(AO_HAVE_char_fetch_and_add_acquire)
 
533
    TA_assert(AO_char_fetch_and_add_acquire(&b, 42) == 13);
 
534
    TA_assert(AO_char_fetch_and_add_acquire(&b, -42) == 55);
 
535
# else
 
536
    MISSING(AO_char_fetch_and_add);
 
537
# endif
 
538
# if defined(AO_HAVE_char_fetch_and_add1_acquire)
 
539
    TA_assert(AO_char_fetch_and_add1_acquire(&b) == 13);
 
540
# else
 
541
    MISSING(AO_char_fetch_and_add1);
 
542
    ++b;
 
543
# endif
 
544
# if defined(AO_HAVE_char_fetch_and_sub1_acquire)
 
545
    TA_assert(AO_char_fetch_and_sub1_acquire(&b) == 14);
 
546
# else
 
547
    MISSING(AO_char_fetch_and_sub1);
 
548
    --b;
 
549
# endif
 
550
# if defined(AO_HAVE_int_store_acquire)
 
551
    AO_int_store_acquire(&zz, 13);
 
552
# else
 
553
    MISSING(AO_int_store);
 
554
    zz = 13;
 
555
# endif
 
556
# if defined(AO_HAVE_int_load_acquire)
 
557
    TA_assert(AO_int_load(&zz) == 13);
 
558
# else
 
559
    MISSING(AO_int_load);
 
560
# endif
 
561
# if defined(AO_HAVE_int_fetch_and_add_acquire)
 
562
    TA_assert(AO_int_fetch_and_add_acquire(&zz, 42) == 13);
 
563
    TA_assert(AO_int_fetch_and_add_acquire(&zz, -42) == 55);
 
564
# else
 
565
    MISSING(AO_int_fetch_and_add);
 
566
# endif
 
567
# if defined(AO_HAVE_int_fetch_and_add1_acquire)
 
568
    TA_assert(AO_int_fetch_and_add1_acquire(&zz) == 13);
 
569
# else
 
570
    MISSING(AO_int_fetch_and_add1);
 
571
    ++zz;
 
572
# endif
 
573
# if defined(AO_HAVE_int_fetch_and_sub1_acquire)
 
574
    TA_assert(AO_int_fetch_and_sub1_acquire(&zz) == 14);
 
575
# else
 
576
    MISSING(AO_int_fetch_and_sub1);
 
577
    --zz;
 
578
# endif
 
579
# if defined(AO_HAVE_compare_and_swap_acquire)
 
580
    TA_assert(!AO_compare_and_swap_acquire(&x, 14, 42));
 
581
    TA_assert(x == 13);
 
582
    TA_assert(AO_compare_and_swap_acquire(&x, 13, 42));
 
583
    TA_assert(x == 42);
 
584
# else
 
585
    MISSING(AO_compare_and_swap);
 
586
# endif
 
587
# if defined(AO_HAVE_or_acquire)
 
588
    AO_or_acquire(&x, 66);
 
589
    TA_assert(x == 106);
 
590
# else
 
591
    MISSING(AO_or);
 
592
    x |= 34;
 
593
# endif
 
594
# if defined(AO_HAVE_compare_double_and_swap_double_acquire)
 
595
    TA_assert(!AO_compare_double_and_swap_double_acquire(&w, 17, 42, 12, 13));
 
596
    TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
 
597
    TA_assert(AO_compare_double_and_swap_double_acquire(&w, 0, 0, 12, 13));
 
598
    TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
 
599
    TA_assert(AO_compare_double_and_swap_double_acquire(&w, 12, 13, 17, 42));
 
600
    TA_assert(w.AO_val1 == 17 && w.AO_val2 == 42);
 
601
    w.AO_val1 = 0; w.AO_val2 = 0;
 
602
# else
 
603
    MISSING(AO_compare_double_and_swap_double);
 
604
# endif
 
605
# if defined(AO_HAVE_compare_and_swap_double_acquire)
 
606
    TA_assert(!AO_compare_and_swap_double_acquire(&w, 17, 12, 13));
 
607
    TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
 
608
    TA_assert(AO_compare_and_swap_double_acquire(&w, 0, 12, 13));
 
609
    TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
 
610
    TA_assert(AO_compare_and_swap_double_acquire(&w, 12, 17, 42));
 
611
    TA_assert(w.AO_val1 == 17 && w.AO_val2 == 42);
 
612
# else
 
613
    MISSING(AO_compare_and_swap_double);
 
614
# endif
 
615
}
 
616
 
 
617
 
 
618
    
 
619
/*
 
620
 * Copyright (c) 2003 by Hewlett-Packard Company.  All rights reserved.
 
621
 *
 
622
 * This file is covered by the GNU general public license, version 2.
 
623
 * see doc/COPYING for details.
 
624
 */
 
625
 
 
626
/* Some basic sanity tests.  These do not test the barrier semantics. */
 
627
 
 
628
#undef TA_assert
 
629
#define TA_assert(e) \
 
630
  if (!(e)) { fprintf(stderr, "Assertion failed %s:%d (barrier: _read)\n", \
 
631
                    __FILE__, __LINE__), exit(1); }
 
632
 
 
633
#undef MISSING
 
634
#define MISSING(name) \
 
635
  fprintf(stderr, "Missing: %s\n", #name "_read")
 
636
 
 
637
void test_atomic_read(void)
 
638
{
 
639
  AO_t x;
 
640
  unsigned char b;
 
641
  unsigned short s;
 
642
  unsigned int zz;
 
643
# if defined(AO_HAVE_test_and_set_read)
 
644
    AO_TS_t z = AO_TS_INITIALIZER;
 
645
# endif
 
646
# if defined(AO_HAVE_double_t)
 
647
    AO_double_t w;
 
648
    w.AO_val1 = 0;
 
649
    w.AO_val2 = 0;
 
650
# endif
 
651
 
 
652
# if defined(AO_HAVE_nop_read)
 
653
    AO_nop_read();
 
654
# else
 
655
    MISSING(AO_nop);
 
656
# endif
 
657
# if defined(AO_HAVE_store_read)
 
658
    AO_store_read(&x, 13);
 
659
    TA_assert (x == 13);
 
660
# else
 
661
    MISSING(AO_store);
 
662
    x = 13;
 
663
# endif
 
664
# if defined(AO_HAVE_load_read)
 
665
    TA_assert(AO_load_read(&x) == 13);
 
666
# else
 
667
    MISSING(AO_load);
 
668
# endif
 
669
# if defined(AO_HAVE_test_and_set_read)
 
670
    assert(AO_test_and_set_read(&z) == AO_TS_CLEAR);
 
671
    assert(AO_test_and_set_read(&z) == AO_TS_SET);
 
672
    assert(AO_test_and_set_read(&z) == AO_TS_SET);
 
673
    AO_CLEAR(&z);
 
674
# else
 
675
    MISSING(AO_test_and_set);
 
676
# endif
 
677
# if defined(AO_HAVE_fetch_and_add_read)
 
678
    TA_assert(AO_fetch_and_add_read(&x, 42) == 13);
 
679
    TA_assert(AO_fetch_and_add_read(&x, -42) == 55);
 
680
# else
 
681
    MISSING(AO_fetch_and_add);
 
682
# endif
 
683
# if defined(AO_HAVE_fetch_and_add1_read)
 
684
    TA_assert(AO_fetch_and_add1_read(&x) == 13);
 
685
# else
 
686
    MISSING(AO_fetch_and_add1);
 
687
    ++x;
 
688
# endif
 
689
# if defined(AO_HAVE_fetch_and_sub1_read)
 
690
    TA_assert(AO_fetch_and_sub1_read(&x) == 14);
 
691
# else
 
692
    MISSING(AO_fetch_and_sub1);
 
693
    --x;
 
694
# endif
 
695
# if defined(AO_HAVE_short_store_read)
 
696
    AO_short_store_read(&s, 13);
 
697
# else
 
698
    MISSING(AO_short_store);
 
699
    s = 13;
 
700
# endif
 
701
# if defined(AO_HAVE_short_load_read)
 
702
    TA_assert(AO_short_load(&s) == 13);
 
703
# else
 
704
    MISSING(AO_short_load);
 
705
# endif
 
706
# if defined(AO_HAVE_short_fetch_and_add_read)
 
707
    TA_assert(AO_short_fetch_and_add_read(&s, 42) == 13);
 
708
    TA_assert(AO_short_fetch_and_add_read(&s, -42) == 55);
 
709
# else
 
710
    MISSING(AO_short_fetch_and_add);
 
711
# endif
 
712
# if defined(AO_HAVE_short_fetch_and_add1_read)
 
713
    TA_assert(AO_short_fetch_and_add1_read(&s) == 13);
 
714
# else
 
715
    MISSING(AO_short_fetch_and_add1);
 
716
    ++s;
 
717
# endif
 
718
# if defined(AO_HAVE_short_fetch_and_sub1_read)
 
719
    TA_assert(AO_short_fetch_and_sub1_read(&s) == 14);
 
720
# else
 
721
    MISSING(AO_short_fetch_and_sub1);
 
722
    --s;
 
723
# endif
 
724
# if defined(AO_HAVE_char_store_read)
 
725
    AO_char_store_read(&b, 13);
 
726
# else
 
727
    MISSING(AO_char_store);
 
728
    b = 13;
 
729
# endif
 
730
# if defined(AO_HAVE_char_load_read)
 
731
    TA_assert(AO_char_load(&b) == 13);
 
732
# else
 
733
    MISSING(AO_char_load);
 
734
# endif
 
735
# if defined(AO_HAVE_char_fetch_and_add_read)
 
736
    TA_assert(AO_char_fetch_and_add_read(&b, 42) == 13);
 
737
    TA_assert(AO_char_fetch_and_add_read(&b, -42) == 55);
 
738
# else
 
739
    MISSING(AO_char_fetch_and_add);
 
740
# endif
 
741
# if defined(AO_HAVE_char_fetch_and_add1_read)
 
742
    TA_assert(AO_char_fetch_and_add1_read(&b) == 13);
 
743
# else
 
744
    MISSING(AO_char_fetch_and_add1);
 
745
    ++b;
 
746
# endif
 
747
# if defined(AO_HAVE_char_fetch_and_sub1_read)
 
748
    TA_assert(AO_char_fetch_and_sub1_read(&b) == 14);
 
749
# else
 
750
    MISSING(AO_char_fetch_and_sub1);
 
751
    --b;
 
752
# endif
 
753
# if defined(AO_HAVE_int_store_read)
 
754
    AO_int_store_read(&zz, 13);
 
755
# else
 
756
    MISSING(AO_int_store);
 
757
    zz = 13;
 
758
# endif
 
759
# if defined(AO_HAVE_int_load_read)
 
760
    TA_assert(AO_int_load(&zz) == 13);
 
761
# else
 
762
    MISSING(AO_int_load);
 
763
# endif
 
764
# if defined(AO_HAVE_int_fetch_and_add_read)
 
765
    TA_assert(AO_int_fetch_and_add_read(&zz, 42) == 13);
 
766
    TA_assert(AO_int_fetch_and_add_read(&zz, -42) == 55);
 
767
# else
 
768
    MISSING(AO_int_fetch_and_add);
 
769
# endif
 
770
# if defined(AO_HAVE_int_fetch_and_add1_read)
 
771
    TA_assert(AO_int_fetch_and_add1_read(&zz) == 13);
 
772
# else
 
773
    MISSING(AO_int_fetch_and_add1);
 
774
    ++zz;
 
775
# endif
 
776
# if defined(AO_HAVE_int_fetch_and_sub1_read)
 
777
    TA_assert(AO_int_fetch_and_sub1_read(&zz) == 14);
 
778
# else
 
779
    MISSING(AO_int_fetch_and_sub1);
 
780
    --zz;
 
781
# endif
 
782
# if defined(AO_HAVE_compare_and_swap_read)
 
783
    TA_assert(!AO_compare_and_swap_read(&x, 14, 42));
 
784
    TA_assert(x == 13);
 
785
    TA_assert(AO_compare_and_swap_read(&x, 13, 42));
 
786
    TA_assert(x == 42);
 
787
# else
 
788
    MISSING(AO_compare_and_swap);
 
789
# endif
 
790
# if defined(AO_HAVE_or_read)
 
791
    AO_or_read(&x, 66);
 
792
    TA_assert(x == 106);
 
793
# else
 
794
    MISSING(AO_or);
 
795
    x |= 34;
 
796
# endif
 
797
# if defined(AO_HAVE_compare_double_and_swap_double_read)
 
798
    TA_assert(!AO_compare_double_and_swap_double_read(&w, 17, 42, 12, 13));
 
799
    TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
 
800
    TA_assert(AO_compare_double_and_swap_double_read(&w, 0, 0, 12, 13));
 
801
    TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
 
802
    TA_assert(AO_compare_double_and_swap_double_read(&w, 12, 13, 17, 42));
 
803
    TA_assert(w.AO_val1 == 17 && w.AO_val2 == 42);
 
804
    w.AO_val1 = 0; w.AO_val2 = 0;
 
805
# else
 
806
    MISSING(AO_compare_double_and_swap_double);
 
807
# endif
 
808
# if defined(AO_HAVE_compare_and_swap_double_read)
 
809
    TA_assert(!AO_compare_and_swap_double_read(&w, 17, 12, 13));
 
810
    TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
 
811
    TA_assert(AO_compare_and_swap_double_read(&w, 0, 12, 13));
 
812
    TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
 
813
    TA_assert(AO_compare_and_swap_double_read(&w, 12, 17, 42));
 
814
    TA_assert(w.AO_val1 == 17 && w.AO_val2 == 42);
 
815
# else
 
816
    MISSING(AO_compare_and_swap_double);
 
817
# endif
 
818
}
 
819
 
 
820
 
 
821
    
 
822
/*
 
823
 * Copyright (c) 2003 by Hewlett-Packard Company.  All rights reserved.
 
824
 *
 
825
 * This file is covered by the GNU general public license, version 2.
 
826
 * see doc/COPYING for details.
 
827
 */
 
828
 
 
829
/* Some basic sanity tests.  These do not test the barrier semantics. */
 
830
 
 
831
#undef TA_assert
 
832
#define TA_assert(e) \
 
833
  if (!(e)) { fprintf(stderr, "Assertion failed %s:%d (barrier: _write)\n", \
 
834
                    __FILE__, __LINE__), exit(1); }
 
835
 
 
836
#undef MISSING
 
837
#define MISSING(name) \
 
838
  fprintf(stderr, "Missing: %s\n", #name "_write")
 
839
 
 
840
void test_atomic_write(void)
 
841
{
 
842
  AO_t x;
 
843
  unsigned char b;
 
844
  unsigned short s;
 
845
  unsigned int zz;
 
846
# if defined(AO_HAVE_test_and_set_write)
 
847
    AO_TS_t z = AO_TS_INITIALIZER;
 
848
# endif
 
849
# if defined(AO_HAVE_double_t)
 
850
    AO_double_t w;
 
851
    w.AO_val1 = 0;
 
852
    w.AO_val2 = 0;
 
853
# endif
 
854
 
 
855
# if defined(AO_HAVE_nop_write)
 
856
    AO_nop_write();
 
857
# else
 
858
    MISSING(AO_nop);
 
859
# endif
 
860
# if defined(AO_HAVE_store_write)
 
861
    AO_store_write(&x, 13);
 
862
    TA_assert (x == 13);
 
863
# else
 
864
    MISSING(AO_store);
 
865
    x = 13;
 
866
# endif
 
867
# if defined(AO_HAVE_load_write)
 
868
    TA_assert(AO_load_write(&x) == 13);
 
869
# else
 
870
    MISSING(AO_load);
 
871
# endif
 
872
# if defined(AO_HAVE_test_and_set_write)
 
873
    assert(AO_test_and_set_write(&z) == AO_TS_CLEAR);
 
874
    assert(AO_test_and_set_write(&z) == AO_TS_SET);
 
875
    assert(AO_test_and_set_write(&z) == AO_TS_SET);
 
876
    AO_CLEAR(&z);
 
877
# else
 
878
    MISSING(AO_test_and_set);
 
879
# endif
 
880
# if defined(AO_HAVE_fetch_and_add_write)
 
881
    TA_assert(AO_fetch_and_add_write(&x, 42) == 13);
 
882
    TA_assert(AO_fetch_and_add_write(&x, -42) == 55);
 
883
# else
 
884
    MISSING(AO_fetch_and_add);
 
885
# endif
 
886
# if defined(AO_HAVE_fetch_and_add1_write)
 
887
    TA_assert(AO_fetch_and_add1_write(&x) == 13);
 
888
# else
 
889
    MISSING(AO_fetch_and_add1);
 
890
    ++x;
 
891
# endif
 
892
# if defined(AO_HAVE_fetch_and_sub1_write)
 
893
    TA_assert(AO_fetch_and_sub1_write(&x) == 14);
 
894
# else
 
895
    MISSING(AO_fetch_and_sub1);
 
896
    --x;
 
897
# endif
 
898
# if defined(AO_HAVE_short_store_write)
 
899
    AO_short_store_write(&s, 13);
 
900
# else
 
901
    MISSING(AO_short_store);
 
902
    s = 13;
 
903
# endif
 
904
# if defined(AO_HAVE_short_load_write)
 
905
    TA_assert(AO_short_load(&s) == 13);
 
906
# else
 
907
    MISSING(AO_short_load);
 
908
# endif
 
909
# if defined(AO_HAVE_short_fetch_and_add_write)
 
910
    TA_assert(AO_short_fetch_and_add_write(&s, 42) == 13);
 
911
    TA_assert(AO_short_fetch_and_add_write(&s, -42) == 55);
 
912
# else
 
913
    MISSING(AO_short_fetch_and_add);
 
914
# endif
 
915
# if defined(AO_HAVE_short_fetch_and_add1_write)
 
916
    TA_assert(AO_short_fetch_and_add1_write(&s) == 13);
 
917
# else
 
918
    MISSING(AO_short_fetch_and_add1);
 
919
    ++s;
 
920
# endif
 
921
# if defined(AO_HAVE_short_fetch_and_sub1_write)
 
922
    TA_assert(AO_short_fetch_and_sub1_write(&s) == 14);
 
923
# else
 
924
    MISSING(AO_short_fetch_and_sub1);
 
925
    --s;
 
926
# endif
 
927
# if defined(AO_HAVE_char_store_write)
 
928
    AO_char_store_write(&b, 13);
 
929
# else
 
930
    MISSING(AO_char_store);
 
931
    b = 13;
 
932
# endif
 
933
# if defined(AO_HAVE_char_load_write)
 
934
    TA_assert(AO_char_load(&b) == 13);
 
935
# else
 
936
    MISSING(AO_char_load);
 
937
# endif
 
938
# if defined(AO_HAVE_char_fetch_and_add_write)
 
939
    TA_assert(AO_char_fetch_and_add_write(&b, 42) == 13);
 
940
    TA_assert(AO_char_fetch_and_add_write(&b, -42) == 55);
 
941
# else
 
942
    MISSING(AO_char_fetch_and_add);
 
943
# endif
 
944
# if defined(AO_HAVE_char_fetch_and_add1_write)
 
945
    TA_assert(AO_char_fetch_and_add1_write(&b) == 13);
 
946
# else
 
947
    MISSING(AO_char_fetch_and_add1);
 
948
    ++b;
 
949
# endif
 
950
# if defined(AO_HAVE_char_fetch_and_sub1_write)
 
951
    TA_assert(AO_char_fetch_and_sub1_write(&b) == 14);
 
952
# else
 
953
    MISSING(AO_char_fetch_and_sub1);
 
954
    --b;
 
955
# endif
 
956
# if defined(AO_HAVE_int_store_write)
 
957
    AO_int_store_write(&zz, 13);
 
958
# else
 
959
    MISSING(AO_int_store);
 
960
    zz = 13;
 
961
# endif
 
962
# if defined(AO_HAVE_int_load_write)
 
963
    TA_assert(AO_int_load(&zz) == 13);
 
964
# else
 
965
    MISSING(AO_int_load);
 
966
# endif
 
967
# if defined(AO_HAVE_int_fetch_and_add_write)
 
968
    TA_assert(AO_int_fetch_and_add_write(&zz, 42) == 13);
 
969
    TA_assert(AO_int_fetch_and_add_write(&zz, -42) == 55);
 
970
# else
 
971
    MISSING(AO_int_fetch_and_add);
 
972
# endif
 
973
# if defined(AO_HAVE_int_fetch_and_add1_write)
 
974
    TA_assert(AO_int_fetch_and_add1_write(&zz) == 13);
 
975
# else
 
976
    MISSING(AO_int_fetch_and_add1);
 
977
    ++zz;
 
978
# endif
 
979
# if defined(AO_HAVE_int_fetch_and_sub1_write)
 
980
    TA_assert(AO_int_fetch_and_sub1_write(&zz) == 14);
 
981
# else
 
982
    MISSING(AO_int_fetch_and_sub1);
 
983
    --zz;
 
984
# endif
 
985
# if defined(AO_HAVE_compare_and_swap_write)
 
986
    TA_assert(!AO_compare_and_swap_write(&x, 14, 42));
 
987
    TA_assert(x == 13);
 
988
    TA_assert(AO_compare_and_swap_write(&x, 13, 42));
 
989
    TA_assert(x == 42);
 
990
# else
 
991
    MISSING(AO_compare_and_swap);
 
992
# endif
 
993
# if defined(AO_HAVE_or_write)
 
994
    AO_or_write(&x, 66);
 
995
    TA_assert(x == 106);
 
996
# else
 
997
    MISSING(AO_or);
 
998
    x |= 34;
 
999
# endif
 
1000
# if defined(AO_HAVE_compare_double_and_swap_double_write)
 
1001
    TA_assert(!AO_compare_double_and_swap_double_write(&w, 17, 42, 12, 13));
 
1002
    TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
 
1003
    TA_assert(AO_compare_double_and_swap_double_write(&w, 0, 0, 12, 13));
 
1004
    TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
 
1005
    TA_assert(AO_compare_double_and_swap_double_write(&w, 12, 13, 17, 42));
 
1006
    TA_assert(w.AO_val1 == 17 && w.AO_val2 == 42);
 
1007
    w.AO_val1 = 0; w.AO_val2 = 0;
 
1008
# else
 
1009
    MISSING(AO_compare_double_and_swap_double);
 
1010
# endif
 
1011
# if defined(AO_HAVE_compare_and_swap_double_write)
 
1012
    TA_assert(!AO_compare_and_swap_double_write(&w, 17, 12, 13));
 
1013
    TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
 
1014
    TA_assert(AO_compare_and_swap_double_write(&w, 0, 12, 13));
 
1015
    TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
 
1016
    TA_assert(AO_compare_and_swap_double_write(&w, 12, 17, 42));
 
1017
    TA_assert(w.AO_val1 == 17 && w.AO_val2 == 42);
 
1018
# else
 
1019
    MISSING(AO_compare_and_swap_double);
 
1020
# endif
 
1021
}
 
1022
 
 
1023
 
 
1024
    
 
1025
/*
 
1026
 * Copyright (c) 2003 by Hewlett-Packard Company.  All rights reserved.
 
1027
 *
 
1028
 * This file is covered by the GNU general public license, version 2.
 
1029
 * see doc/COPYING for details.
 
1030
 */
 
1031
 
 
1032
/* Some basic sanity tests.  These do not test the barrier semantics. */
 
1033
 
 
1034
#undef TA_assert
 
1035
#define TA_assert(e) \
 
1036
  if (!(e)) { fprintf(stderr, "Assertion failed %s:%d (barrier: _full)\n", \
 
1037
                    __FILE__, __LINE__), exit(1); }
 
1038
 
 
1039
#undef MISSING
 
1040
#define MISSING(name) \
 
1041
  fprintf(stderr, "Missing: %s\n", #name "_full")
 
1042
 
 
1043
void test_atomic_full(void)
 
1044
{
 
1045
  AO_t x;
 
1046
  unsigned char b;
 
1047
  unsigned short s;
 
1048
  unsigned int zz;
 
1049
# if defined(AO_HAVE_test_and_set_full)
 
1050
    AO_TS_t z = AO_TS_INITIALIZER;
 
1051
# endif
 
1052
# if defined(AO_HAVE_double_t)
 
1053
    AO_double_t w;
 
1054
    w.AO_val1 = 0;
 
1055
    w.AO_val2 = 0;
 
1056
# endif
 
1057
 
 
1058
# if defined(AO_HAVE_nop_full)
 
1059
    AO_nop_full();
 
1060
# else
 
1061
    MISSING(AO_nop);
 
1062
# endif
 
1063
# if defined(AO_HAVE_store_full)
 
1064
    AO_store_full(&x, 13);
 
1065
    TA_assert (x == 13);
 
1066
# else
 
1067
    MISSING(AO_store);
 
1068
    x = 13;
 
1069
# endif
 
1070
# if defined(AO_HAVE_load_full)
 
1071
    TA_assert(AO_load_full(&x) == 13);
 
1072
# else
 
1073
    MISSING(AO_load);
 
1074
# endif
 
1075
# if defined(AO_HAVE_test_and_set_full)
 
1076
    assert(AO_test_and_set_full(&z) == AO_TS_CLEAR);
 
1077
    assert(AO_test_and_set_full(&z) == AO_TS_SET);
 
1078
    assert(AO_test_and_set_full(&z) == AO_TS_SET);
 
1079
    AO_CLEAR(&z);
 
1080
# else
 
1081
    MISSING(AO_test_and_set);
 
1082
# endif
 
1083
# if defined(AO_HAVE_fetch_and_add_full)
 
1084
    TA_assert(AO_fetch_and_add_full(&x, 42) == 13);
 
1085
    TA_assert(AO_fetch_and_add_full(&x, -42) == 55);
 
1086
# else
 
1087
    MISSING(AO_fetch_and_add);
 
1088
# endif
 
1089
# if defined(AO_HAVE_fetch_and_add1_full)
 
1090
    TA_assert(AO_fetch_and_add1_full(&x) == 13);
 
1091
# else
 
1092
    MISSING(AO_fetch_and_add1);
 
1093
    ++x;
 
1094
# endif
 
1095
# if defined(AO_HAVE_fetch_and_sub1_full)
 
1096
    TA_assert(AO_fetch_and_sub1_full(&x) == 14);
 
1097
# else
 
1098
    MISSING(AO_fetch_and_sub1);
 
1099
    --x;
 
1100
# endif
 
1101
# if defined(AO_HAVE_short_store_full)
 
1102
    AO_short_store_full(&s, 13);
 
1103
# else
 
1104
    MISSING(AO_short_store);
 
1105
    s = 13;
 
1106
# endif
 
1107
# if defined(AO_HAVE_short_load_full)
 
1108
    TA_assert(AO_short_load(&s) == 13);
 
1109
# else
 
1110
    MISSING(AO_short_load);
 
1111
# endif
 
1112
# if defined(AO_HAVE_short_fetch_and_add_full)
 
1113
    TA_assert(AO_short_fetch_and_add_full(&s, 42) == 13);
 
1114
    TA_assert(AO_short_fetch_and_add_full(&s, -42) == 55);
 
1115
# else
 
1116
    MISSING(AO_short_fetch_and_add);
 
1117
# endif
 
1118
# if defined(AO_HAVE_short_fetch_and_add1_full)
 
1119
    TA_assert(AO_short_fetch_and_add1_full(&s) == 13);
 
1120
# else
 
1121
    MISSING(AO_short_fetch_and_add1);
 
1122
    ++s;
 
1123
# endif
 
1124
# if defined(AO_HAVE_short_fetch_and_sub1_full)
 
1125
    TA_assert(AO_short_fetch_and_sub1_full(&s) == 14);
 
1126
# else
 
1127
    MISSING(AO_short_fetch_and_sub1);
 
1128
    --s;
 
1129
# endif
 
1130
# if defined(AO_HAVE_char_store_full)
 
1131
    AO_char_store_full(&b, 13);
 
1132
# else
 
1133
    MISSING(AO_char_store);
 
1134
    b = 13;
 
1135
# endif
 
1136
# if defined(AO_HAVE_char_load_full)
 
1137
    TA_assert(AO_char_load(&b) == 13);
 
1138
# else
 
1139
    MISSING(AO_char_load);
 
1140
# endif
 
1141
# if defined(AO_HAVE_char_fetch_and_add_full)
 
1142
    TA_assert(AO_char_fetch_and_add_full(&b, 42) == 13);
 
1143
    TA_assert(AO_char_fetch_and_add_full(&b, -42) == 55);
 
1144
# else
 
1145
    MISSING(AO_char_fetch_and_add);
 
1146
# endif
 
1147
# if defined(AO_HAVE_char_fetch_and_add1_full)
 
1148
    TA_assert(AO_char_fetch_and_add1_full(&b) == 13);
 
1149
# else
 
1150
    MISSING(AO_char_fetch_and_add1);
 
1151
    ++b;
 
1152
# endif
 
1153
# if defined(AO_HAVE_char_fetch_and_sub1_full)
 
1154
    TA_assert(AO_char_fetch_and_sub1_full(&b) == 14);
 
1155
# else
 
1156
    MISSING(AO_char_fetch_and_sub1);
 
1157
    --b;
 
1158
# endif
 
1159
# if defined(AO_HAVE_int_store_full)
 
1160
    AO_int_store_full(&zz, 13);
 
1161
# else
 
1162
    MISSING(AO_int_store);
 
1163
    zz = 13;
 
1164
# endif
 
1165
# if defined(AO_HAVE_int_load_full)
 
1166
    TA_assert(AO_int_load(&zz) == 13);
 
1167
# else
 
1168
    MISSING(AO_int_load);
 
1169
# endif
 
1170
# if defined(AO_HAVE_int_fetch_and_add_full)
 
1171
    TA_assert(AO_int_fetch_and_add_full(&zz, 42) == 13);
 
1172
    TA_assert(AO_int_fetch_and_add_full(&zz, -42) == 55);
 
1173
# else
 
1174
    MISSING(AO_int_fetch_and_add);
 
1175
# endif
 
1176
# if defined(AO_HAVE_int_fetch_and_add1_full)
 
1177
    TA_assert(AO_int_fetch_and_add1_full(&zz) == 13);
 
1178
# else
 
1179
    MISSING(AO_int_fetch_and_add1);
 
1180
    ++zz;
 
1181
# endif
 
1182
# if defined(AO_HAVE_int_fetch_and_sub1_full)
 
1183
    TA_assert(AO_int_fetch_and_sub1_full(&zz) == 14);
 
1184
# else
 
1185
    MISSING(AO_int_fetch_and_sub1);
 
1186
    --zz;
 
1187
# endif
 
1188
# if defined(AO_HAVE_compare_and_swap_full)
 
1189
    TA_assert(!AO_compare_and_swap_full(&x, 14, 42));
 
1190
    TA_assert(x == 13);
 
1191
    TA_assert(AO_compare_and_swap_full(&x, 13, 42));
 
1192
    TA_assert(x == 42);
 
1193
# else
 
1194
    MISSING(AO_compare_and_swap);
 
1195
# endif
 
1196
# if defined(AO_HAVE_or_full)
 
1197
    AO_or_full(&x, 66);
 
1198
    TA_assert(x == 106);
 
1199
# else
 
1200
    MISSING(AO_or);
 
1201
    x |= 34;
 
1202
# endif
 
1203
# if defined(AO_HAVE_compare_double_and_swap_double_full)
 
1204
    TA_assert(!AO_compare_double_and_swap_double_full(&w, 17, 42, 12, 13));
 
1205
    TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
 
1206
    TA_assert(AO_compare_double_and_swap_double_full(&w, 0, 0, 12, 13));
 
1207
    TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
 
1208
    TA_assert(AO_compare_double_and_swap_double_full(&w, 12, 13, 17, 42));
 
1209
    TA_assert(w.AO_val1 == 17 && w.AO_val2 == 42);
 
1210
    w.AO_val1 = 0; w.AO_val2 = 0;
 
1211
# else
 
1212
    MISSING(AO_compare_double_and_swap_double);
 
1213
# endif
 
1214
# if defined(AO_HAVE_compare_and_swap_double_full)
 
1215
    TA_assert(!AO_compare_and_swap_double_full(&w, 17, 12, 13));
 
1216
    TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
 
1217
    TA_assert(AO_compare_and_swap_double_full(&w, 0, 12, 13));
 
1218
    TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
 
1219
    TA_assert(AO_compare_and_swap_double_full(&w, 12, 17, 42));
 
1220
    TA_assert(w.AO_val1 == 17 && w.AO_val2 == 42);
 
1221
# else
 
1222
    MISSING(AO_compare_and_swap_double);
 
1223
# endif
 
1224
}
 
1225
 
 
1226
 
 
1227
    
 
1228
/*
 
1229
 * Copyright (c) 2003 by Hewlett-Packard Company.  All rights reserved.
 
1230
 *
 
1231
 * This file is covered by the GNU general public license, version 2.
 
1232
 * see doc/COPYING for details.
 
1233
 */
 
1234
 
 
1235
/* Some basic sanity tests.  These do not test the barrier semantics. */
 
1236
 
 
1237
#undef TA_assert
 
1238
#define TA_assert(e) \
 
1239
  if (!(e)) { fprintf(stderr, "Assertion failed %s:%d (barrier: _release_write)\n", \
 
1240
                    __FILE__, __LINE__), exit(1); }
 
1241
 
 
1242
#undef MISSING
 
1243
#define MISSING(name) \
 
1244
  fprintf(stderr, "Missing: %s\n", #name "_release_write")
 
1245
 
 
1246
void test_atomic_release_write(void)
 
1247
{
 
1248
  AO_t x;
 
1249
  unsigned char b;
 
1250
  unsigned short s;
 
1251
  unsigned int zz;
 
1252
# if defined(AO_HAVE_test_and_set_release_write)
 
1253
    AO_TS_t z = AO_TS_INITIALIZER;
 
1254
# endif
 
1255
# if defined(AO_HAVE_double_t)
 
1256
    AO_double_t w;
 
1257
    w.AO_val1 = 0;
 
1258
    w.AO_val2 = 0;
 
1259
# endif
 
1260
 
 
1261
# if defined(AO_HAVE_nop_release_write)
 
1262
    AO_nop_release_write();
 
1263
# else
 
1264
    MISSING(AO_nop);
 
1265
# endif
 
1266
# if defined(AO_HAVE_store_release_write)
 
1267
    AO_store_release_write(&x, 13);
 
1268
    TA_assert (x == 13);
 
1269
# else
 
1270
    MISSING(AO_store);
 
1271
    x = 13;
 
1272
# endif
 
1273
# if defined(AO_HAVE_load_release_write)
 
1274
    TA_assert(AO_load_release_write(&x) == 13);
 
1275
# else
 
1276
    MISSING(AO_load);
 
1277
# endif
 
1278
# if defined(AO_HAVE_test_and_set_release_write)
 
1279
    assert(AO_test_and_set_release_write(&z) == AO_TS_CLEAR);
 
1280
    assert(AO_test_and_set_release_write(&z) == AO_TS_SET);
 
1281
    assert(AO_test_and_set_release_write(&z) == AO_TS_SET);
 
1282
    AO_CLEAR(&z);
 
1283
# else
 
1284
    MISSING(AO_test_and_set);
 
1285
# endif
 
1286
# if defined(AO_HAVE_fetch_and_add_release_write)
 
1287
    TA_assert(AO_fetch_and_add_release_write(&x, 42) == 13);
 
1288
    TA_assert(AO_fetch_and_add_release_write(&x, -42) == 55);
 
1289
# else
 
1290
    MISSING(AO_fetch_and_add);
 
1291
# endif
 
1292
# if defined(AO_HAVE_fetch_and_add1_release_write)
 
1293
    TA_assert(AO_fetch_and_add1_release_write(&x) == 13);
 
1294
# else
 
1295
    MISSING(AO_fetch_and_add1);
 
1296
    ++x;
 
1297
# endif
 
1298
# if defined(AO_HAVE_fetch_and_sub1_release_write)
 
1299
    TA_assert(AO_fetch_and_sub1_release_write(&x) == 14);
 
1300
# else
 
1301
    MISSING(AO_fetch_and_sub1);
 
1302
    --x;
 
1303
# endif
 
1304
# if defined(AO_HAVE_short_store_release_write)
 
1305
    AO_short_store_release_write(&s, 13);
 
1306
# else
 
1307
    MISSING(AO_short_store);
 
1308
    s = 13;
 
1309
# endif
 
1310
# if defined(AO_HAVE_short_load_release_write)
 
1311
    TA_assert(AO_short_load(&s) == 13);
 
1312
# else
 
1313
    MISSING(AO_short_load);
 
1314
# endif
 
1315
# if defined(AO_HAVE_short_fetch_and_add_release_write)
 
1316
    TA_assert(AO_short_fetch_and_add_release_write(&s, 42) == 13);
 
1317
    TA_assert(AO_short_fetch_and_add_release_write(&s, -42) == 55);
 
1318
# else
 
1319
    MISSING(AO_short_fetch_and_add);
 
1320
# endif
 
1321
# if defined(AO_HAVE_short_fetch_and_add1_release_write)
 
1322
    TA_assert(AO_short_fetch_and_add1_release_write(&s) == 13);
 
1323
# else
 
1324
    MISSING(AO_short_fetch_and_add1);
 
1325
    ++s;
 
1326
# endif
 
1327
# if defined(AO_HAVE_short_fetch_and_sub1_release_write)
 
1328
    TA_assert(AO_short_fetch_and_sub1_release_write(&s) == 14);
 
1329
# else
 
1330
    MISSING(AO_short_fetch_and_sub1);
 
1331
    --s;
 
1332
# endif
 
1333
# if defined(AO_HAVE_char_store_release_write)
 
1334
    AO_char_store_release_write(&b, 13);
 
1335
# else
 
1336
    MISSING(AO_char_store);
 
1337
    b = 13;
 
1338
# endif
 
1339
# if defined(AO_HAVE_char_load_release_write)
 
1340
    TA_assert(AO_char_load(&b) == 13);
 
1341
# else
 
1342
    MISSING(AO_char_load);
 
1343
# endif
 
1344
# if defined(AO_HAVE_char_fetch_and_add_release_write)
 
1345
    TA_assert(AO_char_fetch_and_add_release_write(&b, 42) == 13);
 
1346
    TA_assert(AO_char_fetch_and_add_release_write(&b, -42) == 55);
 
1347
# else
 
1348
    MISSING(AO_char_fetch_and_add);
 
1349
# endif
 
1350
# if defined(AO_HAVE_char_fetch_and_add1_release_write)
 
1351
    TA_assert(AO_char_fetch_and_add1_release_write(&b) == 13);
 
1352
# else
 
1353
    MISSING(AO_char_fetch_and_add1);
 
1354
    ++b;
 
1355
# endif
 
1356
# if defined(AO_HAVE_char_fetch_and_sub1_release_write)
 
1357
    TA_assert(AO_char_fetch_and_sub1_release_write(&b) == 14);
 
1358
# else
 
1359
    MISSING(AO_char_fetch_and_sub1);
 
1360
    --b;
 
1361
# endif
 
1362
# if defined(AO_HAVE_int_store_release_write)
 
1363
    AO_int_store_release_write(&zz, 13);
 
1364
# else
 
1365
    MISSING(AO_int_store);
 
1366
    zz = 13;
 
1367
# endif
 
1368
# if defined(AO_HAVE_int_load_release_write)
 
1369
    TA_assert(AO_int_load(&zz) == 13);
 
1370
# else
 
1371
    MISSING(AO_int_load);
 
1372
# endif
 
1373
# if defined(AO_HAVE_int_fetch_and_add_release_write)
 
1374
    TA_assert(AO_int_fetch_and_add_release_write(&zz, 42) == 13);
 
1375
    TA_assert(AO_int_fetch_and_add_release_write(&zz, -42) == 55);
 
1376
# else
 
1377
    MISSING(AO_int_fetch_and_add);
 
1378
# endif
 
1379
# if defined(AO_HAVE_int_fetch_and_add1_release_write)
 
1380
    TA_assert(AO_int_fetch_and_add1_release_write(&zz) == 13);
 
1381
# else
 
1382
    MISSING(AO_int_fetch_and_add1);
 
1383
    ++zz;
 
1384
# endif
 
1385
# if defined(AO_HAVE_int_fetch_and_sub1_release_write)
 
1386
    TA_assert(AO_int_fetch_and_sub1_release_write(&zz) == 14);
 
1387
# else
 
1388
    MISSING(AO_int_fetch_and_sub1);
 
1389
    --zz;
 
1390
# endif
 
1391
# if defined(AO_HAVE_compare_and_swap_release_write)
 
1392
    TA_assert(!AO_compare_and_swap_release_write(&x, 14, 42));
 
1393
    TA_assert(x == 13);
 
1394
    TA_assert(AO_compare_and_swap_release_write(&x, 13, 42));
 
1395
    TA_assert(x == 42);
 
1396
# else
 
1397
    MISSING(AO_compare_and_swap);
 
1398
# endif
 
1399
# if defined(AO_HAVE_or_release_write)
 
1400
    AO_or_release_write(&x, 66);
 
1401
    TA_assert(x == 106);
 
1402
# else
 
1403
    MISSING(AO_or);
 
1404
    x |= 34;
 
1405
# endif
 
1406
# if defined(AO_HAVE_compare_double_and_swap_double_release_write)
 
1407
    TA_assert(!AO_compare_double_and_swap_double_release_write(&w, 17, 42, 12, 13));
 
1408
    TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
 
1409
    TA_assert(AO_compare_double_and_swap_double_release_write(&w, 0, 0, 12, 13));
 
1410
    TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
 
1411
    TA_assert(AO_compare_double_and_swap_double_release_write(&w, 12, 13, 17, 42));
 
1412
    TA_assert(w.AO_val1 == 17 && w.AO_val2 == 42);
 
1413
    w.AO_val1 = 0; w.AO_val2 = 0;
 
1414
# else
 
1415
    MISSING(AO_compare_double_and_swap_double);
 
1416
# endif
 
1417
# if defined(AO_HAVE_compare_and_swap_double_release_write)
 
1418
    TA_assert(!AO_compare_and_swap_double_release_write(&w, 17, 12, 13));
 
1419
    TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
 
1420
    TA_assert(AO_compare_and_swap_double_release_write(&w, 0, 12, 13));
 
1421
    TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
 
1422
    TA_assert(AO_compare_and_swap_double_release_write(&w, 12, 17, 42));
 
1423
    TA_assert(w.AO_val1 == 17 && w.AO_val2 == 42);
 
1424
# else
 
1425
    MISSING(AO_compare_and_swap_double);
 
1426
# endif
 
1427
}
 
1428
 
 
1429
 
 
1430
    
 
1431
/*
 
1432
 * Copyright (c) 2003 by Hewlett-Packard Company.  All rights reserved.
 
1433
 *
 
1434
 * This file is covered by the GNU general public license, version 2.
 
1435
 * see doc/COPYING for details.
 
1436
 */
 
1437
 
 
1438
/* Some basic sanity tests.  These do not test the barrier semantics. */
 
1439
 
 
1440
#undef TA_assert
 
1441
#define TA_assert(e) \
 
1442
  if (!(e)) { fprintf(stderr, "Assertion failed %s:%d (barrier: _acquire_read)\n", \
 
1443
                    __FILE__, __LINE__), exit(1); }
 
1444
 
 
1445
#undef MISSING
 
1446
#define MISSING(name) \
 
1447
  fprintf(stderr, "Missing: %s\n", #name "_acquire_read")
 
1448
 
 
1449
void test_atomic_acquire_read(void)
 
1450
{
 
1451
  AO_t x;
 
1452
  unsigned char b;
 
1453
  unsigned short s;
 
1454
  unsigned int zz;
 
1455
# if defined(AO_HAVE_test_and_set_acquire_read)
 
1456
    AO_TS_t z = AO_TS_INITIALIZER;
 
1457
# endif
 
1458
# if defined(AO_HAVE_double_t)
 
1459
    AO_double_t w;
 
1460
    w.AO_val1 = 0;
 
1461
    w.AO_val2 = 0;
 
1462
# endif
 
1463
 
 
1464
# if defined(AO_HAVE_nop_acquire_read)
 
1465
    AO_nop_acquire_read();
 
1466
# else
 
1467
    MISSING(AO_nop);
 
1468
# endif
 
1469
# if defined(AO_HAVE_store_acquire_read)
 
1470
    AO_store_acquire_read(&x, 13);
 
1471
    TA_assert (x == 13);
 
1472
# else
 
1473
    MISSING(AO_store);
 
1474
    x = 13;
 
1475
# endif
 
1476
# if defined(AO_HAVE_load_acquire_read)
 
1477
    TA_assert(AO_load_acquire_read(&x) == 13);
 
1478
# else
 
1479
    MISSING(AO_load);
 
1480
# endif
 
1481
# if defined(AO_HAVE_test_and_set_acquire_read)
 
1482
    assert(AO_test_and_set_acquire_read(&z) == AO_TS_CLEAR);
 
1483
    assert(AO_test_and_set_acquire_read(&z) == AO_TS_SET);
 
1484
    assert(AO_test_and_set_acquire_read(&z) == AO_TS_SET);
 
1485
    AO_CLEAR(&z);
 
1486
# else
 
1487
    MISSING(AO_test_and_set);
 
1488
# endif
 
1489
# if defined(AO_HAVE_fetch_and_add_acquire_read)
 
1490
    TA_assert(AO_fetch_and_add_acquire_read(&x, 42) == 13);
 
1491
    TA_assert(AO_fetch_and_add_acquire_read(&x, -42) == 55);
 
1492
# else
 
1493
    MISSING(AO_fetch_and_add);
 
1494
# endif
 
1495
# if defined(AO_HAVE_fetch_and_add1_acquire_read)
 
1496
    TA_assert(AO_fetch_and_add1_acquire_read(&x) == 13);
 
1497
# else
 
1498
    MISSING(AO_fetch_and_add1);
 
1499
    ++x;
 
1500
# endif
 
1501
# if defined(AO_HAVE_fetch_and_sub1_acquire_read)
 
1502
    TA_assert(AO_fetch_and_sub1_acquire_read(&x) == 14);
 
1503
# else
 
1504
    MISSING(AO_fetch_and_sub1);
 
1505
    --x;
 
1506
# endif
 
1507
# if defined(AO_HAVE_short_store_acquire_read)
 
1508
    AO_short_store_acquire_read(&s, 13);
 
1509
# else
 
1510
    MISSING(AO_short_store);
 
1511
    s = 13;
 
1512
# endif
 
1513
# if defined(AO_HAVE_short_load_acquire_read)
 
1514
    TA_assert(AO_short_load(&s) == 13);
 
1515
# else
 
1516
    MISSING(AO_short_load);
 
1517
# endif
 
1518
# if defined(AO_HAVE_short_fetch_and_add_acquire_read)
 
1519
    TA_assert(AO_short_fetch_and_add_acquire_read(&s, 42) == 13);
 
1520
    TA_assert(AO_short_fetch_and_add_acquire_read(&s, -42) == 55);
 
1521
# else
 
1522
    MISSING(AO_short_fetch_and_add);
 
1523
# endif
 
1524
# if defined(AO_HAVE_short_fetch_and_add1_acquire_read)
 
1525
    TA_assert(AO_short_fetch_and_add1_acquire_read(&s) == 13);
 
1526
# else
 
1527
    MISSING(AO_short_fetch_and_add1);
 
1528
    ++s;
 
1529
# endif
 
1530
# if defined(AO_HAVE_short_fetch_and_sub1_acquire_read)
 
1531
    TA_assert(AO_short_fetch_and_sub1_acquire_read(&s) == 14);
 
1532
# else
 
1533
    MISSING(AO_short_fetch_and_sub1);
 
1534
    --s;
 
1535
# endif
 
1536
# if defined(AO_HAVE_char_store_acquire_read)
 
1537
    AO_char_store_acquire_read(&b, 13);
 
1538
# else
 
1539
    MISSING(AO_char_store);
 
1540
    b = 13;
 
1541
# endif
 
1542
# if defined(AO_HAVE_char_load_acquire_read)
 
1543
    TA_assert(AO_char_load(&b) == 13);
 
1544
# else
 
1545
    MISSING(AO_char_load);
 
1546
# endif
 
1547
# if defined(AO_HAVE_char_fetch_and_add_acquire_read)
 
1548
    TA_assert(AO_char_fetch_and_add_acquire_read(&b, 42) == 13);
 
1549
    TA_assert(AO_char_fetch_and_add_acquire_read(&b, -42) == 55);
 
1550
# else
 
1551
    MISSING(AO_char_fetch_and_add);
 
1552
# endif
 
1553
# if defined(AO_HAVE_char_fetch_and_add1_acquire_read)
 
1554
    TA_assert(AO_char_fetch_and_add1_acquire_read(&b) == 13);
 
1555
# else
 
1556
    MISSING(AO_char_fetch_and_add1);
 
1557
    ++b;
 
1558
# endif
 
1559
# if defined(AO_HAVE_char_fetch_and_sub1_acquire_read)
 
1560
    TA_assert(AO_char_fetch_and_sub1_acquire_read(&b) == 14);
 
1561
# else
 
1562
    MISSING(AO_char_fetch_and_sub1);
 
1563
    --b;
 
1564
# endif
 
1565
# if defined(AO_HAVE_int_store_acquire_read)
 
1566
    AO_int_store_acquire_read(&zz, 13);
 
1567
# else
 
1568
    MISSING(AO_int_store);
 
1569
    zz = 13;
 
1570
# endif
 
1571
# if defined(AO_HAVE_int_load_acquire_read)
 
1572
    TA_assert(AO_int_load(&zz) == 13);
 
1573
# else
 
1574
    MISSING(AO_int_load);
 
1575
# endif
 
1576
# if defined(AO_HAVE_int_fetch_and_add_acquire_read)
 
1577
    TA_assert(AO_int_fetch_and_add_acquire_read(&zz, 42) == 13);
 
1578
    TA_assert(AO_int_fetch_and_add_acquire_read(&zz, -42) == 55);
 
1579
# else
 
1580
    MISSING(AO_int_fetch_and_add);
 
1581
# endif
 
1582
# if defined(AO_HAVE_int_fetch_and_add1_acquire_read)
 
1583
    TA_assert(AO_int_fetch_and_add1_acquire_read(&zz) == 13);
 
1584
# else
 
1585
    MISSING(AO_int_fetch_and_add1);
 
1586
    ++zz;
 
1587
# endif
 
1588
# if defined(AO_HAVE_int_fetch_and_sub1_acquire_read)
 
1589
    TA_assert(AO_int_fetch_and_sub1_acquire_read(&zz) == 14);
 
1590
# else
 
1591
    MISSING(AO_int_fetch_and_sub1);
 
1592
    --zz;
 
1593
# endif
 
1594
# if defined(AO_HAVE_compare_and_swap_acquire_read)
 
1595
    TA_assert(!AO_compare_and_swap_acquire_read(&x, 14, 42));
 
1596
    TA_assert(x == 13);
 
1597
    TA_assert(AO_compare_and_swap_acquire_read(&x, 13, 42));
 
1598
    TA_assert(x == 42);
 
1599
# else
 
1600
    MISSING(AO_compare_and_swap);
 
1601
# endif
 
1602
# if defined(AO_HAVE_or_acquire_read)
 
1603
    AO_or_acquire_read(&x, 66);
 
1604
    TA_assert(x == 106);
 
1605
# else
 
1606
    MISSING(AO_or);
 
1607
    x |= 34;
 
1608
# endif
 
1609
# if defined(AO_HAVE_compare_double_and_swap_double_acquire_read)
 
1610
    TA_assert(!AO_compare_double_and_swap_double_acquire_read(&w, 17, 42, 12, 13));
 
1611
    TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
 
1612
    TA_assert(AO_compare_double_and_swap_double_acquire_read(&w, 0, 0, 12, 13));
 
1613
    TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
 
1614
    TA_assert(AO_compare_double_and_swap_double_acquire_read(&w, 12, 13, 17, 42));
 
1615
    TA_assert(w.AO_val1 == 17 && w.AO_val2 == 42);
 
1616
    w.AO_val1 = 0; w.AO_val2 = 0;
 
1617
# else
 
1618
    MISSING(AO_compare_double_and_swap_double);
 
1619
# endif
 
1620
# if defined(AO_HAVE_compare_and_swap_double_acquire_read)
 
1621
    TA_assert(!AO_compare_and_swap_double_acquire_read(&w, 17, 12, 13));
 
1622
    TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
 
1623
    TA_assert(AO_compare_and_swap_double_acquire_read(&w, 0, 12, 13));
 
1624
    TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
 
1625
    TA_assert(AO_compare_and_swap_double_acquire_read(&w, 12, 17, 42));
 
1626
    TA_assert(w.AO_val1 == 17 && w.AO_val2 == 42);
 
1627
# else
 
1628
    MISSING(AO_compare_and_swap_double);
 
1629
# endif
 
1630
}
 
1631
 
 
1632
 
 
1633