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