| // RUN: %clang_cc1 -verify -fopenmp=libiomp5 -ferror-limit 100 %s |
| |
| int foo() { |
| L1: |
| 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 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@+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: |
| foo(); |
| } |
| |
| return 0; |
| } |
| |
| struct S { |
| int a; |
| }; |
| |
| int readint() { |
| int a = 0, b = 0; |
| // Test for atomic read |
| #pragma omp atomic read |
| // 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}} |
| // expected-note@+1 {{expected an expression statement}} |
| ; |
| #pragma omp atomic read |
| // 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}} |
| // expected-note@+1 {{expected built-in assignment operator}} |
| foo(); |
| #pragma omp atomic read |
| // 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}} |
| // expected-note@+1 {{expected built-in assignment operator}} |
| a += b; |
| #pragma omp atomic read |
| // 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}} |
| // expected-note@+1 {{expected lvalue expression}} |
| a = 0; |
| #pragma omp atomic read |
| a = b; |
| // expected-error@+1 {{directive '#pragma omp atomic' cannot contain more than one 'read' clause}} |
| #pragma omp atomic read read |
| a = b; |
| |
| return 0; |
| } |
| |
| int readS() { |
| struct S a, b; |
| // expected-error@+1 {{directive '#pragma omp atomic' cannot contain more than one 'read' clause}} |
| #pragma omp atomic read read |
| // 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}} |
| // expected-note@+1 {{expected expression of scalar type}} |
| a = b; |
| |
| return a.a; |
| } |
| |
| int writeint() { |
| int a = 0, b = 0; |
| // Test for atomic write |
| #pragma omp atomic write |
| // 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}} |
| // expected-note@+1 {{expected an expression statement}} |
| ; |
| #pragma omp atomic write |
| // 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}} |
| // expected-note@+1 {{expected built-in assignment operator}} |
| foo(); |
| #pragma omp atomic write |
| // 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}} |
| // expected-note@+1 {{expected built-in assignment operator}} |
| a += b; |
| #pragma omp atomic write |
| a = 0; |
| #pragma omp atomic write |
| a = b; |
| // expected-error@+1 {{directive '#pragma omp atomic' cannot contain more than one 'write' clause}} |
| #pragma omp atomic write write |
| a = b; |
| |
| return 0; |
| } |
| |
| int writeS() { |
| struct S a, b; |
| // expected-error@+1 {{directive '#pragma omp atomic' cannot contain more than one 'write' clause}} |
| #pragma omp atomic write write |
| // 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}} |
| // expected-note@+1 {{expected expression of scalar type}} |
| a = b; |
| |
| 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; |
| } |
| |