1	//===--- ASTWriterDecl.cpp - Declaration Serialization --------------------===//
2	//
3	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4	// See https://llvm.org/LICENSE.txt for license information.
5	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6	//
7	//===----------------------------------------------------------------------===//
8	//
9	// This file implements serialization for Declarations.
10	//
11	//===----------------------------------------------------------------------===//
12
13	#include "ASTCommon.h"
14	#include "clang/AST/Attr.h"
15	#include "clang/AST/DeclCXX.h"
16	#include "clang/AST/DeclTemplate.h"
17	#include "clang/AST/DeclVisitor.h"
18	#include "clang/AST/Expr.h"
19	#include "clang/AST/OpenMPClause.h"
20	#include "clang/AST/PrettyDeclStackTrace.h"
21	#include "clang/Basic/SourceManager.h"
22	#include "clang/Serialization/ASTReader.h"
23	#include "clang/Serialization/ASTRecordWriter.h"
24	#include "llvm/Bitstream/BitstreamWriter.h"
25	#include "llvm/Support/ErrorHandling.h"
26	using namespace clang;
27	using namespace serialization;
28
29	//===----------------------------------------------------------------------===//
30	// Utility functions
31	//===----------------------------------------------------------------------===//
32
33	namespace {
34
35	// Helper function that returns true if the decl passed in the argument is
36	// a defintion in dependent contxt.
37	template <typename DT> bool isDefinitionInDependentContext(DT *D) {
38	return D->isDependentContext() && D->isThisDeclarationADefinition();
39	}
40
41	} // namespace
42
43	//===----------------------------------------------------------------------===//
44	// Declaration serialization
45	//===----------------------------------------------------------------------===//
46
47	namespace clang {
48	class ASTDeclWriter : public DeclVisitor<ASTDeclWriter, void> {
49	ASTWriter &Writer;
50	ASTRecordWriter Record;
51
52	serialization::DeclCode Code;
53	unsigned AbbrevToUse;
54
55	bool GeneratingReducedBMI = false;
56
57	public:
58	ASTDeclWriter(ASTWriter &Writer, ASTContext &Context,
59	ASTWriter::RecordDataImpl &Record, bool GeneratingReducedBMI)
60	: Writer(Writer), Record(Context, Writer, Record),
61	Code((serialization::DeclCode)0), AbbrevToUse(0),
62	GeneratingReducedBMI(GeneratingReducedBMI) {}
63
64	uint64_t Emit(Decl *D) {
65	if (!Code)
66	llvm::report_fatal_error(reason: StringRef("unexpected declaration kind '") +
67	D->getDeclKindName() + "'");
68	return Record.Emit(Code, Abbrev: AbbrevToUse);
69	}
70
71	void Visit(Decl *D);
72
73	void VisitDecl(Decl *D);
74	void VisitPragmaCommentDecl(PragmaCommentDecl *D);
75	void VisitPragmaDetectMismatchDecl(PragmaDetectMismatchDecl *D);
76	void VisitTranslationUnitDecl(TranslationUnitDecl *D);
77	void VisitNamedDecl(NamedDecl *D);
78	void VisitLabelDecl(LabelDecl *LD);
79	void VisitNamespaceDecl(NamespaceDecl *D);
80	void VisitUsingDirectiveDecl(UsingDirectiveDecl *D);
81	void VisitNamespaceAliasDecl(NamespaceAliasDecl *D);
82	void VisitTypeDecl(TypeDecl *D);
83	void VisitTypedefNameDecl(TypedefNameDecl *D);
84	void VisitTypedefDecl(TypedefDecl *D);
85	void VisitTypeAliasDecl(TypeAliasDecl *D);
86	void VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D);
87	void VisitUnresolvedUsingIfExistsDecl(UnresolvedUsingIfExistsDecl *D);
88	void VisitTagDecl(TagDecl *D);
89	void VisitEnumDecl(EnumDecl *D);
90	void VisitRecordDecl(RecordDecl *D);
91	void VisitCXXRecordDecl(CXXRecordDecl *D);
92	void VisitClassTemplateSpecializationDecl(
93	ClassTemplateSpecializationDecl *D);
94	void VisitClassTemplatePartialSpecializationDecl(
95	ClassTemplatePartialSpecializationDecl *D);
96	void VisitVarTemplateSpecializationDecl(VarTemplateSpecializationDecl *D);
97	void VisitVarTemplatePartialSpecializationDecl(
98	VarTemplatePartialSpecializationDecl *D);
99	void VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D);
100	void VisitValueDecl(ValueDecl *D);
101	void VisitEnumConstantDecl(EnumConstantDecl *D);
102	void VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D);
103	void VisitDeclaratorDecl(DeclaratorDecl *D);
104	void VisitFunctionDecl(FunctionDecl *D);
105	void VisitCXXDeductionGuideDecl(CXXDeductionGuideDecl *D);
106	void VisitCXXMethodDecl(CXXMethodDecl *D);
107	void VisitCXXConstructorDecl(CXXConstructorDecl *D);
108	void VisitCXXDestructorDecl(CXXDestructorDecl *D);
109	void VisitCXXConversionDecl(CXXConversionDecl *D);
110	void VisitFieldDecl(FieldDecl *D);
111	void VisitMSPropertyDecl(MSPropertyDecl *D);
112	void VisitMSGuidDecl(MSGuidDecl *D);
113	void VisitUnnamedGlobalConstantDecl(UnnamedGlobalConstantDecl *D);
114	void VisitTemplateParamObjectDecl(TemplateParamObjectDecl *D);
115	void VisitIndirectFieldDecl(IndirectFieldDecl *D);
116	void VisitVarDecl(VarDecl *D);
117	void VisitImplicitParamDecl(ImplicitParamDecl *D);
118	void VisitParmVarDecl(ParmVarDecl *D);
119	void VisitDecompositionDecl(DecompositionDecl *D);
120	void VisitBindingDecl(BindingDecl *D);
121	void VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D);
122	void VisitTemplateDecl(TemplateDecl *D);
123	void VisitConceptDecl(ConceptDecl *D);
124	void VisitImplicitConceptSpecializationDecl(
125	ImplicitConceptSpecializationDecl *D);
126	void VisitRequiresExprBodyDecl(RequiresExprBodyDecl *D);
127	void VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D);
128	void VisitClassTemplateDecl(ClassTemplateDecl *D);
129	void VisitVarTemplateDecl(VarTemplateDecl *D);
130	void VisitFunctionTemplateDecl(FunctionTemplateDecl *D);
131	void VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D);
132	void VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D);
133	void VisitUsingDecl(UsingDecl *D);
134	void VisitUsingEnumDecl(UsingEnumDecl *D);
135	void VisitUsingPackDecl(UsingPackDecl *D);
136	void VisitUsingShadowDecl(UsingShadowDecl *D);
137	void VisitConstructorUsingShadowDecl(ConstructorUsingShadowDecl *D);
138	void VisitLinkageSpecDecl(LinkageSpecDecl *D);
139	void VisitExportDecl(ExportDecl *D);
140	void VisitFileScopeAsmDecl(FileScopeAsmDecl *D);
141	void VisitTopLevelStmtDecl(TopLevelStmtDecl *D);
142	void VisitImportDecl(ImportDecl *D);
143	void VisitAccessSpecDecl(AccessSpecDecl *D);
144	void VisitFriendDecl(FriendDecl *D);
145	void VisitFriendTemplateDecl(FriendTemplateDecl *D);
146	void VisitStaticAssertDecl(StaticAssertDecl *D);
147	void VisitBlockDecl(BlockDecl *D);
148	void VisitOutlinedFunctionDecl(OutlinedFunctionDecl *D);
149	void VisitCapturedDecl(CapturedDecl *D);
150	void VisitEmptyDecl(EmptyDecl *D);
151	void VisitLifetimeExtendedTemporaryDecl(LifetimeExtendedTemporaryDecl *D);
152	void VisitDeclContext(DeclContext *DC);
153	template <typename T> void VisitRedeclarable(Redeclarable<T> *D);
154	void VisitHLSLBufferDecl(HLSLBufferDecl *D);
155
156	// FIXME: Put in the same order is DeclNodes.td?
157	void VisitObjCMethodDecl(ObjCMethodDecl *D);
158	void VisitObjCTypeParamDecl(ObjCTypeParamDecl *D);
159	void VisitObjCContainerDecl(ObjCContainerDecl *D);
160	void VisitObjCInterfaceDecl(ObjCInterfaceDecl *D);
161	void VisitObjCIvarDecl(ObjCIvarDecl *D);
162	void VisitObjCProtocolDecl(ObjCProtocolDecl *D);
163	void VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D);
164	void VisitObjCCategoryDecl(ObjCCategoryDecl *D);
165	void VisitObjCImplDecl(ObjCImplDecl *D);
166	void VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D);
167	void VisitObjCImplementationDecl(ObjCImplementationDecl *D);
168	void VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D);
169	void VisitObjCPropertyDecl(ObjCPropertyDecl *D);
170	void VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D);
171	void VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D);
172	void VisitOMPAllocateDecl(OMPAllocateDecl *D);
173	void VisitOMPRequiresDecl(OMPRequiresDecl *D);
174	void VisitOMPDeclareReductionDecl(OMPDeclareReductionDecl *D);
175	void VisitOMPDeclareMapperDecl(OMPDeclareMapperDecl *D);
176	void VisitOMPCapturedExprDecl(OMPCapturedExprDecl *D);
177
178	void VisitOpenACCDeclareDecl(OpenACCDeclareDecl *D);
179	void VisitOpenACCRoutineDecl(OpenACCRoutineDecl *D);
180
181	/// Add an Objective-C type parameter list to the given record.
182	void AddObjCTypeParamList(ObjCTypeParamList *typeParams) {
183	// Empty type parameter list.
184	if (!typeParams) {
185	Record.push_back(N: 0);
186	return;
187	}
188
189	Record.push_back(N: typeParams->size());
190	for (auto *typeParam : *typeParams) {
191	Record.AddDeclRef(D: typeParam);
192	}
193	Record.AddSourceLocation(Loc: typeParams->getLAngleLoc());
194	Record.AddSourceLocation(Loc: typeParams->getRAngleLoc());
195	}
196
197	/// Collect the first declaration from each module file that provides a
198	/// declaration of D.
199	void CollectFirstDeclFromEachModule(
200	const Decl *D, bool IncludeLocal,
201	llvm::MapVector<ModuleFile *, const Decl *> &Firsts) {
202
203	// FIXME: We can skip entries that we know are implied by others.
204	for (const Decl *R = D->getMostRecentDecl(); R; R = R->getPreviousDecl()) {
205	if (R->isFromASTFile())
206	Firsts[Writer.Chain->getOwningModuleFile(D: R)] = R;
207	else if (IncludeLocal)
208	Firsts[nullptr] = R;
209	}
210	}
211
212	/// Add to the record the first declaration from each module file that
213	/// provides a declaration of D. The intent is to provide a sufficient
214	/// set such that reloading this set will load all current redeclarations.
215	void AddFirstDeclFromEachModule(const Decl *D, bool IncludeLocal) {
216	llvm::MapVector<ModuleFile *, const Decl *> Firsts;
217	CollectFirstDeclFromEachModule(D, IncludeLocal, Firsts);
218
219	for (const auto &F : Firsts)
220	Record.AddDeclRef(D: F.second);
221	}
222
223	template <typename T> bool shouldSkipWritingSpecializations(T *Spec) {
224	// Now we will only avoid writing specializations if we're generating
225	// reduced BMI.
226	if (!GeneratingReducedBMI)
227	return false;
228
229	assert((isa<FunctionDecl, ClassTemplateSpecializationDecl,
230	VarTemplateSpecializationDecl>(Spec)));
231
232	ArrayRef<TemplateArgument> Args;
233	if (auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(Spec))
234	Args = CTSD->getTemplateArgs().asArray();
235	else if (auto *VTSD = dyn_cast<VarTemplateSpecializationDecl>(Spec))
236	Args = VTSD->getTemplateArgs().asArray();
237	else
238	Args = cast<FunctionDecl>(Spec)
239	->getTemplateSpecializationArgs()
240	->asArray();
241
242	// If there is any template argument is TULocal, we can avoid writing the
243	// specialization since the consumers of reduced BMI won't get the
244	// specialization anyway.
245	for (const TemplateArgument &TA : Args) {
246	switch (TA.getKind()) {
247	case TemplateArgument::Type: {
248	Linkage L = TA.getAsType()->getLinkage();
249	if (!isExternallyVisible(L))
250	return true;
251	break;
252	}
253	case TemplateArgument::Declaration:
254	if (!TA.getAsDecl()->isExternallyVisible())
255	return true;
256	break;
257	default:
258	break;
259	}
260	}
261
262	return false;
263	}
264
265	/// Add to the record the first template specialization from each module
266	/// file that provides a declaration of D. We store the DeclId and an
267	/// ODRHash of the template arguments of D which should provide enough
268	/// information to load D only if the template instantiator needs it.
269	void AddFirstSpecializationDeclFromEachModule(
270	const Decl *D, llvm::SmallVectorImpl<const Decl *> &SpecsInMap,
271	llvm::SmallVectorImpl<const Decl *> &PartialSpecsInMap) {
272	assert((isa<ClassTemplateSpecializationDecl>(D) ||
273	isa<VarTemplateSpecializationDecl>(D) || isa<FunctionDecl>(D)) &&
274	"Must not be called with other decls");
275	llvm::MapVector<ModuleFile *, const Decl *> Firsts;
276	CollectFirstDeclFromEachModule(D, /*IncludeLocal*/ true, Firsts);
277
278	for (const auto &F : Firsts) {
279	if (shouldSkipWritingSpecializations(Spec: F.second))
280	continue;
281
282	if (isa<ClassTemplatePartialSpecializationDecl,
283	VarTemplatePartialSpecializationDecl>(Val: F.second))
284	PartialSpecsInMap.push_back(Elt: F.second);
285	else
286	SpecsInMap.push_back(Elt: F.second);
287	}
288	}
289
290	/// Get the specialization decl from an entry in the specialization list.
291	template <typename EntryType>
292	typename RedeclarableTemplateDecl::SpecEntryTraits<EntryType>::DeclType *
293	getSpecializationDecl(EntryType &T) {
294	return RedeclarableTemplateDecl::SpecEntryTraits<EntryType>::getDecl(&T);
295	}
296
297	/// Get the list of partial specializations from a template's common ptr.
298	template<typename T>
299	decltype(T::PartialSpecializations) &getPartialSpecializations(T *Common) {
300	return Common->PartialSpecializations;
301	}
302	MutableArrayRef<FunctionTemplateSpecializationInfo>
303	getPartialSpecializations(FunctionTemplateDecl::Common *) {
304	return {};
305	}
306
307	template<typename DeclTy>
308	void AddTemplateSpecializations(DeclTy *D) {
309	auto *Common = D->getCommonPtr();
310
311	// If we have any lazy specializations, and the external AST source is
312	// our chained AST reader, we can just write out the DeclIDs. Otherwise,
313	// we need to resolve them to actual declarations.
314	if (Writer.Chain != Record.getASTContext().getExternalSource() &&
315	Writer.Chain && Writer.Chain->haveUnloadedSpecializations(D)) {
316	D->LoadLazySpecializations();
317	assert(!Writer.Chain->haveUnloadedSpecializations(D));
318	}
319
320	// AddFirstSpecializationDeclFromEachModule might trigger deserialization,
321	// invalidating *Specializations iterators.
322	llvm::SmallVector<const Decl *, 16> AllSpecs;
323	for (auto &Entry : Common->Specializations)
324	AllSpecs.push_back(Elt: getSpecializationDecl(Entry));
325	for (auto &Entry : getPartialSpecializations(Common))
326	AllSpecs.push_back(Elt: getSpecializationDecl(Entry));
327
328	llvm::SmallVector<const Decl *, 16> Specs;
329	llvm::SmallVector<const Decl *, 16> PartialSpecs;
330	for (auto *D : AllSpecs) {
331	assert(D->isCanonicalDecl() && "non-canonical decl in set");
332	AddFirstSpecializationDeclFromEachModule(D, SpecsInMap&: Specs, PartialSpecsInMap&: PartialSpecs);
333	}
334
335	Record.AddOffset(BitOffset: Writer.WriteSpecializationInfoLookupTable(
336	D, Specializations&: Specs, /*IsPartial=*/false));
337
338	// Function Template Decl doesn't have partial decls.
339	if (isa<FunctionTemplateDecl>(D)) {
340	assert(PartialSpecs.empty());
341	return;
342	}
343
344	Record.AddOffset(BitOffset: Writer.WriteSpecializationInfoLookupTable(
345	D, Specializations&: PartialSpecs, /*IsPartial=*/true));
346	}
347
348	/// Ensure that this template specialization is associated with the specified
349	/// template on reload.
350	void RegisterTemplateSpecialization(const Decl *Template,
351	const Decl *Specialization) {
352	Template = Template->getCanonicalDecl();
353
354	// If the canonical template is local, we'll write out this specialization
355	// when we emit it.
356	// FIXME: We can do the same thing if there is any local declaration of
357	// the template, to avoid emitting an update record.
358	if (!Template->isFromASTFile())
359	return;
360
361	// We only need to associate the first local declaration of the
362	// specialization. The other declarations will get pulled in by it.
363	if (Writer.getFirstLocalDecl(D: Specialization) != Specialization)
364	return;
365
366	if (isa<ClassTemplatePartialSpecializationDecl,
367	VarTemplatePartialSpecializationDecl>(Val: Specialization))
368	Writer.PartialSpecializationsUpdates[cast<NamedDecl>(Val: Template)]
369	.push_back(Elt: cast<NamedDecl>(Val: Specialization));
370	else
371	Writer.SpecializationsUpdates[cast<NamedDecl>(Val: Template)].push_back(
372	Elt: cast<NamedDecl>(Val: Specialization));
373	}
374	};
375	}
376
377	// When building a C++20 module interface unit or a partition unit, a
378	// strong definition in the module interface is provided by the
379	// compilation of that unit, not by its users. (Inline variables are still
380	// emitted in module users.)
381	static bool shouldVarGenerateHereOnly(const VarDecl *VD) {
382	if (VD->getStorageDuration() != SD_Static)
383	return false;
384
385	if (VD->getDescribedVarTemplate())
386	return false;
387
388	Module *M = VD->getOwningModule();
389	if (!M)
390	return false;
391
392	M = M->getTopLevelModule();
393	ASTContext &Ctx = VD->getASTContext();
394	if (!M->isInterfaceOrPartition() &&
395	(!VD->hasAttr<DLLExportAttr>() ||
396	!Ctx.getLangOpts().BuildingPCHWithObjectFile))
397	return false;
398
399	return Ctx.GetGVALinkageForVariable(VD) >= GVA_StrongExternal;
400	}
401
402	static bool shouldFunctionGenerateHereOnly(const FunctionDecl *FD) {
403	if (FD->isDependentContext())
404	return false;
405
406	ASTContext &Ctx = FD->getASTContext();
407	auto Linkage = Ctx.GetGVALinkageForFunction(FD);
408	if (Ctx.getLangOpts().ModulesCodegen ||
409	(FD->hasAttr<DLLExportAttr>() &&
410	Ctx.getLangOpts().BuildingPCHWithObjectFile))
411	// Under -fmodules-codegen, codegen is performed for all non-internal,
412	// non-always_inline functions, unless they are available elsewhere.
413	if (!FD->hasAttr<AlwaysInlineAttr>() && Linkage != GVA_Internal &&
414	Linkage != GVA_AvailableExternally)
415	return true;
416
417	Module *M = FD->getOwningModule();
418	if (!M)
419	return false;
420
421	M = M->getTopLevelModule();
422	if (M->isInterfaceOrPartition())
423	if (Linkage >= GVA_StrongExternal)
424	return true;
425
426	return false;
427	}
428
429	bool clang::CanElideDeclDef(const Decl *D) {
430	if (auto *FD = dyn_cast<FunctionDecl>(Val: D)) {
431	if (FD->isInlined() || FD->isConstexpr() || FD->isConsteval())
432	return false;
433
434	// If the function should be generated somewhere else, we shouldn't elide
435	// it.
436	if (!shouldFunctionGenerateHereOnly(FD))
437	return false;
438	}
439
440	if (auto *VD = dyn_cast<VarDecl>(Val: D)) {
441	if (VD->getDeclContext()->isDependentContext())
442	return false;
443
444	// Constant initialized variable may not affect the ABI, but they
445	// may be used in constant evaluation in the frontend, so we have
446	// to remain them.
447	if (VD->hasConstantInitialization() || VD->isConstexpr())
448	return false;
449
450	// If the variable should be generated somewhere else, we shouldn't elide
451	// it.
452	if (!shouldVarGenerateHereOnly(VD))
453	return false;
454	}
455
456	return true;
457	}
458
459	void ASTDeclWriter::Visit(Decl *D) {
460	DeclVisitor<ASTDeclWriter>::Visit(D);
461
462	// Source locations require array (variable-length) abbreviations. The
463	// abbreviation infrastructure requires that arrays are encoded last, so
464	// we handle it here in the case of those classes derived from DeclaratorDecl
465	if (auto *DD = dyn_cast<DeclaratorDecl>(Val: D)) {
466	if (auto *TInfo = DD->getTypeSourceInfo())
467	Record.AddTypeLoc(TL: TInfo->getTypeLoc());
468	}
469
470	// Handle FunctionDecl's body here and write it after all other Stmts/Exprs
471	// have been written. We want it last because we will not read it back when
472	// retrieving it from the AST, we'll just lazily set the offset.
473	if (auto *FD = dyn_cast<FunctionDecl>(Val: D)) {
474	if (!GeneratingReducedBMI || !CanElideDeclDef(D: FD)) {
475	Record.push_back(N: FD->doesThisDeclarationHaveABody());
476	if (FD->doesThisDeclarationHaveABody())
477	Record.AddFunctionDefinition(FD);
478	} else
479	Record.push_back(N: 0);
480	}
481
482	// Similar to FunctionDecls, handle VarDecl's initializer here and write it
483	// after all other Stmts/Exprs. We will not read the initializer until after
484	// we have finished recursive deserialization, because it can recursively
485	// refer back to the variable.
486	if (auto *VD = dyn_cast<VarDecl>(Val: D)) {
487	if (!GeneratingReducedBMI || !CanElideDeclDef(D: VD))
488	Record.AddVarDeclInit(VD);
489	else
490	Record.push_back(N: 0);
491	}
492
493	// And similarly for FieldDecls. We already serialized whether there is a
494	// default member initializer.
495	if (auto *FD = dyn_cast<FieldDecl>(Val: D)) {
496	if (FD->hasInClassInitializer()) {
497	if (Expr *Init = FD->getInClassInitializer()) {
498	Record.push_back(N: 1);
499	Record.AddStmt(S: Init);
500	} else {
501	Record.push_back(N: 0);
502	// Initializer has not been instantiated yet.
503	}
504	}
505	}
506
507	// If this declaration is also a DeclContext, write blocks for the
508	// declarations that lexically stored inside its context and those
509	// declarations that are visible from its context.
510	if (auto *DC = dyn_cast<DeclContext>(Val: D))
511	VisitDeclContext(DC);
512	}
513
514	void ASTDeclWriter::VisitDecl(Decl *D) {
515	BitsPacker DeclBits;
516
517	// The order matters here. It will be better to put the bit with higher
518	// probability to be 0 in the end of the bits.
519	//
520	// Since we're using VBR6 format to store it.
521	// It will be pretty effient if all the higher bits are 0.
522	// For example, if we need to pack 8 bits into a value and the stored value
523	// is 0xf0, the actual stored value will be 0b000111'110000, which takes 12
524	// bits actually. However, if we changed the order to be 0x0f, then we can
525	// store it as 0b001111, which takes 6 bits only now.
526	DeclBits.addBits(Value: (uint64_t)D->getModuleOwnershipKind(), /*BitWidth=*/BitsWidth: 3);
527	DeclBits.addBit(Value: D->isReferenced());
528	DeclBits.addBit(Value: D->isUsed(CheckUsedAttr: false));
529	DeclBits.addBits(Value: D->getAccess(), /*BitWidth=*/BitsWidth: 2);
530	DeclBits.addBit(Value: D->isImplicit());
531	DeclBits.addBit(Value: D->getDeclContext() != D->getLexicalDeclContext());
532	DeclBits.addBit(Value: D->hasAttrs());
533	DeclBits.addBit(Value: D->isTopLevelDeclInObjCContainer());
534	DeclBits.addBit(Value: D->isInvalidDecl());
535	Record.push_back(N: DeclBits);
536
537	Record.AddDeclRef(D: cast_or_null<Decl>(Val: D->getDeclContext()));
538	if (D->getDeclContext() != D->getLexicalDeclContext())
539	Record.AddDeclRef(D: cast_or_null<Decl>(Val: D->getLexicalDeclContext()));
540
541	if (D->hasAttrs())
542	Record.AddAttributes(Attrs: D->getAttrs());
543
544	Record.push_back(N: Writer.getSubmoduleID(Mod: D->getOwningModule()));
545
546	// If this declaration injected a name into a context different from its
547	// lexical context, and that context is an imported namespace, we need to
548	// update its visible declarations to include this name.
549	//
550	// This happens when we instantiate a class with a friend declaration or a
551	// function with a local extern declaration, for instance.
552	//
553	// FIXME: Can we handle this in AddedVisibleDecl instead?
554	if (D->isOutOfLine()) {
555	auto *DC = D->getDeclContext();
556	while (auto *NS = dyn_cast<NamespaceDecl>(Val: DC->getRedeclContext())) {
557	if (!NS->isFromASTFile())
558	break;
559	Writer.UpdatedDeclContexts.insert(X: NS->getPrimaryContext());
560	if (!NS->isInlineNamespace())
561	break;
562	DC = NS->getParent();
563	}
564	}
565	}
566
567	void ASTDeclWriter::VisitPragmaCommentDecl(PragmaCommentDecl *D) {
568	StringRef Arg = D->getArg();
569	Record.push_back(N: Arg.size());
570	VisitDecl(D);
571	Record.AddSourceLocation(Loc: D->getBeginLoc());
572	Record.push_back(N: D->getCommentKind());
573	Record.AddString(Str: Arg);
574	Code = serialization::DECL_PRAGMA_COMMENT;
575	}
576
577	void ASTDeclWriter::VisitPragmaDetectMismatchDecl(
578	PragmaDetectMismatchDecl *D) {
579	StringRef Name = D->getName();
580	StringRef Value = D->getValue();
581	Record.push_back(N: Name.size() + 1 + Value.size());
582	VisitDecl(D);
583	Record.AddSourceLocation(Loc: D->getBeginLoc());
584	Record.AddString(Str: Name);
585	Record.AddString(Str: Value);
586	Code = serialization::DECL_PRAGMA_DETECT_MISMATCH;
587	}
588
589	void ASTDeclWriter::VisitTranslationUnitDecl(TranslationUnitDecl *D) {
590	llvm_unreachable("Translation units aren't directly serialized");
591	}
592
593	void ASTDeclWriter::VisitNamedDecl(NamedDecl *D) {
594	VisitDecl(D);
595	Record.AddDeclarationName(Name: D->getDeclName());
596	Record.push_back(N: needsAnonymousDeclarationNumber(D)
597	? Writer.getAnonymousDeclarationNumber(D)
598	: 0);
599	}
600
601	void ASTDeclWriter::VisitTypeDecl(TypeDecl *D) {
602	VisitNamedDecl(D);
603	Record.AddSourceLocation(Loc: D->getBeginLoc());
604	Record.AddTypeRef(T: QualType(D->getTypeForDecl(), 0));
605	}
606
607	void ASTDeclWriter::VisitTypedefNameDecl(TypedefNameDecl *D) {
608	VisitRedeclarable(D);
609	VisitTypeDecl(D);
610	Record.AddTypeSourceInfo(TInfo: D->getTypeSourceInfo());
611	Record.push_back(N: D->isModed());
612	if (D->isModed())
613	Record.AddTypeRef(T: D->getUnderlyingType());
614	Record.AddDeclRef(D: D->getAnonDeclWithTypedefName(AnyRedecl: false));
615	}
616
617	void ASTDeclWriter::VisitTypedefDecl(TypedefDecl *D) {
618	VisitTypedefNameDecl(D);
619	if (D->getDeclContext() == D->getLexicalDeclContext() &&
620	!D->hasAttrs() &&
621	!D->isImplicit() &&
622	D->getFirstDecl() == D->getMostRecentDecl() &&
623	!D->isInvalidDecl() &&
624	!D->isTopLevelDeclInObjCContainer() &&
625	!D->isModulePrivate() &&
626	!needsAnonymousDeclarationNumber(D) &&
627	D->getDeclName().getNameKind() == DeclarationName::Identifier)
628	AbbrevToUse = Writer.getDeclTypedefAbbrev();
629
630	Code = serialization::DECL_TYPEDEF;
631	}
632
633	void ASTDeclWriter::VisitTypeAliasDecl(TypeAliasDecl *D) {
634	VisitTypedefNameDecl(D);
635	Record.AddDeclRef(D: D->getDescribedAliasTemplate());
636	Code = serialization::DECL_TYPEALIAS;
637	}
638
639	void ASTDeclWriter::VisitTagDecl(TagDecl *D) {
640	static_assert(DeclContext::NumTagDeclBits == 23,
641	"You need to update the serializer after you change the "
642	"TagDeclBits");
643
644	VisitRedeclarable(D);
645	VisitTypeDecl(D);
646	Record.push_back(N: D->getIdentifierNamespace());
647
648	BitsPacker TagDeclBits;
649	TagDeclBits.addBits(Value: llvm::to_underlying(E: D->getTagKind()), /*BitWidth=*/BitsWidth: 3);
650	TagDeclBits.addBit(Value: !isa<CXXRecordDecl>(Val: D) ? D->isCompleteDefinition() : 0);
651	TagDeclBits.addBit(Value: D->isEmbeddedInDeclarator());
652	TagDeclBits.addBit(Value: D->isFreeStanding());
653	TagDeclBits.addBit(Value: D->isCompleteDefinitionRequired());
654	TagDeclBits.addBits(
655	Value: D->hasExtInfo() ? 1 : (D->getTypedefNameForAnonDecl() ? 2 : 0),
656	/*BitWidth=*/BitsWidth: 2);
657	Record.push_back(N: TagDeclBits);
658
659	Record.AddSourceRange(Range: D->getBraceRange());
660
661	if (D->hasExtInfo()) {
662	Record.AddQualifierInfo(Info: *D->getExtInfo());
663	} else if (auto *TD = D->getTypedefNameForAnonDecl()) {
664	Record.AddDeclRef(D: TD);
665	Record.AddIdentifierRef(II: TD->getDeclName().getAsIdentifierInfo());
666	}
667	}
668
669	void ASTDeclWriter::VisitEnumDecl(EnumDecl *D) {
670	static_assert(DeclContext::NumEnumDeclBits == 43,
671	"You need to update the serializer after you change the "
672	"EnumDeclBits");
673
674	VisitTagDecl(D);
675	Record.AddTypeSourceInfo(TInfo: D->getIntegerTypeSourceInfo());
676	if (!D->getIntegerTypeSourceInfo())
677	Record.AddTypeRef(T: D->getIntegerType());
678	Record.AddTypeRef(T: D->getPromotionType());
679
680	BitsPacker EnumDeclBits;
681	EnumDeclBits.addBits(Value: D->getNumPositiveBits(), /*BitWidth=*/BitsWidth: 8);
682	EnumDeclBits.addBits(Value: D->getNumNegativeBits(), /*BitWidth=*/BitsWidth: 8);
683	EnumDeclBits.addBit(Value: D->isScoped());
684	EnumDeclBits.addBit(Value: D->isScopedUsingClassTag());
685	EnumDeclBits.addBit(Value: D->isFixed());
686	Record.push_back(N: EnumDeclBits);
687
688	Record.push_back(N: D->getODRHash());
689
690	if (MemberSpecializationInfo *MemberInfo = D->getMemberSpecializationInfo()) {
691	Record.AddDeclRef(D: MemberInfo->getInstantiatedFrom());
692	Record.push_back(N: MemberInfo->getTemplateSpecializationKind());
693	Record.AddSourceLocation(Loc: MemberInfo->getPointOfInstantiation());
694	} else {
695	Record.AddDeclRef(D: nullptr);
696	}
697
698	if (D->getDeclContext() == D->getLexicalDeclContext() && !D->hasAttrs() &&
699	!D->isInvalidDecl() && !D->isImplicit() && !D->hasExtInfo() &&
700	!D->getTypedefNameForAnonDecl() &&
701	D->getFirstDecl() == D->getMostRecentDecl() &&
702	!D->isTopLevelDeclInObjCContainer() &&
703	!CXXRecordDecl::classofKind(K: D->getKind()) &&
704	!D->getIntegerTypeSourceInfo() && !D->getMemberSpecializationInfo() &&
705	!needsAnonymousDeclarationNumber(D) &&
706	D->getDeclName().getNameKind() == DeclarationName::Identifier)
707	AbbrevToUse = Writer.getDeclEnumAbbrev();
708
709	Code = serialization::DECL_ENUM;
710	}
711
712	void ASTDeclWriter::VisitRecordDecl(RecordDecl *D) {
713	static_assert(DeclContext::NumRecordDeclBits == 64,
714	"You need to update the serializer after you change the "
715	"RecordDeclBits");
716
717	VisitTagDecl(D);
718
719	BitsPacker RecordDeclBits;
720	RecordDeclBits.addBit(Value: D->hasFlexibleArrayMember());
721	RecordDeclBits.addBit(Value: D->isAnonymousStructOrUnion());
722	RecordDeclBits.addBit(Value: D->hasObjectMember());
723	RecordDeclBits.addBit(Value: D->hasVolatileMember());
724	RecordDeclBits.addBit(Value: D->isNonTrivialToPrimitiveDefaultInitialize());
725	RecordDeclBits.addBit(Value: D->isNonTrivialToPrimitiveCopy());
726	RecordDeclBits.addBit(Value: D->isNonTrivialToPrimitiveDestroy());
727	RecordDeclBits.addBit(Value: D->hasNonTrivialToPrimitiveDefaultInitializeCUnion());
728	RecordDeclBits.addBit(Value: D->hasNonTrivialToPrimitiveDestructCUnion());
729	RecordDeclBits.addBit(Value: D->hasNonTrivialToPrimitiveCopyCUnion());
730	RecordDeclBits.addBit(Value: D->hasUninitializedExplicitInitFields());
731	RecordDeclBits.addBit(Value: D->isParamDestroyedInCallee());
732	RecordDeclBits.addBits(Value: llvm::to_underlying(E: D->getArgPassingRestrictions()), BitsWidth: 2);
733	Record.push_back(N: RecordDeclBits);
734
735	// Only compute this for C/Objective-C, in C++ this is computed as part
736	// of CXXRecordDecl.
737	if (!isa<CXXRecordDecl>(Val: D))
738	Record.push_back(N: D->getODRHash());
739
740	if (D->getDeclContext() == D->getLexicalDeclContext() && !D->hasAttrs() &&
741	!D->isImplicit() && !D->isInvalidDecl() && !D->hasExtInfo() &&
742	!D->getTypedefNameForAnonDecl() &&
743	D->getFirstDecl() == D->getMostRecentDecl() &&
744	!D->isTopLevelDeclInObjCContainer() &&
745	!CXXRecordDecl::classofKind(K: D->getKind()) &&
746	!needsAnonymousDeclarationNumber(D) &&
747	D->getDeclName().getNameKind() == DeclarationName::Identifier)
748	AbbrevToUse = Writer.getDeclRecordAbbrev();
749
750	Code = serialization::DECL_RECORD;
751	}
752
753	void ASTDeclWriter::VisitValueDecl(ValueDecl *D) {
754	VisitNamedDecl(D);
755	Record.AddTypeRef(T: D->getType());
756	}
757
758	void ASTDeclWriter::VisitEnumConstantDecl(EnumConstantDecl *D) {
759	VisitValueDecl(D);
760	Record.push_back(N: D->getInitExpr()? 1 : 0);
761	if (D->getInitExpr())
762	Record.AddStmt(S: D->getInitExpr());
763	Record.AddAPSInt(Value: D->getInitVal());
764
765	Code = serialization::DECL_ENUM_CONSTANT;
766	}
767
768	void ASTDeclWriter::VisitDeclaratorDecl(DeclaratorDecl *D) {
769	VisitValueDecl(D);
770	Record.AddSourceLocation(Loc: D->getInnerLocStart());
771	Record.push_back(N: D->hasExtInfo());
772	if (D->hasExtInfo()) {
773	DeclaratorDecl::ExtInfo *Info = D->getExtInfo();
774	Record.AddQualifierInfo(Info: *Info);
775	Record.AddStmt(
776	S: const_cast<Expr *>(Info->TrailingRequiresClause.ConstraintExpr));
777	Record.writeUnsignedOrNone(Value: Info->TrailingRequiresClause.ArgPackSubstIndex);
778	}
779	// The location information is deferred until the end of the record.
780	Record.AddTypeRef(T: D->getTypeSourceInfo() ? D->getTypeSourceInfo()->getType()
781	: QualType());
782	}
783
784	void ASTDeclWriter::VisitFunctionDecl(FunctionDecl *D) {
785	static_assert(DeclContext::NumFunctionDeclBits == 45,
786	"You need to update the serializer after you change the "
787	"FunctionDeclBits");
788
789	VisitRedeclarable(D);
790
791	Record.push_back(N: D->getTemplatedKind());
792	switch (D->getTemplatedKind()) {
793	case FunctionDecl::TK_NonTemplate:
794	break;
795	case FunctionDecl::TK_DependentNonTemplate:
796	Record.AddDeclRef(D: D->getInstantiatedFromDecl());
797	break;
798	case FunctionDecl::TK_FunctionTemplate:
799	Record.AddDeclRef(D: D->getDescribedFunctionTemplate());
800	break;
801	case FunctionDecl::TK_MemberSpecialization: {
802	MemberSpecializationInfo *MemberInfo = D->getMemberSpecializationInfo();
803	Record.AddDeclRef(D: MemberInfo->getInstantiatedFrom());
804	Record.push_back(N: MemberInfo->getTemplateSpecializationKind());
805	Record.AddSourceLocation(Loc: MemberInfo->getPointOfInstantiation());
806	break;
807	}
808	case FunctionDecl::TK_FunctionTemplateSpecialization: {
809	FunctionTemplateSpecializationInfo *
810	FTSInfo = D->getTemplateSpecializationInfo();
811
812	RegisterTemplateSpecialization(Template: FTSInfo->getTemplate(), Specialization: D);
813
814	Record.AddDeclRef(D: FTSInfo->getTemplate());
815	Record.push_back(N: FTSInfo->getTemplateSpecializationKind());
816
817	// Template arguments.
818	Record.AddTemplateArgumentList(TemplateArgs: FTSInfo->TemplateArguments);
819
820	// Template args as written.
821	Record.push_back(N: FTSInfo->TemplateArgumentsAsWritten != nullptr);
822	if (FTSInfo->TemplateArgumentsAsWritten)
823	Record.AddASTTemplateArgumentListInfo(
824	ASTTemplArgList: FTSInfo->TemplateArgumentsAsWritten);
825
826	Record.AddSourceLocation(Loc: FTSInfo->getPointOfInstantiation());
827
828	if (MemberSpecializationInfo *MemberInfo =
829	FTSInfo->getMemberSpecializationInfo()) {
830	Record.push_back(N: 1);
831	Record.AddDeclRef(D: MemberInfo->getInstantiatedFrom());
832	Record.push_back(N: MemberInfo->getTemplateSpecializationKind());
833	Record.AddSourceLocation(Loc: MemberInfo->getPointOfInstantiation());
834	} else {
835	Record.push_back(N: 0);
836	}
837
838	if (D->isCanonicalDecl()) {
839	// Write the template that contains the specializations set. We will
840	// add a FunctionTemplateSpecializationInfo to it when reading.
841	Record.AddDeclRef(D: FTSInfo->getTemplate()->getCanonicalDecl());
842	}
843	break;
844	}
845	case FunctionDecl::TK_DependentFunctionTemplateSpecialization: {
846	DependentFunctionTemplateSpecializationInfo *
847	DFTSInfo = D->getDependentSpecializationInfo();
848
849	// Candidates.
850	Record.push_back(N: DFTSInfo->getCandidates().size());
851	for (FunctionTemplateDecl *FTD : DFTSInfo->getCandidates())
852	Record.AddDeclRef(D: FTD);
853
854	// Templates args.
855	Record.push_back(N: DFTSInfo->TemplateArgumentsAsWritten != nullptr);
856	if (DFTSInfo->TemplateArgumentsAsWritten)
857	Record.AddASTTemplateArgumentListInfo(
858	ASTTemplArgList: DFTSInfo->TemplateArgumentsAsWritten);
859	break;
860	}
861	}
862
863	VisitDeclaratorDecl(D);
864	Record.AddDeclarationNameLoc(DNLoc: D->DNLoc, Name: D->getDeclName());
865	Record.push_back(N: D->getIdentifierNamespace());
866
867	// The order matters here. It will be better to put the bit with higher
868	// probability to be 0 in the end of the bits. See the comments in VisitDecl
869	// for details.
870	BitsPacker FunctionDeclBits;
871	// FIXME: stable encoding
872	FunctionDeclBits.addBits(Value: llvm::to_underlying(E: D->getLinkageInternal()), BitsWidth: 3);
873	FunctionDeclBits.addBits(Value: (uint32_t)D->getStorageClass(), /*BitWidth=*/BitsWidth: 3);
874	FunctionDeclBits.addBit(Value: D->isInlineSpecified());
875	FunctionDeclBits.addBit(Value: D->isInlined());
876	FunctionDeclBits.addBit(Value: D->hasSkippedBody());
877	FunctionDeclBits.addBit(Value: D->isVirtualAsWritten());
878	FunctionDeclBits.addBit(Value: D->isPureVirtual());
879	FunctionDeclBits.addBit(Value: D->hasInheritedPrototype());
880	FunctionDeclBits.addBit(Value: D->hasWrittenPrototype());
881	FunctionDeclBits.addBit(Value: D->isDeletedBit());
882	FunctionDeclBits.addBit(Value: D->isTrivial());
883	FunctionDeclBits.addBit(Value: D->isTrivialForCall());
884	FunctionDeclBits.addBit(Value: D->isDefaulted());
885	FunctionDeclBits.addBit(Value: D->isExplicitlyDefaulted());
886	FunctionDeclBits.addBit(Value: D->isIneligibleOrNotSelected());
887	FunctionDeclBits.addBits(Value: (uint64_t)(D->getConstexprKind()), /*BitWidth=*/BitsWidth: 2);
888	FunctionDeclBits.addBit(Value: D->hasImplicitReturnZero());
889	FunctionDeclBits.addBit(Value: D->isMultiVersion());
890	FunctionDeclBits.addBit(Value: D->isLateTemplateParsed());
891	FunctionDeclBits.addBit(Value: D->isInstantiatedFromMemberTemplate());
892	FunctionDeclBits.addBit(Value: D->FriendConstraintRefersToEnclosingTemplate());
893	FunctionDeclBits.addBit(Value: D->usesSEHTry());
894	FunctionDeclBits.addBit(Value: D->isDestroyingOperatorDelete());
895	FunctionDeclBits.addBit(Value: D->isTypeAwareOperatorNewOrDelete());
896	Record.push_back(N: FunctionDeclBits);
897
898	Record.AddSourceLocation(Loc: D->getEndLoc());
899	if (D->isExplicitlyDefaulted())
900	Record.AddSourceLocation(Loc: D->getDefaultLoc());
901
902	Record.push_back(N: D->getODRHash());
903
904	if (D->isDefaulted() || D->isDeletedAsWritten()) {
905	if (auto *FDI = D->getDefalutedOrDeletedInfo()) {
906	// Store both that there is an DefaultedOrDeletedInfo and whether it
907	// contains a DeletedMessage.
908	StringLiteral *DeletedMessage = FDI->getDeletedMessage();
909	Record.push_back(N: 1 | (DeletedMessage ? 2 : 0));
910	if (DeletedMessage)
911	Record.AddStmt(S: DeletedMessage);
912
913	Record.push_back(N: FDI->getUnqualifiedLookups().size());
914	for (DeclAccessPair P : FDI->getUnqualifiedLookups()) {
915	Record.AddDeclRef(D: P.getDecl());
916	Record.push_back(N: P.getAccess());
917	}
918	} else {
919	Record.push_back(N: 0);
920	}
921	}
922
923	if (D->getFriendObjectKind()) {
924	// For a friend function defined inline within a class template, we have to
925	// force the definition to be the one inside the definition of the template
926	// class. Remember this relation to deserialize them together.
927	if (auto *RD = dyn_cast<CXXRecordDecl>(Val: D->getLexicalParent());
928	RD && isDefinitionInDependentContext(D: RD)) {
929	Writer.RelatedDeclsMap[Writer.GetDeclRef(D: RD)].push_back(
930	Elt: Writer.GetDeclRef(D));
931	}
932	}
933
934	Record.push_back(N: D->param_size());
935	for (auto *P : D->parameters())
936	Record.AddDeclRef(D: P);
937	Code = serialization::DECL_FUNCTION;
938	}
939
940	static void addExplicitSpecifier(ExplicitSpecifier ES,
941	ASTRecordWriter &Record) {
942	uint64_t Kind = static_cast<uint64_t>(ES.getKind());
943	Kind = Kind << 1 | static_cast<bool>(ES.getExpr());
944	Record.push_back(N: Kind);
945	if (ES.getExpr()) {
946	Record.AddStmt(S: ES.getExpr());
947	}
948	}
949
950	void ASTDeclWriter::VisitCXXDeductionGuideDecl(CXXDeductionGuideDecl *D) {
951	addExplicitSpecifier(ES: D->getExplicitSpecifier(), Record);
952	Record.AddDeclRef(D: D->Ctor);
953	VisitFunctionDecl(D);
954	Record.push_back(N: static_cast<unsigned char>(D->getDeductionCandidateKind()));
955	Record.AddDeclRef(D: D->getSourceDeductionGuide());
956	Record.push_back(
957	N: static_cast<unsigned char>(D->getSourceDeductionGuideKind()));
958	Code = serialization::DECL_CXX_DEDUCTION_GUIDE;
959	}
960
961	void ASTDeclWriter::VisitObjCMethodDecl(ObjCMethodDecl *D) {
962	static_assert(DeclContext::NumObjCMethodDeclBits == 37,
963	"You need to update the serializer after you change the "
964	"ObjCMethodDeclBits");
965
966	VisitNamedDecl(D);
967	// FIXME: convert to LazyStmtPtr?
968	// Unlike C/C++, method bodies will never be in header files.
969	bool HasBodyStuff = D->getBody() != nullptr;
970	Record.push_back(N: HasBodyStuff);
971	if (HasBodyStuff) {
972	Record.AddStmt(S: D->getBody());
973	}
974	Record.AddDeclRef(D: D->getSelfDecl());
975	Record.AddDeclRef(D: D->getCmdDecl());
976	Record.push_back(N: D->isInstanceMethod());
977	Record.push_back(N: D->isVariadic());
978	Record.push_back(N: D->isPropertyAccessor());
979	Record.push_back(N: D->isSynthesizedAccessorStub());
980	Record.push_back(N: D->isDefined());
981	Record.push_back(N: D->isOverriding());
982	Record.push_back(N: D->hasSkippedBody());
983
984	Record.push_back(N: D->isRedeclaration());
985	Record.push_back(N: D->hasRedeclaration());
986	if (D->hasRedeclaration()) {
987	assert(Record.getASTContext().getObjCMethodRedeclaration(D));
988	Record.AddDeclRef(D: Record.getASTContext().getObjCMethodRedeclaration(MD: D));
989	}
990
991	// FIXME: stable encoding for @required/@optional
992	Record.push_back(N: llvm::to_underlying(E: D->getImplementationControl()));
993	// FIXME: stable encoding for in/out/inout/bycopy/byref/oneway/nullability
994	Record.push_back(N: D->getObjCDeclQualifier());
995	Record.push_back(N: D->hasRelatedResultType());
996	Record.AddTypeRef(T: D->getReturnType());
997	Record.AddTypeSourceInfo(TInfo: D->getReturnTypeSourceInfo());
998	Record.AddSourceLocation(Loc: D->getEndLoc());
999	Record.push_back(N: D->param_size());
1000	for (const auto *P : D->parameters())
1001	Record.AddDeclRef(D: P);
1002
1003	Record.push_back(N: D->getSelLocsKind());
1004	unsigned NumStoredSelLocs = D->getNumStoredSelLocs();
1005	SourceLocation *SelLocs = D->getStoredSelLocs();
1006	Record.push_back(N: NumStoredSelLocs);
1007	for (unsigned i = 0; i != NumStoredSelLocs; ++i)
1008	Record.AddSourceLocation(Loc: SelLocs[i]);
1009
1010	Code = serialization::DECL_OBJC_METHOD;
1011	}
1012
1013	void ASTDeclWriter::VisitObjCTypeParamDecl(ObjCTypeParamDecl *D) {
1014	VisitTypedefNameDecl(D);
1015	Record.push_back(N: D->Variance);
1016	Record.push_back(N: D->Index);
1017	Record.AddSourceLocation(Loc: D->VarianceLoc);
1018	Record.AddSourceLocation(Loc: D->ColonLoc);
1019
1020	Code = serialization::DECL_OBJC_TYPE_PARAM;
1021	}
1022
1023	void ASTDeclWriter::VisitObjCContainerDecl(ObjCContainerDecl *D) {
1024	static_assert(DeclContext::NumObjCContainerDeclBits == 64,
1025	"You need to update the serializer after you change the "
1026	"ObjCContainerDeclBits");
1027
1028	VisitNamedDecl(D);
1029	Record.AddSourceLocation(Loc: D->getAtStartLoc());
1030	Record.AddSourceRange(Range: D->getAtEndRange());
1031	// Abstract class (no need to define a stable serialization::DECL code).
1032	}
1033
1034	void ASTDeclWriter::VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) {
1035	VisitRedeclarable(D);
1036	VisitObjCContainerDecl(D);
1037	Record.AddTypeRef(T: QualType(D->getTypeForDecl(), 0));
1038	AddObjCTypeParamList(typeParams: D->TypeParamList);
1039
1040	Record.push_back(N: D->isThisDeclarationADefinition());
1041	if (D->isThisDeclarationADefinition()) {
1042	// Write the DefinitionData
1043	ObjCInterfaceDecl::DefinitionData &Data = D->data();
1044
1045	Record.AddTypeSourceInfo(TInfo: D->getSuperClassTInfo());
1046	Record.AddSourceLocation(Loc: D->getEndOfDefinitionLoc());
1047	Record.push_back(N: Data.HasDesignatedInitializers);
1048	Record.push_back(N: D->getODRHash());
1049
1050	// Write out the protocols that are directly referenced by the @interface.
1051	Record.push_back(N: Data.ReferencedProtocols.size());
1052	for (const auto *P : D->protocols())
1053	Record.AddDeclRef(D: P);
1054	for (const auto &PL : D->protocol_locs())
1055	Record.AddSourceLocation(Loc: PL);
1056
1057	// Write out the protocols that are transitively referenced.
1058	Record.push_back(N: Data.AllReferencedProtocols.size());
1059	for (ObjCList<ObjCProtocolDecl>::iterator
1060	P = Data.AllReferencedProtocols.begin(),
1061	PEnd = Data.AllReferencedProtocols.end();
1062	P != PEnd; ++P)
1063	Record.AddDeclRef(D: *P);
1064
1065
1066	if (ObjCCategoryDecl *Cat = D->getCategoryListRaw()) {
1067	// Ensure that we write out the set of categories for this class.
1068	Writer.ObjCClassesWithCategories.insert(X: D);
1069
1070	// Make sure that the categories get serialized.
1071	for (; Cat; Cat = Cat->getNextClassCategoryRaw())
1072	(void)Writer.GetDeclRef(D: Cat);
1073	}
1074	}
1075
1076	Code = serialization::DECL_OBJC_INTERFACE;
1077	}
1078
1079	void ASTDeclWriter::VisitObjCIvarDecl(ObjCIvarDecl *D) {
1080	VisitFieldDecl(D);
1081	// FIXME: stable encoding for @public/@private/@protected/@package
1082	Record.push_back(N: D->getAccessControl());
1083	Record.push_back(N: D->getSynthesize());
1084
1085	if (D->getDeclContext() == D->getLexicalDeclContext() &&
1086	!D->hasAttrs() &&
1087	!D->isImplicit() &&
1088	!D->isUsed(CheckUsedAttr: false) &&
1089	!D->isInvalidDecl() &&
1090	!D->isReferenced() &&
1091	!D->isModulePrivate() &&
1092	!D->getBitWidth() &&
1093	!D->hasExtInfo() &&
1094	D->getDeclName())
1095	AbbrevToUse = Writer.getDeclObjCIvarAbbrev();
1096
1097	Code = serialization::DECL_OBJC_IVAR;
1098	}
1099
1100	void ASTDeclWriter::VisitObjCProtocolDecl(ObjCProtocolDecl *D) {
1101	VisitRedeclarable(D);
1102	VisitObjCContainerDecl(D);
1103
1104	Record.push_back(N: D->isThisDeclarationADefinition());
1105	if (D->isThisDeclarationADefinition()) {
1106	Record.push_back(N: D->protocol_size());
1107	for (const auto *I : D->protocols())
1108	Record.AddDeclRef(D: I);
1109	for (const auto &PL : D->protocol_locs())
1110	Record.AddSourceLocation(Loc: PL);
1111	Record.push_back(N: D->getODRHash());
1112	}
1113
1114	Code = serialization::DECL_OBJC_PROTOCOL;
1115	}
1116
1117	void ASTDeclWriter::VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D) {
1118	VisitFieldDecl(D);
1119	Code = serialization::DECL_OBJC_AT_DEFS_FIELD;
1120	}
1121
1122	void ASTDeclWriter::VisitObjCCategoryDecl(ObjCCategoryDecl *D) {
1123	VisitObjCContainerDecl(D);
1124	Record.AddSourceLocation(Loc: D->getCategoryNameLoc());
1125	Record.AddSourceLocation(Loc: D->getIvarLBraceLoc());
1126	Record.AddSourceLocation(Loc: D->getIvarRBraceLoc());
1127	Record.AddDeclRef(D: D->getClassInterface());
1128	AddObjCTypeParamList(typeParams: D->TypeParamList);
1129	Record.push_back(N: D->protocol_size());
1130	for (const auto *I : D->protocols())
1131	Record.AddDeclRef(D: I);
1132	for (const auto &PL : D->protocol_locs())
1133	Record.AddSourceLocation(Loc: PL);
1134	Code = serialization::DECL_OBJC_CATEGORY;
1135	}
1136
1137	void ASTDeclWriter::VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D) {
1138	VisitNamedDecl(D);
1139	Record.AddDeclRef(D: D->getClassInterface());
1140	Code = serialization::DECL_OBJC_COMPATIBLE_ALIAS;
1141	}
1142
1143	void ASTDeclWriter::VisitObjCPropertyDecl(ObjCPropertyDecl *D) {
1144	VisitNamedDecl(D);
1145	Record.AddSourceLocation(Loc: D->getAtLoc());
1146	Record.AddSourceLocation(Loc: D->getLParenLoc());
1147	Record.AddTypeRef(T: D->getType());
1148	Record.AddTypeSourceInfo(TInfo: D->getTypeSourceInfo());
1149	// FIXME: stable encoding
1150	Record.push_back(N: (unsigned)D->getPropertyAttributes());
1151	Record.push_back(N: (unsigned)D->getPropertyAttributesAsWritten());
1152	// FIXME: stable encoding
1153	Record.push_back(N: (unsigned)D->getPropertyImplementation());
1154	Record.AddDeclarationName(Name: D->getGetterName());
1155	Record.AddSourceLocation(Loc: D->getGetterNameLoc());
1156	Record.AddDeclarationName(Name: D->getSetterName());
1157	Record.AddSourceLocation(Loc: D->getSetterNameLoc());
1158	Record.AddDeclRef(D: D->getGetterMethodDecl());
1159	Record.AddDeclRef(D: D->getSetterMethodDecl());
1160	Record.AddDeclRef(D: D->getPropertyIvarDecl());
1161	Code = serialization::DECL_OBJC_PROPERTY;
1162	}
1163
1164	void ASTDeclWriter::VisitObjCImplDecl(ObjCImplDecl *D) {
1165	VisitObjCContainerDecl(D);
1166	Record.AddDeclRef(D: D->getClassInterface());
1167	// Abstract class (no need to define a stable serialization::DECL code).
1168	}
1169
1170	void ASTDeclWriter::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
1171	VisitObjCImplDecl(D);
1172	Record.AddSourceLocation(Loc: D->getCategoryNameLoc());
1173	Code = serialization::DECL_OBJC_CATEGORY_IMPL;
1174	}
1175
1176	void ASTDeclWriter::VisitObjCImplementationDecl(ObjCImplementationDecl *D) {
1177	VisitObjCImplDecl(D);
1178	Record.AddDeclRef(D: D->getSuperClass());
1179	Record.AddSourceLocation(Loc: D->getSuperClassLoc());
1180	Record.AddSourceLocation(Loc: D->getIvarLBraceLoc());
1181	Record.AddSourceLocation(Loc: D->getIvarRBraceLoc());
1182	Record.push_back(N: D->hasNonZeroConstructors());
1183	Record.push_back(N: D->hasDestructors());
1184	Record.push_back(N: D->NumIvarInitializers);
1185	if (D->NumIvarInitializers)
1186	Record.AddCXXCtorInitializers(
1187	CtorInits: llvm::ArrayRef(D->init_begin(), D->init_end()));
1188	Code = serialization::DECL_OBJC_IMPLEMENTATION;
1189	}
1190
1191	void ASTDeclWriter::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) {
1192	VisitDecl(D);
1193	Record.AddSourceLocation(Loc: D->getBeginLoc());
1194	Record.AddDeclRef(D: D->getPropertyDecl());
1195	Record.AddDeclRef(D: D->getPropertyIvarDecl());
1196	Record.AddSourceLocation(Loc: D->getPropertyIvarDeclLoc());
1197	Record.AddDeclRef(D: D->getGetterMethodDecl());
1198	Record.AddDeclRef(D: D->getSetterMethodDecl());
1199	Record.AddStmt(S: D->getGetterCXXConstructor());
1200	Record.AddStmt(S: D->getSetterCXXAssignment());
1201	Code = serialization::DECL_OBJC_PROPERTY_IMPL;
1202	}
1203
1204	void ASTDeclWriter::VisitFieldDecl(FieldDecl *D) {
1205	VisitDeclaratorDecl(D);
1206	Record.push_back(N: D->isMutable());
1207
1208	Record.push_back(N: (D->StorageKind << 1) | D->BitField);
1209	if (D->StorageKind == FieldDecl::ISK_CapturedVLAType)
1210	Record.AddTypeRef(T: QualType(D->getCapturedVLAType(), 0));
1211	else if (D->BitField)
1212	Record.AddStmt(S: D->getBitWidth());
1213
1214	if (!D->getDeclName() || D->isPlaceholderVar(LangOpts: Writer.getLangOpts()))
1215	Record.AddDeclRef(
1216	D: Record.getASTContext().getInstantiatedFromUnnamedFieldDecl(Field: D));
1217
1218	if (D->getDeclContext() == D->getLexicalDeclContext() &&
1219	!D->hasAttrs() &&
1220	!D->isImplicit() &&
1221	!D->isUsed(CheckUsedAttr: false) &&
1222	!D->isInvalidDecl() &&
1223	!D->isReferenced() &&
1224	!D->isTopLevelDeclInObjCContainer() &&
1225	!D->isModulePrivate() &&
1226	!D->getBitWidth() &&
1227	!D->hasInClassInitializer() &&
1228	!D->hasCapturedVLAType() &&
1229	!D->hasExtInfo() &&
1230	!ObjCIvarDecl::classofKind(K: D->getKind()) &&
1231	!ObjCAtDefsFieldDecl::classofKind(K: D->getKind()) &&
1232	D->getDeclName())
1233	AbbrevToUse = Writer.getDeclFieldAbbrev();
1234
1235	Code = serialization::DECL_FIELD;
1236	}
1237
1238	void ASTDeclWriter::VisitMSPropertyDecl(MSPropertyDecl *D) {
1239	VisitDeclaratorDecl(D);
1240	Record.AddIdentifierRef(II: D->getGetterId());
1241	Record.AddIdentifierRef(II: D->getSetterId());
1242	Code = serialization::DECL_MS_PROPERTY;
1243	}
1244
1245	void ASTDeclWriter::VisitMSGuidDecl(MSGuidDecl *D) {
1246	VisitValueDecl(D);
1247	MSGuidDecl::Parts Parts = D->getParts();
1248	Record.push_back(N: Parts.Part1);
1249	Record.push_back(N: Parts.Part2);
1250	Record.push_back(N: Parts.Part3);
1251	Record.append(begin: std::begin(arr&: Parts.Part4And5), end: std::end(arr&: Parts.Part4And5));
1252	Code = serialization::DECL_MS_GUID;
1253	}
1254
1255	void ASTDeclWriter::VisitUnnamedGlobalConstantDecl(
1256	UnnamedGlobalConstantDecl *D) {
1257	VisitValueDecl(D);
1258	Record.AddAPValue(Value: D->getValue());
1259	Code = serialization::DECL_UNNAMED_GLOBAL_CONSTANT;
1260	}
1261
1262	void ASTDeclWriter::VisitTemplateParamObjectDecl(TemplateParamObjectDecl *D) {
1263	VisitValueDecl(D);
1264	Record.AddAPValue(Value: D->getValue());
1265	Code = serialization::DECL_TEMPLATE_PARAM_OBJECT;
1266	}
1267
1268	void ASTDeclWriter::VisitIndirectFieldDecl(IndirectFieldDecl *D) {
1269	VisitValueDecl(D);
1270	Record.push_back(N: D->getChainingSize());
1271
1272	for (const auto *P : D->chain())
1273	Record.AddDeclRef(D: P);
1274	Code = serialization::DECL_INDIRECTFIELD;
1275	}
1276
1277	void ASTDeclWriter::VisitVarDecl(VarDecl *D) {
1278	VisitRedeclarable(D);
1279	VisitDeclaratorDecl(D);
1280
1281	// The order matters here. It will be better to put the bit with higher
1282	// probability to be 0 in the end of the bits. See the comments in VisitDecl
1283	// for details.
1284	BitsPacker VarDeclBits;
1285	VarDeclBits.addBits(Value: llvm::to_underlying(E: D->getLinkageInternal()),
1286	/*BitWidth=*/BitsWidth: 3);
1287
1288	bool ModulesCodegen = shouldVarGenerateHereOnly(VD: D);
1289	VarDeclBits.addBit(Value: ModulesCodegen);
1290
1291	VarDeclBits.addBits(Value: D->getStorageClass(), /*BitWidth=*/BitsWidth: 3);
1292	VarDeclBits.addBits(Value: D->getTSCSpec(), /*BitWidth=*/BitsWidth: 2);
1293	VarDeclBits.addBits(Value: D->getInitStyle(), /*BitWidth=*/BitsWidth: 2);
1294	VarDeclBits.addBit(Value: D->isARCPseudoStrong());
1295
1296	bool HasDeducedType = false;
1297	if (!isa<ParmVarDecl>(Val: D)) {
1298	VarDeclBits.addBit(Value: D->isThisDeclarationADemotedDefinition());
1299	VarDeclBits.addBit(Value: D->isExceptionVariable());
1300	VarDeclBits.addBit(Value: D->isNRVOVariable());
1301	VarDeclBits.addBit(Value: D->isCXXForRangeDecl());
1302
1303	VarDeclBits.addBit(Value: D->isInline());
1304	VarDeclBits.addBit(Value: D->isInlineSpecified());
1305	VarDeclBits.addBit(Value: D->isConstexpr());
1306	VarDeclBits.addBit(Value: D->isInitCapture());
1307	VarDeclBits.addBit(Value: D->isPreviousDeclInSameBlockScope());
1308
1309	VarDeclBits.addBit(Value: D->isEscapingByref());
1310	HasDeducedType = D->getType()->getContainedDeducedType();
1311	VarDeclBits.addBit(Value: HasDeducedType);
1312
1313	if (const auto *IPD = dyn_cast<ImplicitParamDecl>(Val: D))
1314	VarDeclBits.addBits(Value: llvm::to_underlying(E: IPD->getParameterKind()),
1315	/*Width=*/BitsWidth: 3);
1316	else
1317	VarDeclBits.addBits(Value: 0, /*Width=*/BitsWidth: 3);
1318
1319	VarDeclBits.addBit(Value: D->isObjCForDecl());
1320	VarDeclBits.addBit(Value: D->isCXXForRangeImplicitVar());
1321	}
1322
1323	Record.push_back(N: VarDeclBits);
1324
1325	if (ModulesCodegen)
1326	Writer.AddDeclRef(D, Record&: Writer.ModularCodegenDecls);
1327
1328	if (D->hasAttr<BlocksAttr>()) {
1329	BlockVarCopyInit Init = Record.getASTContext().getBlockVarCopyInit(VD: D);
1330	Record.AddStmt(S: Init.getCopyExpr());
1331	if (Init.getCopyExpr())
1332	Record.push_back(N: Init.canThrow());
1333	}
1334
1335	enum {
1336	VarNotTemplate = 0, VarTemplate, StaticDataMemberSpecialization
1337	};
1338	if (VarTemplateDecl *TemplD = D->getDescribedVarTemplate()) {
1339	Record.push_back(N: VarTemplate);
1340	Record.AddDeclRef(D: TemplD);
1341	} else if (MemberSpecializationInfo *SpecInfo
1342	= D->getMemberSpecializationInfo()) {
1343	Record.push_back(N: StaticDataMemberSpecialization);
1344	Record.AddDeclRef(D: SpecInfo->getInstantiatedFrom());
1345	Record.push_back(N: SpecInfo->getTemplateSpecializationKind());
1346	Record.AddSourceLocation(Loc: SpecInfo->getPointOfInstantiation());
1347	} else {
1348	Record.push_back(N: VarNotTemplate);
1349	}
1350
1351	if (D->getDeclContext() == D->getLexicalDeclContext() && !D->hasAttrs() &&
1352	!D->isTopLevelDeclInObjCContainer() &&
1353	!needsAnonymousDeclarationNumber(D) &&
1354	D->getDeclName().getNameKind() == DeclarationName::Identifier &&
1355	!D->hasExtInfo() && D->getFirstDecl() == D->getMostRecentDecl() &&
1356	D->getKind() == Decl::Var && !D->isInline() && !D->isConstexpr() &&
1357	!D->isInitCapture() && !D->isPreviousDeclInSameBlockScope() &&
1358	!D->hasInitWithSideEffects() && !D->isEscapingByref() &&
1359	!HasDeducedType && D->getStorageDuration() != SD_Static &&
1360	!D->getDescribedVarTemplate() && !D->getMemberSpecializationInfo() &&
1361	!D->isObjCForDecl() && !isa<ImplicitParamDecl>(Val: D) &&
1362	!D->isEscapingByref())
1363	AbbrevToUse = Writer.getDeclVarAbbrev();
1364
1365	Code = serialization::DECL_VAR;
1366	}
1367
1368	void ASTDeclWriter::VisitImplicitParamDecl(ImplicitParamDecl *D) {
1369	VisitVarDecl(D);
1370	Code = serialization::DECL_IMPLICIT_PARAM;
1371	}
1372
1373	void ASTDeclWriter::VisitParmVarDecl(ParmVarDecl *D) {
1374	VisitVarDecl(D);
1375
1376	// See the implementation of `ParmVarDecl::getParameterIndex()`, which may
1377	// exceed the size of the normal bitfield. So it may be better to not pack
1378	// these bits.
1379	Record.push_back(N: D->getFunctionScopeIndex());
1380
1381	BitsPacker ParmVarDeclBits;
1382	ParmVarDeclBits.addBit(Value: D->isObjCMethodParameter());
1383	ParmVarDeclBits.addBits(Value: D->getFunctionScopeDepth(), /*BitsWidth=*/7);
1384	// FIXME: stable encoding
1385	ParmVarDeclBits.addBits(Value: D->getObjCDeclQualifier(), /*BitsWidth=*/7);
1386	ParmVarDeclBits.addBit(Value: D->isKNRPromoted());
1387	ParmVarDeclBits.addBit(Value: D->hasInheritedDefaultArg());
1388	ParmVarDeclBits.addBit(Value: D->hasUninstantiatedDefaultArg());
1389	ParmVarDeclBits.addBit(Value: D->getExplicitObjectParamThisLoc().isValid());
1390	Record.push_back(N: ParmVarDeclBits);
1391
1392	if (D->hasUninstantiatedDefaultArg())
1393	Record.AddStmt(S: D->getUninstantiatedDefaultArg());
1394	if (D->getExplicitObjectParamThisLoc().isValid())
1395	Record.AddSourceLocation(Loc: D->getExplicitObjectParamThisLoc());
1396	Code = serialization::DECL_PARM_VAR;
1397
1398	// If the assumptions about the DECL_PARM_VAR abbrev are true, use it. Here
1399	// we dynamically check for the properties that we optimize for, but don't
1400	// know are true of all PARM_VAR_DECLs.
1401	if (D->getDeclContext() == D->getLexicalDeclContext() && !D->hasAttrs() &&
1402	!D->hasExtInfo() && D->getStorageClass() == 0 && !D->isInvalidDecl() &&
1403	!D->isTopLevelDeclInObjCContainer() &&
1404	D->getInitStyle() == VarDecl::CInit && // Can params have anything else?
1405	D->getInit() == nullptr) // No default expr.
1406	AbbrevToUse = Writer.getDeclParmVarAbbrev();
1407
1408	// Check things we know are true of *every* PARM_VAR_DECL, which is more than
1409	// just us assuming it.
1410	assert(!D->getTSCSpec() && "PARM_VAR_DECL can't use TLS");
1411	assert(!D->isThisDeclarationADemotedDefinition()
1412	&& "PARM_VAR_DECL can't be demoted definition.");
1413	assert(D->getAccess() == AS_none && "PARM_VAR_DECL can't be public/private");
1414	assert(!D->isExceptionVariable() && "PARM_VAR_DECL can't be exception var");
1415	assert(D->getPreviousDecl() == nullptr && "PARM_VAR_DECL can't be redecl");
1416	assert(!D->isStaticDataMember() &&
1417	"PARM_VAR_DECL can't be static data member");
1418	}
1419
1420	void ASTDeclWriter::VisitDecompositionDecl(DecompositionDecl *D) {
1421	// Record the number of bindings first to simplify deserialization.
1422	Record.push_back(N: D->bindings().size());
1423
1424	VisitVarDecl(D);
1425	for (auto *B : D->bindings())
1426	Record.AddDeclRef(D: B);
1427	Code = serialization::DECL_DECOMPOSITION;
1428	}
1429
1430	void ASTDeclWriter::VisitBindingDecl(BindingDecl *D) {
1431	VisitValueDecl(D);
1432	Record.AddStmt(S: D->getBinding());
1433	Code = serialization::DECL_BINDING;
1434	}
1435
1436	void ASTDeclWriter::VisitFileScopeAsmDecl(FileScopeAsmDecl *D) {
1437	VisitDecl(D);
1438	Record.AddStmt(S: D->getAsmStringExpr());
1439	Record.AddSourceLocation(Loc: D->getRParenLoc());
1440	Code = serialization::DECL_FILE_SCOPE_ASM;
1441	}
1442
1443	void ASTDeclWriter::VisitTopLevelStmtDecl(TopLevelStmtDecl *D) {
1444	VisitDecl(D);
1445	Record.AddStmt(S: D->getStmt());
1446	Code = serialization::DECL_TOP_LEVEL_STMT_DECL;
1447	}
1448
1449	void ASTDeclWriter::VisitEmptyDecl(EmptyDecl *D) {
1450	VisitDecl(D);
1451	Code = serialization::DECL_EMPTY;
1452	}
1453
1454	void ASTDeclWriter::VisitLifetimeExtendedTemporaryDecl(
1455	LifetimeExtendedTemporaryDecl *D) {
1456	VisitDecl(D);
1457	Record.AddDeclRef(D: D->getExtendingDecl());
1458	Record.AddStmt(S: D->getTemporaryExpr());
1459	Record.push_back(N: static_cast<bool>(D->getValue()));
1460	if (D->getValue())
1461	Record.AddAPValue(Value: *D->getValue());
1462	Record.push_back(N: D->getManglingNumber());
1463	Code = serialization::DECL_LIFETIME_EXTENDED_TEMPORARY;
1464	}
1465	void ASTDeclWriter::VisitBlockDecl(BlockDecl *D) {
1466	VisitDecl(D);
1467	Record.AddStmt(S: D->getBody());
1468	Record.AddTypeSourceInfo(TInfo: D->getSignatureAsWritten());
1469	Record.push_back(N: D->param_size());
1470	for (ParmVarDecl *P : D->parameters())
1471	Record.AddDeclRef(D: P);
1472	Record.push_back(N: D->isVariadic());
1473	Record.push_back(N: D->blockMissingReturnType());
1474	Record.push_back(N: D->isConversionFromLambda());
1475	Record.push_back(N: D->doesNotEscape());
1476	Record.push_back(N: D->canAvoidCopyToHeap());
1477	Record.push_back(N: D->capturesCXXThis());
1478	Record.push_back(N: D->getNumCaptures());
1479	for (const auto &capture : D->captures()) {
1480	Record.AddDeclRef(D: capture.getVariable());
1481
1482	unsigned flags = 0;
1483	if (capture.isByRef()) flags |= 1;
1484	if (capture.isNested()) flags |= 2;
1485	if (capture.hasCopyExpr()) flags |= 4;
1486	Record.push_back(N: flags);
1487
1488	if (capture.hasCopyExpr()) Record.AddStmt(S: capture.getCopyExpr());
1489	}
1490
1491	Code = serialization::DECL_BLOCK;
1492	}
1493
1494	void ASTDeclWriter::VisitOutlinedFunctionDecl(OutlinedFunctionDecl *D) {
1495	Record.push_back(N: D->getNumParams());
1496	VisitDecl(D);
1497	for (unsigned I = 0; I < D->getNumParams(); ++I)
1498	Record.AddDeclRef(D: D->getParam(i: I));
1499	Record.push_back(N: D->isNothrow() ? 1 : 0);
1500	Record.AddStmt(S: D->getBody());
1501	Code = serialization::DECL_OUTLINEDFUNCTION;
1502	}
1503
1504	void ASTDeclWriter::VisitCapturedDecl(CapturedDecl *CD) {
1505	Record.push_back(N: CD->getNumParams());
1506	VisitDecl(D: CD);
1507	Record.push_back(N: CD->getContextParamPosition());
1508	Record.push_back(N: CD->isNothrow() ? 1 : 0);
1509	// Body is stored by VisitCapturedStmt.
1510	for (unsigned I = 0; I < CD->getNumParams(); ++I)
1511	Record.AddDeclRef(D: CD->getParam(i: I));
1512	Code = serialization::DECL_CAPTURED;
1513	}
1514
1515	void ASTDeclWriter::VisitLinkageSpecDecl(LinkageSpecDecl *D) {
1516	static_assert(DeclContext::NumLinkageSpecDeclBits == 17,
1517	"You need to update the serializer after you change the"
1518	"LinkageSpecDeclBits");
1519
1520	VisitDecl(D);
1521	Record.push_back(N: llvm::to_underlying(E: D->getLanguage()));
1522	Record.AddSourceLocation(Loc: D->getExternLoc());
1523	Record.AddSourceLocation(Loc: D->getRBraceLoc());
1524	Code = serialization::DECL_LINKAGE_SPEC;
1525	}
1526
1527	void ASTDeclWriter::VisitExportDecl(ExportDecl *D) {
1528	VisitDecl(D);
1529	Record.AddSourceLocation(Loc: D->getRBraceLoc());
1530	Code = serialization::DECL_EXPORT;
1531	}
1532
1533	void ASTDeclWriter::VisitLabelDecl(LabelDecl *D) {
1534	VisitNamedDecl(D);
1535	Record.AddSourceLocation(Loc: D->getBeginLoc());
1536	Code = serialization::DECL_LABEL;
1537	}
1538
1539
1540	void ASTDeclWriter::VisitNamespaceDecl(NamespaceDecl *D) {
1541	VisitRedeclarable(D);
1542	VisitNamedDecl(D);
1543
1544	BitsPacker NamespaceDeclBits;
1545	NamespaceDeclBits.addBit(Value: D->isInline());
1546	NamespaceDeclBits.addBit(Value: D->isNested());
1547	Record.push_back(N: NamespaceDeclBits);
1548
1549	Record.AddSourceLocation(Loc: D->getBeginLoc());
1550	Record.AddSourceLocation(Loc: D->getRBraceLoc());
1551
1552	if (D->isFirstDecl())
1553	Record.AddDeclRef(D: D->getAnonymousNamespace());
1554	Code = serialization::DECL_NAMESPACE;
1555
1556	if (Writer.hasChain() && D->isAnonymousNamespace() &&
1557	D == D->getMostRecentDecl()) {
1558	// This is a most recent reopening of the anonymous namespace. If its parent
1559	// is in a previous PCH (or is the TU), mark that parent for update, because
1560	// the original namespace always points to the latest re-opening of its
1561	// anonymous namespace.
1562	Decl *Parent = cast<Decl>(
1563	Val: D->getParent()->getRedeclContext()->getPrimaryContext());
1564	if (Parent->isFromASTFile() || isa<TranslationUnitDecl>(Val: Parent)) {
1565	Writer.DeclUpdates[Parent].push_back(
1566	Elt: ASTWriter::DeclUpdate(DeclUpdateKind::CXXAddedAnonymousNamespace, D));
1567	}
1568	}
1569	}
1570
1571	void ASTDeclWriter::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) {
1572	VisitRedeclarable(D);
1573	VisitNamedDecl(D);
1574	Record.AddSourceLocation(Loc: D->getNamespaceLoc());
1575	Record.AddSourceLocation(Loc: D->getTargetNameLoc());
1576	Record.AddNestedNameSpecifierLoc(NNS: D->getQualifierLoc());
1577	Record.AddDeclRef(D: D->getNamespace());
1578	Code = serialization::DECL_NAMESPACE_ALIAS;
1579	}
1580
1581	void ASTDeclWriter::VisitUsingDecl(UsingDecl *D) {
1582	VisitNamedDecl(D);
1583	Record.AddSourceLocation(Loc: D->getUsingLoc());
1584	Record.AddNestedNameSpecifierLoc(NNS: D->getQualifierLoc());
1585	Record.AddDeclarationNameLoc(DNLoc: D->DNLoc, Name: D->getDeclName());
1586	Record.AddDeclRef(D: D->FirstUsingShadow.getPointer());
1587	Record.push_back(N: D->hasTypename());
1588	Record.AddDeclRef(D: Record.getASTContext().getInstantiatedFromUsingDecl(Inst: D));
1589	Code = serialization::DECL_USING;
1590	}
1591
1592	void ASTDeclWriter::VisitUsingEnumDecl(UsingEnumDecl *D) {
1593	VisitNamedDecl(D);
1594	Record.AddSourceLocation(Loc: D->getUsingLoc());
1595	Record.AddSourceLocation(Loc: D->getEnumLoc());
1596	Record.AddTypeSourceInfo(TInfo: D->getEnumType());
1597	Record.AddDeclRef(D: D->FirstUsingShadow.getPointer());
1598	Record.AddDeclRef(D: Record.getASTContext().getInstantiatedFromUsingEnumDecl(Inst: D));
1599	Code = serialization::DECL_USING_ENUM;
1600	}
1601
1602	void ASTDeclWriter::VisitUsingPackDecl(UsingPackDecl *D) {
1603	Record.push_back(N: D->NumExpansions);
1604	VisitNamedDecl(D);
1605	Record.AddDeclRef(D: D->getInstantiatedFromUsingDecl());
1606	for (auto *E : D->expansions())
1607	Record.AddDeclRef(D: E);
1608	Code = serialization::DECL_USING_PACK;
1609	}
1610
1611	void ASTDeclWriter::VisitUsingShadowDecl(UsingShadowDecl *D) {
1612	VisitRedeclarable(D);
1613	VisitNamedDecl(D);
1614	Record.AddDeclRef(D: D->getTargetDecl());
1615	Record.push_back(N: D->getIdentifierNamespace());
1616	Record.AddDeclRef(D: D->UsingOrNextShadow);
1617	Record.AddDeclRef(
1618	D: Record.getASTContext().getInstantiatedFromUsingShadowDecl(Inst: D));
1619
1620	if (D->getDeclContext() == D->getLexicalDeclContext() &&
1621	D->getFirstDecl() == D->getMostRecentDecl() && !D->hasAttrs() &&
1622	!needsAnonymousDeclarationNumber(D) &&
1623	D->getDeclName().getNameKind() == DeclarationName::Identifier)
1624	AbbrevToUse = Writer.getDeclUsingShadowAbbrev();
1625
1626	Code = serialization::DECL_USING_SHADOW;
1627	}
1628
1629	void ASTDeclWriter::VisitConstructorUsingShadowDecl(
1630	ConstructorUsingShadowDecl *D) {
1631	VisitUsingShadowDecl(D);
1632	Record.AddDeclRef(D: D->NominatedBaseClassShadowDecl);
1633	Record.AddDeclRef(D: D->ConstructedBaseClassShadowDecl);
1634	Record.push_back(N: D->IsVirtual);
1635	Code = serialization::DECL_CONSTRUCTOR_USING_SHADOW;
1636	}
1637
1638	void ASTDeclWriter::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
1639	VisitNamedDecl(D);
1640	Record.AddSourceLocation(Loc: D->getUsingLoc());
1641	Record.AddSourceLocation(Loc: D->getNamespaceKeyLocation());
1642	Record.AddNestedNameSpecifierLoc(NNS: D->getQualifierLoc());
1643	Record.AddDeclRef(D: D->getNominatedNamespace());
1644	Record.AddDeclRef(D: dyn_cast<Decl>(Val: D->getCommonAncestor()));
1645	Code = serialization::DECL_USING_DIRECTIVE;
1646	}
1647
1648	void ASTDeclWriter::VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) {
1649	VisitValueDecl(D);
1650	Record.AddSourceLocation(Loc: D->getUsingLoc());
1651	Record.AddNestedNameSpecifierLoc(NNS: D->getQualifierLoc());
1652	Record.AddDeclarationNameLoc(DNLoc: D->DNLoc, Name: D->getDeclName());
1653	Record.AddSourceLocation(Loc: D->getEllipsisLoc());
1654	Code = serialization::DECL_UNRESOLVED_USING_VALUE;
1655	}
1656
1657	void ASTDeclWriter::VisitUnresolvedUsingTypenameDecl(
1658	UnresolvedUsingTypenameDecl *D) {
1659	VisitTypeDecl(D);
1660	Record.AddSourceLocation(Loc: D->getTypenameLoc());
1661	Record.AddNestedNameSpecifierLoc(NNS: D->getQualifierLoc());
1662	Record.AddSourceLocation(Loc: D->getEllipsisLoc());
1663	Code = serialization::DECL_UNRESOLVED_USING_TYPENAME;
1664	}
1665
1666	void ASTDeclWriter::VisitUnresolvedUsingIfExistsDecl(
1667	UnresolvedUsingIfExistsDecl *D) {
1668	VisitNamedDecl(D);
1669	Code = serialization::DECL_UNRESOLVED_USING_IF_EXISTS;
1670	}
1671
1672	void ASTDeclWriter::VisitCXXRecordDecl(CXXRecordDecl *D) {
1673	VisitRecordDecl(D);
1674
1675	enum {
1676	CXXRecNotTemplate = 0,
1677	CXXRecTemplate,
1678	CXXRecMemberSpecialization,
1679	CXXLambda
1680	};
1681	if (ClassTemplateDecl *TemplD = D->getDescribedClassTemplate()) {
1682	Record.push_back(N: CXXRecTemplate);
1683	Record.AddDeclRef(D: TemplD);
1684	} else if (MemberSpecializationInfo *MSInfo
1685	= D->getMemberSpecializationInfo()) {
1686	Record.push_back(N: CXXRecMemberSpecialization);
1687	Record.AddDeclRef(D: MSInfo->getInstantiatedFrom());
1688	Record.push_back(N: MSInfo->getTemplateSpecializationKind());
1689	Record.AddSourceLocation(Loc: MSInfo->getPointOfInstantiation());
1690	} else if (D->isLambda()) {
1691	// For a lambda, we need some information early for merging.
1692	Record.push_back(N: CXXLambda);
1693	if (auto *Context = D->getLambdaContextDecl()) {
1694	Record.AddDeclRef(D: Context);
1695	Record.push_back(N: D->getLambdaIndexInContext());
1696	} else {
1697	Record.push_back(N: 0);
1698	}
1699	// For lambdas inside template functions, remember the mapping to
1700	// deserialize them together.
1701	if (auto *FD = llvm::dyn_cast_or_null<FunctionDecl>(Val: D->getDeclContext());
1702	FD && isDefinitionInDependentContext(D: FD)) {
1703	Writer.RelatedDeclsMap[Writer.GetDeclRef(D: FD)].push_back(
1704	Elt: Writer.GetDeclRef(D: D->getLambdaCallOperator()));
1705	}
1706	} else {
1707	Record.push_back(N: CXXRecNotTemplate);
1708	}
1709
1710	Record.push_back(N: D->isThisDeclarationADefinition());
1711	if (D->isThisDeclarationADefinition())
1712	Record.AddCXXDefinitionData(D);
1713
1714	if (D->isCompleteDefinition() && D->isInNamedModule())
1715	Writer.AddDeclRef(D, Record&: Writer.ModularCodegenDecls);
1716
1717	// Store (what we currently believe to be) the key function to avoid
1718	// deserializing every method so we can compute it.
1719	//
1720	// FIXME: Avoid adding the key function if the class is defined in
1721	// module purview since in that case the key function is meaningless.
1722	if (D->isCompleteDefinition())
1723	Record.AddDeclRef(D: Record.getASTContext().getCurrentKeyFunction(RD: D));
1724
1725	Code = serialization::DECL_CXX_RECORD;
1726	}
1727
1728	void ASTDeclWriter::VisitCXXMethodDecl(CXXMethodDecl *D) {
1729	VisitFunctionDecl(D);
1730	if (D->isCanonicalDecl()) {
1731	Record.push_back(N: D->size_overridden_methods());
1732	for (const CXXMethodDecl *MD : D->overridden_methods())
1733	Record.AddDeclRef(D: MD);
1734	} else {
1735	// We only need to record overridden methods once for the canonical decl.
1736	Record.push_back(N: 0);
1737	}
1738
1739	if (D->getDeclContext() == D->getLexicalDeclContext() &&
1740	D->getFirstDecl() == D->getMostRecentDecl() && !D->isInvalidDecl() &&
1741	!D->hasAttrs() && !D->isTopLevelDeclInObjCContainer() &&
1742	D->getDeclName().getNameKind() == DeclarationName::Identifier &&
1743	!D->hasExtInfo() && !D->isExplicitlyDefaulted()) {
1744	if (D->getTemplatedKind() == FunctionDecl::TK_NonTemplate ||
1745	D->getTemplatedKind() == FunctionDecl::TK_FunctionTemplate ||
1746	D->getTemplatedKind() == FunctionDecl::TK_MemberSpecialization ||
1747	D->getTemplatedKind() == FunctionDecl::TK_DependentNonTemplate)
1748	AbbrevToUse = Writer.getDeclCXXMethodAbbrev(Kind: D->getTemplatedKind());
1749	else if (D->getTemplatedKind() ==
1750	FunctionDecl::TK_FunctionTemplateSpecialization) {
1751	FunctionTemplateSpecializationInfo *FTSInfo =
1752	D->getTemplateSpecializationInfo();
1753
1754	if (FTSInfo->TemplateArguments->size() == 1) {
1755	const TemplateArgument &TA = FTSInfo->TemplateArguments->get(Idx: 0);
1756	if (TA.getKind() == TemplateArgument::Type &&
1757	!FTSInfo->TemplateArgumentsAsWritten &&
1758	!FTSInfo->getMemberSpecializationInfo())
1759	AbbrevToUse = Writer.getDeclCXXMethodAbbrev(Kind: D->getTemplatedKind());
1760	}
1761	} else if (D->getTemplatedKind() ==
1762	FunctionDecl::TK_DependentFunctionTemplateSpecialization) {
1763	DependentFunctionTemplateSpecializationInfo *DFTSInfo =
1764	D->getDependentSpecializationInfo();
1765	if (!DFTSInfo->TemplateArgumentsAsWritten)
1766	AbbrevToUse = Writer.getDeclCXXMethodAbbrev(Kind: D->getTemplatedKind());
1767	}
1768	}
1769
1770	Code = serialization::DECL_CXX_METHOD;
1771	}
1772
1773	void ASTDeclWriter::VisitCXXConstructorDecl(CXXConstructorDecl *D) {
1774	static_assert(DeclContext::NumCXXConstructorDeclBits == 64,
1775	"You need to update the serializer after you change the "
1776	"CXXConstructorDeclBits");
1777
1778	Record.push_back(N: D->getTrailingAllocKind());
1779	addExplicitSpecifier(ES: D->getExplicitSpecifierInternal(), Record);
1780	if (auto Inherited = D->getInheritedConstructor()) {
1781	Record.AddDeclRef(D: Inherited.getShadowDecl());
1782	Record.AddDeclRef(D: Inherited.getConstructor());
1783	}
1784
1785	VisitCXXMethodDecl(D);
1786	Code = serialization::DECL_CXX_CONSTRUCTOR;
1787	}
1788
1789	void ASTDeclWriter::VisitCXXDestructorDecl(CXXDestructorDecl *D) {
1790	VisitCXXMethodDecl(D);
1791
1792	Record.AddDeclRef(D: D->getOperatorDelete());
1793	if (D->getOperatorDelete())
1794	Record.AddStmt(S: D->getOperatorDeleteThisArg());
1795
1796	Code = serialization::DECL_CXX_DESTRUCTOR;
1797	}
1798
1799	void ASTDeclWriter::VisitCXXConversionDecl(CXXConversionDecl *D) {
1800	addExplicitSpecifier(ES: D->getExplicitSpecifier(), Record);
1801	VisitCXXMethodDecl(D);
1802	Code = serialization::DECL_CXX_CONVERSION;
1803	}
1804
1805	void ASTDeclWriter::VisitImportDecl(ImportDecl *D) {
1806	VisitDecl(D);
1807	Record.push_back(N: Writer.getSubmoduleID(Mod: D->getImportedModule()));
1808	ArrayRef<SourceLocation> IdentifierLocs = D->getIdentifierLocs();
1809	Record.push_back(N: !IdentifierLocs.empty());
1810	if (IdentifierLocs.empty()) {
1811	Record.AddSourceLocation(Loc: D->getEndLoc());
1812	Record.push_back(N: 1);
1813	} else {
1814	for (unsigned I = 0, N = IdentifierLocs.size(); I != N; ++I)
1815	Record.AddSourceLocation(Loc: IdentifierLocs[I]);
1816	Record.push_back(N: IdentifierLocs.size());
1817	}
1818	// Note: the number of source locations must always be the last element in
1819	// the record.
1820	Code = serialization::DECL_IMPORT;
1821	}
1822
1823	void ASTDeclWriter::VisitAccessSpecDecl(AccessSpecDecl *D) {
1824	VisitDecl(D);
1825	Record.AddSourceLocation(Loc: D->getColonLoc());
1826	Code = serialization::DECL_ACCESS_SPEC;
1827	}
1828
1829	void ASTDeclWriter::VisitFriendDecl(FriendDecl *D) {
1830	// Record the number of friend type template parameter lists here
1831	// so as to simplify memory allocation during deserialization.
1832	Record.push_back(N: D->NumTPLists);
1833	VisitDecl(D);
1834	bool hasFriendDecl = isa<NamedDecl *>(Val: D->Friend);
1835	Record.push_back(N: hasFriendDecl);
1836	if (hasFriendDecl)
1837	Record.AddDeclRef(D: D->getFriendDecl());
1838	else
1839	Record.AddTypeSourceInfo(TInfo: D->getFriendType());
1840	for (unsigned i = 0; i < D->NumTPLists; ++i)
1841	Record.AddTemplateParameterList(TemplateParams: D->getFriendTypeTemplateParameterList(N: i));
1842	Record.AddDeclRef(D: D->getNextFriend());
1843	Record.push_back(N: D->UnsupportedFriend);
1844	Record.AddSourceLocation(Loc: D->FriendLoc);
1845	Record.AddSourceLocation(Loc: D->EllipsisLoc);
1846	Code = serialization::DECL_FRIEND;
1847	}
1848
1849	void ASTDeclWriter::VisitFriendTemplateDecl(FriendTemplateDecl *D) {
1850	VisitDecl(D);
1851	Record.push_back(N: D->getNumTemplateParameters());
1852	for (unsigned i = 0, e = D->getNumTemplateParameters(); i != e; ++i)
1853	Record.AddTemplateParameterList(TemplateParams: D->getTemplateParameterList(i));
1854	Record.push_back(N: D->getFriendDecl() != nullptr);
1855	if (D->getFriendDecl())
1856	Record.AddDeclRef(D: D->getFriendDecl());
1857	else
1858	Record.AddTypeSourceInfo(TInfo: D->getFriendType());
1859	Record.AddSourceLocation(Loc: D->getFriendLoc());
1860	Code = serialization::DECL_FRIEND_TEMPLATE;
1861	}
1862
1863	void ASTDeclWriter::VisitTemplateDecl(TemplateDecl *D) {
1864	VisitNamedDecl(D);
1865
1866	Record.AddTemplateParameterList(TemplateParams: D->getTemplateParameters());
1867	Record.AddDeclRef(D: D->getTemplatedDecl());
1868	}
1869
1870	void ASTDeclWriter::VisitConceptDecl(ConceptDecl *D) {
1871	VisitTemplateDecl(D);
1872	Record.AddStmt(S: D->getConstraintExpr());
1873	Code = serialization::DECL_CONCEPT;
1874	}
1875
1876	void ASTDeclWriter::VisitImplicitConceptSpecializationDecl(
1877	ImplicitConceptSpecializationDecl *D) {
1878	Record.push_back(N: D->getTemplateArguments().size());
1879	VisitDecl(D);
1880	for (const TemplateArgument &Arg : D->getTemplateArguments())
1881	Record.AddTemplateArgument(Arg);
1882	Code = serialization::DECL_IMPLICIT_CONCEPT_SPECIALIZATION;
1883	}
1884
1885	void ASTDeclWriter::VisitRequiresExprBodyDecl(RequiresExprBodyDecl *D) {
1886	Code = serialization::DECL_REQUIRES_EXPR_BODY;
1887	}
1888
1889	void ASTDeclWriter::VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D) {
1890	VisitRedeclarable(D);
1891
1892	// Emit data to initialize CommonOrPrev before VisitTemplateDecl so that
1893	// getCommonPtr() can be used while this is still initializing.
1894	if (D->isFirstDecl()) {
1895	// This declaration owns the 'common' pointer, so serialize that data now.
1896	Record.AddDeclRef(D: D->getInstantiatedFromMemberTemplate());
1897	if (D->getInstantiatedFromMemberTemplate())
1898	Record.push_back(N: D->isMemberSpecialization());
1899	}
1900
1901	VisitTemplateDecl(D);
1902	Record.push_back(N: D->getIdentifierNamespace());
1903	}
1904
1905	void ASTDeclWriter::VisitClassTemplateDecl(ClassTemplateDecl *D) {
1906	VisitRedeclarableTemplateDecl(D);
1907
1908	if (D->isFirstDecl())
1909	AddTemplateSpecializations(D);
1910
1911	// Force emitting the corresponding deduction guide in reduced BMI mode.
1912	// Otherwise, the deduction guide may be optimized out incorrectly.
1913	if (Writer.isGeneratingReducedBMI()) {
1914	auto Name =
1915	Record.getASTContext().DeclarationNames.getCXXDeductionGuideName(TD: D);
1916	for (auto *DG : D->getDeclContext()->noload_lookup(Name))
1917	Writer.GetDeclRef(D: DG->getCanonicalDecl());
1918	}
1919
1920	Code = serialization::DECL_CLASS_TEMPLATE;
1921	}
1922
1923	void ASTDeclWriter::VisitClassTemplateSpecializationDecl(
1924	ClassTemplateSpecializationDecl *D) {
1925	RegisterTemplateSpecialization(Template: D->getSpecializedTemplate(), Specialization: D);
1926
1927	VisitCXXRecordDecl(D);
1928
1929	llvm::PointerUnion<ClassTemplateDecl *,
1930	ClassTemplatePartialSpecializationDecl *> InstFrom
1931	= D->getSpecializedTemplateOrPartial();
1932	if (Decl *InstFromD = InstFrom.dyn_cast<ClassTemplateDecl *>()) {
1933	Record.AddDeclRef(D: InstFromD);
1934	} else {
1935	Record.AddDeclRef(D: cast<ClassTemplatePartialSpecializationDecl *>(Val&: InstFrom));
1936	Record.AddTemplateArgumentList(TemplateArgs: &D->getTemplateInstantiationArgs());
1937	}
1938
1939	Record.AddTemplateArgumentList(TemplateArgs: &D->getTemplateArgs());
1940	Record.AddSourceLocation(Loc: D->getPointOfInstantiation());
1941	Record.push_back(N: D->getSpecializationKind());
1942	Record.push_back(N: D->hasStrictPackMatch());
1943	Record.push_back(N: D->isCanonicalDecl());
1944
1945	if (D->isCanonicalDecl()) {
1946	// When reading, we'll add it to the folding set of the following template.
1947	Record.AddDeclRef(D: D->getSpecializedTemplate()->getCanonicalDecl());
1948	}
1949
1950	bool ExplicitInstantiation =
1951	D->getTemplateSpecializationKind() ==
1952	TSK_ExplicitInstantiationDeclaration ||
1953	D->getTemplateSpecializationKind() == TSK_ExplicitInstantiationDefinition;
1954	Record.push_back(N: ExplicitInstantiation);
1955	if (ExplicitInstantiation) {
1956	Record.AddSourceLocation(Loc: D->getExternKeywordLoc());
1957	Record.AddSourceLocation(Loc: D->getTemplateKeywordLoc());
1958	}
1959
1960	const ASTTemplateArgumentListInfo *ArgsWritten =
1961	D->getTemplateArgsAsWritten();
1962	Record.push_back(N: !!ArgsWritten);
1963	if (ArgsWritten)
1964	Record.AddASTTemplateArgumentListInfo(ASTTemplArgList: ArgsWritten);
1965
1966	// Mention the implicitly generated C++ deduction guide to make sure the
1967	// deduction guide will be rewritten as expected.
1968	//
1969	// FIXME: Would it be more efficient to add a callback register function
1970	// in sema to register the deduction guide?
1971	if (Writer.isWritingStdCXXNamedModules()) {
1972	auto Name =
1973	Record.getASTContext().DeclarationNames.getCXXDeductionGuideName(
1974	TD: D->getSpecializedTemplate());
1975	for (auto *DG : D->getDeclContext()->noload_lookup(Name))
1976	Writer.GetDeclRef(D: DG->getCanonicalDecl());
1977	}
1978
1979	Code = serialization::DECL_CLASS_TEMPLATE_SPECIALIZATION;
1980	}
1981
1982	void ASTDeclWriter::VisitClassTemplatePartialSpecializationDecl(
1983	ClassTemplatePartialSpecializationDecl *D) {
1984	Record.AddTemplateParameterList(TemplateParams: D->getTemplateParameters());
1985
1986	VisitClassTemplateSpecializationDecl(D);
1987
1988	// These are read/set from/to the first declaration.
1989	if (D->getPreviousDecl() == nullptr) {
1990	Record.AddDeclRef(D: D->getInstantiatedFromMember());
1991	Record.push_back(N: D->isMemberSpecialization());
1992	}
1993
1994	Code = serialization::DECL_CLASS_TEMPLATE_PARTIAL_SPECIALIZATION;
1995	}
1996
1997	void ASTDeclWriter::VisitVarTemplateDecl(VarTemplateDecl *D) {
1998	VisitRedeclarableTemplateDecl(D);
1999
2000	if (D->isFirstDecl())
2001	AddTemplateSpecializations(D);
2002	Code = serialization::DECL_VAR_TEMPLATE;
2003	}
2004
2005	void ASTDeclWriter::VisitVarTemplateSpecializationDecl(
2006	VarTemplateSpecializationDecl *D) {
2007	RegisterTemplateSpecialization(Template: D->getSpecializedTemplate(), Specialization: D);
2008
2009	llvm::PointerUnion<VarTemplateDecl *, VarTemplatePartialSpecializationDecl *>
2010	InstFrom = D->getSpecializedTemplateOrPartial();
2011	if (Decl *InstFromD = InstFrom.dyn_cast<VarTemplateDecl *>()) {
2012	Record.AddDeclRef(D: InstFromD);
2013	} else {
2014	Record.AddDeclRef(D: cast<VarTemplatePartialSpecializationDecl *>(Val&: InstFrom));
2015	Record.AddTemplateArgumentList(TemplateArgs: &D->getTemplateInstantiationArgs());
2016	}
2017
2018	bool ExplicitInstantiation =
2019	D->getTemplateSpecializationKind() ==
2020	TSK_ExplicitInstantiationDeclaration ||
2021	D->getTemplateSpecializationKind() == TSK_ExplicitInstantiationDefinition;
2022	Record.push_back(N: ExplicitInstantiation);
2023	if (ExplicitInstantiation) {
2024	Record.AddSourceLocation(Loc: D->getExternKeywordLoc());
2025	Record.AddSourceLocation(Loc: D->getTemplateKeywordLoc());
2026	}
2027
2028	const ASTTemplateArgumentListInfo *ArgsWritten =
2029	D->getTemplateArgsAsWritten();
2030	Record.push_back(N: !!ArgsWritten);
2031	if (ArgsWritten)
2032	Record.AddASTTemplateArgumentListInfo(ASTTemplArgList: ArgsWritten);
2033
2034	Record.AddTemplateArgumentList(TemplateArgs: &D->getTemplateArgs());
2035	Record.AddSourceLocation(Loc: D->getPointOfInstantiation());
2036	Record.push_back(N: D->getSpecializationKind());
2037	Record.push_back(N: D->IsCompleteDefinition);
2038
2039	VisitVarDecl(D);
2040
2041	Record.push_back(N: D->isCanonicalDecl());
2042
2043	if (D->isCanonicalDecl()) {
2044	// When reading, we'll add it to the folding set of the following template.
2045	Record.AddDeclRef(D: D->getSpecializedTemplate()->getCanonicalDecl());
2046	}
2047
2048	Code = serialization::DECL_VAR_TEMPLATE_SPECIALIZATION;
2049	}
2050
2051	void ASTDeclWriter::VisitVarTemplatePartialSpecializationDecl(
2052	VarTemplatePartialSpecializationDecl *D) {
2053	Record.AddTemplateParameterList(TemplateParams: D->getTemplateParameters());
2054
2055	VisitVarTemplateSpecializationDecl(D);
2056
2057	// These are read/set from/to the first declaration.
2058	if (D->getPreviousDecl() == nullptr) {
2059	Record.AddDeclRef(D: D->getInstantiatedFromMember());
2060	Record.push_back(N: D->isMemberSpecialization());
2061	}
2062
2063	Code = serialization::DECL_VAR_TEMPLATE_PARTIAL_SPECIALIZATION;
2064	}
2065
2066	void ASTDeclWriter::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
2067	VisitRedeclarableTemplateDecl(D);
2068
2069	if (D->isFirstDecl())
2070	AddTemplateSpecializations(D);
2071	Code = serialization::DECL_FUNCTION_TEMPLATE;
2072	}
2073
2074	void ASTDeclWriter::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
2075	Record.push_back(N: D->hasTypeConstraint());
2076	VisitTypeDecl(D);
2077
2078	Record.push_back(N: D->wasDeclaredWithTypename());
2079
2080	const TypeConstraint *TC = D->getTypeConstraint();
2081	if (D->hasTypeConstraint())
2082	Record.push_back(/*TypeConstraintInitialized=*/N: TC != nullptr);
2083	if (TC) {
2084	auto *CR = TC->getConceptReference();
2085	Record.push_back(N: CR != nullptr);
2086	if (CR)
2087	Record.AddConceptReference(CR);
2088	Record.AddStmt(S: TC->getImmediatelyDeclaredConstraint());
2089	Record.writeUnsignedOrNone(Value: TC->getArgPackSubstIndex());
2090	Record.writeUnsignedOrNone(Value: D->getNumExpansionParameters());
2091	}
2092
2093	bool OwnsDefaultArg = D->hasDefaultArgument() &&
2094	!D->defaultArgumentWasInherited();
2095	Record.push_back(N: OwnsDefaultArg);
2096	if (OwnsDefaultArg)
2097	Record.AddTemplateArgumentLoc(Arg: D->getDefaultArgument());
2098
2099	if (!D->hasTypeConstraint() && !OwnsDefaultArg &&
2100	D->getDeclContext() == D->getLexicalDeclContext() &&
2101	!D->isInvalidDecl() && !D->hasAttrs() &&
2102	!D->isTopLevelDeclInObjCContainer() && !D->isImplicit() &&
2103	D->getDeclName().getNameKind() == DeclarationName::Identifier)
2104	AbbrevToUse = Writer.getDeclTemplateTypeParmAbbrev();
2105
2106	Code = serialization::DECL_TEMPLATE_TYPE_PARM;
2107	}
2108
2109	void ASTDeclWriter::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) {
2110	// For an expanded parameter pack, record the number of expansion types here
2111	// so that it's easier for deserialization to allocate the right amount of
2112	// memory.
2113	Record.push_back(N: D->hasPlaceholderTypeConstraint());
2114	if (D->isExpandedParameterPack())
2115	Record.push_back(N: D->getNumExpansionTypes());
2116
2117	VisitDeclaratorDecl(D);
2118	// TemplateParmPosition.
2119	Record.push_back(N: D->getDepth());
2120	Record.push_back(N: D->getPosition());
2121
2122	if (D->hasPlaceholderTypeConstraint())
2123	Record.AddStmt(S: D->getPlaceholderTypeConstraint());
2124
2125	if (D->isExpandedParameterPack()) {
2126	for (unsigned I = 0, N = D->getNumExpansionTypes(); I != N; ++I) {
2127	Record.AddTypeRef(T: D->getExpansionType(I));
2128	Record.AddTypeSourceInfo(TInfo: D->getExpansionTypeSourceInfo(I));
2129	}
2130
2131	Code = serialization::DECL_EXPANDED_NON_TYPE_TEMPLATE_PARM_PACK;
2132	} else {
2133	// Rest of NonTypeTemplateParmDecl.
2134	Record.push_back(N: D->isParameterPack());
2135	bool OwnsDefaultArg = D->hasDefaultArgument() &&
2136	!D->defaultArgumentWasInherited();
2137	Record.push_back(N: OwnsDefaultArg);
2138	if (OwnsDefaultArg)
2139	Record.AddTemplateArgumentLoc(Arg: D->getDefaultArgument());
2140	Code = serialization::DECL_NON_TYPE_TEMPLATE_PARM;
2141	}
2142	}
2143
2144	void ASTDeclWriter::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) {
2145	// For an expanded parameter pack, record the number of expansion types here
2146	// so that it's easier for deserialization to allocate the right amount of
2147	// memory.
2148	if (D->isExpandedParameterPack())
2149	Record.push_back(N: D->getNumExpansionTemplateParameters());
2150
2151	VisitTemplateDecl(D);
2152	Record.push_back(N: D->wasDeclaredWithTypename());
2153	// TemplateParmPosition.
2154	Record.push_back(N: D->getDepth());
2155	Record.push_back(N: D->getPosition());
2156
2157	if (D->isExpandedParameterPack()) {
2158	for (unsigned I = 0, N = D->getNumExpansionTemplateParameters();
2159	I != N; ++I)
2160	Record.AddTemplateParameterList(TemplateParams: D->getExpansionTemplateParameters(I));
2161	Code = serialization::DECL_EXPANDED_TEMPLATE_TEMPLATE_PARM_PACK;
2162	} else {
2163	// Rest of TemplateTemplateParmDecl.
2164	Record.push_back(N: D->isParameterPack());
2165	bool OwnsDefaultArg = D->hasDefaultArgument() &&
2166	!D->defaultArgumentWasInherited();
2167	Record.push_back(N: OwnsDefaultArg);
2168	if (OwnsDefaultArg)
2169	Record.AddTemplateArgumentLoc(Arg: D->getDefaultArgument());
2170	Code = serialization::DECL_TEMPLATE_TEMPLATE_PARM;
2171	}
2172	}
2173
2174	void ASTDeclWriter::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) {
2175	VisitRedeclarableTemplateDecl(D);
2176	Code = serialization::DECL_TYPE_ALIAS_TEMPLATE;
2177	}
2178
2179	void ASTDeclWriter::VisitStaticAssertDecl(StaticAssertDecl *D) {
2180	VisitDecl(D);
2181	Record.AddStmt(S: D->getAssertExpr());
2182	Record.push_back(N: D->isFailed());
2183	Record.AddStmt(S: D->getMessage());
2184	Record.AddSourceLocation(Loc: D->getRParenLoc());
2185	Code = serialization::DECL_STATIC_ASSERT;
2186	}
2187
2188	/// Emit the DeclContext part of a declaration context decl.
2189	void ASTDeclWriter::VisitDeclContext(DeclContext *DC) {
2190	static_assert(DeclContext::NumDeclContextBits == 13,
2191	"You need to update the serializer after you change the "
2192	"DeclContextBits");
2193	LookupBlockOffsets Offsets;
2194
2195	if (Writer.isGeneratingReducedBMI() && isa<NamespaceDecl>(Val: DC) &&
2196	cast<NamespaceDecl>(Val: DC)->isFromExplicitGlobalModule()) {
2197	// In reduced BMI, delay writing lexical and visible block for namespace
2198	// in the global module fragment. See the comments of DelayedNamespace for
2199	// details.
2200	Writer.DelayedNamespace.push_back(Elt: cast<NamespaceDecl>(Val: DC));
2201	} else {
2202	Offsets.LexicalOffset =
2203	Writer.WriteDeclContextLexicalBlock(Context&: Record.getASTContext(), DC);
2204	Writer.WriteDeclContextVisibleBlock(Context&: Record.getASTContext(), DC, Offsets);
2205	}
2206
2207	Record.AddLookupOffsets(Offsets);
2208	}
2209
2210	const Decl *ASTWriter::getFirstLocalDecl(const Decl *D) {
2211	assert(IsLocalDecl(D) && "expected a local declaration");
2212
2213	const Decl *Canon = D->getCanonicalDecl();
2214	if (IsLocalDecl(D: Canon))
2215	return Canon;
2216
2217	const Decl *&CacheEntry = FirstLocalDeclCache[Canon];
2218	if (CacheEntry)
2219	return CacheEntry;
2220
2221	for (const Decl *Redecl = D; Redecl; Redecl = Redecl->getPreviousDecl())
2222	if (IsLocalDecl(D: Redecl))
2223	D = Redecl;
2224	return CacheEntry = D;
2225	}
2226
2227	template <typename T>
2228	void ASTDeclWriter::VisitRedeclarable(Redeclarable<T> *D) {
2229	T *First = D->getFirstDecl();
2230	T *MostRecent = First->getMostRecentDecl();
2231	T *DAsT = static_cast<T *>(D);
2232	if (MostRecent != First) {
2233	assert(isRedeclarableDeclKind(DAsT->getKind()) &&
2234	"Not considered redeclarable?");
2235
2236	Record.AddDeclRef(D: First);
2237
2238	// Write out a list of local redeclarations of this declaration if it's the
2239	// first local declaration in the chain.
2240	const Decl *FirstLocal = Writer.getFirstLocalDecl(D: DAsT);
2241	if (DAsT == FirstLocal) {
2242	// Emit a list of all imported first declarations so that we can be sure
2243	// that all redeclarations visible to this module are before D in the
2244	// redecl chain.
2245	unsigned I = Record.size();
2246	Record.push_back(N: 0);
2247	if (Writer.Chain)
2248	AddFirstDeclFromEachModule(D: DAsT, /*IncludeLocal*/false);
2249	// This is the number of imported first declarations + 1.
2250	Record[I] = Record.size() - I;
2251
2252	// Collect the set of local redeclarations of this declaration, from
2253	// newest to oldest.
2254	ASTWriter::RecordData LocalRedecls;
2255	ASTRecordWriter LocalRedeclWriter(Record, LocalRedecls);
2256	for (const Decl *Prev = FirstLocal->getMostRecentDecl();
2257	Prev != FirstLocal; Prev = Prev->getPreviousDecl())
2258	if (!Prev->isFromASTFile())
2259	LocalRedeclWriter.AddDeclRef(D: Prev);
2260
2261	// If we have any redecls, write them now as a separate record preceding
2262	// the declaration itself.
2263	if (LocalRedecls.empty())
2264	Record.push_back(N: 0);
2265	else
2266	Record.AddOffset(BitOffset: LocalRedeclWriter.Emit(Code: LOCAL_REDECLARATIONS));
2267	} else {
2268	Record.push_back(N: 0);
2269	Record.AddDeclRef(D: FirstLocal);
2270	}
2271
2272	// Make sure that we serialize both the previous and the most-recent
2273	// declarations, which (transitively) ensures that all declarations in the
2274	// chain get serialized.
2275	//
2276	// FIXME: This is not correct; when we reach an imported declaration we
2277	// won't emit its previous declaration.
2278	(void)Writer.GetDeclRef(D: D->getPreviousDecl());
2279	(void)Writer.GetDeclRef(D: MostRecent);
2280	} else {
2281	// We use the sentinel value 0 to indicate an only declaration.
2282	Record.push_back(N: 0);
2283	}
2284	}
2285
2286	void ASTDeclWriter::VisitHLSLBufferDecl(HLSLBufferDecl *D) {
2287	VisitNamedDecl(D);
2288	VisitDeclContext(DC: D);
2289	Record.push_back(N: D->isCBuffer());
2290	Record.AddSourceLocation(Loc: D->getLocStart());
2291	Record.AddSourceLocation(Loc: D->getLBraceLoc());
2292	Record.AddSourceLocation(Loc: D->getRBraceLoc());
2293
2294	Code = serialization::DECL_HLSL_BUFFER;
2295	}
2296
2297	void ASTDeclWriter::VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D) {
2298	Record.writeOMPChildren(Data: D->Data);
2299	VisitDecl(D);
2300	Code = serialization::DECL_OMP_THREADPRIVATE;
2301	}
2302
2303	void ASTDeclWriter::VisitOMPAllocateDecl(OMPAllocateDecl *D) {
2304	Record.writeOMPChildren(Data: D->Data);
2305	VisitDecl(D);
2306	Code = serialization::DECL_OMP_ALLOCATE;
2307	}
2308
2309	void ASTDeclWriter::VisitOMPRequiresDecl(OMPRequiresDecl *D) {
2310	Record.writeOMPChildren(Data: D->Data);
2311	VisitDecl(D);
2312	Code = serialization::DECL_OMP_REQUIRES;
2313	}
2314
2315	void ASTDeclWriter::VisitOMPDeclareReductionDecl(OMPDeclareReductionDecl *D) {
2316	static_assert(DeclContext::NumOMPDeclareReductionDeclBits == 15,
2317	"You need to update the serializer after you change the "
2318	"NumOMPDeclareReductionDeclBits");
2319
2320	VisitValueDecl(D);
2321	Record.AddSourceLocation(Loc: D->getBeginLoc());
2322	Record.AddStmt(S: D->getCombinerIn());
2323	Record.AddStmt(S: D->getCombinerOut());
2324	Record.AddStmt(S: D->getCombiner());
2325	Record.AddStmt(S: D->getInitOrig());
2326	Record.AddStmt(S: D->getInitPriv());
2327	Record.AddStmt(S: D->getInitializer());
2328	Record.push_back(N: llvm::to_underlying(E: D->getInitializerKind()));
2329	Record.AddDeclRef(D: D->getPrevDeclInScope());
2330	Code = serialization::DECL_OMP_DECLARE_REDUCTION;
2331	}
2332
2333	void ASTDeclWriter::VisitOMPDeclareMapperDecl(OMPDeclareMapperDecl *D) {
2334	Record.writeOMPChildren(Data: D->Data);
2335	VisitValueDecl(D);
2336	Record.AddDeclarationName(Name: D->getVarName());
2337	Record.AddDeclRef(D: D->getPrevDeclInScope());
2338	Code = serialization::DECL_OMP_DECLARE_MAPPER;
2339	}
2340
2341	void ASTDeclWriter::VisitOMPCapturedExprDecl(OMPCapturedExprDecl *D) {
2342	VisitVarDecl(D);
2343	Code = serialization::DECL_OMP_CAPTUREDEXPR;
2344	}
2345
2346	void ASTDeclWriter::VisitOpenACCDeclareDecl(OpenACCDeclareDecl *D) {
2347	Record.writeUInt32(Value: D->clauses().size());
2348	VisitDecl(D);
2349	Record.writeEnum(value: D->DirKind);
2350	Record.AddSourceLocation(Loc: D->DirectiveLoc);
2351	Record.AddSourceLocation(Loc: D->EndLoc);
2352	Record.writeOpenACCClauseList(Clauses: D->clauses());
2353	Code = serialization::DECL_OPENACC_DECLARE;
2354	}
2355	void ASTDeclWriter::VisitOpenACCRoutineDecl(OpenACCRoutineDecl *D) {
2356	Record.writeUInt32(Value: D->clauses().size());
2357	VisitDecl(D);
2358	Record.writeEnum(value: D->DirKind);
2359	Record.AddSourceLocation(Loc: D->DirectiveLoc);
2360	Record.AddSourceLocation(Loc: D->EndLoc);
2361	Record.AddSourceRange(Range: D->ParensLoc);
2362	Record.AddStmt(S: D->FuncRef);
2363	Record.writeOpenACCClauseList(Clauses: D->clauses());
2364	Code = serialization::DECL_OPENACC_ROUTINE;
2365	}
2366
2367	//===----------------------------------------------------------------------===//
2368	// ASTWriter Implementation
2369	//===----------------------------------------------------------------------===//
2370
2371	namespace {
2372	template <FunctionDecl::TemplatedKind Kind>
2373	std::shared_ptr<llvm::BitCodeAbbrev>
2374	getFunctionDeclAbbrev(serialization::DeclCode Code) {
2375	using namespace llvm;
2376
2377	auto Abv = std::make_shared<BitCodeAbbrev>();
2378	Abv->Add(OpInfo: BitCodeAbbrevOp(Code));
2379	// RedeclarableDecl
2380	Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // CanonicalDecl
2381	Abv->Add(OpInfo: BitCodeAbbrevOp(Kind));
2382	if constexpr (Kind == FunctionDecl::TK_NonTemplate) {
2383
2384	} else if constexpr (Kind == FunctionDecl::TK_FunctionTemplate) {
2385	// DescribedFunctionTemplate
2386	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
2387	} else if constexpr (Kind == FunctionDecl::TK_DependentNonTemplate) {
2388	// Instantiated From Decl
2389	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
2390	} else if constexpr (Kind == FunctionDecl::TK_MemberSpecialization) {
2391	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InstantiatedFrom
2392	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,
2393	3)); // TemplateSpecializationKind
2394	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Specialized Location
2395	} else if constexpr (Kind ==
2396	FunctionDecl::TK_FunctionTemplateSpecialization) {
2397	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Template
2398	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,
2399	3)); // TemplateSpecializationKind
2400	Abv->Add(OpInfo: BitCodeAbbrevOp(1)); // Template Argument Size
2401	Abv->Add(OpInfo: BitCodeAbbrevOp(TemplateArgument::Type)); // Template Argument Kind
2402	Abv->Add(
2403	OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Template Argument Type
2404	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Is Defaulted
2405	Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // TemplateArgumentsAsWritten
2406	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SourceLocation
2407	Abv->Add(OpInfo: BitCodeAbbrevOp(0));
2408	Abv->Add(
2409	OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Canonical Decl of template
2410	} else if constexpr (Kind == FunctionDecl::
2411	TK_DependentFunctionTemplateSpecialization) {
2412	// Candidates of specialization
2413	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
2414	Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // TemplateArgumentsAsWritten
2415	} else {
2416	llvm_unreachable("Unknown templated kind?");
2417	}
2418	// Decl
2419	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,
2420	8)); // Packed DeclBits: ModuleOwnershipKind,
2421	// isUsed, isReferenced, AccessSpecifier,
2422	// isImplicit
2423	//
2424	// The following bits should be 0:
2425	// HasStandaloneLexicalDC, HasAttrs,
2426	// TopLevelDeclInObjCContainer,
2427	// isInvalidDecl
2428	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
2429	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
2430	// NamedDecl
2431	Abv->Add(OpInfo: BitCodeAbbrevOp(DeclarationName::Identifier)); // NameKind
2432	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Identifier
2433	Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // AnonDeclNumber
2434	// ValueDecl
2435	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
2436	// DeclaratorDecl
2437	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerLocStart
2438	Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // HasExtInfo
2439	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TSIType
2440	// FunctionDecl
2441	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 11)); // IDNS
2442	Abv->Add(OpInfo: BitCodeAbbrevOp(
2443	BitCodeAbbrevOp::Fixed,
2444	28)); // Packed Function Bits: StorageClass, Inline, InlineSpecified,
2445	// VirtualAsWritten, Pure, HasInheritedProto, HasWrittenProto,
2446	// Deleted, Trivial, TrivialForCall, Defaulted, ExplicitlyDefaulted,
2447	// IsIneligibleOrNotSelected, ImplicitReturnZero, Constexpr,
2448	// UsesSEHTry, SkippedBody, MultiVersion, LateParsed,
2449	// FriendConstraintRefersToEnclosingTemplate, Linkage,
2450	// ShouldSkipCheckingODR
2451	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LocEnd
2452	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // ODRHash
2453	// This Array slurps the rest of the record. Fortunately we want to encode
2454	// (nearly) all the remaining (variable number of) fields in the same way.
2455	//
2456	// This is:
2457	// NumParams and Params[] from FunctionDecl, and
2458	// NumOverriddenMethods, OverriddenMethods[] from CXXMethodDecl.
2459	//
2460	// Add an AbbrevOp for 'size then elements' and use it here.
2461	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
2462	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
2463	return Abv;
2464	}
2465
2466	template <FunctionDecl::TemplatedKind Kind>
2467	std::shared_ptr<llvm::BitCodeAbbrev> getCXXMethodAbbrev() {
2468	return getFunctionDeclAbbrev<Kind>(serialization::DECL_CXX_METHOD);
2469	}
2470	} // namespace
2471
2472	void ASTWriter::WriteDeclAbbrevs() {
2473	using namespace llvm;
2474
2475	std::shared_ptr<BitCodeAbbrev> Abv;
2476
2477	// Abbreviation for DECL_FIELD
2478	Abv = std::make_shared<BitCodeAbbrev>();
2479	Abv->Add(OpInfo: BitCodeAbbrevOp(serialization::DECL_FIELD));
2480	// Decl
2481	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,
2482	7)); // Packed DeclBits: ModuleOwnershipKind,
2483	// isUsed, isReferenced, AccessSpecifier,
2484	//
2485	// The following bits should be 0:
2486	// isImplicit, HasStandaloneLexicalDC, HasAttrs,
2487	// TopLevelDeclInObjCContainer,
2488	// isInvalidDecl
2489	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
2490	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
2491	// NamedDecl
2492	Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // NameKind = Identifier
2493	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
2494	Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // AnonDeclNumber
2495	// ValueDecl
2496	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
2497	// DeclaratorDecl
2498	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerStartLoc
2499	Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // hasExtInfo
2500	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TSIType
2501	// FieldDecl
2502	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isMutable
2503	Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // StorageKind
2504	// Type Source Info
2505	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
2506	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc
2507	DeclFieldAbbrev = Stream.EmitAbbrev(Abbv: std::move(Abv));
2508
2509	// Abbreviation for DECL_OBJC_IVAR
2510	Abv = std::make_shared<BitCodeAbbrev>();
2511	Abv->Add(OpInfo: BitCodeAbbrevOp(serialization::DECL_OBJC_IVAR));
2512	// Decl
2513	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,
2514	12)); // Packed DeclBits: HasStandaloneLexicalDC,
2515	// isInvalidDecl, HasAttrs, isImplicit, isUsed,
2516	// isReferenced, TopLevelDeclInObjCContainer,
2517	// AccessSpecifier, ModuleOwnershipKind
2518	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
2519	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
2520	// NamedDecl
2521	Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // NameKind = Identifier
2522	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
2523	Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // AnonDeclNumber
2524	// ValueDecl
2525	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
2526	// DeclaratorDecl
2527	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerStartLoc
2528	Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // hasExtInfo
2529	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TSIType
2530	// FieldDecl
2531	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isMutable
2532	Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // InitStyle
2533	// ObjC Ivar
2534	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getAccessControl
2535	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getSynthesize
2536	// Type Source Info
2537	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
2538	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc
2539	DeclObjCIvarAbbrev = Stream.EmitAbbrev(Abbv: std::move(Abv));
2540
2541	// Abbreviation for DECL_ENUM
2542	Abv = std::make_shared<BitCodeAbbrev>();
2543	Abv->Add(OpInfo: BitCodeAbbrevOp(serialization::DECL_ENUM));
2544	// Redeclarable
2545	Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // No redeclaration
2546	// Decl
2547	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,
2548	7)); // Packed DeclBits: ModuleOwnershipKind,
2549	// isUsed, isReferenced, AccessSpecifier,
2550	//
2551	// The following bits should be 0:
2552	// isImplicit, HasStandaloneLexicalDC, HasAttrs,
2553	// TopLevelDeclInObjCContainer,
2554	// isInvalidDecl
2555	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
2556	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
2557	// NamedDecl
2558	Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // NameKind = Identifier
2559	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
2560	Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // AnonDeclNumber
2561	// TypeDecl
2562	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Source Location
2563	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type Ref
2564	// TagDecl
2565	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // IdentifierNamespace
2566	Abv->Add(OpInfo: BitCodeAbbrevOp(
2567	BitCodeAbbrevOp::Fixed,
2568	9)); // Packed Tag Decl Bits: getTagKind, isCompleteDefinition,
2569	// EmbeddedInDeclarator, IsFreeStanding,
2570	// isCompleteDefinitionRequired, ExtInfoKind
2571	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SourceLocation
2572	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SourceLocation
2573	// EnumDecl
2574	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // AddTypeRef
2575	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // IntegerType
2576	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getPromotionType
2577	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 20)); // Enum Decl Bits
2578	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));// ODRHash
2579	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InstantiatedMembEnum
2580	// DC
2581	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalOffset
2582	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // VisibleOffset
2583	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // ModuleLocalOffset
2584	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TULocalOffset
2585	DeclEnumAbbrev = Stream.EmitAbbrev(Abbv: std::move(Abv));
2586
2587	// Abbreviation for DECL_RECORD
2588	Abv = std::make_shared<BitCodeAbbrev>();
2589	Abv->Add(OpInfo: BitCodeAbbrevOp(serialization::DECL_RECORD));
2590	// Redeclarable
2591	Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // No redeclaration
2592	// Decl
2593	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,
2594	7)); // Packed DeclBits: ModuleOwnershipKind,
2595	// isUsed, isReferenced, AccessSpecifier,
2596	//
2597	// The following bits should be 0:
2598	// isImplicit, HasStandaloneLexicalDC, HasAttrs,
2599	// TopLevelDeclInObjCContainer,
2600	// isInvalidDecl
2601	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
2602	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
2603	// NamedDecl
2604	Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // NameKind = Identifier
2605	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
2606	Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // AnonDeclNumber
2607	// TypeDecl
2608	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Source Location
2609	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type Ref
2610	// TagDecl
2611	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // IdentifierNamespace
2612	Abv->Add(OpInfo: BitCodeAbbrevOp(
2613	BitCodeAbbrevOp::Fixed,
2614	9)); // Packed Tag Decl Bits: getTagKind, isCompleteDefinition,
2615	// EmbeddedInDeclarator, IsFreeStanding,
2616	// isCompleteDefinitionRequired, ExtInfoKind
2617	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SourceLocation
2618	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SourceLocation
2619	// RecordDecl
2620	Abv->Add(OpInfo: BitCodeAbbrevOp(
2621	BitCodeAbbrevOp::Fixed,
2622	14)); // Packed Record Decl Bits: FlexibleArrayMember,
2623	// AnonymousStructUnion, hasObjectMember, hasVolatileMember,
2624	// isNonTrivialToPrimitiveDefaultInitialize,
2625	// isNonTrivialToPrimitiveCopy, isNonTrivialToPrimitiveDestroy,
2626	// hasNonTrivialToPrimitiveDefaultInitializeCUnion,
2627	// hasNonTrivialToPrimitiveDestructCUnion,
2628	// hasNonTrivialToPrimitiveCopyCUnion,
2629	// hasUninitializedExplicitInitFields, isParamDestroyedInCallee,
2630	// getArgPassingRestrictions
2631	// ODRHash
2632	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 26));
2633
2634	// DC
2635	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalOffset
2636	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // VisibleOffset
2637	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // ModuleLocalOffset
2638	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TULocalOffset
2639	DeclRecordAbbrev = Stream.EmitAbbrev(Abbv: std::move(Abv));
2640
2641	// Abbreviation for DECL_PARM_VAR
2642	Abv = std::make_shared<BitCodeAbbrev>();
2643	Abv->Add(OpInfo: BitCodeAbbrevOp(serialization::DECL_PARM_VAR));
2644	// Redeclarable
2645	Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // No redeclaration
2646	// Decl
2647	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,
2648	8)); // Packed DeclBits: ModuleOwnershipKind, isUsed,
2649	// isReferenced, AccessSpecifier,
2650	// HasStandaloneLexicalDC, HasAttrs, isImplicit,
2651	// TopLevelDeclInObjCContainer,
2652	// isInvalidDecl,
2653	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
2654	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
2655	// NamedDecl
2656	Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // NameKind = Identifier
2657	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
2658	Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // AnonDeclNumber
2659	// ValueDecl
2660	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
2661	// DeclaratorDecl
2662	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerStartLoc
2663	Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // hasExtInfo
2664	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TSIType
2665	// VarDecl
2666	Abv->Add(
2667	OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,
2668	12)); // Packed Var Decl bits: SClass, TSCSpec, InitStyle,
2669	// isARCPseudoStrong, Linkage, ModulesCodegen
2670	Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // VarKind (local enum)
2671	// ParmVarDecl
2672	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // ScopeIndex
2673	Abv->Add(OpInfo: BitCodeAbbrevOp(
2674	BitCodeAbbrevOp::Fixed,
2675	19)); // Packed Parm Var Decl bits: IsObjCMethodParameter, ScopeDepth,
2676	// ObjCDeclQualifier, KNRPromoted,
2677	// HasInheritedDefaultArg, HasUninstantiatedDefaultArg
2678	// Type Source Info
2679	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
2680	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc
2681	DeclParmVarAbbrev = Stream.EmitAbbrev(Abbv: std::move(Abv));
2682
2683	// Abbreviation for DECL_TYPEDEF
2684	Abv = std::make_shared<BitCodeAbbrev>();
2685	Abv->Add(OpInfo: BitCodeAbbrevOp(serialization::DECL_TYPEDEF));
2686	// Redeclarable
2687	Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // No redeclaration
2688	// Decl
2689	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,
2690	7)); // Packed DeclBits: ModuleOwnershipKind,
2691	// isReferenced, isUsed, AccessSpecifier. Other
2692	// higher bits should be 0: isImplicit,
2693	// HasStandaloneLexicalDC, HasAttrs,
2694	// TopLevelDeclInObjCContainer, isInvalidDecl
2695	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
2696	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
2697	// NamedDecl
2698	Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // NameKind = Identifier
2699	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
2700	Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // AnonDeclNumber
2701	// TypeDecl
2702	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Source Location
2703	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type Ref
2704	// TypedefDecl
2705	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
2706	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc
2707	DeclTypedefAbbrev = Stream.EmitAbbrev(Abbv: std::move(Abv));
2708
2709	// Abbreviation for DECL_VAR
2710	Abv = std::make_shared<BitCodeAbbrev>();
2711	Abv->Add(OpInfo: BitCodeAbbrevOp(serialization::DECL_VAR));
2712	// Redeclarable
2713	Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // No redeclaration
2714	// Decl
2715	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,
2716	12)); // Packed DeclBits: HasStandaloneLexicalDC,
2717	// isInvalidDecl, HasAttrs, isImplicit, isUsed,
2718	// isReferenced, TopLevelDeclInObjCContainer,
2719	// AccessSpecifier, ModuleOwnershipKind
2720	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
2721	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
2722	// NamedDecl
2723	Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // NameKind = Identifier
2724	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
2725	Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // AnonDeclNumber
2726	// ValueDecl
2727	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
2728	// DeclaratorDecl
2729	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerStartLoc
2730	Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // hasExtInfo
2731	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TSIType
2732	// VarDecl
2733	Abv->Add(OpInfo: BitCodeAbbrevOp(
2734	BitCodeAbbrevOp::Fixed,
2735	22)); // Packed Var Decl bits: Linkage, ModulesCodegen,
2736	// SClass, TSCSpec, InitStyle,
2737	// isARCPseudoStrong, IsThisDeclarationADemotedDefinition,
2738	// isExceptionVariable, isNRVOVariable, isCXXForRangeDecl,
2739	// isInline, isInlineSpecified, isConstexpr,
2740	// isInitCapture, isPrevDeclInSameScope, hasInitWithSideEffects,
2741	// EscapingByref, HasDeducedType, ImplicitParamKind, isObjCForDecl
2742	// IsCXXForRangeImplicitVar
2743	Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // VarKind (local enum)
2744	// Type Source Info
2745	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
2746	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc
2747	DeclVarAbbrev = Stream.EmitAbbrev(Abbv: std::move(Abv));
2748
2749	// Abbreviation for DECL_CXX_METHOD
2750	DeclCXXMethodAbbrev =
2751	Stream.EmitAbbrev(Abbv: getCXXMethodAbbrev<FunctionDecl::TK_NonTemplate>());
2752	DeclTemplateCXXMethodAbbrev = Stream.EmitAbbrev(
2753	Abbv: getCXXMethodAbbrev<FunctionDecl::TK_FunctionTemplate>());
2754	DeclDependentNonTemplateCXXMethodAbbrev = Stream.EmitAbbrev(
2755	Abbv: getCXXMethodAbbrev<FunctionDecl::TK_DependentNonTemplate>());
2756	DeclMemberSpecializedCXXMethodAbbrev = Stream.EmitAbbrev(
2757	Abbv: getCXXMethodAbbrev<FunctionDecl::TK_MemberSpecialization>());
2758	DeclTemplateSpecializedCXXMethodAbbrev = Stream.EmitAbbrev(
2759	Abbv: getCXXMethodAbbrev<FunctionDecl::TK_FunctionTemplateSpecialization>());
2760	DeclDependentSpecializationCXXMethodAbbrev = Stream.EmitAbbrev(
2761	Abbv: getCXXMethodAbbrev<
2762	FunctionDecl::TK_DependentFunctionTemplateSpecialization>());
2763
2764	// Abbreviation for DECL_TEMPLATE_TYPE_PARM
2765	Abv = std::make_shared<BitCodeAbbrev>();
2766	Abv->Add(OpInfo: BitCodeAbbrevOp(serialization::DECL_TEMPLATE_TYPE_PARM));
2767	Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // hasTypeConstraint
2768	// Decl
2769	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,
2770	7)); // Packed DeclBits: ModuleOwnershipKind,
2771	// isReferenced, isUsed, AccessSpecifier. Other
2772	// higher bits should be 0: isImplicit,
2773	// HasStandaloneLexicalDC, HasAttrs,
2774	// TopLevelDeclInObjCContainer, isInvalidDecl
2775	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
2776	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
2777	// NamedDecl
2778	Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // NameKind = Identifier
2779	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
2780	Abv->Add(OpInfo: BitCodeAbbrevOp(0));
2781	// TypeDecl
2782	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Source Location
2783	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type Ref
2784	// TemplateTypeParmDecl
2785	Abv->Add(
2786	OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // wasDeclaredWithTypename
2787	Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // OwnsDefaultArg
2788	DeclTemplateTypeParmAbbrev = Stream.EmitAbbrev(Abbv: std::move(Abv));
2789
2790	// Abbreviation for DECL_USING_SHADOW
2791	Abv = std::make_shared<BitCodeAbbrev>();
2792	Abv->Add(OpInfo: BitCodeAbbrevOp(serialization::DECL_USING_SHADOW));
2793	// Redeclarable
2794	Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // No redeclaration
2795	// Decl
2796	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,
2797	12)); // Packed DeclBits: HasStandaloneLexicalDC,
2798	// isInvalidDecl, HasAttrs, isImplicit, isUsed,
2799	// isReferenced, TopLevelDeclInObjCContainer,
2800	// AccessSpecifier, ModuleOwnershipKind
2801	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
2802	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
2803	// NamedDecl
2804	Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // NameKind = Identifier
2805	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
2806	Abv->Add(OpInfo: BitCodeAbbrevOp(0));
2807	// UsingShadowDecl
2808	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TargetDecl
2809	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 11)); // IDNS
2810	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // UsingOrNextShadow
2811	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR,
2812	6)); // InstantiatedFromUsingShadowDecl
2813	DeclUsingShadowAbbrev = Stream.EmitAbbrev(Abbv: std::move(Abv));
2814
2815	// Abbreviation for EXPR_DECL_REF
2816	Abv = std::make_shared<BitCodeAbbrev>();
2817	Abv->Add(OpInfo: BitCodeAbbrevOp(serialization::EXPR_DECL_REF));
2818	// Stmt
2819	// Expr
2820	// PackingBits: DependenceKind, ValueKind. ObjectKind should be 0.
2821	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 7));
2822	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
2823	// DeclRefExpr
2824	// Packing Bits: , HadMultipleCandidates, RefersToEnclosingVariableOrCapture,
2825	// IsImmediateEscalating, NonOdrUseReason.
2826	// GetDeclFound, HasQualifier and ExplicitTemplateArgs should be 0.
2827	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 5));
2828	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclRef
2829	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Location
2830	DeclRefExprAbbrev = Stream.EmitAbbrev(Abbv: std::move(Abv));
2831
2832	// Abbreviation for EXPR_INTEGER_LITERAL
2833	Abv = std::make_shared<BitCodeAbbrev>();
2834	Abv->Add(OpInfo: BitCodeAbbrevOp(serialization::EXPR_INTEGER_LITERAL));
2835	//Stmt
2836	// Expr
2837	// DependenceKind, ValueKind, ObjectKind
2838	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 10));
2839	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
2840	// Integer Literal
2841	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Location
2842	Abv->Add(OpInfo: BitCodeAbbrevOp(32)); // Bit Width
2843	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Value
2844	IntegerLiteralAbbrev = Stream.EmitAbbrev(Abbv: std::move(Abv));
2845
2846	// Abbreviation for EXPR_CHARACTER_LITERAL
2847	Abv = std::make_shared<BitCodeAbbrev>();
2848	Abv->Add(OpInfo: BitCodeAbbrevOp(serialization::EXPR_CHARACTER_LITERAL));
2849	//Stmt
2850	// Expr
2851	// DependenceKind, ValueKind, ObjectKind
2852	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 10));
2853	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
2854	// Character Literal
2855	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getValue
2856	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Location
2857	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // getKind
2858	CharacterLiteralAbbrev = Stream.EmitAbbrev(Abbv: std::move(Abv));
2859
2860	// Abbreviation for EXPR_IMPLICIT_CAST
2861	Abv = std::make_shared<BitCodeAbbrev>();
2862	Abv->Add(OpInfo: BitCodeAbbrevOp(serialization::EXPR_IMPLICIT_CAST));
2863	// Stmt
2864	// Expr
2865	// Packing Bits: DependenceKind, ValueKind, ObjectKind,
2866	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 10));
2867	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
2868	// CastExpr
2869	Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // PathSize
2870	// Packing Bits: CastKind, StoredFPFeatures, isPartOfExplicitCast
2871	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 9));
2872	// ImplicitCastExpr
2873	ExprImplicitCastAbbrev = Stream.EmitAbbrev(Abbv: std::move(Abv));
2874
2875	// Abbreviation for EXPR_BINARY_OPERATOR
2876	Abv = std::make_shared<BitCodeAbbrev>();
2877	Abv->Add(OpInfo: BitCodeAbbrevOp(serialization::EXPR_BINARY_OPERATOR));
2878	// Stmt
2879	// Expr
2880	// Packing Bits: DependenceKind. ValueKind and ObjectKind should
2881	// be 0 in this case.
2882	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 5));
2883	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
2884	// BinaryOperator
2885	Abv->Add(
2886	OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // OpCode and HasFPFeatures
2887	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Source Location
2888	BinaryOperatorAbbrev = Stream.EmitAbbrev(Abbv: std::move(Abv));
2889
2890	// Abbreviation for EXPR_COMPOUND_ASSIGN_OPERATOR
2891	Abv = std::make_shared<BitCodeAbbrev>();
2892	Abv->Add(OpInfo: BitCodeAbbrevOp(serialization::EXPR_COMPOUND_ASSIGN_OPERATOR));
2893	// Stmt
2894	// Expr
2895	// Packing Bits: DependenceKind. ValueKind and ObjectKind should
2896	// be 0 in this case.
2897	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 5));
2898	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
2899	// BinaryOperator
2900	// Packing Bits: OpCode. The HasFPFeatures bit should be 0
2901	Abv->Add(
2902	OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // OpCode and HasFPFeatures
2903	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Source Location
2904	// CompoundAssignOperator
2905	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LHSType
2906	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Result Type
2907	CompoundAssignOperatorAbbrev = Stream.EmitAbbrev(Abbv: std::move(Abv));
2908
2909	// Abbreviation for EXPR_CALL
2910	Abv = std::make_shared<BitCodeAbbrev>();
2911	Abv->Add(OpInfo: BitCodeAbbrevOp(serialization::EXPR_CALL));
2912	// Stmt
2913	// Expr
2914	// Packing Bits: DependenceKind, ValueKind, ObjectKind,
2915	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 10));
2916	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
2917	// CallExpr
2918	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // NumArgs
2919	Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // ADLCallKind
2920	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Source Location
2921	CallExprAbbrev = Stream.EmitAbbrev(Abbv: std::move(Abv));
2922
2923	// Abbreviation for EXPR_CXX_OPERATOR_CALL
2924	Abv = std::make_shared<BitCodeAbbrev>();
2925	Abv->Add(OpInfo: BitCodeAbbrevOp(serialization::EXPR_CXX_OPERATOR_CALL));
2926	// Stmt
2927	// Expr
2928	// Packing Bits: DependenceKind, ValueKind, ObjectKind,
2929	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 10));
2930	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
2931	// CallExpr
2932	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // NumArgs
2933	Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // ADLCallKind
2934	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Source Location
2935	// CXXOperatorCallExpr
2936	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Operator Kind
2937	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Source Location
2938	CXXOperatorCallExprAbbrev = Stream.EmitAbbrev(Abbv: std::move(Abv));
2939
2940	// Abbreviation for EXPR_CXX_MEMBER_CALL
2941	Abv = std::make_shared<BitCodeAbbrev>();
2942	Abv->Add(OpInfo: BitCodeAbbrevOp(serialization::EXPR_CXX_MEMBER_CALL));
2943	// Stmt
2944	// Expr
2945	// Packing Bits: DependenceKind, ValueKind, ObjectKind,
2946	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 10));
2947	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
2948	// CallExpr
2949	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // NumArgs
2950	Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // ADLCallKind
2951	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Source Location
2952	// CXXMemberCallExpr
2953	CXXMemberCallExprAbbrev = Stream.EmitAbbrev(Abbv: std::move(Abv));
2954
2955	// Abbreviation for STMT_COMPOUND
2956	Abv = std::make_shared<BitCodeAbbrev>();
2957	Abv->Add(OpInfo: BitCodeAbbrevOp(serialization::STMT_COMPOUND));
2958	// Stmt
2959	// CompoundStmt
2960	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Num Stmts
2961	Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // hasStoredFPFeatures
2962	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Source Location
2963	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Source Location
2964	CompoundStmtAbbrev = Stream.EmitAbbrev(Abbv: std::move(Abv));
2965
2966	Abv = std::make_shared<BitCodeAbbrev>();
2967	Abv->Add(OpInfo: BitCodeAbbrevOp(serialization::DECL_CONTEXT_LEXICAL));
2968	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2969	DeclContextLexicalAbbrev = Stream.EmitAbbrev(Abbv: std::move(Abv));
2970
2971	Abv = std::make_shared<BitCodeAbbrev>();
2972	Abv->Add(OpInfo: BitCodeAbbrevOp(serialization::DECL_CONTEXT_VISIBLE));
2973	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2974	DeclContextVisibleLookupAbbrev = Stream.EmitAbbrev(Abbv: std::move(Abv));
2975
2976	Abv = std::make_shared<BitCodeAbbrev>();
2977	Abv->Add(OpInfo: BitCodeAbbrevOp(serialization::DECL_CONTEXT_MODULE_LOCAL_VISIBLE));
2978	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2979	DeclModuleLocalVisibleLookupAbbrev = Stream.EmitAbbrev(Abbv: std::move(Abv));
2980
2981	Abv = std::make_shared<BitCodeAbbrev>();
2982	Abv->Add(OpInfo: BitCodeAbbrevOp(serialization::DECL_CONTEXT_TU_LOCAL_VISIBLE));
2983	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2984	DeclTULocalLookupAbbrev = Stream.EmitAbbrev(Abbv: std::move(Abv));
2985
2986	Abv = std::make_shared<BitCodeAbbrev>();
2987	Abv->Add(OpInfo: BitCodeAbbrevOp(serialization::DECL_SPECIALIZATIONS));
2988	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2989	DeclSpecializationsAbbrev = Stream.EmitAbbrev(Abbv: std::move(Abv));
2990
2991	Abv = std::make_shared<BitCodeAbbrev>();
2992	Abv->Add(OpInfo: BitCodeAbbrevOp(serialization::DECL_PARTIAL_SPECIALIZATIONS));
2993	Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2994	DeclPartialSpecializationsAbbrev = Stream.EmitAbbrev(Abbv: std::move(Abv));
2995	}
2996
2997	/// isRequiredDecl - Check if this is a "required" Decl, which must be seen by
2998	/// consumers of the AST.
2999	///
3000	/// Such decls will always be deserialized from the AST file, so we would like
3001	/// this to be as restrictive as possible. Currently the predicate is driven by
3002	/// code generation requirements, if other clients have a different notion of
3003	/// what is "required" then we may have to consider an alternate scheme where
3004	/// clients can iterate over the top-level decls and get information on them,
3005	/// without necessary deserializing them. We could explicitly require such
3006	/// clients to use a separate API call to "realize" the decl. This should be
3007	/// relatively painless since they would presumably only do it for top-level
3008	/// decls.
3009	static bool isRequiredDecl(const Decl *D, ASTContext &Context,
3010	Module *WritingModule) {
3011	// Named modules have different semantics than header modules. Every named
3012	// module units owns a translation unit. So the importer of named modules
3013	// doesn't need to deserilize everything ahead of time.
3014	if (WritingModule && WritingModule->isNamedModule()) {
3015	// The PragmaCommentDecl and PragmaDetectMismatchDecl are MSVC's extension.
3016	// And the behavior of MSVC for such cases will leak this to the module
3017	// users. Given pragma is not a standard thing, the compiler has the space
3018	// to do their own decision. Let's follow MSVC here.
3019	if (isa<PragmaCommentDecl, PragmaDetectMismatchDecl>(Val: D))
3020	return true;
3021	return false;
3022	}
3023
3024	// An ObjCMethodDecl is never considered as "required" because its
3025	// implementation container always is.
3026
3027	// File scoped assembly or obj-c or OMP declare target implementation must be
3028	// seen.
3029	if (isa<FileScopeAsmDecl, TopLevelStmtDecl, ObjCImplDecl>(Val: D))
3030	return true;
3031
3032	if (WritingModule && isPartOfPerModuleInitializer(D)) {
3033	// These declarations are part of the module initializer, and are emitted
3034	// if and when the module is imported, rather than being emitted eagerly.
3035	return false;
3036	}
3037
3038	return Context.DeclMustBeEmitted(D);
3039	}
3040
3041	void ASTWriter::WriteDecl(ASTContext &Context, Decl *D) {
3042	PrettyDeclStackTraceEntry CrashInfo(Context, D, SourceLocation(),
3043	"serializing");
3044
3045	// Determine the ID for this declaration.
3046	LocalDeclID ID;
3047	assert(!D->isFromASTFile() && "should not be emitting imported decl");
3048	LocalDeclID &IDR = DeclIDs[D];
3049	if (IDR.isInvalid())
3050	IDR = NextDeclID++;
3051
3052	ID = IDR;
3053
3054	assert(ID >= FirstDeclID && "invalid decl ID");
3055
3056	RecordData Record;
3057	ASTDeclWriter W(*this, Context, Record, GeneratingReducedBMI);
3058
3059	// Build a record for this declaration
3060	W.Visit(D);
3061
3062	// Emit this declaration to the bitstream.
3063	uint64_t Offset = W.Emit(D);
3064
3065	// Record the offset for this declaration
3066	SourceLocation Loc = D->getLocation();
3067	SourceLocationEncoding::RawLocEncoding RawLoc =
3068	getRawSourceLocationEncoding(Loc: getAdjustedLocation(Loc));
3069
3070	unsigned Index = ID.getRawValue() - FirstDeclID.getRawValue();
3071	if (DeclOffsets.size() == Index)
3072	DeclOffsets.emplace_back(args&: RawLoc, args&: Offset, args&: DeclTypesBlockStartOffset);
3073	else if (DeclOffsets.size() < Index) {
3074	// FIXME: Can/should this happen?
3075	DeclOffsets.resize(new_size: Index+1);
3076	DeclOffsets[Index].setRawLoc(RawLoc);
3077	DeclOffsets[Index].setBitOffset(Offset, DeclTypesBlockStartOffset);
3078	} else {
3079	llvm_unreachable("declarations should be emitted in ID order");
3080	}
3081
3082	SourceManager &SM = Context.getSourceManager();
3083	if (Loc.isValid() && SM.isLocalSourceLocation(Loc))
3084	associateDeclWithFile(D, ID);
3085
3086	// Note declarations that should be deserialized eagerly so that we can add
3087	// them to a record in the AST file later.
3088	if (isRequiredDecl(D, Context, WritingModule))
3089	AddDeclRef(D, Record&: EagerlyDeserializedDecls);
3090	}
3091
3092	void ASTRecordWriter::AddFunctionDefinition(const FunctionDecl *FD) {
3093	// Switch case IDs are per function body.
3094	Writer->ClearSwitchCaseIDs();
3095
3096	assert(FD->doesThisDeclarationHaveABody());
3097	bool ModulesCodegen = shouldFunctionGenerateHereOnly(FD);
3098	Record->push_back(Elt: ModulesCodegen);
3099	if (ModulesCodegen)
3100	Writer->AddDeclRef(D: FD, Record&: Writer->ModularCodegenDecls);
3101	if (auto *CD = dyn_cast<CXXConstructorDecl>(Val: FD)) {
3102	Record->push_back(Elt: CD->getNumCtorInitializers());
3103	if (CD->getNumCtorInitializers())
3104	AddCXXCtorInitializers(CtorInits: llvm::ArrayRef(CD->init_begin(), CD->init_end()));
3105	}
3106	AddStmt(S: FD->getBody());
3107	}
3108