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 c = T(); 24 T b = T(); 25 T a = T(); 26 #pragma omp atomic 27 a++; 28 #pragma omp atomic read 29 a = argc; 30 #pragma omp atomic write 31 a = argc + argc; 32 #pragma omp atomic update 33 a = a + argc; 34 #pragma omp atomic capture 35 a = b++; 36 #pragma omp atomic capture 37 { 38 a = b; 39 b++; 40 } 41 #ifdef OMP51 42 #pragma omp atomic compare 43 { a = a > b ? b : a; } 44 #pragma omp atomic compare 45 { a = a < b ? b : a; } 46 #pragma omp atomic compare 47 { a = a == b ? c : a; } 48 #endif 49 #pragma omp atomic seq_cst 50 a++; 51 #pragma omp atomic read seq_cst 52 a = argc; 53 #pragma omp atomic seq_cst write 54 a = argc + argc; 55 #pragma omp atomic update seq_cst 56 a = a + argc; 57 #pragma omp atomic seq_cst capture 58 a = b++; 59 #pragma omp atomic capture seq_cst 60 { 61 a = b; 62 b++; 63 } 64 #ifdef OMP51 65 #pragma omp atomic compare seq_cst 66 { a = a > b ? b : a; } 67 #pragma omp atomic seq_cst compare 68 { a = a < b ? b : a; } 69 #pragma omp atomic compare seq_cst 70 { a = a == b ? c : a; } 71 #endif 72 #pragma omp atomic 73 a++; 74 #pragma omp atomic read 75 a = argc; 76 #pragma omp atomic write 77 a = argc + argc; 78 #pragma omp atomic update 79 a = a + argc; 80 #pragma omp atomic acq_rel capture 81 a = b++; 82 #pragma omp atomic capture acq_rel 83 { 84 a = b; 85 b++; 86 } 87 #ifdef OMP51 88 #pragma omp atomic compare acq_rel 89 { a = a > b ? b : a; } 90 #pragma omp atomic acq_rel compare 91 { a = a < b ? b : a; } 92 #pragma omp atomic compare acq_rel 93 { a = a == b ? c : a; } 94 #endif 95 #pragma omp atomic 96 a++; 97 #pragma omp atomic read acquire 98 a = argc; 99 #pragma omp atomic write 100 a = argc + argc; 101 #pragma omp atomic update 102 a = a + argc; 103 #pragma omp atomic acquire capture 104 a = b++; 105 #pragma omp atomic capture acquire 106 { 107 a = b; 108 b++; 109 } 110 #ifdef OMP51 111 #pragma omp atomic compare acquire 112 { a = a > b ? b : a; } 113 #pragma omp atomic acquire compare 114 { a = a < b ? b : a; } 115 #pragma omp atomic compare acquire 116 { a = a == b ? c : a; } 117 #endif 118 #pragma omp atomic release 119 a++; 120 #pragma omp atomic read 121 a = argc; 122 #pragma omp atomic release write 123 a = argc + argc; 124 #pragma omp atomic update release 125 a = a + argc; 126 #pragma omp atomic release capture 127 a = b++; 128 #pragma omp atomic capture release 129 { 130 a = b; 131 b++; 132 } 133 #ifdef OMP51 134 #pragma omp atomic compare release 135 { a = a > b ? b : a; } 136 #pragma omp atomic release compare 137 { a = a < b ? b : a; } 138 #pragma omp atomic compare release 139 { a = a == b ? c : a; } 140 #endif 141 #pragma omp atomic relaxed 142 a++; 143 #pragma omp atomic read 144 a = argc; 145 #pragma omp atomic relaxed write 146 a = argc + argc; 147 #pragma omp atomic update relaxed 148 a = a + argc; 149 #pragma omp atomic relaxed capture 150 a = b++; 151 #pragma omp atomic capture relaxed 152 { 153 a = b; 154 b++; 155 } 156 #ifdef OMP51 157 #pragma omp atomic compare relaxed 158 { a = a > b ? b : a; } 159 #pragma omp atomic relaxed compare 160 { a = a < b ? b : a; } 161 #pragma omp atomic compare relaxed 162 { a = a == b ? c : a; } 163 #endif 164 #pragma omp atomic hint(6) 165 a++; 166 #pragma omp atomic read hint(6) 167 a = argc; 168 #pragma omp atomic hint(6) write 169 a = argc + argc; 170 #pragma omp atomic update hint(6) 171 a = a + argc; 172 #pragma omp atomic hint(6) capture 173 a = b++; 174 #pragma omp atomic capture hint(6) 175 { 176 a = b; 177 b++; 178 } 179 #ifdef OMP51 180 #pragma omp atomic compare hint(6) 181 { a = a > b ? b : a; } 182 #pragma omp atomic hint(6) compare 183 { a = a < b ? b : a; } 184 #pragma omp atomic compare hint(6) 185 { a = a == b ? c : a; } 186 #endif 187 return T(); 188 } 189 190 // CHECK: T a = T(); 191 // CHECK-NEXT: #pragma omp atomic{{$}} 192 // CHECK-NEXT: a++; 193 // CHECK-NEXT: #pragma omp atomic read 194 // CHECK-NEXT: a = argc; 195 // CHECK-NEXT: #pragma omp atomic write 196 // CHECK-NEXT: a = argc + argc; 197 // CHECK-NEXT: #pragma omp atomic update 198 // CHECK-NEXT: a = a + argc; 199 // CHECK-NEXT: #pragma omp atomic capture 200 // CHECK-NEXT: a = b++; 201 // CHECK-NEXT: #pragma omp atomic capture 202 // CHECK-NEXT: { 203 // CHECK-NEXT: a = b; 204 // CHECK-NEXT: b++; 205 // CHECK-NEXT: } 206 // CHECK-51-NEXT: #pragma omp atomic compare 207 // CHECK-51-NEXT: { 208 // CHECK-51-NEXT: a = a > b ? b : a; 209 // CHECK-51-NEXT: } 210 // CHECK-51-NEXT: #pragma omp atomic compare 211 // CHECK-51-NEXT: { 212 // CHECK-51-NEXT: a = a < b ? b : a; 213 // CHECK-51-NEXT: } 214 // CHECK-51-NEXT: #pragma omp atomic compare 215 // CHECK-51-NEXT: { 216 // CHECK-51-NEXT: a = a == b ? c : a; 217 // CHECK-51-NEXT: } 218 // CHECK-NEXT: #pragma omp atomic seq_cst 219 // CHECK-NEXT: a++; 220 // CHECK-NEXT: #pragma omp atomic read seq_cst 221 // CHECK-NEXT: a = argc; 222 // CHECK-NEXT: #pragma omp atomic seq_cst write 223 // CHECK-NEXT: a = argc + argc; 224 // CHECK-NEXT: #pragma omp atomic update seq_cst 225 // CHECK-NEXT: a = a + argc; 226 // CHECK-NEXT: #pragma omp atomic seq_cst capture 227 // CHECK-NEXT: a = b++; 228 // CHECK-NEXT: #pragma omp atomic capture seq_cst 229 // CHECK-NEXT: { 230 // CHECK-NEXT: a = b; 231 // CHECK-NEXT: b++; 232 // CHECK-NEXT: } 233 // CHECK-51-NEXT: #pragma omp atomic compare seq_cst 234 // CHECK-51-NEXT: { 235 // CHECK-51-NEXT: a = a > b ? b : a; 236 // CHECK-51-NEXT: } 237 // CHECK-51-NEXT: #pragma omp atomic seq_cst compare 238 // CHECK-51-NEXT: { 239 // CHECK-51-NEXT: a = a < b ? b : a; 240 // CHECK-51-NEXT: } 241 // CHECK-51-NEXT: #pragma omp atomic compare seq_cst 242 // CHECK-51-NEXT: { 243 // CHECK-51-NEXT: a = a == b ? c : a; 244 // CHECK-51-NEXT: } 245 // CHECK-NEXT: #pragma omp atomic 246 // CHECK-NEXT: a++; 247 // CHECK-NEXT: #pragma omp atomic read 248 // CHECK-NEXT: a = argc; 249 // CHECK-NEXT: #pragma omp atomic write 250 // CHECK-NEXT: a = argc + argc; 251 // CHECK-NEXT: #pragma omp atomic update 252 // CHECK-NEXT: a = a + argc; 253 // CHECK-NEXT: #pragma omp atomic acq_rel capture 254 // CHECK-NEXT: a = b++; 255 // CHECK-NEXT: #pragma omp atomic capture acq_rel 256 // CHECK-NEXT: { 257 // CHECK-NEXT: a = b; 258 // CHECK-NEXT: b++; 259 // CHECK-NEXT: } 260 // CHECK-51-NEXT: #pragma omp atomic compare acq_rel 261 // CHECK-51-NEXT: { 262 // CHECK-51-NEXT: a = a > b ? b : a; 263 // CHECK-51-NEXT: } 264 // CHECK-51-NEXT: #pragma omp atomic acq_rel compare 265 // CHECK-51-NEXT: { 266 // CHECK-51-NEXT: a = a < b ? b : a; 267 // CHECK-51-NEXT: } 268 // CHECK-51-NEXT: #pragma omp atomic compare acq_rel 269 // CHECK-51-NEXT: { 270 // CHECK-51-NEXT: a = a == b ? c : a; 271 // CHECK-51-NEXT: } 272 // CHECK-NEXT: #pragma omp atomic 273 // CHECK-NEXT: a++; 274 // CHECK-NEXT: #pragma omp atomic read acquire 275 // CHECK-NEXT: a = argc; 276 // CHECK-NEXT: #pragma omp atomic write 277 // CHECK-NEXT: a = argc + argc; 278 // CHECK-NEXT: #pragma omp atomic update 279 // CHECK-NEXT: a = a + argc; 280 // CHECK-NEXT: #pragma omp atomic acquire capture 281 // CHECK-NEXT: a = b++; 282 // CHECK-NEXT: #pragma omp atomic capture acquire 283 // CHECK-NEXT: { 284 // CHECK-NEXT: a = b; 285 // CHECK-NEXT: b++; 286 // CHECK-NEXT: } 287 // CHECK-51-NEXT: #pragma omp atomic compare acquire 288 // CHECK-51-NEXT: { 289 // CHECK-51-NEXT: a = a > b ? b : a; 290 // CHECK-51-NEXT: } 291 // CHECK-51-NEXT: #pragma omp atomic acquire compare 292 // CHECK-51-NEXT: { 293 // CHECK-51-NEXT: a = a < b ? b : a; 294 // CHECK-51-NEXT: } 295 // CHECK-51-NEXT: #pragma omp atomic compare acquire 296 // CHECK-51-NEXT: { 297 // CHECK-51-NEXT: a = a == b ? c : a; 298 // CHECK-51-NEXT: } 299 // CHECK-NEXT: #pragma omp atomic release 300 // CHECK-NEXT: a++; 301 // CHECK-NEXT: #pragma omp atomic read 302 // CHECK-NEXT: a = argc; 303 // CHECK-NEXT: #pragma omp atomic release write 304 // CHECK-NEXT: a = argc + argc; 305 // CHECK-NEXT: #pragma omp atomic update release 306 // CHECK-NEXT: a = a + argc; 307 // CHECK-NEXT: #pragma omp atomic release capture 308 // CHECK-NEXT: a = b++; 309 // CHECK-NEXT: #pragma omp atomic capture release 310 // CHECK-NEXT: { 311 // CHECK-NEXT: a = b; 312 // CHECK-NEXT: b++; 313 // CHECK-NEXT: } 314 // CHECK-51-NEXT: #pragma omp atomic compare release 315 // CHECK-51-NEXT: { 316 // CHECK-51-NEXT: a = a > b ? b : a; 317 // CHECK-51-NEXT: } 318 // CHECK-51-NEXT: #pragma omp atomic release compare 319 // CHECK-51-NEXT: { 320 // CHECK-51-NEXT: a = a < b ? b : a; 321 // CHECK-51-NEXT: } 322 // CHECK-51-NEXT: #pragma omp atomic compare release 323 // CHECK-51-NEXT: { 324 // CHECK-51-NEXT: a = a == b ? c : a; 325 // CHECK-51-NEXT: } 326 // CHECK-NEXT: #pragma omp atomic relaxed 327 // CHECK-NEXT: a++; 328 // CHECK-NEXT: #pragma omp atomic read 329 // CHECK-NEXT: a = argc; 330 // CHECK-NEXT: #pragma omp atomic relaxed write 331 // CHECK-NEXT: a = argc + argc; 332 // CHECK-NEXT: #pragma omp atomic update relaxed 333 // CHECK-NEXT: a = a + argc; 334 // CHECK-NEXT: #pragma omp atomic relaxed capture 335 // CHECK-NEXT: a = b++; 336 // CHECK-NEXT: #pragma omp atomic capture relaxed 337 // CHECK-NEXT: { 338 // CHECK-NEXT: a = b; 339 // CHECK-NEXT: b++; 340 // CHECK-NEXT: } 341 // CHECK-51-NEXT: #pragma omp atomic compare relaxed 342 // CHECK-51-NEXT: { 343 // CHECK-51-NEXT: a = a > b ? b : a; 344 // CHECK-51-NEXT: } 345 // CHECK-51-NEXT: #pragma omp atomic relaxed compare 346 // CHECK-51-NEXT: { 347 // CHECK-51-NEXT: a = a < b ? b : a; 348 // CHECK-51-NEXT: } 349 // CHECK-51-NEXT: #pragma omp atomic compare relaxed 350 // CHECK-51-NEXT: { 351 // CHECK-51-NEXT: a = a == b ? c : a; 352 // CHECK-51-NEXT: } 353 // CHECK-NEXT: #pragma omp atomic hint(6) 354 // CHECK-NEXT: a++; 355 // CHECK-NEXT: #pragma omp atomic read hint(6) 356 // CHECK-NEXT: a = argc; 357 // CHECK-NEXT: #pragma omp atomic hint(6) write 358 // CHECK-NEXT: a = argc + argc; 359 // CHECK-NEXT: #pragma omp atomic update hint(6) 360 // CHECK-NEXT: a = a + argc; 361 // CHECK-NEXT: #pragma omp atomic hint(6) capture 362 // CHECK-NEXT: a = b++; 363 // CHECK-NEXT: #pragma omp atomic capture hint(6) 364 // CHECK-NEXT: { 365 // CHECK-NEXT: a = b; 366 // CHECK-NEXT: b++; 367 // CHECK-NEXT: } 368 // CHECK-51-NEXT: #pragma omp atomic compare hint(6) 369 // CHECK-51-NEXT: { 370 // CHECK-51-NEXT: a = a > b ? b : a; 371 // CHECK-51-NEXT: } 372 // CHECK-51-NEXT: #pragma omp atomic hint(6) compare 373 // CHECK-51-NEXT: { 374 // CHECK-51-NEXT: a = a < b ? b : a; 375 // CHECK-51-NEXT: } 376 // CHECK-51-NEXT: #pragma omp atomic compare hint(6) 377 // CHECK-51-NEXT: { 378 // CHECK-51-NEXT: a = a == b ? c : a; 379 // CHECK-51-NEXT: } 380 // CHECK: int a = int(); 381 // CHECK-NEXT: #pragma omp atomic 382 // CHECK-NEXT: a++; 383 // CHECK-NEXT: #pragma omp atomic read 384 // CHECK-NEXT: a = argc; 385 // CHECK-NEXT: #pragma omp atomic write 386 // CHECK-NEXT: a = argc + argc; 387 // CHECK-NEXT: #pragma omp atomic update 388 // CHECK-NEXT: a = a + argc; 389 // CHECK-NEXT: #pragma omp atomic capture 390 // CHECK-NEXT: a = b++; 391 // CHECK-NEXT: #pragma omp atomic capture 392 // CHECK-NEXT: { 393 // CHECK-NEXT: a = b; 394 // CHECK-NEXT: b++; 395 // CHECK-NEXT: } 396 // CHECK-51-NEXT: #pragma omp atomic compare 397 // CHECK-51-NEXT: { 398 // CHECK-51-NEXT: a = a > b ? b : a; 399 // CHECK-51-NEXT: } 400 // CHECK-51-NEXT: #pragma omp atomic compare 401 // CHECK-51-NEXT: { 402 // CHECK-51-NEXT: a = a < b ? b : a; 403 // CHECK-51-NEXT: } 404 // CHECK-51-NEXT: #pragma omp atomic compare 405 // CHECK-51-NEXT: { 406 // CHECK-51-NEXT: a = a == b ? c : a; 407 // CHECK-51-NEXT: } 408 // CHECK-NEXT: #pragma omp atomic seq_cst 409 // CHECK-NEXT: a++; 410 // CHECK-NEXT: #pragma omp atomic read seq_cst 411 // CHECK-NEXT: a = argc; 412 // CHECK-NEXT: #pragma omp atomic seq_cst write 413 // CHECK-NEXT: a = argc + argc; 414 // CHECK-NEXT: #pragma omp atomic update seq_cst 415 // CHECK-NEXT: a = a + argc; 416 // CHECK-NEXT: #pragma omp atomic seq_cst capture 417 // CHECK-NEXT: a = b++; 418 // CHECK-NEXT: #pragma omp atomic capture seq_cst 419 // CHECK-NEXT: { 420 // CHECK-NEXT: a = b; 421 // CHECK-NEXT: b++; 422 // CHECK-NEXT: } 423 // CHECK-51-NEXT: #pragma omp atomic compare seq_cst 424 // CHECK-51-NEXT: { 425 // CHECK-51-NEXT: a = a > b ? b : a; 426 // CHECK-51-NEXT: } 427 // CHECK-51-NEXT: #pragma omp atomic seq_cst compare 428 // CHECK-51-NEXT: { 429 // CHECK-51-NEXT: a = a < b ? b : a; 430 // CHECK-51-NEXT: } 431 // CHECK-51-NEXT: #pragma omp atomic compare seq_cst 432 // CHECK-51-NEXT: { 433 // CHECK-51-NEXT: a = a == b ? c : a; 434 // CHECK-51-NEXT: } 435 // CHECK-NEXT: #pragma omp atomic 436 // CHECK-NEXT: a++; 437 // CHECK-NEXT: #pragma omp atomic read 438 // CHECK-NEXT: a = argc; 439 // CHECK-NEXT: #pragma omp atomic write 440 // CHECK-NEXT: a = argc + argc; 441 // CHECK-NEXT: #pragma omp atomic update 442 // CHECK-NEXT: a = a + argc; 443 // CHECK-NEXT: #pragma omp atomic acq_rel capture 444 // CHECK-NEXT: a = b++; 445 // CHECK-NEXT: #pragma omp atomic capture acq_rel 446 // CHECK-NEXT: { 447 // CHECK-NEXT: a = b; 448 // CHECK-NEXT: b++; 449 // CHECK-NEXT: } 450 // CHECK-51-NEXT: #pragma omp atomic compare acq_rel 451 // CHECK-51-NEXT: { 452 // CHECK-51-NEXT: a = a > b ? b : a; 453 // CHECK-51-NEXT: } 454 // CHECK-51-NEXT: #pragma omp atomic acq_rel compare 455 // CHECK-51-NEXT: { 456 // CHECK-51-NEXT: a = a < b ? b : a; 457 // CHECK-51-NEXT: } 458 // CHECK-51-NEXT: #pragma omp atomic compare acq_rel 459 // CHECK-51-NEXT: { 460 // CHECK-51-NEXT: a = a == b ? c : a; 461 // CHECK-51-NEXT: } 462 // CHECK-NEXT: #pragma omp atomic 463 // CHECK-NEXT: a++; 464 // CHECK-NEXT: #pragma omp atomic read acquire 465 // CHECK-NEXT: a = argc; 466 // CHECK-NEXT: #pragma omp atomic write 467 // CHECK-NEXT: a = argc + argc; 468 // CHECK-NEXT: #pragma omp atomic update 469 // CHECK-NEXT: a = a + argc; 470 // CHECK-NEXT: #pragma omp atomic acquire capture 471 // CHECK-NEXT: a = b++; 472 // CHECK-NEXT: #pragma omp atomic capture acquire 473 // CHECK-NEXT: { 474 // CHECK-NEXT: a = b; 475 // CHECK-NEXT: b++; 476 // CHECK-NEXT: } 477 // CHECK-51-NEXT: #pragma omp atomic compare acquire 478 // CHECK-51-NEXT: { 479 // CHECK-51-NEXT: a = a > b ? b : a; 480 // CHECK-51-NEXT: } 481 // CHECK-51-NEXT: #pragma omp atomic acquire compare 482 // CHECK-51-NEXT: { 483 // CHECK-51-NEXT: a = a < b ? b : a; 484 // CHECK-51-NEXT: } 485 // CHECK-51-NEXT: #pragma omp atomic compare acquire 486 // CHECK-51-NEXT: { 487 // CHECK-51-NEXT: a = a == b ? c : a; 488 // CHECK-51-NEXT: } 489 // CHECK-NEXT: #pragma omp atomic release 490 // CHECK-NEXT: a++; 491 // CHECK-NEXT: #pragma omp atomic read 492 // CHECK-NEXT: a = argc; 493 // CHECK-NEXT: #pragma omp atomic release write 494 // CHECK-NEXT: a = argc + argc; 495 // CHECK-NEXT: #pragma omp atomic update release 496 // CHECK-NEXT: a = a + argc; 497 // CHECK-NEXT: #pragma omp atomic release capture 498 // CHECK-NEXT: a = b++; 499 // CHECK-NEXT: #pragma omp atomic capture release 500 // CHECK-NEXT: { 501 // CHECK-NEXT: a = b; 502 // CHECK-NEXT: b++; 503 // CHECK-NEXT: } 504 // CHECK-51-NEXT: #pragma omp atomic compare release 505 // CHECK-51-NEXT: { 506 // CHECK-51-NEXT: a = a > b ? b : a; 507 // CHECK-51-NEXT: } 508 // CHECK-51-NEXT: #pragma omp atomic release compare 509 // CHECK-51-NEXT: { 510 // CHECK-51-NEXT: a = a < b ? b : a; 511 // CHECK-51-NEXT: } 512 // CHECK-51-NEXT: #pragma omp atomic compare release 513 // CHECK-51-NEXT: { 514 // CHECK-51-NEXT: a = a == b ? c : a; 515 // CHECK-51-NEXT: } 516 // CHECK-NEXT: #pragma omp atomic relaxed 517 // CHECK-NEXT: a++; 518 // CHECK-NEXT: #pragma omp atomic read 519 // CHECK-NEXT: a = argc; 520 // CHECK-NEXT: #pragma omp atomic relaxed write 521 // CHECK-NEXT: a = argc + argc; 522 // CHECK-NEXT: #pragma omp atomic update relaxed 523 // CHECK-NEXT: a = a + argc; 524 // CHECK-NEXT: #pragma omp atomic relaxed capture 525 // CHECK-NEXT: a = b++; 526 // CHECK-NEXT: #pragma omp atomic capture relaxed 527 // CHECK-NEXT: { 528 // CHECK-NEXT: a = b; 529 // CHECK-NEXT: b++; 530 // CHECK-NEXT: } 531 // CHECK-51-NEXT: #pragma omp atomic compare relaxed 532 // CHECK-51-NEXT: { 533 // CHECK-51-NEXT: a = a > b ? b : a; 534 // CHECK-51-NEXT: } 535 // CHECK-51-NEXT: #pragma omp atomic relaxed 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 relaxed 540 // CHECK-51-NEXT: { 541 // CHECK-51-NEXT: a = a == b ? c : a; 542 // CHECK-51-NEXT: } 543 // CHECK-NEXT: #pragma omp atomic hint(6) 544 // CHECK-NEXT: a++; 545 // CHECK-NEXT: #pragma omp atomic read hint(6) 546 // CHECK-NEXT: a = argc; 547 // CHECK-NEXT: #pragma omp atomic hint(6) write 548 // CHECK-NEXT: a = argc + argc; 549 // CHECK-NEXT: #pragma omp atomic update hint(6) 550 // CHECK-NEXT: a = a + argc; 551 // CHECK-NEXT: #pragma omp atomic hint(6) capture 552 // CHECK-NEXT: a = b++; 553 // CHECK-NEXT: #pragma omp atomic capture hint(6) 554 // CHECK-NEXT: { 555 // CHECK-NEXT: a = b; 556 // CHECK-NEXT: b++; 557 // CHECK-NEXT: } 558 // CHECK-51-NEXT: #pragma omp atomic compare hint(6) 559 // CHECK-51-NEXT: { 560 // CHECK-51-NEXT: a = a > b ? b : a; 561 // CHECK-51-NEXT: } 562 // CHECK-51-NEXT: #pragma omp atomic hint(6) compare 563 // CHECK-51-NEXT: { 564 // CHECK-51-NEXT: a = a < b ? b : a; 565 // CHECK-51-NEXT: } 566 // CHECK-51-NEXT: #pragma omp atomic compare hint(6) 567 // CHECK-51-NEXT: { 568 // CHECK-51-NEXT: a = a == b ? c : a; 569 // CHECK-51-NEXT: } 570 571 int main(int argc, char **argv) { 572 int c = 0; 573 int b = 0; 574 int a = 0; 575 // CHECK: int a = 0; 576 #pragma omp atomic 577 a++; 578 #pragma omp atomic read 579 a = argc; 580 #pragma omp atomic write 581 a = argc + argc; 582 #pragma omp atomic update 583 a = a + argc; 584 #pragma omp atomic capture 585 a = b++; 586 #pragma omp atomic capture 587 { 588 a = b; 589 b++; 590 } 591 #ifdef OMP51 592 #pragma omp atomic compare 593 { a = a > b ? b : a; } 594 #pragma omp atomic compare 595 { a = a < b ? b : a; } 596 #pragma omp atomic compare 597 { a = a == b ? c : a; } 598 #endif 599 #pragma omp atomic seq_cst 600 a++; 601 #pragma omp atomic read seq_cst 602 a = argc; 603 #pragma omp atomic seq_cst write 604 a = argc + argc; 605 #pragma omp atomic update seq_cst 606 a = a + argc; 607 #pragma omp atomic seq_cst capture 608 a = b++; 609 #pragma omp atomic capture seq_cst 610 { 611 a = b; 612 b++; 613 } 614 #ifdef OMP51 615 #pragma omp atomic compare seq_cst 616 { a = a > b ? b : a; } 617 #pragma omp atomic seq_cst compare 618 { a = a < b ? b : a; } 619 #pragma omp atomic compare seq_cst 620 { a = a == b ? c : a; } 621 #endif 622 #pragma omp atomic 623 a++; 624 #pragma omp atomic read 625 a = argc; 626 #pragma omp atomic write 627 a = argc + argc; 628 #pragma omp atomic update 629 a = a + argc; 630 #pragma omp atomic acq_rel capture 631 a = b++; 632 #pragma omp atomic capture acq_rel 633 { 634 a = b; 635 b++; 636 } 637 #ifdef OMP51 638 #pragma omp atomic compare acq_rel 639 { a = a > b ? b : a; } 640 #pragma omp atomic acq_rel compare 641 { a = a < b ? b : a; } 642 #pragma omp atomic compare acq_rel 643 { a = a == b ? c : a; } 644 #endif 645 #pragma omp atomic 646 a++; 647 #pragma omp atomic read acquire 648 a = argc; 649 #pragma omp atomic write 650 a = argc + argc; 651 #pragma omp atomic update 652 a = a + argc; 653 #pragma omp atomic acquire capture 654 a = b++; 655 #pragma omp atomic capture acquire 656 { 657 a = b; 658 b++; 659 } 660 #ifdef OMP51 661 #pragma omp atomic compare acquire 662 { a = a > b ? b : a; } 663 #pragma omp atomic acquire compare 664 { a = a < b ? b : a; } 665 #pragma omp atomic compare acquire 666 { a = a == b ? c : a; } 667 #endif 668 #pragma omp atomic release 669 a++; 670 #pragma omp atomic read 671 a = argc; 672 #pragma omp atomic release write 673 a = argc + argc; 674 #pragma omp atomic update release 675 a = a + argc; 676 #pragma omp atomic release capture 677 a = b++; 678 #pragma omp atomic capture release 679 { 680 a = b; 681 b++; 682 } 683 #ifdef OMP51 684 #pragma omp atomic compare release 685 { a = a > b ? b : a; } 686 #pragma omp atomic release compare 687 { a = a < b ? b : a; } 688 #pragma omp atomic compare release 689 { a = a == b ? c : a; } 690 #endif 691 #pragma omp atomic relaxed 692 a++; 693 #pragma omp atomic read 694 a = argc; 695 #pragma omp atomic relaxed write 696 a = argc + argc; 697 #pragma omp atomic update relaxed 698 a = a + argc; 699 #pragma omp atomic relaxed capture 700 a = b++; 701 #pragma omp atomic capture relaxed 702 { 703 a = b; 704 b++; 705 } 706 #ifdef OMP51 707 #pragma omp atomic compare relaxed 708 { a = a > b ? b : a; } 709 #pragma omp atomic relaxed compare 710 { a = a < b ? b : a; } 711 #pragma omp atomic compare relaxed 712 { a = a == b ? c : a; } 713 #endif 714 #pragma omp atomic hint(6) 715 a++; 716 #pragma omp atomic read hint(6) 717 a = argc; 718 #pragma omp atomic hint(6) write 719 a = argc + argc; 720 #pragma omp atomic update hint(6) 721 a = a + argc; 722 #pragma omp atomic hint(6) capture 723 a = b++; 724 #pragma omp atomic capture hint(6) 725 { 726 a = b; 727 b++; 728 } 729 #ifdef OMP51 730 #pragma omp atomic compare hint(6) 731 { a = a > b ? b : a; } 732 #pragma omp atomic hint(6) compare 733 { a = a < b ? b : a; } 734 #pragma omp atomic compare hint(6) 735 { a = a == b ? c : a; } 736 #endif 737 // CHECK-NEXT: #pragma omp atomic 738 // CHECK-NEXT: a++; 739 // CHECK-NEXT: #pragma omp atomic read 740 // CHECK-NEXT: a = argc; 741 // CHECK-NEXT: #pragma omp atomic write 742 // CHECK-NEXT: a = argc + argc; 743 // CHECK-NEXT: #pragma omp atomic update 744 // CHECK-NEXT: a = a + argc; 745 // CHECK-NEXT: #pragma omp atomic capture 746 // CHECK-NEXT: a = b++; 747 // CHECK-NEXT: #pragma omp atomic capture 748 // CHECK-NEXT: { 749 // CHECK-NEXT: a = b; 750 // CHECK-NEXT: b++; 751 // CHECK-NEXT: } 752 // CHECK-51-NEXT: #pragma omp atomic compare 753 // CHECK-51-NEXT: { 754 // CHECK-51-NEXT: a = a > b ? b : a; 755 // CHECK-51-NEXT: } 756 // CHECK-51-NEXT: #pragma omp atomic compare 757 // CHECK-51-NEXT: { 758 // CHECK-51-NEXT: a = a < b ? b : a; 759 // CHECK-51-NEXT: } 760 // CHECK-51-NEXT: #pragma omp atomic compare 761 // CHECK-51-NEXT: { 762 // CHECK-51-NEXT: a = a == b ? c : a; 763 // CHECK-51-NEXT: } 764 // CHECK-NEXT: #pragma omp atomic seq_cst 765 // CHECK-NEXT: a++; 766 // CHECK-NEXT: #pragma omp atomic read seq_cst 767 // CHECK-NEXT: a = argc; 768 // CHECK-NEXT: #pragma omp atomic seq_cst write 769 // CHECK-NEXT: a = argc + argc; 770 // CHECK-NEXT: #pragma omp atomic update seq_cst 771 // CHECK-NEXT: a = a + argc; 772 // CHECK-NEXT: #pragma omp atomic seq_cst capture 773 // CHECK-NEXT: a = b++; 774 // CHECK-NEXT: #pragma omp atomic capture seq_cst 775 // CHECK-NEXT: { 776 // CHECK-NEXT: a = b; 777 // CHECK-NEXT: b++; 778 // CHECK-NEXT: } 779 // CHECK-51-NEXT: #pragma omp atomic compare seq_cst 780 // CHECK-51-NEXT: { 781 // CHECK-51-NEXT: a = a > b ? b : a; 782 // CHECK-51-NEXT: } 783 // CHECK-51-NEXT: #pragma omp atomic seq_cst compare 784 // CHECK-51-NEXT: { 785 // CHECK-51-NEXT: a = a < b ? b : a; 786 // CHECK-51-NEXT: } 787 // CHECK-51-NEXT: #pragma omp atomic compare seq_cst 788 // CHECK-51-NEXT: { 789 // CHECK-51-NEXT: a = a == b ? c : a; 790 // CHECK-51-NEXT: } 791 // CHECK-NEXT: #pragma omp atomic 792 // CHECK-NEXT: a++; 793 // CHECK-NEXT: #pragma omp atomic read 794 // CHECK-NEXT: a = argc; 795 // CHECK-NEXT: #pragma omp atomic write 796 // CHECK-NEXT: a = argc + argc; 797 // CHECK-NEXT: #pragma omp atomic update 798 // CHECK-NEXT: a = a + argc; 799 // CHECK-NEXT: #pragma omp atomic acq_rel capture 800 // CHECK-NEXT: a = b++; 801 // CHECK-NEXT: #pragma omp atomic capture acq_rel 802 // CHECK-NEXT: { 803 // CHECK-NEXT: a = b; 804 // CHECK-NEXT: b++; 805 // CHECK-NEXT: } 806 // CHECK-51-NEXT: #pragma omp atomic compare acq_rel 807 // CHECK-51-NEXT: { 808 // CHECK-51-NEXT: a = a > b ? b : a; 809 // CHECK-51-NEXT: } 810 // CHECK-51-NEXT: #pragma omp atomic acq_rel compare 811 // CHECK-51-NEXT: { 812 // CHECK-51-NEXT: a = a < b ? b : a; 813 // CHECK-51-NEXT: } 814 // CHECK-51-NEXT: #pragma omp atomic compare acq_rel 815 // CHECK-51-NEXT: { 816 // CHECK-51-NEXT: a = a == b ? c : a; 817 // CHECK-51-NEXT: } 818 // CHECK-NEXT: #pragma omp atomic 819 // CHECK-NEXT: a++; 820 // CHECK-NEXT: #pragma omp atomic read acquire 821 // CHECK-NEXT: a = argc; 822 // CHECK-NEXT: #pragma omp atomic write 823 // CHECK-NEXT: a = argc + argc; 824 // CHECK-NEXT: #pragma omp atomic update 825 // CHECK-NEXT: a = a + argc; 826 // CHECK-NEXT: #pragma omp atomic acquire capture 827 // CHECK-NEXT: a = b++; 828 // CHECK-NEXT: #pragma omp atomic capture acquire 829 // CHECK-NEXT: { 830 // CHECK-NEXT: a = b; 831 // CHECK-NEXT: b++; 832 // CHECK-NEXT: } 833 // CHECK-51-NEXT: #pragma omp atomic compare acquire 834 // CHECK-51-NEXT: { 835 // CHECK-51-NEXT: a = a > b ? b : a; 836 // CHECK-51-NEXT: } 837 // CHECK-51-NEXT: #pragma omp atomic acquire compare 838 // CHECK-51-NEXT: { 839 // CHECK-51-NEXT: a = a < b ? b : a; 840 // CHECK-51-NEXT: } 841 // CHECK-51-NEXT: #pragma omp atomic compare acquire 842 // CHECK-51-NEXT: { 843 // CHECK-51-NEXT: a = a == b ? c : a; 844 // CHECK-51-NEXT: } 845 // CHECK-NEXT: #pragma omp atomic release 846 // CHECK-NEXT: a++; 847 // CHECK-NEXT: #pragma omp atomic read 848 // CHECK-NEXT: a = argc; 849 // CHECK-NEXT: #pragma omp atomic release write 850 // CHECK-NEXT: a = argc + argc; 851 // CHECK-NEXT: #pragma omp atomic update release 852 // CHECK-NEXT: a = a + argc; 853 // CHECK-NEXT: #pragma omp atomic release capture 854 // CHECK-NEXT: a = b++; 855 // CHECK-NEXT: #pragma omp atomic capture release 856 // CHECK-NEXT: { 857 // CHECK-NEXT: a = b; 858 // CHECK-NEXT: b++; 859 // CHECK-NEXT: } 860 // CHECK-51-NEXT: #pragma omp atomic compare release 861 // CHECK-51-NEXT: { 862 // CHECK-51-NEXT: a = a > b ? b : a; 863 // CHECK-51-NEXT: } 864 // CHECK-51-NEXT: #pragma omp atomic release compare 865 // CHECK-51-NEXT: { 866 // CHECK-51-NEXT: a = a < b ? b : a; 867 // CHECK-51-NEXT: } 868 // CHECK-51-NEXT: #pragma omp atomic compare release 869 // CHECK-51-NEXT: { 870 // CHECK-51-NEXT: a = a == b ? c : a; 871 // CHECK-51-NEXT: } 872 // CHECK-NEXT: #pragma omp atomic relaxed 873 // CHECK-NEXT: a++; 874 // CHECK-NEXT: #pragma omp atomic read 875 // CHECK-NEXT: a = argc; 876 // CHECK-NEXT: #pragma omp atomic relaxed write 877 // CHECK-NEXT: a = argc + argc; 878 // CHECK-NEXT: #pragma omp atomic update relaxed 879 // CHECK-NEXT: a = a + argc; 880 // CHECK-NEXT: #pragma omp atomic relaxed capture 881 // CHECK-NEXT: a = b++; 882 // CHECK-NEXT: #pragma omp atomic capture relaxed 883 // CHECK-NEXT: { 884 // CHECK-NEXT: a = b; 885 // CHECK-NEXT: b++; 886 // CHECK-NEXT: } 887 // CHECK-51-NEXT: #pragma omp atomic compare relaxed 888 // CHECK-51-NEXT: { 889 // CHECK-51-NEXT: a = a > b ? b : a; 890 // CHECK-51-NEXT: } 891 // CHECK-51-NEXT: #pragma omp atomic relaxed compare 892 // CHECK-51-NEXT: { 893 // CHECK-51-NEXT: a = a < b ? b : a; 894 // CHECK-51-NEXT: } 895 // CHECK-51-NEXT: #pragma omp atomic compare relaxed 896 // CHECK-51-NEXT: { 897 // CHECK-51-NEXT: a = a == b ? c : a; 898 // CHECK-51-NEXT: } 899 // CHECK-NEXT: #pragma omp atomic hint(6) 900 // CHECK-NEXT: a++; 901 // CHECK-NEXT: #pragma omp atomic read hint(6) 902 // CHECK-NEXT: a = argc; 903 // CHECK-NEXT: #pragma omp atomic hint(6) write 904 // CHECK-NEXT: a = argc + argc; 905 // CHECK-NEXT: #pragma omp atomic update hint(6) 906 // CHECK-NEXT: a = a + argc; 907 // CHECK-NEXT: #pragma omp atomic hint(6) capture 908 // CHECK-NEXT: a = b++; 909 // CHECK-NEXT: #pragma omp atomic capture hint(6) 910 // CHECK-NEXT: { 911 // CHECK-NEXT: a = b; 912 // CHECK-NEXT: b++; 913 // CHECK-NEXT: } 914 // CHECK-51-NEXT: #pragma omp atomic compare hint(6) 915 // CHECK-51-NEXT: { 916 // CHECK-51-NEXT: a = a > b ? b : a; 917 // CHECK-51-NEXT: } 918 // CHECK-51-NEXT: #pragma omp atomic hint(6) compare 919 // CHECK-51-NEXT: { 920 // CHECK-51-NEXT: a = a < b ? b : a; 921 // CHECK-51-NEXT: } 922 // CHECK-51-NEXT: #pragma omp atomic compare hint(6) 923 // CHECK-51-NEXT: { 924 // CHECK-51-NEXT: a = a == b ? c : a; 925 // CHECK-51-NEXT: } 926 // expect-note@+1 {{in instantiation of function template specialization 'foo<int>' requested here}} 927 return foo(a); 928 } 929 930 #endif 931