1 /* Test for _Atomic in C11. Test of invalid code. */
2 /* { dg-do compile } */
3 /* { dg-options "-std=c11 -pedantic-errors" } */
4
5 /* Increment and decrement are invalid for atomic complex types and
6 atomic pointers to incomplete types, just as for the corresponding
7 non-atomic types. Likewise for types on which arithmetic is
8 invalid. */
9 _Atomic _Complex float acf;
10 void *_Atomic apv;
11 struct s *_Atomic aps;
12 _Atomic struct t { char c; } as;
13
14 void
15 func (void)
16 {
17 acf++; /* { dg-error "complex types" } */
18 acf--; /* { dg-error "complex types" } */
19 ++acf; /* { dg-error "complex types" } */
20 --acf; /* { dg-error "complex types" } */
21 apv++; /* { dg-error "wrong type|pointer of type" } */
22 apv--; /* { dg-error "wrong type|pointer of type" } */
23 ++apv; /* { dg-error "wrong type|pointer of type" } */
24 --apv; /* { dg-error "wrong type|pointer of type" } */
25 aps++; /* { dg-error "pointer to|invalid use of undefined type" } */
26 aps--; /* { dg-error "pointer to|invalid use of undefined type" } */
27 ++aps; /* { dg-error "pointer to|invalid use of undefined type" } */
28 --aps; /* { dg-error "pointer to|invalid use of undefined type" } */
29 as++; /* { dg-error "wrong type" } */
30 as--; /* { dg-error "wrong type" } */
31 ++as; /* { dg-error "wrong type" } */
32 --as; /* { dg-error "wrong type" } */
33 }
34
35 /* Pointer subtraction and comparisons differing in _Atomic are
36 invalid where such subtraction and comparisons differing in
37 qualifiers are valid. There is no special allowance for equality
38 comparisons of pointers to atomic void to pointers to object
39 types. Likewise for conditional expressions. */
40 int *pi;
41 _Atomic int *pai;
42 _Atomic void *pav;
43 int r;
44
45 void
46 func2 (void)
47 {
48 r = pai - pi; /* { dg-error "invalid operands" } */
49 r = pi - pai; /* { dg-error "invalid operands" } */
50 r = pi < pai; /* { dg-error "distinct pointer types" } */
51 r = pi > pai; /* { dg-error "distinct pointer types" } */
52 r = pi <= pai; /* { dg-error "distinct pointer types" } */
53 r = pi >= pai; /* { dg-error "distinct pointer types" } */
54 r = pai < pi; /* { dg-error "distinct pointer types" } */
55 r = pai > pi; /* { dg-error "distinct pointer types" } */
56 r = pai <= pi; /* { dg-error "distinct pointer types" } */
57 r = pai >= pi; /* { dg-error "distinct pointer types" } */
58 r = pav == pi; /* { dg-error "distinct pointer types" } */
59 r = pav != pi; /* { dg-error "distinct pointer types" } */
60 r = pi == pav; /* { dg-error "distinct pointer types" } */
61 r = pi != pav; /* { dg-error "distinct pointer types" } */
62 (void) (r ? pai : pi); /* { dg-error "pointer type mismatch" } */
63 (void) (r ? pi : pai); /* { dg-error "pointer type mismatch" } */
64 (void) (r ? pai : pav); /* { dg-error "pointer type mismatch" } */
65 (void) (r ? pav : pai); /* { dg-error "pointer type mismatch" } */
66 }
67
68 /* Likewise for pointer assignment. */
69 void
70 func3 (void)
71 {
72 pai = pi; /* { dg-error "incompatible pointer type" } */
73 pi = pai; /* { dg-error "incompatible pointer type" } */
74 pav = pai; /* { dg-error "incompatible pointer type" } */
75 pai = pav; /* { dg-error "incompatible pointer type" } */
76 }
77
78 /* Cases that are invalid for normal assignments are just as invalid
79 (and should not ICE) when the LHS is atomic. */
80 void
81 func4 (void)
82 {
83 as = acf; /* { dg-error "incompatible types" } */
84 apv = as; /* { dg-error "incompatible types" } */
85 as += 1; /* { dg-error "invalid operands" } */
86 apv -= 1; /* { dg-error "pointer of type" } */
87 apv *= 1; /* { dg-error "invalid operands" } */
88 apv /= 1; /* { dg-error "invalid operands" } */
89 apv %= 1; /* { dg-error "invalid operands" } */
90 apv <<= 1; /* { dg-error "invalid operands" } */
91 apv >>= 1; /* { dg-error "invalid operands" } */
92 apv &= 1; /* { dg-error "invalid operands" } */
93 apv ^= 1; /* { dg-error "invalid operands" } */
94 apv |= 1; /* { dg-error "invalid operands" } */
95 }
96
97 /* We don't allow atomic bit-fields in GCC (implementation-defined
98 whether they are permitted). */
99 struct abf
100 {
101 _Atomic int i : 1; /* { dg-error "atomic type" } */
102 _Atomic int : 0; /* { dg-error "atomic type" } */
103 };
104
105 /* _Atomic (type-name) may not use a name for an array, function,
106 qualified or atomic type. */
107 _Atomic (int [2]) v0; /* { dg-error "array type" } */
108 _Atomic (void (void)) v1; /* { dg-error "function type" } */
109 _Atomic (_Atomic int) v2; /* { dg-error "applied to a qualified type" } */
110 _Atomic (const int) v3; /* { dg-error "applied to a qualified type" } */
111 _Atomic (volatile int) v4; /* { dg-error "applied to a qualified type" } */
112 _Atomic (int *restrict) v5; /* { dg-error "applied to a qualified type" } */
113
114 /* _Atomic, used as a qualifier, may not be applied to a function or
115 array type. */
116 typedef int arraytype[2];
117 typedef void functiontype (void);
118 _Atomic arraytype v6; /* { dg-error "array type" } */
119 _Atomic arraytype *v7; /* { dg-error "array type" } */
120 typedef _Atomic arraytype v8; /* { dg-error "array type" } */
121 int v9 = sizeof (_Atomic arraytype); /* { dg-error "array type" } */
122 void v10 (_Atomic arraytype parm); /* { dg-error "array type" } */
123 struct v11 { _Atomic arraytype f; }; /* { dg-error "array type" } */
124 _Atomic functiontype v12; /* { dg-error "function type" } */
125 _Atomic functiontype *v13; /* { dg-error "function type" } */
126 typedef _Atomic functiontype *v14; /* { dg-error "function type" } */
127 void v15 (_Atomic functiontype parm); /* { dg-error "function type" } */
128
129 /* Function parameters, when function types are required to be
130 compatible, may not differ in the presence of _Atomic. See
131 c11-atomic-1.c for corresponding tests where _Atomic matches. */
132 void fc0 (int _Atomic); /* { dg-message "previous declaration" } */
133 void fc0 (int); /* { dg-error "conflicting types" } */
134 void fc1 (int); /* { dg-message "prototype declaration" } */
135 void
136 fc1 (x)
137 _Atomic int x; /* { dg-error "match prototype" } */
138 {
139 }
140 void
141 fc2 (x) /* { dg-message "previous definition" } */
142 _Atomic int x;
143 {
144 }
145 void fc2 (int); /* { dg-error "incompatible type" } */
146 void fc3 (int); /* { dg-message "prototype declaration" } */
147 void
148 fc3 (x)
149 _Atomic short x; /* { dg-error "match prototype" } */
150 {
151 }
152 void
153 fc4 (x) /* { dg-message "previous definition" } */
154 _Atomic short x;
155 {
156 }
157 void fc4 (int); /* { dg-error "incompatible type" } */
158
159 /* Arrays of atomic elements cannot be initialized with string
160 literals. */
161 _Atomic char si0[] = ""; /* { dg-error "inappropriate type" } */
162 _Atomic char si1[] = u8""; /* { dg-error "inappropriate type" } */
163 _Atomic signed char si2[] = ""; /* { dg-error "inappropriate type" } */
164 _Atomic signed char si3[] = u8""; /* { dg-error "inappropriate type" } */
165 _Atomic unsigned char si4[] = ""; /* { dg-error "inappropriate type" } */
166 _Atomic unsigned char si5[] = u8""; /* { dg-error "inappropriate type" } */
167 _Atomic __WCHAR_TYPE__ si6[] = L""; /* { dg-error "inappropriate type" } */
168 _Atomic __CHAR16_TYPE__ si7[] = u""; /* { dg-error "inappropriate type" } */
169 _Atomic __CHAR32_TYPE__ si8[] = U""; /* { dg-error "inappropriate type" } */
170
171 /* Anything that is syntactically a qualifier applied to the (void)
172 parameter list results in undefined behavior, which we
173 diagnose. */
174 void fv (_Atomic void); /* { dg-error "may not be qualified" } */