1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
|
// 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 requires explicit conversion from 'struct ExplicitConvertOnly' 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 requires explicit conversion from 'const ExplicitConvertOnly' 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 requires explicit conversion from 'const ExplicitConvertOnly' 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
}
|
