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 "clang/Serialization/ASTReader.h"
16 #include "ASTCommon.h"
17 #include "clang/AST/DeclVisitor.h"
18 #include "clang/AST/DeclCXX.h"
19 #include "clang/AST/DeclTemplate.h"
20 #include "clang/AST/Expr.h"
21 #include "clang/AST/DeclContextInternals.h"
22 #include "clang/Basic/SourceManager.h"
23 #include "llvm/ADT/Twine.h"
24 #include "llvm/Bitcode/BitstreamWriter.h"
25 #include "llvm/Support/ErrorHandling.h"
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 VisitIndirectFieldDecl(IndirectFieldDecl *D);
85 void VisitVarDecl(VarDecl *D);
86 void VisitImplicitParamDecl(ImplicitParamDecl *D);
87 void VisitParmVarDecl(ParmVarDecl *D);
88 void VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D);
89 void VisitTemplateDecl(TemplateDecl *D);
90 void VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D);
91 void VisitClassTemplateDecl(ClassTemplateDecl *D);
92 void VisitFunctionTemplateDecl(FunctionTemplateDecl *D);
93 void VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D);
94 void VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D);
95 void VisitUsingDecl(UsingDecl *D);
96 void VisitUsingShadowDecl(UsingShadowDecl *D);
97 void VisitLinkageSpecDecl(LinkageSpecDecl *D);
98 void VisitFileScopeAsmDecl(FileScopeAsmDecl *D);
99 void VisitImportDecl(ImportDecl *D);
100 void VisitAccessSpecDecl(AccessSpecDecl *D);
101 void VisitFriendDecl(FriendDecl *D);
102 void VisitFriendTemplateDecl(FriendTemplateDecl *D);
103 void VisitStaticAssertDecl(StaticAssertDecl *D);
104 void VisitBlockDecl(BlockDecl *D);
106 void VisitDeclContext(DeclContext *DC, uint64_t LexicalOffset,
107 uint64_t VisibleOffset);
108 template <typename T> void VisitRedeclarable(Redeclarable<T> *D);
111 // FIXME: Put in the same order is DeclNodes.td?
112 void VisitObjCMethodDecl(ObjCMethodDecl *D);
113 void VisitObjCContainerDecl(ObjCContainerDecl *D);
114 void VisitObjCInterfaceDecl(ObjCInterfaceDecl *D);
115 void VisitObjCIvarDecl(ObjCIvarDecl *D);
116 void VisitObjCProtocolDecl(ObjCProtocolDecl *D);
117 void VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D);
118 void VisitObjCCategoryDecl(ObjCCategoryDecl *D);
119 void VisitObjCImplDecl(ObjCImplDecl *D);
120 void VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D);
121 void VisitObjCImplementationDecl(ObjCImplementationDecl *D);
122 void VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D);
123 void VisitObjCPropertyDecl(ObjCPropertyDecl *D);
124 void VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D);
128 void ASTDeclWriter::Visit(Decl *D) {
129 DeclVisitor<ASTDeclWriter>::Visit(D);
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);
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());
148 void 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());
154 Writer.WriteAttributes(ArrayRef<const Attr*>(D->getAttrs().begin(),
155 D->getAttrs().size()), Record);
156 Record.push_back(D->isImplicit());
157 Record.push_back(D->isUsed(false));
158 Record.push_back(D->isReferenced());
159 Record.push_back(D->isTopLevelDeclInObjCContainer());
160 Record.push_back(D->getAccess());
161 Record.push_back(D->isModulePrivate());
162 Record.push_back(Writer.inferSubmoduleIDFromLocation(D->getLocation()));
165 void ASTDeclWriter::VisitTranslationUnitDecl(TranslationUnitDecl *D) {
166 llvm_unreachable("Translation units aren't directly serialized");
169 void ASTDeclWriter::VisitNamedDecl(NamedDecl *D) {
171 Writer.AddDeclarationName(D->getDeclName(), Record);
174 void ASTDeclWriter::VisitTypeDecl(TypeDecl *D) {
176 Writer.AddSourceLocation(D->getLocStart(), Record);
177 Writer.AddTypeRef(QualType(D->getTypeForDecl(), 0), Record);
180 void ASTDeclWriter::VisitTypedefNameDecl(TypedefNameDecl *D) {
181 VisitRedeclarable(D);
183 Writer.AddTypeSourceInfo(D->getTypeSourceInfo(), Record);
186 void ASTDeclWriter::VisitTypedefDecl(TypedefDecl *D) {
187 VisitTypedefNameDecl(D);
188 if (!D->hasAttrs() &&
191 D->getFirstDeclaration() == D->getMostRecentDecl() &&
192 !D->isInvalidDecl() &&
193 !D->isReferenced() &&
194 !D->isTopLevelDeclInObjCContainer() &&
195 D->getAccess() == AS_none &&
196 !D->isModulePrivate() &&
197 D->getDeclName().getNameKind() == DeclarationName::Identifier)
198 AbbrevToUse = Writer.getDeclTypedefAbbrev();
200 Code = serialization::DECL_TYPEDEF;
203 void ASTDeclWriter::VisitTypeAliasDecl(TypeAliasDecl *D) {
204 VisitTypedefNameDecl(D);
205 Code = serialization::DECL_TYPEALIAS;
208 void ASTDeclWriter::VisitTagDecl(TagDecl *D) {
209 VisitRedeclarable(D);
211 Record.push_back(D->getIdentifierNamespace());
212 Record.push_back((unsigned)D->getTagKind()); // FIXME: stable encoding
213 Record.push_back(D->isCompleteDefinition());
214 Record.push_back(D->isEmbeddedInDeclarator());
215 Record.push_back(D->isFreeStanding());
216 Writer.AddSourceLocation(D->getRBraceLoc(), Record);
217 Record.push_back(D->hasExtInfo());
219 Writer.AddQualifierInfo(*D->getExtInfo(), Record);
221 Writer.AddDeclRef(D->getTypedefNameForAnonDecl(), Record);
224 void ASTDeclWriter::VisitEnumDecl(EnumDecl *D) {
226 Writer.AddTypeSourceInfo(D->getIntegerTypeSourceInfo(), Record);
227 if (!D->getIntegerTypeSourceInfo())
228 Writer.AddTypeRef(D->getIntegerType(), Record);
229 Writer.AddTypeRef(D->getPromotionType(), Record);
230 Record.push_back(D->getNumPositiveBits());
231 Record.push_back(D->getNumNegativeBits());
232 Record.push_back(D->isScoped());
233 Record.push_back(D->isScopedUsingClassTag());
234 Record.push_back(D->isFixed());
235 if (MemberSpecializationInfo *MemberInfo = D->getMemberSpecializationInfo()) {
236 Writer.AddDeclRef(MemberInfo->getInstantiatedFrom(), Record);
237 Record.push_back(MemberInfo->getTemplateSpecializationKind());
238 Writer.AddSourceLocation(MemberInfo->getPointOfInstantiation(), Record);
240 Writer.AddDeclRef(0, Record);
243 if (!D->hasAttrs() &&
247 D->getFirstDeclaration() == D->getMostRecentDecl() &&
248 !D->isInvalidDecl() &&
249 !D->isReferenced() &&
250 !D->isTopLevelDeclInObjCContainer() &&
251 D->getAccess() == AS_none &&
252 !D->isModulePrivate() &&
253 !CXXRecordDecl::classofKind(D->getKind()) &&
254 !D->getIntegerTypeSourceInfo() &&
255 D->getDeclName().getNameKind() == DeclarationName::Identifier)
256 AbbrevToUse = Writer.getDeclEnumAbbrev();
258 Code = serialization::DECL_ENUM;
261 void ASTDeclWriter::VisitRecordDecl(RecordDecl *D) {
263 Record.push_back(D->hasFlexibleArrayMember());
264 Record.push_back(D->isAnonymousStructOrUnion());
265 Record.push_back(D->hasObjectMember());
267 if (!D->hasAttrs() &&
271 D->getFirstDeclaration() == D->getMostRecentDecl() &&
272 !D->isInvalidDecl() &&
273 !D->isReferenced() &&
274 !D->isTopLevelDeclInObjCContainer() &&
275 D->getAccess() == AS_none &&
276 !D->isModulePrivate() &&
277 !CXXRecordDecl::classofKind(D->getKind()) &&
278 D->getDeclName().getNameKind() == DeclarationName::Identifier)
279 AbbrevToUse = Writer.getDeclRecordAbbrev();
281 Code = serialization::DECL_RECORD;
284 void ASTDeclWriter::VisitValueDecl(ValueDecl *D) {
286 Writer.AddTypeRef(D->getType(), Record);
289 void ASTDeclWriter::VisitEnumConstantDecl(EnumConstantDecl *D) {
291 Record.push_back(D->getInitExpr()? 1 : 0);
292 if (D->getInitExpr())
293 Writer.AddStmt(D->getInitExpr());
294 Writer.AddAPSInt(D->getInitVal(), Record);
296 Code = serialization::DECL_ENUM_CONSTANT;
299 void ASTDeclWriter::VisitDeclaratorDecl(DeclaratorDecl *D) {
301 Writer.AddSourceLocation(D->getInnerLocStart(), Record);
302 Record.push_back(D->hasExtInfo());
304 Writer.AddQualifierInfo(*D->getExtInfo(), Record);
307 void ASTDeclWriter::VisitFunctionDecl(FunctionDecl *D) {
308 VisitRedeclarable(D);
309 VisitDeclaratorDecl(D);
311 Writer.AddDeclarationNameLoc(D->DNLoc, D->getDeclName(), Record);
312 Record.push_back(D->getIdentifierNamespace());
314 // FunctionDecl's body is handled last at ASTWriterDecl::Visit,
315 // after everything else is written.
317 Record.push_back(D->getStorageClass()); // FIXME: stable encoding
318 Record.push_back(D->getStorageClassAsWritten());
319 Record.push_back(D->IsInline);
320 Record.push_back(D->isInlineSpecified());
321 Record.push_back(D->isVirtualAsWritten());
322 Record.push_back(D->isPure());
323 Record.push_back(D->hasInheritedPrototype());
324 Record.push_back(D->hasWrittenPrototype());
325 Record.push_back(D->isDeletedAsWritten());
326 Record.push_back(D->isTrivial());
327 Record.push_back(D->isDefaulted());
328 Record.push_back(D->isExplicitlyDefaulted());
329 Record.push_back(D->hasImplicitReturnZero());
330 Record.push_back(D->isConstexpr());
331 Writer.AddSourceLocation(D->getLocEnd(), Record);
333 Record.push_back(D->getTemplatedKind());
334 switch (D->getTemplatedKind()) {
335 case FunctionDecl::TK_NonTemplate:
337 case FunctionDecl::TK_FunctionTemplate:
338 Writer.AddDeclRef(D->getDescribedFunctionTemplate(), Record);
340 case FunctionDecl::TK_MemberSpecialization: {
341 MemberSpecializationInfo *MemberInfo = D->getMemberSpecializationInfo();
342 Writer.AddDeclRef(MemberInfo->getInstantiatedFrom(), Record);
343 Record.push_back(MemberInfo->getTemplateSpecializationKind());
344 Writer.AddSourceLocation(MemberInfo->getPointOfInstantiation(), Record);
347 case FunctionDecl::TK_FunctionTemplateSpecialization: {
348 FunctionTemplateSpecializationInfo *
349 FTSInfo = D->getTemplateSpecializationInfo();
350 Writer.AddDeclRef(FTSInfo->getTemplate(), Record);
351 Record.push_back(FTSInfo->getTemplateSpecializationKind());
353 // Template arguments.
354 Writer.AddTemplateArgumentList(FTSInfo->TemplateArguments, Record);
356 // Template args as written.
357 Record.push_back(FTSInfo->TemplateArgumentsAsWritten != 0);
358 if (FTSInfo->TemplateArgumentsAsWritten) {
359 Record.push_back(FTSInfo->TemplateArgumentsAsWritten->NumTemplateArgs);
360 for (int i=0, e = FTSInfo->TemplateArgumentsAsWritten->NumTemplateArgs;
362 Writer.AddTemplateArgumentLoc((*FTSInfo->TemplateArgumentsAsWritten)[i],
364 Writer.AddSourceLocation(FTSInfo->TemplateArgumentsAsWritten->LAngleLoc,
366 Writer.AddSourceLocation(FTSInfo->TemplateArgumentsAsWritten->RAngleLoc,
370 Writer.AddSourceLocation(FTSInfo->getPointOfInstantiation(), Record);
372 if (D->isCanonicalDecl()) {
373 // Write the template that contains the specializations set. We will
374 // add a FunctionTemplateSpecializationInfo to it when reading.
375 Writer.AddDeclRef(FTSInfo->getTemplate()->getCanonicalDecl(), Record);
379 case FunctionDecl::TK_DependentFunctionTemplateSpecialization: {
380 DependentFunctionTemplateSpecializationInfo *
381 DFTSInfo = D->getDependentSpecializationInfo();
384 Record.push_back(DFTSInfo->getNumTemplates());
385 for (int i=0, e = DFTSInfo->getNumTemplates(); i != e; ++i)
386 Writer.AddDeclRef(DFTSInfo->getTemplate(i), Record);
389 Record.push_back(DFTSInfo->getNumTemplateArgs());
390 for (int i=0, e = DFTSInfo->getNumTemplateArgs(); i != e; ++i)
391 Writer.AddTemplateArgumentLoc(DFTSInfo->getTemplateArg(i), Record);
392 Writer.AddSourceLocation(DFTSInfo->getLAngleLoc(), Record);
393 Writer.AddSourceLocation(DFTSInfo->getRAngleLoc(), Record);
398 Record.push_back(D->param_size());
399 for (FunctionDecl::param_iterator P = D->param_begin(), PEnd = D->param_end();
401 Writer.AddDeclRef(*P, Record);
402 Code = serialization::DECL_FUNCTION;
405 void ASTDeclWriter::VisitObjCMethodDecl(ObjCMethodDecl *D) {
407 // FIXME: convert to LazyStmtPtr?
408 // Unlike C/C++, method bodies will never be in header files.
409 bool HasBodyStuff = D->getBody() != 0 ||
410 D->getSelfDecl() != 0 || D->getCmdDecl() != 0;
411 Record.push_back(HasBodyStuff);
413 Writer.AddStmt(D->getBody());
414 Writer.AddDeclRef(D->getSelfDecl(), Record);
415 Writer.AddDeclRef(D->getCmdDecl(), Record);
417 Record.push_back(D->isInstanceMethod());
418 Record.push_back(D->isVariadic());
419 Record.push_back(D->isPropertyAccessor());
420 Record.push_back(D->isDefined());
421 Record.push_back(D->IsOverriding);
423 Record.push_back(D->IsRedeclaration);
424 Record.push_back(D->HasRedeclaration);
425 if (D->HasRedeclaration) {
426 assert(Context.getObjCMethodRedeclaration(D));
427 Writer.AddDeclRef(Context.getObjCMethodRedeclaration(D), Record);
430 // FIXME: stable encoding for @required/@optional
431 Record.push_back(D->getImplementationControl());
432 // FIXME: stable encoding for in/out/inout/bycopy/byref/oneway
433 Record.push_back(D->getObjCDeclQualifier());
434 Record.push_back(D->hasRelatedResultType());
435 Writer.AddTypeRef(D->getResultType(), Record);
436 Writer.AddTypeSourceInfo(D->getResultTypeSourceInfo(), Record);
437 Writer.AddSourceLocation(D->getLocEnd(), Record);
438 Record.push_back(D->param_size());
439 for (ObjCMethodDecl::param_iterator P = D->param_begin(),
440 PEnd = D->param_end(); P != PEnd; ++P)
441 Writer.AddDeclRef(*P, Record);
443 Record.push_back(D->SelLocsKind);
444 unsigned NumStoredSelLocs = D->getNumStoredSelLocs();
445 SourceLocation *SelLocs = D->getStoredSelLocs();
446 Record.push_back(NumStoredSelLocs);
447 for (unsigned i = 0; i != NumStoredSelLocs; ++i)
448 Writer.AddSourceLocation(SelLocs[i], Record);
450 Code = serialization::DECL_OBJC_METHOD;
453 void ASTDeclWriter::VisitObjCContainerDecl(ObjCContainerDecl *D) {
455 Writer.AddSourceLocation(D->getAtStartLoc(), Record);
456 Writer.AddSourceRange(D->getAtEndRange(), Record);
457 // Abstract class (no need to define a stable serialization::DECL code).
460 void ASTDeclWriter::VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) {
461 VisitRedeclarable(D);
462 VisitObjCContainerDecl(D);
463 Writer.AddTypeRef(QualType(D->getTypeForDecl(), 0), Record);
465 Record.push_back(D->isThisDeclarationADefinition());
466 if (D->isThisDeclarationADefinition()) {
467 // Write the DefinitionData
468 ObjCInterfaceDecl::DefinitionData &Data = D->data();
470 Writer.AddDeclRef(D->getSuperClass(), Record);
471 Writer.AddSourceLocation(D->getSuperClassLoc(), Record);
472 Writer.AddSourceLocation(D->getEndOfDefinitionLoc(), Record);
474 // Write out the protocols that are directly referenced by the @interface.
475 Record.push_back(Data.ReferencedProtocols.size());
476 for (ObjCInterfaceDecl::protocol_iterator P = D->protocol_begin(),
477 PEnd = D->protocol_end();
479 Writer.AddDeclRef(*P, Record);
480 for (ObjCInterfaceDecl::protocol_loc_iterator PL = D->protocol_loc_begin(),
481 PLEnd = D->protocol_loc_end();
483 Writer.AddSourceLocation(*PL, Record);
485 // Write out the protocols that are transitively referenced.
486 Record.push_back(Data.AllReferencedProtocols.size());
487 for (ObjCList<ObjCProtocolDecl>::iterator
488 P = Data.AllReferencedProtocols.begin(),
489 PEnd = Data.AllReferencedProtocols.end();
491 Writer.AddDeclRef(*P, Record);
493 if (ObjCCategoryDecl *Cat = D->getCategoryList()) {
494 // Ensure that we write out the set of categories for this class.
495 Writer.ObjCClassesWithCategories.insert(D);
497 // Make sure that the categories get serialized.
498 for (; Cat; Cat = Cat->getNextClassCategory())
499 (void)Writer.GetDeclRef(Cat);
503 Code = serialization::DECL_OBJC_INTERFACE;
506 void ASTDeclWriter::VisitObjCIvarDecl(ObjCIvarDecl *D) {
508 // FIXME: stable encoding for @public/@private/@protected/@package
509 Record.push_back(D->getAccessControl());
510 Record.push_back(D->getSynthesize());
512 if (!D->hasAttrs() &&
515 !D->isInvalidDecl() &&
516 !D->isReferenced() &&
517 !D->isModulePrivate() &&
521 AbbrevToUse = Writer.getDeclObjCIvarAbbrev();
523 Code = serialization::DECL_OBJC_IVAR;
526 void ASTDeclWriter::VisitObjCProtocolDecl(ObjCProtocolDecl *D) {
527 VisitRedeclarable(D);
528 VisitObjCContainerDecl(D);
530 Record.push_back(D->isThisDeclarationADefinition());
531 if (D->isThisDeclarationADefinition()) {
532 Record.push_back(D->protocol_size());
533 for (ObjCProtocolDecl::protocol_iterator
534 I = D->protocol_begin(), IEnd = D->protocol_end(); I != IEnd; ++I)
535 Writer.AddDeclRef(*I, Record);
536 for (ObjCProtocolDecl::protocol_loc_iterator PL = D->protocol_loc_begin(),
537 PLEnd = D->protocol_loc_end();
539 Writer.AddSourceLocation(*PL, Record);
542 Code = serialization::DECL_OBJC_PROTOCOL;
545 void ASTDeclWriter::VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D) {
547 Code = serialization::DECL_OBJC_AT_DEFS_FIELD;
550 void ASTDeclWriter::VisitObjCCategoryDecl(ObjCCategoryDecl *D) {
551 VisitObjCContainerDecl(D);
552 Writer.AddSourceLocation(D->getCategoryNameLoc(), Record);
553 Writer.AddSourceLocation(D->getIvarLBraceLoc(), Record);
554 Writer.AddSourceLocation(D->getIvarRBraceLoc(), Record);
555 Writer.AddDeclRef(D->getClassInterface(), Record);
556 Record.push_back(D->protocol_size());
557 for (ObjCCategoryDecl::protocol_iterator
558 I = D->protocol_begin(), IEnd = D->protocol_end(); I != IEnd; ++I)
559 Writer.AddDeclRef(*I, Record);
560 for (ObjCCategoryDecl::protocol_loc_iterator
561 PL = D->protocol_loc_begin(), PLEnd = D->protocol_loc_end();
563 Writer.AddSourceLocation(*PL, Record);
564 Code = serialization::DECL_OBJC_CATEGORY;
567 void ASTDeclWriter::VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D) {
569 Writer.AddDeclRef(D->getClassInterface(), Record);
570 Code = serialization::DECL_OBJC_COMPATIBLE_ALIAS;
573 void ASTDeclWriter::VisitObjCPropertyDecl(ObjCPropertyDecl *D) {
575 Writer.AddSourceLocation(D->getAtLoc(), Record);
576 Writer.AddSourceLocation(D->getLParenLoc(), Record);
577 Writer.AddTypeSourceInfo(D->getTypeSourceInfo(), Record);
578 // FIXME: stable encoding
579 Record.push_back((unsigned)D->getPropertyAttributes());
580 Record.push_back((unsigned)D->getPropertyAttributesAsWritten());
581 // FIXME: stable encoding
582 Record.push_back((unsigned)D->getPropertyImplementation());
583 Writer.AddDeclarationName(D->getGetterName(), Record);
584 Writer.AddDeclarationName(D->getSetterName(), Record);
585 Writer.AddDeclRef(D->getGetterMethodDecl(), Record);
586 Writer.AddDeclRef(D->getSetterMethodDecl(), Record);
587 Writer.AddDeclRef(D->getPropertyIvarDecl(), Record);
588 Code = serialization::DECL_OBJC_PROPERTY;
591 void ASTDeclWriter::VisitObjCImplDecl(ObjCImplDecl *D) {
592 VisitObjCContainerDecl(D);
593 Writer.AddDeclRef(D->getClassInterface(), Record);
594 // Abstract class (no need to define a stable serialization::DECL code).
597 void ASTDeclWriter::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
598 VisitObjCImplDecl(D);
599 Writer.AddIdentifierRef(D->getIdentifier(), Record);
600 Writer.AddSourceLocation(D->getCategoryNameLoc(), Record);
601 Code = serialization::DECL_OBJC_CATEGORY_IMPL;
604 void ASTDeclWriter::VisitObjCImplementationDecl(ObjCImplementationDecl *D) {
605 VisitObjCImplDecl(D);
606 Writer.AddDeclRef(D->getSuperClass(), Record);
607 Writer.AddSourceLocation(D->getIvarLBraceLoc(), Record);
608 Writer.AddSourceLocation(D->getIvarRBraceLoc(), Record);
609 Record.push_back(D->hasNonZeroConstructors());
610 Record.push_back(D->hasDestructors());
611 Writer.AddCXXCtorInitializers(D->IvarInitializers, D->NumIvarInitializers,
613 Code = serialization::DECL_OBJC_IMPLEMENTATION;
616 void ASTDeclWriter::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) {
618 Writer.AddSourceLocation(D->getLocStart(), Record);
619 Writer.AddDeclRef(D->getPropertyDecl(), Record);
620 Writer.AddDeclRef(D->getPropertyIvarDecl(), Record);
621 Writer.AddSourceLocation(D->getPropertyIvarDeclLoc(), Record);
622 Writer.AddStmt(D->getGetterCXXConstructor());
623 Writer.AddStmt(D->getSetterCXXAssignment());
624 Code = serialization::DECL_OBJC_PROPERTY_IMPL;
627 void ASTDeclWriter::VisitFieldDecl(FieldDecl *D) {
628 VisitDeclaratorDecl(D);
629 Record.push_back(D->isMutable());
630 if (D->InitializerOrBitWidth.getInt() != ICIS_NoInit ||
631 D->InitializerOrBitWidth.getPointer()) {
632 Record.push_back(D->InitializerOrBitWidth.getInt() + 1);
633 Writer.AddStmt(D->InitializerOrBitWidth.getPointer());
637 if (!D->getDeclName())
638 Writer.AddDeclRef(Context.getInstantiatedFromUnnamedFieldDecl(D), Record);
640 if (!D->hasAttrs() &&
643 !D->isInvalidDecl() &&
644 !D->isReferenced() &&
645 !D->isTopLevelDeclInObjCContainer() &&
646 !D->isModulePrivate() &&
648 !D->hasInClassInitializer() &&
650 !ObjCIvarDecl::classofKind(D->getKind()) &&
651 !ObjCAtDefsFieldDecl::classofKind(D->getKind()) &&
653 AbbrevToUse = Writer.getDeclFieldAbbrev();
655 Code = serialization::DECL_FIELD;
658 void ASTDeclWriter::VisitIndirectFieldDecl(IndirectFieldDecl *D) {
660 Record.push_back(D->getChainingSize());
662 for (IndirectFieldDecl::chain_iterator
663 P = D->chain_begin(),
664 PEnd = D->chain_end(); P != PEnd; ++P)
665 Writer.AddDeclRef(*P, Record);
666 Code = serialization::DECL_INDIRECTFIELD;
669 void ASTDeclWriter::VisitVarDecl(VarDecl *D) {
670 VisitRedeclarable(D);
671 VisitDeclaratorDecl(D);
672 Record.push_back(D->getStorageClass()); // FIXME: stable encoding
673 Record.push_back(D->getStorageClassAsWritten());
674 Record.push_back(D->isThreadSpecified());
675 Record.push_back(D->getInitStyle());
676 Record.push_back(D->isExceptionVariable());
677 Record.push_back(D->isNRVOVariable());
678 Record.push_back(D->isCXXForRangeDecl());
679 Record.push_back(D->isARCPseudoStrong());
680 Record.push_back(D->isConstexpr());
683 Record.push_back(!D->isInitKnownICE() ? 1 : (D->isInitICE() ? 3 : 2));
684 Writer.AddStmt(D->getInit());
689 MemberSpecializationInfo *SpecInfo
690 = D->isStaticDataMember() ? D->getMemberSpecializationInfo() : 0;
691 Record.push_back(SpecInfo != 0);
693 Writer.AddDeclRef(SpecInfo->getInstantiatedFrom(), Record);
694 Record.push_back(SpecInfo->getTemplateSpecializationKind());
695 Writer.AddSourceLocation(SpecInfo->getPointOfInstantiation(), Record);
698 if (!D->hasAttrs() &&
701 !D->isInvalidDecl() &&
702 !D->isReferenced() &&
703 !D->isTopLevelDeclInObjCContainer() &&
704 D->getAccess() == AS_none &&
705 !D->isModulePrivate() &&
706 D->getDeclName().getNameKind() == DeclarationName::Identifier &&
708 D->getFirstDeclaration() == D->getMostRecentDecl() &&
709 D->getInitStyle() == VarDecl::CInit &&
711 !isa<ParmVarDecl>(D) &&
714 AbbrevToUse = Writer.getDeclVarAbbrev();
716 Code = serialization::DECL_VAR;
719 void ASTDeclWriter::VisitImplicitParamDecl(ImplicitParamDecl *D) {
721 Code = serialization::DECL_IMPLICIT_PARAM;
724 void ASTDeclWriter::VisitParmVarDecl(ParmVarDecl *D) {
726 Record.push_back(D->isObjCMethodParameter());
727 Record.push_back(D->getFunctionScopeDepth());
728 Record.push_back(D->getFunctionScopeIndex());
729 Record.push_back(D->getObjCDeclQualifier()); // FIXME: stable encoding
730 Record.push_back(D->isKNRPromoted());
731 Record.push_back(D->hasInheritedDefaultArg());
732 Record.push_back(D->hasUninstantiatedDefaultArg());
733 if (D->hasUninstantiatedDefaultArg())
734 Writer.AddStmt(D->getUninstantiatedDefaultArg());
735 Code = serialization::DECL_PARM_VAR;
737 assert(!D->isARCPseudoStrong()); // can be true of ImplicitParamDecl
739 // If the assumptions about the DECL_PARM_VAR abbrev are true, use it. Here
740 // we dynamically check for the properties that we optimize for, but don't
741 // know are true of all PARM_VAR_DECLs.
742 if (!D->hasAttrs() &&
746 !D->isInvalidDecl() &&
747 !D->isReferenced() &&
748 D->getAccess() == AS_none &&
749 !D->isModulePrivate() &&
750 D->getStorageClass() == 0 &&
751 D->getInitStyle() == VarDecl::CInit && // Can params have anything else?
752 D->getFunctionScopeDepth() == 0 &&
753 D->getObjCDeclQualifier() == 0 &&
754 !D->isKNRPromoted() &&
755 !D->hasInheritedDefaultArg() &&
757 !D->hasUninstantiatedDefaultArg()) // No default expr.
758 AbbrevToUse = Writer.getDeclParmVarAbbrev();
760 // Check things we know are true of *every* PARM_VAR_DECL, which is more than
761 // just us assuming it.
762 assert(!D->isThreadSpecified() && "PARM_VAR_DECL can't be __thread");
763 assert(D->getAccess() == AS_none && "PARM_VAR_DECL can't be public/private");
764 assert(!D->isExceptionVariable() && "PARM_VAR_DECL can't be exception var");
765 assert(D->getPreviousDecl() == 0 && "PARM_VAR_DECL can't be redecl");
766 assert(!D->isStaticDataMember() &&
767 "PARM_VAR_DECL can't be static data member");
770 void ASTDeclWriter::VisitFileScopeAsmDecl(FileScopeAsmDecl *D) {
772 Writer.AddStmt(D->getAsmString());
773 Writer.AddSourceLocation(D->getRParenLoc(), Record);
774 Code = serialization::DECL_FILE_SCOPE_ASM;
777 void ASTDeclWriter::VisitBlockDecl(BlockDecl *D) {
779 Writer.AddStmt(D->getBody());
780 Writer.AddTypeSourceInfo(D->getSignatureAsWritten(), Record);
781 Record.push_back(D->param_size());
782 for (FunctionDecl::param_iterator P = D->param_begin(), PEnd = D->param_end();
784 Writer.AddDeclRef(*P, Record);
785 Record.push_back(D->isVariadic());
786 Record.push_back(D->blockMissingReturnType());
787 Record.push_back(D->isConversionFromLambda());
788 Record.push_back(D->capturesCXXThis());
789 Record.push_back(D->getNumCaptures());
790 for (BlockDecl::capture_iterator
791 i = D->capture_begin(), e = D->capture_end(); i != e; ++i) {
792 const BlockDecl::Capture &capture = *i;
793 Writer.AddDeclRef(capture.getVariable(), Record);
796 if (capture.isByRef()) flags |= 1;
797 if (capture.isNested()) flags |= 2;
798 if (capture.hasCopyExpr()) flags |= 4;
799 Record.push_back(flags);
801 if (capture.hasCopyExpr()) Writer.AddStmt(capture.getCopyExpr());
804 Code = serialization::DECL_BLOCK;
807 void ASTDeclWriter::VisitLinkageSpecDecl(LinkageSpecDecl *D) {
809 Record.push_back(D->getLanguage());
810 Writer.AddSourceLocation(D->getExternLoc(), Record);
811 Writer.AddSourceLocation(D->getRBraceLoc(), Record);
812 Code = serialization::DECL_LINKAGE_SPEC;
815 void ASTDeclWriter::VisitLabelDecl(LabelDecl *D) {
817 Writer.AddSourceLocation(D->getLocStart(), Record);
818 Code = serialization::DECL_LABEL;
822 void ASTDeclWriter::VisitNamespaceDecl(NamespaceDecl *D) {
823 VisitRedeclarable(D);
825 Record.push_back(D->isInline());
826 Writer.AddSourceLocation(D->getLocStart(), Record);
827 Writer.AddSourceLocation(D->getRBraceLoc(), Record);
829 if (D->isOriginalNamespace())
830 Writer.AddDeclRef(D->getAnonymousNamespace(), Record);
831 Code = serialization::DECL_NAMESPACE;
833 if (Writer.hasChain() && !D->isOriginalNamespace() &&
834 D->getOriginalNamespace()->isFromASTFile()) {
835 NamespaceDecl *NS = D->getOriginalNamespace();
836 Writer.AddUpdatedDeclContext(NS);
838 // Make sure all visible decls are written. They will be recorded later.
839 if (StoredDeclsMap *Map = NS->buildLookup()) {
840 for (StoredDeclsMap::iterator D = Map->begin(), DEnd = Map->end();
842 DeclContext::lookup_result Result = D->second.getLookupResult();
843 while (Result.first != Result.second) {
844 Writer.GetDeclRef(*Result.first);
851 if (Writer.hasChain() && D->isAnonymousNamespace() &&
852 D == D->getMostRecentDecl()) {
853 // This is a most recent reopening of the anonymous namespace. If its parent
854 // is in a previous PCH (or is the TU), mark that parent for update, because
855 // the original namespace always points to the latest re-opening of its
856 // anonymous namespace.
857 Decl *Parent = cast<Decl>(
858 D->getParent()->getRedeclContext()->getPrimaryContext());
859 if (Parent->isFromASTFile() || isa<TranslationUnitDecl>(Parent)) {
860 ASTWriter::UpdateRecord &Record = Writer.DeclUpdates[Parent];
861 Record.push_back(UPD_CXX_ADDED_ANONYMOUS_NAMESPACE);
862 Writer.AddDeclRef(D, Record);
867 void ASTDeclWriter::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) {
869 Writer.AddSourceLocation(D->getNamespaceLoc(), Record);
870 Writer.AddSourceLocation(D->getTargetNameLoc(), Record);
871 Writer.AddNestedNameSpecifierLoc(D->getQualifierLoc(), Record);
872 Writer.AddDeclRef(D->getNamespace(), Record);
873 Code = serialization::DECL_NAMESPACE_ALIAS;
876 void ASTDeclWriter::VisitUsingDecl(UsingDecl *D) {
878 Writer.AddSourceLocation(D->getUsingLocation(), Record);
879 Writer.AddNestedNameSpecifierLoc(D->getQualifierLoc(), Record);
880 Writer.AddDeclarationNameLoc(D->DNLoc, D->getDeclName(), Record);
881 Writer.AddDeclRef(D->FirstUsingShadow.getPointer(), Record);
882 Record.push_back(D->isTypeName());
883 Writer.AddDeclRef(Context.getInstantiatedFromUsingDecl(D), Record);
884 Code = serialization::DECL_USING;
887 void ASTDeclWriter::VisitUsingShadowDecl(UsingShadowDecl *D) {
889 Writer.AddDeclRef(D->getTargetDecl(), Record);
890 Writer.AddDeclRef(D->UsingOrNextShadow, Record);
891 Writer.AddDeclRef(Context.getInstantiatedFromUsingShadowDecl(D), Record);
892 Code = serialization::DECL_USING_SHADOW;
895 void ASTDeclWriter::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
897 Writer.AddSourceLocation(D->getUsingLoc(), Record);
898 Writer.AddSourceLocation(D->getNamespaceKeyLocation(), Record);
899 Writer.AddNestedNameSpecifierLoc(D->getQualifierLoc(), Record);
900 Writer.AddDeclRef(D->getNominatedNamespace(), Record);
901 Writer.AddDeclRef(dyn_cast<Decl>(D->getCommonAncestor()), Record);
902 Code = serialization::DECL_USING_DIRECTIVE;
905 void ASTDeclWriter::VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) {
907 Writer.AddSourceLocation(D->getUsingLoc(), Record);
908 Writer.AddNestedNameSpecifierLoc(D->getQualifierLoc(), Record);
909 Writer.AddDeclarationNameLoc(D->DNLoc, D->getDeclName(), Record);
910 Code = serialization::DECL_UNRESOLVED_USING_VALUE;
913 void ASTDeclWriter::VisitUnresolvedUsingTypenameDecl(
914 UnresolvedUsingTypenameDecl *D) {
916 Writer.AddSourceLocation(D->getTypenameLoc(), Record);
917 Writer.AddNestedNameSpecifierLoc(D->getQualifierLoc(), Record);
918 Code = serialization::DECL_UNRESOLVED_USING_TYPENAME;
921 void ASTDeclWriter::VisitCXXRecordDecl(CXXRecordDecl *D) {
923 Record.push_back(D->isThisDeclarationADefinition());
924 if (D->isThisDeclarationADefinition())
925 Writer.AddCXXDefinitionData(D, Record);
928 CXXRecNotTemplate = 0, CXXRecTemplate, CXXRecMemberSpecialization
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);
940 Record.push_back(CXXRecNotTemplate);
943 // Store the key function to avoid deserializing every method so we can
945 if (D->IsCompleteDefinition)
946 Writer.AddDeclRef(Context.getKeyFunction(D), Record);
948 Code = serialization::DECL_CXX_RECORD;
951 void ASTDeclWriter::VisitCXXMethodDecl(CXXMethodDecl *D) {
952 VisitFunctionDecl(D);
953 if (D->isCanonicalDecl()) {
954 Record.push_back(D->size_overridden_methods());
955 for (CXXMethodDecl::method_iterator
956 I = D->begin_overridden_methods(), E = D->end_overridden_methods();
958 Writer.AddDeclRef(*I, Record);
960 // We only need to record overridden methods once for the canonical decl.
963 Code = serialization::DECL_CXX_METHOD;
966 void ASTDeclWriter::VisitCXXConstructorDecl(CXXConstructorDecl *D) {
967 VisitCXXMethodDecl(D);
969 Record.push_back(D->IsExplicitSpecified);
970 Record.push_back(D->ImplicitlyDefined);
971 Writer.AddCXXCtorInitializers(D->CtorInitializers, D->NumCtorInitializers,
974 Code = serialization::DECL_CXX_CONSTRUCTOR;
977 void ASTDeclWriter::VisitCXXDestructorDecl(CXXDestructorDecl *D) {
978 VisitCXXMethodDecl(D);
980 Record.push_back(D->ImplicitlyDefined);
981 Writer.AddDeclRef(D->OperatorDelete, Record);
983 Code = serialization::DECL_CXX_DESTRUCTOR;
986 void ASTDeclWriter::VisitCXXConversionDecl(CXXConversionDecl *D) {
987 VisitCXXMethodDecl(D);
988 Record.push_back(D->IsExplicitSpecified);
989 Code = serialization::DECL_CXX_CONVERSION;
992 void ASTDeclWriter::VisitImportDecl(ImportDecl *D) {
994 Record.push_back(Writer.getSubmoduleID(D->getImportedModule()));
995 ArrayRef<SourceLocation> IdentifierLocs = D->getIdentifierLocs();
996 Record.push_back(!IdentifierLocs.empty());
997 if (IdentifierLocs.empty()) {
998 Writer.AddSourceLocation(D->getLocEnd(), Record);
1001 for (unsigned I = 0, N = IdentifierLocs.size(); I != N; ++I)
1002 Writer.AddSourceLocation(IdentifierLocs[I], Record);
1003 Record.push_back(IdentifierLocs.size());
1005 // Note: the number of source locations must always be the last element in
1007 Code = serialization::DECL_IMPORT;
1010 void ASTDeclWriter::VisitAccessSpecDecl(AccessSpecDecl *D) {
1012 Writer.AddSourceLocation(D->getColonLoc(), Record);
1013 Code = serialization::DECL_ACCESS_SPEC;
1016 void ASTDeclWriter::VisitFriendDecl(FriendDecl *D) {
1018 Record.push_back(D->Friend.is<TypeSourceInfo*>());
1019 if (D->Friend.is<TypeSourceInfo*>())
1020 Writer.AddTypeSourceInfo(D->Friend.get<TypeSourceInfo*>(), Record);
1022 Writer.AddDeclRef(D->Friend.get<NamedDecl*>(), Record);
1023 Writer.AddDeclRef(D->getNextFriend(), Record);
1024 Record.push_back(D->UnsupportedFriend);
1025 Writer.AddSourceLocation(D->FriendLoc, Record);
1026 Code = serialization::DECL_FRIEND;
1029 void ASTDeclWriter::VisitFriendTemplateDecl(FriendTemplateDecl *D) {
1031 Record.push_back(D->getNumTemplateParameters());
1032 for (unsigned i = 0, e = D->getNumTemplateParameters(); i != e; ++i)
1033 Writer.AddTemplateParameterList(D->getTemplateParameterList(i), Record);
1034 Record.push_back(D->getFriendDecl() != 0);
1035 if (D->getFriendDecl())
1036 Writer.AddDeclRef(D->getFriendDecl(), Record);
1038 Writer.AddTypeSourceInfo(D->getFriendType(), Record);
1039 Writer.AddSourceLocation(D->getFriendLoc(), Record);
1040 Code = serialization::DECL_FRIEND_TEMPLATE;
1043 void ASTDeclWriter::VisitTemplateDecl(TemplateDecl *D) {
1046 Writer.AddDeclRef(D->getTemplatedDecl(), Record);
1047 Writer.AddTemplateParameterList(D->getTemplateParameters(), Record);
1050 void ASTDeclWriter::VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D) {
1051 VisitRedeclarable(D);
1053 // Emit data to initialize CommonOrPrev before VisitTemplateDecl so that
1054 // getCommonPtr() can be used while this is still initializing.
1055 if (D->isFirstDeclaration()) {
1056 // This declaration owns the 'common' pointer, so serialize that data now.
1057 Writer.AddDeclRef(D->getInstantiatedFromMemberTemplate(), Record);
1058 if (D->getInstantiatedFromMemberTemplate())
1059 Record.push_back(D->isMemberSpecialization());
1062 VisitTemplateDecl(D);
1063 Record.push_back(D->getIdentifierNamespace());
1066 void ASTDeclWriter::VisitClassTemplateDecl(ClassTemplateDecl *D) {
1067 VisitRedeclarableTemplateDecl(D);
1069 if (D->isFirstDeclaration()) {
1070 typedef llvm::FoldingSetVector<ClassTemplateSpecializationDecl> CTSDSetTy;
1071 CTSDSetTy &CTSDSet = D->getSpecializations();
1072 Record.push_back(CTSDSet.size());
1073 for (CTSDSetTy::iterator I=CTSDSet.begin(), E = CTSDSet.end(); I!=E; ++I) {
1074 assert(I->isCanonicalDecl() && "Expected only canonical decls in set");
1075 Writer.AddDeclRef(&*I, Record);
1078 typedef llvm::FoldingSetVector<ClassTemplatePartialSpecializationDecl>
1080 CTPSDSetTy &CTPSDSet = D->getPartialSpecializations();
1081 Record.push_back(CTPSDSet.size());
1082 for (CTPSDSetTy::iterator I=CTPSDSet.begin(), E=CTPSDSet.end(); I!=E; ++I) {
1083 assert(I->isCanonicalDecl() && "Expected only canonical decls in set");
1084 Writer.AddDeclRef(&*I, Record);
1087 Writer.AddTypeRef(D->getCommonPtr()->InjectedClassNameType, Record);
1089 Code = serialization::DECL_CLASS_TEMPLATE;
1092 void ASTDeclWriter::VisitClassTemplateSpecializationDecl(
1093 ClassTemplateSpecializationDecl *D) {
1094 VisitCXXRecordDecl(D);
1096 llvm::PointerUnion<ClassTemplateDecl *,
1097 ClassTemplatePartialSpecializationDecl *> InstFrom
1098 = D->getSpecializedTemplateOrPartial();
1099 if (Decl *InstFromD = InstFrom.dyn_cast<ClassTemplateDecl *>()) {
1100 Writer.AddDeclRef(InstFromD, Record);
1102 Writer.AddDeclRef(InstFrom.get<ClassTemplatePartialSpecializationDecl *>(),
1104 Writer.AddTemplateArgumentList(&D->getTemplateInstantiationArgs(), Record);
1108 Writer.AddTypeSourceInfo(D->getTypeAsWritten(), Record);
1109 if (D->getTypeAsWritten()) {
1110 Writer.AddSourceLocation(D->getExternLoc(), Record);
1111 Writer.AddSourceLocation(D->getTemplateKeywordLoc(), Record);
1114 Writer.AddTemplateArgumentList(&D->getTemplateArgs(), Record);
1115 Writer.AddSourceLocation(D->getPointOfInstantiation(), Record);
1116 Record.push_back(D->getSpecializationKind());
1117 Record.push_back(D->isCanonicalDecl());
1119 if (D->isCanonicalDecl()) {
1120 // When reading, we'll add it to the folding set of the following template.
1121 Writer.AddDeclRef(D->getSpecializedTemplate()->getCanonicalDecl(), Record);
1124 Code = serialization::DECL_CLASS_TEMPLATE_SPECIALIZATION;
1127 void ASTDeclWriter::VisitClassTemplatePartialSpecializationDecl(
1128 ClassTemplatePartialSpecializationDecl *D) {
1129 VisitClassTemplateSpecializationDecl(D);
1131 Writer.AddTemplateParameterList(D->getTemplateParameters(), Record);
1133 Record.push_back(D->getNumTemplateArgsAsWritten());
1134 for (int i = 0, e = D->getNumTemplateArgsAsWritten(); i != e; ++i)
1135 Writer.AddTemplateArgumentLoc(D->getTemplateArgsAsWritten()[i], Record);
1137 Record.push_back(D->getSequenceNumber());
1139 // These are read/set from/to the first declaration.
1140 if (D->getPreviousDecl() == 0) {
1141 Writer.AddDeclRef(D->getInstantiatedFromMember(), Record);
1142 Record.push_back(D->isMemberSpecialization());
1145 Code = serialization::DECL_CLASS_TEMPLATE_PARTIAL_SPECIALIZATION;
1148 void ASTDeclWriter::VisitClassScopeFunctionSpecializationDecl(
1149 ClassScopeFunctionSpecializationDecl *D) {
1151 Writer.AddDeclRef(D->getSpecialization(), Record);
1152 Code = serialization::DECL_CLASS_SCOPE_FUNCTION_SPECIALIZATION;
1156 void ASTDeclWriter::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
1157 VisitRedeclarableTemplateDecl(D);
1159 if (D->isFirstDeclaration()) {
1160 // This FunctionTemplateDecl owns the CommonPtr; write it.
1162 // Write the function specialization declarations.
1163 Record.push_back(D->getSpecializations().size());
1164 for (llvm::FoldingSetVector<FunctionTemplateSpecializationInfo>::iterator
1165 I = D->getSpecializations().begin(),
1166 E = D->getSpecializations().end() ; I != E; ++I) {
1167 assert(I->Function->isCanonicalDecl() &&
1168 "Expected only canonical decls in set");
1169 Writer.AddDeclRef(I->Function, Record);
1172 Code = serialization::DECL_FUNCTION_TEMPLATE;
1175 void ASTDeclWriter::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
1178 Record.push_back(D->wasDeclaredWithTypename());
1179 Record.push_back(D->defaultArgumentWasInherited());
1180 Writer.AddTypeSourceInfo(D->getDefaultArgumentInfo(), Record);
1182 Code = serialization::DECL_TEMPLATE_TYPE_PARM;
1185 void ASTDeclWriter::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) {
1186 // For an expanded parameter pack, record the number of expansion types here
1187 // so that it's easier for deserialization to allocate the right amount of
1189 if (D->isExpandedParameterPack())
1190 Record.push_back(D->getNumExpansionTypes());
1192 VisitDeclaratorDecl(D);
1193 // TemplateParmPosition.
1194 Record.push_back(D->getDepth());
1195 Record.push_back(D->getPosition());
1197 if (D->isExpandedParameterPack()) {
1198 for (unsigned I = 0, N = D->getNumExpansionTypes(); I != N; ++I) {
1199 Writer.AddTypeRef(D->getExpansionType(I), Record);
1200 Writer.AddTypeSourceInfo(D->getExpansionTypeSourceInfo(I), Record);
1203 Code = serialization::DECL_EXPANDED_NON_TYPE_TEMPLATE_PARM_PACK;
1205 // Rest of NonTypeTemplateParmDecl.
1206 Record.push_back(D->isParameterPack());
1207 Record.push_back(D->getDefaultArgument() != 0);
1208 if (D->getDefaultArgument()) {
1209 Writer.AddStmt(D->getDefaultArgument());
1210 Record.push_back(D->defaultArgumentWasInherited());
1212 Code = serialization::DECL_NON_TYPE_TEMPLATE_PARM;
1216 void ASTDeclWriter::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) {
1217 // For an expanded parameter pack, record the number of expansion types here
1218 // so that it's easier for deserialization to allocate the right amount of
1220 if (D->isExpandedParameterPack())
1221 Record.push_back(D->getNumExpansionTemplateParameters());
1223 VisitTemplateDecl(D);
1224 // TemplateParmPosition.
1225 Record.push_back(D->getDepth());
1226 Record.push_back(D->getPosition());
1228 if (D->isExpandedParameterPack()) {
1229 for (unsigned I = 0, N = D->getNumExpansionTemplateParameters();
1231 Writer.AddTemplateParameterList(D->getExpansionTemplateParameters(I),
1233 Code = serialization::DECL_EXPANDED_TEMPLATE_TEMPLATE_PARM_PACK;
1235 // Rest of TemplateTemplateParmDecl.
1236 Writer.AddTemplateArgumentLoc(D->getDefaultArgument(), Record);
1237 Record.push_back(D->defaultArgumentWasInherited());
1238 Record.push_back(D->isParameterPack());
1239 Code = serialization::DECL_TEMPLATE_TEMPLATE_PARM;
1243 void ASTDeclWriter::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) {
1244 VisitRedeclarableTemplateDecl(D);
1245 Code = serialization::DECL_TYPE_ALIAS_TEMPLATE;
1248 void ASTDeclWriter::VisitStaticAssertDecl(StaticAssertDecl *D) {
1250 Writer.AddStmt(D->getAssertExpr());
1251 Record.push_back(D->isFailed());
1252 Writer.AddStmt(D->getMessage());
1253 Writer.AddSourceLocation(D->getRParenLoc(), Record);
1254 Code = serialization::DECL_STATIC_ASSERT;
1257 /// \brief Emit the DeclContext part of a declaration context decl.
1259 /// \param LexicalOffset the offset at which the DECL_CONTEXT_LEXICAL
1260 /// block for this declaration context is stored. May be 0 to indicate
1261 /// that there are no declarations stored within this context.
1263 /// \param VisibleOffset the offset at which the DECL_CONTEXT_VISIBLE
1264 /// block for this declaration context is stored. May be 0 to indicate
1265 /// that there are no declarations visible from this context. Note
1266 /// that this value will not be emitted for non-primary declaration
1268 void ASTDeclWriter::VisitDeclContext(DeclContext *DC, uint64_t LexicalOffset,
1269 uint64_t VisibleOffset) {
1270 Record.push_back(LexicalOffset);
1271 Record.push_back(VisibleOffset);
1274 template <typename T>
1275 void ASTDeclWriter::VisitRedeclarable(Redeclarable<T> *D) {
1276 T *First = D->getFirstDeclaration();
1277 if (First->getMostRecentDecl() != First) {
1278 // There is more than one declaration of this entity, so we will need to
1279 // write a redeclaration chain.
1280 Writer.AddDeclRef(First, Record);
1281 Writer.Redeclarations.insert(First);
1283 // Make sure that we serialize both the previous and the most-recent
1284 // declarations, which (transitively) ensures that all declarations in the
1285 // chain get serialized.
1286 (void)Writer.GetDeclRef(D->getPreviousDecl());
1287 (void)Writer.GetDeclRef(First->getMostRecentDecl());
1289 // We use the sentinel value 0 to indicate an only declaration.
1290 Record.push_back(0);
1295 //===----------------------------------------------------------------------===//
1296 // ASTWriter Implementation
1297 //===----------------------------------------------------------------------===//
1299 void ASTWriter::WriteDeclsBlockAbbrevs() {
1300 using namespace llvm;
1304 // Abbreviation for DECL_FIELD
1305 Abv = new BitCodeAbbrev();
1306 Abv->Add(BitCodeAbbrevOp(serialization::DECL_FIELD));
1308 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
1309 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalDeclContext
1310 Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl
1311 Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs
1312 Abv->Add(BitCodeAbbrevOp(0)); // isImplicit
1313 Abv->Add(BitCodeAbbrevOp(0)); // isUsed
1314 Abv->Add(BitCodeAbbrevOp(0)); // isReferenced
1315 Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer
1316 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // AccessSpecifier
1317 Abv->Add(BitCodeAbbrevOp(0)); // ModulePrivate
1318 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
1320 Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier
1321 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
1323 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
1325 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerStartLoc
1326 Abv->Add(BitCodeAbbrevOp(0)); // hasExtInfo
1328 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isMutable
1329 Abv->Add(BitCodeAbbrevOp(0)); //getBitWidth
1331 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1332 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
1333 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc
1334 DeclFieldAbbrev = Stream.EmitAbbrev(Abv);
1336 // Abbreviation for DECL_OBJC_IVAR
1337 Abv = new BitCodeAbbrev();
1338 Abv->Add(BitCodeAbbrevOp(serialization::DECL_OBJC_IVAR));
1340 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
1341 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalDeclContext
1342 Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl
1343 Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs
1344 Abv->Add(BitCodeAbbrevOp(0)); // isImplicit
1345 Abv->Add(BitCodeAbbrevOp(0)); // isUsed
1346 Abv->Add(BitCodeAbbrevOp(0)); // isReferenced
1347 Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer
1348 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // AccessSpecifier
1349 Abv->Add(BitCodeAbbrevOp(0)); // ModulePrivate
1350 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
1352 Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier
1353 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
1355 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
1357 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerStartLoc
1358 Abv->Add(BitCodeAbbrevOp(0)); // hasExtInfo
1360 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isMutable
1361 Abv->Add(BitCodeAbbrevOp(0)); //getBitWidth
1363 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getAccessControl
1364 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getSynthesize
1366 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1367 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
1368 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc
1369 DeclObjCIvarAbbrev = Stream.EmitAbbrev(Abv);
1371 // Abbreviation for DECL_ENUM
1372 Abv = new BitCodeAbbrev();
1373 Abv->Add(BitCodeAbbrevOp(serialization::DECL_ENUM));
1375 Abv->Add(BitCodeAbbrevOp(0)); // No redeclaration
1377 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
1378 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalDeclContext
1379 Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl
1380 Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs
1381 Abv->Add(BitCodeAbbrevOp(0)); // isImplicit
1382 Abv->Add(BitCodeAbbrevOp(0)); // isUsed
1383 Abv->Add(BitCodeAbbrevOp(0)); // isReferenced
1384 Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer
1385 Abv->Add(BitCodeAbbrevOp(AS_none)); // C++ AccessSpecifier
1386 Abv->Add(BitCodeAbbrevOp(0)); // ModulePrivate
1387 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
1389 Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier
1390 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
1392 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Source Location
1393 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type Ref
1395 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // IdentifierNamespace
1396 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getTagKind
1397 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isCompleteDefinition
1398 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // EmbeddedInDeclarator
1399 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsFreeStanding
1400 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SourceLocation
1401 Abv->Add(BitCodeAbbrevOp(0)); // hasExtInfo
1402 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypedefNameAnonDecl
1404 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // AddTypeRef
1405 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // IntegerType
1406 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getPromotionType
1407 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getNumPositiveBits
1408 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getNumNegativeBits
1409 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isScoped
1410 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isScopedUsingClassTag
1411 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isFixed
1412 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InstantiatedMembEnum
1414 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalOffset
1415 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // VisibleOffset
1416 DeclEnumAbbrev = Stream.EmitAbbrev(Abv);
1418 // Abbreviation for DECL_RECORD
1419 Abv = new BitCodeAbbrev();
1420 Abv->Add(BitCodeAbbrevOp(serialization::DECL_RECORD));
1422 Abv->Add(BitCodeAbbrevOp(0)); // No redeclaration
1424 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
1425 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalDeclContext
1426 Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl
1427 Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs
1428 Abv->Add(BitCodeAbbrevOp(0)); // isImplicit
1429 Abv->Add(BitCodeAbbrevOp(0)); // isUsed
1430 Abv->Add(BitCodeAbbrevOp(0)); // isReferenced
1431 Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer
1432 Abv->Add(BitCodeAbbrevOp(AS_none)); // C++ AccessSpecifier
1433 Abv->Add(BitCodeAbbrevOp(0)); // ModulePrivate
1434 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
1436 Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier
1437 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
1439 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Source Location
1440 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type Ref
1442 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // IdentifierNamespace
1443 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getTagKind
1444 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isCompleteDefinition
1445 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // EmbeddedInDeclarator
1446 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsFreeStanding
1447 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SourceLocation
1448 Abv->Add(BitCodeAbbrevOp(0)); // hasExtInfo
1449 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypedefNameAnonDecl
1451 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // FlexibleArrayMember
1452 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // AnonymousStructUnion
1453 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // hasObjectMember
1455 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalOffset
1456 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // VisibleOffset
1457 DeclRecordAbbrev = Stream.EmitAbbrev(Abv);
1459 // Abbreviation for DECL_PARM_VAR
1460 Abv = new BitCodeAbbrev();
1461 Abv->Add(BitCodeAbbrevOp(serialization::DECL_PARM_VAR));
1463 Abv->Add(BitCodeAbbrevOp(0)); // No redeclaration
1465 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
1466 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalDeclContext
1467 Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl
1468 Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs
1469 Abv->Add(BitCodeAbbrevOp(0)); // isImplicit
1470 Abv->Add(BitCodeAbbrevOp(0)); // isUsed
1471 Abv->Add(BitCodeAbbrevOp(0)); // isReferenced
1472 Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer
1473 Abv->Add(BitCodeAbbrevOp(AS_none)); // C++ AccessSpecifier
1474 Abv->Add(BitCodeAbbrevOp(0)); // ModulePrivate
1475 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
1477 Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier
1478 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
1480 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
1482 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerStartLoc
1483 Abv->Add(BitCodeAbbrevOp(0)); // hasExtInfo
1485 Abv->Add(BitCodeAbbrevOp(0)); // StorageClass
1486 Abv->Add(BitCodeAbbrevOp(0)); // StorageClassAsWritten
1487 Abv->Add(BitCodeAbbrevOp(0)); // isThreadSpecified
1488 Abv->Add(BitCodeAbbrevOp(0)); // hasCXXDirectInitializer
1489 Abv->Add(BitCodeAbbrevOp(0)); // isExceptionVariable
1490 Abv->Add(BitCodeAbbrevOp(0)); // isNRVOVariable
1491 Abv->Add(BitCodeAbbrevOp(0)); // isCXXForRangeDecl
1492 Abv->Add(BitCodeAbbrevOp(0)); // isARCPseudoStrong
1493 Abv->Add(BitCodeAbbrevOp(0)); // isConstexpr
1494 Abv->Add(BitCodeAbbrevOp(0)); // HasInit
1495 Abv->Add(BitCodeAbbrevOp(0)); // HasMemberSpecializationInfo
1497 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsObjCMethodParameter
1498 Abv->Add(BitCodeAbbrevOp(0)); // ScopeDepth
1499 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // ScopeIndex
1500 Abv->Add(BitCodeAbbrevOp(0)); // ObjCDeclQualifier
1501 Abv->Add(BitCodeAbbrevOp(0)); // KNRPromoted
1502 Abv->Add(BitCodeAbbrevOp(0)); // HasInheritedDefaultArg
1503 Abv->Add(BitCodeAbbrevOp(0)); // HasUninstantiatedDefaultArg
1505 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1506 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
1507 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc
1508 DeclParmVarAbbrev = Stream.EmitAbbrev(Abv);
1510 // Abbreviation for DECL_TYPEDEF
1511 Abv = new BitCodeAbbrev();
1512 Abv->Add(BitCodeAbbrevOp(serialization::DECL_TYPEDEF));
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)); // Source Location
1532 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type Ref
1534 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
1535 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc
1536 DeclTypedefAbbrev = Stream.EmitAbbrev(Abv);
1538 // Abbreviation for DECL_VAR
1539 Abv = new BitCodeAbbrev();
1540 Abv->Add(BitCodeAbbrevOp(serialization::DECL_VAR));
1542 Abv->Add(BitCodeAbbrevOp(0)); // No redeclaration
1544 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
1545 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalDeclContext
1546 Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl
1547 Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs
1548 Abv->Add(BitCodeAbbrevOp(0)); // isImplicit
1549 Abv->Add(BitCodeAbbrevOp(0)); // isUsed
1550 Abv->Add(BitCodeAbbrevOp(0)); // isReferenced
1551 Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer
1552 Abv->Add(BitCodeAbbrevOp(AS_none)); // C++ AccessSpecifier
1553 Abv->Add(BitCodeAbbrevOp(0)); // ModulePrivate
1554 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
1556 Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier
1557 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
1559 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
1561 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerStartLoc
1562 Abv->Add(BitCodeAbbrevOp(0)); // hasExtInfo
1564 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // StorageClass
1565 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // StorageClassAsWritten
1566 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isThreadSpecified
1567 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // CXXDirectInitializer
1568 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isExceptionVariable
1569 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isNRVOVariable
1570 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isCXXForRangeDecl
1571 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isARCPseudoStrong
1572 Abv->Add(BitCodeAbbrevOp(0)); // isConstexpr
1573 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // HasInit
1574 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // HasMemberSpecInfo
1576 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1577 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
1578 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc
1579 DeclVarAbbrev = Stream.EmitAbbrev(Abv);
1581 // Abbreviation for EXPR_DECL_REF
1582 Abv = new BitCodeAbbrev();
1583 Abv->Add(BitCodeAbbrevOp(serialization::EXPR_DECL_REF));
1586 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
1587 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //TypeDependent
1588 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //ValueDependent
1589 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //InstantiationDependent
1590 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //UnexpandedParamPack
1591 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetValueKind
1592 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetObjectKind
1594 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //HasQualifier
1595 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //GetDeclFound
1596 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //ExplicitTemplateArgs
1597 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //HadMultipleCandidates
1598 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //RefersToEnclosingLocal
1599 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclRef
1600 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Location
1601 DeclRefExprAbbrev = Stream.EmitAbbrev(Abv);
1603 // Abbreviation for EXPR_INTEGER_LITERAL
1604 Abv = new BitCodeAbbrev();
1605 Abv->Add(BitCodeAbbrevOp(serialization::EXPR_INTEGER_LITERAL));
1608 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
1609 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //TypeDependent
1610 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //ValueDependent
1611 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //InstantiationDependent
1612 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //UnexpandedParamPack
1613 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetValueKind
1614 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetObjectKind
1616 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Location
1617 Abv->Add(BitCodeAbbrevOp(32)); // Bit Width
1618 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Value
1619 IntegerLiteralAbbrev = Stream.EmitAbbrev(Abv);
1621 // Abbreviation for EXPR_CHARACTER_LITERAL
1622 Abv = new BitCodeAbbrev();
1623 Abv->Add(BitCodeAbbrevOp(serialization::EXPR_CHARACTER_LITERAL));
1626 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
1627 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //TypeDependent
1628 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //ValueDependent
1629 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //InstantiationDependent
1630 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //UnexpandedParamPack
1631 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetValueKind
1632 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetObjectKind
1634 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getValue
1635 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Location
1636 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // getKind
1637 CharacterLiteralAbbrev = Stream.EmitAbbrev(Abv);
1639 Abv = new BitCodeAbbrev();
1640 Abv->Add(BitCodeAbbrevOp(serialization::DECL_CONTEXT_LEXICAL));
1641 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1642 DeclContextLexicalAbbrev = Stream.EmitAbbrev(Abv);
1644 Abv = new BitCodeAbbrev();
1645 Abv->Add(BitCodeAbbrevOp(serialization::DECL_CONTEXT_VISIBLE));
1646 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
1647 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1648 DeclContextVisibleLookupAbbrev = Stream.EmitAbbrev(Abv);
1651 /// isRequiredDecl - Check if this is a "required" Decl, which must be seen by
1652 /// consumers of the AST.
1654 /// Such decls will always be deserialized from the AST file, so we would like
1655 /// this to be as restrictive as possible. Currently the predicate is driven by
1656 /// code generation requirements, if other clients have a different notion of
1657 /// what is "required" then we may have to consider an alternate scheme where
1658 /// clients can iterate over the top-level decls and get information on them,
1659 /// without necessary deserializing them. We could explicitly require such
1660 /// clients to use a separate API call to "realize" the decl. This should be
1661 /// relatively painless since they would presumably only do it for top-level
1663 static bool isRequiredDecl(const Decl *D, ASTContext &Context) {
1664 // An ObjCMethodDecl is never considered as "required" because its
1665 // implementation container always is.
1667 // File scoped assembly or obj-c implementation must be seen.
1668 if (isa<FileScopeAsmDecl>(D) || isa<ObjCImplDecl>(D))
1671 return Context.DeclMustBeEmitted(D);
1674 void ASTWriter::WriteDecl(ASTContext &Context, Decl *D) {
1675 // Switch case IDs are per Decl.
1676 ClearSwitchCaseIDs();
1679 ASTDeclWriter W(*this, Context, Record);
1681 // Determine the ID for this declaration.
1682 serialization::DeclID ID;
1683 if (D->isFromASTFile())
1686 serialization::DeclID &IDR = DeclIDs[D];
1693 bool isReplacingADecl = ID < FirstDeclID;
1695 // If this declaration is also a DeclContext, write blocks for the
1696 // declarations that lexically stored inside its context and those
1697 // declarations that are visible from its context. These blocks
1698 // are written before the declaration itself so that we can put
1699 // their offsets into the record for the declaration.
1700 uint64_t LexicalOffset = 0;
1701 uint64_t VisibleOffset = 0;
1702 DeclContext *DC = dyn_cast<DeclContext>(D);
1704 if (isReplacingADecl) {
1705 // It is replacing a decl from a chained PCH; make sure that the
1706 // DeclContext is fully loaded.
1707 if (DC->hasExternalLexicalStorage())
1708 DC->LoadLexicalDeclsFromExternalStorage();
1709 if (DC->hasExternalVisibleStorage())
1710 Chain->completeVisibleDeclsMap(DC);
1712 LexicalOffset = WriteDeclContextLexicalBlock(Context, DC);
1713 VisibleOffset = WriteDeclContextVisibleBlock(Context, DC);
1716 if (isReplacingADecl) {
1717 // We're replacing a decl in a previous file.
1718 ReplacedDecls.push_back(ReplacedDeclInfo(ID, Stream.GetCurrentBitNo(),
1721 unsigned Index = ID - FirstDeclID;
1723 // Record the offset for this declaration
1724 SourceLocation Loc = D->getLocation();
1725 if (DeclOffsets.size() == Index)
1726 DeclOffsets.push_back(DeclOffset(Loc, Stream.GetCurrentBitNo()));
1727 else if (DeclOffsets.size() < Index) {
1728 DeclOffsets.resize(Index+1);
1729 DeclOffsets[Index].setLocation(Loc);
1730 DeclOffsets[Index].BitOffset = Stream.GetCurrentBitNo();
1733 SourceManager &SM = Context.getSourceManager();
1734 if (Loc.isValid() && SM.isLocalSourceLocation(Loc))
1735 associateDeclWithFile(D, ID);
1738 // Build and emit a record for this declaration
1740 W.Code = (serialization::DeclCode)0;
1743 if (DC) W.VisitDeclContext(DC, LexicalOffset, VisibleOffset);
1746 llvm::report_fatal_error(StringRef("unexpected declaration kind '") +
1747 D->getDeclKindName() + "'");
1748 Stream.EmitRecord(W.Code, Record, W.AbbrevToUse);
1750 // Flush any expressions that were written as part of this declaration.
1753 // Flush C++ base specifiers, if there are any.
1754 FlushCXXBaseSpecifiers();
1756 // Note "external" declarations so that we can add them to a record in the
1759 // FIXME: This should be renamed, the predicate is much more complicated.
1760 if (isRequiredDecl(D, Context))
1761 ExternalDefinitions.push_back(ID);