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