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
136
137
|
// 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 loop async
for (int i = 5; i < 10; ++i);
#pragma acc parallel loop async(1)
for (int i = 5; i < 10; ++i);
#pragma acc kernels loop async(-51)
for (int i = 5; i < 10; ++i);
#pragma acc serial loop async(2)
for (int i = 5; i < 10; ++i);
// expected-error@+1{{OpenACC clause 'async' requires expression of integer type ('struct NotConvertible' invalid}}
#pragma acc parallel loop async(NC)
for (int i = 5; i < 10; ++i);
// expected-error@+2{{OpenACC integer expression has incomplete class type 'struct Incomplete'}}
// expected-note@#INCOMPLETE{{forward declaration of 'Incomplete'}}
#pragma acc kernels loop async(*SomeIncomplete)
for (int i = 5; i < 10; ++i);
#pragma acc parallel loop async(SomeE)
for (int i = 5; i < 10; ++i);
// expected-error@+1{{OpenACC clause 'async' requires expression of integer type ('enum E2' invalid}}
#pragma acc kernels loop async(SomeE2)
for (int i = 5; i < 10; ++i);
#pragma acc parallel loop async(Convert)
for (int i = 5; i < 10; ++i);
// 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 loop async(Explicit)
for (int i = 5; i < 10; ++i);
// 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 loop async(Ambiguous)
for (int i = 5; i < 10; ++i);
}
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 loop async(HasInt::Invalid)
for (int i = 5; i < 10; ++i);
// 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 loop async(T::Invalid)
for (int i = 5; i < 10; ++i);
// 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 loop async(HasInt::ACValue)
for (int i = 5; i < 10; ++i);
// 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 loop async(T::ACValue)
for (int i = 5; i < 10; ++i);
// 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 loop async(HasInt::EXValue)
for (int i = 5; i < 10; ++i);
// 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 loop async(T::EXValue)
for (int i = 5; i < 10; ++i);
#pragma acc parallel loop async(HasInt::value)
for (int i = 5; i < 10; ++i);
#pragma acc kernels loop async(T::value)
for (int i = 5; i < 10; ++i);
#pragma acc parallel loop async(HasInt::IntTy{})
for (int i = 5; i < 10; ++i);
#pragma acc kernels loop async(typename T::ShortTy{})
for (int i = 5; i < 10; ++i);
#pragma acc parallel loop async(HasInt::IntTy{})
for (int i = 5; i < 10; ++i);
#pragma acc kernels loop async(typename T::ShortTy{})
for (int i = 5; i < 10; ++i);
HasInt HI{};
T MyT{};
#pragma acc parallel loop async(HI)
for (int i = 5; i < 10; ++i);
#pragma acc kernels loop async(MyT)
for (int i = 5; i < 10; ++i);
}
void Inst() {
TestInst<HasInt>(); // #INST
}
|
