Coverage Report

Created: 2018-12-14 11:24

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