Line data Source code
1 : /*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
2 : |* *|
3 : |* Parsed attribute helpers *|
4 : |* *|
5 : |* Automatically generated file, do not edit! *|
6 : |* *|
7 : \*===----------------------------------------------------------------------===*/
8 :
9 13582318 : static bool defaultAppertainsTo(Sema &, const ParsedAttr &,const Decl *) {
10 13582318 : return true;
11 : }
12 :
13 27732092 : static bool defaultDiagnoseLangOpts(Sema &, const ParsedAttr &) {
14 27732092 : return true;
15 : }
16 :
17 55452175 : static bool defaultTargetRequirements(const TargetInfo &) {
18 55452175 : return true;
19 : }
20 :
21 0 : static unsigned defaultSpellingIndexToSemanticSpelling(const ParsedAttr &Attr) {
22 0 : return UINT_MAX;
23 : }
24 :
25 95 : static bool checkAMDGPUFlatWorkGroupSizeAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
26 95 : if (!D || (!isa<FunctionDecl>(D))) {
27 1 : S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
28 : << Attr << "kernel functions";
29 1 : return false;
30 : }
31 : return true;
32 : }
33 :
34 0 : static void matchRulesForAMDGPUFlatWorkGroupSize(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
35 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
36 0 : }
37 :
38 72 : static bool checkAMDGPUNumSGPRAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
39 72 : if (!D || (!isa<FunctionDecl>(D))) {
40 1 : S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
41 : << Attr << "kernel functions";
42 1 : return false;
43 : }
44 : return true;
45 : }
46 :
47 0 : static void matchRulesForAMDGPUNumSGPR(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
48 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
49 0 : }
50 :
51 72 : static bool checkAMDGPUNumVGPRAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
52 72 : if (!D || (!isa<FunctionDecl>(D))) {
53 1 : S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
54 : << Attr << "kernel functions";
55 1 : return false;
56 : }
57 : return true;
58 : }
59 :
60 0 : static void matchRulesForAMDGPUNumVGPR(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
61 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
62 0 : }
63 :
64 118 : static bool checkAMDGPUWavesPerEUAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
65 118 : if (!D || (!isa<FunctionDecl>(D))) {
66 2 : S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
67 : << Attr << "kernel functions";
68 2 : return false;
69 : }
70 : return true;
71 : }
72 :
73 0 : static void matchRulesForAMDGPUWavesPerEU(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
74 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
75 0 : }
76 :
77 310 : static bool isTargetarmthumbarmebthumbebavrx86x86_64msp430mipsmipselriscv32riscv64(const TargetInfo &Target) {
78 : const llvm::Triple &T = Target.getTriple();
79 310 : return true && (T.getArch() == llvm::Triple::arm || T.getArch() == llvm::Triple::thumb || T.getArch() == llvm::Triple::armeb || T.getArch() == llvm::Triple::thumbeb || T.getArch() == llvm::Triple::avr || T.getArch() == llvm::Triple::x86 || T.getArch() == llvm::Triple::x86_64 || T.getArch() == llvm::Triple::msp430 || T.getArch() == llvm::Triple::mips || T.getArch() == llvm::Triple::mipsel || T.getArch() == llvm::Triple::riscv32 || T.getArch() == llvm::Triple::riscv64);
80 : }
81 :
82 4 : static bool checkAVRSignalAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
83 4 : if (!D || (!isa<FunctionDecl>(D))) {
84 1 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
85 : << Attr << "functions";
86 1 : return false;
87 : }
88 : return true;
89 : }
90 :
91 6 : static bool isTargetavr(const TargetInfo &Target) {
92 : const llvm::Triple &T = Target.getTriple();
93 6 : return true && (T.getArch() == llvm::Triple::avr);
94 : }
95 :
96 0 : static void matchRulesForAVRSignal(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
97 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
98 0 : }
99 :
100 : static bool isStruct(const Decl *D) {
101 : if (const auto *S = dyn_cast<RecordDecl>(D))
102 17 : return !S->isUnion();
103 : return false;
104 : }
105 :
106 1689 : static bool checkAbiTagAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
107 3378 : if (!D || (!isStruct(D) && !isa<VarDecl>(D) && !isa<FunctionDecl>(D) && !isa<NamespaceDecl>(D))) {
108 0 : S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
109 : << Attr << "structs, variables, functions, and namespaces";
110 0 : return false;
111 : }
112 : return true;
113 : }
114 :
115 60 : static void matchRulesForAbiTag(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
116 60 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record_not_is_union, /*IsSupported=*/true));
117 60 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /*IsSupported=*/true));
118 60 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
119 120 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_namespace, /*IsSupported=*/LangOpts.CPlusPlus));
120 60 : }
121 :
122 516 : static bool checkAcquireCapabilityAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
123 516 : if (!D || (!isa<FunctionDecl>(D))) {
124 31 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
125 : << Attr << "functions";
126 31 : return false;
127 : }
128 : return true;
129 : }
130 :
131 0 : static unsigned AcquireCapabilityAttrSpellingMap(const ParsedAttr &Attr) {
132 : enum Spelling {
133 : GNU_acquire_capability = 0,
134 : CXX11_clang_acquire_capability = 1,
135 : GNU_acquire_shared_capability = 2,
136 : CXX11_clang_acquire_shared_capability = 3,
137 : GNU_exclusive_lock_function = 4,
138 : GNU_shared_lock_function = 5
139 : };
140 :
141 0 : unsigned Idx = Attr.getAttributeSpellingListIndex();
142 : switch (Idx) {
143 0 : default: llvm_unreachable("Unknown spelling list index");
144 : case 0: return GNU_acquire_capability;
145 : case 1: return CXX11_clang_acquire_capability;
146 : case 2: return GNU_acquire_shared_capability;
147 : case 3: return CXX11_clang_acquire_shared_capability;
148 : case 4: return GNU_exclusive_lock_function;
149 : case 5: return GNU_shared_lock_function;
150 : }
151 : }
152 :
153 422 : static bool isSharedVar(const Decl *D) {
154 : if (const auto *S = dyn_cast<VarDecl>(D))
155 376 : return S->hasGlobalStorage() && !S->getTLSKind();
156 : return false;
157 : }
158 :
159 154 : static bool checkAcquiredAfterAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
160 154 : if (!D || (!isa<FieldDecl>(D) && !isSharedVar(D))) {
161 12 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
162 : << Attr << "non-static data members and global variables";
163 12 : return false;
164 : }
165 : return true;
166 : }
167 :
168 115 : static bool checkAcquiredBeforeAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
169 115 : if (!D || (!isa<FieldDecl>(D) && !isSharedVar(D))) {
170 12 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
171 : << Attr << "non-static data members and global variables";
172 12 : return false;
173 : }
174 : return true;
175 : }
176 :
177 : static bool isGlobalVar(const Decl *D) {
178 : if (const auto *S = dyn_cast<VarDecl>(D))
179 : return S->hasGlobalStorage();
180 : return false;
181 : }
182 :
183 97 : static bool checkAliasAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
184 120 : if (!D || (!isa<FunctionDecl>(D) && !isGlobalVar(D))) {
185 0 : S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
186 : << Attr << "functions and global variables";
187 0 : return false;
188 : }
189 : return true;
190 : }
191 :
192 0 : static void matchRulesForAlias(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
193 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
194 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_global, /*IsSupported=*/true));
195 0 : }
196 :
197 157 : static bool checkAlignValueAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
198 157 : if (!D || (!isa<VarDecl>(D) && !isa<TypedefNameDecl>(D))) {
199 3 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
200 : << Attr << "variables and typedefs";
201 3 : return false;
202 : }
203 : return true;
204 : }
205 :
206 0 : static void matchRulesForAlignValue(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
207 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /*IsSupported=*/true));
208 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_type_alias, /*IsSupported=*/true));
209 0 : }
210 :
211 0 : static unsigned AlignedAttrSpellingMap(const ParsedAttr &Attr) {
212 : enum Spelling {
213 : GNU_aligned = 0,
214 : CXX11_gnu_aligned = 1,
215 : Declspec_align = 2,
216 : Keyword_alignas = 3,
217 : Keyword_Alignas = 4
218 : };
219 :
220 0 : unsigned Idx = Attr.getAttributeSpellingListIndex();
221 : switch (Idx) {
222 0 : default: llvm_unreachable("Unknown spelling list index");
223 : case 0: return GNU_aligned;
224 : case 1: return CXX11_gnu_aligned;
225 : case 2: return Declspec_align;
226 : case 3: return Keyword_alignas;
227 : case 4: return Keyword_Alignas;
228 : }
229 : }
230 :
231 1065955 : static bool isHasFunctionProto(const Decl *D) {
232 1065955 : if (const auto *S = dyn_cast<Decl>(D))
233 2131874 : return (S->getFunctionType(true) != nullptr &&
234 1065957 : isa<FunctionProtoType>(S->getFunctionType())) ||
235 1065993 : isa<ObjCMethodDecl>(S) ||
236 : isa<BlockDecl>(S);
237 : return false;
238 : }
239 :
240 24 : static bool checkAllocAlignAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
241 24 : if (!D || (!isHasFunctionProto(D))) {
242 1 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
243 : << Attr << "non-K&R-style functions";
244 1 : return false;
245 : }
246 : return true;
247 : }
248 :
249 39 : static bool checkAllocSizeAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
250 39 : if (!D || (!isa<FunctionDecl>(D))) {
251 2 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
252 : << Attr << "functions";
253 2 : return false;
254 : }
255 : return true;
256 : }
257 :
258 0 : static void matchRulesForAllocSize(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
259 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
260 0 : }
261 :
262 22 : static bool checkAlwaysDestroyAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
263 22 : if (!D || (!isa<VarDecl>(D))) {
264 2 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
265 : << Attr << "variables";
266 2 : return false;
267 : }
268 : return true;
269 : }
270 :
271 0 : static void matchRulesForAlwaysDestroy(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
272 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /*IsSupported=*/true));
273 0 : }
274 :
275 10439057 : static bool checkAlwaysInlineAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
276 10439057 : if (!D || (!isa<FunctionDecl>(D))) {
277 0 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
278 : << Attr << "functions";
279 0 : return false;
280 : }
281 : return true;
282 : }
283 :
284 0 : static unsigned AlwaysInlineAttrSpellingMap(const ParsedAttr &Attr) {
285 : enum Spelling {
286 : GNU_always_inline = 0,
287 : CXX11_gnu_always_inline = 1,
288 : Keyword_forceinline = 2
289 : };
290 :
291 0 : unsigned Idx = Attr.getAttributeSpellingListIndex();
292 : switch (Idx) {
293 0 : default: llvm_unreachable("Unknown spelling list index");
294 : case 0: return GNU_always_inline;
295 : case 1: return CXX11_gnu_always_inline;
296 : case 2: return Keyword_forceinline;
297 : }
298 : }
299 :
300 0 : static void matchRulesForAlwaysInline(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
301 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
302 0 : }
303 :
304 79 : static void matchRulesForAnnotate(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
305 79 : }
306 :
307 133 : static bool isTargetx86x86_64(const TargetInfo &Target) {
308 : const llvm::Triple &T = Target.getTriple();
309 133 : return true && (T.getArch() == llvm::Triple::x86 || T.getArch() == llvm::Triple::x86_64);
310 : }
311 :
312 : static bool isFunctionLike(const Decl *D) {
313 43 : if (const auto *S = dyn_cast<Decl>(D))
314 843453 : return S->getFunctionType(false) != nullptr;
315 : return false;
316 : }
317 :
318 13 : static bool checkAnyX86NoCfCheckAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
319 26 : if (!D || (!isFunctionLike(D))) {
320 3 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
321 : << Attr << "functions and function pointers";
322 3 : return false;
323 : }
324 : return true;
325 : }
326 :
327 0 : static void matchRulesForAnyX86NoCfCheck(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
328 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_hasType_functionType, /*IsSupported=*/true));
329 0 : }
330 :
331 37 : static bool checkArcWeakrefUnavailableAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
332 37 : if (!D || (!isa<ObjCInterfaceDecl>(D))) {
333 2 : S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
334 : << Attr << "Objective-C interfaces";
335 2 : return false;
336 : }
337 : return true;
338 : }
339 :
340 0 : static void matchRulesForArcWeakrefUnavailable(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
341 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_interface, /*IsSupported=*/LangOpts.ObjC1));
342 0 : }
343 :
344 107 : static bool checkArgumentWithTypeTagAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
345 107 : if (!D || (!isHasFunctionProto(D))) {
346 3 : S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
347 : << Attr << "non-K&R-style functions";
348 3 : return false;
349 : }
350 : return true;
351 : }
352 :
353 0 : static unsigned ArgumentWithTypeTagAttrSpellingMap(const ParsedAttr &Attr) {
354 : enum Spelling {
355 : GNU_argument_with_type_tag = 0,
356 : CXX11_clang_argument_with_type_tag = 1,
357 : C2x_clang_argument_with_type_tag = 2,
358 : GNU_pointer_with_type_tag = 3,
359 : CXX11_clang_pointer_with_type_tag = 4,
360 : C2x_clang_pointer_with_type_tag = 5
361 : };
362 :
363 0 : unsigned Idx = Attr.getAttributeSpellingListIndex();
364 : switch (Idx) {
365 0 : default: llvm_unreachable("Unknown spelling list index");
366 : case 0: return GNU_argument_with_type_tag;
367 : case 1: return CXX11_clang_argument_with_type_tag;
368 : case 2: return C2x_clang_argument_with_type_tag;
369 : case 3: return GNU_pointer_with_type_tag;
370 : case 4: return CXX11_clang_pointer_with_type_tag;
371 : case 5: return C2x_clang_pointer_with_type_tag;
372 : }
373 : }
374 :
375 : static bool isInlineFunction(const Decl *D) {
376 : if (const auto *S = dyn_cast<FunctionDecl>(D))
377 37 : return S->isInlineSpecified();
378 : return false;
379 : }
380 :
381 37 : static bool checkArtificialAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
382 74 : if (!D || (!isInlineFunction(D))) {
383 1 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
384 : << Attr << "inline functions";
385 1 : return false;
386 : }
387 : return true;
388 : }
389 :
390 30 : static bool checkAssertCapabilityAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
391 30 : if (!D || (!isa<FunctionDecl>(D))) {
392 0 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
393 : << Attr << "functions";
394 0 : return false;
395 : }
396 : return true;
397 : }
398 :
399 0 : static unsigned AssertCapabilityAttrSpellingMap(const ParsedAttr &Attr) {
400 : enum Spelling {
401 : GNU_assert_capability = 0,
402 : CXX11_clang_assert_capability = 1,
403 : GNU_assert_shared_capability = 2,
404 : CXX11_clang_assert_shared_capability = 3
405 : };
406 :
407 0 : unsigned Idx = Attr.getAttributeSpellingListIndex();
408 : switch (Idx) {
409 0 : default: llvm_unreachable("Unknown spelling list index");
410 : case 0: return GNU_assert_capability;
411 : case 1: return CXX11_clang_assert_capability;
412 : case 2: return GNU_assert_shared_capability;
413 : case 3: return CXX11_clang_assert_shared_capability;
414 : }
415 : }
416 :
417 15 : static bool checkAssertExclusiveLockAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
418 15 : if (!D || (!isa<FunctionDecl>(D))) {
419 0 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
420 : << Attr << "functions";
421 0 : return false;
422 : }
423 : return true;
424 : }
425 :
426 13 : static bool checkAssertSharedLockAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
427 13 : if (!D || (!isa<FunctionDecl>(D))) {
428 0 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
429 : << Attr << "functions";
430 0 : return false;
431 : }
432 : return true;
433 : }
434 :
435 22 : static bool checkAssumeAlignedAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
436 22 : if (!D || (!isa<ObjCMethodDecl>(D) && !isa<FunctionDecl>(D))) {
437 2 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
438 : << Attr << "Objective-C methods and functions";
439 2 : return false;
440 : }
441 : return true;
442 : }
443 :
444 0 : static void matchRulesForAssumeAligned(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
445 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC1));
446 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
447 0 : }
448 :
449 851 : static bool checkAvailabilityAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
450 851 : if (!D || (!isa<NamedDecl>(D))) {
451 2 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
452 : << Attr << "named declarations";
453 2 : return false;
454 : }
455 : return true;
456 : }
457 :
458 0 : static void matchRulesForAvailability(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
459 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true));
460 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_enum, /*IsSupported=*/true));
461 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_enum_constant, /*IsSupported=*/true));
462 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_field, /*IsSupported=*/true));
463 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
464 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_namespace, /*IsSupported=*/LangOpts.CPlusPlus));
465 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_category, /*IsSupported=*/LangOpts.ObjC1));
466 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_interface, /*IsSupported=*/LangOpts.ObjC1));
467 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC1));
468 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_property, /*IsSupported=*/LangOpts.ObjC1));
469 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_protocol, /*IsSupported=*/LangOpts.ObjC1));
470 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true));
471 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_type_alias, /*IsSupported=*/true));
472 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /*IsSupported=*/true));
473 0 : }
474 :
475 0 : static bool checkCFAuditedTransferAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
476 0 : if (!D || (!isa<FunctionDecl>(D))) {
477 0 : S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
478 : << Attr << "functions";
479 0 : return false;
480 : }
481 : return true;
482 : }
483 :
484 0 : static void matchRulesForCFAuditedTransfer(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
485 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
486 0 : }
487 :
488 298 : static bool checkCFConsumedAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
489 298 : if (!D || (!isa<ParmVarDecl>(D))) {
490 0 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
491 : << Attr << "parameters";
492 0 : return false;
493 : }
494 : return true;
495 : }
496 :
497 0 : static void matchRulesForCFConsumed(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
498 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_parameter, /*IsSupported=*/true));
499 0 : }
500 :
501 1 : static bool checkCFUnknownTransferAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
502 1 : if (!D || (!isa<FunctionDecl>(D))) {
503 0 : S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
504 : << Attr << "functions";
505 0 : return false;
506 : }
507 : return true;
508 : }
509 :
510 0 : static void matchRulesForCFUnknownTransfer(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
511 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
512 0 : }
513 :
514 20 : static bool checkCPUDispatchAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
515 20 : if (!D || (!isa<FunctionDecl>(D))) {
516 0 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
517 : << Attr << "functions";
518 0 : return false;
519 : }
520 : return true;
521 : }
522 :
523 0 : static void matchRulesForCPUDispatch(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
524 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
525 0 : }
526 :
527 57 : static bool checkCPUSpecificAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
528 57 : if (!D || (!isa<FunctionDecl>(D))) {
529 0 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
530 : << Attr << "functions";
531 0 : return false;
532 : }
533 : return true;
534 : }
535 :
536 0 : static void matchRulesForCPUSpecific(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
537 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
538 0 : }
539 :
540 121 : static bool checkCUDAConstantAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
541 121 : if (!D || (!isa<VarDecl>(D))) {
542 2 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
543 : << Attr << "variables";
544 2 : return false;
545 : }
546 : return true;
547 : }
548 :
549 2441 : static bool checkCUDALangOpts(Sema &S, const ParsedAttr &Attr) {
550 2441 : if (S.LangOpts.CUDA)
551 : return true;
552 :
553 10 : S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << Attr.getName();
554 10 : return false;
555 : }
556 :
557 0 : static void matchRulesForCUDAConstant(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
558 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /*IsSupported=*/true));
559 0 : }
560 :
561 1313 : static bool checkCUDADeviceAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
562 1313 : if (!D || (!isa<FunctionDecl>(D) && !isa<VarDecl>(D))) {
563 0 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
564 : << Attr << "functions and variables";
565 0 : return false;
566 : }
567 : return true;
568 : }
569 :
570 0 : static void matchRulesForCUDADevice(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
571 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
572 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /*IsSupported=*/true));
573 0 : }
574 :
575 158 : static bool checkCUDAGlobalAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
576 158 : if (!D || (!isa<FunctionDecl>(D))) {
577 2 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
578 : << Attr << "functions";
579 2 : return false;
580 : }
581 : return true;
582 : }
583 :
584 0 : static void matchRulesForCUDAGlobal(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
585 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
586 0 : }
587 :
588 601 : static bool checkCUDAHostAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
589 601 : if (!D || (!isa<FunctionDecl>(D))) {
590 2 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
591 : << Attr << "functions";
592 2 : return false;
593 : }
594 : return true;
595 : }
596 :
597 0 : static void matchRulesForCUDAHost(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
598 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
599 0 : }
600 :
601 0 : static bool checkCUDAInvalidTargetAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
602 0 : if (!D || (!isa<FunctionDecl>(D))) {
603 0 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
604 : << Attr << "functions";
605 0 : return false;
606 : }
607 : return true;
608 : }
609 :
610 30 : static bool checkCUDALaunchBoundsAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
611 60 : if (!D || (!isa<ObjCMethodDecl>(D) && !isFunctionLike(D))) {
612 1 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
613 : << Attr << "Objective-C methods, functions, and function pointers";
614 1 : return false;
615 : }
616 : return true;
617 : }
618 :
619 0 : static void matchRulesForCUDALaunchBounds(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
620 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC1));
621 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_hasType_functionType, /*IsSupported=*/true));
622 0 : }
623 :
624 208 : static bool checkCUDASharedAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
625 208 : if (!D || (!isa<VarDecl>(D))) {
626 2 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
627 : << Attr << "variables";
628 2 : return false;
629 : }
630 : return true;
631 : }
632 :
633 0 : static void matchRulesForCUDAShared(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
634 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /*IsSupported=*/true));
635 0 : }
636 :
637 120696 : static bool checkCXX11NoReturnAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
638 120696 : if (!D || (!isa<FunctionDecl>(D))) {
639 6 : S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
640 : << Attr << "functions";
641 6 : return false;
642 : }
643 : return true;
644 : }
645 :
646 5 : static void matchRulesForCXX11NoReturn(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
647 5 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
648 5 : }
649 :
650 18 : static bool checkCallableWhenAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
651 18 : if (!D || (!isa<CXXMethodDecl>(D))) {
652 2 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
653 : << Attr << "functions";
654 2 : return false;
655 : }
656 : return true;
657 : }
658 :
659 0 : static void matchRulesForCallableWhen(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
660 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function_is_member, /*IsSupported=*/LangOpts.CPlusPlus));
661 0 : }
662 :
663 40 : static bool checkCapabilityAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
664 40 : if (!D || (!isa<RecordDecl>(D) && !isa<TypedefNameDecl>(D))) {
665 2 : S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
666 : << Attr << "structs, unions, classes, and typedefs";
667 2 : return false;
668 : }
669 : return true;
670 : }
671 :
672 0 : static unsigned CapabilityAttrSpellingMap(const ParsedAttr &Attr) {
673 : enum Spelling {
674 : GNU_capability = 0,
675 : CXX11_clang_capability = 1,
676 : GNU_shared_capability = 2,
677 : CXX11_clang_shared_capability = 3
678 : };
679 :
680 0 : unsigned Idx = Attr.getAttributeSpellingListIndex();
681 : switch (Idx) {
682 0 : default: llvm_unreachable("Unknown spelling list index");
683 : case 0: return GNU_capability;
684 : case 1: return CXX11_clang_capability;
685 : case 2: return GNU_shared_capability;
686 : case 3: return CXX11_clang_shared_capability;
687 : }
688 : }
689 :
690 0 : static void matchRulesForCapability(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
691 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true));
692 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_type_alias, /*IsSupported=*/true));
693 0 : }
694 :
695 30 : static bool checkCarriesDependencyAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
696 30 : if (!D || (!isa<ParmVarDecl>(D) && !isa<ObjCMethodDecl>(D) && !isa<FunctionDecl>(D))) {
697 4 : S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
698 : << Attr << "parameters, Objective-C methods, and functions";
699 4 : return false;
700 : }
701 : return true;
702 : }
703 :
704 0 : static void matchRulesForCarriesDependency(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
705 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_parameter, /*IsSupported=*/true));
706 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC1));
707 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
708 0 : }
709 :
710 39 : static bool isLocalVar(const Decl *D) {
711 : if (const auto *S = dyn_cast<VarDecl>(D))
712 39 : return S->hasLocalStorage() && !isa<ParmVarDecl>(S);
713 : return false;
714 : }
715 :
716 39 : static bool checkCleanupAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
717 39 : if (!D || (!isLocalVar(D))) {
718 5 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
719 : << Attr << "local variables";
720 5 : return false;
721 : }
722 : return true;
723 : }
724 :
725 81 : static bool checkCodeSegAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
726 81 : if (!D || (!isa<FunctionDecl>(D) && !isa<CXXRecordDecl>(D))) {
727 0 : S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
728 : << Attr << "functions and classes";
729 0 : return false;
730 : }
731 : return true;
732 : }
733 :
734 27 : static bool checkColdAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
735 27 : if (!D || (!isa<FunctionDecl>(D))) {
736 1 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
737 : << Attr << "functions";
738 1 : return false;
739 : }
740 : return true;
741 : }
742 :
743 0 : static void matchRulesForCold(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
744 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
745 0 : }
746 :
747 9 : static bool checkCommonAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
748 9 : if (!D || (!isa<VarDecl>(D))) {
749 0 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
750 : << Attr << "variables";
751 0 : return false;
752 : }
753 : return true;
754 : }
755 :
756 0 : static void matchRulesForCommon(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
757 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /*IsSupported=*/true));
758 0 : }
759 :
760 25 : static bool checkConstructorAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
761 25 : if (!D || (!isa<FunctionDecl>(D))) {
762 1 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
763 : << Attr << "functions";
764 1 : return false;
765 : }
766 : return true;
767 : }
768 :
769 0 : static void matchRulesForConstructor(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
770 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
771 0 : }
772 :
773 9 : static bool checkConsumableAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
774 9 : if (!D || (!isa<CXXRecordDecl>(D))) {
775 2 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
776 : << Attr << "classes";
777 2 : return false;
778 : }
779 : return true;
780 : }
781 :
782 0 : static void matchRulesForConsumable(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
783 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true));
784 0 : }
785 :
786 2 : static bool checkConsumableAutoCastAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
787 2 : if (!D || (!isa<CXXRecordDecl>(D))) {
788 0 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
789 : << Attr << "classes";
790 0 : return false;
791 : }
792 : return true;
793 : }
794 :
795 0 : static void matchRulesForConsumableAutoCast(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
796 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true));
797 0 : }
798 :
799 2 : static bool checkConsumableSetOnReadAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
800 2 : if (!D || (!isa<CXXRecordDecl>(D))) {
801 0 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
802 : << Attr << "classes";
803 0 : return false;
804 : }
805 : return true;
806 : }
807 :
808 0 : static void matchRulesForConsumableSetOnRead(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
809 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true));
810 0 : }
811 :
812 3197 : static bool checkConvergentAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
813 3197 : if (!D || (!isa<FunctionDecl>(D))) {
814 2 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
815 : << Attr << "functions";
816 2 : return false;
817 : }
818 : return true;
819 : }
820 :
821 0 : static void matchRulesForConvergent(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
822 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
823 0 : }
824 :
825 3455 : static bool checkDLLExportAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
826 3455 : if (!D || (!isa<FunctionDecl>(D) && !isa<VarDecl>(D) && !isa<CXXRecordDecl>(D) && !isa<ObjCInterfaceDecl>(D))) {
827 68 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
828 : << Attr << "functions, variables, classes, and Objective-C interfaces";
829 68 : return false;
830 : }
831 : return true;
832 : }
833 :
834 15081 : static bool isTargetx86x86_64armthumbaarch64Win32(const TargetInfo &Target) {
835 : const llvm::Triple &T = Target.getTriple();
836 15081 : return true && (T.getArch() == llvm::Triple::x86 || T.getArch() == llvm::Triple::x86_64 || T.getArch() == llvm::Triple::arm || T.getArch() == llvm::Triple::thumb || T.getArch() == llvm::Triple::aarch64) && (T.getOS() == llvm::Triple::Win32);
837 : }
838 :
839 1 : static void matchRulesForDLLExport(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
840 1 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
841 1 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /*IsSupported=*/true));
842 1 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true));
843 2 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_interface, /*IsSupported=*/LangOpts.ObjC1));
844 1 : }
845 :
846 4139 : static bool checkDLLImportAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
847 4139 : if (!D || (!isa<FunctionDecl>(D) && !isa<VarDecl>(D) && !isa<CXXRecordDecl>(D) && !isa<ObjCInterfaceDecl>(D))) {
848 74 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
849 : << Attr << "functions, variables, classes, and Objective-C interfaces";
850 74 : return false;
851 : }
852 : return true;
853 : }
854 :
855 0 : static void matchRulesForDLLImport(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
856 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
857 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /*IsSupported=*/true));
858 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true));
859 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_interface, /*IsSupported=*/LangOpts.ObjC1));
860 0 : }
861 :
862 25 : static bool checkDestructorAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
863 25 : if (!D || (!isa<FunctionDecl>(D))) {
864 1 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
865 : << Attr << "functions";
866 1 : return false;
867 : }
868 : return true;
869 : }
870 :
871 0 : static void matchRulesForDestructor(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
872 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
873 0 : }
874 :
875 77860 : static bool checkDiagnoseIfAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
876 77860 : if (!D || (!isa<FunctionDecl>(D) && !isa<ObjCMethodDecl>(D) && !isa<ObjCPropertyDecl>(D))) {
877 0 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
878 : << Attr << "functions, Objective-C methods, and Objective-C properties";
879 0 : return false;
880 : }
881 : return true;
882 : }
883 :
884 15 : static bool checkDisableTailCallsAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
885 15 : if (!D || (!isa<FunctionDecl>(D) && !isa<ObjCMethodDecl>(D))) {
886 1 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
887 : << Attr << "functions and Objective-C methods";
888 1 : return false;
889 : }
890 : return true;
891 : }
892 :
893 1 : static void matchRulesForDisableTailCalls(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
894 1 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
895 2 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC1));
896 1 : }
897 :
898 14 : static bool checkEmptyBasesAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
899 14 : if (!D || (!isa<CXXRecordDecl>(D))) {
900 4 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
901 : << Attr << "classes";
902 4 : return false;
903 : }
904 : return true;
905 : }
906 :
907 52 : static bool isTargetx86x86_64armthumbaarch64Microsoft(const TargetInfo &Target) {
908 : const llvm::Triple &T = Target.getTriple();
909 52 : return true && (T.getArch() == llvm::Triple::x86 || T.getArch() == llvm::Triple::x86_64 || T.getArch() == llvm::Triple::arm || T.getArch() == llvm::Triple::thumb || T.getArch() == llvm::Triple::aarch64) && (Target.getCXXABI().getKind() == TargetCXXABI::Microsoft);
910 : }
911 :
912 52388 : static bool checkEnableIfAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
913 52388 : if (!D || (!isa<FunctionDecl>(D))) {
914 1 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
915 : << Attr << "functions";
916 1 : return false;
917 : }
918 : return true;
919 : }
920 :
921 0 : static void matchRulesForEnableIf(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
922 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
923 0 : }
924 :
925 14 : static bool checkEnumExtensibilityAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
926 14 : if (!D || (!isa<EnumDecl>(D))) {
927 1 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
928 : << Attr << "enums";
929 1 : return false;
930 : }
931 : return true;
932 : }
933 :
934 0 : static void matchRulesForEnumExtensibility(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
935 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_enum, /*IsSupported=*/true));
936 0 : }
937 :
938 29 : static bool checkExcludeFromExplicitInstantiationAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
939 29 : if (!D || (!isa<VarDecl>(D) && !isa<FunctionDecl>(D) && !isa<CXXRecordDecl>(D))) {
940 0 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
941 : << Attr << "variables, functions, and classes";
942 0 : return false;
943 : }
944 : return true;
945 : }
946 :
947 0 : static void matchRulesForExcludeFromExplicitInstantiation(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
948 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /*IsSupported=*/true));
949 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
950 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true));
951 0 : }
952 :
953 96 : static bool checkExclusiveTrylockFunctionAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
954 96 : if (!D || (!isa<FunctionDecl>(D))) {
955 15 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
956 : << Attr << "functions";
957 15 : return false;
958 : }
959 : return true;
960 : }
961 :
962 1761 : static bool checkExtVectorTypeAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
963 1761 : if (!D || (!isa<TypedefNameDecl>(D))) {
964 4 : S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
965 : << Attr << "typedefs";
966 4 : return false;
967 : }
968 : return true;
969 : }
970 :
971 64 : static bool checkExternalSourceSymbolAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
972 64 : if (!D || (!isa<NamedDecl>(D))) {
973 1 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
974 : << Attr << "named declarations";
975 1 : return false;
976 : }
977 : return true;
978 : }
979 :
980 2 : static void matchRulesForExternalSourceSymbol(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
981 2 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true));
982 2 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_enum, /*IsSupported=*/true));
983 2 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_enum_constant, /*IsSupported=*/true));
984 2 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_field, /*IsSupported=*/true));
985 2 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
986 4 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_namespace, /*IsSupported=*/LangOpts.CPlusPlus));
987 4 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_category, /*IsSupported=*/LangOpts.ObjC1));
988 4 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_interface, /*IsSupported=*/LangOpts.ObjC1));
989 4 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC1));
990 4 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_property, /*IsSupported=*/LangOpts.ObjC1));
991 4 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_protocol, /*IsSupported=*/LangOpts.ObjC1));
992 2 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true));
993 2 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_type_alias, /*IsSupported=*/true));
994 2 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /*IsSupported=*/true));
995 2 : }
996 :
997 14 : static bool checkFlagEnumAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
998 14 : if (!D || (!isa<EnumDecl>(D))) {
999 0 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
1000 : << Attr << "enums";
1001 0 : return false;
1002 : }
1003 : return true;
1004 : }
1005 :
1006 0 : static void matchRulesForFlagEnum(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
1007 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_enum, /*IsSupported=*/true));
1008 0 : }
1009 :
1010 18 : static bool checkFlattenAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
1011 18 : if (!D || (!isa<FunctionDecl>(D))) {
1012 6 : S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
1013 : << Attr << "functions";
1014 6 : return false;
1015 : }
1016 : return true;
1017 : }
1018 :
1019 0 : static void matchRulesForFlatten(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
1020 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
1021 0 : }
1022 :
1023 36387 : static bool checkFormatAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
1024 36387 : if (!D || (!isa<ObjCMethodDecl>(D) && !isa<BlockDecl>(D) && !isHasFunctionProto(D))) {
1025 0 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
1026 : << Attr << "Objective-C methods, blocks, and non-K&R-style functions";
1027 0 : return false;
1028 : }
1029 : return true;
1030 : }
1031 :
1032 686 : static bool checkFormatArgAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
1033 686 : if (!D || (!isa<ObjCMethodDecl>(D) && !isHasFunctionProto(D))) {
1034 3 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
1035 : << Attr << "Objective-C methods and non-K&R-style functions";
1036 3 : return false;
1037 : }
1038 : return true;
1039 : }
1040 :
1041 7117 : static bool checkGNUInlineAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
1042 7117 : if (!D || (!isa<FunctionDecl>(D))) {
1043 0 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
1044 : << Attr << "functions";
1045 0 : return false;
1046 : }
1047 : return true;
1048 : }
1049 :
1050 0 : static void matchRulesForGNUInline(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
1051 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
1052 0 : }
1053 :
1054 571 : static bool checkGuardedByAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
1055 571 : if (!D || (!isa<FieldDecl>(D) && !isSharedVar(D))) {
1056 14 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
1057 : << Attr << "non-static data members and global variables";
1058 14 : return false;
1059 : }
1060 : return true;
1061 : }
1062 :
1063 31 : static bool checkGuardedVarAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
1064 31 : if (!D || (!isa<FieldDecl>(D) && !isSharedVar(D))) {
1065 12 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
1066 : << Attr << "non-static data members and global variables";
1067 12 : return false;
1068 : }
1069 : return true;
1070 : }
1071 :
1072 4 : static bool checkHotAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
1073 4 : if (!D || (!isa<FunctionDecl>(D))) {
1074 1 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
1075 : << Attr << "functions";
1076 1 : return false;
1077 : }
1078 : return true;
1079 : }
1080 :
1081 0 : static void matchRulesForHot(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
1082 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
1083 0 : }
1084 :
1085 : static bool isObjCInstanceMethod(const Decl *D) {
1086 : if (const auto *S = dyn_cast<ObjCMethodDecl>(D))
1087 4 : return S->isInstanceMethod();
1088 : return false;
1089 : }
1090 :
1091 57 : static bool checkIBActionAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
1092 114 : if (!D || (!isObjCInstanceMethod(D))) {
1093 2 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
1094 : << Attr << "Objective-C instance methods";
1095 2 : return false;
1096 : }
1097 : return true;
1098 : }
1099 :
1100 0 : static void matchRulesForIBAction(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
1101 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method_is_instance, /*IsSupported=*/LangOpts.ObjC1));
1102 0 : }
1103 :
1104 11 : static bool checkIFuncAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
1105 11 : if (!D || (!isa<FunctionDecl>(D))) {
1106 0 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
1107 : << Attr << "functions";
1108 0 : return false;
1109 : }
1110 : return true;
1111 : }
1112 :
1113 23 : static bool isTargetELF(const TargetInfo &Target) {
1114 : const llvm::Triple &T = Target.getTriple();
1115 23 : return true && (T.getObjectFormat() == llvm::Triple::ELF);
1116 : }
1117 :
1118 0 : static void matchRulesForIFunc(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
1119 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
1120 0 : }
1121 :
1122 605 : static bool checkInitPriorityAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
1123 605 : if (!D || (!isa<VarDecl>(D))) {
1124 1 : S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
1125 : << Attr << "variables";
1126 1 : return false;
1127 : }
1128 : return true;
1129 : }
1130 :
1131 0 : static void matchRulesForInitPriority(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
1132 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /*IsSupported=*/true));
1133 0 : }
1134 :
1135 42 : static bool checkInternalLinkageAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
1136 42 : if (!D || (!isa<VarDecl>(D) && !isa<FunctionDecl>(D) && !isa<CXXRecordDecl>(D))) {
1137 5 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
1138 : << Attr << "variables, functions, and classes";
1139 5 : return false;
1140 : }
1141 : return true;
1142 : }
1143 :
1144 0 : static void matchRulesForInternalLinkage(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
1145 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /*IsSupported=*/true));
1146 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
1147 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true));
1148 0 : }
1149 :
1150 11 : static bool checkLTOVisibilityPublicAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
1151 11 : if (!D || (!isa<RecordDecl>(D))) {
1152 5 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
1153 : << Attr << "structs, unions, and classes";
1154 5 : return false;
1155 : }
1156 : return true;
1157 : }
1158 :
1159 0 : static void matchRulesForLTOVisibilityPublic(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
1160 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true));
1161 0 : }
1162 :
1163 8 : static bool checkLayoutVersionAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
1164 8 : if (!D || (!isa<CXXRecordDecl>(D))) {
1165 4 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
1166 : << Attr << "classes";
1167 4 : return false;
1168 : }
1169 : return true;
1170 : }
1171 :
1172 0 : static bool isImplicitObjectParameter(const Decl *D) {
1173 : if (const auto *S = dyn_cast<FunctionDecl>(D))
1174 : return static_cast<void>(S), false;
1175 : return false;
1176 : }
1177 :
1178 13 : static bool checkLifetimeBoundAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
1179 13 : if (!D || (!isa<ParmVarDecl>(D) && !isImplicitObjectParameter(D))) {
1180 1 : S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
1181 : << Attr << "parameters and implicit object parameters";
1182 1 : return false;
1183 : }
1184 : return true;
1185 : }
1186 :
1187 231 : static bool checkCPlusPlusLangOpts(Sema &S, const ParsedAttr &Attr) {
1188 231 : if (S.LangOpts.CPlusPlus)
1189 : return true;
1190 :
1191 1 : S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << Attr.getName();
1192 1 : return false;
1193 : }
1194 :
1195 101 : static bool checkLockReturnedAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
1196 101 : if (!D || (!isa<FunctionDecl>(D))) {
1197 15 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
1198 : << Attr << "functions";
1199 15 : return false;
1200 : }
1201 : return true;
1202 : }
1203 :
1204 61 : static bool checkLockableAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
1205 61 : if (!D || (!isa<RecordDecl>(D))) {
1206 18 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
1207 : << Attr << "structs, unions, and classes";
1208 18 : return false;
1209 : }
1210 : return true;
1211 : }
1212 :
1213 0 : static void matchRulesForLockable(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
1214 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true));
1215 0 : }
1216 :
1217 149 : static bool checkLocksExcludedAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
1218 149 : if (!D || (!isa<FunctionDecl>(D))) {
1219 15 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
1220 : << Attr << "functions";
1221 15 : return false;
1222 : }
1223 : return true;
1224 : }
1225 :
1226 0 : static unsigned LoopHintAttrSpellingMap(const ParsedAttr &Attr) {
1227 : enum Spelling {
1228 : Pragma_clang_loop = 0,
1229 : Pragma_unroll = 1,
1230 : Pragma_nounroll = 2,
1231 : Pragma_unroll_and_jam = 3,
1232 : Pragma_nounroll_and_jam = 4
1233 : };
1234 :
1235 0 : unsigned Idx = Attr.getAttributeSpellingListIndex();
1236 : switch (Idx) {
1237 0 : default: llvm_unreachable("Unknown spelling list index");
1238 : case 0: return Pragma_clang_loop;
1239 : case 1: return Pragma_unroll;
1240 : case 2: return Pragma_nounroll;
1241 : case 3: return Pragma_unroll_and_jam;
1242 : case 4: return Pragma_nounroll_and_jam;
1243 : }
1244 : }
1245 :
1246 113 : static bool checkMicrosoftExtLangOpts(Sema &S, const ParsedAttr &Attr) {
1247 113 : if (S.LangOpts.MicrosoftExt)
1248 : return true;
1249 :
1250 0 : S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << Attr.getName();
1251 0 : return false;
1252 : }
1253 :
1254 58 : static unsigned MSInheritanceAttrSpellingMap(const ParsedAttr &Attr) {
1255 : enum Spelling {
1256 : Keyword_single_inheritance = 0,
1257 : Keyword_multiple_inheritance = 1,
1258 : Keyword_virtual_inheritance = 2,
1259 : Keyword_unspecified_inheritance = 3
1260 : };
1261 :
1262 58 : unsigned Idx = Attr.getAttributeSpellingListIndex();
1263 : switch (Idx) {
1264 0 : default: llvm_unreachable("Unknown spelling list index");
1265 : case 0: return Keyword_single_inheritance;
1266 : case 1: return Keyword_multiple_inheritance;
1267 : case 2: return Keyword_virtual_inheritance;
1268 : case 3: return Keyword_unspecified_inheritance;
1269 : }
1270 : }
1271 :
1272 10 : static bool checkMSNoVTableAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
1273 10 : if (!D || (!isa<CXXRecordDecl>(D))) {
1274 4 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
1275 : << Attr << "classes";
1276 4 : return false;
1277 : }
1278 : return true;
1279 : }
1280 :
1281 75 : static bool checkMSStructAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
1282 75 : if (!D || (!isa<RecordDecl>(D))) {
1283 2 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
1284 : << Attr << "structs, unions, and classes";
1285 2 : return false;
1286 : }
1287 : return true;
1288 : }
1289 :
1290 0 : static void matchRulesForMSStruct(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
1291 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true));
1292 0 : }
1293 :
1294 7 : static bool checkMicroMipsAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
1295 7 : if (!D || (!isa<FunctionDecl>(D))) {
1296 1 : S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
1297 : << Attr << "functions";
1298 1 : return false;
1299 : }
1300 : return true;
1301 : }
1302 :
1303 56 : static bool isTargetmipsmipsel(const TargetInfo &Target) {
1304 : const llvm::Triple &T = Target.getTriple();
1305 56 : return true && (T.getArch() == llvm::Triple::mips || T.getArch() == llvm::Triple::mipsel);
1306 : }
1307 :
1308 0 : static void matchRulesForMicroMips(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
1309 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
1310 0 : }
1311 :
1312 25 : static bool checkMinSizeAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
1313 25 : if (!D || (!isa<FunctionDecl>(D) && !isa<ObjCMethodDecl>(D))) {
1314 1 : S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
1315 : << Attr << "functions and Objective-C methods";
1316 1 : return false;
1317 : }
1318 : return true;
1319 : }
1320 :
1321 0 : static void matchRulesForMinSize(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
1322 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
1323 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC1));
1324 0 : }
1325 :
1326 492746 : static bool checkMinVectorWidthAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
1327 492746 : if (!D || (!isa<FunctionDecl>(D))) {
1328 1 : S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
1329 : << Attr << "functions";
1330 1 : return false;
1331 : }
1332 : return true;
1333 : }
1334 :
1335 0 : static void matchRulesForMinVectorWidth(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
1336 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
1337 0 : }
1338 :
1339 14 : static bool checkMips16AppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
1340 14 : if (!D || (!isa<FunctionDecl>(D))) {
1341 1 : S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
1342 : << Attr << "functions";
1343 1 : return false;
1344 : }
1345 : return true;
1346 : }
1347 :
1348 0 : static void matchRulesForMips16(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
1349 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
1350 0 : }
1351 :
1352 24 : static bool checkMipsLongCallAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
1353 24 : if (!D || (!isa<FunctionDecl>(D))) {
1354 4 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
1355 : << Attr << "functions";
1356 4 : return false;
1357 : }
1358 : return true;
1359 : }
1360 :
1361 80 : static bool isTargetmipsmipselmips64mips64el(const TargetInfo &Target) {
1362 : const llvm::Triple &T = Target.getTriple();
1363 80 : return true && (T.getArch() == llvm::Triple::mips || T.getArch() == llvm::Triple::mipsel || T.getArch() == llvm::Triple::mips64 || T.getArch() == llvm::Triple::mips64el);
1364 : }
1365 :
1366 0 : static unsigned MipsLongCallAttrSpellingMap(const ParsedAttr &Attr) {
1367 : enum Spelling {
1368 : GNU_long_call = 0,
1369 : CXX11_gnu_long_call = 1,
1370 : GNU_far = 2,
1371 : CXX11_gnu_far = 3
1372 : };
1373 :
1374 0 : unsigned Idx = Attr.getAttributeSpellingListIndex();
1375 : switch (Idx) {
1376 0 : default: llvm_unreachable("Unknown spelling list index");
1377 : case 0: return GNU_long_call;
1378 : case 1: return CXX11_gnu_long_call;
1379 : case 2: return GNU_far;
1380 : case 3: return CXX11_gnu_far;
1381 : }
1382 : }
1383 :
1384 0 : static void matchRulesForMipsLongCall(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
1385 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
1386 0 : }
1387 :
1388 24 : static bool checkMipsShortCallAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
1389 24 : if (!D || (!isa<FunctionDecl>(D))) {
1390 4 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
1391 : << Attr << "functions";
1392 4 : return false;
1393 : }
1394 : return true;
1395 : }
1396 :
1397 0 : static unsigned MipsShortCallAttrSpellingMap(const ParsedAttr &Attr) {
1398 : enum Spelling {
1399 : GNU_short_call = 0,
1400 : CXX11_gnu_short_call = 1,
1401 : GNU_near = 2,
1402 : CXX11_gnu_near = 3
1403 : };
1404 :
1405 0 : unsigned Idx = Attr.getAttributeSpellingListIndex();
1406 : switch (Idx) {
1407 0 : default: llvm_unreachable("Unknown spelling list index");
1408 : case 0: return GNU_short_call;
1409 : case 1: return CXX11_gnu_short_call;
1410 : case 2: return GNU_near;
1411 : case 3: return CXX11_gnu_near;
1412 : }
1413 : }
1414 :
1415 0 : static void matchRulesForMipsShortCall(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
1416 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
1417 0 : }
1418 :
1419 26392 : static bool checkModeAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
1420 26392 : if (!D || (!isa<VarDecl>(D) && !isa<EnumDecl>(D) && !isa<TypedefNameDecl>(D) && !isa<FieldDecl>(D))) {
1421 9 : S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
1422 : << Attr << "variables, enums, typedefs, and non-static data members";
1423 9 : return false;
1424 : }
1425 : return true;
1426 : }
1427 :
1428 112 : static bool checkNSConsumedAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
1429 112 : if (!D || (!isa<ParmVarDecl>(D))) {
1430 0 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
1431 : << Attr << "parameters";
1432 0 : return false;
1433 : }
1434 : return true;
1435 : }
1436 :
1437 0 : static void matchRulesForNSConsumed(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
1438 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_parameter, /*IsSupported=*/true));
1439 0 : }
1440 :
1441 20 : static bool checkNSConsumesSelfAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
1442 20 : if (!D || (!isa<ObjCMethodDecl>(D))) {
1443 0 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
1444 : << Attr << "Objective-C methods";
1445 0 : return false;
1446 : }
1447 : return true;
1448 : }
1449 :
1450 0 : static void matchRulesForNSConsumesSelf(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
1451 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC1));
1452 0 : }
1453 :
1454 34 : static bool checkNakedAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
1455 34 : if (!D || (!isa<FunctionDecl>(D))) {
1456 1 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
1457 : << Attr << "functions";
1458 1 : return false;
1459 : }
1460 : return true;
1461 : }
1462 :
1463 0 : static void matchRulesForNaked(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
1464 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
1465 0 : }
1466 :
1467 2 : static bool checkNoAliasAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
1468 2 : if (!D || (!isa<FunctionDecl>(D))) {
1469 0 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
1470 : << Attr << "functions";
1471 0 : return false;
1472 : }
1473 : return true;
1474 : }
1475 :
1476 4 : static bool checkNoCommonAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
1477 4 : if (!D || (!isa<VarDecl>(D))) {
1478 0 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
1479 : << Attr << "variables";
1480 0 : return false;
1481 : }
1482 : return true;
1483 : }
1484 :
1485 0 : static void matchRulesForNoCommon(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
1486 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /*IsSupported=*/true));
1487 0 : }
1488 :
1489 : static bool isNonParmVar(const Decl *D) {
1490 : if (const auto *S = dyn_cast<VarDecl>(D))
1491 7 : return S->getKind() != Decl::ParmVar;
1492 : return false;
1493 : }
1494 :
1495 725186 : static bool checkNoDebugAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
1496 1450383 : if (!D || (!isFunctionLike(D) && !isa<ObjCMethodDecl>(D) && !isNonParmVar(D))) {
1497 1 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
1498 : << Attr << "functions, function pointers, Objective-C methods, and variables";
1499 1 : return false;
1500 : }
1501 : return true;
1502 : }
1503 :
1504 0 : static void matchRulesForNoDebug(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
1505 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_hasType_functionType, /*IsSupported=*/true));
1506 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC1));
1507 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_not_is_parameter, /*IsSupported=*/true));
1508 0 : }
1509 :
1510 19 : static bool checkNoDestroyAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
1511 19 : if (!D || (!isa<VarDecl>(D))) {
1512 2 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
1513 : << Attr << "variables";
1514 2 : return false;
1515 : }
1516 : return true;
1517 : }
1518 :
1519 0 : static void matchRulesForNoDestroy(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
1520 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /*IsSupported=*/true));
1521 0 : }
1522 :
1523 7 : static bool checkNoDuplicateAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
1524 7 : if (!D || (!isa<FunctionDecl>(D))) {
1525 1 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
1526 : << Attr << "functions";
1527 1 : return false;
1528 : }
1529 : return true;
1530 : }
1531 :
1532 0 : static void matchRulesForNoDuplicate(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
1533 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
1534 0 : }
1535 :
1536 94 : static bool checkNoEscapeAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
1537 94 : if (!D || (!isa<ParmVarDecl>(D))) {
1538 2 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
1539 : << Attr << "parameters";
1540 2 : return false;
1541 : }
1542 : return true;
1543 : }
1544 :
1545 0 : static void matchRulesForNoEscape(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
1546 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_parameter, /*IsSupported=*/true));
1547 0 : }
1548 :
1549 387 : static bool checkNoInlineAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
1550 387 : if (!D || (!isa<FunctionDecl>(D))) {
1551 1 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
1552 : << Attr << "functions";
1553 1 : return false;
1554 : }
1555 : return true;
1556 : }
1557 :
1558 0 : static void matchRulesForNoInline(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
1559 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
1560 0 : }
1561 :
1562 27 : static bool checkNoInstrumentFunctionAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
1563 27 : if (!D || (!isa<FunctionDecl>(D))) {
1564 0 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
1565 : << Attr << "functions";
1566 0 : return false;
1567 : }
1568 : return true;
1569 : }
1570 :
1571 0 : static void matchRulesForNoInstrumentFunction(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
1572 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
1573 0 : }
1574 :
1575 4 : static bool checkNoMicroMipsAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
1576 4 : if (!D || (!isa<FunctionDecl>(D))) {
1577 1 : S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
1578 : << Attr << "functions";
1579 1 : return false;
1580 : }
1581 : return true;
1582 : }
1583 :
1584 0 : static void matchRulesForNoMicroMips(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
1585 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
1586 0 : }
1587 :
1588 7 : static bool checkNoMips16AppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
1589 7 : if (!D || (!isa<FunctionDecl>(D))) {
1590 1 : S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
1591 : << Attr << "functions";
1592 1 : return false;
1593 : }
1594 : return true;
1595 : }
1596 :
1597 0 : static void matchRulesForNoMips16(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
1598 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
1599 0 : }
1600 :
1601 68943 : static bool checkNoSanitizeAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
1602 68945 : if (!D || (!isa<FunctionDecl>(D) && !isa<ObjCMethodDecl>(D) && !isGlobalVar(D))) {
1603 0 : S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
1604 : << Attr << "functions, Objective-C methods, and global variables";
1605 0 : return false;
1606 : }
1607 : return true;
1608 : }
1609 :
1610 0 : static void matchRulesForNoSanitize(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
1611 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
1612 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC1));
1613 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_global, /*IsSupported=*/true));
1614 0 : }
1615 :
1616 73 : static bool checkNoSanitizeSpecificAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
1617 81 : if (!D || (!isa<FunctionDecl>(D) && !isGlobalVar(D))) {
1618 12 : S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
1619 : << Attr << "functions and global variables";
1620 12 : return false;
1621 : }
1622 : return true;
1623 : }
1624 :
1625 0 : static void matchRulesForNoSanitizeSpecific(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
1626 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
1627 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_global, /*IsSupported=*/true));
1628 0 : }
1629 :
1630 22 : static bool checkNoSplitStackAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
1631 22 : if (!D || (!isa<FunctionDecl>(D))) {
1632 6 : S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
1633 : << Attr << "functions";
1634 6 : return false;
1635 : }
1636 : return true;
1637 : }
1638 :
1639 0 : static void matchRulesForNoSplitStack(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
1640 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
1641 0 : }
1642 :
1643 12 : static bool checkNoStackProtectorAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
1644 12 : if (!D || (!isa<FunctionDecl>(D))) {
1645 1 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
1646 : << Attr << "functions";
1647 1 : return false;
1648 : }
1649 : return true;
1650 : }
1651 :
1652 0 : static void matchRulesForNoStackProtector(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
1653 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
1654 0 : }
1655 :
1656 64 : static bool checkNoThreadSafetyAnalysisAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
1657 64 : if (!D || (!isa<FunctionDecl>(D))) {
1658 18 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
1659 : << Attr << "functions";
1660 18 : return false;
1661 : }
1662 : return true;
1663 : }
1664 :
1665 0 : static void matchRulesForNoThreadSafetyAnalysis(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
1666 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
1667 0 : }
1668 :
1669 52164 : static bool checkNoThrowAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
1670 52164 : if (!D || (!isa<FunctionDecl>(D))) {
1671 0 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
1672 : << Attr << "functions";
1673 0 : return false;
1674 : }
1675 : return true;
1676 : }
1677 :
1678 0 : static void matchRulesForNoThrow(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
1679 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
1680 0 : }
1681 :
1682 1028754 : static bool checkNonNullAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
1683 1028754 : if (!D || (!isa<ObjCMethodDecl>(D) && !isHasFunctionProto(D) && !isa<ParmVarDecl>(D))) {
1684 2 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
1685 : << Attr << "functions, methods, and parameters";
1686 2 : return false;
1687 : }
1688 : return true;
1689 : }
1690 :
1691 12 : static bool checkNotTailCalledAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
1692 12 : if (!D || (!isa<FunctionDecl>(D))) {
1693 1 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
1694 : << Attr << "functions";
1695 1 : return false;
1696 : }
1697 : return true;
1698 : }
1699 :
1700 0 : static void matchRulesForNotTailCalled(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
1701 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
1702 0 : }
1703 :
1704 57 : static bool checkObjCBoxableAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
1705 57 : if (!D || (!isa<RecordDecl>(D))) {
1706 0 : S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
1707 : << Attr << "structs, unions, and classes";
1708 0 : return false;
1709 : }
1710 : return true;
1711 : }
1712 :
1713 0 : static void matchRulesForObjCBoxable(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
1714 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true));
1715 0 : }
1716 :
1717 71 : static bool checkObjCBridgeAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
1718 71 : if (!D || (!isa<RecordDecl>(D) && !isa<TypedefNameDecl>(D))) {
1719 2 : S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
1720 : << Attr << "structs, unions, classes, and typedefs";
1721 2 : return false;
1722 : }
1723 : return true;
1724 : }
1725 :
1726 0 : static void matchRulesForObjCBridge(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
1727 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true));
1728 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_type_alias, /*IsSupported=*/true));
1729 0 : }
1730 :
1731 7 : static bool checkObjCBridgeMutableAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
1732 7 : if (!D || (!isa<RecordDecl>(D))) {
1733 0 : S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
1734 : << Attr << "structs, unions, and classes";
1735 0 : return false;
1736 : }
1737 : return true;
1738 : }
1739 :
1740 0 : static void matchRulesForObjCBridgeMutable(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
1741 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true));
1742 0 : }
1743 :
1744 26 : static bool checkObjCBridgeRelatedAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
1745 26 : if (!D || (!isa<RecordDecl>(D))) {
1746 0 : S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
1747 : << Attr << "structs, unions, and classes";
1748 0 : return false;
1749 : }
1750 : return true;
1751 : }
1752 :
1753 1 : static void matchRulesForObjCBridgeRelated(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
1754 1 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true));
1755 1 : }
1756 :
1757 36 : static bool isObjCInterfaceDeclInitMethod(const Decl *D) {
1758 : if (const auto *S = dyn_cast<ObjCMethodDecl>(D))
1759 68 : return S->getMethodFamily() == OMF_init &&
1760 9 : (isa<ObjCInterfaceDecl>(S->getDeclContext()) ||
1761 6 : (isa<ObjCCategoryDecl>(S->getDeclContext()) &&
1762 : cast<ObjCCategoryDecl>(S->getDeclContext())->IsClassExtension()));
1763 : return false;
1764 : }
1765 :
1766 36 : static bool checkObjCDesignatedInitializerAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
1767 36 : if (!D || (!isObjCInterfaceDeclInitMethod(D))) {
1768 8 : S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
1769 : << Attr << "init methods of interface or class extension declarations";
1770 8 : return false;
1771 : }
1772 : return true;
1773 : }
1774 :
1775 31 : static bool checkObjCExceptionAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
1776 31 : if (!D || (!isa<ObjCInterfaceDecl>(D))) {
1777 2 : S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
1778 : << Attr << "Objective-C interfaces";
1779 2 : return false;
1780 : }
1781 : return true;
1782 : }
1783 :
1784 0 : static void matchRulesForObjCException(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
1785 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_interface, /*IsSupported=*/LangOpts.ObjC1));
1786 0 : }
1787 :
1788 14 : static bool checkObjCExplicitProtocolImplAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
1789 14 : if (!D || (!isa<ObjCProtocolDecl>(D))) {
1790 2 : S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
1791 : << Attr << "Objective-C protocols";
1792 2 : return false;
1793 : }
1794 : return true;
1795 : }
1796 :
1797 0 : static void matchRulesForObjCExplicitProtocolImpl(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
1798 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_protocol, /*IsSupported=*/LangOpts.ObjC1));
1799 0 : }
1800 :
1801 13 : static bool checkObjCMethodFamilyAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
1802 13 : if (!D || (!isa<ObjCMethodDecl>(D))) {
1803 0 : S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
1804 : << Attr << "Objective-C methods";
1805 0 : return false;
1806 : }
1807 : return true;
1808 : }
1809 :
1810 0 : static void matchRulesForObjCMethodFamily(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
1811 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC1));
1812 0 : }
1813 :
1814 10 : static bool checkObjCPreciseLifetimeAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
1815 10 : if (!D || (!isa<VarDecl>(D))) {
1816 0 : S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
1817 : << Attr << "variables";
1818 0 : return false;
1819 : }
1820 : return true;
1821 : }
1822 :
1823 0 : static void matchRulesForObjCPreciseLifetime(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
1824 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /*IsSupported=*/true));
1825 0 : }
1826 :
1827 10 : static bool checkObjCRequiresPropertyDefsAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
1828 10 : if (!D || (!isa<ObjCInterfaceDecl>(D))) {
1829 4 : S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
1830 : << Attr << "Objective-C interfaces";
1831 4 : return false;
1832 : }
1833 : return true;
1834 : }
1835 :
1836 0 : static void matchRulesForObjCRequiresPropertyDefs(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
1837 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_interface, /*IsSupported=*/LangOpts.ObjC1));
1838 0 : }
1839 :
1840 53 : static bool checkObjCRequiresSuperAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
1841 53 : if (!D || (!isa<ObjCMethodDecl>(D))) {
1842 0 : S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
1843 : << Attr << "Objective-C methods";
1844 0 : return false;
1845 : }
1846 : return true;
1847 : }
1848 :
1849 0 : static void matchRulesForObjCRequiresSuper(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
1850 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC1));
1851 0 : }
1852 :
1853 28 : static bool checkObjCReturnsInnerPointerAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
1854 28 : if (!D || (!isa<ObjCMethodDecl>(D) && !isa<ObjCPropertyDecl>(D))) {
1855 1 : S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
1856 : << Attr << "Objective-C methods and Objective-C properties";
1857 1 : return false;
1858 : }
1859 : return true;
1860 : }
1861 :
1862 0 : static void matchRulesForObjCReturnsInnerPointer(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
1863 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC1));
1864 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_property, /*IsSupported=*/LangOpts.ObjC1));
1865 0 : }
1866 :
1867 165 : static bool checkObjCRootClassAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
1868 165 : if (!D || (!isa<ObjCInterfaceDecl>(D))) {
1869 1 : S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
1870 : << Attr << "Objective-C interfaces";
1871 1 : return false;
1872 : }
1873 : return true;
1874 : }
1875 :
1876 0 : static void matchRulesForObjCRootClass(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
1877 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_interface, /*IsSupported=*/LangOpts.ObjC1));
1878 0 : }
1879 :
1880 36 : static bool checkObjCRuntimeNameAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
1881 36 : if (!D || (!isa<ObjCInterfaceDecl>(D) && !isa<ObjCProtocolDecl>(D))) {
1882 6 : S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
1883 : << Attr << "Objective-C interfaces and Objective-C protocols";
1884 6 : return false;
1885 : }
1886 : return true;
1887 : }
1888 :
1889 0 : static void matchRulesForObjCRuntimeName(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
1890 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_interface, /*IsSupported=*/LangOpts.ObjC1));
1891 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_protocol, /*IsSupported=*/LangOpts.ObjC1));
1892 0 : }
1893 :
1894 4 : static bool checkObjCRuntimeVisibleAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
1895 4 : if (!D || (!isa<ObjCInterfaceDecl>(D))) {
1896 0 : S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
1897 : << Attr << "Objective-C interfaces";
1898 0 : return false;
1899 : }
1900 : return true;
1901 : }
1902 :
1903 0 : static void matchRulesForObjCRuntimeVisible(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
1904 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_interface, /*IsSupported=*/LangOpts.ObjC1));
1905 0 : }
1906 :
1907 15 : static bool checkObjCSubclassingRestrictedAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
1908 15 : if (!D || (!isa<ObjCInterfaceDecl>(D))) {
1909 0 : S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
1910 : << Attr << "Objective-C interfaces";
1911 0 : return false;
1912 : }
1913 : return true;
1914 : }
1915 :
1916 8 : static void matchRulesForObjCSubclassingRestricted(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
1917 16 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_interface, /*IsSupported=*/LangOpts.ObjC1));
1918 8 : }
1919 :
1920 6893 : static bool checkOpenCLAccessAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
1921 6893 : if (!D || (!isa<ParmVarDecl>(D) && !isa<TypedefNameDecl>(D))) {
1922 0 : S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
1923 : << Attr << "parameters and typedefs";
1924 0 : return false;
1925 : }
1926 : return true;
1927 : }
1928 :
1929 6884 : static unsigned OpenCLAccessAttrSpellingMap(const ParsedAttr &Attr) {
1930 : enum Spelling {
1931 : Keyword_read_only = 0,
1932 : Keyword_write_only = 2,
1933 : Keyword_read_write = 4
1934 : };
1935 :
1936 6884 : unsigned Idx = Attr.getAttributeSpellingListIndex();
1937 : switch (Idx) {
1938 0 : default: llvm_unreachable("Unknown spelling list index");
1939 : case 0: return Keyword_read_only;
1940 : case 1: return Keyword_read_only;
1941 : case 2: return Keyword_write_only;
1942 : case 3: return Keyword_write_only;
1943 : case 4: return Keyword_read_write;
1944 : case 5: return Keyword_read_write;
1945 : }
1946 : }
1947 :
1948 6 : static bool checkOpenCLIntelReqdSubGroupSizeAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
1949 6 : if (!D || (!isa<FunctionDecl>(D))) {
1950 0 : S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
1951 : << Attr << "functions";
1952 0 : return false;
1953 : }
1954 : return true;
1955 : }
1956 :
1957 0 : static void matchRulesForOpenCLIntelReqdSubGroupSize(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
1958 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
1959 0 : }
1960 :
1961 594 : static bool checkOpenCLKernelAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
1962 594 : if (!D || (!isa<FunctionDecl>(D))) {
1963 2 : S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
1964 : << Attr << "functions";
1965 2 : return false;
1966 : }
1967 : return true;
1968 : }
1969 :
1970 4 : static bool checkOpenCLNoSVMAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
1971 4 : if (!D || (!isa<VarDecl>(D))) {
1972 2 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
1973 : << Attr << "variables";
1974 2 : return false;
1975 : }
1976 : return true;
1977 : }
1978 :
1979 5 : static bool checkOpenCLLangOpts(Sema &S, const ParsedAttr &Attr) {
1980 5 : if (S.LangOpts.OpenCL)
1981 : return true;
1982 :
1983 1 : S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << Attr.getName();
1984 1 : return false;
1985 : }
1986 :
1987 0 : static void matchRulesForOpenCLNoSVM(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
1988 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /*IsSupported=*/true));
1989 0 : }
1990 :
1991 79 : static bool checkOptimizeNoneAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
1992 79 : if (!D || (!isa<FunctionDecl>(D) && !isa<ObjCMethodDecl>(D))) {
1993 6 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
1994 : << Attr << "functions and Objective-C methods";
1995 6 : return false;
1996 : }
1997 : return true;
1998 : }
1999 :
2000 1 : static void matchRulesForOptimizeNone(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
2001 1 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
2002 2 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC1));
2003 1 : }
2004 :
2005 290326 : static bool checkOverloadableAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
2006 290326 : if (!D || (!isa<FunctionDecl>(D))) {
2007 1 : S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
2008 : << Attr << "functions";
2009 1 : return false;
2010 : }
2011 : return true;
2012 : }
2013 :
2014 0 : static void matchRulesForOverloadable(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
2015 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
2016 0 : }
2017 :
2018 52 : static bool checkOwnershipAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
2019 52 : if (!D || (!isHasFunctionProto(D))) {
2020 3 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
2021 : << Attr << "non-K&R-style functions";
2022 3 : return false;
2023 : }
2024 : return true;
2025 : }
2026 :
2027 0 : static unsigned OwnershipAttrSpellingMap(const ParsedAttr &Attr) {
2028 : enum Spelling {
2029 : GNU_ownership_holds = 0,
2030 : CXX11_clang_ownership_holds = 1,
2031 : C2x_clang_ownership_holds = 2,
2032 : GNU_ownership_returns = 3,
2033 : CXX11_clang_ownership_returns = 4,
2034 : C2x_clang_ownership_returns = 5,
2035 : GNU_ownership_takes = 6,
2036 : CXX11_clang_ownership_takes = 7,
2037 : C2x_clang_ownership_takes = 8
2038 : };
2039 :
2040 0 : unsigned Idx = Attr.getAttributeSpellingListIndex();
2041 : switch (Idx) {
2042 0 : default: llvm_unreachable("Unknown spelling list index");
2043 : case 0: return GNU_ownership_holds;
2044 : case 1: return CXX11_clang_ownership_holds;
2045 : case 2: return C2x_clang_ownership_holds;
2046 : case 3: return GNU_ownership_returns;
2047 : case 4: return CXX11_clang_ownership_returns;
2048 : case 5: return C2x_clang_ownership_returns;
2049 : case 6: return GNU_ownership_takes;
2050 : case 7: return CXX11_clang_ownership_takes;
2051 : case 8: return C2x_clang_ownership_takes;
2052 : }
2053 : }
2054 :
2055 7 : static bool checkParamTypestateAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
2056 7 : if (!D || (!isa<ParmVarDecl>(D))) {
2057 0 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
2058 : << Attr << "parameters";
2059 0 : return false;
2060 : }
2061 : return true;
2062 : }
2063 :
2064 0 : static void matchRulesForParamTypestate(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
2065 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_parameter, /*IsSupported=*/true));
2066 0 : }
2067 :
2068 114 : static bool checkPassObjectSizeAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
2069 114 : if (!D || (!isa<ParmVarDecl>(D))) {
2070 0 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
2071 : << Attr << "parameters";
2072 0 : return false;
2073 : }
2074 : return true;
2075 : }
2076 :
2077 0 : static void matchRulesForPassObjectSize(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
2078 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_parameter, /*IsSupported=*/true));
2079 0 : }
2080 :
2081 0 : static bool checkPragmaClangBSSSectionAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
2082 0 : if (!D || (!isGlobalVar(D))) {
2083 0 : S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
2084 : << Attr << "global variables";
2085 0 : return false;
2086 : }
2087 : return true;
2088 : }
2089 :
2090 0 : static bool checkPragmaClangDataSectionAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
2091 0 : if (!D || (!isGlobalVar(D))) {
2092 0 : S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
2093 : << Attr << "global variables";
2094 0 : return false;
2095 : }
2096 : return true;
2097 : }
2098 :
2099 0 : static bool checkPragmaClangRodataSectionAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
2100 0 : if (!D || (!isGlobalVar(D))) {
2101 0 : S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
2102 : << Attr << "global variables";
2103 0 : return false;
2104 : }
2105 : return true;
2106 : }
2107 :
2108 0 : static bool checkPragmaClangTextSectionAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
2109 0 : if (!D || (!isa<FunctionDecl>(D))) {
2110 0 : S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
2111 : << Attr << "functions";
2112 0 : return false;
2113 : }
2114 : return true;
2115 : }
2116 :
2117 161 : static bool checkPtGuardedByAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
2118 161 : if (!D || (!isa<FieldDecl>(D) && !isSharedVar(D))) {
2119 20 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
2120 : << Attr << "non-static data members and global variables";
2121 20 : return false;
2122 : }
2123 : return true;
2124 : }
2125 :
2126 47 : static bool checkPtGuardedVarAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
2127 47 : if (!D || (!isa<FieldDecl>(D) && !isSharedVar(D))) {
2128 20 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
2129 : << Attr << "non-static data members and global variables";
2130 20 : return false;
2131 : }
2132 : return true;
2133 : }
2134 :
2135 11 : static bool isNonStaticNonConstCXXMethod(const Decl *D) {
2136 : if (const auto *S = dyn_cast<CXXMethodDecl>(D))
2137 8 : return !S->isStatic() && !S->isConst();
2138 : return false;
2139 : }
2140 :
2141 11 : static bool checkReinitializesAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
2142 11 : if (!D || (!isNonStaticNonConstCXXMethod(D))) {
2143 5 : S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
2144 : << Attr << "non-static non-const member functions";
2145 5 : return false;
2146 : }
2147 : return true;
2148 : }
2149 :
2150 415 : static bool checkReleaseCapabilityAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
2151 415 : if (!D || (!isa<FunctionDecl>(D))) {
2152 13 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
2153 : << Attr << "functions";
2154 13 : return false;
2155 : }
2156 : return true;
2157 : }
2158 :
2159 0 : static unsigned ReleaseCapabilityAttrSpellingMap(const ParsedAttr &Attr) {
2160 : enum Spelling {
2161 : GNU_release_capability = 0,
2162 : CXX11_clang_release_capability = 1,
2163 : GNU_release_shared_capability = 2,
2164 : CXX11_clang_release_shared_capability = 3,
2165 : GNU_release_generic_capability = 4,
2166 : CXX11_clang_release_generic_capability = 5,
2167 : GNU_unlock_function = 6,
2168 : CXX11_clang_unlock_function = 7
2169 : };
2170 :
2171 0 : unsigned Idx = Attr.getAttributeSpellingListIndex();
2172 : switch (Idx) {
2173 0 : default: llvm_unreachable("Unknown spelling list index");
2174 : case 0: return GNU_release_capability;
2175 : case 1: return CXX11_clang_release_capability;
2176 : case 2: return GNU_release_shared_capability;
2177 : case 3: return CXX11_clang_release_shared_capability;
2178 : case 4: return GNU_release_generic_capability;
2179 : case 5: return CXX11_clang_release_generic_capability;
2180 : case 6: return GNU_unlock_function;
2181 : case 7: return CXX11_clang_unlock_function;
2182 : }
2183 : }
2184 :
2185 2 : static bool checkRenderScriptKernelAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
2186 2 : if (!D || (!isa<FunctionDecl>(D))) {
2187 1 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
2188 : << Attr << "functions";
2189 1 : return false;
2190 : }
2191 : return true;
2192 : }
2193 :
2194 4 : static bool checkRenderScriptLangOpts(Sema &S, const ParsedAttr &Attr) {
2195 4 : if (S.LangOpts.RenderScript)
2196 : return true;
2197 :
2198 2 : S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << Attr.getName();
2199 2 : return false;
2200 : }
2201 :
2202 0 : static void matchRulesForRenderScriptKernel(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
2203 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
2204 0 : }
2205 :
2206 15 : static bool checkReqdWorkGroupSizeAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
2207 15 : if (!D || (!isa<FunctionDecl>(D))) {
2208 1 : S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
2209 : << Attr << "functions";
2210 1 : return false;
2211 : }
2212 : return true;
2213 : }
2214 :
2215 0 : static void matchRulesForReqdWorkGroupSize(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
2216 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
2217 0 : }
2218 :
2219 184 : static bool checkRequireConstantInitAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
2220 362 : if (!D || (!isGlobalVar(D))) {
2221 12 : S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
2222 : << Attr << "global variables";
2223 12 : return false;
2224 : }
2225 : return true;
2226 : }
2227 :
2228 2 : static void matchRulesForRequireConstantInit(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
2229 2 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_global, /*IsSupported=*/true));
2230 2 : }
2231 :
2232 727 : static bool checkRequiresCapabilityAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
2233 727 : if (!D || (!isa<FunctionDecl>(D))) {
2234 30 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
2235 : << Attr << "functions";
2236 30 : return false;
2237 : }
2238 : return true;
2239 : }
2240 :
2241 0 : static unsigned RequiresCapabilityAttrSpellingMap(const ParsedAttr &Attr) {
2242 : enum Spelling {
2243 : GNU_requires_capability = 0,
2244 : CXX11_clang_requires_capability = 1,
2245 : GNU_exclusive_locks_required = 2,
2246 : CXX11_clang_exclusive_locks_required = 3,
2247 : GNU_requires_shared_capability = 4,
2248 : CXX11_clang_requires_shared_capability = 5,
2249 : GNU_shared_locks_required = 6,
2250 : CXX11_clang_shared_locks_required = 7
2251 : };
2252 :
2253 0 : unsigned Idx = Attr.getAttributeSpellingListIndex();
2254 : switch (Idx) {
2255 0 : default: llvm_unreachable("Unknown spelling list index");
2256 : case 0: return GNU_requires_capability;
2257 : case 1: return CXX11_clang_requires_capability;
2258 : case 2: return GNU_exclusive_locks_required;
2259 : case 3: return CXX11_clang_exclusive_locks_required;
2260 : case 4: return GNU_requires_shared_capability;
2261 : case 5: return CXX11_clang_requires_shared_capability;
2262 : case 6: return GNU_shared_locks_required;
2263 : case 7: return CXX11_clang_shared_locks_required;
2264 : }
2265 : }
2266 :
2267 58498 : static bool checkRestrictAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
2268 58498 : if (!D || (!isa<FunctionDecl>(D))) {
2269 11 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
2270 : << Attr << "functions";
2271 11 : return false;
2272 : }
2273 : return true;
2274 : }
2275 :
2276 0 : static unsigned RestrictAttrSpellingMap(const ParsedAttr &Attr) {
2277 : enum Spelling {
2278 : Declspec_restrict = 0,
2279 : GNU_malloc = 1,
2280 : CXX11_gnu_malloc = 2
2281 : };
2282 :
2283 0 : unsigned Idx = Attr.getAttributeSpellingListIndex();
2284 : switch (Idx) {
2285 0 : default: llvm_unreachable("Unknown spelling list index");
2286 : case 0: return Declspec_restrict;
2287 : case 1: return GNU_malloc;
2288 : case 2: return CXX11_gnu_malloc;
2289 : }
2290 : }
2291 :
2292 0 : static void matchRulesForRestrict(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
2293 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
2294 0 : }
2295 :
2296 13 : static bool checkReturnTypestateAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
2297 13 : if (!D || (!isa<FunctionDecl>(D) && !isa<ParmVarDecl>(D))) {
2298 1 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
2299 : << Attr << "functions and parameters";
2300 1 : return false;
2301 : }
2302 : return true;
2303 : }
2304 :
2305 0 : static void matchRulesForReturnTypestate(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
2306 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
2307 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_parameter, /*IsSupported=*/true));
2308 0 : }
2309 :
2310 28 : static bool checkReturnsNonNullAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
2311 28 : if (!D || (!isa<ObjCMethodDecl>(D) && !isa<FunctionDecl>(D))) {
2312 2 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
2313 : << Attr << "Objective-C methods and functions";
2314 2 : return false;
2315 : }
2316 : return true;
2317 : }
2318 :
2319 0 : static void matchRulesForReturnsNonNull(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
2320 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC1));
2321 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
2322 0 : }
2323 :
2324 12 : static bool checkReturnsTwiceAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
2325 12 : if (!D || (!isa<FunctionDecl>(D))) {
2326 2 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
2327 : << Attr << "functions";
2328 2 : return false;
2329 : }
2330 : return true;
2331 : }
2332 :
2333 0 : static void matchRulesForReturnsTwice(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
2334 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
2335 0 : }
2336 :
2337 82 : static bool checkScopedLockableAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
2338 82 : if (!D || (!isa<RecordDecl>(D))) {
2339 18 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
2340 : << Attr << "structs, unions, and classes";
2341 18 : return false;
2342 : }
2343 : return true;
2344 : }
2345 :
2346 0 : static void matchRulesForScopedLockable(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
2347 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true));
2348 0 : }
2349 :
2350 79 : static bool checkSectionAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
2351 137 : if (!D || (!isa<FunctionDecl>(D) && !isGlobalVar(D) && !isa<ObjCMethodDecl>(D) && !isa<ObjCPropertyDecl>(D))) {
2352 4 : S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
2353 : << Attr << "functions, global variables, Objective-C methods, and Objective-C properties";
2354 4 : return false;
2355 : }
2356 : return true;
2357 : }
2358 :
2359 0 : static unsigned SectionAttrSpellingMap(const ParsedAttr &Attr) {
2360 : enum Spelling {
2361 : GNU_section = 0,
2362 : CXX11_gnu_section = 1,
2363 : Declspec_allocate = 2
2364 : };
2365 :
2366 0 : unsigned Idx = Attr.getAttributeSpellingListIndex();
2367 : switch (Idx) {
2368 0 : default: llvm_unreachable("Unknown spelling list index");
2369 : case 0: return GNU_section;
2370 : case 1: return CXX11_gnu_section;
2371 : case 2: return Declspec_allocate;
2372 : }
2373 : }
2374 :
2375 0 : static void matchRulesForSection(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
2376 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
2377 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_global, /*IsSupported=*/true));
2378 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC1));
2379 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_property, /*IsSupported=*/LangOpts.ObjC1));
2380 0 : }
2381 :
2382 13 : static bool checkSetTypestateAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
2383 13 : if (!D || (!isa<CXXMethodDecl>(D))) {
2384 2 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
2385 : << Attr << "functions";
2386 2 : return false;
2387 : }
2388 : return true;
2389 : }
2390 :
2391 0 : static void matchRulesForSetTypestate(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
2392 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function_is_member, /*IsSupported=*/LangOpts.CPlusPlus));
2393 0 : }
2394 :
2395 88 : static bool checkSharedTrylockFunctionAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
2396 88 : if (!D || (!isa<FunctionDecl>(D))) {
2397 15 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
2398 : << Attr << "functions";
2399 15 : return false;
2400 : }
2401 : return true;
2402 : }
2403 :
2404 58 : static bool checkSwiftContextAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
2405 58 : if (!D || (!isa<ParmVarDecl>(D))) {
2406 0 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
2407 : << Attr << "parameters";
2408 0 : return false;
2409 : }
2410 : return true;
2411 : }
2412 :
2413 0 : static void matchRulesForSwiftContext(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
2414 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_parameter, /*IsSupported=*/true));
2415 0 : }
2416 :
2417 34 : static bool checkSwiftErrorResultAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
2418 34 : if (!D || (!isa<ParmVarDecl>(D))) {
2419 0 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
2420 : << Attr << "parameters";
2421 0 : return false;
2422 : }
2423 : return true;
2424 : }
2425 :
2426 0 : static void matchRulesForSwiftErrorResult(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
2427 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_parameter, /*IsSupported=*/true));
2428 0 : }
2429 :
2430 68 : static bool checkSwiftIndirectResultAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
2431 68 : if (!D || (!isa<ParmVarDecl>(D))) {
2432 0 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
2433 : << Attr << "parameters";
2434 0 : return false;
2435 : }
2436 : return true;
2437 : }
2438 :
2439 0 : static void matchRulesForSwiftIndirectResult(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
2440 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_parameter, /*IsSupported=*/true));
2441 0 : }
2442 :
2443 : static bool isTLSVar(const Decl *D) {
2444 : if (const auto *S = dyn_cast<VarDecl>(D))
2445 20 : return S->getTLSKind() != 0;
2446 : return false;
2447 : }
2448 :
2449 19 : static bool checkTLSModelAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
2450 37 : if (!D || (!isTLSVar(D))) {
2451 2 : S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
2452 : << Attr << "thread-local variables";
2453 2 : return false;
2454 : }
2455 : return true;
2456 : }
2457 :
2458 0 : static void matchRulesForTLSModel(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
2459 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_thread_local, /*IsSupported=*/true));
2460 0 : }
2461 :
2462 518720 : static bool checkTargetAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
2463 518720 : if (!D || (!isa<FunctionDecl>(D))) {
2464 0 : S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
2465 : << Attr << "functions";
2466 0 : return false;
2467 : }
2468 : return true;
2469 : }
2470 :
2471 0 : static void matchRulesForTarget(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
2472 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
2473 0 : }
2474 :
2475 9 : static bool checkTestTypestateAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
2476 9 : if (!D || (!isa<CXXMethodDecl>(D))) {
2477 2 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
2478 : << Attr << "functions";
2479 2 : return false;
2480 : }
2481 : return true;
2482 : }
2483 :
2484 0 : static void matchRulesForTestTypestate(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
2485 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function_is_member, /*IsSupported=*/LangOpts.CPlusPlus));
2486 0 : }
2487 :
2488 55 : static bool checkThreadAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
2489 55 : if (!D || (!isa<VarDecl>(D))) {
2490 4 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
2491 : << Attr << "variables";
2492 4 : return false;
2493 : }
2494 : return true;
2495 : }
2496 :
2497 54 : static bool checkNotCPlusPlusLangOpts(Sema &S, const ParsedAttr &Attr) {
2498 54 : if (!S.LangOpts.CPlusPlus)
2499 : return true;
2500 :
2501 3 : S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << Attr.getName();
2502 3 : return false;
2503 : }
2504 :
2505 33 : static bool checkTrivialABIAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
2506 33 : if (!D || (!isa<CXXRecordDecl>(D))) {
2507 1 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
2508 : << Attr << "classes";
2509 1 : return false;
2510 : }
2511 : return true;
2512 : }
2513 :
2514 0 : static void matchRulesForTrivialABI(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
2515 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true));
2516 0 : }
2517 :
2518 35 : static bool checkTryAcquireCapabilityAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
2519 35 : if (!D || (!isa<FunctionDecl>(D))) {
2520 1 : S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
2521 : << Attr << "functions";
2522 1 : return false;
2523 : }
2524 : return true;
2525 : }
2526 :
2527 0 : static unsigned TryAcquireCapabilityAttrSpellingMap(const ParsedAttr &Attr) {
2528 : enum Spelling {
2529 : GNU_try_acquire_capability = 0,
2530 : CXX11_clang_try_acquire_capability = 1,
2531 : GNU_try_acquire_shared_capability = 2,
2532 : CXX11_clang_try_acquire_shared_capability = 3
2533 : };
2534 :
2535 0 : unsigned Idx = Attr.getAttributeSpellingListIndex();
2536 : switch (Idx) {
2537 0 : default: llvm_unreachable("Unknown spelling list index");
2538 : case 0: return GNU_try_acquire_capability;
2539 : case 1: return CXX11_clang_try_acquire_capability;
2540 : case 2: return GNU_try_acquire_shared_capability;
2541 : case 3: return CXX11_clang_try_acquire_shared_capability;
2542 : }
2543 : }
2544 :
2545 1367 : static bool checkUnusedAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
2546 1589 : if (!D || (!isa<VarDecl>(D) && !isa<ObjCIvarDecl>(D) && !isa<TypeDecl>(D) && !isa<EnumDecl>(D) && !isa<EnumConstantDecl>(D) && !isa<LabelDecl>(D) && !isa<FieldDecl>(D) && !isa<ObjCMethodDecl>(D) && !isFunctionLike(D))) {
2547 1 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
2548 : << Attr << "variables, non-static data members, types, enums, enumerators, labels, non-static data members, Objective-C methods, functions, and function pointers";
2549 1 : return false;
2550 : }
2551 : return true;
2552 : }
2553 :
2554 0 : static unsigned UnusedAttrSpellingMap(const ParsedAttr &Attr) {
2555 : enum Spelling {
2556 : CXX11_maybe_unused = 0,
2557 : GNU_unused = 1,
2558 : CXX11_gnu_unused = 2,
2559 : C2x_maybe_unused = 3
2560 : };
2561 :
2562 0 : unsigned Idx = Attr.getAttributeSpellingListIndex();
2563 : switch (Idx) {
2564 0 : default: llvm_unreachable("Unknown spelling list index");
2565 : case 0: return CXX11_maybe_unused;
2566 : case 1: return GNU_unused;
2567 : case 2: return CXX11_gnu_unused;
2568 : case 3: return C2x_maybe_unused;
2569 : }
2570 : }
2571 :
2572 : static bool isNonLocalVar(const Decl *D) {
2573 : if (const auto *S = dyn_cast<VarDecl>(D))
2574 45 : return !S->hasLocalStorage();
2575 : return false;
2576 : }
2577 :
2578 107 : static bool checkUsedAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
2579 214 : if (!D || (!isNonLocalVar(D) && !isa<FunctionDecl>(D) && !isa<ObjCMethodDecl>(D))) {
2580 2 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
2581 : << Attr << "variables with non-local storage, functions, and Objective-C methods";
2582 2 : return false;
2583 : }
2584 : return true;
2585 : }
2586 :
2587 136 : static bool checkUuidAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
2588 136 : if (!D || (!isa<RecordDecl>(D) && !isa<EnumDecl>(D))) {
2589 3 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
2590 : << Attr << "structs, unions, classes, and enums";
2591 3 : return false;
2592 : }
2593 : return true;
2594 : }
2595 :
2596 136 : static bool checkMicrosoftExtBorlandLangOpts(Sema &S, const ParsedAttr &Attr) {
2597 136 : if (S.LangOpts.MicrosoftExt || S.LangOpts.Borland)
2598 : return true;
2599 :
2600 0 : S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << Attr.getName();
2601 0 : return false;
2602 : }
2603 :
2604 11 : static bool checkVecReturnAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
2605 11 : if (!D || (!isa<CXXRecordDecl>(D))) {
2606 0 : S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
2607 : << Attr << "classes";
2608 0 : return false;
2609 : }
2610 : return true;
2611 : }
2612 :
2613 0 : static void matchRulesForVecReturn(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
2614 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true));
2615 0 : }
2616 :
2617 10 : static bool checkVecTypeHintAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
2618 10 : if (!D || (!isa<FunctionDecl>(D))) {
2619 1 : S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
2620 : << Attr << "functions";
2621 1 : return false;
2622 : }
2623 : return true;
2624 : }
2625 :
2626 0 : static void matchRulesForVecTypeHint(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
2627 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
2628 0 : }
2629 :
2630 7 : static bool checkWarnUnusedAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
2631 7 : if (!D || (!isa<RecordDecl>(D))) {
2632 1 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
2633 : << Attr << "structs, unions, and classes";
2634 1 : return false;
2635 : }
2636 : return true;
2637 : }
2638 :
2639 0 : static void matchRulesForWarnUnused(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
2640 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true));
2641 0 : }
2642 :
2643 117985 : static bool checkWarnUnusedResultAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
2644 235944 : if (!D || (!isa<ObjCMethodDecl>(D) && !isa<EnumDecl>(D) && !isa<RecordDecl>(D) && !isFunctionLike(D))) {
2645 3 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
2646 : << Attr << "Objective-C methods, enums, structs, unions, classes, functions, and function pointers";
2647 3 : return false;
2648 : }
2649 : return true;
2650 : }
2651 :
2652 0 : static unsigned WarnUnusedResultAttrSpellingMap(const ParsedAttr &Attr) {
2653 : enum Spelling {
2654 : CXX11_nodiscard = 0,
2655 : C2x_nodiscard = 1,
2656 : CXX11_clang_warn_unused_result = 2,
2657 : GNU_warn_unused_result = 3,
2658 : CXX11_gnu_warn_unused_result = 4
2659 : };
2660 :
2661 0 : unsigned Idx = Attr.getAttributeSpellingListIndex();
2662 : switch (Idx) {
2663 0 : default: llvm_unreachable("Unknown spelling list index");
2664 : case 0: return CXX11_nodiscard;
2665 : case 1: return C2x_nodiscard;
2666 : case 2: return CXX11_clang_warn_unused_result;
2667 : case 3: return GNU_warn_unused_result;
2668 : case 4: return CXX11_gnu_warn_unused_result;
2669 : }
2670 : }
2671 :
2672 0 : static void matchRulesForWarnUnusedResult(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
2673 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC1));
2674 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_enum, /*IsSupported=*/true));
2675 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true));
2676 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_hasType_functionType, /*IsSupported=*/true));
2677 0 : }
2678 :
2679 1209 : static bool checkWeakAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
2680 1209 : if (!D || (!isa<VarDecl>(D) && !isa<FunctionDecl>(D) && !isa<CXXRecordDecl>(D))) {
2681 2 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
2682 : << Attr << "variables, functions, and classes";
2683 2 : return false;
2684 : }
2685 : return true;
2686 : }
2687 :
2688 0 : static void matchRulesForWeak(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
2689 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /*IsSupported=*/true));
2690 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
2691 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true));
2692 0 : }
2693 :
2694 2392 : static bool checkWeakRefAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
2695 2392 : if (!D || (!isa<VarDecl>(D) && !isa<FunctionDecl>(D))) {
2696 0 : S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
2697 : << Attr << "variables and functions";
2698 0 : return false;
2699 : }
2700 : return true;
2701 : }
2702 :
2703 0 : static void matchRulesForWeakRef(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
2704 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /*IsSupported=*/true));
2705 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
2706 0 : }
2707 :
2708 8 : static bool checkWorkGroupSizeHintAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
2709 8 : if (!D || (!isa<FunctionDecl>(D))) {
2710 1 : S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
2711 : << Attr << "functions";
2712 1 : return false;
2713 : }
2714 : return true;
2715 : }
2716 :
2717 0 : static void matchRulesForWorkGroupSizeHint(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
2718 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
2719 0 : }
2720 :
2721 85 : static bool checkXRayInstrumentAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
2722 85 : if (!D || (!isa<FunctionDecl>(D) && !isa<ObjCMethodDecl>(D))) {
2723 2 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
2724 : << Attr << "functions and Objective-C methods";
2725 2 : return false;
2726 : }
2727 : return true;
2728 : }
2729 :
2730 0 : static unsigned XRayInstrumentAttrSpellingMap(const ParsedAttr &Attr) {
2731 : enum Spelling {
2732 : GNU_xray_always_instrument = 0,
2733 : CXX11_clang_xray_always_instrument = 1,
2734 : C2x_clang_xray_always_instrument = 2,
2735 : GNU_xray_never_instrument = 3,
2736 : CXX11_clang_xray_never_instrument = 4,
2737 : C2x_clang_xray_never_instrument = 5
2738 : };
2739 :
2740 0 : unsigned Idx = Attr.getAttributeSpellingListIndex();
2741 : switch (Idx) {
2742 0 : default: llvm_unreachable("Unknown spelling list index");
2743 : case 0: return GNU_xray_always_instrument;
2744 : case 1: return CXX11_clang_xray_always_instrument;
2745 : case 2: return C2x_clang_xray_always_instrument;
2746 : case 3: return GNU_xray_never_instrument;
2747 : case 4: return CXX11_clang_xray_never_instrument;
2748 : case 5: return C2x_clang_xray_never_instrument;
2749 : }
2750 : }
2751 :
2752 0 : static void matchRulesForXRayInstrument(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
2753 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
2754 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC1));
2755 0 : }
2756 :
2757 19 : static bool checkXRayLogArgsAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) {
2758 19 : if (!D || (!isa<FunctionDecl>(D) && !isa<ObjCMethodDecl>(D))) {
2759 2 : S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
2760 : << Attr << "functions and Objective-C methods";
2761 2 : return false;
2762 : }
2763 : return true;
2764 : }
2765 :
2766 0 : static void matchRulesForXRayLogArgs(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) {
2767 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
2768 0 : MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC1));
2769 0 : }
2770 :
2771 : static const ParsedAttrInfo AttrInfoMap[ParsedAttr::UnknownAttribute + 1] = {
2772 : { 2, 0, 0, 0, 0, 0, 0, 1, checkAMDGPUFlatWorkGroupSizeAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForAMDGPUFlatWorkGroupSize }, // AT_AMDGPUFlatWorkGroupSize
2773 : { 1, 0, 0, 0, 0, 0, 0, 1, checkAMDGPUNumSGPRAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForAMDGPUNumSGPR }, // AT_AMDGPUNumSGPR
2774 : { 1, 0, 0, 0, 0, 0, 0, 1, checkAMDGPUNumVGPRAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForAMDGPUNumVGPR }, // AT_AMDGPUNumVGPR
2775 : { 1, 1, 0, 0, 0, 0, 0, 1, checkAMDGPUWavesPerEUAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForAMDGPUWavesPerEU }, // AT_AMDGPUWavesPerEU
2776 : { 0, 1, 1, 1, 0, 0, 1, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, isTargetarmthumbarmebthumbebavrx86x86_64msp430mipsmipselriscv32riscv64, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_Interrupt
2777 : { 0, 0, 0, 1, 0, 0, 1, 1, checkAVRSignalAppertainsTo, defaultDiagnoseLangOpts, isTargetavr, defaultSpellingIndexToSemanticSpelling, matchRulesForAVRSignal }, // AT_AVRSignal
2778 : { 0, 15, 0, 0, 0, 0, 1, 1, checkAbiTagAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForAbiTag }, // AT_AbiTag
2779 : { 0, 15, 0, 0, 0, 0, 0, 0, checkAcquireCapabilityAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, AcquireCapabilityAttrSpellingMap, nullptr }, // AT_AcquireCapability
2780 : { 0, 15, 0, 0, 0, 0, 0, 0, checkAcquiredAfterAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_AcquiredAfter
2781 : { 0, 15, 0, 0, 0, 0, 0, 0, checkAcquiredBeforeAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_AcquiredBefore
2782 : { 1, 0, 0, 0, 1, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_AddressSpace
2783 : { 1, 0, 0, 0, 0, 0, 1, 1, checkAliasAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForAlias }, // AT_Alias
2784 : { 1, 0, 0, 0, 0, 0, 0, 1, checkAlignValueAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForAlignValue }, // AT_AlignValue
2785 : { 0, 1, 0, 0, 0, 0, 1, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, AlignedAttrSpellingMap, nullptr }, // AT_Aligned
2786 : { 1, 0, 0, 0, 0, 0, 1, 0, checkAllocAlignAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_AllocAlign
2787 : { 1, 1, 0, 0, 0, 0, 1, 1, checkAllocSizeAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForAllocSize }, // AT_AllocSize
2788 : { 0, 0, 0, 0, 0, 0, 0, 1, checkAlwaysDestroyAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForAlwaysDestroy }, // AT_AlwaysDestroy
2789 : { 0, 0, 0, 0, 0, 0, 1, 1, checkAlwaysInlineAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, AlwaysInlineAttrSpellingMap, matchRulesForAlwaysInline }, // AT_AlwaysInline
2790 : { 0, 0, 0, 0, 0, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_AnalyzerNoReturn
2791 : { 1, 0, 0, 0, 0, 0, 0, 1, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForAnnotate }, // AT_Annotate
2792 : { 0, 0, 0, 1, 0, 0, 1, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, isTargetx86x86_64, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_AnyX86NoCallerSavedRegisters
2793 : { 0, 0, 0, 1, 1, 0, 1, 1, checkAnyX86NoCfCheckAppertainsTo, defaultDiagnoseLangOpts, isTargetx86x86_64, defaultSpellingIndexToSemanticSpelling, matchRulesForAnyX86NoCfCheck }, // AT_AnyX86NoCfCheck
2794 : { 0, 0, 0, 0, 0, 0, 0, 1, checkArcWeakrefUnavailableAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForArcWeakrefUnavailable }, // AT_ArcWeakrefUnavailable
2795 : { 3, 0, 0, 0, 0, 0, 0, 0, checkArgumentWithTypeTagAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, ArgumentWithTypeTagAttrSpellingMap, nullptr }, // AT_ArgumentWithTypeTag
2796 : { 0, 0, 0, 0, 0, 0, 1, 0, checkArtificialAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_Artificial
2797 : { 0, 15, 0, 0, 0, 0, 0, 0, checkAssertCapabilityAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, AssertCapabilityAttrSpellingMap, nullptr }, // AT_AssertCapability
2798 : { 0, 15, 0, 0, 0, 0, 0, 0, checkAssertExclusiveLockAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_AssertExclusiveLock
2799 : { 0, 15, 0, 0, 0, 0, 0, 0, checkAssertSharedLockAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_AssertSharedLock
2800 : { 1, 1, 0, 0, 0, 0, 1, 1, checkAssumeAlignedAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForAssumeAligned }, // AT_AssumeAligned
2801 : { 8, 0, 1, 0, 0, 0, 0, 1, checkAvailabilityAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForAvailability }, // AT_Availability
2802 : { 1, 0, 0, 0, 0, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_Blocks
2803 : { 0, 0, 0, 0, 1, 0, 1, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_CDecl
2804 : { 0, 0, 0, 0, 0, 0, 0, 1, checkCFAuditedTransferAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForCFAuditedTransfer }, // AT_CFAuditedTransfer
2805 : { 0, 0, 0, 0, 0, 0, 0, 1, checkCFConsumedAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForCFConsumed }, // AT_CFConsumed
2806 : { 0, 0, 0, 0, 0, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_CFReturnsNotRetained
2807 : { 0, 0, 0, 0, 0, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_CFReturnsRetained
2808 : { 0, 0, 0, 0, 0, 0, 0, 1, checkCFUnknownTransferAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForCFUnknownTransfer }, // AT_CFUnknownTransfer
2809 : { 0, 15, 0, 0, 0, 0, 0, 1, checkCPUDispatchAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForCPUDispatch }, // AT_CPUDispatch
2810 : { 0, 15, 0, 0, 0, 0, 0, 1, checkCPUSpecificAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForCPUSpecific }, // AT_CPUSpecific
2811 : { 0, 0, 0, 0, 0, 0, 0, 1, checkCUDAConstantAppertainsTo, checkCUDALangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForCUDAConstant }, // AT_CUDAConstant
2812 : { 0, 0, 0, 0, 0, 0, 0, 1, checkCUDADeviceAppertainsTo, checkCUDALangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForCUDADevice }, // AT_CUDADevice
2813 : { 0, 0, 0, 0, 0, 0, 0, 1, checkCUDAGlobalAppertainsTo, checkCUDALangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForCUDAGlobal }, // AT_CUDAGlobal
2814 : { 0, 0, 0, 0, 0, 0, 0, 1, checkCUDAHostAppertainsTo, checkCUDALangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForCUDAHost }, // AT_CUDAHost
2815 : { 0, 0, 0, 0, 0, 0, 0, 0, checkCUDAInvalidTargetAppertainsTo, checkCUDALangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_CUDAInvalidTarget
2816 : { 1, 1, 0, 0, 0, 0, 0, 1, checkCUDALaunchBoundsAppertainsTo, checkCUDALangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForCUDALaunchBounds }, // AT_CUDALaunchBounds
2817 : { 0, 0, 0, 0, 0, 0, 0, 1, checkCUDASharedAppertainsTo, checkCUDALangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForCUDAShared }, // AT_CUDAShared
2818 : { 0, 0, 0, 0, 0, 0, 0, 1, checkCXX11NoReturnAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForCXX11NoReturn }, // AT_CXX11NoReturn
2819 : { 0, 15, 0, 0, 0, 0, 0, 1, checkCallableWhenAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForCallableWhen }, // AT_CallableWhen
2820 : { 1, 0, 0, 0, 0, 0, 0, 1, checkCapabilityAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, CapabilityAttrSpellingMap, matchRulesForCapability }, // AT_Capability
2821 : { 0, 0, 0, 0, 0, 0, 0, 1, checkCarriesDependencyAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForCarriesDependency }, // AT_CarriesDependency
2822 : { 1, 0, 0, 0, 0, 0, 1, 0, checkCleanupAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_Cleanup
2823 : { 1, 0, 0, 0, 0, 0, 0, 0, checkCodeSegAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_CodeSeg
2824 : { 0, 0, 0, 0, 0, 0, 1, 1, checkColdAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForCold }, // AT_Cold
2825 : { 0, 0, 0, 0, 0, 0, 1, 1, checkCommonAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForCommon }, // AT_Common
2826 : { 0, 0, 0, 0, 0, 0, 1, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_Const
2827 : { 0, 1, 0, 0, 0, 0, 1, 1, checkConstructorAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForConstructor }, // AT_Constructor
2828 : { 1, 0, 0, 0, 0, 0, 0, 1, checkConsumableAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForConsumable }, // AT_Consumable
2829 : { 0, 0, 0, 0, 0, 0, 0, 1, checkConsumableAutoCastAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForConsumableAutoCast }, // AT_ConsumableAutoCast
2830 : { 0, 0, 0, 0, 0, 0, 0, 1, checkConsumableSetOnReadAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForConsumableSetOnRead }, // AT_ConsumableSetOnRead
2831 : { 0, 0, 0, 0, 0, 0, 0, 1, checkConvergentAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForConvergent }, // AT_Convergent
2832 : { 0, 0, 0, 1, 0, 0, 1, 1, checkDLLExportAppertainsTo, defaultDiagnoseLangOpts, isTargetx86x86_64armthumbaarch64Win32, defaultSpellingIndexToSemanticSpelling, matchRulesForDLLExport }, // AT_DLLExport
2833 : { 0, 0, 0, 1, 0, 0, 1, 1, checkDLLImportAppertainsTo, defaultDiagnoseLangOpts, isTargetx86x86_64armthumbaarch64Win32, defaultSpellingIndexToSemanticSpelling, matchRulesForDLLImport }, // AT_DLLImport
2834 : { 0, 2, 0, 0, 0, 0, 1, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_Deprecated
2835 : { 0, 1, 0, 0, 0, 0, 1, 1, checkDestructorAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForDestructor }, // AT_Destructor
2836 : { 3, 0, 0, 0, 0, 0, 0, 0, checkDiagnoseIfAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_DiagnoseIf
2837 : { 0, 0, 0, 0, 0, 0, 0, 1, checkDisableTailCallsAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForDisableTailCalls }, // AT_DisableTailCalls
2838 : { 0, 0, 0, 1, 0, 0, 0, 0, checkEmptyBasesAppertainsTo, defaultDiagnoseLangOpts, isTargetx86x86_64armthumbaarch64Microsoft, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_EmptyBases
2839 : { 2, 0, 0, 0, 0, 0, 0, 1, checkEnableIfAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForEnableIf }, // AT_EnableIf
2840 : { 1, 0, 0, 0, 0, 0, 0, 1, checkEnumExtensibilityAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForEnumExtensibility }, // AT_EnumExtensibility
2841 : { 0, 0, 0, 0, 0, 0, 0, 1, checkExcludeFromExplicitInstantiationAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForExcludeFromExplicitInstantiation }, // AT_ExcludeFromExplicitInstantiation
2842 : { 1, 15, 0, 0, 0, 0, 0, 0, checkExclusiveTrylockFunctionAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_ExclusiveTrylockFunction
2843 : { 1, 0, 0, 0, 0, 0, 0, 0, checkExtVectorTypeAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_ExtVectorType
2844 : { 0, 3, 1, 0, 0, 0, 0, 1, checkExternalSourceSymbolAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForExternalSourceSymbol }, // AT_ExternalSourceSymbol
2845 : { 0, 0, 0, 0, 0, 1, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_FallThrough
2846 : { 0, 0, 0, 0, 1, 0, 1, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_FastCall
2847 : { 0, 0, 0, 0, 0, 0, 0, 1, checkFlagEnumAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForFlagEnum }, // AT_FlagEnum
2848 : { 0, 0, 0, 0, 0, 0, 1, 1, checkFlattenAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForFlatten }, // AT_Flatten
2849 : { 3, 0, 0, 0, 0, 0, 1, 0, checkFormatAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_Format
2850 : { 1, 0, 0, 0, 0, 0, 1, 0, checkFormatArgAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_FormatArg
2851 : { 0, 0, 0, 0, 0, 0, 1, 1, checkGNUInlineAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForGNUInline }, // AT_GNUInline
2852 : { 1, 0, 0, 0, 0, 0, 0, 0, checkGuardedByAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_GuardedBy
2853 : { 0, 0, 0, 0, 0, 0, 0, 0, checkGuardedVarAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_GuardedVar
2854 : { 0, 0, 0, 0, 0, 0, 1, 1, checkHotAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForHot }, // AT_Hot
2855 : { 0, 0, 0, 0, 0, 0, 0, 1, checkIBActionAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForIBAction }, // AT_IBAction
2856 : { 0, 0, 0, 0, 0, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_IBOutlet
2857 : { 0, 1, 0, 0, 0, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_IBOutletCollection
2858 : { 1, 0, 0, 1, 0, 0, 1, 1, checkIFuncAppertainsTo, defaultDiagnoseLangOpts, isTargetELF, defaultSpellingIndexToSemanticSpelling, matchRulesForIFunc }, // AT_IFunc
2859 : { 1, 0, 0, 0, 0, 0, 1, 1, checkInitPriorityAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForInitPriority }, // AT_InitPriority
2860 : { 0, 0, 0, 0, 1, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_IntelOclBicc
2861 : { 0, 0, 0, 0, 0, 0, 0, 1, checkInternalLinkageAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForInternalLinkage }, // AT_InternalLinkage
2862 : { 0, 0, 0, 0, 0, 0, 0, 1, checkLTOVisibilityPublicAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForLTOVisibilityPublic }, // AT_LTOVisibilityPublic
2863 : { 1, 0, 0, 1, 0, 0, 0, 0, checkLayoutVersionAppertainsTo, defaultDiagnoseLangOpts, isTargetx86x86_64armthumbaarch64Microsoft, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_LayoutVersion
2864 : { 0, 0, 0, 0, 1, 0, 0, 0, checkLifetimeBoundAppertainsTo, checkCPlusPlusLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_LifetimeBound
2865 : { 1, 0, 0, 0, 0, 0, 0, 0, checkLockReturnedAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_LockReturned
2866 : { 0, 0, 0, 0, 0, 0, 0, 1, checkLockableAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForLockable }, // AT_Lockable
2867 : { 0, 15, 0, 0, 0, 0, 0, 0, checkLocksExcludedAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_LocksExcluded
2868 : { 3, 0, 0, 0, 0, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, LoopHintAttrSpellingMap, nullptr }, // AT_LoopHint
2869 : { 0, 0, 0, 0, 1, 0, 1, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_MSABI
2870 : { 0, 0, 0, 0, 0, 0, 0, 0, defaultAppertainsTo, checkMicrosoftExtLangOpts, defaultTargetRequirements, MSInheritanceAttrSpellingMap, nullptr }, // AT_MSInheritance
2871 : { 0, 0, 0, 1, 0, 0, 0, 0, checkMSNoVTableAppertainsTo, defaultDiagnoseLangOpts, isTargetx86x86_64armthumbaarch64Microsoft, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_MSNoVTable
2872 : { 0, 0, 0, 0, 0, 0, 1, 1, checkMSStructAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForMSStruct }, // AT_MSStruct
2873 : { 0, 0, 0, 0, 0, 0, 1, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_MayAlias
2874 : { 0, 0, 0, 1, 0, 0, 1, 1, checkMicroMipsAppertainsTo, defaultDiagnoseLangOpts, isTargetmipsmipsel, defaultSpellingIndexToSemanticSpelling, matchRulesForMicroMips }, // AT_MicroMips
2875 : { 0, 0, 0, 0, 0, 0, 0, 1, checkMinSizeAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForMinSize }, // AT_MinSize
2876 : { 1, 0, 0, 0, 0, 0, 0, 1, checkMinVectorWidthAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForMinVectorWidth }, // AT_MinVectorWidth
2877 : { 0, 0, 0, 1, 0, 0, 1, 1, checkMips16AppertainsTo, defaultDiagnoseLangOpts, isTargetmipsmipsel, defaultSpellingIndexToSemanticSpelling, matchRulesForMips16 }, // AT_Mips16
2878 : { 0, 0, 0, 1, 0, 0, 1, 1, checkMipsLongCallAppertainsTo, defaultDiagnoseLangOpts, isTargetmipsmipselmips64mips64el, MipsLongCallAttrSpellingMap, matchRulesForMipsLongCall }, // AT_MipsLongCall
2879 : { 0, 0, 0, 1, 0, 0, 1, 1, checkMipsShortCallAppertainsTo, defaultDiagnoseLangOpts, isTargetmipsmipselmips64mips64el, MipsShortCallAttrSpellingMap, matchRulesForMipsShortCall }, // AT_MipsShortCall
2880 : { 1, 0, 0, 0, 0, 0, 1, 0, checkModeAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_Mode
2881 : { 0, 0, 0, 0, 0, 0, 0, 1, checkNSConsumedAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForNSConsumed }, // AT_NSConsumed
2882 : { 0, 0, 0, 0, 0, 0, 0, 1, checkNSConsumesSelfAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForNSConsumesSelf }, // AT_NSConsumesSelf
2883 : { 0, 0, 0, 0, 0, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_NSReturnsAutoreleased
2884 : { 0, 0, 0, 0, 0, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_NSReturnsNotRetained
2885 : { 0, 0, 0, 0, 1, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_NSReturnsRetained
2886 : { 0, 0, 0, 0, 0, 0, 1, 1, checkNakedAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForNaked }, // AT_Naked
2887 : { 1, 0, 0, 0, 1, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_NeonPolyVectorType
2888 : { 1, 0, 0, 0, 1, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_NeonVectorType
2889 : { 0, 0, 0, 0, 0, 0, 0, 0, checkNoAliasAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_NoAlias
2890 : { 0, 0, 0, 0, 0, 0, 1, 1, checkNoCommonAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForNoCommon }, // AT_NoCommon
2891 : { 0, 0, 0, 0, 0, 0, 1, 1, checkNoDebugAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForNoDebug }, // AT_NoDebug
2892 : { 0, 0, 0, 0, 0, 0, 0, 1, checkNoDestroyAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForNoDestroy }, // AT_NoDestroy
2893 : { 0, 0, 0, 0, 0, 0, 0, 1, checkNoDuplicateAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForNoDuplicate }, // AT_NoDuplicate
2894 : { 0, 0, 0, 0, 0, 0, 0, 1, checkNoEscapeAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForNoEscape }, // AT_NoEscape
2895 : { 0, 0, 0, 0, 0, 0, 1, 1, checkNoInlineAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForNoInline }, // AT_NoInline
2896 : { 0, 0, 0, 0, 0, 0, 1, 1, checkNoInstrumentFunctionAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForNoInstrumentFunction }, // AT_NoInstrumentFunction
2897 : { 0, 0, 0, 1, 0, 0, 1, 1, checkNoMicroMipsAppertainsTo, defaultDiagnoseLangOpts, isTargetmipsmipsel, defaultSpellingIndexToSemanticSpelling, matchRulesForNoMicroMips }, // AT_NoMicroMips
2898 : { 0, 0, 0, 1, 0, 0, 1, 1, checkNoMips16AppertainsTo, defaultDiagnoseLangOpts, isTargetmipsmipsel, defaultSpellingIndexToSemanticSpelling, matchRulesForNoMips16 }, // AT_NoMips16
2899 : { 0, 0, 0, 0, 0, 0, 1, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_NoReturn
2900 : { 0, 15, 0, 0, 0, 0, 0, 1, checkNoSanitizeAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForNoSanitize }, // AT_NoSanitize
2901 : { 0, 0, 0, 0, 0, 0, 1, 1, checkNoSanitizeSpecificAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForNoSanitizeSpecific }, // AT_NoSanitizeSpecific
2902 : { 0, 0, 0, 0, 0, 0, 1, 1, checkNoSplitStackAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForNoSplitStack }, // AT_NoSplitStack
2903 : { 0, 0, 0, 0, 0, 0, 0, 1, checkNoStackProtectorAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForNoStackProtector }, // AT_NoStackProtector
2904 : { 0, 0, 0, 0, 0, 0, 0, 1, checkNoThreadSafetyAnalysisAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForNoThreadSafetyAnalysis }, // AT_NoThreadSafetyAnalysis
2905 : { 0, 0, 0, 0, 0, 0, 1, 1, checkNoThrowAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForNoThrow }, // AT_NoThrow
2906 : { 0, 15, 0, 0, 0, 0, 1, 0, checkNonNullAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_NonNull
2907 : { 0, 0, 0, 0, 0, 0, 0, 1, checkNotTailCalledAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForNotTailCalled }, // AT_NotTailCalled
2908 : { 0, 0, 0, 0, 0, 0, 0, 1, checkObjCBoxableAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForObjCBoxable }, // AT_ObjCBoxable
2909 : { 1, 0, 0, 0, 0, 0, 0, 1, checkObjCBridgeAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForObjCBridge }, // AT_ObjCBridge
2910 : { 1, 0, 0, 0, 0, 0, 0, 1, checkObjCBridgeMutableAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForObjCBridgeMutable }, // AT_ObjCBridgeMutable
2911 : { 3, 0, 1, 0, 0, 0, 0, 1, checkObjCBridgeRelatedAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForObjCBridgeRelated }, // AT_ObjCBridgeRelated
2912 : { 0, 0, 0, 0, 0, 0, 0, 0, checkObjCDesignatedInitializerAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_ObjCDesignatedInitializer
2913 : { 0, 0, 0, 0, 0, 0, 0, 1, checkObjCExceptionAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForObjCException }, // AT_ObjCException
2914 : { 0, 0, 0, 0, 0, 0, 0, 1, checkObjCExplicitProtocolImplAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForObjCExplicitProtocolImpl }, // AT_ObjCExplicitProtocolImpl
2915 : { 1, 0, 0, 0, 1, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_ObjCGC
2916 : { 0, 0, 0, 0, 0, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_ObjCIndependentClass
2917 : { 0, 0, 0, 0, 1, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_ObjCInertUnsafeUnretained
2918 : { 0, 0, 0, 0, 1, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_ObjCKindOf
2919 : { 1, 0, 0, 0, 0, 0, 0, 1, checkObjCMethodFamilyAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForObjCMethodFamily }, // AT_ObjCMethodFamily
2920 : { 0, 0, 0, 0, 0, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_ObjCNSObject
2921 : { 1, 0, 0, 0, 1, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_ObjCOwnership
2922 : { 0, 0, 0, 0, 0, 0, 0, 1, checkObjCPreciseLifetimeAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForObjCPreciseLifetime }, // AT_ObjCPreciseLifetime
2923 : { 0, 0, 0, 0, 0, 0, 0, 1, checkObjCRequiresPropertyDefsAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForObjCRequiresPropertyDefs }, // AT_ObjCRequiresPropertyDefs
2924 : { 0, 0, 0, 0, 0, 0, 0, 1, checkObjCRequiresSuperAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForObjCRequiresSuper }, // AT_ObjCRequiresSuper
2925 : { 0, 0, 0, 0, 0, 0, 0, 1, checkObjCReturnsInnerPointerAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForObjCReturnsInnerPointer }, // AT_ObjCReturnsInnerPointer
2926 : { 0, 0, 0, 0, 0, 0, 0, 1, checkObjCRootClassAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForObjCRootClass }, // AT_ObjCRootClass
2927 : { 1, 0, 0, 0, 0, 0, 0, 1, checkObjCRuntimeNameAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForObjCRuntimeName }, // AT_ObjCRuntimeName
2928 : { 0, 0, 0, 0, 0, 0, 0, 1, checkObjCRuntimeVisibleAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForObjCRuntimeVisible }, // AT_ObjCRuntimeVisible
2929 : { 0, 0, 0, 0, 0, 0, 0, 1, checkObjCSubclassingRestrictedAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForObjCSubclassingRestricted }, // AT_ObjCSubclassingRestricted
2930 : { 0, 0, 0, 0, 0, 0, 0, 0, checkOpenCLAccessAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, OpenCLAccessAttrSpellingMap, nullptr }, // AT_OpenCLAccess
2931 : { 0, 0, 0, 0, 1, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_OpenCLConstantAddressSpace
2932 : { 0, 0, 0, 0, 1, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_OpenCLGenericAddressSpace
2933 : { 0, 0, 0, 0, 1, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_OpenCLGlobalAddressSpace
2934 : { 1, 0, 0, 0, 0, 0, 0, 1, checkOpenCLIntelReqdSubGroupSizeAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForOpenCLIntelReqdSubGroupSize }, // AT_OpenCLIntelReqdSubGroupSize
2935 : { 0, 0, 0, 0, 0, 0, 0, 0, checkOpenCLKernelAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_OpenCLKernel
2936 : { 0, 0, 0, 0, 1, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_OpenCLLocalAddressSpace
2937 : { 0, 0, 0, 0, 0, 0, 0, 1, checkOpenCLNoSVMAppertainsTo, checkOpenCLLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForOpenCLNoSVM }, // AT_OpenCLNoSVM
2938 : { 0, 0, 0, 0, 1, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_OpenCLPrivateAddressSpace
2939 : { 1, 0, 0, 0, 0, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_OpenCLUnrollHint
2940 : { 0, 0, 0, 0, 0, 0, 0, 1, checkOptimizeNoneAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForOptimizeNone }, // AT_OptimizeNone
2941 : { 0, 0, 0, 0, 0, 0, 0, 1, checkOverloadableAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForOverloadable }, // AT_Overloadable
2942 : { 1, 15, 0, 0, 0, 0, 0, 0, checkOwnershipAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, OwnershipAttrSpellingMap, nullptr }, // AT_Ownership
2943 : { 0, 0, 0, 0, 0, 0, 1, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_Packed
2944 : { 1, 0, 0, 0, 0, 0, 0, 1, checkParamTypestateAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForParamTypestate }, // AT_ParamTypestate
2945 : { 0, 0, 0, 0, 1, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_Pascal
2946 : { 1, 0, 0, 0, 0, 0, 0, 1, checkPassObjectSizeAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForPassObjectSize }, // AT_PassObjectSize
2947 : { 1, 0, 0, 0, 1, 0, 1, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_Pcs
2948 : { 1, 0, 0, 0, 0, 0, 0, 0, checkPragmaClangBSSSectionAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_PragmaClangBSSSection
2949 : { 1, 0, 0, 0, 0, 0, 0, 0, checkPragmaClangDataSectionAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_PragmaClangDataSection
2950 : { 1, 0, 0, 0, 0, 0, 0, 0, checkPragmaClangRodataSectionAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_PragmaClangRodataSection
2951 : { 1, 0, 0, 0, 0, 0, 0, 0, checkPragmaClangTextSectionAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_PragmaClangTextSection
2952 : { 0, 0, 0, 0, 1, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_PreserveAll
2953 : { 0, 0, 0, 0, 1, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_PreserveMost
2954 : { 1, 0, 0, 0, 0, 0, 0, 0, checkPtGuardedByAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_PtGuardedBy
2955 : { 0, 0, 0, 0, 0, 0, 0, 0, checkPtGuardedVarAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_PtGuardedVar
2956 : { 0, 0, 0, 0, 1, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_Ptr32
2957 : { 0, 0, 0, 0, 1, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_Ptr64
2958 : { 0, 0, 0, 0, 0, 0, 1, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_Pure
2959 : { 0, 0, 0, 0, 1, 0, 1, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_RegCall
2960 : { 1, 0, 0, 0, 1, 0, 1, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_Regparm
2961 : { 0, 0, 0, 0, 0, 0, 0, 0, checkReinitializesAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_Reinitializes
2962 : { 0, 15, 0, 0, 0, 0, 0, 0, checkReleaseCapabilityAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, ReleaseCapabilityAttrSpellingMap, nullptr }, // AT_ReleaseCapability
2963 : { 0, 0, 0, 0, 0, 0, 0, 1, checkRenderScriptKernelAppertainsTo, checkRenderScriptLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForRenderScriptKernel }, // AT_RenderScriptKernel
2964 : { 3, 0, 0, 0, 0, 0, 0, 1, checkReqdWorkGroupSizeAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForReqdWorkGroupSize }, // AT_ReqdWorkGroupSize
2965 : { 0, 0, 0, 0, 0, 0, 0, 1, checkRequireConstantInitAppertainsTo, checkCPlusPlusLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForRequireConstantInit }, // AT_RequireConstantInit
2966 : { 0, 15, 0, 0, 0, 0, 0, 0, checkRequiresCapabilityAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, RequiresCapabilityAttrSpellingMap, nullptr }, // AT_RequiresCapability
2967 : { 0, 0, 0, 0, 0, 0, 1, 1, checkRestrictAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, RestrictAttrSpellingMap, matchRulesForRestrict }, // AT_Restrict
2968 : { 1, 0, 0, 0, 0, 0, 0, 1, checkReturnTypestateAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForReturnTypestate }, // AT_ReturnTypestate
2969 : { 0, 0, 0, 0, 0, 0, 1, 1, checkReturnsNonNullAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForReturnsNonNull }, // AT_ReturnsNonNull
2970 : { 0, 0, 0, 0, 0, 0, 1, 1, checkReturnsTwiceAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForReturnsTwice }, // AT_ReturnsTwice
2971 : { 0, 0, 0, 0, 1, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_SPtr
2972 : { 0, 0, 0, 0, 0, 0, 0, 1, checkScopedLockableAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForScopedLockable }, // AT_ScopedLockable
2973 : { 1, 0, 0, 0, 0, 0, 1, 1, checkSectionAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, SectionAttrSpellingMap, matchRulesForSection }, // AT_Section
2974 : { 0, 0, 0, 0, 0, 0, 1, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_SelectAny
2975 : { 0, 2, 0, 0, 0, 0, 1, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_Sentinel
2976 : { 1, 0, 0, 0, 0, 0, 0, 1, checkSetTypestateAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForSetTypestate }, // AT_SetTypestate
2977 : { 1, 15, 0, 0, 0, 0, 0, 0, checkSharedTrylockFunctionAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_SharedTrylockFunction
2978 : { 0, 0, 0, 0, 1, 0, 1, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_StdCall
2979 : { 0, 15, 0, 0, 0, 1, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_Suppress
2980 : { 0, 0, 0, 0, 1, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_SwiftCall
2981 : { 0, 0, 0, 0, 0, 0, 0, 1, checkSwiftContextAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForSwiftContext }, // AT_SwiftContext
2982 : { 0, 0, 0, 0, 0, 0, 0, 1, checkSwiftErrorResultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForSwiftErrorResult }, // AT_SwiftErrorResult
2983 : { 0, 0, 0, 0, 0, 0, 0, 1, checkSwiftIndirectResultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForSwiftIndirectResult }, // AT_SwiftIndirectResult
2984 : { 0, 0, 0, 0, 1, 0, 1, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_SysVABI
2985 : { 1, 0, 0, 0, 0, 0, 1, 1, checkTLSModelAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForTLSModel }, // AT_TLSModel
2986 : { 1, 0, 0, 0, 0, 0, 1, 1, checkTargetAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForTarget }, // AT_Target
2987 : { 1, 0, 0, 0, 0, 0, 0, 1, checkTestTypestateAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForTestTypestate }, // AT_TestTypestate
2988 : { 0, 0, 0, 0, 1, 0, 1, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_ThisCall
2989 : { 0, 0, 0, 0, 0, 0, 0, 0, checkThreadAppertainsTo, checkMicrosoftExtLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_Thread
2990 : { 0, 0, 0, 0, 0, 0, 1, 0, defaultAppertainsTo, checkNotCPlusPlusLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_TransparentUnion
2991 : { 0, 0, 0, 0, 0, 0, 0, 1, checkTrivialABIAppertainsTo, checkCPlusPlusLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForTrivialABI }, // AT_TrivialABI
2992 : { 1, 15, 0, 0, 0, 0, 0, 0, checkTryAcquireCapabilityAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, TryAcquireCapabilityAttrSpellingMap, nullptr }, // AT_TryAcquireCapability
2993 : { 0, 0, 0, 0, 1, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_TypeNonNull
2994 : { 0, 0, 0, 0, 1, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_TypeNullUnspecified
2995 : { 0, 0, 0, 0, 1, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_TypeNullable
2996 : { 4, 0, 1, 0, 0, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_TypeTagForDatatype
2997 : { 1, 0, 0, 0, 0, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_TypeVisibility
2998 : { 0, 0, 0, 0, 1, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_UPtr
2999 : { 0, 1, 0, 0, 0, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_Unavailable
3000 : { 0, 0, 0, 0, 0, 0, 1, 0, checkUnusedAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, UnusedAttrSpellingMap, nullptr }, // AT_Unused
3001 : { 0, 0, 0, 0, 0, 0, 1, 0, checkUsedAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_Used
3002 : { 1, 0, 0, 0, 0, 0, 0, 0, checkUuidAppertainsTo, checkMicrosoftExtBorlandLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_Uuid
3003 : { 0, 0, 0, 0, 0, 0, 0, 1, checkVecReturnAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForVecReturn }, // AT_VecReturn
3004 : { 1, 0, 0, 0, 0, 0, 0, 1, checkVecTypeHintAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForVecTypeHint }, // AT_VecTypeHint
3005 : { 0, 0, 0, 0, 1, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_VectorCall
3006 : { 1, 0, 0, 0, 1, 0, 1, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_VectorSize
3007 : { 1, 0, 0, 0, 0, 0, 1, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_Visibility
3008 : { 0, 0, 0, 0, 0, 0, 1, 1, checkWarnUnusedAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForWarnUnused }, // AT_WarnUnused
3009 : { 0, 0, 0, 0, 0, 0, 1, 1, checkWarnUnusedResultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, WarnUnusedResultAttrSpellingMap, matchRulesForWarnUnusedResult }, // AT_WarnUnusedResult
3010 : { 0, 0, 0, 0, 0, 0, 1, 1, checkWeakAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForWeak }, // AT_Weak
3011 : { 0, 0, 0, 0, 0, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_WeakImport
3012 : { 0, 1, 0, 0, 0, 0, 1, 1, checkWeakRefAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForWeakRef }, // AT_WeakRef
3013 : { 3, 0, 0, 0, 0, 0, 0, 1, checkWorkGroupSizeHintAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForWorkGroupSizeHint }, // AT_WorkGroupSizeHint
3014 : { 0, 0, 0, 1, 0, 0, 1, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, isTargetx86x86_64, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_X86ForceAlignArgPointer
3015 : { 0, 0, 0, 0, 0, 0, 0, 1, checkXRayInstrumentAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, XRayInstrumentAttrSpellingMap, matchRulesForXRayInstrument }, // AT_XRayInstrument
3016 : { 1, 0, 0, 0, 0, 0, 0, 1, checkXRayLogArgsAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForXRayLogArgs } // AT_XRayLogArgs
3017 : };
3018 :
3019 934 : static bool checkAttributeMatchRuleAppliesTo(const Decl *D, attr::SubjectMatchRule rule) {
3020 934 : switch (rule) {
3021 15 : case attr::SubjectMatchRule_block:
3022 15 : return isa<BlockDecl>(D);
3023 42 : case attr::SubjectMatchRule_enum:
3024 42 : return isa<EnumDecl>(D);
3025 26 : case attr::SubjectMatchRule_enum_constant:
3026 26 : return isa<EnumConstantDecl>(D);
3027 53 : case attr::SubjectMatchRule_field:
3028 53 : return isa<FieldDecl>(D);
3029 129 : case attr::SubjectMatchRule_function:
3030 129 : return isa<FunctionDecl>(D);
3031 26 : case attr::SubjectMatchRule_function_is_member:
3032 26 : return isa<CXXMethodDecl>(D);
3033 34 : case attr::SubjectMatchRule_namespace:
3034 34 : return isa<NamespaceDecl>(D);
3035 25 : case attr::SubjectMatchRule_objc_category:
3036 25 : return isa<ObjCCategoryDecl>(D);
3037 71 : case attr::SubjectMatchRule_objc_interface:
3038 71 : return isa<ObjCInterfaceDecl>(D);
3039 47 : case attr::SubjectMatchRule_objc_method:
3040 47 : return isa<ObjCMethodDecl>(D);
3041 15 : case attr::SubjectMatchRule_objc_method_is_instance:
3042 : return isObjCInstanceMethod(D);
3043 37 : case attr::SubjectMatchRule_objc_property:
3044 37 : return isa<ObjCPropertyDecl>(D);
3045 28 : case attr::SubjectMatchRule_objc_protocol:
3046 28 : return isa<ObjCProtocolDecl>(D);
3047 32 : case attr::SubjectMatchRule_record:
3048 32 : return isa<RecordDecl>(D) || isa<CXXRecordDecl>(D);
3049 78 : case attr::SubjectMatchRule_record_not_is_union:
3050 : return isStruct(D);
3051 : case attr::SubjectMatchRule_hasType_abstract:
3052 : assert(false && "Abstract matcher rule isn't allowed");
3053 : return false;
3054 43 : case attr::SubjectMatchRule_hasType_functionType:
3055 : return isFunctionLike(D);
3056 28 : case attr::SubjectMatchRule_type_alias:
3057 28 : return isa<TypedefNameDecl>(D);
3058 110 : case attr::SubjectMatchRule_variable:
3059 110 : return isa<VarDecl>(D);
3060 2 : case attr::SubjectMatchRule_variable_is_thread_local:
3061 : return isTLSVar(D);
3062 35 : case attr::SubjectMatchRule_variable_is_global:
3063 : return isGlobalVar(D);
3064 28 : case attr::SubjectMatchRule_variable_is_parameter:
3065 28 : return isa<ParmVarDecl>(D);
3066 30 : case attr::SubjectMatchRule_variable_not_is_parameter:
3067 : return isNonParmVar(D);
3068 : }
3069 0 : llvm_unreachable("Invalid match rule");
3070 : return false;
3071 : }
3072 :
|
