OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [testsuite/] [gcc.dg/] [atomic-op-4.c] - Blame information for rev 774

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 689 jeremybenn
/* Test __atomic routines for existence and proper execution on 8 byte
2
   values with each valid memory model.  */
3
/* { dg-do run } */
4
/* { dg-require-effective-target sync_long_long_runtime } */
5
/* { dg-options "" } */
6
/* { dg-options "-march=pentium" { target { { i?86-*-* x86_64-*-* } && ia32 } } } */
7
 
8
/* Test the execution of the __atomic_*OP builtin routines for long long.  */
9
 
10
extern void abort(void);
11
 
12
long long v, count, res;
13
const long long init = ~0;
14
 
15
/* The fetch_op routines return the original value before the operation.  */
16
 
17
void
18
test_fetch_add ()
19
{
20
  v = 0;
21
  count = 1;
22
 
23
  if (__atomic_fetch_add (&v, count, __ATOMIC_RELAXED) != 0)
24
    abort ();
25
 
26
  if (__atomic_fetch_add (&v, 1, __ATOMIC_CONSUME) != 1)
27
    abort ();
28
 
29
  if (__atomic_fetch_add (&v, count, __ATOMIC_ACQUIRE) != 2)
30
    abort ();
31
 
32
  if (__atomic_fetch_add (&v, 1, __ATOMIC_RELEASE) != 3)
33
    abort ();
34
 
35
  if (__atomic_fetch_add (&v, count, __ATOMIC_ACQ_REL) != 4)
36
    abort ();
37
 
38
  if (__atomic_fetch_add (&v, 1, __ATOMIC_SEQ_CST) != 5)
39
    abort ();
40
}
41
 
42
 
43
void
44
test_fetch_sub()
45
{
46
  v = res = 20;
47
  count = 0;
48
 
49
  if (__atomic_fetch_sub (&v, count + 1, __ATOMIC_RELAXED) !=  res--)
50
    abort ();
51
 
52
  if (__atomic_fetch_sub (&v, 1, __ATOMIC_CONSUME) !=  res--)
53
    abort ();
54
 
55
  if (__atomic_fetch_sub (&v, count + 1, __ATOMIC_ACQUIRE) !=  res--)
56
    abort ();
57
 
58
  if (__atomic_fetch_sub (&v, 1, __ATOMIC_RELEASE) !=  res--)
59
    abort ();
60
 
61
  if (__atomic_fetch_sub (&v, count + 1, __ATOMIC_ACQ_REL) !=  res--)
62
    abort ();
63
 
64
  if (__atomic_fetch_sub (&v, 1, __ATOMIC_SEQ_CST) !=  res--)
65
    abort ();
66
}
67
 
68
void
69
test_fetch_and ()
70
{
71
  v = init;
72
 
73
  if (__atomic_fetch_and (&v, 0, __ATOMIC_RELAXED) !=  init)
74
    abort ();
75
 
76
  if (__atomic_fetch_and (&v, init, __ATOMIC_CONSUME) !=  0)
77
    abort ();
78
 
79
  if (__atomic_fetch_and (&v, 0, __ATOMIC_ACQUIRE) !=  0)
80
    abort ();
81
 
82
  v = ~v;
83
  if (__atomic_fetch_and (&v, init, __ATOMIC_RELEASE) !=  init)
84
    abort ();
85
 
86
  if (__atomic_fetch_and (&v, 0, __ATOMIC_ACQ_REL) !=  init)
87
    abort ();
88
 
89
  if (__atomic_fetch_and (&v, 0, __ATOMIC_SEQ_CST) !=  0)
90
    abort ();
91
}
92
 
