Line data Source code
1 : /*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
2 : |* *|
3 : |* Template instantiation code for attributes *|
4 : |* *|
5 : |* Automatically generated file, do not edit! *|
6 : |* *|
7 : \*===----------------------------------------------------------------------===*/
8 :
9 : namespace clang {
10 : namespace sema {
11 :
12 19202909 : Attr *instantiateTemplateAttribute(const Attr *At, ASTContext &C, Sema &S,
13 : const MultiLevelTemplateArgumentList &TemplateArgs) {
14 19202909 : switch (At->getKind()) {
15 : case attr::AMDGPUFlatWorkGroupSize: {
16 : const auto *A = cast<AMDGPUFlatWorkGroupSizeAttr>(At);
17 0 : return A->clone(C);
18 : }
19 : case attr::AMDGPUNumSGPR: {
20 : const auto *A = cast<AMDGPUNumSGPRAttr>(At);
21 0 : return A->clone(C);
22 : }
23 : case attr::AMDGPUNumVGPR: {
24 : const auto *A = cast<AMDGPUNumVGPRAttr>(At);
25 0 : return A->clone(C);
26 : }
27 : case attr::AMDGPUWavesPerEU: {
28 : const auto *A = cast<AMDGPUWavesPerEUAttr>(At);
29 0 : return A->clone(C);
30 : }
31 : case attr::ARMInterrupt: {
32 : const auto *A = cast<ARMInterruptAttr>(At);
33 0 : return A->clone(C);
34 : }
35 : case attr::AVRInterrupt: {
36 : const auto *A = cast<AVRInterruptAttr>(At);
37 0 : return A->clone(C);
38 : }
39 : case attr::AVRSignal: {
40 : const auto *A = cast<AVRSignalAttr>(At);
41 0 : return A->clone(C);
42 : }
43 : case attr::AbiTag: {
44 : const auto *A = cast<AbiTagAttr>(At);
45 892 : return A->clone(C);
46 : }
47 : case attr::AcquireCapability: {
48 : const auto *A = cast<AcquireCapabilityAttr>(At);
49 10 : auto *tempInstArgs = new (C, 16) Expr *[A->args_size()];
50 : {
51 : EnterExpressionEvaluationContext Unevaluated(S, Sema::ExpressionEvaluationContext::Unevaluated);
52 : Expr * *TI = tempInstArgs;
53 10 : Expr * *I = A->args_begin();
54 10 : Expr * *E = A->args_end();
55 20 : for (; I != E; ++I, ++TI) {
56 10 : ExprResult Result = S.SubstExpr(*I, TemplateArgs);
57 10 : *TI = Result.getAs<Expr>();
58 : }
59 : }
60 10 : return new (C) AcquireCapabilityAttr(A->getLocation(), C, tempInstArgs, A->args_size(), A->getSpellingListIndex());
61 : }
62 : case attr::AcquiredAfter: {
63 : const auto *A = cast<AcquiredAfterAttr>(At);
64 0 : auto *tempInstArgs = new (C, 16) Expr *[A->args_size()];
65 : {
66 : EnterExpressionEvaluationContext Unevaluated(S, Sema::ExpressionEvaluationContext::Unevaluated);
67 : Expr * *TI = tempInstArgs;
68 0 : Expr * *I = A->args_begin();
69 0 : Expr * *E = A->args_end();
70 0 : for (; I != E; ++I, ++TI) {
71 0 : ExprResult Result = S.SubstExpr(*I, TemplateArgs);
72 0 : *TI = Result.getAs<Expr>();
73 : }
74 : }
75 0 : return new (C) AcquiredAfterAttr(A->getLocation(), C, tempInstArgs, A->args_size(), A->getSpellingListIndex());
76 : }
77 : case attr::AcquiredBefore: {
78 : const auto *A = cast<AcquiredBeforeAttr>(At);
79 0 : auto *tempInstArgs = new (C, 16) Expr *[A->args_size()];
80 : {
81 : EnterExpressionEvaluationContext Unevaluated(S, Sema::ExpressionEvaluationContext::Unevaluated);
82 : Expr * *TI = tempInstArgs;
83 0 : Expr * *I = A->args_begin();
84 0 : Expr * *E = A->args_end();
85 0 : for (; I != E; ++I, ++TI) {
86 0 : ExprResult Result = S.SubstExpr(*I, TemplateArgs);
87 0 : *TI = Result.getAs<Expr>();
88 : }
89 : }
90 0 : return new (C) AcquiredBeforeAttr(A->getLocation(), C, tempInstArgs, A->args_size(), A->getSpellingListIndex());
91 : }
92 : case attr::AddressSpace: {
93 : const auto *A = cast<AddressSpaceAttr>(At);
94 0 : return A->clone(C);
95 : }
96 : case attr::Alias: {
97 : const auto *A = cast<AliasAttr>(At);
98 0 : return A->clone(C);
99 : }
100 : case attr::AlignMac68k: {
101 : const auto *A = cast<AlignMac68kAttr>(At);
102 0 : return A->clone(C);
103 : }
104 : case attr::AlignValue: {
105 : const auto *A = cast<AlignValueAttr>(At);
106 0 : return A->clone(C);
107 : }
108 : case attr::Aligned: {
109 : const auto *A = cast<AlignedAttr>(At);
110 4872 : return A->clone(C);
111 : }
112 : case attr::AllocAlign: {
113 : const auto *A = cast<AllocAlignAttr>(At);
114 0 : return A->clone(C);
115 : }
116 : case attr::AllocSize: {
117 : const auto *A = cast<AllocSizeAttr>(At);
118 10 : return new (C) AllocSizeAttr(A->getLocation(), C, A->getElemSizeParam(), A->getNumElemsParam(), A->getSpellingListIndex());
119 : }
120 : case attr::AlwaysDestroy: {
121 : const auto *A = cast<AlwaysDestroyAttr>(At);
122 0 : return A->clone(C);
123 : }
124 : case attr::AlwaysInline: {
125 : const auto *A = cast<AlwaysInlineAttr>(At);
126 7033526 : return A->clone(C);
127 : }
128 : case attr::AnalyzerNoReturn: {
129 : const auto *A = cast<AnalyzerNoReturnAttr>(At);
130 0 : return A->clone(C);
131 : }
132 : case attr::Annotate: {
133 : const auto *A = cast<AnnotateAttr>(At);
134 4 : return A->clone(C);
135 : }
136 : case attr::AnyX86Interrupt: {
137 : const auto *A = cast<AnyX86InterruptAttr>(At);
138 5 : return A->clone(C);
139 : }
140 : case attr::AnyX86NoCallerSavedRegisters: {
141 : const auto *A = cast<AnyX86NoCallerSavedRegistersAttr>(At);
142 0 : return A->clone(C);
143 : }
144 : case attr::AnyX86NoCfCheck: {
145 : const auto *A = cast<AnyX86NoCfCheckAttr>(At);
146 0 : return A->clone(C);
147 : }
148 : case attr::ArcWeakrefUnavailable: {
149 : const auto *A = cast<ArcWeakrefUnavailableAttr>(At);
150 0 : return A->clone(C);
151 : }
152 : case attr::ArgumentWithTypeTag: {
153 : const auto *A = cast<ArgumentWithTypeTagAttr>(At);
154 0 : return A->clone(C);
155 : }
156 : case attr::Artificial: {
157 : const auto *A = cast<ArtificialAttr>(At);
158 0 : return A->clone(C);
159 : }
160 : case attr::AsmLabel: {
161 : const auto *A = cast<AsmLabelAttr>(At);
162 1 : return A->clone(C);
163 : }
164 : case attr::AssertCapability: {
165 : const auto *A = cast<AssertCapabilityAttr>(At);
166 0 : auto *tempInstArgs = new (C, 16) Expr *[A->args_size()];
167 : {
168 : EnterExpressionEvaluationContext Unevaluated(S, Sema::ExpressionEvaluationContext::Unevaluated);
169 : Expr * *TI = tempInstArgs;
170 0 : Expr * *I = A->args_begin();
171 0 : Expr * *E = A->args_end();
172 0 : for (; I != E; ++I, ++TI) {
173 0 : ExprResult Result = S.SubstExpr(*I, TemplateArgs);
174 0 : *TI = Result.getAs<Expr>();
175 : }
176 : }
177 0 : return new (C) AssertCapabilityAttr(A->getLocation(), C, tempInstArgs, A->args_size(), A->getSpellingListIndex());
178 : }
179 : case attr::AssertExclusiveLock: {
180 : const auto *A = cast<AssertExclusiveLockAttr>(At);
181 0 : auto *tempInstArgs = new (C, 16) Expr *[A->args_size()];
182 : {
183 : EnterExpressionEvaluationContext Unevaluated(S, Sema::ExpressionEvaluationContext::Unevaluated);
184 : Expr * *TI = tempInstArgs;
185 0 : Expr * *I = A->args_begin();
186 0 : Expr * *E = A->args_end();
187 0 : for (; I != E; ++I, ++TI) {
188 0 : ExprResult Result = S.SubstExpr(*I, TemplateArgs);
189 0 : *TI = Result.getAs<Expr>();
190 : }
191 : }
192 0 : return new (C) AssertExclusiveLockAttr(A->getLocation(), C, tempInstArgs, A->args_size(), A->getSpellingListIndex());
193 : }
194 : case attr::AssertSharedLock: {
195 : const auto *A = cast<AssertSharedLockAttr>(At);
196 0 : auto *tempInstArgs = new (C, 16) Expr *[A->args_size()];
197 : {
198 : EnterExpressionEvaluationContext Unevaluated(S, Sema::ExpressionEvaluationContext::Unevaluated);
199 : Expr * *TI = tempInstArgs;
200 0 : Expr * *I = A->args_begin();
201 0 : Expr * *E = A->args_end();
202 0 : for (; I != E; ++I, ++TI) {
203 0 : ExprResult Result = S.SubstExpr(*I, TemplateArgs);
204 0 : *TI = Result.getAs<Expr>();
205 : }
206 : }
207 0 : return new (C) AssertSharedLockAttr(A->getLocation(), C, tempInstArgs, A->args_size(), A->getSpellingListIndex());
208 : }
209 : case attr::AssumeAligned: {
210 : const auto *A = cast<AssumeAlignedAttr>(At);
211 0 : return A->clone(C);
212 : }
213 : case attr::Availability: {
214 : const auto *A = cast<AvailabilityAttr>(At);
215 2 : return A->clone(C);
216 : }
217 : case attr::Blocks: {
218 : const auto *A = cast<BlocksAttr>(At);
219 3 : return A->clone(C);
220 : }
221 : case attr::C11NoReturn: {
222 : const auto *A = cast<C11NoReturnAttr>(At);
223 0 : return A->clone(C);
224 : }
225 : case attr::CDecl: {
226 : const auto *A = cast<CDeclAttr>(At);
227 0 : return A->clone(C);
228 : }
229 : case attr::CFAuditedTransfer: {
230 : const auto *A = cast<CFAuditedTransferAttr>(At);
231 0 : return A->clone(C);
232 : }
233 : case attr::CFConsumed: {
234 : const auto *A = cast<CFConsumedAttr>(At);
235 0 : return A->clone(C);
236 : }
237 : case attr::CFReturnsNotRetained: {
238 : const auto *A = cast<CFReturnsNotRetainedAttr>(At);
239 0 : return A->clone(C);
240 : }
241 : case attr::CFReturnsRetained: {
242 : const auto *A = cast<CFReturnsRetainedAttr>(At);
243 0 : return A->clone(C);
244 : }
245 : case attr::CFUnknownTransfer: {
246 : const auto *A = cast<CFUnknownTransferAttr>(At);
247 0 : return A->clone(C);
248 : }
249 : case attr::CPUDispatch: {
250 : const auto *A = cast<CPUDispatchAttr>(At);
251 0 : return A->clone(C);
252 : }
253 : case attr::CPUSpecific: {
254 : const auto *A = cast<CPUSpecificAttr>(At);
255 0 : return A->clone(C);
256 : }
257 : case attr::CUDAConstant: {
258 : const auto *A = cast<CUDAConstantAttr>(At);
259 0 : return A->clone(C);
260 : }
261 : case attr::CUDADevice: {
262 : const auto *A = cast<CUDADeviceAttr>(At);
263 120 : return A->clone(C);
264 : }
265 : case attr::CUDAGlobal: {
266 : const auto *A = cast<CUDAGlobalAttr>(At);
267 12 : return A->clone(C);
268 : }
269 : case attr::CUDAHost: {
270 : const auto *A = cast<CUDAHostAttr>(At);
271 104 : return A->clone(C);
272 : }
273 : case attr::CUDAInvalidTarget: {
274 : const auto *A = cast<CUDAInvalidTargetAttr>(At);
275 0 : return A->clone(C);
276 : }
277 : case attr::CUDALaunchBounds: {
278 : const auto *A = cast<CUDALaunchBoundsAttr>(At);
279 0 : return A->clone(C);
280 : }
281 : case attr::CUDAShared: {
282 : const auto *A = cast<CUDASharedAttr>(At);
283 2 : return A->clone(C);
284 : }
285 : case attr::CXX11NoReturn: {
286 : const auto *A = cast<CXX11NoReturnAttr>(At);
287 12013 : return A->clone(C);
288 : }
289 : case attr::CallableWhen: {
290 : const auto *A = cast<CallableWhenAttr>(At);
291 6 : return A->clone(C);
292 : }
293 : case attr::Capability: {
294 : const auto *A = cast<CapabilityAttr>(At);
295 0 : return A->clone(C);
296 : }
297 : case attr::CapturedRecord: {
298 : const auto *A = cast<CapturedRecordAttr>(At);
299 0 : return A->clone(C);
300 : }
301 : case attr::CarriesDependency: {
302 : const auto *A = cast<CarriesDependencyAttr>(At);
303 0 : return A->clone(C);
304 : }
305 : case attr::Cleanup: {
306 : const auto *A = cast<CleanupAttr>(At);
307 0 : return A->clone(C);
308 : }
309 : case attr::CodeSeg: {
310 : const auto *A = cast<CodeSegAttr>(At);
311 12 : return A->clone(C);
312 : }
313 : case attr::Cold: {
314 : const auto *A = cast<ColdAttr>(At);
315 0 : return A->clone(C);
316 : }
317 : case attr::Common: {
318 : const auto *A = cast<CommonAttr>(At);
319 0 : return A->clone(C);
320 : }
321 : case attr::Const: {
322 : const auto *A = cast<ConstAttr>(At);
323 0 : return A->clone(C);
324 : }
325 : case attr::Constructor: {
326 : const auto *A = cast<ConstructorAttr>(At);
327 0 : return A->clone(C);
328 : }
329 : case attr::Consumable: {
330 : const auto *A = cast<ConsumableAttr>(At);
331 2 : return A->clone(C);
332 : }
333 : case attr::ConsumableAutoCast: {
334 : const auto *A = cast<ConsumableAutoCastAttr>(At);
335 0 : return A->clone(C);
336 : }
337 : case attr::ConsumableSetOnRead: {
338 : const auto *A = cast<ConsumableSetOnReadAttr>(At);
339 0 : return A->clone(C);
340 : }
341 : case attr::Convergent: {
342 : const auto *A = cast<ConvergentAttr>(At);
343 0 : return A->clone(C);
344 : }
345 : case attr::DLLExport: {
346 : const auto *A = cast<DLLExportAttr>(At);
347 626 : return A->clone(C);
348 : }
349 : case attr::DLLImport: {
350 : const auto *A = cast<DLLImportAttr>(At);
351 358 : return A->clone(C);
352 : }
353 : case attr::Deprecated: {
354 : const auto *A = cast<DeprecatedAttr>(At);
355 35 : return A->clone(C);
356 : }
357 : case attr::Destructor: {
358 : const auto *A = cast<DestructorAttr>(At);
359 0 : return A->clone(C);
360 : }
361 : case attr::DiagnoseIf: {
362 : const auto *A = cast<DiagnoseIfAttr>(At);
363 : Expr * tempInstCond;
364 : {
365 : EnterExpressionEvaluationContext Unevaluated(S, Sema::ExpressionEvaluationContext::Unevaluated);
366 0 : ExprResult Result = S.SubstExpr(A->getCond(), TemplateArgs);
367 : tempInstCond = Result.getAs<Expr>();
368 : }
369 0 : return new (C) DiagnoseIfAttr(A->getLocation(), C, tempInstCond, A->getMessage(), A->getDiagnosticType(), A->getArgDependent(), A->getParent(), A->getSpellingListIndex());
370 : }
371 : case attr::DisableTailCalls: {
372 : const auto *A = cast<DisableTailCallsAttr>(At);
373 0 : return A->clone(C);
374 : }
375 : case attr::EmptyBases: {
376 : const auto *A = cast<EmptyBasesAttr>(At);
377 0 : return A->clone(C);
378 : }
379 : case attr::EnableIf: {
380 : const auto *A = cast<EnableIfAttr>(At);
381 : Expr * tempInstCond;
382 : {
383 : EnterExpressionEvaluationContext Unevaluated(S, Sema::ExpressionEvaluationContext::Unevaluated);
384 0 : ExprResult Result = S.SubstExpr(A->getCond(), TemplateArgs);
385 : tempInstCond = Result.getAs<Expr>();
386 : }
387 0 : return new (C) EnableIfAttr(A->getLocation(), C, tempInstCond, A->getMessage(), A->getSpellingListIndex());
388 : }
389 : case attr::EnumExtensibility: {
390 : const auto *A = cast<EnumExtensibilityAttr>(At);
391 0 : return A->clone(C);
392 : }
393 : case attr::ExcludeFromExplicitInstantiation: {
394 : const auto *A = cast<ExcludeFromExplicitInstantiationAttr>(At);
395 29 : return A->clone(C);
396 : }
397 : case attr::ExclusiveTrylockFunction: {
398 : const auto *A = cast<ExclusiveTrylockFunctionAttr>(At);
399 : Expr * tempInstSuccessValue;
400 : {
401 : EnterExpressionEvaluationContext Unevaluated(S, Sema::ExpressionEvaluationContext::Unevaluated);
402 0 : ExprResult Result = S.SubstExpr(A->getSuccessValue(), TemplateArgs);
403 : tempInstSuccessValue = Result.getAs<Expr>();
404 : }
405 0 : auto *tempInstArgs = new (C, 16) Expr *[A->args_size()];
406 : {
407 : EnterExpressionEvaluationContext Unevaluated(S, Sema::ExpressionEvaluationContext::Unevaluated);
408 : Expr * *TI = tempInstArgs;
409 0 : Expr * *I = A->args_begin();
410 0 : Expr * *E = A->args_end();
411 0 : for (; I != E; ++I, ++TI) {
412 0 : ExprResult Result = S.SubstExpr(*I, TemplateArgs);
413 0 : *TI = Result.getAs<Expr>();
414 : }
415 : }
416 0 : return new (C) ExclusiveTrylockFunctionAttr(A->getLocation(), C, tempInstSuccessValue, tempInstArgs, A->args_size(), A->getSpellingListIndex());
417 : }
418 : case attr::ExternalSourceSymbol: {
419 : const auto *A = cast<ExternalSourceSymbolAttr>(At);
420 0 : return A->clone(C);
421 : }
422 : case attr::FallThrough: {
423 : const auto *A = cast<FallThroughAttr>(At);
424 0 : return A->clone(C);
425 : }
426 : case attr::FastCall: {
427 : const auto *A = cast<FastCallAttr>(At);
428 0 : return A->clone(C);
429 : }
430 : case attr::Final: {
431 : const auto *A = cast<FinalAttr>(At);
432 108 : return A->clone(C);
433 : }
434 : case attr::FlagEnum: {
435 : const auto *A = cast<FlagEnumAttr>(At);
436 0 : return A->clone(C);
437 : }
438 : case attr::Flatten: {
439 : const auto *A = cast<FlattenAttr>(At);
440 0 : return A->clone(C);
441 : }
442 : case attr::Format: {
443 : const auto *A = cast<FormatAttr>(At);
444 3 : return A->clone(C);
445 : }
446 : case attr::FormatArg: {
447 : const auto *A = cast<FormatArgAttr>(At);
448 0 : return A->clone(C);
449 : }
450 : case attr::GNUInline: {
451 : const auto *A = cast<GNUInlineAttr>(At);
452 0 : return A->clone(C);
453 : }
454 : case attr::GuardedBy: {
455 : const auto *A = cast<GuardedByAttr>(At);
456 : Expr * tempInstArg;
457 : {
458 : EnterExpressionEvaluationContext Unevaluated(S, Sema::ExpressionEvaluationContext::Unevaluated);
459 24 : ExprResult Result = S.SubstExpr(A->getArg(), TemplateArgs);
460 : tempInstArg = Result.getAs<Expr>();
461 : }
462 : return new (C) GuardedByAttr(A->getLocation(), C, tempInstArg, A->getSpellingListIndex());
463 : }
464 : case attr::GuardedVar: {
465 : const auto *A = cast<GuardedVarAttr>(At);
466 0 : return A->clone(C);
467 : }
468 : case attr::Hot: {
469 : const auto *A = cast<HotAttr>(At);
470 0 : return A->clone(C);
471 : }
472 : case attr::IBAction: {
473 : const auto *A = cast<IBActionAttr>(At);
474 0 : return A->clone(C);
475 : }
476 : case attr::IBOutlet: {
477 : const auto *A = cast<IBOutletAttr>(At);
478 0 : return A->clone(C);
479 : }
480 : case attr::IBOutletCollection: {
481 : const auto *A = cast<IBOutletCollectionAttr>(At);
482 0 : return A->clone(C);
483 : }
484 : case attr::IFunc: {
485 : const auto *A = cast<IFuncAttr>(At);
486 0 : return A->clone(C);
487 : }
488 : case attr::InitPriority: {
489 : const auto *A = cast<InitPriorityAttr>(At);
490 0 : return A->clone(C);
491 : }
492 : case attr::InitSeg: {
493 : const auto *A = cast<InitSegAttr>(At);
494 2 : return A->clone(C);
495 : }
496 : case attr::IntelOclBicc: {
497 : const auto *A = cast<IntelOclBiccAttr>(At);
498 0 : return A->clone(C);
499 : }
500 : case attr::InternalLinkage: {
501 : const auto *A = cast<InternalLinkageAttr>(At);
502 0 : return A->clone(C);
503 : }
504 : case attr::LTOVisibilityPublic: {
505 : const auto *A = cast<LTOVisibilityPublicAttr>(At);
506 0 : return A->clone(C);
507 : }
508 : case attr::LayoutVersion: {
509 : const auto *A = cast<LayoutVersionAttr>(At);
510 0 : return A->clone(C);
511 : }
512 : case attr::LifetimeBound: {
513 : const auto *A = cast<LifetimeBoundAttr>(At);
514 3 : return A->clone(C);
515 : }
516 : case attr::LockReturned: {
517 : const auto *A = cast<LockReturnedAttr>(At);
518 : Expr * tempInstArg;
519 : {
520 : EnterExpressionEvaluationContext Unevaluated(S, Sema::ExpressionEvaluationContext::Unevaluated);
521 4 : ExprResult Result = S.SubstExpr(A->getArg(), TemplateArgs);
522 : tempInstArg = Result.getAs<Expr>();
523 : }
524 : return new (C) LockReturnedAttr(A->getLocation(), C, tempInstArg, A->getSpellingListIndex());
525 : }
526 : case attr::LocksExcluded: {
527 : const auto *A = cast<LocksExcludedAttr>(At);
528 4 : auto *tempInstArgs = new (C, 16) Expr *[A->args_size()];
529 : {
530 : EnterExpressionEvaluationContext Unevaluated(S, Sema::ExpressionEvaluationContext::Unevaluated);
531 : Expr * *TI = tempInstArgs;
532 4 : Expr * *I = A->args_begin();
533 4 : Expr * *E = A->args_end();
534 8 : for (; I != E; ++I, ++TI) {
535 4 : ExprResult Result = S.SubstExpr(*I, TemplateArgs);
536 4 : *TI = Result.getAs<Expr>();
537 : }
538 : }
539 4 : return new (C) LocksExcludedAttr(A->getLocation(), C, tempInstArgs, A->args_size(), A->getSpellingListIndex());
540 : }
541 : case attr::LoopHint: {
542 : const auto *A = cast<LoopHintAttr>(At);
543 0 : return A->clone(C);
544 : }
545 : case attr::MSABI: {
546 : const auto *A = cast<MSABIAttr>(At);
547 0 : return A->clone(C);
548 : }
549 : case attr::MSInheritance: {
550 : const auto *A = cast<MSInheritanceAttr>(At);
551 0 : return A->clone(C);
552 : }
553 : case attr::MSNoVTable: {
554 : const auto *A = cast<MSNoVTableAttr>(At);
555 0 : return A->clone(C);
556 : }
557 : case attr::MSP430Interrupt: {
558 : const auto *A = cast<MSP430InterruptAttr>(At);
559 0 : return A->clone(C);
560 : }
561 : case attr::MSStruct: {
562 : const auto *A = cast<MSStructAttr>(At);
563 1 : return A->clone(C);
564 : }
565 : case attr::MSVtorDisp: {
566 : const auto *A = cast<MSVtorDispAttr>(At);
567 2 : return A->clone(C);
568 : }
569 : case attr::MaxFieldAlignment: {
570 : const auto *A = cast<MaxFieldAlignmentAttr>(At);
571 1 : return A->clone(C);
572 : }
573 : case attr::MayAlias: {
574 : const auto *A = cast<MayAliasAttr>(At);
575 0 : return A->clone(C);
576 : }
577 : case attr::MicroMips: {
578 : const auto *A = cast<MicroMipsAttr>(At);
579 0 : return A->clone(C);
580 : }
581 : case attr::MinSize: {
582 : const auto *A = cast<MinSizeAttr>(At);
583 12 : return A->clone(C);
584 : }
585 : case attr::MinVectorWidth: {
586 : const auto *A = cast<MinVectorWidthAttr>(At);
587 0 : return A->clone(C);
588 : }
589 : case attr::Mips16: {
590 : const auto *A = cast<Mips16Attr>(At);
591 0 : return A->clone(C);
592 : }
593 : case attr::MipsInterrupt: {
594 : const auto *A = cast<MipsInterruptAttr>(At);
595 0 : return A->clone(C);
596 : }
597 : case attr::MipsLongCall: {
598 : const auto *A = cast<MipsLongCallAttr>(At);
599 0 : return A->clone(C);
600 : }
601 : case attr::MipsShortCall: {
602 : const auto *A = cast<MipsShortCallAttr>(At);
603 0 : return A->clone(C);
604 : }
605 : case attr::Mode: {
606 : const auto *A = cast<ModeAttr>(At);
607 0 : return A->clone(C);
608 : }
609 : case attr::NSConsumed: {
610 : const auto *A = cast<NSConsumedAttr>(At);
611 0 : return A->clone(C);
612 : }
613 : case attr::NSConsumesSelf: {
614 : const auto *A = cast<NSConsumesSelfAttr>(At);
615 0 : return A->clone(C);
616 : }
617 : case attr::NSReturnsAutoreleased: {
618 : const auto *A = cast<NSReturnsAutoreleasedAttr>(At);
619 0 : return A->clone(C);
620 : }
621 : case attr::NSReturnsNotRetained: {
622 : const auto *A = cast<NSReturnsNotRetainedAttr>(At);
623 0 : return A->clone(C);
624 : }
625 : case attr::NSReturnsRetained: {
626 : const auto *A = cast<NSReturnsRetainedAttr>(At);
627 0 : return A->clone(C);
628 : }
629 : case attr::Naked: {
630 : const auto *A = cast<NakedAttr>(At);
631 0 : return A->clone(C);
632 : }
633 : case attr::NoAlias: {
634 : const auto *A = cast<NoAliasAttr>(At);
635 0 : return A->clone(C);
636 : }
637 : case attr::NoCommon: {
638 : const auto *A = cast<NoCommonAttr>(At);
639 0 : return A->clone(C);
640 : }
641 : case attr::NoDebug: {
642 : const auto *A = cast<NoDebugAttr>(At);
643 0 : return A->clone(C);
644 : }
645 : case attr::NoDestroy: {
646 : const auto *A = cast<NoDestroyAttr>(At);
647 0 : return A->clone(C);
648 : }
649 : case attr::NoDuplicate: {
650 : const auto *A = cast<NoDuplicateAttr>(At);
651 0 : return A->clone(C);
652 : }
653 : case attr::NoEscape: {
654 : const auto *A = cast<NoEscapeAttr>(At);
655 0 : return A->clone(C);
656 : }
657 : case attr::NoInline: {
658 : const auto *A = cast<NoInlineAttr>(At);
659 73 : return A->clone(C);
660 : }
661 : case attr::NoInstrumentFunction: {
662 : const auto *A = cast<NoInstrumentFunctionAttr>(At);
663 0 : return A->clone(C);
664 : }
665 : case attr::NoMicroMips: {
666 : const auto *A = cast<NoMicroMipsAttr>(At);
667 0 : return A->clone(C);
668 : }
669 : case attr::NoMips16: {
670 : const auto *A = cast<NoMips16Attr>(At);
671 0 : return A->clone(C);
672 : }
673 : case attr::NoReturn: {
674 : const auto *A = cast<NoReturnAttr>(At);
675 0 : return A->clone(C);
676 : }
677 : case attr::NoSanitize: {
678 : const auto *A = cast<NoSanitizeAttr>(At);
679 77548 : return A->clone(C);
680 : }
681 : case attr::NoSplitStack: {
682 : const auto *A = cast<NoSplitStackAttr>(At);
683 2 : return A->clone(C);
684 : }
685 : case attr::NoStackProtector: {
686 : const auto *A = cast<NoStackProtectorAttr>(At);
687 0 : return A->clone(C);
688 : }
689 : case attr::NoThreadSafetyAnalysis: {
690 : const auto *A = cast<NoThreadSafetyAnalysisAttr>(At);
691 20 : return A->clone(C);
692 : }
693 : case attr::NoThrow: {
694 : const auto *A = cast<NoThrowAttr>(At);
695 6 : return A->clone(C);
696 : }
697 : case attr::NonNull: {
698 : const auto *A = cast<NonNullAttr>(At);
699 2 : return A->clone(C);
700 : }
701 : case attr::NotTailCalled: {
702 : const auto *A = cast<NotTailCalledAttr>(At);
703 0 : return A->clone(C);
704 : }
705 : case attr::OMPCaptureKind: {
706 : const auto *A = cast<OMPCaptureKindAttr>(At);
707 0 : return A->clone(C);
708 : }
709 : case attr::OMPCaptureNoInit: {
710 : const auto *A = cast<OMPCaptureNoInitAttr>(At);
711 0 : return A->clone(C);
712 : }
713 : case attr::OMPDeclareSimdDecl: {
714 : const auto *A = cast<OMPDeclareSimdDeclAttr>(At);
715 0 : return A->clone(C);
716 : }
717 : case attr::OMPDeclareTargetDecl: {
718 : const auto *A = cast<OMPDeclareTargetDeclAttr>(At);
719 30 : return A->clone(C);
720 : }
721 : case attr::OMPReferencedVar: {
722 : const auto *A = cast<OMPReferencedVarAttr>(At);
723 0 : return A->clone(C);
724 : }
725 : case attr::OMPThreadPrivateDecl: {
726 : const auto *A = cast<OMPThreadPrivateDeclAttr>(At);
727 4 : return A->clone(C);
728 : }
729 : case attr::ObjCBoxable: {
730 : const auto *A = cast<ObjCBoxableAttr>(At);
731 0 : return A->clone(C);
732 : }
733 : case attr::ObjCBridge: {
734 : const auto *A = cast<ObjCBridgeAttr>(At);
735 0 : return A->clone(C);
736 : }
737 : case attr::ObjCBridgeMutable: {
738 : const auto *A = cast<ObjCBridgeMutableAttr>(At);
739 0 : return A->clone(C);
740 : }
741 : case attr::ObjCBridgeRelated: {
742 : const auto *A = cast<ObjCBridgeRelatedAttr>(At);
743 0 : return A->clone(C);
744 : }
745 : case attr::ObjCDesignatedInitializer: {
746 : const auto *A = cast<ObjCDesignatedInitializerAttr>(At);
747 0 : return A->clone(C);
748 : }
749 : case attr::ObjCException: {
750 : const auto *A = cast<ObjCExceptionAttr>(At);
751 0 : return A->clone(C);
752 : }
753 : case attr::ObjCExplicitProtocolImpl: {
754 : const auto *A = cast<ObjCExplicitProtocolImplAttr>(At);
755 0 : return A->clone(C);
756 : }
757 : case attr::ObjCGC: {
758 : const auto *A = cast<ObjCGCAttr>(At);
759 0 : return A->clone(C);
760 : }
761 : case attr::ObjCIndependentClass: {
762 : const auto *A = cast<ObjCIndependentClassAttr>(At);
763 0 : return A->clone(C);
764 : }
765 : case attr::ObjCInertUnsafeUnretained: {
766 : const auto *A = cast<ObjCInertUnsafeUnretainedAttr>(At);
767 0 : return A->clone(C);
768 : }
769 : case attr::ObjCKindOf: {
770 : const auto *A = cast<ObjCKindOfAttr>(At);
771 0 : return A->clone(C);
772 : }
773 : case attr::ObjCMethodFamily: {
774 : const auto *A = cast<ObjCMethodFamilyAttr>(At);
775 0 : return A->clone(C);
776 : }
777 : case attr::ObjCNSObject: {
778 : const auto *A = cast<ObjCNSObjectAttr>(At);
779 0 : return A->clone(C);
780 : }
781 : case attr::ObjCOwnership: {
782 : const auto *A = cast<ObjCOwnershipAttr>(At);
783 0 : return A->clone(C);
784 : }
785 : case attr::ObjCPreciseLifetime: {
786 : const auto *A = cast<ObjCPreciseLifetimeAttr>(At);
787 0 : return A->clone(C);
788 : }
789 : case attr::ObjCRequiresPropertyDefs: {
790 : const auto *A = cast<ObjCRequiresPropertyDefsAttr>(At);
791 0 : return A->clone(C);
792 : }
793 : case attr::ObjCRequiresSuper: {
794 : const auto *A = cast<ObjCRequiresSuperAttr>(At);
795 0 : return A->clone(C);
796 : }
797 : case attr::ObjCReturnsInnerPointer: {
798 : const auto *A = cast<ObjCReturnsInnerPointerAttr>(At);
799 0 : return A->clone(C);
800 : }
801 : case attr::ObjCRootClass: {
802 : const auto *A = cast<ObjCRootClassAttr>(At);
803 0 : return A->clone(C);
804 : }
805 : case attr::ObjCRuntimeName: {
806 : const auto *A = cast<ObjCRuntimeNameAttr>(At);
807 0 : return A->clone(C);
808 : }
809 : case attr::ObjCRuntimeVisible: {
810 : const auto *A = cast<ObjCRuntimeVisibleAttr>(At);
811 0 : return A->clone(C);
812 : }
813 : case attr::ObjCSubclassingRestricted: {
814 : const auto *A = cast<ObjCSubclassingRestrictedAttr>(At);
815 0 : return A->clone(C);
816 : }
817 : case attr::OpenCLAccess: {
818 : const auto *A = cast<OpenCLAccessAttr>(At);
819 0 : return A->clone(C);
820 : }
821 : case attr::OpenCLConstantAddressSpace: {
822 : const auto *A = cast<OpenCLConstantAddressSpaceAttr>(At);
823 0 : return A->clone(C);
824 : }
825 : case attr::OpenCLGenericAddressSpace: {
826 : const auto *A = cast<OpenCLGenericAddressSpaceAttr>(At);
827 0 : return A->clone(C);
828 : }
829 : case attr::OpenCLGlobalAddressSpace: {
830 : const auto *A = cast<OpenCLGlobalAddressSpaceAttr>(At);
831 0 : return A->clone(C);
832 : }
833 : case attr::OpenCLIntelReqdSubGroupSize: {
834 : const auto *A = cast<OpenCLIntelReqdSubGroupSizeAttr>(At);
835 0 : return A->clone(C);
836 : }
837 : case attr::OpenCLKernel: {
838 : const auto *A = cast<OpenCLKernelAttr>(At);
839 0 : return A->clone(C);
840 : }
841 : case attr::OpenCLLocalAddressSpace: {
842 : const auto *A = cast<OpenCLLocalAddressSpaceAttr>(At);
843 0 : return A->clone(C);
844 : }
845 : case attr::OpenCLPrivateAddressSpace: {
846 : const auto *A = cast<OpenCLPrivateAddressSpaceAttr>(At);
847 0 : return A->clone(C);
848 : }
849 : case attr::OpenCLUnrollHint: {
850 : const auto *A = cast<OpenCLUnrollHintAttr>(At);
851 0 : return A->clone(C);
852 : }
853 : case attr::OptimizeNone: {
854 : const auto *A = cast<OptimizeNoneAttr>(At);
855 9 : return A->clone(C);
856 : }
857 : case attr::Overloadable: {
858 : const auto *A = cast<OverloadableAttr>(At);
859 0 : return A->clone(C);
860 : }
861 : case attr::Override: {
862 : const auto *A = cast<OverrideAttr>(At);
863 22 : return A->clone(C);
864 : }
865 : case attr::Ownership: {
866 : const auto *A = cast<OwnershipAttr>(At);
867 0 : return A->clone(C);
868 : }
869 : case attr::Packed: {
870 : const auto *A = cast<PackedAttr>(At);
871 8 : return A->clone(C);
872 : }
873 : case attr::ParamTypestate: {
874 : const auto *A = cast<ParamTypestateAttr>(At);
875 0 : return A->clone(C);
876 : }
877 : case attr::Pascal: {
878 : const auto *A = cast<PascalAttr>(At);
879 0 : return A->clone(C);
880 : }
881 : case attr::PassObjectSize: {
882 : const auto *A = cast<PassObjectSizeAttr>(At);
883 11 : return A->clone(C);
884 : }
885 : case attr::Pcs: {
886 : const auto *A = cast<PcsAttr>(At);
887 0 : return A->clone(C);
888 : }
889 : case attr::PragmaClangBSSSection: {
890 : const auto *A = cast<PragmaClangBSSSectionAttr>(At);
891 0 : return A->clone(C);
892 : }
893 : case attr::PragmaClangDataSection: {
894 : const auto *A = cast<PragmaClangDataSectionAttr>(At);
895 0 : return A->clone(C);
896 : }
897 : case attr::PragmaClangRodataSection: {
898 : const auto *A = cast<PragmaClangRodataSectionAttr>(At);
899 0 : return A->clone(C);
900 : }
901 : case attr::PragmaClangTextSection: {
902 : const auto *A = cast<PragmaClangTextSectionAttr>(At);
903 0 : return A->clone(C);
904 : }
905 : case attr::PreserveAll: {
906 : const auto *A = cast<PreserveAllAttr>(At);
907 0 : return A->clone(C);
908 : }
909 : case attr::PreserveMost: {
910 : const auto *A = cast<PreserveMostAttr>(At);
911 0 : return A->clone(C);
912 : }
913 : case attr::PtGuardedBy: {
914 : const auto *A = cast<PtGuardedByAttr>(At);
915 : Expr * tempInstArg;
916 : {
917 : EnterExpressionEvaluationContext Unevaluated(S, Sema::ExpressionEvaluationContext::Unevaluated);
918 0 : ExprResult Result = S.SubstExpr(A->getArg(), TemplateArgs);
919 : tempInstArg = Result.getAs<Expr>();
920 : }
921 : return new (C) PtGuardedByAttr(A->getLocation(), C, tempInstArg, A->getSpellingListIndex());
922 : }
923 : case attr::PtGuardedVar: {
924 : const auto *A = cast<PtGuardedVarAttr>(At);
925 0 : return A->clone(C);
926 : }
927 : case attr::Ptr32: {
928 : const auto *A = cast<Ptr32Attr>(At);
929 0 : return A->clone(C);
930 : }
931 : case attr::Ptr64: {
932 : const auto *A = cast<Ptr64Attr>(At);
933 0 : return A->clone(C);
934 : }
935 : case attr::Pure: {
936 : const auto *A = cast<PureAttr>(At);
937 2 : return A->clone(C);
938 : }
939 : case attr::RISCVInterrupt: {
940 : const auto *A = cast<RISCVInterruptAttr>(At);
941 0 : return A->clone(C);
942 : }
943 : case attr::RegCall: {
944 : const auto *A = cast<RegCallAttr>(At);
945 0 : return A->clone(C);
946 : }
947 : case attr::Reinitializes: {
948 : const auto *A = cast<ReinitializesAttr>(At);
949 1 : return A->clone(C);
950 : }
951 : case attr::ReleaseCapability: {
952 : const auto *A = cast<ReleaseCapabilityAttr>(At);
953 14 : auto *tempInstArgs = new (C, 16) Expr *[A->args_size()];
954 : {
955 : EnterExpressionEvaluationContext Unevaluated(S, Sema::ExpressionEvaluationContext::Unevaluated);
956 : Expr * *TI = tempInstArgs;
957 14 : Expr * *I = A->args_begin();
958 14 : Expr * *E = A->args_end();
959 16 : for (; I != E; ++I, ++TI) {
960 2 : ExprResult Result = S.SubstExpr(*I, TemplateArgs);
961 2 : *TI = Result.getAs<Expr>();
962 : }
963 : }
964 14 : return new (C) ReleaseCapabilityAttr(A->getLocation(), C, tempInstArgs, A->args_size(), A->getSpellingListIndex());
965 : }
966 : case attr::RenderScriptKernel: {
967 : const auto *A = cast<RenderScriptKernelAttr>(At);
968 0 : return A->clone(C);
969 : }
970 : case attr::ReqdWorkGroupSize: {
971 : const auto *A = cast<ReqdWorkGroupSizeAttr>(At);
972 0 : return A->clone(C);
973 : }
974 : case attr::RequireConstantInit: {
975 : const auto *A = cast<RequireConstantInitAttr>(At);
976 0 : return A->clone(C);
977 : }
978 : case attr::RequiresCapability: {
979 : const auto *A = cast<RequiresCapabilityAttr>(At);
980 80 : auto *tempInstArgs = new (C, 16) Expr *[A->args_size()];
981 : {
982 : EnterExpressionEvaluationContext Unevaluated(S, Sema::ExpressionEvaluationContext::Unevaluated);
983 : Expr * *TI = tempInstArgs;
984 80 : Expr * *I = A->args_begin();
985 80 : Expr * *E = A->args_end();
986 184 : for (; I != E; ++I, ++TI) {
987 104 : ExprResult Result = S.SubstExpr(*I, TemplateArgs);
988 104 : *TI = Result.getAs<Expr>();
989 : }
990 : }
991 80 : return new (C) RequiresCapabilityAttr(A->getLocation(), C, tempInstArgs, A->args_size(), A->getSpellingListIndex());
992 : }
993 : case attr::Restrict: {
994 : const auto *A = cast<RestrictAttr>(At);
995 0 : return A->clone(C);
996 : }
997 : case attr::ReturnTypestate: {
998 : const auto *A = cast<ReturnTypestateAttr>(At);
999 4 : return A->clone(C);
1000 : }
1001 : case attr::ReturnsNonNull: {
1002 : const auto *A = cast<ReturnsNonNullAttr>(At);
1003 0 : return A->clone(C);
1004 : }
1005 : case attr::ReturnsTwice: {
1006 : const auto *A = cast<ReturnsTwiceAttr>(At);
1007 0 : return A->clone(C);
1008 : }
1009 : case attr::SPtr: {
1010 : const auto *A = cast<SPtrAttr>(At);
1011 0 : return A->clone(C);
1012 : }
1013 : case attr::ScopedLockable: {
1014 : const auto *A = cast<ScopedLockableAttr>(At);
1015 9 : return A->clone(C);
1016 : }
1017 : case attr::Section: {
1018 : const auto *A = cast<SectionAttr>(At);
1019 9 : return A->clone(C);
1020 : }
1021 : case attr::SelectAny: {
1022 : const auto *A = cast<SelectAnyAttr>(At);
1023 0 : return A->clone(C);
1024 : }
1025 : case attr::Sentinel: {
1026 : const auto *A = cast<SentinelAttr>(At);
1027 0 : return A->clone(C);
1028 : }
1029 : case attr::SetTypestate: {
1030 : const auto *A = cast<SetTypestateAttr>(At);
1031 8 : return A->clone(C);
1032 : }
1033 : case attr::SharedTrylockFunction: {
1034 : const auto *A = cast<SharedTrylockFunctionAttr>(At);
1035 : Expr * tempInstSuccessValue;
1036 : {
1037 : EnterExpressionEvaluationContext Unevaluated(S, Sema::ExpressionEvaluationContext::Unevaluated);
1038 0 : ExprResult Result = S.SubstExpr(A->getSuccessValue(), TemplateArgs);
1039 : tempInstSuccessValue = Result.getAs<Expr>();
1040 : }
1041 0 : auto *tempInstArgs = new (C, 16) Expr *[A->args_size()];
1042 : {
1043 : EnterExpressionEvaluationContext Unevaluated(S, Sema::ExpressionEvaluationContext::Unevaluated);
1044 : Expr * *TI = tempInstArgs;
1045 0 : Expr * *I = A->args_begin();
1046 0 : Expr * *E = A->args_end();
1047 0 : for (; I != E; ++I, ++TI) {
1048 0 : ExprResult Result = S.SubstExpr(*I, TemplateArgs);
1049 0 : *TI = Result.getAs<Expr>();
1050 : }
1051 : }
1052 0 : return new (C) SharedTrylockFunctionAttr(A->getLocation(), C, tempInstSuccessValue, tempInstArgs, A->args_size(), A->getSpellingListIndex());
1053 : }
1054 : case attr::StdCall: {
1055 : const auto *A = cast<StdCallAttr>(At);
1056 0 : return A->clone(C);
1057 : }
1058 : case attr::Suppress: {
1059 : const auto *A = cast<SuppressAttr>(At);
1060 0 : return A->clone(C);
1061 : }
1062 : case attr::SwiftCall: {
1063 : const auto *A = cast<SwiftCallAttr>(At);
1064 0 : return A->clone(C);
1065 : }
1066 : case attr::SwiftContext: {
1067 : const auto *A = cast<SwiftContextAttr>(At);
1068 0 : return A->clone(C);
1069 : }
1070 : case attr::SwiftErrorResult: {
1071 : const auto *A = cast<SwiftErrorResultAttr>(At);
1072 0 : return A->clone(C);
1073 : }
1074 : case attr::SwiftIndirectResult: {
1075 : const auto *A = cast<SwiftIndirectResultAttr>(At);
1076 0 : return A->clone(C);
1077 : }
1078 : case attr::SysVABI: {
1079 : const auto *A = cast<SysVABIAttr>(At);
1080 0 : return A->clone(C);
1081 : }
1082 : case attr::TLSModel: {
1083 : const auto *A = cast<TLSModelAttr>(At);
1084 0 : return A->clone(C);
1085 : }
1086 : case attr::Target: {
1087 : const auto *A = cast<TargetAttr>(At);
1088 12 : return A->clone(C);
1089 : }
1090 : case attr::TestTypestate: {
1091 : const auto *A = cast<TestTypestateAttr>(At);
1092 8 : return A->clone(C);
1093 : }
1094 : case attr::ThisCall: {
1095 : const auto *A = cast<ThisCallAttr>(At);
1096 0 : return A->clone(C);
1097 : }
1098 : case attr::Thread: {
1099 : const auto *A = cast<ThreadAttr>(At);
1100 0 : return A->clone(C);
1101 : }
1102 : case attr::TransparentUnion: {
1103 : const auto *A = cast<TransparentUnionAttr>(At);
1104 0 : return A->clone(C);
1105 : }
1106 : case attr::TrivialABI: {
1107 : const auto *A = cast<TrivialABIAttr>(At);
1108 6 : return A->clone(C);
1109 : }
1110 : case attr::TryAcquireCapability: {
1111 : const auto *A = cast<TryAcquireCapabilityAttr>(At);
1112 : Expr * tempInstSuccessValue;
1113 : {
1114 : EnterExpressionEvaluationContext Unevaluated(S, Sema::ExpressionEvaluationContext::Unevaluated);
1115 0 : ExprResult Result = S.SubstExpr(A->getSuccessValue(), TemplateArgs);
1116 : tempInstSuccessValue = Result.getAs<Expr>();
1117 : }
1118 0 : auto *tempInstArgs = new (C, 16) Expr *[A->args_size()];
1119 : {
1120 : EnterExpressionEvaluationContext Unevaluated(S, Sema::ExpressionEvaluationContext::Unevaluated);
1121 : Expr * *TI = tempInstArgs;
1122 0 : Expr * *I = A->args_begin();
1123 0 : Expr * *E = A->args_end();
1124 0 : for (; I != E; ++I, ++TI) {
1125 0 : ExprResult Result = S.SubstExpr(*I, TemplateArgs);
1126 0 : *TI = Result.getAs<Expr>();
1127 : }
1128 : }
1129 0 : return new (C) TryAcquireCapabilityAttr(A->getLocation(), C, tempInstSuccessValue, tempInstArgs, A->args_size(), A->getSpellingListIndex());
1130 : }
1131 : case attr::TypeNonNull: {
1132 : const auto *A = cast<TypeNonNullAttr>(At);
1133 0 : return A->clone(C);
1134 : }
1135 : case attr::TypeNullUnspecified: {
1136 : const auto *A = cast<TypeNullUnspecifiedAttr>(At);
1137 0 : return A->clone(C);
1138 : }
1139 : case attr::TypeNullable: {
1140 : const auto *A = cast<TypeNullableAttr>(At);
1141 0 : return A->clone(C);
1142 : }
1143 : case attr::TypeTagForDatatype: {
1144 : const auto *A = cast<TypeTagForDatatypeAttr>(At);
1145 0 : return A->clone(C);
1146 : }
1147 : case attr::TypeVisibility: {
1148 : return nullptr;
1149 : }
1150 : case attr::UPtr: {
1151 : const auto *A = cast<UPtrAttr>(At);
1152 0 : return A->clone(C);
1153 : }
1154 : case attr::Unavailable: {
1155 : const auto *A = cast<UnavailableAttr>(At);
1156 3 : return A->clone(C);
1157 : }
1158 : case attr::Unused: {
1159 : const auto *A = cast<UnusedAttr>(At);
1160 428 : return A->clone(C);
1161 : }
1162 : case attr::Used: {
1163 : const auto *A = cast<UsedAttr>(At);
1164 11 : return A->clone(C);
1165 : }
1166 : case attr::Uuid: {
1167 : const auto *A = cast<UuidAttr>(At);
1168 0 : return A->clone(C);
1169 : }
1170 : case attr::VecReturn: {
1171 : const auto *A = cast<VecReturnAttr>(At);
1172 0 : return A->clone(C);
1173 : }
1174 : case attr::VecTypeHint: {
1175 : const auto *A = cast<VecTypeHintAttr>(At);
1176 0 : return A->clone(C);
1177 : }
1178 : case attr::VectorCall: {
1179 : const auto *A = cast<VectorCallAttr>(At);
1180 0 : return A->clone(C);
1181 : }
1182 : case attr::Visibility: {
1183 : return nullptr;
1184 : }
1185 : case attr::WarnUnused: {
1186 : const auto *A = cast<WarnUnusedAttr>(At);
1187 0 : return A->clone(C);
1188 : }
1189 : case attr::WarnUnusedResult: {
1190 : const auto *A = cast<WarnUnusedResultAttr>(At);
1191 91420 : return A->clone(C);
1192 : }
1193 : case attr::Weak: {
1194 : const auto *A = cast<WeakAttr>(At);
1195 6 : return A->clone(C);
1196 : }
1197 : case attr::WeakImport: {
1198 : const auto *A = cast<WeakImportAttr>(At);
1199 0 : return A->clone(C);
1200 : }
1201 : case attr::WeakRef: {
1202 : const auto *A = cast<WeakRefAttr>(At);
1203 0 : return A->clone(C);
1204 : }
1205 : case attr::WorkGroupSizeHint: {
1206 : const auto *A = cast<WorkGroupSizeHintAttr>(At);
1207 0 : return A->clone(C);
1208 : }
1209 : case attr::X86ForceAlignArgPointer: {
1210 : const auto *A = cast<X86ForceAlignArgPointerAttr>(At);
1211 0 : return A->clone(C);
1212 : }
1213 : case attr::XRayInstrument: {
1214 : const auto *A = cast<XRayInstrumentAttr>(At);
1215 0 : return A->clone(C);
1216 : }
1217 : case attr::XRayLogArgs: {
1218 : const auto *A = cast<XRayLogArgsAttr>(At);
1219 0 : return A->clone(C);
1220 : }
1221 : } // end switch
1222 0 : llvm_unreachable("Unknown attribute!");
1223 : return nullptr;
1224 : }
1225 :
1226 5638375 : Attr *instantiateTemplateAttributeForDecl(const Attr *At,
1227 : ASTContext &C, Sema &S,
1228 : const MultiLevelTemplateArgumentList &TemplateArgs) {
1229 5638375 : switch (At->getKind()) {
1230 : case attr::AMDGPUFlatWorkGroupSize: {
1231 : return nullptr;
1232 : }
1233 : case attr::AMDGPUNumSGPR: {
1234 : return nullptr;
1235 : }
1236 : case attr::AMDGPUNumVGPR: {
1237 : return nullptr;
1238 : }
1239 : case attr::AMDGPUWavesPerEU: {
1240 : return nullptr;
1241 : }
1242 : case attr::ARMInterrupt: {
1243 : return nullptr;
1244 : }
1245 : case attr::AVRInterrupt: {
1246 : return nullptr;
1247 : }
1248 : case attr::AVRSignal: {
1249 : return nullptr;
1250 : }
1251 : case attr::AbiTag: {
1252 : const auto *A = cast<AbiTagAttr>(At);
1253 19 : return A->clone(C);
1254 : }
1255 : case attr::AcquireCapability: {
1256 : return nullptr;
1257 : }
1258 : case attr::AcquiredAfter: {
1259 : return nullptr;
1260 : }
1261 : case attr::AcquiredBefore: {
1262 : return nullptr;
1263 : }
1264 : case attr::AddressSpace: {
1265 : return nullptr;
1266 : }
1267 : case attr::Alias: {
1268 : return nullptr;
1269 : }
1270 : case attr::AlignMac68k: {
1271 : return nullptr;
1272 : }
1273 : case attr::AlignValue: {
1274 : return nullptr;
1275 : }
1276 : case attr::Aligned: {
1277 : return nullptr;
1278 : }
1279 : case attr::AllocAlign: {
1280 : return nullptr;
1281 : }
1282 : case attr::AllocSize: {
1283 : return nullptr;
1284 : }
1285 : case attr::AlwaysDestroy: {
1286 : return nullptr;
1287 : }
1288 : case attr::AlwaysInline: {
1289 : return nullptr;
1290 : }
1291 : case attr::AnalyzerNoReturn: {
1292 : return nullptr;
1293 : }
1294 : case attr::Annotate: {
1295 : return nullptr;
1296 : }
1297 : case attr::AnyX86Interrupt: {
1298 : return nullptr;
1299 : }
1300 : case attr::AnyX86NoCallerSavedRegisters: {
1301 : return nullptr;
1302 : }
1303 : case attr::AnyX86NoCfCheck: {
1304 : return nullptr;
1305 : }
1306 : case attr::ArcWeakrefUnavailable: {
1307 : return nullptr;
1308 : }
1309 : case attr::ArgumentWithTypeTag: {
1310 : return nullptr;
1311 : }
1312 : case attr::Artificial: {
1313 : return nullptr;
1314 : }
1315 : case attr::AsmLabel: {
1316 : return nullptr;
1317 : }
1318 : case attr::AssertCapability: {
1319 : return nullptr;
1320 : }
1321 : case attr::AssertExclusiveLock: {
1322 : return nullptr;
1323 : }
1324 : case attr::AssertSharedLock: {
1325 : return nullptr;
1326 : }
1327 : case attr::AssumeAligned: {
1328 : return nullptr;
1329 : }
1330 : case attr::Availability: {
1331 : return nullptr;
1332 : }
1333 : case attr::Blocks: {
1334 : return nullptr;
1335 : }
1336 : case attr::C11NoReturn: {
1337 : return nullptr;
1338 : }
1339 : case attr::CDecl: {
1340 : return nullptr;
1341 : }
1342 : case attr::CFAuditedTransfer: {
1343 : return nullptr;
1344 : }
1345 : case attr::CFConsumed: {
1346 : return nullptr;
1347 : }
1348 : case attr::CFReturnsNotRetained: {
1349 : return nullptr;
1350 : }
1351 : case attr::CFReturnsRetained: {
1352 : return nullptr;
1353 : }
1354 : case attr::CFUnknownTransfer: {
1355 : return nullptr;
1356 : }
1357 : case attr::CPUDispatch: {
1358 : return nullptr;
1359 : }
1360 : case attr::CPUSpecific: {
1361 : return nullptr;
1362 : }
1363 : case attr::CUDAConstant: {
1364 : return nullptr;
1365 : }
1366 : case attr::CUDADevice: {
1367 : return nullptr;
1368 : }
1369 : case attr::CUDAGlobal: {
1370 : return nullptr;
1371 : }
1372 : case attr::CUDAHost: {
1373 : return nullptr;
1374 : }
1375 : case attr::CUDAInvalidTarget: {
1376 : return nullptr;
1377 : }
1378 : case attr::CUDALaunchBounds: {
1379 : return nullptr;
1380 : }
1381 : case attr::CUDAShared: {
1382 : return nullptr;
1383 : }
1384 : case attr::CXX11NoReturn: {
1385 : return nullptr;
1386 : }
1387 : case attr::CallableWhen: {
1388 : return nullptr;
1389 : }
1390 : case attr::Capability: {
1391 : return nullptr;
1392 : }
1393 : case attr::CapturedRecord: {
1394 : return nullptr;
1395 : }
1396 : case attr::CarriesDependency: {
1397 : return nullptr;
1398 : }
1399 : case attr::Cleanup: {
1400 : return nullptr;
1401 : }
1402 : case attr::CodeSeg: {
1403 : return nullptr;
1404 : }
1405 : case attr::Cold: {
1406 : return nullptr;
1407 : }
1408 : case attr::Common: {
1409 : return nullptr;
1410 : }
1411 : case attr::Const: {
1412 : return nullptr;
1413 : }
1414 : case attr::Constructor: {
1415 : return nullptr;
1416 : }
1417 : case attr::Consumable: {
1418 : return nullptr;
1419 : }
1420 : case attr::ConsumableAutoCast: {
1421 : return nullptr;
1422 : }
1423 : case attr::ConsumableSetOnRead: {
1424 : return nullptr;
1425 : }
1426 : case attr::Convergent: {
1427 : return nullptr;
1428 : }
1429 : case attr::DLLExport: {
1430 : return nullptr;
1431 : }
1432 : case attr::DLLImport: {
1433 : return nullptr;
1434 : }
1435 : case attr::Deprecated: {
1436 : const auto *A = cast<DeprecatedAttr>(At);
1437 50 : return A->clone(C);
1438 : }
1439 : case attr::Destructor: {
1440 : return nullptr;
1441 : }
1442 : case attr::DiagnoseIf: {
1443 : return nullptr;
1444 : }
1445 : case attr::DisableTailCalls: {
1446 : return nullptr;
1447 : }
1448 : case attr::EmptyBases: {
1449 : return nullptr;
1450 : }
1451 : case attr::EnableIf: {
1452 : return nullptr;
1453 : }
1454 : case attr::EnumExtensibility: {
1455 : return nullptr;
1456 : }
1457 : case attr::ExcludeFromExplicitInstantiation: {
1458 : const auto *A = cast<ExcludeFromExplicitInstantiationAttr>(At);
1459 4 : return A->clone(C);
1460 : }
1461 : case attr::ExclusiveTrylockFunction: {
1462 : return nullptr;
1463 : }
1464 : case attr::ExternalSourceSymbol: {
1465 : return nullptr;
1466 : }
1467 : case attr::FallThrough: {
1468 : return nullptr;
1469 : }
1470 : case attr::FastCall: {
1471 : return nullptr;
1472 : }
1473 : case attr::Final: {
1474 : return nullptr;
1475 : }
1476 : case attr::FlagEnum: {
1477 : return nullptr;
1478 : }
1479 : case attr::Flatten: {
1480 : return nullptr;
1481 : }
1482 : case attr::Format: {
1483 : return nullptr;
1484 : }
1485 : case attr::FormatArg: {
1486 : return nullptr;
1487 : }
1488 : case attr::GNUInline: {
1489 : return nullptr;
1490 : }
1491 : case attr::GuardedBy: {
1492 : return nullptr;
1493 : }
1494 : case attr::GuardedVar: {
1495 : return nullptr;
1496 : }
1497 : case attr::Hot: {
1498 : return nullptr;
1499 : }
1500 : case attr::IBAction: {
1501 : return nullptr;
1502 : }
1503 : case attr::IBOutlet: {
1504 : return nullptr;
1505 : }
1506 : case attr::IBOutletCollection: {
1507 : return nullptr;
1508 : }
1509 : case attr::IFunc: {
1510 : return nullptr;
1511 : }
1512 : case attr::InitPriority: {
1513 : return nullptr;
1514 : }
1515 : case attr::InitSeg: {
1516 : return nullptr;
1517 : }
1518 : case attr::IntelOclBicc: {
1519 : return nullptr;
1520 : }
1521 : case attr::InternalLinkage: {
1522 : return nullptr;
1523 : }
1524 : case attr::LTOVisibilityPublic: {
1525 : return nullptr;
1526 : }
1527 : case attr::LayoutVersion: {
1528 : return nullptr;
1529 : }
1530 : case attr::LifetimeBound: {
1531 : return nullptr;
1532 : }
1533 : case attr::LockReturned: {
1534 : return nullptr;
1535 : }
1536 : case attr::LocksExcluded: {
1537 : return nullptr;
1538 : }
1539 : case attr::LoopHint: {
1540 : return nullptr;
1541 : }
1542 : case attr::MSABI: {
1543 : return nullptr;
1544 : }
1545 : case attr::MSInheritance: {
1546 : return nullptr;
1547 : }
1548 : case attr::MSNoVTable: {
1549 : return nullptr;
1550 : }
1551 : case attr::MSP430Interrupt: {
1552 : return nullptr;
1553 : }
1554 : case attr::MSStruct: {
1555 : return nullptr;
1556 : }
1557 : case attr::MSVtorDisp: {
1558 : return nullptr;
1559 : }
1560 : case attr::MaxFieldAlignment: {
1561 : return nullptr;
1562 : }
1563 : case attr::MayAlias: {
1564 : return nullptr;
1565 : }
1566 : case attr::MicroMips: {
1567 : return nullptr;
1568 : }
1569 : case attr::MinSize: {
1570 : return nullptr;
1571 : }
1572 : case attr::MinVectorWidth: {
1573 : return nullptr;
1574 : }
1575 : case attr::Mips16: {
1576 : return nullptr;
1577 : }
1578 : case attr::MipsInterrupt: {
1579 : return nullptr;
1580 : }
1581 : case attr::MipsLongCall: {
1582 : return nullptr;
1583 : }
1584 : case attr::MipsShortCall: {
1585 : return nullptr;
1586 : }
1587 : case attr::Mode: {
1588 : return nullptr;
1589 : }
1590 : case attr::NSConsumed: {
1591 : return nullptr;
1592 : }
1593 : case attr::NSConsumesSelf: {
1594 : return nullptr;
1595 : }
1596 : case attr::NSReturnsAutoreleased: {
1597 : return nullptr;
1598 : }
1599 : case attr::NSReturnsNotRetained: {
1600 : return nullptr;
1601 : }
1602 : case attr::NSReturnsRetained: {
1603 : return nullptr;
1604 : }
1605 : case attr::Naked: {
1606 : return nullptr;
1607 : }
1608 : case attr::NoAlias: {
1609 : return nullptr;
1610 : }
1611 : case attr::NoCommon: {
1612 : return nullptr;
1613 : }
1614 : case attr::NoDebug: {
1615 : return nullptr;
1616 : }
1617 : case attr::NoDestroy: {
1618 : return nullptr;
1619 : }
1620 : case attr::NoDuplicate: {
1621 : return nullptr;
1622 : }
1623 : case attr::NoEscape: {
1624 : return nullptr;
1625 : }
1626 : case attr::NoInline: {
1627 : return nullptr;
1628 : }
1629 : case attr::NoInstrumentFunction: {
1630 : return nullptr;
1631 : }
1632 : case attr::NoMicroMips: {
1633 : return nullptr;
1634 : }
1635 : case attr::NoMips16: {
1636 : return nullptr;
1637 : }
1638 : case attr::NoReturn: {
1639 : return nullptr;
1640 : }
1641 : case attr::NoSanitize: {
1642 : return nullptr;
1643 : }
1644 : case attr::NoSplitStack: {
1645 : return nullptr;
1646 : }
1647 : case attr::NoStackProtector: {
1648 : return nullptr;
1649 : }
1650 : case attr::NoThreadSafetyAnalysis: {
1651 : return nullptr;
1652 : }
1653 : case attr::NoThrow: {
1654 : return nullptr;
1655 : }
1656 : case attr::NonNull: {
1657 : return nullptr;
1658 : }
1659 : case attr::NotTailCalled: {
1660 : return nullptr;
1661 : }
1662 : case attr::OMPCaptureKind: {
1663 : return nullptr;
1664 : }
1665 : case attr::OMPCaptureNoInit: {
1666 : return nullptr;
1667 : }
1668 : case attr::OMPDeclareSimdDecl: {
1669 : return nullptr;
1670 : }
1671 : case attr::OMPDeclareTargetDecl: {
1672 : return nullptr;
1673 : }
1674 : case attr::OMPReferencedVar: {
1675 : return nullptr;
1676 : }
1677 : case attr::OMPThreadPrivateDecl: {
1678 : return nullptr;
1679 : }
1680 : case attr::ObjCBoxable: {
1681 : return nullptr;
1682 : }
1683 : case attr::ObjCBridge: {
1684 : return nullptr;
1685 : }
1686 : case attr::ObjCBridgeMutable: {
1687 : return nullptr;
1688 : }
1689 : case attr::ObjCBridgeRelated: {
1690 : return nullptr;
1691 : }
1692 : case attr::ObjCDesignatedInitializer: {
1693 : return nullptr;
1694 : }
1695 : case attr::ObjCException: {
1696 : return nullptr;
1697 : }
1698 : case attr::ObjCExplicitProtocolImpl: {
1699 : return nullptr;
1700 : }
1701 : case attr::ObjCGC: {
1702 : return nullptr;
1703 : }
1704 : case attr::ObjCIndependentClass: {
1705 : return nullptr;
1706 : }
1707 : case attr::ObjCInertUnsafeUnretained: {
1708 : return nullptr;
1709 : }
1710 : case attr::ObjCKindOf: {
1711 : return nullptr;
1712 : }
1713 : case attr::ObjCMethodFamily: {
1714 : return nullptr;
1715 : }
1716 : case attr::ObjCNSObject: {
1717 : return nullptr;
1718 : }
1719 : case attr::ObjCOwnership: {
1720 : return nullptr;
1721 : }
1722 : case attr::ObjCPreciseLifetime: {
1723 : return nullptr;
1724 : }
1725 : case attr::ObjCRequiresPropertyDefs: {
1726 : return nullptr;
1727 : }
1728 : case attr::ObjCRequiresSuper: {
1729 : return nullptr;
1730 : }
1731 : case attr::ObjCReturnsInnerPointer: {
1732 : return nullptr;
1733 : }
1734 : case attr::ObjCRootClass: {
1735 : return nullptr;
1736 : }
1737 : case attr::ObjCRuntimeName: {
1738 : return nullptr;
1739 : }
1740 : case attr::ObjCRuntimeVisible: {
1741 : return nullptr;
1742 : }
1743 : case attr::ObjCSubclassingRestricted: {
1744 : return nullptr;
1745 : }
1746 : case attr::OpenCLAccess: {
1747 : return nullptr;
1748 : }
1749 : case attr::OpenCLConstantAddressSpace: {
1750 : return nullptr;
1751 : }
1752 : case attr::OpenCLGenericAddressSpace: {
1753 : return nullptr;
1754 : }
1755 : case attr::OpenCLGlobalAddressSpace: {
1756 : return nullptr;
1757 : }
1758 : case attr::OpenCLIntelReqdSubGroupSize: {
1759 : return nullptr;
1760 : }
1761 : case attr::OpenCLKernel: {
1762 : return nullptr;
1763 : }
1764 : case attr::OpenCLLocalAddressSpace: {
1765 : return nullptr;
1766 : }
1767 : case attr::OpenCLPrivateAddressSpace: {
1768 : return nullptr;
1769 : }
1770 : case attr::OpenCLUnrollHint: {
1771 : return nullptr;
1772 : }
1773 : case attr::OptimizeNone: {
1774 : return nullptr;
1775 : }
1776 : case attr::Overloadable: {
1777 : return nullptr;
1778 : }
1779 : case attr::Override: {
1780 : return nullptr;
1781 : }
1782 : case attr::Ownership: {
1783 : return nullptr;
1784 : }
1785 : case attr::Packed: {
1786 : return nullptr;
1787 : }
1788 : case attr::ParamTypestate: {
1789 : return nullptr;
1790 : }
1791 : case attr::Pascal: {
1792 : return nullptr;
1793 : }
1794 : case attr::PassObjectSize: {
1795 : return nullptr;
1796 : }
1797 : case attr::Pcs: {
1798 : return nullptr;
1799 : }
1800 : case attr::PragmaClangBSSSection: {
1801 : return nullptr;
1802 : }
1803 : case attr::PragmaClangDataSection: {
1804 : return nullptr;
1805 : }
1806 : case attr::PragmaClangRodataSection: {
1807 : return nullptr;
1808 : }
1809 : case attr::PragmaClangTextSection: {
1810 : return nullptr;
1811 : }
1812 : case attr::PreserveAll: {
1813 : return nullptr;
1814 : }
1815 : case attr::PreserveMost: {
1816 : return nullptr;
1817 : }
1818 : case attr::PtGuardedBy: {
1819 : return nullptr;
1820 : }
1821 : case attr::PtGuardedVar: {
1822 : return nullptr;
1823 : }
1824 : case attr::Ptr32: {
1825 : return nullptr;
1826 : }
1827 : case attr::Ptr64: {
1828 : return nullptr;
1829 : }
1830 : case attr::Pure: {
1831 : return nullptr;
1832 : }
1833 : case attr::RISCVInterrupt: {
1834 : return nullptr;
1835 : }
1836 : case attr::RegCall: {
1837 : return nullptr;
1838 : }
1839 : case attr::Reinitializes: {
1840 : return nullptr;
1841 : }
1842 : case attr::ReleaseCapability: {
1843 : return nullptr;
1844 : }
1845 : case attr::RenderScriptKernel: {
1846 : return nullptr;
1847 : }
1848 : case attr::ReqdWorkGroupSize: {
1849 : return nullptr;
1850 : }
1851 : case attr::RequireConstantInit: {
1852 : return nullptr;
1853 : }
1854 : case attr::RequiresCapability: {
1855 : return nullptr;
1856 : }
1857 : case attr::Restrict: {
1858 : return nullptr;
1859 : }
1860 : case attr::ReturnTypestate: {
1861 : return nullptr;
1862 : }
1863 : case attr::ReturnsNonNull: {
1864 : return nullptr;
1865 : }
1866 : case attr::ReturnsTwice: {
1867 : return nullptr;
1868 : }
1869 : case attr::SPtr: {
1870 : return nullptr;
1871 : }
1872 : case attr::ScopedLockable: {
1873 : return nullptr;
1874 : }
1875 : case attr::Section: {
1876 : return nullptr;
1877 : }
1878 : case attr::SelectAny: {
1879 : return nullptr;
1880 : }
1881 : case attr::Sentinel: {
1882 : return nullptr;
1883 : }
1884 : case attr::SetTypestate: {
1885 : return nullptr;
1886 : }
1887 : case attr::SharedTrylockFunction: {
1888 : return nullptr;
1889 : }
1890 : case attr::StdCall: {
1891 : return nullptr;
1892 : }
1893 : case attr::Suppress: {
1894 : return nullptr;
1895 : }
1896 : case attr::SwiftCall: {
1897 : return nullptr;
1898 : }
1899 : case attr::SwiftContext: {
1900 : return nullptr;
1901 : }
1902 : case attr::SwiftErrorResult: {
1903 : return nullptr;
1904 : }
1905 : case attr::SwiftIndirectResult: {
1906 : return nullptr;
1907 : }
1908 : case attr::SysVABI: {
1909 : return nullptr;
1910 : }
1911 : case attr::TLSModel: {
1912 : return nullptr;
1913 : }
1914 : case attr::Target: {
1915 : return nullptr;
1916 : }
1917 : case attr::TestTypestate: {
1918 : return nullptr;
1919 : }
1920 : case attr::ThisCall: {
1921 : return nullptr;
1922 : }
1923 : case attr::Thread: {
1924 : return nullptr;
1925 : }
1926 : case attr::TransparentUnion: {
1927 : return nullptr;
1928 : }
1929 : case attr::TrivialABI: {
1930 : return nullptr;
1931 : }
1932 : case attr::TryAcquireCapability: {
1933 : return nullptr;
1934 : }
1935 : case attr::TypeNonNull: {
1936 : return nullptr;
1937 : }
1938 : case attr::TypeNullUnspecified: {
1939 : return nullptr;
1940 : }
1941 : case attr::TypeNullable: {
1942 : return nullptr;
1943 : }
1944 : case attr::TypeTagForDatatype: {
1945 : return nullptr;
1946 : }
1947 : case attr::TypeVisibility: {
1948 : return nullptr;
1949 : }
1950 : case attr::UPtr: {
1951 : return nullptr;
1952 : }
1953 : case attr::Unavailable: {
1954 : return nullptr;
1955 : }
1956 : case attr::Unused: {
1957 : return nullptr;
1958 : }
1959 : case attr::Used: {
1960 : return nullptr;
1961 : }
1962 : case attr::Uuid: {
1963 : return nullptr;
1964 : }
1965 : case attr::VecReturn: {
1966 : return nullptr;
1967 : }
1968 : case attr::VecTypeHint: {
1969 : return nullptr;
1970 : }
1971 : case attr::VectorCall: {
1972 : return nullptr;
1973 : }
1974 : case attr::Visibility: {
1975 : return nullptr;
1976 : }
1977 : case attr::WarnUnused: {
1978 : return nullptr;
1979 : }
1980 : case attr::WarnUnusedResult: {
1981 : return nullptr;
1982 : }
1983 : case attr::Weak: {
1984 : return nullptr;
1985 : }
1986 : case attr::WeakImport: {
1987 : return nullptr;
1988 : }
1989 : case attr::WeakRef: {
1990 : return nullptr;
1991 : }
1992 : case attr::WorkGroupSizeHint: {
1993 : return nullptr;
1994 : }
1995 : case attr::X86ForceAlignArgPointer: {
1996 : return nullptr;
1997 : }
1998 : case attr::XRayInstrument: {
1999 : return nullptr;
2000 : }
2001 : case attr::XRayLogArgs: {
2002 : return nullptr;
2003 : }
2004 : } // end switch
2005 0 : llvm_unreachable("Unknown attribute!");
2006 : return nullptr;
2007 : }
2008 :
2009 : } // end namespace sema
2010 : } // end namespace clang
|