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