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 689

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.