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; a = a > b ? b : a; } 51 #pragma omp atomic compare capture 52 { v = a; a = a < b ? b : a; } 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; a = a > b ? b : a; } 80 #pragma omp atomic compare seq_cst capture 81 { v = a; a = a < b ? b : a; } 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; a = a > b ? b : a; } 109 #pragma omp atomic compare acq_rel capture 110 { v = a; a = a < b ? b : a; } 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; a = a > b ? b : a; } 138 #pragma omp atomic compare acquire capture 139 { v = a; a = a < b ? b : a; } 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; a = a > b ? b : a; } 167 #pragma omp atomic compare release capture 168 { v = a; a = a < b ? b : a; } 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; a = a > b ? b : a; } 196 #pragma omp atomic compare relaxed capture 197 { v = a; a = a < b ? b : a; } 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; a = a > b ? b : a; } 225 #pragma omp atomic compare hint(6) capture 226 { v = a; a = a < b ? b : a; } 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: a = a > b ? b : a; 265 // CHECK-51-NEXT: } 266 // CHECK-51-NEXT: #pragma omp atomic compare capture 267 // CHECK-51-NEXT: { 268 // CHECK-51-NEXT: v = a; 269 // CHECK-51-NEXT: a = a < b ? b : a; 270 // CHECK-51-NEXT: } 271 // CHECK-51-NEXT: #pragma omp atomic compare capture 272 // CHECK-51-NEXT: { 273 // CHECK-51-NEXT: v = a == b; 274 // CHECK-51-NEXT: if (v) 275 // CHECK-51-NEXT: a = c; 276 // CHECK-51-NEXT: } 277 // CHECK-NEXT: #pragma omp atomic seq_cst 278 // CHECK-NEXT: a++; 279 // CHECK-NEXT: #pragma omp atomic read seq_cst 280 // CHECK-NEXT: a = argc; 281 // CHECK-NEXT: #pragma omp atomic seq_cst write 282 // CHECK-NEXT: a = argc + argc; 283 // CHECK-NEXT: #pragma omp atomic update seq_cst 284 // CHECK-NEXT: a = a + argc; 285 // CHECK-NEXT: #pragma omp atomic seq_cst capture 286 // CHECK-NEXT: a = b++; 287 // CHECK-NEXT: #pragma omp atomic capture seq_cst 288 // CHECK-NEXT: { 289 // CHECK-NEXT: a = b; 290 // CHECK-NEXT: b++; 291 // CHECK-NEXT: } 292 // CHECK-51-NEXT: #pragma omp atomic compare seq_cst 293 // CHECK-51-NEXT: { 294 // CHECK-51-NEXT: a = a > b ? b : a; 295 // CHECK-51-NEXT: } 296 // CHECK-51-NEXT: #pragma omp atomic seq_cst compare 297 // CHECK-51-NEXT: { 298 // CHECK-51-NEXT: a = a < b ? b : a; 299 // CHECK-51-NEXT: } 300 // CHECK-51-NEXT: #pragma omp atomic compare seq_cst 301 // CHECK-51-NEXT: { 302 // CHECK-51-NEXT: a = a == b ? c : a; 303 // CHECK-51-NEXT: } 304 // CHECK-51-NEXT: #pragma omp atomic compare capture seq_cst 305 // CHECK-51-NEXT: { 306 // CHECK-51-NEXT: v = a; 307 // CHECK-51-NEXT: a = a > b ? b : a; 308 // CHECK-51-NEXT: } 309 // CHECK-51-NEXT: #pragma omp atomic compare seq_cst capture 310 // CHECK-51-NEXT: { 311 // CHECK-51-NEXT: v = a; 312 // CHECK-51-NEXT: a = a < b ? b : a; 313 // CHECK-51-NEXT: } 314 // CHECK-51-NEXT: #pragma omp atomic compare capture seq_cst 315 // CHECK-51-NEXT: { 316 // CHECK-51-NEXT: v = a == b; 317 // CHECK-51-NEXT: if (v) 318 // CHECK-51-NEXT: a = c; 319 // CHECK-51-NEXT: } 320 // CHECK-NEXT: #pragma omp atomic 321 // CHECK-NEXT: a++; 322 // CHECK-NEXT: #pragma omp atomic read 323 // CHECK-NEXT: a = argc; 324 // CHECK-NEXT: #pragma omp atomic write 325 // CHECK-NEXT: a = argc + argc; 326 // CHECK-NEXT: #pragma omp atomic update 327 // CHECK-NEXT: a = a + argc; 328 // CHECK-NEXT: #pragma omp atomic acq_rel capture 329 // CHECK-NEXT: a = b++; 330 // CHECK-NEXT: #pragma omp atomic capture acq_rel 331 // CHECK-NEXT: { 332 // CHECK-NEXT: a = b; 333 // CHECK-NEXT: b++; 334 // CHECK-NEXT: } 335 // CHECK-51-NEXT: #pragma omp atomic compare acq_rel 336 // CHECK-51-NEXT: { 337 // CHECK-51-NEXT: a = a > b ? b : a; 338 // CHECK-51-NEXT: } 339 // CHECK-51-NEXT: #pragma omp atomic acq_rel compare 340 // CHECK-51-NEXT: { 341 // CHECK-51-NEXT: a = a < b ? b : a; 342 // CHECK-51-NEXT: } 343 // CHECK-51-NEXT: #pragma omp atomic compare acq_rel 344 // CHECK-51-NEXT: { 345 // CHECK-51-NEXT: a = a == b ? c : a; 346 // CHECK-51-NEXT: } 347 // CHECK-51-NEXT: #pragma omp atomic compare capture acq_rel 348 // CHECK-51-NEXT: { 349 // CHECK-51-NEXT: v = a; 350 // CHECK-51-NEXT: a = a > b ? b : a; 351 // CHECK-51-NEXT: } 352 // CHECK-51-NEXT: #pragma omp atomic compare acq_rel capture 353 // CHECK-51-NEXT: { 354 // CHECK-51-NEXT: v = a; 355 // CHECK-51-NEXT: a = a < b ? b : a; 356 // CHECK-51-NEXT: } 357 // CHECK-51-NEXT: #pragma omp atomic compare capture acq_rel 358 // CHECK-51-NEXT: { 359 // CHECK-51-NEXT: v = a == b; 360 // CHECK-51-NEXT: if (v) 361 // CHECK-51-NEXT: a = c; 362 // CHECK-51-NEXT: } 363 // CHECK-NEXT: #pragma omp atomic 364 // CHECK-NEXT: a++; 365 // CHECK-NEXT: #pragma omp atomic read acquire 366 // CHECK-NEXT: a = argc; 367 // CHECK-NEXT: #pragma omp atomic write 368 // CHECK-NEXT: a = argc + argc; 369 // CHECK-NEXT: #pragma omp atomic update 370 // CHECK-NEXT: a = a + argc; 371 // CHECK-NEXT: #pragma omp atomic acquire capture 372 // CHECK-NEXT: a = b++; 373 // CHECK-NEXT: #pragma omp atomic capture acquire 374 // CHECK-NEXT: { 375 // CHECK-NEXT: a = b; 376 // CHECK-NEXT: b++; 377 // CHECK-NEXT: } 378 // CHECK-51-NEXT: #pragma omp atomic compare acquire 379 // CHECK-51-NEXT: { 380 // CHECK-51-NEXT: a = a > b ? b : a; 381 // CHECK-51-NEXT: } 382 // CHECK-51-NEXT: #pragma omp atomic acquire compare 383 // CHECK-51-NEXT: { 384 // CHECK-51-NEXT: a = a < b ? b : a; 385 // CHECK-51-NEXT: } 386 // CHECK-51-NEXT: #pragma omp atomic compare acquire 387 // CHECK-51-NEXT: { 388 // CHECK-51-NEXT: a = a == b ? c : a; 389 // CHECK-51-NEXT: } 390 // CHECK-51-NEXT: #pragma omp atomic compare capture acquire 391 // CHECK-51-NEXT: { 392 // CHECK-51-NEXT: v = a; 393 // CHECK-51-NEXT: a = a > b ? b : a; 394 // CHECK-51-NEXT: } 395 // CHECK-51-NEXT: #pragma omp atomic compare acquire capture 396 // CHECK-51-NEXT: { 397 // CHECK-51-NEXT: v = a; 398 // CHECK-51-NEXT: a = a < b ? b : a; 399 // CHECK-51-NEXT: } 400 // CHECK-51-NEXT: #pragma omp atomic compare capture acquire 401 // CHECK-51-NEXT: { 402 // CHECK-51-NEXT: v = a == b; 403 // CHECK-51-NEXT: if (v) 404 // CHECK-51-NEXT: a = c; 405 // CHECK-51-NEXT: } 406 // CHECK-NEXT: #pragma omp atomic release 407 // CHECK-NEXT: a++; 408 // CHECK-NEXT: #pragma omp atomic read 409 // CHECK-NEXT: a = argc; 410 // CHECK-NEXT: #pragma omp atomic release write 411 // CHECK-NEXT: a = argc + argc; 412 // CHECK-NEXT: #pragma omp atomic update release 413 // CHECK-NEXT: a = a + argc; 414 // CHECK-NEXT: #pragma omp atomic release capture 415 // CHECK-NEXT: a = b++; 416 // CHECK-NEXT: #pragma omp atomic capture release 417 // CHECK-NEXT: { 418 // CHECK-NEXT: a = b; 419 // CHECK-NEXT: b++; 420 // CHECK-NEXT: } 421 // CHECK-51-NEXT: #pragma omp atomic compare release 422 // CHECK-51-NEXT: { 423 // CHECK-51-NEXT: a = a > b ? b : a; 424 // CHECK-51-NEXT: } 425 // CHECK-51-NEXT: #pragma omp atomic release compare 426 // CHECK-51-NEXT: { 427 // CHECK-51-NEXT: a = a < b ? b : a; 428 // CHECK-51-NEXT: } 429 // CHECK-51-NEXT: #pragma omp atomic compare release 430 // CHECK-51-NEXT: { 431 // CHECK-51-NEXT: a = a == b ? c : a; 432 // CHECK-51-NEXT: } 433 // CHECK-51-NEXT: #pragma omp atomic compare capture release 434 // CHECK-51-NEXT: { 435 // CHECK-51-NEXT: v = a; 436 // CHECK-51-NEXT: a = a > b ? b : a; 437 // CHECK-51-NEXT: } 438 // CHECK-51-NEXT: #pragma omp atomic compare release capture 439 // CHECK-51-NEXT: { 440 // CHECK-51-NEXT: v = a; 441 // CHECK-51-NEXT: a = a < b ? b : a; 442 // CHECK-51-NEXT: } 443 // CHECK-51-NEXT: #pragma omp atomic compare capture release 444 // CHECK-51-NEXT: { 445 // CHECK-51-NEXT: v = a == b; 446 // CHECK-51-NEXT: if (v) 447 // CHECK-51-NEXT: a = c; 448 // CHECK-51-NEXT: } 449 // CHECK-NEXT: #pragma omp atomic relaxed 450 // CHECK-NEXT: a++; 451 // CHECK-NEXT: #pragma omp atomic read 452 // CHECK-NEXT: a = argc; 453 // CHECK-NEXT: #pragma omp atomic relaxed write 454 // CHECK-NEXT: a = argc + argc; 455 // CHECK-NEXT: #pragma omp atomic update relaxed 456 // CHECK-NEXT: a = a + argc; 457 // CHECK-NEXT: #pragma omp atomic relaxed capture 458 // CHECK-NEXT: a = b++; 459 // CHECK-NEXT: #pragma omp atomic capture relaxed 460 // CHECK-NEXT: { 461 // CHECK-NEXT: a = b; 462 // CHECK-NEXT: b++; 463 // CHECK-NEXT: } 464 // CHECK-51-NEXT: #pragma omp atomic compare relaxed 465 // CHECK-51-NEXT: { 466 // CHECK-51-NEXT: a = a > b ? b : a; 467 // CHECK-51-NEXT: } 468 // CHECK-51-NEXT: #pragma omp atomic relaxed compare 469 // CHECK-51-NEXT: { 470 // CHECK-51-NEXT: a = a < b ? b : a; 471 // CHECK-51-NEXT: } 472 // CHECK-51-NEXT: #pragma omp atomic compare relaxed 473 // CHECK-51-NEXT: { 474 // CHECK-51-NEXT: a = a == b ? c : a; 475 // CHECK-51-NEXT: } 476 // CHECK-51-NEXT: #pragma omp atomic compare capture relaxed 477 // CHECK-51-NEXT: { 478 // CHECK-51-NEXT: v = a; 479 // CHECK-51-NEXT: a = a > b ? b : a; 480 // CHECK-51-NEXT: } 481 // CHECK-51-NEXT: #pragma omp atomic compare relaxed capture 482 // CHECK-51-NEXT: { 483 // CHECK-51-NEXT: v = a; 484 // CHECK-51-NEXT: a = a < b ? b : a; 485 // CHECK-51-NEXT: } 486 // CHECK-51-NEXT: #pragma omp atomic compare capture relaxed 487 // CHECK-51-NEXT: { 488 // CHECK-51-NEXT: v = a == b; 489 // CHECK-51-NEXT: if (v) 490 // CHECK-51-NEXT: a = c; 491 // CHECK-51-NEXT: } 492 // CHECK-NEXT: #pragma omp atomic hint(6) 493 // CHECK-NEXT: a++; 494 // CHECK-NEXT: #pragma omp atomic read hint(6) 495 // CHECK-NEXT: a = argc; 496 // CHECK-NEXT: #pragma omp atomic hint(6) write 497 // CHECK-NEXT: a = argc + argc; 498 // CHECK-NEXT: #pragma omp atomic update hint(6) 499 // CHECK-NEXT: a = a + argc; 500 // CHECK-NEXT: #pragma omp atomic hint(6) capture 501 // CHECK-NEXT: a = b++; 502 // CHECK-NEXT: #pragma omp atomic capture hint(6) 503 // CHECK-NEXT: { 504 // CHECK-NEXT: a = b; 505 // CHECK-NEXT: b++; 506 // CHECK-NEXT: } 507 // CHECK-51-NEXT: #pragma omp atomic compare hint(6) 508 // CHECK-51-NEXT: { 509 // CHECK-51-NEXT: a = a > b ? b : a; 510 // CHECK-51-NEXT: } 511 // CHECK-51-NEXT: #pragma omp atomic hint(6) compare 512 // CHECK-51-NEXT: { 513 // CHECK-51-NEXT: a = a < b ? b : a; 514 // CHECK-51-NEXT: } 515 // CHECK-51-NEXT: #pragma omp atomic compare hint(6) 516 // CHECK-51-NEXT: { 517 // CHECK-51-NEXT: a = a == b ? c : a; 518 // CHECK-51-NEXT: } 519 // CHECK-51-NEXT: #pragma omp atomic compare capture hint(6) 520 // CHECK-51-NEXT: { 521 // CHECK-51-NEXT: v = a; 522 // CHECK-51-NEXT: a = a > b ? b : a; 523 // CHECK-51-NEXT: } 524 // CHECK-51-NEXT: #pragma omp atomic compare hint(6) capture 525 // CHECK-51-NEXT: { 526 // CHECK-51-NEXT: v = a; 527 // CHECK-51-NEXT: a = a < b ? b : a; 528 // CHECK-51-NEXT: } 529 // CHECK-51-NEXT: #pragma omp atomic compare capture hint(6) 530 // CHECK-51-NEXT: { 531 // CHECK-51-NEXT: v = a == b; 532 // CHECK-51-NEXT: if (v) 533 // CHECK-51-NEXT: a = c; 534 // CHECK-51-NEXT: } 535 // CHECK: int a = int(); 536 // CHECK-NEXT: #pragma omp atomic 537 // CHECK-NEXT: a++; 538 // CHECK-NEXT: #pragma omp atomic read 539 // CHECK-NEXT: a = argc; 540 // CHECK-NEXT: #pragma omp atomic write 541 // CHECK-NEXT: a = argc + argc; 542 // CHECK-NEXT: #pragma omp atomic update 543 // CHECK-NEXT: a = a + argc; 544 // CHECK-NEXT: #pragma omp atomic capture 545 // CHECK-NEXT: a = b++; 546 // CHECK-NEXT: #pragma omp atomic capture 547 // CHECK-NEXT: { 548 // CHECK-NEXT: a = b; 549 // CHECK-NEXT: b++; 550 // CHECK-NEXT: } 551 // CHECK-51-NEXT: #pragma omp atomic compare 552 // CHECK-51-NEXT: { 553 // CHECK-51-NEXT: a = a > b ? b : a; 554 // CHECK-51-NEXT: } 555 // CHECK-51-NEXT: #pragma omp atomic compare 556 // CHECK-51-NEXT: { 557 // CHECK-51-NEXT: a = a < b ? b : a; 558 // CHECK-51-NEXT: } 559 // CHECK-51-NEXT: #pragma omp atomic compare 560 // CHECK-51-NEXT: { 561 // CHECK-51-NEXT: a = a == b ? c : a; 562 // CHECK-51-NEXT: } 563 // CHECK-51-NEXT: #pragma omp atomic compare capture 564 // CHECK-51-NEXT: { 565 // CHECK-51-NEXT: v = a; 566 // CHECK-51-NEXT: a = a > b ? b : a; 567 // CHECK-51-NEXT: } 568 // CHECK-51-NEXT: #pragma omp atomic compare capture 569 // CHECK-51-NEXT: { 570 // CHECK-51-NEXT: v = a; 571 // CHECK-51-NEXT: a = a < b ? b : a; 572 // CHECK-51-NEXT: } 573 // CHECK-51-NEXT: #pragma omp atomic compare capture 574 // CHECK-51-NEXT: { 575 // CHECK-51-NEXT: v = a == b; 576 // CHECK-51-NEXT: if (v) 577 // CHECK-51-NEXT: a = c; 578 // CHECK-51-NEXT: } 579 // CHECK-NEXT: #pragma omp atomic seq_cst 580 // CHECK-NEXT: a++; 581 // CHECK-NEXT: #pragma omp atomic read seq_cst 582 // CHECK-NEXT: a = argc; 583 // CHECK-NEXT: #pragma omp atomic seq_cst write 584 // CHECK-NEXT: a = argc + argc; 585 // CHECK-NEXT: #pragma omp atomic update seq_cst 586 // CHECK-NEXT: a = a + argc; 587 // CHECK-NEXT: #pragma omp atomic seq_cst capture 588 // CHECK-NEXT: a = b++; 589 // CHECK-NEXT: #pragma omp atomic capture seq_cst 590 // CHECK-NEXT: { 591 // CHECK-NEXT: a = b; 592 // CHECK-NEXT: b++; 593 // CHECK-NEXT: } 594 // CHECK-51-NEXT: #pragma omp atomic compare seq_cst 595 // CHECK-51-NEXT: { 596 // CHECK-51-NEXT: a = a > b ? b : a; 597 // CHECK-51-NEXT: } 598 // CHECK-51-NEXT: #pragma omp atomic seq_cst compare 599 // CHECK-51-NEXT: { 600 // CHECK-51-NEXT: a = a < b ? b : a; 601 // CHECK-51-NEXT: } 602 // CHECK-51-NEXT: #pragma omp atomic compare seq_cst 603 // CHECK-51-NEXT: { 604 // CHECK-51-NEXT: a = a == b ? c : a; 605 // CHECK-51-NEXT: } 606 // CHECK-51-NEXT: #pragma omp atomic compare capture seq_cst 607 // CHECK-51-NEXT: { 608 // CHECK-51-NEXT: v = a; 609 // CHECK-51-NEXT: a = a > b ? b : a; 610 // CHECK-51-NEXT: } 611 // CHECK-51-NEXT: #pragma omp atomic compare seq_cst capture 612 // CHECK-51-NEXT: { 613 // CHECK-51-NEXT: v = a; 614 // CHECK-51-NEXT: a = a < b ? b : a; 615 // CHECK-51-NEXT: } 616 // CHECK-51-NEXT: #pragma omp atomic compare capture seq_cst 617 // CHECK-51-NEXT: { 618 // CHECK-51-NEXT: v = a == b; 619 // CHECK-51-NEXT: if (v) 620 // CHECK-51-NEXT: a = c; 621 // CHECK-51-NEXT: } 622 // CHECK-NEXT: #pragma omp atomic 623 // CHECK-NEXT: a++; 624 // CHECK-NEXT: #pragma omp atomic read 625 // CHECK-NEXT: a = argc; 626 // CHECK-NEXT: #pragma omp atomic write 627 // CHECK-NEXT: a = argc + argc; 628 // CHECK-NEXT: #pragma omp atomic update 629 // CHECK-NEXT: a = a + argc; 630 // CHECK-NEXT: #pragma omp atomic acq_rel capture 631 // CHECK-NEXT: a = b++; 632 // CHECK-NEXT: #pragma omp atomic capture acq_rel 633 // CHECK-NEXT: { 634 // CHECK-NEXT: a = b; 635 // CHECK-NEXT: b++; 636 // CHECK-NEXT: } 637 // CHECK-51-NEXT: #pragma omp atomic compare acq_rel 638 // CHECK-51-NEXT: { 639 // CHECK-51-NEXT: a = a > b ? b : a; 640 // CHECK-51-NEXT: } 641 // CHECK-51-NEXT: #pragma omp atomic acq_rel compare 642 // CHECK-51-NEXT: { 643 // CHECK-51-NEXT: a = a < b ? b : a; 644 // CHECK-51-NEXT: } 645 // CHECK-51-NEXT: #pragma omp atomic compare acq_rel 646 // CHECK-51-NEXT: { 647 // CHECK-51-NEXT: a = a == b ? c : a; 648 // CHECK-51-NEXT: } 649 // CHECK-51-NEXT: #pragma omp atomic compare capture acq_rel 650 // CHECK-51-NEXT: { 651 // CHECK-51-NEXT: v = a; 652 // CHECK-51-NEXT: a = a > b ? b : a; 653 // CHECK-51-NEXT: } 654 // CHECK-51-NEXT: #pragma omp atomic compare acq_rel capture 655 // CHECK-51-NEXT: { 656 // CHECK-51-NEXT: v = a; 657 // CHECK-51-NEXT: a = a < b ? b : a; 658 // CHECK-51-NEXT: } 659 // CHECK-51-NEXT: #pragma omp atomic compare capture acq_rel 660 // CHECK-51-NEXT: { 661 // CHECK-51-NEXT: v = a == b; 662 // CHECK-51-NEXT: if (v) 663 // CHECK-51-NEXT: a = c; 664 // CHECK-51-NEXT: } 665 // CHECK-NEXT: #pragma omp atomic 666 // CHECK-NEXT: a++; 667 // CHECK-NEXT: #pragma omp atomic read acquire 668 // CHECK-NEXT: a = argc; 669 // CHECK-NEXT: #pragma omp atomic write 670 // CHECK-NEXT: a = argc + argc; 671 // CHECK-NEXT: #pragma omp atomic update 672 // CHECK-NEXT: a = a + argc; 673 // CHECK-NEXT: #pragma omp atomic acquire capture 674 // CHECK-NEXT: a = b++; 675 // CHECK-NEXT: #pragma omp atomic capture acquire 676 // CHECK-NEXT: { 677 // CHECK-NEXT: a = b; 678 // CHECK-NEXT: b++; 679 // CHECK-NEXT: } 680 // CHECK-51-NEXT: #pragma omp atomic compare acquire 681 // CHECK-51-NEXT: { 682 // CHECK-51-NEXT: a = a > b ? b : a; 683 // CHECK-51-NEXT: } 684 // CHECK-51-NEXT: #pragma omp atomic acquire compare 685 // CHECK-51-NEXT: { 686 // CHECK-51-NEXT: a = a < b ? b : a; 687 // CHECK-51-NEXT: } 688 // CHECK-51-NEXT: #pragma omp atomic compare acquire 689 // CHECK-51-NEXT: { 690 // CHECK-51-NEXT: a = a == b ? c : a; 691 // CHECK-51-NEXT: } 692 // CHECK-51-NEXT: #pragma omp atomic compare capture acquire 693 // CHECK-51-NEXT: { 694 // CHECK-51-NEXT: v = a; 695 // CHECK-51-NEXT: a = a > b ? b : a; 696 // CHECK-51-NEXT: } 697 // CHECK-51-NEXT: #pragma omp atomic compare acquire capture 698 // CHECK-51-NEXT: { 699 // CHECK-51-NEXT: v = a; 700 // CHECK-51-NEXT: a = a < b ? b : a; 701 // CHECK-51-NEXT: } 702 // CHECK-51-NEXT: #pragma omp atomic compare capture acquire 703 // CHECK-51-NEXT: { 704 // CHECK-51-NEXT: v = a == b; 705 // CHECK-51-NEXT: if (v) 706 // CHECK-51-NEXT: a = c; 707 // CHECK-51-NEXT: } 708 // CHECK-NEXT: #pragma omp atomic release 709 // CHECK-NEXT: a++; 710 // CHECK-NEXT: #pragma omp atomic read 711 // CHECK-NEXT: a = argc; 712 // CHECK-NEXT: #pragma omp atomic release write 713 // CHECK-NEXT: a = argc + argc; 714 // CHECK-NEXT: #pragma omp atomic update release 715 // CHECK-NEXT: a = a + argc; 716 // CHECK-NEXT: #pragma omp atomic release capture 717 // CHECK-NEXT: a = b++; 718 // CHECK-NEXT: #pragma omp atomic capture release 719 // CHECK-NEXT: { 720 // CHECK-NEXT: a = b; 721 // CHECK-NEXT: b++; 722 // CHECK-NEXT: } 723 // CHECK-51-NEXT: #pragma omp atomic compare release 724 // CHECK-51-NEXT: { 725 // CHECK-51-NEXT: a = a > b ? b : a; 726 // CHECK-51-NEXT: } 727 // CHECK-51-NEXT: #pragma omp atomic release compare 728 // CHECK-51-NEXT: { 729 // CHECK-51-NEXT: a = a < b ? b : a; 730 // CHECK-51-NEXT: } 731 // CHECK-51-NEXT: #pragma omp atomic compare release 732 // CHECK-51-NEXT: { 733 // CHECK-51-NEXT: a = a == b ? c : a; 734 // CHECK-51-NEXT: } 735 // CHECK-51-NEXT: #pragma omp atomic compare capture release 736 // CHECK-51-NEXT: { 737 // CHECK-51-NEXT: v = a; 738 // CHECK-51-NEXT: a = a > b ? b : a; 739 // CHECK-51-NEXT: } 740 // CHECK-51-NEXT: #pragma omp atomic compare release capture 741 // CHECK-51-NEXT: { 742 // CHECK-51-NEXT: v = a; 743 // CHECK-51-NEXT: a = a < b ? b : a; 744 // CHECK-51-NEXT: } 745 // CHECK-51-NEXT: #pragma omp atomic compare capture release 746 // CHECK-51-NEXT: { 747 // CHECK-51-NEXT: v = a == b; 748 // CHECK-51-NEXT: if (v) 749 // CHECK-51-NEXT: a = c; 750 // CHECK-51-NEXT: } 751 // CHECK-NEXT: #pragma omp atomic relaxed 752 // CHECK-NEXT: a++; 753 // CHECK-NEXT: #pragma omp atomic read 754 // CHECK-NEXT: a = argc; 755 // CHECK-NEXT: #pragma omp atomic relaxed write 756 // CHECK-NEXT: a = argc + argc; 757 // CHECK-NEXT: #pragma omp atomic update relaxed 758 // CHECK-NEXT: a = a + argc; 759 // CHECK-NEXT: #pragma omp atomic relaxed capture 760 // CHECK-NEXT: a = b++; 761 // CHECK-NEXT: #pragma omp atomic capture relaxed 762 // CHECK-NEXT: { 763 // CHECK-NEXT: a = b; 764 // CHECK-NEXT: b++; 765 // CHECK-NEXT: } 766 // CHECK-51-NEXT: #pragma omp atomic compare relaxed 767 // CHECK-51-NEXT: { 768 // CHECK-51-NEXT: a = a > b ? b : a; 769 // CHECK-51-NEXT: } 770 // CHECK-51-NEXT: #pragma omp atomic relaxed compare 771 // CHECK-51-NEXT: { 772 // CHECK-51-NEXT: a = a < b ? b : a; 773 // CHECK-51-NEXT: } 774 // CHECK-51-NEXT: #pragma omp atomic compare relaxed 775 // CHECK-51-NEXT: { 776 // CHECK-51-NEXT: a = a == b ? c : a; 777 // CHECK-51-NEXT: } 778 // CHECK-51-NEXT: #pragma omp atomic compare capture relaxed 779 // CHECK-51-NEXT: { 780 // CHECK-51-NEXT: v = a; 781 // CHECK-51-NEXT: a = a > b ? b : a; 782 // CHECK-51-NEXT: } 783 // CHECK-51-NEXT: #pragma omp atomic compare relaxed capture 784 // CHECK-51-NEXT: { 785 // CHECK-51-NEXT: v = a; 786 // CHECK-51-NEXT: a = a < b ? b : a; 787 // CHECK-51-NEXT: } 788 // CHECK-51-NEXT: #pragma omp atomic compare capture relaxed 789 // CHECK-51-NEXT: { 790 // CHECK-51-NEXT: v = a == b; 791 // CHECK-51-NEXT: if (v) 792 // CHECK-51-NEXT: a = c; 793 // CHECK-51-NEXT: } 794 // CHECK-NEXT: #pragma omp atomic hint(6) 795 // CHECK-NEXT: a++; 796 // CHECK-NEXT: #pragma omp atomic read hint(6) 797 // CHECK-NEXT: a = argc; 798 // CHECK-NEXT: #pragma omp atomic hint(6) write 799 // CHECK-NEXT: a = argc + argc; 800 // CHECK-NEXT: #pragma omp atomic update hint(6) 801 // CHECK-NEXT: a = a + argc; 802 // CHECK-NEXT: #pragma omp atomic hint(6) capture 803 // CHECK-NEXT: a = b++; 804 // CHECK-NEXT: #pragma omp atomic capture hint(6) 805 // CHECK-NEXT: { 806 // CHECK-NEXT: a = b; 807 // CHECK-NEXT: b++; 808 // CHECK-NEXT: } 809 // CHECK-51-NEXT: #pragma omp atomic compare hint(6) 810 // CHECK-51-NEXT: { 811 // CHECK-51-NEXT: a = a > b ? b : a; 812 // CHECK-51-NEXT: } 813 // CHECK-51-NEXT: #pragma omp atomic hint(6) compare 814 // CHECK-51-NEXT: { 815 // CHECK-51-NEXT: a = a < b ? b : a; 816 // CHECK-51-NEXT: } 817 // CHECK-51-NEXT: #pragma omp atomic compare hint(6) 818 // CHECK-51-NEXT: { 819 // CHECK-51-NEXT: a = a == b ? c : a; 820 // CHECK-51-NEXT: } 821 // CHECK-51-NEXT: #pragma omp atomic compare capture hint(6) 822 // CHECK-51-NEXT: { 823 // CHECK-51-NEXT: v = a; 824 // CHECK-51-NEXT: a = a > b ? b : a; 825 // CHECK-51-NEXT: } 826 // CHECK-51-NEXT: #pragma omp atomic compare hint(6) capture 827 // CHECK-51-NEXT: { 828 // CHECK-51-NEXT: v = a; 829 // CHECK-51-NEXT: a = a < b ? b : a; 830 // CHECK-51-NEXT: } 831 // CHECK-51-NEXT: #pragma omp atomic compare capture hint(6) 832 // CHECK-51-NEXT: { 833 // CHECK-51-NEXT: v = a == b; 834 // CHECK-51-NEXT: if (v) 835 // CHECK-51-NEXT: a = c; 836 // CHECK-51-NEXT: } 837 838 int main(int argc, char **argv) { 839 int v = 0; 840 int c = 0; 841 int b = 0; 842 int a = 0; 843 // CHECK: int a = 0; 844 #pragma omp atomic 845 a++; 846 #pragma omp atomic read 847 a = argc; 848 #pragma omp atomic write 849 a = argc + argc; 850 #pragma omp atomic update 851 a = a + argc; 852 #pragma omp atomic capture 853 a = b++; 854 #pragma omp atomic capture 855 { 856 a = b; 857 b++; 858 } 859 #ifdef OMP51 860 #pragma omp atomic compare 861 { a = a > b ? b : a; } 862 #pragma omp atomic compare 863 { a = a < b ? b : a; } 864 #pragma omp atomic compare 865 { a = a == b ? c : a; } 866 #pragma omp atomic compare capture 867 { v = a; a = a > b ? b : a; } 868 #pragma omp atomic compare capture 869 { v = a; a = a < b ? b : a; } 870 #pragma omp atomic compare capture 871 { v = a == b; if (v) a = c; } 872 #endif 873 #pragma omp atomic seq_cst 874 a++; 875 #pragma omp atomic read seq_cst 876 a = argc; 877 #pragma omp atomic seq_cst write 878 a = argc + argc; 879 #pragma omp atomic update seq_cst 880 a = a + argc; 881 #pragma omp atomic seq_cst capture 882 a = b++; 883 #pragma omp atomic capture seq_cst 884 { 885 a = b; 886 b++; 887 } 888 #ifdef OMP51 889 #pragma omp atomic compare seq_cst 890 { a = a > b ? b : a; } 891 #pragma omp atomic seq_cst compare 892 { a = a < b ? b : a; } 893 #pragma omp atomic compare seq_cst 894 { a = a == b ? c : a; } 895 #pragma omp atomic compare capture seq_cst 896 { v = a; a = a > b ? b : a; } 897 #pragma omp atomic compare seq_cst capture 898 { v = a; a = a < b ? b : a; } 899 #pragma omp atomic compare capture seq_cst 900 { v = a == b; if (v) a = c; } 901 #endif 902 #pragma omp atomic 903 a++; 904 #pragma omp atomic read 905 a = argc; 906 #pragma omp atomic write 907 a = argc + argc; 908 #pragma omp atomic update 909 a = a + argc; 910 #pragma omp atomic acq_rel capture 911 a = b++; 912 #pragma omp atomic capture acq_rel 913 { 914 a = b; 915 b++; 916 } 917 #ifdef OMP51 918 #pragma omp atomic compare acq_rel 919 { a = a > b ? b : a; } 920 #pragma omp atomic acq_rel compare 921 { a = a < b ? b : a; } 922 #pragma omp atomic compare acq_rel 923 { a = a == b ? c : a; } 924 #pragma omp atomic compare capture acq_rel 925 { v = a; a = a > b ? b : a; } 926 #pragma omp atomic compare acq_rel capture 927 { v = a; a = a < b ? b : a; } 928 #pragma omp atomic compare capture acq_rel 929 { v = a == b; if (v) a = c; } 930 #endif 931 #pragma omp atomic 932 a++; 933 #pragma omp atomic read acquire 934 a = argc; 935 #pragma omp atomic write 936 a = argc + argc; 937 #pragma omp atomic update 938 a = a + argc; 939 #pragma omp atomic acquire capture 940 a = b++; 941 #pragma omp atomic capture acquire 942 { 943 a = b; 944 b++; 945 } 946 #ifdef OMP51 947 #pragma omp atomic compare acquire 948 { a = a > b ? b : a; } 949 #pragma omp atomic acquire compare 950 { a = a < b ? b : a; } 951 #pragma omp atomic compare acquire 952 { a = a == b ? c : a; } 953 #pragma omp atomic compare capture acquire 954 { v = a; a = a > b ? b : a; } 955 #pragma omp atomic compare acquire capture 956 { v = a; a = a < b ? b : a; } 957 #pragma omp atomic compare capture acquire 958 { v = a == b; if (v) a = c; } 959 #endif 960 #pragma omp atomic release 961 a++; 962 #pragma omp atomic read 963 a = argc; 964 #pragma omp atomic release write 965 a = argc + argc; 966 #pragma omp atomic update release 967 a = a + argc; 968 #pragma omp atomic release capture 969 a = b++; 970 #pragma omp atomic capture release 971 { 972 a = b; 973 b++; 974 } 975 #ifdef OMP51 976 #pragma omp atomic compare release 977 { a = a > b ? b : a; } 978 #pragma omp atomic release compare 979 { a = a < b ? b : a; } 980 #pragma omp atomic compare release 981 { a = a == b ? c : a; } 982 #pragma omp atomic compare capture release 983 { v = a; a = a > b ? b : a; } 984 #pragma omp atomic compare release capture 985 { v = a; a = a < b ? b : a; } 986 #pragma omp atomic compare capture release 987 { v = a == b; if (v) a = c; } 988 #endif 989 #pragma omp atomic relaxed 990 a++; 991 #pragma omp atomic read 992 a = argc; 993 #pragma omp atomic relaxed write 994 a = argc + argc; 995 #pragma omp atomic update relaxed 996 a = a + argc; 997 #pragma omp atomic relaxed capture 998 a = b++; 999 #pragma omp atomic capture relaxed 1000 { 1001 a = b; 1002 b++; 1003 } 1004 #ifdef OMP51 1005 #pragma omp atomic compare relaxed 1006 { a = a > b ? b : a; } 1007 #pragma omp atomic relaxed compare 1008 { a = a < b ? b : a; } 1009 #pragma omp atomic compare relaxed 1010 { a = a == b ? c : a; } 1011 #pragma omp atomic compare capture relaxed 1012 { v = a; a = a > b ? b : a; } 1013 #pragma omp atomic compare relaxed capture 1014 { v = a; a = a < b ? b : a; } 1015 #pragma omp atomic compare capture relaxed 1016 { v = a == b; if (v) a = c; } 1017 #endif 1018 #pragma omp atomic hint(6) 1019 a++; 1020 #pragma omp atomic read hint(6) 1021 a = argc; 1022 #pragma omp atomic hint(6) write 1023 a = argc + argc; 1024 #pragma omp atomic update hint(6) 1025 a = a + argc; 1026 #pragma omp atomic hint(6) capture 1027 a = b++; 1028 #pragma omp atomic capture hint(6) 1029 { 1030 a = b; 1031 b++; 1032 } 1033 #ifdef OMP51 1034 #pragma omp atomic compare hint(6) 1035 { a = a > b ? b : a; } 1036 #pragma omp atomic hint(6) compare 1037 { a = a < b ? b : a; } 1038 #pragma omp atomic compare hint(6) 1039 { a = a == b ? c : a; } 1040 #pragma omp atomic compare capture hint(6) 1041 { v = a; a = a > b ? b : a; } 1042 #pragma omp atomic compare hint(6) capture 1043 { v = a; a = a < b ? b : a; } 1044 #pragma omp atomic compare capture hint(6) 1045 { v = a == b; if (v) a = c; } 1046 #endif 1047 // CHECK-NEXT: #pragma omp atomic 1048 // CHECK-NEXT: a++; 1049 // CHECK-NEXT: #pragma omp atomic read 1050 // CHECK-NEXT: a = argc; 1051 // CHECK-NEXT: #pragma omp atomic write 1052 // CHECK-NEXT: a = argc + argc; 1053 // CHECK-NEXT: #pragma omp atomic update 1054 // CHECK-NEXT: a = a + argc; 1055 // CHECK-NEXT: #pragma omp atomic capture 1056 // CHECK-NEXT: a = b++; 1057 // CHECK-NEXT: #pragma omp atomic capture 1058 // CHECK-NEXT: { 1059 // CHECK-NEXT: a = b; 1060 // CHECK-NEXT: b++; 1061 // CHECK-NEXT: } 1062 // CHECK-51-NEXT: #pragma omp atomic compare 1063 // CHECK-51-NEXT: { 1064 // CHECK-51-NEXT: a = a > b ? b : a; 1065 // CHECK-51-NEXT: } 1066 // CHECK-51-NEXT: #pragma omp atomic compare 1067 // CHECK-51-NEXT: { 1068 // CHECK-51-NEXT: a = a < b ? b : a; 1069 // CHECK-51-NEXT: } 1070 // CHECK-51-NEXT: #pragma omp atomic compare 1071 // CHECK-51-NEXT: { 1072 // CHECK-51-NEXT: a = a == b ? c : a; 1073 // CHECK-51-NEXT: } 1074 // CHECK-51-NEXT: #pragma omp atomic compare capture 1075 // CHECK-51-NEXT: { 1076 // CHECK-51-NEXT: v = a; 1077 // CHECK-51-NEXT: a = a > b ? b : a; 1078 // CHECK-51-NEXT: } 1079 // CHECK-51-NEXT: #pragma omp atomic compare capture 1080 // CHECK-51-NEXT: { 1081 // CHECK-51-NEXT: v = a; 1082 // CHECK-51-NEXT: a = a < b ? b : a; 1083 // CHECK-51-NEXT: } 1084 // CHECK-51-NEXT: #pragma omp atomic compare capture 1085 // CHECK-51-NEXT: { 1086 // CHECK-51-NEXT: v = a == b; 1087 // CHECK-51-NEXT: if (v) 1088 // CHECK-51-NEXT: a = c; 1089 // CHECK-51-NEXT: } 1090 // CHECK-NEXT: #pragma omp atomic seq_cst 1091 // CHECK-NEXT: a++; 1092 // CHECK-NEXT: #pragma omp atomic read seq_cst 1093 // CHECK-NEXT: a = argc; 1094 // CHECK-NEXT: #pragma omp atomic seq_cst write 1095 // CHECK-NEXT: a = argc + argc; 1096 // CHECK-NEXT: #pragma omp atomic update seq_cst 1097 // CHECK-NEXT: a = a + argc; 1098 // CHECK-NEXT: #pragma omp atomic seq_cst capture 1099 // CHECK-NEXT: a = b++; 1100 // CHECK-NEXT: #pragma omp atomic capture seq_cst 1101 // CHECK-NEXT: { 1102 // CHECK-NEXT: a = b; 1103 // CHECK-NEXT: b++; 1104 // CHECK-NEXT: } 1105 // CHECK-51-NEXT: #pragma omp atomic compare seq_cst 1106 // CHECK-51-NEXT: { 1107 // CHECK-51-NEXT: a = a > b ? b : a; 1108 // CHECK-51-NEXT: } 1109 // CHECK-51-NEXT: #pragma omp atomic seq_cst compare 1110 // CHECK-51-NEXT: { 1111 // CHECK-51-NEXT: a = a < b ? b : a; 1112 // CHECK-51-NEXT: } 1113 // CHECK-51-NEXT: #pragma omp atomic compare seq_cst 1114 // CHECK-51-NEXT: { 1115 // CHECK-51-NEXT: a = a == b ? c : a; 1116 // CHECK-51-NEXT: } 1117 // CHECK-51-NEXT: #pragma omp atomic compare capture seq_cst 1118 // CHECK-51-NEXT: { 1119 // CHECK-51-NEXT: v = a; 1120 // CHECK-51-NEXT: a = a > b ? b : a; 1121 // CHECK-51-NEXT: } 1122 // CHECK-51-NEXT: #pragma omp atomic compare seq_cst capture 1123 // CHECK-51-NEXT: { 1124 // CHECK-51-NEXT: v = a; 1125 // CHECK-51-NEXT: a = a < b ? b : a; 1126 // CHECK-51-NEXT: } 1127 // CHECK-51-NEXT: #pragma omp atomic compare capture seq_cst 1128 // CHECK-51-NEXT: { 1129 // CHECK-51-NEXT: v = a == b; 1130 // CHECK-51-NEXT: if (v) 1131 // CHECK-51-NEXT: a = c; 1132 // CHECK-51-NEXT: } 1133 // CHECK-NEXT: #pragma omp atomic 1134 // CHECK-NEXT: a++; 1135 // CHECK-NEXT: #pragma omp atomic read 1136 // CHECK-NEXT: a = argc; 1137 // CHECK-NEXT: #pragma omp atomic write 1138 // CHECK-NEXT: a = argc + argc; 1139 // CHECK-NEXT: #pragma omp atomic update 1140 // CHECK-NEXT: a = a + argc; 1141 // CHECK-NEXT: #pragma omp atomic acq_rel capture 1142 // CHECK-NEXT: a = b++; 1143 // CHECK-NEXT: #pragma omp atomic capture acq_rel 1144 // CHECK-NEXT: { 1145 // CHECK-NEXT: a = b; 1146 // CHECK-NEXT: b++; 1147 // CHECK-NEXT: } 1148 // CHECK-51-NEXT: #pragma omp atomic compare acq_rel 1149 // CHECK-51-NEXT: { 1150 // CHECK-51-NEXT: a = a > b ? b : a; 1151 // CHECK-51-NEXT: } 1152 // CHECK-51-NEXT: #pragma omp atomic acq_rel compare 1153 // CHECK-51-NEXT: { 1154 // CHECK-51-NEXT: a = a < b ? b : a; 1155 // CHECK-51-NEXT: } 1156 // CHECK-51-NEXT: #pragma omp atomic compare acq_rel 1157 // CHECK-51-NEXT: { 1158 // CHECK-51-NEXT: a = a == b ? c : a; 1159 // CHECK-51-NEXT: } 1160 // CHECK-51-NEXT: #pragma omp atomic compare capture acq_rel 1161 // CHECK-51-NEXT: { 1162 // CHECK-51-NEXT: v = a; 1163 // CHECK-51-NEXT: a = a > b ? b : a; 1164 // CHECK-51-NEXT: } 1165 // CHECK-51-NEXT: #pragma omp atomic compare acq_rel capture 1166 // CHECK-51-NEXT: { 1167 // CHECK-51-NEXT: v = a; 1168 // CHECK-51-NEXT: a = a < b ? b : a; 1169 // CHECK-51-NEXT: } 1170 // CHECK-51-NEXT: #pragma omp atomic compare capture acq_rel 1171 // CHECK-51-NEXT: { 1172 // CHECK-51-NEXT: v = a == b; 1173 // CHECK-51-NEXT: if (v) 1174 // CHECK-51-NEXT: a = c; 1175 // CHECK-51-NEXT: } 1176 // CHECK-NEXT: #pragma omp atomic 1177 // CHECK-NEXT: a++; 1178 // CHECK-NEXT: #pragma omp atomic read acquire 1179 // CHECK-NEXT: a = argc; 1180 // CHECK-NEXT: #pragma omp atomic write 1181 // CHECK-NEXT: a = argc + argc; 1182 // CHECK-NEXT: #pragma omp atomic update 1183 // CHECK-NEXT: a = a + argc; 1184 // CHECK-NEXT: #pragma omp atomic acquire capture 1185 // CHECK-NEXT: a = b++; 1186 // CHECK-NEXT: #pragma omp atomic capture acquire 1187 // CHECK-NEXT: { 1188 // CHECK-NEXT: a = b; 1189 // CHECK-NEXT: b++; 1190 // CHECK-NEXT: } 1191 // CHECK-51-NEXT: #pragma omp atomic compare acquire 1192 // CHECK-51-NEXT: { 1193 // CHECK-51-NEXT: a = a > b ? b : a; 1194 // CHECK-51-NEXT: } 1195 // CHECK-51-NEXT: #pragma omp atomic acquire compare 1196 // CHECK-51-NEXT: { 1197 // CHECK-51-NEXT: a = a < b ? b : a; 1198 // CHECK-51-NEXT: } 1199 // CHECK-51-NEXT: #pragma omp atomic compare acquire 1200 // CHECK-51-NEXT: { 1201 // CHECK-51-NEXT: a = a == b ? c : a; 1202 // CHECK-51-NEXT: } 1203 // CHECK-51-NEXT: #pragma omp atomic compare capture acquire 1204 // CHECK-51-NEXT: { 1205 // CHECK-51-NEXT: v = a; 1206 // CHECK-51-NEXT: a = a > b ? b : a; 1207 // CHECK-51-NEXT: } 1208 // CHECK-51-NEXT: #pragma omp atomic compare acquire capture 1209 // CHECK-51-NEXT: { 1210 // CHECK-51-NEXT: v = a; 1211 // CHECK-51-NEXT: a = a < b ? b : a; 1212 // CHECK-51-NEXT: } 1213 // CHECK-51-NEXT: #pragma omp atomic compare capture acquire 1214 // CHECK-51-NEXT: { 1215 // CHECK-51-NEXT: v = a == b; 1216 // CHECK-51-NEXT: if (v) 1217 // CHECK-51-NEXT: a = c; 1218 // CHECK-51-NEXT: } 1219 // CHECK-NEXT: #pragma omp atomic release 1220 // CHECK-NEXT: a++; 1221 // CHECK-NEXT: #pragma omp atomic read 1222 // CHECK-NEXT: a = argc; 1223 // CHECK-NEXT: #pragma omp atomic release write 1224 // CHECK-NEXT: a = argc + argc; 1225 // CHECK-NEXT: #pragma omp atomic update release 1226 // CHECK-NEXT: a = a + argc; 1227 // CHECK-NEXT: #pragma omp atomic release capture 1228 // CHECK-NEXT: a = b++; 1229 // CHECK-NEXT: #pragma omp atomic capture release 1230 // CHECK-NEXT: { 1231 // CHECK-NEXT: a = b; 1232 // CHECK-NEXT: b++; 1233 // CHECK-NEXT: } 1234 // CHECK-51-NEXT: #pragma omp atomic compare release 1235 // CHECK-51-NEXT: { 1236 // CHECK-51-NEXT: a = a > b ? b : a; 1237 // CHECK-51-NEXT: } 1238 // CHECK-51-NEXT: #pragma omp atomic release compare 1239 // CHECK-51-NEXT: { 1240 // CHECK-51-NEXT: a = a < b ? b : a; 1241 // CHECK-51-NEXT: } 1242 // CHECK-51-NEXT: #pragma omp atomic compare release 1243 // CHECK-51-NEXT: { 1244 // CHECK-51-NEXT: a = a == b ? c : a; 1245 // CHECK-51-NEXT: } 1246 // CHECK-51-NEXT: #pragma omp atomic compare capture release 1247 // CHECK-51-NEXT: { 1248 // CHECK-51-NEXT: v = a; 1249 // CHECK-51-NEXT: a = a > b ? b : a; 1250 // CHECK-51-NEXT: } 1251 // CHECK-51-NEXT: #pragma omp atomic compare release capture 1252 // CHECK-51-NEXT: { 1253 // CHECK-51-NEXT: v = a; 1254 // CHECK-51-NEXT: a = a < b ? b : a; 1255 // CHECK-51-NEXT: } 1256 // CHECK-51-NEXT: #pragma omp atomic compare capture release 1257 // CHECK-51-NEXT: { 1258 // CHECK-51-NEXT: v = a == b; 1259 // CHECK-51-NEXT: if (v) 1260 // CHECK-51-NEXT: a = c; 1261 // CHECK-51-NEXT: } 1262 // CHECK-NEXT: #pragma omp atomic relaxed 1263 // CHECK-NEXT: a++; 1264 // CHECK-NEXT: #pragma omp atomic read 1265 // CHECK-NEXT: a = argc; 1266 // CHECK-NEXT: #pragma omp atomic relaxed write 1267 // CHECK-NEXT: a = argc + argc; 1268 // CHECK-NEXT: #pragma omp atomic update relaxed 1269 // CHECK-NEXT: a = a + argc; 1270 // CHECK-NEXT: #pragma omp atomic relaxed capture 1271 // CHECK-NEXT: a = b++; 1272 // CHECK-NEXT: #pragma omp atomic capture relaxed 1273 // CHECK-NEXT: { 1274 // CHECK-NEXT: a = b; 1275 // CHECK-NEXT: b++; 1276 // CHECK-NEXT: } 1277 // CHECK-51-NEXT: #pragma omp atomic compare relaxed 1278 // CHECK-51-NEXT: { 1279 // CHECK-51-NEXT: a = a > b ? b : a; 1280 // CHECK-51-NEXT: } 1281 // CHECK-51-NEXT: #pragma omp atomic relaxed compare 1282 // CHECK-51-NEXT: { 1283 // CHECK-51-NEXT: a = a < b ? b : a; 1284 // CHECK-51-NEXT: } 1285 // CHECK-51-NEXT: #pragma omp atomic compare relaxed 1286 // CHECK-51-NEXT: { 1287 // CHECK-51-NEXT: a = a == b ? c : a; 1288 // CHECK-51-NEXT: } 1289 // CHECK-51-NEXT: #pragma omp atomic compare capture relaxed 1290 // CHECK-51-NEXT: { 1291 // CHECK-51-NEXT: v = a; 1292 // CHECK-51-NEXT: a = a > b ? b : a; 1293 // CHECK-51-NEXT: } 1294 // CHECK-51-NEXT: #pragma omp atomic compare relaxed capture 1295 // CHECK-51-NEXT: { 1296 // CHECK-51-NEXT: v = a; 1297 // CHECK-51-NEXT: a = a < b ? b : a; 1298 // CHECK-51-NEXT: } 1299 // CHECK-51-NEXT: #pragma omp atomic compare capture relaxed 1300 // CHECK-51-NEXT: { 1301 // CHECK-51-NEXT: v = a == b; 1302 // CHECK-51-NEXT: if (v) 1303 // CHECK-51-NEXT: a = c; 1304 // CHECK-51-NEXT: } 1305 // CHECK-NEXT: #pragma omp atomic hint(6) 1306 // CHECK-NEXT: a++; 1307 // CHECK-NEXT: #pragma omp atomic read hint(6) 1308 // CHECK-NEXT: a = argc; 1309 // CHECK-NEXT: #pragma omp atomic hint(6) write 1310 // CHECK-NEXT: a = argc + argc; 1311 // CHECK-NEXT: #pragma omp atomic update hint(6) 1312 // CHECK-NEXT: a = a + argc; 1313 // CHECK-NEXT: #pragma omp atomic hint(6) capture 1314 // CHECK-NEXT: a = b++; 1315 // CHECK-NEXT: #pragma omp atomic capture hint(6) 1316 // CHECK-NEXT: { 1317 // CHECK-NEXT: a = b; 1318 // CHECK-NEXT: b++; 1319 // CHECK-NEXT: } 1320 // CHECK-51-NEXT: #pragma omp atomic compare hint(6) 1321 // CHECK-51-NEXT: { 1322 // CHECK-51-NEXT: a = a > b ? b : a; 1323 // CHECK-51-NEXT: } 1324 // CHECK-51-NEXT: #pragma omp atomic hint(6) compare 1325 // CHECK-51-NEXT: { 1326 // CHECK-51-NEXT: a = a < b ? b : a; 1327 // CHECK-51-NEXT: } 1328 // CHECK-51-NEXT: #pragma omp atomic compare hint(6) 1329 // CHECK-51-NEXT: { 1330 // CHECK-51-NEXT: a = a == b ? c : a; 1331 // CHECK-51-NEXT: } 1332 // CHECK-51-NEXT: #pragma omp atomic compare capture hint(6) 1333 // CHECK-51-NEXT: { 1334 // CHECK-51-NEXT: v = a; 1335 // CHECK-51-NEXT: a = a > b ? b : a; 1336 // CHECK-51-NEXT: } 1337 // CHECK-51-NEXT: #pragma omp atomic compare hint(6) capture 1338 // CHECK-51-NEXT: { 1339 // CHECK-51-NEXT: v = a; 1340 // CHECK-51-NEXT: a = a < b ? b : a; 1341 // CHECK-51-NEXT: } 1342 // CHECK-51-NEXT: #pragma omp atomic compare capture hint(6) 1343 // CHECK-51-NEXT: { 1344 // CHECK-51-NEXT: v = a == b; 1345 // CHECK-51-NEXT: if (v) 1346 // CHECK-51-NEXT: a = c; 1347 // CHECK-51-NEXT: } 1348 // expect-note@+1 {{in instantiation of function template specialization 'foo<int>' requested here}} 1349 return foo(a); 1350 } 1351 1352 #endif 1353