blob: b7ca623d7d38b9884a87e1c4fab2699fe39f0cad [file] [log] [blame]
Sebastian Redl4ee2ad02010-08-18 23:56:31 +00001//===--- ASTWriterDecl.cpp - Declaration Serialization --------------------===//
Chris Lattner12b1c762009-04-27 06:16:06 +00002//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file implements serialization for Declarations.
11//
12//===----------------------------------------------------------------------===//
13
Sebastian Redl7faa2ec2010-08-18 23:56:37 +000014#include "clang/Serialization/ASTWriter.h"
Sebastian Redl7c0837f2011-04-24 16:28:13 +000015#include "ASTCommon.h"
Chris Lattner6ad9ac02010-05-07 21:43:38 +000016#include "clang/AST/DeclCXX.h"
Argyrios Kyrtzidis0ad6dc32010-10-20 16:22:56 +000017#include "clang/AST/DeclContextInternals.h"
Chandler Carruth55fc8732012-12-04 09:13:33 +000018#include "clang/AST/DeclTemplate.h"
19#include "clang/AST/DeclVisitor.h"
20#include "clang/AST/Expr.h"
Argyrios Kyrtzidis10f3df52011-10-28 22:54:21 +000021#include "clang/Basic/SourceManager.h"
Chandler Carruth55fc8732012-12-04 09:13:33 +000022#include "clang/Serialization/ASTReader.h"
Daniel Dunbar33671982009-12-03 09:13:36 +000023#include "llvm/ADT/Twine.h"
Chris Lattner12b1c762009-04-27 06:16:06 +000024#include "llvm/Bitcode/BitstreamWriter.h"
Daniel Dunbar33671982009-12-03 09:13:36 +000025#include "llvm/Support/ErrorHandling.h"
Chris Lattner12b1c762009-04-27 06:16:06 +000026using namespace clang;
Sebastian Redl7c0837f2011-04-24 16:28:13 +000027using namespace serialization;
Chris Lattner12b1c762009-04-27 06:16:06 +000028
29//===----------------------------------------------------------------------===//
30// Declaration serialization
31//===----------------------------------------------------------------------===//
32
Argyrios Kyrtzidis67643342010-06-29 22:47:00 +000033namespace clang {
Sebastian Redl3397c552010-08-18 23:56:27 +000034 class ASTDeclWriter : public DeclVisitor<ASTDeclWriter, void> {
Chris Lattner12b1c762009-04-27 06:16:06 +000035
Sebastian Redla4232eb2010-08-18 23:56:21 +000036 ASTWriter &Writer;
Chris Lattner12b1c762009-04-27 06:16:06 +000037 ASTContext &Context;
Argyrios Kyrtzidisc01dc6f2010-10-24 17:26:27 +000038 typedef ASTWriter::RecordData RecordData;
39 RecordData &Record;
Chris Lattner12b1c762009-04-27 06:16:06 +000040
41 public:
Sebastian Redl8538e8d2010-08-18 23:57:32 +000042 serialization::DeclCode Code;
Chris Lattnerea5ce472009-04-27 07:35:58 +000043 unsigned AbbrevToUse;
Chris Lattner12b1c762009-04-27 06:16:06 +000044
Argyrios Kyrtzidisc01dc6f2010-10-24 17:26:27 +000045 ASTDeclWriter(ASTWriter &Writer, ASTContext &Context, RecordData &Record)
Chris Lattnerea5ce472009-04-27 07:35:58 +000046 : Writer(Writer), Context(Context), Record(Record) {
47 }
Argyrios Kyrtzidisc01dc6f2010-10-24 17:26:27 +000048
Argyrios Kyrtzidis91468322010-07-02 15:58:43 +000049 void Visit(Decl *D);
Chris Lattner12b1c762009-04-27 06:16:06 +000050
51 void VisitDecl(Decl *D);
52 void VisitTranslationUnitDecl(TranslationUnitDecl *D);
53 void VisitNamedDecl(NamedDecl *D);
Chris Lattnerad8dcf42011-02-17 07:39:24 +000054 void VisitLabelDecl(LabelDecl *LD);
Douglas Gregor0cef4832010-02-21 18:22:14 +000055 void VisitNamespaceDecl(NamespaceDecl *D);
Chris Lattner6ad9ac02010-05-07 21:43:38 +000056 void VisitUsingDirectiveDecl(UsingDirectiveDecl *D);
57 void VisitNamespaceAliasDecl(NamespaceAliasDecl *D);
Chris Lattner12b1c762009-04-27 06:16:06 +000058 void VisitTypeDecl(TypeDecl *D);
Douglas Gregor0f456822011-12-19 14:40:25 +000059 void VisitTypedefNameDecl(TypedefNameDecl *D);
Chris Lattner12b1c762009-04-27 06:16:06 +000060 void VisitTypedefDecl(TypedefDecl *D);
Richard Smith162e1c12011-04-15 14:24:37 +000061 void VisitTypeAliasDecl(TypeAliasDecl *D);
Argyrios Kyrtzidis8f4eae92010-06-30 08:49:30 +000062 void VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D);
Chris Lattner12b1c762009-04-27 06:16:06 +000063 void VisitTagDecl(TagDecl *D);
64 void VisitEnumDecl(EnumDecl *D);
65 void VisitRecordDecl(RecordDecl *D);
Chris Lattner6ad9ac02010-05-07 21:43:38 +000066 void VisitCXXRecordDecl(CXXRecordDecl *D);
67 void VisitClassTemplateSpecializationDecl(
68 ClassTemplateSpecializationDecl *D);
69 void VisitClassTemplatePartialSpecializationDecl(
70 ClassTemplatePartialSpecializationDecl *D);
Fariborz Jahanian95ed7782011-08-27 20:50:59 +000071 void VisitClassScopeFunctionSpecializationDecl(
72 ClassScopeFunctionSpecializationDecl *D);
Chris Lattner6ad9ac02010-05-07 21:43:38 +000073 void VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D);
Chris Lattner12b1c762009-04-27 06:16:06 +000074 void VisitValueDecl(ValueDecl *D);
75 void VisitEnumConstantDecl(EnumConstantDecl *D);
Argyrios Kyrtzidis8f4eae92010-06-30 08:49:30 +000076 void VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D);
Argyrios Kyrtzidisd4a7e542009-08-19 01:28:35 +000077 void VisitDeclaratorDecl(DeclaratorDecl *D);
Chris Lattner12b1c762009-04-27 06:16:06 +000078 void VisitFunctionDecl(FunctionDecl *D);
Chris Lattner6ad9ac02010-05-07 21:43:38 +000079 void VisitCXXMethodDecl(CXXMethodDecl *D);
80 void VisitCXXConstructorDecl(CXXConstructorDecl *D);
81 void VisitCXXDestructorDecl(CXXDestructorDecl *D);
82 void VisitCXXConversionDecl(CXXConversionDecl *D);
Chris Lattner12b1c762009-04-27 06:16:06 +000083 void VisitFieldDecl(FieldDecl *D);
John McCall76da55d2013-04-16 07:28:30 +000084 void VisitMSPropertyDecl(MSPropertyDecl *D);
Francois Pichet87c2e122010-11-21 06:08:52 +000085 void VisitIndirectFieldDecl(IndirectFieldDecl *D);
Chris Lattner12b1c762009-04-27 06:16:06 +000086 void VisitVarDecl(VarDecl *D);
87 void VisitImplicitParamDecl(ImplicitParamDecl *D);
88 void VisitParmVarDecl(ParmVarDecl *D);
Chris Lattner6ad9ac02010-05-07 21:43:38 +000089 void VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D);
90 void VisitTemplateDecl(TemplateDecl *D);
Peter Collingbourne9eabeba2010-07-29 16:11:51 +000091 void VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D);
Chris Lattner6ad9ac02010-05-07 21:43:38 +000092 void VisitClassTemplateDecl(ClassTemplateDecl *D);
Argyrios Kyrtzidisf511ba62010-06-22 09:55:07 +000093 void VisitFunctionTemplateDecl(FunctionTemplateDecl *D);
Chris Lattner6ad9ac02010-05-07 21:43:38 +000094 void VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D);
Richard Smith3e4c6c42011-05-05 21:57:07 +000095 void VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D);
Argyrios Kyrtzidisb01a5522010-06-20 14:40:59 +000096 void VisitUsingDecl(UsingDecl *D);
97 void VisitUsingShadowDecl(UsingShadowDecl *D);
Chris Lattner6ad9ac02010-05-07 21:43:38 +000098 void VisitLinkageSpecDecl(LinkageSpecDecl *D);
Chris Lattner12b1c762009-04-27 06:16:06 +000099 void VisitFileScopeAsmDecl(FileScopeAsmDecl *D);
Douglas Gregor15de72c2011-12-02 23:23:56 +0000100 void VisitImportDecl(ImportDecl *D);
Abramo Bagnara6206d532010-06-05 05:09:32 +0000101 void VisitAccessSpecDecl(AccessSpecDecl *D);
Argyrios Kyrtzidis67643342010-06-29 22:47:00 +0000102 void VisitFriendDecl(FriendDecl *D);
Chris Lattner6ad9ac02010-05-07 21:43:38 +0000103 void VisitFriendTemplateDecl(FriendTemplateDecl *D);
104 void VisitStaticAssertDecl(StaticAssertDecl *D);
Chris Lattner12b1c762009-04-27 06:16:06 +0000105 void VisitBlockDecl(BlockDecl *D);
Tareq A. Siraj6afcf882013-04-16 19:37:38 +0000106 void VisitCapturedDecl(CapturedDecl *D);
Michael Han684aa732013-02-22 17:15:32 +0000107 void VisitEmptyDecl(EmptyDecl *D);
Chris Lattner6ad9ac02010-05-07 21:43:38 +0000108
Mike Stump1eb44332009-09-09 15:08:12 +0000109 void VisitDeclContext(DeclContext *DC, uint64_t LexicalOffset,
Chris Lattner12b1c762009-04-27 06:16:06 +0000110 uint64_t VisibleOffset);
Argyrios Kyrtzidisa8650052010-08-03 17:30:10 +0000111 template <typename T> void VisitRedeclarable(Redeclarable<T> *D);
Chris Lattner6ad9ac02010-05-07 21:43:38 +0000112
113
Sean Hunt9a555912010-05-30 07:21:58 +0000114 // FIXME: Put in the same order is DeclNodes.td?
Chris Lattner12b1c762009-04-27 06:16:06 +0000115 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);
Chris Lattner12b1c762009-04-27 06:16:06 +0000121 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);
Alexey Bataevc6400582013-03-22 06:34:35 +0000128 void VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D);
Chris Lattner12b1c762009-04-27 06:16:06 +0000129 };
130}
131
Sebastian Redl3397c552010-08-18 23:56:27 +0000132void ASTDeclWriter::Visit(Decl *D) {
133 DeclVisitor<ASTDeclWriter>::Visit(D);
Argyrios Kyrtzidis91468322010-07-02 15:58:43 +0000134
Jonathan D. Turner953c5642011-06-03 23:11:16 +0000135 // Source locations require array (variable-length) abbreviations. The
136 // abbreviation infrastructure requires that arrays are encoded last, so
137 // we handle it here in the case of those classes derived from DeclaratorDecl
138 if (DeclaratorDecl *DD = dyn_cast<DeclaratorDecl>(D)){
139 Writer.AddTypeSourceInfo(DD->getTypeSourceInfo(), Record);
140 }
141
Argyrios Kyrtzidis91468322010-07-02 15:58:43 +0000142 // 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
Sebastian Redl3397c552010-08-18 23:56:27 +0000144 // retrieving it from the AST, we'll just lazily set the offset.
Argyrios Kyrtzidis91468322010-07-02 15:58:43 +0000145 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
Sean Hunt10620eb2011-05-06 20:44:56 +0000146 Record.push_back(FD->doesThisDeclarationHaveABody());
147 if (FD->doesThisDeclarationHaveABody())
Argyrios Kyrtzidis91468322010-07-02 15:58:43 +0000148 Writer.AddStmt(FD->getBody());
149 }
150}
151
Sebastian Redl3397c552010-08-18 23:56:27 +0000152void ASTDeclWriter::VisitDecl(Decl *D) {
Chris Lattner12b1c762009-04-27 06:16:06 +0000153 Writer.AddDeclRef(cast_or_null<Decl>(D->getDeclContext()), Record);
154 Writer.AddDeclRef(cast_or_null<Decl>(D->getLexicalDeclContext()), Record);
Chris Lattner12b1c762009-04-27 06:16:06 +0000155 Record.push_back(D->isInvalidDecl());
156 Record.push_back(D->hasAttrs());
Argyrios Kyrtzidis4eb9fc02010-10-18 19:20:11 +0000157 if (D->hasAttrs())
Alexander Kornienko49908902012-07-09 10:04:07 +0000158 Writer.WriteAttributes(ArrayRef<const Attr*>(D->getAttrs().begin(),
159 D->getAttrs().size()), Record);
Chris Lattner12b1c762009-04-27 06:16:06 +0000160 Record.push_back(D->isImplicit());
Douglas Gregorc070cc62010-06-17 23:14:26 +0000161 Record.push_back(D->isUsed(false));
Argyrios Kyrtzidis6b6b42a2011-04-19 19:51:10 +0000162 Record.push_back(D->isReferenced());
Douglas Gregor46cd2182012-01-06 16:59:53 +0000163 Record.push_back(D->isTopLevelDeclInObjCContainer());
Chris Lattner12b1c762009-04-27 06:16:06 +0000164 Record.push_back(D->getAccess());
Douglas Gregor46cd2182012-01-06 16:59:53 +0000165 Record.push_back(D->isModulePrivate());
Douglas Gregor185dbd72011-12-01 02:07:58 +0000166 Record.push_back(Writer.inferSubmoduleIDFromLocation(D->getLocation()));
Chris Lattner12b1c762009-04-27 06:16:06 +0000167}
168
Sebastian Redl3397c552010-08-18 23:56:27 +0000169void ASTDeclWriter::VisitTranslationUnitDecl(TranslationUnitDecl *D) {
Douglas Gregor6bf2b9f2011-08-12 00:15:20 +0000170 llvm_unreachable("Translation units aren't directly serialized");
Chris Lattner12b1c762009-04-27 06:16:06 +0000171}
172
Sebastian Redl3397c552010-08-18 23:56:27 +0000173void ASTDeclWriter::VisitNamedDecl(NamedDecl *D) {
Chris Lattner12b1c762009-04-27 06:16:06 +0000174 VisitDecl(D);
175 Writer.AddDeclarationName(D->getDeclName(), Record);
176}
177
Sebastian Redl3397c552010-08-18 23:56:27 +0000178void ASTDeclWriter::VisitTypeDecl(TypeDecl *D) {
Chris Lattner12b1c762009-04-27 06:16:06 +0000179 VisitNamedDecl(D);
Abramo Bagnara344577e2011-03-06 15:48:19 +0000180 Writer.AddSourceLocation(D->getLocStart(), Record);
Argyrios Kyrtzidisd8a0c6f2010-07-02 11:55:01 +0000181 Writer.AddTypeRef(QualType(D->getTypeForDecl(), 0), Record);
Chris Lattner12b1c762009-04-27 06:16:06 +0000182}
183
Douglas Gregor0f456822011-12-19 14:40:25 +0000184void ASTDeclWriter::VisitTypedefNameDecl(TypedefNameDecl *D) {
Douglas Gregora1be2782011-12-17 23:38:30 +0000185 VisitRedeclarable(D);
Chris Lattner12b1c762009-04-27 06:16:06 +0000186 VisitTypeDecl(D);
Douglas Gregor0f456822011-12-19 14:40:25 +0000187 Writer.AddTypeSourceInfo(D->getTypeSourceInfo(), Record);
188}
Jonathan D. Turner953c5642011-06-03 23:11:16 +0000189
Douglas Gregor0f456822011-12-19 14:40:25 +0000190void ASTDeclWriter::VisitTypedefDecl(TypedefDecl *D) {
191 VisitTypedefNameDecl(D);
Jonathan D. Turner953c5642011-06-03 23:11:16 +0000192 if (!D->hasAttrs() &&
193 !D->isImplicit() &&
194 !D->isUsed(false) &&
Douglas Gregor2171bf12012-01-15 16:58:34 +0000195 D->getFirstDeclaration() == D->getMostRecentDecl() &&
Jonathan D. Turner953c5642011-06-03 23:11:16 +0000196 !D->isInvalidDecl() &&
197 !D->isReferenced() &&
Argyrios Kyrtzidisbcf8df82011-11-23 21:11:23 +0000198 !D->isTopLevelDeclInObjCContainer() &&
Jonathan D. Turner953c5642011-06-03 23:11:16 +0000199 D->getAccess() == AS_none &&
Douglas Gregor8d267c52011-09-09 02:06:17 +0000200 !D->isModulePrivate() &&
Jonathan D. Turner953c5642011-06-03 23:11:16 +0000201 D->getDeclName().getNameKind() == DeclarationName::Identifier)
202 AbbrevToUse = Writer.getDeclTypedefAbbrev();
203
Sebastian Redl8538e8d2010-08-18 23:57:32 +0000204 Code = serialization::DECL_TYPEDEF;
Chris Lattner12b1c762009-04-27 06:16:06 +0000205}
206
Richard Smith162e1c12011-04-15 14:24:37 +0000207void ASTDeclWriter::VisitTypeAliasDecl(TypeAliasDecl *D) {
Douglas Gregor0f456822011-12-19 14:40:25 +0000208 VisitTypedefNameDecl(D);
Richard Smith162e1c12011-04-15 14:24:37 +0000209 Code = serialization::DECL_TYPEALIAS;
210}
211
Sebastian Redl3397c552010-08-18 23:56:27 +0000212void ASTDeclWriter::VisitTagDecl(TagDecl *D) {
Argyrios Kyrtzidisa8650052010-08-03 17:30:10 +0000213 VisitRedeclarable(D);
Douglas Gregord488b3a2011-10-26 17:53:41 +0000214 VisitTypeDecl(D);
Argyrios Kyrtzidis6b541512010-09-08 19:31:22 +0000215 Record.push_back(D->getIdentifierNamespace());
Chris Lattner12b1c762009-04-27 06:16:06 +0000216 Record.push_back((unsigned)D->getTagKind()); // FIXME: stable encoding
John McCall5e1cdac2011-10-07 06:10:15 +0000217 Record.push_back(D->isCompleteDefinition());
Douglas Gregorb37b6482010-02-12 17:40:34 +0000218 Record.push_back(D->isEmbeddedInDeclarator());
Argyrios Kyrtzidis717a20b2011-09-30 22:11:31 +0000219 Record.push_back(D->isFreeStanding());
Argyrios Kyrtzidisad93a742009-07-14 03:18:02 +0000220 Writer.AddSourceLocation(D->getRBraceLoc(), Record);
Argyrios Kyrtzidis40451072010-10-15 18:21:24 +0000221 Record.push_back(D->hasExtInfo());
222 if (D->hasExtInfo())
223 Writer.AddQualifierInfo(*D->getExtInfo(), Record);
224 else
Richard Smith162e1c12011-04-15 14:24:37 +0000225 Writer.AddDeclRef(D->getTypedefNameForAnonDecl(), Record);
Chris Lattner12b1c762009-04-27 06:16:06 +0000226}
227
Sebastian Redl3397c552010-08-18 23:56:27 +0000228void ASTDeclWriter::VisitEnumDecl(EnumDecl *D) {
Chris Lattner12b1c762009-04-27 06:16:06 +0000229 VisitTagDecl(D);
Douglas Gregor1274ccd2010-10-08 23:50:27 +0000230 Writer.AddTypeSourceInfo(D->getIntegerTypeSourceInfo(), Record);
231 if (!D->getIntegerTypeSourceInfo())
232 Writer.AddTypeRef(D->getIntegerType(), Record);
John McCall842aef82009-12-09 09:09:27 +0000233 Writer.AddTypeRef(D->getPromotionType(), Record);
John McCall1b5a6182010-05-06 08:49:23 +0000234 Record.push_back(D->getNumPositiveBits());
235 Record.push_back(D->getNumNegativeBits());
Douglas Gregor1274ccd2010-10-08 23:50:27 +0000236 Record.push_back(D->isScoped());
Abramo Bagnaraa88cefd2010-12-03 18:54:17 +0000237 Record.push_back(D->isScopedUsingClassTag());
Douglas Gregor1274ccd2010-10-08 23:50:27 +0000238 Record.push_back(D->isFixed());
Richard Smithf1c66b42012-03-14 23:13:10 +0000239 if (MemberSpecializationInfo *MemberInfo = D->getMemberSpecializationInfo()) {
240 Writer.AddDeclRef(MemberInfo->getInstantiatedFrom(), Record);
241 Record.push_back(MemberInfo->getTemplateSpecializationKind());
242 Writer.AddSourceLocation(MemberInfo->getPointOfInstantiation(), Record);
243 } else {
244 Writer.AddDeclRef(0, Record);
245 }
Jonathan D. Turner953c5642011-06-03 23:11:16 +0000246
247 if (!D->hasAttrs() &&
248 !D->isImplicit() &&
249 !D->isUsed(false) &&
Jonathan D. Turner953c5642011-06-03 23:11:16 +0000250 !D->hasExtInfo() &&
Douglas Gregor2171bf12012-01-15 16:58:34 +0000251 D->getFirstDeclaration() == D->getMostRecentDecl() &&
Jonathan D. Turner953c5642011-06-03 23:11:16 +0000252 !D->isInvalidDecl() &&
253 !D->isReferenced() &&
Argyrios Kyrtzidisbcf8df82011-11-23 21:11:23 +0000254 !D->isTopLevelDeclInObjCContainer() &&
Jonathan D. Turner953c5642011-06-03 23:11:16 +0000255 D->getAccess() == AS_none &&
Douglas Gregor8d267c52011-09-09 02:06:17 +0000256 !D->isModulePrivate() &&
Jonathan D. Turner953c5642011-06-03 23:11:16 +0000257 !CXXRecordDecl::classofKind(D->getKind()) &&
258 !D->getIntegerTypeSourceInfo() &&
Argyrios Kyrtzidis03784332013-03-18 22:23:49 +0000259 !D->getMemberSpecializationInfo() &&
Jonathan D. Turner953c5642011-06-03 23:11:16 +0000260 D->getDeclName().getNameKind() == DeclarationName::Identifier)
261 AbbrevToUse = Writer.getDeclEnumAbbrev();
262
Sebastian Redl8538e8d2010-08-18 23:57:32 +0000263 Code = serialization::DECL_ENUM;
Chris Lattner12b1c762009-04-27 06:16:06 +0000264}
265
Sebastian Redl3397c552010-08-18 23:56:27 +0000266void ASTDeclWriter::VisitRecordDecl(RecordDecl *D) {
Chris Lattner12b1c762009-04-27 06:16:06 +0000267 VisitTagDecl(D);
268 Record.push_back(D->hasFlexibleArrayMember());
269 Record.push_back(D->isAnonymousStructOrUnion());
Fariborz Jahanian643b7df2009-07-08 16:37:44 +0000270 Record.push_back(D->hasObjectMember());
Fariborz Jahanian3ac83d62013-01-25 23:57:05 +0000271 Record.push_back(D->hasVolatileMember());
Douglas Gregora72d8c42011-06-03 02:27:19 +0000272
273 if (!D->hasAttrs() &&
274 !D->isImplicit() &&
275 !D->isUsed(false) &&
Douglas Gregora72d8c42011-06-03 02:27:19 +0000276 !D->hasExtInfo() &&
Douglas Gregor2171bf12012-01-15 16:58:34 +0000277 D->getFirstDeclaration() == D->getMostRecentDecl() &&
Douglas Gregora72d8c42011-06-03 02:27:19 +0000278 !D->isInvalidDecl() &&
279 !D->isReferenced() &&
Argyrios Kyrtzidisbcf8df82011-11-23 21:11:23 +0000280 !D->isTopLevelDeclInObjCContainer() &&
Douglas Gregora72d8c42011-06-03 02:27:19 +0000281 D->getAccess() == AS_none &&
Douglas Gregor8d267c52011-09-09 02:06:17 +0000282 !D->isModulePrivate() &&
Douglas Gregora72d8c42011-06-03 02:27:19 +0000283 !CXXRecordDecl::classofKind(D->getKind()) &&
284 D->getDeclName().getNameKind() == DeclarationName::Identifier)
Douglas Gregora72d8c42011-06-03 02:27:19 +0000285 AbbrevToUse = Writer.getDeclRecordAbbrev();
286
Sebastian Redl8538e8d2010-08-18 23:57:32 +0000287 Code = serialization::DECL_RECORD;
Chris Lattner12b1c762009-04-27 06:16:06 +0000288}
289
Sebastian Redl3397c552010-08-18 23:56:27 +0000290void ASTDeclWriter::VisitValueDecl(ValueDecl *D) {
Chris Lattner12b1c762009-04-27 06:16:06 +0000291 VisitNamedDecl(D);
292 Writer.AddTypeRef(D->getType(), Record);
293}
294
Sebastian Redl3397c552010-08-18 23:56:27 +0000295void ASTDeclWriter::VisitEnumConstantDecl(EnumConstantDecl *D) {
Chris Lattner12b1c762009-04-27 06:16:06 +0000296 VisitValueDecl(D);
297 Record.push_back(D->getInitExpr()? 1 : 0);
298 if (D->getInitExpr())
299 Writer.AddStmt(D->getInitExpr());
300 Writer.AddAPSInt(D->getInitVal(), Record);
Douglas Gregora72d8c42011-06-03 02:27:19 +0000301
Sebastian Redl8538e8d2010-08-18 23:57:32 +0000302 Code = serialization::DECL_ENUM_CONSTANT;
Chris Lattner12b1c762009-04-27 06:16:06 +0000303}
Argyrios Kyrtzidisd4a7e542009-08-19 01:28:35 +0000304
Sebastian Redl3397c552010-08-18 23:56:27 +0000305void ASTDeclWriter::VisitDeclaratorDecl(DeclaratorDecl *D) {
Argyrios Kyrtzidisd4a7e542009-08-19 01:28:35 +0000306 VisitValueDecl(D);
Abramo Bagnaraff676cb2011-03-08 08:55:46 +0000307 Writer.AddSourceLocation(D->getInnerLocStart(), Record);
Argyrios Kyrtzidis40451072010-10-15 18:21:24 +0000308 Record.push_back(D->hasExtInfo());
309 if (D->hasExtInfo())
310 Writer.AddQualifierInfo(*D->getExtInfo(), Record);
Argyrios Kyrtzidisd4a7e542009-08-19 01:28:35 +0000311}
Chris Lattner12b1c762009-04-27 06:16:06 +0000312
Sebastian Redl3397c552010-08-18 23:56:27 +0000313void ASTDeclWriter::VisitFunctionDecl(FunctionDecl *D) {
Argyrios Kyrtzidis6b541512010-09-08 19:31:22 +0000314 VisitRedeclarable(D);
Douglas Gregord488b3a2011-10-26 17:53:41 +0000315 VisitDeclaratorDecl(D);
Chris Lattner6ad9ac02010-05-07 21:43:38 +0000316
Argyrios Kyrtzidis40451072010-10-15 18:21:24 +0000317 Writer.AddDeclarationNameLoc(D->DNLoc, D->getDeclName(), Record);
Argyrios Kyrtzidisc8f9af22010-07-05 10:38:01 +0000318 Record.push_back(D->getIdentifierNamespace());
Douglas Gregor70762812012-01-04 17:13:46 +0000319
320 // FunctionDecl's body is handled last at ASTWriterDecl::Visit,
321 // after everything else is written.
322
323 Record.push_back(D->getStorageClass()); // FIXME: stable encoding
Douglas Gregor70762812012-01-04 17:13:46 +0000324 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());
Argyrios Kyrtzidis35f3f362012-12-06 18:59:10 +0000336 Record.push_back(D->HasSkippedBody);
Richard Smithad0e27b2013-02-12 05:48:23 +0000337 Record.push_back(D->getLinkage());
Douglas Gregor70762812012-01-04 17:13:46 +0000338 Writer.AddSourceLocation(D->getLocEnd(), Record);
339
Argyrios Kyrtzidisf511ba62010-06-22 09:55:07 +0000340 Record.push_back(D->getTemplatedKind());
341 switch (D->getTemplatedKind()) {
342 case FunctionDecl::TK_NonTemplate:
343 break;
344 case FunctionDecl::TK_FunctionTemplate:
345 Writer.AddDeclRef(D->getDescribedFunctionTemplate(), Record);
346 break;
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);
352 break;
353 }
354 case FunctionDecl::TK_FunctionTemplateSpecialization: {
355 FunctionTemplateSpecializationInfo *
356 FTSInfo = D->getTemplateSpecializationInfo();
Argyrios Kyrtzidisa626a3d2010-09-09 11:28:23 +0000357 Writer.AddDeclRef(FTSInfo->getTemplate(), Record);
Argyrios Kyrtzidisf511ba62010-06-22 09:55:07 +0000358 Record.push_back(FTSInfo->getTemplateSpecializationKind());
359
360 // Template arguments.
Argyrios Kyrtzidisdd41c142010-06-23 13:48:30 +0000361 Writer.AddTemplateArgumentList(FTSInfo->TemplateArguments, Record);
Argyrios Kyrtzidisf511ba62010-06-22 09:55:07 +0000362
363 // Template args as written.
Argyrios Kyrtzidis5efb06f2010-07-02 11:55:40 +0000364 Record.push_back(FTSInfo->TemplateArgumentsAsWritten != 0);
Argyrios Kyrtzidisf511ba62010-06-22 09:55:07 +0000365 if (FTSInfo->TemplateArgumentsAsWritten) {
Argyrios Kyrtzidis71a76052011-09-22 20:07:09 +0000366 Record.push_back(FTSInfo->TemplateArgumentsAsWritten->NumTemplateArgs);
367 for (int i=0, e = FTSInfo->TemplateArgumentsAsWritten->NumTemplateArgs;
368 i!=e; ++i)
Argyrios Kyrtzidisf511ba62010-06-22 09:55:07 +0000369 Writer.AddTemplateArgumentLoc((*FTSInfo->TemplateArgumentsAsWritten)[i],
370 Record);
Argyrios Kyrtzidis71a76052011-09-22 20:07:09 +0000371 Writer.AddSourceLocation(FTSInfo->TemplateArgumentsAsWritten->LAngleLoc,
Argyrios Kyrtzidisf511ba62010-06-22 09:55:07 +0000372 Record);
Argyrios Kyrtzidis71a76052011-09-22 20:07:09 +0000373 Writer.AddSourceLocation(FTSInfo->TemplateArgumentsAsWritten->RAngleLoc,
Argyrios Kyrtzidisf511ba62010-06-22 09:55:07 +0000374 Record);
Argyrios Kyrtzidisf511ba62010-06-22 09:55:07 +0000375 }
Argyrios Kyrtzidis7b081c82010-07-05 10:37:55 +0000376
377 Writer.AddSourceLocation(FTSInfo->getPointOfInstantiation(), Record);
Argyrios Kyrtzidis99a8ca02010-09-13 11:45:48 +0000378
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);
383 }
Argyrios Kyrtzidisa56b0492010-06-25 16:24:51 +0000384 break;
Argyrios Kyrtzidisf511ba62010-06-22 09:55:07 +0000385 }
386 case FunctionDecl::TK_DependentFunctionTemplateSpecialization: {
387 DependentFunctionTemplateSpecializationInfo *
388 DFTSInfo = D->getDependentSpecializationInfo();
389
390 // Templates.
391 Record.push_back(DFTSInfo->getNumTemplates());
392 for (int i=0, e = DFTSInfo->getNumTemplates(); i != e; ++i)
393 Writer.AddDeclRef(DFTSInfo->getTemplate(i), Record);
394
395 // Templates args.
396 Record.push_back(DFTSInfo->getNumTemplateArgs());
397 for (int i=0, e = DFTSInfo->getNumTemplateArgs(); i != e; ++i)
398 Writer.AddTemplateArgumentLoc(DFTSInfo->getTemplateArg(i), Record);
Argyrios Kyrtzidis7b081c82010-07-05 10:37:55 +0000399 Writer.AddSourceLocation(DFTSInfo->getLAngleLoc(), Record);
400 Writer.AddSourceLocation(DFTSInfo->getRAngleLoc(), Record);
Argyrios Kyrtzidisa56b0492010-06-25 16:24:51 +0000401 break;
Argyrios Kyrtzidisf511ba62010-06-22 09:55:07 +0000402 }
403 }
Chris Lattner6ad9ac02010-05-07 21:43:38 +0000404
Chris Lattner12b1c762009-04-27 06:16:06 +0000405 Record.push_back(D->param_size());
406 for (FunctionDecl::param_iterator P = D->param_begin(), PEnd = D->param_end();
407 P != PEnd; ++P)
408 Writer.AddDeclRef(*P, Record);
Sebastian Redl8538e8d2010-08-18 23:57:32 +0000409 Code = serialization::DECL_FUNCTION;
Chris Lattner12b1c762009-04-27 06:16:06 +0000410}
411
Sebastian Redl3397c552010-08-18 23:56:27 +0000412void ASTDeclWriter::VisitObjCMethodDecl(ObjCMethodDecl *D) {
Chris Lattner12b1c762009-04-27 06:16:06 +0000413 VisitNamedDecl(D);
414 // FIXME: convert to LazyStmtPtr?
Mike Stump1eb44332009-09-09 15:08:12 +0000415 // Unlike C/C++, method bodies will never be in header files.
Argyrios Kyrtzidis2f922302010-08-09 10:54:37 +0000416 bool HasBodyStuff = D->getBody() != 0 ||
417 D->getSelfDecl() != 0 || D->getCmdDecl() != 0;
418 Record.push_back(HasBodyStuff);
419 if (HasBodyStuff) {
Argyrios Kyrtzidis6fb0aee2009-06-30 02:35:26 +0000420 Writer.AddStmt(D->getBody());
Chris Lattner12b1c762009-04-27 06:16:06 +0000421 Writer.AddDeclRef(D->getSelfDecl(), Record);
422 Writer.AddDeclRef(D->getCmdDecl(), Record);
423 }
424 Record.push_back(D->isInstanceMethod());
425 Record.push_back(D->isVariadic());
Jordan Rose1e4691b2012-10-10 16:42:25 +0000426 Record.push_back(D->isPropertyAccessor());
Fariborz Jahanian3fe10412010-07-22 18:24:20 +0000427 Record.push_back(D->isDefined());
Argyrios Kyrtzidise15db6f2012-05-09 16:12:57 +0000428 Record.push_back(D->IsOverriding);
Argyrios Kyrtzidis35f3f362012-12-06 18:59:10 +0000429 Record.push_back(D->HasSkippedBody);
Argyrios Kyrtzidis72b26252011-10-14 17:41:52 +0000430
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);
436 }
437
Chris Lattner12b1c762009-04-27 06:16:06 +0000438 // FIXME: stable encoding for @required/@optional
Mike Stump1eb44332009-09-09 15:08:12 +0000439 Record.push_back(D->getImplementationControl());
Chris Lattner12b1c762009-04-27 06:16:06 +0000440 // FIXME: stable encoding for in/out/inout/bycopy/byref/oneway
Mike Stump1eb44332009-09-09 15:08:12 +0000441 Record.push_back(D->getObjCDeclQualifier());
Douglas Gregor926df6c2011-06-11 01:09:30 +0000442 Record.push_back(D->hasRelatedResultType());
Chris Lattner12b1c762009-04-27 06:16:06 +0000443 Writer.AddTypeRef(D->getResultType(), Record);
Douglas Gregor4bc1cb62010-03-08 14:59:44 +0000444 Writer.AddTypeSourceInfo(D->getResultTypeSourceInfo(), Record);
Chris Lattner12b1c762009-04-27 06:16:06 +0000445 Writer.AddSourceLocation(D->getLocEnd(), Record);
446 Record.push_back(D->param_size());
Mike Stump1eb44332009-09-09 15:08:12 +0000447 for (ObjCMethodDecl::param_iterator P = D->param_begin(),
Chris Lattner12b1c762009-04-27 06:16:06 +0000448 PEnd = D->param_end(); P != PEnd; ++P)
449 Writer.AddDeclRef(*P, Record);
Argyrios Kyrtzidis491306a2011-10-03 06:37:04 +0000450
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);
457
Sebastian Redl8538e8d2010-08-18 23:57:32 +0000458 Code = serialization::DECL_OBJC_METHOD;
Chris Lattner12b1c762009-04-27 06:16:06 +0000459}
460
Sebastian Redl3397c552010-08-18 23:56:27 +0000461void ASTDeclWriter::VisitObjCContainerDecl(ObjCContainerDecl *D) {
Chris Lattner12b1c762009-04-27 06:16:06 +0000462 VisitNamedDecl(D);
Argyrios Kyrtzidis1711fc92011-10-04 04:48:02 +0000463 Writer.AddSourceLocation(D->getAtStartLoc(), Record);
Chris Lattner6ad9ac02010-05-07 21:43:38 +0000464 Writer.AddSourceRange(D->getAtEndRange(), Record);
Sebastian Redl8538e8d2010-08-18 23:57:32 +0000465 // Abstract class (no need to define a stable serialization::DECL code).
Chris Lattner12b1c762009-04-27 06:16:06 +0000466}
467
Sebastian Redl3397c552010-08-18 23:56:27 +0000468void ASTDeclWriter::VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) {
Douglas Gregor53df7a12011-12-15 18:03:09 +0000469 VisitRedeclarable(D);
Chris Lattner12b1c762009-04-27 06:16:06 +0000470 VisitObjCContainerDecl(D);
471 Writer.AddTypeRef(QualType(D->getTypeForDecl(), 0), Record);
Ted Kremenek53b94412010-09-01 01:21:15 +0000472
Douglas Gregorc23f8572012-01-15 18:17:48 +0000473 Record.push_back(D->isThisDeclarationADefinition());
474 if (D->isThisDeclarationADefinition()) {
Douglas Gregor2e5c15b2011-12-15 05:27:12 +0000475 // Write the DefinitionData
476 ObjCInterfaceDecl::DefinitionData &Data = D->data();
477
478 Writer.AddDeclRef(D->getSuperClass(), Record);
479 Writer.AddSourceLocation(D->getSuperClassLoc(), Record);
Douglas Gregor05c272f2011-12-15 22:34:59 +0000480 Writer.AddSourceLocation(D->getEndOfDefinitionLoc(), Record);
481
Douglas Gregor2e5c15b2011-12-15 05:27:12 +0000482 // 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();
486 P != PEnd; ++P)
487 Writer.AddDeclRef(*P, Record);
488 for (ObjCInterfaceDecl::protocol_loc_iterator PL = D->protocol_loc_begin(),
489 PLEnd = D->protocol_loc_end();
490 PL != PLEnd; ++PL)
491 Writer.AddSourceLocation(*PL, Record);
492
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();
498 P != PEnd; ++P)
499 Writer.AddDeclRef(*P, Record);
Douglas Gregord3297242013-01-16 23:00:23 +0000500
Douglas Gregor2e5c15b2011-12-15 05:27:12 +0000501
Douglas Gregord3297242013-01-16 23:00:23 +0000502 if (ObjCCategoryDecl *Cat = D->getCategoryListRaw()) {
Douglas Gregorcff9f262012-01-27 01:47:08 +0000503 // Ensure that we write out the set of categories for this class.
504 Writer.ObjCClassesWithCategories.insert(D);
505
506 // Make sure that the categories get serialized.
Douglas Gregord3297242013-01-16 23:00:23 +0000507 for (; Cat; Cat = Cat->getNextClassCategoryRaw())
Douglas Gregorcff9f262012-01-27 01:47:08 +0000508 (void)Writer.GetDeclRef(Cat);
509 }
Douglas Gregor2e5c15b2011-12-15 05:27:12 +0000510 }
511
Sebastian Redl8538e8d2010-08-18 23:57:32 +0000512 Code = serialization::DECL_OBJC_INTERFACE;
Chris Lattner12b1c762009-04-27 06:16:06 +0000513}
514
Sebastian Redl3397c552010-08-18 23:56:27 +0000515void ASTDeclWriter::VisitObjCIvarDecl(ObjCIvarDecl *D) {
Chris Lattner12b1c762009-04-27 06:16:06 +0000516 VisitFieldDecl(D);
517 // FIXME: stable encoding for @public/@private/@protected/@package
Mike Stump1eb44332009-09-09 15:08:12 +0000518 Record.push_back(D->getAccessControl());
Fariborz Jahanianac0021b2010-07-17 18:35:47 +0000519 Record.push_back(D->getSynthesize());
Jonathan D. Turner953c5642011-06-03 23:11:16 +0000520
521 if (!D->hasAttrs() &&
522 !D->isImplicit() &&
523 !D->isUsed(false) &&
524 !D->isInvalidDecl() &&
525 !D->isReferenced() &&
Douglas Gregor8d267c52011-09-09 02:06:17 +0000526 !D->isModulePrivate() &&
Jonathan D. Turner953c5642011-06-03 23:11:16 +0000527 !D->getBitWidth() &&
528 !D->hasExtInfo() &&
529 D->getDeclName())
530 AbbrevToUse = Writer.getDeclObjCIvarAbbrev();
531
Sebastian Redl8538e8d2010-08-18 23:57:32 +0000532 Code = serialization::DECL_OBJC_IVAR;
Chris Lattner12b1c762009-04-27 06:16:06 +0000533}
534
Sebastian Redl3397c552010-08-18 23:56:27 +0000535void ASTDeclWriter::VisitObjCProtocolDecl(ObjCProtocolDecl *D) {
Douglas Gregor1d784b22012-01-01 19:51:50 +0000536 VisitRedeclarable(D);
Chris Lattner12b1c762009-04-27 06:16:06 +0000537 VisitObjCContainerDecl(D);
Douglas Gregor5e2a1ff2012-01-01 19:29:29 +0000538
Douglas Gregorc23f8572012-01-15 18:17:48 +0000539 Record.push_back(D->isThisDeclarationADefinition());
540 if (D->isThisDeclarationADefinition()) {
Douglas Gregor5e2a1ff2012-01-01 19:29:29 +0000541 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();
547 PL != PLEnd; ++PL)
548 Writer.AddSourceLocation(*PL, Record);
549 }
550
Sebastian Redl8538e8d2010-08-18 23:57:32 +0000551 Code = serialization::DECL_OBJC_PROTOCOL;
Chris Lattner12b1c762009-04-27 06:16:06 +0000552}
553
Sebastian Redl3397c552010-08-18 23:56:27 +0000554void ASTDeclWriter::VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D) {
Chris Lattner12b1c762009-04-27 06:16:06 +0000555 VisitFieldDecl(D);
Sebastian Redl8538e8d2010-08-18 23:57:32 +0000556 Code = serialization::DECL_OBJC_AT_DEFS_FIELD;
Chris Lattner12b1c762009-04-27 06:16:06 +0000557}
558
Sebastian Redl3397c552010-08-18 23:56:27 +0000559void ASTDeclWriter::VisitObjCCategoryDecl(ObjCCategoryDecl *D) {
Chris Lattner12b1c762009-04-27 06:16:06 +0000560 VisitObjCContainerDecl(D);
Douglas Gregorcff9f262012-01-27 01:47:08 +0000561 Writer.AddSourceLocation(D->getCategoryNameLoc(), Record);
Fariborz Jahanianaf300292012-02-20 20:09:20 +0000562 Writer.AddSourceLocation(D->getIvarLBraceLoc(), Record);
563 Writer.AddSourceLocation(D->getIvarRBraceLoc(), Record);
Chris Lattner12b1c762009-04-27 06:16:06 +0000564 Writer.AddDeclRef(D->getClassInterface(), Record);
565 Record.push_back(D->protocol_size());
Douglas Gregor18df52b2010-01-16 15:02:53 +0000566 for (ObjCCategoryDecl::protocol_iterator
Chris Lattner12b1c762009-04-27 06:16:06 +0000567 I = D->protocol_begin(), IEnd = D->protocol_end(); I != IEnd; ++I)
568 Writer.AddDeclRef(*I, Record);
Douglas Gregor18df52b2010-01-16 15:02:53 +0000569 for (ObjCCategoryDecl::protocol_loc_iterator
570 PL = D->protocol_loc_begin(), PLEnd = D->protocol_loc_end();
571 PL != PLEnd; ++PL)
572 Writer.AddSourceLocation(*PL, Record);
Sebastian Redl8538e8d2010-08-18 23:57:32 +0000573 Code = serialization::DECL_OBJC_CATEGORY;
Chris Lattner12b1c762009-04-27 06:16:06 +0000574}
575
Sebastian Redl3397c552010-08-18 23:56:27 +0000576void ASTDeclWriter::VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D) {
Chris Lattner12b1c762009-04-27 06:16:06 +0000577 VisitNamedDecl(D);
578 Writer.AddDeclRef(D->getClassInterface(), Record);
Sebastian Redl8538e8d2010-08-18 23:57:32 +0000579 Code = serialization::DECL_OBJC_COMPATIBLE_ALIAS;
Chris Lattner12b1c762009-04-27 06:16:06 +0000580}
581
Sebastian Redl3397c552010-08-18 23:56:27 +0000582void ASTDeclWriter::VisitObjCPropertyDecl(ObjCPropertyDecl *D) {
Chris Lattner12b1c762009-04-27 06:16:06 +0000583 VisitNamedDecl(D);
Fariborz Jahaniand0502402010-01-21 17:36:00 +0000584 Writer.AddSourceLocation(D->getAtLoc(), Record);
Fariborz Jahanian77bfb8b2012-02-29 22:18:55 +0000585 Writer.AddSourceLocation(D->getLParenLoc(), Record);
John McCall83a230c2010-06-04 20:50:08 +0000586 Writer.AddTypeSourceInfo(D->getTypeSourceInfo(), Record);
Chris Lattner12b1c762009-04-27 06:16:06 +0000587 // FIXME: stable encoding
588 Record.push_back((unsigned)D->getPropertyAttributes());
Fariborz Jahanian80aa1cd2010-06-22 23:20:40 +0000589 Record.push_back((unsigned)D->getPropertyAttributesAsWritten());
Chris Lattner12b1c762009-04-27 06:16:06 +0000590 // 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);
Sebastian Redl8538e8d2010-08-18 23:57:32 +0000597 Code = serialization::DECL_OBJC_PROPERTY;
Chris Lattner12b1c762009-04-27 06:16:06 +0000598}
599
Sebastian Redl3397c552010-08-18 23:56:27 +0000600void ASTDeclWriter::VisitObjCImplDecl(ObjCImplDecl *D) {
Argyrios Kyrtzidisaecae622009-07-27 19:04:32 +0000601 VisitObjCContainerDecl(D);
Chris Lattner12b1c762009-04-27 06:16:06 +0000602 Writer.AddDeclRef(D->getClassInterface(), Record);
Sebastian Redl8538e8d2010-08-18 23:57:32 +0000603 // Abstract class (no need to define a stable serialization::DECL code).
Chris Lattner12b1c762009-04-27 06:16:06 +0000604}
605
Sebastian Redl3397c552010-08-18 23:56:27 +0000606void ASTDeclWriter::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
Chris Lattner12b1c762009-04-27 06:16:06 +0000607 VisitObjCImplDecl(D);
608 Writer.AddIdentifierRef(D->getIdentifier(), Record);
Argyrios Kyrtzidisc6994002011-12-09 00:31:40 +0000609 Writer.AddSourceLocation(D->getCategoryNameLoc(), Record);
Sebastian Redl8538e8d2010-08-18 23:57:32 +0000610 Code = serialization::DECL_OBJC_CATEGORY_IMPL;
Chris Lattner12b1c762009-04-27 06:16:06 +0000611}
612
Sebastian Redl3397c552010-08-18 23:56:27 +0000613void ASTDeclWriter::VisitObjCImplementationDecl(ObjCImplementationDecl *D) {
Chris Lattner12b1c762009-04-27 06:16:06 +0000614 VisitObjCImplDecl(D);
615 Writer.AddDeclRef(D->getSuperClass(), Record);
Fariborz Jahanianaf300292012-02-20 20:09:20 +0000616 Writer.AddSourceLocation(D->getIvarLBraceLoc(), Record);
617 Writer.AddSourceLocation(D->getIvarRBraceLoc(), Record);
John McCallb03527a2012-10-17 04:53:31 +0000618 Record.push_back(D->hasNonZeroConstructors());
619 Record.push_back(D->hasDestructors());
Sean Huntcbb67482011-01-08 20:30:50 +0000620 Writer.AddCXXCtorInitializers(D->IvarInitializers, D->NumIvarInitializers,
621 Record);
Sebastian Redl8538e8d2010-08-18 23:57:32 +0000622 Code = serialization::DECL_OBJC_IMPLEMENTATION;
Chris Lattner12b1c762009-04-27 06:16:06 +0000623}
624
Sebastian Redl3397c552010-08-18 23:56:27 +0000625void ASTDeclWriter::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) {
Chris Lattner12b1c762009-04-27 06:16:06 +0000626 VisitDecl(D);
627 Writer.AddSourceLocation(D->getLocStart(), Record);
628 Writer.AddDeclRef(D->getPropertyDecl(), Record);
629 Writer.AddDeclRef(D->getPropertyIvarDecl(), Record);
Douglas Gregora4ffd852010-11-17 01:03:52 +0000630 Writer.AddSourceLocation(D->getPropertyIvarDeclLoc(), Record);
Argyrios Kyrtzidis2f922302010-08-09 10:54:37 +0000631 Writer.AddStmt(D->getGetterCXXConstructor());
632 Writer.AddStmt(D->getSetterCXXAssignment());
Sebastian Redl8538e8d2010-08-18 23:57:32 +0000633 Code = serialization::DECL_OBJC_PROPERTY_IMPL;
Chris Lattner12b1c762009-04-27 06:16:06 +0000634}
635
Sebastian Redl3397c552010-08-18 23:56:27 +0000636void ASTDeclWriter::VisitFieldDecl(FieldDecl *D) {
Argyrios Kyrtzidisd4a7e542009-08-19 01:28:35 +0000637 VisitDeclaratorDecl(D);
Chris Lattner12b1c762009-04-27 06:16:06 +0000638 Record.push_back(D->isMutable());
Richard Smithca523302012-06-10 03:12:00 +0000639 if (D->InitializerOrBitWidth.getInt() != ICIS_NoInit ||
640 D->InitializerOrBitWidth.getPointer()) {
641 Record.push_back(D->InitializerOrBitWidth.getInt() + 1);
642 Writer.AddStmt(D->InitializerOrBitWidth.getPointer());
643 } else {
644 Record.push_back(0);
645 }
Argyrios Kyrtzidisc91e9f42010-07-04 21:44:35 +0000646 if (!D->getDeclName())
647 Writer.AddDeclRef(Context.getInstantiatedFromUnnamedFieldDecl(D), Record);
Jonathan D. Turner953c5642011-06-03 23:11:16 +0000648
649 if (!D->hasAttrs() &&
650 !D->isImplicit() &&
651 !D->isUsed(false) &&
652 !D->isInvalidDecl() &&
653 !D->isReferenced() &&
Argyrios Kyrtzidisbcf8df82011-11-23 21:11:23 +0000654 !D->isTopLevelDeclInObjCContainer() &&
Douglas Gregor8d267c52011-09-09 02:06:17 +0000655 !D->isModulePrivate() &&
Jonathan D. Turner953c5642011-06-03 23:11:16 +0000656 !D->getBitWidth() &&
Richard Smith7a614d82011-06-11 17:19:42 +0000657 !D->hasInClassInitializer() &&
Jonathan D. Turner953c5642011-06-03 23:11:16 +0000658 !D->hasExtInfo() &&
659 !ObjCIvarDecl::classofKind(D->getKind()) &&
660 !ObjCAtDefsFieldDecl::classofKind(D->getKind()) &&
661 D->getDeclName())
662 AbbrevToUse = Writer.getDeclFieldAbbrev();
663
Sebastian Redl8538e8d2010-08-18 23:57:32 +0000664 Code = serialization::DECL_FIELD;
Chris Lattner12b1c762009-04-27 06:16:06 +0000665}
666
John McCall76da55d2013-04-16 07:28:30 +0000667void ASTDeclWriter::VisitMSPropertyDecl(MSPropertyDecl *D) {
668 VisitDeclaratorDecl(D);
669 Writer.AddIdentifierRef(D->getGetterId(), Record);
670 Writer.AddIdentifierRef(D->getSetterId(), Record);
671 Code = serialization::DECL_MS_PROPERTY;
672}
673
Francois Pichet87c2e122010-11-21 06:08:52 +0000674void ASTDeclWriter::VisitIndirectFieldDecl(IndirectFieldDecl *D) {
675 VisitValueDecl(D);
676 Record.push_back(D->getChainingSize());
677
678 for (IndirectFieldDecl::chain_iterator
679 P = D->chain_begin(),
680 PEnd = D->chain_end(); P != PEnd; ++P)
681 Writer.AddDeclRef(*P, Record);
682 Code = serialization::DECL_INDIRECTFIELD;
683}
684
Sebastian Redl3397c552010-08-18 23:56:27 +0000685void ASTDeclWriter::VisitVarDecl(VarDecl *D) {
Argyrios Kyrtzidis6b541512010-09-08 19:31:22 +0000686 VisitRedeclarable(D);
Douglas Gregord488b3a2011-10-26 17:53:41 +0000687 VisitDeclaratorDecl(D);
Rafael Espindolad2615cc2013-04-03 19:27:57 +0000688 Record.push_back(D->getStorageClass());
Richard Smith38afbc72013-04-13 02:43:54 +0000689 Record.push_back(D->getTLSKind());
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +0000690 Record.push_back(D->getInitStyle());
Douglas Gregor324b54d2010-05-03 18:51:14 +0000691 Record.push_back(D->isExceptionVariable());
Douglas Gregor5077c382010-05-15 06:01:05 +0000692 Record.push_back(D->isNRVOVariable());
Richard Smithad762fc2011-04-14 22:09:26 +0000693 Record.push_back(D->isCXXForRangeDecl());
John McCall7acddac2011-06-17 06:42:21 +0000694 Record.push_back(D->isARCPseudoStrong());
Douglas Gregor67d45ec2012-09-20 23:43:29 +0000695 Record.push_back(D->isConstexpr());
Richard Smithad0e27b2013-02-12 05:48:23 +0000696 Record.push_back(D->getLinkage());
Douglas Gregor67d45ec2012-09-20 23:43:29 +0000697
Richard Smith099e7f62011-12-19 06:19:21 +0000698 if (D->getInit()) {
699 Record.push_back(!D->isInitKnownICE() ? 1 : (D->isInitICE() ? 3 : 2));
Chris Lattner12b1c762009-04-27 06:16:06 +0000700 Writer.AddStmt(D->getInit());
Richard Smith099e7f62011-12-19 06:19:21 +0000701 } else {
702 Record.push_back(0);
703 }
Argyrios Kyrtzidis9421adc2010-07-04 21:44:00 +0000704
705 MemberSpecializationInfo *SpecInfo
706 = D->isStaticDataMember() ? D->getMemberSpecializationInfo() : 0;
707 Record.push_back(SpecInfo != 0);
708 if (SpecInfo) {
709 Writer.AddDeclRef(SpecInfo->getInstantiatedFrom(), Record);
710 Record.push_back(SpecInfo->getTemplateSpecializationKind());
711 Writer.AddSourceLocation(SpecInfo->getPointOfInstantiation(), Record);
712 }
713
Jonathan D. Turner953c5642011-06-03 23:11:16 +0000714 if (!D->hasAttrs() &&
715 !D->isImplicit() &&
716 !D->isUsed(false) &&
717 !D->isInvalidDecl() &&
718 !D->isReferenced() &&
Argyrios Kyrtzidisbcf8df82011-11-23 21:11:23 +0000719 !D->isTopLevelDeclInObjCContainer() &&
Jonathan D. Turner953c5642011-06-03 23:11:16 +0000720 D->getAccess() == AS_none &&
Douglas Gregor8d267c52011-09-09 02:06:17 +0000721 !D->isModulePrivate() &&
Jonathan D. Turner953c5642011-06-03 23:11:16 +0000722 D->getDeclName().getNameKind() == DeclarationName::Identifier &&
723 !D->hasExtInfo() &&
Douglas Gregor2171bf12012-01-15 16:58:34 +0000724 D->getFirstDeclaration() == D->getMostRecentDecl() &&
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +0000725 D->getInitStyle() == VarDecl::CInit &&
Jonathan D. Turner953c5642011-06-03 23:11:16 +0000726 D->getInit() == 0 &&
John McCall7acddac2011-06-17 06:42:21 +0000727 !isa<ParmVarDecl>(D) &&
Douglas Gregor67d45ec2012-09-20 23:43:29 +0000728 !D->isConstexpr() &&
Jonathan D. Turner953c5642011-06-03 23:11:16 +0000729 !SpecInfo)
730 AbbrevToUse = Writer.getDeclVarAbbrev();
731
Sebastian Redl8538e8d2010-08-18 23:57:32 +0000732 Code = serialization::DECL_VAR;
Chris Lattner12b1c762009-04-27 06:16:06 +0000733}
734
Sebastian Redl3397c552010-08-18 23:56:27 +0000735void ASTDeclWriter::VisitImplicitParamDecl(ImplicitParamDecl *D) {
Chris Lattner12b1c762009-04-27 06:16:06 +0000736 VisitVarDecl(D);
Sebastian Redl8538e8d2010-08-18 23:57:32 +0000737 Code = serialization::DECL_IMPLICIT_PARAM;
Chris Lattner12b1c762009-04-27 06:16:06 +0000738}
739
Sebastian Redl3397c552010-08-18 23:56:27 +0000740void ASTDeclWriter::VisitParmVarDecl(ParmVarDecl *D) {
Chris Lattner12b1c762009-04-27 06:16:06 +0000741 VisitVarDecl(D);
John McCall70798862011-05-02 00:30:12 +0000742 Record.push_back(D->isObjCMethodParameter());
John McCallfb44de92011-05-01 22:35:37 +0000743 Record.push_back(D->getFunctionScopeDepth());
744 Record.push_back(D->getFunctionScopeIndex());
Chris Lattner12b1c762009-04-27 06:16:06 +0000745 Record.push_back(D->getObjCDeclQualifier()); // FIXME: stable encoding
John McCalleecf5fa2011-03-09 04:22:44 +0000746 Record.push_back(D->isKNRPromoted());
John McCallbf73b352010-03-12 18:31:32 +0000747 Record.push_back(D->hasInheritedDefaultArg());
Argyrios Kyrtzidis691d77f2010-07-04 21:44:07 +0000748 Record.push_back(D->hasUninstantiatedDefaultArg());
749 if (D->hasUninstantiatedDefaultArg())
750 Writer.AddStmt(D->getUninstantiatedDefaultArg());
Sebastian Redl8538e8d2010-08-18 23:57:32 +0000751 Code = serialization::DECL_PARM_VAR;
Mike Stump1eb44332009-09-09 15:08:12 +0000752
John McCall7acddac2011-06-17 06:42:21 +0000753 assert(!D->isARCPseudoStrong()); // can be true of ImplicitParamDecl
754
Chris Lattnerea5ce472009-04-27 07:35:58 +0000755 // If the assumptions about the DECL_PARM_VAR abbrev are true, use it. Here
756 // we dynamically check for the properties that we optimize for, but don't
757 // know are true of all PARM_VAR_DECLs.
Jonathan D. Turner953c5642011-06-03 23:11:16 +0000758 if (!D->hasAttrs() &&
759 !D->hasExtInfo() &&
Chris Lattnerea5ce472009-04-27 07:35:58 +0000760 !D->isImplicit() &&
Douglas Gregorc070cc62010-06-17 23:14:26 +0000761 !D->isUsed(false) &&
Argyrios Kyrtzidisba50b3e2012-03-09 21:09:04 +0000762 !D->isInvalidDecl() &&
Eli Friedmandd9d6452012-01-13 23:41:25 +0000763 !D->isReferenced() &&
Chris Lattnerea5ce472009-04-27 07:35:58 +0000764 D->getAccess() == AS_none &&
Douglas Gregor8d267c52011-09-09 02:06:17 +0000765 !D->isModulePrivate() &&
Chris Lattnerea5ce472009-04-27 07:35:58 +0000766 D->getStorageClass() == 0 &&
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +0000767 D->getInitStyle() == VarDecl::CInit && // Can params have anything else?
John McCall70798862011-05-02 00:30:12 +0000768 D->getFunctionScopeDepth() == 0 &&
John McCallbf73b352010-03-12 18:31:32 +0000769 D->getObjCDeclQualifier() == 0 &&
John McCalleecf5fa2011-03-09 04:22:44 +0000770 !D->isKNRPromoted() &&
Chris Lattner030854b2010-05-09 06:40:08 +0000771 !D->hasInheritedDefaultArg() &&
Argyrios Kyrtzidis691d77f2010-07-04 21:44:07 +0000772 D->getInit() == 0 &&
773 !D->hasUninstantiatedDefaultArg()) // No default expr.
Jonathan D. Turner953c5642011-06-03 23:11:16 +0000774 AbbrevToUse = Writer.getDeclParmVarAbbrev();
Chris Lattnerea5ce472009-04-27 07:35:58 +0000775
776 // Check things we know are true of *every* PARM_VAR_DECL, which is more than
777 // just us assuming it.
Richard Smith38afbc72013-04-13 02:43:54 +0000778 assert(!D->getTLSKind() && "PARM_VAR_DECL can't use TLS");
Chris Lattnerea5ce472009-04-27 07:35:58 +0000779 assert(D->getAccess() == AS_none && "PARM_VAR_DECL can't be public/private");
Douglas Gregor324b54d2010-05-03 18:51:14 +0000780 assert(!D->isExceptionVariable() && "PARM_VAR_DECL can't be exception var");
Douglas Gregoref96ee02012-01-14 16:38:05 +0000781 assert(D->getPreviousDecl() == 0 && "PARM_VAR_DECL can't be redecl");
Argyrios Kyrtzidis9421adc2010-07-04 21:44:00 +0000782 assert(!D->isStaticDataMember() &&
783 "PARM_VAR_DECL can't be static data member");
Chris Lattner12b1c762009-04-27 06:16:06 +0000784}
785
Sebastian Redl3397c552010-08-18 23:56:27 +0000786void ASTDeclWriter::VisitFileScopeAsmDecl(FileScopeAsmDecl *D) {
Chris Lattner12b1c762009-04-27 06:16:06 +0000787 VisitDecl(D);
788 Writer.AddStmt(D->getAsmString());
Abramo Bagnara21e006e2011-03-03 14:20:18 +0000789 Writer.AddSourceLocation(D->getRParenLoc(), Record);
Sebastian Redl8538e8d2010-08-18 23:57:32 +0000790 Code = serialization::DECL_FILE_SCOPE_ASM;
Chris Lattner12b1c762009-04-27 06:16:06 +0000791}
792
Michael Han684aa732013-02-22 17:15:32 +0000793void ASTDeclWriter::VisitEmptyDecl(EmptyDecl *D) {
794 VisitDecl(D);
795 Code = serialization::DECL_EMPTY;
796}
797
Sebastian Redl3397c552010-08-18 23:56:27 +0000798void ASTDeclWriter::VisitBlockDecl(BlockDecl *D) {
Chris Lattner12b1c762009-04-27 06:16:06 +0000799 VisitDecl(D);
800 Writer.AddStmt(D->getBody());
John McCall82dc0092010-06-04 11:21:44 +0000801 Writer.AddTypeSourceInfo(D->getSignatureAsWritten(), Record);
Chris Lattner12b1c762009-04-27 06:16:06 +0000802 Record.push_back(D->param_size());
803 for (FunctionDecl::param_iterator P = D->param_begin(), PEnd = D->param_end();
804 P != PEnd; ++P)
805 Writer.AddDeclRef(*P, Record);
John McCallb8896142012-04-13 17:33:29 +0000806 Record.push_back(D->isVariadic());
807 Record.push_back(D->blockMissingReturnType());
808 Record.push_back(D->isConversionFromLambda());
John McCall469a1eb2011-02-02 13:00:07 +0000809 Record.push_back(D->capturesCXXThis());
John McCall6b5a61b2011-02-07 10:33:21 +0000810 Record.push_back(D->getNumCaptures());
John McCall469a1eb2011-02-02 13:00:07 +0000811 for (BlockDecl::capture_iterator
John McCall6b5a61b2011-02-07 10:33:21 +0000812 i = D->capture_begin(), e = D->capture_end(); i != e; ++i) {
813 const BlockDecl::Capture &capture = *i;
814 Writer.AddDeclRef(capture.getVariable(), Record);
815
816 unsigned flags = 0;
817 if (capture.isByRef()) flags |= 1;
818 if (capture.isNested()) flags |= 2;
819 if (capture.hasCopyExpr()) flags |= 4;
820 Record.push_back(flags);
821
822 if (capture.hasCopyExpr()) Writer.AddStmt(capture.getCopyExpr());
823 }
John McCall469a1eb2011-02-02 13:00:07 +0000824
Sebastian Redl8538e8d2010-08-18 23:57:32 +0000825 Code = serialization::DECL_BLOCK;
Chris Lattner12b1c762009-04-27 06:16:06 +0000826}
827
Tareq A. Siraj6afcf882013-04-16 19:37:38 +0000828void ASTDeclWriter::VisitCapturedDecl(CapturedDecl *) {
829 llvm_unreachable("not implemented yet");
830}
831
Sebastian Redl3397c552010-08-18 23:56:27 +0000832void ASTDeclWriter::VisitLinkageSpecDecl(LinkageSpecDecl *D) {
Chris Lattner6ad9ac02010-05-07 21:43:38 +0000833 VisitDecl(D);
Chris Lattner6ad9ac02010-05-07 21:43:38 +0000834 Record.push_back(D->getLanguage());
Abramo Bagnaraa2026c92011-03-08 16:41:52 +0000835 Writer.AddSourceLocation(D->getExternLoc(), Record);
Abramo Bagnara5f6bcbe2011-03-03 14:52:38 +0000836 Writer.AddSourceLocation(D->getRBraceLoc(), Record);
Sebastian Redl8538e8d2010-08-18 23:57:32 +0000837 Code = serialization::DECL_LINKAGE_SPEC;
Chris Lattner6ad9ac02010-05-07 21:43:38 +0000838}
839
Chris Lattnerad8dcf42011-02-17 07:39:24 +0000840void ASTDeclWriter::VisitLabelDecl(LabelDecl *D) {
841 VisitNamedDecl(D);
Abramo Bagnara67843042011-03-05 18:21:20 +0000842 Writer.AddSourceLocation(D->getLocStart(), Record);
Chris Lattnerad8dcf42011-02-17 07:39:24 +0000843 Code = serialization::DECL_LABEL;
844}
845
846
Sebastian Redl3397c552010-08-18 23:56:27 +0000847void ASTDeclWriter::VisitNamespaceDecl(NamespaceDecl *D) {
Douglas Gregorf5c9f9f2012-01-07 09:11:48 +0000848 VisitRedeclarable(D);
Chris Lattner6ad9ac02010-05-07 21:43:38 +0000849 VisitNamedDecl(D);
Douglas Gregor0a0c3e72010-10-05 20:41:58 +0000850 Record.push_back(D->isInline());
Abramo Bagnaraacba90f2011-03-08 12:38:20 +0000851 Writer.AddSourceLocation(D->getLocStart(), Record);
852 Writer.AddSourceLocation(D->getRBraceLoc(), Record);
Chris Lattner6ad9ac02010-05-07 21:43:38 +0000853
Chris Lattner6ad9ac02010-05-07 21:43:38 +0000854 if (D->isOriginalNamespace())
855 Writer.AddDeclRef(D->getAnonymousNamespace(), Record);
Sebastian Redl8538e8d2010-08-18 23:57:32 +0000856 Code = serialization::DECL_NAMESPACE;
Sebastian Redla7be5062010-08-05 21:22:19 +0000857
858 if (Writer.hasChain() && !D->isOriginalNamespace() &&
Douglas Gregor919814d2011-09-09 23:01:35 +0000859 D->getOriginalNamespace()->isFromASTFile()) {
Argyrios Kyrtzidis0ad6dc32010-10-20 16:22:56 +0000860 NamespaceDecl *NS = D->getOriginalNamespace();
Argyrios Kyrtzidis100050b2010-10-28 07:38:51 +0000861 Writer.AddUpdatedDeclContext(NS);
Argyrios Kyrtzidis0ad6dc32010-10-20 16:22:56 +0000862
863 // Make sure all visible decls are written. They will be recorded later.
Richard Smithc5d3e802012-03-16 06:12:59 +0000864 if (StoredDeclsMap *Map = NS->buildLookup()) {
Argyrios Kyrtzidis0ad6dc32010-10-20 16:22:56 +0000865 for (StoredDeclsMap::iterator D = Map->begin(), DEnd = Map->end();
866 D != DEnd; ++D) {
David Blaikie3bc93e32012-12-19 00:45:41 +0000867 DeclContext::lookup_result R = D->second.getLookupResult();
868 for (DeclContext::lookup_iterator I = R.begin(), E = R.end(); I != E;
869 ++I)
870 Writer.GetDeclRef(*I);
Argyrios Kyrtzidis0ad6dc32010-10-20 16:22:56 +0000871 }
872 }
Sebastian Redla7be5062010-08-05 21:22:19 +0000873 }
Sebastian Redl7c0837f2011-04-24 16:28:13 +0000874
Douglas Gregorf5c9f9f2012-01-07 09:11:48 +0000875 if (Writer.hasChain() && D->isAnonymousNamespace() &&
Douglas Gregoref96ee02012-01-14 16:38:05 +0000876 D == D->getMostRecentDecl()) {
Sebastian Redl74b485a2011-04-24 16:28:21 +0000877 // This is a most recent reopening of the anonymous namespace. If its parent
878 // is in a previous PCH (or is the TU), mark that parent for update, because
879 // the original namespace always points to the latest re-opening of its
880 // anonymous namespace.
881 Decl *Parent = cast<Decl>(
882 D->getParent()->getRedeclContext()->getPrimaryContext());
Douglas Gregor919814d2011-09-09 23:01:35 +0000883 if (Parent->isFromASTFile() || isa<TranslationUnitDecl>(Parent)) {
Sebastian Redl7c0837f2011-04-24 16:28:13 +0000884 ASTWriter::UpdateRecord &Record = Writer.DeclUpdates[Parent];
885 Record.push_back(UPD_CXX_ADDED_ANONYMOUS_NAMESPACE);
886 Writer.AddDeclRef(D, Record);
887 }
888 }
Chris Lattner6ad9ac02010-05-07 21:43:38 +0000889}
890
Sebastian Redl3397c552010-08-18 23:56:27 +0000891void ASTDeclWriter::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) {
Chris Lattner6ad9ac02010-05-07 21:43:38 +0000892 VisitNamedDecl(D);
Douglas Gregor8ea5b9d2010-09-01 00:08:19 +0000893 Writer.AddSourceLocation(D->getNamespaceLoc(), Record);
Chris Lattner6ad9ac02010-05-07 21:43:38 +0000894 Writer.AddSourceLocation(D->getTargetNameLoc(), Record);
Douglas Gregor0cfaf6a2011-02-25 17:08:07 +0000895 Writer.AddNestedNameSpecifierLoc(D->getQualifierLoc(), Record);
Chris Lattner6ad9ac02010-05-07 21:43:38 +0000896 Writer.AddDeclRef(D->getNamespace(), Record);
Sebastian Redl8538e8d2010-08-18 23:57:32 +0000897 Code = serialization::DECL_NAMESPACE_ALIAS;
Chris Lattner6ad9ac02010-05-07 21:43:38 +0000898}
899
Sebastian Redl3397c552010-08-18 23:56:27 +0000900void ASTDeclWriter::VisitUsingDecl(UsingDecl *D) {
Chris Lattner6ad9ac02010-05-07 21:43:38 +0000901 VisitNamedDecl(D);
Chris Lattner6ad9ac02010-05-07 21:43:38 +0000902 Writer.AddSourceLocation(D->getUsingLocation(), Record);
Douglas Gregordc355712011-02-25 00:36:19 +0000903 Writer.AddNestedNameSpecifierLoc(D->getQualifierLoc(), Record);
Argyrios Kyrtzidis40451072010-10-15 18:21:24 +0000904 Writer.AddDeclarationNameLoc(D->DNLoc, D->getDeclName(), Record);
Benjamin Kramer9bc6fb62012-01-07 19:09:05 +0000905 Writer.AddDeclRef(D->FirstUsingShadow.getPointer(), Record);
Chris Lattner6ad9ac02010-05-07 21:43:38 +0000906 Record.push_back(D->isTypeName());
Argyrios Kyrtzidisc91e9f42010-07-04 21:44:35 +0000907 Writer.AddDeclRef(Context.getInstantiatedFromUsingDecl(D), Record);
Sebastian Redl8538e8d2010-08-18 23:57:32 +0000908 Code = serialization::DECL_USING;
Chris Lattner6ad9ac02010-05-07 21:43:38 +0000909}
910
Sebastian Redl3397c552010-08-18 23:56:27 +0000911void ASTDeclWriter::VisitUsingShadowDecl(UsingShadowDecl *D) {
Chris Lattner6ad9ac02010-05-07 21:43:38 +0000912 VisitNamedDecl(D);
913 Writer.AddDeclRef(D->getTargetDecl(), Record);
Argyrios Kyrtzidis826faa22010-11-10 05:40:41 +0000914 Writer.AddDeclRef(D->UsingOrNextShadow, Record);
Argyrios Kyrtzidisc91e9f42010-07-04 21:44:35 +0000915 Writer.AddDeclRef(Context.getInstantiatedFromUsingShadowDecl(D), Record);
Sebastian Redl8538e8d2010-08-18 23:57:32 +0000916 Code = serialization::DECL_USING_SHADOW;
Chris Lattner6ad9ac02010-05-07 21:43:38 +0000917}
918
Sebastian Redl3397c552010-08-18 23:56:27 +0000919void ASTDeclWriter::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
Chris Lattner6ad9ac02010-05-07 21:43:38 +0000920 VisitNamedDecl(D);
Douglas Gregor0a35bce2010-09-01 03:07:18 +0000921 Writer.AddSourceLocation(D->getUsingLoc(), Record);
Chris Lattner6ad9ac02010-05-07 21:43:38 +0000922 Writer.AddSourceLocation(D->getNamespaceKeyLocation(), Record);
Douglas Gregordb992412011-02-25 16:33:46 +0000923 Writer.AddNestedNameSpecifierLoc(D->getQualifierLoc(), Record);
Chris Lattner6ad9ac02010-05-07 21:43:38 +0000924 Writer.AddDeclRef(D->getNominatedNamespace(), Record);
925 Writer.AddDeclRef(dyn_cast<Decl>(D->getCommonAncestor()), Record);
Sebastian Redl8538e8d2010-08-18 23:57:32 +0000926 Code = serialization::DECL_USING_DIRECTIVE;
Chris Lattner6ad9ac02010-05-07 21:43:38 +0000927}
928
Sebastian Redl3397c552010-08-18 23:56:27 +0000929void ASTDeclWriter::VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) {
Chris Lattner6ad9ac02010-05-07 21:43:38 +0000930 VisitValueDecl(D);
Chris Lattner6ad9ac02010-05-07 21:43:38 +0000931 Writer.AddSourceLocation(D->getUsingLoc(), Record);
Douglas Gregordc355712011-02-25 00:36:19 +0000932 Writer.AddNestedNameSpecifierLoc(D->getQualifierLoc(), Record);
Argyrios Kyrtzidis40451072010-10-15 18:21:24 +0000933 Writer.AddDeclarationNameLoc(D->DNLoc, D->getDeclName(), Record);
Sebastian Redl8538e8d2010-08-18 23:57:32 +0000934 Code = serialization::DECL_UNRESOLVED_USING_VALUE;
Chris Lattner6ad9ac02010-05-07 21:43:38 +0000935}
936
Sebastian Redl3397c552010-08-18 23:56:27 +0000937void ASTDeclWriter::VisitUnresolvedUsingTypenameDecl(
Chris Lattner6ad9ac02010-05-07 21:43:38 +0000938 UnresolvedUsingTypenameDecl *D) {
939 VisitTypeDecl(D);
Chris Lattner6ad9ac02010-05-07 21:43:38 +0000940 Writer.AddSourceLocation(D->getTypenameLoc(), Record);
Douglas Gregordc355712011-02-25 00:36:19 +0000941 Writer.AddNestedNameSpecifierLoc(D->getQualifierLoc(), Record);
Sebastian Redl8538e8d2010-08-18 23:57:32 +0000942 Code = serialization::DECL_UNRESOLVED_USING_TYPENAME;
Chris Lattner6ad9ac02010-05-07 21:43:38 +0000943}
944
Sebastian Redl3397c552010-08-18 23:56:27 +0000945void ASTDeclWriter::VisitCXXRecordDecl(CXXRecordDecl *D) {
Chris Lattner6ad9ac02010-05-07 21:43:38 +0000946 VisitRecordDecl(D);
Douglas Gregorc23f8572012-01-15 18:17:48 +0000947 Record.push_back(D->isThisDeclarationADefinition());
948 if (D->isThisDeclarationADefinition())
Argyrios Kyrtzidis89eaf3a2010-10-24 17:26:40 +0000949 Writer.AddCXXDefinitionData(D, Record);
Argyrios Kyrtzidis37ffed32010-07-02 11:55:32 +0000950
Argyrios Kyrtzidis90b715e2010-06-19 19:28:53 +0000951 enum {
952 CXXRecNotTemplate = 0, CXXRecTemplate, CXXRecMemberSpecialization
953 };
954 if (ClassTemplateDecl *TemplD = D->getDescribedClassTemplate()) {
955 Record.push_back(CXXRecTemplate);
956 Writer.AddDeclRef(TemplD, Record);
957 } else if (MemberSpecializationInfo *MSInfo
958 = D->getMemberSpecializationInfo()) {
959 Record.push_back(CXXRecMemberSpecialization);
960 Writer.AddDeclRef(MSInfo->getInstantiatedFrom(), Record);
961 Record.push_back(MSInfo->getTemplateSpecializationKind());
962 Writer.AddSourceLocation(MSInfo->getPointOfInstantiation(), Record);
963 } else {
964 Record.push_back(CXXRecNotTemplate);
965 }
966
John McCalld5617ee2013-01-25 22:31:03 +0000967 // Store (what we currently believe to be) the key function to avoid
968 // deserializing every method so we can compute it.
John McCall5e1cdac2011-10-07 06:10:15 +0000969 if (D->IsCompleteDefinition)
John McCalld5617ee2013-01-25 22:31:03 +0000970 Writer.AddDeclRef(Context.getCurrentKeyFunction(D), Record);
Argyrios Kyrtzidis36d2fd42010-10-14 20:14:38 +0000971
Sebastian Redl8538e8d2010-08-18 23:57:32 +0000972 Code = serialization::DECL_CXX_RECORD;
Chris Lattner6ad9ac02010-05-07 21:43:38 +0000973}
974
Sebastian Redl3397c552010-08-18 23:56:27 +0000975void ASTDeclWriter::VisitCXXMethodDecl(CXXMethodDecl *D) {
Chris Lattner6ad9ac02010-05-07 21:43:38 +0000976 VisitFunctionDecl(D);
Argyrios Kyrtzidis716c8df2012-10-12 05:31:40 +0000977 if (D->isCanonicalDecl()) {
978 Record.push_back(D->size_overridden_methods());
979 for (CXXMethodDecl::method_iterator
980 I = D->begin_overridden_methods(), E = D->end_overridden_methods();
981 I != E; ++I)
982 Writer.AddDeclRef(*I, Record);
983 } else {
984 // We only need to record overridden methods once for the canonical decl.
985 Record.push_back(0);
986 }
Sebastian Redl8538e8d2010-08-18 23:57:32 +0000987 Code = serialization::DECL_CXX_METHOD;
Chris Lattner6ad9ac02010-05-07 21:43:38 +0000988}
989
Sebastian Redl3397c552010-08-18 23:56:27 +0000990void ASTDeclWriter::VisitCXXConstructorDecl(CXXConstructorDecl *D) {
Chris Lattner6ad9ac02010-05-07 21:43:38 +0000991 VisitCXXMethodDecl(D);
Argyrios Kyrtzidis91468322010-07-02 15:58:43 +0000992
993 Record.push_back(D->IsExplicitSpecified);
994 Record.push_back(D->ImplicitlyDefined);
Sean Huntcbb67482011-01-08 20:30:50 +0000995 Writer.AddCXXCtorInitializers(D->CtorInitializers, D->NumCtorInitializers,
996 Record);
Argyrios Kyrtzidis91468322010-07-02 15:58:43 +0000997
Sebastian Redl8538e8d2010-08-18 23:57:32 +0000998 Code = serialization::DECL_CXX_CONSTRUCTOR;
Chris Lattner6ad9ac02010-05-07 21:43:38 +0000999}
1000
Sebastian Redl3397c552010-08-18 23:56:27 +00001001void ASTDeclWriter::VisitCXXDestructorDecl(CXXDestructorDecl *D) {
Chris Lattner6ad9ac02010-05-07 21:43:38 +00001002 VisitCXXMethodDecl(D);
Argyrios Kyrtzidis91468322010-07-02 15:58:43 +00001003
1004 Record.push_back(D->ImplicitlyDefined);
1005 Writer.AddDeclRef(D->OperatorDelete, Record);
1006
Sebastian Redl8538e8d2010-08-18 23:57:32 +00001007 Code = serialization::DECL_CXX_DESTRUCTOR;
Chris Lattner6ad9ac02010-05-07 21:43:38 +00001008}
1009
Sebastian Redl3397c552010-08-18 23:56:27 +00001010void ASTDeclWriter::VisitCXXConversionDecl(CXXConversionDecl *D) {
Chris Lattner6ad9ac02010-05-07 21:43:38 +00001011 VisitCXXMethodDecl(D);
Argyrios Kyrtzidis91468322010-07-02 15:58:43 +00001012 Record.push_back(D->IsExplicitSpecified);
Sebastian Redl8538e8d2010-08-18 23:57:32 +00001013 Code = serialization::DECL_CXX_CONVERSION;
Chris Lattner6ad9ac02010-05-07 21:43:38 +00001014}
1015
Douglas Gregor15de72c2011-12-02 23:23:56 +00001016void ASTDeclWriter::VisitImportDecl(ImportDecl *D) {
1017 VisitDecl(D);
Argyrios Kyrtzidisbebae7c2012-10-03 01:58:45 +00001018 Record.push_back(Writer.getSubmoduleID(D->getImportedModule()));
Douglas Gregor15de72c2011-12-02 23:23:56 +00001019 ArrayRef<SourceLocation> IdentifierLocs = D->getIdentifierLocs();
1020 Record.push_back(!IdentifierLocs.empty());
1021 if (IdentifierLocs.empty()) {
1022 Writer.AddSourceLocation(D->getLocEnd(), Record);
1023 Record.push_back(1);
1024 } else {
1025 for (unsigned I = 0, N = IdentifierLocs.size(); I != N; ++I)
1026 Writer.AddSourceLocation(IdentifierLocs[I], Record);
1027 Record.push_back(IdentifierLocs.size());
1028 }
1029 // Note: the number of source locations must always be the last element in
1030 // the record.
1031 Code = serialization::DECL_IMPORT;
1032}
1033
Sebastian Redl3397c552010-08-18 23:56:27 +00001034void ASTDeclWriter::VisitAccessSpecDecl(AccessSpecDecl *D) {
Abramo Bagnara6206d532010-06-05 05:09:32 +00001035 VisitDecl(D);
1036 Writer.AddSourceLocation(D->getColonLoc(), Record);
Sebastian Redl8538e8d2010-08-18 23:57:32 +00001037 Code = serialization::DECL_ACCESS_SPEC;
Abramo Bagnara6206d532010-06-05 05:09:32 +00001038}
1039
Sebastian Redl3397c552010-08-18 23:56:27 +00001040void ASTDeclWriter::VisitFriendDecl(FriendDecl *D) {
Enea Zaffanella8c840282013-01-31 09:54:08 +00001041 // Record the number of friend type template parameter lists here
1042 // so as to simplify memory allocation during deserialization.
1043 Record.push_back(D->NumTPLists);
Argyrios Kyrtzidisc8f9af22010-07-05 10:38:01 +00001044 VisitDecl(D);
Enea Zaffanella8c840282013-01-31 09:54:08 +00001045 bool hasFriendDecl = D->Friend.is<NamedDecl*>();
1046 Record.push_back(hasFriendDecl);
1047 if (hasFriendDecl)
1048 Writer.AddDeclRef(D->getFriendDecl(), Record);
Argyrios Kyrtzidis67643342010-06-29 22:47:00 +00001049 else
Enea Zaffanella8c840282013-01-31 09:54:08 +00001050 Writer.AddTypeSourceInfo(D->getFriendType(), Record);
1051 for (unsigned i = 0; i < D->NumTPLists; ++i)
1052 Writer.AddTemplateParameterList(D->getFriendTypeTemplateParameterList(i),
1053 Record);
Douglas Gregor69aecc62010-10-27 20:23:41 +00001054 Writer.AddDeclRef(D->getNextFriend(), Record);
John McCall6102ca12010-10-16 06:59:13 +00001055 Record.push_back(D->UnsupportedFriend);
Argyrios Kyrtzidis67643342010-06-29 22:47:00 +00001056 Writer.AddSourceLocation(D->FriendLoc, Record);
Sebastian Redl8538e8d2010-08-18 23:57:32 +00001057 Code = serialization::DECL_FRIEND;
Argyrios Kyrtzidis67643342010-06-29 22:47:00 +00001058}
1059
Sebastian Redl3397c552010-08-18 23:56:27 +00001060void ASTDeclWriter::VisitFriendTemplateDecl(FriendTemplateDecl *D) {
Argyrios Kyrtzidis554e6aa2010-07-22 16:04:10 +00001061 VisitDecl(D);
1062 Record.push_back(D->getNumTemplateParameters());
1063 for (unsigned i = 0, e = D->getNumTemplateParameters(); i != e; ++i)
1064 Writer.AddTemplateParameterList(D->getTemplateParameterList(i), Record);
1065 Record.push_back(D->getFriendDecl() != 0);
1066 if (D->getFriendDecl())
1067 Writer.AddDeclRef(D->getFriendDecl(), Record);
1068 else
1069 Writer.AddTypeSourceInfo(D->getFriendType(), Record);
1070 Writer.AddSourceLocation(D->getFriendLoc(), Record);
Sebastian Redl8538e8d2010-08-18 23:57:32 +00001071 Code = serialization::DECL_FRIEND_TEMPLATE;
Chris Lattner6ad9ac02010-05-07 21:43:38 +00001072}
1073
Sebastian Redl3397c552010-08-18 23:56:27 +00001074void ASTDeclWriter::VisitTemplateDecl(TemplateDecl *D) {
Argyrios Kyrtzidis90b715e2010-06-19 19:28:53 +00001075 VisitNamedDecl(D);
1076
1077 Writer.AddDeclRef(D->getTemplatedDecl(), Record);
Argyrios Kyrtzidisdd41c142010-06-23 13:48:30 +00001078 Writer.AddTemplateParameterList(D->getTemplateParameters(), Record);
Chris Lattner6ad9ac02010-05-07 21:43:38 +00001079}
1080
Sebastian Redl3397c552010-08-18 23:56:27 +00001081void ASTDeclWriter::VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D) {
Douglas Gregor7c99bb5c2012-01-14 15:13:49 +00001082 VisitRedeclarable(D);
1083
Argyrios Kyrtzidis6b541512010-09-08 19:31:22 +00001084 // Emit data to initialize CommonOrPrev before VisitTemplateDecl so that
1085 // getCommonPtr() can be used while this is still initializing.
Douglas Gregor7c99bb5c2012-01-14 15:13:49 +00001086 if (D->isFirstDeclaration()) {
Douglas Gregorf63b0a52011-12-19 18:19:24 +00001087 // This declaration owns the 'common' pointer, so serialize that data now.
Peter Collingbourne9eabeba2010-07-29 16:11:51 +00001088 Writer.AddDeclRef(D->getInstantiatedFromMemberTemplate(), Record);
1089 if (D->getInstantiatedFromMemberTemplate())
1090 Record.push_back(D->isMemberSpecialization());
Douglas Gregorf63b0a52011-12-19 18:19:24 +00001091 }
1092
Argyrios Kyrtzidis6b541512010-09-08 19:31:22 +00001093 VisitTemplateDecl(D);
1094 Record.push_back(D->getIdentifierNamespace());
Peter Collingbourne9eabeba2010-07-29 16:11:51 +00001095}
1096
Sebastian Redl3397c552010-08-18 23:56:27 +00001097void ASTDeclWriter::VisitClassTemplateDecl(ClassTemplateDecl *D) {
Peter Collingbourne9eabeba2010-07-29 16:11:51 +00001098 VisitRedeclarableTemplateDecl(D);
1099
Douglas Gregor7c99bb5c2012-01-14 15:13:49 +00001100 if (D->isFirstDeclaration()) {
Chandler Carruthd964d632012-05-03 23:49:05 +00001101 typedef llvm::FoldingSetVector<ClassTemplateSpecializationDecl> CTSDSetTy;
Argyrios Kyrtzidis90b715e2010-06-19 19:28:53 +00001102 CTSDSetTy &CTSDSet = D->getSpecializations();
1103 Record.push_back(CTSDSet.size());
Argyrios Kyrtzidis7d530482010-07-02 11:55:37 +00001104 for (CTSDSetTy::iterator I=CTSDSet.begin(), E = CTSDSet.end(); I!=E; ++I) {
Argyrios Kyrtzidisbc5ab7c2010-07-20 13:59:40 +00001105 assert(I->isCanonicalDecl() && "Expected only canonical decls in set");
Argyrios Kyrtzidisecf966e2010-07-09 21:11:43 +00001106 Writer.AddDeclRef(&*I, Record);
Argyrios Kyrtzidis7d530482010-07-02 11:55:37 +00001107 }
Argyrios Kyrtzidis90b715e2010-06-19 19:28:53 +00001108
Chandler Carruthd964d632012-05-03 23:49:05 +00001109 typedef llvm::FoldingSetVector<ClassTemplatePartialSpecializationDecl>
1110 CTPSDSetTy;
Argyrios Kyrtzidis90b715e2010-06-19 19:28:53 +00001111 CTPSDSetTy &CTPSDSet = D->getPartialSpecializations();
1112 Record.push_back(CTPSDSet.size());
Argyrios Kyrtzidis7d530482010-07-02 11:55:37 +00001113 for (CTPSDSetTy::iterator I=CTPSDSet.begin(), E=CTPSDSet.end(); I!=E; ++I) {
Argyrios Kyrtzidisbc5ab7c2010-07-20 13:59:40 +00001114 assert(I->isCanonicalDecl() && "Expected only canonical decls in set");
Argyrios Kyrtzidisecf966e2010-07-09 21:11:43 +00001115 Writer.AddDeclRef(&*I, Record);
Argyrios Kyrtzidis7d530482010-07-02 11:55:37 +00001116 }
Argyrios Kyrtzidis90b715e2010-06-19 19:28:53 +00001117
Argyrios Kyrtzidis4f112342012-11-06 00:35:02 +00001118 Writer.AddTypeRef(D->getCommonPtr()->InjectedClassNameType, Record);
Argyrios Kyrtzidis90b715e2010-06-19 19:28:53 +00001119 }
Sebastian Redl8538e8d2010-08-18 23:57:32 +00001120 Code = serialization::DECL_CLASS_TEMPLATE;
Chris Lattner6ad9ac02010-05-07 21:43:38 +00001121}
1122
Sebastian Redl3397c552010-08-18 23:56:27 +00001123void ASTDeclWriter::VisitClassTemplateSpecializationDecl(
Chris Lattner6ad9ac02010-05-07 21:43:38 +00001124 ClassTemplateSpecializationDecl *D) {
Argyrios Kyrtzidisdd41c142010-06-23 13:48:30 +00001125 VisitCXXRecordDecl(D);
1126
1127 llvm::PointerUnion<ClassTemplateDecl *,
1128 ClassTemplatePartialSpecializationDecl *> InstFrom
1129 = D->getSpecializedTemplateOrPartial();
Argyrios Kyrtzidis28fc50c2011-08-17 21:35:28 +00001130 if (Decl *InstFromD = InstFrom.dyn_cast<ClassTemplateDecl *>()) {
Sebastian Redl4153a062010-08-24 22:50:24 +00001131 Writer.AddDeclRef(InstFromD, Record);
Argyrios Kyrtzidisdd41c142010-06-23 13:48:30 +00001132 } else {
Argyrios Kyrtzidis28fc50c2011-08-17 21:35:28 +00001133 Writer.AddDeclRef(InstFrom.get<ClassTemplatePartialSpecializationDecl *>(),
1134 Record);
Argyrios Kyrtzidisdd41c142010-06-23 13:48:30 +00001135 Writer.AddTemplateArgumentList(&D->getTemplateInstantiationArgs(), Record);
1136 }
1137
1138 // Explicit info.
1139 Writer.AddTypeSourceInfo(D->getTypeAsWritten(), Record);
1140 if (D->getTypeAsWritten()) {
1141 Writer.AddSourceLocation(D->getExternLoc(), Record);
1142 Writer.AddSourceLocation(D->getTemplateKeywordLoc(), Record);
1143 }
1144
1145 Writer.AddTemplateArgumentList(&D->getTemplateArgs(), Record);
1146 Writer.AddSourceLocation(D->getPointOfInstantiation(), Record);
1147 Record.push_back(D->getSpecializationKind());
Axel Naumann7b3b95a2012-10-01 07:34:47 +00001148 Record.push_back(D->isCanonicalDecl());
Argyrios Kyrtzidisdd41c142010-06-23 13:48:30 +00001149
Argyrios Kyrtzidisbc5ab7c2010-07-20 13:59:40 +00001150 if (D->isCanonicalDecl()) {
1151 // When reading, we'll add it to the folding set of the following template.
Argyrios Kyrtzidisecf966e2010-07-09 21:11:43 +00001152 Writer.AddDeclRef(D->getSpecializedTemplate()->getCanonicalDecl(), Record);
1153 }
1154
Sebastian Redl8538e8d2010-08-18 23:57:32 +00001155 Code = serialization::DECL_CLASS_TEMPLATE_SPECIALIZATION;
Chris Lattner6ad9ac02010-05-07 21:43:38 +00001156}
1157
Sebastian Redl3397c552010-08-18 23:56:27 +00001158void ASTDeclWriter::VisitClassTemplatePartialSpecializationDecl(
Chris Lattner6ad9ac02010-05-07 21:43:38 +00001159 ClassTemplatePartialSpecializationDecl *D) {
Argyrios Kyrtzidisdd41c142010-06-23 13:48:30 +00001160 VisitClassTemplateSpecializationDecl(D);
1161
1162 Writer.AddTemplateParameterList(D->getTemplateParameters(), Record);
1163
1164 Record.push_back(D->getNumTemplateArgsAsWritten());
1165 for (int i = 0, e = D->getNumTemplateArgsAsWritten(); i != e; ++i)
1166 Writer.AddTemplateArgumentLoc(D->getTemplateArgsAsWritten()[i], Record);
1167
1168 Record.push_back(D->getSequenceNumber());
1169
1170 // These are read/set from/to the first declaration.
Douglas Gregoref96ee02012-01-14 16:38:05 +00001171 if (D->getPreviousDecl() == 0) {
Argyrios Kyrtzidisdd41c142010-06-23 13:48:30 +00001172 Writer.AddDeclRef(D->getInstantiatedFromMember(), Record);
1173 Record.push_back(D->isMemberSpecialization());
1174 }
1175
Sebastian Redl8538e8d2010-08-18 23:57:32 +00001176 Code = serialization::DECL_CLASS_TEMPLATE_PARTIAL_SPECIALIZATION;
Chris Lattner6ad9ac02010-05-07 21:43:38 +00001177}
1178
Fariborz Jahanian95ed7782011-08-27 20:50:59 +00001179void ASTDeclWriter::VisitClassScopeFunctionSpecializationDecl(
1180 ClassScopeFunctionSpecializationDecl *D) {
Francois Pichetbc845322011-08-17 01:06:54 +00001181 VisitDecl(D);
1182 Writer.AddDeclRef(D->getSpecialization(), Record);
1183 Code = serialization::DECL_CLASS_SCOPE_FUNCTION_SPECIALIZATION;
1184}
1185
1186
Sebastian Redl3397c552010-08-18 23:56:27 +00001187void ASTDeclWriter::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
Peter Collingbourne9eabeba2010-07-29 16:11:51 +00001188 VisitRedeclarableTemplateDecl(D);
Argyrios Kyrtzidisf511ba62010-06-22 09:55:07 +00001189
Douglas Gregor7c99bb5c2012-01-14 15:13:49 +00001190 if (D->isFirstDeclaration()) {
Argyrios Kyrtzidisf511ba62010-06-22 09:55:07 +00001191 // This FunctionTemplateDecl owns the CommonPtr; write it.
1192
Argyrios Kyrtzidis057d9af2010-07-06 15:37:09 +00001193 // Write the function specialization declarations.
1194 Record.push_back(D->getSpecializations().size());
Chandler Carruthd964d632012-05-03 23:49:05 +00001195 for (llvm::FoldingSetVector<FunctionTemplateSpecializationInfo>::iterator
Argyrios Kyrtzidis057d9af2010-07-06 15:37:09 +00001196 I = D->getSpecializations().begin(),
Argyrios Kyrtzidis2c853e42010-07-20 13:59:58 +00001197 E = D->getSpecializations().end() ; I != E; ++I) {
1198 assert(I->Function->isCanonicalDecl() &&
1199 "Expected only canonical decls in set");
Argyrios Kyrtzidis057d9af2010-07-06 15:37:09 +00001200 Writer.AddDeclRef(I->Function, Record);
Argyrios Kyrtzidis2c853e42010-07-20 13:59:58 +00001201 }
Argyrios Kyrtzidisf511ba62010-06-22 09:55:07 +00001202 }
Sebastian Redl8538e8d2010-08-18 23:57:32 +00001203 Code = serialization::DECL_FUNCTION_TEMPLATE;
Chris Lattner6ad9ac02010-05-07 21:43:38 +00001204}
1205
Sebastian Redl3397c552010-08-18 23:56:27 +00001206void ASTDeclWriter::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
Argyrios Kyrtzidis90b715e2010-06-19 19:28:53 +00001207 VisitTypeDecl(D);
1208
1209 Record.push_back(D->wasDeclaredWithTypename());
Argyrios Kyrtzidis90b715e2010-06-19 19:28:53 +00001210 Record.push_back(D->defaultArgumentWasInherited());
1211 Writer.AddTypeSourceInfo(D->getDefaultArgumentInfo(), Record);
1212
Sebastian Redl8538e8d2010-08-18 23:57:32 +00001213 Code = serialization::DECL_TEMPLATE_TYPE_PARM;
Chris Lattner6ad9ac02010-05-07 21:43:38 +00001214}
1215
Sebastian Redl3397c552010-08-18 23:56:27 +00001216void ASTDeclWriter::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) {
Douglas Gregor6952f1e2011-01-19 20:10:05 +00001217 // For an expanded parameter pack, record the number of expansion types here
Richard Smith6964b3f2012-09-07 02:06:42 +00001218 // so that it's easier for deserialization to allocate the right amount of
1219 // memory.
Douglas Gregor6952f1e2011-01-19 20:10:05 +00001220 if (D->isExpandedParameterPack())
1221 Record.push_back(D->getNumExpansionTypes());
1222
John McCall76a40212011-02-09 01:13:10 +00001223 VisitDeclaratorDecl(D);
Argyrios Kyrtzidisb24e1992010-06-25 16:25:09 +00001224 // TemplateParmPosition.
1225 Record.push_back(D->getDepth());
1226 Record.push_back(D->getPosition());
Douglas Gregor6952f1e2011-01-19 20:10:05 +00001227
1228 if (D->isExpandedParameterPack()) {
1229 for (unsigned I = 0, N = D->getNumExpansionTypes(); I != N; ++I) {
1230 Writer.AddTypeRef(D->getExpansionType(I), Record);
1231 Writer.AddTypeSourceInfo(D->getExpansionTypeSourceInfo(I), Record);
1232 }
1233
1234 Code = serialization::DECL_EXPANDED_NON_TYPE_TEMPLATE_PARM_PACK;
1235 } else {
1236 // Rest of NonTypeTemplateParmDecl.
1237 Record.push_back(D->isParameterPack());
1238 Record.push_back(D->getDefaultArgument() != 0);
1239 if (D->getDefaultArgument()) {
1240 Writer.AddStmt(D->getDefaultArgument());
1241 Record.push_back(D->defaultArgumentWasInherited());
1242 }
1243 Code = serialization::DECL_NON_TYPE_TEMPLATE_PARM;
Argyrios Kyrtzidisb24e1992010-06-25 16:25:09 +00001244 }
Chris Lattner6ad9ac02010-05-07 21:43:38 +00001245}
1246
Sebastian Redl3397c552010-08-18 23:56:27 +00001247void ASTDeclWriter::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) {
Richard Smith6964b3f2012-09-07 02:06:42 +00001248 // For an expanded parameter pack, record the number of expansion types here
1249 // so that it's easier for deserialization to allocate the right amount of
1250 // memory.
1251 if (D->isExpandedParameterPack())
1252 Record.push_back(D->getNumExpansionTemplateParameters());
1253
Argyrios Kyrtzidisbfcc92c2010-07-08 17:12:57 +00001254 VisitTemplateDecl(D);
1255 // TemplateParmPosition.
1256 Record.push_back(D->getDepth());
1257 Record.push_back(D->getPosition());
Richard Smith6964b3f2012-09-07 02:06:42 +00001258
1259 if (D->isExpandedParameterPack()) {
1260 for (unsigned I = 0, N = D->getNumExpansionTemplateParameters();
1261 I != N; ++I)
1262 Writer.AddTemplateParameterList(D->getExpansionTemplateParameters(I),
1263 Record);
1264 Code = serialization::DECL_EXPANDED_TEMPLATE_TEMPLATE_PARM_PACK;
1265 } else {
1266 // Rest of TemplateTemplateParmDecl.
1267 Writer.AddTemplateArgumentLoc(D->getDefaultArgument(), Record);
1268 Record.push_back(D->defaultArgumentWasInherited());
1269 Record.push_back(D->isParameterPack());
1270 Code = serialization::DECL_TEMPLATE_TEMPLATE_PARM;
1271 }
Chris Lattner6ad9ac02010-05-07 21:43:38 +00001272}
1273
Richard Smith3e4c6c42011-05-05 21:57:07 +00001274void ASTDeclWriter::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) {
1275 VisitRedeclarableTemplateDecl(D);
1276 Code = serialization::DECL_TYPE_ALIAS_TEMPLATE;
1277}
1278
Sebastian Redl3397c552010-08-18 23:56:27 +00001279void ASTDeclWriter::VisitStaticAssertDecl(StaticAssertDecl *D) {
Argyrios Kyrtzidis0d396892010-07-22 17:28:12 +00001280 VisitDecl(D);
1281 Writer.AddStmt(D->getAssertExpr());
Richard Smithe3f470a2012-07-11 22:37:56 +00001282 Record.push_back(D->isFailed());
Argyrios Kyrtzidis0d396892010-07-22 17:28:12 +00001283 Writer.AddStmt(D->getMessage());
Abramo Bagnaraa2026c92011-03-08 16:41:52 +00001284 Writer.AddSourceLocation(D->getRParenLoc(), Record);
Sebastian Redl8538e8d2010-08-18 23:57:32 +00001285 Code = serialization::DECL_STATIC_ASSERT;
Chris Lattner6ad9ac02010-05-07 21:43:38 +00001286}
1287
Chris Lattner12b1c762009-04-27 06:16:06 +00001288/// \brief Emit the DeclContext part of a declaration context decl.
1289///
1290/// \param LexicalOffset the offset at which the DECL_CONTEXT_LEXICAL
1291/// block for this declaration context is stored. May be 0 to indicate
1292/// that there are no declarations stored within this context.
1293///
1294/// \param VisibleOffset the offset at which the DECL_CONTEXT_VISIBLE
1295/// block for this declaration context is stored. May be 0 to indicate
1296/// that there are no declarations visible from this context. Note
1297/// that this value will not be emitted for non-primary declaration
1298/// contexts.
Sebastian Redl3397c552010-08-18 23:56:27 +00001299void ASTDeclWriter::VisitDeclContext(DeclContext *DC, uint64_t LexicalOffset,
Chris Lattner12b1c762009-04-27 06:16:06 +00001300 uint64_t VisibleOffset) {
1301 Record.push_back(LexicalOffset);
1302 Record.push_back(VisibleOffset);
1303}
1304
Argyrios Kyrtzidisa8650052010-08-03 17:30:10 +00001305template <typename T>
Sebastian Redl3397c552010-08-18 23:56:27 +00001306void ASTDeclWriter::VisitRedeclarable(Redeclarable<T> *D) {
Douglas Gregor9fcbf2d2012-01-14 15:31:52 +00001307 T *First = D->getFirstDeclaration();
Douglas Gregor2171bf12012-01-15 16:58:34 +00001308 if (First->getMostRecentDecl() != First) {
Douglas Gregor9cfdc032013-01-21 16:16:40 +00001309 assert(isRedeclarableDeclKind(static_cast<T *>(D)->getKind()) &&
1310 "Not considered redeclarable?");
1311
1312 // There is more than one declaration of this entity, so we will need to
Douglas Gregor2171bf12012-01-15 16:58:34 +00001313 // write a redeclaration chain.
Douglas Gregorf63b0a52011-12-19 18:19:24 +00001314 Writer.AddDeclRef(First, Record);
Douglas Gregor2171bf12012-01-15 16:58:34 +00001315 Writer.Redeclarations.insert(First);
1316
1317 // Make sure that we serialize both the previous and the most-recent
1318 // declarations, which (transitively) ensures that all declarations in the
1319 // chain get serialized.
1320 (void)Writer.GetDeclRef(D->getPreviousDecl());
1321 (void)Writer.GetDeclRef(First->getMostRecentDecl());
1322 } else {
1323 // We use the sentinel value 0 to indicate an only declaration.
1324 Record.push_back(0);
Douglas Gregorecb19382011-12-19 15:27:36 +00001325 }
1326
Argyrios Kyrtzidisa8650052010-08-03 17:30:10 +00001327}
Chris Lattner12b1c762009-04-27 06:16:06 +00001328
Alexey Bataevc6400582013-03-22 06:34:35 +00001329void ASTDeclWriter::VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D) {
1330 Record.push_back(D->varlist_size());
1331 VisitDecl(D);
1332 for (OMPThreadPrivateDecl::varlist_iterator I = D->varlist_begin(),
1333 E = D->varlist_end();
1334 I != E; ++I)
1335 Writer.AddStmt(*I);
1336 Code = serialization::DECL_OMP_THREADPRIVATE;
1337}
1338
Chris Lattner12b1c762009-04-27 06:16:06 +00001339//===----------------------------------------------------------------------===//
Sebastian Redla4232eb2010-08-18 23:56:21 +00001340// ASTWriter Implementation
Chris Lattner12b1c762009-04-27 06:16:06 +00001341//===----------------------------------------------------------------------===//
1342
Sebastian Redla4232eb2010-08-18 23:56:21 +00001343void ASTWriter::WriteDeclsBlockAbbrevs() {
Chris Lattnerea5ce472009-04-27 07:35:58 +00001344 using namespace llvm;
Chris Lattnerea5ce472009-04-27 07:35:58 +00001345
Douglas Gregora72d8c42011-06-03 02:27:19 +00001346 BitCodeAbbrev *Abv;
1347
Jonathan D. Turner953c5642011-06-03 23:11:16 +00001348 // Abbreviation for DECL_FIELD
1349 Abv = new BitCodeAbbrev();
1350 Abv->Add(BitCodeAbbrevOp(serialization::DECL_FIELD));
1351 // Decl
1352 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
1353 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalDeclContext
Argyrios Kyrtzidisba50b3e2012-03-09 21:09:04 +00001354 Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl
Jonathan D. Turner953c5642011-06-03 23:11:16 +00001355 Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs
1356 Abv->Add(BitCodeAbbrevOp(0)); // isImplicit
1357 Abv->Add(BitCodeAbbrevOp(0)); // isUsed
1358 Abv->Add(BitCodeAbbrevOp(0)); // isReferenced
Argyrios Kyrtzidisc14a03d2011-11-23 20:27:36 +00001359 Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer
Jonathan D. Turner953c5642011-06-03 23:11:16 +00001360 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // AccessSpecifier
Douglas Gregor8d267c52011-09-09 02:06:17 +00001361 Abv->Add(BitCodeAbbrevOp(0)); // ModulePrivate
Douglas Gregor185dbd72011-12-01 02:07:58 +00001362 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
Jonathan D. Turner953c5642011-06-03 23:11:16 +00001363 // NamedDecl
1364 Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier
1365 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
1366 // ValueDecl
1367 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
1368 // DeclaratorDecl
1369 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerStartLoc
1370 Abv->Add(BitCodeAbbrevOp(0)); // hasExtInfo
1371 // FieldDecl
1372 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isMutable
1373 Abv->Add(BitCodeAbbrevOp(0)); //getBitWidth
1374 // Type Source Info
1375 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1376 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
1377 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc
1378 DeclFieldAbbrev = Stream.EmitAbbrev(Abv);
1379
1380 // Abbreviation for DECL_OBJC_IVAR
1381 Abv = new BitCodeAbbrev();
1382 Abv->Add(BitCodeAbbrevOp(serialization::DECL_OBJC_IVAR));
1383 // Decl
1384 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
1385 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalDeclContext
Argyrios Kyrtzidisba50b3e2012-03-09 21:09:04 +00001386 Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl
Jonathan D. Turner953c5642011-06-03 23:11:16 +00001387 Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs
1388 Abv->Add(BitCodeAbbrevOp(0)); // isImplicit
1389 Abv->Add(BitCodeAbbrevOp(0)); // isUsed
1390 Abv->Add(BitCodeAbbrevOp(0)); // isReferenced
Argyrios Kyrtzidisc14a03d2011-11-23 20:27:36 +00001391 Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer
Jonathan D. Turner953c5642011-06-03 23:11:16 +00001392 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // AccessSpecifier
Douglas Gregor8d267c52011-09-09 02:06:17 +00001393 Abv->Add(BitCodeAbbrevOp(0)); // ModulePrivate
Douglas Gregor185dbd72011-12-01 02:07:58 +00001394 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
Jonathan D. Turner953c5642011-06-03 23:11:16 +00001395 // NamedDecl
1396 Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier
1397 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
1398 // ValueDecl
1399 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
1400 // DeclaratorDecl
1401 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerStartLoc
1402 Abv->Add(BitCodeAbbrevOp(0)); // hasExtInfo
1403 // FieldDecl
1404 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isMutable
1405 Abv->Add(BitCodeAbbrevOp(0)); //getBitWidth
1406 // ObjC Ivar
1407 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getAccessControl
1408 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getSynthesize
1409 // Type Source Info
1410 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1411 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
1412 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc
1413 DeclObjCIvarAbbrev = Stream.EmitAbbrev(Abv);
1414
1415 // Abbreviation for DECL_ENUM
1416 Abv = new BitCodeAbbrev();
1417 Abv->Add(BitCodeAbbrevOp(serialization::DECL_ENUM));
Douglas Gregord488b3a2011-10-26 17:53:41 +00001418 // Redeclarable
Douglas Gregorecb19382011-12-19 15:27:36 +00001419 Abv->Add(BitCodeAbbrevOp(0)); // No redeclaration
Chris Lattnerea5ce472009-04-27 07:35:58 +00001420 // Decl
1421 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
1422 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalDeclContext
Argyrios Kyrtzidisba50b3e2012-03-09 21:09:04 +00001423 Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl
Chris Lattnerea5ce472009-04-27 07:35:58 +00001424 Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs
1425 Abv->Add(BitCodeAbbrevOp(0)); // isImplicit
Douglas Gregore0762c92009-06-19 23:52:42 +00001426 Abv->Add(BitCodeAbbrevOp(0)); // isUsed
Argyrios Kyrtzidis6b6b42a2011-04-19 19:51:10 +00001427 Abv->Add(BitCodeAbbrevOp(0)); // isReferenced
Argyrios Kyrtzidisc14a03d2011-11-23 20:27:36 +00001428 Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer
Chris Lattnerea5ce472009-04-27 07:35:58 +00001429 Abv->Add(BitCodeAbbrevOp(AS_none)); // C++ AccessSpecifier
Douglas Gregor8d267c52011-09-09 02:06:17 +00001430 Abv->Add(BitCodeAbbrevOp(0)); // ModulePrivate
Douglas Gregor185dbd72011-12-01 02:07:58 +00001431 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
Douglas Gregora72d8c42011-06-03 02:27:19 +00001432 // NamedDecl
1433 Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier
1434 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
Jonathan D. Turner953c5642011-06-03 23:11:16 +00001435 // TypeDecl
1436 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Source Location
1437 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type Ref
Jonathan D. Turner953c5642011-06-03 23:11:16 +00001438 // TagDecl
1439 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // IdentifierNamespace
1440 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getTagKind
John McCall5e1cdac2011-10-07 06:10:15 +00001441 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isCompleteDefinition
Jonathan D. Turner953c5642011-06-03 23:11:16 +00001442 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // EmbeddedInDeclarator
Argyrios Kyrtzidis717a20b2011-09-30 22:11:31 +00001443 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsFreeStanding
Jonathan D. Turner953c5642011-06-03 23:11:16 +00001444 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SourceLocation
1445 Abv->Add(BitCodeAbbrevOp(0)); // hasExtInfo
1446 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypedefNameAnonDecl
1447 // EnumDecl
1448 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // AddTypeRef
1449 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // IntegerType
1450 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getPromotionType
1451 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getNumPositiveBits
1452 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getNumNegativeBits
1453 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isScoped
1454 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isScopedUsingClassTag
1455 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isFixed
1456 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InstantiatedMembEnum
1457 // DC
1458 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalOffset
1459 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // VisibleOffset
1460 DeclEnumAbbrev = Stream.EmitAbbrev(Abv);
Mike Stump1eb44332009-09-09 15:08:12 +00001461
Douglas Gregora72d8c42011-06-03 02:27:19 +00001462 // Abbreviation for DECL_RECORD
1463 Abv = new BitCodeAbbrev();
1464 Abv->Add(BitCodeAbbrevOp(serialization::DECL_RECORD));
Douglas Gregord488b3a2011-10-26 17:53:41 +00001465 // Redeclarable
Douglas Gregorecb19382011-12-19 15:27:36 +00001466 Abv->Add(BitCodeAbbrevOp(0)); // No redeclaration
Douglas Gregora72d8c42011-06-03 02:27:19 +00001467 // Decl
1468 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
1469 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalDeclContext
Argyrios Kyrtzidisba50b3e2012-03-09 21:09:04 +00001470 Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl
Douglas Gregora72d8c42011-06-03 02:27:19 +00001471 Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs
1472 Abv->Add(BitCodeAbbrevOp(0)); // isImplicit
1473 Abv->Add(BitCodeAbbrevOp(0)); // isUsed
1474 Abv->Add(BitCodeAbbrevOp(0)); // isReferenced
Argyrios Kyrtzidisc14a03d2011-11-23 20:27:36 +00001475 Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer
Douglas Gregora72d8c42011-06-03 02:27:19 +00001476 Abv->Add(BitCodeAbbrevOp(AS_none)); // C++ AccessSpecifier
Douglas Gregor8d267c52011-09-09 02:06:17 +00001477 Abv->Add(BitCodeAbbrevOp(0)); // ModulePrivate
Douglas Gregor185dbd72011-12-01 02:07:58 +00001478 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
Douglas Gregora72d8c42011-06-03 02:27:19 +00001479 // NamedDecl
1480 Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier
1481 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
1482 // TypeDecl
1483 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Source Location
1484 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type Ref
Douglas Gregora72d8c42011-06-03 02:27:19 +00001485 // TagDecl
1486 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // IdentifierNamespace
1487 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getTagKind
John McCall5e1cdac2011-10-07 06:10:15 +00001488 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isCompleteDefinition
Douglas Gregora72d8c42011-06-03 02:27:19 +00001489 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // EmbeddedInDeclarator
Argyrios Kyrtzidis717a20b2011-09-30 22:11:31 +00001490 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsFreeStanding
Douglas Gregora72d8c42011-06-03 02:27:19 +00001491 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SourceLocation
1492 Abv->Add(BitCodeAbbrevOp(0)); // hasExtInfo
1493 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypedefNameAnonDecl
1494 // RecordDecl
1495 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // FlexibleArrayMember
1496 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // AnonymousStructUnion
1497 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // hasObjectMember
Fariborz Jahanian3ac83d62013-01-25 23:57:05 +00001498 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // hasVolatileMember
Douglas Gregora72d8c42011-06-03 02:27:19 +00001499 // DC
1500 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalOffset
1501 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // VisibleOffset
1502 DeclRecordAbbrev = Stream.EmitAbbrev(Abv);
1503
1504 // Abbreviation for DECL_PARM_VAR
1505 Abv = new BitCodeAbbrev();
1506 Abv->Add(BitCodeAbbrevOp(serialization::DECL_PARM_VAR));
Douglas Gregord488b3a2011-10-26 17:53:41 +00001507 // Redeclarable
Douglas Gregorecb19382011-12-19 15:27:36 +00001508 Abv->Add(BitCodeAbbrevOp(0)); // No redeclaration
Douglas Gregora72d8c42011-06-03 02:27:19 +00001509 // Decl
1510 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
1511 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalDeclContext
Argyrios Kyrtzidisba50b3e2012-03-09 21:09:04 +00001512 Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl
Douglas Gregora72d8c42011-06-03 02:27:19 +00001513 Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs
1514 Abv->Add(BitCodeAbbrevOp(0)); // isImplicit
1515 Abv->Add(BitCodeAbbrevOp(0)); // isUsed
1516 Abv->Add(BitCodeAbbrevOp(0)); // isReferenced
Argyrios Kyrtzidisc14a03d2011-11-23 20:27:36 +00001517 Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer
Douglas Gregora72d8c42011-06-03 02:27:19 +00001518 Abv->Add(BitCodeAbbrevOp(AS_none)); // C++ AccessSpecifier
Douglas Gregor8d267c52011-09-09 02:06:17 +00001519 Abv->Add(BitCodeAbbrevOp(0)); // ModulePrivate
Douglas Gregor185dbd72011-12-01 02:07:58 +00001520 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
Chris Lattnerea5ce472009-04-27 07:35:58 +00001521 // NamedDecl
1522 Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier
1523 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
1524 // ValueDecl
1525 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
Argyrios Kyrtzidisd4a7e542009-08-19 01:28:35 +00001526 // DeclaratorDecl
Abramo Bagnaraff676cb2011-03-08 08:55:46 +00001527 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerStartLoc
Argyrios Kyrtzidis40451072010-10-15 18:21:24 +00001528 Abv->Add(BitCodeAbbrevOp(0)); // hasExtInfo
Chris Lattnerea5ce472009-04-27 07:35:58 +00001529 // VarDecl
1530 Abv->Add(BitCodeAbbrevOp(0)); // StorageClass
Richard Smith38afbc72013-04-13 02:43:54 +00001531 Abv->Add(BitCodeAbbrevOp(0)); // getTLSKind
Chris Lattnerea5ce472009-04-27 07:35:58 +00001532 Abv->Add(BitCodeAbbrevOp(0)); // hasCXXDirectInitializer
Douglas Gregor324b54d2010-05-03 18:51:14 +00001533 Abv->Add(BitCodeAbbrevOp(0)); // isExceptionVariable
Douglas Gregor5077c382010-05-15 06:01:05 +00001534 Abv->Add(BitCodeAbbrevOp(0)); // isNRVOVariable
Richard Smithad762fc2011-04-14 22:09:26 +00001535 Abv->Add(BitCodeAbbrevOp(0)); // isCXXForRangeDecl
John McCall7acddac2011-06-17 06:42:21 +00001536 Abv->Add(BitCodeAbbrevOp(0)); // isARCPseudoStrong
Douglas Gregor67d45ec2012-09-20 23:43:29 +00001537 Abv->Add(BitCodeAbbrevOp(0)); // isConstexpr
Richard Smithad0e27b2013-02-12 05:48:23 +00001538 Abv->Add(BitCodeAbbrevOp(0)); // Linkage
Chris Lattnerea5ce472009-04-27 07:35:58 +00001539 Abv->Add(BitCodeAbbrevOp(0)); // HasInit
Argyrios Kyrtzidis9421adc2010-07-04 21:44:00 +00001540 Abv->Add(BitCodeAbbrevOp(0)); // HasMemberSpecializationInfo
Chris Lattnerea5ce472009-04-27 07:35:58 +00001541 // ParmVarDecl
John McCall70798862011-05-02 00:30:12 +00001542 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsObjCMethodParameter
John McCallfb44de92011-05-01 22:35:37 +00001543 Abv->Add(BitCodeAbbrevOp(0)); // ScopeDepth
1544 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // ScopeIndex
Chris Lattnerea5ce472009-04-27 07:35:58 +00001545 Abv->Add(BitCodeAbbrevOp(0)); // ObjCDeclQualifier
John McCalleecf5fa2011-03-09 04:22:44 +00001546 Abv->Add(BitCodeAbbrevOp(0)); // KNRPromoted
John McCallbf73b352010-03-12 18:31:32 +00001547 Abv->Add(BitCodeAbbrevOp(0)); // HasInheritedDefaultArg
Argyrios Kyrtzidis691d77f2010-07-04 21:44:07 +00001548 Abv->Add(BitCodeAbbrevOp(0)); // HasUninstantiatedDefaultArg
Jonathan D. Turner953c5642011-06-03 23:11:16 +00001549 // Type Source Info
1550 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1551 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
1552 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc
1553 DeclParmVarAbbrev = Stream.EmitAbbrev(Abv);
Sebastian Redl681d7232010-07-27 00:17:23 +00001554
Jonathan D. Turner8e1b80c2011-06-06 16:22:39 +00001555 // Abbreviation for DECL_TYPEDEF
Douglas Gregora72d8c42011-06-03 02:27:19 +00001556 Abv = new BitCodeAbbrev();
Jonathan D. Turner953c5642011-06-03 23:11:16 +00001557 Abv->Add(BitCodeAbbrevOp(serialization::DECL_TYPEDEF));
Douglas Gregora1be2782011-12-17 23:38:30 +00001558 // Redeclarable
Douglas Gregorecb19382011-12-19 15:27:36 +00001559 Abv->Add(BitCodeAbbrevOp(0)); // No redeclaration
Jonathan D. Turner953c5642011-06-03 23:11:16 +00001560 // Decl
1561 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
1562 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalDeclContext
Argyrios Kyrtzidisba50b3e2012-03-09 21:09:04 +00001563 Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl
Jonathan D. Turner953c5642011-06-03 23:11:16 +00001564 Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs
1565 Abv->Add(BitCodeAbbrevOp(0)); // isImplicit
1566 Abv->Add(BitCodeAbbrevOp(0)); // isUsed
1567 Abv->Add(BitCodeAbbrevOp(0)); // isReferenced
Argyrios Kyrtzidisc14a03d2011-11-23 20:27:36 +00001568 Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer
Jonathan D. Turner953c5642011-06-03 23:11:16 +00001569 Abv->Add(BitCodeAbbrevOp(AS_none)); // C++ AccessSpecifier
Douglas Gregor8d267c52011-09-09 02:06:17 +00001570 Abv->Add(BitCodeAbbrevOp(0)); // ModulePrivate
Douglas Gregor185dbd72011-12-01 02:07:58 +00001571 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
Jonathan D. Turner953c5642011-06-03 23:11:16 +00001572 // NamedDecl
1573 Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier
1574 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
1575 // TypeDecl
1576 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Source Location
1577 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type Ref
1578 // TypedefDecl
1579 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
1580 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc
1581 DeclTypedefAbbrev = Stream.EmitAbbrev(Abv);
1582
Jonathan D. Turner8e1b80c2011-06-06 16:22:39 +00001583 // Abbreviation for DECL_VAR
Jonathan D. Turner953c5642011-06-03 23:11:16 +00001584 Abv = new BitCodeAbbrev();
1585 Abv->Add(BitCodeAbbrevOp(serialization::DECL_VAR));
Douglas Gregord488b3a2011-10-26 17:53:41 +00001586 // Redeclarable
Douglas Gregorecb19382011-12-19 15:27:36 +00001587 Abv->Add(BitCodeAbbrevOp(0)); // No redeclaration
Jonathan D. Turner953c5642011-06-03 23:11:16 +00001588 // Decl
1589 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
1590 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalDeclContext
Argyrios Kyrtzidisba50b3e2012-03-09 21:09:04 +00001591 Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl
Jonathan D. Turner953c5642011-06-03 23:11:16 +00001592 Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs
1593 Abv->Add(BitCodeAbbrevOp(0)); // isImplicit
1594 Abv->Add(BitCodeAbbrevOp(0)); // isUsed
1595 Abv->Add(BitCodeAbbrevOp(0)); // isReferenced
Argyrios Kyrtzidisc14a03d2011-11-23 20:27:36 +00001596 Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer
Jonathan D. Turner953c5642011-06-03 23:11:16 +00001597 Abv->Add(BitCodeAbbrevOp(AS_none)); // C++ AccessSpecifier
Douglas Gregor8d267c52011-09-09 02:06:17 +00001598 Abv->Add(BitCodeAbbrevOp(0)); // ModulePrivate
Douglas Gregor185dbd72011-12-01 02:07:58 +00001599 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
Jonathan D. Turner953c5642011-06-03 23:11:16 +00001600 // NamedDecl
1601 Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier
1602 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
1603 // ValueDecl
1604 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
1605 // DeclaratorDecl
1606 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerStartLoc
1607 Abv->Add(BitCodeAbbrevOp(0)); // hasExtInfo
1608 // VarDecl
Jonathan D. Turner953c5642011-06-03 23:11:16 +00001609 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // StorageClass
Richard Smith38afbc72013-04-13 02:43:54 +00001610 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // getTLSKind
Jonathan D. Turner953c5642011-06-03 23:11:16 +00001611 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // CXXDirectInitializer
1612 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isExceptionVariable
1613 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isNRVOVariable
1614 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isCXXForRangeDecl
John McCall7acddac2011-06-17 06:42:21 +00001615 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isARCPseudoStrong
Douglas Gregor67d45ec2012-09-20 23:43:29 +00001616 Abv->Add(BitCodeAbbrevOp(0)); // isConstexpr
Richard Smithad0e27b2013-02-12 05:48:23 +00001617 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // Linkage
Jonathan D. Turner953c5642011-06-03 23:11:16 +00001618 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // HasInit
1619 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // HasMemberSpecInfo
1620 // Type Source Info
1621 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1622 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
1623 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc
1624 DeclVarAbbrev = Stream.EmitAbbrev(Abv);
1625
Jonathan D. Turner8e1b80c2011-06-06 16:22:39 +00001626 // Abbreviation for EXPR_DECL_REF
Jonathan D. Turner953c5642011-06-03 23:11:16 +00001627 Abv = new BitCodeAbbrev();
Douglas Gregora72d8c42011-06-03 02:27:19 +00001628 Abv->Add(BitCodeAbbrevOp(serialization::EXPR_DECL_REF));
1629 //Stmt
1630 //Expr
1631 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
Douglas Gregor561f8122011-07-01 01:22:09 +00001632 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //TypeDependent
1633 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //ValueDependent
1634 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //InstantiationDependent
Douglas Gregora72d8c42011-06-03 02:27:19 +00001635 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //UnexpandedParamPack
1636 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetValueKind
1637 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetObjectKind
1638 //DeclRefExpr
1639 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //HasQualifier
1640 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //GetDeclFound
1641 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //ExplicitTemplateArgs
Abramo Bagnara7cc58b42011-10-05 07:56:41 +00001642 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //HadMultipleCandidates
John McCallf4b88a42012-03-10 09:33:50 +00001643 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //RefersToEnclosingLocal
Douglas Gregora72d8c42011-06-03 02:27:19 +00001644 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclRef
1645 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Location
1646 DeclRefExprAbbrev = Stream.EmitAbbrev(Abv);
1647
1648 // Abbreviation for EXPR_INTEGER_LITERAL
1649 Abv = new BitCodeAbbrev();
1650 Abv->Add(BitCodeAbbrevOp(serialization::EXPR_INTEGER_LITERAL));
1651 //Stmt
1652 //Expr
1653 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
Douglas Gregor561f8122011-07-01 01:22:09 +00001654 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //TypeDependent
1655 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //ValueDependent
1656 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //InstantiationDependent
Douglas Gregora72d8c42011-06-03 02:27:19 +00001657 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //UnexpandedParamPack
1658 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetValueKind
1659 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetObjectKind
1660 //Integer Literal
1661 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Location
1662 Abv->Add(BitCodeAbbrevOp(32)); // Bit Width
1663 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Value
1664 IntegerLiteralAbbrev = Stream.EmitAbbrev(Abv);
1665
1666 // Abbreviation for EXPR_CHARACTER_LITERAL
1667 Abv = new BitCodeAbbrev();
1668 Abv->Add(BitCodeAbbrevOp(serialization::EXPR_CHARACTER_LITERAL));
1669 //Stmt
1670 //Expr
1671 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
Douglas Gregor561f8122011-07-01 01:22:09 +00001672 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //TypeDependent
1673 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //ValueDependent
1674 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //InstantiationDependent
Douglas Gregora72d8c42011-06-03 02:27:19 +00001675 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //UnexpandedParamPack
1676 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetValueKind
1677 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetObjectKind
Jonathan D. Turner28087572011-06-03 21:46:44 +00001678 //Character Literal
Douglas Gregora72d8c42011-06-03 02:27:19 +00001679 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getValue
1680 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Location
Eli Friedmanb3b6c222012-09-14 00:51:36 +00001681 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // getKind
Douglas Gregora72d8c42011-06-03 02:27:19 +00001682 CharacterLiteralAbbrev = Stream.EmitAbbrev(Abv);
1683
Sebastian Redl681d7232010-07-27 00:17:23 +00001684 Abv = new BitCodeAbbrev();
Sebastian Redl8538e8d2010-08-18 23:57:32 +00001685 Abv->Add(BitCodeAbbrevOp(serialization::DECL_CONTEXT_LEXICAL));
Sebastian Redl681d7232010-07-27 00:17:23 +00001686 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1687 DeclContextLexicalAbbrev = Stream.EmitAbbrev(Abv);
Argyrios Kyrtzidis074dcc82010-08-20 16:04:35 +00001688
1689 Abv = new BitCodeAbbrev();
1690 Abv->Add(BitCodeAbbrevOp(serialization::DECL_CONTEXT_VISIBLE));
1691 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
1692 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1693 DeclContextVisibleLookupAbbrev = Stream.EmitAbbrev(Abv);
Chris Lattnerea5ce472009-04-27 07:35:58 +00001694}
1695
Daniel Dunbare24d38f2009-09-17 03:06:51 +00001696/// isRequiredDecl - Check if this is a "required" Decl, which must be seen by
1697/// consumers of the AST.
1698///
Sebastian Redl3397c552010-08-18 23:56:27 +00001699/// Such decls will always be deserialized from the AST file, so we would like
Daniel Dunbare24d38f2009-09-17 03:06:51 +00001700/// this to be as restrictive as possible. Currently the predicate is driven by
1701/// code generation requirements, if other clients have a different notion of
1702/// what is "required" then we may have to consider an alternate scheme where
1703/// clients can iterate over the top-level decls and get information on them,
1704/// without necessary deserializing them. We could explicitly require such
1705/// clients to use a separate API call to "realize" the decl. This should be
1706/// relatively painless since they would presumably only do it for top-level
1707/// decls.
Daniel Dunbare24d38f2009-09-17 03:06:51 +00001708static bool isRequiredDecl(const Decl *D, ASTContext &Context) {
Argyrios Kyrtzidis144b38a2011-09-13 21:35:00 +00001709 // An ObjCMethodDecl is never considered as "required" because its
1710 // implementation container always is.
1711
Argyrios Kyrtzidis9d50c062010-08-09 10:54:20 +00001712 // File scoped assembly or obj-c implementation must be seen.
Douglas Gregor94da1582011-09-10 00:22:34 +00001713 if (isa<FileScopeAsmDecl>(D) || isa<ObjCImplDecl>(D))
Daniel Dunbare24d38f2009-09-17 03:06:51 +00001714 return true;
1715
Argyrios Kyrtzidis4ac7c0b2010-07-29 20:08:05 +00001716 return Context.DeclMustBeEmitted(D);
Daniel Dunbare24d38f2009-09-17 03:06:51 +00001717}
1718
Sebastian Redla4232eb2010-08-18 23:56:21 +00001719void ASTWriter::WriteDecl(ASTContext &Context, Decl *D) {
Argyrios Kyrtzidise09a2752010-10-28 09:29:32 +00001720 // Switch case IDs are per Decl.
1721 ClearSwitchCaseIDs();
1722
Chris Lattner12b1c762009-04-27 06:16:06 +00001723 RecordData Record;
Sebastian Redl3397c552010-08-18 23:56:27 +00001724 ASTDeclWriter W(*this, Context, Record);
Chris Lattner12b1c762009-04-27 06:16:06 +00001725
Douglas Gregor1c7946a2012-01-05 22:33:30 +00001726 // Determine the ID for this declaration.
1727 serialization::DeclID ID;
1728 if (D->isFromASTFile())
1729 ID = getDeclID(D);
1730 else {
1731 serialization::DeclID &IDR = DeclIDs[D];
1732 if (IDR == 0)
1733 IDR = NextDeclID++;
1734
1735 ID= IDR;
1736 }
Argyrios Kyrtzidis643586f2012-03-22 16:08:04 +00001737
1738 bool isReplacingADecl = ID < FirstDeclID;
1739
1740 // If this declaration is also a DeclContext, write blocks for the
1741 // declarations that lexically stored inside its context and those
1742 // declarations that are visible from its context. These blocks
1743 // are written before the declaration itself so that we can put
1744 // their offsets into the record for the declaration.
1745 uint64_t LexicalOffset = 0;
1746 uint64_t VisibleOffset = 0;
1747 DeclContext *DC = dyn_cast<DeclContext>(D);
1748 if (DC) {
1749 if (isReplacingADecl) {
1750 // It is replacing a decl from a chained PCH; make sure that the
1751 // DeclContext is fully loaded.
1752 if (DC->hasExternalLexicalStorage())
1753 DC->LoadLexicalDeclsFromExternalStorage();
1754 if (DC->hasExternalVisibleStorage())
1755 Chain->completeVisibleDeclsMap(DC);
1756 }
1757 LexicalOffset = WriteDeclContextLexicalBlock(Context, DC);
1758 VisibleOffset = WriteDeclContextVisibleBlock(Context, DC);
1759 }
Douglas Gregor1c7946a2012-01-05 22:33:30 +00001760
Argyrios Kyrtzidis643586f2012-03-22 16:08:04 +00001761 if (isReplacingADecl) {
Sebastian Redl0b17c612010-08-13 00:28:03 +00001762 // We're replacing a decl in a previous file.
Argyrios Kyrtzidisef23b602011-10-31 07:20:15 +00001763 ReplacedDecls.push_back(ReplacedDeclInfo(ID, Stream.GetCurrentBitNo(),
1764 D->getLocation()));
Sebastian Redl0b17c612010-08-13 00:28:03 +00001765 } else {
1766 unsigned Index = ID - FirstDeclID;
Douglas Gregor61d60ee2009-10-17 00:13:19 +00001767
Sebastian Redl0b17c612010-08-13 00:28:03 +00001768 // Record the offset for this declaration
Argyrios Kyrtzidis10f3df52011-10-28 22:54:21 +00001769 SourceLocation Loc = D->getLocation();
Sebastian Redl0b17c612010-08-13 00:28:03 +00001770 if (DeclOffsets.size() == Index)
Argyrios Kyrtzidis10f3df52011-10-28 22:54:21 +00001771 DeclOffsets.push_back(DeclOffset(Loc, Stream.GetCurrentBitNo()));
Sebastian Redl0b17c612010-08-13 00:28:03 +00001772 else if (DeclOffsets.size() < Index) {
1773 DeclOffsets.resize(Index+1);
Argyrios Kyrtzidis10f3df52011-10-28 22:54:21 +00001774 DeclOffsets[Index].setLocation(Loc);
Argyrios Kyrtzidis9d31fa72011-10-27 18:47:35 +00001775 DeclOffsets[Index].BitOffset = Stream.GetCurrentBitNo();
Sebastian Redl0b17c612010-08-13 00:28:03 +00001776 }
Argyrios Kyrtzidis10f3df52011-10-28 22:54:21 +00001777
1778 SourceManager &SM = Context.getSourceManager();
Argyrios Kyrtzidis19645d22011-10-28 23:57:43 +00001779 if (Loc.isValid() && SM.isLocalSourceLocation(Loc))
1780 associateDeclWithFile(D, ID);
Douglas Gregor61d60ee2009-10-17 00:13:19 +00001781 }
1782
1783 // Build and emit a record for this declaration
1784 Record.clear();
Sebastian Redl8538e8d2010-08-18 23:57:32 +00001785 W.Code = (serialization::DeclCode)0;
Douglas Gregor61d60ee2009-10-17 00:13:19 +00001786 W.AbbrevToUse = 0;
1787 W.Visit(D);
1788 if (DC) W.VisitDeclContext(DC, LexicalOffset, VisibleOffset);
1789
Daniel Dunbar33671982009-12-03 09:13:36 +00001790 if (!W.Code)
Chris Lattner5f9e2722011-07-23 10:55:15 +00001791 llvm::report_fatal_error(StringRef("unexpected declaration kind '") +
Daniel Dunbar33671982009-12-03 09:13:36 +00001792 D->getDeclKindName() + "'");
Douglas Gregor61d60ee2009-10-17 00:13:19 +00001793 Stream.EmitRecord(W.Code, Record, W.AbbrevToUse);
1794
Douglas Gregor61d60ee2009-10-17 00:13:19 +00001795 // Flush any expressions that were written as part of this declaration.
1796 FlushStmts();
Douglas Gregor7c789c12010-10-29 22:39:52 +00001797
1798 // Flush C++ base specifiers, if there are any.
1799 FlushCXXBaseSpecifiers();
1800
Douglas Gregor61d60ee2009-10-17 00:13:19 +00001801 // Note "external" declarations so that we can add them to a record in the
Sebastian Redl3397c552010-08-18 23:56:27 +00001802 // AST file later.
Douglas Gregor61d60ee2009-10-17 00:13:19 +00001803 //
1804 // FIXME: This should be renamed, the predicate is much more complicated.
1805 if (isRequiredDecl(D, Context))
Sebastian Redl0b17c612010-08-13 00:28:03 +00001806 ExternalDefinitions.push_back(ID);
Chris Lattner12b1c762009-04-27 06:16:06 +00001807}