93
void
94
test_fetch_nand ()
95
{
96
  v = init;
97
 
98
  if (__atomic_fetch_nand (&v, 0, __ATOMIC_RELAXED) !=  init)
99
    abort ();
100
 
101
  if (__atomic_fetch_nand (&v, init, __ATOMIC_CONSUME) !=  init)
102
    abort ();
103
 
104
  if (__atomic_fetch_nand (&v, 0, __ATOMIC_ACQUIRE) !=  0 )
105
    abort ();
106
 
107
  if (__atomic_fetch_nand (&v, init, __ATOMIC_RELEASE) !=  init)
108
    abort ();
109
 
110
  if (__atomic_fetch_nand (&v, init, __ATOMIC_ACQ_REL) !=  0)
111
    abort ();
112
 
113
  if (__atomic_fetch_nand (&v, 0, __ATOMIC_SEQ_CST) !=  init)
114
    abort ();
115
}
116
 
117
void
118
test_fetch_xor ()
119
{
120
  v = init;
121
  count = 0;
122
 
123
  if (__atomic_fetch_xor (&v, count, __ATOMIC_RELAXED) !=  init)
124
    abort ();
125
 
126
  if (__atomic_fetch_xor (&v, ~count, __ATOMIC_CONSUME) !=  init)
127
    abort ();
128
 
129
  if (__atomic_fetch_xor (&v, 0, __ATOMIC_ACQUIRE) !=  0)
130
    abort ();
131
 
132
  if (__atomic_fetch_xor (&v, ~count, __ATOMIC_RELEASE) !=  0)
133
    abort ();
134
 
135
  if (__atomic_fetch_xor (&v, 0, __ATOMIC_ACQ_REL) !=  init)
136
    abort ();
137
 
138
  if (__atomic_fetch_xor (&v, ~count, __ATOMIC_SEQ_CST) !=  init)
139
    abort ();
140
}
141
 
142
void
143
test_fetch_or ()
144
{
145
  v = 0;
146
  count = 1;
147
 
148
  if (__atomic_fetch_or (&v, count, __ATOMIC_RELAXED) !=  0)
149
    abort ();
150
 
151
  count *= 2;
152
  if (__atomic_fetch_or (&v, 2, __ATOMIC_CONSUME) !=  1)
153
    abort ();
154
 
155
  count *= 2;
156
  if (__atomic_fetch_or (&v, count, __ATOMIC_ACQUIRE) !=  3)
157
    abort ();
158
 
159
  count *= 2;
160
  if (__atomic_fetch_or (&v, 8, __ATOMIC_RELEASE) !=  7)
161
    abort ();
162
 
163
  count *= 2;
164
  if (__atomic_fetch_or (&v, count, __ATOMIC_ACQ_REL) !=  15)
165
    abort ();
166
 
167
  count *= 2;
168
  if (__atomic_fetch_or (&v, count, __ATOMIC_SEQ_CST) !=  31)
169
    abort ();
170
}
171
 
172
/* The OP_fetch routines return the new value after the operation.  */
173
 
174
void
175
test_add_fetch ()
176
{
177
  v = 0;
178
  count = 1;
179
 
180
  if (__atomic_add_fetch (&v, count, __ATOMIC_RELAXED) != 1)
181
    abort ();
182
 
183
  if (__atomic_add_fetch (&v, 1, __ATOMIC_CONSUME) != 2)
184
    abort ();
185
 
186
  if (__atomic_add_fetch (&v, count, __ATOMIC_ACQUIRE) != 3)
187
    abort ();
188
 
189
  if (__atomic_add_fetch (&v, 1, __ATOMIC_RELEASE) != 4)
190
    abort ();
191
 
192
  if (__atomic_add_fetch (&v, count, __ATOMIC_ACQ_REL) != 5)
193
    abort ();
194
 
195
  if (__atomic_add_fetch (&v, count, __ATOMIC_SEQ_CST) != 6)
196
    abort ();
197
}
198
 
199
 
