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