Coverage Report

Created: 2019-03-24 22:13

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