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