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