200
void
201
test_sub_fetch ()
202
{
203
  v = res = 20;
204
  count = 0;
205
 
206
  if (__atomic_sub_fetch (&v, count + 1, __ATOMIC_RELAXED) !=  --res)
207
    abort ();
208
 
209
  if (__atomic_sub_fetch (&v, 1, __ATOMIC_CONSUME) !=  --res)
210
    abort ();
211
 
212
  if (__atomic_sub_fetch (&v, count + 1, __ATOMIC_ACQUIRE) !=  --res)
213
    abort ();
214
 
215
  if (__atomic_sub_fetch (&v, 1, __ATOMIC_RELEASE) !=  --res)
216
    abort ();
217
 
218
  if (__atomic_sub_fetch (&v, count + 1, __ATOMIC_ACQ_REL) !=  --res)
219
    abort ();
220
 
221
  if (__atomic_sub_fetch (&v, count + 1, __ATOMIC_SEQ_CST) !=  --res)
222
    abort ();
223
}
224
 
225
void
226
test_and_fetch ()
227
{
228
  v = init;
229
 
230
  if (__atomic_and_fetch (&v, 0, __ATOMIC_RELAXED) !=  0)
231
    abort ();
232
 
233
  v = init;
234
  if (__atomic_and_fetch (&v, init, __ATOMIC_CONSUME) !=  init)
235
    abort ();
236
 
237
  if (__atomic_and_fetch (&v, 0, __ATOMIC_ACQUIRE) !=  0)
238
    abort ();
239
 
240
  v = ~v;
241
  if (__atomic_and_fetch (&v, init, __ATOMIC_RELEASE) !=  init)
242
    abort ();
243
 
244
  if (__atomic_and_fetch (&v, 0, __ATOMIC_ACQ_REL) !=  0)
245
    abort ();
246
 
247
  v = ~v;
248
  if (__atomic_and_fetch (&v, 0, __ATOMIC_SEQ_CST) !=  0)
249
    abort ();
250
}
251
 
252
void
253
test_nand_fetch ()
254
{
255
  v = init;
256
 
257
  if (__atomic_nand_fetch (&v, 0, __ATOMIC_RELAXED) !=  init)
258
    abort ();
259
 
260
  if (__atomic_nand_fetch (&v, init, __ATOMIC_CONSUME) !=  0)
261
    abort ();
262
 
263
  if (__atomic_nand_fetch (&v, 0, __ATOMIC_ACQUIRE) !=  init)
264
    abort ();
265
 
266
  if (__atomic_nand_fetch (&v, init, __ATOMIC_RELEASE) !=  0)
267
    abort ();
268
 
269
  if (__atomic_nand_fetch (&v, init, __ATOMIC_ACQ_REL) !=  init)
270
    abort ();
271
 
272
  if (__atomic_nand_fetch (&v, 0, __ATOMIC_SEQ_CST) !=  init)
273
    abort ();
274
}
275
 
276
 
277
 
278
void
279
test_xor_fetch ()
280
{
281
  v = init;
282
  count = 0;
283
 
284
  if (__atomic_xor_fetch (&v, count, __ATOMIC_RELAXED) !=  init)
285
    abort ();
286
 
287
  if (__atomic_xor_fetch (&v, ~count, __ATOMIC_CONSUME) !=  0)
288
    abort ();
289
 
290
  if (__atomic_xor_fetch (&v, 0, __ATOMIC_ACQUIRE) !=  0)
291
    abort ();
292
 
293
  if (__atomic_xor_fetch (&v, ~count, __ATOMIC_RELEASE) !=  init)
294
    abort ();
295
 
296
  if (__atomic_xor_fetch (&v, 0, __ATOMIC_ACQ_REL) !=  init)
297
    abort ();
298
 
299
  if (__atomic_xor_fetch (&v, ~count, __ATOMIC_SEQ_CST) !=  0)
300
    abort ();
301
}
302
 
