1 // RUN: sed -e "s@ATTR_USE@__arm_streaming@g" -e "s@ATTR_NAME@__arm_streaming@g" %s > %t
2 // RUN: %clang_cc1 -fcxx-exceptions -fdeclspec -fexceptions -fsyntax-only -verify -std=c++11 -Wc++14-compat -Wc++14-extensions -Wc++17-extensions -triple aarch64-none-linux-gnu -target-feature +sme -x c++ %t
3 // RUN: sed -e "s@ATTR_USE@__arm_inout\(\"za\"\)@g" -e "s@ATTR_NAME@__arm_inout@g" %s > %t
4 // RUN: %clang_cc1 -fcxx-exceptions -fdeclspec -fexceptions -fsyntax-only -verify -std=c++11 -Wc++14-compat -Wc++14-extensions -Wc++17-extensions -triple aarch64-none-linux-gnu -target-feature +sme -x c++ %t
5
6 // Need std::initializer_list
7 namespace std {
8 typedef decltype(sizeof(int)) size_t;
9
10 // libc++'s implementation
11 template <class _E>
12 class initializer_list
13 {
14 const _E* __begin_;
15 size_t __size_;
16
initializer_list(const _E * __b,size_t __s)17 initializer_list(const _E* __b, size_t __s)
18 : __begin_(__b),
19 __size_(__s)
20 {}
21
22 public:
23 typedef _E value_type;
24 typedef const _E& reference;
25 typedef const _E& const_reference;
26 typedef size_t size_type;
27
28 typedef const _E* iterator;
29 typedef const _E* const_iterator;
30
initializer_list()31 initializer_list() : __begin_(nullptr), __size_(0) {}
32
size() const33 size_t size() const {return __size_;}
begin() const34 const _E* begin() const {return __begin_;}
end() const35 const _E* end() const {return __begin_ + __size_;}
36 };
37 }
38
39
40 // Declaration syntax checks
41 ATTR_USE int before_attr; // expected-error {{'ATTR_NAME' only applies to function types}}
42 int ATTR_USE between_attr; // expected-error {{'ATTR_NAME' only applies to function types}}
43 const ATTR_USE int between_attr_2 = 0; // expected-error {{'ATTR_NAME' cannot appear here}}
44 int after_attr ATTR_USE; // expected-error {{'ATTR_NAME' only applies to function types}}
45 int * ATTR_USE ptr_attr; // expected-error {{'ATTR_NAME' only applies to function types}}
46 int & ATTR_USE ref_attr = after_attr; // expected-error {{'ATTR_NAME' only applies to function types}}
47 int && ATTR_USE rref_attr = 0; // expected-error {{'ATTR_NAME' only applies to function types}}
48 int array_attr [1] ATTR_USE; // expected-error {{'ATTR_NAME' only applies to function types}}
49 void fn_attr () ATTR_USE;
50 void noexcept_fn_attr () noexcept ATTR_USE;
51 struct MemberFnOrder {
52 virtual void f() const volatile && noexcept ATTR_USE final = 0;
53 };
54 struct ATTR_USE struct_attr; // expected-error {{'ATTR_NAME' only applies to non-K&R-style functions}}
55 class ATTR_USE class_attr {}; // expected-error {{'ATTR_NAME' only applies to non-K&R-style functions}}
56 union ATTR_USE union_attr; // expected-error {{'ATTR_NAME' only applies to non-K&R-style functions}}
57 enum ATTR_USE E { }; // expected-error {{'ATTR_NAME' only applies to non-K&R-style functions}}
58 namespace test_misplacement {
59 ATTR_USE struct struct_attr2; // expected-error {{misplaced 'ATTR_NAME'}}
60 ATTR_USE class class_attr2; // expected-error {{misplaced 'ATTR_NAME'}}
61 ATTR_USE union union_attr2; // expected-error {{misplaced 'ATTR_NAME'}}
62 ATTR_USE enum E2 { }; // expected-error {{misplaced 'ATTR_NAME'}}
63 }
64
65 // Checks attributes placed at wrong syntactic locations of class specifiers.
66 class ATTR_USE ATTR_USE // expected-error 2 {{'ATTR_NAME' only applies to non-K&R-style functions}}
67 attr_after_class_name_decl ATTR_USE ATTR_USE; // expected-error {{'ATTR_NAME' cannot appear here}} \
68 expected-error 2 {{'ATTR_NAME' only applies to non-K&R-style functions}}
69
70 class ATTR_USE ATTR_USE // expected-error 2 {{'ATTR_NAME' only applies to non-K&R-style functions}}
71 attr_after_class_name_definition ATTR_USE ATTR_USE ATTR_USE{}; // expected-error {{'ATTR_NAME' cannot appear here}} \
72 expected-error 3 {{'ATTR_NAME' only applies to non-K&R-style functions}}
73
74 class ATTR_USE c {}; // expected-error {{'ATTR_NAME' only applies to non-K&R-style functions}}
75 class c ATTR_USE ATTR_USE x; // expected-error 2 {{'ATTR_NAME' only applies to function types}}
76 class c ATTR_USE ATTR_USE y ATTR_USE ATTR_USE; // expected-error 4 {{'ATTR_NAME' only applies to function types}}
77 class c final [(int){0}];
78
79 class base {};
80 class ATTR_USE ATTR_USE final_class // expected-error 2 {{'ATTR_NAME' only applies to non-K&R-style functions}}
81 ATTR_USE alignas(float) final // expected-error {{'ATTR_NAME' cannot appear here}} \
82 expected-error {{'ATTR_NAME' only applies to non-K&R-style functions}}
83 ATTR_USE alignas(float) ATTR_USE alignas(float): base{}; // expected-error {{'ATTR_NAME' cannot appear here}}
84
85 class ATTR_USE ATTR_USE final_class_another // expected-error 2 {{'ATTR_NAME' only applies to non-K&R-style functions}}
86 ATTR_USE ATTR_USE alignas(16) final // expected-error {{'ATTR_NAME' cannot appear here}} \
87 expected-error 2 {{'ATTR_NAME' only applies to non-K&R-style functions}}
88 ATTR_USE ATTR_USE alignas(16) ATTR_USE{}; // expected-error {{'ATTR_NAME' cannot appear here}}
89
90 class after_class_close {} ATTR_USE; // expected-error {{'ATTR_NAME' cannot appear here, place it after "class" to apply it to the type declaration}}
91
92 class C {};
93
94 ATTR_USE struct with_init_declarators {} init_declarator; // expected-error {{'ATTR_NAME' only applies to function types}}
95 ATTR_USE struct no_init_declarators; // expected-error {{misplaced 'ATTR_NAME'}}
96 template<typename> ATTR_USE struct no_init_declarators_template; // expected-error {{'ATTR_NAME' cannot appear here}}
fn_with_structs()97 void fn_with_structs() {
98 ATTR_USE struct with_init_declarators {} init_declarator; // expected-error {{'ATTR_NAME' only applies to function types}}
99 ATTR_USE struct no_init_declarators; // expected-error {{'ATTR_NAME' cannot appear here}}
100 }
101 ATTR_USE; // expected-error {{'ATTR_NAME' only applies to non-K&R-style functions}}
102 struct ctordtor {
103 ATTR_USE ctordtor ATTR_USE () ATTR_USE; // expected-error 2 {{'ATTR_NAME' cannot be applied to a declaration}}
104 ctordtor (C) ATTR_USE;
105 ATTR_USE ~ctordtor ATTR_USE () ATTR_USE; // expected-error 2 {{'ATTR_NAME' cannot be applied to a declaration}}
106 };
ATTR_USE()107 ATTR_USE ctordtor::ctordtor ATTR_USE () ATTR_USE {} // expected-error 2 {{'ATTR_NAME' cannot be applied to a declaration}}
ctordtor(C)108 ATTR_USE ctordtor::ctordtor (C) ATTR_USE try {} catch (...) {} // expected-error {{'ATTR_NAME' cannot be applied to a declaration}}
ATTR_USE()109 ATTR_USE ctordtor::~ctordtor ATTR_USE () ATTR_USE {} // expected-error 2 {{'ATTR_NAME' cannot be applied to a declaration}}
110 extern "C++" ATTR_USE int extern_attr; // expected-error {{'ATTR_NAME' only applies to function types}}
111 template <typename T> ATTR_USE void template_attr (); // expected-error {{'ATTR_NAME' cannot be applied to a declaration}}
112 ATTR_USE ATTR_USE int ATTR_USE ATTR_USE multi_attr ATTR_USE ATTR_USE; // expected-error 6 {{'ATTR_NAME' only applies to function types}}
113
114 int (paren_attr) ATTR_USE; // expected-error {{'ATTR_NAME' cannot appear here}}
115 unsigned ATTR_USE int attr_in_decl_spec; // expected-error {{'ATTR_NAME' cannot appear here}}
116 unsigned ATTR_USE int ATTR_USE const double_decl_spec = 0; // expected-error 2 {{'ATTR_NAME' cannot appear here}}
117 class foo {
118 void const_after_attr () ATTR_USE const; // expected-error {{expected ';'}}
119 };
120 extern "C++" ATTR_USE { } // expected-error {{'ATTR_NAME' cannot appear here}}
121 ATTR_USE extern "C++" { } // expected-error {{'ATTR_NAME' cannot appear here}}
122 ATTR_USE template <typename T> void before_template_attr (); // expected-error {{'ATTR_NAME' cannot appear here}}
123 ATTR_USE namespace ns { int i; } // expected-error {{'ATTR_NAME' cannot appear here}}
124 ATTR_USE static_assert(true, ""); //expected-error {{'ATTR_NAME' cannot appear here}}
125 ATTR_USE asm(""); // expected-error {{'ATTR_NAME' cannot appear here}}
126
127 ATTR_USE using ns::i; // expected-warning {{ISO C++}} \
128 expected-error {{'ATTR_NAME' only applies to non-K&R-style functions}}
129 ATTR_USE using namespace ns; // expected-error {{'ATTR_NAME' only applies to non-K&R-style functions}}
130 namespace ATTR_USE ns2 {} // expected-warning {{attributes on a namespace declaration are a C++17 extension}} \
131 expected-error {{'ATTR_NAME' only applies to non-K&R-style functions}}
132
133 using ATTR_USE alignas(4)ATTR_USE ns::i; // expected-warning 2 {{ISO C++}} \
134 expected-error {{'ATTR_NAME' cannot appear here}} \
135 expected-error {{'alignas' attribute only applies to variables, data members and tag types}} \
136 expected-warning {{ISO C++}} \
137 expected-error 2 {{'ATTR_NAME' only applies to non-K&R-style functions}}
138 using ATTR_USE alignas(4) ATTR_USE foobar = int; // expected-error {{'ATTR_NAME' cannot appear here}} \
139 expected-error {{'alignas' attribute only applies to}} \
140 expected-error 2 {{'ATTR_NAME' only applies to function types}}
141
142 ATTR_USE using T = int; // expected-error {{'ATTR_NAME' cannot appear here}}
143 using T ATTR_USE = int; // expected-error {{'ATTR_NAME' only applies to function types}}
144 template<typename T> using U ATTR_USE = T; // expected-error {{'ATTR_NAME' only applies to function types}}
145 using ns::i ATTR_USE; // expected-warning {{ISO C++}} \
146 expected-error {{'ATTR_NAME' only applies to non-K&R-style functions}}
147 using ns::i ATTR_USE, ns::i ATTR_USE; // expected-warning 2 {{ISO C++}} \
148 expected-warning {{use of multiple declarators in a single using declaration is a C++17 extension}} \
149 expected-error 2 {{'ATTR_NAME' only applies to non-K&R-style functions}}
150 struct using_in_struct_base {
151 typedef int i, j, k, l;
152 };
153 struct using_in_struct : using_in_struct_base {
154 ATTR_USE using using_in_struct_base::i; // expected-warning {{ISO C++}} \
155 expected-error {{'ATTR_NAME' only applies to non-K&R-style functions}}
156 using using_in_struct_base::j ATTR_USE; // expected-warning {{ISO C++}} \
157 expected-error {{'ATTR_NAME' only applies to non-K&R-style functions}}
158 ATTR_USE using using_in_struct_base::k ATTR_USE, using_in_struct_base::l ATTR_USE; // expected-warning 3 {{ISO C++}} \
159 expected-warning {{use of multiple declarators in a single using declaration is a C++17 extension}} \
160 expected-error 4 {{'ATTR_NAME' only applies to non-K&R-style functions}}
161 };
162 using ATTR_USE ns::i; // expected-warning {{ISO C++}} \
163 expected-error {{'ATTR_NAME' cannot appear here}} \
164 expected-error {{'ATTR_NAME' only applies to non-K&R-style functions}}
165 using T ATTR_USE = int; // expected-error {{'ATTR_NAME' only applies to function types}}
166
167 auto trailing() -> ATTR_USE const int; // expected-error {{'ATTR_NAME' cannot appear here}}
168 auto trailing() -> const ATTR_USE int; // expected-error {{'ATTR_NAME' cannot appear here}}
169 auto trailing() -> const int ATTR_USE; // expected-error {{'ATTR_NAME' only applies to function types}}
170 auto trailing_2() -> struct struct_attr ATTR_USE; // expected-error {{'ATTR_NAME' only applies to function types}}
171
172 namespace N {
173 struct S {};
174 };
175 template<typename> struct Template {};
176
177 // FIXME: Improve this diagnostic
178 struct ATTR_USE N::S s; // expected-error {{'ATTR_NAME' cannot appear here}}
179 struct ATTR_USE Template<int> t; // expected-error {{'ATTR_NAME' cannot appear here}}
180 struct ATTR_USE ::template Template<int> u; // expected-error {{'ATTR_NAME' cannot appear here}}
181 template struct ATTR_USE Template<char>; // expected-error {{'ATTR_NAME' cannot appear here}}
182 template struct __attribute__((pure)) Template<std::size_t>; // We still allow GNU-style attributes here
183 template <> struct ATTR_USE Template<void>; // expected-error {{'ATTR_NAME' only applies to non-K&R-style functions}}
184
185 enum ATTR_USE E1 {}; // expected-error {{'ATTR_NAME' only applies to non-K&R-style functions}}
186 enum ATTR_USE E2; // expected-error {{forbids forward references}} \
187 expected-error {{'ATTR_NAME' only applies to non-K&R-style functions}}
188 enum ATTR_USE E1; // expected-error {{'ATTR_NAME' only applies to non-K&R-style functions}}
189 enum ATTR_USE E3 : int; // expected-error {{'ATTR_NAME' only applies to non-K&R-style functions}}
190 enum ATTR_USE { // expected-error {{'ATTR_NAME' only applies to non-K&R-style functions}}
191 k_123 ATTR_USE = 123 // expected-warning {{attributes on an enumerator declaration are a C++17 extension}} \
192 expected-error {{'ATTR_NAME' only applies to non-K&R-style functions}}
193 };
194 enum ATTR_USE E1 e; // expected-error {{'ATTR_NAME' cannot appear here}}
195 enum ATTR_USE class E4 { }; // expected-error {{'ATTR_NAME' cannot appear here}}
196 enum struct ATTR_USE E5; // expected-error {{'ATTR_NAME' only applies to non-K&R-style functions}}
197 enum E6 {} ATTR_USE; // expected-error {{'ATTR_NAME' cannot appear here, place it after "enum" to apply it to the type declaration}}
198
199 struct S {
200 friend int f ATTR_USE (); // expected-error {{'ATTR_NAME' cannot appear here}} \
201 expected-error {{'ATTR_NAME' cannot be applied to a declaration}}
ATTR_USE()202 friend int f2 ATTR_USE () {} // expected-error {{'ATTR_NAME' cannot be applied to a declaration}}
203 ATTR_USE friend int g(); // expected-error {{'ATTR_NAME' cannot appear here}}
h()204 ATTR_USE friend int h() { // expected-error {{'ATTR_NAME' cannot be applied to a declaration}}
205 }
206 ATTR_USE friend int f3(), f4(), f5(); // expected-error {{'ATTR_NAME' cannot appear here}}
207 friend int f6 ATTR_USE (), f7 ATTR_USE (), f8 ATTR_USE (); // expected-error3 {{'ATTR_NAME' cannot appear here}} \
208 expected-error 3 {{'ATTR_NAME' cannot be applied to a declaration}}
209 friend class ATTR_USE C; // expected-error {{'ATTR_NAME' cannot appear here}}
210 ATTR_USE friend class D; // expected-error {{'ATTR_NAME' cannot appear here}}
211 ATTR_USE friend int; // expected-error {{'ATTR_NAME' cannot appear here}}
212 };
tmpl(T)213 template<typename T> void tmpl (T) {}
214 template ATTR_USE void tmpl(char); // expected-error {{'ATTR_NAME' cannot appear here}}
215 template void ATTR_USE tmpl(short); // expected-error {{'ATTR_NAME' only applies to function types}}
216
217 // Statement tests
foo()218 void foo () {
219 ATTR_USE ; // expected-error {{'ATTR_NAME' cannot be applied to a statement}}
220 ATTR_USE { } // expected-error {{'ATTR_NAME' cannot be applied to a statement}}
221 ATTR_USE if (0) { } // expected-error {{'ATTR_NAME' cannot be applied to a statement}}
222 ATTR_USE for (;;); // expected-error {{'ATTR_NAME' cannot be applied to a statement}}
223 ATTR_USE do { // expected-error {{'ATTR_NAME' cannot be applied to a statement}}
224 ATTR_USE continue; // expected-error {{'ATTR_NAME' cannot be applied to a statement}}
225 } while (0);
226 ATTR_USE while (0); // expected-error {{'ATTR_NAME' cannot be applied to a statement}}
227
228 ATTR_USE switch (i) { // expected-error {{'ATTR_NAME' cannot be applied to a statement}}
229 ATTR_USE case 0: // expected-error {{'ATTR_NAME' cannot be applied to a statement}}
230 ATTR_USE default: // expected-error {{'ATTR_NAME' cannot be applied to a statement}}
231 ATTR_USE break; // expected-error {{'ATTR_NAME' cannot be applied to a statement}}
232 }
233
234 ATTR_USE goto there; // expected-error {{'ATTR_NAME' cannot be applied to a statement}}
235 ATTR_USE there: // expected-error {{'ATTR_NAME' only applies to non-K&R-style functions}}
236
237 ATTR_USE try { // expected-error {{'ATTR_NAME' cannot be applied to a statement}}
238 } ATTR_USE catch (...) { // expected-error {{'ATTR_NAME' cannot appear here}}
239 }
240
241 void bar ATTR_USE (ATTR_USE int i, ATTR_USE int j); // expected-error 2 {{'ATTR_NAME' only applies to function types}} \
242 expected-error {{'ATTR_NAME' cannot be applied to a declaration}}
243 using FuncType = void (ATTR_USE int); // expected-error {{'ATTR_NAME' only applies to function types}}
244 void baz(ATTR_USE...); // expected-error {{expected parameter declarator}}
245
246 ATTR_USE return; // expected-error {{'ATTR_NAME' cannot be applied to a statement}}
247 }
248
249 // Expression tests
bar()250 void bar () {
251 new int[42]ATTR_USE[5]ATTR_USE{}; // expected-error {{'ATTR_NAME' only applies to function types}}
252 }
253
254 // Condition tests
baz()255 void baz () {
256 if (ATTR_USE bool b = true) { // expected-error {{'ATTR_NAME' only applies to function types}}
257 switch (ATTR_USE int n { 42 }) { // expected-error {{'ATTR_NAME' only applies to function types}}
258 default:
259 for (ATTR_USE int n = 0; ATTR_USE char b = n < 5; ++b) { // expected-error 2 {{'ATTR_NAME' only applies to function types}}
260 }
261 }
262 }
263 int x;
264 // An attribute can be applied to an expression-statement, such as the first
265 // statement in a for. But it can't be applied to a condition which is an
266 // expression.
267 for (ATTR_USE x = 0; ; ) {} // expected-error {{'ATTR_NAME' cannot appear here}}
268 for (; ATTR_USE x < 5; ) {} // expected-error {{'ATTR_NAME' cannot appear here}}
269 while (ATTR_USE bool k { false }) { // expected-error {{'ATTR_NAME' only applies to function types}}
270 }
271 while (ATTR_USE true) { // expected-error {{'ATTR_NAME' cannot appear here}}
272 }
273 do {
274 } while (ATTR_USE false); // expected-error {{'ATTR_NAME' cannot appear here}}
275
276 for (ATTR_USE int n : { 1, 2, 3 }) { // expected-error {{'ATTR_NAME' only applies to function types}}
277 }
278 }
279
280 enum class __attribute__((visibility("hidden"))) SecretKeepers {
281 one, /* rest are deprecated */ two, three
282 };
283 enum class ATTR_USE EvenMoreSecrets {}; // expected-error {{'ATTR_NAME' only applies to non-K&R-style functions}}
284
285 // Forbid attributes on decl specifiers.
286 unsigned ATTR_USE static int ATTR_USE v1; // expected-error {{'ATTR_NAME' only applies to function types}} \
287 expected-error {{'ATTR_NAME' cannot appear here}}
288 typedef ATTR_USE unsigned long ATTR_USE v2; // expected-error {{'ATTR_NAME' only applies to function types}} \
289 expected-error {{'ATTR_NAME' cannot appear here}}
290 int ATTR_USE foo(int ATTR_USE x); // expected-error 2 {{'ATTR_NAME' only applies to function types}}
291
292 ATTR_USE; // expected-error {{'ATTR_NAME' only applies to non-K&R-style functions}}
293
294 class A {
295 A(ATTR_USE int a); // expected-error {{'ATTR_NAME' only applies to function types}}
296 };
A(ATTR_USE int a)297 A::A(ATTR_USE int a) {} // expected-error {{'ATTR_NAME' only applies to function types}}
298
299 template<typename T> struct TemplateStruct {};
300 class FriendClassesWithAttributes {
301 // We allow GNU-style attributes here
302 template <class _Tp, class _Alloc> friend class __attribute__((__type_visibility__("default"))) vector;
303 template <class _Tp, class _Alloc> friend class __declspec(code_seg("foo,whatever")) vector2;
304 // But not C++11 ones
305 template <class _Tp, class _Alloc> friend class ATTR_USE vector3; // expected-error {{'ATTR_NAME' cannot appear here}}
306
307 // Also allowed
308 friend struct __attribute__((__type_visibility__("default"))) TemplateStruct<FriendClassesWithAttributes>;
309 friend struct __declspec(code_seg("foo,whatever")) TemplateStruct<FriendClassesWithAttributes>;
310 friend struct ATTR_USE TemplateStruct<FriendClassesWithAttributes>; // expected-error {{'ATTR_NAME' cannot appear here}}
311 };
312
313 // Check ordering: C++11 attributes must appear before GNU attributes.
314 class Ordering {
f1(int (ATTR_USE int n))315 void f1(
316 int (ATTR_USE __attribute__(()) int n) // expected-error {{'ATTR_NAME' only applies to function types}}
317 ) {
318 }
319
f2(int (*)(ATTR_USE int n))320 void f2(
321 int (*)(ATTR_USE __attribute__(()) int n) // expected-error {{'ATTR_NAME' only applies to function types}}
322 ) {
323 }
324
f3(int (ATTR_USE int n))325 void f3(
326 int (__attribute__(()) ATTR_USE int n) // expected-error {{'ATTR_NAME' cannot appear here}}
327 ) {
328 }
329
f4(int (*)(ATTR_USE int n))330 void f4(
331 int (*)(__attribute__(()) ATTR_USE int n) // expected-error {{'ATTR_NAME' cannot appear here}}
332 ) {
333 }
334 };
335
336 namespace base_specs {
337 struct A {};
338 struct B : ATTR_USE A {}; // expected-error {{'ATTR_NAME' cannot be applied to a base specifier}}
339 struct C : ATTR_USE virtual A {}; // expected-error {{'ATTR_NAME' cannot be applied to a base specifier}}
340 struct D : ATTR_USE public virtual A {}; // expected-error {{'ATTR_NAME' cannot be applied to a base specifier}}
341 struct E : public ATTR_USE virtual A {}; // expected-error {{'ATTR_NAME' cannot appear here}} \
342 expected-error {{'ATTR_NAME' cannot be applied to a base specifier}}
343 struct F : virtual ATTR_USE public A {}; // expected-error {{'ATTR_NAME' cannot appear here}} \
344 expected-error {{'ATTR_NAME' cannot be applied to a base specifier}}
345 }
346
347 namespace ATTR_USE ns_attr {}; // expected-error {{'ATTR_NAME' only applies to non-K&R-style functions}} \
348 expected-warning {{attributes on a namespace declaration are a C++17 extension}}
349