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

Rev	Author	Line No.	Line
14	pmbaty	1	/===- TableGen'erated file -------------------------------------- C++ --===\
		2	\|* *\|
		3	\|* Attribute deserialization code *\|
		4	\|* *\|
		5	\|* Automatically generated file, do not edit! *\|
		6	\|* *\|
		7	\===----------------------------------------------------------------------===/
		8
		9	switch (Kind) {
		10	case attr::AArch64SVEPcs: {
		11	bool isInherited = Record.readInt();
		12	bool isImplicit = Record.readInt();
		13	bool isPackExpansion = Record.readInt();
		14	New = new (Context) AArch64SVEPcsAttr(Context, Info);
		15	cast<InheritableAttr>(New)->setInherited(isInherited);
		16	New->setImplicit(isImplicit);
		17	New->setPackExpansion(isPackExpansion);
		18	break;
		19	}
		20	case attr::AArch64VectorPcs: {
		21	bool isInherited = Record.readInt();
		22	bool isImplicit = Record.readInt();
		23	bool isPackExpansion = Record.readInt();
		24	New = new (Context) AArch64VectorPcsAttr(Context, Info);
		25	cast<InheritableAttr>(New)->setInherited(isInherited);
		26	New->setImplicit(isImplicit);
		27	New->setPackExpansion(isPackExpansion);
		28	break;
		29	}
		30	case attr::AMDGPUFlatWorkGroupSize: {
		31	bool isInherited = Record.readInt();
		32	bool isImplicit = Record.readInt();
		33	bool isPackExpansion = Record.readInt();
		34	Expr * min = Record.readExpr();
		35	Expr * max = Record.readExpr();
		36	New = new (Context) AMDGPUFlatWorkGroupSizeAttr(Context, Info, min, max);
		37	cast<InheritableAttr>(New)->setInherited(isInherited);
		38	New->setImplicit(isImplicit);
		39	New->setPackExpansion(isPackExpansion);
		40	break;
		41	}
		42	case attr::AMDGPUKernelCall: {
		43	bool isInherited = Record.readInt();
		44	bool isImplicit = Record.readInt();
		45	bool isPackExpansion = Record.readInt();
		46	New = new (Context) AMDGPUKernelCallAttr(Context, Info);
		47	cast<InheritableAttr>(New)->setInherited(isInherited);
		48	New->setImplicit(isImplicit);
		49	New->setPackExpansion(isPackExpansion);
		50	break;
		51	}
		52	case attr::AMDGPUNumSGPR: {
		53	bool isInherited = Record.readInt();
		54	bool isImplicit = Record.readInt();
		55	bool isPackExpansion = Record.readInt();
		56	unsigned numSGPR = Record.readInt();
		57	New = new (Context) AMDGPUNumSGPRAttr(Context, Info, numSGPR);
		58	cast<InheritableAttr>(New)->setInherited(isInherited);
		59	New->setImplicit(isImplicit);
		60	New->setPackExpansion(isPackExpansion);
		61	break;
		62	}
		63	case attr::AMDGPUNumVGPR: {
		64	bool isInherited = Record.readInt();
		65	bool isImplicit = Record.readInt();
		66	bool isPackExpansion = Record.readInt();
		67	unsigned numVGPR = Record.readInt();
		68	New = new (Context) AMDGPUNumVGPRAttr(Context, Info, numVGPR);
		69	cast<InheritableAttr>(New)->setInherited(isInherited);
		70	New->setImplicit(isImplicit);
		71	New->setPackExpansion(isPackExpansion);
		72	break;
		73	}
		74	case attr::AMDGPUWavesPerEU: {
		75	bool isInherited = Record.readInt();
		76	bool isImplicit = Record.readInt();
		77	bool isPackExpansion = Record.readInt();
		78	Expr * min = Record.readExpr();
		79	Expr * max = Record.readExpr();
		80	New = new (Context) AMDGPUWavesPerEUAttr(Context, Info, min, max);
		81	cast<InheritableAttr>(New)->setInherited(isInherited);
		82	New->setImplicit(isImplicit);
		83	New->setPackExpansion(isPackExpansion);
		84	break;
		85	}
		86	case attr::ARMInterrupt: {
		87	bool isInherited = Record.readInt();
		88	bool isImplicit = Record.readInt();
		89	bool isPackExpansion = Record.readInt();
		90	ARMInterruptAttr::InterruptType interrupt(static_cast<ARMInterruptAttr::InterruptType>(Record.readInt()));
		91	New = new (Context) ARMInterruptAttr(Context, Info, interrupt);
		92	cast<InheritableAttr>(New)->setInherited(isInherited);
		93	New->setImplicit(isImplicit);
		94	New->setPackExpansion(isPackExpansion);
		95	break;
		96	}
		97	case attr::AVRInterrupt: {
		98	bool isInherited = Record.readInt();
		99	bool isImplicit = Record.readInt();
		100	bool isPackExpansion = Record.readInt();
		101	New = new (Context) AVRInterruptAttr(Context, Info);
		102	cast<InheritableAttr>(New)->setInherited(isInherited);
		103	New->setImplicit(isImplicit);
		104	New->setPackExpansion(isPackExpansion);
		105	break;
		106	}
		107	case attr::AVRSignal: {
		108	bool isInherited = Record.readInt();
		109	bool isImplicit = Record.readInt();
		110	bool isPackExpansion = Record.readInt();
		111	New = new (Context) AVRSignalAttr(Context, Info);
		112	cast<InheritableAttr>(New)->setInherited(isInherited);
		113	New->setImplicit(isImplicit);
		114	New->setPackExpansion(isPackExpansion);
		115	break;
		116	}
		117	case attr::AbiTag: {
		118	bool isImplicit = Record.readInt();
		119	bool isPackExpansion = Record.readInt();
		120	unsigned tagsSize = Record.readInt();
		121	SmallVector<StringRef, 4> tags;
		122	tags.reserve(tagsSize);
		123	SmallVector<std::string, 4> tagsStorage;
		124	tagsStorage.reserve(tagsSize);
		125	for (unsigned i = 0; i != tagsSize; ++i)
		126	tagsStorage.push_back(Record.readString());
		127	for (unsigned i = 0; i != tagsSize; ++i)
		128	tags.push_back(tagsStorage[i]);
		129	New = new (Context) AbiTagAttr(Context, Info, tags.data(), tagsSize);
		130	New->setImplicit(isImplicit);
		131	New->setPackExpansion(isPackExpansion);
		132	break;
		133	}
		134	case attr::AcquireCapability: {
		135	bool isInherited = Record.readInt();
		136	bool isImplicit = Record.readInt();
		137	bool isPackExpansion = Record.readInt();
		138	unsigned argsSize = Record.readInt();
		139	SmallVector<Expr *, 4> args;
		140	args.reserve(argsSize);
		141	for (unsigned i = 0; i != argsSize; ++i)
		142	args.push_back(Record.readExpr());
		143	New = new (Context) AcquireCapabilityAttr(Context, Info, args.data(), argsSize);
		144	cast<InheritableAttr>(New)->setInherited(isInherited);
		145	New->setImplicit(isImplicit);
		146	New->setPackExpansion(isPackExpansion);
		147	break;
		148	}
		149	case attr::AcquireHandle: {
		150	bool isInherited = Record.readInt();
		151	bool isImplicit = Record.readInt();
		152	bool isPackExpansion = Record.readInt();
		153	std::string handleType= Record.readString();
		154	New = new (Context) AcquireHandleAttr(Context, Info, handleType);
		155	cast<InheritableAttr>(New)->setInherited(isInherited);
		156	New->setImplicit(isImplicit);
		157	New->setPackExpansion(isPackExpansion);
		158	break;
		159	}
		160	case attr::AcquiredAfter: {
		161	bool isInherited = Record.readInt();
		162	bool isImplicit = Record.readInt();
		163	bool isPackExpansion = Record.readInt();
		164	unsigned argsSize = Record.readInt();
		165	SmallVector<Expr *, 4> args;
		166	args.reserve(argsSize);
		167	for (unsigned i = 0; i != argsSize; ++i)
		168	args.push_back(Record.readExpr());
		169	New = new (Context) AcquiredAfterAttr(Context, Info, args.data(), argsSize);
		170	cast<InheritableAttr>(New)->setInherited(isInherited);
		171	New->setImplicit(isImplicit);
		172	New->setPackExpansion(isPackExpansion);
		173	break;
		174	}
		175	case attr::AcquiredBefore: {
		176	bool isInherited = Record.readInt();
		177	bool isImplicit = Record.readInt();
		178	bool isPackExpansion = Record.readInt();
		179	unsigned argsSize = Record.readInt();
		180	SmallVector<Expr *, 4> args;
		181	args.reserve(argsSize);
		182	for (unsigned i = 0; i != argsSize; ++i)
		183	args.push_back(Record.readExpr());
		184	New = new (Context) AcquiredBeforeAttr(Context, Info, args.data(), argsSize);
		185	cast<InheritableAttr>(New)->setInherited(isInherited);
		186	New->setImplicit(isImplicit);
		187	New->setPackExpansion(isPackExpansion);
		188	break;
		189	}
		190	case attr::AddressSpace: {
		191	bool isImplicit = Record.readInt();
		192	bool isPackExpansion = Record.readInt();
		193	int addressSpace = Record.readInt();
		194	New = new (Context) AddressSpaceAttr(Context, Info, addressSpace);
		195	New->setImplicit(isImplicit);
		196	New->setPackExpansion(isPackExpansion);
		197	break;
		198	}
		199	case attr::Alias: {
		200	bool isImplicit = Record.readInt();
		201	bool isPackExpansion = Record.readInt();
		202	std::string aliasee= Record.readString();
		203	New = new (Context) AliasAttr(Context, Info, aliasee);
		204	New->setImplicit(isImplicit);
		205	New->setPackExpansion(isPackExpansion);
		206	break;
		207	}
		208	case attr::AlignMac68k: {
		209	bool isInherited = Record.readInt();
		210	bool isImplicit = Record.readInt();
		211	bool isPackExpansion = Record.readInt();
		212	New = new (Context) AlignMac68kAttr(Context, Info);
		213	cast<InheritableAttr>(New)->setInherited(isInherited);
		214	New->setImplicit(isImplicit);
		215	New->setPackExpansion(isPackExpansion);
		216	break;
		217	}
		218	case attr::AlignNatural: {
		219	bool isInherited = Record.readInt();
		220	bool isImplicit = Record.readInt();
		221	bool isPackExpansion = Record.readInt();
		222	New = new (Context) AlignNaturalAttr(Context, Info);
		223	cast<InheritableAttr>(New)->setInherited(isInherited);
		224	New->setImplicit(isImplicit);
		225	New->setPackExpansion(isPackExpansion);
		226	break;
		227	}
		228	case attr::AlignValue: {
		229	bool isImplicit = Record.readInt();
		230	bool isPackExpansion = Record.readInt();
		231	Expr * alignment = Record.readExpr();
		232	New = new (Context) AlignValueAttr(Context, Info, alignment);
		233	New->setImplicit(isImplicit);
		234	New->setPackExpansion(isPackExpansion);
		235	break;
		236	}
		237	case attr::Aligned: {
		238	bool isInherited = Record.readInt();
		239	bool isImplicit = Record.readInt();
		240	bool isPackExpansion = Record.readInt();
		241	bool isalignmentExpr = Record.readInt();
		242	void *alignmentPtr;
		243	if (isalignmentExpr)
		244	alignmentPtr = Record.readExpr();
		245	else
		246	alignmentPtr = Record.readTypeSourceInfo();
		247	New = new (Context) AlignedAttr(Context, Info, isalignmentExpr, alignmentPtr);
		248	cast<InheritableAttr>(New)->setInherited(isInherited);
		249	New->setImplicit(isImplicit);
		250	New->setPackExpansion(isPackExpansion);
		251	break;
		252	}
		253	case attr::AllocAlign: {
		254	bool isInherited = Record.readInt();
		255	bool isImplicit = Record.readInt();
		256	bool isPackExpansion = Record.readInt();
		257	ParamIdx paramIndex = ParamIdx::deserialize(Record.readInt());
		258	New = new (Context) AllocAlignAttr(Context, Info, paramIndex);
		259	cast<InheritableAttr>(New)->setInherited(isInherited);
		260	New->setImplicit(isImplicit);
		261	New->setPackExpansion(isPackExpansion);
		262	break;
		263	}
		264	case attr::AllocSize: {
		265	bool isInherited = Record.readInt();
		266	bool isImplicit = Record.readInt();
		267	bool isPackExpansion = Record.readInt();
		268	ParamIdx elemSizeParam = ParamIdx::deserialize(Record.readInt());
		269	ParamIdx numElemsParam = ParamIdx::deserialize(Record.readInt());
		270	New = new (Context) AllocSizeAttr(Context, Info, elemSizeParam, numElemsParam);
		271	cast<InheritableAttr>(New)->setInherited(isInherited);
		272	New->setImplicit(isImplicit);
		273	New->setPackExpansion(isPackExpansion);
		274	break;
		275	}
		276	case attr::AlwaysDestroy: {
		277	bool isInherited = Record.readInt();
		278	bool isImplicit = Record.readInt();
		279	bool isPackExpansion = Record.readInt();
		280	New = new (Context) AlwaysDestroyAttr(Context, Info);
		281	cast<InheritableAttr>(New)->setInherited(isInherited);
		282	New->setImplicit(isImplicit);
		283	New->setPackExpansion(isPackExpansion);
		284	break;
		285	}
		286	case attr::AlwaysInline: {
		287	bool isInherited = Record.readInt();
		288	bool isImplicit = Record.readInt();
		289	bool isPackExpansion = Record.readInt();
		290	New = new (Context) AlwaysInlineAttr(Context, Info);
		291	cast<InheritableAttr>(New)->setInherited(isInherited);
		292	New->setImplicit(isImplicit);
		293	New->setPackExpansion(isPackExpansion);
		294	break;
		295	}
		296	case attr::AnalyzerNoReturn: {
		297	bool isInherited = Record.readInt();
		298	bool isImplicit = Record.readInt();
		299	bool isPackExpansion = Record.readInt();
		300	New = new (Context) AnalyzerNoReturnAttr(Context, Info);
		301	cast<InheritableAttr>(New)->setInherited(isInherited);
		302	New->setImplicit(isImplicit);
		303	New->setPackExpansion(isPackExpansion);
		304	break;
		305	}
		306	case attr::Annotate: {
		307	bool isInherited = Record.readInt();
		308	bool isImplicit = Record.readInt();
		309	bool isPackExpansion = Record.readInt();
		310	unsigned delayedArgsSize = Record.readInt();
		311	SmallVector<Expr *, 4> delayedArgs;
		312	delayedArgs.reserve(delayedArgsSize);
		313	for (unsigned i = 0; i != delayedArgsSize; ++i)
		314	delayedArgs.push_back(Record.readExpr());
		315	std::string annotation= Record.readString();
		316	unsigned argsSize = Record.readInt();
		317	SmallVector<Expr *, 4> args;
		318	args.reserve(argsSize);
		319	for (unsigned i = 0; i != argsSize; ++i)
		320	args.push_back(Record.readExpr());
		321	New = new (Context) AnnotateAttr(Context, Info, annotation, args.data(), argsSize);
		322	cast<InheritableAttr>(New)->setInherited(isInherited);
		323	New->setImplicit(isImplicit);
		324	New->setPackExpansion(isPackExpansion);
		325	cast<AnnotateAttr>(New)->setDelayedArgs(Context, delayedArgs.data(), delayedArgsSize);
		326	break;
		327	}
		328	case attr::AnnotateType: {
		329	bool isImplicit = Record.readInt();
		330	bool isPackExpansion = Record.readInt();
		331	unsigned delayedArgsSize = Record.readInt();
		332	SmallVector<Expr *, 4> delayedArgs;
		333	delayedArgs.reserve(delayedArgsSize);
		334	for (unsigned i = 0; i != delayedArgsSize; ++i)
		335	delayedArgs.push_back(Record.readExpr());
		336	std::string annotation= Record.readString();
		337	unsigned argsSize = Record.readInt();
		338	SmallVector<Expr *, 4> args;
		339	args.reserve(argsSize);
		340	for (unsigned i = 0; i != argsSize; ++i)
		341	args.push_back(Record.readExpr());
		342	New = new (Context) AnnotateTypeAttr(Context, Info, annotation, args.data(), argsSize);
		343	New->setImplicit(isImplicit);
		344	New->setPackExpansion(isPackExpansion);
		345	cast<AnnotateTypeAttr>(New)->setDelayedArgs(Context, delayedArgs.data(), delayedArgsSize);
		346	break;
		347	}
		348	case attr::AnyX86Interrupt: {
		349	bool isInherited = Record.readInt();
		350	bool isImplicit = Record.readInt();
		351	bool isPackExpansion = Record.readInt();
		352	New = new (Context) AnyX86InterruptAttr(Context, Info);
		353	cast<InheritableAttr>(New)->setInherited(isInherited);
		354	New->setImplicit(isImplicit);
		355	New->setPackExpansion(isPackExpansion);
		356	break;
		357	}
		358	case attr::AnyX86NoCallerSavedRegisters: {
		359	bool isInherited = Record.readInt();
		360	bool isImplicit = Record.readInt();
		361	bool isPackExpansion = Record.readInt();
		362	New = new (Context) AnyX86NoCallerSavedRegistersAttr(Context, Info);
		363	cast<InheritableAttr>(New)->setInherited(isInherited);
		364	New->setImplicit(isImplicit);
		365	New->setPackExpansion(isPackExpansion);
		366	break;
		367	}
		368	case attr::AnyX86NoCfCheck: {
		369	bool isInherited = Record.readInt();
		370	bool isImplicit = Record.readInt();
		371	bool isPackExpansion = Record.readInt();
		372	New = new (Context) AnyX86NoCfCheckAttr(Context, Info);
		373	cast<InheritableAttr>(New)->setInherited(isInherited);
		374	New->setImplicit(isImplicit);
		375	New->setPackExpansion(isPackExpansion);
		376	break;
		377	}
		378	case attr::ArcWeakrefUnavailable: {
		379	bool isInherited = Record.readInt();
		380	bool isImplicit = Record.readInt();
		381	bool isPackExpansion = Record.readInt();
		382	New = new (Context) ArcWeakrefUnavailableAttr(Context, Info);
		383	cast<InheritableAttr>(New)->setInherited(isInherited);
		384	New->setImplicit(isImplicit);
		385	New->setPackExpansion(isPackExpansion);
		386	break;
		387	}
		388	case attr::ArgumentWithTypeTag: {
		389	bool isInherited = Record.readInt();
		390	bool isImplicit = Record.readInt();
		391	bool isPackExpansion = Record.readInt();
		392	IdentifierInfo * argumentKind = Record.readIdentifier();
		393	ParamIdx argumentIdx = ParamIdx::deserialize(Record.readInt());
		394	ParamIdx typeTagIdx = ParamIdx::deserialize(Record.readInt());
		395	bool isPointer = Record.readInt();
		396	New = new (Context) ArgumentWithTypeTagAttr(Context, Info, argumentKind, argumentIdx, typeTagIdx, isPointer);
		397	cast<InheritableAttr>(New)->setInherited(isInherited);
		398	New->setImplicit(isImplicit);
		399	New->setPackExpansion(isPackExpansion);
		400	break;
		401	}
		402	case attr::ArmBuiltinAlias: {
		403	bool isInherited = Record.readInt();
		404	bool isImplicit = Record.readInt();
		405	bool isPackExpansion = Record.readInt();
		406	IdentifierInfo * builtinName = Record.readIdentifier();
		407	New = new (Context) ArmBuiltinAliasAttr(Context, Info, builtinName);
		408	cast<InheritableAttr>(New)->setInherited(isInherited);
		409	New->setImplicit(isImplicit);
		410	New->setPackExpansion(isPackExpansion);
		411	break;
		412	}
		413	case attr::ArmMveStrictPolymorphism: {
		414	bool isImplicit = Record.readInt();
		415	bool isPackExpansion = Record.readInt();
		416	New = new (Context) ArmMveStrictPolymorphismAttr(Context, Info);
		417	New->setImplicit(isImplicit);
		418	New->setPackExpansion(isPackExpansion);
		419	break;
		420	}
		421	case attr::Artificial: {
		422	bool isInherited = Record.readInt();
		423	bool isImplicit = Record.readInt();
		424	bool isPackExpansion = Record.readInt();
		425	New = new (Context) ArtificialAttr(Context, Info);
		426	cast<InheritableAttr>(New)->setInherited(isInherited);
		427	New->setImplicit(isImplicit);
		428	New->setPackExpansion(isPackExpansion);
		429	break;
		430	}
		431	case attr::AsmLabel: {
		432	bool isInherited = Record.readInt();
		433	bool isImplicit = Record.readInt();
		434	bool isPackExpansion = Record.readInt();
		435	std::string label= Record.readString();
		436	bool isLiteralLabel = Record.readInt();
		437	New = new (Context) AsmLabelAttr(Context, Info, label, isLiteralLabel);
		438	cast<InheritableAttr>(New)->setInherited(isInherited);
		439	New->setImplicit(isImplicit);
		440	New->setPackExpansion(isPackExpansion);
		441	break;
		442	}
		443	case attr::AssertCapability: {
		444	bool isInherited = Record.readInt();
		445	bool isImplicit = Record.readInt();
		446	bool isPackExpansion = Record.readInt();
		447	unsigned argsSize = Record.readInt();
		448	SmallVector<Expr *, 4> args;
		449	args.reserve(argsSize);
		450	for (unsigned i = 0; i != argsSize; ++i)
		451	args.push_back(Record.readExpr());
		452	New = new (Context) AssertCapabilityAttr(Context, Info, args.data(), argsSize);
		453	cast<InheritableAttr>(New)->setInherited(isInherited);
		454	New->setImplicit(isImplicit);
		455	New->setPackExpansion(isPackExpansion);
		456	break;
		457	}
		458	case attr::AssertExclusiveLock: {
		459	bool isInherited = Record.readInt();
		460	bool isImplicit = Record.readInt();
		461	bool isPackExpansion = Record.readInt();
		462	unsigned argsSize = Record.readInt();
		463	SmallVector<Expr *, 4> args;
		464	args.reserve(argsSize);
		465	for (unsigned i = 0; i != argsSize; ++i)
		466	args.push_back(Record.readExpr());
		467	New = new (Context) AssertExclusiveLockAttr(Context, Info, args.data(), argsSize);
		468	cast<InheritableAttr>(New)->setInherited(isInherited);
		469	New->setImplicit(isImplicit);
		470	New->setPackExpansion(isPackExpansion);
		471	break;
		472	}
		473	case attr::AssertSharedLock: {
		474	bool isInherited = Record.readInt();
		475	bool isImplicit = Record.readInt();
		476	bool isPackExpansion = Record.readInt();
		477	unsigned argsSize = Record.readInt();
		478	SmallVector<Expr *, 4> args;
		479	args.reserve(argsSize);
		480	for (unsigned i = 0; i != argsSize; ++i)
		481	args.push_back(Record.readExpr());
		482	New = new (Context) AssertSharedLockAttr(Context, Info, args.data(), argsSize);
		483	cast<InheritableAttr>(New)->setInherited(isInherited);
		484	New->setImplicit(isImplicit);
		485	New->setPackExpansion(isPackExpansion);
		486	break;
		487	}
		488	case attr::AssumeAligned: {
		489	bool isInherited = Record.readInt();
		490	bool isImplicit = Record.readInt();
		491	bool isPackExpansion = Record.readInt();
		492	Expr * alignment = Record.readExpr();
		493	Expr * offset = Record.readExpr();
		494	New = new (Context) AssumeAlignedAttr(Context, Info, alignment, offset);
		495	cast<InheritableAttr>(New)->setInherited(isInherited);
		496	New->setImplicit(isImplicit);
		497	New->setPackExpansion(isPackExpansion);
		498	break;
		499	}
		500	case attr::Assumption: {
		501	bool isInherited = Record.readInt();
		502	bool isImplicit = Record.readInt();
		503	bool isPackExpansion = Record.readInt();
		504	std::string assumption= Record.readString();
		505	New = new (Context) AssumptionAttr(Context, Info, assumption);
		506	cast<InheritableAttr>(New)->setInherited(isInherited);
		507	New->setImplicit(isImplicit);
		508	New->setPackExpansion(isPackExpansion);
		509	break;
		510	}
		511	case attr::Availability: {
		512	bool isInherited = Record.readInt();
		513	bool isImplicit = Record.readInt();
		514	bool isPackExpansion = Record.readInt();
		515	IdentifierInfo * platform = Record.readIdentifier();
		516	VersionTuple introduced= Record.readVersionTuple();
		517	VersionTuple deprecated= Record.readVersionTuple();
		518	VersionTuple obsoleted= Record.readVersionTuple();
		519	bool unavailable = Record.readInt();
		520	std::string message= Record.readString();
		521	bool strict = Record.readInt();
		522	std::string replacement= Record.readString();
		523	int priority = Record.readInt();
		524	New = new (Context) AvailabilityAttr(Context, Info, platform, introduced, deprecated, obsoleted, unavailable, message, strict, replacement, priority);
		525	cast<InheritableAttr>(New)->setInherited(isInherited);
		526	New->setImplicit(isImplicit);
		527	New->setPackExpansion(isPackExpansion);
		528	break;
		529	}
		530	case attr::BPFPreserveAccessIndex: {
		531	bool isInherited = Record.readInt();
		532	bool isImplicit = Record.readInt();
		533	bool isPackExpansion = Record.readInt();
		534	New = new (Context) BPFPreserveAccessIndexAttr(Context, Info);
		535	cast<InheritableAttr>(New)->setInherited(isInherited);
		536	New->setImplicit(isImplicit);
		537	New->setPackExpansion(isPackExpansion);
		538	break;
		539	}
		540	case attr::BTFDeclTag: {
		541	bool isInherited = Record.readInt();
		542	bool isImplicit = Record.readInt();
		543	bool isPackExpansion = Record.readInt();
		544	std::string bTFDeclTag= Record.readString();
		545	New = new (Context) BTFDeclTagAttr(Context, Info, bTFDeclTag);
		546	cast<InheritableAttr>(New)->setInherited(isInherited);
		547	New->setImplicit(isImplicit);
		548	New->setPackExpansion(isPackExpansion);
		549	break;
		550	}
		551	case attr::BTFTypeTag: {
		552	bool isImplicit = Record.readInt();
		553	bool isPackExpansion = Record.readInt();
		554	std::string bTFTypeTag= Record.readString();
		555	New = new (Context) BTFTypeTagAttr(Context, Info, bTFTypeTag);
		556	New->setImplicit(isImplicit);
		557	New->setPackExpansion(isPackExpansion);
		558	break;
		559	}
		560	case attr::Blocks: {
		561	bool isInherited = Record.readInt();
		562	bool isImplicit = Record.readInt();
		563	bool isPackExpansion = Record.readInt();
		564	BlocksAttr::BlockType type(static_cast<BlocksAttr::BlockType>(Record.readInt()));
		565	New = new (Context) BlocksAttr(Context, Info, type);
		566	cast<InheritableAttr>(New)->setInherited(isInherited);
		567	New->setImplicit(isImplicit);
		568	New->setPackExpansion(isPackExpansion);
		569	break;
		570	}
		571	case attr::Builtin: {
		572	bool isInherited = Record.readInt();
		573	bool isImplicit = Record.readInt();
		574	bool isPackExpansion = Record.readInt();
		575	unsigned iD = Record.readInt();
		576	New = new (Context) BuiltinAttr(Context, Info, iD);
		577	cast<InheritableAttr>(New)->setInherited(isInherited);
		578	New->setImplicit(isImplicit);
		579	New->setPackExpansion(isPackExpansion);
		580	break;
		581	}
		582	case attr::BuiltinAlias: {
		583	bool isImplicit = Record.readInt();
		584	bool isPackExpansion = Record.readInt();
		585	IdentifierInfo * builtinName = Record.readIdentifier();
		586	New = new (Context) BuiltinAliasAttr(Context, Info, builtinName);
		587	New->setImplicit(isImplicit);
		588	New->setPackExpansion(isPackExpansion);
		589	break;
		590	}
		591	case attr::C11NoReturn: {
		592	bool isInherited = Record.readInt();
		593	bool isImplicit = Record.readInt();
		594	bool isPackExpansion = Record.readInt();
		595	New = new (Context) C11NoReturnAttr(Context, Info);
		596	cast<InheritableAttr>(New)->setInherited(isInherited);
		597	New->setImplicit(isImplicit);
		598	New->setPackExpansion(isPackExpansion);
		599	break;
		600	}
		601	case attr::CDecl: {
		602	bool isInherited = Record.readInt();
		603	bool isImplicit = Record.readInt();
		604	bool isPackExpansion = Record.readInt();
		605	New = new (Context) CDeclAttr(Context, Info);
		606	cast<InheritableAttr>(New)->setInherited(isInherited);
		607	New->setImplicit(isImplicit);
		608	New->setPackExpansion(isPackExpansion);
		609	break;
		610	}
		611	case attr::CFAuditedTransfer: {
		612	bool isInherited = Record.readInt();
		613	bool isImplicit = Record.readInt();
		614	bool isPackExpansion = Record.readInt();
		615	New = new (Context) CFAuditedTransferAttr(Context, Info);
		616	cast<InheritableAttr>(New)->setInherited(isInherited);
		617	New->setImplicit(isImplicit);
		618	New->setPackExpansion(isPackExpansion);
		619	break;
		620	}
		621	case attr::CFConsumed: {
		622	bool isInherited = Record.readInt();
		623	bool isImplicit = Record.readInt();
		624	bool isPackExpansion = Record.readInt();
		625	New = new (Context) CFConsumedAttr(Context, Info);
		626	cast<InheritableAttr>(New)->setInherited(isInherited);
		627	New->setImplicit(isImplicit);
		628	New->setPackExpansion(isPackExpansion);
		629	break;
		630	}
		631	case attr::CFGuard: {
		632	bool isInherited = Record.readInt();
		633	bool isImplicit = Record.readInt();
		634	bool isPackExpansion = Record.readInt();
		635	CFGuardAttr::GuardArg guard(static_cast<CFGuardAttr::GuardArg>(Record.readInt()));
		636	New = new (Context) CFGuardAttr(Context, Info, guard);
		637	cast<InheritableAttr>(New)->setInherited(isInherited);
		638	New->setImplicit(isImplicit);
		639	New->setPackExpansion(isPackExpansion);
		640	break;
		641	}
		642	case attr::CFICanonicalJumpTable: {
		643	bool isInherited = Record.readInt();
		644	bool isImplicit = Record.readInt();
		645	bool isPackExpansion = Record.readInt();
		646	New = new (Context) CFICanonicalJumpTableAttr(Context, Info);
		647	cast<InheritableAttr>(New)->setInherited(isInherited);
		648	New->setImplicit(isImplicit);
		649	New->setPackExpansion(isPackExpansion);
		650	break;
		651	}
		652	case attr::CFReturnsNotRetained: {
		653	bool isInherited = Record.readInt();
		654	bool isImplicit = Record.readInt();
		655	bool isPackExpansion = Record.readInt();
		656	New = new (Context) CFReturnsNotRetainedAttr(Context, Info);
		657	cast<InheritableAttr>(New)->setInherited(isInherited);
		658	New->setImplicit(isImplicit);
		659	New->setPackExpansion(isPackExpansion);
		660	break;
		661	}
		662	case attr::CFReturnsRetained: {
		663	bool isInherited = Record.readInt();
		664	bool isImplicit = Record.readInt();
		665	bool isPackExpansion = Record.readInt();
		666	New = new (Context) CFReturnsRetainedAttr(Context, Info);
		667	cast<InheritableAttr>(New)->setInherited(isInherited);
		668	New->setImplicit(isImplicit);
		669	New->setPackExpansion(isPackExpansion);
		670	break;
		671	}
		672	case attr::CFUnknownTransfer: {
		673	bool isInherited = Record.readInt();
		674	bool isImplicit = Record.readInt();
		675	bool isPackExpansion = Record.readInt();
		676	New = new (Context) CFUnknownTransferAttr(Context, Info);
		677	cast<InheritableAttr>(New)->setInherited(isInherited);
		678	New->setImplicit(isImplicit);
		679	New->setPackExpansion(isPackExpansion);
		680	break;
		681	}
		682	case attr::CPUDispatch: {
		683	bool isInherited = Record.readInt();
		684	bool isImplicit = Record.readInt();
		685	bool isPackExpansion = Record.readInt();
		686	unsigned cpusSize = Record.readInt();
		687	SmallVector<IdentifierInfo *, 4> cpus;
		688	cpus.reserve(cpusSize);
		689	for (unsigned i = 0; i != cpusSize; ++i)
		690	cpus.push_back(Record.readIdentifier());
		691	New = new (Context) CPUDispatchAttr(Context, Info, cpus.data(), cpusSize);
		692	cast<InheritableAttr>(New)->setInherited(isInherited);
		693	New->setImplicit(isImplicit);
		694	New->setPackExpansion(isPackExpansion);
		695	break;
		696	}
		697	case attr::CPUSpecific: {
		698	bool isInherited = Record.readInt();
		699	bool isImplicit = Record.readInt();
		700	bool isPackExpansion = Record.readInt();
		701	unsigned cpusSize = Record.readInt();
		702	SmallVector<IdentifierInfo *, 4> cpus;
		703	cpus.reserve(cpusSize);
		704	for (unsigned i = 0; i != cpusSize; ++i)
		705	cpus.push_back(Record.readIdentifier());
		706	New = new (Context) CPUSpecificAttr(Context, Info, cpus.data(), cpusSize);
		707	cast<InheritableAttr>(New)->setInherited(isInherited);
		708	New->setImplicit(isImplicit);
		709	New->setPackExpansion(isPackExpansion);
		710	break;
		711	}
		712	case attr::CUDAConstant: {
		713	bool isInherited = Record.readInt();
		714	bool isImplicit = Record.readInt();
		715	bool isPackExpansion = Record.readInt();
		716	New = new (Context) CUDAConstantAttr(Context, Info);
		717	cast<InheritableAttr>(New)->setInherited(isInherited);
		718	New->setImplicit(isImplicit);
		719	New->setPackExpansion(isPackExpansion);
		720	break;
		721	}
		722	case attr::CUDADevice: {
		723	bool isInherited = Record.readInt();
		724	bool isImplicit = Record.readInt();
		725	bool isPackExpansion = Record.readInt();
		726	New = new (Context) CUDADeviceAttr(Context, Info);
		727	cast<InheritableAttr>(New)->setInherited(isInherited);
		728	New->setImplicit(isImplicit);
		729	New->setPackExpansion(isPackExpansion);
		730	break;
		731	}
		732	case attr::CUDADeviceBuiltinSurfaceType: {
		733	bool isInherited = Record.readInt();
		734	bool isImplicit = Record.readInt();
		735	bool isPackExpansion = Record.readInt();
		736	New = new (Context) CUDADeviceBuiltinSurfaceTypeAttr(Context, Info);
		737	cast<InheritableAttr>(New)->setInherited(isInherited);
		738	New->setImplicit(isImplicit);
		739	New->setPackExpansion(isPackExpansion);
		740	break;
		741	}
		742	case attr::CUDADeviceBuiltinTextureType: {
		743	bool isInherited = Record.readInt();
		744	bool isImplicit = Record.readInt();
		745	bool isPackExpansion = Record.readInt();
		746	New = new (Context) CUDADeviceBuiltinTextureTypeAttr(Context, Info);
		747	cast<InheritableAttr>(New)->setInherited(isInherited);
		748	New->setImplicit(isImplicit);
		749	New->setPackExpansion(isPackExpansion);
		750	break;
		751	}
		752	case attr::CUDAGlobal: {
		753	bool isInherited = Record.readInt();
		754	bool isImplicit = Record.readInt();
		755	bool isPackExpansion = Record.readInt();
		756	New = new (Context) CUDAGlobalAttr(Context, Info);
		757	cast<InheritableAttr>(New)->setInherited(isInherited);
		758	New->setImplicit(isImplicit);
		759	New->setPackExpansion(isPackExpansion);
		760	break;
		761	}
		762	case attr::CUDAHost: {
		763	bool isInherited = Record.readInt();
		764	bool isImplicit = Record.readInt();
		765	bool isPackExpansion = Record.readInt();
		766	New = new (Context) CUDAHostAttr(Context, Info);
		767	cast<InheritableAttr>(New)->setInherited(isInherited);
		768	New->setImplicit(isImplicit);
		769	New->setPackExpansion(isPackExpansion);
		770	break;
		771	}
		772	case attr::CUDAInvalidTarget: {
		773	bool isInherited = Record.readInt();
		774	bool isImplicit = Record.readInt();
		775	bool isPackExpansion = Record.readInt();
		776	New = new (Context) CUDAInvalidTargetAttr(Context, Info);
		777	cast<InheritableAttr>(New)->setInherited(isInherited);
		778	New->setImplicit(isImplicit);
		779	New->setPackExpansion(isPackExpansion);
		780	break;
		781	}
		782	case attr::CUDALaunchBounds: {
		783	bool isInherited = Record.readInt();
		784	bool isImplicit = Record.readInt();
		785	bool isPackExpansion = Record.readInt();
		786	Expr * maxThreads = Record.readExpr();
		787	Expr * minBlocks = Record.readExpr();
		788	New = new (Context) CUDALaunchBoundsAttr(Context, Info, maxThreads, minBlocks);
		789	cast<InheritableAttr>(New)->setInherited(isInherited);
		790	New->setImplicit(isImplicit);
		791	New->setPackExpansion(isPackExpansion);
		792	break;
		793	}
		794	case attr::CUDAShared: {
		795	bool isInherited = Record.readInt();
		796	bool isImplicit = Record.readInt();
		797	bool isPackExpansion = Record.readInt();
		798	New = new (Context) CUDASharedAttr(Context, Info);
		799	cast<InheritableAttr>(New)->setInherited(isInherited);
		800	New->setImplicit(isImplicit);
		801	New->setPackExpansion(isPackExpansion);
		802	break;
		803	}
		804	case attr::CXX11NoReturn: {
		805	bool isInherited = Record.readInt();
		806	bool isImplicit = Record.readInt();
		807	bool isPackExpansion = Record.readInt();
		808	New = new (Context) CXX11NoReturnAttr(Context, Info);
		809	cast<InheritableAttr>(New)->setInherited(isInherited);
		810	New->setImplicit(isImplicit);
		811	New->setPackExpansion(isPackExpansion);
		812	break;
		813	}
		814	case attr::CallableWhen: {
		815	bool isInherited = Record.readInt();
		816	bool isImplicit = Record.readInt();
		817	bool isPackExpansion = Record.readInt();
		818	unsigned callableStatesSize = Record.readInt();
		819	SmallVector<CallableWhenAttr::ConsumedState, 4> callableStates;
		820	callableStates.reserve(callableStatesSize);
		821	for (unsigned i = callableStatesSize; i; --i)
		822	callableStates.push_back(static_cast<CallableWhenAttr::ConsumedState>(Record.readInt()));
		823	New = new (Context) CallableWhenAttr(Context, Info, callableStates.data(), callableStatesSize);
		824	cast<InheritableAttr>(New)->setInherited(isInherited);
		825	New->setImplicit(isImplicit);
		826	New->setPackExpansion(isPackExpansion);
		827	break;
		828	}
		829	case attr::Callback: {
		830	bool isInherited = Record.readInt();
		831	bool isImplicit = Record.readInt();
		832	bool isPackExpansion = Record.readInt();
		833	unsigned encodingSize = Record.readInt();
		834	SmallVector<int, 4> encoding;
		835	encoding.reserve(encodingSize);
		836	for (unsigned i = 0; i != encodingSize; ++i)
		837	encoding.push_back(Record.readInt());
		838	New = new (Context) CallbackAttr(Context, Info, encoding.data(), encodingSize);
		839	cast<InheritableAttr>(New)->setInherited(isInherited);
		840	New->setImplicit(isImplicit);
		841	New->setPackExpansion(isPackExpansion);
		842	break;
		843	}
		844	case attr::CalledOnce: {
		845	bool isImplicit = Record.readInt();
		846	bool isPackExpansion = Record.readInt();
		847	New = new (Context) CalledOnceAttr(Context, Info);
		848	New->setImplicit(isImplicit);
		849	New->setPackExpansion(isPackExpansion);
		850	break;
		851	}
		852	case attr::Capability: {
		853	bool isInherited = Record.readInt();
		854	bool isImplicit = Record.readInt();
		855	bool isPackExpansion = Record.readInt();
		856	std::string name= Record.readString();
		857	New = new (Context) CapabilityAttr(Context, Info, name);
		858	cast<InheritableAttr>(New)->setInherited(isInherited);
		859	New->setImplicit(isImplicit);
		860	New->setPackExpansion(isPackExpansion);
		861	break;
		862	}
		863	case attr::CapturedRecord: {
		864	bool isInherited = Record.readInt();
		865	bool isImplicit = Record.readInt();
		866	bool isPackExpansion = Record.readInt();
		867	New = new (Context) CapturedRecordAttr(Context, Info);
		868	cast<InheritableAttr>(New)->setInherited(isInherited);
		869	New->setImplicit(isImplicit);
		870	New->setPackExpansion(isPackExpansion);
		871	break;
		872	}
		873	case attr::CarriesDependency: {
		874	bool isInherited = Record.readInt();
		875	bool isImplicit = Record.readInt();
		876	bool isPackExpansion = Record.readInt();
		877	New = new (Context) CarriesDependencyAttr(Context, Info);
		878	cast<InheritableAttr>(New)->setInherited(isInherited);
		879	New->setImplicit(isImplicit);
		880	New->setPackExpansion(isPackExpansion);
		881	break;
		882	}
		883	case attr::Cleanup: {
		884	bool isInherited = Record.readInt();
		885	bool isImplicit = Record.readInt();
		886	bool isPackExpansion = Record.readInt();
		887	FunctionDecl * functionDecl = Record.GetLocalDeclAs<FunctionDecl >(Record.readInt());
		888	New = new (Context) CleanupAttr(Context, Info, functionDecl);
		889	cast<InheritableAttr>(New)->setInherited(isInherited);
		890	New->setImplicit(isImplicit);
		891	New->setPackExpansion(isPackExpansion);
		892	break;
		893	}
		894	case attr::CmseNSCall: {
		895	bool isImplicit = Record.readInt();
		896	bool isPackExpansion = Record.readInt();
		897	New = new (Context) CmseNSCallAttr(Context, Info);
		898	New->setImplicit(isImplicit);
		899	New->setPackExpansion(isPackExpansion);
		900	break;
		901	}
		902	case attr::CmseNSEntry: {
		903	bool isInherited = Record.readInt();
		904	bool isImplicit = Record.readInt();
		905	bool isPackExpansion = Record.readInt();
		906	New = new (Context) CmseNSEntryAttr(Context, Info);
		907	cast<InheritableAttr>(New)->setInherited(isInherited);
		908	New->setImplicit(isImplicit);
		909	New->setPackExpansion(isPackExpansion);
		910	break;
		911	}
		912	case attr::CodeSeg: {
		913	bool isInherited = Record.readInt();
		914	bool isImplicit = Record.readInt();
		915	bool isPackExpansion = Record.readInt();
		916	std::string name= Record.readString();
		917	New = new (Context) CodeSegAttr(Context, Info, name);
		918	cast<InheritableAttr>(New)->setInherited(isInherited);
		919	New->setImplicit(isImplicit);
		920	New->setPackExpansion(isPackExpansion);
		921	break;
		922	}
		923	case attr::Cold: {
		924	bool isInherited = Record.readInt();
		925	bool isImplicit = Record.readInt();
		926	bool isPackExpansion = Record.readInt();
		927	New = new (Context) ColdAttr(Context, Info);
		928	cast<InheritableAttr>(New)->setInherited(isInherited);
		929	New->setImplicit(isImplicit);
		930	New->setPackExpansion(isPackExpansion);
		931	break;
		932	}
		933	case attr::Common: {
		934	bool isInherited = Record.readInt();
		935	bool isImplicit = Record.readInt();
		936	bool isPackExpansion = Record.readInt();
		937	New = new (Context) CommonAttr(Context, Info);
		938	cast<InheritableAttr>(New)->setInherited(isInherited);
		939	New->setImplicit(isImplicit);
		940	New->setPackExpansion(isPackExpansion);
		941	break;
		942	}
		943	case attr::Const: {
		944	bool isInherited = Record.readInt();
		945	bool isImplicit = Record.readInt();
		946	bool isPackExpansion = Record.readInt();
		947	New = new (Context) ConstAttr(Context, Info);
		948	cast<InheritableAttr>(New)->setInherited(isInherited);
		949	New->setImplicit(isImplicit);
		950	New->setPackExpansion(isPackExpansion);
		951	break;
		952	}
		953	case attr::ConstInit: {
		954	bool isInherited = Record.readInt();
		955	bool isImplicit = Record.readInt();
		956	bool isPackExpansion = Record.readInt();
		957	New = new (Context) ConstInitAttr(Context, Info);
		958	cast<InheritableAttr>(New)->setInherited(isInherited);
		959	New->setImplicit(isImplicit);
		960	New->setPackExpansion(isPackExpansion);
		961	break;
		962	}
		963	case attr::Constructor: {
		964	bool isInherited = Record.readInt();
		965	bool isImplicit = Record.readInt();
		966	bool isPackExpansion = Record.readInt();
		967	int priority = Record.readInt();
		968	New = new (Context) ConstructorAttr(Context, Info, priority);
		969	cast<InheritableAttr>(New)->setInherited(isInherited);
		970	New->setImplicit(isImplicit);
		971	New->setPackExpansion(isPackExpansion);
		972	break;
		973	}
		974	case attr::Consumable: {
		975	bool isInherited = Record.readInt();
		976	bool isImplicit = Record.readInt();
		977	bool isPackExpansion = Record.readInt();
		978	ConsumableAttr::ConsumedState defaultState(static_cast<ConsumableAttr::ConsumedState>(Record.readInt()));
		979	New = new (Context) ConsumableAttr(Context, Info, defaultState);
		980	cast<InheritableAttr>(New)->setInherited(isInherited);
		981	New->setImplicit(isImplicit);
		982	New->setPackExpansion(isPackExpansion);
		983	break;
		984	}
		985	case attr::ConsumableAutoCast: {
		986	bool isInherited = Record.readInt();
		987	bool isImplicit = Record.readInt();
		988	bool isPackExpansion = Record.readInt();
		989	New = new (Context) ConsumableAutoCastAttr(Context, Info);
		990	cast<InheritableAttr>(New)->setInherited(isInherited);
		991	New->setImplicit(isImplicit);
		992	New->setPackExpansion(isPackExpansion);
		993	break;
		994	}
		995	case attr::ConsumableSetOnRead: {
		996	bool isInherited = Record.readInt();
		997	bool isImplicit = Record.readInt();
		998	bool isPackExpansion = Record.readInt();
		999	New = new (Context) ConsumableSetOnReadAttr(Context, Info);
		1000	cast<InheritableAttr>(New)->setInherited(isInherited);
		1001	New->setImplicit(isImplicit);
		1002	New->setPackExpansion(isPackExpansion);
		1003	break;
		1004	}
		1005	case attr::Convergent: {
		1006	bool isInherited = Record.readInt();
		1007	bool isImplicit = Record.readInt();
		1008	bool isPackExpansion = Record.readInt();
		1009	New = new (Context) ConvergentAttr(Context, Info);
		1010	cast<InheritableAttr>(New)->setInherited(isInherited);
		1011	New->setImplicit(isImplicit);
		1012	New->setPackExpansion(isPackExpansion);
		1013	break;
		1014	}
		1015	case attr::DLLExport: {
		1016	bool isInherited = Record.readInt();
		1017	bool isImplicit = Record.readInt();
		1018	bool isPackExpansion = Record.readInt();
		1019	New = new (Context) DLLExportAttr(Context, Info);
		1020	cast<InheritableAttr>(New)->setInherited(isInherited);
		1021	New->setImplicit(isImplicit);
		1022	New->setPackExpansion(isPackExpansion);
		1023	break;
		1024	}
		1025	case attr::DLLExportStaticLocal: {
		1026	bool isInherited = Record.readInt();
		1027	bool isImplicit = Record.readInt();
		1028	bool isPackExpansion = Record.readInt();
		1029	New = new (Context) DLLExportStaticLocalAttr(Context, Info);
		1030	cast<InheritableAttr>(New)->setInherited(isInherited);
		1031	New->setImplicit(isImplicit);
		1032	New->setPackExpansion(isPackExpansion);
		1033	break;
		1034	}
		1035	case attr::DLLImport: {
		1036	bool isInherited = Record.readInt();
		1037	bool isImplicit = Record.readInt();
		1038	bool isPackExpansion = Record.readInt();
		1039	New = new (Context) DLLImportAttr(Context, Info);
		1040	cast<InheritableAttr>(New)->setInherited(isInherited);
		1041	New->setImplicit(isImplicit);
		1042	New->setPackExpansion(isPackExpansion);
		1043	break;
		1044	}
		1045	case attr::DLLImportStaticLocal: {
		1046	bool isInherited = Record.readInt();
		1047	bool isImplicit = Record.readInt();
		1048	bool isPackExpansion = Record.readInt();
		1049	New = new (Context) DLLImportStaticLocalAttr(Context, Info);
		1050	cast<InheritableAttr>(New)->setInherited(isInherited);
		1051	New->setImplicit(isImplicit);
		1052	New->setPackExpansion(isPackExpansion);
		1053	break;
		1054	}
		1055	case attr::Deprecated: {
		1056	bool isInherited = Record.readInt();
		1057	bool isImplicit = Record.readInt();
		1058	bool isPackExpansion = Record.readInt();
		1059	std::string message= Record.readString();
		1060	std::string replacement= Record.readString();
		1061	New = new (Context) DeprecatedAttr(Context, Info, message, replacement);
		1062	cast<InheritableAttr>(New)->setInherited(isInherited);
		1063	New->setImplicit(isImplicit);
		1064	New->setPackExpansion(isPackExpansion);
		1065	break;
		1066	}
		1067	case attr::Destructor: {
		1068	bool isInherited = Record.readInt();
		1069	bool isImplicit = Record.readInt();
		1070	bool isPackExpansion = Record.readInt();
		1071	int priority = Record.readInt();
		1072	New = new (Context) DestructorAttr(Context, Info, priority);
		1073	cast<InheritableAttr>(New)->setInherited(isInherited);
		1074	New->setImplicit(isImplicit);
		1075	New->setPackExpansion(isPackExpansion);
		1076	break;
		1077	}
		1078	case attr::DiagnoseAsBuiltin: {
		1079	bool isInherited = Record.readInt();
		1080	bool isImplicit = Record.readInt();
		1081	bool isPackExpansion = Record.readInt();
		1082	FunctionDecl * function = Record.GetLocalDeclAs<FunctionDecl >(Record.readInt());
		1083	unsigned argIndicesSize = Record.readInt();
		1084	SmallVector<unsigned, 4> argIndices;
		1085	argIndices.reserve(argIndicesSize);
		1086	for (unsigned i = 0; i != argIndicesSize; ++i)
		1087	argIndices.push_back(Record.readInt());
		1088	New = new (Context) DiagnoseAsBuiltinAttr(Context, Info, function, argIndices.data(), argIndicesSize);
		1089	cast<InheritableAttr>(New)->setInherited(isInherited);
		1090	New->setImplicit(isImplicit);
		1091	New->setPackExpansion(isPackExpansion);
		1092	break;
		1093	}
		1094	case attr::DiagnoseIf: {
		1095	bool isInherited = Record.readInt();
		1096	bool isImplicit = Record.readInt();
		1097	bool isPackExpansion = Record.readInt();
		1098	Expr * cond = Record.readExpr();
		1099	std::string message= Record.readString();
		1100	DiagnoseIfAttr::DiagnosticType diagnosticType(static_cast<DiagnoseIfAttr::DiagnosticType>(Record.readInt()));
		1101	bool argDependent = Record.readInt();
		1102	NamedDecl * parent = Record.GetLocalDeclAs<NamedDecl >(Record.readInt());
		1103	New = new (Context) DiagnoseIfAttr(Context, Info, cond, message, diagnosticType, argDependent, parent);
		1104	cast<InheritableAttr>(New)->setInherited(isInherited);
		1105	New->setImplicit(isImplicit);
		1106	New->setPackExpansion(isPackExpansion);
		1107	break;
		1108	}
		1109	case attr::DisableSanitizerInstrumentation: {
		1110	bool isInherited = Record.readInt();
		1111	bool isImplicit = Record.readInt();
		1112	bool isPackExpansion = Record.readInt();
		1113	New = new (Context) DisableSanitizerInstrumentationAttr(Context, Info);
		1114	cast<InheritableAttr>(New)->setInherited(isInherited);
		1115	New->setImplicit(isImplicit);
		1116	New->setPackExpansion(isPackExpansion);
		1117	break;
		1118	}
		1119	case attr::DisableTailCalls: {
		1120	bool isInherited = Record.readInt();
		1121	bool isImplicit = Record.readInt();
		1122	bool isPackExpansion = Record.readInt();
		1123	New = new (Context) DisableTailCallsAttr(Context, Info);
		1124	cast<InheritableAttr>(New)->setInherited(isInherited);
		1125	New->setImplicit(isImplicit);
		1126	New->setPackExpansion(isPackExpansion);
		1127	break;
		1128	}
		1129	case attr::EmptyBases: {
		1130	bool isInherited = Record.readInt();
		1131	bool isImplicit = Record.readInt();
		1132	bool isPackExpansion = Record.readInt();
		1133	New = new (Context) EmptyBasesAttr(Context, Info);
		1134	cast<InheritableAttr>(New)->setInherited(isInherited);
		1135	New->setImplicit(isImplicit);
		1136	New->setPackExpansion(isPackExpansion);
		1137	break;
		1138	}
		1139	case attr::EnableIf: {
		1140	bool isInherited = Record.readInt();
		1141	bool isImplicit = Record.readInt();
		1142	bool isPackExpansion = Record.readInt();
		1143	Expr * cond = Record.readExpr();
		1144	std::string message= Record.readString();
		1145	New = new (Context) EnableIfAttr(Context, Info, cond, message);
		1146	cast<InheritableAttr>(New)->setInherited(isInherited);
		1147	New->setImplicit(isImplicit);
		1148	New->setPackExpansion(isPackExpansion);
		1149	break;
		1150	}
		1151	case attr::EnforceTCB: {
		1152	bool isInherited = Record.readInt();
		1153	bool isImplicit = Record.readInt();
		1154	bool isPackExpansion = Record.readInt();
		1155	std::string tCBName= Record.readString();
		1156	New = new (Context) EnforceTCBAttr(Context, Info, tCBName);
		1157	cast<InheritableAttr>(New)->setInherited(isInherited);
		1158	New->setImplicit(isImplicit);
		1159	New->setPackExpansion(isPackExpansion);
		1160	break;
		1161	}
		1162	case attr::EnforceTCBLeaf: {
		1163	bool isInherited = Record.readInt();
		1164	bool isImplicit = Record.readInt();
		1165	bool isPackExpansion = Record.readInt();
		1166	std::string tCBName= Record.readString();
		1167	New = new (Context) EnforceTCBLeafAttr(Context, Info, tCBName);
		1168	cast<InheritableAttr>(New)->setInherited(isInherited);
		1169	New->setImplicit(isImplicit);
		1170	New->setPackExpansion(isPackExpansion);
		1171	break;
		1172	}
		1173	case attr::EnumExtensibility: {
		1174	bool isInherited = Record.readInt();
		1175	bool isImplicit = Record.readInt();
		1176	bool isPackExpansion = Record.readInt();
		1177	EnumExtensibilityAttr::Kind extensibility(static_cast<EnumExtensibilityAttr::Kind>(Record.readInt()));
		1178	New = new (Context) EnumExtensibilityAttr(Context, Info, extensibility);
		1179	cast<InheritableAttr>(New)->setInherited(isInherited);
		1180	New->setImplicit(isImplicit);
		1181	New->setPackExpansion(isPackExpansion);
		1182	break;
		1183	}
		1184	case attr::Error: {
		1185	bool isInherited = Record.readInt();
		1186	bool isImplicit = Record.readInt();
		1187	bool isPackExpansion = Record.readInt();
		1188	std::string userDiagnostic= Record.readString();
		1189	New = new (Context) ErrorAttr(Context, Info, userDiagnostic);
		1190	cast<InheritableAttr>(New)->setInherited(isInherited);
		1191	New->setImplicit(isImplicit);
		1192	New->setPackExpansion(isPackExpansion);
		1193	break;
		1194	}
		1195	case attr::ExcludeFromExplicitInstantiation: {
		1196	bool isInherited = Record.readInt();
		1197	bool isImplicit = Record.readInt();
		1198	bool isPackExpansion = Record.readInt();
		1199	New = new (Context) ExcludeFromExplicitInstantiationAttr(Context, Info);
		1200	cast<InheritableAttr>(New)->setInherited(isInherited);
		1201	New->setImplicit(isImplicit);
		1202	New->setPackExpansion(isPackExpansion);
		1203	break;
		1204	}
		1205	case attr::ExclusiveTrylockFunction: {
		1206	bool isInherited = Record.readInt();
		1207	bool isImplicit = Record.readInt();
		1208	bool isPackExpansion = Record.readInt();
		1209	Expr * successValue = Record.readExpr();
		1210	unsigned argsSize = Record.readInt();
		1211	SmallVector<Expr *, 4> args;
		1212	args.reserve(argsSize);
		1213	for (unsigned i = 0; i != argsSize; ++i)
		1214	args.push_back(Record.readExpr());
		1215	New = new (Context) ExclusiveTrylockFunctionAttr(Context, Info, successValue, args.data(), argsSize);
		1216	cast<InheritableAttr>(New)->setInherited(isInherited);
		1217	New->setImplicit(isImplicit);
		1218	New->setPackExpansion(isPackExpansion);
		1219	break;
		1220	}
		1221	case attr::ExternalSourceSymbol: {
		1222	bool isInherited = Record.readInt();
		1223	bool isImplicit = Record.readInt();
		1224	bool isPackExpansion = Record.readInt();
		1225	std::string language= Record.readString();
		1226	std::string definedIn= Record.readString();
		1227	bool generatedDeclaration = Record.readInt();
		1228	New = new (Context) ExternalSourceSymbolAttr(Context, Info, language, definedIn, generatedDeclaration);
		1229	cast<InheritableAttr>(New)->setInherited(isInherited);
		1230	New->setImplicit(isImplicit);
		1231	New->setPackExpansion(isPackExpansion);
		1232	break;
		1233	}
		1234	case attr::FallThrough: {
		1235	bool isImplicit = Record.readInt();
		1236	bool isPackExpansion = Record.readInt();
		1237	New = new (Context) FallThroughAttr(Context, Info);
		1238	New->setImplicit(isImplicit);
		1239	New->setPackExpansion(isPackExpansion);
		1240	break;
		1241	}
		1242	case attr::FastCall: {
		1243	bool isInherited = Record.readInt();
		1244	bool isImplicit = Record.readInt();
		1245	bool isPackExpansion = Record.readInt();
		1246	New = new (Context) FastCallAttr(Context, Info);
		1247	cast<InheritableAttr>(New)->setInherited(isInherited);
		1248	New->setImplicit(isImplicit);
		1249	New->setPackExpansion(isPackExpansion);
		1250	break;
		1251	}
		1252	case attr::Final: {
		1253	bool isInherited = Record.readInt();
		1254	bool isImplicit = Record.readInt();
		1255	bool isPackExpansion = Record.readInt();
		1256	New = new (Context) FinalAttr(Context, Info);
		1257	cast<InheritableAttr>(New)->setInherited(isInherited);
		1258	New->setImplicit(isImplicit);
		1259	New->setPackExpansion(isPackExpansion);
		1260	break;
		1261	}
		1262	case attr::FlagEnum: {
		1263	bool isInherited = Record.readInt();
		1264	bool isImplicit = Record.readInt();
		1265	bool isPackExpansion = Record.readInt();
		1266	New = new (Context) FlagEnumAttr(Context, Info);
		1267	cast<InheritableAttr>(New)->setInherited(isInherited);
		1268	New->setImplicit(isImplicit);
		1269	New->setPackExpansion(isPackExpansion);
		1270	break;
		1271	}
		1272	case attr::Flatten: {
		1273	bool isInherited = Record.readInt();
		1274	bool isImplicit = Record.readInt();
		1275	bool isPackExpansion = Record.readInt();
		1276	New = new (Context) FlattenAttr(Context, Info);
		1277	cast<InheritableAttr>(New)->setInherited(isInherited);
		1278	New->setImplicit(isImplicit);
		1279	New->setPackExpansion(isPackExpansion);
		1280	break;
		1281	}
		1282	case attr::Format: {
		1283	bool isInherited = Record.readInt();
		1284	bool isImplicit = Record.readInt();
		1285	bool isPackExpansion = Record.readInt();
		1286	IdentifierInfo * type = Record.readIdentifier();
		1287	int formatIdx = Record.readInt();
		1288	int firstArg = Record.readInt();
		1289	New = new (Context) FormatAttr(Context, Info, type, formatIdx, firstArg);
		1290	cast<InheritableAttr>(New)->setInherited(isInherited);
		1291	New->setImplicit(isImplicit);
		1292	New->setPackExpansion(isPackExpansion);
		1293	break;
		1294	}
		1295	case attr::FormatArg: {
		1296	bool isInherited = Record.readInt();
		1297	bool isImplicit = Record.readInt();
		1298	bool isPackExpansion = Record.readInt();
		1299	ParamIdx formatIdx = ParamIdx::deserialize(Record.readInt());
		1300	New = new (Context) FormatArgAttr(Context, Info, formatIdx);
		1301	cast<InheritableAttr>(New)->setInherited(isInherited);
		1302	New->setImplicit(isImplicit);
		1303	New->setPackExpansion(isPackExpansion);
		1304	break;
		1305	}
		1306	case attr::FunctionReturnThunks: {
		1307	bool isInherited = Record.readInt();
		1308	bool isImplicit = Record.readInt();
		1309	bool isPackExpansion = Record.readInt();
		1310	FunctionReturnThunksAttr::Kind thunkType(static_cast<FunctionReturnThunksAttr::Kind>(Record.readInt()));
		1311	New = new (Context) FunctionReturnThunksAttr(Context, Info, thunkType);
		1312	cast<InheritableAttr>(New)->setInherited(isInherited);
		1313	New->setImplicit(isImplicit);
		1314	New->setPackExpansion(isPackExpansion);
		1315	break;
		1316	}
		1317	case attr::GNUInline: {
		1318	bool isInherited = Record.readInt();
		1319	bool isImplicit = Record.readInt();
		1320	bool isPackExpansion = Record.readInt();
		1321	New = new (Context) GNUInlineAttr(Context, Info);
		1322	cast<InheritableAttr>(New)->setInherited(isInherited);
		1323	New->setImplicit(isImplicit);
		1324	New->setPackExpansion(isPackExpansion);
		1325	break;
		1326	}
		1327	case attr::GuardedBy: {
		1328	bool isInherited = Record.readInt();
		1329	bool isImplicit = Record.readInt();
		1330	bool isPackExpansion = Record.readInt();
		1331	Expr * arg = Record.readExpr();
		1332	New = new (Context) GuardedByAttr(Context, Info, arg);
		1333	cast<InheritableAttr>(New)->setInherited(isInherited);
		1334	New->setImplicit(isImplicit);
		1335	New->setPackExpansion(isPackExpansion);
		1336	break;
		1337	}
		1338	case attr::GuardedVar: {
		1339	bool isInherited = Record.readInt();
		1340	bool isImplicit = Record.readInt();
		1341	bool isPackExpansion = Record.readInt();
		1342	New = new (Context) GuardedVarAttr(Context, Info);
		1343	cast<InheritableAttr>(New)->setInherited(isInherited);
		1344	New->setImplicit(isImplicit);
		1345	New->setPackExpansion(isPackExpansion);
		1346	break;
		1347	}
		1348	case attr::HIPManaged: {
		1349	bool isInherited = Record.readInt();
		1350	bool isImplicit = Record.readInt();
		1351	bool isPackExpansion = Record.readInt();
		1352	New = new (Context) HIPManagedAttr(Context, Info);
		1353	cast<InheritableAttr>(New)->setInherited(isInherited);
		1354	New->setImplicit(isImplicit);
		1355	New->setPackExpansion(isPackExpansion);
		1356	break;
		1357	}
		1358	case attr::HLSLGroupSharedAddressSpace: {
		1359	bool isImplicit = Record.readInt();
		1360	bool isPackExpansion = Record.readInt();
		1361	New = new (Context) HLSLGroupSharedAddressSpaceAttr(Context, Info);
		1362	New->setImplicit(isImplicit);
		1363	New->setPackExpansion(isPackExpansion);
		1364	break;
		1365	}
		1366	case attr::HLSLNumThreads: {
		1367	bool isInherited = Record.readInt();
		1368	bool isImplicit = Record.readInt();
		1369	bool isPackExpansion = Record.readInt();
		1370	int x = Record.readInt();
		1371	int y = Record.readInt();
		1372	int z = Record.readInt();
		1373	New = new (Context) HLSLNumThreadsAttr(Context, Info, x, y, z);
		1374	cast<InheritableAttr>(New)->setInherited(isInherited);
		1375	New->setImplicit(isImplicit);
		1376	New->setPackExpansion(isPackExpansion);
		1377	break;
		1378	}
		1379	case attr::HLSLResource: {
		1380	bool isInherited = Record.readInt();
		1381	bool isImplicit = Record.readInt();
		1382	bool isPackExpansion = Record.readInt();
		1383	HLSLResourceAttr::ResourceClass resourceType(static_cast<HLSLResourceAttr::ResourceClass>(Record.readInt()));
		1384	HLSLResourceAttr::ResourceKind resourceShape(static_cast<HLSLResourceAttr::ResourceKind>(Record.readInt()));
		1385	New = new (Context) HLSLResourceAttr(Context, Info, resourceType, resourceShape);
		1386	cast<InheritableAttr>(New)->setInherited(isInherited);
		1387	New->setImplicit(isImplicit);
		1388	New->setPackExpansion(isPackExpansion);
		1389	break;
		1390	}
		1391	case attr::HLSLResourceBinding: {
		1392	bool isInherited = Record.readInt();
		1393	bool isImplicit = Record.readInt();
		1394	bool isPackExpansion = Record.readInt();
		1395	std::string slot= Record.readString();
		1396	std::string space= Record.readString();
		1397	New = new (Context) HLSLResourceBindingAttr(Context, Info, slot, space);
		1398	cast<InheritableAttr>(New)->setInherited(isInherited);
		1399	New->setImplicit(isImplicit);
		1400	New->setPackExpansion(isPackExpansion);
		1401	break;
		1402	}
		1403	case attr::HLSLSV_DispatchThreadID: {
		1404	bool isInherited = Record.readInt();
		1405	bool isImplicit = Record.readInt();
		1406	bool isPackExpansion = Record.readInt();
		1407	New = new (Context) HLSLSV_DispatchThreadIDAttr(Context, Info);
		1408	cast<InheritableAttr>(New)->setInherited(isInherited);
		1409	New->setImplicit(isImplicit);
		1410	New->setPackExpansion(isPackExpansion);
		1411	break;
		1412	}
		1413	case attr::HLSLSV_GroupIndex: {
		1414	bool isInherited = Record.readInt();
		1415	bool isImplicit = Record.readInt();
		1416	bool isPackExpansion = Record.readInt();
		1417	New = new (Context) HLSLSV_GroupIndexAttr(Context, Info);
		1418	cast<InheritableAttr>(New)->setInherited(isInherited);
		1419	New->setImplicit(isImplicit);
		1420	New->setPackExpansion(isPackExpansion);
		1421	break;
		1422	}
		1423	case attr::HLSLShader: {
		1424	bool isInherited = Record.readInt();
		1425	bool isImplicit = Record.readInt();
		1426	bool isPackExpansion = Record.readInt();
		1427	HLSLShaderAttr::ShaderType type(static_cast<HLSLShaderAttr::ShaderType>(Record.readInt()));
		1428	New = new (Context) HLSLShaderAttr(Context, Info, type);
		1429	cast<InheritableAttr>(New)->setInherited(isInherited);
		1430	New->setImplicit(isImplicit);
		1431	New->setPackExpansion(isPackExpansion);
		1432	break;
		1433	}
		1434	case attr::Hot: {
		1435	bool isInherited = Record.readInt();
		1436	bool isImplicit = Record.readInt();
		1437	bool isPackExpansion = Record.readInt();
		1438	New = new (Context) HotAttr(Context, Info);
		1439	cast<InheritableAttr>(New)->setInherited(isInherited);
		1440	New->setImplicit(isImplicit);
		1441	New->setPackExpansion(isPackExpansion);
		1442	break;
		1443	}
		1444	case attr::IBAction: {
		1445	bool isInherited = Record.readInt();
		1446	bool isImplicit = Record.readInt();
		1447	bool isPackExpansion = Record.readInt();
		1448	New = new (Context) IBActionAttr(Context, Info);
		1449	cast<InheritableAttr>(New)->setInherited(isInherited);
		1450	New->setImplicit(isImplicit);
		1451	New->setPackExpansion(isPackExpansion);
		1452	break;
		1453	}
		1454	case attr::IBOutlet: {
		1455	bool isInherited = Record.readInt();
		1456	bool isImplicit = Record.readInt();
		1457	bool isPackExpansion = Record.readInt();
		1458	New = new (Context) IBOutletAttr(Context, Info);
		1459	cast<InheritableAttr>(New)->setInherited(isInherited);
		1460	New->setImplicit(isImplicit);
		1461	New->setPackExpansion(isPackExpansion);
		1462	break;
		1463	}
		1464	case attr::IBOutletCollection: {
		1465	bool isInherited = Record.readInt();
		1466	bool isImplicit = Record.readInt();
		1467	bool isPackExpansion = Record.readInt();
		1468	TypeSourceInfo * interface_ = Record.readTypeSourceInfo();
		1469	New = new (Context) IBOutletCollectionAttr(Context, Info, interface_);
		1470	cast<InheritableAttr>(New)->setInherited(isInherited);
		1471	New->setImplicit(isImplicit);
		1472	New->setPackExpansion(isPackExpansion);
		1473	break;
		1474	}
		1475	case attr::IFunc: {
		1476	bool isImplicit = Record.readInt();
		1477	bool isPackExpansion = Record.readInt();
		1478	std::string resolver= Record.readString();
		1479	New = new (Context) IFuncAttr(Context, Info, resolver);
		1480	New->setImplicit(isImplicit);
		1481	New->setPackExpansion(isPackExpansion);
		1482	break;
		1483	}
		1484	case attr::InitPriority: {
		1485	bool isInherited = Record.readInt();
		1486	bool isImplicit = Record.readInt();
		1487	bool isPackExpansion = Record.readInt();
		1488	unsigned priority = Record.readInt();
		1489	New = new (Context) InitPriorityAttr(Context, Info, priority);
		1490	cast<InheritableAttr>(New)->setInherited(isInherited);
		1491	New->setImplicit(isImplicit);
		1492	New->setPackExpansion(isPackExpansion);
		1493	break;
		1494	}
		1495	case attr::InitSeg: {
		1496	bool isImplicit = Record.readInt();
		1497	bool isPackExpansion = Record.readInt();
		1498	std::string section= Record.readString();
		1499	New = new (Context) InitSegAttr(Context, Info, section);
		1500	New->setImplicit(isImplicit);
		1501	New->setPackExpansion(isPackExpansion);
		1502	break;
		1503	}
		1504	case attr::IntelOclBicc: {
		1505	bool isInherited = Record.readInt();
		1506	bool isImplicit = Record.readInt();
		1507	bool isPackExpansion = Record.readInt();
		1508	New = new (Context) IntelOclBiccAttr(Context, Info);
		1509	cast<InheritableAttr>(New)->setInherited(isInherited);
		1510	New->setImplicit(isImplicit);
		1511	New->setPackExpansion(isPackExpansion);
		1512	break;
		1513	}
		1514	case attr::InternalLinkage: {
		1515	bool isInherited = Record.readInt();
		1516	bool isImplicit = Record.readInt();
		1517	bool isPackExpansion = Record.readInt();
		1518	New = new (Context) InternalLinkageAttr(Context, Info);
		1519	cast<InheritableAttr>(New)->setInherited(isInherited);
		1520	New->setImplicit(isImplicit);
		1521	New->setPackExpansion(isPackExpansion);
		1522	break;
		1523	}
		1524	case attr::LTOVisibilityPublic: {
		1525	bool isInherited = Record.readInt();
		1526	bool isImplicit = Record.readInt();
		1527	bool isPackExpansion = Record.readInt();
		1528	New = new (Context) LTOVisibilityPublicAttr(Context, Info);
		1529	cast<InheritableAttr>(New)->setInherited(isInherited);
		1530	New->setImplicit(isImplicit);
		1531	New->setPackExpansion(isPackExpansion);
		1532	break;
		1533	}
		1534	case attr::LayoutVersion: {
		1535	bool isInherited = Record.readInt();
		1536	bool isImplicit = Record.readInt();
		1537	bool isPackExpansion = Record.readInt();
		1538	unsigned version = Record.readInt();
		1539	New = new (Context) LayoutVersionAttr(Context, Info, version);
		1540	cast<InheritableAttr>(New)->setInherited(isInherited);
		1541	New->setImplicit(isImplicit);
		1542	New->setPackExpansion(isPackExpansion);
		1543	break;
		1544	}
		1545	case attr::Leaf: {
		1546	bool isInherited = Record.readInt();
		1547	bool isImplicit = Record.readInt();
		1548	bool isPackExpansion = Record.readInt();
		1549	New = new (Context) LeafAttr(Context, Info);
		1550	cast<InheritableAttr>(New)->setInherited(isInherited);
		1551	New->setImplicit(isImplicit);
		1552	New->setPackExpansion(isPackExpansion);
		1553	break;
		1554	}
		1555	case attr::LifetimeBound: {
		1556	bool isInherited = Record.readInt();
		1557	bool isImplicit = Record.readInt();
		1558	bool isPackExpansion = Record.readInt();
		1559	New = new (Context) LifetimeBoundAttr(Context, Info);
		1560	cast<InheritableAttr>(New)->setInherited(isInherited);
		1561	New->setImplicit(isImplicit);
		1562	New->setPackExpansion(isPackExpansion);
		1563	break;
		1564	}
		1565	case attr::Likely: {
		1566	bool isImplicit = Record.readInt();
		1567	bool isPackExpansion = Record.readInt();
		1568	New = new (Context) LikelyAttr(Context, Info);
		1569	New->setImplicit(isImplicit);
		1570	New->setPackExpansion(isPackExpansion);
		1571	break;
		1572	}
		1573	case attr::LoaderUninitialized: {
		1574	bool isImplicit = Record.readInt();
		1575	bool isPackExpansion = Record.readInt();
		1576	New = new (Context) LoaderUninitializedAttr(Context, Info);
		1577	New->setImplicit(isImplicit);
		1578	New->setPackExpansion(isPackExpansion);
		1579	break;
		1580	}
		1581	case attr::LockReturned: {
		1582	bool isInherited = Record.readInt();
		1583	bool isImplicit = Record.readInt();
		1584	bool isPackExpansion = Record.readInt();
		1585	Expr * arg = Record.readExpr();
		1586	New = new (Context) LockReturnedAttr(Context, Info, arg);
		1587	cast<InheritableAttr>(New)->setInherited(isInherited);
		1588	New->setImplicit(isImplicit);
		1589	New->setPackExpansion(isPackExpansion);
		1590	break;
		1591	}
		1592	case attr::LocksExcluded: {
		1593	bool isInherited = Record.readInt();
		1594	bool isImplicit = Record.readInt();
		1595	bool isPackExpansion = Record.readInt();
		1596	unsigned argsSize = Record.readInt();
		1597	SmallVector<Expr *, 4> args;
		1598	args.reserve(argsSize);
		1599	for (unsigned i = 0; i != argsSize; ++i)
		1600	args.push_back(Record.readExpr());
		1601	New = new (Context) LocksExcludedAttr(Context, Info, args.data(), argsSize);
		1602	cast<InheritableAttr>(New)->setInherited(isInherited);
		1603	New->setImplicit(isImplicit);
		1604	New->setPackExpansion(isPackExpansion);
		1605	break;
		1606	}
		1607	case attr::LoopHint: {
		1608	bool isImplicit = Record.readInt();
		1609	bool isPackExpansion = Record.readInt();
		1610	LoopHintAttr::OptionType option(static_cast<LoopHintAttr::OptionType>(Record.readInt()));
		1611	LoopHintAttr::LoopHintState state(static_cast<LoopHintAttr::LoopHintState>(Record.readInt()));
		1612	Expr * value = Record.readExpr();
		1613	New = new (Context) LoopHintAttr(Context, Info, option, state, value);
		1614	New->setImplicit(isImplicit);
		1615	New->setPackExpansion(isPackExpansion);
		1616	break;
		1617	}
		1618	case attr::M68kInterrupt: {
		1619	bool isInherited = Record.readInt();
		1620	bool isImplicit = Record.readInt();
		1621	bool isPackExpansion = Record.readInt();
		1622	unsigned number = Record.readInt();
		1623	New = new (Context) M68kInterruptAttr(Context, Info, number);
		1624	cast<InheritableAttr>(New)->setInherited(isInherited);
		1625	New->setImplicit(isImplicit);
		1626	New->setPackExpansion(isPackExpansion);
		1627	break;
		1628	}
		1629	case attr::MIGServerRoutine: {
		1630	bool isInherited = Record.readInt();
		1631	bool isImplicit = Record.readInt();
		1632	bool isPackExpansion = Record.readInt();
		1633	New = new (Context) MIGServerRoutineAttr(Context, Info);
		1634	cast<InheritableAttr>(New)->setInherited(isInherited);
		1635	New->setImplicit(isImplicit);
		1636	New->setPackExpansion(isPackExpansion);
		1637	break;
		1638	}
		1639	case attr::MSABI: {
		1640	bool isInherited = Record.readInt();
		1641	bool isImplicit = Record.readInt();
		1642	bool isPackExpansion = Record.readInt();
		1643	New = new (Context) MSABIAttr(Context, Info);
		1644	cast<InheritableAttr>(New)->setInherited(isInherited);
		1645	New->setImplicit(isImplicit);
		1646	New->setPackExpansion(isPackExpansion);
		1647	break;
		1648	}
		1649	case attr::MSAllocator: {
		1650	bool isInherited = Record.readInt();
		1651	bool isImplicit = Record.readInt();
		1652	bool isPackExpansion = Record.readInt();
		1653	New = new (Context) MSAllocatorAttr(Context, Info);
		1654	cast<InheritableAttr>(New)->setInherited(isInherited);
		1655	New->setImplicit(isImplicit);
		1656	New->setPackExpansion(isPackExpansion);
		1657	break;
		1658	}
		1659	case attr::MSInheritance: {
		1660	bool isInherited = Record.readInt();
		1661	bool isImplicit = Record.readInt();
		1662	bool isPackExpansion = Record.readInt();
		1663	bool bestCase = Record.readInt();
		1664	New = new (Context) MSInheritanceAttr(Context, Info, bestCase);
		1665	cast<InheritableAttr>(New)->setInherited(isInherited);
		1666	New->setImplicit(isImplicit);
		1667	New->setPackExpansion(isPackExpansion);
		1668	break;
		1669	}
		1670	case attr::MSNoVTable: {
		1671	bool isInherited = Record.readInt();
		1672	bool isImplicit = Record.readInt();
		1673	bool isPackExpansion = Record.readInt();
		1674	New = new (Context) MSNoVTableAttr(Context, Info);
		1675	cast<InheritableAttr>(New)->setInherited(isInherited);
		1676	New->setImplicit(isImplicit);
		1677	New->setPackExpansion(isPackExpansion);
		1678	break;
		1679	}
		1680	case attr::MSP430Interrupt: {
		1681	bool isInherited = Record.readInt();
		1682	bool isImplicit = Record.readInt();
		1683	bool isPackExpansion = Record.readInt();
		1684	unsigned number = Record.readInt();
		1685	New = new (Context) MSP430InterruptAttr(Context, Info, number);
		1686	cast<InheritableAttr>(New)->setInherited(isInherited);
		1687	New->setImplicit(isImplicit);
		1688	New->setPackExpansion(isPackExpansion);
		1689	break;
		1690	}
		1691	case attr::MSStruct: {
		1692	bool isInherited = Record.readInt();
		1693	bool isImplicit = Record.readInt();
		1694	bool isPackExpansion = Record.readInt();
		1695	New = new (Context) MSStructAttr(Context, Info);
		1696	cast<InheritableAttr>(New)->setInherited(isInherited);
		1697	New->setImplicit(isImplicit);
		1698	New->setPackExpansion(isPackExpansion);
		1699	break;
		1700	}
		1701	case attr::MSVtorDisp: {
		1702	bool isInherited = Record.readInt();
		1703	bool isImplicit = Record.readInt();
		1704	bool isPackExpansion = Record.readInt();
		1705	unsigned vdm = Record.readInt();
		1706	New = new (Context) MSVtorDispAttr(Context, Info, vdm);
		1707	cast<InheritableAttr>(New)->setInherited(isInherited);
		1708	New->setImplicit(isImplicit);
		1709	New->setPackExpansion(isPackExpansion);
		1710	break;
		1711	}
		1712	case attr::MaxFieldAlignment: {
		1713	bool isInherited = Record.readInt();
		1714	bool isImplicit = Record.readInt();
		1715	bool isPackExpansion = Record.readInt();
		1716	unsigned alignment = Record.readInt();
		1717	New = new (Context) MaxFieldAlignmentAttr(Context, Info, alignment);
		1718	cast<InheritableAttr>(New)->setInherited(isInherited);
		1719	New->setImplicit(isImplicit);
		1720	New->setPackExpansion(isPackExpansion);
		1721	break;
		1722	}
		1723	case attr::MayAlias: {
		1724	bool isInherited = Record.readInt();
		1725	bool isImplicit = Record.readInt();
		1726	bool isPackExpansion = Record.readInt();
		1727	New = new (Context) MayAliasAttr(Context, Info);
		1728	cast<InheritableAttr>(New)->setInherited(isInherited);
		1729	New->setImplicit(isImplicit);
		1730	New->setPackExpansion(isPackExpansion);
		1731	break;
		1732	}
		1733	case attr::MaybeUndef: {
		1734	bool isInherited = Record.readInt();
		1735	bool isImplicit = Record.readInt();
		1736	bool isPackExpansion = Record.readInt();
		1737	New = new (Context) MaybeUndefAttr(Context, Info);
		1738	cast<InheritableAttr>(New)->setInherited(isInherited);
		1739	New->setImplicit(isImplicit);
		1740	New->setPackExpansion(isPackExpansion);
		1741	break;
		1742	}
		1743	case attr::MicroMips: {
		1744	bool isInherited = Record.readInt();
		1745	bool isImplicit = Record.readInt();
		1746	bool isPackExpansion = Record.readInt();
		1747	New = new (Context) MicroMipsAttr(Context, Info);
		1748	cast<InheritableAttr>(New)->setInherited(isInherited);
		1749	New->setImplicit(isImplicit);
		1750	New->setPackExpansion(isPackExpansion);
		1751	break;
		1752	}
		1753	case attr::MinSize: {
		1754	bool isInherited = Record.readInt();
		1755	bool isImplicit = Record.readInt();
		1756	bool isPackExpansion = Record.readInt();
		1757	New = new (Context) MinSizeAttr(Context, Info);
		1758	cast<InheritableAttr>(New)->setInherited(isInherited);
		1759	New->setImplicit(isImplicit);
		1760	New->setPackExpansion(isPackExpansion);
		1761	break;
		1762	}
		1763	case attr::MinVectorWidth: {
		1764	bool isInherited = Record.readInt();
		1765	bool isImplicit = Record.readInt();
		1766	bool isPackExpansion = Record.readInt();
		1767	unsigned vectorWidth = Record.readInt();
		1768	New = new (Context) MinVectorWidthAttr(Context, Info, vectorWidth);
		1769	cast<InheritableAttr>(New)->setInherited(isInherited);
		1770	New->setImplicit(isImplicit);
		1771	New->setPackExpansion(isPackExpansion);
		1772	break;
		1773	}
		1774	case attr::Mips16: {
		1775	bool isInherited = Record.readInt();
		1776	bool isImplicit = Record.readInt();
		1777	bool isPackExpansion = Record.readInt();
		1778	New = new (Context) Mips16Attr(Context, Info);
		1779	cast<InheritableAttr>(New)->setInherited(isInherited);
		1780	New->setImplicit(isImplicit);
		1781	New->setPackExpansion(isPackExpansion);
		1782	break;
		1783	}
		1784	case attr::MipsInterrupt: {
		1785	bool isInherited = Record.readInt();
		1786	bool isImplicit = Record.readInt();
		1787	bool isPackExpansion = Record.readInt();
		1788	MipsInterruptAttr::InterruptType interrupt(static_cast<MipsInterruptAttr::InterruptType>(Record.readInt()));
		1789	New = new (Context) MipsInterruptAttr(Context, Info, interrupt);
		1790	cast<InheritableAttr>(New)->setInherited(isInherited);
		1791	New->setImplicit(isImplicit);
		1792	New->setPackExpansion(isPackExpansion);
		1793	break;
		1794	}
		1795	case attr::MipsLongCall: {
		1796	bool isInherited = Record.readInt();
		1797	bool isImplicit = Record.readInt();
		1798	bool isPackExpansion = Record.readInt();
		1799	New = new (Context) MipsLongCallAttr(Context, Info);
		1800	cast<InheritableAttr>(New)->setInherited(isInherited);
		1801	New->setImplicit(isImplicit);
		1802	New->setPackExpansion(isPackExpansion);
		1803	break;
		1804	}
		1805	case attr::MipsShortCall: {
		1806	bool isInherited = Record.readInt();
		1807	bool isImplicit = Record.readInt();
		1808	bool isPackExpansion = Record.readInt();
		1809	New = new (Context) MipsShortCallAttr(Context, Info);
		1810	cast<InheritableAttr>(New)->setInherited(isInherited);
		1811	New->setImplicit(isImplicit);
		1812	New->setPackExpansion(isPackExpansion);
		1813	break;
		1814	}
		1815	case attr::Mode: {
		1816	bool isImplicit = Record.readInt();
		1817	bool isPackExpansion = Record.readInt();
		1818	IdentifierInfo * mode = Record.readIdentifier();
		1819	New = new (Context) ModeAttr(Context, Info, mode);
		1820	New->setImplicit(isImplicit);
		1821	New->setPackExpansion(isPackExpansion);
		1822	break;
		1823	}
		1824	case attr::MustTail: {
		1825	bool isImplicit = Record.readInt();
		1826	bool isPackExpansion = Record.readInt();
		1827	New = new (Context) MustTailAttr(Context, Info);
		1828	New->setImplicit(isImplicit);
		1829	New->setPackExpansion(isPackExpansion);
		1830	break;
		1831	}
		1832	case attr::NSConsumed: {
		1833	bool isInherited = Record.readInt();
		1834	bool isImplicit = Record.readInt();
		1835	bool isPackExpansion = Record.readInt();
		1836	New = new (Context) NSConsumedAttr(Context, Info);
		1837	cast<InheritableAttr>(New)->setInherited(isInherited);
		1838	New->setImplicit(isImplicit);
		1839	New->setPackExpansion(isPackExpansion);
		1840	break;
		1841	}
		1842	case attr::NSConsumesSelf: {
		1843	bool isInherited = Record.readInt();
		1844	bool isImplicit = Record.readInt();
		1845	bool isPackExpansion = Record.readInt();
		1846	New = new (Context) NSConsumesSelfAttr(Context, Info);
		1847	cast<InheritableAttr>(New)->setInherited(isInherited);
		1848	New->setImplicit(isImplicit);
		1849	New->setPackExpansion(isPackExpansion);
		1850	break;
		1851	}
		1852	case attr::NSErrorDomain: {
		1853	bool isInherited = Record.readInt();
		1854	bool isImplicit = Record.readInt();
		1855	bool isPackExpansion = Record.readInt();
		1856	VarDecl * errorDomain = Record.GetLocalDeclAs<VarDecl >(Record.readInt());
		1857	New = new (Context) NSErrorDomainAttr(Context, Info, errorDomain);
		1858	cast<InheritableAttr>(New)->setInherited(isInherited);
		1859	New->setImplicit(isImplicit);
		1860	New->setPackExpansion(isPackExpansion);
		1861	break;
		1862	}
		1863	case attr::NSReturnsAutoreleased: {
		1864	bool isInherited = Record.readInt();
		1865	bool isImplicit = Record.readInt();
		1866	bool isPackExpansion = Record.readInt();
		1867	New = new (Context) NSReturnsAutoreleasedAttr(Context, Info);
		1868	cast<InheritableAttr>(New)->setInherited(isInherited);
		1869	New->setImplicit(isImplicit);
		1870	New->setPackExpansion(isPackExpansion);
		1871	break;
		1872	}
		1873	case attr::NSReturnsNotRetained: {
		1874	bool isInherited = Record.readInt();
		1875	bool isImplicit = Record.readInt();
		1876	bool isPackExpansion = Record.readInt();
		1877	New = new (Context) NSReturnsNotRetainedAttr(Context, Info);
		1878	cast<InheritableAttr>(New)->setInherited(isInherited);
		1879	New->setImplicit(isImplicit);
		1880	New->setPackExpansion(isPackExpansion);
		1881	break;
		1882	}
		1883	case attr::NSReturnsRetained: {
		1884	bool isInherited = Record.readInt();
		1885	bool isImplicit = Record.readInt();
		1886	bool isPackExpansion = Record.readInt();
		1887	New = new (Context) NSReturnsRetainedAttr(Context, Info);
		1888	cast<InheritableAttr>(New)->setInherited(isInherited);
		1889	New->setImplicit(isImplicit);
		1890	New->setPackExpansion(isPackExpansion);
		1891	break;
		1892	}
		1893	case attr::Naked: {
		1894	bool isInherited = Record.readInt();
		1895	bool isImplicit = Record.readInt();
		1896	bool isPackExpansion = Record.readInt();
		1897	New = new (Context) NakedAttr(Context, Info);
		1898	cast<InheritableAttr>(New)->setInherited(isInherited);
		1899	New->setImplicit(isImplicit);
		1900	New->setPackExpansion(isPackExpansion);
		1901	break;
		1902	}
		1903	case attr::NoAlias: {
		1904	bool isInherited = Record.readInt();
		1905	bool isImplicit = Record.readInt();
		1906	bool isPackExpansion = Record.readInt();
		1907	New = new (Context) NoAliasAttr(Context, Info);
		1908	cast<InheritableAttr>(New)->setInherited(isInherited);
		1909	New->setImplicit(isImplicit);
		1910	New->setPackExpansion(isPackExpansion);
		1911	break;
		1912	}
		1913	case attr::NoBuiltin: {
		1914	bool isImplicit = Record.readInt();
		1915	bool isPackExpansion = Record.readInt();
		1916	unsigned builtinNamesSize = Record.readInt();
		1917	SmallVector<StringRef, 4> builtinNames;
		1918	builtinNames.reserve(builtinNamesSize);
		1919	SmallVector<std::string, 4> builtinNamesStorage;
		1920	builtinNamesStorage.reserve(builtinNamesSize);
		1921	for (unsigned i = 0; i != builtinNamesSize; ++i)
		1922	builtinNamesStorage.push_back(Record.readString());
		1923	for (unsigned i = 0; i != builtinNamesSize; ++i)
		1924	builtinNames.push_back(builtinNamesStorage[i]);
		1925	New = new (Context) NoBuiltinAttr(Context, Info, builtinNames.data(), builtinNamesSize);
		1926	New->setImplicit(isImplicit);
		1927	New->setPackExpansion(isPackExpansion);
		1928	break;
		1929	}
		1930	case attr::NoCommon: {
		1931	bool isInherited = Record.readInt();
		1932	bool isImplicit = Record.readInt();
		1933	bool isPackExpansion = Record.readInt();
		1934	New = new (Context) NoCommonAttr(Context, Info);
		1935	cast<InheritableAttr>(New)->setInherited(isInherited);
		1936	New->setImplicit(isImplicit);
		1937	New->setPackExpansion(isPackExpansion);
		1938	break;
		1939	}
		1940	case attr::NoDebug: {
		1941	bool isInherited = Record.readInt();
		1942	bool isImplicit = Record.readInt();
		1943	bool isPackExpansion = Record.readInt();
		1944	New = new (Context) NoDebugAttr(Context, Info);
		1945	cast<InheritableAttr>(New)->setInherited(isInherited);
		1946	New->setImplicit(isImplicit);
		1947	New->setPackExpansion(isPackExpansion);
		1948	break;
		1949	}
		1950	case attr::NoDeref: {
		1951	bool isImplicit = Record.readInt();
		1952	bool isPackExpansion = Record.readInt();
		1953	New = new (Context) NoDerefAttr(Context, Info);
		1954	New->setImplicit(isImplicit);
		1955	New->setPackExpansion(isPackExpansion);
		1956	break;
		1957	}
		1958	case attr::NoDestroy: {
		1959	bool isInherited = Record.readInt();
		1960	bool isImplicit = Record.readInt();
		1961	bool isPackExpansion = Record.readInt();
		1962	New = new (Context) NoDestroyAttr(Context, Info);
		1963	cast<InheritableAttr>(New)->setInherited(isInherited);
		1964	New->setImplicit(isImplicit);
		1965	New->setPackExpansion(isPackExpansion);
		1966	break;
		1967	}
		1968	case attr::NoDuplicate: {
		1969	bool isInherited = Record.readInt();
		1970	bool isImplicit = Record.readInt();
		1971	bool isPackExpansion = Record.readInt();
		1972	New = new (Context) NoDuplicateAttr(Context, Info);
		1973	cast<InheritableAttr>(New)->setInherited(isInherited);
		1974	New->setImplicit(isImplicit);
		1975	New->setPackExpansion(isPackExpansion);
		1976	break;
		1977	}
		1978	case attr::NoEscape: {
		1979	bool isImplicit = Record.readInt();
		1980	bool isPackExpansion = Record.readInt();
		1981	New = new (Context) NoEscapeAttr(Context, Info);
		1982	New->setImplicit(isImplicit);
		1983	New->setPackExpansion(isPackExpansion);
		1984	break;
		1985	}
		1986	case attr::NoInline: {
		1987	bool isInherited = Record.readInt();
		1988	bool isImplicit = Record.readInt();
		1989	bool isPackExpansion = Record.readInt();
		1990	New = new (Context) NoInlineAttr(Context, Info);
		1991	cast<InheritableAttr>(New)->setInherited(isInherited);
		1992	New->setImplicit(isImplicit);
		1993	New->setPackExpansion(isPackExpansion);
		1994	break;
		1995	}
		1996	case attr::NoInstrumentFunction: {
		1997	bool isInherited = Record.readInt();
		1998	bool isImplicit = Record.readInt();
		1999	bool isPackExpansion = Record.readInt();
		2000	New = new (Context) NoInstrumentFunctionAttr(Context, Info);
		2001	cast<InheritableAttr>(New)->setInherited(isInherited);
		2002	New->setImplicit(isImplicit);
		2003	New->setPackExpansion(isPackExpansion);
		2004	break;
		2005	}
		2006	case attr::NoMerge: {
		2007	bool isInherited = Record.readInt();
		2008	bool isImplicit = Record.readInt();
		2009	bool isPackExpansion = Record.readInt();
		2010	New = new (Context) NoMergeAttr(Context, Info);
		2011	cast<InheritableAttr>(New)->setInherited(isInherited);
		2012	New->setImplicit(isImplicit);
		2013	New->setPackExpansion(isPackExpansion);
		2014	break;
		2015	}
		2016	case attr::NoMicroMips: {
		2017	bool isInherited = Record.readInt();
		2018	bool isImplicit = Record.readInt();
		2019	bool isPackExpansion = Record.readInt();
		2020	New = new (Context) NoMicroMipsAttr(Context, Info);
		2021	cast<InheritableAttr>(New)->setInherited(isInherited);
		2022	New->setImplicit(isImplicit);
		2023	New->setPackExpansion(isPackExpansion);
		2024	break;
		2025	}
		2026	case attr::NoMips16: {
		2027	bool isInherited = Record.readInt();
		2028	bool isImplicit = Record.readInt();
		2029	bool isPackExpansion = Record.readInt();
		2030	New = new (Context) NoMips16Attr(Context, Info);
		2031	cast<InheritableAttr>(New)->setInherited(isInherited);
		2032	New->setImplicit(isImplicit);
		2033	New->setPackExpansion(isPackExpansion);
		2034	break;
		2035	}
		2036	case attr::NoProfileFunction: {
		2037	bool isInherited = Record.readInt();
		2038	bool isImplicit = Record.readInt();
		2039	bool isPackExpansion = Record.readInt();
		2040	New = new (Context) NoProfileFunctionAttr(Context, Info);
		2041	cast<InheritableAttr>(New)->setInherited(isInherited);
		2042	New->setImplicit(isImplicit);
		2043	New->setPackExpansion(isPackExpansion);
		2044	break;
		2045	}
		2046	case attr::NoRandomizeLayout: {
		2047	bool isInherited = Record.readInt();
		2048	bool isImplicit = Record.readInt();
		2049	bool isPackExpansion = Record.readInt();
		2050	New = new (Context) NoRandomizeLayoutAttr(Context, Info);
		2051	cast<InheritableAttr>(New)->setInherited(isInherited);
		2052	New->setImplicit(isImplicit);
		2053	New->setPackExpansion(isPackExpansion);
		2054	break;
		2055	}
		2056	case attr::NoReturn: {
		2057	bool isInherited = Record.readInt();
		2058	bool isImplicit = Record.readInt();
		2059	bool isPackExpansion = Record.readInt();
		2060	New = new (Context) NoReturnAttr(Context, Info);
		2061	cast<InheritableAttr>(New)->setInherited(isInherited);
		2062	New->setImplicit(isImplicit);
		2063	New->setPackExpansion(isPackExpansion);
		2064	break;
		2065	}
		2066	case attr::NoSanitize: {
		2067	bool isInherited = Record.readInt();
		2068	bool isImplicit = Record.readInt();
		2069	bool isPackExpansion = Record.readInt();
		2070	unsigned sanitizersSize = Record.readInt();
		2071	SmallVector<StringRef, 4> sanitizers;
		2072	sanitizers.reserve(sanitizersSize);
		2073	SmallVector<std::string, 4> sanitizersStorage;
		2074	sanitizersStorage.reserve(sanitizersSize);
		2075	for (unsigned i = 0; i != sanitizersSize; ++i)
		2076	sanitizersStorage.push_back(Record.readString());
		2077	for (unsigned i = 0; i != sanitizersSize; ++i)
		2078	sanitizers.push_back(sanitizersStorage[i]);
		2079	New = new (Context) NoSanitizeAttr(Context, Info, sanitizers.data(), sanitizersSize);
		2080	cast<InheritableAttr>(New)->setInherited(isInherited);
		2081	New->setImplicit(isImplicit);
		2082	New->setPackExpansion(isPackExpansion);
		2083	break;
		2084	}
		2085	case attr::NoSpeculativeLoadHardening: {
		2086	bool isInherited = Record.readInt();
		2087	bool isImplicit = Record.readInt();
		2088	bool isPackExpansion = Record.readInt();
		2089	New = new (Context) NoSpeculativeLoadHardeningAttr(Context, Info);
		2090	cast<InheritableAttr>(New)->setInherited(isInherited);
		2091	New->setImplicit(isImplicit);
		2092	New->setPackExpansion(isPackExpansion);
		2093	break;
		2094	}
		2095	case attr::NoSplitStack: {
		2096	bool isInherited = Record.readInt();
		2097	bool isImplicit = Record.readInt();
		2098	bool isPackExpansion = Record.readInt();
		2099	New = new (Context) NoSplitStackAttr(Context, Info);
		2100	cast<InheritableAttr>(New)->setInherited(isInherited);
		2101	New->setImplicit(isImplicit);
		2102	New->setPackExpansion(isPackExpansion);
		2103	break;
		2104	}
		2105	case attr::NoStackProtector: {
		2106	bool isInherited = Record.readInt();
		2107	bool isImplicit = Record.readInt();
		2108	bool isPackExpansion = Record.readInt();
		2109	New = new (Context) NoStackProtectorAttr(Context, Info);
		2110	cast<InheritableAttr>(New)->setInherited(isInherited);
		2111	New->setImplicit(isImplicit);
		2112	New->setPackExpansion(isPackExpansion);
		2113	break;
		2114	}
		2115	case attr::NoThreadSafetyAnalysis: {
		2116	bool isInherited = Record.readInt();
		2117	bool isImplicit = Record.readInt();
		2118	bool isPackExpansion = Record.readInt();
		2119	New = new (Context) NoThreadSafetyAnalysisAttr(Context, Info);
		2120	cast<InheritableAttr>(New)->setInherited(isInherited);
		2121	New->setImplicit(isImplicit);
		2122	New->setPackExpansion(isPackExpansion);
		2123	break;
		2124	}
		2125	case attr::NoThrow: {
		2126	bool isInherited = Record.readInt();
		2127	bool isImplicit = Record.readInt();
		2128	bool isPackExpansion = Record.readInt();
		2129	New = new (Context) NoThrowAttr(Context, Info);
		2130	cast<InheritableAttr>(New)->setInherited(isInherited);
		2131	New->setImplicit(isImplicit);
		2132	New->setPackExpansion(isPackExpansion);
		2133	break;
		2134	}
		2135	case attr::NoUniqueAddress: {
		2136	bool isInherited = Record.readInt();
		2137	bool isImplicit = Record.readInt();
		2138	bool isPackExpansion = Record.readInt();
		2139	New = new (Context) NoUniqueAddressAttr(Context, Info);
		2140	cast<InheritableAttr>(New)->setInherited(isInherited);
		2141	New->setImplicit(isImplicit);
		2142	New->setPackExpansion(isPackExpansion);
		2143	break;
		2144	}
		2145	case attr::NoUwtable: {
		2146	bool isInherited = Record.readInt();
		2147	bool isImplicit = Record.readInt();
		2148	bool isPackExpansion = Record.readInt();
		2149	New = new (Context) NoUwtableAttr(Context, Info);
		2150	cast<InheritableAttr>(New)->setInherited(isInherited);
		2151	New->setImplicit(isImplicit);
		2152	New->setPackExpansion(isPackExpansion);
		2153	break;
		2154	}
		2155	case attr::NonNull: {
		2156	bool isInherited = Record.readInt();
		2157	bool isImplicit = Record.readInt();
		2158	bool isPackExpansion = Record.readInt();
		2159	unsigned argsSize = Record.readInt();
		2160	SmallVector<ParamIdx, 4> args;
		2161	args.reserve(argsSize);
		2162	for (unsigned i = 0; i != argsSize; ++i)
		2163	args.push_back(ParamIdx::deserialize(Record.readInt()));
		2164	New = new (Context) NonNullAttr(Context, Info, args.data(), argsSize);
		2165	cast<InheritableAttr>(New)->setInherited(isInherited);
		2166	New->setImplicit(isImplicit);
		2167	New->setPackExpansion(isPackExpansion);
		2168	break;
		2169	}
		2170	case attr::NotTailCalled: {
		2171	bool isInherited = Record.readInt();
		2172	bool isImplicit = Record.readInt();
		2173	bool isPackExpansion = Record.readInt();
		2174	New = new (Context) NotTailCalledAttr(Context, Info);
		2175	cast<InheritableAttr>(New)->setInherited(isInherited);
		2176	New->setImplicit(isImplicit);
		2177	New->setPackExpansion(isPackExpansion);
		2178	break;
		2179	}
		2180	case attr::OMPAllocateDecl: {
		2181	bool isInherited = Record.readInt();
		2182	bool isImplicit = Record.readInt();
		2183	bool isPackExpansion = Record.readInt();
		2184	OMPAllocateDeclAttr::AllocatorTypeTy allocatorType(static_cast<OMPAllocateDeclAttr::AllocatorTypeTy>(Record.readInt()));
		2185	Expr * allocator = Record.readExpr();
		2186	Expr * alignment = Record.readExpr();
		2187	New = new (Context) OMPAllocateDeclAttr(Context, Info, allocatorType, allocator, alignment);
		2188	cast<InheritableAttr>(New)->setInherited(isInherited);
		2189	New->setImplicit(isImplicit);
		2190	New->setPackExpansion(isPackExpansion);
		2191	break;
		2192	}
		2193	case attr::OMPCaptureKind: {
		2194	bool isImplicit = Record.readInt();
		2195	bool isPackExpansion = Record.readInt();
		2196	unsigned captureKindVal = Record.readInt();
		2197	New = new (Context) OMPCaptureKindAttr(Context, Info, captureKindVal);
		2198	New->setImplicit(isImplicit);
		2199	New->setPackExpansion(isPackExpansion);
		2200	break;
		2201	}
		2202	case attr::OMPCaptureNoInit: {
		2203	bool isInherited = Record.readInt();
		2204	bool isImplicit = Record.readInt();
		2205	bool isPackExpansion = Record.readInt();
		2206	New = new (Context) OMPCaptureNoInitAttr(Context, Info);
		2207	cast<InheritableAttr>(New)->setInherited(isInherited);
		2208	New->setImplicit(isImplicit);
		2209	New->setPackExpansion(isPackExpansion);
		2210	break;
		2211	}
		2212	case attr::OMPDeclareSimdDecl: {
		2213	bool isImplicit = Record.readInt();
		2214	bool isPackExpansion = Record.readInt();
		2215	OMPDeclareSimdDeclAttr::BranchStateTy branchState(static_cast<OMPDeclareSimdDeclAttr::BranchStateTy>(Record.readInt()));
		2216	Expr * simdlen = Record.readExpr();
		2217	unsigned uniformsSize = Record.readInt();
		2218	SmallVector<Expr *, 4> uniforms;
		2219	uniforms.reserve(uniformsSize);
		2220	for (unsigned i = 0; i != uniformsSize; ++i)
		2221	uniforms.push_back(Record.readExpr());
		2222	unsigned alignedsSize = Record.readInt();
		2223	SmallVector<Expr *, 4> aligneds;
		2224	aligneds.reserve(alignedsSize);
		2225	for (unsigned i = 0; i != alignedsSize; ++i)
		2226	aligneds.push_back(Record.readExpr());
		2227	unsigned alignmentsSize = Record.readInt();
		2228	SmallVector<Expr *, 4> alignments;
		2229	alignments.reserve(alignmentsSize);
		2230	for (unsigned i = 0; i != alignmentsSize; ++i)
		2231	alignments.push_back(Record.readExpr());
		2232	unsigned linearsSize = Record.readInt();
		2233	SmallVector<Expr *, 4> linears;
		2234	linears.reserve(linearsSize);
		2235	for (unsigned i = 0; i != linearsSize; ++i)
		2236	linears.push_back(Record.readExpr());
		2237	unsigned modifiersSize = Record.readInt();
		2238	SmallVector<unsigned, 4> modifiers;
		2239	modifiers.reserve(modifiersSize);
		2240	for (unsigned i = 0; i != modifiersSize; ++i)
		2241	modifiers.push_back(Record.readInt());
		2242	unsigned stepsSize = Record.readInt();
		2243	SmallVector<Expr *, 4> steps;
		2244	steps.reserve(stepsSize);
		2245	for (unsigned i = 0; i != stepsSize; ++i)
		2246	steps.push_back(Record.readExpr());
		2247	New = new (Context) OMPDeclareSimdDeclAttr(Context, Info, branchState, simdlen, uniforms.data(), uniformsSize, aligneds.data(), alignedsSize, alignments.data(), alignmentsSize, linears.data(), linearsSize, modifiers.data(), modifiersSize, steps.data(), stepsSize);
		2248	New->setImplicit(isImplicit);
		2249	New->setPackExpansion(isPackExpansion);
		2250	break;
		2251	}
		2252	case attr::OMPDeclareTargetDecl: {
		2253	bool isInherited = Record.readInt();
		2254	bool isImplicit = Record.readInt();
		2255	bool isPackExpansion = Record.readInt();
		2256	OMPDeclareTargetDeclAttr::MapTypeTy mapType(static_cast<OMPDeclareTargetDeclAttr::MapTypeTy>(Record.readInt()));
		2257	OMPDeclareTargetDeclAttr::DevTypeTy devType(static_cast<OMPDeclareTargetDeclAttr::DevTypeTy>(Record.readInt()));
		2258	Expr * indirectExpr = Record.readExpr();
		2259	bool indirect = Record.readInt();
		2260	unsigned level = Record.readInt();
		2261	New = new (Context) OMPDeclareTargetDeclAttr(Context, Info, mapType, devType, indirectExpr, indirect, level);
		2262	cast<InheritableAttr>(New)->setInherited(isInherited);
		2263	New->setImplicit(isImplicit);
		2264	New->setPackExpansion(isPackExpansion);
		2265	break;
		2266	}
		2267	case attr::OMPDeclareVariant: {
		2268	bool isInherited = Record.readInt();
		2269	bool isImplicit = Record.readInt();
		2270	bool isPackExpansion = Record.readInt();
		2271	Expr * variantFuncRef = Record.readExpr();
		2272	OMPTraitInfo * traitInfos = Record.readOMPTraitInfo();
		2273	unsigned adjustArgsNothingSize = Record.readInt();
		2274	SmallVector<Expr *, 4> adjustArgsNothing;
		2275	adjustArgsNothing.reserve(adjustArgsNothingSize);
		2276	for (unsigned i = 0; i != adjustArgsNothingSize; ++i)
		2277	adjustArgsNothing.push_back(Record.readExpr());
		2278	unsigned adjustArgsNeedDevicePtrSize = Record.readInt();
		2279	SmallVector<Expr *, 4> adjustArgsNeedDevicePtr;
		2280	adjustArgsNeedDevicePtr.reserve(adjustArgsNeedDevicePtrSize);
		2281	for (unsigned i = 0; i != adjustArgsNeedDevicePtrSize; ++i)
		2282	adjustArgsNeedDevicePtr.push_back(Record.readExpr());
		2283	unsigned appendArgsSize = Record.readInt();
		2284	SmallVector<OMPInteropInfo, 4> appendArgs;
		2285	appendArgs.reserve(appendArgsSize);
		2286	for (unsigned I = 0, E = appendArgsSize; I != E; ++I) {
		2287	bool IsTarget = Record.readBool();
		2288	bool IsTargetSync = Record.readBool();
		2289	appendArgs.emplace_back(IsTarget, IsTargetSync);
		2290	}
		2291	New = new (Context) OMPDeclareVariantAttr(Context, Info, variantFuncRef, traitInfos, adjustArgsNothing.data(), adjustArgsNothingSize, adjustArgsNeedDevicePtr.data(), adjustArgsNeedDevicePtrSize, appendArgs.data(), appendArgsSize);
		2292	cast<InheritableAttr>(New)->setInherited(isInherited);
		2293	New->setImplicit(isImplicit);
		2294	New->setPackExpansion(isPackExpansion);
		2295	break;
		2296	}
		2297	case attr::OMPReferencedVar: {
		2298	bool isImplicit = Record.readInt();
		2299	bool isPackExpansion = Record.readInt();
		2300	Expr * ref = Record.readExpr();
		2301	New = new (Context) OMPReferencedVarAttr(Context, Info, ref);
		2302	New->setImplicit(isImplicit);
		2303	New->setPackExpansion(isPackExpansion);
		2304	break;
		2305	}
		2306	case attr::OMPThreadPrivateDecl: {
		2307	bool isInherited = Record.readInt();
		2308	bool isImplicit = Record.readInt();
		2309	bool isPackExpansion = Record.readInt();
		2310	New = new (Context) OMPThreadPrivateDeclAttr(Context, Info);
		2311	cast<InheritableAttr>(New)->setInherited(isInherited);
		2312	New->setImplicit(isImplicit);
		2313	New->setPackExpansion(isPackExpansion);
		2314	break;
		2315	}
		2316	case attr::OSConsumed: {
		2317	bool isInherited = Record.readInt();
		2318	bool isImplicit = Record.readInt();
		2319	bool isPackExpansion = Record.readInt();
		2320	New = new (Context) OSConsumedAttr(Context, Info);
		2321	cast<InheritableAttr>(New)->setInherited(isInherited);
		2322	New->setImplicit(isImplicit);
		2323	New->setPackExpansion(isPackExpansion);
		2324	break;
		2325	}
		2326	case attr::OSConsumesThis: {
		2327	bool isInherited = Record.readInt();
		2328	bool isImplicit = Record.readInt();
		2329	bool isPackExpansion = Record.readInt();
		2330	New = new (Context) OSConsumesThisAttr(Context, Info);
		2331	cast<InheritableAttr>(New)->setInherited(isInherited);
		2332	New->setImplicit(isImplicit);
		2333	New->setPackExpansion(isPackExpansion);
		2334	break;
		2335	}
		2336	case attr::OSReturnsNotRetained: {
		2337	bool isInherited = Record.readInt();
		2338	bool isImplicit = Record.readInt();
		2339	bool isPackExpansion = Record.readInt();
		2340	New = new (Context) OSReturnsNotRetainedAttr(Context, Info);
		2341	cast<InheritableAttr>(New)->setInherited(isInherited);
		2342	New->setImplicit(isImplicit);
		2343	New->setPackExpansion(isPackExpansion);
		2344	break;
		2345	}
		2346	case attr::OSReturnsRetained: {
		2347	bool isInherited = Record.readInt();
		2348	bool isImplicit = Record.readInt();
		2349	bool isPackExpansion = Record.readInt();
		2350	New = new (Context) OSReturnsRetainedAttr(Context, Info);
		2351	cast<InheritableAttr>(New)->setInherited(isInherited);
		2352	New->setImplicit(isImplicit);
		2353	New->setPackExpansion(isPackExpansion);
		2354	break;
		2355	}
		2356	case attr::OSReturnsRetainedOnNonZero: {
		2357	bool isInherited = Record.readInt();
		2358	bool isImplicit = Record.readInt();
		2359	bool isPackExpansion = Record.readInt();
		2360	New = new (Context) OSReturnsRetainedOnNonZeroAttr(Context, Info);
		2361	cast<InheritableAttr>(New)->setInherited(isInherited);
		2362	New->setImplicit(isImplicit);
		2363	New->setPackExpansion(isPackExpansion);
		2364	break;
		2365	}
		2366	case attr::OSReturnsRetainedOnZero: {
		2367	bool isInherited = Record.readInt();
		2368	bool isImplicit = Record.readInt();
		2369	bool isPackExpansion = Record.readInt();
		2370	New = new (Context) OSReturnsRetainedOnZeroAttr(Context, Info);
		2371	cast<InheritableAttr>(New)->setInherited(isInherited);
		2372	New->setImplicit(isImplicit);
		2373	New->setPackExpansion(isPackExpansion);
		2374	break;
		2375	}
		2376	case attr::ObjCBoxable: {
		2377	bool isImplicit = Record.readInt();
		2378	bool isPackExpansion = Record.readInt();
		2379	New = new (Context) ObjCBoxableAttr(Context, Info);
		2380	New->setImplicit(isImplicit);
		2381	New->setPackExpansion(isPackExpansion);
		2382	break;
		2383	}
		2384	case attr::ObjCBridge: {
		2385	bool isInherited = Record.readInt();
		2386	bool isImplicit = Record.readInt();
		2387	bool isPackExpansion = Record.readInt();
		2388	IdentifierInfo * bridgedType = Record.readIdentifier();
		2389	New = new (Context) ObjCBridgeAttr(Context, Info, bridgedType);
		2390	cast<InheritableAttr>(New)->setInherited(isInherited);
		2391	New->setImplicit(isImplicit);
		2392	New->setPackExpansion(isPackExpansion);
		2393	break;
		2394	}
		2395	case attr::ObjCBridgeMutable: {
		2396	bool isInherited = Record.readInt();
		2397	bool isImplicit = Record.readInt();
		2398	bool isPackExpansion = Record.readInt();
		2399	IdentifierInfo * bridgedType = Record.readIdentifier();
		2400	New = new (Context) ObjCBridgeMutableAttr(Context, Info, bridgedType);
		2401	cast<InheritableAttr>(New)->setInherited(isInherited);
		2402	New->setImplicit(isImplicit);
		2403	New->setPackExpansion(isPackExpansion);
		2404	break;
		2405	}
		2406	case attr::ObjCBridgeRelated: {
		2407	bool isInherited = Record.readInt();
		2408	bool isImplicit = Record.readInt();
		2409	bool isPackExpansion = Record.readInt();
		2410	IdentifierInfo * relatedClass = Record.readIdentifier();
		2411	IdentifierInfo * classMethod = Record.readIdentifier();
		2412	IdentifierInfo * instanceMethod = Record.readIdentifier();
		2413	New = new (Context) ObjCBridgeRelatedAttr(Context, Info, relatedClass, classMethod, instanceMethod);
		2414	cast<InheritableAttr>(New)->setInherited(isInherited);
		2415	New->setImplicit(isImplicit);
		2416	New->setPackExpansion(isPackExpansion);
		2417	break;
		2418	}
		2419	case attr::ObjCClassStub: {
		2420	bool isImplicit = Record.readInt();
		2421	bool isPackExpansion = Record.readInt();
		2422	New = new (Context) ObjCClassStubAttr(Context, Info);
		2423	New->setImplicit(isImplicit);
		2424	New->setPackExpansion(isPackExpansion);
		2425	break;
		2426	}
		2427	case attr::ObjCDesignatedInitializer: {
		2428	bool isImplicit = Record.readInt();
		2429	bool isPackExpansion = Record.readInt();
		2430	New = new (Context) ObjCDesignatedInitializerAttr(Context, Info);
		2431	New->setImplicit(isImplicit);
		2432	New->setPackExpansion(isPackExpansion);
		2433	break;
		2434	}
		2435	case attr::ObjCDirect: {
		2436	bool isImplicit = Record.readInt();
		2437	bool isPackExpansion = Record.readInt();
		2438	New = new (Context) ObjCDirectAttr(Context, Info);
		2439	New->setImplicit(isImplicit);
		2440	New->setPackExpansion(isPackExpansion);
		2441	break;
		2442	}
		2443	case attr::ObjCDirectMembers: {
		2444	bool isImplicit = Record.readInt();
		2445	bool isPackExpansion = Record.readInt();
		2446	New = new (Context) ObjCDirectMembersAttr(Context, Info);
		2447	New->setImplicit(isImplicit);
		2448	New->setPackExpansion(isPackExpansion);
		2449	break;
		2450	}
		2451	case attr::ObjCException: {
		2452	bool isInherited = Record.readInt();
		2453	bool isImplicit = Record.readInt();
		2454	bool isPackExpansion = Record.readInt();
		2455	New = new (Context) ObjCExceptionAttr(Context, Info);
		2456	cast<InheritableAttr>(New)->setInherited(isInherited);
		2457	New->setImplicit(isImplicit);
		2458	New->setPackExpansion(isPackExpansion);
		2459	break;
		2460	}
		2461	case attr::ObjCExplicitProtocolImpl: {
		2462	bool isInherited = Record.readInt();
		2463	bool isImplicit = Record.readInt();
		2464	bool isPackExpansion = Record.readInt();
		2465	New = new (Context) ObjCExplicitProtocolImplAttr(Context, Info);
		2466	cast<InheritableAttr>(New)->setInherited(isInherited);
		2467	New->setImplicit(isImplicit);
		2468	New->setPackExpansion(isPackExpansion);
		2469	break;
		2470	}
		2471	case attr::ObjCExternallyRetained: {
		2472	bool isInherited = Record.readInt();
		2473	bool isImplicit = Record.readInt();
		2474	bool isPackExpansion = Record.readInt();
		2475	New = new (Context) ObjCExternallyRetainedAttr(Context, Info);
		2476	cast<InheritableAttr>(New)->setInherited(isInherited);
		2477	New->setImplicit(isImplicit);
		2478	New->setPackExpansion(isPackExpansion);
		2479	break;
		2480	}
		2481	case attr::ObjCGC: {
		2482	bool isImplicit = Record.readInt();
		2483	bool isPackExpansion = Record.readInt();
		2484	IdentifierInfo * kind = Record.readIdentifier();
		2485	New = new (Context) ObjCGCAttr(Context, Info, kind);
		2486	New->setImplicit(isImplicit);
		2487	New->setPackExpansion(isPackExpansion);
		2488	break;
		2489	}
		2490	case attr::ObjCIndependentClass: {
		2491	bool isInherited = Record.readInt();
		2492	bool isImplicit = Record.readInt();
		2493	bool isPackExpansion = Record.readInt();
		2494	New = new (Context) ObjCIndependentClassAttr(Context, Info);
		2495	cast<InheritableAttr>(New)->setInherited(isInherited);
		2496	New->setImplicit(isImplicit);
		2497	New->setPackExpansion(isPackExpansion);
		2498	break;
		2499	}
		2500	case attr::ObjCInertUnsafeUnretained: {
		2501	bool isImplicit = Record.readInt();
		2502	bool isPackExpansion = Record.readInt();
		2503	New = new (Context) ObjCInertUnsafeUnretainedAttr(Context, Info);
		2504	New->setImplicit(isImplicit);
		2505	New->setPackExpansion(isPackExpansion);
		2506	break;
		2507	}
		2508	case attr::ObjCKindOf: {
		2509	bool isImplicit = Record.readInt();
		2510	bool isPackExpansion = Record.readInt();
		2511	New = new (Context) ObjCKindOfAttr(Context, Info);
		2512	New->setImplicit(isImplicit);
		2513	New->setPackExpansion(isPackExpansion);
		2514	break;
		2515	}
		2516	case attr::ObjCMethodFamily: {
		2517	bool isInherited = Record.readInt();
		2518	bool isImplicit = Record.readInt();
		2519	bool isPackExpansion = Record.readInt();
		2520	ObjCMethodFamilyAttr::FamilyKind family(static_cast<ObjCMethodFamilyAttr::FamilyKind>(Record.readInt()));
		2521	New = new (Context) ObjCMethodFamilyAttr(Context, Info, family);
		2522	cast<InheritableAttr>(New)->setInherited(isInherited);
		2523	New->setImplicit(isImplicit);
		2524	New->setPackExpansion(isPackExpansion);
		2525	break;
		2526	}
		2527	case attr::ObjCNSObject: {
		2528	bool isInherited = Record.readInt();
		2529	bool isImplicit = Record.readInt();
		2530	bool isPackExpansion = Record.readInt();
		2531	New = new (Context) ObjCNSObjectAttr(Context, Info);
		2532	cast<InheritableAttr>(New)->setInherited(isInherited);
		2533	New->setImplicit(isImplicit);
		2534	New->setPackExpansion(isPackExpansion);
		2535	break;
		2536	}
		2537	case attr::ObjCNonLazyClass: {
		2538	bool isImplicit = Record.readInt();
		2539	bool isPackExpansion = Record.readInt();
		2540	New = new (Context) ObjCNonLazyClassAttr(Context, Info);
		2541	New->setImplicit(isImplicit);
		2542	New->setPackExpansion(isPackExpansion);
		2543	break;
		2544	}
		2545	case attr::ObjCNonRuntimeProtocol: {
		2546	bool isImplicit = Record.readInt();
		2547	bool isPackExpansion = Record.readInt();
		2548	New = new (Context) ObjCNonRuntimeProtocolAttr(Context, Info);
		2549	New->setImplicit(isImplicit);
		2550	New->setPackExpansion(isPackExpansion);
		2551	break;
		2552	}
		2553	case attr::ObjCOwnership: {
		2554	bool isInherited = Record.readInt();
		2555	bool isImplicit = Record.readInt();
		2556	bool isPackExpansion = Record.readInt();
		2557	IdentifierInfo * kind = Record.readIdentifier();
		2558	New = new (Context) ObjCOwnershipAttr(Context, Info, kind);
		2559	cast<InheritableAttr>(New)->setInherited(isInherited);
		2560	New->setImplicit(isImplicit);
		2561	New->setPackExpansion(isPackExpansion);
		2562	break;
		2563	}
		2564	case attr::ObjCPreciseLifetime: {
		2565	bool isInherited = Record.readInt();
		2566	bool isImplicit = Record.readInt();
		2567	bool isPackExpansion = Record.readInt();
		2568	New = new (Context) ObjCPreciseLifetimeAttr(Context, Info);
		2569	cast<InheritableAttr>(New)->setInherited(isInherited);
		2570	New->setImplicit(isImplicit);
		2571	New->setPackExpansion(isPackExpansion);
		2572	break;
		2573	}
		2574	case attr::ObjCRequiresPropertyDefs: {
		2575	bool isInherited = Record.readInt();
		2576	bool isImplicit = Record.readInt();
		2577	bool isPackExpansion = Record.readInt();
		2578	New = new (Context) ObjCRequiresPropertyDefsAttr(Context, Info);
		2579	cast<InheritableAttr>(New)->setInherited(isInherited);
		2580	New->setImplicit(isImplicit);
		2581	New->setPackExpansion(isPackExpansion);
		2582	break;
		2583	}
		2584	case attr::ObjCRequiresSuper: {
		2585	bool isInherited = Record.readInt();
		2586	bool isImplicit = Record.readInt();
		2587	bool isPackExpansion = Record.readInt();
		2588	New = new (Context) ObjCRequiresSuperAttr(Context, Info);
		2589	cast<InheritableAttr>(New)->setInherited(isInherited);
		2590	New->setImplicit(isImplicit);
		2591	New->setPackExpansion(isPackExpansion);
		2592	break;
		2593	}
		2594	case attr::ObjCReturnsInnerPointer: {
		2595	bool isInherited = Record.readInt();
		2596	bool isImplicit = Record.readInt();
		2597	bool isPackExpansion = Record.readInt();
		2598	New = new (Context) ObjCReturnsInnerPointerAttr(Context, Info);
		2599	cast<InheritableAttr>(New)->setInherited(isInherited);
		2600	New->setImplicit(isImplicit);
		2601	New->setPackExpansion(isPackExpansion);
		2602	break;
		2603	}
		2604	case attr::ObjCRootClass: {
		2605	bool isInherited = Record.readInt();
		2606	bool isImplicit = Record.readInt();
		2607	bool isPackExpansion = Record.readInt();
		2608	New = new (Context) ObjCRootClassAttr(Context, Info);
		2609	cast<InheritableAttr>(New)->setInherited(isInherited);
		2610	New->setImplicit(isImplicit);
		2611	New->setPackExpansion(isPackExpansion);
		2612	break;
		2613	}
		2614	case attr::ObjCRuntimeName: {
		2615	bool isImplicit = Record.readInt();
		2616	bool isPackExpansion = Record.readInt();
		2617	std::string metadataName= Record.readString();
		2618	New = new (Context) ObjCRuntimeNameAttr(Context, Info, metadataName);
		2619	New->setImplicit(isImplicit);
		2620	New->setPackExpansion(isPackExpansion);
		2621	break;
		2622	}
		2623	case attr::ObjCRuntimeVisible: {
		2624	bool isImplicit = Record.readInt();
		2625	bool isPackExpansion = Record.readInt();
		2626	New = new (Context) ObjCRuntimeVisibleAttr(Context, Info);
		2627	New->setImplicit(isImplicit);
		2628	New->setPackExpansion(isPackExpansion);
		2629	break;
		2630	}
		2631	case attr::ObjCSubclassingRestricted: {
		2632	bool isInherited = Record.readInt();
		2633	bool isImplicit = Record.readInt();
		2634	bool isPackExpansion = Record.readInt();
		2635	New = new (Context) ObjCSubclassingRestrictedAttr(Context, Info);
		2636	cast<InheritableAttr>(New)->setInherited(isInherited);
		2637	New->setImplicit(isImplicit);
		2638	New->setPackExpansion(isPackExpansion);
		2639	break;
		2640	}
		2641	case attr::OpenCLAccess: {
		2642	bool isImplicit = Record.readInt();
		2643	bool isPackExpansion = Record.readInt();
		2644	New = new (Context) OpenCLAccessAttr(Context, Info);
		2645	New->setImplicit(isImplicit);
		2646	New->setPackExpansion(isPackExpansion);
		2647	break;
		2648	}
		2649	case attr::OpenCLConstantAddressSpace: {
		2650	bool isImplicit = Record.readInt();
		2651	bool isPackExpansion = Record.readInt();
		2652	New = new (Context) OpenCLConstantAddressSpaceAttr(Context, Info);
		2653	New->setImplicit(isImplicit);
		2654	New->setPackExpansion(isPackExpansion);
		2655	break;
		2656	}
		2657	case attr::OpenCLGenericAddressSpace: {
		2658	bool isImplicit = Record.readInt();
		2659	bool isPackExpansion = Record.readInt();
		2660	New = new (Context) OpenCLGenericAddressSpaceAttr(Context, Info);
		2661	New->setImplicit(isImplicit);
		2662	New->setPackExpansion(isPackExpansion);
		2663	break;
		2664	}
		2665	case attr::OpenCLGlobalAddressSpace: {
		2666	bool isImplicit = Record.readInt();
		2667	bool isPackExpansion = Record.readInt();
		2668	New = new (Context) OpenCLGlobalAddressSpaceAttr(Context, Info);
		2669	New->setImplicit(isImplicit);
		2670	New->setPackExpansion(isPackExpansion);
		2671	break;
		2672	}
		2673	case attr::OpenCLGlobalDeviceAddressSpace: {
		2674	bool isImplicit = Record.readInt();
		2675	bool isPackExpansion = Record.readInt();
		2676	New = new (Context) OpenCLGlobalDeviceAddressSpaceAttr(Context, Info);
		2677	New->setImplicit(isImplicit);
		2678	New->setPackExpansion(isPackExpansion);
		2679	break;
		2680	}
		2681	case attr::OpenCLGlobalHostAddressSpace: {
		2682	bool isImplicit = Record.readInt();
		2683	bool isPackExpansion = Record.readInt();
		2684	New = new (Context) OpenCLGlobalHostAddressSpaceAttr(Context, Info);
		2685	New->setImplicit(isImplicit);
		2686	New->setPackExpansion(isPackExpansion);
		2687	break;
		2688	}
		2689	case attr::OpenCLIntelReqdSubGroupSize: {
		2690	bool isInherited = Record.readInt();
		2691	bool isImplicit = Record.readInt();
		2692	bool isPackExpansion = Record.readInt();
		2693	unsigned subGroupSize = Record.readInt();
		2694	New = new (Context) OpenCLIntelReqdSubGroupSizeAttr(Context, Info, subGroupSize);
		2695	cast<InheritableAttr>(New)->setInherited(isInherited);
		2696	New->setImplicit(isImplicit);
		2697	New->setPackExpansion(isPackExpansion);
		2698	break;
		2699	}
		2700	case attr::OpenCLKernel: {
		2701	bool isInherited = Record.readInt();
		2702	bool isImplicit = Record.readInt();
		2703	bool isPackExpansion = Record.readInt();
		2704	New = new (Context) OpenCLKernelAttr(Context, Info);
		2705	cast<InheritableAttr>(New)->setInherited(isInherited);
		2706	New->setImplicit(isImplicit);
		2707	New->setPackExpansion(isPackExpansion);
		2708	break;
		2709	}
		2710	case attr::OpenCLLocalAddressSpace: {
		2711	bool isImplicit = Record.readInt();
		2712	bool isPackExpansion = Record.readInt();
		2713	New = new (Context) OpenCLLocalAddressSpaceAttr(Context, Info);
		2714	New->setImplicit(isImplicit);
		2715	New->setPackExpansion(isPackExpansion);
		2716	break;
		2717	}
		2718	case attr::OpenCLPrivateAddressSpace: {
		2719	bool isImplicit = Record.readInt();
		2720	bool isPackExpansion = Record.readInt();
		2721	New = new (Context) OpenCLPrivateAddressSpaceAttr(Context, Info);
		2722	New->setImplicit(isImplicit);
		2723	New->setPackExpansion(isPackExpansion);
		2724	break;
		2725	}
		2726	case attr::OpenCLUnrollHint: {
		2727	bool isImplicit = Record.readInt();
		2728	bool isPackExpansion = Record.readInt();
		2729	unsigned unrollHint = Record.readInt();
		2730	New = new (Context) OpenCLUnrollHintAttr(Context, Info, unrollHint);
		2731	New->setImplicit(isImplicit);
		2732	New->setPackExpansion(isPackExpansion);
		2733	break;
		2734	}
		2735	case attr::OptimizeNone: {
		2736	bool isInherited = Record.readInt();
		2737	bool isImplicit = Record.readInt();
		2738	bool isPackExpansion = Record.readInt();
		2739	New = new (Context) OptimizeNoneAttr(Context, Info);
		2740	cast<InheritableAttr>(New)->setInherited(isInherited);
		2741	New->setImplicit(isImplicit);
		2742	New->setPackExpansion(isPackExpansion);
		2743	break;
		2744	}
		2745	case attr::Overloadable: {
		2746	bool isImplicit = Record.readInt();
		2747	bool isPackExpansion = Record.readInt();
		2748	New = new (Context) OverloadableAttr(Context, Info);
		2749	New->setImplicit(isImplicit);
		2750	New->setPackExpansion(isPackExpansion);
		2751	break;
		2752	}
		2753	case attr::Override: {
		2754	bool isInherited = Record.readInt();
		2755	bool isImplicit = Record.readInt();
		2756	bool isPackExpansion = Record.readInt();
		2757	New = new (Context) OverrideAttr(Context, Info);
		2758	cast<InheritableAttr>(New)->setInherited(isInherited);
		2759	New->setImplicit(isImplicit);
		2760	New->setPackExpansion(isPackExpansion);
		2761	break;
		2762	}
		2763	case attr::Owner: {
		2764	bool isInherited = Record.readInt();
		2765	bool isImplicit = Record.readInt();
		2766	bool isPackExpansion = Record.readInt();
		2767	TypeSourceInfo * derefType = Record.readTypeSourceInfo();
		2768	New = new (Context) OwnerAttr(Context, Info, derefType);
		2769	cast<InheritableAttr>(New)->setInherited(isInherited);
		2770	New->setImplicit(isImplicit);
		2771	New->setPackExpansion(isPackExpansion);
		2772	break;
		2773	}
		2774	case attr::Ownership: {
		2775	bool isInherited = Record.readInt();
		2776	bool isImplicit = Record.readInt();
		2777	bool isPackExpansion = Record.readInt();
		2778	IdentifierInfo * module = Record.readIdentifier();
		2779	unsigned argsSize = Record.readInt();
		2780	SmallVector<ParamIdx, 4> args;
		2781	args.reserve(argsSize);
		2782	for (unsigned i = 0; i != argsSize; ++i)
		2783	args.push_back(ParamIdx::deserialize(Record.readInt()));
		2784	New = new (Context) OwnershipAttr(Context, Info, module, args.data(), argsSize);
		2785	cast<InheritableAttr>(New)->setInherited(isInherited);
		2786	New->setImplicit(isImplicit);
		2787	New->setPackExpansion(isPackExpansion);
		2788	break;
		2789	}
		2790	case attr::Packed: {
		2791	bool isInherited = Record.readInt();
		2792	bool isImplicit = Record.readInt();
		2793	bool isPackExpansion = Record.readInt();
		2794	New = new (Context) PackedAttr(Context, Info);
		2795	cast<InheritableAttr>(New)->setInherited(isInherited);
		2796	New->setImplicit(isImplicit);
		2797	New->setPackExpansion(isPackExpansion);
		2798	break;
		2799	}
		2800	case attr::ParamTypestate: {
		2801	bool isInherited = Record.readInt();
		2802	bool isImplicit = Record.readInt();
		2803	bool isPackExpansion = Record.readInt();
		2804	ParamTypestateAttr::ConsumedState paramState(static_cast<ParamTypestateAttr::ConsumedState>(Record.readInt()));
		2805	New = new (Context) ParamTypestateAttr(Context, Info, paramState);
		2806	cast<InheritableAttr>(New)->setInherited(isInherited);
		2807	New->setImplicit(isImplicit);
		2808	New->setPackExpansion(isPackExpansion);
		2809	break;
		2810	}
		2811	case attr::Pascal: {
		2812	bool isInherited = Record.readInt();
		2813	bool isImplicit = Record.readInt();
		2814	bool isPackExpansion = Record.readInt();
		2815	New = new (Context) PascalAttr(Context, Info);
		2816	cast<InheritableAttr>(New)->setInherited(isInherited);
		2817	New->setImplicit(isImplicit);
		2818	New->setPackExpansion(isPackExpansion);
		2819	break;
		2820	}
		2821	case attr::PassObjectSize: {
		2822	bool isInherited = Record.readInt();
		2823	bool isImplicit = Record.readInt();
		2824	bool isPackExpansion = Record.readInt();
		2825	int type = Record.readInt();
		2826	New = new (Context) PassObjectSizeAttr(Context, Info, type);
		2827	cast<InheritableAttr>(New)->setInherited(isInherited);
		2828	New->setImplicit(isImplicit);
		2829	New->setPackExpansion(isPackExpansion);
		2830	break;
		2831	}
		2832	case attr::PatchableFunctionEntry: {
		2833	bool isInherited = Record.readInt();
		2834	bool isImplicit = Record.readInt();
		2835	bool isPackExpansion = Record.readInt();
		2836	unsigned count = Record.readInt();
		2837	int offset = Record.readInt();
		2838	New = new (Context) PatchableFunctionEntryAttr(Context, Info, count, offset);
		2839	cast<InheritableAttr>(New)->setInherited(isInherited);
		2840	New->setImplicit(isImplicit);
		2841	New->setPackExpansion(isPackExpansion);
		2842	break;
		2843	}
		2844	case attr::Pcs: {
		2845	bool isInherited = Record.readInt();
		2846	bool isImplicit = Record.readInt();
		2847	bool isPackExpansion = Record.readInt();
		2848	PcsAttr::PCSType pCS(static_cast<PcsAttr::PCSType>(Record.readInt()));
		2849	New = new (Context) PcsAttr(Context, Info, pCS);
		2850	cast<InheritableAttr>(New)->setInherited(isInherited);
		2851	New->setImplicit(isImplicit);
		2852	New->setPackExpansion(isPackExpansion);
		2853	break;
		2854	}
		2855	case attr::Pointer: {
		2856	bool isInherited = Record.readInt();
		2857	bool isImplicit = Record.readInt();
		2858	bool isPackExpansion = Record.readInt();
		2859	TypeSourceInfo * derefType = Record.readTypeSourceInfo();
		2860	New = new (Context) PointerAttr(Context, Info, derefType);
		2861	cast<InheritableAttr>(New)->setInherited(isInherited);
		2862	New->setImplicit(isImplicit);
		2863	New->setPackExpansion(isPackExpansion);
		2864	break;
		2865	}
		2866	case attr::PragmaClangBSSSection: {
		2867	bool isInherited = Record.readInt();
		2868	bool isImplicit = Record.readInt();
		2869	bool isPackExpansion = Record.readInt();
		2870	std::string name= Record.readString();
		2871	New = new (Context) PragmaClangBSSSectionAttr(Context, Info, name);
		2872	cast<InheritableAttr>(New)->setInherited(isInherited);
		2873	New->setImplicit(isImplicit);
		2874	New->setPackExpansion(isPackExpansion);
		2875	break;
		2876	}
		2877	case attr::PragmaClangDataSection: {
		2878	bool isInherited = Record.readInt();
		2879	bool isImplicit = Record.readInt();
		2880	bool isPackExpansion = Record.readInt();
		2881	std::string name= Record.readString();
		2882	New = new (Context) PragmaClangDataSectionAttr(Context, Info, name);
		2883	cast<InheritableAttr>(New)->setInherited(isInherited);
		2884	New->setImplicit(isImplicit);
		2885	New->setPackExpansion(isPackExpansion);
		2886	break;
		2887	}
		2888	case attr::PragmaClangRelroSection: {
		2889	bool isInherited = Record.readInt();
		2890	bool isImplicit = Record.readInt();
		2891	bool isPackExpansion = Record.readInt();
		2892	std::string name= Record.readString();
		2893	New = new (Context) PragmaClangRelroSectionAttr(Context, Info, name);
		2894	cast<InheritableAttr>(New)->setInherited(isInherited);
		2895	New->setImplicit(isImplicit);
		2896	New->setPackExpansion(isPackExpansion);
		2897	break;
		2898	}
		2899	case attr::PragmaClangRodataSection: {
		2900	bool isInherited = Record.readInt();
		2901	bool isImplicit = Record.readInt();
		2902	bool isPackExpansion = Record.readInt();
		2903	std::string name= Record.readString();
		2904	New = new (Context) PragmaClangRodataSectionAttr(Context, Info, name);
		2905	cast<InheritableAttr>(New)->setInherited(isInherited);
		2906	New->setImplicit(isImplicit);
		2907	New->setPackExpansion(isPackExpansion);
		2908	break;
		2909	}
		2910	case attr::PragmaClangTextSection: {
		2911	bool isInherited = Record.readInt();
		2912	bool isImplicit = Record.readInt();
		2913	bool isPackExpansion = Record.readInt();
		2914	std::string name= Record.readString();
		2915	New = new (Context) PragmaClangTextSectionAttr(Context, Info, name);
		2916	cast<InheritableAttr>(New)->setInherited(isInherited);
		2917	New->setImplicit(isImplicit);
		2918	New->setPackExpansion(isPackExpansion);
		2919	break;
		2920	}
		2921	case attr::PreferredName: {
		2922	bool isInherited = Record.readInt();
		2923	bool isImplicit = Record.readInt();
		2924	bool isPackExpansion = Record.readInt();
		2925	TypeSourceInfo * typedefType = Record.readTypeSourceInfo();
		2926	New = new (Context) PreferredNameAttr(Context, Info, typedefType);
		2927	cast<InheritableAttr>(New)->setInherited(isInherited);
		2928	New->setImplicit(isImplicit);
		2929	New->setPackExpansion(isPackExpansion);
		2930	break;
		2931	}
		2932	case attr::PreserveAll: {
		2933	bool isInherited = Record.readInt();
		2934	bool isImplicit = Record.readInt();
		2935	bool isPackExpansion = Record.readInt();
		2936	New = new (Context) PreserveAllAttr(Context, Info);
		2937	cast<InheritableAttr>(New)->setInherited(isInherited);
		2938	New->setImplicit(isImplicit);
		2939	New->setPackExpansion(isPackExpansion);
		2940	break;
		2941	}
		2942	case attr::PreserveMost: {
		2943	bool isInherited = Record.readInt();
		2944	bool isImplicit = Record.readInt();
		2945	bool isPackExpansion = Record.readInt();
		2946	New = new (Context) PreserveMostAttr(Context, Info);
		2947	cast<InheritableAttr>(New)->setInherited(isInherited);
		2948	New->setImplicit(isImplicit);
		2949	New->setPackExpansion(isPackExpansion);
		2950	break;
		2951	}
		2952	case attr::PtGuardedBy: {
		2953	bool isInherited = Record.readInt();
		2954	bool isImplicit = Record.readInt();
		2955	bool isPackExpansion = Record.readInt();
		2956	Expr * arg = Record.readExpr();
		2957	New = new (Context) PtGuardedByAttr(Context, Info, arg);
		2958	cast<InheritableAttr>(New)->setInherited(isInherited);
		2959	New->setImplicit(isImplicit);
		2960	New->setPackExpansion(isPackExpansion);
		2961	break;
		2962	}
		2963	case attr::PtGuardedVar: {
		2964	bool isInherited = Record.readInt();
		2965	bool isImplicit = Record.readInt();
		2966	bool isPackExpansion = Record.readInt();
		2967	New = new (Context) PtGuardedVarAttr(Context, Info);
		2968	cast<InheritableAttr>(New)->setInherited(isInherited);
		2969	New->setImplicit(isImplicit);
		2970	New->setPackExpansion(isPackExpansion);
		2971	break;
		2972	}
		2973	case attr::Ptr32: {
		2974	bool isImplicit = Record.readInt();
		2975	bool isPackExpansion = Record.readInt();
		2976	New = new (Context) Ptr32Attr(Context, Info);
		2977	New->setImplicit(isImplicit);
		2978	New->setPackExpansion(isPackExpansion);
		2979	break;
		2980	}
		2981	case attr::Ptr64: {
		2982	bool isImplicit = Record.readInt();
		2983	bool isPackExpansion = Record.readInt();
		2984	New = new (Context) Ptr64Attr(Context, Info);
		2985	New->setImplicit(isImplicit);
		2986	New->setPackExpansion(isPackExpansion);
		2987	break;
		2988	}
		2989	case attr::Pure: {
		2990	bool isInherited = Record.readInt();
		2991	bool isImplicit = Record.readInt();
		2992	bool isPackExpansion = Record.readInt();
		2993	New = new (Context) PureAttr(Context, Info);
		2994	cast<InheritableAttr>(New)->setInherited(isInherited);
		2995	New->setImplicit(isImplicit);
		2996	New->setPackExpansion(isPackExpansion);
		2997	break;
		2998	}
		2999	case attr::RISCVInterrupt: {
		3000	bool isInherited = Record.readInt();
		3001	bool isImplicit = Record.readInt();
		3002	bool isPackExpansion = Record.readInt();
		3003	RISCVInterruptAttr::InterruptType interrupt(static_cast<RISCVInterruptAttr::InterruptType>(Record.readInt()));
		3004	New = new (Context) RISCVInterruptAttr(Context, Info, interrupt);
		3005	cast<InheritableAttr>(New)->setInherited(isInherited);
		3006	New->setImplicit(isImplicit);
		3007	New->setPackExpansion(isPackExpansion);
		3008	break;
		3009	}
		3010	case attr::RandomizeLayout: {
		3011	bool isInherited = Record.readInt();
		3012	bool isImplicit = Record.readInt();
		3013	bool isPackExpansion = Record.readInt();
		3014	New = new (Context) RandomizeLayoutAttr(Context, Info);
		3015	cast<InheritableAttr>(New)->setInherited(isInherited);
		3016	New->setImplicit(isImplicit);
		3017	New->setPackExpansion(isPackExpansion);
		3018	break;
		3019	}
		3020	case attr::ReadOnlyPlacement: {
		3021	bool isInherited = Record.readInt();
		3022	bool isImplicit = Record.readInt();
		3023	bool isPackExpansion = Record.readInt();
		3024	New = new (Context) ReadOnlyPlacementAttr(Context, Info);
		3025	cast<InheritableAttr>(New)->setInherited(isInherited);
		3026	New->setImplicit(isImplicit);
		3027	New->setPackExpansion(isPackExpansion);
		3028	break;
		3029	}
		3030	case attr::RegCall: {
		3031	bool isInherited = Record.readInt();
		3032	bool isImplicit = Record.readInt();
		3033	bool isPackExpansion = Record.readInt();
		3034	New = new (Context) RegCallAttr(Context, Info);
		3035	cast<InheritableAttr>(New)->setInherited(isInherited);
		3036	New->setImplicit(isImplicit);
		3037	New->setPackExpansion(isPackExpansion);
		3038	break;
		3039	}
		3040	case attr::Reinitializes: {
		3041	bool isInherited = Record.readInt();
		3042	bool isImplicit = Record.readInt();
		3043	bool isPackExpansion = Record.readInt();
		3044	New = new (Context) ReinitializesAttr(Context, Info);
		3045	cast<InheritableAttr>(New)->setInherited(isInherited);
		3046	New->setImplicit(isImplicit);
		3047	New->setPackExpansion(isPackExpansion);
		3048	break;
		3049	}
		3050	case attr::ReleaseCapability: {
		3051	bool isInherited = Record.readInt();
		3052	bool isImplicit = Record.readInt();
		3053	bool isPackExpansion = Record.readInt();
		3054	unsigned argsSize = Record.readInt();
		3055	SmallVector<Expr *, 4> args;
		3056	args.reserve(argsSize);
		3057	for (unsigned i = 0; i != argsSize; ++i)
		3058	args.push_back(Record.readExpr());
		3059	New = new (Context) ReleaseCapabilityAttr(Context, Info, args.data(), argsSize);
		3060	cast<InheritableAttr>(New)->setInherited(isInherited);
		3061	New->setImplicit(isImplicit);
		3062	New->setPackExpansion(isPackExpansion);
		3063	break;
		3064	}
		3065	case attr::ReleaseHandle: {
		3066	bool isInherited = Record.readInt();
		3067	bool isImplicit = Record.readInt();
		3068	bool isPackExpansion = Record.readInt();
		3069	std::string handleType= Record.readString();
		3070	New = new (Context) ReleaseHandleAttr(Context, Info, handleType);
		3071	cast<InheritableAttr>(New)->setInherited(isInherited);
		3072	New->setImplicit(isImplicit);
		3073	New->setPackExpansion(isPackExpansion);
		3074	break;
		3075	}
		3076	case attr::RenderScriptKernel: {
		3077	bool isImplicit = Record.readInt();
		3078	bool isPackExpansion = Record.readInt();
		3079	New = new (Context) RenderScriptKernelAttr(Context, Info);
		3080	New->setImplicit(isImplicit);
		3081	New->setPackExpansion(isPackExpansion);
		3082	break;
		3083	}
		3084	case attr::ReqdWorkGroupSize: {
		3085	bool isInherited = Record.readInt();
		3086	bool isImplicit = Record.readInt();
		3087	bool isPackExpansion = Record.readInt();
		3088	unsigned xDim = Record.readInt();
		3089	unsigned yDim = Record.readInt();
		3090	unsigned zDim = Record.readInt();
		3091	New = new (Context) ReqdWorkGroupSizeAttr(Context, Info, xDim, yDim, zDim);
		3092	cast<InheritableAttr>(New)->setInherited(isInherited);
		3093	New->setImplicit(isImplicit);
		3094	New->setPackExpansion(isPackExpansion);
		3095	break;
		3096	}
		3097	case attr::RequiresCapability: {
		3098	bool isInherited = Record.readInt();
		3099	bool isImplicit = Record.readInt();
		3100	bool isPackExpansion = Record.readInt();
		3101	unsigned argsSize = Record.readInt();
		3102	SmallVector<Expr *, 4> args;
		3103	args.reserve(argsSize);
		3104	for (unsigned i = 0; i != argsSize; ++i)
		3105	args.push_back(Record.readExpr());
		3106	New = new (Context) RequiresCapabilityAttr(Context, Info, args.data(), argsSize);
		3107	cast<InheritableAttr>(New)->setInherited(isInherited);
		3108	New->setImplicit(isImplicit);
		3109	New->setPackExpansion(isPackExpansion);
		3110	break;
		3111	}
		3112	case attr::Restrict: {
		3113	bool isInherited = Record.readInt();
		3114	bool isImplicit = Record.readInt();
		3115	bool isPackExpansion = Record.readInt();
		3116	New = new (Context) RestrictAttr(Context, Info);
		3117	cast<InheritableAttr>(New)->setInherited(isInherited);
		3118	New->setImplicit(isImplicit);
		3119	New->setPackExpansion(isPackExpansion);
		3120	break;
		3121	}
		3122	case attr::Retain: {
		3123	bool isInherited = Record.readInt();
		3124	bool isImplicit = Record.readInt();
		3125	bool isPackExpansion = Record.readInt();
		3126	New = new (Context) RetainAttr(Context, Info);
		3127	cast<InheritableAttr>(New)->setInherited(isInherited);
		3128	New->setImplicit(isImplicit);
		3129	New->setPackExpansion(isPackExpansion);
		3130	break;
		3131	}
		3132	case attr::ReturnTypestate: {
		3133	bool isInherited = Record.readInt();
		3134	bool isImplicit = Record.readInt();
		3135	bool isPackExpansion = Record.readInt();
		3136	ReturnTypestateAttr::ConsumedState state(static_cast<ReturnTypestateAttr::ConsumedState>(Record.readInt()));
		3137	New = new (Context) ReturnTypestateAttr(Context, Info, state);
		3138	cast<InheritableAttr>(New)->setInherited(isInherited);
		3139	New->setImplicit(isImplicit);
		3140	New->setPackExpansion(isPackExpansion);
		3141	break;
		3142	}
		3143	case attr::ReturnsNonNull: {
		3144	bool isInherited = Record.readInt();
		3145	bool isImplicit = Record.readInt();
		3146	bool isPackExpansion = Record.readInt();
		3147	New = new (Context) ReturnsNonNullAttr(Context, Info);
		3148	cast<InheritableAttr>(New)->setInherited(isInherited);
		3149	New->setImplicit(isImplicit);
		3150	New->setPackExpansion(isPackExpansion);
		3151	break;
		3152	}
		3153	case attr::ReturnsTwice: {
		3154	bool isInherited = Record.readInt();
		3155	bool isImplicit = Record.readInt();
		3156	bool isPackExpansion = Record.readInt();
		3157	New = new (Context) ReturnsTwiceAttr(Context, Info);
		3158	cast<InheritableAttr>(New)->setInherited(isInherited);
		3159	New->setImplicit(isImplicit);
		3160	New->setPackExpansion(isPackExpansion);
		3161	break;
		3162	}
		3163	case attr::SPtr: {
		3164	bool isImplicit = Record.readInt();
		3165	bool isPackExpansion = Record.readInt();
		3166	New = new (Context) SPtrAttr(Context, Info);
		3167	New->setImplicit(isImplicit);
		3168	New->setPackExpansion(isPackExpansion);
		3169	break;
		3170	}
		3171	case attr::SYCLKernel: {
		3172	bool isInherited = Record.readInt();
		3173	bool isImplicit = Record.readInt();
		3174	bool isPackExpansion = Record.readInt();
		3175	New = new (Context) SYCLKernelAttr(Context, Info);
		3176	cast<InheritableAttr>(New)->setInherited(isInherited);
		3177	New->setImplicit(isImplicit);
		3178	New->setPackExpansion(isPackExpansion);
		3179	break;
		3180	}
		3181	case attr::SYCLSpecialClass: {
		3182	bool isInherited = Record.readInt();
		3183	bool isImplicit = Record.readInt();
		3184	bool isPackExpansion = Record.readInt();
		3185	New = new (Context) SYCLSpecialClassAttr(Context, Info);
		3186	cast<InheritableAttr>(New)->setInherited(isInherited);
		3187	New->setImplicit(isImplicit);
		3188	New->setPackExpansion(isPackExpansion);
		3189	break;
		3190	}
		3191	case attr::ScopedLockable: {
		3192	bool isInherited = Record.readInt();
		3193	bool isImplicit = Record.readInt();
		3194	bool isPackExpansion = Record.readInt();
		3195	New = new (Context) ScopedLockableAttr(Context, Info);
		3196	cast<InheritableAttr>(New)->setInherited(isInherited);
		3197	New->setImplicit(isImplicit);
		3198	New->setPackExpansion(isPackExpansion);
		3199	break;
		3200	}
		3201	case attr::Section: {
		3202	bool isInherited = Record.readInt();
		3203	bool isImplicit = Record.readInt();
		3204	bool isPackExpansion = Record.readInt();
		3205	std::string name= Record.readString();
		3206	New = new (Context) SectionAttr(Context, Info, name);
		3207	cast<InheritableAttr>(New)->setInherited(isInherited);
		3208	New->setImplicit(isImplicit);
		3209	New->setPackExpansion(isPackExpansion);
		3210	break;
		3211	}
		3212	case attr::SelectAny: {
		3213	bool isInherited = Record.readInt();
		3214	bool isImplicit = Record.readInt();
		3215	bool isPackExpansion = Record.readInt();
		3216	New = new (Context) SelectAnyAttr(Context, Info);
		3217	cast<InheritableAttr>(New)->setInherited(isInherited);
		3218	New->setImplicit(isImplicit);
		3219	New->setPackExpansion(isPackExpansion);
		3220	break;
		3221	}
		3222	case attr::Sentinel: {
		3223	bool isInherited = Record.readInt();
		3224	bool isImplicit = Record.readInt();
		3225	bool isPackExpansion = Record.readInt();
		3226	int sentinel = Record.readInt();
		3227	int nullPos = Record.readInt();
		3228	New = new (Context) SentinelAttr(Context, Info, sentinel, nullPos);
		3229	cast<InheritableAttr>(New)->setInherited(isInherited);
		3230	New->setImplicit(isImplicit);
		3231	New->setPackExpansion(isPackExpansion);
		3232	break;
		3233	}
		3234	case attr::SetTypestate: {
		3235	bool isInherited = Record.readInt();
		3236	bool isImplicit = Record.readInt();
		3237	bool isPackExpansion = Record.readInt();
		3238	SetTypestateAttr::ConsumedState newState(static_cast<SetTypestateAttr::ConsumedState>(Record.readInt()));
		3239	New = new (Context) SetTypestateAttr(Context, Info, newState);
		3240	cast<InheritableAttr>(New)->setInherited(isInherited);
		3241	New->setImplicit(isImplicit);
		3242	New->setPackExpansion(isPackExpansion);
		3243	break;
		3244	}
		3245	case attr::SharedTrylockFunction: {
		3246	bool isInherited = Record.readInt();
		3247	bool isImplicit = Record.readInt();
		3248	bool isPackExpansion = Record.readInt();
		3249	Expr * successValue = Record.readExpr();
		3250	unsigned argsSize = Record.readInt();
		3251	SmallVector<Expr *, 4> args;
		3252	args.reserve(argsSize);
		3253	for (unsigned i = 0; i != argsSize; ++i)
		3254	args.push_back(Record.readExpr());
		3255	New = new (Context) SharedTrylockFunctionAttr(Context, Info, successValue, args.data(), argsSize);
		3256	cast<InheritableAttr>(New)->setInherited(isInherited);
		3257	New->setImplicit(isImplicit);
		3258	New->setPackExpansion(isPackExpansion);
		3259	break;
		3260	}
		3261	case attr::SpeculativeLoadHardening: {
		3262	bool isInherited = Record.readInt();
		3263	bool isImplicit = Record.readInt();
		3264	bool isPackExpansion = Record.readInt();
		3265	New = new (Context) SpeculativeLoadHardeningAttr(Context, Info);
		3266	cast<InheritableAttr>(New)->setInherited(isInherited);
		3267	New->setImplicit(isImplicit);
		3268	New->setPackExpansion(isPackExpansion);
		3269	break;
		3270	}
		3271	case attr::StandaloneDebug: {
		3272	bool isInherited = Record.readInt();
		3273	bool isImplicit = Record.readInt();
		3274	bool isPackExpansion = Record.readInt();
		3275	New = new (Context) StandaloneDebugAttr(Context, Info);
		3276	cast<InheritableAttr>(New)->setInherited(isInherited);
		3277	New->setImplicit(isImplicit);
		3278	New->setPackExpansion(isPackExpansion);
		3279	break;
		3280	}
		3281	case attr::StdCall: {
		3282	bool isInherited = Record.readInt();
		3283	bool isImplicit = Record.readInt();
		3284	bool isPackExpansion = Record.readInt();
		3285	New = new (Context) StdCallAttr(Context, Info);
		3286	cast<InheritableAttr>(New)->setInherited(isInherited);
		3287	New->setImplicit(isImplicit);
		3288	New->setPackExpansion(isPackExpansion);
		3289	break;
		3290	}
		3291	case attr::StrictFP: {
		3292	bool isInherited = Record.readInt();
		3293	bool isImplicit = Record.readInt();
		3294	bool isPackExpansion = Record.readInt();
		3295	New = new (Context) StrictFPAttr(Context, Info);
		3296	cast<InheritableAttr>(New)->setInherited(isInherited);
		3297	New->setImplicit(isImplicit);
		3298	New->setPackExpansion(isPackExpansion);
		3299	break;
		3300	}
		3301	case attr::StrictGuardStackCheck: {
		3302	bool isInherited = Record.readInt();
		3303	bool isImplicit = Record.readInt();
		3304	bool isPackExpansion = Record.readInt();
		3305	New = new (Context) StrictGuardStackCheckAttr(Context, Info);
		3306	cast<InheritableAttr>(New)->setInherited(isInherited);
		3307	New->setImplicit(isImplicit);
		3308	New->setPackExpansion(isPackExpansion);
		3309	break;
		3310	}
		3311	case attr::Suppress: {
		3312	bool isImplicit = Record.readInt();
		3313	bool isPackExpansion = Record.readInt();
		3314	unsigned diagnosticIdentifiersSize = Record.readInt();
		3315	SmallVector<StringRef, 4> diagnosticIdentifiers;
		3316	diagnosticIdentifiers.reserve(diagnosticIdentifiersSize);
		3317	SmallVector<std::string, 4> diagnosticIdentifiersStorage;
		3318	diagnosticIdentifiersStorage.reserve(diagnosticIdentifiersSize);
		3319	for (unsigned i = 0; i != diagnosticIdentifiersSize; ++i)
		3320	diagnosticIdentifiersStorage.push_back(Record.readString());
		3321	for (unsigned i = 0; i != diagnosticIdentifiersSize; ++i)
		3322	diagnosticIdentifiers.push_back(diagnosticIdentifiersStorage[i]);
		3323	New = new (Context) SuppressAttr(Context, Info, diagnosticIdentifiers.data(), diagnosticIdentifiersSize);
		3324	New->setImplicit(isImplicit);
		3325	New->setPackExpansion(isPackExpansion);
		3326	break;
		3327	}
		3328	case attr::SwiftAsync: {
		3329	bool isInherited = Record.readInt();
		3330	bool isImplicit = Record.readInt();
		3331	bool isPackExpansion = Record.readInt();
		3332	SwiftAsyncAttr::Kind kind(static_cast<SwiftAsyncAttr::Kind>(Record.readInt()));
		3333	ParamIdx completionHandlerIndex = ParamIdx::deserialize(Record.readInt());
		3334	New = new (Context) SwiftAsyncAttr(Context, Info, kind, completionHandlerIndex);
		3335	cast<InheritableAttr>(New)->setInherited(isInherited);
		3336	New->setImplicit(isImplicit);
		3337	New->setPackExpansion(isPackExpansion);
		3338	break;
		3339	}
		3340	case attr::SwiftAsyncCall: {
		3341	bool isInherited = Record.readInt();
		3342	bool isImplicit = Record.readInt();
		3343	bool isPackExpansion = Record.readInt();
		3344	New = new (Context) SwiftAsyncCallAttr(Context, Info);
		3345	cast<InheritableAttr>(New)->setInherited(isInherited);
		3346	New->setImplicit(isImplicit);
		3347	New->setPackExpansion(isPackExpansion);
		3348	break;
		3349	}
		3350	case attr::SwiftAsyncContext: {
		3351	bool isInherited = Record.readInt();
		3352	bool isImplicit = Record.readInt();
		3353	bool isPackExpansion = Record.readInt();
		3354	New = new (Context) SwiftAsyncContextAttr(Context, Info);
		3355	cast<InheritableAttr>(New)->setInherited(isInherited);
		3356	New->setImplicit(isImplicit);
		3357	New->setPackExpansion(isPackExpansion);
		3358	break;
		3359	}
		3360	case attr::SwiftAsyncError: {
		3361	bool isInherited = Record.readInt();
		3362	bool isImplicit = Record.readInt();
		3363	bool isPackExpansion = Record.readInt();
		3364	SwiftAsyncErrorAttr::ConventionKind convention(static_cast<SwiftAsyncErrorAttr::ConventionKind>(Record.readInt()));
		3365	unsigned handlerParamIdx = Record.readInt();
		3366	New = new (Context) SwiftAsyncErrorAttr(Context, Info, convention, handlerParamIdx);
		3367	cast<InheritableAttr>(New)->setInherited(isInherited);
		3368	New->setImplicit(isImplicit);
		3369	New->setPackExpansion(isPackExpansion);
		3370	break;
		3371	}
		3372	case attr::SwiftAsyncName: {
		3373	bool isInherited = Record.readInt();
		3374	bool isImplicit = Record.readInt();
		3375	bool isPackExpansion = Record.readInt();
		3376	std::string name= Record.readString();
		3377	New = new (Context) SwiftAsyncNameAttr(Context, Info, name);
		3378	cast<InheritableAttr>(New)->setInherited(isInherited);
		3379	New->setImplicit(isImplicit);
		3380	New->setPackExpansion(isPackExpansion);
		3381	break;
		3382	}
		3383	case attr::SwiftAttr: {
		3384	bool isInherited = Record.readInt();
		3385	bool isImplicit = Record.readInt();
		3386	bool isPackExpansion = Record.readInt();
		3387	std::string attribute= Record.readString();
		3388	New = new (Context) SwiftAttrAttr(Context, Info, attribute);
		3389	cast<InheritableAttr>(New)->setInherited(isInherited);
		3390	New->setImplicit(isImplicit);
		3391	New->setPackExpansion(isPackExpansion);
		3392	break;
		3393	}
		3394	case attr::SwiftBridge: {
		3395	bool isInherited = Record.readInt();
		3396	bool isImplicit = Record.readInt();
		3397	bool isPackExpansion = Record.readInt();
		3398	std::string swiftType= Record.readString();
		3399	New = new (Context) SwiftBridgeAttr(Context, Info, swiftType);
		3400	cast<InheritableAttr>(New)->setInherited(isInherited);
		3401	New->setImplicit(isImplicit);
		3402	New->setPackExpansion(isPackExpansion);
		3403	break;
		3404	}
		3405	case attr::SwiftBridgedTypedef: {
		3406	bool isInherited = Record.readInt();
		3407	bool isImplicit = Record.readInt();
		3408	bool isPackExpansion = Record.readInt();
		3409	New = new (Context) SwiftBridgedTypedefAttr(Context, Info);
		3410	cast<InheritableAttr>(New)->setInherited(isInherited);
		3411	New->setImplicit(isImplicit);
		3412	New->setPackExpansion(isPackExpansion);
		3413	break;
		3414	}
		3415	case attr::SwiftCall: {
		3416	bool isInherited = Record.readInt();
		3417	bool isImplicit = Record.readInt();
		3418	bool isPackExpansion = Record.readInt();
		3419	New = new (Context) SwiftCallAttr(Context, Info);
		3420	cast<InheritableAttr>(New)->setInherited(isInherited);
		3421	New->setImplicit(isImplicit);
		3422	New->setPackExpansion(isPackExpansion);
		3423	break;
		3424	}
		3425	case attr::SwiftContext: {
		3426	bool isInherited = Record.readInt();
		3427	bool isImplicit = Record.readInt();
		3428	bool isPackExpansion = Record.readInt();
		3429	New = new (Context) SwiftContextAttr(Context, Info);
		3430	cast<InheritableAttr>(New)->setInherited(isInherited);
		3431	New->setImplicit(isImplicit);
		3432	New->setPackExpansion(isPackExpansion);
		3433	break;
		3434	}
		3435	case attr::SwiftError: {
		3436	bool isInherited = Record.readInt();
		3437	bool isImplicit = Record.readInt();
		3438	bool isPackExpansion = Record.readInt();
		3439	SwiftErrorAttr::ConventionKind convention(static_cast<SwiftErrorAttr::ConventionKind>(Record.readInt()));
		3440	New = new (Context) SwiftErrorAttr(Context, Info, convention);
		3441	cast<InheritableAttr>(New)->setInherited(isInherited);
		3442	New->setImplicit(isImplicit);
		3443	New->setPackExpansion(isPackExpansion);
		3444	break;
		3445	}
		3446	case attr::SwiftErrorResult: {
		3447	bool isInherited = Record.readInt();
		3448	bool isImplicit = Record.readInt();
		3449	bool isPackExpansion = Record.readInt();
		3450	New = new (Context) SwiftErrorResultAttr(Context, Info);
		3451	cast<InheritableAttr>(New)->setInherited(isInherited);
		3452	New->setImplicit(isImplicit);
		3453	New->setPackExpansion(isPackExpansion);
		3454	break;
		3455	}
		3456	case attr::SwiftIndirectResult: {
		3457	bool isInherited = Record.readInt();
		3458	bool isImplicit = Record.readInt();
		3459	bool isPackExpansion = Record.readInt();
		3460	New = new (Context) SwiftIndirectResultAttr(Context, Info);
		3461	cast<InheritableAttr>(New)->setInherited(isInherited);
		3462	New->setImplicit(isImplicit);
		3463	New->setPackExpansion(isPackExpansion);
		3464	break;
		3465	}
		3466	case attr::SwiftName: {
		3467	bool isInherited = Record.readInt();
		3468	bool isImplicit = Record.readInt();
		3469	bool isPackExpansion = Record.readInt();
		3470	std::string name= Record.readString();
		3471	New = new (Context) SwiftNameAttr(Context, Info, name);
		3472	cast<InheritableAttr>(New)->setInherited(isInherited);
		3473	New->setImplicit(isImplicit);
		3474	New->setPackExpansion(isPackExpansion);
		3475	break;
		3476	}
		3477	case attr::SwiftNewType: {
		3478	bool isInherited = Record.readInt();
		3479	bool isImplicit = Record.readInt();
		3480	bool isPackExpansion = Record.readInt();
		3481	SwiftNewTypeAttr::NewtypeKind newtypeKind(static_cast<SwiftNewTypeAttr::NewtypeKind>(Record.readInt()));
		3482	New = new (Context) SwiftNewTypeAttr(Context, Info, newtypeKind);
		3483	cast<InheritableAttr>(New)->setInherited(isInherited);
		3484	New->setImplicit(isImplicit);
		3485	New->setPackExpansion(isPackExpansion);
		3486	break;
		3487	}
		3488	case attr::SwiftObjCMembers: {
		3489	bool isImplicit = Record.readInt();
		3490	bool isPackExpansion = Record.readInt();
		3491	New = new (Context) SwiftObjCMembersAttr(Context, Info);
		3492	New->setImplicit(isImplicit);
		3493	New->setPackExpansion(isPackExpansion);
		3494	break;
		3495	}
		3496	case attr::SwiftPrivate: {
		3497	bool isInherited = Record.readInt();
		3498	bool isImplicit = Record.readInt();
		3499	bool isPackExpansion = Record.readInt();
		3500	New = new (Context) SwiftPrivateAttr(Context, Info);
		3501	cast<InheritableAttr>(New)->setInherited(isInherited);
		3502	New->setImplicit(isImplicit);
		3503	New->setPackExpansion(isPackExpansion);
		3504	break;
		3505	}
		3506	case attr::SysVABI: {
		3507	bool isInherited = Record.readInt();
		3508	bool isImplicit = Record.readInt();
		3509	bool isPackExpansion = Record.readInt();
		3510	New = new (Context) SysVABIAttr(Context, Info);
		3511	cast<InheritableAttr>(New)->setInherited(isInherited);
		3512	New->setImplicit(isImplicit);
		3513	New->setPackExpansion(isPackExpansion);
		3514	break;
		3515	}
		3516	case attr::TLSModel: {
		3517	bool isInherited = Record.readInt();
		3518	bool isImplicit = Record.readInt();
		3519	bool isPackExpansion = Record.readInt();
		3520	std::string model= Record.readString();
		3521	New = new (Context) TLSModelAttr(Context, Info, model);
		3522	cast<InheritableAttr>(New)->setInherited(isInherited);
		3523	New->setImplicit(isImplicit);
		3524	New->setPackExpansion(isPackExpansion);
		3525	break;
		3526	}
		3527	case attr::Target: {
		3528	bool isInherited = Record.readInt();
		3529	bool isImplicit = Record.readInt();
		3530	bool isPackExpansion = Record.readInt();
		3531	std::string featuresStr= Record.readString();
		3532	New = new (Context) TargetAttr(Context, Info, featuresStr);
		3533	cast<InheritableAttr>(New)->setInherited(isInherited);
		3534	New->setImplicit(isImplicit);
		3535	New->setPackExpansion(isPackExpansion);
		3536	break;
		3537	}
		3538	case attr::TargetClones: {
		3539	bool isInherited = Record.readInt();
		3540	bool isImplicit = Record.readInt();
		3541	bool isPackExpansion = Record.readInt();
		3542	unsigned featuresStrsSize = Record.readInt();
		3543	SmallVector<StringRef, 4> featuresStrs;
		3544	featuresStrs.reserve(featuresStrsSize);
		3545	SmallVector<std::string, 4> featuresStrsStorage;
		3546	featuresStrsStorage.reserve(featuresStrsSize);
		3547	for (unsigned i = 0; i != featuresStrsSize; ++i)
		3548	featuresStrsStorage.push_back(Record.readString());
		3549	for (unsigned i = 0; i != featuresStrsSize; ++i)
		3550	featuresStrs.push_back(featuresStrsStorage[i]);
		3551	New = new (Context) TargetClonesAttr(Context, Info, featuresStrs.data(), featuresStrsSize);
		3552	cast<InheritableAttr>(New)->setInherited(isInherited);
		3553	New->setImplicit(isImplicit);
		3554	New->setPackExpansion(isPackExpansion);
		3555	break;
		3556	}
		3557	case attr::TargetVersion: {
		3558	bool isInherited = Record.readInt();
		3559	bool isImplicit = Record.readInt();
		3560	bool isPackExpansion = Record.readInt();
		3561	std::string namesStr= Record.readString();
		3562	New = new (Context) TargetVersionAttr(Context, Info, namesStr);
		3563	cast<InheritableAttr>(New)->setInherited(isInherited);
		3564	New->setImplicit(isImplicit);
		3565	New->setPackExpansion(isPackExpansion);
		3566	break;
		3567	}
		3568	case attr::TestTypestate: {
		3569	bool isInherited = Record.readInt();
		3570	bool isImplicit = Record.readInt();
		3571	bool isPackExpansion = Record.readInt();
		3572	TestTypestateAttr::ConsumedState testState(static_cast<TestTypestateAttr::ConsumedState>(Record.readInt()));
		3573	New = new (Context) TestTypestateAttr(Context, Info, testState);
		3574	cast<InheritableAttr>(New)->setInherited(isInherited);
		3575	New->setImplicit(isImplicit);
		3576	New->setPackExpansion(isPackExpansion);
		3577	break;
		3578	}
		3579	case attr::ThisCall: {
		3580	bool isInherited = Record.readInt();
		3581	bool isImplicit = Record.readInt();
		3582	bool isPackExpansion = Record.readInt();
		3583	New = new (Context) ThisCallAttr(Context, Info);
		3584	cast<InheritableAttr>(New)->setInherited(isInherited);
		3585	New->setImplicit(isImplicit);
		3586	New->setPackExpansion(isPackExpansion);
		3587	break;
		3588	}
		3589	case attr::Thread: {
		3590	bool isImplicit = Record.readInt();
		3591	bool isPackExpansion = Record.readInt();
		3592	New = new (Context) ThreadAttr(Context, Info);
		3593	New->setImplicit(isImplicit);
		3594	New->setPackExpansion(isPackExpansion);
		3595	break;
		3596	}
		3597	case attr::TransparentUnion: {
		3598	bool isInherited = Record.readInt();
		3599	bool isImplicit = Record.readInt();
		3600	bool isPackExpansion = Record.readInt();
		3601	New = new (Context) TransparentUnionAttr(Context, Info);
		3602	cast<InheritableAttr>(New)->setInherited(isInherited);
		3603	New->setImplicit(isImplicit);
		3604	New->setPackExpansion(isPackExpansion);
		3605	break;
		3606	}
		3607	case attr::TrivialABI: {
		3608	bool isInherited = Record.readInt();
		3609	bool isImplicit = Record.readInt();
		3610	bool isPackExpansion = Record.readInt();
		3611	New = new (Context) TrivialABIAttr(Context, Info);
		3612	cast<InheritableAttr>(New)->setInherited(isInherited);
		3613	New->setImplicit(isImplicit);
		3614	New->setPackExpansion(isPackExpansion);
		3615	break;
		3616	}
		3617	case attr::TryAcquireCapability: {
		3618	bool isInherited = Record.readInt();
		3619	bool isImplicit = Record.readInt();
		3620	bool isPackExpansion = Record.readInt();
		3621	Expr * successValue = Record.readExpr();
		3622	unsigned argsSize = Record.readInt();
		3623	SmallVector<Expr *, 4> args;
		3624	args.reserve(argsSize);
		3625	for (unsigned i = 0; i != argsSize; ++i)
		3626	args.push_back(Record.readExpr());
		3627	New = new (Context) TryAcquireCapabilityAttr(Context, Info, successValue, args.data(), argsSize);
		3628	cast<InheritableAttr>(New)->setInherited(isInherited);
		3629	New->setImplicit(isImplicit);
		3630	New->setPackExpansion(isPackExpansion);
		3631	break;
		3632	}
		3633	case attr::TypeNonNull: {
		3634	bool isImplicit = Record.readInt();
		3635	bool isPackExpansion = Record.readInt();
		3636	New = new (Context) TypeNonNullAttr(Context, Info);
		3637	New->setImplicit(isImplicit);
		3638	New->setPackExpansion(isPackExpansion);
		3639	break;
		3640	}
		3641	case attr::TypeNullUnspecified: {
		3642	bool isImplicit = Record.readInt();
		3643	bool isPackExpansion = Record.readInt();
		3644	New = new (Context) TypeNullUnspecifiedAttr(Context, Info);
		3645	New->setImplicit(isImplicit);
		3646	New->setPackExpansion(isPackExpansion);
		3647	break;
		3648	}
		3649	case attr::TypeNullable: {
		3650	bool isImplicit = Record.readInt();
		3651	bool isPackExpansion = Record.readInt();
		3652	New = new (Context) TypeNullableAttr(Context, Info);
		3653	New->setImplicit(isImplicit);
		3654	New->setPackExpansion(isPackExpansion);
		3655	break;
		3656	}
		3657	case attr::TypeNullableResult: {
		3658	bool isImplicit = Record.readInt();
		3659	bool isPackExpansion = Record.readInt();
		3660	New = new (Context) TypeNullableResultAttr(Context, Info);
		3661	New->setImplicit(isImplicit);
		3662	New->setPackExpansion(isPackExpansion);
		3663	break;
		3664	}
		3665	case attr::TypeTagForDatatype: {
		3666	bool isInherited = Record.readInt();
		3667	bool isImplicit = Record.readInt();
		3668	bool isPackExpansion = Record.readInt();
		3669	IdentifierInfo * argumentKind = Record.readIdentifier();
		3670	TypeSourceInfo * matchingCType = Record.readTypeSourceInfo();
		3671	bool layoutCompatible = Record.readInt();
		3672	bool mustBeNull = Record.readInt();
		3673	New = new (Context) TypeTagForDatatypeAttr(Context, Info, argumentKind, matchingCType, layoutCompatible, mustBeNull);
		3674	cast<InheritableAttr>(New)->setInherited(isInherited);
		3675	New->setImplicit(isImplicit);
		3676	New->setPackExpansion(isPackExpansion);
		3677	break;
		3678	}
		3679	case attr::TypeVisibility: {
		3680	bool isInherited = Record.readInt();
		3681	bool isImplicit = Record.readInt();
		3682	bool isPackExpansion = Record.readInt();
		3683	TypeVisibilityAttr::VisibilityType visibility(static_cast<TypeVisibilityAttr::VisibilityType>(Record.readInt()));
		3684	New = new (Context) TypeVisibilityAttr(Context, Info, visibility);
		3685	cast<InheritableAttr>(New)->setInherited(isInherited);
		3686	New->setImplicit(isImplicit);
		3687	New->setPackExpansion(isPackExpansion);
		3688	break;
		3689	}
		3690	case attr::UPtr: {
		3691	bool isImplicit = Record.readInt();
		3692	bool isPackExpansion = Record.readInt();
		3693	New = new (Context) UPtrAttr(Context, Info);
		3694	New->setImplicit(isImplicit);
		3695	New->setPackExpansion(isPackExpansion);
		3696	break;
		3697	}
		3698	case attr::Unavailable: {
		3699	bool isInherited = Record.readInt();
		3700	bool isImplicit = Record.readInt();
		3701	bool isPackExpansion = Record.readInt();
		3702	std::string message= Record.readString();
		3703	UnavailableAttr::ImplicitReason implicitReason(static_cast<UnavailableAttr::ImplicitReason>(Record.readInt()));
		3704	New = new (Context) UnavailableAttr(Context, Info, message, implicitReason);
		3705	cast<InheritableAttr>(New)->setInherited(isInherited);
		3706	New->setImplicit(isImplicit);
		3707	New->setPackExpansion(isPackExpansion);
		3708	break;
		3709	}
		3710	case attr::Uninitialized: {
		3711	bool isInherited = Record.readInt();
		3712	bool isImplicit = Record.readInt();
		3713	bool isPackExpansion = Record.readInt();
		3714	New = new (Context) UninitializedAttr(Context, Info);
		3715	cast<InheritableAttr>(New)->setInherited(isInherited);
		3716	New->setImplicit(isImplicit);
		3717	New->setPackExpansion(isPackExpansion);
		3718	break;
		3719	}
		3720	case attr::Unlikely: {
		3721	bool isImplicit = Record.readInt();
		3722	bool isPackExpansion = Record.readInt();
		3723	New = new (Context) UnlikelyAttr(Context, Info);
		3724	New->setImplicit(isImplicit);
		3725	New->setPackExpansion(isPackExpansion);
		3726	break;
		3727	}
		3728	case attr::Unused: {
		3729	bool isInherited = Record.readInt();
		3730	bool isImplicit = Record.readInt();
		3731	bool isPackExpansion = Record.readInt();
		3732	New = new (Context) UnusedAttr(Context, Info);
		3733	cast<InheritableAttr>(New)->setInherited(isInherited);
		3734	New->setImplicit(isImplicit);
		3735	New->setPackExpansion(isPackExpansion);
		3736	break;
		3737	}
		3738	case attr::UseHandle: {
		3739	bool isInherited = Record.readInt();
		3740	bool isImplicit = Record.readInt();
		3741	bool isPackExpansion = Record.readInt();
		3742	std::string handleType= Record.readString();
		3743	New = new (Context) UseHandleAttr(Context, Info, handleType);
		3744	cast<InheritableAttr>(New)->setInherited(isInherited);
		3745	New->setImplicit(isImplicit);
		3746	New->setPackExpansion(isPackExpansion);
		3747	break;
		3748	}
		3749	case attr::Used: {
		3750	bool isInherited = Record.readInt();
		3751	bool isImplicit = Record.readInt();
		3752	bool isPackExpansion = Record.readInt();
		3753	New = new (Context) UsedAttr(Context, Info);
		3754	cast<InheritableAttr>(New)->setInherited(isInherited);
		3755	New->setImplicit(isImplicit);
		3756	New->setPackExpansion(isPackExpansion);
		3757	break;
		3758	}
		3759	case attr::UsingIfExists: {
		3760	bool isInherited = Record.readInt();
		3761	bool isImplicit = Record.readInt();
		3762	bool isPackExpansion = Record.readInt();
		3763	New = new (Context) UsingIfExistsAttr(Context, Info);
		3764	cast<InheritableAttr>(New)->setInherited(isInherited);
		3765	New->setImplicit(isImplicit);
		3766	New->setPackExpansion(isPackExpansion);
		3767	break;
		3768	}
		3769	case attr::Uuid: {
		3770	bool isInherited = Record.readInt();
		3771	bool isImplicit = Record.readInt();
		3772	bool isPackExpansion = Record.readInt();
		3773	std::string guid= Record.readString();
		3774	MSGuidDecl * guidDecl = Record.GetLocalDeclAs<MSGuidDecl >(Record.readInt());
		3775	New = new (Context) UuidAttr(Context, Info, guid, guidDecl);
		3776	cast<InheritableAttr>(New)->setInherited(isInherited);
		3777	New->setImplicit(isImplicit);
		3778	New->setPackExpansion(isPackExpansion);
		3779	break;
		3780	}
		3781	case attr::VecReturn: {
		3782	bool isInherited = Record.readInt();
		3783	bool isImplicit = Record.readInt();
		3784	bool isPackExpansion = Record.readInt();
		3785	New = new (Context) VecReturnAttr(Context, Info);
		3786	cast<InheritableAttr>(New)->setInherited(isInherited);
		3787	New->setImplicit(isImplicit);
		3788	New->setPackExpansion(isPackExpansion);
		3789	break;
		3790	}
		3791	case attr::VecTypeHint: {
		3792	bool isInherited = Record.readInt();
		3793	bool isImplicit = Record.readInt();
		3794	bool isPackExpansion = Record.readInt();
		3795	TypeSourceInfo * typeHint = Record.readTypeSourceInfo();
		3796	New = new (Context) VecTypeHintAttr(Context, Info, typeHint);
		3797	cast<InheritableAttr>(New)->setInherited(isInherited);
		3798	New->setImplicit(isImplicit);
		3799	New->setPackExpansion(isPackExpansion);
		3800	break;
		3801	}
		3802	case attr::VectorCall: {
		3803	bool isInherited = Record.readInt();
		3804	bool isImplicit = Record.readInt();
		3805	bool isPackExpansion = Record.readInt();
		3806	New = new (Context) VectorCallAttr(Context, Info);
		3807	cast<InheritableAttr>(New)->setInherited(isInherited);
		3808	New->setImplicit(isImplicit);
		3809	New->setPackExpansion(isPackExpansion);
		3810	break;
		3811	}
		3812	case attr::Visibility: {
		3813	bool isInherited = Record.readInt();
		3814	bool isImplicit = Record.readInt();
		3815	bool isPackExpansion = Record.readInt();
		3816	VisibilityAttr::VisibilityType visibility(static_cast<VisibilityAttr::VisibilityType>(Record.readInt()));
		3817	New = new (Context) VisibilityAttr(Context, Info, visibility);
		3818	cast<InheritableAttr>(New)->setInherited(isInherited);
		3819	New->setImplicit(isImplicit);
		3820	New->setPackExpansion(isPackExpansion);
		3821	break;
		3822	}
		3823	case attr::WarnUnused: {
		3824	bool isInherited = Record.readInt();
		3825	bool isImplicit = Record.readInt();
		3826	bool isPackExpansion = Record.readInt();
		3827	New = new (Context) WarnUnusedAttr(Context, Info);
		3828	cast<InheritableAttr>(New)->setInherited(isInherited);
		3829	New->setImplicit(isImplicit);
		3830	New->setPackExpansion(isPackExpansion);
		3831	break;
		3832	}
		3833	case attr::WarnUnusedResult: {
		3834	bool isInherited = Record.readInt();
		3835	bool isImplicit = Record.readInt();
		3836	bool isPackExpansion = Record.readInt();
		3837	std::string message= Record.readString();
		3838	New = new (Context) WarnUnusedResultAttr(Context, Info, message);
		3839	cast<InheritableAttr>(New)->setInherited(isInherited);
		3840	New->setImplicit(isImplicit);
		3841	New->setPackExpansion(isPackExpansion);
		3842	break;
		3843	}
		3844	case attr::Weak: {
		3845	bool isInherited = Record.readInt();
		3846	bool isImplicit = Record.readInt();
		3847	bool isPackExpansion = Record.readInt();
		3848	New = new (Context) WeakAttr(Context, Info);
		3849	cast<InheritableAttr>(New)->setInherited(isInherited);
		3850	New->setImplicit(isImplicit);
		3851	New->setPackExpansion(isPackExpansion);
		3852	break;
		3853	}
		3854	case attr::WeakImport: {
		3855	bool isInherited = Record.readInt();
		3856	bool isImplicit = Record.readInt();
		3857	bool isPackExpansion = Record.readInt();
		3858	New = new (Context) WeakImportAttr(Context, Info);
		3859	cast<InheritableAttr>(New)->setInherited(isInherited);
		3860	New->setImplicit(isImplicit);
		3861	New->setPackExpansion(isPackExpansion);
		3862	break;
		3863	}
		3864	case attr::WeakRef: {
		3865	bool isInherited = Record.readInt();
		3866	bool isImplicit = Record.readInt();
		3867	bool isPackExpansion = Record.readInt();
		3868	std::string aliasee= Record.readString();
		3869	New = new (Context) WeakRefAttr(Context, Info, aliasee);
		3870	cast<InheritableAttr>(New)->setInherited(isInherited);
		3871	New->setImplicit(isImplicit);
		3872	New->setPackExpansion(isPackExpansion);
		3873	break;
		3874	}
		3875	case attr::WebAssemblyExportName: {
		3876	bool isInherited = Record.readInt();
		3877	bool isImplicit = Record.readInt();
		3878	bool isPackExpansion = Record.readInt();
		3879	std::string exportName= Record.readString();
		3880	New = new (Context) WebAssemblyExportNameAttr(Context, Info, exportName);
		3881	cast<InheritableAttr>(New)->setInherited(isInherited);
		3882	New->setImplicit(isImplicit);
		3883	New->setPackExpansion(isPackExpansion);
		3884	break;
		3885	}
		3886	case attr::WebAssemblyImportModule: {
		3887	bool isInherited = Record.readInt();
		3888	bool isImplicit = Record.readInt();
		3889	bool isPackExpansion = Record.readInt();
		3890	std::string importModule= Record.readString();
		3891	New = new (Context) WebAssemblyImportModuleAttr(Context, Info, importModule);
		3892	cast<InheritableAttr>(New)->setInherited(isInherited);
		3893	New->setImplicit(isImplicit);
		3894	New->setPackExpansion(isPackExpansion);
		3895	break;
		3896	}
		3897	case attr::WebAssemblyImportName: {
		3898	bool isInherited = Record.readInt();
		3899	bool isImplicit = Record.readInt();
		3900	bool isPackExpansion = Record.readInt();
		3901	std::string importName= Record.readString();
		3902	New = new (Context) WebAssemblyImportNameAttr(Context, Info, importName);
		3903	cast<InheritableAttr>(New)->setInherited(isInherited);
		3904	New->setImplicit(isImplicit);
		3905	New->setPackExpansion(isPackExpansion);
		3906	break;
		3907	}
		3908	case attr::WorkGroupSizeHint: {
		3909	bool isInherited = Record.readInt();
		3910	bool isImplicit = Record.readInt();
		3911	bool isPackExpansion = Record.readInt();
		3912	unsigned xDim = Record.readInt();
		3913	unsigned yDim = Record.readInt();
		3914	unsigned zDim = Record.readInt();
		3915	New = new (Context) WorkGroupSizeHintAttr(Context, Info, xDim, yDim, zDim);
		3916	cast<InheritableAttr>(New)->setInherited(isInherited);
		3917	New->setImplicit(isImplicit);
		3918	New->setPackExpansion(isPackExpansion);
		3919	break;
		3920	}
		3921	case attr::X86ForceAlignArgPointer: {
		3922	bool isInherited = Record.readInt();
		3923	bool isImplicit = Record.readInt();
		3924	bool isPackExpansion = Record.readInt();
		3925	New = new (Context) X86ForceAlignArgPointerAttr(Context, Info);
		3926	cast<InheritableAttr>(New)->setInherited(isInherited);
		3927	New->setImplicit(isImplicit);
		3928	New->setPackExpansion(isPackExpansion);
		3929	break;
		3930	}
		3931	case attr::XRayInstrument: {
		3932	bool isInherited = Record.readInt();
		3933	bool isImplicit = Record.readInt();
		3934	bool isPackExpansion = Record.readInt();
		3935	New = new (Context) XRayInstrumentAttr(Context, Info);
		3936	cast<InheritableAttr>(New)->setInherited(isInherited);
		3937	New->setImplicit(isImplicit);
		3938	New->setPackExpansion(isPackExpansion);
		3939	break;
		3940	}
		3941	case attr::XRayLogArgs: {
		3942	bool isInherited = Record.readInt();
		3943	bool isImplicit = Record.readInt();
		3944	bool isPackExpansion = Record.readInt();
		3945	unsigned argumentCount = Record.readInt();
		3946	New = new (Context) XRayLogArgsAttr(Context, Info, argumentCount);
		3947	cast<InheritableAttr>(New)->setInherited(isInherited);
		3948	New->setImplicit(isImplicit);
		3949	New->setPackExpansion(isPackExpansion);
		3950	break;
		3951	}
		3952	case attr::ZeroCallUsedRegs: {
		3953	bool isInherited = Record.readInt();
		3954	bool isImplicit = Record.readInt();
		3955	bool isPackExpansion = Record.readInt();
		3956	ZeroCallUsedRegsAttr::ZeroCallUsedRegsKind zeroCallUsedRegs(static_cast<ZeroCallUsedRegsAttr::ZeroCallUsedRegsKind>(Record.readInt()));
		3957	New = new (Context) ZeroCallUsedRegsAttr(Context, Info, zeroCallUsedRegs);
		3958	cast<InheritableAttr>(New)->setInherited(isInherited);
		3959	New->setImplicit(isImplicit);
		3960	New->setPackExpansion(isPackExpansion);
		3961	break;
		3962	}
		3963	}

Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

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