303
void
304
test_or_fetch ()
305
{
306
  v = 0;
307
  count = 1;
308
 
309
  if (__atomic_or_fetch (&v, count, __ATOMIC_RELAXED) !=  1)
310
    abort ();
311
 
312
  count *= 2;
313
  if (__atomic_or_fetch (&v, 2, __ATOMIC_CONSUME) !=  3)
314
    abort ();
315
 
316
  count *= 2;
317
  if (__atomic_or_fetch (&v, count, __ATOMIC_ACQUIRE) !=  7)
318
    abort ();
319
 
320
  count *= 2;
321
  if (__atomic_or_fetch (&v, 8, __ATOMIC_RELEASE) !=  15)
322
    abort ();
323
 
324
  count *= 2;
325
  if (__atomic_or_fetch (&v, count, __ATOMIC_ACQ_REL) !=  31)
326
    abort ();
327
 
328
  count *= 2;
329
  if (__atomic_or_fetch (&v, count, __ATOMIC_SEQ_CST) !=  63)
330
    abort ();
331
}
332
 
333
 
334
/* Test the OP routines with a result which isn't used. Use both variations
335
   within each function.  */
336
 
337
void
338
test_add ()
339
{
340
  v = 0;
341
  count = 1;
342
 
343
  __atomic_add_fetch (&v, count, __ATOMIC_RELAXED);
344
  if (v != 1)
345
    abort ();
346
 
347
  __atomic_fetch_add (&v, count, __ATOMIC_CONSUME);
348
  if (v != 2)
349
    abort ();
350
 
351
  __atomic_add_fetch (&v, 1 , __ATOMIC_ACQUIRE);
352
  if (v != 3)
353
    abort ();
354
 
355
  __atomic_fetch_add (&v, 1, __ATOMIC_RELEASE);
356
  if (v != 4)
357
    abort ();
358
 
359
  __atomic_add_fetch (&v, count, __ATOMIC_ACQ_REL);
360
  if (v != 5)
361
    abort ();
362
 
363
  __atomic_fetch_add (&v, count, __ATOMIC_SEQ_CST);
364
  if (v != 6)
365
    abort ();
366
}
367
 
368
 
369
void
370
test_sub()
371
{
372
  v = res = 20;
373
  count = 0;
374
 
375
  __atomic_sub_fetch (&v, count + 1, __ATOMIC_RELAXED);
376
  if (v != --res)
377
    abort ();
378
 
379
  __atomic_fetch_sub (&v, count + 1, __ATOMIC_CONSUME);
380
  if (v != --res)
381
    abort ();
382
 
383
  __atomic_sub_fetch (&v, 1, __ATOMIC_ACQUIRE);
384
  if (v != --res)
385
    abort ();
386
 
387
  __atomic_fetch_sub (&v, 1, __ATOMIC_RELEASE);
388
  if (v != --res)
389
    abort ();
390
 
391
  __atomic_sub_fetch (&v, count + 1, __ATOMIC_ACQ_REL);
392
  if (v != --res)
393
    abort ();
394
 
395
  __atomic_fetch_sub (&v, count + 1, __ATOMIC_SEQ_CST);
396
  if (v != --res)
397
    abort ();
398
}
399
 
400
void
401
test_and ()
402
{
403
  v = init;
404
 
405
  __atomic_and_fetch (&v, 0, __ATOMIC_RELAXED);
406
  if (v != 0)
407
    abort ();
408
 
409
  v = init;
410
  __atomic_fetch_and (&v, init, __ATOMIC_CONSUME);
411
  if (v != init)
412
    abort ();
413
 
414
  __atomic_and_fetch (&v, 0, __ATOMIC_ACQUIRE);
415
  if (v != 0)
416
    abort ();
417
 
418
  v = ~v;
419
  __atomic_fetch_and (&v, init, __ATOMIC_RELEASE);
420
  if (v != init)
421
    abort ();
422
 
423
  __atomic_and_fetch (&v, 0, __ATOMIC_ACQ_REL);
424
  if (v != 0)
425
    abort ();
426
 
427
  v = ~v;
428
  __atomic_fetch_and (&v, 0, __ATOMIC_SEQ_CST);
429
  if (v != 0)
430
    abort ();
431
}
432
 
