1 // RUN: %clang_cc1 -verify -fopenmp -ast-print %s | FileCheck %s
2 // RUN: %clang_cc1 -fopenmp -x c++ -std=c++11 -emit-pch -o %t %s
3 // RUN: %clang_cc1 -fopenmp -std=c++11 -include-pch %t -fsyntax-only -verify %s -ast-print | FileCheck %s
4 
5 // RUN: %clang_cc1 -verify -fopenmp-simd -ast-print %s | FileCheck %s
6 // RUN: %clang_cc1 -fopenmp-simd -x c++ -std=c++11 -emit-pch -o %t %s
7 // RUN: %clang_cc1 -fopenmp-simd -std=c++11 -include-pch %t -fsyntax-only -verify %s -ast-print | FileCheck %s
8 
9 // RUN: %clang_cc1 -DOMP51 -verify -fopenmp -fopenmp-version=51 -ast-print %s | FileCheck --check-prefixes=CHECK,CHECK-51 %s
10 // RUN: %clang_cc1 -DOMP51 -fopenmp -fopenmp-version=51 -x c++ -std=c++11 -emit-pch -o %t %s
11 // RUN: %clang_cc1 -DOMP51 -fopenmp -fopenmp-version=51 -std=c++11 -include-pch %t -fsyntax-only -verify %s -ast-print | FileCheck --check-prefixes=CHECK,CHECK-51 %s
12 
13 // RUN: %clang_cc1 -DOMP51 -verify -fopenmp-simd -fopenmp-version=51 -ast-print %s | FileCheck --check-prefixes=CHECK,CHECK-51 %s
14 // RUN: %clang_cc1 -DOMP51 -fopenmp-simd -fopenmp-version=51 -x c++ -std=c++11 -emit-pch -o %t %s
15 // RUN: %clang_cc1 -DOMP51 -fopenmp-simd -fopenmp-version=51 -std=c++11 -include-pch %t -fsyntax-only -verify %s -ast-print | FileCheck --check-prefixes=CHECK,CHECK-51 %s
16 // expected-no-diagnostics
17 
18 #ifndef HEADER
19 #define HEADER
20 
21 template <class T>
22 T foo(T argc) {
23   T v = T();
24   T c = T();
25   T b = T();
26   T a = T();
27 #pragma omp atomic
28   a++;
29 #pragma omp atomic read
30   a = argc;
31 #pragma omp atomic write
32   a = argc + argc;
33 #pragma omp atomic update
34   a = a + argc;
35 #pragma omp atomic capture
36   a = b++;
37 #pragma omp atomic capture
38   {
39     a = b;
40     b++;
41   }
42 #ifdef OMP51
43 #pragma omp atomic compare
44   { a = a > b ? b : a; }
45 #pragma omp atomic compare
46   { a = a < b ? b : a; }
47 #pragma omp atomic compare
48   { a = a == b ? c : a; }
49 #pragma omp atomic compare capture
50   { v = a; if (a > b) { a = b; } }
51 #pragma omp atomic compare capture
52   { v = a; if (a < b) { a = b; } }
53 #pragma omp atomic compare capture
54   { v = a == b; if (v) a = c; }
55 #endif
56 #pragma omp atomic seq_cst
57   a++;
58 #pragma omp atomic read seq_cst
59   a = argc;
60 #pragma omp atomic seq_cst write
61   a = argc + argc;
62 #pragma omp atomic update seq_cst
63   a = a + argc;
64 #pragma omp atomic seq_cst capture
65   a = b++;
66 #pragma omp atomic capture seq_cst
67   {
68     a = b;
69     b++;
70   }
71 #ifdef OMP51
72 #pragma omp atomic compare seq_cst
73   { a = a > b ? b : a; }
74 #pragma omp atomic seq_cst compare
75   { a = a < b ? b : a; }
76 #pragma omp atomic compare seq_cst
77   { a = a == b ? c : a; }
78 #pragma omp atomic compare capture seq_cst
79   { v = a; if (a > b) { a = b; } }
80 #pragma omp atomic compare seq_cst capture
81   { v = a; if (a < b) { a = b; } }
82 #pragma omp atomic compare capture seq_cst
83   { v = a == b; if (v) a = c; }
84 #endif
85 #pragma omp atomic
86   a++;
87 #pragma omp atomic read
88   a = argc;
89 #pragma omp atomic write
90   a = argc + argc;
91 #pragma omp atomic update
92   a = a + argc;
93 #pragma omp atomic acq_rel capture
94   a = b++;
95 #pragma omp atomic capture acq_rel
96   {
97     a = b;
98     b++;
99   }
100 #ifdef OMP51
101 #pragma omp atomic compare acq_rel
102   { a = a > b ? b : a; }
103 #pragma omp atomic acq_rel compare
104   { a = a < b ? b : a; }
105 #pragma omp atomic compare acq_rel
106   { a = a == b ? c : a; }
107 #pragma omp atomic compare capture acq_rel
108   { v = a; if (a > b) { a = b; } }
109 #pragma omp atomic compare acq_rel capture
110   { v = a; if (a < b) { a = b; } }
111 #pragma omp atomic compare capture acq_rel
112   { v = a == b; if (v) a = c; }
113 #endif
114 #pragma omp atomic
115   a++;
116 #pragma omp atomic read acquire
117   a = argc;
118 #pragma omp atomic write
119   a = argc + argc;
120 #pragma omp atomic update
121   a = a + argc;
122 #pragma omp atomic acquire capture
123   a = b++;
124 #pragma omp atomic capture acquire
125   {
126     a = b;
127     b++;
128   }
129 #ifdef OMP51
130 #pragma omp atomic compare acquire
131   { a = a > b ? b : a; }
132 #pragma omp atomic acquire compare
133   { a = a < b ? b : a; }
134 #pragma omp atomic compare acquire
135   { a = a == b ? c : a; }
136 #pragma omp atomic compare capture acquire
137   { v = a; if (a > b) { a = b; } }
138 #pragma omp atomic compare acquire capture
139   { v = a; if (a < b) { a = b; } }
140 #pragma omp atomic compare capture acquire
141   { v = a == b; if (v) a = c; }
142 #endif
143 #pragma omp atomic release
144   a++;
145 #pragma omp atomic read
146   a = argc;
147 #pragma omp atomic release write
148   a = argc + argc;
149 #pragma omp atomic update release
150   a = a + argc;
151 #pragma omp atomic release capture
152   a = b++;
153 #pragma omp atomic capture release
154   {
155     a = b;
156     b++;
157   }
158 #ifdef OMP51
159 #pragma omp atomic compare release
160   { a = a > b ? b : a; }
161 #pragma omp atomic release compare
162   { a = a < b ? b : a; }
163 #pragma omp atomic compare release
164   { a = a == b ? c : a; }
165 #pragma omp atomic compare capture release
166   { v = a; if (a > b) { a = b; } }
167 #pragma omp atomic compare release capture
168   { v = a; if (a < b) { a = b; } }
169 #pragma omp atomic compare capture release
170   { v = a == b; if (v) a = c; }
171 #endif
172 #pragma omp atomic relaxed
173   a++;
174 #pragma omp atomic read
175   a = argc;
176 #pragma omp atomic relaxed write
177   a = argc + argc;
178 #pragma omp atomic update relaxed
179   a = a + argc;
180 #pragma omp atomic relaxed capture
181   a = b++;
182 #pragma omp atomic capture relaxed
183   {
184     a = b;
185     b++;
186   }
187 #ifdef OMP51
188 #pragma omp atomic compare relaxed
189   { a = a > b ? b : a; }
190 #pragma omp atomic relaxed compare
191   { a = a < b ? b : a; }
192 #pragma omp atomic compare relaxed
193   { a = a == b ? c : a; }
194 #pragma omp atomic compare capture relaxed
195   { v = a; if (a > b) { a = b; } }
196 #pragma omp atomic compare relaxed capture
197   { v = a; if (a < b) { a = b; } }
198 #pragma omp atomic compare capture relaxed
199   { v = a == b; if (v) a = c; }
200 #endif
201 #pragma omp atomic hint(6)
202   a++;
203 #pragma omp atomic read hint(6)
204   a = argc;
205 #pragma omp atomic hint(6) write
206   a = argc + argc;
207 #pragma omp atomic update hint(6)
208   a = a + argc;
209 #pragma omp atomic hint(6) capture
210   a = b++;
211 #pragma omp atomic capture hint(6)
212   {
213     a = b;
214     b++;
215   }
216 #ifdef OMP51
217 #pragma omp atomic compare hint(6)
218   { a = a > b ? b : a; }
219 #pragma omp atomic hint(6) compare
220   { a = a < b ? b : a; }
221 #pragma omp atomic compare hint(6)
222   { a = a == b ? c : a; }
223 #pragma omp atomic compare capture hint(6)
224   { v = a; if (a > b) { a = b; } }
225 #pragma omp atomic compare hint(6) capture
226   { v = a; if (a < b) { a = b; } }
227 #pragma omp atomic compare capture hint(6)
228   { v = a == b; if (v) a = c; }
229 #endif
230   return T();
231 }
232 
233 // CHECK: T a = T();
234 // CHECK-NEXT: #pragma omp atomic{{$}}
235 // CHECK-NEXT: a++;
236 // CHECK-NEXT: #pragma omp atomic read
237 // CHECK-NEXT: a = argc;
238 // CHECK-NEXT: #pragma omp atomic write
239 // CHECK-NEXT: a = argc + argc;
240 // CHECK-NEXT: #pragma omp atomic update
241 // CHECK-NEXT: a = a + argc;
242 // CHECK-NEXT: #pragma omp atomic capture
243 // CHECK-NEXT: a = b++;
244 // CHECK-NEXT: #pragma omp atomic capture
245 // CHECK-NEXT: {
246 // CHECK-NEXT: a = b;
247 // CHECK-NEXT: b++;
248 // CHECK-NEXT: }
249 // CHECK-51-NEXT: #pragma omp atomic compare
250 // CHECK-51-NEXT: {
251 // CHECK-51-NEXT: a = a > b ? b : a;
252 // CHECK-51-NEXT: }
253 // CHECK-51-NEXT: #pragma omp atomic compare
254 // CHECK-51-NEXT: {
255 // CHECK-51-NEXT: a = a < b ? b : a;
256 // CHECK-51-NEXT: }
257 // CHECK-51-NEXT: #pragma omp atomic compare
258 // CHECK-51-NEXT: {
259 // CHECK-51-NEXT: a = a == b ? c : a;
260 // CHECK-51-NEXT: }
261 // CHECK-51-NEXT: #pragma omp atomic compare capture
262 // CHECK-51-NEXT: {
263 // CHECK-51-NEXT: v = a;
264 // CHECK-51-NEXT: if (a > b) {
265 // CHECK-51-NEXT: a = b;
266 // CHECK-51-NEXT: }
267 // CHECK-51-NEXT: }
268 // CHECK-51-NEXT: #pragma omp atomic compare capture
269 // CHECK-51-NEXT: {
270 // CHECK-51-NEXT: v = a;
271 // CHECK-51-NEXT: if (a < b) {
272 // CHECK-51-NEXT: a = b;
273 // CHECK-51-NEXT: }
274 // CHECK-51-NEXT: }
275 // CHECK-51-NEXT: #pragma omp atomic compare capture
276 // CHECK-51-NEXT: {
277 // CHECK-51-NEXT: v = a == b;
278 // CHECK-51-NEXT: if (v)
279 // CHECK-51-NEXT: a = c;
280 // CHECK-51-NEXT: }
281 // CHECK-NEXT: #pragma omp atomic seq_cst
282 // CHECK-NEXT: a++;
283 // CHECK-NEXT: #pragma omp atomic read seq_cst
284 // CHECK-NEXT: a = argc;
285 // CHECK-NEXT: #pragma omp atomic seq_cst write
286 // CHECK-NEXT: a = argc + argc;
287 // CHECK-NEXT: #pragma omp atomic update seq_cst
288 // CHECK-NEXT: a = a + argc;
289 // CHECK-NEXT: #pragma omp atomic seq_cst capture
290 // CHECK-NEXT: a = b++;
291 // CHECK-NEXT: #pragma omp atomic capture seq_cst
292 // CHECK-NEXT: {
293 // CHECK-NEXT: a = b;
294 // CHECK-NEXT: b++;
295 // CHECK-NEXT: }
296 // CHECK-51-NEXT: #pragma omp atomic compare seq_cst
297 // CHECK-51-NEXT: {
298 // CHECK-51-NEXT: a = a > b ? b : a;
299 // CHECK-51-NEXT: }
300 // CHECK-51-NEXT: #pragma omp atomic seq_cst compare
301 // CHECK-51-NEXT: {
302 // CHECK-51-NEXT: a = a < b ? b : a;
303 // CHECK-51-NEXT: }
304 // CHECK-51-NEXT: #pragma omp atomic compare seq_cst
305 // CHECK-51-NEXT: {
306 // CHECK-51-NEXT: a = a == b ? c : a;
307 // CHECK-51-NEXT: }
308 // CHECK-51-NEXT: #pragma omp atomic compare capture seq_cst
309 // CHECK-51-NEXT: {
310 // CHECK-51-NEXT: v = a;
311 // CHECK-51-NEXT: if (a > b) {
312 // CHECK-51-NEXT: a = b;
313 // CHECK-51-NEXT: }
314 // CHECK-51-NEXT: }
315 // CHECK-51-NEXT: #pragma omp atomic compare seq_cst capture
316 // CHECK-51-NEXT: {
317 // CHECK-51-NEXT: v = a;
318 // CHECK-51-NEXT: if (a < b) {
319 // CHECK-51-NEXT: a = b;
320 // CHECK-51-NEXT: }
321 // CHECK-51-NEXT: }
322 // CHECK-51-NEXT: #pragma omp atomic compare capture seq_cst
323 // CHECK-51-NEXT: {
324 // CHECK-51-NEXT: v = a == b;
325 // CHECK-51-NEXT: if (v)
326 // CHECK-51-NEXT: a = c;
327 // CHECK-51-NEXT: }
328 // CHECK-NEXT: #pragma omp atomic
329 // CHECK-NEXT: a++;
330 // CHECK-NEXT: #pragma omp atomic read
331 // CHECK-NEXT: a = argc;
332 // CHECK-NEXT: #pragma omp atomic write
333 // CHECK-NEXT: a = argc + argc;
334 // CHECK-NEXT: #pragma omp atomic update
335 // CHECK-NEXT: a = a + argc;
336 // CHECK-NEXT: #pragma omp atomic acq_rel capture
337 // CHECK-NEXT: a = b++;
338 // CHECK-NEXT: #pragma omp atomic capture acq_rel
339 // CHECK-NEXT: {
340 // CHECK-NEXT: a = b;
341 // CHECK-NEXT: b++;
342 // CHECK-NEXT: }
343 // CHECK-51-NEXT: #pragma omp atomic compare acq_rel
344 // CHECK-51-NEXT: {
345 // CHECK-51-NEXT: a = a > b ? b : a;
346 // CHECK-51-NEXT: }
347 // CHECK-51-NEXT: #pragma omp atomic acq_rel compare
348 // CHECK-51-NEXT: {
349 // CHECK-51-NEXT: a = a < b ? b : a;
350 // CHECK-51-NEXT: }
351 // CHECK-51-NEXT: #pragma omp atomic compare acq_rel
352 // CHECK-51-NEXT: {
353 // CHECK-51-NEXT: a = a == b ? c : a;
354 // CHECK-51-NEXT: }
355 // CHECK-51-NEXT: #pragma omp atomic compare capture acq_rel
356 // CHECK-51-NEXT: {
357 // CHECK-51-NEXT: v = a;
358 // CHECK-51-NEXT: if (a > b) {
359 // CHECK-51-NEXT: a = b;
360 // CHECK-51-NEXT: }
361 // CHECK-51-NEXT: }
362 // CHECK-51-NEXT: #pragma omp atomic compare acq_rel capture
363 // CHECK-51-NEXT: {
364 // CHECK-51-NEXT: v = a;
365 // CHECK-51-NEXT: if (a < b) {
366 // CHECK-51-NEXT: a = b;
367 // CHECK-51-NEXT: }
368 // CHECK-51-NEXT: }
369 // CHECK-51-NEXT: #pragma omp atomic compare capture acq_rel
370 // CHECK-51-NEXT: {
371 // CHECK-51-NEXT: v = a == b;
372 // CHECK-51-NEXT: if (v)
373 // CHECK-51-NEXT: a = c;
374 // CHECK-51-NEXT: }
375 // CHECK-NEXT: #pragma omp atomic
376 // CHECK-NEXT: a++;
377 // CHECK-NEXT: #pragma omp atomic read acquire
378 // CHECK-NEXT: a = argc;
379 // CHECK-NEXT: #pragma omp atomic write
380 // CHECK-NEXT: a = argc + argc;
381 // CHECK-NEXT: #pragma omp atomic update
382 // CHECK-NEXT: a = a + argc;
383 // CHECK-NEXT: #pragma omp atomic acquire capture
384 // CHECK-NEXT: a = b++;
385 // CHECK-NEXT: #pragma omp atomic capture acquire
386 // CHECK-NEXT: {
387 // CHECK-NEXT: a = b;
388 // CHECK-NEXT: b++;
389 // CHECK-NEXT: }
390 // CHECK-51-NEXT: #pragma omp atomic compare acquire
391 // CHECK-51-NEXT: {
392 // CHECK-51-NEXT: a = a > b ? b : a;
393 // CHECK-51-NEXT: }
394 // CHECK-51-NEXT: #pragma omp atomic acquire compare
395 // CHECK-51-NEXT: {
396 // CHECK-51-NEXT: a = a < b ? b : a;
397 // CHECK-51-NEXT: }
398 // CHECK-51-NEXT: #pragma omp atomic compare acquire
399 // CHECK-51-NEXT: {
400 // CHECK-51-NEXT: a = a == b ? c : a;
401 // CHECK-51-NEXT: }
402 // CHECK-51-NEXT: #pragma omp atomic compare capture acquire
403 // CHECK-51-NEXT: {
404 // CHECK-51-NEXT: v = a;
405 // CHECK-51-NEXT: if (a > b) {
406 // CHECK-51-NEXT: a = b;
407 // CHECK-51-NEXT: }
408 // CHECK-51-NEXT: }
409 // CHECK-51-NEXT: #pragma omp atomic compare acquire capture
410 // CHECK-51-NEXT: {
411 // CHECK-51-NEXT: v = a;
412 // CHECK-51-NEXT: if (a < b) {
413 // CHECK-51-NEXT: a = b;
414 // CHECK-51-NEXT: }
415 // CHECK-51-NEXT: }
416 // CHECK-51-NEXT: #pragma omp atomic compare capture acquire
417 // CHECK-51-NEXT: {
418 // CHECK-51-NEXT: v = a == b;
419 // CHECK-51-NEXT: if (v)
420 // CHECK-51-NEXT: a = c;
421 // CHECK-51-NEXT: }
422 // CHECK-NEXT: #pragma omp atomic release
423 // CHECK-NEXT: a++;
424 // CHECK-NEXT: #pragma omp atomic read
425 // CHECK-NEXT: a = argc;
426 // CHECK-NEXT: #pragma omp atomic release write
427 // CHECK-NEXT: a = argc + argc;
428 // CHECK-NEXT: #pragma omp atomic update release
429 // CHECK-NEXT: a = a + argc;
430 // CHECK-NEXT: #pragma omp atomic release capture
431 // CHECK-NEXT: a = b++;
432 // CHECK-NEXT: #pragma omp atomic capture release
433 // CHECK-NEXT: {
434 // CHECK-NEXT: a = b;
435 // CHECK-NEXT: b++;
436 // CHECK-NEXT: }
437 // CHECK-51-NEXT: #pragma omp atomic compare release
438 // CHECK-51-NEXT: {
439 // CHECK-51-NEXT: a = a > b ? b : a;
440 // CHECK-51-NEXT: }
441 // CHECK-51-NEXT: #pragma omp atomic release compare
442 // CHECK-51-NEXT: {
443 // CHECK-51-NEXT: a = a < b ? b : a;
444 // CHECK-51-NEXT: }
445 // CHECK-51-NEXT: #pragma omp atomic compare release
446 // CHECK-51-NEXT: {
447 // CHECK-51-NEXT: a = a == b ? c : a;
448 // CHECK-51-NEXT: }
449 // CHECK-51-NEXT: #pragma omp atomic compare capture release
450 // CHECK-51-NEXT: {
451 // CHECK-51-NEXT: v = a;
452 // CHECK-51-NEXT: if (a > b) {
453 // CHECK-51-NEXT: a = b;
454 // CHECK-51-NEXT: }
455 // CHECK-51-NEXT: }
456 // CHECK-51-NEXT: #pragma omp atomic compare release capture
457 // CHECK-51-NEXT: {
458 // CHECK-51-NEXT: v = a;
459 // CHECK-51-NEXT: if (a < b) {
460 // CHECK-51-NEXT: a = b;
461 // CHECK-51-NEXT: }
462 // CHECK-51-NEXT: }
463 // CHECK-51-NEXT: #pragma omp atomic compare capture release
464 // CHECK-51-NEXT: {
465 // CHECK-51-NEXT: v = a == b;
466 // CHECK-51-NEXT: if (v)
467 // CHECK-51-NEXT: a = c;
468 // CHECK-51-NEXT: }
469 // CHECK-NEXT: #pragma omp atomic relaxed
470 // CHECK-NEXT: a++;
471 // CHECK-NEXT: #pragma omp atomic read
472 // CHECK-NEXT: a = argc;
473 // CHECK-NEXT: #pragma omp atomic relaxed write
474 // CHECK-NEXT: a = argc + argc;
475 // CHECK-NEXT: #pragma omp atomic update relaxed
476 // CHECK-NEXT: a = a + argc;
477 // CHECK-NEXT: #pragma omp atomic relaxed capture
478 // CHECK-NEXT: a = b++;
479 // CHECK-NEXT: #pragma omp atomic capture relaxed
480 // CHECK-NEXT: {
481 // CHECK-NEXT: a = b;
482 // CHECK-NEXT: b++;
483 // CHECK-NEXT: }
484 // CHECK-51-NEXT: #pragma omp atomic compare relaxed
485 // CHECK-51-NEXT: {
486 // CHECK-51-NEXT: a = a > b ? b : a;
487 // CHECK-51-NEXT: }
488 // CHECK-51-NEXT: #pragma omp atomic relaxed compare
489 // CHECK-51-NEXT: {
490 // CHECK-51-NEXT: a = a < b ? b : a;
491 // CHECK-51-NEXT: }
492 // CHECK-51-NEXT: #pragma omp atomic compare relaxed
493 // CHECK-51-NEXT: {
494 // CHECK-51-NEXT: a = a == b ? c : a;
495 // CHECK-51-NEXT: }
496 // CHECK-51-NEXT: #pragma omp atomic compare capture relaxed
497 // CHECK-51-NEXT: {
498 // CHECK-51-NEXT: v = a;
499 // CHECK-51-NEXT: if (a > b) {
500 // CHECK-51-NEXT: a = b;
501 // CHECK-51-NEXT: }
502 // CHECK-51-NEXT: }
503 // CHECK-51-NEXT: #pragma omp atomic compare relaxed capture
504 // CHECK-51-NEXT: {
505 // CHECK-51-NEXT: v = a;
506 // CHECK-51-NEXT: if (a < b) {
507 // CHECK-51-NEXT: a = b;
508 // CHECK-51-NEXT: }
509 // CHECK-51-NEXT: }
510 // CHECK-51-NEXT: #pragma omp atomic compare capture relaxed
511 // CHECK-51-NEXT: {
512 // CHECK-51-NEXT: v = a == b;
513 // CHECK-51-NEXT: if (v)
514 // CHECK-51-NEXT: a = c;
515 // CHECK-51-NEXT: }
516 // CHECK-NEXT: #pragma omp atomic hint(6)
517 // CHECK-NEXT: a++;
518 // CHECK-NEXT: #pragma omp atomic read hint(6)
519 // CHECK-NEXT: a = argc;
520 // CHECK-NEXT: #pragma omp atomic hint(6) write
521 // CHECK-NEXT: a = argc + argc;
522 // CHECK-NEXT: #pragma omp atomic update hint(6)
523 // CHECK-NEXT: a = a + argc;
524 // CHECK-NEXT: #pragma omp atomic hint(6) capture
525 // CHECK-NEXT: a = b++;
526 // CHECK-NEXT: #pragma omp atomic capture hint(6)
527 // CHECK-NEXT: {
528 // CHECK-NEXT: a = b;
529 // CHECK-NEXT: b++;
530 // CHECK-NEXT: }
531 // CHECK-51-NEXT: #pragma omp atomic compare hint(6)
532 // CHECK-51-NEXT: {
533 // CHECK-51-NEXT: a = a > b ? b : a;
534 // CHECK-51-NEXT: }
535 // CHECK-51-NEXT: #pragma omp atomic hint(6) compare
536 // CHECK-51-NEXT: {
537 // CHECK-51-NEXT: a = a < b ? b : a;
538 // CHECK-51-NEXT: }
539 // CHECK-51-NEXT: #pragma omp atomic compare hint(6)
540 // CHECK-51-NEXT: {
541 // CHECK-51-NEXT: a = a == b ? c : a;
542 // CHECK-51-NEXT: }
543 // CHECK-51-NEXT: #pragma omp atomic compare capture hint(6)
544 // CHECK-51-NEXT: {
545 // CHECK-51-NEXT: v = a;
546 // CHECK-51-NEXT: if (a > b) {
547 // CHECK-51-NEXT: a = b;
548 // CHECK-51-NEXT: }
549 // CHECK-51-NEXT: }
550 // CHECK-51-NEXT: #pragma omp atomic compare hint(6) capture
551 // CHECK-51-NEXT: {
552 // CHECK-51-NEXT: v = a;
553 // CHECK-51-NEXT: if (a < b) {
554 // CHECK-51-NEXT: a = b;
555 // CHECK-51-NEXT: }
556 // CHECK-51-NEXT: }
557 // CHECK-51-NEXT: #pragma omp atomic compare capture hint(6)
558 // CHECK-51-NEXT: {
559 // CHECK-51-NEXT: v = a == b;
560 // CHECK-51-NEXT: if (v)
561 // CHECK-51-NEXT: a = c;
562 // CHECK-51-NEXT: }
563 // CHECK: int a = int();
564 // CHECK-NEXT: #pragma omp atomic
565 // CHECK-NEXT: a++;
566 // CHECK-NEXT: #pragma omp atomic read
567 // CHECK-NEXT: a = argc;
568 // CHECK-NEXT: #pragma omp atomic write
569 // CHECK-NEXT: a = argc + argc;
570 // CHECK-NEXT: #pragma omp atomic update
571 // CHECK-NEXT: a = a + argc;
572 // CHECK-NEXT: #pragma omp atomic capture
573 // CHECK-NEXT: a = b++;
574 // CHECK-NEXT: #pragma omp atomic capture
575 // CHECK-NEXT: {
576 // CHECK-NEXT: a = b;
577 // CHECK-NEXT: b++;
578 // CHECK-NEXT: }
579 // CHECK-51-NEXT: #pragma omp atomic compare
580 // CHECK-51-NEXT: {
581 // CHECK-51-NEXT: a = a > b ? b : a;
582 // CHECK-51-NEXT: }
583 // CHECK-51-NEXT: #pragma omp atomic compare
584 // CHECK-51-NEXT: {
585 // CHECK-51-NEXT: a = a < b ? b : a;
586 // CHECK-51-NEXT: }
587 // CHECK-51-NEXT: #pragma omp atomic compare
588 // CHECK-51-NEXT: {
589 // CHECK-51-NEXT: a = a == b ? c : a;
590 // CHECK-51-NEXT: }
591 // CHECK-51-NEXT: #pragma omp atomic compare capture
592 // CHECK-51-NEXT: {
593 // CHECK-51-NEXT: v = a;
594 // CHECK-51-NEXT: if (a > b) {
595 // CHECK-51-NEXT: a = b;
596 // CHECK-51-NEXT: }
597 // CHECK-51-NEXT: }
598 // CHECK-51-NEXT: #pragma omp atomic compare capture
599 // CHECK-51-NEXT: {
600 // CHECK-51-NEXT: v = a;
601 // CHECK-51-NEXT: if (a < b) {
602 // CHECK-51-NEXT: a = b;
603 // CHECK-51-NEXT: }
604 // CHECK-51-NEXT: }
605 // CHECK-51-NEXT: #pragma omp atomic compare capture
606 // CHECK-51-NEXT: {
607 // CHECK-51-NEXT: v = a == b;
608 // CHECK-51-NEXT: if (v)
609 // CHECK-51-NEXT: a = c;
610 // CHECK-51-NEXT: }
611 // CHECK-NEXT: #pragma omp atomic seq_cst
612 // CHECK-NEXT: a++;
613 // CHECK-NEXT: #pragma omp atomic read seq_cst
614 // CHECK-NEXT: a = argc;
615 // CHECK-NEXT: #pragma omp atomic seq_cst write
616 // CHECK-NEXT: a = argc + argc;
617 // CHECK-NEXT: #pragma omp atomic update seq_cst
618 // CHECK-NEXT: a = a + argc;
619 // CHECK-NEXT: #pragma omp atomic seq_cst capture
620 // CHECK-NEXT: a = b++;
621 // CHECK-NEXT: #pragma omp atomic capture seq_cst
622 // CHECK-NEXT: {
623 // CHECK-NEXT: a = b;
624 // CHECK-NEXT: b++;
625 // CHECK-NEXT: }
626 // CHECK-51-NEXT: #pragma omp atomic compare seq_cst
627 // CHECK-51-NEXT: {
628 // CHECK-51-NEXT: a = a > b ? b : a;
629 // CHECK-51-NEXT: }
630 // CHECK-51-NEXT: #pragma omp atomic seq_cst compare
631 // CHECK-51-NEXT: {
632 // CHECK-51-NEXT: a = a < b ? b : a;
633 // CHECK-51-NEXT: }
634 // CHECK-51-NEXT: #pragma omp atomic compare seq_cst
635 // CHECK-51-NEXT: {
636 // CHECK-51-NEXT: a = a == b ? c : a;
637 // CHECK-51-NEXT: }
638 // CHECK-51-NEXT: #pragma omp atomic compare capture seq_cst
639 // CHECK-51-NEXT: {
640 // CHECK-51-NEXT: v = a;
641 // CHECK-51-NEXT: if (a > b) {
642 // CHECK-51-NEXT: a = b;
643 // CHECK-51-NEXT: }
644 // CHECK-51-NEXT: }
645 // CHECK-51-NEXT: #pragma omp atomic compare seq_cst capture
646 // CHECK-51-NEXT: {
647 // CHECK-51-NEXT: v = a;
648 // CHECK-51-NEXT: if (a < b) {
649 // CHECK-51-NEXT: a = b;
650 // CHECK-51-NEXT: }
651 // CHECK-51-NEXT: }
652 // CHECK-51-NEXT: #pragma omp atomic compare capture seq_cst
653 // CHECK-51-NEXT: {
654 // CHECK-51-NEXT: v = a == b;
655 // CHECK-51-NEXT: if (v)
656 // CHECK-51-NEXT: a = c;
657 // CHECK-51-NEXT: }
658 // CHECK-NEXT: #pragma omp atomic
659 // CHECK-NEXT: a++;
660 // CHECK-NEXT: #pragma omp atomic read
661 // CHECK-NEXT: a = argc;
662 // CHECK-NEXT: #pragma omp atomic write
663 // CHECK-NEXT: a = argc + argc;
664 // CHECK-NEXT: #pragma omp atomic update
665 // CHECK-NEXT: a = a + argc;
666 // CHECK-NEXT: #pragma omp atomic acq_rel capture
667 // CHECK-NEXT: a = b++;
668 // CHECK-NEXT: #pragma omp atomic capture acq_rel
669 // CHECK-NEXT: {
670 // CHECK-NEXT: a = b;
671 // CHECK-NEXT: b++;
672 // CHECK-NEXT: }
673 // CHECK-51-NEXT: #pragma omp atomic compare acq_rel
674 // CHECK-51-NEXT: {
675 // CHECK-51-NEXT: a = a > b ? b : a;
676 // CHECK-51-NEXT: }
677 // CHECK-51-NEXT: #pragma omp atomic acq_rel compare
678 // CHECK-51-NEXT: {
679 // CHECK-51-NEXT: a = a < b ? b : a;
680 // CHECK-51-NEXT: }
681 // CHECK-51-NEXT: #pragma omp atomic compare acq_rel
682 // CHECK-51-NEXT: {
683 // CHECK-51-NEXT: a = a == b ? c : a;
684 // CHECK-51-NEXT: }
685 // CHECK-51-NEXT: #pragma omp atomic compare capture acq_rel
686 // CHECK-51-NEXT: {
687 // CHECK-51-NEXT: v = a;
688 // CHECK-51-NEXT: if (a > b) {
689 // CHECK-51-NEXT: a = b;
690 // CHECK-51-NEXT: }
691 // CHECK-51-NEXT: }
692 // CHECK-51-NEXT: #pragma omp atomic compare acq_rel capture
693 // CHECK-51-NEXT: {
694 // CHECK-51-NEXT: v = a;
695 // CHECK-51-NEXT: if (a < b) {
696 // CHECK-51-NEXT: a = b;
697 // CHECK-51-NEXT: }
698 // CHECK-51-NEXT: }
699 // CHECK-51-NEXT: #pragma omp atomic compare capture acq_rel
700 // CHECK-51-NEXT: {
701 // CHECK-51-NEXT: v = a == b;
702 // CHECK-51-NEXT: if (v)
703 // CHECK-51-NEXT: a = c;
704 // CHECK-51-NEXT: }
705 // CHECK-NEXT: #pragma omp atomic
706 // CHECK-NEXT: a++;
707 // CHECK-NEXT: #pragma omp atomic read acquire
708 // CHECK-NEXT: a = argc;
709 // CHECK-NEXT: #pragma omp atomic write
710 // CHECK-NEXT: a = argc + argc;
711 // CHECK-NEXT: #pragma omp atomic update
712 // CHECK-NEXT: a = a + argc;
713 // CHECK-NEXT: #pragma omp atomic acquire capture
714 // CHECK-NEXT: a = b++;
715 // CHECK-NEXT: #pragma omp atomic capture acquire
716 // CHECK-NEXT: {
717 // CHECK-NEXT: a = b;
718 // CHECK-NEXT: b++;
719 // CHECK-NEXT: }
720 // CHECK-51-NEXT: #pragma omp atomic compare acquire
721 // CHECK-51-NEXT: {
722 // CHECK-51-NEXT: a = a > b ? b : a;
723 // CHECK-51-NEXT: }
724 // CHECK-51-NEXT: #pragma omp atomic acquire compare
725 // CHECK-51-NEXT: {
726 // CHECK-51-NEXT: a = a < b ? b : a;
727 // CHECK-51-NEXT: }
728 // CHECK-51-NEXT: #pragma omp atomic compare acquire
729 // CHECK-51-NEXT: {
730 // CHECK-51-NEXT: a = a == b ? c : a;
731 // CHECK-51-NEXT: }
732 // CHECK-51-NEXT: #pragma omp atomic compare capture acquire
733 // CHECK-51-NEXT: {
734 // CHECK-51-NEXT: v = a;
735 // CHECK-51-NEXT: if (a > b) {
736 // CHECK-51-NEXT: a = b;
737 // CHECK-51-NEXT: }
738 // CHECK-51-NEXT: }
739 // CHECK-51-NEXT: #pragma omp atomic compare acquire capture
740 // CHECK-51-NEXT: {
741 // CHECK-51-NEXT: v = a;
742 // CHECK-51-NEXT: if (a < b) {
743 // CHECK-51-NEXT: a = b;
744 // CHECK-51-NEXT: }
745 // CHECK-51-NEXT: }
746 // CHECK-51-NEXT: #pragma omp atomic compare capture acquire
747 // CHECK-51-NEXT: {
748 // CHECK-51-NEXT: v = a == b;
749 // CHECK-51-NEXT: if (v)
750 // CHECK-51-NEXT: a = c;
751 // CHECK-51-NEXT: }
752 // CHECK-NEXT: #pragma omp atomic release
753 // CHECK-NEXT: a++;
754 // CHECK-NEXT: #pragma omp atomic read
755 // CHECK-NEXT: a = argc;
756 // CHECK-NEXT: #pragma omp atomic release write
757 // CHECK-NEXT: a = argc + argc;
758 // CHECK-NEXT: #pragma omp atomic update release
759 // CHECK-NEXT: a = a + argc;
760 // CHECK-NEXT: #pragma omp atomic release capture
761 // CHECK-NEXT: a = b++;
762 // CHECK-NEXT: #pragma omp atomic capture release
763 // CHECK-NEXT: {
764 // CHECK-NEXT: a = b;
765 // CHECK-NEXT: b++;
766 // CHECK-NEXT: }
767 // CHECK-51-NEXT: #pragma omp atomic compare release
768 // CHECK-51-NEXT: {
769 // CHECK-51-NEXT: a = a > b ? b : a;
770 // CHECK-51-NEXT: }
771 // CHECK-51-NEXT: #pragma omp atomic release compare
772 // CHECK-51-NEXT: {
773 // CHECK-51-NEXT: a = a < b ? b : a;
774 // CHECK-51-NEXT: }
775 // CHECK-51-NEXT: #pragma omp atomic compare release
776 // CHECK-51-NEXT: {
777 // CHECK-51-NEXT: a = a == b ? c : a;
778 // CHECK-51-NEXT: }
779 // CHECK-51-NEXT: #pragma omp atomic compare capture release
780 // CHECK-51-NEXT: {
781 // CHECK-51-NEXT: v = a;
782 // CHECK-51-NEXT: if (a > b) {
783 // CHECK-51-NEXT: a = b;
784 // CHECK-51-NEXT: }
785 // CHECK-51-NEXT: }
786 // CHECK-51-NEXT: #pragma omp atomic compare release capture
787 // CHECK-51-NEXT: {
788 // CHECK-51-NEXT: v = a;
789 // CHECK-51-NEXT: if (a < b) {
790 // CHECK-51-NEXT: a = b;
791 // CHECK-51-NEXT: }
792 // CHECK-51-NEXT: }
793 // CHECK-51-NEXT: #pragma omp atomic compare capture release
794 // CHECK-51-NEXT: {
795 // CHECK-51-NEXT: v = a == b;
796 // CHECK-51-NEXT: if (v)
797 // CHECK-51-NEXT: a = c;
798 // CHECK-51-NEXT: }
799 // CHECK-NEXT: #pragma omp atomic relaxed
800 // CHECK-NEXT: a++;
801 // CHECK-NEXT: #pragma omp atomic read
802 // CHECK-NEXT: a = argc;
803 // CHECK-NEXT: #pragma omp atomic relaxed write
804 // CHECK-NEXT: a = argc + argc;
805 // CHECK-NEXT: #pragma omp atomic update relaxed
806 // CHECK-NEXT: a = a + argc;
807 // CHECK-NEXT: #pragma omp atomic relaxed capture
808 // CHECK-NEXT: a = b++;
809 // CHECK-NEXT: #pragma omp atomic capture relaxed
810 // CHECK-NEXT: {
811 // CHECK-NEXT: a = b;
812 // CHECK-NEXT: b++;
813 // CHECK-NEXT: }
814 // CHECK-51-NEXT: #pragma omp atomic compare relaxed
815 // CHECK-51-NEXT: {
816 // CHECK-51-NEXT: a = a > b ? b : a;
817 // CHECK-51-NEXT: }
818 // CHECK-51-NEXT: #pragma omp atomic relaxed compare
819 // CHECK-51-NEXT: {
820 // CHECK-51-NEXT: a = a < b ? b : a;
821 // CHECK-51-NEXT: }
822 // CHECK-51-NEXT: #pragma omp atomic compare relaxed
823 // CHECK-51-NEXT: {
824 // CHECK-51-NEXT: a = a == b ? c : a;
825 // CHECK-51-NEXT: }
826 // CHECK-51-NEXT: #pragma omp atomic compare capture relaxed
827 // CHECK-51-NEXT: {
828 // CHECK-51-NEXT: v = a;
829 // CHECK-51-NEXT: if (a > b) {
830 // CHECK-51-NEXT: a = b;
831 // CHECK-51-NEXT: }
832 // CHECK-51-NEXT: }
833 // CHECK-51-NEXT: #pragma omp atomic compare relaxed capture
834 // CHECK-51-NEXT: {
835 // CHECK-51-NEXT: v = a;
836 // CHECK-51-NEXT: if (a < b) {
837 // CHECK-51-NEXT: a = b;
838 // CHECK-51-NEXT: }
839 // CHECK-51-NEXT: }
840 // CHECK-51-NEXT: #pragma omp atomic compare capture relaxed
841 // CHECK-51-NEXT: {
842 // CHECK-51-NEXT: v = a == b;
843 // CHECK-51-NEXT: if (v)
844 // CHECK-51-NEXT: a = c;
845 // CHECK-51-NEXT: }
846 // CHECK-NEXT: #pragma omp atomic hint(6)
847 // CHECK-NEXT: a++;
848 // CHECK-NEXT: #pragma omp atomic read hint(6)
849 // CHECK-NEXT: a = argc;
850 // CHECK-NEXT: #pragma omp atomic hint(6) write
851 // CHECK-NEXT: a = argc + argc;
852 // CHECK-NEXT: #pragma omp atomic update hint(6)
853 // CHECK-NEXT: a = a + argc;
854 // CHECK-NEXT: #pragma omp atomic hint(6) capture
855 // CHECK-NEXT: a = b++;
856 // CHECK-NEXT: #pragma omp atomic capture hint(6)
857 // CHECK-NEXT: {
858 // CHECK-NEXT: a = b;
859 // CHECK-NEXT: b++;
860 // CHECK-NEXT: }
861 // CHECK-51-NEXT: #pragma omp atomic compare hint(6)
862 // CHECK-51-NEXT: {
863 // CHECK-51-NEXT: a = a > b ? b : a;
864 // CHECK-51-NEXT: }
865 // CHECK-51-NEXT: #pragma omp atomic hint(6) compare
866 // CHECK-51-NEXT: {
867 // CHECK-51-NEXT: a = a < b ? b : a;
868 // CHECK-51-NEXT: }
869 // CHECK-51-NEXT: #pragma omp atomic compare hint(6)
870 // CHECK-51-NEXT: {
871 // CHECK-51-NEXT: a = a == b ? c : a;
872 // CHECK-51-NEXT: }
873 // CHECK-51-NEXT: #pragma omp atomic compare capture hint(6)
874 // CHECK-51-NEXT: {
875 // CHECK-51-NEXT: v = a;
876 // CHECK-51-NEXT: if (a > b) {
877 // CHECK-51-NEXT: a = b;
878 // CHECK-51-NEXT: }
879 // CHECK-51-NEXT: }
880 // CHECK-51-NEXT: #pragma omp atomic compare hint(6) capture
881 // CHECK-51-NEXT: {
882 // CHECK-51-NEXT: v = a;
883 // CHECK-51-NEXT: if (a < b) {
884 // CHECK-51-NEXT: a = b;
885 // CHECK-51-NEXT: }
886 // CHECK-51-NEXT: }
887 // CHECK-51-NEXT: #pragma omp atomic compare capture hint(6)
888 // CHECK-51-NEXT: {
889 // CHECK-51-NEXT: v = a == b;
890 // CHECK-51-NEXT: if (v)
891 // CHECK-51-NEXT: a = c;
892 // CHECK-51-NEXT: }
893 
894 int main(int argc, char **argv) {
895   int v = 0;
896   int c = 0;
897   int b = 0;
898   int a = 0;
899 // CHECK: int a = 0;
900 #pragma omp atomic
901   a++;
902 #pragma omp atomic read
903   a = argc;
904 #pragma omp atomic write
905   a = argc + argc;
906 #pragma omp atomic update
907   a = a + argc;
908 #pragma omp atomic capture
909   a = b++;
910 #pragma omp atomic capture
911   {
912     a = b;
913     b++;
914   }
915 #ifdef OMP51
916 #pragma omp atomic compare
917   { a = a > b ? b : a; }
918 #pragma omp atomic compare
919   { a = a < b ? b : a; }
920 #pragma omp atomic compare
921   { a = a == b ? c : a; }
922 #pragma omp atomic compare capture
923   { v = a; if (a > b) { a = b; } }
924 #pragma omp atomic compare capture
925   { v = a; if (a < b) { a = b; } }
926 #pragma omp atomic compare capture
927   { v = a == b; if (v) a = c; }
928 #endif
929 #pragma omp atomic seq_cst
930   a++;
931 #pragma omp atomic read seq_cst
932   a = argc;
933 #pragma omp atomic seq_cst write
934   a = argc + argc;
935 #pragma omp atomic update seq_cst
936   a = a + argc;
937 #pragma omp atomic seq_cst capture
938   a = b++;
939 #pragma omp atomic capture seq_cst
940   {
941     a = b;
942     b++;
943   }
944 #ifdef OMP51
945 #pragma omp atomic compare seq_cst
946   { a = a > b ? b : a; }
947 #pragma omp atomic seq_cst compare
948   { a = a < b ? b : a; }
949 #pragma omp atomic compare seq_cst
950   { a = a == b ? c : a; }
951 #pragma omp atomic compare capture seq_cst
952   { v = a; if (a > b) { a = b; } }
953 #pragma omp atomic compare seq_cst capture
954   { v = a; if (a < b) { a = b; } }
955 #pragma omp atomic compare capture seq_cst
956   { v = a == b; if (v) a = c; }
957 #endif
958 #pragma omp atomic
959   a++;
960 #pragma omp atomic read
961   a = argc;
962 #pragma omp atomic write
963   a = argc + argc;
964 #pragma omp atomic update
965   a = a + argc;
966 #pragma omp atomic acq_rel capture
967   a = b++;
968 #pragma omp atomic capture acq_rel
969   {
970     a = b;
971     b++;
972   }
973 #ifdef OMP51
974 #pragma omp atomic compare acq_rel
975   { a = a > b ? b : a; }
976 #pragma omp atomic acq_rel compare
977   { a = a < b ? b : a; }
978 #pragma omp atomic compare acq_rel
979   { a = a == b ? c : a; }
980 #pragma omp atomic compare capture acq_rel
981   { v = a; if (a > b) { a = b; } }
982 #pragma omp atomic compare acq_rel capture
983   { v = a; if (a < b) { a = b; } }
984 #pragma omp atomic compare capture acq_rel
985   { v = a == b; if (v) a = c; }
986 #endif
987 #pragma omp atomic
988   a++;
989 #pragma omp atomic read acquire
990   a = argc;
991 #pragma omp atomic write
992   a = argc + argc;
993 #pragma omp atomic update
994   a = a + argc;
995 #pragma omp atomic acquire capture
996   a = b++;
997 #pragma omp atomic capture acquire
998   {
999     a = b;
1000     b++;
1001   }
1002 #ifdef OMP51
1003 #pragma omp atomic compare acquire
1004   { a = a > b ? b : a; }
1005 #pragma omp atomic acquire compare
1006   { a = a < b ? b : a; }
1007 #pragma omp atomic compare acquire
1008   { a = a == b ? c : a; }
1009 #pragma omp atomic compare capture acquire
1010   { v = a; if (a > b) { a = b; } }
1011 #pragma omp atomic compare acquire capture
1012   { v = a; if (a < b) { a = b; } }
1013 #pragma omp atomic compare capture acquire
1014   { v = a == b; if (v) a = c; }
1015 #endif
1016 #pragma omp atomic release
1017   a++;
1018 #pragma omp atomic read
1019   a = argc;
1020 #pragma omp atomic release write
1021   a = argc + argc;
1022 #pragma omp atomic update release
1023   a = a + argc;
1024 #pragma omp atomic release capture
1025   a = b++;
1026 #pragma omp atomic capture release
1027   {
1028     a = b;
1029     b++;
1030   }
1031 #ifdef OMP51
1032 #pragma omp atomic compare release
1033   { a = a > b ? b : a; }
1034 #pragma omp atomic release compare
1035   { a = a < b ? b : a; }
1036 #pragma omp atomic compare release
1037   { a = a == b ? c : a; }
1038 #pragma omp atomic compare capture release
1039   { v = a; if (a > b) { a = b; } }
1040 #pragma omp atomic compare release capture
1041   { v = a; if (a < b) { a = b; } }
1042 #pragma omp atomic compare capture release
1043   { v = a == b; if (v) a = c; }
1044 #endif
1045 #pragma omp atomic relaxed
1046   a++;
1047 #pragma omp atomic read
1048   a = argc;
1049 #pragma omp atomic relaxed write
1050   a = argc + argc;
1051 #pragma omp atomic update relaxed
1052   a = a + argc;
1053 #pragma omp atomic relaxed capture
1054   a = b++;
1055 #pragma omp atomic capture relaxed
1056   {
1057     a = b;
1058     b++;
1059   }
1060 #ifdef OMP51
1061 #pragma omp atomic compare relaxed
1062   { a = a > b ? b : a; }
1063 #pragma omp atomic relaxed compare
1064   { a = a < b ? b : a; }
1065 #pragma omp atomic compare relaxed
1066   { a = a == b ? c : a; }
1067 #pragma omp atomic compare capture relaxed
1068   { v = a; if (a > b) { a = b; } }
1069 #pragma omp atomic compare relaxed capture
1070   { v = a; if (a < b) { a = b; } }
1071 #pragma omp atomic compare capture relaxed
1072   { v = a == b; if (v) a = c; }
1073 #endif
1074 #pragma omp atomic hint(6)
1075   a++;
1076 #pragma omp atomic read hint(6)
1077   a = argc;
1078 #pragma omp atomic hint(6) write
1079   a = argc + argc;
1080 #pragma omp atomic update hint(6)
1081   a = a + argc;
1082 #pragma omp atomic hint(6) capture
1083   a = b++;
1084 #pragma omp atomic capture hint(6)
1085   {
1086     a = b;
1087     b++;
1088   }
1089 #ifdef OMP51
1090 #pragma omp atomic compare hint(6)
1091   { a = a > b ? b : a; }
1092 #pragma omp atomic hint(6) compare
1093   { a = a < b ? b : a; }
1094 #pragma omp atomic compare hint(6)
1095   { a = a == b ? c : a; }
1096 #pragma omp atomic compare capture hint(6)
1097   { v = a; if (a > b) { a = b; } }
1098 #pragma omp atomic compare hint(6) capture
1099   { v = a; if (a < b) { a = b; } }
1100 #pragma omp atomic compare capture hint(6)
1101   { v = a == b; if (v) a = c; }
1102 #endif
1103   // CHECK-NEXT: #pragma omp atomic
1104   // CHECK-NEXT: a++;
1105   // CHECK-NEXT: #pragma omp atomic read
1106   // CHECK-NEXT: a = argc;
1107   // CHECK-NEXT: #pragma omp atomic write
1108   // CHECK-NEXT: a = argc + argc;
1109   // CHECK-NEXT: #pragma omp atomic update
1110   // CHECK-NEXT: a = a + argc;
1111   // CHECK-NEXT: #pragma omp atomic capture
1112   // CHECK-NEXT: a = b++;
1113   // CHECK-NEXT: #pragma omp atomic capture
1114   // CHECK-NEXT: {
1115   // CHECK-NEXT: a = b;
1116   // CHECK-NEXT: b++;
1117   // CHECK-NEXT: }
1118   // CHECK-51-NEXT: #pragma omp atomic compare
1119   // CHECK-51-NEXT: {
1120   // CHECK-51-NEXT: a = a > b ? b : a;
1121   // CHECK-51-NEXT: }
1122   // CHECK-51-NEXT: #pragma omp atomic compare
1123   // CHECK-51-NEXT: {
1124   // CHECK-51-NEXT: a = a < b ? b : a;
1125   // CHECK-51-NEXT: }
1126   // CHECK-51-NEXT: #pragma omp atomic compare
1127   // CHECK-51-NEXT: {
1128   // CHECK-51-NEXT: a = a == b ? c : a;
1129   // CHECK-51-NEXT: }
1130   // CHECK-51-NEXT: #pragma omp atomic compare capture
1131   // CHECK-51-NEXT: {
1132   // CHECK-51-NEXT: v = a;
1133   // CHECK-51-NEXT: if (a > b) {
1134   // CHECK-51-NEXT: a = b;
1135   // CHECK-51-NEXT: }
1136   // CHECK-51-NEXT: }
1137   // CHECK-51-NEXT: #pragma omp atomic compare capture
1138   // CHECK-51-NEXT: {
1139   // CHECK-51-NEXT: v = a;
1140   // CHECK-51-NEXT: if (a < b) {
1141   // CHECK-51-NEXT: a = b;
1142   // CHECK-51-NEXT: }
1143   // CHECK-51-NEXT: }
1144   // CHECK-51-NEXT: #pragma omp atomic compare capture
1145   // CHECK-51-NEXT: {
1146   // CHECK-51-NEXT: v = a == b;
1147   // CHECK-51-NEXT: if (v)
1148   // CHECK-51-NEXT: a = c;
1149   // CHECK-51-NEXT: }
1150   // CHECK-NEXT: #pragma omp atomic seq_cst
1151   // CHECK-NEXT: a++;
1152   // CHECK-NEXT: #pragma omp atomic read seq_cst
1153   // CHECK-NEXT: a = argc;
1154   // CHECK-NEXT: #pragma omp atomic seq_cst write
1155   // CHECK-NEXT: a = argc + argc;
1156   // CHECK-NEXT: #pragma omp atomic update seq_cst
1157   // CHECK-NEXT: a = a + argc;
1158   // CHECK-NEXT: #pragma omp atomic seq_cst capture
1159   // CHECK-NEXT: a = b++;
1160   // CHECK-NEXT: #pragma omp atomic capture seq_cst
1161   // CHECK-NEXT: {
1162   // CHECK-NEXT: a = b;
1163   // CHECK-NEXT: b++;
1164   // CHECK-NEXT: }
1165   // CHECK-51-NEXT: #pragma omp atomic compare seq_cst
1166   // CHECK-51-NEXT: {
1167   // CHECK-51-NEXT: a = a > b ? b : a;
1168   // CHECK-51-NEXT: }
1169   // CHECK-51-NEXT: #pragma omp atomic seq_cst compare
1170   // CHECK-51-NEXT: {
1171   // CHECK-51-NEXT: a = a < b ? b : a;
1172   // CHECK-51-NEXT: }
1173   // CHECK-51-NEXT: #pragma omp atomic compare seq_cst
1174   // CHECK-51-NEXT: {
1175   // CHECK-51-NEXT: a = a == b ? c : a;
1176   // CHECK-51-NEXT: }
1177   // CHECK-51-NEXT: #pragma omp atomic compare capture seq_cst
1178   // CHECK-51-NEXT: {
1179   // CHECK-51-NEXT: v = a;
1180   // CHECK-51-NEXT: if (a > b) {
1181   // CHECK-51-NEXT: a = b;
1182   // CHECK-51-NEXT: }
1183   // CHECK-51-NEXT: }
1184   // CHECK-51-NEXT: #pragma omp atomic compare seq_cst capture
1185   // CHECK-51-NEXT: {
1186   // CHECK-51-NEXT: v = a;
1187   // CHECK-51-NEXT: if (a < b) {
1188   // CHECK-51-NEXT: a = b;
1189   // CHECK-51-NEXT: }
1190   // CHECK-51-NEXT: }
1191   // CHECK-51-NEXT: #pragma omp atomic compare capture seq_cst
1192   // CHECK-51-NEXT: {
1193   // CHECK-51-NEXT: v = a == b;
1194   // CHECK-51-NEXT: if (v)
1195   // CHECK-51-NEXT: a = c;
1196   // CHECK-51-NEXT: }
1197   // CHECK-NEXT: #pragma omp atomic
1198   // CHECK-NEXT: a++;
1199   // CHECK-NEXT: #pragma omp atomic read
1200   // CHECK-NEXT: a = argc;
1201   // CHECK-NEXT: #pragma omp atomic write
1202   // CHECK-NEXT: a = argc + argc;
1203   // CHECK-NEXT: #pragma omp atomic update
1204   // CHECK-NEXT: a = a + argc;
1205   // CHECK-NEXT: #pragma omp atomic acq_rel capture
1206   // CHECK-NEXT: a = b++;
1207   // CHECK-NEXT: #pragma omp atomic capture acq_rel
1208   // CHECK-NEXT: {
1209   // CHECK-NEXT: a = b;
1210   // CHECK-NEXT: b++;
1211   // CHECK-NEXT: }
1212   // CHECK-51-NEXT: #pragma omp atomic compare acq_rel
1213   // CHECK-51-NEXT: {
1214   // CHECK-51-NEXT: a = a > b ? b : a;
1215   // CHECK-51-NEXT: }
1216   // CHECK-51-NEXT: #pragma omp atomic acq_rel compare
1217   // CHECK-51-NEXT: {
1218   // CHECK-51-NEXT: a = a < b ? b : a;
1219   // CHECK-51-NEXT: }
1220   // CHECK-51-NEXT: #pragma omp atomic compare acq_rel
1221   // CHECK-51-NEXT: {
1222   // CHECK-51-NEXT: a = a == b ? c : a;
1223   // CHECK-51-NEXT: }
1224   // CHECK-51-NEXT: #pragma omp atomic compare capture acq_rel
1225   // CHECK-51-NEXT: {
1226   // CHECK-51-NEXT: v = a;
1227   // CHECK-51-NEXT: if (a > b) {
1228   // CHECK-51-NEXT: a = b;
1229   // CHECK-51-NEXT: }
1230   // CHECK-51-NEXT: }
1231   // CHECK-51-NEXT: #pragma omp atomic compare acq_rel capture
1232   // CHECK-51-NEXT: {
1233   // CHECK-51-NEXT: v = a;
1234   // CHECK-51-NEXT: if (a < b) {
1235   // CHECK-51-NEXT: a = b;
1236   // CHECK-51-NEXT: }
1237   // CHECK-51-NEXT: }
1238   // CHECK-51-NEXT: #pragma omp atomic compare capture acq_rel
1239   // CHECK-51-NEXT: {
1240   // CHECK-51-NEXT: v = a == b;
1241   // CHECK-51-NEXT: if (v)
1242   // CHECK-51-NEXT: a = c;
1243   // CHECK-51-NEXT: }
1244   // CHECK-NEXT: #pragma omp atomic
1245   // CHECK-NEXT: a++;
1246   // CHECK-NEXT: #pragma omp atomic read acquire
1247   // CHECK-NEXT: a = argc;
1248   // CHECK-NEXT: #pragma omp atomic write
1249   // CHECK-NEXT: a = argc + argc;
1250   // CHECK-NEXT: #pragma omp atomic update
1251   // CHECK-NEXT: a = a + argc;
1252   // CHECK-NEXT: #pragma omp atomic acquire capture
1253   // CHECK-NEXT: a = b++;
1254   // CHECK-NEXT: #pragma omp atomic capture acquire
1255   // CHECK-NEXT: {
1256   // CHECK-NEXT: a = b;
1257   // CHECK-NEXT: b++;
1258   // CHECK-NEXT: }
1259   // CHECK-51-NEXT: #pragma omp atomic compare acquire
1260   // CHECK-51-NEXT: {
1261   // CHECK-51-NEXT: a = a > b ? b : a;
1262   // CHECK-51-NEXT: }
1263   // CHECK-51-NEXT: #pragma omp atomic acquire compare
1264   // CHECK-51-NEXT: {
1265   // CHECK-51-NEXT: a = a < b ? b : a;
1266   // CHECK-51-NEXT: }
1267   // CHECK-51-NEXT: #pragma omp atomic compare acquire
1268   // CHECK-51-NEXT: {
1269   // CHECK-51-NEXT: a = a == b ? c : a;
1270   // CHECK-51-NEXT: }
1271   // CHECK-51-NEXT: #pragma omp atomic compare capture acquire
1272   // CHECK-51-NEXT: {
1273   // CHECK-51-NEXT: v = a;
1274   // CHECK-51-NEXT: if (a > b) {
1275   // CHECK-51-NEXT: a = b;
1276   // CHECK-51-NEXT: }
1277   // CHECK-51-NEXT: }
1278   // CHECK-51-NEXT: #pragma omp atomic compare acquire capture
1279   // CHECK-51-NEXT: {
1280   // CHECK-51-NEXT: v = a;
1281   // CHECK-51-NEXT: if (a < b) {
1282   // CHECK-51-NEXT: a = b;
1283   // CHECK-51-NEXT: }
1284   // CHECK-51-NEXT: }
1285   // CHECK-51-NEXT: #pragma omp atomic compare capture acquire
1286   // CHECK-51-NEXT: {
1287   // CHECK-51-NEXT: v = a == b;
1288   // CHECK-51-NEXT: if (v)
1289   // CHECK-51-NEXT: a = c;
1290   // CHECK-51-NEXT: }
1291   // CHECK-NEXT: #pragma omp atomic release
1292   // CHECK-NEXT: a++;
1293   // CHECK-NEXT: #pragma omp atomic read
1294   // CHECK-NEXT: a = argc;
1295   // CHECK-NEXT: #pragma omp atomic release write
1296   // CHECK-NEXT: a = argc + argc;
1297   // CHECK-NEXT: #pragma omp atomic update release
1298   // CHECK-NEXT: a = a + argc;
1299   // CHECK-NEXT: #pragma omp atomic release capture
1300   // CHECK-NEXT: a = b++;
1301   // CHECK-NEXT: #pragma omp atomic capture release
1302   // CHECK-NEXT: {
1303   // CHECK-NEXT: a = b;
1304   // CHECK-NEXT: b++;
1305   // CHECK-NEXT: }
1306   // CHECK-51-NEXT: #pragma omp atomic compare release
1307   // CHECK-51-NEXT: {
1308   // CHECK-51-NEXT: a = a > b ? b : a;
1309   // CHECK-51-NEXT: }
1310   // CHECK-51-NEXT: #pragma omp atomic release compare
1311   // CHECK-51-NEXT: {
1312   // CHECK-51-NEXT: a = a < b ? b : a;
1313   // CHECK-51-NEXT: }
1314   // CHECK-51-NEXT: #pragma omp atomic compare release
1315   // CHECK-51-NEXT: {
1316   // CHECK-51-NEXT: a = a == b ? c : a;
1317   // CHECK-51-NEXT: }
1318   // CHECK-51-NEXT: #pragma omp atomic compare capture release
1319   // CHECK-51-NEXT: {
1320   // CHECK-51-NEXT: v = a;
1321   // CHECK-51-NEXT: if (a > b) {
1322   // CHECK-51-NEXT: a = b;
1323   // CHECK-51-NEXT: }
1324   // CHECK-51-NEXT: }
1325   // CHECK-51-NEXT: #pragma omp atomic compare release capture
1326   // CHECK-51-NEXT: {
1327   // CHECK-51-NEXT: v = a;
1328   // CHECK-51-NEXT: if (a < b) {
1329   // CHECK-51-NEXT: a = b;
1330   // CHECK-51-NEXT: }
1331   // CHECK-51-NEXT: }
1332   // CHECK-51-NEXT: #pragma omp atomic compare capture release
1333   // CHECK-51-NEXT: {
1334   // CHECK-51-NEXT: v = a == b;
1335   // CHECK-51-NEXT: if (v)
1336   // CHECK-51-NEXT: a = c;
1337   // CHECK-51-NEXT: }
1338   // CHECK-NEXT: #pragma omp atomic relaxed
1339   // CHECK-NEXT: a++;
1340   // CHECK-NEXT: #pragma omp atomic read
1341   // CHECK-NEXT: a = argc;
1342   // CHECK-NEXT: #pragma omp atomic relaxed write
1343   // CHECK-NEXT: a = argc + argc;
1344   // CHECK-NEXT: #pragma omp atomic update relaxed
1345   // CHECK-NEXT: a = a + argc;
1346   // CHECK-NEXT: #pragma omp atomic relaxed capture
1347   // CHECK-NEXT: a = b++;
1348   // CHECK-NEXT: #pragma omp atomic capture relaxed
1349   // CHECK-NEXT: {
1350   // CHECK-NEXT: a = b;
1351   // CHECK-NEXT: b++;
1352   // CHECK-NEXT: }
1353   // CHECK-51-NEXT: #pragma omp atomic compare relaxed
1354   // CHECK-51-NEXT: {
1355   // CHECK-51-NEXT: a = a > b ? b : a;
1356   // CHECK-51-NEXT: }
1357   // CHECK-51-NEXT: #pragma omp atomic relaxed compare
1358   // CHECK-51-NEXT: {
1359   // CHECK-51-NEXT: a = a < b ? b : a;
1360   // CHECK-51-NEXT: }
1361   // CHECK-51-NEXT: #pragma omp atomic compare relaxed
1362   // CHECK-51-NEXT: {
1363   // CHECK-51-NEXT: a = a == b ? c : a;
1364   // CHECK-51-NEXT: }
1365   // CHECK-51-NEXT: #pragma omp atomic compare capture relaxed
1366   // CHECK-51-NEXT: {
1367   // CHECK-51-NEXT: v = a;
1368   // CHECK-51-NEXT: if (a > b) {
1369   // CHECK-51-NEXT: a = b;
1370   // CHECK-51-NEXT: }
1371   // CHECK-51-NEXT: }
1372   // CHECK-51-NEXT: #pragma omp atomic compare relaxed capture
1373   // CHECK-51-NEXT: {
1374   // CHECK-51-NEXT: v = a;
1375   // CHECK-51-NEXT: if (a < b) {
1376   // CHECK-51-NEXT: a = b;
1377   // CHECK-51-NEXT: }
1378   // CHECK-51-NEXT: }
1379   // CHECK-51-NEXT: #pragma omp atomic compare capture relaxed
1380   // CHECK-51-NEXT: {
1381   // CHECK-51-NEXT: v = a == b;
1382   // CHECK-51-NEXT: if (v)
1383   // CHECK-51-NEXT: a = c;
1384   // CHECK-51-NEXT: }
1385   // CHECK-NEXT: #pragma omp atomic hint(6)
1386   // CHECK-NEXT: a++;
1387   // CHECK-NEXT: #pragma omp atomic read hint(6)
1388   // CHECK-NEXT: a = argc;
1389   // CHECK-NEXT: #pragma omp atomic hint(6) write
1390   // CHECK-NEXT: a = argc + argc;
1391   // CHECK-NEXT: #pragma omp atomic update hint(6)
1392   // CHECK-NEXT: a = a + argc;
1393   // CHECK-NEXT: #pragma omp atomic hint(6) capture
1394   // CHECK-NEXT: a = b++;
1395   // CHECK-NEXT: #pragma omp atomic capture hint(6)
1396   // CHECK-NEXT: {
1397   // CHECK-NEXT: a = b;
1398   // CHECK-NEXT: b++;
1399   // CHECK-NEXT: }
1400   // CHECK-51-NEXT: #pragma omp atomic compare hint(6)
1401   // CHECK-51-NEXT: {
1402   // CHECK-51-NEXT: a = a > b ? b : a;
1403   // CHECK-51-NEXT: }
1404   // CHECK-51-NEXT: #pragma omp atomic hint(6) compare
1405   // CHECK-51-NEXT: {
1406   // CHECK-51-NEXT: a = a < b ? b : a;
1407   // CHECK-51-NEXT: }
1408   // CHECK-51-NEXT: #pragma omp atomic compare hint(6)
1409   // CHECK-51-NEXT: {
1410   // CHECK-51-NEXT: a = a == b ? c : a;
1411   // CHECK-51-NEXT: }
1412   // CHECK-51-NEXT: #pragma omp atomic compare capture hint(6)
1413   // CHECK-51-NEXT: {
1414   // CHECK-51-NEXT: v = a;
1415   // CHECK-51-NEXT: if (a > b) {
1416   // CHECK-51-NEXT: a = b;
1417   // CHECK-51-NEXT: }
1418   // CHECK-51-NEXT: }
1419   // CHECK-51-NEXT: #pragma omp atomic compare hint(6) capture
1420   // CHECK-51-NEXT: {
1421   // CHECK-51-NEXT: v = a;
1422   // CHECK-51-NEXT: if (a < b) {
1423   // CHECK-51-NEXT: a = b;
1424   // CHECK-51-NEXT: }
1425   // CHECK-51-NEXT: }
1426   // CHECK-51-NEXT: #pragma omp atomic compare capture hint(6)
1427   // CHECK-51-NEXT: {
1428   // CHECK-51-NEXT: v = a == b;
1429   // CHECK-51-NEXT: if (v)
1430   // CHECK-51-NEXT: a = c;
1431   // CHECK-51-NEXT: }
1432   // expect-note@+1 {{in instantiation of function template specialization 'foo<int>' requested here}}
1433   return foo(a);
1434 }
1435 
1436 #endif
1437