blob: 6b4ba67904f14cbd51ed779a3cc34a19c9dc9793 [file] [log] [blame]
Chris Lattner12b1c762009-04-27 06:16:06 +00001//===--- PCHWriterDecl.cpp - Declaration Serialization --------------------===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file implements serialization for Declarations.
11//
12//===----------------------------------------------------------------------===//
13
14#include "clang/Frontend/PCHWriter.h"
15#include "clang/AST/DeclVisitor.h"
16#include "clang/AST/Expr.h"
Daniel Dunbar33671982009-12-03 09:13:36 +000017#include "llvm/ADT/Twine.h"
Chris Lattner12b1c762009-04-27 06:16:06 +000018#include "llvm/Bitcode/BitstreamWriter.h"
Daniel Dunbar33671982009-12-03 09:13:36 +000019#include "llvm/Support/ErrorHandling.h"
Chris Lattner12b1c762009-04-27 06:16:06 +000020using namespace clang;
21
22//===----------------------------------------------------------------------===//
23// Declaration serialization
24//===----------------------------------------------------------------------===//
25
26namespace {
27 class PCHDeclWriter : public DeclVisitor<PCHDeclWriter, void> {
28
29 PCHWriter &Writer;
30 ASTContext &Context;
31 PCHWriter::RecordData &Record;
32
33 public:
34 pch::DeclCode Code;
Chris Lattnerea5ce472009-04-27 07:35:58 +000035 unsigned AbbrevToUse;
Chris Lattner12b1c762009-04-27 06:16:06 +000036
Mike Stump1eb44332009-09-09 15:08:12 +000037 PCHDeclWriter(PCHWriter &Writer, ASTContext &Context,
38 PCHWriter::RecordData &Record)
Chris Lattnerea5ce472009-04-27 07:35:58 +000039 : Writer(Writer), Context(Context), Record(Record) {
40 }
Chris Lattner12b1c762009-04-27 06:16:06 +000041
42 void VisitDecl(Decl *D);
43 void VisitTranslationUnitDecl(TranslationUnitDecl *D);
44 void VisitNamedDecl(NamedDecl *D);
Douglas Gregor0cef4832010-02-21 18:22:14 +000045 void VisitNamespaceDecl(NamespaceDecl *D);
Chris Lattner12b1c762009-04-27 06:16:06 +000046 void VisitTypeDecl(TypeDecl *D);
47 void VisitTypedefDecl(TypedefDecl *D);
48 void VisitTagDecl(TagDecl *D);
49 void VisitEnumDecl(EnumDecl *D);
50 void VisitRecordDecl(RecordDecl *D);
51 void VisitValueDecl(ValueDecl *D);
52 void VisitEnumConstantDecl(EnumConstantDecl *D);
Argyrios Kyrtzidisd4a7e542009-08-19 01:28:35 +000053 void VisitDeclaratorDecl(DeclaratorDecl *D);
Chris Lattner12b1c762009-04-27 06:16:06 +000054 void VisitFunctionDecl(FunctionDecl *D);
55 void VisitFieldDecl(FieldDecl *D);
56 void VisitVarDecl(VarDecl *D);
57 void VisitImplicitParamDecl(ImplicitParamDecl *D);
58 void VisitParmVarDecl(ParmVarDecl *D);
Chris Lattner12b1c762009-04-27 06:16:06 +000059 void VisitFileScopeAsmDecl(FileScopeAsmDecl *D);
60 void VisitBlockDecl(BlockDecl *D);
Mike Stump1eb44332009-09-09 15:08:12 +000061 void VisitDeclContext(DeclContext *DC, uint64_t LexicalOffset,
Chris Lattner12b1c762009-04-27 06:16:06 +000062 uint64_t VisibleOffset);
63 void VisitObjCMethodDecl(ObjCMethodDecl *D);
64 void VisitObjCContainerDecl(ObjCContainerDecl *D);
65 void VisitObjCInterfaceDecl(ObjCInterfaceDecl *D);
66 void VisitObjCIvarDecl(ObjCIvarDecl *D);
67 void VisitObjCProtocolDecl(ObjCProtocolDecl *D);
68 void VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D);
69 void VisitObjCClassDecl(ObjCClassDecl *D);
70 void VisitObjCForwardProtocolDecl(ObjCForwardProtocolDecl *D);
71 void VisitObjCCategoryDecl(ObjCCategoryDecl *D);
72 void VisitObjCImplDecl(ObjCImplDecl *D);
73 void VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D);
74 void VisitObjCImplementationDecl(ObjCImplementationDecl *D);
75 void VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D);
76 void VisitObjCPropertyDecl(ObjCPropertyDecl *D);
77 void VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D);
78 };
79}
80
81void PCHDeclWriter::VisitDecl(Decl *D) {
82 Writer.AddDeclRef(cast_or_null<Decl>(D->getDeclContext()), Record);
83 Writer.AddDeclRef(cast_or_null<Decl>(D->getLexicalDeclContext()), Record);
84 Writer.AddSourceLocation(D->getLocation(), Record);
85 Record.push_back(D->isInvalidDecl());
86 Record.push_back(D->hasAttrs());
87 Record.push_back(D->isImplicit());
Douglas Gregore0762c92009-06-19 23:52:42 +000088 Record.push_back(D->isUsed());
Chris Lattner12b1c762009-04-27 06:16:06 +000089 Record.push_back(D->getAccess());
Douglas Gregor7d1d49d2009-10-16 20:01:17 +000090 Record.push_back(D->getPCHLevel());
Chris Lattner12b1c762009-04-27 06:16:06 +000091}
92
93void PCHDeclWriter::VisitTranslationUnitDecl(TranslationUnitDecl *D) {
94 VisitDecl(D);
95 Code = pch::DECL_TRANSLATION_UNIT;
96}
97
98void PCHDeclWriter::VisitNamedDecl(NamedDecl *D) {
99 VisitDecl(D);
100 Writer.AddDeclarationName(D->getDeclName(), Record);
101}
102
Douglas Gregor0cef4832010-02-21 18:22:14 +0000103void PCHDeclWriter::VisitNamespaceDecl(NamespaceDecl *D) {
104 VisitNamedDecl(D);
105 Writer.AddSourceLocation(D->getLBracLoc(), Record);
106 Writer.AddSourceLocation(D->getRBracLoc(), Record);
107 Writer.AddDeclRef(D->getNextNamespace(), Record);
108 Writer.AddDeclRef(D->getOriginalNamespace(), Record);
109 Writer.AddDeclRef(D->getAnonymousNamespace(), Record);
110 Code = pch::DECL_NAMESPACE;
111}
112
Chris Lattner12b1c762009-04-27 06:16:06 +0000113void PCHDeclWriter::VisitTypeDecl(TypeDecl *D) {
114 VisitNamedDecl(D);
115 Writer.AddTypeRef(QualType(D->getTypeForDecl(), 0), Record);
116}
117
118void PCHDeclWriter::VisitTypedefDecl(TypedefDecl *D) {
119 VisitTypeDecl(D);
John McCalla93c9342009-12-07 02:54:59 +0000120 Writer.AddTypeSourceInfo(D->getTypeSourceInfo(), Record);
Chris Lattner12b1c762009-04-27 06:16:06 +0000121 Code = pch::DECL_TYPEDEF;
122}
123
124void PCHDeclWriter::VisitTagDecl(TagDecl *D) {
125 VisitTypeDecl(D);
Douglas Gregor8e9e9ef2009-07-29 23:36:44 +0000126 Writer.AddDeclRef(D->getPreviousDeclaration(), Record);
Chris Lattner12b1c762009-04-27 06:16:06 +0000127 Record.push_back((unsigned)D->getTagKind()); // FIXME: stable encoding
128 Record.push_back(D->isDefinition());
Douglas Gregorb37b6482010-02-12 17:40:34 +0000129 Record.push_back(D->isEmbeddedInDeclarator());
Argyrios Kyrtzidisad93a742009-07-14 03:18:02 +0000130 Writer.AddSourceLocation(D->getRBraceLoc(), Record);
Douglas Gregor741dd9a2009-07-21 14:46:17 +0000131 Writer.AddSourceLocation(D->getTagKeywordLoc(), Record);
John McCallb6217662010-03-15 10:12:16 +0000132 // FIXME: maybe write optional qualifier and its range.
133 Writer.AddDeclRef(D->getTypedefForAnonDecl(), Record);
Chris Lattner12b1c762009-04-27 06:16:06 +0000134}
135
136void PCHDeclWriter::VisitEnumDecl(EnumDecl *D) {
137 VisitTagDecl(D);
138 Writer.AddTypeRef(D->getIntegerType(), Record);
John McCall842aef82009-12-09 09:09:27 +0000139 Writer.AddTypeRef(D->getPromotionType(), Record);
Douglas Gregor8dbc3c62009-05-27 17:20:35 +0000140 // FIXME: C++ InstantiatedFrom
Chris Lattner12b1c762009-04-27 06:16:06 +0000141 Code = pch::DECL_ENUM;
142}
143
144void PCHDeclWriter::VisitRecordDecl(RecordDecl *D) {
145 VisitTagDecl(D);
146 Record.push_back(D->hasFlexibleArrayMember());
147 Record.push_back(D->isAnonymousStructOrUnion());
Fariborz Jahanian643b7df2009-07-08 16:37:44 +0000148 Record.push_back(D->hasObjectMember());
Chris Lattner12b1c762009-04-27 06:16:06 +0000149 Code = pch::DECL_RECORD;
150}
151
152void PCHDeclWriter::VisitValueDecl(ValueDecl *D) {
153 VisitNamedDecl(D);
154 Writer.AddTypeRef(D->getType(), Record);
155}
156
157void PCHDeclWriter::VisitEnumConstantDecl(EnumConstantDecl *D) {
158 VisitValueDecl(D);
159 Record.push_back(D->getInitExpr()? 1 : 0);
160 if (D->getInitExpr())
161 Writer.AddStmt(D->getInitExpr());
162 Writer.AddAPSInt(D->getInitVal(), Record);
163 Code = pch::DECL_ENUM_CONSTANT;
164}
Argyrios Kyrtzidisd4a7e542009-08-19 01:28:35 +0000165
166void PCHDeclWriter::VisitDeclaratorDecl(DeclaratorDecl *D) {
167 VisitValueDecl(D);
John McCalla93c9342009-12-07 02:54:59 +0000168 Writer.AddTypeSourceInfo(D->getTypeSourceInfo(), Record);
John McCallb6217662010-03-15 10:12:16 +0000169 // FIXME: write optional qualifier and its range.
Argyrios Kyrtzidisd4a7e542009-08-19 01:28:35 +0000170}
Chris Lattner12b1c762009-04-27 06:16:06 +0000171
172void PCHDeclWriter::VisitFunctionDecl(FunctionDecl *D) {
Argyrios Kyrtzidisd4a7e542009-08-19 01:28:35 +0000173 VisitDeclaratorDecl(D);
Chris Lattner12b1c762009-04-27 06:16:06 +0000174 Record.push_back(D->isThisDeclarationADefinition());
175 if (D->isThisDeclarationADefinition())
Argyrios Kyrtzidis6fb0aee2009-06-30 02:35:26 +0000176 Writer.AddStmt(D->getBody());
Chris Lattner12b1c762009-04-27 06:16:06 +0000177 Writer.AddDeclRef(D->getPreviousDeclaration(), Record);
178 Record.push_back(D->getStorageClass()); // FIXME: stable encoding
Douglas Gregor16573fa2010-04-19 22:54:31 +0000179 Record.push_back(D->getStorageClassAsWritten());
Douglas Gregor0130f3c2009-10-27 21:01:01 +0000180 Record.push_back(D->isInlineSpecified());
Anders Carlsson77b7f1d2009-05-14 22:15:41 +0000181 Record.push_back(D->isVirtualAsWritten());
Chris Lattner12b1c762009-04-27 06:16:06 +0000182 Record.push_back(D->isPure());
Anders Carlssona75e8532009-05-14 21:46:00 +0000183 Record.push_back(D->hasInheritedPrototype());
184 Record.push_back(D->hasWrittenPrototype());
Chris Lattner12b1c762009-04-27 06:16:06 +0000185 Record.push_back(D->isDeleted());
Daniel Dunbar7f8b57a2009-09-22 05:38:14 +0000186 Record.push_back(D->isTrivial());
187 Record.push_back(D->isCopyAssignment());
188 Record.push_back(D->hasImplicitReturnZero());
Argyrios Kyrtzidis8cff90e2009-06-20 08:09:34 +0000189 Writer.AddSourceLocation(D->getLocEnd(), Record);
Douglas Gregor1eee0e72009-05-14 21:06:31 +0000190 // FIXME: C++ TemplateOrInstantiation
Chris Lattner12b1c762009-04-27 06:16:06 +0000191 Record.push_back(D->param_size());
192 for (FunctionDecl::param_iterator P = D->param_begin(), PEnd = D->param_end();
193 P != PEnd; ++P)
194 Writer.AddDeclRef(*P, Record);
195 Code = pch::DECL_FUNCTION;
196}
197
198void PCHDeclWriter::VisitObjCMethodDecl(ObjCMethodDecl *D) {
199 VisitNamedDecl(D);
200 // FIXME: convert to LazyStmtPtr?
Mike Stump1eb44332009-09-09 15:08:12 +0000201 // Unlike C/C++, method bodies will never be in header files.
Chris Lattner12b1c762009-04-27 06:16:06 +0000202 Record.push_back(D->getBody() != 0);
203 if (D->getBody() != 0) {
Argyrios Kyrtzidis6fb0aee2009-06-30 02:35:26 +0000204 Writer.AddStmt(D->getBody());
Chris Lattner12b1c762009-04-27 06:16:06 +0000205 Writer.AddDeclRef(D->getSelfDecl(), Record);
206 Writer.AddDeclRef(D->getCmdDecl(), Record);
207 }
208 Record.push_back(D->isInstanceMethod());
209 Record.push_back(D->isVariadic());
210 Record.push_back(D->isSynthesized());
211 // FIXME: stable encoding for @required/@optional
Mike Stump1eb44332009-09-09 15:08:12 +0000212 Record.push_back(D->getImplementationControl());
Chris Lattner12b1c762009-04-27 06:16:06 +0000213 // FIXME: stable encoding for in/out/inout/bycopy/byref/oneway
Mike Stump1eb44332009-09-09 15:08:12 +0000214 Record.push_back(D->getObjCDeclQualifier());
Fariborz Jahanian7732cc92010-04-08 21:29:11 +0000215 Record.push_back(D->getNumSelectorArgs());
Chris Lattner12b1c762009-04-27 06:16:06 +0000216 Writer.AddTypeRef(D->getResultType(), Record);
Douglas Gregor4bc1cb62010-03-08 14:59:44 +0000217 Writer.AddTypeSourceInfo(D->getResultTypeSourceInfo(), Record);
Chris Lattner12b1c762009-04-27 06:16:06 +0000218 Writer.AddSourceLocation(D->getLocEnd(), Record);
219 Record.push_back(D->param_size());
Mike Stump1eb44332009-09-09 15:08:12 +0000220 for (ObjCMethodDecl::param_iterator P = D->param_begin(),
Chris Lattner12b1c762009-04-27 06:16:06 +0000221 PEnd = D->param_end(); P != PEnd; ++P)
222 Writer.AddDeclRef(*P, Record);
223 Code = pch::DECL_OBJC_METHOD;
224}
225
226void PCHDeclWriter::VisitObjCContainerDecl(ObjCContainerDecl *D) {
227 VisitNamedDecl(D);
Ted Kremenek782f2f52010-01-07 01:20:12 +0000228 SourceRange R = D->getAtEndRange();
229 Writer.AddSourceLocation(R.getBegin(), Record);
230 Writer.AddSourceLocation(R.getEnd(), Record);
Chris Lattner12b1c762009-04-27 06:16:06 +0000231 // Abstract class (no need to define a stable pch::DECL code).
232}
233
234void PCHDeclWriter::VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) {
235 VisitObjCContainerDecl(D);
236 Writer.AddTypeRef(QualType(D->getTypeForDecl(), 0), Record);
237 Writer.AddDeclRef(D->getSuperClass(), Record);
238 Record.push_back(D->protocol_size());
Mike Stump1eb44332009-09-09 15:08:12 +0000239 for (ObjCInterfaceDecl::protocol_iterator P = D->protocol_begin(),
Chris Lattner12b1c762009-04-27 06:16:06 +0000240 PEnd = D->protocol_end();
241 P != PEnd; ++P)
242 Writer.AddDeclRef(*P, Record);
Douglas Gregor18df52b2010-01-16 15:02:53 +0000243 for (ObjCInterfaceDecl::protocol_loc_iterator PL = D->protocol_loc_begin(),
244 PLEnd = D->protocol_loc_end();
245 PL != PLEnd; ++PL)
246 Writer.AddSourceLocation(*PL, Record);
Chris Lattner12b1c762009-04-27 06:16:06 +0000247 Record.push_back(D->ivar_size());
Mike Stump1eb44332009-09-09 15:08:12 +0000248 for (ObjCInterfaceDecl::ivar_iterator I = D->ivar_begin(),
Chris Lattner12b1c762009-04-27 06:16:06 +0000249 IEnd = D->ivar_end(); I != IEnd; ++I)
250 Writer.AddDeclRef(*I, Record);
251 Writer.AddDeclRef(D->getCategoryList(), Record);
252 Record.push_back(D->isForwardDecl());
253 Record.push_back(D->isImplicitInterfaceDecl());
254 Writer.AddSourceLocation(D->getClassLoc(), Record);
255 Writer.AddSourceLocation(D->getSuperClassLoc(), Record);
256 Writer.AddSourceLocation(D->getLocEnd(), Record);
257 Code = pch::DECL_OBJC_INTERFACE;
258}
259
260void PCHDeclWriter::VisitObjCIvarDecl(ObjCIvarDecl *D) {
261 VisitFieldDecl(D);
262 // FIXME: stable encoding for @public/@private/@protected/@package
Mike Stump1eb44332009-09-09 15:08:12 +0000263 Record.push_back(D->getAccessControl());
Chris Lattner12b1c762009-04-27 06:16:06 +0000264 Code = pch::DECL_OBJC_IVAR;
265}
266
267void PCHDeclWriter::VisitObjCProtocolDecl(ObjCProtocolDecl *D) {
268 VisitObjCContainerDecl(D);
269 Record.push_back(D->isForwardDecl());
270 Writer.AddSourceLocation(D->getLocEnd(), Record);
271 Record.push_back(D->protocol_size());
Mike Stump1eb44332009-09-09 15:08:12 +0000272 for (ObjCProtocolDecl::protocol_iterator
Chris Lattner12b1c762009-04-27 06:16:06 +0000273 I = D->protocol_begin(), IEnd = D->protocol_end(); I != IEnd; ++I)
274 Writer.AddDeclRef(*I, Record);
Douglas Gregor18df52b2010-01-16 15:02:53 +0000275 for (ObjCProtocolDecl::protocol_loc_iterator PL = D->protocol_loc_begin(),
276 PLEnd = D->protocol_loc_end();
277 PL != PLEnd; ++PL)
278 Writer.AddSourceLocation(*PL, Record);
Chris Lattner12b1c762009-04-27 06:16:06 +0000279 Code = pch::DECL_OBJC_PROTOCOL;
280}
281
282void PCHDeclWriter::VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D) {
283 VisitFieldDecl(D);
284 Code = pch::DECL_OBJC_AT_DEFS_FIELD;
285}
286
287void PCHDeclWriter::VisitObjCClassDecl(ObjCClassDecl *D) {
288 VisitDecl(D);
289 Record.push_back(D->size());
290 for (ObjCClassDecl::iterator I = D->begin(), IEnd = D->end(); I != IEnd; ++I)
Ted Kremenek321c22f2009-11-18 00:28:11 +0000291 Writer.AddDeclRef(I->getInterface(), Record);
292 for (ObjCClassDecl::iterator I = D->begin(), IEnd = D->end(); I != IEnd; ++I)
293 Writer.AddSourceLocation(I->getLocation(), Record);
Chris Lattner12b1c762009-04-27 06:16:06 +0000294 Code = pch::DECL_OBJC_CLASS;
295}
296
297void PCHDeclWriter::VisitObjCForwardProtocolDecl(ObjCForwardProtocolDecl *D) {
298 VisitDecl(D);
299 Record.push_back(D->protocol_size());
Douglas Gregor18df52b2010-01-16 15:02:53 +0000300 for (ObjCForwardProtocolDecl::protocol_iterator
Chris Lattner12b1c762009-04-27 06:16:06 +0000301 I = D->protocol_begin(), IEnd = D->protocol_end(); I != IEnd; ++I)
302 Writer.AddDeclRef(*I, Record);
Douglas Gregor18df52b2010-01-16 15:02:53 +0000303 for (ObjCForwardProtocolDecl::protocol_loc_iterator
304 PL = D->protocol_loc_begin(), PLEnd = D->protocol_loc_end();
305 PL != PLEnd; ++PL)
306 Writer.AddSourceLocation(*PL, Record);
Chris Lattner12b1c762009-04-27 06:16:06 +0000307 Code = pch::DECL_OBJC_FORWARD_PROTOCOL;
308}
309
310void PCHDeclWriter::VisitObjCCategoryDecl(ObjCCategoryDecl *D) {
311 VisitObjCContainerDecl(D);
312 Writer.AddDeclRef(D->getClassInterface(), Record);
313 Record.push_back(D->protocol_size());
Douglas Gregor18df52b2010-01-16 15:02:53 +0000314 for (ObjCCategoryDecl::protocol_iterator
Chris Lattner12b1c762009-04-27 06:16:06 +0000315 I = D->protocol_begin(), IEnd = D->protocol_end(); I != IEnd; ++I)
316 Writer.AddDeclRef(*I, Record);
Douglas Gregor18df52b2010-01-16 15:02:53 +0000317 for (ObjCCategoryDecl::protocol_loc_iterator
318 PL = D->protocol_loc_begin(), PLEnd = D->protocol_loc_end();
319 PL != PLEnd; ++PL)
320 Writer.AddSourceLocation(*PL, Record);
Chris Lattner12b1c762009-04-27 06:16:06 +0000321 Writer.AddDeclRef(D->getNextClassCategory(), Record);
Douglas Gregor3db211b2010-01-16 16:38:58 +0000322 Writer.AddSourceLocation(D->getAtLoc(), Record);
323 Writer.AddSourceLocation(D->getCategoryNameLoc(), Record);
Chris Lattner12b1c762009-04-27 06:16:06 +0000324 Code = pch::DECL_OBJC_CATEGORY;
325}
326
327void PCHDeclWriter::VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D) {
328 VisitNamedDecl(D);
329 Writer.AddDeclRef(D->getClassInterface(), Record);
330 Code = pch::DECL_OBJC_COMPATIBLE_ALIAS;
331}
332
333void PCHDeclWriter::VisitObjCPropertyDecl(ObjCPropertyDecl *D) {
334 VisitNamedDecl(D);
Fariborz Jahaniand0502402010-01-21 17:36:00 +0000335 Writer.AddSourceLocation(D->getAtLoc(), Record);
Chris Lattner12b1c762009-04-27 06:16:06 +0000336 Writer.AddTypeRef(D->getType(), Record);
337 // FIXME: stable encoding
338 Record.push_back((unsigned)D->getPropertyAttributes());
339 // FIXME: stable encoding
340 Record.push_back((unsigned)D->getPropertyImplementation());
341 Writer.AddDeclarationName(D->getGetterName(), Record);
342 Writer.AddDeclarationName(D->getSetterName(), Record);
343 Writer.AddDeclRef(D->getGetterMethodDecl(), Record);
344 Writer.AddDeclRef(D->getSetterMethodDecl(), Record);
345 Writer.AddDeclRef(D->getPropertyIvarDecl(), Record);
346 Code = pch::DECL_OBJC_PROPERTY;
347}
348
349void PCHDeclWriter::VisitObjCImplDecl(ObjCImplDecl *D) {
Argyrios Kyrtzidisaecae622009-07-27 19:04:32 +0000350 VisitObjCContainerDecl(D);
Chris Lattner12b1c762009-04-27 06:16:06 +0000351 Writer.AddDeclRef(D->getClassInterface(), Record);
Chris Lattner12b1c762009-04-27 06:16:06 +0000352 // Abstract class (no need to define a stable pch::DECL code).
353}
354
355void PCHDeclWriter::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
356 VisitObjCImplDecl(D);
357 Writer.AddIdentifierRef(D->getIdentifier(), Record);
358 Code = pch::DECL_OBJC_CATEGORY_IMPL;
359}
360
361void PCHDeclWriter::VisitObjCImplementationDecl(ObjCImplementationDecl *D) {
362 VisitObjCImplDecl(D);
363 Writer.AddDeclRef(D->getSuperClass(), Record);
364 Code = pch::DECL_OBJC_IMPLEMENTATION;
365}
366
367void PCHDeclWriter::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) {
368 VisitDecl(D);
369 Writer.AddSourceLocation(D->getLocStart(), Record);
370 Writer.AddDeclRef(D->getPropertyDecl(), Record);
371 Writer.AddDeclRef(D->getPropertyIvarDecl(), Record);
372 Code = pch::DECL_OBJC_PROPERTY_IMPL;
373}
374
375void PCHDeclWriter::VisitFieldDecl(FieldDecl *D) {
Argyrios Kyrtzidisd4a7e542009-08-19 01:28:35 +0000376 VisitDeclaratorDecl(D);
Chris Lattner12b1c762009-04-27 06:16:06 +0000377 Record.push_back(D->isMutable());
378 Record.push_back(D->getBitWidth()? 1 : 0);
379 if (D->getBitWidth())
380 Writer.AddStmt(D->getBitWidth());
381 Code = pch::DECL_FIELD;
382}
383
384void PCHDeclWriter::VisitVarDecl(VarDecl *D) {
Argyrios Kyrtzidisd4a7e542009-08-19 01:28:35 +0000385 VisitDeclaratorDecl(D);
Chris Lattner12b1c762009-04-27 06:16:06 +0000386 Record.push_back(D->getStorageClass()); // FIXME: stable encoding
Douglas Gregor16573fa2010-04-19 22:54:31 +0000387 Record.push_back(D->getStorageClassAsWritten());
Chris Lattner12b1c762009-04-27 06:16:06 +0000388 Record.push_back(D->isThreadSpecified());
389 Record.push_back(D->hasCXXDirectInitializer());
390 Record.push_back(D->isDeclaredInCondition());
391 Writer.AddDeclRef(D->getPreviousDeclaration(), Record);
Chris Lattner12b1c762009-04-27 06:16:06 +0000392 Record.push_back(D->getInit()? 1 : 0);
393 if (D->getInit())
394 Writer.AddStmt(D->getInit());
395 Code = pch::DECL_VAR;
396}
397
398void PCHDeclWriter::VisitImplicitParamDecl(ImplicitParamDecl *D) {
399 VisitVarDecl(D);
400 Code = pch::DECL_IMPLICIT_PARAM;
401}
402
403void PCHDeclWriter::VisitParmVarDecl(ParmVarDecl *D) {
404 VisitVarDecl(D);
405 Record.push_back(D->getObjCDeclQualifier()); // FIXME: stable encoding
John McCallbf73b352010-03-12 18:31:32 +0000406 Record.push_back(D->hasInheritedDefaultArg());
Chris Lattner12b1c762009-04-27 06:16:06 +0000407 Code = pch::DECL_PARM_VAR;
Mike Stump1eb44332009-09-09 15:08:12 +0000408
409
Chris Lattnerea5ce472009-04-27 07:35:58 +0000410 // If the assumptions about the DECL_PARM_VAR abbrev are true, use it. Here
411 // we dynamically check for the properties that we optimize for, but don't
412 // know are true of all PARM_VAR_DECLs.
John McCalla93c9342009-12-07 02:54:59 +0000413 if (!D->getTypeSourceInfo() &&
Argyrios Kyrtzidisd4a7e542009-08-19 01:28:35 +0000414 !D->hasAttrs() &&
Chris Lattnerea5ce472009-04-27 07:35:58 +0000415 !D->isImplicit() &&
Douglas Gregore0762c92009-06-19 23:52:42 +0000416 !D->isUsed() &&
Chris Lattnerea5ce472009-04-27 07:35:58 +0000417 D->getAccess() == AS_none &&
Douglas Gregor7d1d49d2009-10-16 20:01:17 +0000418 D->getPCHLevel() == 0 &&
Chris Lattnerea5ce472009-04-27 07:35:58 +0000419 D->getStorageClass() == 0 &&
420 !D->hasCXXDirectInitializer() && // Can params have this ever?
John McCallbf73b352010-03-12 18:31:32 +0000421 D->getObjCDeclQualifier() == 0 &&
422 !D->hasInheritedDefaultArg())
Chris Lattnerea5ce472009-04-27 07:35:58 +0000423 AbbrevToUse = Writer.getParmVarDeclAbbrev();
424
425 // Check things we know are true of *every* PARM_VAR_DECL, which is more than
426 // just us assuming it.
427 assert(!D->isInvalidDecl() && "Shouldn't emit invalid decls");
428 assert(!D->isThreadSpecified() && "PARM_VAR_DECL can't be __thread");
429 assert(D->getAccess() == AS_none && "PARM_VAR_DECL can't be public/private");
430 assert(!D->isDeclaredInCondition() && "PARM_VAR_DECL can't be in condition");
431 assert(D->getPreviousDeclaration() == 0 && "PARM_VAR_DECL can't be redecl");
432 assert(D->getInit() == 0 && "PARM_VAR_DECL never has init");
Chris Lattner12b1c762009-04-27 06:16:06 +0000433}
434
Chris Lattner12b1c762009-04-27 06:16:06 +0000435void PCHDeclWriter::VisitFileScopeAsmDecl(FileScopeAsmDecl *D) {
436 VisitDecl(D);
437 Writer.AddStmt(D->getAsmString());
438 Code = pch::DECL_FILE_SCOPE_ASM;
439}
440
441void PCHDeclWriter::VisitBlockDecl(BlockDecl *D) {
442 VisitDecl(D);
443 Writer.AddStmt(D->getBody());
444 Record.push_back(D->param_size());
445 for (FunctionDecl::param_iterator P = D->param_begin(), PEnd = D->param_end();
446 P != PEnd; ++P)
447 Writer.AddDeclRef(*P, Record);
448 Code = pch::DECL_BLOCK;
449}
450
451/// \brief Emit the DeclContext part of a declaration context decl.
452///
453/// \param LexicalOffset the offset at which the DECL_CONTEXT_LEXICAL
454/// block for this declaration context is stored. May be 0 to indicate
455/// that there are no declarations stored within this context.
456///
457/// \param VisibleOffset the offset at which the DECL_CONTEXT_VISIBLE
458/// block for this declaration context is stored. May be 0 to indicate
459/// that there are no declarations visible from this context. Note
460/// that this value will not be emitted for non-primary declaration
461/// contexts.
Mike Stump1eb44332009-09-09 15:08:12 +0000462void PCHDeclWriter::VisitDeclContext(DeclContext *DC, uint64_t LexicalOffset,
Chris Lattner12b1c762009-04-27 06:16:06 +0000463 uint64_t VisibleOffset) {
464 Record.push_back(LexicalOffset);
465 Record.push_back(VisibleOffset);
466}
467
468
469//===----------------------------------------------------------------------===//
470// PCHWriter Implementation
471//===----------------------------------------------------------------------===//
472
Chris Lattnerea5ce472009-04-27 07:35:58 +0000473void PCHWriter::WriteDeclsBlockAbbrevs() {
474 using namespace llvm;
475 // Abbreviation for DECL_PARM_VAR.
476 BitCodeAbbrev *Abv = new BitCodeAbbrev();
477 Abv->Add(BitCodeAbbrevOp(pch::DECL_PARM_VAR));
478
479 // Decl
480 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
481 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalDeclContext
482 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Location
483 Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl (!?)
484 Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs
485 Abv->Add(BitCodeAbbrevOp(0)); // isImplicit
Douglas Gregore0762c92009-06-19 23:52:42 +0000486 Abv->Add(BitCodeAbbrevOp(0)); // isUsed
Chris Lattnerea5ce472009-04-27 07:35:58 +0000487 Abv->Add(BitCodeAbbrevOp(AS_none)); // C++ AccessSpecifier
Douglas Gregor7d1d49d2009-10-16 20:01:17 +0000488 Abv->Add(BitCodeAbbrevOp(0)); // PCH level
Mike Stump1eb44332009-09-09 15:08:12 +0000489
Chris Lattnerea5ce472009-04-27 07:35:58 +0000490 // NamedDecl
491 Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier
492 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
493 // ValueDecl
494 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
Argyrios Kyrtzidisd4a7e542009-08-19 01:28:35 +0000495 // DeclaratorDecl
496 Abv->Add(BitCodeAbbrevOp(pch::PREDEF_TYPE_NULL_ID)); // InfoType
Chris Lattnerea5ce472009-04-27 07:35:58 +0000497 // VarDecl
498 Abv->Add(BitCodeAbbrevOp(0)); // StorageClass
Douglas Gregor16573fa2010-04-19 22:54:31 +0000499 Abv->Add(BitCodeAbbrevOp(0)); // StorageClassAsWritten
Chris Lattnerea5ce472009-04-27 07:35:58 +0000500 Abv->Add(BitCodeAbbrevOp(0)); // isThreadSpecified
501 Abv->Add(BitCodeAbbrevOp(0)); // hasCXXDirectInitializer
502 Abv->Add(BitCodeAbbrevOp(0)); // isDeclaredInCondition
503 Abv->Add(BitCodeAbbrevOp(0)); // PrevDecl
Chris Lattnerea5ce472009-04-27 07:35:58 +0000504 Abv->Add(BitCodeAbbrevOp(0)); // HasInit
505 // ParmVarDecl
506 Abv->Add(BitCodeAbbrevOp(0)); // ObjCDeclQualifier
John McCallbf73b352010-03-12 18:31:32 +0000507 Abv->Add(BitCodeAbbrevOp(0)); // HasInheritedDefaultArg
Mike Stump1eb44332009-09-09 15:08:12 +0000508
Chris Lattnerea5ce472009-04-27 07:35:58 +0000509 ParmVarDeclAbbrev = Stream.EmitAbbrev(Abv);
510}
511
Daniel Dunbare24d38f2009-09-17 03:06:51 +0000512/// isRequiredDecl - Check if this is a "required" Decl, which must be seen by
513/// consumers of the AST.
514///
515/// Such decls will always be deserialized from the PCH file, so we would like
516/// this to be as restrictive as possible. Currently the predicate is driven by
517/// code generation requirements, if other clients have a different notion of
518/// what is "required" then we may have to consider an alternate scheme where
519/// clients can iterate over the top-level decls and get information on them,
520/// without necessary deserializing them. We could explicitly require such
521/// clients to use a separate API call to "realize" the decl. This should be
522/// relatively painless since they would presumably only do it for top-level
523/// decls.
524//
525// FIXME: This predicate is essentially IRgen's predicate to determine whether a
526// declaration can be deferred. Merge them somehow.
527static bool isRequiredDecl(const Decl *D, ASTContext &Context) {
528 // File scoped assembly must be seen.
529 if (isa<FileScopeAsmDecl>(D))
530 return true;
531
532 // Otherwise if this isn't a function or a file scoped variable it doesn't
533 // need to be seen.
534 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
535 if (!VD->isFileVarDecl())
536 return false;
537 } else if (!isa<FunctionDecl>(D))
538 return false;
539
540 // Aliases and used decls must be seen.
541 if (D->hasAttr<AliasAttr>() || D->hasAttr<UsedAttr>())
542 return true;
543
544 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
545 // Forward declarations don't need to be seen.
546 if (!FD->isThisDeclarationADefinition())
547 return false;
548
549 // Constructors and destructors must be seen.
550 if (FD->hasAttr<ConstructorAttr>() || FD->hasAttr<DestructorAttr>())
551 return true;
552
553 // Otherwise, this is required unless it is static.
554 //
555 // FIXME: Inlines.
556 return FD->getStorageClass() != FunctionDecl::Static;
557 } else {
558 const VarDecl *VD = cast<VarDecl>(D);
559
560 // In C++, this doesn't need to be seen if it is marked "extern".
561 if (Context.getLangOptions().CPlusPlus && !VD->getInit() &&
562 (VD->getStorageClass() == VarDecl::Extern ||
563 VD->isExternC()))
564 return false;
565
566 // In C, this doesn't need to be seen unless it is a definition.
567 if (!Context.getLangOptions().CPlusPlus && !VD->getInit())
568 return false;
569
570 // Otherwise, this is required unless it is static.
571 return VD->getStorageClass() != VarDecl::Static;
572 }
573}
574
Douglas Gregor61d60ee2009-10-17 00:13:19 +0000575void PCHWriter::WriteDecl(ASTContext &Context, Decl *D) {
Chris Lattner12b1c762009-04-27 06:16:06 +0000576 RecordData Record;
577 PCHDeclWriter W(*this, Context, Record);
Chris Lattner12b1c762009-04-27 06:16:06 +0000578
Douglas Gregor61d60ee2009-10-17 00:13:19 +0000579 // If this declaration is also a DeclContext, write blocks for the
580 // declarations that lexically stored inside its context and those
581 // declarations that are visible from its context. These blocks
582 // are written before the declaration itself so that we can put
583 // their offsets into the record for the declaration.
584 uint64_t LexicalOffset = 0;
585 uint64_t VisibleOffset = 0;
586 DeclContext *DC = dyn_cast<DeclContext>(D);
587 if (DC) {
588 LexicalOffset = WriteDeclContextLexicalBlock(Context, DC);
589 VisibleOffset = WriteDeclContextVisibleBlock(Context, DC);
Chris Lattner12b1c762009-04-27 06:16:06 +0000590 }
591
Douglas Gregor61d60ee2009-10-17 00:13:19 +0000592 // Determine the ID for this declaration
593 pch::DeclID &ID = DeclIDs[D];
594 if (ID == 0)
595 ID = DeclIDs.size();
596
597 unsigned Index = ID - 1;
598
599 // Record the offset for this declaration
600 if (DeclOffsets.size() == Index)
601 DeclOffsets.push_back(Stream.GetCurrentBitNo());
602 else if (DeclOffsets.size() < Index) {
603 DeclOffsets.resize(Index+1);
604 DeclOffsets[Index] = Stream.GetCurrentBitNo();
605 }
606
607 // Build and emit a record for this declaration
608 Record.clear();
609 W.Code = (pch::DeclCode)0;
610 W.AbbrevToUse = 0;
611 W.Visit(D);
612 if (DC) W.VisitDeclContext(DC, LexicalOffset, VisibleOffset);
613
Daniel Dunbar33671982009-12-03 09:13:36 +0000614 if (!W.Code)
Chris Lattner83e7a782010-04-07 22:58:06 +0000615 llvm::report_fatal_error(llvm::StringRef("unexpected declaration kind '") +
Daniel Dunbar33671982009-12-03 09:13:36 +0000616 D->getDeclKindName() + "'");
Douglas Gregor61d60ee2009-10-17 00:13:19 +0000617 Stream.EmitRecord(W.Code, Record, W.AbbrevToUse);
618
619 // If the declaration had any attributes, write them now.
620 if (D->hasAttrs())
621 WriteAttributeRecord(D->getAttrs());
622
623 // Flush any expressions that were written as part of this declaration.
624 FlushStmts();
625
626 // Note "external" declarations so that we can add them to a record in the
627 // PCH file later.
628 //
629 // FIXME: This should be renamed, the predicate is much more complicated.
630 if (isRequiredDecl(D, Context))
631 ExternalDefinitions.push_back(Index + 1);
Chris Lattner12b1c762009-04-27 06:16:06 +0000632}