433
void
434
test_nand ()
435
{
436
  v = init;
437
 
438
  __atomic_fetch_nand (&v, 0, __ATOMIC_RELAXED);
439
  if (v != init)
440
    abort ();
441
 
442
  __atomic_fetch_nand (&v, init, __ATOMIC_CONSUME);
443
  if (v != 0)
444
    abort ();
445
 
446
  __atomic_nand_fetch (&v, 0, __ATOMIC_ACQUIRE);
447
  if (v != init)
448
    abort ();
449
 
450
  __atomic_nand_fetch (&v, init, __ATOMIC_RELEASE);
451
  if (v != 0)
452
    abort ();
453
 
454
  __atomic_fetch_nand (&v, init, __ATOMIC_ACQ_REL);
455
  if (v != init)
456
    abort ();
457
 
458
  __atomic_nand_fetch (&v, 0, __ATOMIC_SEQ_CST);
459
  if (v != init)
460
    abort ();
461
}
462
 
463
 
464
 
465
void
466
test_xor ()
467
{
468
  v = init;
469
  count = 0;
470
 
471
  __atomic_xor_fetch (&v, count, __ATOMIC_RELAXED);
472
  if (v != init)
473
    abort ();
474
 
475
  __atomic_fetch_xor (&v, ~count, __ATOMIC_CONSUME);
476
  if (v != 0)
477
    abort ();
478
 
479
  __atomic_xor_fetch (&v, 0, __ATOMIC_ACQUIRE);
480
  if (v != 0)
481
    abort ();
482
 
483
  __atomic_fetch_xor (&v, ~count, __ATOMIC_RELEASE);
484
  if (v != init)
485
    abort ();
486
 
487
  __atomic_fetch_xor (&v, 0, __ATOMIC_ACQ_REL);
488
  if (v != init)
489
    abort ();
490
 
491
  __atomic_xor_fetch (&v, ~count, __ATOMIC_SEQ_CST);
492
  if (v != 0)
493
    abort ();
494
}
495
 
496
void
497
test_or ()
498
{
499
  v = 0;
500
  count = 1;
501
 
502
  __atomic_or_fetch (&v, count, __ATOMIC_RELAXED);
503
  if (v != 1)
504
    abort ();
505
 
506
  count *= 2;
507
  __atomic_fetch_or (&v, count, __ATOMIC_CONSUME);
508
  if (v != 3)
509
    abort ();
510
 
511
  count *= 2;
512
  __atomic_or_fetch (&v, 4, __ATOMIC_ACQUIRE);
513
  if (v != 7)
514
    abort ();
515
 
516
  count *= 2;
517
  __atomic_fetch_or (&v, 8, __ATOMIC_RELEASE);
518
  if (v != 15)
519
    abort ();
520
 
521
  count *= 2;
522
  __atomic_or_fetch (&v, count, __ATOMIC_ACQ_REL);
523
  if (v != 31)
524
    abort ();
525
 
526
  count *= 2;
527
  __atomic_fetch_or (&v, count, __ATOMIC_SEQ_CST);
528
  if (v != 63)
529
    abort ();
530
}
531
 
532
main ()
533
{
534
  test_fetch_add ();
535
  test_fetch_sub ();
536
  test_fetch_and ();
537
  test_fetch_nand ();
538
  test_fetch_xor ();
539
  test_fetch_or ();
540
 
541
  test_add_fetch ();
542
  test_sub_fetch ();
543
  test_and_fetch ();
544
  test_nand_fetch ();
545
  test_xor_fetch ();
546
  test_or_fetch ();
547
 
548
  test_add ();
549
  test_sub ();
550
  test_and ();
551
  test_nand ();
552
  test_xor ();
553
  test_or ();
554
 
555
  return 0;
556
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.