diff options
Diffstat (limited to 'test/OpenMP/atomic_messages.cpp')
| -rw-r--r-- | test/OpenMP/atomic_messages.cpp | 517 |
1 files changed, 490 insertions, 27 deletions
diff --git a/test/OpenMP/atomic_messages.cpp b/test/OpenMP/atomic_messages.cpp index a6c07ad9e289..c3e02bc96e86 100644 --- a/test/OpenMP/atomic_messages.cpp +++ b/test/OpenMP/atomic_messages.cpp @@ -1,17 +1,19 @@ -// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -ferror-limit 100 %s +// RUN: %clang_cc1 -verify -fopenmp -ferror-limit 100 %s int foo() { L1: foo(); #pragma omp atomic - // expected-error@+1 {{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 l-value expression with scalar type}} + // 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 l-value expression with scalar type}} + // expected-note@+1 {{expected an expression statement}} { foo(); goto L1; // expected-error {{use of undeclared label 'L1'}} } goto L2; // expected-error {{use of undeclared label 'L2'}} #pragma omp atomic - // expected-error@+1 {{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 l-value expression with scalar type}} + // 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 l-value expression with scalar type}} + // expected-note@+1 {{expected an expression statement}} { foo(); L2: @@ -150,17 +152,91 @@ int write() { template <class T> T update() { - T a, b = 0; + T a = 0, b = 0, c = 0; // Test for atomic update #pragma omp atomic update - // expected-error@+1 {{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 l-value expression with scalar type}} + // 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 l-value expression with scalar type}} + // expected-note@+1 {{expected an expression statement}} ; // expected-error@+1 {{directive '#pragma omp atomic' cannot contain more than one 'update' clause}} #pragma omp atomic update update a += b; +#pragma omp atomic + // 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 l-value expression with scalar type}} + // expected-note@+1 {{expected built-in binary operator}} + a = b; +#pragma omp atomic update + // 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 l-value expression with scalar type}} + // expected-note@+1 {{expected one of '+', '*', '-', '/', '&', '^', '|', '<<', or '>>' built-in operations}} + a = b || a; +#pragma omp atomic update + // 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 l-value expression with scalar type}} + // expected-note@+1 {{expected one of '+', '*', '-', '/', '&', '^', '|', '<<', or '>>' built-in operations}} + a = a && b; +#pragma omp atomic update + // 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 l-value expression with scalar type}} + // expected-note@+1 {{expected in right hand side of expression}} + a = float(a) + b; +#pragma omp atomic + // 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 l-value expression with scalar type}} + // expected-note@+1 {{expected in right hand side of expression}} + a = 2 * b; +#pragma omp atomic + // 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 l-value expression with scalar type}} + // expected-note@+1 {{expected in right hand side of expression}} + a = b + *&a; +#pragma omp atomic + *&a = b * *&a; +#pragma omp atomic update + a++; +#pragma omp atomic + ++a; +#pragma omp atomic update + a--; +#pragma omp atomic + --a; +#pragma omp atomic update + a += b; +#pragma omp atomic + a %= b; +#pragma omp atomic update + a *= b; +#pragma omp atomic + a -= b; +#pragma omp atomic update + a /= b; +#pragma omp atomic + a &= b; +#pragma omp atomic update + a ^= b; +#pragma omp atomic + a |= b; +#pragma omp atomic update + a <<= b; +#pragma omp atomic + a >>= b; +#pragma omp atomic update + a = b + a; +#pragma omp atomic + a = a * b; +#pragma omp atomic update + a = b - a; +#pragma omp atomic + a = a / b; +#pragma omp atomic update + a = b & a; +#pragma omp atomic + a = a ^ b; +#pragma omp atomic update + a = b | a; +#pragma omp atomic + a = a << b; +#pragma omp atomic + a = b >> a; #pragma omp atomic - // expected-error@+1 {{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 l-value expression with scalar type}} + // 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 l-value expression with scalar type}} + // expected-note@+1 {{expected an expression statement}} ; return T(); @@ -170,14 +246,85 @@ int update() { int a, b = 0; // Test for atomic update #pragma omp atomic update - // expected-error@+1 {{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 l-value expression with scalar type}} + // 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 l-value expression with scalar type}} + // expected-note@+1 {{expected an expression statement}} ; // expected-error@+1 {{directive '#pragma omp atomic' cannot contain more than one 'update' clause}} #pragma omp atomic update update a += b; - #pragma omp atomic - // expected-error@+1 {{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 l-value expression with scalar type}} + // 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 l-value expression with scalar type}} + // expected-note@+1 {{expected built-in binary operator}} + a = b; +#pragma omp atomic update + // 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 l-value expression with scalar type}} + // expected-note@+1 {{expected one of '+', '*', '-', '/', '&', '^', '|', '<<', or '>>' built-in operations}} + a = b || a; +#pragma omp atomic update + // 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 l-value expression with scalar type}} + // expected-note@+1 {{expected one of '+', '*', '-', '/', '&', '^', '|', '<<', or '>>' built-in operations}} + a = a && b; +#pragma omp atomic update + // 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 l-value expression with scalar type}} + // expected-note@+1 {{expected in right hand side of expression}} + a = float(a) + b; +#pragma omp atomic + // 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 l-value expression with scalar type}} + // expected-note@+1 {{expected in right hand side of expression}} + a = 2 * b; +#pragma omp atomic + // 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 l-value expression with scalar type}} + // expected-note@+1 {{expected in right hand side of expression}} + a = b + *&a; +#pragma omp atomic update + a++; +#pragma omp atomic + ++a; +#pragma omp atomic update + a--; +#pragma omp atomic + --a; +#pragma omp atomic update + a += b; +#pragma omp atomic + a %= b; +#pragma omp atomic update + a *= b; +#pragma omp atomic + a -= b; +#pragma omp atomic update + a /= b; +#pragma omp atomic + a &= b; +#pragma omp atomic update + a ^= b; +#pragma omp atomic + a |= b; +#pragma omp atomic update + a <<= b; +#pragma omp atomic + a >>= b; +#pragma omp atomic update + a = b + a; +#pragma omp atomic + a = a * b; +#pragma omp atomic update + a = b - a; +#pragma omp atomic + a = a / b; +#pragma omp atomic update + a = b & a; +#pragma omp atomic + a = a ^ b; +#pragma omp atomic update + a = b | a; +#pragma omp atomic + a = a << b; +#pragma omp atomic + a = b >> a; +#pragma omp atomic + // 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 l-value expression with scalar type}} + // expected-note@+1 {{expected an expression statement}} ; return update<int>(); @@ -185,33 +332,345 @@ int update() { template <class T> T capture() { - T a, b = 0; + T a = 0, b = 0, c = 0; // Test for atomic capture #pragma omp atomic capture - // expected-error@+1 {{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 l-value expressions with scalar type}} - ++a; -#pragma omp atomic capture - // expected-error@+1 {{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 l-value expression with scalar type}} + // 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 l-value expression with scalar type}} + // expected-note@+1 {{expected compound statement}} ; -// expected-error@+1 {{directive '#pragma omp atomic' cannot contain more than one 'capture' clause}} +#pragma omp atomic capture + // 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 l-value expressions with scalar type}} + // expected-note@+1 {{expected assignment expression}} + foo(); +#pragma omp atomic capture + // 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 l-value expressions with scalar type}} + // expected-note@+1 {{expected built-in binary or unary operator}} + a = b; +#pragma omp atomic capture + // 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 l-value expressions with scalar type}} + // expected-note@+1 {{expected assignment expression}} + a = b || a; +#pragma omp atomic capture + // 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 l-value expressions with scalar type}} + // expected-note@+1 {{expected one of '+', '*', '-', '/', '&', '^', '|', '<<', or '>>' built-in operations}} + b = a = a && b; +#pragma omp atomic capture + // 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 l-value expressions with scalar type}} + // expected-note@+1 {{expected assignment expression}} + a = (float)a + b; +#pragma omp atomic capture + // 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 l-value expressions with scalar type}} + // expected-note@+1 {{expected assignment expression}} + a = 2 * b; +#pragma omp atomic capture + // 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 l-value expressions with scalar type}} + // expected-note@+1 {{expected assignment expression}} + a = b + *&a; +#pragma omp atomic capture + // 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 l-value expression with scalar type}} + // expected-note@+1 {{expected exactly two expression statements}} + { a = b; } +#pragma omp atomic capture + // 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 l-value expression with scalar type}} + // expected-note@+1 {{expected exactly two expression statements}} + {} +#pragma omp atomic capture + // 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 l-value expression with scalar type}} + // expected-note@+1 {{expected in right hand side of the first expression}} + {a = b;a = b;} +#pragma omp atomic capture + // 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 l-value expression with scalar type}} + // expected-note@+1 {{expected in right hand side of the first expression}} + {a = b; a = b || a;} +#pragma omp atomic capture + {b = a; a = a && b;} +#pragma omp atomic capture + // 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 l-value expressions with scalar type}} + // expected-note@+1 {{expected in right hand side of expression}} + b = a = (float)a + b; +#pragma omp atomic capture + // 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 l-value expressions with scalar type}} + // expected-note@+1 {{expected in right hand side of expression}} + b = a = 2 * b; +#pragma omp atomic capture + // 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 l-value expressions with scalar type}} + // expected-note@+1 {{expected in right hand side of expression}} + b = a = b + *&a; +#pragma omp atomic capture + c = *&a = *&a + 2; +#pragma omp atomic capture + c = a++; +#pragma omp atomic capture + c = ++a; +#pragma omp atomic capture + c = a--; +#pragma omp atomic capture + c = --a; +#pragma omp atomic capture + c = a += b; +#pragma omp atomic capture + c = a %= b; +#pragma omp atomic capture + c = a *= b; +#pragma omp atomic capture + c = a -= b; +#pragma omp atomic capture + c = a /= b; +#pragma omp atomic capture + c = a &= b; +#pragma omp atomic capture + c = a ^= b; +#pragma omp atomic capture + c = a |= b; +#pragma omp atomic capture + c = a <<= b; +#pragma omp atomic capture + c = a >>= b; +#pragma omp atomic capture + c = a = b + a; +#pragma omp atomic capture + c = a = a * b; +#pragma omp atomic capture + c = a = b - a; +#pragma omp atomic capture + c = a = a / b; +#pragma omp atomic capture + c = a = b & a; +#pragma omp atomic capture + c = a = a ^ b; +#pragma omp atomic capture + c = a = b | a; +#pragma omp atomic capture + c = a = a << b; +#pragma omp atomic capture + c = a = b >> a; +#pragma omp atomic capture + { c = *&a; *&a = *&a + 2;} +#pragma omp atomic capture + { *&a = *&a + 2; c = *&a;} +#pragma omp atomic capture + {c = a; a++;} +#pragma omp atomic capture + {++a;c = a;} +#pragma omp atomic capture + {c = a;a--;} +#pragma omp atomic capture + {--a;c = a;} +#pragma omp atomic capture + {c = a; a += b;} +#pragma omp atomic capture + {a %= b; c = a;} +#pragma omp atomic capture + {c = a; a *= b;} +#pragma omp atomic capture + {a -= b;c = a;} +#pragma omp atomic capture + {c = a; a /= b;} +#pragma omp atomic capture + {a &= b; c = a;} +#pragma omp atomic capture + {c = a; a ^= b;} +#pragma omp atomic capture + {a |= b; c = a;} +#pragma omp atomic capture + {c = a; a <<= b;} +#pragma omp atomic capture + {a >>= b; c = a;} +#pragma omp atomic capture + {c = a; a = b + a;} +#pragma omp atomic capture + {a = a * b; c = a;} +#pragma omp atomic capture + {c = a; a = b - a;} +#pragma omp atomic capture + {a = a / b; c = a;} +#pragma omp atomic capture + {c = a; a = b & a;} +#pragma omp atomic capture + {a = a ^ b; c = a;} +#pragma omp atomic capture + {c = a; a = b | a;} +#pragma omp atomic capture + {a = a << b; c = a;} +#pragma omp atomic capture + {c = a; a = b >> a;} +#pragma omp atomic capture + {c = a; a = foo();} + // expected-error@+1 {{directive '#pragma omp atomic' cannot contain more than one 'capture' clause}} #pragma omp atomic capture capture - a = ++b; + b = a /= b; return T(); } int capture() { - int a, b = 0; + int a = 0, b = 0, c = 0; // Test for atomic capture #pragma omp atomic capture - // expected-error@+1 {{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 l-value expressions with scalar type}} - ++a; -#pragma omp atomic capture - // expected-error@+1 {{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 l-value expression with scalar type}} + // 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 l-value expression with scalar type}} + // expected-note@+1 {{expected compound statement}} ; -// expected-error@+1 {{directive '#pragma omp atomic' cannot contain more than one 'capture' clause}} +#pragma omp atomic capture + // 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 l-value expressions with scalar type}} + // expected-note@+1 {{expected assignment expression}} + foo(); +#pragma omp atomic capture + // 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 l-value expressions with scalar type}} + // expected-note@+1 {{expected built-in binary or unary operator}} + a = b; +#pragma omp atomic capture + // 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 l-value expressions with scalar type}} + // expected-note@+1 {{expected assignment expression}} + a = b || a; +#pragma omp atomic capture + // 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 l-value expressions with scalar type}} + // expected-note@+1 {{expected one of '+', '*', '-', '/', '&', '^', '|', '<<', or '>>' built-in operations}} + b = a = a && b; +#pragma omp atomic capture + // 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 l-value expressions with scalar type}} + // expected-note@+1 {{expected assignment expression}} + a = (float)a + b; +#pragma omp atomic capture + // 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 l-value expressions with scalar type}} + // expected-note@+1 {{expected assignment expression}} + a = 2 * b; +#pragma omp atomic capture + // 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 l-value expressions with scalar type}} + // expected-note@+1 {{expected assignment expression}} + a = b + *&a; +#pragma omp atomic capture + // 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 l-value expression with scalar type}} + // expected-note@+1 {{expected exactly two expression statements}} + { a = b; } +#pragma omp atomic capture + // 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 l-value expression with scalar type}} + // expected-note@+1 {{expected exactly two expression statements}} + {} +#pragma omp atomic capture + // 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 l-value expression with scalar type}} + // expected-note@+1 {{expected in right hand side of the first expression}} + {a = b;a = b;} +#pragma omp atomic capture + // 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 l-value expression with scalar type}} + // expected-note@+1 {{expected in right hand side of the first expression}} + {a = b; a = b || a;} +#pragma omp atomic capture + {b = a; a = a && b;} +#pragma omp atomic capture + // 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 l-value expressions with scalar type}} + // expected-note@+1 {{expected in right hand side of expression}} + b = a = (float)a + b; +#pragma omp atomic capture + // 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 l-value expressions with scalar type}} + // expected-note@+1 {{expected in right hand side of expression}} + b = a = 2 * b; +#pragma omp atomic capture + // 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 l-value expressions with scalar type}} + // expected-note@+1 {{expected in right hand side of expression}} + b = a = b + *&a; +#pragma omp atomic capture + c = *&a = *&a + 2; +#pragma omp atomic capture + c = a++; +#pragma omp atomic capture + c = ++a; +#pragma omp atomic capture + c = a--; +#pragma omp atomic capture + c = --a; +#pragma omp atomic capture + c = a += b; +#pragma omp atomic capture + c = a %= b; +#pragma omp atomic capture + c = a *= b; +#pragma omp atomic capture + c = a -= b; +#pragma omp atomic capture + c = a /= b; +#pragma omp atomic capture + c = a &= b; +#pragma omp atomic capture + c = a ^= b; +#pragma omp atomic capture + c = a |= b; +#pragma omp atomic capture + c = a <<= b; +#pragma omp atomic capture + c = a >>= b; +#pragma omp atomic capture + c = a = b + a; +#pragma omp atomic capture + c = a = a * b; +#pragma omp atomic capture + c = a = b - a; +#pragma omp atomic capture + c = a = a / b; +#pragma omp atomic capture + c = a = b & a; +#pragma omp atomic capture + c = a = a ^ b; +#pragma omp atomic capture + c = a = b | a; +#pragma omp atomic capture + c = a = a << b; +#pragma omp atomic capture + c = a = b >> a; +#pragma omp atomic capture + { c = *&a; *&a = *&a + 2;} +#pragma omp atomic capture + { *&a = *&a + 2; c = *&a;} +#pragma omp atomic capture + {c = a; a++;} +#pragma omp atomic capture + {++a;c = a;} +#pragma omp atomic capture + {c = a;a--;} +#pragma omp atomic capture + {--a;c = a;} +#pragma omp atomic capture + {c = a; a += b;} +#pragma omp atomic capture + {a %= b; c = a;} +#pragma omp atomic capture + {c = a; a *= b;} +#pragma omp atomic capture + {a -= b;c = a;} +#pragma omp atomic capture + {c = a; a /= b;} +#pragma omp atomic capture + {a &= b; c = a;} +#pragma omp atomic capture + {c = a; a ^= b;} +#pragma omp atomic capture + {a |= b; c = a;} +#pragma omp atomic capture + {c = a; a <<= b;} +#pragma omp atomic capture + {a >>= b; c = a;} +#pragma omp atomic capture + {c = a; a = b + a;} +#pragma omp atomic capture + {a = a * b; c = a;} +#pragma omp atomic capture + {c = a; a = b - a;} +#pragma omp atomic capture + {a = a / b; c = a;} +#pragma omp atomic capture + {c = a; a = b & a;} +#pragma omp atomic capture + {a = a ^ b; c = a;} +#pragma omp atomic capture + {c = a; a = b | a;} +#pragma omp atomic capture + {a = a << b; c = a;} +#pragma omp atomic capture + {c = a; a = b >> a;} +#pragma omp atomic capture + {c = a; a = foo();} + // expected-error@+1 {{directive '#pragma omp atomic' cannot contain more than one 'capture' clause}} #pragma omp atomic capture capture - a = ++b; + b = a /= b; return capture<int>(); } @@ -221,14 +680,16 @@ T seq_cst() { T a, b = 0; // Test for atomic seq_cst #pragma omp atomic seq_cst - // expected-error@+1 {{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 l-value expression with scalar type}} + // 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 l-value expression with scalar type}} + // expected-note@+1 {{expected an expression statement}} ; // expected-error@+1 {{directive '#pragma omp atomic' cannot contain more than one 'seq_cst' clause}} #pragma omp atomic seq_cst seq_cst a += b; #pragma omp atomic update seq_cst - // expected-error@+1 {{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 l-value expression with scalar type}} + // 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 l-value expression with scalar type}} + // expected-note@+1 {{expected an expression statement}} ; return T(); @@ -238,14 +699,16 @@ int seq_cst() { int a, b = 0; // Test for atomic seq_cst #pragma omp atomic seq_cst - // expected-error@+1 {{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 l-value expression with scalar type}} + // 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 l-value expression with scalar type}} + // expected-note@+1 {{expected an expression statement}} ; // expected-error@+1 {{directive '#pragma omp atomic' cannot contain more than one 'seq_cst' clause}} #pragma omp atomic seq_cst seq_cst a += b; #pragma omp atomic update seq_cst - // expected-error@+1 {{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 l-value expression with scalar type}} + // 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 l-value expression with scalar type}} + // expected-note@+1 {{expected an expression statement}} ; return seq_cst<int>(); |