Coverage Report

Created: 2017-10-03 07:32

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