WebSVN – QNX 8.QNX8 LLVM/Clang compiler suite – Blame – /llvm-build/x86_64/include/clang/Serialization/AttrPCHWrite.inc

Rev	Author	Line No.	Line
14	pmbaty	1	/===- TableGen'erated file -------------------------------------- C++ --===\
		2	\|* *\|
		3	\|* Attribute serialization code *\|
		4	\|* *\|
		5	\|* Automatically generated file, do not edit! *\|
		6	\|* *\|
		7	\===----------------------------------------------------------------------===/
		8
		9	switch (A->getKind()) {
		10	case attr::AArch64SVEPcs: {
		11	const auto *SA = cast<AArch64SVEPcsAttr>(A);
		12	Record.push_back(SA->isInherited());
		13	Record.push_back(A->isImplicit());
		14	Record.push_back(A->isPackExpansion());
		15	break;
		16	}
		17	case attr::AArch64VectorPcs: {
		18	const auto *SA = cast<AArch64VectorPcsAttr>(A);
		19	Record.push_back(SA->isInherited());
		20	Record.push_back(A->isImplicit());
		21	Record.push_back(A->isPackExpansion());
		22	break;
		23	}
		24	case attr::AMDGPUFlatWorkGroupSize: {
		25	const auto *SA = cast<AMDGPUFlatWorkGroupSizeAttr>(A);
		26	Record.push_back(SA->isInherited());
		27	Record.push_back(A->isImplicit());
		28	Record.push_back(A->isPackExpansion());
		29	Record.AddStmt(SA->getMin());
		30	Record.AddStmt(SA->getMax());
		31	break;
		32	}
		33	case attr::AMDGPUKernelCall: {
		34	const auto *SA = cast<AMDGPUKernelCallAttr>(A);
		35	Record.push_back(SA->isInherited());
		36	Record.push_back(A->isImplicit());
		37	Record.push_back(A->isPackExpansion());
		38	break;
		39	}
		40	case attr::AMDGPUNumSGPR: {
		41	const auto *SA = cast<AMDGPUNumSGPRAttr>(A);
		42	Record.push_back(SA->isInherited());
		43	Record.push_back(A->isImplicit());
		44	Record.push_back(A->isPackExpansion());
		45	Record.push_back(SA->getNumSGPR());
		46	break;
		47	}
		48	case attr::AMDGPUNumVGPR: {
		49	const auto *SA = cast<AMDGPUNumVGPRAttr>(A);
		50	Record.push_back(SA->isInherited());
		51	Record.push_back(A->isImplicit());
		52	Record.push_back(A->isPackExpansion());
		53	Record.push_back(SA->getNumVGPR());
		54	break;
		55	}
		56	case attr::AMDGPUWavesPerEU: {
		57	const auto *SA = cast<AMDGPUWavesPerEUAttr>(A);
		58	Record.push_back(SA->isInherited());
		59	Record.push_back(A->isImplicit());
		60	Record.push_back(A->isPackExpansion());
		61	Record.AddStmt(SA->getMin());
		62	Record.AddStmt(SA->getMax());
		63	break;
		64	}
		65	case attr::ARMInterrupt: {
		66	const auto *SA = cast<ARMInterruptAttr>(A);
		67	Record.push_back(SA->isInherited());
		68	Record.push_back(A->isImplicit());
		69	Record.push_back(A->isPackExpansion());
		70	Record.push_back(SA->getInterrupt());
		71	break;
		72	}
		73	case attr::AVRInterrupt: {
		74	const auto *SA = cast<AVRInterruptAttr>(A);
		75	Record.push_back(SA->isInherited());
		76	Record.push_back(A->isImplicit());
		77	Record.push_back(A->isPackExpansion());
		78	break;
		79	}
		80	case attr::AVRSignal: {
		81	const auto *SA = cast<AVRSignalAttr>(A);
		82	Record.push_back(SA->isInherited());
		83	Record.push_back(A->isImplicit());
		84	Record.push_back(A->isPackExpansion());
		85	break;
		86	}
		87	case attr::AbiTag: {
		88	const auto *SA = cast<AbiTagAttr>(A);
		89	Record.push_back(A->isImplicit());
		90	Record.push_back(A->isPackExpansion());
		91	Record.push_back(SA->tags_size());
		92	for (auto &Val : SA->tags())
		93	Record.AddString(Val);
		94	break;
		95	}
		96	case attr::AcquireCapability: {
		97	const auto *SA = cast<AcquireCapabilityAttr>(A);
		98	Record.push_back(SA->isInherited());
		99	Record.push_back(A->isImplicit());
		100	Record.push_back(A->isPackExpansion());
		101	Record.push_back(SA->args_size());
		102	for (auto &Val : SA->args())
		103	Record.AddStmt(Val);
		104	break;
		105	}
		106	case attr::AcquireHandle: {
		107	const auto *SA = cast<AcquireHandleAttr>(A);
		108	Record.push_back(SA->isInherited());
		109	Record.push_back(A->isImplicit());
		110	Record.push_back(A->isPackExpansion());
		111	Record.AddString(SA->getHandleType());
		112	break;
		113	}
		114	case attr::AcquiredAfter: {
		115	const auto *SA = cast<AcquiredAfterAttr>(A);
		116	Record.push_back(SA->isInherited());
		117	Record.push_back(A->isImplicit());
		118	Record.push_back(A->isPackExpansion());
		119	Record.push_back(SA->args_size());
		120	for (auto &Val : SA->args())
		121	Record.AddStmt(Val);
		122	break;
		123	}
		124	case attr::AcquiredBefore: {
		125	const auto *SA = cast<AcquiredBeforeAttr>(A);
		126	Record.push_back(SA->isInherited());
		127	Record.push_back(A->isImplicit());
		128	Record.push_back(A->isPackExpansion());
		129	Record.push_back(SA->args_size());
		130	for (auto &Val : SA->args())
		131	Record.AddStmt(Val);
		132	break;
		133	}
		134	case attr::AddressSpace: {
		135	const auto *SA = cast<AddressSpaceAttr>(A);
		136	Record.push_back(A->isImplicit());
		137	Record.push_back(A->isPackExpansion());
		138	Record.push_back(SA->getAddressSpace());
		139	break;
		140	}
		141	case attr::Alias: {
		142	const auto *SA = cast<AliasAttr>(A);
		143	Record.push_back(A->isImplicit());
		144	Record.push_back(A->isPackExpansion());
		145	Record.AddString(SA->getAliasee());
		146	break;
		147	}
		148	case attr::AlignMac68k: {
		149	const auto *SA = cast<AlignMac68kAttr>(A);
		150	Record.push_back(SA->isInherited());
		151	Record.push_back(A->isImplicit());
		152	Record.push_back(A->isPackExpansion());
		153	break;
		154	}
		155	case attr::AlignNatural: {
		156	const auto *SA = cast<AlignNaturalAttr>(A);
		157	Record.push_back(SA->isInherited());
		158	Record.push_back(A->isImplicit());
		159	Record.push_back(A->isPackExpansion());
		160	break;
		161	}
		162	case attr::AlignValue: {
		163	const auto *SA = cast<AlignValueAttr>(A);
		164	Record.push_back(A->isImplicit());
		165	Record.push_back(A->isPackExpansion());
		166	Record.AddStmt(SA->getAlignment());
		167	break;
		168	}
		169	case attr::Aligned: {
		170	const auto *SA = cast<AlignedAttr>(A);
		171	Record.push_back(SA->isInherited());
		172	Record.push_back(A->isImplicit());
		173	Record.push_back(A->isPackExpansion());
		174	Record.push_back(SA->isAlignmentExpr());
		175	if (SA->isAlignmentExpr())
		176	Record.AddStmt(SA->getAlignmentExpr());
		177	else
		178	Record.AddTypeSourceInfo(SA->getAlignmentType());
		179	break;
		180	}
		181	case attr::AllocAlign: {
		182	const auto *SA = cast<AllocAlignAttr>(A);
		183	Record.push_back(SA->isInherited());
		184	Record.push_back(A->isImplicit());
		185	Record.push_back(A->isPackExpansion());
		186	Record.push_back(SA->getParamIndex().serialize());
		187	break;
		188	}
		189	case attr::AllocSize: {
		190	const auto *SA = cast<AllocSizeAttr>(A);
		191	Record.push_back(SA->isInherited());
		192	Record.push_back(A->isImplicit());
		193	Record.push_back(A->isPackExpansion());
		194	Record.push_back(SA->getElemSizeParam().serialize());
		195	Record.push_back(SA->getNumElemsParam().serialize());
		196	break;
		197	}
		198	case attr::AlwaysDestroy: {
		199	const auto *SA = cast<AlwaysDestroyAttr>(A);
		200	Record.push_back(SA->isInherited());
		201	Record.push_back(A->isImplicit());
		202	Record.push_back(A->isPackExpansion());
		203	break;
		204	}
		205	case attr::AlwaysInline: {
		206	const auto *SA = cast<AlwaysInlineAttr>(A);
		207	Record.push_back(SA->isInherited());
		208	Record.push_back(A->isImplicit());
		209	Record.push_back(A->isPackExpansion());
		210	break;
		211	}
		212	case attr::AnalyzerNoReturn: {
		213	const auto *SA = cast<AnalyzerNoReturnAttr>(A);
		214	Record.push_back(SA->isInherited());
		215	Record.push_back(A->isImplicit());
		216	Record.push_back(A->isPackExpansion());
		217	break;
		218	}
		219	case attr::Annotate: {
		220	const auto *SA = cast<AnnotateAttr>(A);
		221	Record.push_back(SA->isInherited());
		222	Record.push_back(A->isImplicit());
		223	Record.push_back(A->isPackExpansion());
		224	Record.push_back(SA->delayedArgs_size());
		225	for (auto &Val : SA->delayedArgs())
		226	Record.AddStmt(Val);
		227	Record.AddString(SA->getAnnotation());
		228	Record.push_back(SA->args_size());
		229	for (auto &Val : SA->args())
		230	Record.AddStmt(Val);
		231	break;
		232	}
		233	case attr::AnnotateType: {
		234	const auto *SA = cast<AnnotateTypeAttr>(A);
		235	Record.push_back(A->isImplicit());
		236	Record.push_back(A->isPackExpansion());
		237	Record.push_back(SA->delayedArgs_size());
		238	for (auto &Val : SA->delayedArgs())
		239	Record.AddStmt(Val);
		240	Record.AddString(SA->getAnnotation());
		241	Record.push_back(SA->args_size());
		242	for (auto &Val : SA->args())
		243	Record.AddStmt(Val);
		244	break;
		245	}
		246	case attr::AnyX86Interrupt: {
		247	const auto *SA = cast<AnyX86InterruptAttr>(A);
		248	Record.push_back(SA->isInherited());
		249	Record.push_back(A->isImplicit());
		250	Record.push_back(A->isPackExpansion());
		251	break;
		252	}
		253	case attr::AnyX86NoCallerSavedRegisters: {
		254	const auto *SA = cast<AnyX86NoCallerSavedRegistersAttr>(A);
		255	Record.push_back(SA->isInherited());
		256	Record.push_back(A->isImplicit());
		257	Record.push_back(A->isPackExpansion());
		258	break;
		259	}
		260	case attr::AnyX86NoCfCheck: {
		261	const auto *SA = cast<AnyX86NoCfCheckAttr>(A);
		262	Record.push_back(SA->isInherited());
		263	Record.push_back(A->isImplicit());
		264	Record.push_back(A->isPackExpansion());
		265	break;
		266	}
		267	case attr::ArcWeakrefUnavailable: {
		268	const auto *SA = cast<ArcWeakrefUnavailableAttr>(A);
		269	Record.push_back(SA->isInherited());
		270	Record.push_back(A->isImplicit());
		271	Record.push_back(A->isPackExpansion());
		272	break;
		273	}
		274	case attr::ArgumentWithTypeTag: {
		275	const auto *SA = cast<ArgumentWithTypeTagAttr>(A);
		276	Record.push_back(SA->isInherited());
		277	Record.push_back(A->isImplicit());
		278	Record.push_back(A->isPackExpansion());
		279	Record.AddIdentifierRef(SA->getArgumentKind());
		280	Record.push_back(SA->getArgumentIdx().serialize());
		281	Record.push_back(SA->getTypeTagIdx().serialize());
		282	Record.push_back(SA->getIsPointer());
		283	break;
		284	}
		285	case attr::ArmBuiltinAlias: {
		286	const auto *SA = cast<ArmBuiltinAliasAttr>(A);
		287	Record.push_back(SA->isInherited());
		288	Record.push_back(A->isImplicit());
		289	Record.push_back(A->isPackExpansion());
		290	Record.AddIdentifierRef(SA->getBuiltinName());
		291	break;
		292	}
		293	case attr::ArmMveStrictPolymorphism: {
		294	Record.push_back(A->isImplicit());
		295	Record.push_back(A->isPackExpansion());
		296	break;
		297	}
		298	case attr::Artificial: {
		299	const auto *SA = cast<ArtificialAttr>(A);
		300	Record.push_back(SA->isInherited());
		301	Record.push_back(A->isImplicit());
		302	Record.push_back(A->isPackExpansion());
		303	break;
		304	}
		305	case attr::AsmLabel: {
		306	const auto *SA = cast<AsmLabelAttr>(A);
		307	Record.push_back(SA->isInherited());
		308	Record.push_back(A->isImplicit());
		309	Record.push_back(A->isPackExpansion());
		310	Record.AddString(SA->getLabel());
		311	Record.push_back(SA->getIsLiteralLabel());
		312	break;
		313	}
		314	case attr::AssertCapability: {
		315	const auto *SA = cast<AssertCapabilityAttr>(A);
		316	Record.push_back(SA->isInherited());
		317	Record.push_back(A->isImplicit());
		318	Record.push_back(A->isPackExpansion());
		319	Record.push_back(SA->args_size());
		320	for (auto &Val : SA->args())
		321	Record.AddStmt(Val);
		322	break;
		323	}
		324	case attr::AssertExclusiveLock: {
		325	const auto *SA = cast<AssertExclusiveLockAttr>(A);
		326	Record.push_back(SA->isInherited());
		327	Record.push_back(A->isImplicit());
		328	Record.push_back(A->isPackExpansion());
		329	Record.push_back(SA->args_size());
		330	for (auto &Val : SA->args())
		331	Record.AddStmt(Val);
		332	break;
		333	}
		334	case attr::AssertSharedLock: {
		335	const auto *SA = cast<AssertSharedLockAttr>(A);
		336	Record.push_back(SA->isInherited());
		337	Record.push_back(A->isImplicit());
		338	Record.push_back(A->isPackExpansion());
		339	Record.push_back(SA->args_size());
		340	for (auto &Val : SA->args())
		341	Record.AddStmt(Val);
		342	break;
		343	}
		344	case attr::AssumeAligned: {
		345	const auto *SA = cast<AssumeAlignedAttr>(A);
		346	Record.push_back(SA->isInherited());
		347	Record.push_back(A->isImplicit());
		348	Record.push_back(A->isPackExpansion());
		349	Record.AddStmt(SA->getAlignment());
		350	Record.AddStmt(SA->getOffset());
		351	break;
		352	}
		353	case attr::Assumption: {
		354	const auto *SA = cast<AssumptionAttr>(A);
		355	Record.push_back(SA->isInherited());
		356	Record.push_back(A->isImplicit());
		357	Record.push_back(A->isPackExpansion());
		358	Record.AddString(SA->getAssumption());
		359	break;
		360	}
		361	case attr::Availability: {
		362	const auto *SA = cast<AvailabilityAttr>(A);
		363	Record.push_back(SA->isInherited());
		364	Record.push_back(A->isImplicit());
		365	Record.push_back(A->isPackExpansion());
		366	Record.AddIdentifierRef(SA->getPlatform());
		367	Record.AddVersionTuple(SA->getIntroduced());
		368	Record.AddVersionTuple(SA->getDeprecated());
		369	Record.AddVersionTuple(SA->getObsoleted());
		370	Record.push_back(SA->getUnavailable());
		371	Record.AddString(SA->getMessage());
		372	Record.push_back(SA->getStrict());
		373	Record.AddString(SA->getReplacement());
		374	Record.push_back(SA->getPriority());
		375	break;
		376	}
		377	case attr::BPFPreserveAccessIndex: {
		378	const auto *SA = cast<BPFPreserveAccessIndexAttr>(A);
		379	Record.push_back(SA->isInherited());
		380	Record.push_back(A->isImplicit());
		381	Record.push_back(A->isPackExpansion());
		382	break;
		383	}
		384	case attr::BTFDeclTag: {
		385	const auto *SA = cast<BTFDeclTagAttr>(A);
		386	Record.push_back(SA->isInherited());
		387	Record.push_back(A->isImplicit());
		388	Record.push_back(A->isPackExpansion());
		389	Record.AddString(SA->getBTFDeclTag());
		390	break;
		391	}
		392	case attr::BTFTypeTag: {
		393	const auto *SA = cast<BTFTypeTagAttr>(A);
		394	Record.push_back(A->isImplicit());
		395	Record.push_back(A->isPackExpansion());
		396	Record.AddString(SA->getBTFTypeTag());
		397	break;
		398	}
		399	case attr::Blocks: {
		400	const auto *SA = cast<BlocksAttr>(A);
		401	Record.push_back(SA->isInherited());
		402	Record.push_back(A->isImplicit());
		403	Record.push_back(A->isPackExpansion());
		404	Record.push_back(SA->getType());
		405	break;
		406	}
		407	case attr::Builtin: {
		408	const auto *SA = cast<BuiltinAttr>(A);
		409	Record.push_back(SA->isInherited());
		410	Record.push_back(A->isImplicit());
		411	Record.push_back(A->isPackExpansion());
		412	Record.push_back(SA->getID());
		413	break;
		414	}
		415	case attr::BuiltinAlias: {
		416	const auto *SA = cast<BuiltinAliasAttr>(A);
		417	Record.push_back(A->isImplicit());
		418	Record.push_back(A->isPackExpansion());
		419	Record.AddIdentifierRef(SA->getBuiltinName());
		420	break;
		421	}
		422	case attr::C11NoReturn: {
		423	const auto *SA = cast<C11NoReturnAttr>(A);
		424	Record.push_back(SA->isInherited());
		425	Record.push_back(A->isImplicit());
		426	Record.push_back(A->isPackExpansion());
		427	break;
		428	}
		429	case attr::CDecl: {
		430	const auto *SA = cast<CDeclAttr>(A);
		431	Record.push_back(SA->isInherited());
		432	Record.push_back(A->isImplicit());
		433	Record.push_back(A->isPackExpansion());
		434	break;
		435	}
		436	case attr::CFAuditedTransfer: {
		437	const auto *SA = cast<CFAuditedTransferAttr>(A);
		438	Record.push_back(SA->isInherited());
		439	Record.push_back(A->isImplicit());
		440	Record.push_back(A->isPackExpansion());
		441	break;
		442	}
		443	case attr::CFConsumed: {
		444	const auto *SA = cast<CFConsumedAttr>(A);
		445	Record.push_back(SA->isInherited());
		446	Record.push_back(A->isImplicit());
		447	Record.push_back(A->isPackExpansion());
		448	break;
		449	}
		450	case attr::CFGuard: {
		451	const auto *SA = cast<CFGuardAttr>(A);
		452	Record.push_back(SA->isInherited());
		453	Record.push_back(A->isImplicit());
		454	Record.push_back(A->isPackExpansion());
		455	Record.push_back(SA->getGuard());
		456	break;
		457	}
		458	case attr::CFICanonicalJumpTable: {
		459	const auto *SA = cast<CFICanonicalJumpTableAttr>(A);
		460	Record.push_back(SA->isInherited());
		461	Record.push_back(A->isImplicit());
		462	Record.push_back(A->isPackExpansion());
		463	break;
		464	}
		465	case attr::CFReturnsNotRetained: {
		466	const auto *SA = cast<CFReturnsNotRetainedAttr>(A);
		467	Record.push_back(SA->isInherited());
		468	Record.push_back(A->isImplicit());
		469	Record.push_back(A->isPackExpansion());
		470	break;
		471	}
		472	case attr::CFReturnsRetained: {
		473	const auto *SA = cast<CFReturnsRetainedAttr>(A);
		474	Record.push_back(SA->isInherited());
		475	Record.push_back(A->isImplicit());
		476	Record.push_back(A->isPackExpansion());
		477	break;
		478	}
		479	case attr::CFUnknownTransfer: {
		480	const auto *SA = cast<CFUnknownTransferAttr>(A);
		481	Record.push_back(SA->isInherited());
		482	Record.push_back(A->isImplicit());
		483	Record.push_back(A->isPackExpansion());
		484	break;
		485	}
		486	case attr::CPUDispatch: {
		487	const auto *SA = cast<CPUDispatchAttr>(A);
		488	Record.push_back(SA->isInherited());
		489	Record.push_back(A->isImplicit());
		490	Record.push_back(A->isPackExpansion());
		491	Record.push_back(SA->cpus_size());
		492	for (auto &Val : SA->cpus())
		493	Record.AddIdentifierRef(Val);
		494	break;
		495	}
		496	case attr::CPUSpecific: {
		497	const auto *SA = cast<CPUSpecificAttr>(A);
		498	Record.push_back(SA->isInherited());
		499	Record.push_back(A->isImplicit());
		500	Record.push_back(A->isPackExpansion());
		501	Record.push_back(SA->cpus_size());
		502	for (auto &Val : SA->cpus())
		503	Record.AddIdentifierRef(Val);
		504	break;
		505	}
		506	case attr::CUDAConstant: {
		507	const auto *SA = cast<CUDAConstantAttr>(A);
		508	Record.push_back(SA->isInherited());
		509	Record.push_back(A->isImplicit());
		510	Record.push_back(A->isPackExpansion());
		511	break;
		512	}
		513	case attr::CUDADevice: {
		514	const auto *SA = cast<CUDADeviceAttr>(A);
		515	Record.push_back(SA->isInherited());
		516	Record.push_back(A->isImplicit());
		517	Record.push_back(A->isPackExpansion());
		518	break;
		519	}
		520	case attr::CUDADeviceBuiltinSurfaceType: {
		521	const auto *SA = cast<CUDADeviceBuiltinSurfaceTypeAttr>(A);
		522	Record.push_back(SA->isInherited());
		523	Record.push_back(A->isImplicit());
		524	Record.push_back(A->isPackExpansion());
		525	break;
		526	}
		527	case attr::CUDADeviceBuiltinTextureType: {
		528	const auto *SA = cast<CUDADeviceBuiltinTextureTypeAttr>(A);
		529	Record.push_back(SA->isInherited());
		530	Record.push_back(A->isImplicit());
		531	Record.push_back(A->isPackExpansion());
		532	break;
		533	}
		534	case attr::CUDAGlobal: {
		535	const auto *SA = cast<CUDAGlobalAttr>(A);
		536	Record.push_back(SA->isInherited());
		537	Record.push_back(A->isImplicit());
		538	Record.push_back(A->isPackExpansion());
		539	break;
		540	}
		541	case attr::CUDAHost: {
		542	const auto *SA = cast<CUDAHostAttr>(A);
		543	Record.push_back(SA->isInherited());
		544	Record.push_back(A->isImplicit());
		545	Record.push_back(A->isPackExpansion());
		546	break;
		547	}
		548	case attr::CUDAInvalidTarget: {
		549	const auto *SA = cast<CUDAInvalidTargetAttr>(A);
		550	Record.push_back(SA->isInherited());
		551	Record.push_back(A->isImplicit());
		552	Record.push_back(A->isPackExpansion());
		553	break;
		554	}
		555	case attr::CUDALaunchBounds: {
		556	const auto *SA = cast<CUDALaunchBoundsAttr>(A);
		557	Record.push_back(SA->isInherited());
		558	Record.push_back(A->isImplicit());
		559	Record.push_back(A->isPackExpansion());
		560	Record.AddStmt(SA->getMaxThreads());
		561	Record.AddStmt(SA->getMinBlocks());
		562	break;
		563	}
		564	case attr::CUDAShared: {
		565	const auto *SA = cast<CUDASharedAttr>(A);
		566	Record.push_back(SA->isInherited());
		567	Record.push_back(A->isImplicit());
		568	Record.push_back(A->isPackExpansion());
		569	break;
		570	}
		571	case attr::CXX11NoReturn: {
		572	const auto *SA = cast<CXX11NoReturnAttr>(A);
		573	Record.push_back(SA->isInherited());
		574	Record.push_back(A->isImplicit());
		575	Record.push_back(A->isPackExpansion());
		576	break;
		577	}
		578	case attr::CallableWhen: {
		579	const auto *SA = cast<CallableWhenAttr>(A);
		580	Record.push_back(SA->isInherited());
		581	Record.push_back(A->isImplicit());
		582	Record.push_back(A->isPackExpansion());
		583	Record.push_back(SA->callableStates_size());
		584	for (CallableWhenAttr::callableStates_iterator i = SA->callableStates_begin(), e = SA->callableStates_end(); i != e; ++i)
		585	Record.push_back((*i));
		586	break;
		587	}
		588	case attr::Callback: {
		589	const auto *SA = cast<CallbackAttr>(A);
		590	Record.push_back(SA->isInherited());
		591	Record.push_back(A->isImplicit());
		592	Record.push_back(A->isPackExpansion());
		593	Record.push_back(SA->encoding_size());
		594	for (auto &Val : SA->encoding())
		595	Record.push_back(Val);
		596	break;
		597	}
		598	case attr::CalledOnce: {
		599	Record.push_back(A->isImplicit());
		600	Record.push_back(A->isPackExpansion());
		601	break;
		602	}
		603	case attr::Capability: {
		604	const auto *SA = cast<CapabilityAttr>(A);
		605	Record.push_back(SA->isInherited());
		606	Record.push_back(A->isImplicit());
		607	Record.push_back(A->isPackExpansion());
		608	Record.AddString(SA->getName());
		609	break;
		610	}
		611	case attr::CapturedRecord: {
		612	const auto *SA = cast<CapturedRecordAttr>(A);
		613	Record.push_back(SA->isInherited());
		614	Record.push_back(A->isImplicit());
		615	Record.push_back(A->isPackExpansion());
		616	break;
		617	}
		618	case attr::CarriesDependency: {
		619	const auto *SA = cast<CarriesDependencyAttr>(A);
		620	Record.push_back(SA->isInherited());
		621	Record.push_back(A->isImplicit());
		622	Record.push_back(A->isPackExpansion());
		623	break;
		624	}
		625	case attr::Cleanup: {
		626	const auto *SA = cast<CleanupAttr>(A);
		627	Record.push_back(SA->isInherited());
		628	Record.push_back(A->isImplicit());
		629	Record.push_back(A->isPackExpansion());
		630	Record.AddDeclRef(SA->getFunctionDecl());
		631	break;
		632	}
		633	case attr::CmseNSCall: {
		634	Record.push_back(A->isImplicit());
		635	Record.push_back(A->isPackExpansion());
		636	break;
		637	}
		638	case attr::CmseNSEntry: {
		639	const auto *SA = cast<CmseNSEntryAttr>(A);
		640	Record.push_back(SA->isInherited());
		641	Record.push_back(A->isImplicit());
		642	Record.push_back(A->isPackExpansion());
		643	break;
		644	}
		645	case attr::CodeSeg: {
		646	const auto *SA = cast<CodeSegAttr>(A);
		647	Record.push_back(SA->isInherited());
		648	Record.push_back(A->isImplicit());
		649	Record.push_back(A->isPackExpansion());
		650	Record.AddString(SA->getName());
		651	break;
		652	}
		653	case attr::Cold: {
		654	const auto *SA = cast<ColdAttr>(A);
		655	Record.push_back(SA->isInherited());
		656	Record.push_back(A->isImplicit());
		657	Record.push_back(A->isPackExpansion());
		658	break;
		659	}
		660	case attr::Common: {
		661	const auto *SA = cast<CommonAttr>(A);
		662	Record.push_back(SA->isInherited());
		663	Record.push_back(A->isImplicit());
		664	Record.push_back(A->isPackExpansion());
		665	break;
		666	}
		667	case attr::Const: {
		668	const auto *SA = cast<ConstAttr>(A);
		669	Record.push_back(SA->isInherited());
		670	Record.push_back(A->isImplicit());
		671	Record.push_back(A->isPackExpansion());
		672	break;
		673	}
		674	case attr::ConstInit: {
		675	const auto *SA = cast<ConstInitAttr>(A);
		676	Record.push_back(SA->isInherited());
		677	Record.push_back(A->isImplicit());
		678	Record.push_back(A->isPackExpansion());
		679	break;
		680	}
		681	case attr::Constructor: {
		682	const auto *SA = cast<ConstructorAttr>(A);
		683	Record.push_back(SA->isInherited());
		684	Record.push_back(A->isImplicit());
		685	Record.push_back(A->isPackExpansion());
		686	Record.push_back(SA->getPriority());
		687	break;
		688	}
		689	case attr::Consumable: {
		690	const auto *SA = cast<ConsumableAttr>(A);
		691	Record.push_back(SA->isInherited());
		692	Record.push_back(A->isImplicit());
		693	Record.push_back(A->isPackExpansion());
		694	Record.push_back(SA->getDefaultState());
		695	break;
		696	}
		697	case attr::ConsumableAutoCast: {
		698	const auto *SA = cast<ConsumableAutoCastAttr>(A);
		699	Record.push_back(SA->isInherited());
		700	Record.push_back(A->isImplicit());
		701	Record.push_back(A->isPackExpansion());
		702	break;
		703	}
		704	case attr::ConsumableSetOnRead: {
		705	const auto *SA = cast<ConsumableSetOnReadAttr>(A);
		706	Record.push_back(SA->isInherited());
		707	Record.push_back(A->isImplicit());
		708	Record.push_back(A->isPackExpansion());
		709	break;
		710	}
		711	case attr::Convergent: {
		712	const auto *SA = cast<ConvergentAttr>(A);
		713	Record.push_back(SA->isInherited());
		714	Record.push_back(A->isImplicit());
		715	Record.push_back(A->isPackExpansion());
		716	break;
		717	}
		718	case attr::DLLExport: {
		719	const auto *SA = cast<DLLExportAttr>(A);
		720	Record.push_back(SA->isInherited());
		721	Record.push_back(A->isImplicit());
		722	Record.push_back(A->isPackExpansion());
		723	break;
		724	}
		725	case attr::DLLExportStaticLocal: {
		726	const auto *SA = cast<DLLExportStaticLocalAttr>(A);
		727	Record.push_back(SA->isInherited());
		728	Record.push_back(A->isImplicit());
		729	Record.push_back(A->isPackExpansion());
		730	break;
		731	}
		732	case attr::DLLImport: {
		733	const auto *SA = cast<DLLImportAttr>(A);
		734	Record.push_back(SA->isInherited());
		735	Record.push_back(A->isImplicit());
		736	Record.push_back(A->isPackExpansion());
		737	break;
		738	}
		739	case attr::DLLImportStaticLocal: {
		740	const auto *SA = cast<DLLImportStaticLocalAttr>(A);
		741	Record.push_back(SA->isInherited());
		742	Record.push_back(A->isImplicit());
		743	Record.push_back(A->isPackExpansion());
		744	break;
		745	}
		746	case attr::Deprecated: {
		747	const auto *SA = cast<DeprecatedAttr>(A);
		748	Record.push_back(SA->isInherited());
		749	Record.push_back(A->isImplicit());
		750	Record.push_back(A->isPackExpansion());
		751	Record.AddString(SA->getMessage());
		752	Record.AddString(SA->getReplacement());
		753	break;
		754	}
		755	case attr::Destructor: {
		756	const auto *SA = cast<DestructorAttr>(A);
		757	Record.push_back(SA->isInherited());
		758	Record.push_back(A->isImplicit());
		759	Record.push_back(A->isPackExpansion());
		760	Record.push_back(SA->getPriority());
		761	break;
		762	}
		763	case attr::DiagnoseAsBuiltin: {
		764	const auto *SA = cast<DiagnoseAsBuiltinAttr>(A);
		765	Record.push_back(SA->isInherited());
		766	Record.push_back(A->isImplicit());
		767	Record.push_back(A->isPackExpansion());
		768	Record.AddDeclRef(SA->getFunction());
		769	Record.push_back(SA->argIndices_size());
		770	for (auto &Val : SA->argIndices())
		771	Record.push_back(Val);
		772	break;
		773	}
		774	case attr::DiagnoseIf: {
		775	const auto *SA = cast<DiagnoseIfAttr>(A);
		776	Record.push_back(SA->isInherited());
		777	Record.push_back(A->isImplicit());
		778	Record.push_back(A->isPackExpansion());
		779	Record.AddStmt(SA->getCond());
		780	Record.AddString(SA->getMessage());
		781	Record.push_back(SA->getDiagnosticType());
		782	Record.push_back(SA->getArgDependent());
		783	Record.AddDeclRef(SA->getParent());
		784	break;
		785	}
		786	case attr::DisableSanitizerInstrumentation: {
		787	const auto *SA = cast<DisableSanitizerInstrumentationAttr>(A);
		788	Record.push_back(SA->isInherited());
		789	Record.push_back(A->isImplicit());
		790	Record.push_back(A->isPackExpansion());
		791	break;
		792	}
		793	case attr::DisableTailCalls: {
		794	const auto *SA = cast<DisableTailCallsAttr>(A);
		795	Record.push_back(SA->isInherited());
		796	Record.push_back(A->isImplicit());
		797	Record.push_back(A->isPackExpansion());
		798	break;
		799	}
		800	case attr::EmptyBases: {
		801	const auto *SA = cast<EmptyBasesAttr>(A);
		802	Record.push_back(SA->isInherited());
		803	Record.push_back(A->isImplicit());
		804	Record.push_back(A->isPackExpansion());
		805	break;
		806	}
		807	case attr::EnableIf: {
		808	const auto *SA = cast<EnableIfAttr>(A);
		809	Record.push_back(SA->isInherited());
		810	Record.push_back(A->isImplicit());
		811	Record.push_back(A->isPackExpansion());
		812	Record.AddStmt(SA->getCond());
		813	Record.AddString(SA->getMessage());
		814	break;
		815	}
		816	case attr::EnforceTCB: {
		817	const auto *SA = cast<EnforceTCBAttr>(A);
		818	Record.push_back(SA->isInherited());
		819	Record.push_back(A->isImplicit());
		820	Record.push_back(A->isPackExpansion());
		821	Record.AddString(SA->getTCBName());
		822	break;
		823	}
		824	case attr::EnforceTCBLeaf: {
		825	const auto *SA = cast<EnforceTCBLeafAttr>(A);
		826	Record.push_back(SA->isInherited());
		827	Record.push_back(A->isImplicit());
		828	Record.push_back(A->isPackExpansion());
		829	Record.AddString(SA->getTCBName());
		830	break;
		831	}
		832	case attr::EnumExtensibility: {
		833	const auto *SA = cast<EnumExtensibilityAttr>(A);
		834	Record.push_back(SA->isInherited());
		835	Record.push_back(A->isImplicit());
		836	Record.push_back(A->isPackExpansion());
		837	Record.push_back(SA->getExtensibility());
		838	break;
		839	}
		840	case attr::Error: {
		841	const auto *SA = cast<ErrorAttr>(A);
		842	Record.push_back(SA->isInherited());
		843	Record.push_back(A->isImplicit());
		844	Record.push_back(A->isPackExpansion());
		845	Record.AddString(SA->getUserDiagnostic());
		846	break;
		847	}
		848	case attr::ExcludeFromExplicitInstantiation: {
		849	const auto *SA = cast<ExcludeFromExplicitInstantiationAttr>(A);
		850	Record.push_back(SA->isInherited());
		851	Record.push_back(A->isImplicit());
		852	Record.push_back(A->isPackExpansion());
		853	break;
		854	}
		855	case attr::ExclusiveTrylockFunction: {
		856	const auto *SA = cast<ExclusiveTrylockFunctionAttr>(A);
		857	Record.push_back(SA->isInherited());
		858	Record.push_back(A->isImplicit());
		859	Record.push_back(A->isPackExpansion());
		860	Record.AddStmt(SA->getSuccessValue());
		861	Record.push_back(SA->args_size());
		862	for (auto &Val : SA->args())
		863	Record.AddStmt(Val);
		864	break;
		865	}
		866	case attr::ExternalSourceSymbol: {
		867	const auto *SA = cast<ExternalSourceSymbolAttr>(A);
		868	Record.push_back(SA->isInherited());
		869	Record.push_back(A->isImplicit());
		870	Record.push_back(A->isPackExpansion());
		871	Record.AddString(SA->getLanguage());
		872	Record.AddString(SA->getDefinedIn());
		873	Record.push_back(SA->getGeneratedDeclaration());
		874	break;
		875	}
		876	case attr::FallThrough: {
		877	Record.push_back(A->isImplicit());
		878	Record.push_back(A->isPackExpansion());
		879	break;
		880	}
		881	case attr::FastCall: {
		882	const auto *SA = cast<FastCallAttr>(A);
		883	Record.push_back(SA->isInherited());
		884	Record.push_back(A->isImplicit());
		885	Record.push_back(A->isPackExpansion());
		886	break;
		887	}
		888	case attr::Final: {
		889	const auto *SA = cast<FinalAttr>(A);
		890	Record.push_back(SA->isInherited());
		891	Record.push_back(A->isImplicit());
		892	Record.push_back(A->isPackExpansion());
		893	break;
		894	}
		895	case attr::FlagEnum: {
		896	const auto *SA = cast<FlagEnumAttr>(A);
		897	Record.push_back(SA->isInherited());
		898	Record.push_back(A->isImplicit());
		899	Record.push_back(A->isPackExpansion());
		900	break;
		901	}
		902	case attr::Flatten: {
		903	const auto *SA = cast<FlattenAttr>(A);
		904	Record.push_back(SA->isInherited());
		905	Record.push_back(A->isImplicit());
		906	Record.push_back(A->isPackExpansion());
		907	break;
		908	}
		909	case attr::Format: {
		910	const auto *SA = cast<FormatAttr>(A);
		911	Record.push_back(SA->isInherited());
		912	Record.push_back(A->isImplicit());
		913	Record.push_back(A->isPackExpansion());
		914	Record.AddIdentifierRef(SA->getType());
		915	Record.push_back(SA->getFormatIdx());
		916	Record.push_back(SA->getFirstArg());
		917	break;
		918	}
		919	case attr::FormatArg: {
		920	const auto *SA = cast<FormatArgAttr>(A);
		921	Record.push_back(SA->isInherited());
		922	Record.push_back(A->isImplicit());
		923	Record.push_back(A->isPackExpansion());
		924	Record.push_back(SA->getFormatIdx().serialize());
		925	break;
		926	}
		927	case attr::FunctionReturnThunks: {
		928	const auto *SA = cast<FunctionReturnThunksAttr>(A);
		929	Record.push_back(SA->isInherited());
		930	Record.push_back(A->isImplicit());
		931	Record.push_back(A->isPackExpansion());
		932	Record.push_back(SA->getThunkType());
		933	break;
		934	}
		935	case attr::GNUInline: {
		936	const auto *SA = cast<GNUInlineAttr>(A);
		937	Record.push_back(SA->isInherited());
		938	Record.push_back(A->isImplicit());
		939	Record.push_back(A->isPackExpansion());
		940	break;
		941	}
		942	case attr::GuardedBy: {
		943	const auto *SA = cast<GuardedByAttr>(A);
		944	Record.push_back(SA->isInherited());
		945	Record.push_back(A->isImplicit());
		946	Record.push_back(A->isPackExpansion());
		947	Record.AddStmt(SA->getArg());
		948	break;
		949	}
		950	case attr::GuardedVar: {
		951	const auto *SA = cast<GuardedVarAttr>(A);
		952	Record.push_back(SA->isInherited());
		953	Record.push_back(A->isImplicit());
		954	Record.push_back(A->isPackExpansion());
		955	break;
		956	}
		957	case attr::HIPManaged: {
		958	const auto *SA = cast<HIPManagedAttr>(A);
		959	Record.push_back(SA->isInherited());
		960	Record.push_back(A->isImplicit());
		961	Record.push_back(A->isPackExpansion());
		962	break;
		963	}
		964	case attr::HLSLGroupSharedAddressSpace: {
		965	Record.push_back(A->isImplicit());
		966	Record.push_back(A->isPackExpansion());
		967	break;
		968	}
		969	case attr::HLSLNumThreads: {
		970	const auto *SA = cast<HLSLNumThreadsAttr>(A);
		971	Record.push_back(SA->isInherited());
		972	Record.push_back(A->isImplicit());
		973	Record.push_back(A->isPackExpansion());
		974	Record.push_back(SA->getX());
		975	Record.push_back(SA->getY());
		976	Record.push_back(SA->getZ());
		977	break;
		978	}
		979	case attr::HLSLResource: {
		980	const auto *SA = cast<HLSLResourceAttr>(A);
		981	Record.push_back(SA->isInherited());
		982	Record.push_back(A->isImplicit());
		983	Record.push_back(A->isPackExpansion());
		984	Record.push_back(SA->getResourceType());
		985	Record.push_back(SA->getResourceShape());
		986	break;
		987	}
		988	case attr::HLSLResourceBinding: {
		989	const auto *SA = cast<HLSLResourceBindingAttr>(A);
		990	Record.push_back(SA->isInherited());
		991	Record.push_back(A->isImplicit());
		992	Record.push_back(A->isPackExpansion());
		993	Record.AddString(SA->getSlot());
		994	Record.AddString(SA->getSpace());
		995	break;
		996	}
		997	case attr::HLSLSV_DispatchThreadID: {
		998	const auto *SA = cast<HLSLSV_DispatchThreadIDAttr>(A);
		999	Record.push_back(SA->isInherited());
		1000	Record.push_back(A->isImplicit());
		1001	Record.push_back(A->isPackExpansion());
		1002	break;
		1003	}
		1004	case attr::HLSLSV_GroupIndex: {
		1005	const auto *SA = cast<HLSLSV_GroupIndexAttr>(A);
		1006	Record.push_back(SA->isInherited());
		1007	Record.push_back(A->isImplicit());
		1008	Record.push_back(A->isPackExpansion());
		1009	break;
		1010	}
		1011	case attr::HLSLShader: {
		1012	const auto *SA = cast<HLSLShaderAttr>(A);
		1013	Record.push_back(SA->isInherited());
		1014	Record.push_back(A->isImplicit());
		1015	Record.push_back(A->isPackExpansion());
		1016	Record.push_back(SA->getType());
		1017	break;
		1018	}
		1019	case attr::Hot: {
		1020	const auto *SA = cast<HotAttr>(A);
		1021	Record.push_back(SA->isInherited());
		1022	Record.push_back(A->isImplicit());
		1023	Record.push_back(A->isPackExpansion());
		1024	break;
		1025	}
		1026	case attr::IBAction: {
		1027	const auto *SA = cast<IBActionAttr>(A);
		1028	Record.push_back(SA->isInherited());
		1029	Record.push_back(A->isImplicit());
		1030	Record.push_back(A->isPackExpansion());
		1031	break;
		1032	}
		1033	case attr::IBOutlet: {
		1034	const auto *SA = cast<IBOutletAttr>(A);
		1035	Record.push_back(SA->isInherited());
		1036	Record.push_back(A->isImplicit());
		1037	Record.push_back(A->isPackExpansion());
		1038	break;
		1039	}
		1040	case attr::IBOutletCollection: {
		1041	const auto *SA = cast<IBOutletCollectionAttr>(A);
		1042	Record.push_back(SA->isInherited());
		1043	Record.push_back(A->isImplicit());
		1044	Record.push_back(A->isPackExpansion());
		1045	Record.AddTypeSourceInfo(SA->getInterfaceLoc());
		1046	break;
		1047	}
		1048	case attr::IFunc: {
		1049	const auto *SA = cast<IFuncAttr>(A);
		1050	Record.push_back(A->isImplicit());
		1051	Record.push_back(A->isPackExpansion());
		1052	Record.AddString(SA->getResolver());
		1053	break;
		1054	}
		1055	case attr::InitPriority: {
		1056	const auto *SA = cast<InitPriorityAttr>(A);
		1057	Record.push_back(SA->isInherited());
		1058	Record.push_back(A->isImplicit());
		1059	Record.push_back(A->isPackExpansion());
		1060	Record.push_back(SA->getPriority());
		1061	break;
		1062	}
		1063	case attr::InitSeg: {
		1064	const auto *SA = cast<InitSegAttr>(A);
		1065	Record.push_back(A->isImplicit());
		1066	Record.push_back(A->isPackExpansion());
		1067	Record.AddString(SA->getSection());
		1068	break;
		1069	}
		1070	case attr::IntelOclBicc: {
		1071	const auto *SA = cast<IntelOclBiccAttr>(A);
		1072	Record.push_back(SA->isInherited());
		1073	Record.push_back(A->isImplicit());
		1074	Record.push_back(A->isPackExpansion());
		1075	break;
		1076	}
		1077	case attr::InternalLinkage: {
		1078	const auto *SA = cast<InternalLinkageAttr>(A);
		1079	Record.push_back(SA->isInherited());
		1080	Record.push_back(A->isImplicit());
		1081	Record.push_back(A->isPackExpansion());
		1082	break;
		1083	}
		1084	case attr::LTOVisibilityPublic: {
		1085	const auto *SA = cast<LTOVisibilityPublicAttr>(A);
		1086	Record.push_back(SA->isInherited());
		1087	Record.push_back(A->isImplicit());
		1088	Record.push_back(A->isPackExpansion());
		1089	break;
		1090	}
		1091	case attr::LayoutVersion: {
		1092	const auto *SA = cast<LayoutVersionAttr>(A);
		1093	Record.push_back(SA->isInherited());
		1094	Record.push_back(A->isImplicit());
		1095	Record.push_back(A->isPackExpansion());
		1096	Record.push_back(SA->getVersion());
		1097	break;
		1098	}
		1099	case attr::Leaf: {
		1100	const auto *SA = cast<LeafAttr>(A);
		1101	Record.push_back(SA->isInherited());
		1102	Record.push_back(A->isImplicit());
		1103	Record.push_back(A->isPackExpansion());
		1104	break;
		1105	}
		1106	case attr::LifetimeBound: {
		1107	const auto *SA = cast<LifetimeBoundAttr>(A);
		1108	Record.push_back(SA->isInherited());
		1109	Record.push_back(A->isImplicit());
		1110	Record.push_back(A->isPackExpansion());
		1111	break;
		1112	}
		1113	case attr::Likely: {
		1114	Record.push_back(A->isImplicit());
		1115	Record.push_back(A->isPackExpansion());
		1116	break;
		1117	}
		1118	case attr::LoaderUninitialized: {
		1119	Record.push_back(A->isImplicit());
		1120	Record.push_back(A->isPackExpansion());
		1121	break;
		1122	}
		1123	case attr::LockReturned: {
		1124	const auto *SA = cast<LockReturnedAttr>(A);
		1125	Record.push_back(SA->isInherited());
		1126	Record.push_back(A->isImplicit());
		1127	Record.push_back(A->isPackExpansion());
		1128	Record.AddStmt(SA->getArg());
		1129	break;
		1130	}
		1131	case attr::LocksExcluded: {
		1132	const auto *SA = cast<LocksExcludedAttr>(A);
		1133	Record.push_back(SA->isInherited());
		1134	Record.push_back(A->isImplicit());
		1135	Record.push_back(A->isPackExpansion());
		1136	Record.push_back(SA->args_size());
		1137	for (auto &Val : SA->args())
		1138	Record.AddStmt(Val);
		1139	break;
		1140	}
		1141	case attr::LoopHint: {
		1142	const auto *SA = cast<LoopHintAttr>(A);
		1143	Record.push_back(A->isImplicit());
		1144	Record.push_back(A->isPackExpansion());
		1145	Record.push_back(SA->getOption());
		1146	Record.push_back(SA->getState());
		1147	Record.AddStmt(SA->getValue());
		1148	break;
		1149	}
		1150	case attr::M68kInterrupt: {
		1151	const auto *SA = cast<M68kInterruptAttr>(A);
		1152	Record.push_back(SA->isInherited());
		1153	Record.push_back(A->isImplicit());
		1154	Record.push_back(A->isPackExpansion());
		1155	Record.push_back(SA->getNumber());
		1156	break;
		1157	}
		1158	case attr::MIGServerRoutine: {
		1159	const auto *SA = cast<MIGServerRoutineAttr>(A);
		1160	Record.push_back(SA->isInherited());
		1161	Record.push_back(A->isImplicit());
		1162	Record.push_back(A->isPackExpansion());
		1163	break;
		1164	}
		1165	case attr::MSABI: {
		1166	const auto *SA = cast<MSABIAttr>(A);
		1167	Record.push_back(SA->isInherited());
		1168	Record.push_back(A->isImplicit());
		1169	Record.push_back(A->isPackExpansion());
		1170	break;
		1171	}
		1172	case attr::MSAllocator: {
		1173	const auto *SA = cast<MSAllocatorAttr>(A);
		1174	Record.push_back(SA->isInherited());
		1175	Record.push_back(A->isImplicit());
		1176	Record.push_back(A->isPackExpansion());
		1177	break;
		1178	}
		1179	case attr::MSInheritance: {
		1180	const auto *SA = cast<MSInheritanceAttr>(A);
		1181	Record.push_back(SA->isInherited());
		1182	Record.push_back(A->isImplicit());
		1183	Record.push_back(A->isPackExpansion());
		1184	Record.push_back(SA->getBestCase());
		1185	break;
		1186	}
		1187	case attr::MSNoVTable: {
		1188	const auto *SA = cast<MSNoVTableAttr>(A);
		1189	Record.push_back(SA->isInherited());
		1190	Record.push_back(A->isImplicit());
		1191	Record.push_back(A->isPackExpansion());
		1192	break;
		1193	}
		1194	case attr::MSP430Interrupt: {
		1195	const auto *SA = cast<MSP430InterruptAttr>(A);
		1196	Record.push_back(SA->isInherited());
		1197	Record.push_back(A->isImplicit());
		1198	Record.push_back(A->isPackExpansion());
		1199	Record.push_back(SA->getNumber());
		1200	break;
		1201	}
		1202	case attr::MSStruct: {
		1203	const auto *SA = cast<MSStructAttr>(A);
		1204	Record.push_back(SA->isInherited());
		1205	Record.push_back(A->isImplicit());
		1206	Record.push_back(A->isPackExpansion());
		1207	break;
		1208	}
		1209	case attr::MSVtorDisp: {
		1210	const auto *SA = cast<MSVtorDispAttr>(A);
		1211	Record.push_back(SA->isInherited());
		1212	Record.push_back(A->isImplicit());
		1213	Record.push_back(A->isPackExpansion());
		1214	Record.push_back(SA->getVdm());
		1215	break;
		1216	}
		1217	case attr::MaxFieldAlignment: {
		1218	const auto *SA = cast<MaxFieldAlignmentAttr>(A);
		1219	Record.push_back(SA->isInherited());
		1220	Record.push_back(A->isImplicit());
		1221	Record.push_back(A->isPackExpansion());
		1222	Record.push_back(SA->getAlignment());
		1223	break;
		1224	}
		1225	case attr::MayAlias: {
		1226	const auto *SA = cast<MayAliasAttr>(A);
		1227	Record.push_back(SA->isInherited());
		1228	Record.push_back(A->isImplicit());
		1229	Record.push_back(A->isPackExpansion());
		1230	break;
		1231	}
		1232	case attr::MaybeUndef: {
		1233	const auto *SA = cast<MaybeUndefAttr>(A);
		1234	Record.push_back(SA->isInherited());
		1235	Record.push_back(A->isImplicit());
		1236	Record.push_back(A->isPackExpansion());
		1237	break;
		1238	}
		1239	case attr::MicroMips: {
		1240	const auto *SA = cast<MicroMipsAttr>(A);
		1241	Record.push_back(SA->isInherited());
		1242	Record.push_back(A->isImplicit());
		1243	Record.push_back(A->isPackExpansion());
		1244	break;
		1245	}
		1246	case attr::MinSize: {
		1247	const auto *SA = cast<MinSizeAttr>(A);
		1248	Record.push_back(SA->isInherited());
		1249	Record.push_back(A->isImplicit());
		1250	Record.push_back(A->isPackExpansion());
		1251	break;
		1252	}
		1253	case attr::MinVectorWidth: {
		1254	const auto *SA = cast<MinVectorWidthAttr>(A);
		1255	Record.push_back(SA->isInherited());
		1256	Record.push_back(A->isImplicit());
		1257	Record.push_back(A->isPackExpansion());
		1258	Record.push_back(SA->getVectorWidth());
		1259	break;
		1260	}
		1261	case attr::Mips16: {
		1262	const auto *SA = cast<Mips16Attr>(A);
		1263	Record.push_back(SA->isInherited());
		1264	Record.push_back(A->isImplicit());
		1265	Record.push_back(A->isPackExpansion());
		1266	break;
		1267	}
		1268	case attr::MipsInterrupt: {
		1269	const auto *SA = cast<MipsInterruptAttr>(A);
		1270	Record.push_back(SA->isInherited());
		1271	Record.push_back(A->isImplicit());
		1272	Record.push_back(A->isPackExpansion());
		1273	Record.push_back(SA->getInterrupt());
		1274	break;
		1275	}
		1276	case attr::MipsLongCall: {
		1277	const auto *SA = cast<MipsLongCallAttr>(A);
		1278	Record.push_back(SA->isInherited());
		1279	Record.push_back(A->isImplicit());
		1280	Record.push_back(A->isPackExpansion());
		1281	break;
		1282	}
		1283	case attr::MipsShortCall: {
		1284	const auto *SA = cast<MipsShortCallAttr>(A);
		1285	Record.push_back(SA->isInherited());
		1286	Record.push_back(A->isImplicit());
		1287	Record.push_back(A->isPackExpansion());
		1288	break;
		1289	}
		1290	case attr::Mode: {
		1291	const auto *SA = cast<ModeAttr>(A);
		1292	Record.push_back(A->isImplicit());
		1293	Record.push_back(A->isPackExpansion());
		1294	Record.AddIdentifierRef(SA->getMode());
		1295	break;
		1296	}
		1297	case attr::MustTail: {
		1298	Record.push_back(A->isImplicit());
		1299	Record.push_back(A->isPackExpansion());
		1300	break;
		1301	}
		1302	case attr::NSConsumed: {
		1303	const auto *SA = cast<NSConsumedAttr>(A);
		1304	Record.push_back(SA->isInherited());
		1305	Record.push_back(A->isImplicit());
		1306	Record.push_back(A->isPackExpansion());
		1307	break;
		1308	}
		1309	case attr::NSConsumesSelf: {
		1310	const auto *SA = cast<NSConsumesSelfAttr>(A);
		1311	Record.push_back(SA->isInherited());
		1312	Record.push_back(A->isImplicit());
		1313	Record.push_back(A->isPackExpansion());
		1314	break;
		1315	}
		1316	case attr::NSErrorDomain: {
		1317	const auto *SA = cast<NSErrorDomainAttr>(A);
		1318	Record.push_back(SA->isInherited());
		1319	Record.push_back(A->isImplicit());
		1320	Record.push_back(A->isPackExpansion());
		1321	Record.AddDeclRef(SA->getErrorDomain());
		1322	break;
		1323	}
		1324	case attr::NSReturnsAutoreleased: {
		1325	const auto *SA = cast<NSReturnsAutoreleasedAttr>(A);
		1326	Record.push_back(SA->isInherited());
		1327	Record.push_back(A->isImplicit());
		1328	Record.push_back(A->isPackExpansion());
		1329	break;
		1330	}
		1331	case attr::NSReturnsNotRetained: {
		1332	const auto *SA = cast<NSReturnsNotRetainedAttr>(A);
		1333	Record.push_back(SA->isInherited());
		1334	Record.push_back(A->isImplicit());
		1335	Record.push_back(A->isPackExpansion());
		1336	break;
		1337	}
		1338	case attr::NSReturnsRetained: {
		1339	const auto *SA = cast<NSReturnsRetainedAttr>(A);
		1340	Record.push_back(SA->isInherited());
		1341	Record.push_back(A->isImplicit());
		1342	Record.push_back(A->isPackExpansion());
		1343	break;
		1344	}
		1345	case attr::Naked: {
		1346	const auto *SA = cast<NakedAttr>(A);
		1347	Record.push_back(SA->isInherited());
		1348	Record.push_back(A->isImplicit());
		1349	Record.push_back(A->isPackExpansion());
		1350	break;
		1351	}
		1352	case attr::NoAlias: {
		1353	const auto *SA = cast<NoAliasAttr>(A);
		1354	Record.push_back(SA->isInherited());
		1355	Record.push_back(A->isImplicit());
		1356	Record.push_back(A->isPackExpansion());
		1357	break;
		1358	}
		1359	case attr::NoBuiltin: {
		1360	const auto *SA = cast<NoBuiltinAttr>(A);
		1361	Record.push_back(A->isImplicit());
		1362	Record.push_back(A->isPackExpansion());
		1363	Record.push_back(SA->builtinNames_size());
		1364	for (auto &Val : SA->builtinNames())
		1365	Record.AddString(Val);
		1366	break;
		1367	}
		1368	case attr::NoCommon: {
		1369	const auto *SA = cast<NoCommonAttr>(A);
		1370	Record.push_back(SA->isInherited());
		1371	Record.push_back(A->isImplicit());
		1372	Record.push_back(A->isPackExpansion());
		1373	break;
		1374	}
		1375	case attr::NoDebug: {
		1376	const auto *SA = cast<NoDebugAttr>(A);
		1377	Record.push_back(SA->isInherited());
		1378	Record.push_back(A->isImplicit());
		1379	Record.push_back(A->isPackExpansion());
		1380	break;
		1381	}
		1382	case attr::NoDeref: {
		1383	Record.push_back(A->isImplicit());
		1384	Record.push_back(A->isPackExpansion());
		1385	break;
		1386	}
		1387	case attr::NoDestroy: {
		1388	const auto *SA = cast<NoDestroyAttr>(A);
		1389	Record.push_back(SA->isInherited());
		1390	Record.push_back(A->isImplicit());
		1391	Record.push_back(A->isPackExpansion());
		1392	break;
		1393	}
		1394	case attr::NoDuplicate: {
		1395	const auto *SA = cast<NoDuplicateAttr>(A);
		1396	Record.push_back(SA->isInherited());
		1397	Record.push_back(A->isImplicit());
		1398	Record.push_back(A->isPackExpansion());
		1399	break;
		1400	}
		1401	case attr::NoEscape: {
		1402	Record.push_back(A->isImplicit());
		1403	Record.push_back(A->isPackExpansion());
		1404	break;
		1405	}
		1406	case attr::NoInline: {
		1407	const auto *SA = cast<NoInlineAttr>(A);
		1408	Record.push_back(SA->isInherited());
		1409	Record.push_back(A->isImplicit());
		1410	Record.push_back(A->isPackExpansion());
		1411	break;
		1412	}
		1413	case attr::NoInstrumentFunction: {
		1414	const auto *SA = cast<NoInstrumentFunctionAttr>(A);
		1415	Record.push_back(SA->isInherited());
		1416	Record.push_back(A->isImplicit());
		1417	Record.push_back(A->isPackExpansion());
		1418	break;
		1419	}
		1420	case attr::NoMerge: {
		1421	const auto *SA = cast<NoMergeAttr>(A);
		1422	Record.push_back(SA->isInherited());
		1423	Record.push_back(A->isImplicit());
		1424	Record.push_back(A->isPackExpansion());
		1425	break;
		1426	}
		1427	case attr::NoMicroMips: {
		1428	const auto *SA = cast<NoMicroMipsAttr>(A);
		1429	Record.push_back(SA->isInherited());
		1430	Record.push_back(A->isImplicit());
		1431	Record.push_back(A->isPackExpansion());
		1432	break;
		1433	}
		1434	case attr::NoMips16: {
		1435	const auto *SA = cast<NoMips16Attr>(A);
		1436	Record.push_back(SA->isInherited());
		1437	Record.push_back(A->isImplicit());
		1438	Record.push_back(A->isPackExpansion());
		1439	break;
		1440	}
		1441	case attr::NoProfileFunction: {
		1442	const auto *SA = cast<NoProfileFunctionAttr>(A);
		1443	Record.push_back(SA->isInherited());
		1444	Record.push_back(A->isImplicit());
		1445	Record.push_back(A->isPackExpansion());
		1446	break;
		1447	}
		1448	case attr::NoRandomizeLayout: {
		1449	const auto *SA = cast<NoRandomizeLayoutAttr>(A);
		1450	Record.push_back(SA->isInherited());
		1451	Record.push_back(A->isImplicit());
		1452	Record.push_back(A->isPackExpansion());
		1453	break;
		1454	}
		1455	case attr::NoReturn: {
		1456	const auto *SA = cast<NoReturnAttr>(A);
		1457	Record.push_back(SA->isInherited());
		1458	Record.push_back(A->isImplicit());
		1459	Record.push_back(A->isPackExpansion());
		1460	break;
		1461	}
		1462	case attr::NoSanitize: {
		1463	const auto *SA = cast<NoSanitizeAttr>(A);
		1464	Record.push_back(SA->isInherited());
		1465	Record.push_back(A->isImplicit());
		1466	Record.push_back(A->isPackExpansion());
		1467	Record.push_back(SA->sanitizers_size());
		1468	for (auto &Val : SA->sanitizers())
		1469	Record.AddString(Val);
		1470	break;
		1471	}
		1472	case attr::NoSpeculativeLoadHardening: {
		1473	const auto *SA = cast<NoSpeculativeLoadHardeningAttr>(A);
		1474	Record.push_back(SA->isInherited());
		1475	Record.push_back(A->isImplicit());
		1476	Record.push_back(A->isPackExpansion());
		1477	break;
		1478	}
		1479	case attr::NoSplitStack: {
		1480	const auto *SA = cast<NoSplitStackAttr>(A);
		1481	Record.push_back(SA->isInherited());
		1482	Record.push_back(A->isImplicit());
		1483	Record.push_back(A->isPackExpansion());
		1484	break;
		1485	}
		1486	case attr::NoStackProtector: {
		1487	const auto *SA = cast<NoStackProtectorAttr>(A);
		1488	Record.push_back(SA->isInherited());
		1489	Record.push_back(A->isImplicit());
		1490	Record.push_back(A->isPackExpansion());
		1491	break;
		1492	}
		1493	case attr::NoThreadSafetyAnalysis: {
		1494	const auto *SA = cast<NoThreadSafetyAnalysisAttr>(A);
		1495	Record.push_back(SA->isInherited());
		1496	Record.push_back(A->isImplicit());
		1497	Record.push_back(A->isPackExpansion());
		1498	break;
		1499	}
		1500	case attr::NoThrow: {
		1501	const auto *SA = cast<NoThrowAttr>(A);
		1502	Record.push_back(SA->isInherited());
		1503	Record.push_back(A->isImplicit());
		1504	Record.push_back(A->isPackExpansion());
		1505	break;
		1506	}
		1507	case attr::NoUniqueAddress: {
		1508	const auto *SA = cast<NoUniqueAddressAttr>(A);
		1509	Record.push_back(SA->isInherited());
		1510	Record.push_back(A->isImplicit());
		1511	Record.push_back(A->isPackExpansion());
		1512	break;
		1513	}
		1514	case attr::NoUwtable: {
		1515	const auto *SA = cast<NoUwtableAttr>(A);
		1516	Record.push_back(SA->isInherited());
		1517	Record.push_back(A->isImplicit());
		1518	Record.push_back(A->isPackExpansion());
		1519	break;
		1520	}
		1521	case attr::NonNull: {
		1522	const auto *SA = cast<NonNullAttr>(A);
		1523	Record.push_back(SA->isInherited());
		1524	Record.push_back(A->isImplicit());
		1525	Record.push_back(A->isPackExpansion());
		1526	Record.push_back(SA->args_size());
		1527	for (auto &Val : SA->args())
		1528	Record.push_back(Val.serialize());
		1529	break;
		1530	}
		1531	case attr::NotTailCalled: {
		1532	const auto *SA = cast<NotTailCalledAttr>(A);
		1533	Record.push_back(SA->isInherited());
		1534	Record.push_back(A->isImplicit());
		1535	Record.push_back(A->isPackExpansion());
		1536	break;
		1537	}
		1538	case attr::OMPAllocateDecl: {
		1539	const auto *SA = cast<OMPAllocateDeclAttr>(A);
		1540	Record.push_back(SA->isInherited());
		1541	Record.push_back(A->isImplicit());
		1542	Record.push_back(A->isPackExpansion());
		1543	Record.push_back(SA->getAllocatorType());
		1544	Record.AddStmt(SA->getAllocator());
		1545	Record.AddStmt(SA->getAlignment());
		1546	break;
		1547	}
		1548	case attr::OMPCaptureKind: {
		1549	const auto *SA = cast<OMPCaptureKindAttr>(A);
		1550	Record.push_back(A->isImplicit());
		1551	Record.push_back(A->isPackExpansion());
		1552	Record.push_back(SA->getCaptureKindVal());
		1553	break;
		1554	}
		1555	case attr::OMPCaptureNoInit: {
		1556	const auto *SA = cast<OMPCaptureNoInitAttr>(A);
		1557	Record.push_back(SA->isInherited());
		1558	Record.push_back(A->isImplicit());
		1559	Record.push_back(A->isPackExpansion());
		1560	break;
		1561	}
		1562	case attr::OMPDeclareSimdDecl: {
		1563	const auto *SA = cast<OMPDeclareSimdDeclAttr>(A);
		1564	Record.push_back(A->isImplicit());
		1565	Record.push_back(A->isPackExpansion());
		1566	Record.push_back(SA->getBranchState());
		1567	Record.AddStmt(SA->getSimdlen());
		1568	Record.push_back(SA->uniforms_size());
		1569	for (auto &Val : SA->uniforms())
		1570	Record.AddStmt(Val);
		1571	Record.push_back(SA->aligneds_size());
		1572	for (auto &Val : SA->aligneds())
		1573	Record.AddStmt(Val);
		1574	Record.push_back(SA->alignments_size());
		1575	for (auto &Val : SA->alignments())
		1576	Record.AddStmt(Val);
		1577	Record.push_back(SA->linears_size());
		1578	for (auto &Val : SA->linears())
		1579	Record.AddStmt(Val);
		1580	Record.push_back(SA->modifiers_size());
		1581	for (auto &Val : SA->modifiers())
		1582	Record.push_back(Val);
		1583	Record.push_back(SA->steps_size());
		1584	for (auto &Val : SA->steps())
		1585	Record.AddStmt(Val);
		1586	break;
		1587	}
		1588	case attr::OMPDeclareTargetDecl: {
		1589	const auto *SA = cast<OMPDeclareTargetDeclAttr>(A);
		1590	Record.push_back(SA->isInherited());
		1591	Record.push_back(A->isImplicit());
		1592	Record.push_back(A->isPackExpansion());
		1593	Record.push_back(SA->getMapType());
		1594	Record.push_back(SA->getDevType());
		1595	Record.AddStmt(SA->getIndirectExpr());
		1596	Record.push_back(SA->getIndirect());
		1597	Record.push_back(SA->getLevel());
		1598	break;
		1599	}
		1600	case attr::OMPDeclareVariant: {
		1601	const auto *SA = cast<OMPDeclareVariantAttr>(A);
		1602	Record.push_back(SA->isInherited());
		1603	Record.push_back(A->isImplicit());
		1604	Record.push_back(A->isPackExpansion());
		1605	Record.AddStmt(SA->getVariantFuncRef());
		1606	Record.writeOMPTraitInfo(SA->getTraitInfos());
		1607	Record.push_back(SA->adjustArgsNothing_size());
		1608	for (auto &Val : SA->adjustArgsNothing())
		1609	Record.AddStmt(Val);
		1610	Record.push_back(SA->adjustArgsNeedDevicePtr_size());
		1611	for (auto &Val : SA->adjustArgsNeedDevicePtr())
		1612	Record.AddStmt(Val);
		1613	Record.push_back(SA->appendArgs_size());
		1614	for (OMPDeclareVariantAttr::appendArgs_iterator I = SA->appendArgs_begin(), E = SA->appendArgs_end(); I != E; ++I) {
		1615	Record.writeBool(I->IsTarget);
		1616	Record.writeBool(I->IsTargetSync);
		1617	}
		1618	break;
		1619	}
		1620	case attr::OMPReferencedVar: {
		1621	const auto *SA = cast<OMPReferencedVarAttr>(A);
		1622	Record.push_back(A->isImplicit());
		1623	Record.push_back(A->isPackExpansion());
		1624	Record.AddStmt(SA->getRef());
		1625	break;
		1626	}
		1627	case attr::OMPThreadPrivateDecl: {
		1628	const auto *SA = cast<OMPThreadPrivateDeclAttr>(A);
		1629	Record.push_back(SA->isInherited());
		1630	Record.push_back(A->isImplicit());
		1631	Record.push_back(A->isPackExpansion());
		1632	break;
		1633	}
		1634	case attr::OSConsumed: {
		1635	const auto *SA = cast<OSConsumedAttr>(A);
		1636	Record.push_back(SA->isInherited());
		1637	Record.push_back(A->isImplicit());
		1638	Record.push_back(A->isPackExpansion());
		1639	break;
		1640	}
		1641	case attr::OSConsumesThis: {
		1642	const auto *SA = cast<OSConsumesThisAttr>(A);
		1643	Record.push_back(SA->isInherited());
		1644	Record.push_back(A->isImplicit());
		1645	Record.push_back(A->isPackExpansion());
		1646	break;
		1647	}
		1648	case attr::OSReturnsNotRetained: {
		1649	const auto *SA = cast<OSReturnsNotRetainedAttr>(A);
		1650	Record.push_back(SA->isInherited());
		1651	Record.push_back(A->isImplicit());
		1652	Record.push_back(A->isPackExpansion());
		1653	break;
		1654	}
		1655	case attr::OSReturnsRetained: {
		1656	const auto *SA = cast<OSReturnsRetainedAttr>(A);
		1657	Record.push_back(SA->isInherited());
		1658	Record.push_back(A->isImplicit());
		1659	Record.push_back(A->isPackExpansion());
		1660	break;
		1661	}
		1662	case attr::OSReturnsRetainedOnNonZero: {
		1663	const auto *SA = cast<OSReturnsRetainedOnNonZeroAttr>(A);
		1664	Record.push_back(SA->isInherited());
		1665	Record.push_back(A->isImplicit());
		1666	Record.push_back(A->isPackExpansion());
		1667	break;
		1668	}
		1669	case attr::OSReturnsRetainedOnZero: {
		1670	const auto *SA = cast<OSReturnsRetainedOnZeroAttr>(A);
		1671	Record.push_back(SA->isInherited());
		1672	Record.push_back(A->isImplicit());
		1673	Record.push_back(A->isPackExpansion());
		1674	break;
		1675	}
		1676	case attr::ObjCBoxable: {
		1677	Record.push_back(A->isImplicit());
		1678	Record.push_back(A->isPackExpansion());
		1679	break;
		1680	}
		1681	case attr::ObjCBridge: {
		1682	const auto *SA = cast<ObjCBridgeAttr>(A);
		1683	Record.push_back(SA->isInherited());
		1684	Record.push_back(A->isImplicit());
		1685	Record.push_back(A->isPackExpansion());
		1686	Record.AddIdentifierRef(SA->getBridgedType());
		1687	break;
		1688	}
		1689	case attr::ObjCBridgeMutable: {
		1690	const auto *SA = cast<ObjCBridgeMutableAttr>(A);
		1691	Record.push_back(SA->isInherited());
		1692	Record.push_back(A->isImplicit());
		1693	Record.push_back(A->isPackExpansion());
		1694	Record.AddIdentifierRef(SA->getBridgedType());
		1695	break;
		1696	}
		1697	case attr::ObjCBridgeRelated: {
		1698	const auto *SA = cast<ObjCBridgeRelatedAttr>(A);
		1699	Record.push_back(SA->isInherited());
		1700	Record.push_back(A->isImplicit());
		1701	Record.push_back(A->isPackExpansion());
		1702	Record.AddIdentifierRef(SA->getRelatedClass());
		1703	Record.AddIdentifierRef(SA->getClassMethod());
		1704	Record.AddIdentifierRef(SA->getInstanceMethod());
		1705	break;
		1706	}
		1707	case attr::ObjCClassStub: {
		1708	Record.push_back(A->isImplicit());
		1709	Record.push_back(A->isPackExpansion());
		1710	break;
		1711	}
		1712	case attr::ObjCDesignatedInitializer: {
		1713	Record.push_back(A->isImplicit());
		1714	Record.push_back(A->isPackExpansion());
		1715	break;
		1716	}
		1717	case attr::ObjCDirect: {
		1718	Record.push_back(A->isImplicit());
		1719	Record.push_back(A->isPackExpansion());
		1720	break;
		1721	}
		1722	case attr::ObjCDirectMembers: {
		1723	Record.push_back(A->isImplicit());
		1724	Record.push_back(A->isPackExpansion());
		1725	break;
		1726	}
		1727	case attr::ObjCException: {
		1728	const auto *SA = cast<ObjCExceptionAttr>(A);
		1729	Record.push_back(SA->isInherited());
		1730	Record.push_back(A->isImplicit());
		1731	Record.push_back(A->isPackExpansion());
		1732	break;
		1733	}
		1734	case attr::ObjCExplicitProtocolImpl: {
		1735	const auto *SA = cast<ObjCExplicitProtocolImplAttr>(A);
		1736	Record.push_back(SA->isInherited());
		1737	Record.push_back(A->isImplicit());
		1738	Record.push_back(A->isPackExpansion());
		1739	break;
		1740	}
		1741	case attr::ObjCExternallyRetained: {
		1742	const auto *SA = cast<ObjCExternallyRetainedAttr>(A);
		1743	Record.push_back(SA->isInherited());
		1744	Record.push_back(A->isImplicit());
		1745	Record.push_back(A->isPackExpansion());
		1746	break;
		1747	}
		1748	case attr::ObjCGC: {
		1749	const auto *SA = cast<ObjCGCAttr>(A);
		1750	Record.push_back(A->isImplicit());
		1751	Record.push_back(A->isPackExpansion());
		1752	Record.AddIdentifierRef(SA->getKind());
		1753	break;
		1754	}
		1755	case attr::ObjCIndependentClass: {
		1756	const auto *SA = cast<ObjCIndependentClassAttr>(A);
		1757	Record.push_back(SA->isInherited());
		1758	Record.push_back(A->isImplicit());
		1759	Record.push_back(A->isPackExpansion());
		1760	break;
		1761	}
		1762	case attr::ObjCInertUnsafeUnretained: {
		1763	Record.push_back(A->isImplicit());
		1764	Record.push_back(A->isPackExpansion());
		1765	break;
		1766	}
		1767	case attr::ObjCKindOf: {
		1768	Record.push_back(A->isImplicit());
		1769	Record.push_back(A->isPackExpansion());
		1770	break;
		1771	}
		1772	case attr::ObjCMethodFamily: {
		1773	const auto *SA = cast<ObjCMethodFamilyAttr>(A);
		1774	Record.push_back(SA->isInherited());
		1775	Record.push_back(A->isImplicit());
		1776	Record.push_back(A->isPackExpansion());
		1777	Record.push_back(SA->getFamily());
		1778	break;
		1779	}
		1780	case attr::ObjCNSObject: {
		1781	const auto *SA = cast<ObjCNSObjectAttr>(A);
		1782	Record.push_back(SA->isInherited());
		1783	Record.push_back(A->isImplicit());
		1784	Record.push_back(A->isPackExpansion());
		1785	break;
		1786	}
		1787	case attr::ObjCNonLazyClass: {
		1788	Record.push_back(A->isImplicit());
		1789	Record.push_back(A->isPackExpansion());
		1790	break;
		1791	}
		1792	case attr::ObjCNonRuntimeProtocol: {
		1793	Record.push_back(A->isImplicit());
		1794	Record.push_back(A->isPackExpansion());
		1795	break;
		1796	}
		1797	case attr::ObjCOwnership: {
		1798	const auto *SA = cast<ObjCOwnershipAttr>(A);
		1799	Record.push_back(SA->isInherited());
		1800	Record.push_back(A->isImplicit());
		1801	Record.push_back(A->isPackExpansion());
		1802	Record.AddIdentifierRef(SA->getKind());
		1803	break;
		1804	}
		1805	case attr::ObjCPreciseLifetime: {
		1806	const auto *SA = cast<ObjCPreciseLifetimeAttr>(A);
		1807	Record.push_back(SA->isInherited());
		1808	Record.push_back(A->isImplicit());
		1809	Record.push_back(A->isPackExpansion());
		1810	break;
		1811	}
		1812	case attr::ObjCRequiresPropertyDefs: {
		1813	const auto *SA = cast<ObjCRequiresPropertyDefsAttr>(A);
		1814	Record.push_back(SA->isInherited());
		1815	Record.push_back(A->isImplicit());
		1816	Record.push_back(A->isPackExpansion());
		1817	break;
		1818	}
		1819	case attr::ObjCRequiresSuper: {
		1820	const auto *SA = cast<ObjCRequiresSuperAttr>(A);
		1821	Record.push_back(SA->isInherited());
		1822	Record.push_back(A->isImplicit());
		1823	Record.push_back(A->isPackExpansion());
		1824	break;
		1825	}
		1826	case attr::ObjCReturnsInnerPointer: {
		1827	const auto *SA = cast<ObjCReturnsInnerPointerAttr>(A);
		1828	Record.push_back(SA->isInherited());
		1829	Record.push_back(A->isImplicit());
		1830	Record.push_back(A->isPackExpansion());
		1831	break;
		1832	}
		1833	case attr::ObjCRootClass: {
		1834	const auto *SA = cast<ObjCRootClassAttr>(A);
		1835	Record.push_back(SA->isInherited());
		1836	Record.push_back(A->isImplicit());
		1837	Record.push_back(A->isPackExpansion());
		1838	break;
		1839	}
		1840	case attr::ObjCRuntimeName: {
		1841	const auto *SA = cast<ObjCRuntimeNameAttr>(A);
		1842	Record.push_back(A->isImplicit());
		1843	Record.push_back(A->isPackExpansion());
		1844	Record.AddString(SA->getMetadataName());
		1845	break;
		1846	}
		1847	case attr::ObjCRuntimeVisible: {
		1848	Record.push_back(A->isImplicit());
		1849	Record.push_back(A->isPackExpansion());
		1850	break;
		1851	}
		1852	case attr::ObjCSubclassingRestricted: {
		1853	const auto *SA = cast<ObjCSubclassingRestrictedAttr>(A);
		1854	Record.push_back(SA->isInherited());
		1855	Record.push_back(A->isImplicit());
		1856	Record.push_back(A->isPackExpansion());
		1857	break;
		1858	}
		1859	case attr::OpenCLAccess: {
		1860	Record.push_back(A->isImplicit());
		1861	Record.push_back(A->isPackExpansion());
		1862	break;
		1863	}
		1864	case attr::OpenCLConstantAddressSpace: {
		1865	Record.push_back(A->isImplicit());
		1866	Record.push_back(A->isPackExpansion());
		1867	break;
		1868	}
		1869	case attr::OpenCLGenericAddressSpace: {
		1870	Record.push_back(A->isImplicit());
		1871	Record.push_back(A->isPackExpansion());
		1872	break;
		1873	}
		1874	case attr::OpenCLGlobalAddressSpace: {
		1875	Record.push_back(A->isImplicit());
		1876	Record.push_back(A->isPackExpansion());
		1877	break;
		1878	}
		1879	case attr::OpenCLGlobalDeviceAddressSpace: {
		1880	Record.push_back(A->isImplicit());
		1881	Record.push_back(A->isPackExpansion());
		1882	break;
		1883	}
		1884	case attr::OpenCLGlobalHostAddressSpace: {
		1885	Record.push_back(A->isImplicit());
		1886	Record.push_back(A->isPackExpansion());
		1887	break;
		1888	}
		1889	case attr::OpenCLIntelReqdSubGroupSize: {
		1890	const auto *SA = cast<OpenCLIntelReqdSubGroupSizeAttr>(A);
		1891	Record.push_back(SA->isInherited());
		1892	Record.push_back(A->isImplicit());
		1893	Record.push_back(A->isPackExpansion());
		1894	Record.push_back(SA->getSubGroupSize());
		1895	break;
		1896	}
		1897	case attr::OpenCLKernel: {
		1898	const auto *SA = cast<OpenCLKernelAttr>(A);
		1899	Record.push_back(SA->isInherited());
		1900	Record.push_back(A->isImplicit());
		1901	Record.push_back(A->isPackExpansion());
		1902	break;
		1903	}
		1904	case attr::OpenCLLocalAddressSpace: {
		1905	Record.push_back(A->isImplicit());
		1906	Record.push_back(A->isPackExpansion());
		1907	break;
		1908	}
		1909	case attr::OpenCLPrivateAddressSpace: {
		1910	Record.push_back(A->isImplicit());
		1911	Record.push_back(A->isPackExpansion());
		1912	break;
		1913	}
		1914	case attr::OpenCLUnrollHint: {
		1915	const auto *SA = cast<OpenCLUnrollHintAttr>(A);
		1916	Record.push_back(A->isImplicit());
		1917	Record.push_back(A->isPackExpansion());
		1918	Record.push_back(SA->getUnrollHint());
		1919	break;
		1920	}
		1921	case attr::OptimizeNone: {
		1922	const auto *SA = cast<OptimizeNoneAttr>(A);
		1923	Record.push_back(SA->isInherited());
		1924	Record.push_back(A->isImplicit());
		1925	Record.push_back(A->isPackExpansion());
		1926	break;
		1927	}
		1928	case attr::Overloadable: {
		1929	Record.push_back(A->isImplicit());
		1930	Record.push_back(A->isPackExpansion());
		1931	break;
		1932	}
		1933	case attr::Override: {
		1934	const auto *SA = cast<OverrideAttr>(A);
		1935	Record.push_back(SA->isInherited());
		1936	Record.push_back(A->isImplicit());
		1937	Record.push_back(A->isPackExpansion());
		1938	break;
		1939	}
		1940	case attr::Owner: {
		1941	const auto *SA = cast<OwnerAttr>(A);
		1942	Record.push_back(SA->isInherited());
		1943	Record.push_back(A->isImplicit());
		1944	Record.push_back(A->isPackExpansion());
		1945	Record.AddTypeSourceInfo(SA->getDerefTypeLoc());
		1946	break;
		1947	}
		1948	case attr::Ownership: {
		1949	const auto *SA = cast<OwnershipAttr>(A);
		1950	Record.push_back(SA->isInherited());
		1951	Record.push_back(A->isImplicit());
		1952	Record.push_back(A->isPackExpansion());
		1953	Record.AddIdentifierRef(SA->getModule());
		1954	Record.push_back(SA->args_size());
		1955	for (auto &Val : SA->args())
		1956	Record.push_back(Val.serialize());
		1957	break;
		1958	}
		1959	case attr::Packed: {
		1960	const auto *SA = cast<PackedAttr>(A);
		1961	Record.push_back(SA->isInherited());
		1962	Record.push_back(A->isImplicit());
		1963	Record.push_back(A->isPackExpansion());
		1964	break;
		1965	}
		1966	case attr::ParamTypestate: {
		1967	const auto *SA = cast<ParamTypestateAttr>(A);
		1968	Record.push_back(SA->isInherited());
		1969	Record.push_back(A->isImplicit());
		1970	Record.push_back(A->isPackExpansion());
		1971	Record.push_back(SA->getParamState());
		1972	break;
		1973	}
		1974	case attr::Pascal: {
		1975	const auto *SA = cast<PascalAttr>(A);
		1976	Record.push_back(SA->isInherited());
		1977	Record.push_back(A->isImplicit());
		1978	Record.push_back(A->isPackExpansion());
		1979	break;
		1980	}
		1981	case attr::PassObjectSize: {
		1982	const auto *SA = cast<PassObjectSizeAttr>(A);
		1983	Record.push_back(SA->isInherited());
		1984	Record.push_back(A->isImplicit());
		1985	Record.push_back(A->isPackExpansion());
		1986	Record.push_back(SA->getType());
		1987	break;
		1988	}
		1989	case attr::PatchableFunctionEntry: {
		1990	const auto *SA = cast<PatchableFunctionEntryAttr>(A);
		1991	Record.push_back(SA->isInherited());
		1992	Record.push_back(A->isImplicit());
		1993	Record.push_back(A->isPackExpansion());
		1994	Record.push_back(SA->getCount());
		1995	Record.push_back(SA->getOffset());
		1996	break;
		1997	}
		1998	case attr::Pcs: {
		1999	const auto *SA = cast<PcsAttr>(A);
		2000	Record.push_back(SA->isInherited());
		2001	Record.push_back(A->isImplicit());
		2002	Record.push_back(A->isPackExpansion());
		2003	Record.push_back(SA->getPCS());
		2004	break;
		2005	}
		2006	case attr::Pointer: {
		2007	const auto *SA = cast<PointerAttr>(A);
		2008	Record.push_back(SA->isInherited());
		2009	Record.push_back(A->isImplicit());
		2010	Record.push_back(A->isPackExpansion());
		2011	Record.AddTypeSourceInfo(SA->getDerefTypeLoc());
		2012	break;
		2013	}
		2014	case attr::PragmaClangBSSSection: {
		2015	const auto *SA = cast<PragmaClangBSSSectionAttr>(A);
		2016	Record.push_back(SA->isInherited());
		2017	Record.push_back(A->isImplicit());
		2018	Record.push_back(A->isPackExpansion());
		2019	Record.AddString(SA->getName());
		2020	break;
		2021	}
		2022	case attr::PragmaClangDataSection: {
		2023	const auto *SA = cast<PragmaClangDataSectionAttr>(A);
		2024	Record.push_back(SA->isInherited());
		2025	Record.push_back(A->isImplicit());
		2026	Record.push_back(A->isPackExpansion());
		2027	Record.AddString(SA->getName());
		2028	break;
		2029	}
		2030	case attr::PragmaClangRelroSection: {
		2031	const auto *SA = cast<PragmaClangRelroSectionAttr>(A);
		2032	Record.push_back(SA->isInherited());
		2033	Record.push_back(A->isImplicit());
		2034	Record.push_back(A->isPackExpansion());
		2035	Record.AddString(SA->getName());
		2036	break;
		2037	}
		2038	case attr::PragmaClangRodataSection: {
		2039	const auto *SA = cast<PragmaClangRodataSectionAttr>(A);
		2040	Record.push_back(SA->isInherited());
		2041	Record.push_back(A->isImplicit());
		2042	Record.push_back(A->isPackExpansion());
		2043	Record.AddString(SA->getName());
		2044	break;
		2045	}
		2046	case attr::PragmaClangTextSection: {
		2047	const auto *SA = cast<PragmaClangTextSectionAttr>(A);
		2048	Record.push_back(SA->isInherited());
		2049	Record.push_back(A->isImplicit());
		2050	Record.push_back(A->isPackExpansion());
		2051	Record.AddString(SA->getName());
		2052	break;
		2053	}
		2054	case attr::PreferredName: {
		2055	const auto *SA = cast<PreferredNameAttr>(A);
		2056	Record.push_back(SA->isInherited());
		2057	Record.push_back(A->isImplicit());
		2058	Record.push_back(A->isPackExpansion());
		2059	Record.AddTypeSourceInfo(SA->getTypedefTypeLoc());
		2060	break;
		2061	}
		2062	case attr::PreserveAll: {
		2063	const auto *SA = cast<PreserveAllAttr>(A);
		2064	Record.push_back(SA->isInherited());
		2065	Record.push_back(A->isImplicit());
		2066	Record.push_back(A->isPackExpansion());
		2067	break;
		2068	}
		2069	case attr::PreserveMost: {
		2070	const auto *SA = cast<PreserveMostAttr>(A);
		2071	Record.push_back(SA->isInherited());
		2072	Record.push_back(A->isImplicit());
		2073	Record.push_back(A->isPackExpansion());
		2074	break;
		2075	}
		2076	case attr::PtGuardedBy: {
		2077	const auto *SA = cast<PtGuardedByAttr>(A);
		2078	Record.push_back(SA->isInherited());
		2079	Record.push_back(A->isImplicit());
		2080	Record.push_back(A->isPackExpansion());
		2081	Record.AddStmt(SA->getArg());
		2082	break;
		2083	}
		2084	case attr::PtGuardedVar: {
		2085	const auto *SA = cast<PtGuardedVarAttr>(A);
		2086	Record.push_back(SA->isInherited());
		2087	Record.push_back(A->isImplicit());
		2088	Record.push_back(A->isPackExpansion());
		2089	break;
		2090	}
		2091	case attr::Ptr32: {
		2092	Record.push_back(A->isImplicit());
		2093	Record.push_back(A->isPackExpansion());
		2094	break;
		2095	}
		2096	case attr::Ptr64: {
		2097	Record.push_back(A->isImplicit());
		2098	Record.push_back(A->isPackExpansion());
		2099	break;
		2100	}
		2101	case attr::Pure: {
		2102	const auto *SA = cast<PureAttr>(A);
		2103	Record.push_back(SA->isInherited());
		2104	Record.push_back(A->isImplicit());
		2105	Record.push_back(A->isPackExpansion());
		2106	break;
		2107	}
		2108	case attr::RISCVInterrupt: {
		2109	const auto *SA = cast<RISCVInterruptAttr>(A);
		2110	Record.push_back(SA->isInherited());
		2111	Record.push_back(A->isImplicit());
		2112	Record.push_back(A->isPackExpansion());
		2113	Record.push_back(SA->getInterrupt());
		2114	break;
		2115	}
		2116	case attr::RandomizeLayout: {
		2117	const auto *SA = cast<RandomizeLayoutAttr>(A);
		2118	Record.push_back(SA->isInherited());
		2119	Record.push_back(A->isImplicit());
		2120	Record.push_back(A->isPackExpansion());
		2121	break;
		2122	}
		2123	case attr::ReadOnlyPlacement: {
		2124	const auto *SA = cast<ReadOnlyPlacementAttr>(A);
		2125	Record.push_back(SA->isInherited());
		2126	Record.push_back(A->isImplicit());
		2127	Record.push_back(A->isPackExpansion());
		2128	break;
		2129	}
		2130	case attr::RegCall: {
		2131	const auto *SA = cast<RegCallAttr>(A);
		2132	Record.push_back(SA->isInherited());
		2133	Record.push_back(A->isImplicit());
		2134	Record.push_back(A->isPackExpansion());
		2135	break;
		2136	}
		2137	case attr::Reinitializes: {
		2138	const auto *SA = cast<ReinitializesAttr>(A);
		2139	Record.push_back(SA->isInherited());
		2140	Record.push_back(A->isImplicit());
		2141	Record.push_back(A->isPackExpansion());
		2142	break;
		2143	}
		2144	case attr::ReleaseCapability: {
		2145	const auto *SA = cast<ReleaseCapabilityAttr>(A);
		2146	Record.push_back(SA->isInherited());
		2147	Record.push_back(A->isImplicit());
		2148	Record.push_back(A->isPackExpansion());
		2149	Record.push_back(SA->args_size());
		2150	for (auto &Val : SA->args())
		2151	Record.AddStmt(Val);
		2152	break;
		2153	}
		2154	case attr::ReleaseHandle: {
		2155	const auto *SA = cast<ReleaseHandleAttr>(A);
		2156	Record.push_back(SA->isInherited());
		2157	Record.push_back(A->isImplicit());
		2158	Record.push_back(A->isPackExpansion());
		2159	Record.AddString(SA->getHandleType());
		2160	break;
		2161	}
		2162	case attr::RenderScriptKernel: {
		2163	Record.push_back(A->isImplicit());
		2164	Record.push_back(A->isPackExpansion());
		2165	break;
		2166	}
		2167	case attr::ReqdWorkGroupSize: {
		2168	const auto *SA = cast<ReqdWorkGroupSizeAttr>(A);
		2169	Record.push_back(SA->isInherited());
		2170	Record.push_back(A->isImplicit());
		2171	Record.push_back(A->isPackExpansion());
		2172	Record.push_back(SA->getXDim());
		2173	Record.push_back(SA->getYDim());
		2174	Record.push_back(SA->getZDim());
		2175	break;
		2176	}
		2177	case attr::RequiresCapability: {
		2178	const auto *SA = cast<RequiresCapabilityAttr>(A);
		2179	Record.push_back(SA->isInherited());
		2180	Record.push_back(A->isImplicit());
		2181	Record.push_back(A->isPackExpansion());
		2182	Record.push_back(SA->args_size());
		2183	for (auto &Val : SA->args())
		2184	Record.AddStmt(Val);
		2185	break;
		2186	}
		2187	case attr::Restrict: {
		2188	const auto *SA = cast<RestrictAttr>(A);
		2189	Record.push_back(SA->isInherited());
		2190	Record.push_back(A->isImplicit());
		2191	Record.push_back(A->isPackExpansion());
		2192	break;
		2193	}
		2194	case attr::Retain: {
		2195	const auto *SA = cast<RetainAttr>(A);
		2196	Record.push_back(SA->isInherited());
		2197	Record.push_back(A->isImplicit());
		2198	Record.push_back(A->isPackExpansion());
		2199	break;
		2200	}
		2201	case attr::ReturnTypestate: {
		2202	const auto *SA = cast<ReturnTypestateAttr>(A);
		2203	Record.push_back(SA->isInherited());
		2204	Record.push_back(A->isImplicit());
		2205	Record.push_back(A->isPackExpansion());
		2206	Record.push_back(SA->getState());
		2207	break;
		2208	}
		2209	case attr::ReturnsNonNull: {
		2210	const auto *SA = cast<ReturnsNonNullAttr>(A);
		2211	Record.push_back(SA->isInherited());
		2212	Record.push_back(A->isImplicit());
		2213	Record.push_back(A->isPackExpansion());
		2214	break;
		2215	}
		2216	case attr::ReturnsTwice: {
		2217	const auto *SA = cast<ReturnsTwiceAttr>(A);
		2218	Record.push_back(SA->isInherited());
		2219	Record.push_back(A->isImplicit());
		2220	Record.push_back(A->isPackExpansion());
		2221	break;
		2222	}
		2223	case attr::SPtr: {
		2224	Record.push_back(A->isImplicit());
		2225	Record.push_back(A->isPackExpansion());
		2226	break;
		2227	}
		2228	case attr::SYCLKernel: {
		2229	const auto *SA = cast<SYCLKernelAttr>(A);
		2230	Record.push_back(SA->isInherited());
		2231	Record.push_back(A->isImplicit());
		2232	Record.push_back(A->isPackExpansion());
		2233	break;
		2234	}
		2235	case attr::SYCLSpecialClass: {
		2236	const auto *SA = cast<SYCLSpecialClassAttr>(A);
		2237	Record.push_back(SA->isInherited());
		2238	Record.push_back(A->isImplicit());
		2239	Record.push_back(A->isPackExpansion());
		2240	break;
		2241	}
		2242	case attr::ScopedLockable: {
		2243	const auto *SA = cast<ScopedLockableAttr>(A);
		2244	Record.push_back(SA->isInherited());
		2245	Record.push_back(A->isImplicit());
		2246	Record.push_back(A->isPackExpansion());
		2247	break;
		2248	}
		2249	case attr::Section: {
		2250	const auto *SA = cast<SectionAttr>(A);
		2251	Record.push_back(SA->isInherited());
		2252	Record.push_back(A->isImplicit());
		2253	Record.push_back(A->isPackExpansion());
		2254	Record.AddString(SA->getName());
		2255	break;
		2256	}
		2257	case attr::SelectAny: {
		2258	const auto *SA = cast<SelectAnyAttr>(A);
		2259	Record.push_back(SA->isInherited());
		2260	Record.push_back(A->isImplicit());
		2261	Record.push_back(A->isPackExpansion());
		2262	break;
		2263	}
		2264	case attr::Sentinel: {
		2265	const auto *SA = cast<SentinelAttr>(A);
		2266	Record.push_back(SA->isInherited());
		2267	Record.push_back(A->isImplicit());
		2268	Record.push_back(A->isPackExpansion());
		2269	Record.push_back(SA->getSentinel());
		2270	Record.push_back(SA->getNullPos());
		2271	break;
		2272	}
		2273	case attr::SetTypestate: {
		2274	const auto *SA = cast<SetTypestateAttr>(A);
		2275	Record.push_back(SA->isInherited());
		2276	Record.push_back(A->isImplicit());
		2277	Record.push_back(A->isPackExpansion());
		2278	Record.push_back(SA->getNewState());
		2279	break;
		2280	}
		2281	case attr::SharedTrylockFunction: {
		2282	const auto *SA = cast<SharedTrylockFunctionAttr>(A);
		2283	Record.push_back(SA->isInherited());
		2284	Record.push_back(A->isImplicit());
		2285	Record.push_back(A->isPackExpansion());
		2286	Record.AddStmt(SA->getSuccessValue());
		2287	Record.push_back(SA->args_size());
		2288	for (auto &Val : SA->args())
		2289	Record.AddStmt(Val);
		2290	break;
		2291	}
		2292	case attr::SpeculativeLoadHardening: {
		2293	const auto *SA = cast<SpeculativeLoadHardeningAttr>(A);
		2294	Record.push_back(SA->isInherited());
		2295	Record.push_back(A->isImplicit());
		2296	Record.push_back(A->isPackExpansion());
		2297	break;
		2298	}
		2299	case attr::StandaloneDebug: {
		2300	const auto *SA = cast<StandaloneDebugAttr>(A);
		2301	Record.push_back(SA->isInherited());
		2302	Record.push_back(A->isImplicit());
		2303	Record.push_back(A->isPackExpansion());
		2304	break;
		2305	}
		2306	case attr::StdCall: {
		2307	const auto *SA = cast<StdCallAttr>(A);
		2308	Record.push_back(SA->isInherited());
		2309	Record.push_back(A->isImplicit());
		2310	Record.push_back(A->isPackExpansion());
		2311	break;
		2312	}
		2313	case attr::StrictFP: {
		2314	const auto *SA = cast<StrictFPAttr>(A);
		2315	Record.push_back(SA->isInherited());
		2316	Record.push_back(A->isImplicit());
		2317	Record.push_back(A->isPackExpansion());
		2318	break;
		2319	}
		2320	case attr::StrictGuardStackCheck: {
		2321	const auto *SA = cast<StrictGuardStackCheckAttr>(A);
		2322	Record.push_back(SA->isInherited());
		2323	Record.push_back(A->isImplicit());
		2324	Record.push_back(A->isPackExpansion());
		2325	break;
		2326	}
		2327	case attr::Suppress: {
		2328	const auto *SA = cast<SuppressAttr>(A);
		2329	Record.push_back(A->isImplicit());
		2330	Record.push_back(A->isPackExpansion());
		2331	Record.push_back(SA->diagnosticIdentifiers_size());
		2332	for (auto &Val : SA->diagnosticIdentifiers())
		2333	Record.AddString(Val);
		2334	break;
		2335	}
		2336	case attr::SwiftAsync: {
		2337	const auto *SA = cast<SwiftAsyncAttr>(A);
		2338	Record.push_back(SA->isInherited());
		2339	Record.push_back(A->isImplicit());
		2340	Record.push_back(A->isPackExpansion());
		2341	Record.push_back(SA->getKind());
		2342	Record.push_back(SA->getCompletionHandlerIndex().serialize());
		2343	break;
		2344	}
		2345	case attr::SwiftAsyncCall: {
		2346	const auto *SA = cast<SwiftAsyncCallAttr>(A);
		2347	Record.push_back(SA->isInherited());
		2348	Record.push_back(A->isImplicit());
		2349	Record.push_back(A->isPackExpansion());
		2350	break;
		2351	}
		2352	case attr::SwiftAsyncContext: {
		2353	const auto *SA = cast<SwiftAsyncContextAttr>(A);
		2354	Record.push_back(SA->isInherited());
		2355	Record.push_back(A->isImplicit());
		2356	Record.push_back(A->isPackExpansion());
		2357	break;
		2358	}
		2359	case attr::SwiftAsyncError: {
		2360	const auto *SA = cast<SwiftAsyncErrorAttr>(A);
		2361	Record.push_back(SA->isInherited());
		2362	Record.push_back(A->isImplicit());
		2363	Record.push_back(A->isPackExpansion());
		2364	Record.push_back(SA->getConvention());
		2365	Record.push_back(SA->getHandlerParamIdx());
		2366	break;
		2367	}
		2368	case attr::SwiftAsyncName: {
		2369	const auto *SA = cast<SwiftAsyncNameAttr>(A);
		2370	Record.push_back(SA->isInherited());
		2371	Record.push_back(A->isImplicit());
		2372	Record.push_back(A->isPackExpansion());
		2373	Record.AddString(SA->getName());
		2374	break;
		2375	}
		2376	case attr::SwiftAttr: {
		2377	const auto *SA = cast<SwiftAttrAttr>(A);
		2378	Record.push_back(SA->isInherited());
		2379	Record.push_back(A->isImplicit());
		2380	Record.push_back(A->isPackExpansion());
		2381	Record.AddString(SA->getAttribute());
		2382	break;
		2383	}
		2384	case attr::SwiftBridge: {
		2385	const auto *SA = cast<SwiftBridgeAttr>(A);
		2386	Record.push_back(SA->isInherited());
		2387	Record.push_back(A->isImplicit());
		2388	Record.push_back(A->isPackExpansion());
		2389	Record.AddString(SA->getSwiftType());
		2390	break;
		2391	}
		2392	case attr::SwiftBridgedTypedef: {
		2393	const auto *SA = cast<SwiftBridgedTypedefAttr>(A);
		2394	Record.push_back(SA->isInherited());
		2395	Record.push_back(A->isImplicit());
		2396	Record.push_back(A->isPackExpansion());
		2397	break;
		2398	}
		2399	case attr::SwiftCall: {
		2400	const auto *SA = cast<SwiftCallAttr>(A);
		2401	Record.push_back(SA->isInherited());
		2402	Record.push_back(A->isImplicit());
		2403	Record.push_back(A->isPackExpansion());
		2404	break;
		2405	}
		2406	case attr::SwiftContext: {
		2407	const auto *SA = cast<SwiftContextAttr>(A);
		2408	Record.push_back(SA->isInherited());
		2409	Record.push_back(A->isImplicit());
		2410	Record.push_back(A->isPackExpansion());
		2411	break;
		2412	}
		2413	case attr::SwiftError: {
		2414	const auto *SA = cast<SwiftErrorAttr>(A);
		2415	Record.push_back(SA->isInherited());
		2416	Record.push_back(A->isImplicit());
		2417	Record.push_back(A->isPackExpansion());
		2418	Record.push_back(SA->getConvention());
		2419	break;
		2420	}
		2421	case attr::SwiftErrorResult: {
		2422	const auto *SA = cast<SwiftErrorResultAttr>(A);
		2423	Record.push_back(SA->isInherited());
		2424	Record.push_back(A->isImplicit());
		2425	Record.push_back(A->isPackExpansion());
		2426	break;
		2427	}
		2428	case attr::SwiftIndirectResult: {
		2429	const auto *SA = cast<SwiftIndirectResultAttr>(A);
		2430	Record.push_back(SA->isInherited());
		2431	Record.push_back(A->isImplicit());
		2432	Record.push_back(A->isPackExpansion());
		2433	break;
		2434	}
		2435	case attr::SwiftName: {
		2436	const auto *SA = cast<SwiftNameAttr>(A);
		2437	Record.push_back(SA->isInherited());
		2438	Record.push_back(A->isImplicit());
		2439	Record.push_back(A->isPackExpansion());
		2440	Record.AddString(SA->getName());
		2441	break;
		2442	}
		2443	case attr::SwiftNewType: {
		2444	const auto *SA = cast<SwiftNewTypeAttr>(A);
		2445	Record.push_back(SA->isInherited());
		2446	Record.push_back(A->isImplicit());
		2447	Record.push_back(A->isPackExpansion());
		2448	Record.push_back(SA->getNewtypeKind());
		2449	break;
		2450	}
		2451	case attr::SwiftObjCMembers: {
		2452	Record.push_back(A->isImplicit());
		2453	Record.push_back(A->isPackExpansion());
		2454	break;
		2455	}
		2456	case attr::SwiftPrivate: {
		2457	const auto *SA = cast<SwiftPrivateAttr>(A);
		2458	Record.push_back(SA->isInherited());
		2459	Record.push_back(A->isImplicit());
		2460	Record.push_back(A->isPackExpansion());
		2461	break;
		2462	}
		2463	case attr::SysVABI: {
		2464	const auto *SA = cast<SysVABIAttr>(A);
		2465	Record.push_back(SA->isInherited());
		2466	Record.push_back(A->isImplicit());
		2467	Record.push_back(A->isPackExpansion());
		2468	break;
		2469	}
		2470	case attr::TLSModel: {
		2471	const auto *SA = cast<TLSModelAttr>(A);
		2472	Record.push_back(SA->isInherited());
		2473	Record.push_back(A->isImplicit());
		2474	Record.push_back(A->isPackExpansion());
		2475	Record.AddString(SA->getModel());
		2476	break;
		2477	}
		2478	case attr::Target: {
		2479	const auto *SA = cast<TargetAttr>(A);
		2480	Record.push_back(SA->isInherited());
		2481	Record.push_back(A->isImplicit());
		2482	Record.push_back(A->isPackExpansion());
		2483	Record.AddString(SA->getFeaturesStr());
		2484	break;
		2485	}
		2486	case attr::TargetClones: {
		2487	const auto *SA = cast<TargetClonesAttr>(A);
		2488	Record.push_back(SA->isInherited());
		2489	Record.push_back(A->isImplicit());
		2490	Record.push_back(A->isPackExpansion());
		2491	Record.push_back(SA->featuresStrs_size());
		2492	for (auto &Val : SA->featuresStrs())
		2493	Record.AddString(Val);
		2494	break;
		2495	}
		2496	case attr::TargetVersion: {
		2497	const auto *SA = cast<TargetVersionAttr>(A);
		2498	Record.push_back(SA->isInherited());
		2499	Record.push_back(A->isImplicit());
		2500	Record.push_back(A->isPackExpansion());
		2501	Record.AddString(SA->getNamesStr());
		2502	break;
		2503	}
		2504	case attr::TestTypestate: {
		2505	const auto *SA = cast<TestTypestateAttr>(A);
		2506	Record.push_back(SA->isInherited());
		2507	Record.push_back(A->isImplicit());
		2508	Record.push_back(A->isPackExpansion());
		2509	Record.push_back(SA->getTestState());
		2510	break;
		2511	}
		2512	case attr::ThisCall: {
		2513	const auto *SA = cast<ThisCallAttr>(A);
		2514	Record.push_back(SA->isInherited());
		2515	Record.push_back(A->isImplicit());
		2516	Record.push_back(A->isPackExpansion());
		2517	break;
		2518	}
		2519	case attr::Thread: {
		2520	Record.push_back(A->isImplicit());
		2521	Record.push_back(A->isPackExpansion());
		2522	break;
		2523	}
		2524	case attr::TransparentUnion: {
		2525	const auto *SA = cast<TransparentUnionAttr>(A);
		2526	Record.push_back(SA->isInherited());
		2527	Record.push_back(A->isImplicit());
		2528	Record.push_back(A->isPackExpansion());
		2529	break;
		2530	}
		2531	case attr::TrivialABI: {
		2532	const auto *SA = cast<TrivialABIAttr>(A);
		2533	Record.push_back(SA->isInherited());
		2534	Record.push_back(A->isImplicit());
		2535	Record.push_back(A->isPackExpansion());
		2536	break;
		2537	}
		2538	case attr::TryAcquireCapability: {
		2539	const auto *SA = cast<TryAcquireCapabilityAttr>(A);
		2540	Record.push_back(SA->isInherited());
		2541	Record.push_back(A->isImplicit());
		2542	Record.push_back(A->isPackExpansion());
		2543	Record.AddStmt(SA->getSuccessValue());
		2544	Record.push_back(SA->args_size());
		2545	for (auto &Val : SA->args())
		2546	Record.AddStmt(Val);
		2547	break;
		2548	}
		2549	case attr::TypeNonNull: {
		2550	Record.push_back(A->isImplicit());
		2551	Record.push_back(A->isPackExpansion());
		2552	break;
		2553	}
		2554	case attr::TypeNullUnspecified: {
		2555	Record.push_back(A->isImplicit());
		2556	Record.push_back(A->isPackExpansion());
		2557	break;
		2558	}
		2559	case attr::TypeNullable: {
		2560	Record.push_back(A->isImplicit());
		2561	Record.push_back(A->isPackExpansion());
		2562	break;
		2563	}
		2564	case attr::TypeNullableResult: {
		2565	Record.push_back(A->isImplicit());
		2566	Record.push_back(A->isPackExpansion());
		2567	break;
		2568	}
		2569	case attr::TypeTagForDatatype: {
		2570	const auto *SA = cast<TypeTagForDatatypeAttr>(A);
		2571	Record.push_back(SA->isInherited());
		2572	Record.push_back(A->isImplicit());
		2573	Record.push_back(A->isPackExpansion());
		2574	Record.AddIdentifierRef(SA->getArgumentKind());
		2575	Record.AddTypeSourceInfo(SA->getMatchingCTypeLoc());
		2576	Record.push_back(SA->getLayoutCompatible());
		2577	Record.push_back(SA->getMustBeNull());
		2578	break;
		2579	}
		2580	case attr::TypeVisibility: {
		2581	const auto *SA = cast<TypeVisibilityAttr>(A);
		2582	Record.push_back(SA->isInherited());
		2583	Record.push_back(A->isImplicit());
		2584	Record.push_back(A->isPackExpansion());
		2585	Record.push_back(SA->getVisibility());
		2586	break;
		2587	}
		2588	case attr::UPtr: {
		2589	Record.push_back(A->isImplicit());
		2590	Record.push_back(A->isPackExpansion());
		2591	break;
		2592	}
		2593	case attr::Unavailable: {
		2594	const auto *SA = cast<UnavailableAttr>(A);
		2595	Record.push_back(SA->isInherited());
		2596	Record.push_back(A->isImplicit());
		2597	Record.push_back(A->isPackExpansion());
		2598	Record.AddString(SA->getMessage());
		2599	Record.push_back(SA->getImplicitReason());
		2600	break;
		2601	}
		2602	case attr::Uninitialized: {
		2603	const auto *SA = cast<UninitializedAttr>(A);
		2604	Record.push_back(SA->isInherited());
		2605	Record.push_back(A->isImplicit());
		2606	Record.push_back(A->isPackExpansion());
		2607	break;
		2608	}
		2609	case attr::Unlikely: {
		2610	Record.push_back(A->isImplicit());
		2611	Record.push_back(A->isPackExpansion());
		2612	break;
		2613	}
		2614	case attr::Unused: {
		2615	const auto *SA = cast<UnusedAttr>(A);
		2616	Record.push_back(SA->isInherited());
		2617	Record.push_back(A->isImplicit());
		2618	Record.push_back(A->isPackExpansion());
		2619	break;
		2620	}
		2621	case attr::UseHandle: {
		2622	const auto *SA = cast<UseHandleAttr>(A);
		2623	Record.push_back(SA->isInherited());
		2624	Record.push_back(A->isImplicit());
		2625	Record.push_back(A->isPackExpansion());
		2626	Record.AddString(SA->getHandleType());
		2627	break;
		2628	}
		2629	case attr::Used: {
		2630	const auto *SA = cast<UsedAttr>(A);
		2631	Record.push_back(SA->isInherited());
		2632	Record.push_back(A->isImplicit());
		2633	Record.push_back(A->isPackExpansion());
		2634	break;
		2635	}
		2636	case attr::UsingIfExists: {
		2637	const auto *SA = cast<UsingIfExistsAttr>(A);
		2638	Record.push_back(SA->isInherited());
		2639	Record.push_back(A->isImplicit());
		2640	Record.push_back(A->isPackExpansion());
		2641	break;
		2642	}
		2643	case attr::Uuid: {
		2644	const auto *SA = cast<UuidAttr>(A);
		2645	Record.push_back(SA->isInherited());
		2646	Record.push_back(A->isImplicit());
		2647	Record.push_back(A->isPackExpansion());
		2648	Record.AddString(SA->getGuid());
		2649	Record.AddDeclRef(SA->getGuidDecl());
		2650	break;
		2651	}
		2652	case attr::VecReturn: {
		2653	const auto *SA = cast<VecReturnAttr>(A);
		2654	Record.push_back(SA->isInherited());
		2655	Record.push_back(A->isImplicit());
		2656	Record.push_back(A->isPackExpansion());
		2657	break;
		2658	}
		2659	case attr::VecTypeHint: {
		2660	const auto *SA = cast<VecTypeHintAttr>(A);
		2661	Record.push_back(SA->isInherited());
		2662	Record.push_back(A->isImplicit());
		2663	Record.push_back(A->isPackExpansion());
		2664	Record.AddTypeSourceInfo(SA->getTypeHintLoc());
		2665	break;
		2666	}
		2667	case attr::VectorCall: {
		2668	const auto *SA = cast<VectorCallAttr>(A);
		2669	Record.push_back(SA->isInherited());
		2670	Record.push_back(A->isImplicit());
		2671	Record.push_back(A->isPackExpansion());
		2672	break;
		2673	}
		2674	case attr::Visibility: {
		2675	const auto *SA = cast<VisibilityAttr>(A);
		2676	Record.push_back(SA->isInherited());
		2677	Record.push_back(A->isImplicit());
		2678	Record.push_back(A->isPackExpansion());
		2679	Record.push_back(SA->getVisibility());
		2680	break;
		2681	}
		2682	case attr::WarnUnused: {
		2683	const auto *SA = cast<WarnUnusedAttr>(A);
		2684	Record.push_back(SA->isInherited());
		2685	Record.push_back(A->isImplicit());
		2686	Record.push_back(A->isPackExpansion());
		2687	break;
		2688	}
		2689	case attr::WarnUnusedResult: {
		2690	const auto *SA = cast<WarnUnusedResultAttr>(A);
		2691	Record.push_back(SA->isInherited());
		2692	Record.push_back(A->isImplicit());
		2693	Record.push_back(A->isPackExpansion());
		2694	Record.AddString(SA->getMessage());
		2695	break;
		2696	}
		2697	case attr::Weak: {
		2698	const auto *SA = cast<WeakAttr>(A);
		2699	Record.push_back(SA->isInherited());
		2700	Record.push_back(A->isImplicit());
		2701	Record.push_back(A->isPackExpansion());
		2702	break;
		2703	}
		2704	case attr::WeakImport: {
		2705	const auto *SA = cast<WeakImportAttr>(A);
		2706	Record.push_back(SA->isInherited());
		2707	Record.push_back(A->isImplicit());
		2708	Record.push_back(A->isPackExpansion());
		2709	break;
		2710	}
		2711	case attr::WeakRef: {
		2712	const auto *SA = cast<WeakRefAttr>(A);
		2713	Record.push_back(SA->isInherited());
		2714	Record.push_back(A->isImplicit());
		2715	Record.push_back(A->isPackExpansion());
		2716	Record.AddString(SA->getAliasee());
		2717	break;
		2718	}
		2719	case attr::WebAssemblyExportName: {
		2720	const auto *SA = cast<WebAssemblyExportNameAttr>(A);
		2721	Record.push_back(SA->isInherited());
		2722	Record.push_back(A->isImplicit());
		2723	Record.push_back(A->isPackExpansion());
		2724	Record.AddString(SA->getExportName());
		2725	break;
		2726	}
		2727	case attr::WebAssemblyImportModule: {
		2728	const auto *SA = cast<WebAssemblyImportModuleAttr>(A);
		2729	Record.push_back(SA->isInherited());
		2730	Record.push_back(A->isImplicit());
		2731	Record.push_back(A->isPackExpansion());
		2732	Record.AddString(SA->getImportModule());
		2733	break;
		2734	}
		2735	case attr::WebAssemblyImportName: {
		2736	const auto *SA = cast<WebAssemblyImportNameAttr>(A);
		2737	Record.push_back(SA->isInherited());
		2738	Record.push_back(A->isImplicit());
		2739	Record.push_back(A->isPackExpansion());
		2740	Record.AddString(SA->getImportName());
		2741	break;
		2742	}
		2743	case attr::WorkGroupSizeHint: {
		2744	const auto *SA = cast<WorkGroupSizeHintAttr>(A);
		2745	Record.push_back(SA->isInherited());
		2746	Record.push_back(A->isImplicit());
		2747	Record.push_back(A->isPackExpansion());
		2748	Record.push_back(SA->getXDim());
		2749	Record.push_back(SA->getYDim());
		2750	Record.push_back(SA->getZDim());
		2751	break;
		2752	}
		2753	case attr::X86ForceAlignArgPointer: {
		2754	const auto *SA = cast<X86ForceAlignArgPointerAttr>(A);
		2755	Record.push_back(SA->isInherited());
		2756	Record.push_back(A->isImplicit());
		2757	Record.push_back(A->isPackExpansion());
		2758	break;
		2759	}
		2760	case attr::XRayInstrument: {
		2761	const auto *SA = cast<XRayInstrumentAttr>(A);
		2762	Record.push_back(SA->isInherited());
		2763	Record.push_back(A->isImplicit());
		2764	Record.push_back(A->isPackExpansion());
		2765	break;
		2766	}
		2767	case attr::XRayLogArgs: {
		2768	const auto *SA = cast<XRayLogArgsAttr>(A);
		2769	Record.push_back(SA->isInherited());
		2770	Record.push_back(A->isImplicit());
		2771	Record.push_back(A->isPackExpansion());
		2772	Record.push_back(SA->getArgumentCount());
		2773	break;
		2774	}
		2775	case attr::ZeroCallUsedRegs: {
		2776	const auto *SA = cast<ZeroCallUsedRegsAttr>(A);
		2777	Record.push_back(SA->isInherited());
		2778	Record.push_back(A->isImplicit());
		2779	Record.push_back(A->isPackExpansion());
		2780	Record.push_back(SA->getZeroCallUsedRegs());
		2781	break;
		2782	}
		2783	}

Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

QNX 8.QNX8 LLVM/Clang compiler suite/llvm-build/x86_64/include/clang/Serialization/AttrPCHWrite.inc – Rev 14