Coverage Report

Created: 2018-09-25 17:16

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