ASTWriterDecl.cpp revision 634c5634817b9ad384a706fe87ab302985566bba 
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 *) {
830  llvm_unreachable("not implemented yet");
831}
832
833void ASTDeclWriter::VisitLinkageSpecDecl(LinkageSpecDecl *D) {
834  VisitDecl(D);
835  Record.push_back(D->getLanguage());
836  Writer.AddSourceLocation(D->getExternLoc(), Record);
837  Writer.AddSourceLocation(D->getRBraceLoc(), Record);
838  Code = serialization::DECL_LINKAGE_SPEC;
839}
840
841void ASTDeclWriter::VisitLabelDecl(LabelDecl *D) {
842  VisitNamedDecl(D);
843  Writer.AddSourceLocation(D->getLocStart(), Record);
844  Code = serialization::DECL_LABEL;
845}
846
847
848void ASTDeclWriter::VisitNamespaceDecl(NamespaceDecl *D) {
849  VisitRedeclarable(D);
850  VisitNamedDecl(D);
851  Record.push_back(D->isInline());
852  Writer.AddSourceLocation(D->getLocStart(), Record);
853  Writer.AddSourceLocation(D->getRBraceLoc(), Record);
854
855  if (D->isOriginalNamespace())
856    Writer.AddDeclRef(D->getAnonymousNamespace(), Record);
857  Code = serialization::DECL_NAMESPACE;
858
859  if (Writer.hasChain() && !D->isOriginalNamespace() &&
860      D->getOriginalNamespace()->isFromASTFile()) {
861    NamespaceDecl *NS = D->getOriginalNamespace();
862    Writer.AddUpdatedDeclContext(NS);
863
864    // Make sure all visible decls are written. They will be recorded later.
865    if (StoredDeclsMap *Map = NS->buildLookup()) {
866      for (StoredDeclsMap::iterator D = Map->begin(), DEnd = Map->end();
867           D != DEnd; ++D) {
868        DeclContext::lookup_result R = D->second.getLookupResult();
869        for (DeclContext::lookup_iterator I = R.begin(), E = R.end(); I != E;
870             ++I)
871          Writer.GetDeclRef(*I);
872      }
873    }
874  }
875
876  if (Writer.hasChain() && D->isAnonymousNamespace() &&
877      D == D->getMostRecentDecl()) {
878    // This is a most recent reopening of the anonymous namespace. If its parent
879    // is in a previous PCH (or is the TU), mark that parent for update, because
880    // the original namespace always points to the latest re-opening of its
881    // anonymous namespace.
882    Decl *Parent = cast<Decl>(
883        D->getParent()->getRedeclContext()->getPrimaryContext());
884    if (Parent->isFromASTFile() || isa<TranslationUnitDecl>(Parent)) {
885      ASTWriter::UpdateRecord &Record = Writer.DeclUpdates[Parent];
886      Record.push_back(UPD_CXX_ADDED_ANONYMOUS_NAMESPACE);
887      Writer.AddDeclRef(D, Record);
888    }
889  }
890}
891
892void ASTDeclWriter::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) {
893  VisitNamedDecl(D);
894  Writer.AddSourceLocation(D->getNamespaceLoc(), Record);
895  Writer.AddSourceLocation(D->getTargetNameLoc(), Record);
896  Writer.AddNestedNameSpecifierLoc(D->getQualifierLoc(), Record);
897  Writer.AddDeclRef(D->getNamespace(), Record);
898  Code = serialization::DECL_NAMESPACE_ALIAS;
899}
900
901void ASTDeclWriter::VisitUsingDecl(UsingDecl *D) {
902  VisitNamedDecl(D);
903  Writer.AddSourceLocation(D->getUsingLocation(), Record);
904  Writer.AddNestedNameSpecifierLoc(D->getQualifierLoc(), Record);
905  Writer.AddDeclarationNameLoc(D->DNLoc, D->getDeclName(), Record);
906  Writer.AddDeclRef(D->FirstUsingShadow.getPointer(), Record);
907  Record.push_back(D->isTypeName());
908  Writer.AddDeclRef(Context.getInstantiatedFromUsingDecl(D), Record);
909  Code = serialization::DECL_USING;
910}
911
912void ASTDeclWriter::VisitUsingShadowDecl(UsingShadowDecl *D) {
913  VisitNamedDecl(D);
914  Writer.AddDeclRef(D->getTargetDecl(), Record);
915  Writer.AddDeclRef(D->UsingOrNextShadow, Record);
916  Writer.AddDeclRef(Context.getInstantiatedFromUsingShadowDecl(D), Record);
917  Code = serialization::DECL_USING_SHADOW;
918}
919
920void ASTDeclWriter::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
921  VisitNamedDecl(D);
922  Writer.AddSourceLocation(D->getUsingLoc(), Record);
923  Writer.AddSourceLocation(D->getNamespaceKeyLocation(), Record);
924  Writer.AddNestedNameSpecifierLoc(D->getQualifierLoc(), Record);
925  Writer.AddDeclRef(D->getNominatedNamespace(), Record);
926  Writer.AddDeclRef(dyn_cast<Decl>(D->getCommonAncestor()), Record);
927  Code = serialization::DECL_USING_DIRECTIVE;
928}
929
930void ASTDeclWriter::VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) {
931  VisitValueDecl(D);
932  Writer.AddSourceLocation(D->getUsingLoc(), Record);
933  Writer.AddNestedNameSpecifierLoc(D->getQualifierLoc(), Record);
934  Writer.AddDeclarationNameLoc(D->DNLoc, D->getDeclName(), Record);
935  Code = serialization::DECL_UNRESOLVED_USING_VALUE;
936}
937
938void ASTDeclWriter::VisitUnresolvedUsingTypenameDecl(
939                                               UnresolvedUsingTypenameDecl *D) {
940  VisitTypeDecl(D);
941  Writer.AddSourceLocation(D->getTypenameLoc(), Record);
942  Writer.AddNestedNameSpecifierLoc(D->getQualifierLoc(), Record);
943  Code = serialization::DECL_UNRESOLVED_USING_TYPENAME;
944}
945
946void ASTDeclWriter::VisitCXXRecordDecl(CXXRecordDecl *D) {
947  VisitRecordDecl(D);
948  Record.push_back(D->isThisDeclarationADefinition());
949  if (D->isThisDeclarationADefinition())
950    Writer.AddCXXDefinitionData(D, Record);
951
952  enum {
953    CXXRecNotTemplate = 0, CXXRecTemplate, CXXRecMemberSpecialization
954  };
955  if (ClassTemplateDecl *TemplD = D->getDescribedClassTemplate()) {
956    Record.push_back(CXXRecTemplate);
957    Writer.AddDeclRef(TemplD, Record);
958  } else if (MemberSpecializationInfo *MSInfo
959               = D->getMemberSpecializationInfo()) {
960    Record.push_back(CXXRecMemberSpecialization);
961    Writer.AddDeclRef(MSInfo->getInstantiatedFrom(), Record);
962    Record.push_back(MSInfo->getTemplateSpecializationKind());
963    Writer.AddSourceLocation(MSInfo->getPointOfInstantiation(), Record);
964  } else {
965    Record.push_back(CXXRecNotTemplate);
966  }
967
968  // Store (what we currently believe to be) the key function to avoid
969  // deserializing every method so we can compute it.
970  if (D->IsCompleteDefinition)
971    Writer.AddDeclRef(Context.getCurrentKeyFunction(D), Record);
972
973  Code = serialization::DECL_CXX_RECORD;
974}
975
976void ASTDeclWriter::VisitCXXMethodDecl(CXXMethodDecl *D) {
977  VisitFunctionDecl(D);
978  if (D->isCanonicalDecl()) {
979    Record.push_back(D->size_overridden_methods());
980    for (CXXMethodDecl::method_iterator
981           I = D->begin_overridden_methods(), E = D->end_overridden_methods();
982           I != E; ++I)
983      Writer.AddDeclRef(*I, Record);
984  } else {
985    // We only need to record overridden methods once for the canonical decl.
986    Record.push_back(0);
987  }
988  Code = serialization::DECL_CXX_METHOD;
989}
990
991void ASTDeclWriter::VisitCXXConstructorDecl(CXXConstructorDecl *D) {
992  VisitCXXMethodDecl(D);
993
994  Record.push_back(D->IsExplicitSpecified);
995  Record.push_back(D->ImplicitlyDefined);
996  Writer.AddCXXCtorInitializers(D->CtorInitializers, D->NumCtorInitializers,
997                                Record);
998
999  Code = serialization::DECL_CXX_CONSTRUCTOR;
1000}
1001
1002void ASTDeclWriter::VisitCXXDestructorDecl(CXXDestructorDecl *D) {
1003  VisitCXXMethodDecl(D);
1004
1005  Record.push_back(D->ImplicitlyDefined);
1006  Writer.AddDeclRef(D->OperatorDelete, Record);
1007
1008  Code = serialization::DECL_CXX_DESTRUCTOR;
1009}
1010
1011void ASTDeclWriter::VisitCXXConversionDecl(CXXConversionDecl *D) {
1012  VisitCXXMethodDecl(D);
1013  Record.push_back(D->IsExplicitSpecified);
1014  Code = serialization::DECL_CXX_CONVERSION;
1015}
1016
1017void ASTDeclWriter::VisitImportDecl(ImportDecl *D) {
1018  VisitDecl(D);
1019  Record.push_back(Writer.getSubmoduleID(D->getImportedModule()));
1020  ArrayRef<SourceLocation> IdentifierLocs = D->getIdentifierLocs();
1021  Record.push_back(!IdentifierLocs.empty());
1022  if (IdentifierLocs.empty()) {
1023    Writer.AddSourceLocation(D->getLocEnd(), Record);
1024    Record.push_back(1);
1025  } else {
1026    for (unsigned I = 0, N = IdentifierLocs.size(); I != N; ++I)
1027      Writer.AddSourceLocation(IdentifierLocs[I], Record);
1028    Record.push_back(IdentifierLocs.size());
1029  }
1030  // Note: the number of source locations must always be the last element in
1031  // the record.
1032  Code = serialization::DECL_IMPORT;
1033}
1034
1035void ASTDeclWriter::VisitAccessSpecDecl(AccessSpecDecl *D) {
1036  VisitDecl(D);
1037  Writer.AddSourceLocation(D->getColonLoc(), Record);
1038  Code = serialization::DECL_ACCESS_SPEC;
1039}
1040
1041void ASTDeclWriter::VisitFriendDecl(FriendDecl *D) {
1042  // Record the number of friend type template parameter lists here
1043  // so as to simplify memory allocation during deserialization.
1044  Record.push_back(D->NumTPLists);
1045  VisitDecl(D);
1046  bool hasFriendDecl = D->Friend.is<NamedDecl*>();
1047  Record.push_back(hasFriendDecl);
1048  if (hasFriendDecl)
1049    Writer.AddDeclRef(D->getFriendDecl(), Record);
1050  else
1051    Writer.AddTypeSourceInfo(D->getFriendType(), Record);
1052  for (unsigned i = 0; i < D->NumTPLists; ++i)
1053    Writer.AddTemplateParameterList(D->getFriendTypeTemplateParameterList(i),
1054                                    Record);
1055  Writer.AddDeclRef(D->getNextFriend(), Record);
1056  Record.push_back(D->UnsupportedFriend);
1057  Writer.AddSourceLocation(D->FriendLoc, Record);
1058  Code = serialization::DECL_FRIEND;
1059}
1060
1061void ASTDeclWriter::VisitFriendTemplateDecl(FriendTemplateDecl *D) {
1062  VisitDecl(D);
1063  Record.push_back(D->getNumTemplateParameters());
1064  for (unsigned i = 0, e = D->getNumTemplateParameters(); i != e; ++i)
1065    Writer.AddTemplateParameterList(D->getTemplateParameterList(i), Record);
1066  Record.push_back(D->getFriendDecl() != 0);
1067  if (D->getFriendDecl())
1068    Writer.AddDeclRef(D->getFriendDecl(), Record);
1069  else
1070    Writer.AddTypeSourceInfo(D->getFriendType(), Record);
1071  Writer.AddSourceLocation(D->getFriendLoc(), Record);
1072  Code = serialization::DECL_FRIEND_TEMPLATE;
1073}
1074
1075void ASTDeclWriter::VisitTemplateDecl(TemplateDecl *D) {
1076  VisitNamedDecl(D);
1077
1078  Writer.AddDeclRef(D->getTemplatedDecl(), Record);
1079  Writer.AddTemplateParameterList(D->getTemplateParameters(), Record);
1080}
1081
1082void ASTDeclWriter::VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D) {
1083  VisitRedeclarable(D);
1084
1085  // Emit data to initialize CommonOrPrev before VisitTemplateDecl so that
1086  // getCommonPtr() can be used while this is still initializing.
1087  if (D->isFirstDeclaration()) {
1088    // This declaration owns the 'common' pointer, so serialize that data now.
1089    Writer.AddDeclRef(D->getInstantiatedFromMemberTemplate(), Record);
1090    if (D->getInstantiatedFromMemberTemplate())
1091      Record.push_back(D->isMemberSpecialization());
1092  }
1093
1094  VisitTemplateDecl(D);
1095  Record.push_back(D->getIdentifierNamespace());
1096}
1097
1098void ASTDeclWriter::VisitClassTemplateDecl(ClassTemplateDecl *D) {
1099  VisitRedeclarableTemplateDecl(D);
1100
1101  if (D->isFirstDeclaration()) {
1102    typedef llvm::FoldingSetVector<ClassTemplateSpecializationDecl> CTSDSetTy;
1103    CTSDSetTy &CTSDSet = D->getSpecializations();
1104    Record.push_back(CTSDSet.size());
1105    for (CTSDSetTy::iterator I=CTSDSet.begin(), E = CTSDSet.end(); I!=E; ++I) {
1106      assert(I->isCanonicalDecl() && "Expected only canonical decls in set");
1107      Writer.AddDeclRef(&*I, Record);
1108    }
1109
1110    typedef llvm::FoldingSetVector<ClassTemplatePartialSpecializationDecl>
1111      CTPSDSetTy;
1112    CTPSDSetTy &CTPSDSet = D->getPartialSpecializations();
1113    Record.push_back(CTPSDSet.size());
1114    for (CTPSDSetTy::iterator I=CTPSDSet.begin(), E=CTPSDSet.end(); I!=E; ++I) {
1115      assert(I->isCanonicalDecl() && "Expected only canonical decls in set");
1116      Writer.AddDeclRef(&*I, Record);
1117    }
1118
1119    Writer.AddTypeRef(D->getCommonPtr()->InjectedClassNameType, Record);
1120  }
1121  Code = serialization::DECL_CLASS_TEMPLATE;
1122}
1123
1124void ASTDeclWriter::VisitClassTemplateSpecializationDecl(
1125                                           ClassTemplateSpecializationDecl *D) {
1126  VisitCXXRecordDecl(D);
1127
1128  llvm::PointerUnion<ClassTemplateDecl *,
1129                     ClassTemplatePartialSpecializationDecl *> InstFrom
1130    = D->getSpecializedTemplateOrPartial();
1131  if (Decl *InstFromD = InstFrom.dyn_cast<ClassTemplateDecl *>()) {
1132    Writer.AddDeclRef(InstFromD, Record);
1133  } else {
1134    Writer.AddDeclRef(InstFrom.get<ClassTemplatePartialSpecializationDecl *>(),
1135                      Record);
1136    Writer.AddTemplateArgumentList(&D->getTemplateInstantiationArgs(), Record);
1137  }
1138
1139  // Explicit info.
1140  Writer.AddTypeSourceInfo(D->getTypeAsWritten(), Record);
1141  if (D->getTypeAsWritten()) {
1142    Writer.AddSourceLocation(D->getExternLoc(), Record);
1143    Writer.AddSourceLocation(D->getTemplateKeywordLoc(), Record);
1144  }
1145
1146  Writer.AddTemplateArgumentList(&D->getTemplateArgs(), Record);
1147  Writer.AddSourceLocation(D->getPointOfInstantiation(), Record);
1148  Record.push_back(D->getSpecializationKind());
1149  Record.push_back(D->isCanonicalDecl());
1150
1151  if (D->isCanonicalDecl()) {
1152    // When reading, we'll add it to the folding set of the following template.
1153    Writer.AddDeclRef(D->getSpecializedTemplate()->getCanonicalDecl(), Record);
1154  }
1155
1156  Code = serialization::DECL_CLASS_TEMPLATE_SPECIALIZATION;
1157}
1158
1159void ASTDeclWriter::VisitClassTemplatePartialSpecializationDecl(
1160                                    ClassTemplatePartialSpecializationDecl *D) {
1161  VisitClassTemplateSpecializationDecl(D);
1162
1163  Writer.AddTemplateParameterList(D->getTemplateParameters(), Record);
1164
1165  Record.push_back(D->getNumTemplateArgsAsWritten());
1166  for (int i = 0, e = D->getNumTemplateArgsAsWritten(); i != e; ++i)
1167    Writer.AddTemplateArgumentLoc(D->getTemplateArgsAsWritten()[i], Record);
1168
1169  Record.push_back(D->getSequenceNumber());
1170
1171  // These are read/set from/to the first declaration.
1172  if (D->getPreviousDecl() == 0) {
1173    Writer.AddDeclRef(D->getInstantiatedFromMember(), Record);
1174    Record.push_back(D->isMemberSpecialization());
1175  }
1176
1177  Code = serialization::DECL_CLASS_TEMPLATE_PARTIAL_SPECIALIZATION;
1178}
1179
1180void ASTDeclWriter::VisitClassScopeFunctionSpecializationDecl(
1181                                    ClassScopeFunctionSpecializationDecl *D) {
1182  VisitDecl(D);
1183  Writer.AddDeclRef(D->getSpecialization(), Record);
1184  Code = serialization::DECL_CLASS_SCOPE_FUNCTION_SPECIALIZATION;
1185}
1186
1187
1188void ASTDeclWriter::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
1189  VisitRedeclarableTemplateDecl(D);
1190
1191  if (D->isFirstDeclaration()) {
1192    // This FunctionTemplateDecl owns the CommonPtr; write it.
1193
1194    // Write the function specialization declarations.
1195    Record.push_back(D->getSpecializations().size());
1196    for (llvm::FoldingSetVector<FunctionTemplateSpecializationInfo>::iterator
1197           I = D->getSpecializations().begin(),
1198           E = D->getSpecializations().end()   ; I != E; ++I) {
1199      assert(I->Function->isCanonicalDecl() &&
1200             "Expected only canonical decls in set");
1201      Writer.AddDeclRef(I->Function, Record);
1202    }
1203  }
1204  Code = serialization::DECL_FUNCTION_TEMPLATE;
1205}
1206
1207void ASTDeclWriter::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
1208  VisitTypeDecl(D);
1209
1210  Record.push_back(D->wasDeclaredWithTypename());
1211  Record.push_back(D->defaultArgumentWasInherited());
1212  Writer.AddTypeSourceInfo(D->getDefaultArgumentInfo(), Record);
1213
1214  Code = serialization::DECL_TEMPLATE_TYPE_PARM;
1215}
1216
1217void ASTDeclWriter::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) {
1218  // For an expanded parameter pack, record the number of expansion types here
1219  // so that it's easier for deserialization to allocate the right amount of
1220  // memory.
1221  if (D->isExpandedParameterPack())
1222    Record.push_back(D->getNumExpansionTypes());
1223
1224  VisitDeclaratorDecl(D);
1225  // TemplateParmPosition.
1226  Record.push_back(D->getDepth());
1227  Record.push_back(D->getPosition());
1228
1229  if (D->isExpandedParameterPack()) {
1230    for (unsigned I = 0, N = D->getNumExpansionTypes(); I != N; ++I) {
1231      Writer.AddTypeRef(D->getExpansionType(I), Record);
1232      Writer.AddTypeSourceInfo(D->getExpansionTypeSourceInfo(I), Record);
1233    }
1234
1235    Code = serialization::DECL_EXPANDED_NON_TYPE_TEMPLATE_PARM_PACK;
1236  } else {
1237    // Rest of NonTypeTemplateParmDecl.
1238    Record.push_back(D->isParameterPack());
1239    Record.push_back(D->getDefaultArgument() != 0);
1240    if (D->getDefaultArgument()) {
1241      Writer.AddStmt(D->getDefaultArgument());
1242      Record.push_back(D->defaultArgumentWasInherited());
1243    }
1244    Code = serialization::DECL_NON_TYPE_TEMPLATE_PARM;
1245  }
1246}
1247
1248void ASTDeclWriter::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) {
1249  // For an expanded parameter pack, record the number of expansion types here
1250  // so that it's easier for deserialization to allocate the right amount of
1251  // memory.
1252  if (D->isExpandedParameterPack())
1253    Record.push_back(D->getNumExpansionTemplateParameters());
1254
1255  VisitTemplateDecl(D);
1256  // TemplateParmPosition.
1257  Record.push_back(D->getDepth());
1258  Record.push_back(D->getPosition());
1259
1260  if (D->isExpandedParameterPack()) {
1261    for (unsigned I = 0, N = D->getNumExpansionTemplateParameters();
1262         I != N; ++I)
1263      Writer.AddTemplateParameterList(D->getExpansionTemplateParameters(I),
1264                                      Record);
1265    Code = serialization::DECL_EXPANDED_TEMPLATE_TEMPLATE_PARM_PACK;
1266  } else {
1267    // Rest of TemplateTemplateParmDecl.
1268    Writer.AddTemplateArgumentLoc(D->getDefaultArgument(), Record);
1269    Record.push_back(D->defaultArgumentWasInherited());
1270    Record.push_back(D->isParameterPack());
1271    Code = serialization::DECL_TEMPLATE_TEMPLATE_PARM;
1272  }
1273}
1274
1275void ASTDeclWriter::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) {
1276  VisitRedeclarableTemplateDecl(D);
1277  Code = serialization::DECL_TYPE_ALIAS_TEMPLATE;
1278}
1279
1280void ASTDeclWriter::VisitStaticAssertDecl(StaticAssertDecl *D) {
1281  VisitDecl(D);
1282  Writer.AddStmt(D->getAssertExpr());
1283  Record.push_back(D->isFailed());
1284  Writer.AddStmt(D->getMessage());
1285  Writer.AddSourceLocation(D->getRParenLoc(), Record);
1286  Code = serialization::DECL_STATIC_ASSERT;
1287}
1288
1289/// \brief Emit the DeclContext part of a declaration context decl.
1290///
1291/// \param LexicalOffset the offset at which the DECL_CONTEXT_LEXICAL
1292/// block for this declaration context is stored. May be 0 to indicate
1293/// that there are no declarations stored within this context.
1294///
1295/// \param VisibleOffset the offset at which the DECL_CONTEXT_VISIBLE
1296/// block for this declaration context is stored. May be 0 to indicate
1297/// that there are no declarations visible from this context. Note
1298/// that this value will not be emitted for non-primary declaration
1299/// contexts.
1300void ASTDeclWriter::VisitDeclContext(DeclContext *DC, uint64_t LexicalOffset,
1301                                     uint64_t VisibleOffset) {
1302  Record.push_back(LexicalOffset);
1303  Record.push_back(VisibleOffset);
1304}
1305
1306template <typename T>
1307void ASTDeclWriter::VisitRedeclarable(Redeclarable<T> *D) {
1308  T *First = D->getFirstDeclaration();
1309  if (First->getMostRecentDecl() != First) {
1310    assert(isRedeclarableDeclKind(static_cast<T *>(D)->getKind()) &&
1311           "Not considered redeclarable?");
1312
1313    // There is more than one declaration of this entity, so we will need to
1314    // write a redeclaration chain.
1315    Writer.AddDeclRef(First, Record);
1316    Writer.Redeclarations.insert(First);
1317
1318    // Make sure that we serialize both the previous and the most-recent
1319    // declarations, which (transitively) ensures that all declarations in the
1320    // chain get serialized.
1321    (void)Writer.GetDeclRef(D->getPreviousDecl());
1322    (void)Writer.GetDeclRef(First->getMostRecentDecl());
1323  } else {
1324    // We use the sentinel value 0 to indicate an only declaration.
1325    Record.push_back(0);
1326  }
1327
1328}
1329
1330void ASTDeclWriter::VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D) {
1331  Record.push_back(D->varlist_size());
1332  VisitDecl(D);
1333  for (OMPThreadPrivateDecl::varlist_iterator I = D->varlist_begin(),
1334                                              E = D->varlist_end();
1335       I != E; ++I)
1336    Writer.AddStmt(*I);
1337  Code = serialization::DECL_OMP_THREADPRIVATE;
1338}
1339
1340//===----------------------------------------------------------------------===//
1341// ASTWriter Implementation
1342//===----------------------------------------------------------------------===//
1343
1344void ASTWriter::WriteDeclsBlockAbbrevs() {
1345  using namespace llvm;
1346
1347  BitCodeAbbrev *Abv;
1348
1349  // Abbreviation for DECL_FIELD
1350  Abv = new BitCodeAbbrev();
1351  Abv->Add(BitCodeAbbrevOp(serialization::DECL_FIELD));
1352  // Decl
1353  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
1354  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalDeclContext
1355  Abv->Add(BitCodeAbbrevOp(0));                       // isInvalidDecl
1356  Abv->Add(BitCodeAbbrevOp(0));                       // HasAttrs
1357  Abv->Add(BitCodeAbbrevOp(0));                       // isImplicit
1358  Abv->Add(BitCodeAbbrevOp(0));                       // isUsed
1359  Abv->Add(BitCodeAbbrevOp(0));                       // isReferenced
1360  Abv->Add(BitCodeAbbrevOp(0));                   // TopLevelDeclInObjCContainer
1361  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2));  // AccessSpecifier
1362  Abv->Add(BitCodeAbbrevOp(0));                       // ModulePrivate
1363  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
1364  // NamedDecl
1365  Abv->Add(BitCodeAbbrevOp(0));                       // NameKind = Identifier
1366  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
1367  // ValueDecl
1368  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
1369  // DeclaratorDecl
1370  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerStartLoc
1371  Abv->Add(BitCodeAbbrevOp(0));                       // hasExtInfo
1372  // FieldDecl
1373  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isMutable
1374  Abv->Add(BitCodeAbbrevOp(0));                       //getBitWidth
1375  // Type Source Info
1376  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1377  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
1378  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc
1379  DeclFieldAbbrev = Stream.EmitAbbrev(Abv);
1380
1381  // Abbreviation for DECL_OBJC_IVAR
1382  Abv = new BitCodeAbbrev();
1383  Abv->Add(BitCodeAbbrevOp(serialization::DECL_OBJC_IVAR));
1384  // Decl
1385  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
1386  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalDeclContext
1387  Abv->Add(BitCodeAbbrevOp(0));                       // isInvalidDecl
1388  Abv->Add(BitCodeAbbrevOp(0));                       // HasAttrs
1389  Abv->Add(BitCodeAbbrevOp(0));                       // isImplicit
1390  Abv->Add(BitCodeAbbrevOp(0));                       // isUsed
1391  Abv->Add(BitCodeAbbrevOp(0));                       // isReferenced
1392  Abv->Add(BitCodeAbbrevOp(0));                   // TopLevelDeclInObjCContainer
1393  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2));  // AccessSpecifier
1394  Abv->Add(BitCodeAbbrevOp(0));                       // ModulePrivate
1395  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
1396  // NamedDecl
1397  Abv->Add(BitCodeAbbrevOp(0));                       // NameKind = Identifier
1398  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
1399  // ValueDecl
1400  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
1401  // DeclaratorDecl
1402  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerStartLoc
1403  Abv->Add(BitCodeAbbrevOp(0));                       // hasExtInfo
1404  // FieldDecl
1405  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isMutable
1406  Abv->Add(BitCodeAbbrevOp(0));                       //getBitWidth
1407  // ObjC Ivar
1408  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getAccessControl
1409  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getSynthesize
1410  // Type Source Info
1411  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1412  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
1413  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc
1414  DeclObjCIvarAbbrev = Stream.EmitAbbrev(Abv);
1415
1416  // Abbreviation for DECL_ENUM
1417  Abv = new BitCodeAbbrev();
1418  Abv->Add(BitCodeAbbrevOp(serialization::DECL_ENUM));
1419  // Redeclarable
1420  Abv->Add(BitCodeAbbrevOp(0));                       // No redeclaration
1421  // Decl
1422  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
1423  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalDeclContext
1424  Abv->Add(BitCodeAbbrevOp(0));                       // isInvalidDecl
1425  Abv->Add(BitCodeAbbrevOp(0));                       // HasAttrs
1426  Abv->Add(BitCodeAbbrevOp(0));                       // isImplicit
1427  Abv->Add(BitCodeAbbrevOp(0));                       // isUsed
1428  Abv->Add(BitCodeAbbrevOp(0));                       // isReferenced
1429  Abv->Add(BitCodeAbbrevOp(0));                   // TopLevelDeclInObjCContainer
1430  Abv->Add(BitCodeAbbrevOp(AS_none));                 // C++ AccessSpecifier
1431  Abv->Add(BitCodeAbbrevOp(0));                       // ModulePrivate
1432  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
1433  // NamedDecl
1434  Abv->Add(BitCodeAbbrevOp(0));                       // NameKind = Identifier
1435  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
1436  // TypeDecl
1437  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Source Location
1438  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type Ref
1439  // TagDecl
1440  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // IdentifierNamespace
1441  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // getTagKind
1442  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isCompleteDefinition
1443  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // EmbeddedInDeclarator
1444  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsFreeStanding
1445  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // SourceLocation
1446  Abv->Add(BitCodeAbbrevOp(0));                         // hasExtInfo
1447  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // TypedefNameAnonDecl
1448  // EnumDecl
1449  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // AddTypeRef
1450  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // IntegerType
1451  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // getPromotionType
1452  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // getNumPositiveBits
1453  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // getNumNegativeBits
1454  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isScoped
1455  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isScopedUsingClassTag
1456  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isFixed
1457  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // InstantiatedMembEnum
1458  // DC
1459  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // LexicalOffset
1460  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // VisibleOffset
1461  DeclEnumAbbrev = Stream.EmitAbbrev(Abv);
1462
1463  // Abbreviation for DECL_RECORD
1464  Abv = new BitCodeAbbrev();
1465  Abv->Add(BitCodeAbbrevOp(serialization::DECL_RECORD));
1466  // Redeclarable
1467  Abv->Add(BitCodeAbbrevOp(0));                       // No redeclaration
1468  // Decl
1469  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
1470  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalDeclContext
1471  Abv->Add(BitCodeAbbrevOp(0));                       // isInvalidDecl
1472  Abv->Add(BitCodeAbbrevOp(0));                       // HasAttrs
1473  Abv->Add(BitCodeAbbrevOp(0));                       // isImplicit
1474  Abv->Add(BitCodeAbbrevOp(0));                       // isUsed
1475  Abv->Add(BitCodeAbbrevOp(0));                       // isReferenced
1476  Abv->Add(BitCodeAbbrevOp(0));                   // TopLevelDeclInObjCContainer
1477  Abv->Add(BitCodeAbbrevOp(AS_none));                 // C++ AccessSpecifier
1478  Abv->Add(BitCodeAbbrevOp(0));                       // ModulePrivate
1479  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
1480  // NamedDecl
1481  Abv->Add(BitCodeAbbrevOp(0));                       // NameKind = Identifier
1482  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
1483  // TypeDecl
1484  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Source Location
1485  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type Ref
1486  // TagDecl
1487  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // IdentifierNamespace
1488  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // getTagKind
1489  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isCompleteDefinition
1490  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // EmbeddedInDeclarator
1491  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsFreeStanding
1492  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // SourceLocation
1493  Abv->Add(BitCodeAbbrevOp(0));                         // hasExtInfo
1494  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // TypedefNameAnonDecl
1495  // RecordDecl
1496  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // FlexibleArrayMember
1497  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // AnonymousStructUnion
1498  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // hasObjectMember
1499  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // hasVolatileMember
1500  // DC
1501  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // LexicalOffset
1502  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // VisibleOffset
1503  DeclRecordAbbrev = Stream.EmitAbbrev(Abv);
1504
1505  // Abbreviation for DECL_PARM_VAR
1506  Abv = new BitCodeAbbrev();
1507  Abv->Add(BitCodeAbbrevOp(serialization::DECL_PARM_VAR));
1508  // Redeclarable
1509  Abv->Add(BitCodeAbbrevOp(0));                       // No redeclaration
1510  // Decl
1511  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
1512  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalDeclContext
1513  Abv->Add(BitCodeAbbrevOp(0));                       // isInvalidDecl
1514  Abv->Add(BitCodeAbbrevOp(0));                       // HasAttrs
1515  Abv->Add(BitCodeAbbrevOp(0));                       // isImplicit
1516  Abv->Add(BitCodeAbbrevOp(0));                       // isUsed
1517  Abv->Add(BitCodeAbbrevOp(0));                       // isReferenced
1518  Abv->Add(BitCodeAbbrevOp(0));                   // TopLevelDeclInObjCContainer
1519  Abv->Add(BitCodeAbbrevOp(AS_none));                 // C++ AccessSpecifier
1520  Abv->Add(BitCodeAbbrevOp(0));                       // ModulePrivate
1521  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
1522  // NamedDecl
1523  Abv->Add(BitCodeAbbrevOp(0));                       // NameKind = Identifier
1524  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
1525  // ValueDecl
1526  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
1527  // DeclaratorDecl
1528  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerStartLoc
1529  Abv->Add(BitCodeAbbrevOp(0));                       // hasExtInfo
1530  // VarDecl
1531  Abv->Add(BitCodeAbbrevOp(0));                       // StorageClass
1532  Abv->Add(BitCodeAbbrevOp(0));                       // getTLSKind
1533  Abv->Add(BitCodeAbbrevOp(0));                       // hasCXXDirectInitializer
1534  Abv->Add(BitCodeAbbrevOp(0));                       // isExceptionVariable
1535  Abv->Add(BitCodeAbbrevOp(0));                       // isNRVOVariable
1536  Abv->Add(BitCodeAbbrevOp(0));                       // isCXXForRangeDecl
1537  Abv->Add(BitCodeAbbrevOp(0));                       // isARCPseudoStrong
1538  Abv->Add(BitCodeAbbrevOp(0));                       // isConstexpr
1539  Abv->Add(BitCodeAbbrevOp(0));                       // Linkage
1540  Abv->Add(BitCodeAbbrevOp(0));                       // HasInit
1541  Abv->Add(BitCodeAbbrevOp(0));                   // HasMemberSpecializationInfo
1542  // ParmVarDecl
1543  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsObjCMethodParameter
1544  Abv->Add(BitCodeAbbrevOp(0));                       // ScopeDepth
1545  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // ScopeIndex
1546  Abv->Add(BitCodeAbbrevOp(0));                       // ObjCDeclQualifier
1547  Abv->Add(BitCodeAbbrevOp(0));                       // KNRPromoted
1548  Abv->Add(BitCodeAbbrevOp(0));                       // HasInheritedDefaultArg
1549  Abv->Add(BitCodeAbbrevOp(0));                   // HasUninstantiatedDefaultArg
1550  // Type Source Info
1551  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1552  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
1553  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc
1554  DeclParmVarAbbrev = Stream.EmitAbbrev(Abv);
1555
1556  // Abbreviation for DECL_TYPEDEF
1557  Abv = new BitCodeAbbrev();
1558  Abv->Add(BitCodeAbbrevOp(serialization::DECL_TYPEDEF));
1559  // Redeclarable
1560  Abv->Add(BitCodeAbbrevOp(0));                       // No redeclaration
1561  // Decl
1562  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
1563  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalDeclContext
1564  Abv->Add(BitCodeAbbrevOp(0));                       // isInvalidDecl
1565  Abv->Add(BitCodeAbbrevOp(0));                       // HasAttrs
1566  Abv->Add(BitCodeAbbrevOp(0));                       // isImplicit
1567  Abv->Add(BitCodeAbbrevOp(0));                       // isUsed
1568  Abv->Add(BitCodeAbbrevOp(0));                       // isReferenced
1569  Abv->Add(BitCodeAbbrevOp(0));                   // TopLevelDeclInObjCContainer
1570  Abv->Add(BitCodeAbbrevOp(AS_none));                 // C++ AccessSpecifier
1571  Abv->Add(BitCodeAbbrevOp(0));                       // ModulePrivate
1572  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
1573  // NamedDecl
1574  Abv->Add(BitCodeAbbrevOp(0));                       // NameKind = Identifier
1575  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
1576  // TypeDecl
1577  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Source Location
1578  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type Ref
1579  // TypedefDecl
1580  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
1581  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc
1582  DeclTypedefAbbrev = Stream.EmitAbbrev(Abv);
1583
1584  // Abbreviation for DECL_VAR
1585  Abv = new BitCodeAbbrev();
1586  Abv->Add(BitCodeAbbrevOp(serialization::DECL_VAR));
1587  // Redeclarable
1588  Abv->Add(BitCodeAbbrevOp(0));                       // No redeclaration
1589  // Decl
1590  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
1591  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalDeclContext
1592  Abv->Add(BitCodeAbbrevOp(0));                       // isInvalidDecl
1593  Abv->Add(BitCodeAbbrevOp(0));                       // HasAttrs
1594  Abv->Add(BitCodeAbbrevOp(0));                       // isImplicit
1595  Abv->Add(BitCodeAbbrevOp(0));                       // isUsed
1596  Abv->Add(BitCodeAbbrevOp(0));                       // isReferenced
1597  Abv->Add(BitCodeAbbrevOp(0));                   // TopLevelDeclInObjCContainer
1598  Abv->Add(BitCodeAbbrevOp(AS_none));                 // C++ AccessSpecifier
1599  Abv->Add(BitCodeAbbrevOp(0));                       // ModulePrivate
1600  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
1601  // NamedDecl
1602  Abv->Add(BitCodeAbbrevOp(0));                       // NameKind = Identifier
1603  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
1604  // ValueDecl
1605  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
1606  // DeclaratorDecl
1607  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerStartLoc
1608  Abv->Add(BitCodeAbbrevOp(0));                       // hasExtInfo
1609  // VarDecl
1610  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // StorageClass
1611  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // getTLSKind
1612  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // CXXDirectInitializer
1613  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isExceptionVariable
1614  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isNRVOVariable
1615  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isCXXForRangeDecl
1616  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isARCPseudoStrong
1617  Abv->Add(BitCodeAbbrevOp(0));                         // isConstexpr
1618  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // Linkage
1619  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // HasInit
1620  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // HasMemberSpecInfo
1621  // Type Source Info
1622  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1623  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
1624  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc
1625  DeclVarAbbrev = Stream.EmitAbbrev(Abv);
1626
1627  // Abbreviation for EXPR_DECL_REF
1628  Abv = new BitCodeAbbrev();
1629  Abv->Add(BitCodeAbbrevOp(serialization::EXPR_DECL_REF));
1630  //Stmt
1631  //Expr
1632  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
1633  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //TypeDependent
1634  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //ValueDependent
1635  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //InstantiationDependent
1636  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //UnexpandedParamPack
1637  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetValueKind
1638  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetObjectKind
1639  //DeclRefExpr
1640  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //HasQualifier
1641  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //GetDeclFound
1642  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //ExplicitTemplateArgs
1643  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //HadMultipleCandidates
1644  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //RefersToEnclosingLocal
1645  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclRef
1646  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Location
1647  DeclRefExprAbbrev = Stream.EmitAbbrev(Abv);
1648
1649  // Abbreviation for EXPR_INTEGER_LITERAL
1650  Abv = new BitCodeAbbrev();
1651  Abv->Add(BitCodeAbbrevOp(serialization::EXPR_INTEGER_LITERAL));
1652  //Stmt
1653  //Expr
1654  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
1655  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //TypeDependent
1656  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //ValueDependent
1657  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //InstantiationDependent
1658  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //UnexpandedParamPack
1659  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetValueKind
1660  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetObjectKind
1661  //Integer Literal
1662  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Location
1663  Abv->Add(BitCodeAbbrevOp(32));                      // Bit Width
1664  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Value
1665  IntegerLiteralAbbrev = Stream.EmitAbbrev(Abv);
1666
1667  // Abbreviation for EXPR_CHARACTER_LITERAL
1668  Abv = new BitCodeAbbrev();
1669  Abv->Add(BitCodeAbbrevOp(serialization::EXPR_CHARACTER_LITERAL));
1670  //Stmt
1671  //Expr
1672  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
1673  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //TypeDependent
1674  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //ValueDependent
1675  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //InstantiationDependent
1676  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //UnexpandedParamPack
1677  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetValueKind
1678  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetObjectKind
1679  //Character Literal
1680  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getValue
1681  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Location
1682  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // getKind
1683  CharacterLiteralAbbrev = Stream.EmitAbbrev(Abv);
1684
1685  Abv = new BitCodeAbbrev();
1686  Abv->Add(BitCodeAbbrevOp(serialization::DECL_CONTEXT_LEXICAL));
1687  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1688  DeclContextLexicalAbbrev = Stream.EmitAbbrev(Abv);
1689
1690  Abv = new BitCodeAbbrev();
1691  Abv->Add(BitCodeAbbrevOp(serialization::DECL_CONTEXT_VISIBLE));
1692  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
1693  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1694  DeclContextVisibleLookupAbbrev = Stream.EmitAbbrev(Abv);
1695}
1696
1697/// isRequiredDecl - Check if this is a "required" Decl, which must be seen by
1698/// consumers of the AST.
1699///
1700/// Such decls will always be deserialized from the AST file, so we would like
1701/// this to be as restrictive as possible. Currently the predicate is driven by
1702/// code generation requirements, if other clients have a different notion of
1703/// what is "required" then we may have to consider an alternate scheme where
1704/// clients can iterate over the top-level decls and get information on them,
1705/// without necessary deserializing them. We could explicitly require such
1706/// clients to use a separate API call to "realize" the decl. This should be
1707/// relatively painless since they would presumably only do it for top-level
1708/// decls.
1709static bool isRequiredDecl(const Decl *D, ASTContext &Context) {
1710  // An ObjCMethodDecl is never considered as "required" because its
1711  // implementation container always is.
1712
1713  // File scoped assembly or obj-c implementation must be seen.
1714  if (isa<FileScopeAsmDecl>(D) || isa<ObjCImplDecl>(D))
1715    return true;
1716
1717  return Context.DeclMustBeEmitted(D);
1718}
1719
1720void ASTWriter::WriteDecl(ASTContext &Context, Decl *D) {
1721  // Switch case IDs are per Decl.
1722  ClearSwitchCaseIDs();
1723
1724  RecordData Record;
1725  ASTDeclWriter W(*this, Context, Record);
1726
1727  // Determine the ID for this declaration.
1728  serialization::DeclID ID;
1729  if (D->isFromASTFile())
1730    ID = getDeclID(D);
1731  else {
1732    serialization::DeclID &IDR = DeclIDs[D];
1733    if (IDR == 0)
1734      IDR = NextDeclID++;
1735
1736    ID= IDR;
1737  }
1738
1739  bool isReplacingADecl = ID < FirstDeclID;
1740
1741  // If this declaration is also a DeclContext, write blocks for the
1742  // declarations that lexically stored inside its context and those
1743  // declarations that are visible from its context. These blocks
1744  // are written before the declaration itself so that we can put
1745  // their offsets into the record for the declaration.
1746  uint64_t LexicalOffset = 0;
1747  uint64_t VisibleOffset = 0;
1748  DeclContext *DC = dyn_cast<DeclContext>(D);
1749  if (DC) {
1750    if (isReplacingADecl) {
1751      // It is replacing a decl from a chained PCH; make sure that the
1752      // DeclContext is fully loaded.
1753      if (DC->hasExternalLexicalStorage())
1754        DC->LoadLexicalDeclsFromExternalStorage();
1755      if (DC->hasExternalVisibleStorage())
1756        Chain->completeVisibleDeclsMap(DC);
1757    }
1758    LexicalOffset = WriteDeclContextLexicalBlock(Context, DC);
1759    VisibleOffset = WriteDeclContextVisibleBlock(Context, DC);
1760  }
1761
1762  if (isReplacingADecl) {
1763    // We're replacing a decl in a previous file.
1764    ReplacedDecls.push_back(ReplacedDeclInfo(ID, Stream.GetCurrentBitNo(),
1765                                             D->getLocation()));
1766  } else {
1767    unsigned Index = ID - FirstDeclID;
1768
1769    // Record the offset for this declaration
1770    SourceLocation Loc = D->getLocation();
1771    if (DeclOffsets.size() == Index)
1772      DeclOffsets.push_back(DeclOffset(Loc, Stream.GetCurrentBitNo()));
1773    else if (DeclOffsets.size() < Index) {
1774      DeclOffsets.resize(Index+1);
1775      DeclOffsets[Index].setLocation(Loc);
1776      DeclOffsets[Index].BitOffset = Stream.GetCurrentBitNo();
1777    }
1778
1779    SourceManager &SM = Context.getSourceManager();
1780    if (Loc.isValid() && SM.isLocalSourceLocation(Loc))
1781      associateDeclWithFile(D, ID);
1782  }
1783
1784  // Build and emit a record for this declaration
1785  Record.clear();
1786  W.Code = (serialization::DeclCode)0;
1787  W.AbbrevToUse = 0;
1788  W.Visit(D);
1789  if (DC) W.VisitDeclContext(DC, LexicalOffset, VisibleOffset);
1790
1791  if (!W.Code)
1792    llvm::report_fatal_error(StringRef("unexpected declaration kind '") +
1793                            D->getDeclKindName() + "'");
1794  Stream.EmitRecord(W.Code, Record, W.AbbrevToUse);
1795
1796  // Flush any expressions that were written as part of this declaration.
1797  FlushStmts();
1798
1799  // Flush C++ base specifiers, if there are any.
1800  FlushCXXBaseSpecifiers();
1801
1802  // Note "external" declarations so that we can add them to a record in the
1803  // AST file later.
1804  //
1805  // FIXME: This should be renamed, the predicate is much more complicated.
1806  if (isRequiredDecl(D, Context))
1807    ExternalDefinitions.push_back(ID);
1808}
1809