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