Coverage Report

Created: 2018-07-12 09:57

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