30cfe2b2ac
This is a pretty simple clause, it takes an 'async-argument', which
effectively needs to be just parsed as an 'int' argument, since it can
be an arbitrarly integer at runtime (and negative values are legal for
implementation defined values).
This patch also cleans up the async-argument parsing, so 'wait' got some
minor quality-of-life improvements for parsing (both clause and
construct).
136 lines
3.9 KiB
C++
136 lines
3.9 KiB
C++
// RUN: %clang_cc1 %s -fopenacc -verify
|
|
|
|
struct NotConvertible{} NC;
|
|
struct Incomplete *SomeIncomplete; // #INCOMPLETE
|
|
enum E{} SomeE;
|
|
enum class E2{} SomeE2;
|
|
|
|
struct CorrectConvert {
|
|
operator int();
|
|
} Convert;
|
|
|
|
struct ExplicitConvertOnly {
|
|
explicit operator int() const; // #EXPL_CONV
|
|
} Explicit;
|
|
|
|
struct AmbiguousConvert{
|
|
operator int(); // #AMBIG_INT
|
|
operator short(); // #AMBIG_SHORT
|
|
operator float();
|
|
} Ambiguous;
|
|
|
|
void Test() {
|
|
#pragma acc parallel async
|
|
while(1);
|
|
#pragma acc parallel async(1)
|
|
while(1);
|
|
#pragma acc kernels async(-51)
|
|
while(1);
|
|
|
|
// expected-error@+1{{OpenACC clause 'async' requires expression of integer type ('struct NotConvertible' invalid}}
|
|
#pragma acc parallel async(NC)
|
|
while(1);
|
|
|
|
// expected-error@+2{{OpenACC integer expression has incomplete class type 'struct Incomplete'}}
|
|
// expected-note@#INCOMPLETE{{forward declaration of 'Incomplete'}}
|
|
#pragma acc kernels async(*SomeIncomplete)
|
|
while(1);
|
|
|
|
#pragma acc parallel async(SomeE)
|
|
while(1);
|
|
|
|
// expected-error@+1{{OpenACC clause 'async' requires expression of integer type ('enum E2' invalid}}
|
|
#pragma acc kernels async(SomeE2)
|
|
while(1);
|
|
|
|
#pragma acc parallel async(Convert)
|
|
while(1);
|
|
|
|
// expected-error@+2{{OpenACC integer expression type 'struct ExplicitConvertOnly' requires explicit conversion to 'int'}}
|
|
// expected-note@#EXPL_CONV{{conversion to integral type 'int'}}
|
|
#pragma acc kernels async(Explicit)
|
|
while(1);
|
|
|
|
// expected-error@+3{{multiple conversions from expression type 'struct AmbiguousConvert' to an integral type}}
|
|
// expected-note@#AMBIG_INT{{conversion to integral type 'int'}}
|
|
// expected-note@#AMBIG_SHORT{{conversion to integral type 'short'}}
|
|
#pragma acc parallel async(Ambiguous)
|
|
while(1);
|
|
}
|
|
|
|
struct HasInt {
|
|
using IntTy = int;
|
|
using ShortTy = short;
|
|
static constexpr int value = 1;
|
|
static constexpr AmbiguousConvert ACValue;
|
|
static constexpr ExplicitConvertOnly EXValue;
|
|
|
|
operator char();
|
|
};
|
|
|
|
template<typename T>
|
|
void TestInst() {
|
|
|
|
// expected-error@+1{{no member named 'Invalid' in 'HasInt'}}
|
|
#pragma acc parallel async(HasInt::Invalid)
|
|
while (1);
|
|
|
|
// expected-error@+2{{no member named 'Invalid' in 'HasInt'}}
|
|
// expected-note@#INST{{in instantiation of function template specialization 'TestInst<HasInt>' requested here}}
|
|
#pragma acc kernels async(T::Invalid)
|
|
while (1);
|
|
|
|
// expected-error@+3{{multiple conversions from expression type 'const AmbiguousConvert' to an integral type}}
|
|
// expected-note@#AMBIG_INT{{conversion to integral type 'int'}}
|
|
// expected-note@#AMBIG_SHORT{{conversion to integral type 'short'}}
|
|
#pragma acc parallel async(HasInt::ACValue)
|
|
while (1);
|
|
|
|
// expected-error@+3{{multiple conversions from expression type 'const AmbiguousConvert' to an integral type}}
|
|
// expected-note@#AMBIG_INT{{conversion to integral type 'int'}}
|
|
// expected-note@#AMBIG_SHORT{{conversion to integral type 'short'}}
|
|
#pragma acc kernels async(T::ACValue)
|
|
while (1);
|
|
|
|
// expected-error@+2{{OpenACC integer expression type 'const ExplicitConvertOnly' requires explicit conversion to 'int'}}
|
|
// expected-note@#EXPL_CONV{{conversion to integral type 'int'}}
|
|
#pragma acc parallel async(HasInt::EXValue)
|
|
while (1);
|
|
|
|
// expected-error@+2{{OpenACC integer expression type 'const ExplicitConvertOnly' requires explicit conversion to 'int'}}
|
|
// expected-note@#EXPL_CONV{{conversion to integral type 'int'}}
|
|
#pragma acc kernels async(T::EXValue)
|
|
while (1);
|
|
|
|
#pragma acc parallel async(HasInt::value)
|
|
while (1);
|
|
|
|
#pragma acc kernels async(T::value)
|
|
while (1);
|
|
|
|
#pragma acc parallel async(HasInt::IntTy{})
|
|
while (1);
|
|
|
|
#pragma acc kernels async(typename T::ShortTy{})
|
|
while (1);
|
|
|
|
#pragma acc parallel async(HasInt::IntTy{})
|
|
while (1);
|
|
|
|
#pragma acc kernels async(typename T::ShortTy{})
|
|
while (1);
|
|
|
|
HasInt HI{};
|
|
T MyT{};
|
|
|
|
#pragma acc parallel async(HI)
|
|
while (1);
|
|
|
|
#pragma acc kernels async(MyT)
|
|
while (1);
|
|
}
|
|
|
|
void Inst() {
|
|
TestInst<HasInt>(); // #INST
|
|
}
|