1 //===--- ASTWriterDecl.cpp - Declaration Serialization --------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements serialization for Declarations.
12 //===----------------------------------------------------------------------===//
14 #include "clang/Serialization/ASTWriter.h"
15 #include "ASTCommon.h"
16 #include "clang/AST/DeclCXX.h"
17 #include "clang/AST/DeclContextInternals.h"
18 #include "clang/AST/DeclTemplate.h"
19 #include "clang/AST/DeclVisitor.h"
20 #include "clang/AST/Expr.h"
21 #include "clang/Basic/SourceManager.h"
22 #include "clang/Serialization/ASTReader.h"
23 #include "llvm/ADT/Twine.h"
24 #include "llvm/Bitcode/BitstreamWriter.h"
25 #include "llvm/Support/ErrorHandling.h"
26 using namespace clang;
27 using namespace serialization;
29 //===----------------------------------------------------------------------===//
30 // Declaration serialization
31 //===----------------------------------------------------------------------===//
34 class ASTDeclWriter : public DeclVisitor<ASTDeclWriter, void> {
38 typedef ASTWriter::RecordData RecordData;
42 serialization::DeclCode Code;
45 ASTDeclWriter(ASTWriter &Writer, ASTContext &Context, RecordData &Record)
46 : Writer(Writer), Context(Context), Record(Record) {
51 void VisitDecl(Decl *D);
52 void VisitTranslationUnitDecl(TranslationUnitDecl *D);
53 void VisitNamedDecl(NamedDecl *D);
54 void VisitLabelDecl(LabelDecl *LD);
55 void VisitNamespaceDecl(NamespaceDecl *D);
56 void VisitUsingDirectiveDecl(UsingDirectiveDecl *D);
57 void VisitNamespaceAliasDecl(NamespaceAliasDecl *D);
58 void VisitTypeDecl(TypeDecl *D);
59 void VisitTypedefNameDecl(TypedefNameDecl *D);
60 void VisitTypedefDecl(TypedefDecl *D);
61 void VisitTypeAliasDecl(TypeAliasDecl *D);
62 void VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D);
63 void VisitTagDecl(TagDecl *D);
64 void VisitEnumDecl(EnumDecl *D);
65 void VisitRecordDecl(RecordDecl *D);
66 void VisitCXXRecordDecl(CXXRecordDecl *D);
67 void VisitClassTemplateSpecializationDecl(
68 ClassTemplateSpecializationDecl *D);
69 void VisitClassTemplatePartialSpecializationDecl(
70 ClassTemplatePartialSpecializationDecl *D);
71 void VisitClassScopeFunctionSpecializationDecl(
72 ClassScopeFunctionSpecializationDecl *D);
73 void VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D);
74 void VisitValueDecl(ValueDecl *D);
75 void VisitEnumConstantDecl(EnumConstantDecl *D);
76 void VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D);
77 void VisitDeclaratorDecl(DeclaratorDecl *D);
78 void VisitFunctionDecl(FunctionDecl *D);
79 void VisitCXXMethodDecl(CXXMethodDecl *D);
80 void VisitCXXConstructorDecl(CXXConstructorDecl *D);
81 void VisitCXXDestructorDecl(CXXDestructorDecl *D);
82 void VisitCXXConversionDecl(CXXConversionDecl *D);
83 void VisitFieldDecl(FieldDecl *D);
84 void VisitMSPropertyDecl(MSPropertyDecl *D);
85 void VisitIndirectFieldDecl(IndirectFieldDecl *D);
86 void VisitVarDecl(VarDecl *D);
87 void VisitImplicitParamDecl(ImplicitParamDecl *D);
88 void VisitParmVarDecl(ParmVarDecl *D);
89 void VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D);
90 void VisitTemplateDecl(TemplateDecl *D);
91 void VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D);
92 void VisitClassTemplateDecl(ClassTemplateDecl *D);
93 void VisitFunctionTemplateDecl(FunctionTemplateDecl *D);
94 void VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D);
95 void VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D);
96 void VisitUsingDecl(UsingDecl *D);
97 void VisitUsingShadowDecl(UsingShadowDecl *D);
98 void VisitLinkageSpecDecl(LinkageSpecDecl *D);
99 void VisitFileScopeAsmDecl(FileScopeAsmDecl *D);
100 void VisitImportDecl(ImportDecl *D);
101 void VisitAccessSpecDecl(AccessSpecDecl *D);
102 void VisitFriendDecl(FriendDecl *D);
103 void VisitFriendTemplateDecl(FriendTemplateDecl *D);
104 void VisitStaticAssertDecl(StaticAssertDecl *D);
105 void VisitBlockDecl(BlockDecl *D);
106 void VisitCapturedDecl(CapturedDecl *D);
107 void VisitEmptyDecl(EmptyDecl *D);
109 void VisitDeclContext(DeclContext *DC, uint64_t LexicalOffset,
110 uint64_t VisibleOffset);
111 template <typename T> void VisitRedeclarable(Redeclarable<T> *D);
114 // FIXME: Put in the same order is DeclNodes.td?
115 void VisitObjCMethodDecl(ObjCMethodDecl *D);
116 void VisitObjCContainerDecl(ObjCContainerDecl *D);
117 void VisitObjCInterfaceDecl(ObjCInterfaceDecl *D);
118 void VisitObjCIvarDecl(ObjCIvarDecl *D);
119 void VisitObjCProtocolDecl(ObjCProtocolDecl *D);
120 void VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D);
121 void VisitObjCCategoryDecl(ObjCCategoryDecl *D);
122 void VisitObjCImplDecl(ObjCImplDecl *D);
123 void VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D);
124 void VisitObjCImplementationDecl(ObjCImplementationDecl *D);
125 void VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D);
126 void VisitObjCPropertyDecl(ObjCPropertyDecl *D);
127 void VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D);
128 void VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D);
132 void ASTDeclWriter::Visit(Decl *D) {
133 DeclVisitor<ASTDeclWriter>::Visit(D);
135 // Source locations require array (variable-length) abbreviations. The
136 // abbreviation infrastructure requires that arrays are encoded last, so
137 // we handle it here in the case of those classes derived from DeclaratorDecl
138 if (DeclaratorDecl *DD = dyn_cast<DeclaratorDecl>(D)){
139 Writer.AddTypeSourceInfo(DD->getTypeSourceInfo(), Record);
142 // Handle FunctionDecl's body here and write it after all other Stmts/Exprs
143 // have been written. We want it last because we will not read it back when
144 // retrieving it from the AST, we'll just lazily set the offset.
145 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
146 Record.push_back(FD->doesThisDeclarationHaveABody());
147 if (FD->doesThisDeclarationHaveABody())
148 Writer.AddStmt(FD->getBody());
152 void ASTDeclWriter::VisitDecl(Decl *D) {
153 Writer.AddDeclRef(cast_or_null<Decl>(D->getDeclContext()), Record);
154 Writer.AddDeclRef(cast_or_null<Decl>(D->getLexicalDeclContext()), Record);
155 Record.push_back(D->isInvalidDecl());
156 Record.push_back(D->hasAttrs());
158 Writer.WriteAttributes(ArrayRef<const Attr*>(D->getAttrs().begin(),
159 D->getAttrs().size()), Record);
160 Record.push_back(D->isImplicit());
161 Record.push_back(D->isUsed(false));
162 Record.push_back(D->isReferenced());
163 Record.push_back(D->isTopLevelDeclInObjCContainer());
164 Record.push_back(D->getAccess());
165 Record.push_back(D->isModulePrivate());
166 Record.push_back(Writer.inferSubmoduleIDFromLocation(D->getLocation()));
169 void ASTDeclWriter::VisitTranslationUnitDecl(TranslationUnitDecl *D) {
170 llvm_unreachable("Translation units aren't directly serialized");
173 void ASTDeclWriter::VisitNamedDecl(NamedDecl *D) {
175 Writer.AddDeclarationName(D->getDeclName(), Record);
178 void ASTDeclWriter::VisitTypeDecl(TypeDecl *D) {
180 Writer.AddSourceLocation(D->getLocStart(), Record);
181 Writer.AddTypeRef(QualType(D->getTypeForDecl(), 0), Record);
184 void ASTDeclWriter::VisitTypedefNameDecl(TypedefNameDecl *D) {
185 VisitRedeclarable(D);
187 Writer.AddTypeSourceInfo(D->getTypeSourceInfo(), Record);
190 void ASTDeclWriter::VisitTypedefDecl(TypedefDecl *D) {
191 VisitTypedefNameDecl(D);
192 if (!D->hasAttrs() &&
195 D->getFirstDeclaration() == D->getMostRecentDecl() &&
196 !D->isInvalidDecl() &&
197 !D->isReferenced() &&
198 !D->isTopLevelDeclInObjCContainer() &&
199 D->getAccess() == AS_none &&
200 !D->isModulePrivate() &&
201 D->getDeclName().getNameKind() == DeclarationName::Identifier)
202 AbbrevToUse = Writer.getDeclTypedefAbbrev();
204 Code = serialization::DECL_TYPEDEF;
207 void ASTDeclWriter::VisitTypeAliasDecl(TypeAliasDecl *D) {
208 VisitTypedefNameDecl(D);
209 Code = serialization::DECL_TYPEALIAS;
212 void ASTDeclWriter::VisitTagDecl(TagDecl *D) {
213 VisitRedeclarable(D);
215 Record.push_back(D->getIdentifierNamespace());
216 Record.push_back((unsigned)D->getTagKind()); // FIXME: stable encoding
217 Record.push_back(D->isCompleteDefinition());
218 Record.push_back(D->isEmbeddedInDeclarator());
219 Record.push_back(D->isFreeStanding());
220 Writer.AddSourceLocation(D->getRBraceLoc(), Record);
221 Record.push_back(D->hasExtInfo());
223 Writer.AddQualifierInfo(*D->getExtInfo(), Record);
225 Writer.AddDeclRef(D->getTypedefNameForAnonDecl(), Record);
228 void ASTDeclWriter::VisitEnumDecl(EnumDecl *D) {
230 Writer.AddTypeSourceInfo(D->getIntegerTypeSourceInfo(), Record);
231 if (!D->getIntegerTypeSourceInfo())
232 Writer.AddTypeRef(D->getIntegerType(), Record);
233 Writer.AddTypeRef(D->getPromotionType(), Record);
234 Record.push_back(D->getNumPositiveBits());
235 Record.push_back(D->getNumNegativeBits());
236 Record.push_back(D->isScoped());
237 Record.push_back(D->isScopedUsingClassTag());
238 Record.push_back(D->isFixed());
239 if (MemberSpecializationInfo *MemberInfo = D->getMemberSpecializationInfo()) {
240 Writer.AddDeclRef(MemberInfo->getInstantiatedFrom(), Record);
241 Record.push_back(MemberInfo->getTemplateSpecializationKind());
242 Writer.AddSourceLocation(MemberInfo->getPointOfInstantiation(), Record);
244 Writer.AddDeclRef(0, Record);
247 if (!D->hasAttrs() &&
251 D->getFirstDeclaration() == D->getMostRecentDecl() &&
252 !D->isInvalidDecl() &&
253 !D->isReferenced() &&
254 !D->isTopLevelDeclInObjCContainer() &&
255 D->getAccess() == AS_none &&
256 !D->isModulePrivate() &&
257 !CXXRecordDecl::classofKind(D->getKind()) &&
258 !D->getIntegerTypeSourceInfo() &&
259 !D->getMemberSpecializationInfo() &&
260 D->getDeclName().getNameKind() == DeclarationName::Identifier)
261 AbbrevToUse = Writer.getDeclEnumAbbrev();
263 Code = serialization::DECL_ENUM;
266 void ASTDeclWriter::VisitRecordDecl(RecordDecl *D) {
268 Record.push_back(D->hasFlexibleArrayMember());
269 Record.push_back(D->isAnonymousStructOrUnion());
270 Record.push_back(D->hasObjectMember());
271 Record.push_back(D->hasVolatileMember());
273 if (!D->hasAttrs() &&
277 D->getFirstDeclaration() == D->getMostRecentDecl() &&
278 !D->isInvalidDecl() &&
279 !D->isReferenced() &&
280 !D->isTopLevelDeclInObjCContainer() &&
281 D->getAccess() == AS_none &&
282 !D->isModulePrivate() &&
283 !CXXRecordDecl::classofKind(D->getKind()) &&
284 D->getDeclName().getNameKind() == DeclarationName::Identifier)
285 AbbrevToUse = Writer.getDeclRecordAbbrev();
287 Code = serialization::DECL_RECORD;
290 void ASTDeclWriter::VisitValueDecl(ValueDecl *D) {
292 Writer.AddTypeRef(D->getType(), Record);
295 void ASTDeclWriter::VisitEnumConstantDecl(EnumConstantDecl *D) {
297 Record.push_back(D->getInitExpr()? 1 : 0);
298 if (D->getInitExpr())
299 Writer.AddStmt(D->getInitExpr());
300 Writer.AddAPSInt(D->getInitVal(), Record);
302 Code = serialization::DECL_ENUM_CONSTANT;
305 void ASTDeclWriter::VisitDeclaratorDecl(DeclaratorDecl *D) {
307 Writer.AddSourceLocation(D->getInnerLocStart(), Record);
308 Record.push_back(D->hasExtInfo());
310 Writer.AddQualifierInfo(*D->getExtInfo(), Record);
313 void ASTDeclWriter::VisitFunctionDecl(FunctionDecl *D) {
314 VisitRedeclarable(D);
315 VisitDeclaratorDecl(D);
317 Writer.AddDeclarationNameLoc(D->DNLoc, D->getDeclName(), Record);
318 Record.push_back(D->getIdentifierNamespace());
320 // FunctionDecl's body is handled last at ASTWriterDecl::Visit,
321 // after everything else is written.
323 Record.push_back(D->getStorageClass()); // FIXME: stable encoding
324 Record.push_back(D->IsInline);
325 Record.push_back(D->isInlineSpecified());
326 Record.push_back(D->isVirtualAsWritten());
327 Record.push_back(D->isPure());
328 Record.push_back(D->hasInheritedPrototype());
329 Record.push_back(D->hasWrittenPrototype());
330 Record.push_back(D->isDeletedAsWritten());
331 Record.push_back(D->isTrivial());
332 Record.push_back(D->isDefaulted());
333 Record.push_back(D->isExplicitlyDefaulted());
334 Record.push_back(D->hasImplicitReturnZero());
335 Record.push_back(D->isConstexpr());
336 Record.push_back(D->HasSkippedBody);
337 Record.push_back(D->getLinkage());
338 Writer.AddSourceLocation(D->getLocEnd(), Record);
340 Record.push_back(D->getTemplatedKind());
341 switch (D->getTemplatedKind()) {
342 case FunctionDecl::TK_NonTemplate:
344 case FunctionDecl::TK_FunctionTemplate:
345 Writer.AddDeclRef(D->getDescribedFunctionTemplate(), Record);
347 case FunctionDecl::TK_MemberSpecialization: {
348 MemberSpecializationInfo *MemberInfo = D->getMemberSpecializationInfo();
349 Writer.AddDeclRef(MemberInfo->getInstantiatedFrom(), Record);
350 Record.push_back(MemberInfo->getTemplateSpecializationKind());
351 Writer.AddSourceLocation(MemberInfo->getPointOfInstantiation(), Record);
354 case FunctionDecl::TK_FunctionTemplateSpecialization: {
355 FunctionTemplateSpecializationInfo *
356 FTSInfo = D->getTemplateSpecializationInfo();
357 Writer.AddDeclRef(FTSInfo->getTemplate(), Record);
358 Record.push_back(FTSInfo->getTemplateSpecializationKind());
360 // Template arguments.
361 Writer.AddTemplateArgumentList(FTSInfo->TemplateArguments, Record);
363 // Template args as written.
364 Record.push_back(FTSInfo->TemplateArgumentsAsWritten != 0);
365 if (FTSInfo->TemplateArgumentsAsWritten) {
366 Record.push_back(FTSInfo->TemplateArgumentsAsWritten->NumTemplateArgs);
367 for (int i=0, e = FTSInfo->TemplateArgumentsAsWritten->NumTemplateArgs;
369 Writer.AddTemplateArgumentLoc((*FTSInfo->TemplateArgumentsAsWritten)[i],
371 Writer.AddSourceLocation(FTSInfo->TemplateArgumentsAsWritten->LAngleLoc,
373 Writer.AddSourceLocation(FTSInfo->TemplateArgumentsAsWritten->RAngleLoc,
377 Writer.AddSourceLocation(FTSInfo->getPointOfInstantiation(), Record);
379 if (D->isCanonicalDecl()) {
380 // Write the template that contains the specializations set. We will
381 // add a FunctionTemplateSpecializationInfo to it when reading.
382 Writer.AddDeclRef(FTSInfo->getTemplate()->getCanonicalDecl(), Record);
386 case FunctionDecl::TK_DependentFunctionTemplateSpecialization: {
387 DependentFunctionTemplateSpecializationInfo *
388 DFTSInfo = D->getDependentSpecializationInfo();
391 Record.push_back(DFTSInfo->getNumTemplates());
392 for (int i=0, e = DFTSInfo->getNumTemplates(); i != e; ++i)
393 Writer.AddDeclRef(DFTSInfo->getTemplate(i), Record);
396 Record.push_back(DFTSInfo->getNumTemplateArgs());
397 for (int i=0, e = DFTSInfo->getNumTemplateArgs(); i != e; ++i)
398 Writer.AddTemplateArgumentLoc(DFTSInfo->getTemplateArg(i), Record);
399 Writer.AddSourceLocation(DFTSInfo->getLAngleLoc(), Record);
400 Writer.AddSourceLocation(DFTSInfo->getRAngleLoc(), Record);
405 Record.push_back(D->param_size());
406 for (FunctionDecl::param_iterator P = D->param_begin(), PEnd = D->param_end();
408 Writer.AddDeclRef(*P, Record);
409 Code = serialization::DECL_FUNCTION;
412 void ASTDeclWriter::VisitObjCMethodDecl(ObjCMethodDecl *D) {
414 // FIXME: convert to LazyStmtPtr?
415 // Unlike C/C++, method bodies will never be in header files.
416 bool HasBodyStuff = D->getBody() != 0 ||
417 D->getSelfDecl() != 0 || D->getCmdDecl() != 0;
418 Record.push_back(HasBodyStuff);
420 Writer.AddStmt(D->getBody());
421 Writer.AddDeclRef(D->getSelfDecl(), Record);
422 Writer.AddDeclRef(D->getCmdDecl(), Record);
424 Record.push_back(D->isInstanceMethod());
425 Record.push_back(D->isVariadic());
426 Record.push_back(D->isPropertyAccessor());
427 Record.push_back(D->isDefined());
428 Record.push_back(D->IsOverriding);
429 Record.push_back(D->HasSkippedBody);
431 Record.push_back(D->IsRedeclaration);
432 Record.push_back(D->HasRedeclaration);
433 if (D->HasRedeclaration) {
434 assert(Context.getObjCMethodRedeclaration(D));
435 Writer.AddDeclRef(Context.getObjCMethodRedeclaration(D), Record);
438 // FIXME: stable encoding for @required/@optional
439 Record.push_back(D->getImplementationControl());
440 // FIXME: stable encoding for in/out/inout/bycopy/byref/oneway
441 Record.push_back(D->getObjCDeclQualifier());
442 Record.push_back(D->hasRelatedResultType());
443 Writer.AddTypeRef(D->getResultType(), Record);
444 Writer.AddTypeSourceInfo(D->getResultTypeSourceInfo(), Record);
445 Writer.AddSourceLocation(D->getLocEnd(), Record);
446 Record.push_back(D->param_size());
447 for (ObjCMethodDecl::param_iterator P = D->param_begin(),
448 PEnd = D->param_end(); P != PEnd; ++P)
449 Writer.AddDeclRef(*P, Record);
451 Record.push_back(D->SelLocsKind);
452 unsigned NumStoredSelLocs = D->getNumStoredSelLocs();
453 SourceLocation *SelLocs = D->getStoredSelLocs();
454 Record.push_back(NumStoredSelLocs);
455 for (unsigned i = 0; i != NumStoredSelLocs; ++i)
456 Writer.AddSourceLocation(SelLocs[i], Record);
458 Code = serialization::DECL_OBJC_METHOD;
461 void ASTDeclWriter::VisitObjCContainerDecl(ObjCContainerDecl *D) {
463 Writer.AddSourceLocation(D->getAtStartLoc(), Record);
464 Writer.AddSourceRange(D->getAtEndRange(), Record);
465 // Abstract class (no need to define a stable serialization::DECL code).
468 void ASTDeclWriter::VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) {
469 VisitRedeclarable(D);
470 VisitObjCContainerDecl(D);
471 Writer.AddTypeRef(QualType(D->getTypeForDecl(), 0), Record);
473 Record.push_back(D->isThisDeclarationADefinition());
474 if (D->isThisDeclarationADefinition()) {
475 // Write the DefinitionData
476 ObjCInterfaceDecl::DefinitionData &Data = D->data();
478 Writer.AddDeclRef(D->getSuperClass(), Record);
479 Writer.AddSourceLocation(D->getSuperClassLoc(), Record);
480 Writer.AddSourceLocation(D->getEndOfDefinitionLoc(), Record);
482 // Write out the protocols that are directly referenced by the @interface.
483 Record.push_back(Data.ReferencedProtocols.size());
484 for (ObjCInterfaceDecl::protocol_iterator P = D->protocol_begin(),
485 PEnd = D->protocol_end();
487 Writer.AddDeclRef(*P, Record);
488 for (ObjCInterfaceDecl::protocol_loc_iterator PL = D->protocol_loc_begin(),
489 PLEnd = D->protocol_loc_end();
491 Writer.AddSourceLocation(*PL, Record);
493 // Write out the protocols that are transitively referenced.
494 Record.push_back(Data.AllReferencedProtocols.size());
495 for (ObjCList<ObjCProtocolDecl>::iterator
496 P = Data.AllReferencedProtocols.begin(),
497 PEnd = Data.AllReferencedProtocols.end();
499 Writer.AddDeclRef(*P, Record);
502 if (ObjCCategoryDecl *Cat = D->getCategoryListRaw()) {
503 // Ensure that we write out the set of categories for this class.
504 Writer.ObjCClassesWithCategories.insert(D);
506 // Make sure that the categories get serialized.
507 for (; Cat; Cat = Cat->getNextClassCategoryRaw())
508 (void)Writer.GetDeclRef(Cat);
512 Code = serialization::DECL_OBJC_INTERFACE;
515 void ASTDeclWriter::VisitObjCIvarDecl(ObjCIvarDecl *D) {
517 // FIXME: stable encoding for @public/@private/@protected/@package
518 Record.push_back(D->getAccessControl());
519 Record.push_back(D->getSynthesize());
521 if (!D->hasAttrs() &&
524 !D->isInvalidDecl() &&
525 !D->isReferenced() &&
526 !D->isModulePrivate() &&
530 AbbrevToUse = Writer.getDeclObjCIvarAbbrev();
532 Code = serialization::DECL_OBJC_IVAR;
535 void ASTDeclWriter::VisitObjCProtocolDecl(ObjCProtocolDecl *D) {
536 VisitRedeclarable(D);
537 VisitObjCContainerDecl(D);
539 Record.push_back(D->isThisDeclarationADefinition());
540 if (D->isThisDeclarationADefinition()) {
541 Record.push_back(D->protocol_size());
542 for (ObjCProtocolDecl::protocol_iterator
543 I = D->protocol_begin(), IEnd = D->protocol_end(); I != IEnd; ++I)
544 Writer.AddDeclRef(*I, Record);
545 for (ObjCProtocolDecl::protocol_loc_iterator PL = D->protocol_loc_begin(),
546 PLEnd = D->protocol_loc_end();
548 Writer.AddSourceLocation(*PL, Record);
551 Code = serialization::DECL_OBJC_PROTOCOL;
554 void ASTDeclWriter::VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D) {
556 Code = serialization::DECL_OBJC_AT_DEFS_FIELD;
559 void ASTDeclWriter::VisitObjCCategoryDecl(ObjCCategoryDecl *D) {
560 VisitObjCContainerDecl(D);
561 Writer.AddSourceLocation(D->getCategoryNameLoc(), Record);
562 Writer.AddSourceLocation(D->getIvarLBraceLoc(), Record);
563 Writer.AddSourceLocation(D->getIvarRBraceLoc(), Record);
564 Writer.AddDeclRef(D->getClassInterface(), Record);
565 Record.push_back(D->protocol_size());
566 for (ObjCCategoryDecl::protocol_iterator
567 I = D->protocol_begin(), IEnd = D->protocol_end(); I != IEnd; ++I)
568 Writer.AddDeclRef(*I, Record);
569 for (ObjCCategoryDecl::protocol_loc_iterator
570 PL = D->protocol_loc_begin(), PLEnd = D->protocol_loc_end();
572 Writer.AddSourceLocation(*PL, Record);
573 Code = serialization::DECL_OBJC_CATEGORY;
576 void ASTDeclWriter::VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D) {
578 Writer.AddDeclRef(D->getClassInterface(), Record);
579 Code = serialization::DECL_OBJC_COMPATIBLE_ALIAS;
582 void ASTDeclWriter::VisitObjCPropertyDecl(ObjCPropertyDecl *D) {
584 Writer.AddSourceLocation(D->getAtLoc(), Record);
585 Writer.AddSourceLocation(D->getLParenLoc(), Record);
586 Writer.AddTypeSourceInfo(D->getTypeSourceInfo(), Record);
587 // FIXME: stable encoding
588 Record.push_back((unsigned)D->getPropertyAttributes());
589 Record.push_back((unsigned)D->getPropertyAttributesAsWritten());
590 // FIXME: stable encoding
591 Record.push_back((unsigned)D->getPropertyImplementation());
592 Writer.AddDeclarationName(D->getGetterName(), Record);
593 Writer.AddDeclarationName(D->getSetterName(), Record);
594 Writer.AddDeclRef(D->getGetterMethodDecl(), Record);
595 Writer.AddDeclRef(D->getSetterMethodDecl(), Record);
596 Writer.AddDeclRef(D->getPropertyIvarDecl(), Record);
597 Code = serialization::DECL_OBJC_PROPERTY;
600 void ASTDeclWriter::VisitObjCImplDecl(ObjCImplDecl *D) {
601 VisitObjCContainerDecl(D);
602 Writer.AddDeclRef(D->getClassInterface(), Record);
603 // Abstract class (no need to define a stable serialization::DECL code).
606 void ASTDeclWriter::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
607 VisitObjCImplDecl(D);
608 Writer.AddIdentifierRef(D->getIdentifier(), Record);
609 Writer.AddSourceLocation(D->getCategoryNameLoc(), Record);
610 Code = serialization::DECL_OBJC_CATEGORY_IMPL;
613 void ASTDeclWriter::VisitObjCImplementationDecl(ObjCImplementationDecl *D) {
614 VisitObjCImplDecl(D);
615 Writer.AddDeclRef(D->getSuperClass(), Record);
616 Writer.AddSourceLocation(D->getSuperClassLoc(), Record);
617 Writer.AddSourceLocation(D->getIvarLBraceLoc(), Record);
618 Writer.AddSourceLocation(D->getIvarRBraceLoc(), Record);
619 Record.push_back(D->hasNonZeroConstructors());
620 Record.push_back(D->hasDestructors());
621 Writer.AddCXXCtorInitializers(D->IvarInitializers, D->NumIvarInitializers,
623 Code = serialization::DECL_OBJC_IMPLEMENTATION;
626 void ASTDeclWriter::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) {
628 Writer.AddSourceLocation(D->getLocStart(), Record);
629 Writer.AddDeclRef(D->getPropertyDecl(), Record);
630 Writer.AddDeclRef(D->getPropertyIvarDecl(), Record);
631 Writer.AddSourceLocation(D->getPropertyIvarDeclLoc(), Record);
632 Writer.AddStmt(D->getGetterCXXConstructor());
633 Writer.AddStmt(D->getSetterCXXAssignment());
634 Code = serialization::DECL_OBJC_PROPERTY_IMPL;
637 void ASTDeclWriter::VisitFieldDecl(FieldDecl *D) {
638 VisitDeclaratorDecl(D);
639 Record.push_back(D->isMutable());
640 if (D->InitializerOrBitWidth.getInt() != ICIS_NoInit ||
641 D->InitializerOrBitWidth.getPointer()) {
642 Record.push_back(D->InitializerOrBitWidth.getInt() + 1);
643 Writer.AddStmt(D->InitializerOrBitWidth.getPointer());
647 if (!D->getDeclName())
648 Writer.AddDeclRef(Context.getInstantiatedFromUnnamedFieldDecl(D), Record);
650 if (!D->hasAttrs() &&
653 !D->isInvalidDecl() &&
654 !D->isReferenced() &&
655 !D->isTopLevelDeclInObjCContainer() &&
656 !D->isModulePrivate() &&
658 !D->hasInClassInitializer() &&
660 !ObjCIvarDecl::classofKind(D->getKind()) &&
661 !ObjCAtDefsFieldDecl::classofKind(D->getKind()) &&
663 AbbrevToUse = Writer.getDeclFieldAbbrev();
665 Code = serialization::DECL_FIELD;
668 void ASTDeclWriter::VisitMSPropertyDecl(MSPropertyDecl *D) {
669 VisitDeclaratorDecl(D);
670 Writer.AddIdentifierRef(D->getGetterId(), Record);
671 Writer.AddIdentifierRef(D->getSetterId(), Record);
672 Code = serialization::DECL_MS_PROPERTY;
675 void ASTDeclWriter::VisitIndirectFieldDecl(IndirectFieldDecl *D) {
677 Record.push_back(D->getChainingSize());
679 for (IndirectFieldDecl::chain_iterator
680 P = D->chain_begin(),
681 PEnd = D->chain_end(); P != PEnd; ++P)
682 Writer.AddDeclRef(*P, Record);
683 Code = serialization::DECL_INDIRECTFIELD;
686 void ASTDeclWriter::VisitVarDecl(VarDecl *D) {
687 VisitRedeclarable(D);
688 VisitDeclaratorDecl(D);
689 Record.push_back(D->getStorageClass());
690 Record.push_back(D->getTSCSpec());
691 Record.push_back(D->getInitStyle());
692 Record.push_back(D->isExceptionVariable());
693 Record.push_back(D->isNRVOVariable());
694 Record.push_back(D->isCXXForRangeDecl());
695 Record.push_back(D->isARCPseudoStrong());
696 Record.push_back(D->isConstexpr());
697 Record.push_back(D->getLinkage());
700 Record.push_back(!D->isInitKnownICE() ? 1 : (D->isInitICE() ? 3 : 2));
701 Writer.AddStmt(D->getInit());
706 MemberSpecializationInfo *SpecInfo
707 = D->isStaticDataMember() ? D->getMemberSpecializationInfo() : 0;
708 Record.push_back(SpecInfo != 0);
710 Writer.AddDeclRef(SpecInfo->getInstantiatedFrom(), Record);
711 Record.push_back(SpecInfo->getTemplateSpecializationKind());
712 Writer.AddSourceLocation(SpecInfo->getPointOfInstantiation(), Record);
715 if (!D->hasAttrs() &&
718 !D->isInvalidDecl() &&
719 !D->isReferenced() &&
720 !D->isTopLevelDeclInObjCContainer() &&
721 D->getAccess() == AS_none &&
722 !D->isModulePrivate() &&
723 D->getDeclName().getNameKind() == DeclarationName::Identifier &&
725 D->getFirstDeclaration() == D->getMostRecentDecl() &&
726 D->getInitStyle() == VarDecl::CInit &&
728 !isa<ParmVarDecl>(D) &&
731 AbbrevToUse = Writer.getDeclVarAbbrev();
733 Code = serialization::DECL_VAR;
736 void ASTDeclWriter::VisitImplicitParamDecl(ImplicitParamDecl *D) {
738 Code = serialization::DECL_IMPLICIT_PARAM;
741 void ASTDeclWriter::VisitParmVarDecl(ParmVarDecl *D) {
743 Record.push_back(D->isObjCMethodParameter());
744 Record.push_back(D->getFunctionScopeDepth());
745 Record.push_back(D->getFunctionScopeIndex());
746 Record.push_back(D->getObjCDeclQualifier()); // FIXME: stable encoding
747 Record.push_back(D->isKNRPromoted());
748 Record.push_back(D->hasInheritedDefaultArg());
749 Record.push_back(D->hasUninstantiatedDefaultArg());
750 if (D->hasUninstantiatedDefaultArg())
751 Writer.AddStmt(D->getUninstantiatedDefaultArg());
752 Code = serialization::DECL_PARM_VAR;
754 assert(!D->isARCPseudoStrong()); // can be true of ImplicitParamDecl
756 // If the assumptions about the DECL_PARM_VAR abbrev are true, use it. Here
757 // we dynamically check for the properties that we optimize for, but don't
758 // know are true of all PARM_VAR_DECLs.
759 if (!D->hasAttrs() &&
763 !D->isInvalidDecl() &&
764 !D->isReferenced() &&
765 D->getAccess() == AS_none &&
766 !D->isModulePrivate() &&
767 D->getStorageClass() == 0 &&
768 D->getInitStyle() == VarDecl::CInit && // Can params have anything else?
769 D->getFunctionScopeDepth() == 0 &&
770 D->getObjCDeclQualifier() == 0 &&
771 !D->isKNRPromoted() &&
772 !D->hasInheritedDefaultArg() &&
774 !D->hasUninstantiatedDefaultArg()) // No default expr.
775 AbbrevToUse = Writer.getDeclParmVarAbbrev();
777 // Check things we know are true of *every* PARM_VAR_DECL, which is more than
778 // just us assuming it.
779 assert(!D->getTSCSpec() && "PARM_VAR_DECL can't use TLS");
780 assert(D->getAccess() == AS_none && "PARM_VAR_DECL can't be public/private");
781 assert(!D->isExceptionVariable() && "PARM_VAR_DECL can't be exception var");
782 assert(D->getPreviousDecl() == 0 && "PARM_VAR_DECL can't be redecl");
783 assert(!D->isStaticDataMember() &&
784 "PARM_VAR_DECL can't be static data member");
787 void ASTDeclWriter::VisitFileScopeAsmDecl(FileScopeAsmDecl *D) {
789 Writer.AddStmt(D->getAsmString());
790 Writer.AddSourceLocation(D->getRParenLoc(), Record);
791 Code = serialization::DECL_FILE_SCOPE_ASM;
794 void ASTDeclWriter::VisitEmptyDecl(EmptyDecl *D) {
796 Code = serialization::DECL_EMPTY;
799 void ASTDeclWriter::VisitBlockDecl(BlockDecl *D) {
801 Writer.AddStmt(D->getBody());
802 Writer.AddTypeSourceInfo(D->getSignatureAsWritten(), Record);
803 Record.push_back(D->param_size());
804 for (FunctionDecl::param_iterator P = D->param_begin(), PEnd = D->param_end();
806 Writer.AddDeclRef(*P, Record);
807 Record.push_back(D->isVariadic());
808 Record.push_back(D->blockMissingReturnType());
809 Record.push_back(D->isConversionFromLambda());
810 Record.push_back(D->capturesCXXThis());
811 Record.push_back(D->getNumCaptures());
812 for (BlockDecl::capture_iterator
813 i = D->capture_begin(), e = D->capture_end(); i != e; ++i) {
814 const BlockDecl::Capture &capture = *i;
815 Writer.AddDeclRef(capture.getVariable(), Record);
818 if (capture.isByRef()) flags |= 1;
819 if (capture.isNested()) flags |= 2;
820 if (capture.hasCopyExpr()) flags |= 4;
821 Record.push_back(flags);
823 if (capture.hasCopyExpr()) Writer.AddStmt(capture.getCopyExpr());
826 Code = serialization::DECL_BLOCK;
829 void ASTDeclWriter::VisitCapturedDecl(CapturedDecl *CD) {
830 Record.push_back(CD->getNumParams());
832 // Body is stored by VisitCapturedStmt.
833 for (unsigned i = 0; i < CD->getNumParams(); ++i)
834 Writer.AddDeclRef(CD->getParam(i), Record);
835 Code = serialization::DECL_CAPTURED;
838 void ASTDeclWriter::VisitLinkageSpecDecl(LinkageSpecDecl *D) {
840 Record.push_back(D->getLanguage());
841 Writer.AddSourceLocation(D->getExternLoc(), Record);
842 Writer.AddSourceLocation(D->getRBraceLoc(), Record);
843 Code = serialization::DECL_LINKAGE_SPEC;
846 void ASTDeclWriter::VisitLabelDecl(LabelDecl *D) {
848 Writer.AddSourceLocation(D->getLocStart(), Record);
849 Code = serialization::DECL_LABEL;
853 void ASTDeclWriter::VisitNamespaceDecl(NamespaceDecl *D) {
854 VisitRedeclarable(D);
856 Record.push_back(D->isInline());
857 Writer.AddSourceLocation(D->getLocStart(), Record);
858 Writer.AddSourceLocation(D->getRBraceLoc(), Record);
860 if (D->isOriginalNamespace())
861 Writer.AddDeclRef(D->getAnonymousNamespace(), Record);
862 Code = serialization::DECL_NAMESPACE;
864 if (Writer.hasChain() && !D->isOriginalNamespace() &&
865 D->getOriginalNamespace()->isFromASTFile()) {
866 NamespaceDecl *NS = D->getOriginalNamespace();
867 Writer.AddUpdatedDeclContext(NS);
869 // Make sure all visible decls are written. They will be recorded later.
870 if (StoredDeclsMap *Map = NS->buildLookup()) {
871 for (StoredDeclsMap::iterator D = Map->begin(), DEnd = Map->end();
873 DeclContext::lookup_result R = D->second.getLookupResult();
874 for (DeclContext::lookup_iterator I = R.begin(), E = R.end(); I != E;
876 Writer.GetDeclRef(*I);
881 if (Writer.hasChain() && D->isAnonymousNamespace() &&
882 D == D->getMostRecentDecl()) {
883 // This is a most recent reopening of the anonymous namespace. If its parent
884 // is in a previous PCH (or is the TU), mark that parent for update, because
885 // the original namespace always points to the latest re-opening of its
886 // anonymous namespace.
887 Decl *Parent = cast<Decl>(
888 D->getParent()->getRedeclContext()->getPrimaryContext());
889 if (Parent->isFromASTFile() || isa<TranslationUnitDecl>(Parent)) {
890 ASTWriter::UpdateRecord &Record = Writer.DeclUpdates[Parent];
891 Record.push_back(UPD_CXX_ADDED_ANONYMOUS_NAMESPACE);
892 Writer.AddDeclRef(D, Record);
897 void ASTDeclWriter::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) {
899 Writer.AddSourceLocation(D->getNamespaceLoc(), Record);
900 Writer.AddSourceLocation(D->getTargetNameLoc(), Record);
901 Writer.AddNestedNameSpecifierLoc(D->getQualifierLoc(), Record);
902 Writer.AddDeclRef(D->getNamespace(), Record);
903 Code = serialization::DECL_NAMESPACE_ALIAS;
906 void ASTDeclWriter::VisitUsingDecl(UsingDecl *D) {
908 Writer.AddSourceLocation(D->getUsingLocation(), Record);
909 Writer.AddNestedNameSpecifierLoc(D->getQualifierLoc(), Record);
910 Writer.AddDeclarationNameLoc(D->DNLoc, D->getDeclName(), Record);
911 Writer.AddDeclRef(D->FirstUsingShadow.getPointer(), Record);
912 Record.push_back(D->isTypeName());
913 Writer.AddDeclRef(Context.getInstantiatedFromUsingDecl(D), Record);
914 Code = serialization::DECL_USING;
917 void ASTDeclWriter::VisitUsingShadowDecl(UsingShadowDecl *D) {
919 Writer.AddDeclRef(D->getTargetDecl(), Record);
920 Writer.AddDeclRef(D->UsingOrNextShadow, Record);
921 Writer.AddDeclRef(Context.getInstantiatedFromUsingShadowDecl(D), Record);
922 Code = serialization::DECL_USING_SHADOW;
925 void ASTDeclWriter::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
927 Writer.AddSourceLocation(D->getUsingLoc(), Record);
928 Writer.AddSourceLocation(D->getNamespaceKeyLocation(), Record);
929 Writer.AddNestedNameSpecifierLoc(D->getQualifierLoc(), Record);
930 Writer.AddDeclRef(D->getNominatedNamespace(), Record);
931 Writer.AddDeclRef(dyn_cast<Decl>(D->getCommonAncestor()), Record);
932 Code = serialization::DECL_USING_DIRECTIVE;
935 void ASTDeclWriter::VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) {
937 Writer.AddSourceLocation(D->getUsingLoc(), Record);
938 Writer.AddNestedNameSpecifierLoc(D->getQualifierLoc(), Record);
939 Writer.AddDeclarationNameLoc(D->DNLoc, D->getDeclName(), Record);
940 Code = serialization::DECL_UNRESOLVED_USING_VALUE;
943 void ASTDeclWriter::VisitUnresolvedUsingTypenameDecl(
944 UnresolvedUsingTypenameDecl *D) {
946 Writer.AddSourceLocation(D->getTypenameLoc(), Record);
947 Writer.AddNestedNameSpecifierLoc(D->getQualifierLoc(), Record);
948 Code = serialization::DECL_UNRESOLVED_USING_TYPENAME;
951 void ASTDeclWriter::VisitCXXRecordDecl(CXXRecordDecl *D) {
953 Record.push_back(D->isThisDeclarationADefinition());
954 if (D->isThisDeclarationADefinition())
955 Writer.AddCXXDefinitionData(D, Record);
958 CXXRecNotTemplate = 0, CXXRecTemplate, CXXRecMemberSpecialization
960 if (ClassTemplateDecl *TemplD = D->getDescribedClassTemplate()) {
961 Record.push_back(CXXRecTemplate);
962 Writer.AddDeclRef(TemplD, Record);
963 } else if (MemberSpecializationInfo *MSInfo
964 = D->getMemberSpecializationInfo()) {
965 Record.push_back(CXXRecMemberSpecialization);
966 Writer.AddDeclRef(MSInfo->getInstantiatedFrom(), Record);
967 Record.push_back(MSInfo->getTemplateSpecializationKind());
968 Writer.AddSourceLocation(MSInfo->getPointOfInstantiation(), Record);
970 Record.push_back(CXXRecNotTemplate);
973 // Store (what we currently believe to be) the key function to avoid
974 // deserializing every method so we can compute it.
975 if (D->IsCompleteDefinition)
976 Writer.AddDeclRef(Context.getCurrentKeyFunction(D), Record);
978 Code = serialization::DECL_CXX_RECORD;
981 void ASTDeclWriter::VisitCXXMethodDecl(CXXMethodDecl *D) {
982 VisitFunctionDecl(D);
983 if (D->isCanonicalDecl()) {
984 Record.push_back(D->size_overridden_methods());
985 for (CXXMethodDecl::method_iterator
986 I = D->begin_overridden_methods(), E = D->end_overridden_methods();
988 Writer.AddDeclRef(*I, Record);
990 // We only need to record overridden methods once for the canonical decl.
993 Code = serialization::DECL_CXX_METHOD;
996 void ASTDeclWriter::VisitCXXConstructorDecl(CXXConstructorDecl *D) {
997 VisitCXXMethodDecl(D);
999 Record.push_back(D->IsExplicitSpecified);
1000 Record.push_back(D->ImplicitlyDefined);
1001 Writer.AddCXXCtorInitializers(D->CtorInitializers, D->NumCtorInitializers,
1004 Code = serialization::DECL_CXX_CONSTRUCTOR;
1007 void ASTDeclWriter::VisitCXXDestructorDecl(CXXDestructorDecl *D) {
1008 VisitCXXMethodDecl(D);
1010 Record.push_back(D->ImplicitlyDefined);
1011 Writer.AddDeclRef(D->OperatorDelete, Record);
1013 Code = serialization::DECL_CXX_DESTRUCTOR;
1016 void ASTDeclWriter::VisitCXXConversionDecl(CXXConversionDecl *D) {
1017 VisitCXXMethodDecl(D);
1018 Record.push_back(D->IsExplicitSpecified);
1019 Code = serialization::DECL_CXX_CONVERSION;
1022 void ASTDeclWriter::VisitImportDecl(ImportDecl *D) {
1024 Record.push_back(Writer.getSubmoduleID(D->getImportedModule()));
1025 ArrayRef<SourceLocation> IdentifierLocs = D->getIdentifierLocs();
1026 Record.push_back(!IdentifierLocs.empty());
1027 if (IdentifierLocs.empty()) {
1028 Writer.AddSourceLocation(D->getLocEnd(), Record);
1029 Record.push_back(1);
1031 for (unsigned I = 0, N = IdentifierLocs.size(); I != N; ++I)
1032 Writer.AddSourceLocation(IdentifierLocs[I], Record);
1033 Record.push_back(IdentifierLocs.size());
1035 // Note: the number of source locations must always be the last element in
1037 Code = serialization::DECL_IMPORT;
1040 void ASTDeclWriter::VisitAccessSpecDecl(AccessSpecDecl *D) {
1042 Writer.AddSourceLocation(D->getColonLoc(), Record);
1043 Code = serialization::DECL_ACCESS_SPEC;
1046 void ASTDeclWriter::VisitFriendDecl(FriendDecl *D) {
1047 // Record the number of friend type template parameter lists here
1048 // so as to simplify memory allocation during deserialization.
1049 Record.push_back(D->NumTPLists);
1051 bool hasFriendDecl = D->Friend.is<NamedDecl*>();
1052 Record.push_back(hasFriendDecl);
1054 Writer.AddDeclRef(D->getFriendDecl(), Record);
1056 Writer.AddTypeSourceInfo(D->getFriendType(), Record);
1057 for (unsigned i = 0; i < D->NumTPLists; ++i)
1058 Writer.AddTemplateParameterList(D->getFriendTypeTemplateParameterList(i),
1060 Writer.AddDeclRef(D->getNextFriend(), Record);
1061 Record.push_back(D->UnsupportedFriend);
1062 Writer.AddSourceLocation(D->FriendLoc, Record);
1063 Code = serialization::DECL_FRIEND;
1066 void ASTDeclWriter::VisitFriendTemplateDecl(FriendTemplateDecl *D) {
1068 Record.push_back(D->getNumTemplateParameters());
1069 for (unsigned i = 0, e = D->getNumTemplateParameters(); i != e; ++i)
1070 Writer.AddTemplateParameterList(D->getTemplateParameterList(i), Record);
1071 Record.push_back(D->getFriendDecl() != 0);
1072 if (D->getFriendDecl())
1073 Writer.AddDeclRef(D->getFriendDecl(), Record);
1075 Writer.AddTypeSourceInfo(D->getFriendType(), Record);
1076 Writer.AddSourceLocation(D->getFriendLoc(), Record);
1077 Code = serialization::DECL_FRIEND_TEMPLATE;
1080 void ASTDeclWriter::VisitTemplateDecl(TemplateDecl *D) {
1083 Writer.AddDeclRef(D->getTemplatedDecl(), Record);
1084 Writer.AddTemplateParameterList(D->getTemplateParameters(), Record);
1087 void ASTDeclWriter::VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D) {
1088 VisitRedeclarable(D);
1090 // Emit data to initialize CommonOrPrev before VisitTemplateDecl so that
1091 // getCommonPtr() can be used while this is still initializing.
1092 if (D->isFirstDeclaration()) {
1093 // This declaration owns the 'common' pointer, so serialize that data now.
1094 Writer.AddDeclRef(D->getInstantiatedFromMemberTemplate(), Record);
1095 if (D->getInstantiatedFromMemberTemplate())
1096 Record.push_back(D->isMemberSpecialization());
1099 VisitTemplateDecl(D);
1100 Record.push_back(D->getIdentifierNamespace());
1103 void ASTDeclWriter::VisitClassTemplateDecl(ClassTemplateDecl *D) {
1104 VisitRedeclarableTemplateDecl(D);
1106 if (D->isFirstDeclaration()) {
1107 typedef llvm::FoldingSetVector<ClassTemplateSpecializationDecl> CTSDSetTy;
1108 CTSDSetTy &CTSDSet = D->getSpecializations();
1109 Record.push_back(CTSDSet.size());
1110 for (CTSDSetTy::iterator I=CTSDSet.begin(), E = CTSDSet.end(); I!=E; ++I) {
1111 assert(I->isCanonicalDecl() && "Expected only canonical decls in set");
1112 Writer.AddDeclRef(&*I, Record);
1115 typedef llvm::FoldingSetVector<ClassTemplatePartialSpecializationDecl>
1117 CTPSDSetTy &CTPSDSet = D->getPartialSpecializations();
1118 Record.push_back(CTPSDSet.size());
1119 for (CTPSDSetTy::iterator I=CTPSDSet.begin(), E=CTPSDSet.end(); I!=E; ++I) {
1120 assert(I->isCanonicalDecl() && "Expected only canonical decls in set");
1121 Writer.AddDeclRef(&*I, Record);
1124 Writer.AddTypeRef(D->getCommonPtr()->InjectedClassNameType, Record);
1126 Code = serialization::DECL_CLASS_TEMPLATE;
1129 void ASTDeclWriter::VisitClassTemplateSpecializationDecl(
1130 ClassTemplateSpecializationDecl *D) {
1131 VisitCXXRecordDecl(D);
1133 llvm::PointerUnion<ClassTemplateDecl *,
1134 ClassTemplatePartialSpecializationDecl *> InstFrom
1135 = D->getSpecializedTemplateOrPartial();
1136 if (Decl *InstFromD = InstFrom.dyn_cast<ClassTemplateDecl *>()) {
1137 Writer.AddDeclRef(InstFromD, Record);
1139 Writer.AddDeclRef(InstFrom.get<ClassTemplatePartialSpecializationDecl *>(),
1141 Writer.AddTemplateArgumentList(&D->getTemplateInstantiationArgs(), Record);
1145 Writer.AddTypeSourceInfo(D->getTypeAsWritten(), Record);
1146 if (D->getTypeAsWritten()) {
1147 Writer.AddSourceLocation(D->getExternLoc(), Record);
1148 Writer.AddSourceLocation(D->getTemplateKeywordLoc(), Record);
1151 Writer.AddTemplateArgumentList(&D->getTemplateArgs(), Record);
1152 Writer.AddSourceLocation(D->getPointOfInstantiation(), Record);
1153 Record.push_back(D->getSpecializationKind());
1154 Record.push_back(D->isCanonicalDecl());
1156 if (D->isCanonicalDecl()) {
1157 // When reading, we'll add it to the folding set of the following template.
1158 Writer.AddDeclRef(D->getSpecializedTemplate()->getCanonicalDecl(), Record);
1161 Code = serialization::DECL_CLASS_TEMPLATE_SPECIALIZATION;
1164 void ASTDeclWriter::VisitClassTemplatePartialSpecializationDecl(
1165 ClassTemplatePartialSpecializationDecl *D) {
1166 VisitClassTemplateSpecializationDecl(D);
1168 Writer.AddTemplateParameterList(D->getTemplateParameters(), Record);
1170 Record.push_back(D->getNumTemplateArgsAsWritten());
1171 for (int i = 0, e = D->getNumTemplateArgsAsWritten(); i != e; ++i)
1172 Writer.AddTemplateArgumentLoc(D->getTemplateArgsAsWritten()[i], Record);
1174 Record.push_back(D->getSequenceNumber());
1176 // These are read/set from/to the first declaration.
1177 if (D->getPreviousDecl() == 0) {
1178 Writer.AddDeclRef(D->getInstantiatedFromMember(), Record);
1179 Record.push_back(D->isMemberSpecialization());
1182 Code = serialization::DECL_CLASS_TEMPLATE_PARTIAL_SPECIALIZATION;
1185 void ASTDeclWriter::VisitClassScopeFunctionSpecializationDecl(
1186 ClassScopeFunctionSpecializationDecl *D) {
1188 Writer.AddDeclRef(D->getSpecialization(), Record);
1189 Code = serialization::DECL_CLASS_SCOPE_FUNCTION_SPECIALIZATION;
1193 void ASTDeclWriter::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
1194 VisitRedeclarableTemplateDecl(D);
1196 if (D->isFirstDeclaration()) {
1197 // This FunctionTemplateDecl owns the CommonPtr; write it.
1199 // Write the function specialization declarations.
1200 Record.push_back(D->getSpecializations().size());
1201 for (llvm::FoldingSetVector<FunctionTemplateSpecializationInfo>::iterator
1202 I = D->getSpecializations().begin(),
1203 E = D->getSpecializations().end() ; I != E; ++I) {
1204 assert(I->Function->isCanonicalDecl() &&
1205 "Expected only canonical decls in set");
1206 Writer.AddDeclRef(I->Function, Record);
1209 Code = serialization::DECL_FUNCTION_TEMPLATE;
1212 void ASTDeclWriter::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
1215 Record.push_back(D->wasDeclaredWithTypename());
1216 Record.push_back(D->defaultArgumentWasInherited());
1217 Writer.AddTypeSourceInfo(D->getDefaultArgumentInfo(), Record);
1219 Code = serialization::DECL_TEMPLATE_TYPE_PARM;
1222 void ASTDeclWriter::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) {
1223 // For an expanded parameter pack, record the number of expansion types here
1224 // so that it's easier for deserialization to allocate the right amount of
1226 if (D->isExpandedParameterPack())
1227 Record.push_back(D->getNumExpansionTypes());
1229 VisitDeclaratorDecl(D);
1230 // TemplateParmPosition.
1231 Record.push_back(D->getDepth());
1232 Record.push_back(D->getPosition());
1234 if (D->isExpandedParameterPack()) {
1235 for (unsigned I = 0, N = D->getNumExpansionTypes(); I != N; ++I) {
1236 Writer.AddTypeRef(D->getExpansionType(I), Record);
1237 Writer.AddTypeSourceInfo(D->getExpansionTypeSourceInfo(I), Record);
1240 Code = serialization::DECL_EXPANDED_NON_TYPE_TEMPLATE_PARM_PACK;
1242 // Rest of NonTypeTemplateParmDecl.
1243 Record.push_back(D->isParameterPack());
1244 Record.push_back(D->getDefaultArgument() != 0);
1245 if (D->getDefaultArgument()) {
1246 Writer.AddStmt(D->getDefaultArgument());
1247 Record.push_back(D->defaultArgumentWasInherited());
1249 Code = serialization::DECL_NON_TYPE_TEMPLATE_PARM;
1253 void ASTDeclWriter::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) {
1254 // For an expanded parameter pack, record the number of expansion types here
1255 // so that it's easier for deserialization to allocate the right amount of
1257 if (D->isExpandedParameterPack())
1258 Record.push_back(D->getNumExpansionTemplateParameters());
1260 VisitTemplateDecl(D);
1261 // TemplateParmPosition.
1262 Record.push_back(D->getDepth());
1263 Record.push_back(D->getPosition());
1265 if (D->isExpandedParameterPack()) {
1266 for (unsigned I = 0, N = D->getNumExpansionTemplateParameters();
1268 Writer.AddTemplateParameterList(D->getExpansionTemplateParameters(I),
1270 Code = serialization::DECL_EXPANDED_TEMPLATE_TEMPLATE_PARM_PACK;
1272 // Rest of TemplateTemplateParmDecl.
1273 Writer.AddTemplateArgumentLoc(D->getDefaultArgument(), Record);
1274 Record.push_back(D->defaultArgumentWasInherited());
1275 Record.push_back(D->isParameterPack());
1276 Code = serialization::DECL_TEMPLATE_TEMPLATE_PARM;
1280 void ASTDeclWriter::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) {
1281 VisitRedeclarableTemplateDecl(D);
1282 Code = serialization::DECL_TYPE_ALIAS_TEMPLATE;
1285 void ASTDeclWriter::VisitStaticAssertDecl(StaticAssertDecl *D) {
1287 Writer.AddStmt(D->getAssertExpr());
1288 Record.push_back(D->isFailed());
1289 Writer.AddStmt(D->getMessage());
1290 Writer.AddSourceLocation(D->getRParenLoc(), Record);
1291 Code = serialization::DECL_STATIC_ASSERT;
1294 /// \brief Emit the DeclContext part of a declaration context decl.
1296 /// \param LexicalOffset the offset at which the DECL_CONTEXT_LEXICAL
1297 /// block for this declaration context is stored. May be 0 to indicate
1298 /// that there are no declarations stored within this context.
1300 /// \param VisibleOffset the offset at which the DECL_CONTEXT_VISIBLE
1301 /// block for this declaration context is stored. May be 0 to indicate
1302 /// that there are no declarations visible from this context. Note
1303 /// that this value will not be emitted for non-primary declaration
1305 void ASTDeclWriter::VisitDeclContext(DeclContext *DC, uint64_t LexicalOffset,
1306 uint64_t VisibleOffset) {
1307 Record.push_back(LexicalOffset);
1308 Record.push_back(VisibleOffset);
1311 template <typename T>
1312 void ASTDeclWriter::VisitRedeclarable(Redeclarable<T> *D) {
1313 T *First = D->getFirstDeclaration();
1314 if (First->getMostRecentDecl() != First) {
1315 assert(isRedeclarableDeclKind(static_cast<T *>(D)->getKind()) &&
1316 "Not considered redeclarable?");
1318 // There is more than one declaration of this entity, so we will need to
1319 // write a redeclaration chain.
1320 Writer.AddDeclRef(First, Record);
1321 Writer.Redeclarations.insert(First);
1323 // Make sure that we serialize both the previous and the most-recent
1324 // declarations, which (transitively) ensures that all declarations in the
1325 // chain get serialized.
1326 (void)Writer.GetDeclRef(D->getPreviousDecl());
1327 (void)Writer.GetDeclRef(First->getMostRecentDecl());
1329 // We use the sentinel value 0 to indicate an only declaration.
1330 Record.push_back(0);
1335 void ASTDeclWriter::VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D) {
1336 Record.push_back(D->varlist_size());
1338 for (OMPThreadPrivateDecl::varlist_iterator I = D->varlist_begin(),
1339 E = D->varlist_end();
1342 Code = serialization::DECL_OMP_THREADPRIVATE;
1345 //===----------------------------------------------------------------------===//
1346 // ASTWriter Implementation
1347 //===----------------------------------------------------------------------===//
1349 void ASTWriter::WriteDeclsBlockAbbrevs() {
1350 using namespace llvm;
1354 // Abbreviation for DECL_FIELD
1355 Abv = new BitCodeAbbrev();
1356 Abv->Add(BitCodeAbbrevOp(serialization::DECL_FIELD));
1358 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
1359 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalDeclContext
1360 Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl
1361 Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs
1362 Abv->Add(BitCodeAbbrevOp(0)); // isImplicit
1363 Abv->Add(BitCodeAbbrevOp(0)); // isUsed
1364 Abv->Add(BitCodeAbbrevOp(0)); // isReferenced
1365 Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer
1366 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // AccessSpecifier
1367 Abv->Add(BitCodeAbbrevOp(0)); // ModulePrivate
1368 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
1370 Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier
1371 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
1373 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
1375 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerStartLoc
1376 Abv->Add(BitCodeAbbrevOp(0)); // hasExtInfo
1378 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isMutable
1379 Abv->Add(BitCodeAbbrevOp(0)); //getBitWidth
1381 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1382 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
1383 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc
1384 DeclFieldAbbrev = Stream.EmitAbbrev(Abv);
1386 // Abbreviation for DECL_OBJC_IVAR
1387 Abv = new BitCodeAbbrev();
1388 Abv->Add(BitCodeAbbrevOp(serialization::DECL_OBJC_IVAR));
1390 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
1391 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalDeclContext
1392 Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl
1393 Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs
1394 Abv->Add(BitCodeAbbrevOp(0)); // isImplicit
1395 Abv->Add(BitCodeAbbrevOp(0)); // isUsed
1396 Abv->Add(BitCodeAbbrevOp(0)); // isReferenced
1397 Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer
1398 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // AccessSpecifier
1399 Abv->Add(BitCodeAbbrevOp(0)); // ModulePrivate
1400 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
1402 Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier
1403 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
1405 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
1407 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerStartLoc
1408 Abv->Add(BitCodeAbbrevOp(0)); // hasExtInfo
1410 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isMutable
1411 Abv->Add(BitCodeAbbrevOp(0)); //getBitWidth
1413 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getAccessControl
1414 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getSynthesize
1416 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1417 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
1418 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc
1419 DeclObjCIvarAbbrev = Stream.EmitAbbrev(Abv);
1421 // Abbreviation for DECL_ENUM
1422 Abv = new BitCodeAbbrev();
1423 Abv->Add(BitCodeAbbrevOp(serialization::DECL_ENUM));
1425 Abv->Add(BitCodeAbbrevOp(0)); // No redeclaration
1427 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
1428 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalDeclContext
1429 Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl
1430 Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs
1431 Abv->Add(BitCodeAbbrevOp(0)); // isImplicit
1432 Abv->Add(BitCodeAbbrevOp(0)); // isUsed
1433 Abv->Add(BitCodeAbbrevOp(0)); // isReferenced
1434 Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer
1435 Abv->Add(BitCodeAbbrevOp(AS_none)); // C++ AccessSpecifier
1436 Abv->Add(BitCodeAbbrevOp(0)); // ModulePrivate
1437 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
1439 Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier
1440 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
1442 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Source Location
1443 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type Ref
1445 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // IdentifierNamespace
1446 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getTagKind
1447 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isCompleteDefinition
1448 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // EmbeddedInDeclarator
1449 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsFreeStanding
1450 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SourceLocation
1451 Abv->Add(BitCodeAbbrevOp(0)); // hasExtInfo
1452 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypedefNameAnonDecl
1454 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // AddTypeRef
1455 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // IntegerType
1456 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getPromotionType
1457 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getNumPositiveBits
1458 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getNumNegativeBits
1459 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isScoped
1460 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isScopedUsingClassTag
1461 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isFixed
1462 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InstantiatedMembEnum
1464 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalOffset
1465 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // VisibleOffset
1466 DeclEnumAbbrev = Stream.EmitAbbrev(Abv);
1468 // Abbreviation for DECL_RECORD
1469 Abv = new BitCodeAbbrev();
1470 Abv->Add(BitCodeAbbrevOp(serialization::DECL_RECORD));
1472 Abv->Add(BitCodeAbbrevOp(0)); // No redeclaration
1474 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
1475 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalDeclContext
1476 Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl
1477 Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs
1478 Abv->Add(BitCodeAbbrevOp(0)); // isImplicit
1479 Abv->Add(BitCodeAbbrevOp(0)); // isUsed
1480 Abv->Add(BitCodeAbbrevOp(0)); // isReferenced
1481 Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer
1482 Abv->Add(BitCodeAbbrevOp(AS_none)); // C++ AccessSpecifier
1483 Abv->Add(BitCodeAbbrevOp(0)); // ModulePrivate
1484 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
1486 Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier
1487 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
1489 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Source Location
1490 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type Ref
1492 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // IdentifierNamespace
1493 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getTagKind
1494 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isCompleteDefinition
1495 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // EmbeddedInDeclarator
1496 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsFreeStanding
1497 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SourceLocation
1498 Abv->Add(BitCodeAbbrevOp(0)); // hasExtInfo
1499 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypedefNameAnonDecl
1501 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // FlexibleArrayMember
1502 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // AnonymousStructUnion
1503 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // hasObjectMember
1504 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // hasVolatileMember
1506 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalOffset
1507 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // VisibleOffset
1508 DeclRecordAbbrev = Stream.EmitAbbrev(Abv);
1510 // Abbreviation for DECL_PARM_VAR
1511 Abv = new BitCodeAbbrev();
1512 Abv->Add(BitCodeAbbrevOp(serialization::DECL_PARM_VAR));
1514 Abv->Add(BitCodeAbbrevOp(0)); // No redeclaration
1516 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
1517 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalDeclContext
1518 Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl
1519 Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs
1520 Abv->Add(BitCodeAbbrevOp(0)); // isImplicit
1521 Abv->Add(BitCodeAbbrevOp(0)); // isUsed
1522 Abv->Add(BitCodeAbbrevOp(0)); // isReferenced
1523 Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer
1524 Abv->Add(BitCodeAbbrevOp(AS_none)); // C++ AccessSpecifier
1525 Abv->Add(BitCodeAbbrevOp(0)); // ModulePrivate
1526 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
1528 Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier
1529 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
1531 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
1533 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerStartLoc
1534 Abv->Add(BitCodeAbbrevOp(0)); // hasExtInfo
1536 Abv->Add(BitCodeAbbrevOp(0)); // StorageClass
1537 Abv->Add(BitCodeAbbrevOp(0)); // getTSCSpec
1538 Abv->Add(BitCodeAbbrevOp(0)); // hasCXXDirectInitializer
1539 Abv->Add(BitCodeAbbrevOp(0)); // isExceptionVariable
1540 Abv->Add(BitCodeAbbrevOp(0)); // isNRVOVariable
1541 Abv->Add(BitCodeAbbrevOp(0)); // isCXXForRangeDecl
1542 Abv->Add(BitCodeAbbrevOp(0)); // isARCPseudoStrong
1543 Abv->Add(BitCodeAbbrevOp(0)); // isConstexpr
1544 Abv->Add(BitCodeAbbrevOp(0)); // Linkage
1545 Abv->Add(BitCodeAbbrevOp(0)); // HasInit
1546 Abv->Add(BitCodeAbbrevOp(0)); // HasMemberSpecializationInfo
1548 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsObjCMethodParameter
1549 Abv->Add(BitCodeAbbrevOp(0)); // ScopeDepth
1550 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // ScopeIndex
1551 Abv->Add(BitCodeAbbrevOp(0)); // ObjCDeclQualifier
1552 Abv->Add(BitCodeAbbrevOp(0)); // KNRPromoted
1553 Abv->Add(BitCodeAbbrevOp(0)); // HasInheritedDefaultArg
1554 Abv->Add(BitCodeAbbrevOp(0)); // HasUninstantiatedDefaultArg
1556 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1557 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
1558 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc
1559 DeclParmVarAbbrev = Stream.EmitAbbrev(Abv);
1561 // Abbreviation for DECL_TYPEDEF
1562 Abv = new BitCodeAbbrev();
1563 Abv->Add(BitCodeAbbrevOp(serialization::DECL_TYPEDEF));
1565 Abv->Add(BitCodeAbbrevOp(0)); // No redeclaration
1567 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
1568 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalDeclContext
1569 Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl
1570 Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs
1571 Abv->Add(BitCodeAbbrevOp(0)); // isImplicit
1572 Abv->Add(BitCodeAbbrevOp(0)); // isUsed
1573 Abv->Add(BitCodeAbbrevOp(0)); // isReferenced
1574 Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer
1575 Abv->Add(BitCodeAbbrevOp(AS_none)); // C++ AccessSpecifier
1576 Abv->Add(BitCodeAbbrevOp(0)); // ModulePrivate
1577 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
1579 Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier
1580 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
1582 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Source Location
1583 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type Ref
1585 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
1586 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc
1587 DeclTypedefAbbrev = Stream.EmitAbbrev(Abv);
1589 // Abbreviation for DECL_VAR
1590 Abv = new BitCodeAbbrev();
1591 Abv->Add(BitCodeAbbrevOp(serialization::DECL_VAR));
1593 Abv->Add(BitCodeAbbrevOp(0)); // No redeclaration
1595 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
1596 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalDeclContext
1597 Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl
1598 Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs
1599 Abv->Add(BitCodeAbbrevOp(0)); // isImplicit
1600 Abv->Add(BitCodeAbbrevOp(0)); // isUsed
1601 Abv->Add(BitCodeAbbrevOp(0)); // isReferenced
1602 Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer
1603 Abv->Add(BitCodeAbbrevOp(AS_none)); // C++ AccessSpecifier
1604 Abv->Add(BitCodeAbbrevOp(0)); // ModulePrivate
1605 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
1607 Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier
1608 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
1610 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
1612 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerStartLoc
1613 Abv->Add(BitCodeAbbrevOp(0)); // hasExtInfo
1615 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // StorageClass
1616 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // getTSCSpec
1617 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // CXXDirectInitializer
1618 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isExceptionVariable
1619 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isNRVOVariable
1620 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isCXXForRangeDecl
1621 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isARCPseudoStrong
1622 Abv->Add(BitCodeAbbrevOp(0)); // isConstexpr
1623 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // Linkage
1624 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // HasInit
1625 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // HasMemberSpecInfo
1627 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1628 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
1629 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc
1630 DeclVarAbbrev = Stream.EmitAbbrev(Abv);
1632 // Abbreviation for EXPR_DECL_REF
1633 Abv = new BitCodeAbbrev();
1634 Abv->Add(BitCodeAbbrevOp(serialization::EXPR_DECL_REF));
1637 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
1638 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //TypeDependent
1639 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //ValueDependent
1640 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //InstantiationDependent
1641 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //UnexpandedParamPack
1642 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetValueKind
1643 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetObjectKind
1645 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //HasQualifier
1646 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //GetDeclFound
1647 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //ExplicitTemplateArgs
1648 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //HadMultipleCandidates
1649 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //RefersToEnclosingLocal
1650 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclRef
1651 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Location
1652 DeclRefExprAbbrev = Stream.EmitAbbrev(Abv);
1654 // Abbreviation for EXPR_INTEGER_LITERAL
1655 Abv = new BitCodeAbbrev();
1656 Abv->Add(BitCodeAbbrevOp(serialization::EXPR_INTEGER_LITERAL));
1659 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
1660 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //TypeDependent
1661 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //ValueDependent
1662 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //InstantiationDependent
1663 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //UnexpandedParamPack
1664 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetValueKind
1665 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetObjectKind
1667 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Location
1668 Abv->Add(BitCodeAbbrevOp(32)); // Bit Width
1669 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Value
1670 IntegerLiteralAbbrev = Stream.EmitAbbrev(Abv);
1672 // Abbreviation for EXPR_CHARACTER_LITERAL
1673 Abv = new BitCodeAbbrev();
1674 Abv->Add(BitCodeAbbrevOp(serialization::EXPR_CHARACTER_LITERAL));
1677 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
1678 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //TypeDependent
1679 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //ValueDependent
1680 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //InstantiationDependent
1681 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //UnexpandedParamPack
1682 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetValueKind
1683 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetObjectKind
1685 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getValue
1686 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Location
1687 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // getKind
1688 CharacterLiteralAbbrev = Stream.EmitAbbrev(Abv);
1690 Abv = new BitCodeAbbrev();
1691 Abv->Add(BitCodeAbbrevOp(serialization::DECL_CONTEXT_LEXICAL));
1692 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1693 DeclContextLexicalAbbrev = Stream.EmitAbbrev(Abv);
1695 Abv = new BitCodeAbbrev();
1696 Abv->Add(BitCodeAbbrevOp(serialization::DECL_CONTEXT_VISIBLE));
1697 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
1698 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1699 DeclContextVisibleLookupAbbrev = Stream.EmitAbbrev(Abv);
1702 /// isRequiredDecl - Check if this is a "required" Decl, which must be seen by
1703 /// consumers of the AST.
1705 /// Such decls will always be deserialized from the AST file, so we would like
1706 /// this to be as restrictive as possible. Currently the predicate is driven by
1707 /// code generation requirements, if other clients have a different notion of
1708 /// what is "required" then we may have to consider an alternate scheme where
1709 /// clients can iterate over the top-level decls and get information on them,
1710 /// without necessary deserializing them. We could explicitly require such
1711 /// clients to use a separate API call to "realize" the decl. This should be
1712 /// relatively painless since they would presumably only do it for top-level
1714 static bool isRequiredDecl(const Decl *D, ASTContext &Context) {
1715 // An ObjCMethodDecl is never considered as "required" because its
1716 // implementation container always is.
1718 // File scoped assembly or obj-c implementation must be seen.
1719 if (isa<FileScopeAsmDecl>(D) || isa<ObjCImplDecl>(D))
1722 return Context.DeclMustBeEmitted(D);
1725 void ASTWriter::WriteDecl(ASTContext &Context, Decl *D) {
1726 // Switch case IDs are per Decl.
1727 ClearSwitchCaseIDs();
1730 ASTDeclWriter W(*this, Context, Record);
1732 // Determine the ID for this declaration.
1733 serialization::DeclID ID;
1734 if (D->isFromASTFile())
1737 serialization::DeclID &IDR = DeclIDs[D];
1744 bool isReplacingADecl = ID < FirstDeclID;
1746 // If this declaration is also a DeclContext, write blocks for the
1747 // declarations that lexically stored inside its context and those
1748 // declarations that are visible from its context. These blocks
1749 // are written before the declaration itself so that we can put
1750 // their offsets into the record for the declaration.
1751 uint64_t LexicalOffset = 0;
1752 uint64_t VisibleOffset = 0;
1753 DeclContext *DC = dyn_cast<DeclContext>(D);
1755 if (isReplacingADecl) {
1756 // It is replacing a decl from a chained PCH; make sure that the
1757 // DeclContext is fully loaded.
1758 if (DC->hasExternalLexicalStorage())
1759 DC->LoadLexicalDeclsFromExternalStorage();
1760 if (DC->hasExternalVisibleStorage())
1761 Chain->completeVisibleDeclsMap(DC);
1763 LexicalOffset = WriteDeclContextLexicalBlock(Context, DC);
1764 VisibleOffset = WriteDeclContextVisibleBlock(Context, DC);
1767 if (isReplacingADecl) {
1768 // We're replacing a decl in a previous file.
1769 ReplacedDecls.push_back(ReplacedDeclInfo(ID, Stream.GetCurrentBitNo(),
1772 unsigned Index = ID - FirstDeclID;
1774 // Record the offset for this declaration
1775 SourceLocation Loc = D->getLocation();
1776 if (DeclOffsets.size() == Index)
1777 DeclOffsets.push_back(DeclOffset(Loc, Stream.GetCurrentBitNo()));
1778 else if (DeclOffsets.size() < Index) {
1779 DeclOffsets.resize(Index+1);
1780 DeclOffsets[Index].setLocation(Loc);
1781 DeclOffsets[Index].BitOffset = Stream.GetCurrentBitNo();
1784 SourceManager &SM = Context.getSourceManager();
1785 if (Loc.isValid() && SM.isLocalSourceLocation(Loc))
1786 associateDeclWithFile(D, ID);
1789 // Build and emit a record for this declaration
1791 W.Code = (serialization::DeclCode)0;
1794 if (DC) W.VisitDeclContext(DC, LexicalOffset, VisibleOffset);
1797 llvm::report_fatal_error(StringRef("unexpected declaration kind '") +
1798 D->getDeclKindName() + "'");
1799 Stream.EmitRecord(W.Code, Record, W.AbbrevToUse);
1801 // Flush any expressions that were written as part of this declaration.
1804 // Flush C++ base specifiers, if there are any.
1805 FlushCXXBaseSpecifiers();
1807 // Note "external" declarations so that we can add them to a record in the
1810 // FIXME: This should be renamed, the predicate is much more complicated.
1811 if (isRequiredDecl(D, Context))
1812 ExternalDefinitions.push_back(ID);