1 //===--- ASTWriterDecl.cpp - Declaration Serialization --------------------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 //  This file implements serialization for Declarations.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "ASTCommon.h"
15 #include "clang/AST/DeclCXX.h"
16 #include "clang/AST/DeclContextInternals.h"
17 #include "clang/AST/DeclTemplate.h"
18 #include "clang/AST/DeclVisitor.h"
19 #include "clang/AST/Expr.h"
20 #include "clang/AST/OpenMPClause.h"
21 #include "clang/AST/PrettyDeclStackTrace.h"
22 #include "clang/Basic/SourceManager.h"
23 #include "clang/Serialization/ASTReader.h"
24 #include "clang/Serialization/ASTWriter.h"
25 #include "llvm/Bitcode/BitstreamWriter.h"
26 #include "llvm/Support/ErrorHandling.h"
27 using namespace clang;
28 using namespace serialization;
29 
30 //===----------------------------------------------------------------------===//
31 // Declaration serialization
32 //===----------------------------------------------------------------------===//
33 
34 namespace clang {
35   class ASTDeclWriter : public DeclVisitor<ASTDeclWriter, void> {
36     ASTWriter &Writer;
37     ASTContext &Context;
38     ASTRecordWriter Record;
39 
40     serialization::DeclCode Code;
41     unsigned AbbrevToUse;
42 
43   public:
ASTDeclWriter(ASTWriter & Writer,ASTContext & Context,ASTWriter::RecordDataImpl & Record)44     ASTDeclWriter(ASTWriter &Writer, ASTContext &Context,
45                   ASTWriter::RecordDataImpl &Record)
46         : Writer(Writer), Context(Context), Record(Writer, Record),
47           Code((serialization::DeclCode)0), AbbrevToUse(0) {}
48 
Emit(Decl * D)49     uint64_t Emit(Decl *D) {
50       if (!Code)
51         llvm::report_fatal_error(StringRef("unexpected declaration kind '") +
52             D->getDeclKindName() + "'");
53       return Record.Emit(Code, AbbrevToUse);
54     }
55 
56     void Visit(Decl *D);
57 
58     void VisitDecl(Decl *D);
59     void VisitPragmaCommentDecl(PragmaCommentDecl *D);
60     void VisitPragmaDetectMismatchDecl(PragmaDetectMismatchDecl *D);
61     void VisitTranslationUnitDecl(TranslationUnitDecl *D);
62     void VisitNamedDecl(NamedDecl *D);
63     void VisitLabelDecl(LabelDecl *LD);
64     void VisitNamespaceDecl(NamespaceDecl *D);
65     void VisitUsingDirectiveDecl(UsingDirectiveDecl *D);
66     void VisitNamespaceAliasDecl(NamespaceAliasDecl *D);
67     void VisitTypeDecl(TypeDecl *D);
68     void VisitTypedefNameDecl(TypedefNameDecl *D);
69     void VisitTypedefDecl(TypedefDecl *D);
70     void VisitTypeAliasDecl(TypeAliasDecl *D);
71     void VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D);
72     void VisitTagDecl(TagDecl *D);
73     void VisitEnumDecl(EnumDecl *D);
74     void VisitRecordDecl(RecordDecl *D);
75     void VisitCXXRecordDecl(CXXRecordDecl *D);
76     void VisitClassTemplateSpecializationDecl(
77                                             ClassTemplateSpecializationDecl *D);
78     void VisitClassTemplatePartialSpecializationDecl(
79                                      ClassTemplatePartialSpecializationDecl *D);
80     void VisitVarTemplateSpecializationDecl(VarTemplateSpecializationDecl *D);
81     void VisitVarTemplatePartialSpecializationDecl(
82         VarTemplatePartialSpecializationDecl *D);
83     void VisitClassScopeFunctionSpecializationDecl(
84                                        ClassScopeFunctionSpecializationDecl *D);
85     void VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D);
86     void VisitValueDecl(ValueDecl *D);
87     void VisitEnumConstantDecl(EnumConstantDecl *D);
88     void VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D);
89     void VisitDeclaratorDecl(DeclaratorDecl *D);
90     void VisitFunctionDecl(FunctionDecl *D);
91     void VisitCXXDeductionGuideDecl(CXXDeductionGuideDecl *D);
92     void VisitCXXMethodDecl(CXXMethodDecl *D);
93     void VisitCXXConstructorDecl(CXXConstructorDecl *D);
94     void VisitCXXDestructorDecl(CXXDestructorDecl *D);
95     void VisitCXXConversionDecl(CXXConversionDecl *D);
96     void VisitFieldDecl(FieldDecl *D);
97     void VisitMSPropertyDecl(MSPropertyDecl *D);
98     void VisitIndirectFieldDecl(IndirectFieldDecl *D);
99     void VisitVarDecl(VarDecl *D);
100     void VisitImplicitParamDecl(ImplicitParamDecl *D);
101     void VisitParmVarDecl(ParmVarDecl *D);
102     void VisitDecompositionDecl(DecompositionDecl *D);
103     void VisitBindingDecl(BindingDecl *D);
104     void VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D);
105     void VisitTemplateDecl(TemplateDecl *D);
106     void VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D);
107     void VisitClassTemplateDecl(ClassTemplateDecl *D);
108     void VisitVarTemplateDecl(VarTemplateDecl *D);
109     void VisitFunctionTemplateDecl(FunctionTemplateDecl *D);
110     void VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D);
111     void VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D);
112     void VisitUsingDecl(UsingDecl *D);
113     void VisitUsingPackDecl(UsingPackDecl *D);
114     void VisitUsingShadowDecl(UsingShadowDecl *D);
115     void VisitConstructorUsingShadowDecl(ConstructorUsingShadowDecl *D);
116     void VisitLinkageSpecDecl(LinkageSpecDecl *D);
117     void VisitExportDecl(ExportDecl *D);
118     void VisitFileScopeAsmDecl(FileScopeAsmDecl *D);
119     void VisitImportDecl(ImportDecl *D);
120     void VisitAccessSpecDecl(AccessSpecDecl *D);
121     void VisitFriendDecl(FriendDecl *D);
122     void VisitFriendTemplateDecl(FriendTemplateDecl *D);
123     void VisitStaticAssertDecl(StaticAssertDecl *D);
124     void VisitBlockDecl(BlockDecl *D);
125     void VisitCapturedDecl(CapturedDecl *D);
126     void VisitEmptyDecl(EmptyDecl *D);
127 
128     void VisitDeclContext(DeclContext *DC);
129     template <typename T> void VisitRedeclarable(Redeclarable<T> *D);
130 
131 
132     // FIXME: Put in the same order is DeclNodes.td?
133     void VisitObjCMethodDecl(ObjCMethodDecl *D);
134     void VisitObjCTypeParamDecl(ObjCTypeParamDecl *D);
135     void VisitObjCContainerDecl(ObjCContainerDecl *D);
136     void VisitObjCInterfaceDecl(ObjCInterfaceDecl *D);
137     void VisitObjCIvarDecl(ObjCIvarDecl *D);
138     void VisitObjCProtocolDecl(ObjCProtocolDecl *D);
139     void VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D);
140     void VisitObjCCategoryDecl(ObjCCategoryDecl *D);
141     void VisitObjCImplDecl(ObjCImplDecl *D);
142     void VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D);
143     void VisitObjCImplementationDecl(ObjCImplementationDecl *D);
144     void VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D);
145     void VisitObjCPropertyDecl(ObjCPropertyDecl *D);
146     void VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D);
147     void VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D);
148     void VisitOMPRequiresDecl(OMPRequiresDecl *D);
149     void VisitOMPDeclareReductionDecl(OMPDeclareReductionDecl *D);
150     void VisitOMPCapturedExprDecl(OMPCapturedExprDecl *D);
151 
152     /// Add an Objective-C type parameter list to the given record.
AddObjCTypeParamList(ObjCTypeParamList * typeParams)153     void AddObjCTypeParamList(ObjCTypeParamList *typeParams) {
154       // Empty type parameter list.
155       if (!typeParams) {
156         Record.push_back(0);
157         return;
158       }
159 
160       Record.push_back(typeParams->size());
161       for (auto typeParam : *typeParams) {
162         Record.AddDeclRef(typeParam);
163       }
164       Record.AddSourceLocation(typeParams->getLAngleLoc());
165       Record.AddSourceLocation(typeParams->getRAngleLoc());
166     }
167 
168     /// Add to the record the first declaration from each module file that
169     /// provides a declaration of D. The intent is to provide a sufficient
170     /// set such that reloading this set will load all current redeclarations.
AddFirstDeclFromEachModule(const Decl * D,bool IncludeLocal)171     void AddFirstDeclFromEachModule(const Decl *D, bool IncludeLocal) {
172       llvm::MapVector<ModuleFile*, const Decl*> Firsts;
173       // FIXME: We can skip entries that we know are implied by others.
174       for (const Decl *R = D->getMostRecentDecl(); R; R = R->getPreviousDecl()) {
175         if (R->isFromASTFile())
176           Firsts[Writer.Chain->getOwningModuleFile(R)] = R;
177         else if (IncludeLocal)
178           Firsts[nullptr] = R;
179       }
180       for (const auto &F : Firsts)
181         Record.AddDeclRef(F.second);
182     }
183 
184     /// Get the specialization decl from an entry in the specialization list.
185     template <typename EntryType>
186     typename RedeclarableTemplateDecl::SpecEntryTraits<EntryType>::DeclType *
getSpecializationDecl(EntryType & T)187     getSpecializationDecl(EntryType &T) {
188       return RedeclarableTemplateDecl::SpecEntryTraits<EntryType>::getDecl(&T);
189     }
190 
191     /// Get the list of partial specializations from a template's common ptr.
192     template<typename T>
getPartialSpecializations(T * Common)193     decltype(T::PartialSpecializations) &getPartialSpecializations(T *Common) {
194       return Common->PartialSpecializations;
195     }
getPartialSpecializations(FunctionTemplateDecl::Common *)196     ArrayRef<Decl> getPartialSpecializations(FunctionTemplateDecl::Common *) {
197       return None;
198     }
199 
200     template<typename DeclTy>
AddTemplateSpecializations(DeclTy * D)201     void AddTemplateSpecializations(DeclTy *D) {
202       auto *Common = D->getCommonPtr();
203 
204       // If we have any lazy specializations, and the external AST source is
205       // our chained AST reader, we can just write out the DeclIDs. Otherwise,
206       // we need to resolve them to actual declarations.
207       if (Writer.Chain != Writer.Context->getExternalSource() &&
208           Common->LazySpecializations) {
209         D->LoadLazySpecializations();
210         assert(!Common->LazySpecializations);
211       }
212 
213       ArrayRef<DeclID> LazySpecializations;
214       if (auto *LS = Common->LazySpecializations)
215         LazySpecializations = llvm::makeArrayRef(LS + 1, LS[0]);
216 
217       // Add a slot to the record for the number of specializations.
218       unsigned I = Record.size();
219       Record.push_back(0);
220 
221       // AddFirstDeclFromEachModule might trigger deserialization, invalidating
222       // *Specializations iterators.
223       llvm::SmallVector<const Decl*, 16> Specs;
224       for (auto &Entry : Common->Specializations)
225         Specs.push_back(getSpecializationDecl(Entry));
226       for (auto &Entry : getPartialSpecializations(Common))
227         Specs.push_back(getSpecializationDecl(Entry));
228 
229       for (auto *D : Specs) {
230         assert(D->isCanonicalDecl() && "non-canonical decl in set");
231         AddFirstDeclFromEachModule(D, /*IncludeLocal*/true);
232       }
233       Record.append(LazySpecializations.begin(), LazySpecializations.end());
234 
235       // Update the size entry we added earlier.
236       Record[I] = Record.size() - I - 1;
237     }
238 
239     /// Ensure that this template specialization is associated with the specified
240     /// template on reload.
RegisterTemplateSpecialization(const Decl * Template,const Decl * Specialization)241     void RegisterTemplateSpecialization(const Decl *Template,
242                                         const Decl *Specialization) {
243       Template = Template->getCanonicalDecl();
244 
245       // If the canonical template is local, we'll write out this specialization
246       // when we emit it.
247       // FIXME: We can do the same thing if there is any local declaration of
248       // the template, to avoid emitting an update record.
249       if (!Template->isFromASTFile())
250         return;
251 
252       // We only need to associate the first local declaration of the
253       // specialization. The other declarations will get pulled in by it.
254       if (Writer.getFirstLocalDecl(Specialization) != Specialization)
255         return;
256 
257       Writer.DeclUpdates[Template].push_back(ASTWriter::DeclUpdate(
258           UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION, Specialization));
259     }
260   };
261 }
262 
Visit(Decl * D)263 void ASTDeclWriter::Visit(Decl *D) {
264   DeclVisitor<ASTDeclWriter>::Visit(D);
265 
266   // Source locations require array (variable-length) abbreviations.  The
267   // abbreviation infrastructure requires that arrays are encoded last, so
268   // we handle it here in the case of those classes derived from DeclaratorDecl
269   if (DeclaratorDecl *DD = dyn_cast<DeclaratorDecl>(D)) {
270     if (auto *TInfo = DD->getTypeSourceInfo())
271       Record.AddTypeLoc(TInfo->getTypeLoc());
272   }
273 
274   // Handle FunctionDecl's body here and write it after all other Stmts/Exprs
275   // have been written. We want it last because we will not read it back when
276   // retrieving it from the AST, we'll just lazily set the offset.
277   if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
278     Record.push_back(FD->doesThisDeclarationHaveABody());
279     if (FD->doesThisDeclarationHaveABody())
280       Record.AddFunctionDefinition(FD);
281   }
282 
283   // If this declaration is also a DeclContext, write blocks for the
284   // declarations that lexically stored inside its context and those
285   // declarations that are visible from its context.
286   if (DeclContext *DC = dyn_cast<DeclContext>(D))
287     VisitDeclContext(DC);
288 }
289 
VisitDecl(Decl * D)290 void ASTDeclWriter::VisitDecl(Decl *D) {
291   Record.AddDeclRef(cast_or_null<Decl>(D->getDeclContext()));
292   if (D->getDeclContext() != D->getLexicalDeclContext())
293     Record.AddDeclRef(cast_or_null<Decl>(D->getLexicalDeclContext()));
294   else
295     Record.push_back(0);
296   Record.push_back(D->isInvalidDecl());
297   Record.push_back(D->hasAttrs());
298   if (D->hasAttrs())
299     Record.AddAttributes(D->getAttrs());
300   Record.push_back(D->isImplicit());
301   Record.push_back(D->isUsed(false));
302   Record.push_back(D->isReferenced());
303   Record.push_back(D->isTopLevelDeclInObjCContainer());
304   Record.push_back(D->getAccess());
305   Record.push_back(D->isModulePrivate());
306   Record.push_back(Writer.getSubmoduleID(D->getOwningModule()));
307 
308   // If this declaration injected a name into a context different from its
309   // lexical context, and that context is an imported namespace, we need to
310   // update its visible declarations to include this name.
311   //
312   // This happens when we instantiate a class with a friend declaration or a
313   // function with a local extern declaration, for instance.
314   //
315   // FIXME: Can we handle this in AddedVisibleDecl instead?
316   if (D->isOutOfLine()) {
317     auto *DC = D->getDeclContext();
318     while (auto *NS = dyn_cast<NamespaceDecl>(DC->getRedeclContext())) {
319       if (!NS->isFromASTFile())
320         break;
321       Writer.UpdatedDeclContexts.insert(NS->getPrimaryContext());
322       if (!NS->isInlineNamespace())
323         break;
324       DC = NS->getParent();
325     }
326   }
327 }
328 
VisitPragmaCommentDecl(PragmaCommentDecl * D)329 void ASTDeclWriter::VisitPragmaCommentDecl(PragmaCommentDecl *D) {
330   StringRef Arg = D->getArg();
331   Record.push_back(Arg.size());
332   VisitDecl(D);
333   Record.AddSourceLocation(D->getBeginLoc());
334   Record.push_back(D->getCommentKind());
335   Record.AddString(Arg);
336   Code = serialization::DECL_PRAGMA_COMMENT;
337 }
338 
VisitPragmaDetectMismatchDecl(PragmaDetectMismatchDecl * D)339 void ASTDeclWriter::VisitPragmaDetectMismatchDecl(
340     PragmaDetectMismatchDecl *D) {
341   StringRef Name = D->getName();
342   StringRef Value = D->getValue();
343   Record.push_back(Name.size() + 1 + Value.size());
344   VisitDecl(D);
345   Record.AddSourceLocation(D->getBeginLoc());
346   Record.AddString(Name);
347   Record.AddString(Value);
348   Code = serialization::DECL_PRAGMA_DETECT_MISMATCH;
349 }
350 
VisitTranslationUnitDecl(TranslationUnitDecl * D)351 void ASTDeclWriter::VisitTranslationUnitDecl(TranslationUnitDecl *D) {
352   llvm_unreachable("Translation units aren't directly serialized");
353 }
354 
VisitNamedDecl(NamedDecl * D)355 void ASTDeclWriter::VisitNamedDecl(NamedDecl *D) {
356   VisitDecl(D);
357   Record.AddDeclarationName(D->getDeclName());
358   Record.push_back(needsAnonymousDeclarationNumber(D)
359                        ? Writer.getAnonymousDeclarationNumber(D)
360                        : 0);
361 }
362 
VisitTypeDecl(TypeDecl * D)363 void ASTDeclWriter::VisitTypeDecl(TypeDecl *D) {
364   VisitNamedDecl(D);
365   Record.AddSourceLocation(D->getBeginLoc());
366   Record.AddTypeRef(QualType(D->getTypeForDecl(), 0));
367 }
368 
VisitTypedefNameDecl(TypedefNameDecl * D)369 void ASTDeclWriter::VisitTypedefNameDecl(TypedefNameDecl *D) {
370   VisitRedeclarable(D);
371   VisitTypeDecl(D);
372   Record.AddTypeSourceInfo(D->getTypeSourceInfo());
373   Record.push_back(D->isModed());
374   if (D->isModed())
375     Record.AddTypeRef(D->getUnderlyingType());
376   Record.AddDeclRef(D->getAnonDeclWithTypedefName(false));
377 }
378 
VisitTypedefDecl(TypedefDecl * D)379 void ASTDeclWriter::VisitTypedefDecl(TypedefDecl *D) {
380   VisitTypedefNameDecl(D);
381   if (D->getDeclContext() == D->getLexicalDeclContext() &&
382       !D->hasAttrs() &&
383       !D->isImplicit() &&
384       D->getFirstDecl() == D->getMostRecentDecl() &&
385       !D->isInvalidDecl() &&
386       !D->isTopLevelDeclInObjCContainer() &&
387       !D->isModulePrivate() &&
388       !needsAnonymousDeclarationNumber(D) &&
389       D->getDeclName().getNameKind() == DeclarationName::Identifier)
390     AbbrevToUse = Writer.getDeclTypedefAbbrev();
391 
392   Code = serialization::DECL_TYPEDEF;
393 }
394 
VisitTypeAliasDecl(TypeAliasDecl * D)395 void ASTDeclWriter::VisitTypeAliasDecl(TypeAliasDecl *D) {
396   VisitTypedefNameDecl(D);
397   Record.AddDeclRef(D->getDescribedAliasTemplate());
398   Code = serialization::DECL_TYPEALIAS;
399 }
400 
VisitTagDecl(TagDecl * D)401 void ASTDeclWriter::VisitTagDecl(TagDecl *D) {
402   VisitRedeclarable(D);
403   VisitTypeDecl(D);
404   Record.push_back(D->getIdentifierNamespace());
405   Record.push_back((unsigned)D->getTagKind()); // FIXME: stable encoding
406   if (!isa<CXXRecordDecl>(D))
407     Record.push_back(D->isCompleteDefinition());
408   Record.push_back(D->isEmbeddedInDeclarator());
409   Record.push_back(D->isFreeStanding());
410   Record.push_back(D->isCompleteDefinitionRequired());
411   Record.AddSourceRange(D->getBraceRange());
412 
413   if (D->hasExtInfo()) {
414     Record.push_back(1);
415     Record.AddQualifierInfo(*D->getExtInfo());
416   } else if (auto *TD = D->getTypedefNameForAnonDecl()) {
417     Record.push_back(2);
418     Record.AddDeclRef(TD);
419     Record.AddIdentifierRef(TD->getDeclName().getAsIdentifierInfo());
420   } else {
421     Record.push_back(0);
422   }
423 }
424 
VisitEnumDecl(EnumDecl * D)425 void ASTDeclWriter::VisitEnumDecl(EnumDecl *D) {
426   VisitTagDecl(D);
427   Record.AddTypeSourceInfo(D->getIntegerTypeSourceInfo());
428   if (!D->getIntegerTypeSourceInfo())
429     Record.AddTypeRef(D->getIntegerType());
430   Record.AddTypeRef(D->getPromotionType());
431   Record.push_back(D->getNumPositiveBits());
432   Record.push_back(D->getNumNegativeBits());
433   Record.push_back(D->isScoped());
434   Record.push_back(D->isScopedUsingClassTag());
435   Record.push_back(D->isFixed());
436   Record.push_back(D->getODRHash());
437 
438   if (MemberSpecializationInfo *MemberInfo = D->getMemberSpecializationInfo()) {
439     Record.AddDeclRef(MemberInfo->getInstantiatedFrom());
440     Record.push_back(MemberInfo->getTemplateSpecializationKind());
441     Record.AddSourceLocation(MemberInfo->getPointOfInstantiation());
442   } else {
443     Record.AddDeclRef(nullptr);
444   }
445 
446   if (D->getDeclContext() == D->getLexicalDeclContext() &&
447       !D->hasAttrs() &&
448       !D->isImplicit() &&
449       !D->isUsed(false) &&
450       !D->hasExtInfo() &&
451       !D->getTypedefNameForAnonDecl() &&
452       D->getFirstDecl() == D->getMostRecentDecl() &&
453       !D->isInvalidDecl() &&
454       !D->isReferenced() &&
455       !D->isTopLevelDeclInObjCContainer() &&
456       D->getAccess() == AS_none &&
457       !D->isModulePrivate() &&
458       !CXXRecordDecl::classofKind(D->getKind()) &&
459       !D->getIntegerTypeSourceInfo() &&
460       !D->getMemberSpecializationInfo() &&
461       !needsAnonymousDeclarationNumber(D) &&
462       D->getDeclName().getNameKind() == DeclarationName::Identifier)
463     AbbrevToUse = Writer.getDeclEnumAbbrev();
464 
465   Code = serialization::DECL_ENUM;
466 }
467 
VisitRecordDecl(RecordDecl * D)468 void ASTDeclWriter::VisitRecordDecl(RecordDecl *D) {
469   VisitTagDecl(D);
470   Record.push_back(D->hasFlexibleArrayMember());
471   Record.push_back(D->isAnonymousStructOrUnion());
472   Record.push_back(D->hasObjectMember());
473   Record.push_back(D->hasVolatileMember());
474   Record.push_back(D->isNonTrivialToPrimitiveDefaultInitialize());
475   Record.push_back(D->isNonTrivialToPrimitiveCopy());
476   Record.push_back(D->isNonTrivialToPrimitiveDestroy());
477   Record.push_back(D->isParamDestroyedInCallee());
478   Record.push_back(D->getArgPassingRestrictions());
479 
480   if (D->getDeclContext() == D->getLexicalDeclContext() &&
481       !D->hasAttrs() &&
482       !D->isImplicit() &&
483       !D->isUsed(false) &&
484       !D->hasExtInfo() &&
485       !D->getTypedefNameForAnonDecl() &&
486       D->getFirstDecl() == D->getMostRecentDecl() &&
487       !D->isInvalidDecl() &&
488       !D->isReferenced() &&
489       !D->isTopLevelDeclInObjCContainer() &&
490       D->getAccess() == AS_none &&
491       !D->isModulePrivate() &&
492       !CXXRecordDecl::classofKind(D->getKind()) &&
493       !needsAnonymousDeclarationNumber(D) &&
494       D->getDeclName().getNameKind() == DeclarationName::Identifier)
495     AbbrevToUse = Writer.getDeclRecordAbbrev();
496 
497   Code = serialization::DECL_RECORD;
498 }
499 
VisitValueDecl(ValueDecl * D)500 void ASTDeclWriter::VisitValueDecl(ValueDecl *D) {
501   VisitNamedDecl(D);
502   Record.AddTypeRef(D->getType());
503 }
504 
VisitEnumConstantDecl(EnumConstantDecl * D)505 void ASTDeclWriter::VisitEnumConstantDecl(EnumConstantDecl *D) {
506   VisitValueDecl(D);
507   Record.push_back(D->getInitExpr()? 1 : 0);
508   if (D->getInitExpr())
509     Record.AddStmt(D->getInitExpr());
510   Record.AddAPSInt(D->getInitVal());
511 
512   Code = serialization::DECL_ENUM_CONSTANT;
513 }
514 
VisitDeclaratorDecl(DeclaratorDecl * D)515 void ASTDeclWriter::VisitDeclaratorDecl(DeclaratorDecl *D) {
516   VisitValueDecl(D);
517   Record.AddSourceLocation(D->getInnerLocStart());
518   Record.push_back(D->hasExtInfo());
519   if (D->hasExtInfo())
520     Record.AddQualifierInfo(*D->getExtInfo());
521   // The location information is deferred until the end of the record.
522   Record.AddTypeRef(D->getTypeSourceInfo() ? D->getTypeSourceInfo()->getType()
523                                            : QualType());
524 }
525 
VisitFunctionDecl(FunctionDecl * D)526 void ASTDeclWriter::VisitFunctionDecl(FunctionDecl *D) {
527   VisitRedeclarable(D);
528   VisitDeclaratorDecl(D);
529   Record.AddDeclarationNameLoc(D->DNLoc, D->getDeclName());
530   Record.push_back(D->getIdentifierNamespace());
531 
532   // FunctionDecl's body is handled last at ASTWriterDecl::Visit,
533   // after everything else is written.
534   Record.push_back(static_cast<int>(D->getStorageClass())); // FIXME: stable encoding
535   Record.push_back(D->isInlineSpecified());
536   Record.push_back(D->isInlined());
537   Record.push_back(D->isExplicitSpecified());
538   Record.push_back(D->isVirtualAsWritten());
539   Record.push_back(D->isPure());
540   Record.push_back(D->hasInheritedPrototype());
541   Record.push_back(D->hasWrittenPrototype());
542   Record.push_back(D->isDeletedBit());
543   Record.push_back(D->isTrivial());
544   Record.push_back(D->isTrivialForCall());
545   Record.push_back(D->isDefaulted());
546   Record.push_back(D->isExplicitlyDefaulted());
547   Record.push_back(D->hasImplicitReturnZero());
548   Record.push_back(D->isConstexpr());
549   Record.push_back(D->usesSEHTry());
550   Record.push_back(D->hasSkippedBody());
551   Record.push_back(D->isMultiVersion());
552   Record.push_back(D->isLateTemplateParsed());
553   Record.push_back(D->getLinkageInternal());
554   Record.AddSourceLocation(D->getEndLoc());
555 
556   Record.push_back(D->getODRHash());
557 
558   Record.push_back(D->getTemplatedKind());
559   switch (D->getTemplatedKind()) {
560   case FunctionDecl::TK_NonTemplate:
561     break;
562   case FunctionDecl::TK_FunctionTemplate:
563     Record.AddDeclRef(D->getDescribedFunctionTemplate());
564     break;
565   case FunctionDecl::TK_MemberSpecialization: {
566     MemberSpecializationInfo *MemberInfo = D->getMemberSpecializationInfo();
567     Record.AddDeclRef(MemberInfo->getInstantiatedFrom());
568     Record.push_back(MemberInfo->getTemplateSpecializationKind());
569     Record.AddSourceLocation(MemberInfo->getPointOfInstantiation());
570     break;
571   }
572   case FunctionDecl::TK_FunctionTemplateSpecialization: {
573     FunctionTemplateSpecializationInfo *
574       FTSInfo = D->getTemplateSpecializationInfo();
575 
576     RegisterTemplateSpecialization(FTSInfo->getTemplate(), D);
577 
578     Record.AddDeclRef(FTSInfo->getTemplate());
579     Record.push_back(FTSInfo->getTemplateSpecializationKind());
580 
581     // Template arguments.
582     Record.AddTemplateArgumentList(FTSInfo->TemplateArguments);
583 
584     // Template args as written.
585     Record.push_back(FTSInfo->TemplateArgumentsAsWritten != nullptr);
586     if (FTSInfo->TemplateArgumentsAsWritten) {
587       Record.push_back(FTSInfo->TemplateArgumentsAsWritten->NumTemplateArgs);
588       for (int i=0, e = FTSInfo->TemplateArgumentsAsWritten->NumTemplateArgs;
589              i!=e; ++i)
590         Record.AddTemplateArgumentLoc(
591             (*FTSInfo->TemplateArgumentsAsWritten)[i]);
592       Record.AddSourceLocation(FTSInfo->TemplateArgumentsAsWritten->LAngleLoc);
593       Record.AddSourceLocation(FTSInfo->TemplateArgumentsAsWritten->RAngleLoc);
594     }
595 
596     Record.AddSourceLocation(FTSInfo->getPointOfInstantiation());
597 
598     if (D->isCanonicalDecl()) {
599       // Write the template that contains the specializations set. We will
600       // add a FunctionTemplateSpecializationInfo to it when reading.
601       Record.AddDeclRef(FTSInfo->getTemplate()->getCanonicalDecl());
602     }
603     break;
604   }
605   case FunctionDecl::TK_DependentFunctionTemplateSpecialization: {
606     DependentFunctionTemplateSpecializationInfo *
607       DFTSInfo = D->getDependentSpecializationInfo();
608 
609     // Templates.
610     Record.push_back(DFTSInfo->getNumTemplates());
611     for (int i=0, e = DFTSInfo->getNumTemplates(); i != e; ++i)
612       Record.AddDeclRef(DFTSInfo->getTemplate(i));
613 
614     // Templates args.
615     Record.push_back(DFTSInfo->getNumTemplateArgs());
616     for (int i=0, e = DFTSInfo->getNumTemplateArgs(); i != e; ++i)
617       Record.AddTemplateArgumentLoc(DFTSInfo->getTemplateArg(i));
618     Record.AddSourceLocation(DFTSInfo->getLAngleLoc());
619     Record.AddSourceLocation(DFTSInfo->getRAngleLoc());
620     break;
621   }
622   }
623 
624   Record.push_back(D->param_size());
625   for (auto P : D->parameters())
626     Record.AddDeclRef(P);
627   Code = serialization::DECL_FUNCTION;
628 }
629 
VisitCXXDeductionGuideDecl(CXXDeductionGuideDecl * D)630 void ASTDeclWriter::VisitCXXDeductionGuideDecl(CXXDeductionGuideDecl *D) {
631   VisitFunctionDecl(D);
632   Record.push_back(D->isCopyDeductionCandidate());
633   Code = serialization::DECL_CXX_DEDUCTION_GUIDE;
634 }
635 
VisitObjCMethodDecl(ObjCMethodDecl * D)636 void ASTDeclWriter::VisitObjCMethodDecl(ObjCMethodDecl *D) {
637   VisitNamedDecl(D);
638   // FIXME: convert to LazyStmtPtr?
639   // Unlike C/C++, method bodies will never be in header files.
640   bool HasBodyStuff = D->getBody() != nullptr     ||
641                       D->getSelfDecl() != nullptr || D->getCmdDecl() != nullptr;
642   Record.push_back(HasBodyStuff);
643   if (HasBodyStuff) {
644     Record.AddStmt(D->getBody());
645     Record.AddDeclRef(D->getSelfDecl());
646     Record.AddDeclRef(D->getCmdDecl());
647   }
648   Record.push_back(D->isInstanceMethod());
649   Record.push_back(D->isVariadic());
650   Record.push_back(D->isPropertyAccessor());
651   Record.push_back(D->isDefined());
652   Record.push_back(D->isOverriding());
653   Record.push_back(D->hasSkippedBody());
654 
655   Record.push_back(D->isRedeclaration());
656   Record.push_back(D->hasRedeclaration());
657   if (D->hasRedeclaration()) {
658     assert(Context.getObjCMethodRedeclaration(D));
659     Record.AddDeclRef(Context.getObjCMethodRedeclaration(D));
660   }
661 
662   // FIXME: stable encoding for @required/@optional
663   Record.push_back(D->getImplementationControl());
664   // FIXME: stable encoding for in/out/inout/bycopy/byref/oneway/nullability
665   Record.push_back(D->getObjCDeclQualifier());
666   Record.push_back(D->hasRelatedResultType());
667   Record.AddTypeRef(D->getReturnType());
668   Record.AddTypeSourceInfo(D->getReturnTypeSourceInfo());
669   Record.AddSourceLocation(D->getEndLoc());
670   Record.push_back(D->param_size());
671   for (const auto *P : D->parameters())
672     Record.AddDeclRef(P);
673 
674   Record.push_back(D->getSelLocsKind());
675   unsigned NumStoredSelLocs = D->getNumStoredSelLocs();
676   SourceLocation *SelLocs = D->getStoredSelLocs();
677   Record.push_back(NumStoredSelLocs);
678   for (unsigned i = 0; i != NumStoredSelLocs; ++i)
679     Record.AddSourceLocation(SelLocs[i]);
680 
681   Code = serialization::DECL_OBJC_METHOD;
682 }
683 
VisitObjCTypeParamDecl(ObjCTypeParamDecl * D)684 void ASTDeclWriter::VisitObjCTypeParamDecl(ObjCTypeParamDecl *D) {
685   VisitTypedefNameDecl(D);
686   Record.push_back(D->Variance);
687   Record.push_back(D->Index);
688   Record.AddSourceLocation(D->VarianceLoc);
689   Record.AddSourceLocation(D->ColonLoc);
690 
691   Code = serialization::DECL_OBJC_TYPE_PARAM;
692 }
693 
VisitObjCContainerDecl(ObjCContainerDecl * D)694 void ASTDeclWriter::VisitObjCContainerDecl(ObjCContainerDecl *D) {
695   VisitNamedDecl(D);
696   Record.AddSourceLocation(D->getAtStartLoc());
697   Record.AddSourceRange(D->getAtEndRange());
698   // Abstract class (no need to define a stable serialization::DECL code).
699 }
700 
VisitObjCInterfaceDecl(ObjCInterfaceDecl * D)701 void ASTDeclWriter::VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) {
702   VisitRedeclarable(D);
703   VisitObjCContainerDecl(D);
704   Record.AddTypeRef(QualType(D->getTypeForDecl(), 0));
705   AddObjCTypeParamList(D->TypeParamList);
706 
707   Record.push_back(D->isThisDeclarationADefinition());
708   if (D->isThisDeclarationADefinition()) {
709     // Write the DefinitionData
710     ObjCInterfaceDecl::DefinitionData &Data = D->data();
711 
712     Record.AddTypeSourceInfo(D->getSuperClassTInfo());
713     Record.AddSourceLocation(D->getEndOfDefinitionLoc());
714     Record.push_back(Data.HasDesignatedInitializers);
715 
716     // Write out the protocols that are directly referenced by the @interface.
717     Record.push_back(Data.ReferencedProtocols.size());
718     for (const auto *P : D->protocols())
719       Record.AddDeclRef(P);
720     for (const auto &PL : D->protocol_locs())
721       Record.AddSourceLocation(PL);
722 
723     // Write out the protocols that are transitively referenced.
724     Record.push_back(Data.AllReferencedProtocols.size());
725     for (ObjCList<ObjCProtocolDecl>::iterator
726               P = Data.AllReferencedProtocols.begin(),
727            PEnd = Data.AllReferencedProtocols.end();
728          P != PEnd; ++P)
729       Record.AddDeclRef(*P);
730 
731 
732     if (ObjCCategoryDecl *Cat = D->getCategoryListRaw()) {
733       // Ensure that we write out the set of categories for this class.
734       Writer.ObjCClassesWithCategories.insert(D);
735 
736       // Make sure that the categories get serialized.
737       for (; Cat; Cat = Cat->getNextClassCategoryRaw())
738         (void)Writer.GetDeclRef(Cat);
739     }
740   }
741 
742   Code = serialization::DECL_OBJC_INTERFACE;
743 }
744 
VisitObjCIvarDecl(ObjCIvarDecl * D)745 void ASTDeclWriter::VisitObjCIvarDecl(ObjCIvarDecl *D) {
746   VisitFieldDecl(D);
747   // FIXME: stable encoding for @public/@private/@protected/@package
748   Record.push_back(D->getAccessControl());
749   Record.push_back(D->getSynthesize());
750 
751   if (D->getDeclContext() == D->getLexicalDeclContext() &&
752       !D->hasAttrs() &&
753       !D->isImplicit() &&
754       !D->isUsed(false) &&
755       !D->isInvalidDecl() &&
756       !D->isReferenced() &&
757       !D->isModulePrivate() &&
758       !D->getBitWidth() &&
759       !D->hasExtInfo() &&
760       D->getDeclName())
761     AbbrevToUse = Writer.getDeclObjCIvarAbbrev();
762 
763   Code = serialization::DECL_OBJC_IVAR;
764 }
765 
VisitObjCProtocolDecl(ObjCProtocolDecl * D)766 void ASTDeclWriter::VisitObjCProtocolDecl(ObjCProtocolDecl *D) {
767   VisitRedeclarable(D);
768   VisitObjCContainerDecl(D);
769 
770   Record.push_back(D->isThisDeclarationADefinition());
771   if (D->isThisDeclarationADefinition()) {
772     Record.push_back(D->protocol_size());
773     for (const auto *I : D->protocols())
774       Record.AddDeclRef(I);
775     for (const auto &PL : D->protocol_locs())
776       Record.AddSourceLocation(PL);
777   }
778 
779   Code = serialization::DECL_OBJC_PROTOCOL;
780 }
781 
VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl * D)782 void ASTDeclWriter::VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D) {
783   VisitFieldDecl(D);
784   Code = serialization::DECL_OBJC_AT_DEFS_FIELD;
785 }
786 
VisitObjCCategoryDecl(ObjCCategoryDecl * D)787 void ASTDeclWriter::VisitObjCCategoryDecl(ObjCCategoryDecl *D) {
788   VisitObjCContainerDecl(D);
789   Record.AddSourceLocation(D->getCategoryNameLoc());
790   Record.AddSourceLocation(D->getIvarLBraceLoc());
791   Record.AddSourceLocation(D->getIvarRBraceLoc());
792   Record.AddDeclRef(D->getClassInterface());
793   AddObjCTypeParamList(D->TypeParamList);
794   Record.push_back(D->protocol_size());
795   for (const auto *I : D->protocols())
796     Record.AddDeclRef(I);
797   for (const auto &PL : D->protocol_locs())
798     Record.AddSourceLocation(PL);
799   Code = serialization::DECL_OBJC_CATEGORY;
800 }
801 
VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl * D)802 void ASTDeclWriter::VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D) {
803   VisitNamedDecl(D);
804   Record.AddDeclRef(D->getClassInterface());
805   Code = serialization::DECL_OBJC_COMPATIBLE_ALIAS;
806 }
807 
VisitObjCPropertyDecl(ObjCPropertyDecl * D)808 void ASTDeclWriter::VisitObjCPropertyDecl(ObjCPropertyDecl *D) {
809   VisitNamedDecl(D);
810   Record.AddSourceLocation(D->getAtLoc());
811   Record.AddSourceLocation(D->getLParenLoc());
812   Record.AddTypeRef(D->getType());
813   Record.AddTypeSourceInfo(D->getTypeSourceInfo());
814   // FIXME: stable encoding
815   Record.push_back((unsigned)D->getPropertyAttributes());
816   Record.push_back((unsigned)D->getPropertyAttributesAsWritten());
817   // FIXME: stable encoding
818   Record.push_back((unsigned)D->getPropertyImplementation());
819   Record.AddDeclarationName(D->getGetterName());
820   Record.AddSourceLocation(D->getGetterNameLoc());
821   Record.AddDeclarationName(D->getSetterName());
822   Record.AddSourceLocation(D->getSetterNameLoc());
823   Record.AddDeclRef(D->getGetterMethodDecl());
824   Record.AddDeclRef(D->getSetterMethodDecl());
825   Record.AddDeclRef(D->getPropertyIvarDecl());
826   Code = serialization::DECL_OBJC_PROPERTY;
827 }
828 
VisitObjCImplDecl(ObjCImplDecl * D)829 void ASTDeclWriter::VisitObjCImplDecl(ObjCImplDecl *D) {
830   VisitObjCContainerDecl(D);
831   Record.AddDeclRef(D->getClassInterface());
832   // Abstract class (no need to define a stable serialization::DECL code).
833 }
834 
VisitObjCCategoryImplDecl(ObjCCategoryImplDecl * D)835 void ASTDeclWriter::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
836   VisitObjCImplDecl(D);
837   Record.AddSourceLocation(D->getCategoryNameLoc());
838   Code = serialization::DECL_OBJC_CATEGORY_IMPL;
839 }
840 
VisitObjCImplementationDecl(ObjCImplementationDecl * D)841 void ASTDeclWriter::VisitObjCImplementationDecl(ObjCImplementationDecl *D) {
842   VisitObjCImplDecl(D);
843   Record.AddDeclRef(D->getSuperClass());
844   Record.AddSourceLocation(D->getSuperClassLoc());
845   Record.AddSourceLocation(D->getIvarLBraceLoc());
846   Record.AddSourceLocation(D->getIvarRBraceLoc());
847   Record.push_back(D->hasNonZeroConstructors());
848   Record.push_back(D->hasDestructors());
849   Record.push_back(D->NumIvarInitializers);
850   if (D->NumIvarInitializers)
851     Record.AddCXXCtorInitializers(
852         llvm::makeArrayRef(D->init_begin(), D->init_end()));
853   Code = serialization::DECL_OBJC_IMPLEMENTATION;
854 }
855 
VisitObjCPropertyImplDecl(ObjCPropertyImplDecl * D)856 void ASTDeclWriter::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) {
857   VisitDecl(D);
858   Record.AddSourceLocation(D->getBeginLoc());
859   Record.AddDeclRef(D->getPropertyDecl());
860   Record.AddDeclRef(D->getPropertyIvarDecl());
861   Record.AddSourceLocation(D->getPropertyIvarDeclLoc());
862   Record.AddStmt(D->getGetterCXXConstructor());
863   Record.AddStmt(D->getSetterCXXAssignment());
864   Code = serialization::DECL_OBJC_PROPERTY_IMPL;
865 }
866 
VisitFieldDecl(FieldDecl * D)867 void ASTDeclWriter::VisitFieldDecl(FieldDecl *D) {
868   VisitDeclaratorDecl(D);
869   Record.push_back(D->isMutable());
870 
871   FieldDecl::InitStorageKind ISK = D->InitStorage.getInt();
872   Record.push_back(ISK);
873   if (ISK == FieldDecl::ISK_CapturedVLAType)
874     Record.AddTypeRef(QualType(D->getCapturedVLAType(), 0));
875   else if (ISK)
876     Record.AddStmt(D->getInClassInitializer());
877 
878   Record.AddStmt(D->getBitWidth());
879 
880   if (!D->getDeclName())
881     Record.AddDeclRef(Context.getInstantiatedFromUnnamedFieldDecl(D));
882 
883   if (D->getDeclContext() == D->getLexicalDeclContext() &&
884       !D->hasAttrs() &&
885       !D->isImplicit() &&
886       !D->isUsed(false) &&
887       !D->isInvalidDecl() &&
888       !D->isReferenced() &&
889       !D->isTopLevelDeclInObjCContainer() &&
890       !D->isModulePrivate() &&
891       !D->getBitWidth() &&
892       !D->hasInClassInitializer() &&
893       !D->hasCapturedVLAType() &&
894       !D->hasExtInfo() &&
895       !ObjCIvarDecl::classofKind(D->getKind()) &&
896       !ObjCAtDefsFieldDecl::classofKind(D->getKind()) &&
897       D->getDeclName())
898     AbbrevToUse = Writer.getDeclFieldAbbrev();
899 
900   Code = serialization::DECL_FIELD;
901 }
902 
VisitMSPropertyDecl(MSPropertyDecl * D)903 void ASTDeclWriter::VisitMSPropertyDecl(MSPropertyDecl *D) {
904   VisitDeclaratorDecl(D);
905   Record.AddIdentifierRef(D->getGetterId());
906   Record.AddIdentifierRef(D->getSetterId());
907   Code = serialization::DECL_MS_PROPERTY;
908 }
909 
VisitIndirectFieldDecl(IndirectFieldDecl * D)910 void ASTDeclWriter::VisitIndirectFieldDecl(IndirectFieldDecl *D) {
911   VisitValueDecl(D);
912   Record.push_back(D->getChainingSize());
913 
914   for (const auto *P : D->chain())
915     Record.AddDeclRef(P);
916   Code = serialization::DECL_INDIRECTFIELD;
917 }
918 
VisitVarDecl(VarDecl * D)919 void ASTDeclWriter::VisitVarDecl(VarDecl *D) {
920   VisitRedeclarable(D);
921   VisitDeclaratorDecl(D);
922   Record.push_back(D->getStorageClass());
923   Record.push_back(D->getTSCSpec());
924   Record.push_back(D->getInitStyle());
925   Record.push_back(D->isARCPseudoStrong());
926   if (!isa<ParmVarDecl>(D)) {
927     Record.push_back(D->isThisDeclarationADemotedDefinition());
928     Record.push_back(D->isExceptionVariable());
929     Record.push_back(D->isNRVOVariable());
930     Record.push_back(D->isCXXForRangeDecl());
931     Record.push_back(D->isObjCForDecl());
932     Record.push_back(D->isInline());
933     Record.push_back(D->isInlineSpecified());
934     Record.push_back(D->isConstexpr());
935     Record.push_back(D->isInitCapture());
936     Record.push_back(D->isPreviousDeclInSameBlockScope());
937     if (const auto *IPD = dyn_cast<ImplicitParamDecl>(D))
938       Record.push_back(static_cast<unsigned>(IPD->getParameterKind()));
939     else
940       Record.push_back(0);
941     Record.push_back(D->isEscapingByref());
942   }
943   Record.push_back(D->getLinkageInternal());
944 
945   if (D->getInit()) {
946     Record.push_back(!D->isInitKnownICE() ? 1 : (D->isInitICE() ? 3 : 2));
947     Record.AddStmt(D->getInit());
948   } else {
949     Record.push_back(0);
950   }
951 
952   if (D->hasAttr<BlocksAttr>() && D->getType()->getAsCXXRecordDecl()) {
953     ASTContext::BlockVarCopyInit Init = Writer.Context->getBlockVarCopyInit(D);
954     Record.AddStmt(Init.getCopyExpr());
955     if (Init.getCopyExpr())
956       Record.push_back(Init.canThrow());
957   }
958 
959   if (D->getStorageDuration() == SD_Static) {
960     bool ModulesCodegen = false;
961     if (Writer.WritingModule &&
962         !D->getDescribedVarTemplate() && !D->getMemberSpecializationInfo() &&
963         !isa<VarTemplateSpecializationDecl>(D)) {
964       // When building a C++ Modules TS module interface unit, a strong
965       // definition in the module interface is provided by the compilation of
966       // that module interface unit, not by its users. (Inline variables are
967       // still emitted in module users.)
968       ModulesCodegen =
969           (Writer.WritingModule->Kind == Module::ModuleInterfaceUnit &&
970            Writer.Context->GetGVALinkageForVariable(D) == GVA_StrongExternal);
971     }
972     Record.push_back(ModulesCodegen);
973     if (ModulesCodegen)
974       Writer.ModularCodegenDecls.push_back(Writer.GetDeclRef(D));
975   }
976 
977   enum {
978     VarNotTemplate = 0, VarTemplate, StaticDataMemberSpecialization
979   };
980   if (VarTemplateDecl *TemplD = D->getDescribedVarTemplate()) {
981     Record.push_back(VarTemplate);
982     Record.AddDeclRef(TemplD);
983   } else if (MemberSpecializationInfo *SpecInfo
984                = D->getMemberSpecializationInfo()) {
985     Record.push_back(StaticDataMemberSpecialization);
986     Record.AddDeclRef(SpecInfo->getInstantiatedFrom());
987     Record.push_back(SpecInfo->getTemplateSpecializationKind());
988     Record.AddSourceLocation(SpecInfo->getPointOfInstantiation());
989   } else {
990     Record.push_back(VarNotTemplate);
991   }
992 
993   if (D->getDeclContext() == D->getLexicalDeclContext() &&
994       !D->hasAttrs() &&
995       !D->isImplicit() &&
996       !D->isUsed(false) &&
997       !D->isInvalidDecl() &&
998       !D->isReferenced() &&
999       !D->isTopLevelDeclInObjCContainer() &&
1000       D->getAccess() == AS_none &&
1001       !D->isModulePrivate() &&
1002       !needsAnonymousDeclarationNumber(D) &&
1003       D->getDeclName().getNameKind() == DeclarationName::Identifier &&
1004       !D->hasExtInfo() &&
1005       D->getFirstDecl() == D->getMostRecentDecl() &&
1006       D->getKind() == Decl::Var &&
1007       !D->isInline() &&
1008       !D->isConstexpr() &&
1009       !D->isInitCapture() &&
1010       !D->isPreviousDeclInSameBlockScope() &&
1011       !(D->hasAttr<BlocksAttr>() && D->getType()->getAsCXXRecordDecl()) &&
1012       !D->isEscapingByref() &&
1013       D->getStorageDuration() != SD_Static &&
1014       !D->getMemberSpecializationInfo())
1015     AbbrevToUse = Writer.getDeclVarAbbrev();
1016 
1017   Code = serialization::DECL_VAR;
1018 }
1019 
VisitImplicitParamDecl(ImplicitParamDecl * D)1020 void ASTDeclWriter::VisitImplicitParamDecl(ImplicitParamDecl *D) {
1021   VisitVarDecl(D);
1022   Code = serialization::DECL_IMPLICIT_PARAM;
1023 }
1024 
VisitParmVarDecl(ParmVarDecl * D)1025 void ASTDeclWriter::VisitParmVarDecl(ParmVarDecl *D) {
1026   VisitVarDecl(D);
1027   Record.push_back(D->isObjCMethodParameter());
1028   Record.push_back(D->getFunctionScopeDepth());
1029   Record.push_back(D->getFunctionScopeIndex());
1030   Record.push_back(D->getObjCDeclQualifier()); // FIXME: stable encoding
1031   Record.push_back(D->isKNRPromoted());
1032   Record.push_back(D->hasInheritedDefaultArg());
1033   Record.push_back(D->hasUninstantiatedDefaultArg());
1034   if (D->hasUninstantiatedDefaultArg())
1035     Record.AddStmt(D->getUninstantiatedDefaultArg());
1036   Code = serialization::DECL_PARM_VAR;
1037 
1038   assert(!D->isARCPseudoStrong()); // can be true of ImplicitParamDecl
1039 
1040   // If the assumptions about the DECL_PARM_VAR abbrev are true, use it.  Here
1041   // we dynamically check for the properties that we optimize for, but don't
1042   // know are true of all PARM_VAR_DECLs.
1043   if (D->getDeclContext() == D->getLexicalDeclContext() &&
1044       !D->hasAttrs() &&
1045       !D->hasExtInfo() &&
1046       !D->isImplicit() &&
1047       !D->isUsed(false) &&
1048       !D->isInvalidDecl() &&
1049       !D->isReferenced() &&
1050       D->getAccess() == AS_none &&
1051       !D->isModulePrivate() &&
1052       D->getStorageClass() == 0 &&
1053       D->getInitStyle() == VarDecl::CInit && // Can params have anything else?
1054       D->getFunctionScopeDepth() == 0 &&
1055       D->getObjCDeclQualifier() == 0 &&
1056       !D->isKNRPromoted() &&
1057       !D->hasInheritedDefaultArg() &&
1058       D->getInit() == nullptr &&
1059       !D->hasUninstantiatedDefaultArg())  // No default expr.
1060     AbbrevToUse = Writer.getDeclParmVarAbbrev();
1061 
1062   // Check things we know are true of *every* PARM_VAR_DECL, which is more than
1063   // just us assuming it.
1064   assert(!D->getTSCSpec() && "PARM_VAR_DECL can't use TLS");
1065   assert(!D->isThisDeclarationADemotedDefinition()
1066          && "PARM_VAR_DECL can't be demoted definition.");
1067   assert(D->getAccess() == AS_none && "PARM_VAR_DECL can't be public/private");
1068   assert(!D->isExceptionVariable() && "PARM_VAR_DECL can't be exception var");
1069   assert(D->getPreviousDecl() == nullptr && "PARM_VAR_DECL can't be redecl");
1070   assert(!D->isStaticDataMember() &&
1071          "PARM_VAR_DECL can't be static data member");
1072 }
1073 
VisitDecompositionDecl(DecompositionDecl * D)1074 void ASTDeclWriter::VisitDecompositionDecl(DecompositionDecl *D) {
1075   // Record the number of bindings first to simplify deserialization.
1076   Record.push_back(D->bindings().size());
1077 
1078   VisitVarDecl(D);
1079   for (auto *B : D->bindings())
1080     Record.AddDeclRef(B);
1081   Code = serialization::DECL_DECOMPOSITION;
1082 }
1083 
VisitBindingDecl(BindingDecl * D)1084 void ASTDeclWriter::VisitBindingDecl(BindingDecl *D) {
1085   VisitValueDecl(D);
1086   Record.AddStmt(D->getBinding());
1087   Code = serialization::DECL_BINDING;
1088 }
1089 
VisitFileScopeAsmDecl(FileScopeAsmDecl * D)1090 void ASTDeclWriter::VisitFileScopeAsmDecl(FileScopeAsmDecl *D) {
1091   VisitDecl(D);
1092   Record.AddStmt(D->getAsmString());
1093   Record.AddSourceLocation(D->getRParenLoc());
1094   Code = serialization::DECL_FILE_SCOPE_ASM;
1095 }
1096 
VisitEmptyDecl(EmptyDecl * D)1097 void ASTDeclWriter::VisitEmptyDecl(EmptyDecl *D) {
1098   VisitDecl(D);
1099   Code = serialization::DECL_EMPTY;
1100 }
1101 
VisitBlockDecl(BlockDecl * D)1102 void ASTDeclWriter::VisitBlockDecl(BlockDecl *D) {
1103   VisitDecl(D);
1104   Record.AddStmt(D->getBody());
1105   Record.AddTypeSourceInfo(D->getSignatureAsWritten());
1106   Record.push_back(D->param_size());
1107   for (ParmVarDecl *P : D->parameters())
1108     Record.AddDeclRef(P);
1109   Record.push_back(D->isVariadic());
1110   Record.push_back(D->blockMissingReturnType());
1111   Record.push_back(D->isConversionFromLambda());
1112   Record.push_back(D->doesNotEscape());
1113   Record.push_back(D->capturesCXXThis());
1114   Record.push_back(D->getNumCaptures());
1115   for (const auto &capture : D->captures()) {
1116     Record.AddDeclRef(capture.getVariable());
1117 
1118     unsigned flags = 0;
1119     if (capture.isByRef()) flags |= 1;
1120     if (capture.isNested()) flags |= 2;
1121     if (capture.hasCopyExpr()) flags |= 4;
1122     Record.push_back(flags);
1123 
1124     if (capture.hasCopyExpr()) Record.AddStmt(capture.getCopyExpr());
1125   }
1126 
1127   Code = serialization::DECL_BLOCK;
1128 }
1129 
VisitCapturedDecl(CapturedDecl * CD)1130 void ASTDeclWriter::VisitCapturedDecl(CapturedDecl *CD) {
1131   Record.push_back(CD->getNumParams());
1132   VisitDecl(CD);
1133   Record.push_back(CD->getContextParamPosition());
1134   Record.push_back(CD->isNothrow() ? 1 : 0);
1135   // Body is stored by VisitCapturedStmt.
1136   for (unsigned I = 0; I < CD->getNumParams(); ++I)
1137     Record.AddDeclRef(CD->getParam(I));
1138   Code = serialization::DECL_CAPTURED;
1139 }
1140 
VisitLinkageSpecDecl(LinkageSpecDecl * D)1141 void ASTDeclWriter::VisitLinkageSpecDecl(LinkageSpecDecl *D) {
1142   VisitDecl(D);
1143   Record.push_back(D->getLanguage());
1144   Record.AddSourceLocation(D->getExternLoc());
1145   Record.AddSourceLocation(D->getRBraceLoc());
1146   Code = serialization::DECL_LINKAGE_SPEC;
1147 }
1148 
VisitExportDecl(ExportDecl * D)1149 void ASTDeclWriter::VisitExportDecl(ExportDecl *D) {
1150   VisitDecl(D);
1151   Record.AddSourceLocation(D->getRBraceLoc());
1152   Code = serialization::DECL_EXPORT;
1153 }
1154 
VisitLabelDecl(LabelDecl * D)1155 void ASTDeclWriter::VisitLabelDecl(LabelDecl *D) {
1156   VisitNamedDecl(D);
1157   Record.AddSourceLocation(D->getBeginLoc());
1158   Code = serialization::DECL_LABEL;
1159 }
1160 
1161 
VisitNamespaceDecl(NamespaceDecl * D)1162 void ASTDeclWriter::VisitNamespaceDecl(NamespaceDecl *D) {
1163   VisitRedeclarable(D);
1164   VisitNamedDecl(D);
1165   Record.push_back(D->isInline());
1166   Record.AddSourceLocation(D->getBeginLoc());
1167   Record.AddSourceLocation(D->getRBraceLoc());
1168 
1169   if (D->isOriginalNamespace())
1170     Record.AddDeclRef(D->getAnonymousNamespace());
1171   Code = serialization::DECL_NAMESPACE;
1172 
1173   if (Writer.hasChain() && D->isAnonymousNamespace() &&
1174       D == D->getMostRecentDecl()) {
1175     // This is a most recent reopening of the anonymous namespace. If its parent
1176     // is in a previous PCH (or is the TU), mark that parent for update, because
1177     // the original namespace always points to the latest re-opening of its
1178     // anonymous namespace.
1179     Decl *Parent = cast<Decl>(
1180         D->getParent()->getRedeclContext()->getPrimaryContext());
1181     if (Parent->isFromASTFile() || isa<TranslationUnitDecl>(Parent)) {
1182       Writer.DeclUpdates[Parent].push_back(
1183           ASTWriter::DeclUpdate(UPD_CXX_ADDED_ANONYMOUS_NAMESPACE, D));
1184     }
1185   }
1186 }
1187 
VisitNamespaceAliasDecl(NamespaceAliasDecl * D)1188 void ASTDeclWriter::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) {
1189   VisitRedeclarable(D);
1190   VisitNamedDecl(D);
1191   Record.AddSourceLocation(D->getNamespaceLoc());
1192   Record.AddSourceLocation(D->getTargetNameLoc());
1193   Record.AddNestedNameSpecifierLoc(D->getQualifierLoc());
1194   Record.AddDeclRef(D->getNamespace());
1195   Code = serialization::DECL_NAMESPACE_ALIAS;
1196 }
1197 
VisitUsingDecl(UsingDecl * D)1198 void ASTDeclWriter::VisitUsingDecl(UsingDecl *D) {
1199   VisitNamedDecl(D);
1200   Record.AddSourceLocation(D->getUsingLoc());
1201   Record.AddNestedNameSpecifierLoc(D->getQualifierLoc());
1202   Record.AddDeclarationNameLoc(D->DNLoc, D->getDeclName());
1203   Record.AddDeclRef(D->FirstUsingShadow.getPointer());
1204   Record.push_back(D->hasTypename());
1205   Record.AddDeclRef(Context.getInstantiatedFromUsingDecl(D));
1206   Code = serialization::DECL_USING;
1207 }
1208 
VisitUsingPackDecl(UsingPackDecl * D)1209 void ASTDeclWriter::VisitUsingPackDecl(UsingPackDecl *D) {
1210   Record.push_back(D->NumExpansions);
1211   VisitNamedDecl(D);
1212   Record.AddDeclRef(D->getInstantiatedFromUsingDecl());
1213   for (auto *E : D->expansions())
1214     Record.AddDeclRef(E);
1215   Code = serialization::DECL_USING_PACK;
1216 }
1217 
VisitUsingShadowDecl(UsingShadowDecl * D)1218 void ASTDeclWriter::VisitUsingShadowDecl(UsingShadowDecl *D) {
1219   VisitRedeclarable(D);
1220   VisitNamedDecl(D);
1221   Record.AddDeclRef(D->getTargetDecl());
1222   Record.push_back(D->getIdentifierNamespace());
1223   Record.AddDeclRef(D->UsingOrNextShadow);
1224   Record.AddDeclRef(Context.getInstantiatedFromUsingShadowDecl(D));
1225   Code = serialization::DECL_USING_SHADOW;
1226 }
1227 
VisitConstructorUsingShadowDecl(ConstructorUsingShadowDecl * D)1228 void ASTDeclWriter::VisitConstructorUsingShadowDecl(
1229     ConstructorUsingShadowDecl *D) {
1230   VisitUsingShadowDecl(D);
1231   Record.AddDeclRef(D->NominatedBaseClassShadowDecl);
1232   Record.AddDeclRef(D->ConstructedBaseClassShadowDecl);
1233   Record.push_back(D->IsVirtual);
1234   Code = serialization::DECL_CONSTRUCTOR_USING_SHADOW;
1235 }
1236 
VisitUsingDirectiveDecl(UsingDirectiveDecl * D)1237 void ASTDeclWriter::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
1238   VisitNamedDecl(D);
1239   Record.AddSourceLocation(D->getUsingLoc());
1240   Record.AddSourceLocation(D->getNamespaceKeyLocation());
1241   Record.AddNestedNameSpecifierLoc(D->getQualifierLoc());
1242   Record.AddDeclRef(D->getNominatedNamespace());
1243   Record.AddDeclRef(dyn_cast<Decl>(D->getCommonAncestor()));
1244   Code = serialization::DECL_USING_DIRECTIVE;
1245 }
1246 
VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl * D)1247 void ASTDeclWriter::VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) {
1248   VisitValueDecl(D);
1249   Record.AddSourceLocation(D->getUsingLoc());
1250   Record.AddNestedNameSpecifierLoc(D->getQualifierLoc());
1251   Record.AddDeclarationNameLoc(D->DNLoc, D->getDeclName());
1252   Record.AddSourceLocation(D->getEllipsisLoc());
1253   Code = serialization::DECL_UNRESOLVED_USING_VALUE;
1254 }
1255 
VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl * D)1256 void ASTDeclWriter::VisitUnresolvedUsingTypenameDecl(
1257                                                UnresolvedUsingTypenameDecl *D) {
1258   VisitTypeDecl(D);
1259   Record.AddSourceLocation(D->getTypenameLoc());
1260   Record.AddNestedNameSpecifierLoc(D->getQualifierLoc());
1261   Record.AddSourceLocation(D->getEllipsisLoc());
1262   Code = serialization::DECL_UNRESOLVED_USING_TYPENAME;
1263 }
1264 
VisitCXXRecordDecl(CXXRecordDecl * D)1265 void ASTDeclWriter::VisitCXXRecordDecl(CXXRecordDecl *D) {
1266   VisitRecordDecl(D);
1267 
1268   enum {
1269     CXXRecNotTemplate = 0, CXXRecTemplate, CXXRecMemberSpecialization
1270   };
1271   if (ClassTemplateDecl *TemplD = D->getDescribedClassTemplate()) {
1272     Record.push_back(CXXRecTemplate);
1273     Record.AddDeclRef(TemplD);
1274   } else if (MemberSpecializationInfo *MSInfo
1275                = D->getMemberSpecializationInfo()) {
1276     Record.push_back(CXXRecMemberSpecialization);
1277     Record.AddDeclRef(MSInfo->getInstantiatedFrom());
1278     Record.push_back(MSInfo->getTemplateSpecializationKind());
1279     Record.AddSourceLocation(MSInfo->getPointOfInstantiation());
1280   } else {
1281     Record.push_back(CXXRecNotTemplate);
1282   }
1283 
1284   Record.push_back(D->isThisDeclarationADefinition());
1285   if (D->isThisDeclarationADefinition())
1286     Record.AddCXXDefinitionData(D);
1287 
1288   // Store (what we currently believe to be) the key function to avoid
1289   // deserializing every method so we can compute it.
1290   if (D->isCompleteDefinition())
1291     Record.AddDeclRef(Context.getCurrentKeyFunction(D));
1292 
1293   Code = serialization::DECL_CXX_RECORD;
1294 }
1295 
VisitCXXMethodDecl(CXXMethodDecl * D)1296 void ASTDeclWriter::VisitCXXMethodDecl(CXXMethodDecl *D) {
1297   VisitFunctionDecl(D);
1298   if (D->isCanonicalDecl()) {
1299     Record.push_back(D->size_overridden_methods());
1300     for (const CXXMethodDecl *MD : D->overridden_methods())
1301       Record.AddDeclRef(MD);
1302   } else {
1303     // We only need to record overridden methods once for the canonical decl.
1304     Record.push_back(0);
1305   }
1306 
1307   if (D->getDeclContext() == D->getLexicalDeclContext() &&
1308       D->getFirstDecl() == D->getMostRecentDecl() &&
1309       !D->isInvalidDecl() &&
1310       !D->hasAttrs() &&
1311       !D->isTopLevelDeclInObjCContainer() &&
1312       D->getDeclName().getNameKind() == DeclarationName::Identifier &&
1313       !D->hasExtInfo() &&
1314       !D->hasInheritedPrototype() &&
1315       D->hasWrittenPrototype())
1316     AbbrevToUse = Writer.getDeclCXXMethodAbbrev();
1317 
1318   Code = serialization::DECL_CXX_METHOD;
1319 }
1320 
VisitCXXConstructorDecl(CXXConstructorDecl * D)1321 void ASTDeclWriter::VisitCXXConstructorDecl(CXXConstructorDecl *D) {
1322   if (auto Inherited = D->getInheritedConstructor()) {
1323     Record.AddDeclRef(Inherited.getShadowDecl());
1324     Record.AddDeclRef(Inherited.getConstructor());
1325     Code = serialization::DECL_CXX_INHERITED_CONSTRUCTOR;
1326   } else {
1327     Code = serialization::DECL_CXX_CONSTRUCTOR;
1328   }
1329 
1330   VisitCXXMethodDecl(D);
1331 
1332   Code = D->isInheritingConstructor()
1333              ? serialization::DECL_CXX_INHERITED_CONSTRUCTOR
1334              : serialization::DECL_CXX_CONSTRUCTOR;
1335 }
1336 
VisitCXXDestructorDecl(CXXDestructorDecl * D)1337 void ASTDeclWriter::VisitCXXDestructorDecl(CXXDestructorDecl *D) {
1338   VisitCXXMethodDecl(D);
1339 
1340   Record.AddDeclRef(D->getOperatorDelete());
1341   if (D->getOperatorDelete())
1342     Record.AddStmt(D->getOperatorDeleteThisArg());
1343 
1344   Code = serialization::DECL_CXX_DESTRUCTOR;
1345 }
1346 
VisitCXXConversionDecl(CXXConversionDecl * D)1347 void ASTDeclWriter::VisitCXXConversionDecl(CXXConversionDecl *D) {
1348   VisitCXXMethodDecl(D);
1349   Code = serialization::DECL_CXX_CONVERSION;
1350 }
1351 
VisitImportDecl(ImportDecl * D)1352 void ASTDeclWriter::VisitImportDecl(ImportDecl *D) {
1353   VisitDecl(D);
1354   Record.push_back(Writer.getSubmoduleID(D->getImportedModule()));
1355   ArrayRef<SourceLocation> IdentifierLocs = D->getIdentifierLocs();
1356   Record.push_back(!IdentifierLocs.empty());
1357   if (IdentifierLocs.empty()) {
1358     Record.AddSourceLocation(D->getEndLoc());
1359     Record.push_back(1);
1360   } else {
1361     for (unsigned I = 0, N = IdentifierLocs.size(); I != N; ++I)
1362       Record.AddSourceLocation(IdentifierLocs[I]);
1363     Record.push_back(IdentifierLocs.size());
1364   }
1365   // Note: the number of source locations must always be the last element in
1366   // the record.
1367   Code = serialization::DECL_IMPORT;
1368 }
1369 
VisitAccessSpecDecl(AccessSpecDecl * D)1370 void ASTDeclWriter::VisitAccessSpecDecl(AccessSpecDecl *D) {
1371   VisitDecl(D);
1372   Record.AddSourceLocation(D->getColonLoc());
1373   Code = serialization::DECL_ACCESS_SPEC;
1374 }
1375 
VisitFriendDecl(FriendDecl * D)1376 void ASTDeclWriter::VisitFriendDecl(FriendDecl *D) {
1377   // Record the number of friend type template parameter lists here
1378   // so as to simplify memory allocation during deserialization.
1379   Record.push_back(D->NumTPLists);
1380   VisitDecl(D);
1381   bool hasFriendDecl = D->Friend.is<NamedDecl*>();
1382   Record.push_back(hasFriendDecl);
1383   if (hasFriendDecl)
1384     Record.AddDeclRef(D->getFriendDecl());
1385   else
1386     Record.AddTypeSourceInfo(D->getFriendType());
1387   for (unsigned i = 0; i < D->NumTPLists; ++i)
1388     Record.AddTemplateParameterList(D->getFriendTypeTemplateParameterList(i));
1389   Record.AddDeclRef(D->getNextFriend());
1390   Record.push_back(D->UnsupportedFriend);
1391   Record.AddSourceLocation(D->FriendLoc);
1392   Code = serialization::DECL_FRIEND;
1393 }
1394 
VisitFriendTemplateDecl(FriendTemplateDecl * D)1395 void ASTDeclWriter::VisitFriendTemplateDecl(FriendTemplateDecl *D) {
1396   VisitDecl(D);
1397   Record.push_back(D->getNumTemplateParameters());
1398   for (unsigned i = 0, e = D->getNumTemplateParameters(); i != e; ++i)
1399     Record.AddTemplateParameterList(D->getTemplateParameterList(i));
1400   Record.push_back(D->getFriendDecl() != nullptr);
1401   if (D->getFriendDecl())
1402     Record.AddDeclRef(D->getFriendDecl());
1403   else
1404     Record.AddTypeSourceInfo(D->getFriendType());
1405   Record.AddSourceLocation(D->getFriendLoc());
1406   Code = serialization::DECL_FRIEND_TEMPLATE;
1407 }
1408 
VisitTemplateDecl(TemplateDecl * D)1409 void ASTDeclWriter::VisitTemplateDecl(TemplateDecl *D) {
1410   VisitNamedDecl(D);
1411 
1412   Record.AddDeclRef(D->getTemplatedDecl());
1413   Record.AddTemplateParameterList(D->getTemplateParameters());
1414 }
1415 
VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl * D)1416 void ASTDeclWriter::VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D) {
1417   VisitRedeclarable(D);
1418 
1419   // Emit data to initialize CommonOrPrev before VisitTemplateDecl so that
1420   // getCommonPtr() can be used while this is still initializing.
1421   if (D->isFirstDecl()) {
1422     // This declaration owns the 'common' pointer, so serialize that data now.
1423     Record.AddDeclRef(D->getInstantiatedFromMemberTemplate());
1424     if (D->getInstantiatedFromMemberTemplate())
1425       Record.push_back(D->isMemberSpecialization());
1426   }
1427 
1428   VisitTemplateDecl(D);
1429   Record.push_back(D->getIdentifierNamespace());
1430 }
1431 
VisitClassTemplateDecl(ClassTemplateDecl * D)1432 void ASTDeclWriter::VisitClassTemplateDecl(ClassTemplateDecl *D) {
1433   VisitRedeclarableTemplateDecl(D);
1434 
1435   if (D->isFirstDecl())
1436     AddTemplateSpecializations(D);
1437   Code = serialization::DECL_CLASS_TEMPLATE;
1438 }
1439 
VisitClassTemplateSpecializationDecl(ClassTemplateSpecializationDecl * D)1440 void ASTDeclWriter::VisitClassTemplateSpecializationDecl(
1441                                            ClassTemplateSpecializationDecl *D) {
1442   RegisterTemplateSpecialization(D->getSpecializedTemplate(), D);
1443 
1444   VisitCXXRecordDecl(D);
1445 
1446   llvm::PointerUnion<ClassTemplateDecl *,
1447                      ClassTemplatePartialSpecializationDecl *> InstFrom
1448     = D->getSpecializedTemplateOrPartial();
1449   if (Decl *InstFromD = InstFrom.dyn_cast<ClassTemplateDecl *>()) {
1450     Record.AddDeclRef(InstFromD);
1451   } else {
1452     Record.AddDeclRef(InstFrom.get<ClassTemplatePartialSpecializationDecl *>());
1453     Record.AddTemplateArgumentList(&D->getTemplateInstantiationArgs());
1454   }
1455 
1456   Record.AddTemplateArgumentList(&D->getTemplateArgs());
1457   Record.AddSourceLocation(D->getPointOfInstantiation());
1458   Record.push_back(D->getSpecializationKind());
1459   Record.push_back(D->isCanonicalDecl());
1460 
1461   if (D->isCanonicalDecl()) {
1462     // When reading, we'll add it to the folding set of the following template.
1463     Record.AddDeclRef(D->getSpecializedTemplate()->getCanonicalDecl());
1464   }
1465 
1466   // Explicit info.
1467   Record.AddTypeSourceInfo(D->getTypeAsWritten());
1468   if (D->getTypeAsWritten()) {
1469     Record.AddSourceLocation(D->getExternLoc());
1470     Record.AddSourceLocation(D->getTemplateKeywordLoc());
1471   }
1472 
1473   Code = serialization::DECL_CLASS_TEMPLATE_SPECIALIZATION;
1474 }
1475 
VisitClassTemplatePartialSpecializationDecl(ClassTemplatePartialSpecializationDecl * D)1476 void ASTDeclWriter::VisitClassTemplatePartialSpecializationDecl(
1477                                     ClassTemplatePartialSpecializationDecl *D) {
1478   VisitClassTemplateSpecializationDecl(D);
1479 
1480   Record.AddTemplateParameterList(D->getTemplateParameters());
1481   Record.AddASTTemplateArgumentListInfo(D->getTemplateArgsAsWritten());
1482 
1483   // These are read/set from/to the first declaration.
1484   if (D->getPreviousDecl() == nullptr) {
1485     Record.AddDeclRef(D->getInstantiatedFromMember());
1486     Record.push_back(D->isMemberSpecialization());
1487   }
1488 
1489   Code = serialization::DECL_CLASS_TEMPLATE_PARTIAL_SPECIALIZATION;
1490 }
1491 
VisitVarTemplateDecl(VarTemplateDecl * D)1492 void ASTDeclWriter::VisitVarTemplateDecl(VarTemplateDecl *D) {
1493   VisitRedeclarableTemplateDecl(D);
1494 
1495   if (D->isFirstDecl())
1496     AddTemplateSpecializations(D);
1497   Code = serialization::DECL_VAR_TEMPLATE;
1498 }
1499 
VisitVarTemplateSpecializationDecl(VarTemplateSpecializationDecl * D)1500 void ASTDeclWriter::VisitVarTemplateSpecializationDecl(
1501     VarTemplateSpecializationDecl *D) {
1502   RegisterTemplateSpecialization(D->getSpecializedTemplate(), D);
1503 
1504   VisitVarDecl(D);
1505 
1506   llvm::PointerUnion<VarTemplateDecl *, VarTemplatePartialSpecializationDecl *>
1507   InstFrom = D->getSpecializedTemplateOrPartial();
1508   if (Decl *InstFromD = InstFrom.dyn_cast<VarTemplateDecl *>()) {
1509     Record.AddDeclRef(InstFromD);
1510   } else {
1511     Record.AddDeclRef(InstFrom.get<VarTemplatePartialSpecializationDecl *>());
1512     Record.AddTemplateArgumentList(&D->getTemplateInstantiationArgs());
1513   }
1514 
1515   // Explicit info.
1516   Record.AddTypeSourceInfo(D->getTypeAsWritten());
1517   if (D->getTypeAsWritten()) {
1518     Record.AddSourceLocation(D->getExternLoc());
1519     Record.AddSourceLocation(D->getTemplateKeywordLoc());
1520   }
1521 
1522   Record.AddTemplateArgumentList(&D->getTemplateArgs());
1523   Record.AddSourceLocation(D->getPointOfInstantiation());
1524   Record.push_back(D->getSpecializationKind());
1525   Record.push_back(D->IsCompleteDefinition);
1526   Record.push_back(D->isCanonicalDecl());
1527 
1528   if (D->isCanonicalDecl()) {
1529     // When reading, we'll add it to the folding set of the following template.
1530     Record.AddDeclRef(D->getSpecializedTemplate()->getCanonicalDecl());
1531   }
1532 
1533   Code = serialization::DECL_VAR_TEMPLATE_SPECIALIZATION;
1534 }
1535 
VisitVarTemplatePartialSpecializationDecl(VarTemplatePartialSpecializationDecl * D)1536 void ASTDeclWriter::VisitVarTemplatePartialSpecializationDecl(
1537     VarTemplatePartialSpecializationDecl *D) {
1538   VisitVarTemplateSpecializationDecl(D);
1539 
1540   Record.AddTemplateParameterList(D->getTemplateParameters());
1541   Record.AddASTTemplateArgumentListInfo(D->getTemplateArgsAsWritten());
1542 
1543   // These are read/set from/to the first declaration.
1544   if (D->getPreviousDecl() == nullptr) {
1545     Record.AddDeclRef(D->getInstantiatedFromMember());
1546     Record.push_back(D->isMemberSpecialization());
1547   }
1548 
1549   Code = serialization::DECL_VAR_TEMPLATE_PARTIAL_SPECIALIZATION;
1550 }
1551 
VisitClassScopeFunctionSpecializationDecl(ClassScopeFunctionSpecializationDecl * D)1552 void ASTDeclWriter::VisitClassScopeFunctionSpecializationDecl(
1553                                     ClassScopeFunctionSpecializationDecl *D) {
1554   VisitDecl(D);
1555   Record.AddDeclRef(D->getSpecialization());
1556   Code = serialization::DECL_CLASS_SCOPE_FUNCTION_SPECIALIZATION;
1557 }
1558 
1559 
VisitFunctionTemplateDecl(FunctionTemplateDecl * D)1560 void ASTDeclWriter::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
1561   VisitRedeclarableTemplateDecl(D);
1562 
1563   if (D->isFirstDecl())
1564     AddTemplateSpecializations(D);
1565   Code = serialization::DECL_FUNCTION_TEMPLATE;
1566 }
1567 
VisitTemplateTypeParmDecl(TemplateTypeParmDecl * D)1568 void ASTDeclWriter::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
1569   VisitTypeDecl(D);
1570 
1571   Record.push_back(D->wasDeclaredWithTypename());
1572 
1573   bool OwnsDefaultArg = D->hasDefaultArgument() &&
1574                         !D->defaultArgumentWasInherited();
1575   Record.push_back(OwnsDefaultArg);
1576   if (OwnsDefaultArg)
1577     Record.AddTypeSourceInfo(D->getDefaultArgumentInfo());
1578 
1579   Code = serialization::DECL_TEMPLATE_TYPE_PARM;
1580 }
1581 
VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl * D)1582 void ASTDeclWriter::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) {
1583   // For an expanded parameter pack, record the number of expansion types here
1584   // so that it's easier for deserialization to allocate the right amount of
1585   // memory.
1586   if (D->isExpandedParameterPack())
1587     Record.push_back(D->getNumExpansionTypes());
1588 
1589   VisitDeclaratorDecl(D);
1590   // TemplateParmPosition.
1591   Record.push_back(D->getDepth());
1592   Record.push_back(D->getPosition());
1593 
1594   if (D->isExpandedParameterPack()) {
1595     for (unsigned I = 0, N = D->getNumExpansionTypes(); I != N; ++I) {
1596       Record.AddTypeRef(D->getExpansionType(I));
1597       Record.AddTypeSourceInfo(D->getExpansionTypeSourceInfo(I));
1598     }
1599 
1600     Code = serialization::DECL_EXPANDED_NON_TYPE_TEMPLATE_PARM_PACK;
1601   } else {
1602     // Rest of NonTypeTemplateParmDecl.
1603     Record.push_back(D->isParameterPack());
1604     bool OwnsDefaultArg = D->hasDefaultArgument() &&
1605                           !D->defaultArgumentWasInherited();
1606     Record.push_back(OwnsDefaultArg);
1607     if (OwnsDefaultArg)
1608       Record.AddStmt(D->getDefaultArgument());
1609     Code = serialization::DECL_NON_TYPE_TEMPLATE_PARM;
1610   }
1611 }
1612 
VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl * D)1613 void ASTDeclWriter::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) {
1614   // For an expanded parameter pack, record the number of expansion types here
1615   // so that it's easier for deserialization to allocate the right amount of
1616   // memory.
1617   if (D->isExpandedParameterPack())
1618     Record.push_back(D->getNumExpansionTemplateParameters());
1619 
1620   VisitTemplateDecl(D);
1621   // TemplateParmPosition.
1622   Record.push_back(D->getDepth());
1623   Record.push_back(D->getPosition());
1624 
1625   if (D->isExpandedParameterPack()) {
1626     for (unsigned I = 0, N = D->getNumExpansionTemplateParameters();
1627          I != N; ++I)
1628       Record.AddTemplateParameterList(D->getExpansionTemplateParameters(I));
1629     Code = serialization::DECL_EXPANDED_TEMPLATE_TEMPLATE_PARM_PACK;
1630   } else {
1631     // Rest of TemplateTemplateParmDecl.
1632     Record.push_back(D->isParameterPack());
1633     bool OwnsDefaultArg = D->hasDefaultArgument() &&
1634                           !D->defaultArgumentWasInherited();
1635     Record.push_back(OwnsDefaultArg);
1636     if (OwnsDefaultArg)
1637       Record.AddTemplateArgumentLoc(D->getDefaultArgument());
1638     Code = serialization::DECL_TEMPLATE_TEMPLATE_PARM;
1639   }
1640 }
1641 
VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl * D)1642 void ASTDeclWriter::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) {
1643   VisitRedeclarableTemplateDecl(D);
1644   Code = serialization::DECL_TYPE_ALIAS_TEMPLATE;
1645 }
1646 
VisitStaticAssertDecl(StaticAssertDecl * D)1647 void ASTDeclWriter::VisitStaticAssertDecl(StaticAssertDecl *D) {
1648   VisitDecl(D);
1649   Record.AddStmt(D->getAssertExpr());
1650   Record.push_back(D->isFailed());
1651   Record.AddStmt(D->getMessage());
1652   Record.AddSourceLocation(D->getRParenLoc());
1653   Code = serialization::DECL_STATIC_ASSERT;
1654 }
1655 
1656 /// Emit the DeclContext part of a declaration context decl.
VisitDeclContext(DeclContext * DC)1657 void ASTDeclWriter::VisitDeclContext(DeclContext *DC) {
1658   Record.AddOffset(Writer.WriteDeclContextLexicalBlock(Context, DC));
1659   Record.AddOffset(Writer.WriteDeclContextVisibleBlock(Context, DC));
1660 }
1661 
getFirstLocalDecl(const Decl * D)1662 const Decl *ASTWriter::getFirstLocalDecl(const Decl *D) {
1663   assert(IsLocalDecl(D) && "expected a local declaration");
1664 
1665   const Decl *Canon = D->getCanonicalDecl();
1666   if (IsLocalDecl(Canon))
1667     return Canon;
1668 
1669   const Decl *&CacheEntry = FirstLocalDeclCache[Canon];
1670   if (CacheEntry)
1671     return CacheEntry;
1672 
1673   for (const Decl *Redecl = D; Redecl; Redecl = Redecl->getPreviousDecl())
1674     if (IsLocalDecl(Redecl))
1675       D = Redecl;
1676   return CacheEntry = D;
1677 }
1678 
1679 template <typename T>
VisitRedeclarable(Redeclarable<T> * D)1680 void ASTDeclWriter::VisitRedeclarable(Redeclarable<T> *D) {
1681   T *First = D->getFirstDecl();
1682   T *MostRecent = First->getMostRecentDecl();
1683   T *DAsT = static_cast<T *>(D);
1684   if (MostRecent != First) {
1685     assert(isRedeclarableDeclKind(DAsT->getKind()) &&
1686            "Not considered redeclarable?");
1687 
1688     Record.AddDeclRef(First);
1689 
1690     // Write out a list of local redeclarations of this declaration if it's the
1691     // first local declaration in the chain.
1692     const Decl *FirstLocal = Writer.getFirstLocalDecl(DAsT);
1693     if (DAsT == FirstLocal) {
1694       // Emit a list of all imported first declarations so that we can be sure
1695       // that all redeclarations visible to this module are before D in the
1696       // redecl chain.
1697       unsigned I = Record.size();
1698       Record.push_back(0);
1699       if (Writer.Chain)
1700         AddFirstDeclFromEachModule(DAsT, /*IncludeLocal*/false);
1701       // This is the number of imported first declarations + 1.
1702       Record[I] = Record.size() - I;
1703 
1704       // Collect the set of local redeclarations of this declaration, from
1705       // newest to oldest.
1706       ASTWriter::RecordData LocalRedecls;
1707       ASTRecordWriter LocalRedeclWriter(Record, LocalRedecls);
1708       for (const Decl *Prev = FirstLocal->getMostRecentDecl();
1709            Prev != FirstLocal; Prev = Prev->getPreviousDecl())
1710         if (!Prev->isFromASTFile())
1711           LocalRedeclWriter.AddDeclRef(Prev);
1712 
1713       // If we have any redecls, write them now as a separate record preceding
1714       // the declaration itself.
1715       if (LocalRedecls.empty())
1716         Record.push_back(0);
1717       else
1718         Record.AddOffset(LocalRedeclWriter.Emit(LOCAL_REDECLARATIONS));
1719     } else {
1720       Record.push_back(0);
1721       Record.AddDeclRef(FirstLocal);
1722     }
1723 
1724     // Make sure that we serialize both the previous and the most-recent
1725     // declarations, which (transitively) ensures that all declarations in the
1726     // chain get serialized.
1727     //
1728     // FIXME: This is not correct; when we reach an imported declaration we
1729     // won't emit its previous declaration.
1730     (void)Writer.GetDeclRef(D->getPreviousDecl());
1731     (void)Writer.GetDeclRef(MostRecent);
1732   } else {
1733     // We use the sentinel value 0 to indicate an only declaration.
1734     Record.push_back(0);
1735   }
1736 }
1737 
VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl * D)1738 void ASTDeclWriter::VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D) {
1739   Record.push_back(D->varlist_size());
1740   VisitDecl(D);
1741   for (auto *I : D->varlists())
1742     Record.AddStmt(I);
1743   Code = serialization::DECL_OMP_THREADPRIVATE;
1744 }
1745 
VisitOMPRequiresDecl(OMPRequiresDecl * D)1746 void ASTDeclWriter::VisitOMPRequiresDecl(OMPRequiresDecl *D) {
1747   Record.push_back(D->clauselist_size());
1748   VisitDecl(D);
1749   OMPClauseWriter ClauseWriter(Record);
1750   for (OMPClause *C : D->clauselists())
1751     ClauseWriter.writeClause(C);
1752   Code = serialization::DECL_OMP_REQUIRES;
1753 }
1754 
VisitOMPDeclareReductionDecl(OMPDeclareReductionDecl * D)1755 void ASTDeclWriter::VisitOMPDeclareReductionDecl(OMPDeclareReductionDecl *D) {
1756   VisitValueDecl(D);
1757   Record.AddSourceLocation(D->getBeginLoc());
1758   Record.AddStmt(D->getCombinerIn());
1759   Record.AddStmt(D->getCombinerOut());
1760   Record.AddStmt(D->getCombiner());
1761   Record.AddStmt(D->getInitOrig());
1762   Record.AddStmt(D->getInitPriv());
1763   Record.AddStmt(D->getInitializer());
1764   Record.push_back(D->getInitializerKind());
1765   Record.AddDeclRef(D->getPrevDeclInScope());
1766   Code = serialization::DECL_OMP_DECLARE_REDUCTION;
1767 }
1768 
VisitOMPCapturedExprDecl(OMPCapturedExprDecl * D)1769 void ASTDeclWriter::VisitOMPCapturedExprDecl(OMPCapturedExprDecl *D) {
1770   VisitVarDecl(D);
1771   Code = serialization::DECL_OMP_CAPTUREDEXPR;
1772 }
1773 
1774 //===----------------------------------------------------------------------===//
1775 // ASTWriter Implementation
1776 //===----------------------------------------------------------------------===//
1777 
WriteDeclAbbrevs()1778 void ASTWriter::WriteDeclAbbrevs() {
1779   using namespace llvm;
1780 
1781   std::shared_ptr<BitCodeAbbrev> Abv;
1782 
1783   // Abbreviation for DECL_FIELD
1784   Abv = std::make_shared<BitCodeAbbrev>();
1785   Abv->Add(BitCodeAbbrevOp(serialization::DECL_FIELD));
1786   // Decl
1787   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
1788   Abv->Add(BitCodeAbbrevOp(0));                       // LexicalDeclContext
1789   Abv->Add(BitCodeAbbrevOp(0));                       // isInvalidDecl
1790   Abv->Add(BitCodeAbbrevOp(0));                       // HasAttrs
1791   Abv->Add(BitCodeAbbrevOp(0));                       // isImplicit
1792   Abv->Add(BitCodeAbbrevOp(0));                       // isUsed
1793   Abv->Add(BitCodeAbbrevOp(0));                       // isReferenced
1794   Abv->Add(BitCodeAbbrevOp(0));                   // TopLevelDeclInObjCContainer
1795   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2));  // AccessSpecifier
1796   Abv->Add(BitCodeAbbrevOp(0));                       // ModulePrivate
1797   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
1798   // NamedDecl
1799   Abv->Add(BitCodeAbbrevOp(0));                       // NameKind = Identifier
1800   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
1801   Abv->Add(BitCodeAbbrevOp(0));                       // AnonDeclNumber
1802   // ValueDecl
1803   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
1804   // DeclaratorDecl
1805   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerStartLoc
1806   Abv->Add(BitCodeAbbrevOp(0));                       // hasExtInfo
1807   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TSIType
1808   // FieldDecl
1809   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isMutable
1810   Abv->Add(BitCodeAbbrevOp(0));                       // InitStyle
1811   // Type Source Info
1812   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
1813   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc
1814   DeclFieldAbbrev = Stream.EmitAbbrev(std::move(Abv));
1815 
1816   // Abbreviation for DECL_OBJC_IVAR
1817   Abv = std::make_shared<BitCodeAbbrev>();
1818   Abv->Add(BitCodeAbbrevOp(serialization::DECL_OBJC_IVAR));
1819   // Decl
1820   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
1821   Abv->Add(BitCodeAbbrevOp(0));                       // LexicalDeclContext
1822   Abv->Add(BitCodeAbbrevOp(0));                       // isInvalidDecl
1823   Abv->Add(BitCodeAbbrevOp(0));                       // HasAttrs
1824   Abv->Add(BitCodeAbbrevOp(0));                       // isImplicit
1825   Abv->Add(BitCodeAbbrevOp(0));                       // isUsed
1826   Abv->Add(BitCodeAbbrevOp(0));                       // isReferenced
1827   Abv->Add(BitCodeAbbrevOp(0));                   // TopLevelDeclInObjCContainer
1828   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2));  // AccessSpecifier
1829   Abv->Add(BitCodeAbbrevOp(0));                       // ModulePrivate
1830   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
1831   // NamedDecl
1832   Abv->Add(BitCodeAbbrevOp(0));                       // NameKind = Identifier
1833   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
1834   Abv->Add(BitCodeAbbrevOp(0));                       // AnonDeclNumber
1835   // ValueDecl
1836   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
1837   // DeclaratorDecl
1838   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerStartLoc
1839   Abv->Add(BitCodeAbbrevOp(0));                       // hasExtInfo
1840   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TSIType
1841   // FieldDecl
1842   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isMutable
1843   Abv->Add(BitCodeAbbrevOp(0));                       // InitStyle
1844   // ObjC Ivar
1845   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getAccessControl
1846   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getSynthesize
1847   // Type Source Info
1848   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
1849   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc
1850   DeclObjCIvarAbbrev = Stream.EmitAbbrev(std::move(Abv));
1851 
1852   // Abbreviation for DECL_ENUM
1853   Abv = std::make_shared<BitCodeAbbrev>();
1854   Abv->Add(BitCodeAbbrevOp(serialization::DECL_ENUM));
1855   // Redeclarable
1856   Abv->Add(BitCodeAbbrevOp(0));                       // No redeclaration
1857   // Decl
1858   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
1859   Abv->Add(BitCodeAbbrevOp(0));                       // LexicalDeclContext
1860   Abv->Add(BitCodeAbbrevOp(0));                       // isInvalidDecl
1861   Abv->Add(BitCodeAbbrevOp(0));                       // HasAttrs
1862   Abv->Add(BitCodeAbbrevOp(0));                       // isImplicit
1863   Abv->Add(BitCodeAbbrevOp(0));                       // isUsed
1864   Abv->Add(BitCodeAbbrevOp(0));                       // isReferenced
1865   Abv->Add(BitCodeAbbrevOp(0));                   // TopLevelDeclInObjCContainer
1866   Abv->Add(BitCodeAbbrevOp(AS_none));                 // C++ AccessSpecifier
1867   Abv->Add(BitCodeAbbrevOp(0));                       // ModulePrivate
1868   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
1869   // NamedDecl
1870   Abv->Add(BitCodeAbbrevOp(0));                       // NameKind = Identifier
1871   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
1872   Abv->Add(BitCodeAbbrevOp(0));                       // AnonDeclNumber
1873   // TypeDecl
1874   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Source Location
1875   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type Ref
1876   // TagDecl
1877   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // IdentifierNamespace
1878   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // getTagKind
1879   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isCompleteDefinition
1880   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // EmbeddedInDeclarator
1881   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsFreeStanding
1882   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsCompleteDefinitionRequired
1883   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // SourceLocation
1884   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // SourceLocation
1885   Abv->Add(BitCodeAbbrevOp(0));                         // ExtInfoKind
1886   // EnumDecl
1887   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // AddTypeRef
1888   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // IntegerType
1889   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // getPromotionType
1890   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // getNumPositiveBits
1891   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // getNumNegativeBits
1892   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isScoped
1893   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isScopedUsingClassTag
1894   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isFixed
1895   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));// ODRHash
1896   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // InstantiatedMembEnum
1897   // DC
1898   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // LexicalOffset
1899   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // VisibleOffset
1900   DeclEnumAbbrev = Stream.EmitAbbrev(std::move(Abv));
1901 
1902   // Abbreviation for DECL_RECORD
1903   Abv = std::make_shared<BitCodeAbbrev>();
1904   Abv->Add(BitCodeAbbrevOp(serialization::DECL_RECORD));
1905   // Redeclarable
1906   Abv->Add(BitCodeAbbrevOp(0));                       // No redeclaration
1907   // Decl
1908   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
1909   Abv->Add(BitCodeAbbrevOp(0));                       // LexicalDeclContext
1910   Abv->Add(BitCodeAbbrevOp(0));                       // isInvalidDecl
1911   Abv->Add(BitCodeAbbrevOp(0));                       // HasAttrs
1912   Abv->Add(BitCodeAbbrevOp(0));                       // isImplicit
1913   Abv->Add(BitCodeAbbrevOp(0));                       // isUsed
1914   Abv->Add(BitCodeAbbrevOp(0));                       // isReferenced
1915   Abv->Add(BitCodeAbbrevOp(0));                   // TopLevelDeclInObjCContainer
1916   Abv->Add(BitCodeAbbrevOp(AS_none));                 // C++ AccessSpecifier
1917   Abv->Add(BitCodeAbbrevOp(0));                       // ModulePrivate
1918   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
1919   // NamedDecl
1920   Abv->Add(BitCodeAbbrevOp(0));                       // NameKind = Identifier
1921   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
1922   Abv->Add(BitCodeAbbrevOp(0));                       // AnonDeclNumber
1923   // TypeDecl
1924   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Source Location
1925   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type Ref
1926   // TagDecl
1927   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // IdentifierNamespace
1928   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // getTagKind
1929   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isCompleteDefinition
1930   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // EmbeddedInDeclarator
1931   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsFreeStanding
1932   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsCompleteDefinitionRequired
1933   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // SourceLocation
1934   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // SourceLocation
1935   Abv->Add(BitCodeAbbrevOp(0));                         // ExtInfoKind
1936   // RecordDecl
1937   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // FlexibleArrayMember
1938   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // AnonymousStructUnion
1939   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // hasObjectMember
1940   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // hasVolatileMember
1941 
1942   // isNonTrivialToPrimitiveDefaultInitialize
1943   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
1944   // isNonTrivialToPrimitiveCopy
1945   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
1946   // isNonTrivialToPrimitiveDestroy
1947   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
1948   // isParamDestroyedInCallee
1949   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
1950   // getArgPassingRestrictions
1951   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2));
1952 
1953   // DC
1954   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // LexicalOffset
1955   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // VisibleOffset
1956   DeclRecordAbbrev = Stream.EmitAbbrev(std::move(Abv));
1957 
1958   // Abbreviation for DECL_PARM_VAR
1959   Abv = std::make_shared<BitCodeAbbrev>();
1960   Abv->Add(BitCodeAbbrevOp(serialization::DECL_PARM_VAR));
1961   // Redeclarable
1962   Abv->Add(BitCodeAbbrevOp(0));                       // No redeclaration
1963   // Decl
1964   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
1965   Abv->Add(BitCodeAbbrevOp(0));                       // LexicalDeclContext
1966   Abv->Add(BitCodeAbbrevOp(0));                       // isInvalidDecl
1967   Abv->Add(BitCodeAbbrevOp(0));                       // HasAttrs
1968   Abv->Add(BitCodeAbbrevOp(0));                       // isImplicit
1969   Abv->Add(BitCodeAbbrevOp(0));                       // isUsed
1970   Abv->Add(BitCodeAbbrevOp(0));                       // isReferenced
1971   Abv->Add(BitCodeAbbrevOp(0));                   // TopLevelDeclInObjCContainer
1972   Abv->Add(BitCodeAbbrevOp(AS_none));                 // C++ AccessSpecifier
1973   Abv->Add(BitCodeAbbrevOp(0));                       // ModulePrivate
1974   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
1975   // NamedDecl
1976   Abv->Add(BitCodeAbbrevOp(0));                       // NameKind = Identifier
1977   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
1978   Abv->Add(BitCodeAbbrevOp(0));                       // AnonDeclNumber
1979   // ValueDecl
1980   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
1981   // DeclaratorDecl
1982   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerStartLoc
1983   Abv->Add(BitCodeAbbrevOp(0));                       // hasExtInfo
1984   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TSIType
1985   // VarDecl
1986   Abv->Add(BitCodeAbbrevOp(0));                       // SClass
1987   Abv->Add(BitCodeAbbrevOp(0));                       // TSCSpec
1988   Abv->Add(BitCodeAbbrevOp(0));                       // InitStyle
1989   Abv->Add(BitCodeAbbrevOp(0));                       // ARCPseudoStrong
1990   Abv->Add(BitCodeAbbrevOp(0));                       // Linkage
1991   Abv->Add(BitCodeAbbrevOp(0));                       // HasInit
1992   Abv->Add(BitCodeAbbrevOp(0));                   // HasMemberSpecializationInfo
1993   // ParmVarDecl
1994   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsObjCMethodParameter
1995   Abv->Add(BitCodeAbbrevOp(0));                       // ScopeDepth
1996   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // ScopeIndex
1997   Abv->Add(BitCodeAbbrevOp(0));                       // ObjCDeclQualifier
1998   Abv->Add(BitCodeAbbrevOp(0));                       // KNRPromoted
1999   Abv->Add(BitCodeAbbrevOp(0));                       // HasInheritedDefaultArg
2000   Abv->Add(BitCodeAbbrevOp(0));                   // HasUninstantiatedDefaultArg
2001   // Type Source Info
2002   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
2003   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc
2004   DeclParmVarAbbrev = Stream.EmitAbbrev(std::move(Abv));
2005 
2006   // Abbreviation for DECL_TYPEDEF
2007   Abv = std::make_shared<BitCodeAbbrev>();
2008   Abv->Add(BitCodeAbbrevOp(serialization::DECL_TYPEDEF));
2009   // Redeclarable
2010   Abv->Add(BitCodeAbbrevOp(0));                       // No redeclaration
2011   // Decl
2012   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
2013   Abv->Add(BitCodeAbbrevOp(0));                       // LexicalDeclContext
2014   Abv->Add(BitCodeAbbrevOp(0));                       // isInvalidDecl
2015   Abv->Add(BitCodeAbbrevOp(0));                       // HasAttrs
2016   Abv->Add(BitCodeAbbrevOp(0));                       // isImplicit
2017   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isUsed
2018   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isReferenced
2019   Abv->Add(BitCodeAbbrevOp(0));                   // TopLevelDeclInObjCContainer
2020   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // C++ AccessSpecifier
2021   Abv->Add(BitCodeAbbrevOp(0));                       // ModulePrivate
2022   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
2023   // NamedDecl
2024   Abv->Add(BitCodeAbbrevOp(0));                       // NameKind = Identifier
2025   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
2026   Abv->Add(BitCodeAbbrevOp(0));                       // AnonDeclNumber
2027   // TypeDecl
2028   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Source Location
2029   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type Ref
2030   // TypedefDecl
2031   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
2032   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc
2033   DeclTypedefAbbrev = Stream.EmitAbbrev(std::move(Abv));
2034 
2035   // Abbreviation for DECL_VAR
2036   Abv = std::make_shared<BitCodeAbbrev>();
2037   Abv->Add(BitCodeAbbrevOp(serialization::DECL_VAR));
2038   // Redeclarable
2039   Abv->Add(BitCodeAbbrevOp(0));                       // No redeclaration
2040   // Decl
2041   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
2042   Abv->Add(BitCodeAbbrevOp(0));                       // LexicalDeclContext
2043   Abv->Add(BitCodeAbbrevOp(0));                       // isInvalidDecl
2044   Abv->Add(BitCodeAbbrevOp(0));                       // HasAttrs
2045   Abv->Add(BitCodeAbbrevOp(0));                       // isImplicit
2046   Abv->Add(BitCodeAbbrevOp(0));                       // isUsed
2047   Abv->Add(BitCodeAbbrevOp(0));                       // isReferenced
2048   Abv->Add(BitCodeAbbrevOp(0));                   // TopLevelDeclInObjCContainer
2049   Abv->Add(BitCodeAbbrevOp(AS_none));                 // C++ AccessSpecifier
2050   Abv->Add(BitCodeAbbrevOp(0));                       // ModulePrivate
2051   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
2052   // NamedDecl
2053   Abv->Add(BitCodeAbbrevOp(0));                       // NameKind = Identifier
2054   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
2055   Abv->Add(BitCodeAbbrevOp(0));                       // AnonDeclNumber
2056   // ValueDecl
2057   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
2058   // DeclaratorDecl
2059   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerStartLoc
2060   Abv->Add(BitCodeAbbrevOp(0));                       // hasExtInfo
2061   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TSIType
2062   // VarDecl
2063   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // SClass
2064   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // TSCSpec
2065   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // InitStyle
2066   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isARCPseudoStrong
2067   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsThisDeclarationADemotedDefinition
2068   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isExceptionVariable
2069   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isNRVOVariable
2070   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isCXXForRangeDecl
2071   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isObjCForDecl
2072   Abv->Add(BitCodeAbbrevOp(0));                         // isInline
2073   Abv->Add(BitCodeAbbrevOp(0));                         // isInlineSpecified
2074   Abv->Add(BitCodeAbbrevOp(0));                         // isConstexpr
2075   Abv->Add(BitCodeAbbrevOp(0));                         // isInitCapture
2076   Abv->Add(BitCodeAbbrevOp(0));                         // isPrevDeclInSameScope
2077   Abv->Add(BitCodeAbbrevOp(0));                         // ImplicitParamKind
2078   Abv->Add(BitCodeAbbrevOp(0));                         // EscapingByref
2079   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // Linkage
2080   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // IsInitICE (local)
2081   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // VarKind (local enum)
2082   // Type Source Info
2083   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
2084   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc
2085   DeclVarAbbrev = Stream.EmitAbbrev(std::move(Abv));
2086 
2087   // Abbreviation for DECL_CXX_METHOD
2088   Abv = std::make_shared<BitCodeAbbrev>();
2089   Abv->Add(BitCodeAbbrevOp(serialization::DECL_CXX_METHOD));
2090   // RedeclarableDecl
2091   Abv->Add(BitCodeAbbrevOp(0));                         // CanonicalDecl
2092   // Decl
2093   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // DeclContext
2094   Abv->Add(BitCodeAbbrevOp(0));                         // LexicalDeclContext
2095   Abv->Add(BitCodeAbbrevOp(0));                         // Invalid
2096   Abv->Add(BitCodeAbbrevOp(0));                         // HasAttrs
2097   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Implicit
2098   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Used
2099   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Referenced
2100   Abv->Add(BitCodeAbbrevOp(0));                         // InObjCContainer
2101   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // Access
2102   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // ModulePrivate
2103   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // SubmoduleID
2104   // NamedDecl
2105   Abv->Add(BitCodeAbbrevOp(DeclarationName::Identifier)); // NameKind
2106   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // Identifier
2107   Abv->Add(BitCodeAbbrevOp(0));                         // AnonDeclNumber
2108   // ValueDecl
2109   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // Type
2110   // DeclaratorDecl
2111   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // InnerLocStart
2112   Abv->Add(BitCodeAbbrevOp(0));                         // HasExtInfo
2113   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // TSIType
2114   // FunctionDecl
2115   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 11)); // IDNS
2116   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // StorageClass
2117   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Inline
2118   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // InlineSpecified
2119   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // ExplicitSpecified
2120   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // VirtualAsWritten
2121   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Pure
2122   Abv->Add(BitCodeAbbrevOp(0));                         // HasInheritedProto
2123   Abv->Add(BitCodeAbbrevOp(1));                         // HasWrittenProto
2124   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Deleted
2125   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Trivial
2126   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // TrivialForCall
2127   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Defaulted
2128   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // ExplicitlyDefaulted
2129   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // ImplicitReturnZero
2130   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Constexpr
2131   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // UsesSEHTry
2132   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // SkippedBody
2133   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // MultiVersion
2134   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // LateParsed
2135   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // Linkage
2136   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // LocEnd
2137   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // ODRHash
2138   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // TemplateKind
2139   // This Array slurps the rest of the record. Fortunately we want to encode
2140   // (nearly) all the remaining (variable number of) fields in the same way.
2141   //
2142   // This is the function template information if any, then
2143   //         NumParams and Params[] from FunctionDecl, and
2144   //         NumOverriddenMethods, OverriddenMethods[] from CXXMethodDecl.
2145   //
2146   //  Add an AbbrevOp for 'size then elements' and use it here.
2147   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
2148   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
2149   DeclCXXMethodAbbrev = Stream.EmitAbbrev(std::move(Abv));
2150 
2151   // Abbreviation for EXPR_DECL_REF
2152   Abv = std::make_shared<BitCodeAbbrev>();
2153   Abv->Add(BitCodeAbbrevOp(serialization::EXPR_DECL_REF));
2154   //Stmt
2155   //Expr
2156   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
2157   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //TypeDependent
2158   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //ValueDependent
2159   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //InstantiationDependent
2160   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //UnexpandedParamPack
2161   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetValueKind
2162   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetObjectKind
2163   //DeclRefExpr
2164   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //HasQualifier
2165   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //GetDeclFound
2166   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //ExplicitTemplateArgs
2167   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //HadMultipleCandidates
2168   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,
2169                            1)); // RefersToEnclosingVariableOrCapture
2170   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclRef
2171   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Location
2172   DeclRefExprAbbrev = Stream.EmitAbbrev(std::move(Abv));
2173 
2174   // Abbreviation for EXPR_INTEGER_LITERAL
2175   Abv = std::make_shared<BitCodeAbbrev>();
2176   Abv->Add(BitCodeAbbrevOp(serialization::EXPR_INTEGER_LITERAL));
2177   //Stmt
2178   //Expr
2179   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
2180   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //TypeDependent
2181   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //ValueDependent
2182   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //InstantiationDependent
2183   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //UnexpandedParamPack
2184   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetValueKind
2185   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetObjectKind
2186   //Integer Literal
2187   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Location
2188   Abv->Add(BitCodeAbbrevOp(32));                      // Bit Width
2189   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Value
2190   IntegerLiteralAbbrev = Stream.EmitAbbrev(std::move(Abv));
2191 
2192   // Abbreviation for EXPR_CHARACTER_LITERAL
2193   Abv = std::make_shared<BitCodeAbbrev>();
2194   Abv->Add(BitCodeAbbrevOp(serialization::EXPR_CHARACTER_LITERAL));
2195   //Stmt
2196   //Expr
2197   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
2198   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //TypeDependent
2199   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //ValueDependent
2200   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //InstantiationDependent
2201   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //UnexpandedParamPack
2202   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetValueKind
2203   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetObjectKind
2204   //Character Literal
2205   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getValue
2206   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Location
2207   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // getKind
2208   CharacterLiteralAbbrev = Stream.EmitAbbrev(std::move(Abv));
2209 
2210   // Abbreviation for EXPR_IMPLICIT_CAST
2211   Abv = std::make_shared<BitCodeAbbrev>();
2212   Abv->Add(BitCodeAbbrevOp(serialization::EXPR_IMPLICIT_CAST));
2213   // Stmt
2214   // Expr
2215   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
2216   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //TypeDependent
2217   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //ValueDependent
2218   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //InstantiationDependent
2219   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //UnexpandedParamPack
2220   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetValueKind
2221   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetObjectKind
2222   // CastExpr
2223   Abv->Add(BitCodeAbbrevOp(0)); // PathSize
2224   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 6)); // CastKind
2225   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // PartOfExplicitCast
2226   // ImplicitCastExpr
2227   ExprImplicitCastAbbrev = Stream.EmitAbbrev(std::move(Abv));
2228 
2229   Abv = std::make_shared<BitCodeAbbrev>();
2230   Abv->Add(BitCodeAbbrevOp(serialization::DECL_CONTEXT_LEXICAL));
2231   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2232   DeclContextLexicalAbbrev = Stream.EmitAbbrev(std::move(Abv));
2233 
2234   Abv = std::make_shared<BitCodeAbbrev>();
2235   Abv->Add(BitCodeAbbrevOp(serialization::DECL_CONTEXT_VISIBLE));
2236   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2237   DeclContextVisibleLookupAbbrev = Stream.EmitAbbrev(std::move(Abv));
2238 }
2239 
2240 /// isRequiredDecl - Check if this is a "required" Decl, which must be seen by
2241 /// consumers of the AST.
2242 ///
2243 /// Such decls will always be deserialized from the AST file, so we would like
2244 /// this to be as restrictive as possible. Currently the predicate is driven by
2245 /// code generation requirements, if other clients have a different notion of
2246 /// what is "required" then we may have to consider an alternate scheme where
2247 /// clients can iterate over the top-level decls and get information on them,
2248 /// without necessary deserializing them. We could explicitly require such
2249 /// clients to use a separate API call to "realize" the decl. This should be
2250 /// relatively painless since they would presumably only do it for top-level
2251 /// decls.
isRequiredDecl(const Decl * D,ASTContext & Context,bool WritingModule)2252 static bool isRequiredDecl(const Decl *D, ASTContext &Context,
2253                            bool WritingModule) {
2254   // An ObjCMethodDecl is never considered as "required" because its
2255   // implementation container always is.
2256 
2257   // File scoped assembly or obj-c or OMP declare target implementation must be
2258   // seen.
2259   if (isa<FileScopeAsmDecl>(D) || isa<ObjCImplDecl>(D))
2260     return true;
2261 
2262   if (WritingModule && (isa<VarDecl>(D) || isa<ImportDecl>(D))) {
2263     // These declarations are part of the module initializer, and are emitted
2264     // if and when the module is imported, rather than being emitted eagerly.
2265     return false;
2266   }
2267 
2268   return Context.DeclMustBeEmitted(D);
2269 }
2270 
WriteDecl(ASTContext & Context,Decl * D)2271 void ASTWriter::WriteDecl(ASTContext &Context, Decl *D) {
2272   PrettyDeclStackTraceEntry CrashInfo(Context, D, SourceLocation(),
2273                                       "serializing");
2274 
2275   // Determine the ID for this declaration.
2276   serialization::DeclID ID;
2277   assert(!D->isFromASTFile() && "should not be emitting imported decl");
2278   serialization::DeclID &IDR = DeclIDs[D];
2279   if (IDR == 0)
2280     IDR = NextDeclID++;
2281 
2282   ID = IDR;
2283 
2284   assert(ID >= FirstDeclID && "invalid decl ID");
2285 
2286   RecordData Record;
2287   ASTDeclWriter W(*this, Context, Record);
2288 
2289   // Build a record for this declaration
2290   W.Visit(D);
2291 
2292   // Emit this declaration to the bitstream.
2293   uint64_t Offset = W.Emit(D);
2294 
2295   // Record the offset for this declaration
2296   SourceLocation Loc = D->getLocation();
2297   unsigned Index = ID - FirstDeclID;
2298   if (DeclOffsets.size() == Index)
2299     DeclOffsets.push_back(DeclOffset(Loc, Offset));
2300   else if (DeclOffsets.size() < Index) {
2301     // FIXME: Can/should this happen?
2302     DeclOffsets.resize(Index+1);
2303     DeclOffsets[Index].setLocation(Loc);
2304     DeclOffsets[Index].BitOffset = Offset;
2305   } else {
2306     llvm_unreachable("declarations should be emitted in ID order");
2307   }
2308 
2309   SourceManager &SM = Context.getSourceManager();
2310   if (Loc.isValid() && SM.isLocalSourceLocation(Loc))
2311     associateDeclWithFile(D, ID);
2312 
2313   // Note declarations that should be deserialized eagerly so that we can add
2314   // them to a record in the AST file later.
2315   if (isRequiredDecl(D, Context, WritingModule))
2316     EagerlyDeserializedDecls.push_back(ID);
2317 }
2318 
AddFunctionDefinition(const FunctionDecl * FD)2319 void ASTRecordWriter::AddFunctionDefinition(const FunctionDecl *FD) {
2320   // Switch case IDs are per function body.
2321   Writer->ClearSwitchCaseIDs();
2322 
2323   assert(FD->doesThisDeclarationHaveABody());
2324   bool ModulesCodegen = false;
2325   if (Writer->WritingModule && !FD->isDependentContext()) {
2326     Optional<GVALinkage> Linkage;
2327     if (Writer->WritingModule->Kind == Module::ModuleInterfaceUnit) {
2328       // When building a C++ Modules TS module interface unit, a strong
2329       // definition in the module interface is provided by the compilation of
2330       // that module interface unit, not by its users. (Inline functions are
2331       // still emitted in module users.)
2332       Linkage = Writer->Context->GetGVALinkageForFunction(FD);
2333       ModulesCodegen = *Linkage == GVA_StrongExternal;
2334     }
2335     if (Writer->Context->getLangOpts().ModulesCodegen) {
2336       // Under -fmodules-codegen, codegen is performed for all non-internal,
2337       // non-always_inline functions.
2338       if (!FD->hasAttr<AlwaysInlineAttr>()) {
2339         if (!Linkage)
2340           Linkage = Writer->Context->GetGVALinkageForFunction(FD);
2341         ModulesCodegen = *Linkage != GVA_Internal;
2342       }
2343     }
2344   }
2345   Record->push_back(ModulesCodegen);
2346   if (ModulesCodegen)
2347     Writer->ModularCodegenDecls.push_back(Writer->GetDeclRef(FD));
2348   if (auto *CD = dyn_cast<CXXConstructorDecl>(FD)) {
2349     Record->push_back(CD->getNumCtorInitializers());
2350     if (CD->getNumCtorInitializers())
2351       AddCXXCtorInitializers(
2352           llvm::makeArrayRef(CD->init_begin(), CD->init_end()));
2353   }
2354   AddStmt(FD->getBody());
2355 }
2356