1025 lines · cpp
1// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -ferror-limit 150 %s -Wuninitialized2// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -ferror-limit 150 %s -Wuninitialized3// RUN: %clang_cc1 -DOMP51 -verify=expected,omp50,omp51 -fopenmp -ferror-limit 150 %s -Wuninitialized4 5// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -ferror-limit 150 %s -Wuninitialized6// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -ferror-limit 150 %s -Wuninitialized7// RUN: %clang_cc1 -DOMP51 -verify=expected,omp50,omp51 -fopenmp-simd -ferror-limit 150 %s -Wuninitialized8 9int foo() {10L1:11 foo();12#pragma omp atomic13 // expected-error@+2 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an lvalue expression with scalar type}}14 // expected-note@+1 {{expected an expression statement}}15 {16 foo();17 goto L1;18 }19 goto L2;20#pragma omp atomic21 // expected-error@+2 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an lvalue expression with scalar type}}22 // expected-note@+1 {{expected an expression statement}}23 {24 foo();25 L2:26 foo();27 }28 29 return 0;30}31 32struct S {33 int a;34 S &operator=(int v) {35 a = v;36 return *this;37 }38 S &operator+=(const S &s) {39 a += s.a;40 return *this;41 }42};43 44template <class T>45T read() {46 T a = T(), b = T();47// Test for atomic read48#pragma omp atomic read49 // expected-error@+2 {{the statement for 'atomic read' must be an expression statement of form 'v = x;', where v and x are both lvalue expressions with scalar type}}50 // expected-note@+1 {{expected an expression statement}}51 ;52#pragma omp atomic read53 // expected-error@+2 {{the statement for 'atomic read' must be an expression statement of form 'v = x;', where v and x are both lvalue expressions with scalar type}}54 // expected-note@+1 {{expected built-in assignment operator}}55 foo();56#pragma omp atomic read57 // expected-error@+2 2 {{the statement for 'atomic read' must be an expression statement of form 'v = x;', where v and x are both lvalue expressions with scalar type}}58 // expected-note@+1 2 {{expected built-in assignment operator}}59 a += b;60#pragma omp atomic read61 // expected-error@+2 {{the statement for 'atomic read' must be an expression statement of form 'v = x;', where v and x are both lvalue expressions with scalar type}}62 // expected-note@+1 {{expected lvalue expression}}63 a = 0;64#pragma omp atomic read65 // expected-error@+2 {{the statement for 'atomic read' must be an expression statement of form 'v = x;', where v and x are both lvalue expressions with scalar type}}66 // expected-note@+1 {{expected built-in assignment operator}}67 a = b;68 // expected-error@+1 {{directive '#pragma omp atomic' cannot contain more than one 'read' clause}}69#pragma omp atomic read read70 // expected-error@+2 {{the statement for 'atomic read' must be an expression statement of form 'v = x;', where v and x are both lvalue expressions with scalar type}}71 // expected-note@+1 {{expected built-in assignment operator}}72 a = b;73 74 return a;75}76 77int read() {78 int a = 0, b = 0;79// Test for atomic read80#pragma omp atomic read81 // expected-error@+2 {{the statement for 'atomic read' must be an expression statement of form 'v = x;', where v and x are both lvalue expressions with scalar type}}82 // expected-note@+1 {{expected an expression statement}}83 ;84#pragma omp atomic read85 // expected-error@+2 {{the statement for 'atomic read' must be an expression statement of form 'v = x;', where v and x are both lvalue expressions with scalar type}}86 // expected-note@+1 {{expected built-in assignment operator}}87 foo();88#pragma omp atomic read89 // expected-error@+2 {{the statement for 'atomic read' must be an expression statement of form 'v = x;', where v and x are both lvalue expressions with scalar type}}90 // expected-note@+1 {{expected built-in assignment operator}}91 a += b;92#pragma omp atomic read93 // expected-error@+2 {{the statement for 'atomic read' must be an expression statement of form 'v = x;', where v and x are both lvalue expressions with scalar type}}94 // expected-note@+1 {{expected lvalue expression}}95 a = 0;96#pragma omp atomic read97 a = b;98 // expected-error@+1 {{directive '#pragma omp atomic' cannot contain more than one 'read' clause}}99#pragma omp atomic read read100 a = b;101 102 // expected-note@+2 {{in instantiation of function template specialization 'read<S>' requested here}}103 // expected-note@+1 {{in instantiation of function template specialization 'read<int>' requested here}}104 return read<int>() + read<S>().a;105}106 107template <class T>108T write() {109 T a, b = 0;110// Test for atomic write111#pragma omp atomic write112 // expected-error@+2 {{the statement for 'atomic write' must be an expression statement of form 'x = expr;', where x is a lvalue expression with scalar type}}113 // expected-note@+1 {{expected an expression statement}}114 ;115// expected-error@+1 {{directive '#pragma omp atomic' cannot contain more than one 'write' clause}}116#pragma omp atomic write write117 a = b;118#pragma omp atomic write119 // expected-error@+2 {{the statement for 'atomic write' must be an expression statement of form 'x = expr;', where x is a lvalue expression with scalar type}}120 // expected-note@+1 {{expected built-in assignment operator}}121 foo();122#pragma omp atomic write123 // expected-error@+2 {{the statement for 'atomic write' must be an expression statement of form 'x = expr;', where x is a lvalue expression with scalar type}}124 // expected-note@+1 {{expected built-in assignment operator}}125 a += b;126#pragma omp atomic write127 a = 0;128#pragma omp atomic write129 a = b;130 131 return T();132}133 134int write() {135 int a, b = 0;136// Test for atomic write137#pragma omp atomic write138 // expected-error@+2 {{the statement for 'atomic write' must be an expression statement of form 'x = expr;', where x is a lvalue expression with scalar type}}139 // expected-note@+1 {{expected an expression statement}}140 ;141// expected-error@+1 {{directive '#pragma omp atomic' cannot contain more than one 'write' clause}}142#pragma omp atomic write write143 a = b;144#pragma omp atomic write145 // expected-error@+2 {{the statement for 'atomic write' must be an expression statement of form 'x = expr;', where x is a lvalue expression with scalar type}}146 // expected-note@+1 {{expected built-in assignment operator}}147 foo();148#pragma omp atomic write149 // expected-error@+2 {{the statement for 'atomic write' must be an expression statement of form 'x = expr;', where x is a lvalue expression with scalar type}}150 // expected-note@+1 {{expected built-in assignment operator}}151 a += b;152#pragma omp atomic write153 a = 0;154#pragma omp atomic write155 a = foo();156 157 // expected-note@+1 {{in instantiation of function template specialization 'write<int>' requested here}}158 return write<int>();159}160 161template <class T>162T update() {163 T a = 0, b = 0, c = 0;164// Test for atomic update165#pragma omp atomic update166 // expected-error@+2 {{the statement for 'atomic update' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an lvalue expression with scalar type}}167 // expected-note@+1 {{expected an expression statement}}168 ;169// expected-error@+1 {{directive '#pragma omp atomic' cannot contain more than one 'update' clause}}170#pragma omp atomic update update171 a += b;172#pragma omp atomic173 // expected-error@+2 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an lvalue expression with scalar type}}174 // expected-note@+1 {{expected built-in binary operator}}175 a = b;176#pragma omp atomic update177 // expected-error@+2 {{the statement for 'atomic update' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an lvalue expression with scalar type}}178 // expected-note@+1 {{expected one of '+', '*', '-', '/', '&', '^', '|', '<<', or '>>' built-in operations}}179 a = b || a;180#pragma omp atomic update181 // expected-error@+2 {{the statement for 'atomic update' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an lvalue expression with scalar type}}182 // expected-note@+1 {{expected one of '+', '*', '-', '/', '&', '^', '|', '<<', or '>>' built-in operations}}183 a = a && b;184#pragma omp atomic update185 // expected-error@+2 {{the statement for 'atomic update' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an lvalue expression with scalar type}}186 // expected-note@+1 {{expected in right hand side of expression}}187 a = float(a) + b;188#pragma omp atomic189 // expected-error@+2 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an lvalue expression with scalar type}}190 // expected-note@+1 {{expected in right hand side of expression}}191 a = 2 * b;192#pragma omp atomic193 // expected-error@+2 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an lvalue expression with scalar type}}194 // expected-note@+1 {{expected in right hand side of expression}}195 a = b + *&a;196#pragma omp atomic197 *&a = b * *&a;198#pragma omp atomic update199 a++;200#pragma omp atomic201 ++a;202#pragma omp atomic update203 a--;204#pragma omp atomic205 --a;206#pragma omp atomic update207 a += b;208#pragma omp atomic209 a %= b;210#pragma omp atomic update211 a *= b;212#pragma omp atomic213 a -= b;214#pragma omp atomic update215 a /= b;216#pragma omp atomic217 a &= b;218#pragma omp atomic update219 a ^= b;220#pragma omp atomic221 a |= b;222#pragma omp atomic update223 a <<= b;224#pragma omp atomic225 a >>= b;226#pragma omp atomic update227 a = b + a;228#pragma omp atomic229 a = a * b;230#pragma omp atomic update231 a = b - a;232#pragma omp atomic233 a = a / b;234#pragma omp atomic update235 a = b & a;236#pragma omp atomic237 a = a ^ b;238#pragma omp atomic update239 a = b | a;240#pragma omp atomic241 a = a << b;242#pragma omp atomic243 a = b >> a;244 245#pragma omp atomic246 // expected-error@+2 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an lvalue expression with scalar type}}247 // expected-note@+1 {{expected an expression statement}}248 ;249 250 return T();251}252 253int update() {254 int a, b = 0;255// Test for atomic update256#pragma omp atomic update257 // expected-error@+2 {{the statement for 'atomic update' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an lvalue expression with scalar type}}258 // expected-note@+1 {{expected an expression statement}}259 ;260// expected-error@+1 {{directive '#pragma omp atomic' cannot contain more than one 'update' clause}}261#pragma omp atomic update update262 a += b;263#pragma omp atomic264 // expected-error@+2 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an lvalue expression with scalar type}}265 // expected-note@+1 {{expected built-in binary operator}}266 a = b;267#pragma omp atomic update268 // expected-error@+2 {{the statement for 'atomic update' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an lvalue expression with scalar type}}269 // expected-note@+1 {{expected one of '+', '*', '-', '/', '&', '^', '|', '<<', or '>>' built-in operations}}270 a = b || a;271#pragma omp atomic update272 // expected-error@+2 {{the statement for 'atomic update' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an lvalue expression with scalar type}}273 // expected-note@+1 {{expected one of '+', '*', '-', '/', '&', '^', '|', '<<', or '>>' built-in operations}}274 a = a && b;275#pragma omp atomic update276 // expected-error@+2 {{the statement for 'atomic update' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an lvalue expression with scalar type}}277 // expected-note@+1 {{expected in right hand side of expression}}278 a = float(a) + b;279#pragma omp atomic280 // expected-error@+2 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an lvalue expression with scalar type}}281 // expected-note@+1 {{expected in right hand side of expression}}282 a = 2 * b;283#pragma omp atomic284 // expected-error@+2 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an lvalue expression with scalar type}}285 // expected-note@+1 {{expected in right hand side of expression}}286 a = b + *&a;287#pragma omp atomic update288 a++;289#pragma omp atomic290 ++a;291#pragma omp atomic update292 a--;293#pragma omp atomic294 --a;295#pragma omp atomic update296 a += b;297#pragma omp atomic298 a %= b;299#pragma omp atomic update300 a *= b;301#pragma omp atomic302 a -= b;303#pragma omp atomic update304 a /= b;305#pragma omp atomic306 a &= b;307#pragma omp atomic update308 a ^= b;309#pragma omp atomic310 a |= b;311#pragma omp atomic update312 a <<= b;313#pragma omp atomic314 a >>= b;315#pragma omp atomic update316 a = b + a;317#pragma omp atomic318 a = a * b;319#pragma omp atomic update320 a = b - a;321#pragma omp atomic322 a = a / b;323#pragma omp atomic update324 a = b & a;325#pragma omp atomic326 a = a ^ b;327#pragma omp atomic update328 a = b | a;329#pragma omp atomic330 a = a << b;331#pragma omp atomic332 a = b >> a;333#pragma omp atomic334 // expected-error@+2 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an lvalue expression with scalar type}}335 // expected-note@+1 {{expected an expression statement}}336 ;337 338 return update<int>();339}340 341template <class T>342T capture() {343 T a = 0, b = 0, c = 0;344// Test for atomic capture345#pragma omp atomic capture346 // expected-error@+2 {{the statement for 'atomic capture' must be a compound statement of form '{v = x; x binop= expr;}', '{x binop= expr; v = x;}', '{v = x; x = x binop expr;}', '{v = x; x = expr binop x;}', '{x = x binop expr; v = x;}', '{x = expr binop x; v = x;}' or '{v = x; x = expr;}', '{v = x; x++;}', '{v = x; ++x;}', '{++x; v = x;}', '{x++; v = x;}', '{v = x; x--;}', '{v = x; --x;}', '{--x; v = x;}', '{x--; v = x;}' where x is an lvalue expression with scalar type}}347 // expected-note@+1 {{expected compound statement}}348 ;349#pragma omp atomic capture350 // expected-error@+2 {{the statement for 'atomic capture' must be an expression statement of form 'v = ++x;', 'v = --x;', 'v = x++;', 'v = x--;', 'v = x binop= expr;', 'v = x = x binop expr' or 'v = x = expr binop x', where x and v are both lvalue expressions with scalar type}}351 // expected-note@+1 {{expected assignment expression}}352 foo();353#pragma omp atomic capture354 // expected-error@+2 {{the statement for 'atomic capture' must be an expression statement of form 'v = ++x;', 'v = --x;', 'v = x++;', 'v = x--;', 'v = x binop= expr;', 'v = x = x binop expr' or 'v = x = expr binop x', where x and v are both lvalue expressions with scalar type}}355 // expected-note@+1 {{expected built-in binary or unary operator}}356 a = b;357#pragma omp atomic capture358 // expected-error@+2 {{the statement for 'atomic capture' must be an expression statement of form 'v = ++x;', 'v = --x;', 'v = x++;', 'v = x--;', 'v = x binop= expr;', 'v = x = x binop expr' or 'v = x = expr binop x', where x and v are both lvalue expressions with scalar type}}359 // expected-note@+1 {{expected assignment expression}}360 a = b || a;361#pragma omp atomic capture362 // expected-error@+2 {{the statement for 'atomic capture' must be an expression statement of form 'v = ++x;', 'v = --x;', 'v = x++;', 'v = x--;', 'v = x binop= expr;', 'v = x = x binop expr' or 'v = x = expr binop x', where x and v are both lvalue expressions with scalar type}}363 // expected-note@+1 {{expected one of '+', '*', '-', '/', '&', '^', '|', '<<', or '>>' built-in operations}}364 b = a = a && b;365#pragma omp atomic capture366 // expected-error@+2 {{the statement for 'atomic capture' must be an expression statement of form 'v = ++x;', 'v = --x;', 'v = x++;', 'v = x--;', 'v = x binop= expr;', 'v = x = x binop expr' or 'v = x = expr binop x', where x and v are both lvalue expressions with scalar type}}367 // expected-note@+1 {{expected assignment expression}}368 a = (float)a + b;369#pragma omp atomic capture370 // expected-error@+2 {{the statement for 'atomic capture' must be an expression statement of form 'v = ++x;', 'v = --x;', 'v = x++;', 'v = x--;', 'v = x binop= expr;', 'v = x = x binop expr' or 'v = x = expr binop x', where x and v are both lvalue expressions with scalar type}}371 // expected-note@+1 {{expected assignment expression}}372 a = 2 * b;373#pragma omp atomic capture374 // expected-error@+2 {{the statement for 'atomic capture' must be an expression statement of form 'v = ++x;', 'v = --x;', 'v = x++;', 'v = x--;', 'v = x binop= expr;', 'v = x = x binop expr' or 'v = x = expr binop x', where x and v are both lvalue expressions with scalar type}}375 // expected-note@+1 {{expected assignment expression}}376 a = b + *&a;377#pragma omp atomic capture378 // expected-error@+2 {{the statement for 'atomic capture' must be a compound statement of form '{v = x; x binop= expr;}', '{x binop= expr; v = x;}', '{v = x; x = x binop expr;}', '{v = x; x = expr binop x;}', '{x = x binop expr; v = x;}', '{x = expr binop x; v = x;}' or '{v = x; x = expr;}', '{v = x; x++;}', '{v = x; ++x;}', '{++x; v = x;}', '{x++; v = x;}', '{v = x; x--;}', '{v = x; --x;}', '{--x; v = x;}', '{x--; v = x;}' where x is an lvalue expression with scalar type}}379 // expected-note@+1 {{expected exactly two expression statements}}380 { a = b; }381#pragma omp atomic capture382 // expected-error@+2 {{the statement for 'atomic capture' must be a compound statement of form '{v = x; x binop= expr;}', '{x binop= expr; v = x;}', '{v = x; x = x binop expr;}', '{v = x; x = expr binop x;}', '{x = x binop expr; v = x;}', '{x = expr binop x; v = x;}' or '{v = x; x = expr;}', '{v = x; x++;}', '{v = x; ++x;}', '{++x; v = x;}', '{x++; v = x;}', '{v = x; x--;}', '{v = x; --x;}', '{--x; v = x;}', '{x--; v = x;}' where x is an lvalue expression with scalar type}}383 // expected-note@+1 {{expected exactly two expression statements}}384 {}385#pragma omp atomic capture386 // expected-error@+2 {{the statement for 'atomic capture' must be a compound statement of form '{v = x; x binop= expr;}', '{x binop= expr; v = x;}', '{v = x; x = x binop expr;}', '{v = x; x = expr binop x;}', '{x = x binop expr; v = x;}', '{x = expr binop x; v = x;}' or '{v = x; x = expr;}', '{v = x; x++;}', '{v = x; ++x;}', '{++x; v = x;}', '{x++; v = x;}', '{v = x; x--;}', '{v = x; --x;}', '{--x; v = x;}', '{x--; v = x;}' where x is an lvalue expression with scalar type}}387 // expected-note@+1 {{expected in right hand side of the first expression}}388 {a = b;a = b;}389#pragma omp atomic capture390 // expected-error@+2 {{the statement for 'atomic capture' must be a compound statement of form '{v = x; x binop= expr;}', '{x binop= expr; v = x;}', '{v = x; x = x binop expr;}', '{v = x; x = expr binop x;}', '{x = x binop expr; v = x;}', '{x = expr binop x; v = x;}' or '{v = x; x = expr;}', '{v = x; x++;}', '{v = x; ++x;}', '{++x; v = x;}', '{x++; v = x;}', '{v = x; x--;}', '{v = x; --x;}', '{--x; v = x;}', '{x--; v = x;}' where x is an lvalue expression with scalar type}}391 // expected-note@+1 {{expected in right hand side of the first expression}}392 {a = b; a = b || a;}393#pragma omp atomic capture394 {b = a; a = a && b;}395#pragma omp atomic capture396 // expected-error@+2 {{the statement for 'atomic capture' must be an expression statement of form 'v = ++x;', 'v = --x;', 'v = x++;', 'v = x--;', 'v = x binop= expr;', 'v = x = x binop expr' or 'v = x = expr binop x', where x and v are both lvalue expressions with scalar type}}397 // expected-note@+1 {{expected in right hand side of expression}}398 b = a = (float)a + b;399#pragma omp atomic capture400 // expected-error@+2 {{the statement for 'atomic capture' must be an expression statement of form 'v = ++x;', 'v = --x;', 'v = x++;', 'v = x--;', 'v = x binop= expr;', 'v = x = x binop expr' or 'v = x = expr binop x', where x and v are both lvalue expressions with scalar type}}401 // expected-note@+1 {{expected in right hand side of expression}}402 b = a = 2 * b;403#pragma omp atomic capture404 // expected-error@+2 {{the statement for 'atomic capture' must be an expression statement of form 'v = ++x;', 'v = --x;', 'v = x++;', 'v = x--;', 'v = x binop= expr;', 'v = x = x binop expr' or 'v = x = expr binop x', where x and v are both lvalue expressions with scalar type}}405 // expected-note@+1 {{expected in right hand side of expression}}406 b = a = b + *&a;407#pragma omp atomic capture408 c = *&a = *&a + 2;409#pragma omp atomic capture410 c = a++;411#pragma omp atomic capture412 c = ++a;413#pragma omp atomic capture414 c = a--;415#pragma omp atomic capture416 c = --a;417#pragma omp atomic capture418 c = a += b;419#pragma omp atomic capture420 c = a %= b;421#pragma omp atomic capture422 c = a *= b;423#pragma omp atomic capture424 c = a -= b;425#pragma omp atomic capture426 c = a /= b;427#pragma omp atomic capture428 c = a &= b;429#pragma omp atomic capture430 c = a ^= b;431#pragma omp atomic capture432 c = a |= b;433#pragma omp atomic capture434 c = a <<= b;435#pragma omp atomic capture436 c = a >>= b;437#pragma omp atomic capture438 c = a = b + a;439#pragma omp atomic capture440 c = a = a * b;441#pragma omp atomic capture442 c = a = b - a;443#pragma omp atomic capture444 c = a = a / b;445#pragma omp atomic capture446 c = a = b & a;447#pragma omp atomic capture448 c = a = a ^ b;449#pragma omp atomic capture450 c = a = b | a;451#pragma omp atomic capture452 c = a = a << b;453#pragma omp atomic capture454 c = a = b >> a;455#pragma omp atomic capture456 { c = *&a; *&a = *&a + 2;}457#pragma omp atomic capture458 { *&a = *&a + 2; c = *&a;}459#pragma omp atomic capture460 {c = a; a++;}461#pragma omp atomic capture462 {c = a; (a)++;}463#pragma omp atomic capture464 {++a;c = a;}465#pragma omp atomic capture466 {c = a;a--;}467#pragma omp atomic capture468 {--a;c = a;}469#pragma omp atomic capture470 {c = a; a += b;}471#pragma omp atomic capture472 {c = a; (a) += b;}473#pragma omp atomic capture474 {a %= b; c = a;}475#pragma omp atomic capture476 {c = a; a *= b;}477#pragma omp atomic capture478 {a -= b;c = a;}479#pragma omp atomic capture480 {c = a; a /= b;}481#pragma omp atomic capture482 {a &= b; c = a;}483#pragma omp atomic capture484 {c = a; a ^= b;}485#pragma omp atomic capture486 {a |= b; c = a;}487#pragma omp atomic capture488 {c = a; a <<= b;}489#pragma omp atomic capture490 {a >>= b; c = a;}491#pragma omp atomic capture492 {c = a; a = b + a;}493#pragma omp atomic capture494 {a = a * b; c = a;}495#pragma omp atomic capture496 {c = a; a = b - a;}497#pragma omp atomic capture498 {a = a / b; c = a;}499#pragma omp atomic capture500 {c = a; a = b & a;}501#pragma omp atomic capture502 {a = a ^ b; c = a;}503#pragma omp atomic capture504 {c = a; a = b | a;}505#pragma omp atomic capture506 {a = a << b; c = a;}507#pragma omp atomic capture508 {c = a; a = b >> a;}509#pragma omp atomic capture510 {c = a; a = foo();}511 // expected-error@+1 {{directive '#pragma omp atomic' cannot contain more than one 'capture' clause}}512#pragma omp atomic capture capture513 b = a /= b;514 515 return T();516}517 518int capture() {519 int a = 0, b = 0, c = 0;520// Test for atomic capture521#pragma omp atomic capture522 // expected-error@+2 {{the statement for 'atomic capture' must be a compound statement of form '{v = x; x binop= expr;}', '{x binop= expr; v = x;}', '{v = x; x = x binop expr;}', '{v = x; x = expr binop x;}', '{x = x binop expr; v = x;}', '{x = expr binop x; v = x;}' or '{v = x; x = expr;}', '{v = x; x++;}', '{v = x; ++x;}', '{++x; v = x;}', '{x++; v = x;}', '{v = x; x--;}', '{v = x; --x;}', '{--x; v = x;}', '{x--; v = x;}' where x is an lvalue expression with scalar type}}523 // expected-note@+1 {{expected compound statement}}524 ;525#pragma omp atomic capture526 // expected-error@+2 {{the statement for 'atomic capture' must be an expression statement of form 'v = ++x;', 'v = --x;', 'v = x++;', 'v = x--;', 'v = x binop= expr;', 'v = x = x binop expr' or 'v = x = expr binop x', where x and v are both lvalue expressions with scalar type}}527 // expected-note@+1 {{expected assignment expression}}528 foo();529#pragma omp atomic capture530 // expected-error@+2 {{the statement for 'atomic capture' must be an expression statement of form 'v = ++x;', 'v = --x;', 'v = x++;', 'v = x--;', 'v = x binop= expr;', 'v = x = x binop expr' or 'v = x = expr binop x', where x and v are both lvalue expressions with scalar type}}531 // expected-note@+1 {{expected built-in binary or unary operator}}532 a = b;533#pragma omp atomic capture534 // expected-error@+2 {{the statement for 'atomic capture' must be an expression statement of form 'v = ++x;', 'v = --x;', 'v = x++;', 'v = x--;', 'v = x binop= expr;', 'v = x = x binop expr' or 'v = x = expr binop x', where x and v are both lvalue expressions with scalar type}}535 // expected-note@+1 {{expected assignment expression}}536 a = b || a;537#pragma omp atomic capture538 // expected-error@+2 {{the statement for 'atomic capture' must be an expression statement of form 'v = ++x;', 'v = --x;', 'v = x++;', 'v = x--;', 'v = x binop= expr;', 'v = x = x binop expr' or 'v = x = expr binop x', where x and v are both lvalue expressions with scalar type}}539 // expected-note@+1 {{expected one of '+', '*', '-', '/', '&', '^', '|', '<<', or '>>' built-in operations}}540 b = a = a && b;541#pragma omp atomic capture542 // expected-error@+2 {{the statement for 'atomic capture' must be an expression statement of form 'v = ++x;', 'v = --x;', 'v = x++;', 'v = x--;', 'v = x binop= expr;', 'v = x = x binop expr' or 'v = x = expr binop x', where x and v are both lvalue expressions with scalar type}}543 // expected-note@+1 {{expected assignment expression}}544 a = (float)a + b;545#pragma omp atomic capture546 // expected-error@+2 {{the statement for 'atomic capture' must be an expression statement of form 'v = ++x;', 'v = --x;', 'v = x++;', 'v = x--;', 'v = x binop= expr;', 'v = x = x binop expr' or 'v = x = expr binop x', where x and v are both lvalue expressions with scalar type}}547 // expected-note@+1 {{expected assignment expression}}548 a = 2 * b;549#pragma omp atomic capture550 // expected-error@+2 {{the statement for 'atomic capture' must be an expression statement of form 'v = ++x;', 'v = --x;', 'v = x++;', 'v = x--;', 'v = x binop= expr;', 'v = x = x binop expr' or 'v = x = expr binop x', where x and v are both lvalue expressions with scalar type}}551 // expected-note@+1 {{expected assignment expression}}552 a = b + *&a;553#pragma omp atomic capture554 // expected-error@+2 {{the statement for 'atomic capture' must be a compound statement of form '{v = x; x binop= expr;}', '{x binop= expr; v = x;}', '{v = x; x = x binop expr;}', '{v = x; x = expr binop x;}', '{x = x binop expr; v = x;}', '{x = expr binop x; v = x;}' or '{v = x; x = expr;}', '{v = x; x++;}', '{v = x; ++x;}', '{++x; v = x;}', '{x++; v = x;}', '{v = x; x--;}', '{v = x; --x;}', '{--x; v = x;}', '{x--; v = x;}' where x is an lvalue expression with scalar type}}555 // expected-note@+1 {{expected exactly two expression statements}}556 { a = b; }557#pragma omp atomic capture558 // expected-error@+2 {{the statement for 'atomic capture' must be a compound statement of form '{v = x; x binop= expr;}', '{x binop= expr; v = x;}', '{v = x; x = x binop expr;}', '{v = x; x = expr binop x;}', '{x = x binop expr; v = x;}', '{x = expr binop x; v = x;}' or '{v = x; x = expr;}', '{v = x; x++;}', '{v = x; ++x;}', '{++x; v = x;}', '{x++; v = x;}', '{v = x; x--;}', '{v = x; --x;}', '{--x; v = x;}', '{x--; v = x;}' where x is an lvalue expression with scalar type}}559 // expected-note@+1 {{expected exactly two expression statements}}560 {}561#pragma omp atomic capture562 // expected-error@+2 {{the statement for 'atomic capture' must be a compound statement of form '{v = x; x binop= expr;}', '{x binop= expr; v = x;}', '{v = x; x = x binop expr;}', '{v = x; x = expr binop x;}', '{x = x binop expr; v = x;}', '{x = expr binop x; v = x;}' or '{v = x; x = expr;}', '{v = x; x++;}', '{v = x; ++x;}', '{++x; v = x;}', '{x++; v = x;}', '{v = x; x--;}', '{v = x; --x;}', '{--x; v = x;}', '{x--; v = x;}' where x is an lvalue expression with scalar type}}563 // expected-note@+1 {{expected in right hand side of the first expression}}564 {a = b;a = b;}565#pragma omp atomic capture566 // expected-error@+2 {{the statement for 'atomic capture' must be a compound statement of form '{v = x; x binop= expr;}', '{x binop= expr; v = x;}', '{v = x; x = x binop expr;}', '{v = x; x = expr binop x;}', '{x = x binop expr; v = x;}', '{x = expr binop x; v = x;}' or '{v = x; x = expr;}', '{v = x; x++;}', '{v = x; ++x;}', '{++x; v = x;}', '{x++; v = x;}', '{v = x; x--;}', '{v = x; --x;}', '{--x; v = x;}', '{x--; v = x;}' where x is an lvalue expression with scalar type}}567 // expected-note@+1 {{expected in right hand side of the first expression}}568 {a = b; a = b || a;}569#pragma omp atomic capture570 {b = a; a = a && b;}571#pragma omp atomic capture572 // expected-error@+2 {{the statement for 'atomic capture' must be an expression statement of form 'v = ++x;', 'v = --x;', 'v = x++;', 'v = x--;', 'v = x binop= expr;', 'v = x = x binop expr' or 'v = x = expr binop x', where x and v are both lvalue expressions with scalar type}}573 // expected-note@+1 {{expected in right hand side of expression}}574 b = a = (float)a + b;575#pragma omp atomic capture576 // expected-error@+2 {{the statement for 'atomic capture' must be an expression statement of form 'v = ++x;', 'v = --x;', 'v = x++;', 'v = x--;', 'v = x binop= expr;', 'v = x = x binop expr' or 'v = x = expr binop x', where x and v are both lvalue expressions with scalar type}}577 // expected-note@+1 {{expected in right hand side of expression}}578 b = a = 2 * b;579#pragma omp atomic capture580 // expected-error@+2 {{the statement for 'atomic capture' must be an expression statement of form 'v = ++x;', 'v = --x;', 'v = x++;', 'v = x--;', 'v = x binop= expr;', 'v = x = x binop expr' or 'v = x = expr binop x', where x and v are both lvalue expressions with scalar type}}581 // expected-note@+1 {{expected in right hand side of expression}}582 b = a = b + *&a;583#pragma omp atomic capture584 c = *&a = *&a + 2;585#pragma omp atomic capture586 c = a++;587#pragma omp atomic capture588 c = ++a;589#pragma omp atomic capture590 c = a--;591#pragma omp atomic capture592 c = --a;593#pragma omp atomic capture594 c = a += b;595#pragma omp atomic capture596 c = a %= b;597#pragma omp atomic capture598 c = a *= b;599#pragma omp atomic capture600 c = a -= b;601#pragma omp atomic capture602 c = a /= b;603#pragma omp atomic capture604 c = a &= b;605#pragma omp atomic capture606 c = a ^= b;607#pragma omp atomic capture608 c = a |= b;609#pragma omp atomic capture610 c = a <<= b;611#pragma omp atomic capture612 c = a >>= b;613#pragma omp atomic capture614 c = a = b + a;615#pragma omp atomic capture616 c = a = a * b;617#pragma omp atomic capture618 c = a = b - a;619#pragma omp atomic capture620 c = a = a / b;621#pragma omp atomic capture622 c = a = b & a;623#pragma omp atomic capture624 c = a = a ^ b;625#pragma omp atomic capture626 c = a = b | a;627#pragma omp atomic capture628 c = a = a << b;629#pragma omp atomic capture630 c = a = b >> a;631#pragma omp atomic capture632 { c = *&a; *&a = *&a + 2;}633#pragma omp atomic capture634 { *&a = *&a + 2; c = *&a;}635#pragma omp atomic capture636 {c = a; a++;}637#pragma omp atomic capture638 {++a;c = a;}639#pragma omp atomic capture640 {c = a;a--;}641#pragma omp atomic capture642 {--a;c = a;}643#pragma omp atomic capture644 {c = a; a += b;}645#pragma omp atomic capture646 {a %= b; c = a;}647#pragma omp atomic capture648 {c = a; a *= b;}649#pragma omp atomic capture650 {a -= b;c = a;}651#pragma omp atomic capture652 {c = a; a /= b;}653#pragma omp atomic capture654 {a &= b; c = a;}655#pragma omp atomic capture656 {c = a; a ^= b;}657#pragma omp atomic capture658 {a |= b; c = a;}659#pragma omp atomic capture660 {c = a; a <<= b;}661#pragma omp atomic capture662 {a >>= b; c = a;}663#pragma omp atomic capture664 {c = a; a = b + a;}665#pragma omp atomic capture666 {a = a * b; c = a;}667#pragma omp atomic capture668 {c = a; a = b - a;}669#pragma omp atomic capture670 {a = a / b; c = a;}671#pragma omp atomic capture672 {c = a; a = b & a;}673#pragma omp atomic capture674 {a = a ^ b; c = a;}675#pragma omp atomic capture676 {c = a; a = b | a;}677#pragma omp atomic capture678 {a = a << b; c = a;}679#pragma omp atomic capture680 {c = a; a = b >> a;}681#pragma omp atomic capture682 {c = a; a = foo();}683 // expected-error@+1 {{directive '#pragma omp atomic' cannot contain more than one 'capture' clause}}684#pragma omp atomic capture capture685 b = a /= b;686 687 // expected-note@+1 {{in instantiation of function template specialization 'capture<int>' requested here}}688 return capture<int>();689}690 691template <class T>692T seq_cst() {693 T a, b = 0;694// Test for atomic seq_cst695#pragma omp atomic seq_cst696 // expected-error@+2 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an lvalue expression with scalar type}}697 // expected-note@+1 {{expected an expression statement}}698 ;699// expected-error@+1 {{directive '#pragma omp atomic' cannot contain more than one 'seq_cst' clause}}700#pragma omp atomic seq_cst seq_cst701 a += b;702 703#pragma omp atomic update seq_cst704 // expected-error@+2 {{the statement for 'atomic update' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an lvalue expression with scalar type}}705 // expected-note@+1 {{expected an expression statement}}706 ;707 708 return T();709}710 711int seq_cst() {712 int a, b = 0;713// Test for atomic seq_cst714#pragma omp atomic seq_cst715 // expected-error@+2 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an lvalue expression with scalar type}}716 // expected-note@+1 {{expected an expression statement}}717 ;718// expected-error@+1 {{directive '#pragma omp atomic' cannot contain more than one 'seq_cst' clause}}719#pragma omp atomic seq_cst seq_cst720 a += b;721 722#pragma omp atomic update seq_cst723 // expected-error@+2 {{the statement for 'atomic update' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an lvalue expression with scalar type}}724 // expected-note@+1 {{expected an expression statement}}725 ;726 727 return seq_cst<int>();728}729 730template <class T>731T acq_rel() {732 T a = 0, b = 0;733// omp45-error@+1 {{unexpected OpenMP clause 'acq_rel' in directive '#pragma omp atomic'}} omp50-error@+1 {{directive '#pragma omp atomic' cannot be used with 'acq_rel' clause}} omp50-note@+1 {{'acq_rel' clause used here}}734#pragma omp atomic acq_rel735 // expected-error@+2 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an lvalue expression with scalar type}}736 // expected-note@+1 {{expected an expression statement}}737 ;738// omp50-error@+1 2 {{directive '#pragma omp atomic' cannot contain more than one 'seq_cst', 'relaxed', 'acq_rel', 'acquire' or 'release' clause}} omp50-note@+1 2 {{'acq_rel' clause used here}} omp45-error@+1 {{unexpected OpenMP clause 'acq_rel' in directive '#pragma omp atomic'}} omp50-error@+1 2 {{directive '#pragma omp atomic read' cannot be used with 'acq_rel' clause}} omp50-note@+1 2 {{'acq_rel' clause used here}}739#pragma omp atomic read acq_rel seq_cst740 a = b;741 742// omp45-error@+1 {{unexpected OpenMP clause 'acq_rel' in directive '#pragma omp atomic'}} omp50-error@+1 {{directive '#pragma omp atomic update' cannot be used with 'acq_rel' clause}} omp50-note@+1 {{'acq_rel' clause used here}}743#pragma omp atomic update acq_rel744 // expected-error@+2 {{the statement for 'atomic update' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an lvalue expression with scalar type}}745 // expected-note@+1 {{expected an expression statement}}746 ;747 748 return T();749}750 751int acq_rel() {752 int a = 0, b = 0;753// Test for atomic acq_rel754// omp45-error@+1 {{unexpected OpenMP clause 'acq_rel' in directive '#pragma omp atomic'}} omp50-error@+1 {{directive '#pragma omp atomic write' cannot be used with 'acq_rel' clause}} omp50-note@+1 {{'acq_rel' clause used here}}755#pragma omp atomic acq_rel write756 // expected-error@+2 {{the statement for 'atomic write' must be an expression statement of form 'x = expr;', where x is a lvalue expression with scalar type}}757 // expected-note@+1 {{expected an expression statement}}758 ;759// omp50-error@+1 {{directive '#pragma omp atomic' cannot contain more than one 'seq_cst', 'relaxed', 'acq_rel', 'acquire' or 'release' clause}} omp50-note@+1 {{'seq_cst' clause used here}} omp45-error@+1 {{unexpected OpenMP clause 'acq_rel' in directive '#pragma omp atomic'}}760#pragma omp atomic seq_cst acq_rel761 a += b;762 763// omp45-error@+1 {{unexpected OpenMP clause 'acq_rel' in directive '#pragma omp atomic'}} omp50-error@+1 {{directive '#pragma omp atomic update' cannot be used with 'acq_rel' clause}} omp50-note@+1 {{'acq_rel' clause used here}}764#pragma omp atomic update acq_rel765 // expected-error@+2 {{the statement for 'atomic update' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an lvalue expression with scalar type}}766 // expected-note@+1 {{expected an expression statement}}767 ;768 769 return acq_rel<int>(); // omp50-note {{in instantiation of function template specialization 'acq_rel<int>' requested here}}770}771 772template <class T>773T acquire() {774 T a = 0, b = 0;775// omp45-error@+1 {{unexpected OpenMP clause 'acquire' in directive '#pragma omp atomic'}} omp50-error@+1 {{directive '#pragma omp atomic' cannot be used with 'acquire' clause}} omp50-note@+1 {{'acquire' clause used here}}776#pragma omp atomic acquire777 // expected-error@+2 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an lvalue expression with scalar type}}778 // expected-note@+1 {{expected an expression statement}}779 ;780// omp50-error@+1 2 {{directive '#pragma omp atomic' cannot contain more than one 'seq_cst', 'relaxed', 'acq_rel', 'acquire' or 'release' clause}} omp50-note@+1 2 {{'acquire' clause used here}} omp45-error@+1 {{unexpected OpenMP clause 'acquire' in directive '#pragma omp atomic'}} omp50-error@+1 2 {{directive '#pragma omp atomic' cannot be used with 'acquire' clause}} omp50-note@+1 2 {{'acquire' clause used here}}781#pragma omp atomic acquire seq_cst782 a += b;783 784// omp45-error@+1 {{unexpected OpenMP clause 'acquire' in directive '#pragma omp atomic'}} omp50-error@+1 {{directive '#pragma omp atomic update' cannot be used with 'acquire' clause}} omp50-note@+1 {{'acquire' clause used here}}785#pragma omp atomic update acquire786 // expected-error@+2 {{the statement for 'atomic update' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an lvalue expression with scalar type}}787 // expected-note@+1 {{expected an expression statement}}788 ;789 790 return T();791}792 793int acquire() {794 int a = 0, b = 0;795// Test for atomic acquire796// omp45-error@+1 {{unexpected OpenMP clause 'acquire' in directive '#pragma omp atomic'}} omp50-error@+1 {{directive '#pragma omp atomic write' cannot be used with 'acquire' clause}} omp50-note@+1 {{'acquire' clause used here}}797#pragma omp atomic write acquire798 // expected-error@+2 {{the statement for 'atomic write' must be an expression statement of form 'x = expr;', where x is a lvalue expression with scalar type}}799 // expected-note@+1 {{expected an expression statement}}800 ;801// omp50-error@+1 {{directive '#pragma omp atomic' cannot contain more than one 'seq_cst', 'relaxed', 'acq_rel', 'acquire' or 'release' clause}} omp50-note@+1 {{'seq_cst' clause used here}} omp45-error@+1 {{unexpected OpenMP clause 'acquire' in directive '#pragma omp atomic'}}802#pragma omp atomic seq_cst acquire803 a += b;804 805// omp45-error@+1 {{unexpected OpenMP clause 'acquire' in directive '#pragma omp atomic'}} omp50-error@+1 {{directive '#pragma omp atomic update' cannot be used with 'acquire' clause}} omp50-note@+1 {{'acquire' clause used here}}806#pragma omp atomic update acquire807 // expected-error@+2 {{the statement for 'atomic update' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an lvalue expression with scalar type}}808 // expected-note@+1 {{expected an expression statement}}809 ;810 811 return acquire<int>(); // omp50-note {{in instantiation of function template specialization 'acquire<int>' requested here}}812}813 814template <class T>815T release() {816 T a = 0, b = 0;817// omp45-error@+1 {{unexpected OpenMP clause 'release' in directive '#pragma omp atomic'}}818#pragma omp atomic release819 // expected-error@+2 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an lvalue expression with scalar type}}820 // expected-note@+1 {{expected an expression statement}}821 ;822// omp50-error@+1 2 {{directive '#pragma omp atomic' cannot contain more than one 'seq_cst', 'relaxed', 'acq_rel', 'acquire' or 'release' clause}} omp50-note@+1 2 {{'release' clause used here}} omp45-error@+1 {{unexpected OpenMP clause 'release' in directive '#pragma omp atomic'}}823#pragma omp atomic release seq_cst824 a += b;825 826// omp45-error@+1 {{unexpected OpenMP clause 'release' in directive '#pragma omp atomic'}}827#pragma omp atomic update release828 // expected-error@+2 {{the statement for 'atomic update' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an lvalue expression with scalar type}}829 // expected-note@+1 {{expected an expression statement}}830 ;831 832 return T();833}834 835int release() {836 int a = 0, b = 0;837// Test for atomic release838// omp45-error@+1 {{unexpected OpenMP clause 'release' in directive '#pragma omp atomic'}} omp50-error@+1 {{directive '#pragma omp atomic read' cannot be used with 'release' clause}} omp50-note@+1 {{'release' clause used here}}839#pragma omp atomic read release840 // expected-error@+2 {{the statement for 'atomic read' must be an expression statement of form 'v = x;', where v and x are both lvalue expressions with scalar type}}841 // expected-note@+1 {{expected an expression statement}}842 ;843// omp50-error@+1 {{directive '#pragma omp atomic' cannot contain more than one 'seq_cst', 'relaxed', 'acq_rel', 'acquire' or 'release' clause}} omp50-note@+1 {{'seq_cst' clause used here}} omp45-error@+1 {{unexpected OpenMP clause 'release' in directive '#pragma omp atomic'}}844#pragma omp atomic seq_cst release845 a += b;846 847// omp45-error@+1 {{unexpected OpenMP clause 'release' in directive '#pragma omp atomic'}}848#pragma omp atomic update release849 // expected-error@+2 {{the statement for 'atomic update' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an lvalue expression with scalar type}}850 // expected-note@+1 {{expected an expression statement}}851 ;852 853 return release<int>(); // omp50-note {{in instantiation of function template specialization 'release<int>' requested here}}854}855 856template <class T>857T relaxed() {858 T a = 0, b = 0;859// omp45-error@+1 {{unexpected OpenMP clause 'relaxed' in directive '#pragma omp atomic'}}860#pragma omp atomic relaxed861 // expected-error@+2 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an lvalue expression with scalar type}}862 // expected-note@+1 {{expected an expression statement}}863 ;864// omp50-error@+1 2 {{directive '#pragma omp atomic' cannot contain more than one 'seq_cst', 'relaxed', 'acq_rel', 'acquire' or 'release' clause}} omp50-note@+1 2 {{'relaxed' clause used here}} omp45-error@+1 {{unexpected OpenMP clause 'relaxed' in directive '#pragma omp atomic'}}865#pragma omp atomic relaxed seq_cst866 a += b;867 868// omp45-error@+1 {{unexpected OpenMP clause 'relaxed' in directive '#pragma omp atomic'}}869#pragma omp atomic update relaxed870 // expected-error@+2 {{the statement for 'atomic update' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an lvalue expression with scalar type}}871 // expected-note@+1 {{expected an expression statement}}872 ;873 874 return T();875}876 877int relaxed() {878 int a = 0, b = 0;879// Test for atomic relaxed880// omp45-error@+1 {{unexpected OpenMP clause 'relaxed' in directive '#pragma omp atomic'}}881#pragma omp atomic read relaxed882 // expected-error@+2 {{the statement for 'atomic read' must be an expression statement of form 'v = x;', where v and x are both lvalue expressions with scalar type}}883 // expected-note@+1 {{expected an expression statement}}884 ;885// omp50-error@+1 {{directive '#pragma omp atomic' cannot contain more than one 'seq_cst', 'relaxed', 'acq_rel', 'acquire' or 'release' clause}} omp50-note@+1 {{'seq_cst' clause used here}} omp45-error@+1 {{unexpected OpenMP clause 'relaxed' in directive '#pragma omp atomic'}}886#pragma omp atomic seq_cst relaxed887 a += b;888 889// omp45-error@+1 {{unexpected OpenMP clause 'relaxed' in directive '#pragma omp atomic'}}890#pragma omp atomic update relaxed891 // expected-error@+2 {{the statement for 'atomic update' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an lvalue expression with scalar type}}892 // expected-note@+1 {{expected an expression statement}}893 ;894 895 return relaxed<int>(); // omp50-note {{in instantiation of function template specialization 'relaxed<int>' requested here}}896}897 898template <class T>899T mixed() {900 T a, b = T();901// expected-error@+2 2 {{directive '#pragma omp atomic' cannot contain more than one 'read', 'write', 'update', 'capture', or 'compare' clause}}902// expected-note@+1 2 {{'read' clause used here}}903#pragma omp atomic read write904 a = b;905// expected-error@+2 2 {{directive '#pragma omp atomic' cannot contain more than one 'read', 'write', 'update', 'capture', or 'compare' clause}}906// expected-note@+1 2 {{'write' clause used here}}907#pragma omp atomic write read908 a = b;909// expected-error@+2 2 {{directive '#pragma omp atomic' cannot contain more than one 'read', 'write', 'update', 'capture', or 'compare' clause}}910// expected-note@+1 2 {{'update' clause used here}}911#pragma omp atomic update read912 a += b;913// expected-error@+2 2 {{directive '#pragma omp atomic' cannot contain more than one 'read', 'write', 'update', 'capture', or 'compare' clause}}914// expected-note@+1 2 {{'capture' clause used here}}915#pragma omp atomic capture read916 a = ++b;917#ifdef OMP51918// expected-error@+2 2 {{directive '#pragma omp atomic' cannot contain more than one 'read', 'write', 'update', 'capture', or 'compare' clause}}919// expected-note@+1 2 {{'write' clause used here}}920#pragma omp atomic write compare921 a = b;922// expected-error@+2 2 {{directive '#pragma omp atomic' cannot contain more than one 'read', 'write', 'update', 'capture', or 'compare' clause}}923// expected-note@+1 2 {{'read' clause used here}}924#pragma omp atomic read compare925 a = b;926#endif927 return T();928}929 930int mixed() {931 int a, v, b = 0;932// expected-error@+2 {{directive '#pragma omp atomic' cannot contain more than one 'read', 'write', 'update', 'capture', or 'compare' clause}}933// expected-note@+1 {{'read' clause used here}}934#pragma omp atomic read write935 a = b;936// expected-error@+2 {{directive '#pragma omp atomic' cannot contain more than one 'read', 'write', 'update', 'capture', or 'compare' clause}}937// expected-note@+1 {{'write' clause used here}}938#pragma omp atomic write read939 a = b;940// expected-error@+2 {{directive '#pragma omp atomic' cannot contain more than one 'read', 'write', 'update', 'capture', or 'compare' clause}}941// expected-note@+1 {{'write' clause used here}}942#pragma omp atomic write update943 a = b;944// expected-error@+2 {{directive '#pragma omp atomic' cannot contain more than one 'read', 'write', 'update', 'capture', or 'compare' clause}}945// expected-note@+1 {{'write' clause used here}}946#pragma omp atomic write capture947 a = b;948#ifdef OMP51949// expected-error@+2 {{directive '#pragma omp atomic' cannot contain more than one 'read', 'write', 'update', 'capture', or 'compare' clause}}950// expected-note@+1 {{'write' clause used here}}951#pragma omp atomic write compare952 a = b;953// expected-error@+2 {{directive '#pragma omp atomic' cannot contain more than one 'read', 'write', 'update', 'capture', or 'compare' clause}}954// expected-note@+1 {{'read' clause used here}}955#pragma omp atomic read compare956 a = b;957// expected-error@+2 {{directive '#pragma omp atomic' cannot contain more than one 'compare' clause}}958// expected-error@+1 {{directive '#pragma omp atomic' cannot contain more than one 'capture' clause}}959#pragma omp atomic compare compare capture capture960 { v = a; if (a > b) a = b; }961// expected-error@+1 {{expected 'compare' clause with the 'fail' modifier}}962#pragma omp atomic fail(seq_cst)963 if(v == a) { v = a; }964// expected-error@+1 {{expected '(' after 'fail'}}965#pragma omp atomic compare fail966 if(v < a) { v = a; }967// expected-error@+1 {{expected a memory order clause}}968#pragma omp atomic compare fail(capture)969 if(v < a) { v = a; }970 // expected-error@+2 {{expected ')'}}971 // expected-note@+1 {{to match this '('}}972#pragma omp atomic compare fail(seq_cst | acquire)973 if(v < a) { v = a; }974// expected-error@+1 {{directive '#pragma omp atomic' cannot contain more than one 'fail' clause}}975#pragma omp atomic compare fail(relaxed) fail(seq_cst)976 if(v < a) { v = a; }977#pragma omp atomic compare seq_cst weak978 if(v == a) { v = a; }979// expected-error@+1 {{expected 'compare' clause with the 'weak' modifier}}980#pragma omp atomic weak981 if(v < a) { v = a; }982#pragma omp atomic compare release weak983// expected-error@+1 {{expected '==' operator for 'weak' clause}}984 if(v < a) { v = a; }985// expected-error@+1 {{directive '#pragma omp atomic' cannot contain more than one 'weak' clause}}986#pragma omp atomic compare release weak fail(seq_cst) weak987 if(v == a) { v = a; }988 989 990#endif991 // expected-note@+1 {{in instantiation of function template specialization 'mixed<int>' requested here}}992 return mixed<int>();993}994 995#ifdef OMP51996struct U {};997struct U operator<(U, U);998struct U operator>(U, U);999struct U operator==(U, U);1000 1001template <typename T> void templated() {1002 T cx, cv, ce, cd;1003#pragma omp atomic compare capture1004 if (cx == ce) {1005 cx = cd;1006 } else {1007 cv = cx;1008 }1009#pragma omp atomic compare capture1010 {1011 cv = cx;1012 if (ce > cx) {1013 cx = ce;1014 }1015 }1016#pragma omp atomic compare capture1017 {1018 cv = cx;1019 if (cx < ce) {1020 cx = ce;1021 }1022 }1023}1024#endif1025