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