3bd34ec924
Running an external test suite (UDel) showed that our expression comparison for the 'cache' rule checking was overly strict in the presence of irrelevant parens/casts/etc. This patch ensures we skip them when checking. This also changes the diagnostic to say 'sub-expression' instead of variable, which is more correct.
1884 lines
71 KiB
C++
1884 lines
71 KiB
C++
// RUN: %clang_cc1 %s -fopenacc -Wno-unused-value -verify
|
|
|
|
void NormalFunc(int I) {
|
|
// No clauses are valid, but we parse them anyway, just mark them as not valid
|
|
// on this construct.
|
|
|
|
// expected-error@+1{{OpenACC 'copy' clause is not valid on 'atomic' directive}}
|
|
#pragma acc atomic copy(I)
|
|
I = I + 1;
|
|
// expected-error@+1{{OpenACC 'copy' clause is not valid on 'atomic' directive}}
|
|
#pragma acc atomic read copy(I)
|
|
I = I;
|
|
}
|
|
|
|
struct Struct{
|
|
Struct *getPtr();
|
|
Struct &operator++();
|
|
Struct &operator--();
|
|
Struct &operator++(int);
|
|
Struct &operator--(int);
|
|
|
|
Struct &operator+=(int);
|
|
Struct &operator*=(int);
|
|
Struct &operator-=(int);
|
|
Struct &operator/=(int);
|
|
Struct &operator&=(int);
|
|
Struct &operator|=(int);
|
|
Struct &operator<<=(int);
|
|
Struct &operator>>=(int);
|
|
Struct &operator^=(int);
|
|
Struct &operator%=(int);
|
|
Struct &operator!=(int);
|
|
Struct &operator+();
|
|
Struct &operator-();
|
|
|
|
operator int();
|
|
void operator()();
|
|
Struct &operator*();
|
|
Struct &operator=(int);
|
|
};
|
|
|
|
int operator+(Struct&, int);
|
|
int operator+(int, Struct&);
|
|
Struct &operator+(Struct&, Struct&);
|
|
Struct &operator*(Struct&, Struct&);
|
|
Struct &operator-(Struct&, Struct&);
|
|
|
|
Struct S1, S2;
|
|
|
|
struct NotCondition{} NC;
|
|
|
|
template<typename T>
|
|
T &getRValue();
|
|
|
|
void IfClause(int x, int v) {
|
|
// expected-error@+1{{OpenACC 'seq' clause is not valid on 'atomic' directive}}
|
|
#pragma acc atomic read seq
|
|
x = v;
|
|
|
|
// expected-error@+1{{expected '('}}
|
|
#pragma acc atomic read if
|
|
x = v;
|
|
|
|
// expected-error@+1{{value of type 'struct NotCondition' is not contextually convertible to 'bool'}}
|
|
#pragma acc atomic read if(NC)
|
|
x = v;
|
|
|
|
// expected-error@+2{{OpenACC 'if' clause cannot appear more than once on a 'atomic' directive}}
|
|
// expected-note@+1{{previous 'if' clause is here}}
|
|
#pragma acc atomic read if(x) if (v)
|
|
x = v;
|
|
}
|
|
|
|
template<typename T>
|
|
void AtomicReadTemplate(T LHS, T RHS) {
|
|
#pragma acc atomic read
|
|
LHS = RHS;
|
|
|
|
T *LHSPtr, *RHSPtr;
|
|
|
|
#pragma acc atomic read
|
|
LHSPtr = RHSPtr;
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic read' directive is invalid}}
|
|
// expected-note@+2{{right operand to assignment expression must be an l-value}}
|
|
#pragma acc atomic read
|
|
LHS = RHS + 1;
|
|
|
|
#pragma acc atomic read
|
|
*LHSPtr = RHS;
|
|
|
|
#pragma acc atomic read
|
|
LHS = *RHSPtr;
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic read' directive is invalid}}
|
|
// expected-note@+2{{right operand to assignment expression must be an l-value}}
|
|
#pragma acc atomic read
|
|
LHS = getRValue<T>();
|
|
}
|
|
|
|
template<typename T>
|
|
void AtomicReadTemplate2(T LHS, T RHS) {
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic read' directive is invalid}}
|
|
// expected-note@+2{{left operand to assignment expression must be of scalar type (was 'Struct')}}
|
|
#pragma acc atomic read
|
|
LHS = RHS;
|
|
|
|
T *LHSPtr, *RHSPtr;
|
|
// Fine, now a pointer.
|
|
#pragma acc atomic read
|
|
LHSPtr = RHSPtr;
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic read' directive is invalid}}
|
|
// expected-note@+2{{right operand to assignment expression must be an l-value}}
|
|
#pragma acc atomic read
|
|
LHS = *RHS.getPtr();
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic read' directive is invalid}}
|
|
// expected-note@+2{{left operand to assignment expression must be of scalar type (was 'Struct')}}
|
|
#pragma acc atomic read
|
|
*LHSPtr = RHS;
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic read' directive is invalid}}
|
|
// expected-note@+2{{left operand to assignment expression must be of scalar type (was 'Struct')}}
|
|
#pragma acc atomic read
|
|
LHS = *RHSPtr;
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic read' directive is invalid}}
|
|
// expected-note@+2{{left operand to assignment expression must be an l-value}}
|
|
#pragma acc atomic read
|
|
getRValue<T>() = getRValue<T>();
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic read' directive is invalid}}
|
|
// expected-note@+2{{right operand to assignment expression must be an l-value}}
|
|
#pragma acc atomic read
|
|
LHS = getRValue<T>();
|
|
}
|
|
|
|
void AtomicRead(int LHS, int RHS) {
|
|
AtomicReadTemplate(LHS, RHS);
|
|
AtomicReadTemplate2(S1, S2); // expected-note{{in instantiation of function template specialization}}
|
|
|
|
#pragma acc atomic read
|
|
LHS = RHS;
|
|
|
|
int *LHSPtr, *RHSPtr;
|
|
|
|
#pragma acc atomic read
|
|
LHSPtr = RHSPtr;
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic read' directive is invalid}}
|
|
// expected-note@+2{{left operand to assignment expression must be of scalar type (was 'Struct')}}
|
|
#pragma acc atomic read
|
|
S1 = S2;
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic read' directive is invalid}}
|
|
// expected-note@+2{{right operand to assignment expression must be an l-value}}
|
|
#pragma acc atomic read
|
|
LHS = RHS + 1;
|
|
|
|
#pragma acc atomic read
|
|
*LHSPtr = RHS;
|
|
|
|
#pragma acc atomic read
|
|
LHS = *RHSPtr;
|
|
|
|
// There is no way to test that = is an overloaded operator, since there
|
|
// really isn't a way to create an operator= without a class type on one side
|
|
// or the other.
|
|
}
|
|
|
|
template<typename T>
|
|
void AtomicWriteTemplate(T LHS, T RHS) {
|
|
#pragma acc atomic write
|
|
LHS = RHS;
|
|
|
|
T *LHSPtr, *RHSPtr;
|
|
#pragma acc atomic write
|
|
LHSPtr = RHSPtr;
|
|
|
|
#pragma acc atomic write
|
|
*LHSPtr = *RHSPtr;
|
|
|
|
// allowed, expr is ok.
|
|
#pragma acc atomic write
|
|
LHS = *RHSPtr;
|
|
|
|
#pragma acc atomic write
|
|
LHS = RHS * 2;
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic write' directive is invalid}}
|
|
// expected-note@+2{{left operand to assignment expression must be an l-value}}
|
|
#pragma acc atomic write
|
|
getRValue<T>() = getRValue<T>();
|
|
|
|
#pragma acc atomic write
|
|
LHS = getRValue<T>();
|
|
}
|
|
|
|
template<typename T>
|
|
void AtomicWriteTemplate2(T LHS, T RHS) {
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic write' directive is invalid}}
|
|
// expected-note@+2{{left operand to assignment expression must be of scalar type (was 'Struct')}}
|
|
#pragma acc atomic write
|
|
LHS = RHS;
|
|
|
|
T *LHSPtr, *RHSPtr;
|
|
#pragma acc atomic write
|
|
LHSPtr = RHSPtr;
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic write' directive is invalid}}
|
|
// expected-note@+2{{left operand to assignment expression must be of scalar type (was 'Struct')}}
|
|
#pragma acc atomic write
|
|
LHS = *RHSPtr;
|
|
|
|
#pragma acc atomic write
|
|
LHSPtr = RHS.getPtr();
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic write' directive is invalid}}
|
|
// expected-note@+2{{left operand to assignment expression must be an l-value}}
|
|
#pragma acc atomic write
|
|
getRValue<T>() = getRValue<T>();
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic write' directive is invalid}}
|
|
// expected-note@+2{{left operand to assignment expression must be of scalar type (was 'Struct')}}
|
|
#pragma acc atomic write
|
|
LHS = getRValue<T>();
|
|
}
|
|
|
|
void AtomicWrite(int LHS, int RHS) {
|
|
AtomicWriteTemplate(LHS, RHS);
|
|
AtomicWriteTemplate2(S1, S2); // expected-note{{in instantiation of function template specialization}}
|
|
|
|
#pragma acc atomic write
|
|
LHS = RHS;
|
|
|
|
int *LHSPtr, *RHSPtr;
|
|
#pragma acc atomic write
|
|
LHSPtr = RHSPtr;
|
|
|
|
#pragma acc atomic write
|
|
*LHSPtr = *RHSPtr;
|
|
|
|
// allowed, expr is ok.
|
|
#pragma acc atomic write
|
|
LHS = *RHSPtr;
|
|
|
|
#pragma acc atomic write
|
|
LHS = RHS * 2;
|
|
}
|
|
|
|
template<typename T>
|
|
void AtomicUpdateTemplate(T LHS, T RHS) {
|
|
#pragma acc atomic
|
|
LHS++;
|
|
|
|
#pragma acc atomic update
|
|
LHS--;
|
|
|
|
#pragma acc atomic
|
|
++LHS;
|
|
|
|
#pragma acc atomic update
|
|
--LHS;
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic' directive is invalid}}
|
|
// expected-note@+2{{unary operator not supported, only increment and decrement operations permitted}}
|
|
#pragma acc atomic
|
|
+LHS;
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic update' directive is invalid}}
|
|
// expected-note@+2{{unary operator not supported, only increment and decrement operations permitted}}
|
|
#pragma acc atomic update
|
|
-LHS;
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic update' directive is invalid}}
|
|
// expected-note@+2{{expected binary operation on right hand side of assignment operator}}
|
|
#pragma acc atomic update
|
|
LHS = RHS;
|
|
|
|
T *LHSPtr, *RHSPtr;
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic' directive is invalid}}
|
|
// expected-note@+2{{expected binary operation on right hand side of assignment operator}}
|
|
#pragma acc atomic
|
|
*LHSPtr = *RHSPtr;
|
|
|
|
// x binop= expr;
|
|
#pragma acc atomic
|
|
LHS += 1 + RHS;
|
|
#pragma acc atomic update
|
|
LHS *= 1 + RHS;
|
|
#pragma acc atomic
|
|
LHS -= 1 + RHS;
|
|
#pragma acc atomic update
|
|
LHS /= 1 + RHS;
|
|
#pragma acc atomic
|
|
LHS &= 1 + RHS;
|
|
#pragma acc atomic update
|
|
LHS ^= 1 + RHS;
|
|
#pragma acc atomic
|
|
LHS |= 1 + RHS;
|
|
#pragma acc atomic update
|
|
LHS <<= 1 + RHS;
|
|
#pragma acc atomic
|
|
LHS >>= 1 + RHS;
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic update' directive is invalid}}
|
|
// expected-note@+2{{compound binary operator not supported, only +=, *=, -=, /=, &=, ^=, |=, <<=, or >>= are permitted}}
|
|
#pragma acc atomic update
|
|
LHS != 1 + RHS;
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic update' directive is invalid}}
|
|
// expected-note@+2{{compound binary operator not supported, only +=, *=, -=, /=, &=, ^=, |=, <<=, or >>= are permitted}}
|
|
#pragma acc atomic update
|
|
LHS <= 1 + RHS;
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic update' directive is invalid}}
|
|
// expected-note@+2{{compound binary operator not supported, only +=, *=, -=, /=, &=, ^=, |=, <<=, or >>= are permitted}}
|
|
#pragma acc atomic update
|
|
LHS >= 1 + RHS;
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic update' directive is invalid}}
|
|
// expected-note@+2{{compound binary operator not supported, only +=, *=, -=, /=, &=, ^=, |=, <<=, or >>= are permitted}}
|
|
#pragma acc atomic update
|
|
LHS %= 1 + RHS;
|
|
|
|
// x = x binop expr.
|
|
#pragma acc atomic
|
|
LHS = LHS + getRValue<T>();
|
|
#pragma acc atomic update
|
|
LHS = LHS * getRValue<T>();
|
|
#pragma acc atomic update
|
|
LHS = LHS - getRValue<T>();
|
|
#pragma acc atomic update
|
|
LHS = LHS / getRValue<T>();
|
|
#pragma acc atomic update
|
|
LHS = LHS & getRValue<T>();
|
|
#pragma acc atomic update
|
|
LHS = LHS ^ getRValue<T>();
|
|
#pragma acc atomic update
|
|
LHS = LHS | getRValue<T>();
|
|
#pragma acc atomic update
|
|
LHS = LHS << getRValue<T>();
|
|
#pragma acc atomic update
|
|
LHS = LHS >> getRValue<T>();
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic update' directive is invalid}}
|
|
// expected-note@+2{{binary operator not supported, only +, *, -, /, &, ^, |, <<, or >> are permitted}}
|
|
#pragma acc atomic update
|
|
LHS = LHS < getRValue<T>();
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic update' directive is invalid}}
|
|
// expected-note@+2{{binary operator not supported, only +, *, -, /, &, ^, |, <<, or >> are permitted}}
|
|
#pragma acc atomic update
|
|
LHS = LHS > getRValue<T>();
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic update' directive is invalid}}
|
|
// expected-note@+2{{binary operator not supported, only +, *, -, /, &, ^, |, <<, or >> are permitted}}
|
|
#pragma acc atomic update
|
|
LHS = LHS <= getRValue<T>();
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic update' directive is invalid}}
|
|
// expected-note@+2{{binary operator not supported, only +, *, -, /, &, ^, |, <<, or >> are permitted}}
|
|
#pragma acc atomic update
|
|
LHS = LHS >= getRValue<T>();
|
|
#pragma acc atomic update
|
|
LHS = LHS ^ getRValue<T>();
|
|
|
|
|
|
// x = expr binop x.
|
|
#pragma acc atomic
|
|
LHS = getRValue<T>() + LHS;
|
|
#pragma acc atomic update
|
|
LHS = getRValue<T>() * LHS;
|
|
#pragma acc atomic update
|
|
LHS = getRValue<T>() - LHS;
|
|
#pragma acc atomic update
|
|
LHS = getRValue<T>() / LHS;
|
|
#pragma acc atomic update
|
|
LHS = getRValue<T>() & LHS;
|
|
#pragma acc atomic update
|
|
LHS = getRValue<T>() ^ LHS;
|
|
#pragma acc atomic update
|
|
LHS = getRValue<T>() | LHS;
|
|
#pragma acc atomic update
|
|
LHS = getRValue<T>() << LHS;
|
|
#pragma acc atomic update
|
|
LHS = getRValue<T>() >> LHS;
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic update' directive is invalid}}
|
|
// expected-note@+2{{binary operator not supported, only +, *, -, /, &, ^, |, <<, or >> are permitted}}
|
|
#pragma acc atomic update
|
|
LHS = getRValue<T>() < LHS;
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic update' directive is invalid}}
|
|
// expected-note@+2{{binary operator not supported, only +, *, -, /, &, ^, |, <<, or >> are permitted}}
|
|
#pragma acc atomic update
|
|
LHS = getRValue<T>() > LHS;
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic update' directive is invalid}}
|
|
// expected-note@+2{{binary operator not supported, only +, *, -, /, &, ^, |, <<, or >> are permitted}}
|
|
#pragma acc atomic update
|
|
LHS = getRValue<T>() <= LHS;
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic update' directive is invalid}}
|
|
// expected-note@+2{{binary operator not supported, only +, *, -, /, &, ^, |, <<, or >> are permitted}}
|
|
#pragma acc atomic update
|
|
LHS = getRValue<T>() >= LHS;
|
|
#pragma acc atomic update
|
|
LHS = getRValue<T>() ^ LHS;
|
|
|
|
#pragma acc atomic update
|
|
LHS = LHS + getRValue<T>();
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic update' directive is invalid}}
|
|
// expected-note@+2{{left hand side of assignment operation('LHS') must match one side of the sub-operation on the right hand side('RHS' and 'getRValue<T>()')}}
|
|
#pragma acc atomic update
|
|
LHS = RHS + getRValue<T>();
|
|
|
|
#pragma acc atomic update
|
|
LHS = getRValue<T>() - LHS;
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic update' directive is invalid}}
|
|
// expected-note@+2{{left hand side of assignment operation('LHS') must match one side of the sub-operation on the right hand side('getRValue<T>()' and 'RHS')}}
|
|
#pragma acc atomic update
|
|
LHS = getRValue<T>() + RHS;
|
|
}
|
|
|
|
template<typename T>
|
|
void AtomicUpdateTemplate2(T LHS, T RHS) {
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic' directive is invalid}}
|
|
// expected-note@+2{{operand to increment expression must be of scalar type (was 'Struct')}}
|
|
#pragma acc atomic
|
|
LHS++;
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic update' directive is invalid}}
|
|
// expected-note@+2{{operand to decrement expression must be of scalar type (was 'Struct')}}
|
|
#pragma acc atomic update
|
|
LHS--;
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic' directive is invalid}}
|
|
// expected-note@+2{{operand to increment expression must be of scalar type (was 'Struct')}}
|
|
#pragma acc atomic
|
|
++LHS;
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic update' directive is invalid}}
|
|
// expected-note@+2{{operand to decrement expression must be of scalar type (was 'Struct')}}
|
|
#pragma acc atomic update
|
|
--LHS;
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic' directive is invalid}}
|
|
// expected-note@+2{{unary operator not supported, only increment and decrement operations permitted}}
|
|
#pragma acc atomic
|
|
+LHS;
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic update' directive is invalid}}
|
|
// expected-note@+2{{unary operator not supported, only increment and decrement operations permitted}}
|
|
#pragma acc atomic update
|
|
-LHS;
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic' directive is invalid}}
|
|
// expected-note@+2{{expected assignment, compound assignment, increment, or decrement expression}}
|
|
#pragma acc atomic
|
|
LHS();
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic' directive is invalid}}
|
|
// expected-note@+2{{unary operator not supported, only increment and decrement operations permitted}}
|
|
#pragma acc atomic
|
|
*LHS;
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic update' directive is invalid}}
|
|
// expected-note@+2{{expected binary operation on right hand side of assignment operator}}
|
|
#pragma acc atomic update
|
|
LHS = RHS;
|
|
|
|
T *LHSPtr, *RHSPtr;
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic' directive is invalid}}
|
|
// expected-note@+2{{expected binary operation on right hand side of assignment operator}}
|
|
#pragma acc atomic
|
|
*LHSPtr = *RHSPtr;
|
|
|
|
// x binop= expr;
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic' directive is invalid}}
|
|
// expected-note@+2{{left operand to compound assignment expression must be of scalar type (was 'Struct')}}
|
|
#pragma acc atomic
|
|
LHS += 1 + RHS;
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic update' directive is invalid}}
|
|
// expected-note@+2{{left operand to compound assignment expression must be of scalar type (was 'Struct')}}
|
|
#pragma acc atomic update
|
|
LHS *= 1 + RHS;
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic' directive is invalid}}
|
|
// expected-note@+2{{left operand to compound assignment expression must be of scalar type (was 'Struct')}}
|
|
#pragma acc atomic
|
|
LHS -= 1 + RHS;
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic update' directive is invalid}}
|
|
// expected-note@+2{{left operand to compound assignment expression must be of scalar type (was 'Struct')}}
|
|
#pragma acc atomic update
|
|
LHS /= 1 + RHS;
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic' directive is invalid}}
|
|
// expected-note@+2{{left operand to compound assignment expression must be of scalar type (was 'Struct')}}
|
|
#pragma acc atomic
|
|
LHS &= 1 + RHS;
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic update' directive is invalid}}
|
|
// expected-note@+2{{left operand to compound assignment expression must be of scalar type (was 'Struct')}}
|
|
#pragma acc atomic update
|
|
LHS ^= 1 + RHS;
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic' directive is invalid}}
|
|
// expected-note@+2{{left operand to compound assignment expression must be of scalar type (was 'Struct')}}
|
|
#pragma acc atomic
|
|
LHS |= 1 + RHS;
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic update' directive is invalid}}
|
|
// expected-note@+2{{left operand to compound assignment expression must be of scalar type (was 'Struct')}}
|
|
#pragma acc atomic update
|
|
LHS <<= 1 + RHS;
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic' directive is invalid}}
|
|
// expected-note@+2{{left operand to compound assignment expression must be of scalar type (was 'Struct')}}
|
|
#pragma acc atomic
|
|
LHS >>= 1 + RHS;
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic update' directive is invalid}}
|
|
// expected-note@+2{{compound binary operator not supported, only +=, *=, -=, /=, &=, ^=, |=, <<=, or >>= are permitted}}
|
|
#pragma acc atomic update
|
|
LHS != 1 + RHS;
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic update' directive is invalid}}
|
|
// expected-note@+2{{compound binary operator not supported, only +=, *=, -=, /=, &=, ^=, |=, <<=, or >>= are permitted}}
|
|
#pragma acc atomic update
|
|
LHS %= 1 + RHS;
|
|
|
|
// x = x binop expr.
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic' directive is invalid}}
|
|
// expected-note@+2{{left operand to assignment expression must be of scalar type (was 'Struct')}}
|
|
#pragma acc atomic
|
|
LHS = LHS + getRValue<T>();
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic update' directive is invalid}}
|
|
// expected-note@+2{{left operand to assignment expression must be of scalar type (was 'Struct')}}
|
|
#pragma acc atomic update
|
|
LHS = LHS * getRValue<T>();
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic update' directive is invalid}}
|
|
// expected-note@+2{{left operand to assignment expression must be of scalar type (was 'Struct')}}
|
|
#pragma acc atomic update
|
|
LHS = LHS - getRValue<T>();
|
|
|
|
// x = expr binop x.
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic' directive is invalid}}
|
|
// expected-note@+2{{left operand to assignment expression must be of scalar type (was 'Struct')}}
|
|
#pragma acc atomic
|
|
LHS = getRValue<T>() + LHS;
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic update' directive is invalid}}
|
|
// expected-note@+2{{left operand to assignment expression must be of scalar type (was 'Struct')}}
|
|
#pragma acc atomic update
|
|
LHS = getRValue<T>() * LHS;
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic update' directive is invalid}}
|
|
// expected-note@+2{{left operand to assignment expression must be of scalar type (was 'Struct')}}
|
|
#pragma acc atomic update
|
|
LHS = getRValue<T>() - LHS;
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic update' directive is invalid}}
|
|
// expected-note@+2{{left operand to assignment expression must be of scalar type (was 'Struct')}}
|
|
#pragma acc atomic update
|
|
LHS = LHS + getRValue<T>();
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic update' directive is invalid}}
|
|
// expected-note@+2{{left hand side of assignment operation('LHS') must match one side of the sub-operation on the right hand side('RHS' and 'getRValue<T>()')}}
|
|
#pragma acc atomic update
|
|
LHS = RHS + getRValue<T>();
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic update' directive is invalid}}
|
|
// expected-note@+2{{left operand to assignment expression must be of scalar type (was 'Struct')}}
|
|
#pragma acc atomic update
|
|
LHS = getRValue<T>() - LHS;
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic update' directive is invalid}}
|
|
// expected-note@+2{{left hand side of assignment operation('LHS') must match one side of the sub-operation on the right hand side('getRValue<T>()' and 'RHS')}}
|
|
#pragma acc atomic update
|
|
LHS = getRValue<T>() + RHS;
|
|
}
|
|
|
|
void AtomicUpdate() {
|
|
AtomicUpdateTemplate(1, 2);
|
|
AtomicUpdateTemplate2(S1, S2); //expected-note{{in instantiation of function template specialization}}
|
|
|
|
int I, J;
|
|
|
|
#pragma acc atomic
|
|
I++;
|
|
#pragma acc atomic update
|
|
--I;
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic' directive is invalid}}
|
|
// expected-note@+2{{operand to increment expression must be of scalar type (was 'Struct')}}
|
|
#pragma acc atomic
|
|
S1++;
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic update' directive is invalid}}
|
|
// expected-note@+2{{operand to decrement expression must be of scalar type (was 'Struct')}}
|
|
#pragma acc atomic update
|
|
--S2;
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic' directive is invalid}}
|
|
// expected-note@+2{{unary operator not supported, only increment and decrement operations permitted}}
|
|
#pragma acc atomic
|
|
+I;
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic update' directive is invalid}}
|
|
// expected-note@+2{{unary operator not supported, only increment and decrement operations permitted}}
|
|
#pragma acc atomic update
|
|
-J;
|
|
|
|
#pragma acc atomic update
|
|
I ^= 1 + J;
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic update' directive is invalid}}
|
|
// expected-note@+2{{compound binary operator not supported, only +=, *=, -=, /=, &=, ^=, |=, <<=, or >>= are permitted}}
|
|
#pragma acc atomic update
|
|
I%= 1 + J;
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic update' directive is invalid}}
|
|
// expected-note@+2{{left operand to compound assignment expression must be of scalar type (was 'Struct')}}
|
|
#pragma acc atomic update
|
|
S1 ^= 1 + J;
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic update' directive is invalid}}
|
|
// expected-note@+2{{compound binary operator not supported, only +=, *=, -=, /=, &=, ^=, |=, <<=, or >>= are permitted}}
|
|
#pragma acc atomic update
|
|
S2 %= 1 + J;
|
|
|
|
#pragma acc atomic update
|
|
I = I + getRValue<int>();
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic update' directive is invalid}}
|
|
// expected-note@+2{{left hand side of assignment operation('I') must match one side of the sub-operation on the right hand side('J' and 'getRValue<int>()')}}
|
|
#pragma acc atomic update
|
|
I = J + getRValue<int>();
|
|
|
|
#pragma acc atomic update
|
|
I = getRValue<int>() - I;
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic update' directive is invalid}}
|
|
// expected-note@+2{{left hand side of assignment operation('I') must match one side of the sub-operation on the right hand side('getRValue<int>()' and 'J')}}
|
|
#pragma acc atomic update
|
|
I = getRValue<int>() + J;
|
|
}
|
|
|
|
template<typename T>
|
|
void AtomicCaptureTemplateSimple(T LHS, T RHS) {
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{expected assignment expression}}
|
|
#pragma acc atomic capture
|
|
LHS++;
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{expected assignment expression}}
|
|
#pragma acc atomic capture
|
|
--LHS;
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{expected assignment expression}}
|
|
#pragma acc atomic capture
|
|
LHS += 1 + RHS;
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{expected assignment, compound assignment, increment, or decrement expression}}
|
|
#pragma acc atomic capture
|
|
LHS = RHS;
|
|
|
|
#pragma acc atomic capture
|
|
LHS = RHS++;
|
|
|
|
#pragma acc atomic capture
|
|
LHS = RHS--;
|
|
|
|
#pragma acc atomic capture
|
|
LHS = ++RHS;
|
|
|
|
#pragma acc atomic capture
|
|
LHS = --RHS;
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{unary operator not supported, only increment and decrement operations permitted}}
|
|
#pragma acc atomic capture
|
|
LHS = +RHS;
|
|
|
|
#pragma acc atomic capture
|
|
LHS = RHS += 1 + RHS;
|
|
#pragma acc atomic capture
|
|
LHS = RHS *= 1 + RHS;
|
|
#pragma acc atomic capture
|
|
LHS = RHS -= 1 + RHS;
|
|
#pragma acc atomic capture
|
|
LHS = RHS /= 1 + RHS;
|
|
#pragma acc atomic capture
|
|
LHS = RHS &= 1 + RHS;
|
|
#pragma acc atomic capture
|
|
LHS = RHS ^= 1 + RHS;
|
|
#pragma acc atomic capture
|
|
LHS = RHS >>= 1 + RHS;
|
|
#pragma acc atomic capture
|
|
LHS = RHS |= 1 + RHS;
|
|
#pragma acc atomic capture
|
|
LHS = RHS <<= 1 + RHS;
|
|
#pragma acc atomic capture
|
|
LHS = RHS >>= 1 + RHS;
|
|
|
|
#pragma acc atomic capture
|
|
LHS = RHS ^= 1 + RHS;
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{compound binary operator not supported, only +=, *=, -=, /=, &=, ^=, |=, <<=, or >>= are permitted}}
|
|
#pragma acc atomic capture
|
|
LHS = RHS <= 1 + RHS;
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{compound binary operator not supported, only +=, *=, -=, /=, &=, ^=, |=, <<=, or >>= are permitted}}
|
|
#pragma acc atomic capture
|
|
LHS = RHS >= 1 + RHS;
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{compound binary operator not supported, only +=, *=, -=, /=, &=, ^=, |=, <<=, or >>= are permitted}}
|
|
#pragma acc atomic capture
|
|
LHS = RHS + 1;
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{compound binary operator not supported, only +=, *=, -=, /=, &=, ^=, |=, <<=, or >>= are permitted}}
|
|
#pragma acc atomic capture
|
|
LHS = RHS < 1 + RHS;
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{compound binary operator not supported, only +=, *=, -=, /=, &=, ^=, |=, <<=, or >>= are permitted}}
|
|
#pragma acc atomic capture
|
|
LHS = RHS > 1 + RHS;
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{compound binary operator not supported, only +=, *=, -=, /=, &=, ^=, |=, <<=, or >>= are permitted}}
|
|
#pragma acc atomic capture
|
|
LHS = RHS ^ 1 + RHS;
|
|
|
|
#pragma acc atomic capture
|
|
LHS = RHS = RHS + 1;
|
|
#pragma acc atomic capture
|
|
LHS = RHS = 1 + RHS;
|
|
#pragma acc atomic capture
|
|
LHS = RHS = RHS * 1;
|
|
#pragma acc atomic capture
|
|
LHS = RHS = 1 * RHS;
|
|
#pragma acc atomic capture
|
|
LHS = RHS = RHS / 1;
|
|
#pragma acc atomic capture
|
|
LHS = RHS = 1 / RHS;
|
|
#pragma acc atomic capture
|
|
LHS = RHS = RHS ^ 1;
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{binary operator not supported, only +, *, -, /, &, ^, |, <<, or >> are permitted}}
|
|
#pragma acc atomic capture
|
|
LHS = RHS = 1 % RHS;
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{binary operator not supported, only +, *, -, /, &, ^, |, <<, or >> are permitted}}
|
|
#pragma acc atomic capture
|
|
LHS = RHS = RHS < 1;
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{binary operator not supported, only +, *, -, /, &, ^, |, <<, or >> are permitted}}
|
|
#pragma acc atomic capture
|
|
LHS = RHS = 1 > RHS;
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{left hand side of assignment operation('LHS') must match one side of the sub-operation on the right hand side('RHS' and 'getRValue<T>()')}}
|
|
#pragma acc atomic capture
|
|
LHS = LHS = RHS + getRValue<T>();
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{left hand side of assignment operation('LHS') must match one side of the sub-operation on the right hand side('getRValue<T>()' and 'RHS')}}
|
|
#pragma acc atomic capture
|
|
LHS = LHS = getRValue<T>() + RHS;
|
|
}
|
|
template<typename T>
|
|
void AtomicCaptureTemplateSimple2(T LHS, T RHS) {
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{expected assignment expression}}
|
|
#pragma acc atomic capture
|
|
LHS++;
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{expected assignment expression}}
|
|
#pragma acc atomic capture
|
|
--LHS;
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{expected assignment expression}}
|
|
#pragma acc atomic capture
|
|
LHS += 1 + RHS;
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{expected assignment, compound assignment, increment, or decrement expression}}
|
|
#pragma acc atomic capture
|
|
LHS = RHS;
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{left operand to assignment expression must be of scalar type (was 'Struct')}}
|
|
#pragma acc atomic capture
|
|
LHS = RHS++;
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{left operand to assignment expression must be of scalar type (was 'Struct')}}
|
|
#pragma acc atomic capture
|
|
LHS = RHS--;
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{left operand to assignment expression must be of scalar type (was 'Struct')}}
|
|
#pragma acc atomic capture
|
|
LHS = ++RHS;
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{left operand to assignment expression must be of scalar type (was 'Struct')}}
|
|
#pragma acc atomic capture
|
|
LHS = --RHS;
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{unary operator not supported, only increment and decrement operations permitted}}
|
|
#pragma acc atomic capture
|
|
LHS = +RHS;
|
|
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{left operand to assignment expression must be of scalar type (was 'Struct')}}
|
|
#pragma acc atomic capture
|
|
LHS = RHS += 1 + RHS;
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{left operand to assignment expression must be of scalar type (was 'Struct')}}
|
|
#pragma acc atomic capture
|
|
LHS = RHS *= 1 + RHS;
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{left operand to assignment expression must be of scalar type (was 'Struct')}}
|
|
#pragma acc atomic capture
|
|
LHS = RHS -= 1 + RHS;
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{left operand to assignment expression must be of scalar type (was 'Struct')}}
|
|
#pragma acc atomic capture
|
|
LHS = RHS /= 1 + RHS;
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{left operand to assignment expression must be of scalar type (was 'Struct')}}
|
|
#pragma acc atomic capture
|
|
LHS = RHS &= 1 + RHS;
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{left operand to assignment expression must be of scalar type (was 'Struct')}}
|
|
#pragma acc atomic capture
|
|
LHS = RHS ^= 1 + RHS;
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{left operand to assignment expression must be of scalar type (was 'Struct')}}
|
|
#pragma acc atomic capture
|
|
LHS = RHS >>= 1 + RHS;
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{left operand to assignment expression must be of scalar type (was 'Struct')}}
|
|
#pragma acc atomic capture
|
|
LHS = RHS |= 1 + RHS;
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{left operand to assignment expression must be of scalar type (was 'Struct')}}
|
|
#pragma acc atomic capture
|
|
LHS = RHS <<= 1 + RHS;
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{left operand to assignment expression must be of scalar type (was 'Struct')}}
|
|
#pragma acc atomic capture
|
|
LHS = RHS >>= 1 + RHS;
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{left operand to assignment expression must be of scalar type (was 'Struct')}}
|
|
#pragma acc atomic capture
|
|
LHS = RHS ^= 1 + RHS;
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{compound binary operator not supported, only +=, *=, -=, /=, &=, ^=, |=, <<=, or >>= are permitted}}
|
|
#pragma acc atomic capture
|
|
LHS = RHS <= 1 + RHS;
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{compound binary operator not supported, only +=, *=, -=, /=, &=, ^=, |=, <<=, or >>= are permitted}}
|
|
#pragma acc atomic capture
|
|
LHS = RHS >= 1 + RHS;
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{compound binary operator not supported, only +=, *=, -=, /=, &=, ^=, |=, <<=, or >>= are permitted}}
|
|
#pragma acc atomic capture
|
|
LHS = RHS + 1;
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{compound binary operator not supported, only +=, *=, -=, /=, &=, ^=, |=, <<=, or >>= are permitted}}
|
|
#pragma acc atomic capture
|
|
LHS = RHS < 1 + RHS;
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{compound binary operator not supported, only +=, *=, -=, /=, &=, ^=, |=, <<=, or >>= are permitted}}
|
|
#pragma acc atomic capture
|
|
LHS = RHS > 1 + RHS;
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{compound binary operator not supported, only +=, *=, -=, /=, &=, ^=, |=, <<=, or >>= are permitted}}
|
|
#pragma acc atomic capture
|
|
LHS = RHS ^ 1 + RHS;
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{left operand to assignment expression must be of scalar type (was 'Struct')}}
|
|
#pragma acc atomic capture
|
|
LHS = RHS = RHS + 1;
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{left operand to assignment expression must be of scalar type (was 'Struct')}}
|
|
#pragma acc atomic capture
|
|
LHS = RHS = 1 + RHS;
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{left operand to assignment expression must be of scalar type (was 'Struct')}}
|
|
#pragma acc atomic capture
|
|
LHS = RHS = RHS * 1;
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{left operand to assignment expression must be of scalar type (was 'Struct')}}
|
|
#pragma acc atomic capture
|
|
LHS = RHS = 1 * RHS;
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{left operand to assignment expression must be of scalar type (was 'Struct')}}
|
|
#pragma acc atomic capture
|
|
LHS = RHS = RHS / 1;
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{left operand to assignment expression must be of scalar type (was 'Struct')}}
|
|
#pragma acc atomic capture
|
|
LHS = RHS = 1 / RHS;
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{left operand to assignment expression must be of scalar type (was 'Struct')}}
|
|
#pragma acc atomic capture
|
|
LHS = RHS = RHS ^ 1;
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{binary operator not supported, only +, *, -, /, &, ^, |, <<, or >> are permitted}}
|
|
#pragma acc atomic capture
|
|
LHS = RHS = 1 % RHS;
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{binary operator not supported, only +, *, -, /, &, ^, |, <<, or >> are permitted}}
|
|
#pragma acc atomic capture
|
|
LHS = RHS = RHS < 1;
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{binary operator not supported, only +, *, -, /, &, ^, |, <<, or >> are permitted}}
|
|
#pragma acc atomic capture
|
|
LHS = RHS = 1 > RHS;
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{left hand side of assignment operation('LHS') must match one side of the sub-operation on the right hand side('RHS' and 'getRValue<T>()')}}
|
|
#pragma acc atomic capture
|
|
LHS = LHS = RHS + getRValue<T>();
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{left hand side of assignment operation('LHS') must match one side of the sub-operation on the right hand side('getRValue<T>()' and 'RHS')}}
|
|
#pragma acc atomic capture
|
|
LHS = LHS = getRValue<T>() + RHS;
|
|
}
|
|
|
|
void AtomicCaptureSimple(int LHS, int RHS) {
|
|
AtomicCaptureTemplateSimple(1, 2);
|
|
AtomicCaptureTemplateSimple2(S1, S2); //expected-note{{in instantiation of function template specialization}}
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{expected assignment expression}}
|
|
#pragma acc atomic capture
|
|
LHS++;
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{expected assignment expression}}
|
|
#pragma acc atomic capture
|
|
--LHS;
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{expected assignment expression}}
|
|
#pragma acc atomic capture
|
|
LHS += 1 + RHS;
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{expected assignment, compound assignment, increment, or decrement expression}}
|
|
#pragma acc atomic capture
|
|
LHS = RHS;
|
|
|
|
#pragma acc atomic capture
|
|
LHS = RHS++;
|
|
|
|
#pragma acc atomic capture
|
|
LHS = RHS--;
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{left operand to assignment expression must be of scalar type (was 'Struct')}}
|
|
#pragma acc atomic capture
|
|
S1 = ++S2;
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{left operand to assignment expression must be of scalar type (was 'Struct')}}
|
|
#pragma acc atomic capture
|
|
S1 = --S2 ;
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{unary operator not supported, only increment and decrement operations permitted}}
|
|
#pragma acc atomic capture
|
|
LHS = +RHS;
|
|
|
|
#pragma acc atomic capture
|
|
LHS = RHS += 1 + RHS;
|
|
#pragma acc atomic capture
|
|
LHS = RHS *= 1 + RHS;
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{left operand to assignment expression must be of scalar type (was 'Struct')}}
|
|
#pragma acc atomic capture
|
|
S1 = RHS -= 1 + RHS;
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{expected assignment, compound assignment, increment, or decrement expression}}
|
|
#pragma acc atomic capture
|
|
LHS = S1 /= 1 + RHS;
|
|
#pragma acc atomic capture
|
|
LHS = RHS &= 1 + S2;
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{expected assignment, compound assignment, increment, or decrement expression}}
|
|
#pragma acc atomic capture
|
|
LHS = S1^= 1 + S2;
|
|
|
|
#pragma acc atomic capture
|
|
LHS = RHS ^= 1 + RHS;
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{compound binary operator not supported, only +=, *=, -=, /=, &=, ^=, |=, <<=, or >>= are permitted}}
|
|
#pragma acc atomic capture
|
|
LHS = RHS <= 1 + RHS;
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{left operand to assignment expression must be of scalar type (was 'Struct')}}
|
|
#pragma acc atomic capture
|
|
S1 = RHS ^= 1 + RHS;
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{compound binary operator not supported, only +=, *=, -=, /=, &=, ^=, |=, <<=, or >>= are permitted}}
|
|
#pragma acc atomic capture
|
|
LHS = S1 <= 1 + RHS;
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{compound binary operator not supported, only +=, *=, -=, /=, &=, ^=, |=, <<=, or >>= are permitted}}
|
|
#pragma acc atomic capture
|
|
LHS = RHS <= 1 + S2;
|
|
|
|
#pragma acc atomic capture
|
|
LHS = RHS = RHS + 1;
|
|
#pragma acc atomic capture
|
|
LHS = RHS = 1 + RHS;
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{left operand to assignment expression must be of scalar type (was 'Struct')}}
|
|
#pragma acc atomic capture
|
|
S1 = RHS = RHS * 1;
|
|
// A little weird, because this contains a 'operator int' call here rather
|
|
// than a conversion, so the diagnostic could be better.
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{expected assignment, compound assignment, increment, or decrement expression}}
|
|
#pragma acc atomic capture
|
|
LHS = S2 = 1 * S2;
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{binary operator not supported, only +, *, -, /, &, ^, |, <<, or >> are permitted}}
|
|
#pragma acc atomic capture
|
|
LHS = RHS = RHS < 1;
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{binary operator not supported, only +, *, -, /, &, ^, |, <<, or >> are permitted}}
|
|
#pragma acc atomic capture
|
|
LHS = RHS = 1 > RHS;
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{left operand to assignment expression must be of scalar type (was 'Struct')}}
|
|
#pragma acc atomic capture
|
|
S1 = RHS = RHS < 1;
|
|
|
|
// A little weird, because this contains a 'operator int' call here rather
|
|
// than a conversion, so the diagnostic could be better.
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{expected assignment, compound assignment, increment, or decrement expression}}
|
|
#pragma acc atomic capture
|
|
LHS = S1 = 1 > S1;
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{left hand side of assignment operation('LHS') must match one side of the sub-operation on the right hand side('RHS' and 'getRValue<int>()')}}
|
|
#pragma acc atomic capture
|
|
LHS = LHS = RHS + getRValue<int>();
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{left hand side of assignment operation('LHS') must match one side of the sub-operation on the right hand side('getRValue<int>()' and 'RHS')}}
|
|
#pragma acc atomic capture
|
|
LHS = LHS = getRValue<int>() + RHS;
|
|
}
|
|
|
|
template<typename T>
|
|
void AtomicCaptureTemplateCompound(T LHS, T RHS) {
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{expected assignment, compound assignment, increment, or decrement expression}}
|
|
#pragma acc atomic capture
|
|
{
|
|
}
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+4{{expected assignment, compound assignment, increment, or decrement expression}}
|
|
#pragma acc atomic capture
|
|
{
|
|
LHS = RHS;
|
|
}
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+3{{'atomic capture' with a compound statement only supports two statements}}
|
|
#pragma acc atomic capture
|
|
{
|
|
LHS = RHS; RHS += 1; LHS=RHS;
|
|
}
|
|
|
|
|
|
#pragma acc atomic capture
|
|
{
|
|
LHS++;
|
|
RHS = LHS;
|
|
}
|
|
|
|
#pragma acc atomic capture
|
|
{
|
|
++LHS;
|
|
RHS = LHS;
|
|
}
|
|
|
|
#pragma acc atomic capture
|
|
{
|
|
--LHS;
|
|
RHS = LHS;
|
|
}
|
|
|
|
|
|
#pragma acc atomic capture
|
|
{
|
|
LHS--;
|
|
// expected-error@-3{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{sub-expression on right hand side of assignment('RHS') must match sub-expression used in unary expression('LHS') from the first statement}}
|
|
LHS = RHS;
|
|
}
|
|
|
|
#pragma acc atomic capture
|
|
{
|
|
// expected-error@-2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{unary operator not supported, only increment and decrement operations permitted}}
|
|
-LHS;
|
|
RHS = LHS;
|
|
}
|
|
|
|
#pragma acc atomic capture
|
|
{
|
|
--LHS;
|
|
// expected-error@-3{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{expected assignment expression}}
|
|
RHS += LHS;
|
|
}
|
|
|
|
// { x binop = expr; v = x; }
|
|
#pragma acc atomic capture
|
|
{
|
|
LHS += 1;
|
|
RHS = LHS;
|
|
}
|
|
#pragma acc atomic capture
|
|
{
|
|
LHS *= 1;
|
|
// expected-error@-3{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{sub-expression on right hand side of assignment('RHS') must match sub-expression used on left hand side of compound assignment('LHS') from the first statement}}
|
|
LHS = RHS;
|
|
}
|
|
#pragma acc atomic capture
|
|
{
|
|
LHS /= 1;
|
|
// expected-error@-3{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{expected assignment expression}}
|
|
RHS += LHS;
|
|
}
|
|
|
|
// { x = x binop expr; v = x; }
|
|
#pragma acc atomic capture
|
|
{
|
|
LHS = LHS + 1;
|
|
RHS = LHS;
|
|
}
|
|
|
|
#pragma acc atomic capture
|
|
{
|
|
// expected-error@-2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{left hand side of assignment operation('LHS') must match one side of the sub-operation on the right hand side('RHS' and '1')}}
|
|
LHS = RHS - 1;
|
|
RHS = LHS;
|
|
}
|
|
#pragma acc atomic capture
|
|
{
|
|
LHS = LHS * 1;
|
|
// expected-error@-3{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{sub-expression on right hand side of assignment('RHS') must match sub-expression used on left hand side of assignment('LHS') from the first statement}}
|
|
RHS = RHS;
|
|
}
|
|
#pragma acc atomic capture
|
|
{
|
|
LHS = LHS / 1;
|
|
// expected-error@-3{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{expected assignment expression}}
|
|
RHS += LHS;
|
|
}
|
|
|
|
// { x = expr binop x; v = x; }
|
|
#pragma acc atomic capture
|
|
{
|
|
LHS = 1 ^ LHS;
|
|
RHS = LHS;
|
|
}
|
|
|
|
#pragma acc atomic capture
|
|
{
|
|
// expected-error@-2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{left hand side of assignment operation('LHS') must match one side of the sub-operation on the right hand side('1' and 'RHS')}}
|
|
LHS = 1 & RHS;
|
|
RHS = LHS;
|
|
}
|
|
#pragma acc atomic capture
|
|
{
|
|
LHS = LHS | 1;
|
|
// expected-error@-3{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{sub-expression on right hand side of assignment('RHS') must match sub-expression used on left hand side of assignment('LHS') from the first statement}}
|
|
RHS = RHS;
|
|
}
|
|
#pragma acc atomic capture
|
|
{
|
|
LHS = LHS << 1;
|
|
// expected-error@-3{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{expected assignment expression}}
|
|
RHS += LHS;
|
|
}
|
|
|
|
// { v = x; x binop = expr; }
|
|
#pragma acc atomic capture
|
|
{
|
|
LHS = RHS;
|
|
RHS += 1;
|
|
}
|
|
|
|
// { v = x; x = x binop expr; }
|
|
#pragma acc atomic capture
|
|
{
|
|
LHS = RHS;
|
|
RHS = RHS / 1;
|
|
}
|
|
#pragma acc atomic capture
|
|
{
|
|
LHS = RHS;
|
|
// expected-error@-3{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{left hand side of assignment operation('RHS') must match one side of the sub-operation on the right hand side('LHS' and '1')}}
|
|
RHS = LHS ^ 1;
|
|
}
|
|
#pragma acc atomic capture
|
|
{
|
|
LHS = RHS;
|
|
// expected-error@-3{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{left hand side of assignment operation('LHS') must match one side of the sub-operation on the right hand side('RHS' and '1')}}
|
|
LHS = RHS << 1;
|
|
}
|
|
// { v = x; x = expr binop x; }
|
|
#pragma acc atomic capture
|
|
{
|
|
LHS = RHS;
|
|
RHS = 1 / RHS;
|
|
}
|
|
#pragma acc atomic capture
|
|
{
|
|
LHS = RHS;
|
|
// expected-error@-3{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{left hand side of assignment operation('RHS') must match one side of the sub-operation on the right hand side('1' and 'LHS')}}
|
|
RHS = 1 ^ LHS;
|
|
}
|
|
#pragma acc atomic capture
|
|
{
|
|
LHS = RHS;
|
|
// expected-error@-3{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{left hand side of assignment operation('LHS') must match one side of the sub-operation on the right hand side('1' and 'RHS')}}
|
|
LHS = 1 << RHS;
|
|
}
|
|
|
|
// { v = x; x = expr; }
|
|
#pragma acc atomic capture
|
|
{
|
|
LHS = RHS;
|
|
RHS = 1;
|
|
}
|
|
#pragma acc atomic capture
|
|
{
|
|
LHS = RHS;
|
|
// expected-error@-3{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{sub-expression on left hand side of assignment('LHS') must match sub-expression used on right hand side of assignment('RHS') from the first statement}}
|
|
LHS = 1;
|
|
}
|
|
|
|
// { v = x; x++; }
|
|
// { v = x; ++x; }
|
|
// { v = x; x--; }
|
|
// { v = x; --x; }
|
|
#pragma acc atomic capture
|
|
{
|
|
LHS = RHS;
|
|
RHS++;
|
|
}
|
|
#pragma acc atomic capture
|
|
{
|
|
LHS = RHS;
|
|
RHS--;
|
|
}
|
|
#pragma acc atomic capture
|
|
{
|
|
LHS = RHS;
|
|
++RHS;
|
|
}
|
|
#pragma acc atomic capture
|
|
{
|
|
LHS = RHS;
|
|
--RHS;
|
|
}
|
|
#pragma acc atomic capture
|
|
{
|
|
LHS = RHS;
|
|
// expected-error@-3{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{unary operator not supported, only increment and decrement operations permitted}}
|
|
-RHS;
|
|
}
|
|
#pragma acc atomic capture
|
|
{
|
|
LHS = RHS;
|
|
// expected-error@-3{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{sub-expression in unary expression('LHS') must match sub-expression used on right hand side of assignment('RHS') from the first statement}}
|
|
LHS++;
|
|
}
|
|
}
|
|
|
|
template<typename T>
|
|
void AtomicCaptureTemplateCompound2(T LHS, T RHS) {
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{expected assignment, compound assignment, increment, or decrement expression}}
|
|
#pragma acc atomic capture
|
|
{
|
|
}
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+4{{expected assignment, compound assignment, increment, or decrement expression}}
|
|
#pragma acc atomic capture
|
|
{
|
|
LHS = RHS;
|
|
}
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+3{{'atomic capture' with a compound statement only supports two statements}}
|
|
#pragma acc atomic capture
|
|
{
|
|
LHS = RHS; RHS += 1; LHS=RHS;
|
|
}
|
|
|
|
|
|
#pragma acc atomic capture
|
|
{
|
|
// expected-error@-2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{operand to increment expression must be of scalar type (was 'Struct')}}
|
|
LHS++;
|
|
RHS = LHS;
|
|
}
|
|
|
|
#pragma acc atomic capture
|
|
{
|
|
// expected-error@-2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{operand to increment expression must be of scalar type (was 'Struct')}}
|
|
++LHS;
|
|
RHS = LHS;
|
|
}
|
|
|
|
#pragma acc atomic capture
|
|
{
|
|
// expected-error@-2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{operand to decrement expression must be of scalar type (was 'Struct')}}
|
|
--LHS;
|
|
RHS = LHS;
|
|
}
|
|
|
|
|
|
#pragma acc atomic capture
|
|
{
|
|
LHS--;
|
|
// expected-error@-3{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{sub-expression on right hand side of assignment('RHS') must match sub-expression used in unary expression('LHS') from the first statement}}
|
|
LHS = RHS;
|
|
}
|
|
|
|
#pragma acc atomic capture
|
|
{
|
|
// expected-error@-2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{unary operator not supported, only increment and decrement operations permitted}}
|
|
-LHS;
|
|
RHS = LHS;
|
|
}
|
|
|
|
#pragma acc atomic capture
|
|
{
|
|
--LHS;
|
|
// expected-error@-3{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{expected assignment expression}}
|
|
RHS += LHS;
|
|
}
|
|
|
|
// { x binop = expr; v = x; }
|
|
#pragma acc atomic capture
|
|
{
|
|
// expected-error@-2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{left operand to compound assignment expression must be of scalar type (was 'Struct')}}
|
|
LHS += 1;
|
|
RHS = LHS;
|
|
}
|
|
#pragma acc atomic capture
|
|
{
|
|
LHS *= 1;
|
|
// expected-error@-3{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{sub-expression on right hand side of assignment('RHS') must match sub-expression used on left hand side of compound assignment('LHS') from the first statement}}
|
|
LHS = RHS;
|
|
}
|
|
#pragma acc atomic capture
|
|
{
|
|
LHS /= 1;
|
|
// expected-error@-3{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{expected assignment expression}}
|
|
RHS += LHS;
|
|
}
|
|
|
|
// { x = x binop expr; v = x; }
|
|
#pragma acc atomic capture
|
|
{
|
|
// expected-error@-2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{left operand to assignment expression must be of scalar type (was 'Struct')}}
|
|
LHS = LHS + 1;
|
|
RHS = LHS;
|
|
}
|
|
|
|
#pragma acc atomic capture
|
|
{
|
|
// expected-error@-2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{left hand side of assignment operation('LHS') must match one side of the sub-operation on the right hand side('RHS' and '1')}}
|
|
LHS = RHS - 1;
|
|
RHS = LHS;
|
|
}
|
|
#pragma acc atomic capture
|
|
{
|
|
LHS = LHS * 1;
|
|
// expected-error@-3{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{sub-expression on right hand side of assignment('RHS') must match sub-expression used on left hand side of assignment('LHS') from the first statement}}
|
|
RHS = RHS;
|
|
}
|
|
#pragma acc atomic capture
|
|
{
|
|
LHS = LHS / 1;
|
|
// expected-error@-3{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{expected assignment expression}}
|
|
RHS += LHS;
|
|
}
|
|
|
|
// { x = expr binop x; v = x; }
|
|
#pragma acc atomic capture
|
|
{
|
|
// expected-error@-2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{left operand to assignment expression must be of scalar type (was 'Struct')}}
|
|
LHS = 1 ^ LHS;
|
|
RHS = LHS;
|
|
}
|
|
|
|
#pragma acc atomic capture
|
|
{
|
|
// expected-error@-2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{left hand side of assignment operation('LHS') must match one side of the sub-operation on the right hand side('1' and 'RHS')}}
|
|
LHS = 1 & RHS;
|
|
RHS = LHS;
|
|
}
|
|
#pragma acc atomic capture
|
|
{
|
|
LHS = LHS | 1;
|
|
// expected-error@-3{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{sub-expression on right hand side of assignment('RHS') must match sub-expression used on left hand side of assignment('LHS') from the first statement}}
|
|
RHS = RHS;
|
|
}
|
|
#pragma acc atomic capture
|
|
{
|
|
LHS = LHS << 1;
|
|
// expected-error@-3{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{expected assignment expression}}
|
|
RHS += LHS;
|
|
}
|
|
|
|
// { v = x; x binop = expr; }
|
|
#pragma acc atomic capture
|
|
{
|
|
// expected-error@-2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{left operand to assignment expression must be of scalar type (was 'Struct')}}
|
|
LHS = RHS;
|
|
RHS += 1;
|
|
}
|
|
|
|
// { v = x; x = x binop expr; }
|
|
#pragma acc atomic capture
|
|
{
|
|
// expected-error@-2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{left operand to assignment expression must be of scalar type (was 'Struct')}}
|
|
LHS = RHS;
|
|
RHS = RHS / 1;
|
|
}
|
|
#pragma acc atomic capture
|
|
{
|
|
LHS = RHS;
|
|
// expected-error@-3{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{left hand side of assignment operation('RHS') must match one side of the sub-operation on the right hand side('LHS' and '1')}}
|
|
RHS = LHS ^ 1;
|
|
}
|
|
#pragma acc atomic capture
|
|
{
|
|
LHS = RHS;
|
|
// expected-error@-3{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{left hand side of assignment operation('LHS') must match one side of the sub-operation on the right hand side('RHS' and '1')}}
|
|
LHS = RHS << 1;
|
|
}
|
|
// { v = x; x = expr binop x; }
|
|
#pragma acc atomic capture
|
|
{
|
|
// expected-error@-2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{left operand to assignment expression must be of scalar type (was 'Struct')}}
|
|
LHS = RHS;
|
|
RHS = 1 / RHS;
|
|
}
|
|
#pragma acc atomic capture
|
|
{
|
|
LHS = RHS;
|
|
// expected-error@-3{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{left hand side of assignment operation('RHS') must match one side of the sub-operation on the right hand side('1' and 'LHS')}}
|
|
RHS = 1 ^ LHS;
|
|
}
|
|
#pragma acc atomic capture
|
|
{
|
|
LHS = RHS;
|
|
// expected-error@-3{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{left hand side of assignment operation('LHS') must match one side of the sub-operation on the right hand side('1' and 'RHS')}}
|
|
LHS = 1 << RHS;
|
|
}
|
|
|
|
// { v = x; x = expr; }
|
|
#pragma acc atomic capture
|
|
{
|
|
// expected-error@-2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{left operand to assignment expression must be of scalar type (was 'Struct')}}
|
|
LHS = RHS;
|
|
RHS = 1;
|
|
}
|
|
#pragma acc atomic capture
|
|
{
|
|
LHS = RHS;
|
|
// expected-error@-3{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{sub-expression on left hand side of assignment('LHS') must match sub-expression used on right hand side of assignment('RHS') from the first statement}}
|
|
LHS = 1;
|
|
}
|
|
|
|
// { v = x; x++; }
|
|
// { v = x; ++x; }
|
|
// { v = x; x--; }
|
|
// { v = x; --x; }
|
|
#pragma acc atomic capture
|
|
{
|
|
// expected-error@-2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{left operand to assignment expression must be of scalar type (was 'Struct')}}
|
|
LHS = RHS;
|
|
RHS++;
|
|
}
|
|
#pragma acc atomic capture
|
|
{
|
|
// expected-error@-2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{left operand to assignment expression must be of scalar type (was 'Struct')}}
|
|
LHS = RHS;
|
|
RHS--;
|
|
}
|
|
#pragma acc atomic capture
|
|
{
|
|
// expected-error@-2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{left operand to assignment expression must be of scalar type (was 'Struct')}}
|
|
LHS = RHS;
|
|
++RHS;
|
|
}
|
|
#pragma acc atomic capture
|
|
{
|
|
// expected-error@-2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{left operand to assignment expression must be of scalar type (was 'Struct')}}
|
|
LHS = RHS;
|
|
--RHS;
|
|
}
|
|
#pragma acc atomic capture
|
|
{
|
|
LHS = RHS;
|
|
// expected-error@-3{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{unary operator not supported, only increment and decrement operations permitted}}
|
|
-RHS;
|
|
}
|
|
#pragma acc atomic capture
|
|
{
|
|
LHS = RHS;
|
|
// expected-error@-3{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{sub-expression in unary expression('LHS') must match sub-expression used on right hand side of assignment('RHS') from the first statement}}
|
|
LHS++;
|
|
}
|
|
}
|
|
void AtomicCaptureCompound(int LHS, int RHS) {
|
|
AtomicCaptureTemplateCompound(1, 2);
|
|
AtomicCaptureTemplateCompound2(S1, S2); //expected-note{{in instantiation of function template specialization}}
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+2{{expected assignment, compound assignment, increment, or decrement expression}}
|
|
#pragma acc atomic capture
|
|
{
|
|
}
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+4{{expected assignment, compound assignment, increment, or decrement expression}}
|
|
#pragma acc atomic capture
|
|
{
|
|
LHS = RHS;
|
|
}
|
|
|
|
// expected-error@+2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+3{{'atomic capture' with a compound statement only supports two statements}}
|
|
#pragma acc atomic capture
|
|
{
|
|
LHS = RHS; RHS += 1; LHS=RHS;
|
|
}
|
|
|
|
|
|
#pragma acc atomic capture
|
|
{
|
|
LHS++;
|
|
RHS = LHS;
|
|
}
|
|
#pragma acc atomic capture
|
|
{
|
|
// expected-error@-2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{operand to increment expression must be of scalar type (was 'Struct')}}
|
|
S1++;
|
|
S2= S1;
|
|
}
|
|
|
|
#pragma acc atomic capture
|
|
{
|
|
++LHS;
|
|
RHS = LHS;
|
|
}
|
|
|
|
#pragma acc atomic capture
|
|
{
|
|
--LHS;
|
|
RHS = LHS;
|
|
}
|
|
|
|
|
|
#pragma acc atomic capture
|
|
{
|
|
LHS--;
|
|
// expected-error@-3{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{sub-expression on right hand side of assignment('RHS') must match sub-expression used in unary expression('LHS') from the first statement}}
|
|
LHS = RHS;
|
|
}
|
|
|
|
#pragma acc atomic capture
|
|
{
|
|
// expected-error@-2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{unary operator not supported, only increment and decrement operations permitted}}
|
|
-LHS;
|
|
RHS = LHS;
|
|
}
|
|
|
|
#pragma acc atomic capture
|
|
{
|
|
--LHS;
|
|
// expected-error@-3{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{expected assignment expression}}
|
|
RHS += LHS;
|
|
}
|
|
|
|
// { x binop = expr; v = x; }
|
|
#pragma acc atomic capture
|
|
{
|
|
LHS += 1;
|
|
RHS = LHS;
|
|
}
|
|
#pragma acc atomic capture
|
|
{
|
|
// expected-error@-2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{left operand to compound assignment expression must be of scalar type (was 'Struct')}}
|
|
S1 += 1;
|
|
S2= S1;
|
|
}
|
|
#pragma acc atomic capture
|
|
{
|
|
LHS *= 1;
|
|
// expected-error@-3{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{sub-expression on right hand side of assignment('RHS') must match sub-expression used on left hand side of compound assignment('LHS') from the first statement}}
|
|
LHS = RHS;
|
|
}
|
|
#pragma acc atomic capture
|
|
{
|
|
LHS /= 1;
|
|
// expected-error@-3{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{expected assignment expression}}
|
|
RHS += LHS;
|
|
}
|
|
|
|
// { x = x binop expr; v = x; }
|
|
#pragma acc atomic capture
|
|
{
|
|
LHS = LHS + 1;
|
|
RHS = LHS;
|
|
}
|
|
#pragma acc atomic capture
|
|
{
|
|
// expected-error@-2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{left operand to assignment expression must be of scalar type (was 'Struct')}}
|
|
S1 = S1 + 1;
|
|
S2= S1;
|
|
}
|
|
|
|
#pragma acc atomic capture
|
|
{
|
|
// expected-error@-2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{left hand side of assignment operation('LHS') must match one side of the sub-operation on the right hand side('RHS' and '1')}}
|
|
LHS = RHS - 1;
|
|
RHS = LHS;
|
|
}
|
|
#pragma acc atomic capture
|
|
{
|
|
LHS = LHS * 1;
|
|
// expected-error@-3{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{sub-expression on right hand side of assignment('RHS') must match sub-expression used on left hand side of assignment('LHS') from the first statement}}
|
|
RHS = RHS;
|
|
}
|
|
#pragma acc atomic capture
|
|
{
|
|
LHS = LHS / 1;
|
|
// expected-error@-3{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{expected assignment expression}}
|
|
RHS += LHS;
|
|
}
|
|
|
|
// { x = expr binop x; v = x; }
|
|
#pragma acc atomic capture
|
|
{
|
|
LHS = 1 ^ LHS;
|
|
RHS = LHS;
|
|
}
|
|
#pragma acc atomic capture
|
|
{
|
|
// expected-error@-2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{left operand to assignment expression must be of scalar type (was 'Struct')}}
|
|
S1 = 1 ^ S1;
|
|
S2 = S1;
|
|
}
|
|
|
|
#pragma acc atomic capture
|
|
{
|
|
// expected-error@-2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{left hand side of assignment operation('LHS') must match one side of the sub-operation on the right hand side('1' and 'RHS')}}
|
|
LHS = 1 & RHS;
|
|
RHS = LHS;
|
|
}
|
|
#pragma acc atomic capture
|
|
{
|
|
LHS = LHS | 1;
|
|
// expected-error@-3{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{sub-expression on right hand side of assignment('RHS') must match sub-expression used on left hand side of assignment('LHS') from the first statement}}
|
|
RHS = RHS;
|
|
}
|
|
#pragma acc atomic capture
|
|
{
|
|
LHS = LHS << 1;
|
|
// expected-error@-3{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{expected assignment expression}}
|
|
RHS += LHS;
|
|
}
|
|
|
|
// { v = x; x binop = expr; }
|
|
#pragma acc atomic capture
|
|
{
|
|
LHS = RHS;
|
|
RHS += 1;
|
|
}
|
|
|
|
#pragma acc atomic capture
|
|
{
|
|
// expected-error@-2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{left operand to assignment expression must be of scalar type (was 'Struct')}}
|
|
S1 = S2;
|
|
S2 += 1;
|
|
}
|
|
|
|
// { v = x; x = x binop expr; }
|
|
#pragma acc atomic capture
|
|
{
|
|
LHS = RHS;
|
|
RHS = RHS / 1;
|
|
}
|
|
#pragma acc atomic capture
|
|
{
|
|
LHS = RHS;
|
|
// expected-error@-3{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{left hand side of assignment operation('RHS') must match one side of the sub-operation on the right hand side('LHS' and '1')}}
|
|
RHS = LHS ^ 1;
|
|
}
|
|
#pragma acc atomic capture
|
|
{
|
|
LHS = RHS;
|
|
// expected-error@-3{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{left hand side of assignment operation('LHS') must match one side of the sub-operation on the right hand side('RHS' and '1')}}
|
|
LHS = RHS << 1;
|
|
}
|
|
// { v = x; x = expr binop x; }
|
|
#pragma acc atomic capture
|
|
{
|
|
LHS = RHS;
|
|
RHS = 1 / RHS;
|
|
}
|
|
#pragma acc atomic capture
|
|
{
|
|
LHS = RHS;
|
|
// expected-error@-3{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{left hand side of assignment operation('RHS') must match one side of the sub-operation on the right hand side('1' and 'LHS')}}
|
|
RHS = 1 ^ LHS;
|
|
}
|
|
#pragma acc atomic capture
|
|
{
|
|
LHS = RHS;
|
|
// expected-error@-3{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{left hand side of assignment operation('LHS') must match one side of the sub-operation on the right hand side('1' and 'RHS')}}
|
|
LHS = 1 << RHS;
|
|
}
|
|
|
|
// { v = x; x = expr; }
|
|
#pragma acc atomic capture
|
|
{
|
|
LHS = RHS;
|
|
RHS = 1;
|
|
}
|
|
#pragma acc atomic capture
|
|
{
|
|
LHS = RHS;
|
|
// expected-error@-3{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{sub-expression on left hand side of assignment('LHS') must match sub-expression used on right hand side of assignment('RHS') from the first statement}}
|
|
LHS = 1;
|
|
}
|
|
|
|
// { v = x; x++; }
|
|
// { v = x; ++x; }
|
|
// { v = x; x--; }
|
|
// { v = x; --x; }
|
|
#pragma acc atomic capture
|
|
{
|
|
LHS = RHS;
|
|
RHS++;
|
|
}
|
|
#pragma acc atomic capture
|
|
{
|
|
LHS = RHS;
|
|
RHS--;
|
|
}
|
|
#pragma acc atomic capture
|
|
{
|
|
LHS = RHS;
|
|
++RHS;
|
|
}
|
|
#pragma acc atomic capture
|
|
{
|
|
LHS = RHS;
|
|
--RHS;
|
|
}
|
|
#pragma acc atomic capture
|
|
{
|
|
// expected-error@-2{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{left operand to assignment expression must be of scalar type (was 'Struct')}}
|
|
S1= S2;
|
|
--S2;
|
|
}
|
|
#pragma acc atomic capture
|
|
{
|
|
LHS = RHS;
|
|
// expected-error@-3{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{unary operator not supported, only increment and decrement operations permitted}}
|
|
-RHS;
|
|
}
|
|
#pragma acc atomic capture
|
|
{
|
|
LHS = RHS;
|
|
// expected-error@-3{{statement associated with OpenACC 'atomic capture' directive is invalid}}
|
|
// expected-note@+1{{sub-expression in unary expression('LHS') must match sub-expression used on right hand side of assignment('RHS') from the first statement}}
|
|
LHS++;
|
|
}
|
|
|
|
// Example from UDel test suite, which wasn't working because of irrelevant
|
|
// parens, make sure we work with these. This should not diagnose.
|
|
typedef double real_t;
|
|
int * distribution;
|
|
real_t *a;
|
|
real_t *b;
|
|
int *c;
|
|
for (int x = 0; x < 5; ++x) {
|
|
#pragma acc atomic capture
|
|
{
|
|
c[x] = distribution[(int) (a[x]*b[x]/10)];
|
|
(distribution[(int)(a[x]*b[x]/10)])--;
|
|
}
|
|
}
|
|
|
|
}
|