diff options
Diffstat (limited to 'test/OpenMP/atomic_messages.c')
| -rw-r--r-- | test/OpenMP/atomic_messages.c | 271 |
1 files changed, 268 insertions, 3 deletions
diff --git a/test/OpenMP/atomic_messages.c b/test/OpenMP/atomic_messages.c index ae490ee..8182465 100644 --- a/test/OpenMP/atomic_messages.c +++ b/test/OpenMP/atomic_messages.c @@ -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: @@ -100,3 +102,266 @@ int writeS() { return a.a; } + +int updateint() { + int a = 0, b = 0; +// Test for atomic update +#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 an expression statement}} + ; +#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 or unary operator}} + foo(); +#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 update + *&a = *&a + 2; +#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; + // expected-error@+1 {{directive '#pragma omp atomic' cannot contain more than one 'update' clause}} +#pragma omp atomic update update + a /= b; + + return 0; +} + +int captureint() { + int a = 0, b = 0, c = 0; +// Test for atomic capture +#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 compound statement}} + ; +#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 + b = a /= b; + + return 0; +} + |
