blob: 311ce7b5b11469f385c299b0ebe4877930bf2f7e [file] [log] [blame]
Sebastian Redl3b3c8742010-08-18 23:57:11 +00001//===--- ASTReaderDecl.cpp - Decl Deserialization ---------------*- C++ -*-===//
Chris Lattner487412d2009-04-27 05:27:42 +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//
Sebastian Redl2c499f62010-08-18 23:56:43 +000010// This file implements the ASTReader::ReadDeclRecord method, which is the
Chris Lattner487412d2009-04-27 05:27:42 +000011// entrypoint for loading a decl.
12//
13//===----------------------------------------------------------------------===//
14
Argyrios Kyrtzidis65ad5692010-10-24 17:26:36 +000015#include "ASTCommon.h"
Sebastian Redlf5b13462010-08-18 23:57:17 +000016#include "clang/Serialization/ASTReader.h"
Chris Lattner487412d2009-04-27 05:27:42 +000017#include "clang/AST/ASTConsumer.h"
18#include "clang/AST/ASTContext.h"
19#include "clang/AST/DeclVisitor.h"
20#include "clang/AST/DeclGroup.h"
Chris Lattnerca025db2010-05-07 21:43:38 +000021#include "clang/AST/DeclCXX.h"
22#include "clang/AST/DeclTemplate.h"
Chris Lattner487412d2009-04-27 05:27:42 +000023#include "clang/AST/Expr.h"
24using namespace clang;
Sebastian Redl539c5062010-08-18 23:57:32 +000025using namespace clang::serialization;
Chris Lattner487412d2009-04-27 05:27:42 +000026
27//===----------------------------------------------------------------------===//
28// Declaration deserialization
29//===----------------------------------------------------------------------===//
30
Argyrios Kyrtzidis74d28bd2010-06-29 22:47:00 +000031namespace clang {
Sebastian Redlb3298c32010-08-18 23:56:48 +000032 class ASTDeclReader : public DeclVisitor<ASTDeclReader, void> {
Sebastian Redl2c499f62010-08-18 23:56:43 +000033 ASTReader &Reader;
Sebastian Redl2c373b92010-10-05 15:59:54 +000034 ASTReader::PerFileData &F;
Sebastian Redlc67764e2010-07-22 22:43:28 +000035 llvm::BitstreamCursor &Cursor;
Sebastian Redl539c5062010-08-18 23:57:32 +000036 const DeclID ThisDeclID;
Argyrios Kyrtzidis8b200a52010-10-24 17:26:27 +000037 typedef ASTReader::RecordData RecordData;
38 const RecordData &Record;
Chris Lattner487412d2009-04-27 05:27:42 +000039 unsigned &Idx;
Sebastian Redl539c5062010-08-18 23:57:32 +000040 TypeID TypeIDForTypeDecl;
Chris Lattner487412d2009-04-27 05:27:42 +000041
Sebastian Redlc67764e2010-07-22 22:43:28 +000042 uint64_t GetCurrentCursorOffset();
Argyrios Kyrtzidis8b200a52010-10-24 17:26:27 +000043 SourceLocation ReadSourceLocation(const RecordData &R, unsigned &I) {
Sebastian Redl2c373b92010-10-05 15:59:54 +000044 return Reader.ReadSourceLocation(F, R, I);
45 }
Argyrios Kyrtzidis8b200a52010-10-24 17:26:27 +000046 SourceRange ReadSourceRange(const RecordData &R, unsigned &I) {
Sebastian Redl2c373b92010-10-05 15:59:54 +000047 return Reader.ReadSourceRange(F, R, I);
48 }
Argyrios Kyrtzidis8b200a52010-10-24 17:26:27 +000049 TypeSourceInfo *GetTypeSourceInfo(const RecordData &R, unsigned &I) {
Sebastian Redl2c373b92010-10-05 15:59:54 +000050 return Reader.GetTypeSourceInfo(F, R, I);
51 }
Argyrios Kyrtzidis434383d2010-10-15 18:21:24 +000052 void ReadQualifierInfo(QualifierInfo &Info,
Argyrios Kyrtzidis8b200a52010-10-24 17:26:27 +000053 const RecordData &R, unsigned &I) {
Argyrios Kyrtzidis434383d2010-10-15 18:21:24 +000054 Reader.ReadQualifierInfo(F, Info, R, I);
55 }
56 void ReadDeclarationNameLoc(DeclarationNameLoc &DNLoc, DeclarationName Name,
Argyrios Kyrtzidis8b200a52010-10-24 17:26:27 +000057 const RecordData &R, unsigned &I) {
Argyrios Kyrtzidis434383d2010-10-15 18:21:24 +000058 Reader.ReadDeclarationNameLoc(F, DNLoc, Name, R, I);
59 }
60 void ReadDeclarationNameInfo(DeclarationNameInfo &NameInfo,
Argyrios Kyrtzidis8b200a52010-10-24 17:26:27 +000061 const RecordData &R, unsigned &I) {
Argyrios Kyrtzidis434383d2010-10-15 18:21:24 +000062 Reader.ReadDeclarationNameInfo(F, NameInfo, R, I);
63 }
Sebastian Redlc67764e2010-07-22 22:43:28 +000064
Argyrios Kyrtzidiseb39d9a2010-10-24 17:26:40 +000065 void ReadCXXDefinitionData(struct CXXRecordDecl::DefinitionData &Data,
66 const RecordData &R, unsigned &I);
67
68 void InitializeCXXDefinitionData(CXXRecordDecl *D,
69 CXXRecordDecl *DefinitionDecl,
70 const RecordData &Record, unsigned &Idx);
Chris Lattner487412d2009-04-27 05:27:42 +000071 public:
Sebastian Redl2c373b92010-10-05 15:59:54 +000072 ASTDeclReader(ASTReader &Reader, ASTReader::PerFileData &F,
73 llvm::BitstreamCursor &Cursor, DeclID thisDeclID,
Argyrios Kyrtzidis8b200a52010-10-24 17:26:27 +000074 const RecordData &Record, unsigned &Idx)
Sebastian Redl2c373b92010-10-05 15:59:54 +000075 : Reader(Reader), F(F), Cursor(Cursor), ThisDeclID(thisDeclID),
76 Record(Record), Idx(Idx), TypeIDForTypeDecl(0) { }
Chris Lattner487412d2009-04-27 05:27:42 +000077
Argyrios Kyrtzidis318b0e72010-07-02 11:55:01 +000078 void Visit(Decl *D);
79
Argyrios Kyrtzidis65ad5692010-10-24 17:26:36 +000080 void UpdateDecl(Decl *D, const RecordData &Record);
81
Chris Lattner487412d2009-04-27 05:27:42 +000082 void VisitDecl(Decl *D);
83 void VisitTranslationUnitDecl(TranslationUnitDecl *TU);
84 void VisitNamedDecl(NamedDecl *ND);
Douglas Gregore31bbd92010-02-21 18:22:14 +000085 void VisitNamespaceDecl(NamespaceDecl *D);
Chris Lattnerca025db2010-05-07 21:43:38 +000086 void VisitUsingDirectiveDecl(UsingDirectiveDecl *D);
87 void VisitNamespaceAliasDecl(NamespaceAliasDecl *D);
Chris Lattner487412d2009-04-27 05:27:42 +000088 void VisitTypeDecl(TypeDecl *TD);
89 void VisitTypedefDecl(TypedefDecl *TD);
Argyrios Kyrtzidisbd8ac8c2010-06-30 08:49:30 +000090 void VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D);
Chris Lattner487412d2009-04-27 05:27:42 +000091 void VisitTagDecl(TagDecl *TD);
92 void VisitEnumDecl(EnumDecl *ED);
93 void VisitRecordDecl(RecordDecl *RD);
Chris Lattnerca025db2010-05-07 21:43:38 +000094 void VisitCXXRecordDecl(CXXRecordDecl *D);
95 void VisitClassTemplateSpecializationDecl(
96 ClassTemplateSpecializationDecl *D);
97 void VisitClassTemplatePartialSpecializationDecl(
98 ClassTemplatePartialSpecializationDecl *D);
99 void VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D);
Chris Lattner487412d2009-04-27 05:27:42 +0000100 void VisitValueDecl(ValueDecl *VD);
101 void VisitEnumConstantDecl(EnumConstantDecl *ECD);
Argyrios Kyrtzidisbd8ac8c2010-06-30 08:49:30 +0000102 void VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D);
Argyrios Kyrtzidis560ac972009-08-19 01:28:35 +0000103 void VisitDeclaratorDecl(DeclaratorDecl *DD);
Chris Lattner487412d2009-04-27 05:27:42 +0000104 void VisitFunctionDecl(FunctionDecl *FD);
Chris Lattnerca025db2010-05-07 21:43:38 +0000105 void VisitCXXMethodDecl(CXXMethodDecl *D);
106 void VisitCXXConstructorDecl(CXXConstructorDecl *D);
107 void VisitCXXDestructorDecl(CXXDestructorDecl *D);
108 void VisitCXXConversionDecl(CXXConversionDecl *D);
Chris Lattner487412d2009-04-27 05:27:42 +0000109 void VisitFieldDecl(FieldDecl *FD);
Francois Pichet783dd6e2010-11-21 06:08:52 +0000110 void VisitIndirectFieldDecl(IndirectFieldDecl *FD);
Chris Lattner487412d2009-04-27 05:27:42 +0000111 void VisitVarDecl(VarDecl *VD);
112 void VisitImplicitParamDecl(ImplicitParamDecl *PD);
113 void VisitParmVarDecl(ParmVarDecl *PD);
Chris Lattnerca025db2010-05-07 21:43:38 +0000114 void VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D);
115 void VisitTemplateDecl(TemplateDecl *D);
Peter Collingbourne91b25b72010-07-29 16:11:51 +0000116 void VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D);
Chris Lattnerca025db2010-05-07 21:43:38 +0000117 void VisitClassTemplateDecl(ClassTemplateDecl *D);
Argyrios Kyrtzidis69da4a82010-06-22 09:55:07 +0000118 void VisitFunctionTemplateDecl(FunctionTemplateDecl *D);
Chris Lattnerca025db2010-05-07 21:43:38 +0000119 void VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D);
Argyrios Kyrtzidis41d45622010-06-20 14:40:59 +0000120 void VisitUsingDecl(UsingDecl *D);
121 void VisitUsingShadowDecl(UsingShadowDecl *D);
Chris Lattnerca025db2010-05-07 21:43:38 +0000122 void VisitLinkageSpecDecl(LinkageSpecDecl *D);
Chris Lattner487412d2009-04-27 05:27:42 +0000123 void VisitFileScopeAsmDecl(FileScopeAsmDecl *AD);
Abramo Bagnarad7340582010-06-05 05:09:32 +0000124 void VisitAccessSpecDecl(AccessSpecDecl *D);
Argyrios Kyrtzidis74d28bd2010-06-29 22:47:00 +0000125 void VisitFriendDecl(FriendDecl *D);
Chris Lattnerca025db2010-05-07 21:43:38 +0000126 void VisitFriendTemplateDecl(FriendTemplateDecl *D);
127 void VisitStaticAssertDecl(StaticAssertDecl *D);
Chris Lattner487412d2009-04-27 05:27:42 +0000128 void VisitBlockDecl(BlockDecl *BD);
Chris Lattnerca025db2010-05-07 21:43:38 +0000129
Chris Lattner487412d2009-04-27 05:27:42 +0000130 std::pair<uint64_t, uint64_t> VisitDeclContext(DeclContext *DC);
Argyrios Kyrtzidis839bbac2010-08-03 17:30:10 +0000131 template <typename T> void VisitRedeclarable(Redeclarable<T> *D);
Chris Lattnerca025db2010-05-07 21:43:38 +0000132
Alexis Hunted053252010-05-30 07:21:58 +0000133 // FIXME: Reorder according to DeclNodes.td?
Chris Lattner487412d2009-04-27 05:27:42 +0000134 void VisitObjCMethodDecl(ObjCMethodDecl *D);
135 void VisitObjCContainerDecl(ObjCContainerDecl *D);
136 void VisitObjCInterfaceDecl(ObjCInterfaceDecl *D);
137 void VisitObjCIvarDecl(ObjCIvarDecl *D);
138 void VisitObjCProtocolDecl(ObjCProtocolDecl *D);
139 void VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D);
140 void VisitObjCClassDecl(ObjCClassDecl *D);
141 void VisitObjCForwardProtocolDecl(ObjCForwardProtocolDecl *D);
142 void VisitObjCCategoryDecl(ObjCCategoryDecl *D);
143 void VisitObjCImplDecl(ObjCImplDecl *D);
144 void VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D);
145 void VisitObjCImplementationDecl(ObjCImplementationDecl *D);
146 void VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D);
147 void VisitObjCPropertyDecl(ObjCPropertyDecl *D);
148 void VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D);
149 };
150}
151
Sebastian Redlb3298c32010-08-18 23:56:48 +0000152uint64_t ASTDeclReader::GetCurrentCursorOffset() {
Sebastian Redlc67764e2010-07-22 22:43:28 +0000153 uint64_t Off = 0;
154 for (unsigned I = 0, N = Reader.Chain.size(); I != N; ++I) {
Sebastian Redl2c499f62010-08-18 23:56:43 +0000155 ASTReader::PerFileData &F = *Reader.Chain[N - I - 1];
Sebastian Redlc67764e2010-07-22 22:43:28 +0000156 if (&Cursor == &F.DeclsCursor) {
157 Off += F.DeclsCursor.GetCurrentBitNo();
158 break;
159 }
160 Off += F.SizeInBits;
161 }
162 return Off;
163}
164
Sebastian Redlb3298c32010-08-18 23:56:48 +0000165void ASTDeclReader::Visit(Decl *D) {
166 DeclVisitor<ASTDeclReader, void>::Visit(D);
Argyrios Kyrtzidis318b0e72010-07-02 11:55:01 +0000167
Argyrios Kyrtzidis33575162010-07-02 15:58:43 +0000168 if (TypeDecl *TD = dyn_cast<TypeDecl>(D)) {
Douglas Gregor1c283312010-08-11 12:19:30 +0000169 // if we have a fully initialized TypeDecl, we can safely read its type now.
Douglas Gregor0cdc8322010-12-10 17:03:06 +0000170 TD->setTypeForDecl(Reader.GetType(TypeIDForTypeDecl).getTypePtrOrNull());
Argyrios Kyrtzidis33575162010-07-02 15:58:43 +0000171 } else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
172 // FunctionDecl's body was written last after all other Stmts/Exprs.
173 if (Record[Idx++])
Sebastian Redlc67764e2010-07-22 22:43:28 +0000174 FD->setLazyBody(GetCurrentCursorOffset());
Argyrios Kyrtzidis33575162010-07-02 15:58:43 +0000175 }
Argyrios Kyrtzidis318b0e72010-07-02 11:55:01 +0000176}
177
Sebastian Redlb3298c32010-08-18 23:56:48 +0000178void ASTDeclReader::VisitDecl(Decl *D) {
Chris Lattner487412d2009-04-27 05:27:42 +0000179 D->setDeclContext(cast_or_null<DeclContext>(Reader.GetDecl(Record[Idx++])));
180 D->setLexicalDeclContext(
181 cast_or_null<DeclContext>(Reader.GetDecl(Record[Idx++])));
Sebastian Redl2c373b92010-10-05 15:59:54 +0000182 D->setLocation(ReadSourceLocation(Record, Idx));
Chris Lattner487412d2009-04-27 05:27:42 +0000183 D->setInvalidDecl(Record[Idx++]);
Argyrios Kyrtzidis9beef8e2010-10-18 19:20:11 +0000184 if (Record[Idx++]) { // hasAttrs
Alexis Huntdcfba7b2010-08-18 23:23:40 +0000185 AttrVec Attrs;
Argyrios Kyrtzidis9beef8e2010-10-18 19:20:11 +0000186 Reader.ReadAttributes(F, Attrs, Record, Idx);
Alexis Huntdcfba7b2010-08-18 23:23:40 +0000187 D->setAttrs(Attrs);
188 }
Chris Lattner487412d2009-04-27 05:27:42 +0000189 D->setImplicit(Record[Idx++]);
Douglas Gregorc9c02ed2009-06-19 23:52:42 +0000190 D->setUsed(Record[Idx++]);
Chris Lattner487412d2009-04-27 05:27:42 +0000191 D->setAccess((AccessSpecifier)Record[Idx++]);
Sebastian Redl009e7f22010-10-05 16:15:19 +0000192 D->setPCHLevel(Record[Idx++] + (F.Type <= ASTReader::PCH));
Chris Lattner487412d2009-04-27 05:27:42 +0000193}
194
Sebastian Redlb3298c32010-08-18 23:56:48 +0000195void ASTDeclReader::VisitTranslationUnitDecl(TranslationUnitDecl *TU) {
Chris Lattner487412d2009-04-27 05:27:42 +0000196 VisitDecl(TU);
Chris Lattnerca025db2010-05-07 21:43:38 +0000197 TU->setAnonymousNamespace(
198 cast_or_null<NamespaceDecl>(Reader.GetDecl(Record[Idx++])));
Chris Lattner487412d2009-04-27 05:27:42 +0000199}
200
Sebastian Redlb3298c32010-08-18 23:56:48 +0000201void ASTDeclReader::VisitNamedDecl(NamedDecl *ND) {
Chris Lattner487412d2009-04-27 05:27:42 +0000202 VisitDecl(ND);
Mike Stump11289f42009-09-09 15:08:12 +0000203 ND->setDeclName(Reader.ReadDeclarationName(Record, Idx));
Chris Lattner487412d2009-04-27 05:27:42 +0000204}
205
Sebastian Redlb3298c32010-08-18 23:56:48 +0000206void ASTDeclReader::VisitTypeDecl(TypeDecl *TD) {
Chris Lattner487412d2009-04-27 05:27:42 +0000207 VisitNamedDecl(TD);
Argyrios Kyrtzidis318b0e72010-07-02 11:55:01 +0000208 // Delay type reading until after we have fully initialized the decl.
Douglas Gregor1c283312010-08-11 12:19:30 +0000209 TypeIDForTypeDecl = Record[Idx++];
Chris Lattner487412d2009-04-27 05:27:42 +0000210}
211
Sebastian Redlb3298c32010-08-18 23:56:48 +0000212void ASTDeclReader::VisitTypedefDecl(TypedefDecl *TD) {
Argyrios Kyrtzidis318b0e72010-07-02 11:55:01 +0000213 VisitTypeDecl(TD);
Sebastian Redl2c373b92010-10-05 15:59:54 +0000214 TD->setTypeSourceInfo(GetTypeSourceInfo(Record, Idx));
Chris Lattner487412d2009-04-27 05:27:42 +0000215}
216
Sebastian Redlb3298c32010-08-18 23:56:48 +0000217void ASTDeclReader::VisitTagDecl(TagDecl *TD) {
Chris Lattner487412d2009-04-27 05:27:42 +0000218 VisitTypeDecl(TD);
Argyrios Kyrtzidis839bbac2010-08-03 17:30:10 +0000219 VisitRedeclarable(TD);
Argyrios Kyrtzidisf4bc0d82010-09-08 19:31:22 +0000220 TD->IdentifierNamespace = Record[Idx++];
Chris Lattner487412d2009-04-27 05:27:42 +0000221 TD->setTagKind((TagDecl::TagKind)Record[Idx++]);
222 TD->setDefinition(Record[Idx++]);
Douglas Gregor5089c762010-02-12 17:40:34 +0000223 TD->setEmbeddedInDeclarator(Record[Idx++]);
Sebastian Redl2c373b92010-10-05 15:59:54 +0000224 TD->setRBraceLoc(ReadSourceLocation(Record, Idx));
225 TD->setTagKeywordLoc(ReadSourceLocation(Record, Idx));
Argyrios Kyrtzidis434383d2010-10-15 18:21:24 +0000226 if (Record[Idx++]) { // hasExtInfo
227 TagDecl::ExtInfo *Info = new (*Reader.getContext()) TagDecl::ExtInfo();
228 ReadQualifierInfo(*Info, Record, Idx);
229 TD->TypedefDeclOrQualifier = Info;
230 } else
231 TD->setTypedefForAnonDecl(
232 cast_or_null<TypedefDecl>(Reader.GetDecl(Record[Idx++])));
Chris Lattner487412d2009-04-27 05:27:42 +0000233}
234
Sebastian Redlb3298c32010-08-18 23:56:48 +0000235void ASTDeclReader::VisitEnumDecl(EnumDecl *ED) {
Chris Lattner487412d2009-04-27 05:27:42 +0000236 VisitTagDecl(ED);
Douglas Gregor0bf31402010-10-08 23:50:27 +0000237 if (TypeSourceInfo *TI = Reader.GetTypeSourceInfo(F, Record, Idx))
238 ED->setIntegerTypeSourceInfo(TI);
239 else
240 ED->setIntegerType(Reader.GetType(Record[Idx++]));
John McCall56774992009-12-09 09:09:27 +0000241 ED->setPromotionType(Reader.GetType(Record[Idx++]));
John McCall9aa35be2010-05-06 08:49:23 +0000242 ED->setNumPositiveBits(Record[Idx++]);
243 ED->setNumNegativeBits(Record[Idx++]);
Douglas Gregor0bf31402010-10-08 23:50:27 +0000244 ED->IsScoped = Record[Idx++];
Abramo Bagnara0e05e242010-12-03 18:54:17 +0000245 ED->IsScopedUsingClassTag = Record[Idx++];
Douglas Gregor0bf31402010-10-08 23:50:27 +0000246 ED->IsFixed = Record[Idx++];
Argyrios Kyrtzidis282b36b2010-07-06 15:36:48 +0000247 ED->setInstantiationOfMemberEnum(
248 cast_or_null<EnumDecl>(Reader.GetDecl(Record[Idx++])));
Chris Lattner487412d2009-04-27 05:27:42 +0000249}
250
Sebastian Redlb3298c32010-08-18 23:56:48 +0000251void ASTDeclReader::VisitRecordDecl(RecordDecl *RD) {
Chris Lattner487412d2009-04-27 05:27:42 +0000252 VisitTagDecl(RD);
253 RD->setHasFlexibleArrayMember(Record[Idx++]);
254 RD->setAnonymousStructOrUnion(Record[Idx++]);
Fariborz Jahanian8e0d0422009-07-08 16:37:44 +0000255 RD->setHasObjectMember(Record[Idx++]);
Chris Lattner487412d2009-04-27 05:27:42 +0000256}
257
Sebastian Redlb3298c32010-08-18 23:56:48 +0000258void ASTDeclReader::VisitValueDecl(ValueDecl *VD) {
Chris Lattner487412d2009-04-27 05:27:42 +0000259 VisitNamedDecl(VD);
260 VD->setType(Reader.GetType(Record[Idx++]));
261}
262
Sebastian Redlb3298c32010-08-18 23:56:48 +0000263void ASTDeclReader::VisitEnumConstantDecl(EnumConstantDecl *ECD) {
Chris Lattner487412d2009-04-27 05:27:42 +0000264 VisitValueDecl(ECD);
265 if (Record[Idx++])
Sebastian Redl2c373b92010-10-05 15:59:54 +0000266 ECD->setInitExpr(Reader.ReadExpr(F));
Chris Lattner487412d2009-04-27 05:27:42 +0000267 ECD->setInitVal(Reader.ReadAPSInt(Record, Idx));
268}
269
Sebastian Redlb3298c32010-08-18 23:56:48 +0000270void ASTDeclReader::VisitDeclaratorDecl(DeclaratorDecl *DD) {
Argyrios Kyrtzidis560ac972009-08-19 01:28:35 +0000271 VisitValueDecl(DD);
Argyrios Kyrtzidis434383d2010-10-15 18:21:24 +0000272 if (Record[Idx++]) { // hasExtInfo
273 DeclaratorDecl::ExtInfo *Info
274 = new (*Reader.getContext()) DeclaratorDecl::ExtInfo();
275 ReadQualifierInfo(*Info, Record, Idx);
276 Info->TInfo = GetTypeSourceInfo(Record, Idx);
277 DD->DeclInfo = Info;
278 } else
279 DD->DeclInfo = GetTypeSourceInfo(Record, Idx);
Argyrios Kyrtzidis560ac972009-08-19 01:28:35 +0000280}
281
Sebastian Redlb3298c32010-08-18 23:56:48 +0000282void ASTDeclReader::VisitFunctionDecl(FunctionDecl *FD) {
Argyrios Kyrtzidis560ac972009-08-19 01:28:35 +0000283 VisitDeclaratorDecl(FD);
Argyrios Kyrtzidisf4bc0d82010-09-08 19:31:22 +0000284 VisitRedeclarable(FD);
Chris Lattnerca025db2010-05-07 21:43:38 +0000285
Argyrios Kyrtzidis434383d2010-10-15 18:21:24 +0000286 ReadDeclarationNameLoc(FD->DNLoc, FD->getDeclName(), Record, Idx);
Argyrios Kyrtzidisa95d0192010-07-05 10:38:01 +0000287 FD->IdentifierNamespace = Record[Idx++];
Argyrios Kyrtzidis69da4a82010-06-22 09:55:07 +0000288 switch ((FunctionDecl::TemplatedKind)Record[Idx++]) {
Argyrios Kyrtzidis0b0369a2010-06-28 09:31:34 +0000289 default: assert(false && "Unhandled TemplatedKind!");
290 break;
Argyrios Kyrtzidis69da4a82010-06-22 09:55:07 +0000291 case FunctionDecl::TK_NonTemplate:
292 break;
293 case FunctionDecl::TK_FunctionTemplate:
294 FD->setDescribedFunctionTemplate(
295 cast<FunctionTemplateDecl>(Reader.GetDecl(Record[Idx++])));
296 break;
297 case FunctionDecl::TK_MemberSpecialization: {
298 FunctionDecl *InstFD = cast<FunctionDecl>(Reader.GetDecl(Record[Idx++]));
299 TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++];
Sebastian Redl2c373b92010-10-05 15:59:54 +0000300 SourceLocation POI = ReadSourceLocation(Record, Idx);
Argyrios Kyrtzidisf4bc0d82010-09-08 19:31:22 +0000301 FD->setInstantiationOfMemberFunction(*Reader.getContext(), InstFD, TSK);
Argyrios Kyrtzidis69da4a82010-06-22 09:55:07 +0000302 FD->getMemberSpecializationInfo()->setPointOfInstantiation(POI);
303 break;
304 }
305 case FunctionDecl::TK_FunctionTemplateSpecialization: {
306 FunctionTemplateDecl *Template
307 = cast<FunctionTemplateDecl>(Reader.GetDecl(Record[Idx++]));
308 TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++];
309
310 // Template arguments.
Argyrios Kyrtzidis69da4a82010-06-22 09:55:07 +0000311 llvm::SmallVector<TemplateArgument, 8> TemplArgs;
Sebastian Redl2c373b92010-10-05 15:59:54 +0000312 Reader.ReadTemplateArgumentList(TemplArgs, F, Record, Idx);
Argyrios Kyrtzidis69da4a82010-06-22 09:55:07 +0000313
314 // Template args as written.
Argyrios Kyrtzidis69da4a82010-06-22 09:55:07 +0000315 llvm::SmallVector<TemplateArgumentLoc, 8> TemplArgLocs;
Argyrios Kyrtzidis69da4a82010-06-22 09:55:07 +0000316 SourceLocation LAngleLoc, RAngleLoc;
Argyrios Kyrtzidis373a83a2010-07-02 11:55:40 +0000317 if (Record[Idx++]) { // TemplateArgumentsAsWritten != 0
318 unsigned NumTemplateArgLocs = Record[Idx++];
319 TemplArgLocs.reserve(NumTemplateArgLocs);
320 for (unsigned i=0; i != NumTemplateArgLocs; ++i)
Sebastian Redlc67764e2010-07-22 22:43:28 +0000321 TemplArgLocs.push_back(
Sebastian Redl2c373b92010-10-05 15:59:54 +0000322 Reader.ReadTemplateArgumentLoc(F, Record, Idx));
Argyrios Kyrtzidis373a83a2010-07-02 11:55:40 +0000323
Sebastian Redl2c373b92010-10-05 15:59:54 +0000324 LAngleLoc = ReadSourceLocation(Record, Idx);
325 RAngleLoc = ReadSourceLocation(Record, Idx);
Argyrios Kyrtzidis69da4a82010-06-22 09:55:07 +0000326 }
Argyrios Kyrtzidis927d8e02010-07-05 10:37:55 +0000327
Sebastian Redl2c373b92010-10-05 15:59:54 +0000328 SourceLocation POI = ReadSourceLocation(Record, Idx);
Argyrios Kyrtzidis69da4a82010-06-22 09:55:07 +0000329
Argyrios Kyrtzidise262a952010-09-09 11:28:23 +0000330 ASTContext &C = *Reader.getContext();
331 TemplateArgumentList *TemplArgList
Douglas Gregor1ccc8412010-11-07 23:05:16 +0000332 = TemplateArgumentList::CreateCopy(C, TemplArgs.data(), TemplArgs.size());
Argyrios Kyrtzidise262a952010-09-09 11:28:23 +0000333 TemplateArgumentListInfo *TemplArgsInfo
334 = new (C) TemplateArgumentListInfo(LAngleLoc, RAngleLoc);
335 for (unsigned i=0, e = TemplArgLocs.size(); i != e; ++i)
336 TemplArgsInfo->addArgument(TemplArgLocs[i]);
337 FunctionTemplateSpecializationInfo *FTInfo
338 = FunctionTemplateSpecializationInfo::Create(C, FD, Template, TSK,
339 TemplArgList,
340 TemplArgsInfo, POI);
341 FD->TemplateOrSpecialization = FTInfo;
Argyrios Kyrtzidisf4bc0d82010-09-08 19:31:22 +0000342
Argyrios Kyrtzidise262a952010-09-09 11:28:23 +0000343 if (FD->isCanonicalDecl()) { // if canonical add to template's set.
Argyrios Kyrtzidisf24d5692010-09-13 11:45:48 +0000344 // The template that contains the specializations set. It's not safe to
345 // use getCanonicalDecl on Template since it may still be initializing.
346 FunctionTemplateDecl *CanonTemplate
347 = cast<FunctionTemplateDecl>(Reader.GetDecl(Record[Idx++]));
Argyrios Kyrtzidise262a952010-09-09 11:28:23 +0000348 // Get the InsertPos by FindNodeOrInsertPos() instead of calling
349 // InsertNode(FTInfo) directly to avoid the getASTContext() call in
350 // FunctionTemplateSpecializationInfo's Profile().
351 // We avoid getASTContext because a decl in the parent hierarchy may
352 // be initializing.
Argyrios Kyrtzidisf4bc0d82010-09-08 19:31:22 +0000353 llvm::FoldingSetNodeID ID;
354 FunctionTemplateSpecializationInfo::Profile(ID, TemplArgs.data(),
355 TemplArgs.size(), C);
356 void *InsertPos = 0;
Argyrios Kyrtzidisf24d5692010-09-13 11:45:48 +0000357 CanonTemplate->getSpecializations().FindNodeOrInsertPos(ID, InsertPos);
Argyrios Kyrtzidise262a952010-09-09 11:28:23 +0000358 assert(InsertPos && "Another specialization already inserted!");
Argyrios Kyrtzidisf24d5692010-09-13 11:45:48 +0000359 CanonTemplate->getSpecializations().InsertNode(FTInfo, InsertPos);
Argyrios Kyrtzidisf4bc0d82010-09-08 19:31:22 +0000360 }
Argyrios Kyrtzidis0b0369a2010-06-28 09:31:34 +0000361 break;
Argyrios Kyrtzidis69da4a82010-06-22 09:55:07 +0000362 }
363 case FunctionDecl::TK_DependentFunctionTemplateSpecialization: {
364 // Templates.
365 UnresolvedSet<8> TemplDecls;
366 unsigned NumTemplates = Record[Idx++];
367 while (NumTemplates--)
368 TemplDecls.addDecl(cast<NamedDecl>(Reader.GetDecl(Record[Idx++])));
369
370 // Templates args.
371 TemplateArgumentListInfo TemplArgs;
372 unsigned NumArgs = Record[Idx++];
373 while (NumArgs--)
Sebastian Redl2c373b92010-10-05 15:59:54 +0000374 TemplArgs.addArgument(Reader.ReadTemplateArgumentLoc(F, Record, Idx));
375 TemplArgs.setLAngleLoc(ReadSourceLocation(Record, Idx));
376 TemplArgs.setRAngleLoc(ReadSourceLocation(Record, Idx));
Argyrios Kyrtzidis69da4a82010-06-22 09:55:07 +0000377
378 FD->setDependentTemplateSpecialization(*Reader.getContext(),
379 TemplDecls, TemplArgs);
Argyrios Kyrtzidis0b0369a2010-06-28 09:31:34 +0000380 break;
Argyrios Kyrtzidis69da4a82010-06-22 09:55:07 +0000381 }
382 }
Argyrios Kyrtzidis373a83a2010-07-02 11:55:40 +0000383
Sebastian Redlb3298c32010-08-18 23:56:48 +0000384 // FunctionDecl's body is handled last at ASTDeclReader::Visit,
Argyrios Kyrtzidis33575162010-07-02 15:58:43 +0000385 // after everything else is read.
386
Douglas Gregorbf62d642010-12-06 18:36:25 +0000387 FD->SClass = (StorageClass)Record[Idx++];
Argyrios Kyrtzidis7cd69242011-01-03 17:57:40 +0000388 FD->SClassAsWritten = (StorageClass)Record[Idx++];
Douglas Gregorff76cb92010-12-09 16:59:22 +0000389 FD->IsInline = Record[Idx++];
390 FD->IsInlineSpecified = Record[Idx++];
Argyrios Kyrtzidis7cd69242011-01-03 17:57:40 +0000391 FD->IsVirtualAsWritten = Record[Idx++];
392 FD->IsPure = Record[Idx++];
393 FD->HasInheritedPrototype = Record[Idx++];
394 FD->HasWrittenPrototype = Record[Idx++];
395 FD->IsDeleted = Record[Idx++];
396 FD->IsTrivial = Record[Idx++];
397 FD->HasImplicitReturnZero = Record[Idx++];
398 FD->EndRangeLoc = ReadSourceLocation(Record, Idx);
Argyrios Kyrtzidis373a83a2010-07-02 11:55:40 +0000399
Chris Lattnerca025db2010-05-07 21:43:38 +0000400 // Read in the parameters.
Chris Lattner487412d2009-04-27 05:27:42 +0000401 unsigned NumParams = Record[Idx++];
402 llvm::SmallVector<ParmVarDecl *, 16> Params;
403 Params.reserve(NumParams);
404 for (unsigned I = 0; I != NumParams; ++I)
405 Params.push_back(cast<ParmVarDecl>(Reader.GetDecl(Record[Idx++])));
Argyrios Kyrtzidisf4bc0d82010-09-08 19:31:22 +0000406 FD->setParams(*Reader.getContext(), Params.data(), NumParams);
Chris Lattner487412d2009-04-27 05:27:42 +0000407}
408
Sebastian Redlb3298c32010-08-18 23:56:48 +0000409void ASTDeclReader::VisitObjCMethodDecl(ObjCMethodDecl *MD) {
Chris Lattner487412d2009-04-27 05:27:42 +0000410 VisitNamedDecl(MD);
411 if (Record[Idx++]) {
412 // In practice, this won't be executed (since method definitions
413 // don't occur in header files).
Sebastian Redl2c373b92010-10-05 15:59:54 +0000414 MD->setBody(Reader.ReadStmt(F));
Chris Lattner487412d2009-04-27 05:27:42 +0000415 MD->setSelfDecl(cast<ImplicitParamDecl>(Reader.GetDecl(Record[Idx++])));
416 MD->setCmdDecl(cast<ImplicitParamDecl>(Reader.GetDecl(Record[Idx++])));
417 }
418 MD->setInstanceMethod(Record[Idx++]);
419 MD->setVariadic(Record[Idx++]);
420 MD->setSynthesized(Record[Idx++]);
Fariborz Jahanian6e7e8cc2010-07-22 18:24:20 +0000421 MD->setDefined(Record[Idx++]);
Chris Lattner487412d2009-04-27 05:27:42 +0000422 MD->setDeclImplementation((ObjCMethodDecl::ImplementationControl)Record[Idx++]);
423 MD->setObjCDeclQualifier((Decl::ObjCDeclQualifier)Record[Idx++]);
Fariborz Jahaniand9235db2010-04-08 21:29:11 +0000424 MD->setNumSelectorArgs(unsigned(Record[Idx++]));
Chris Lattner487412d2009-04-27 05:27:42 +0000425 MD->setResultType(Reader.GetType(Record[Idx++]));
Sebastian Redl2c373b92010-10-05 15:59:54 +0000426 MD->setResultTypeSourceInfo(GetTypeSourceInfo(Record, Idx));
427 MD->setEndLoc(ReadSourceLocation(Record, Idx));
Chris Lattner487412d2009-04-27 05:27:42 +0000428 unsigned NumParams = Record[Idx++];
429 llvm::SmallVector<ParmVarDecl *, 16> Params;
430 Params.reserve(NumParams);
431 for (unsigned I = 0; I != NumParams; ++I)
432 Params.push_back(cast<ParmVarDecl>(Reader.GetDecl(Record[Idx++])));
Fariborz Jahaniancdabb312010-04-09 15:40:42 +0000433 MD->setMethodParams(*Reader.getContext(), Params.data(), NumParams,
434 NumParams);
Chris Lattner487412d2009-04-27 05:27:42 +0000435}
436
Sebastian Redlb3298c32010-08-18 23:56:48 +0000437void ASTDeclReader::VisitObjCContainerDecl(ObjCContainerDecl *CD) {
Chris Lattner487412d2009-04-27 05:27:42 +0000438 VisitNamedDecl(CD);
Sebastian Redl2c373b92010-10-05 15:59:54 +0000439 SourceLocation A = ReadSourceLocation(Record, Idx);
440 SourceLocation B = ReadSourceLocation(Record, Idx);
Ted Kremenekc7c64312010-01-07 01:20:12 +0000441 CD->setAtEndRange(SourceRange(A, B));
Chris Lattner487412d2009-04-27 05:27:42 +0000442}
443
Sebastian Redlb3298c32010-08-18 23:56:48 +0000444void ASTDeclReader::VisitObjCInterfaceDecl(ObjCInterfaceDecl *ID) {
Chris Lattner487412d2009-04-27 05:27:42 +0000445 VisitObjCContainerDecl(ID);
Douglas Gregor0cdc8322010-12-10 17:03:06 +0000446 ID->setTypeForDecl(Reader.GetType(Record[Idx++]).getTypePtrOrNull());
Chris Lattner487412d2009-04-27 05:27:42 +0000447 ID->setSuperClass(cast_or_null<ObjCInterfaceDecl>
448 (Reader.GetDecl(Record[Idx++])));
Ted Kremenek0ef508d2010-09-01 01:21:15 +0000449
450 // Read the directly referenced protocols and their SourceLocations.
Chris Lattner487412d2009-04-27 05:27:42 +0000451 unsigned NumProtocols = Record[Idx++];
452 llvm::SmallVector<ObjCProtocolDecl *, 16> Protocols;
453 Protocols.reserve(NumProtocols);
454 for (unsigned I = 0; I != NumProtocols; ++I)
455 Protocols.push_back(cast<ObjCProtocolDecl>(Reader.GetDecl(Record[Idx++])));
Douglas Gregor002b6712010-01-16 15:02:53 +0000456 llvm::SmallVector<SourceLocation, 16> ProtoLocs;
457 ProtoLocs.reserve(NumProtocols);
458 for (unsigned I = 0; I != NumProtocols; ++I)
Sebastian Redl2c373b92010-10-05 15:59:54 +0000459 ProtoLocs.push_back(ReadSourceLocation(Record, Idx));
Douglas Gregor002b6712010-01-16 15:02:53 +0000460 ID->setProtocolList(Protocols.data(), NumProtocols, ProtoLocs.data(),
461 *Reader.getContext());
Ted Kremenek0ef508d2010-09-01 01:21:15 +0000462
463 // Read the transitive closure of protocols referenced by this class.
464 NumProtocols = Record[Idx++];
465 Protocols.clear();
466 Protocols.reserve(NumProtocols);
467 for (unsigned I = 0; I != NumProtocols; ++I)
468 Protocols.push_back(cast<ObjCProtocolDecl>(Reader.GetDecl(Record[Idx++])));
469 ID->AllReferencedProtocols.set(Protocols.data(), NumProtocols,
470 *Reader.getContext());
471
472 // Read the ivars.
Chris Lattner487412d2009-04-27 05:27:42 +0000473 unsigned NumIvars = Record[Idx++];
474 llvm::SmallVector<ObjCIvarDecl *, 16> IVars;
475 IVars.reserve(NumIvars);
476 for (unsigned I = 0; I != NumIvars; ++I)
477 IVars.push_back(cast<ObjCIvarDecl>(Reader.GetDecl(Record[Idx++])));
Chris Lattner487412d2009-04-27 05:27:42 +0000478 ID->setCategoryList(
479 cast_or_null<ObjCCategoryDecl>(Reader.GetDecl(Record[Idx++])));
Fariborz Jahaniana50b3a22010-08-20 21:21:08 +0000480 // We will rebuild this list lazily.
481 ID->setIvarList(0);
Douglas Gregor1c283312010-08-11 12:19:30 +0000482 ID->setForwardDecl(Record[Idx++]);
483 ID->setImplicitInterfaceDecl(Record[Idx++]);
Sebastian Redl2c373b92010-10-05 15:59:54 +0000484 ID->setClassLoc(ReadSourceLocation(Record, Idx));
485 ID->setSuperClassLoc(ReadSourceLocation(Record, Idx));
486 ID->setLocEnd(ReadSourceLocation(Record, Idx));
Chris Lattner487412d2009-04-27 05:27:42 +0000487}
488
Sebastian Redlb3298c32010-08-18 23:56:48 +0000489void ASTDeclReader::VisitObjCIvarDecl(ObjCIvarDecl *IVD) {
Chris Lattner487412d2009-04-27 05:27:42 +0000490 VisitFieldDecl(IVD);
491 IVD->setAccessControl((ObjCIvarDecl::AccessControl)Record[Idx++]);
Fariborz Jahaniana50b3a22010-08-20 21:21:08 +0000492 // This field will be built lazily.
493 IVD->setNextIvar(0);
Fariborz Jahanianaea8e1e2010-07-17 18:35:47 +0000494 bool synth = Record[Idx++];
495 IVD->setSynthesize(synth);
Chris Lattner487412d2009-04-27 05:27:42 +0000496}
497
Sebastian Redlb3298c32010-08-18 23:56:48 +0000498void ASTDeclReader::VisitObjCProtocolDecl(ObjCProtocolDecl *PD) {
Chris Lattner487412d2009-04-27 05:27:42 +0000499 VisitObjCContainerDecl(PD);
500 PD->setForwardDecl(Record[Idx++]);
Sebastian Redl2c373b92010-10-05 15:59:54 +0000501 PD->setLocEnd(ReadSourceLocation(Record, Idx));
Chris Lattner487412d2009-04-27 05:27:42 +0000502 unsigned NumProtoRefs = Record[Idx++];
503 llvm::SmallVector<ObjCProtocolDecl *, 16> ProtoRefs;
504 ProtoRefs.reserve(NumProtoRefs);
505 for (unsigned I = 0; I != NumProtoRefs; ++I)
506 ProtoRefs.push_back(cast<ObjCProtocolDecl>(Reader.GetDecl(Record[Idx++])));
Douglas Gregor002b6712010-01-16 15:02:53 +0000507 llvm::SmallVector<SourceLocation, 16> ProtoLocs;
508 ProtoLocs.reserve(NumProtoRefs);
509 for (unsigned I = 0; I != NumProtoRefs; ++I)
Sebastian Redl2c373b92010-10-05 15:59:54 +0000510 ProtoLocs.push_back(ReadSourceLocation(Record, Idx));
Douglas Gregor002b6712010-01-16 15:02:53 +0000511 PD->setProtocolList(ProtoRefs.data(), NumProtoRefs, ProtoLocs.data(),
512 *Reader.getContext());
Chris Lattner487412d2009-04-27 05:27:42 +0000513}
514
Sebastian Redlb3298c32010-08-18 23:56:48 +0000515void ASTDeclReader::VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *FD) {
Chris Lattner487412d2009-04-27 05:27:42 +0000516 VisitFieldDecl(FD);
517}
518
Sebastian Redlb3298c32010-08-18 23:56:48 +0000519void ASTDeclReader::VisitObjCClassDecl(ObjCClassDecl *CD) {
Chris Lattner487412d2009-04-27 05:27:42 +0000520 VisitDecl(CD);
521 unsigned NumClassRefs = Record[Idx++];
522 llvm::SmallVector<ObjCInterfaceDecl *, 16> ClassRefs;
523 ClassRefs.reserve(NumClassRefs);
524 for (unsigned I = 0; I != NumClassRefs; ++I)
525 ClassRefs.push_back(cast<ObjCInterfaceDecl>(Reader.GetDecl(Record[Idx++])));
Ted Kremenek9b124e12009-11-18 00:28:11 +0000526 llvm::SmallVector<SourceLocation, 16> SLocs;
527 SLocs.reserve(NumClassRefs);
528 for (unsigned I = 0; I != NumClassRefs; ++I)
Sebastian Redl2c373b92010-10-05 15:59:54 +0000529 SLocs.push_back(ReadSourceLocation(Record, Idx));
Ted Kremenek9b124e12009-11-18 00:28:11 +0000530 CD->setClassList(*Reader.getContext(), ClassRefs.data(), SLocs.data(),
531 NumClassRefs);
Chris Lattner487412d2009-04-27 05:27:42 +0000532}
533
Sebastian Redlb3298c32010-08-18 23:56:48 +0000534void ASTDeclReader::VisitObjCForwardProtocolDecl(ObjCForwardProtocolDecl *FPD) {
Chris Lattner487412d2009-04-27 05:27:42 +0000535 VisitDecl(FPD);
536 unsigned NumProtoRefs = Record[Idx++];
537 llvm::SmallVector<ObjCProtocolDecl *, 16> ProtoRefs;
538 ProtoRefs.reserve(NumProtoRefs);
539 for (unsigned I = 0; I != NumProtoRefs; ++I)
540 ProtoRefs.push_back(cast<ObjCProtocolDecl>(Reader.GetDecl(Record[Idx++])));
Douglas Gregor002b6712010-01-16 15:02:53 +0000541 llvm::SmallVector<SourceLocation, 16> ProtoLocs;
542 ProtoLocs.reserve(NumProtoRefs);
543 for (unsigned I = 0; I != NumProtoRefs; ++I)
Sebastian Redl2c373b92010-10-05 15:59:54 +0000544 ProtoLocs.push_back(ReadSourceLocation(Record, Idx));
Douglas Gregor002b6712010-01-16 15:02:53 +0000545 FPD->setProtocolList(ProtoRefs.data(), NumProtoRefs, ProtoLocs.data(),
546 *Reader.getContext());
Chris Lattner487412d2009-04-27 05:27:42 +0000547}
548
Sebastian Redlb3298c32010-08-18 23:56:48 +0000549void ASTDeclReader::VisitObjCCategoryDecl(ObjCCategoryDecl *CD) {
Chris Lattner487412d2009-04-27 05:27:42 +0000550 VisitObjCContainerDecl(CD);
551 CD->setClassInterface(cast<ObjCInterfaceDecl>(Reader.GetDecl(Record[Idx++])));
552 unsigned NumProtoRefs = Record[Idx++];
553 llvm::SmallVector<ObjCProtocolDecl *, 16> ProtoRefs;
554 ProtoRefs.reserve(NumProtoRefs);
555 for (unsigned I = 0; I != NumProtoRefs; ++I)
556 ProtoRefs.push_back(cast<ObjCProtocolDecl>(Reader.GetDecl(Record[Idx++])));
Douglas Gregor002b6712010-01-16 15:02:53 +0000557 llvm::SmallVector<SourceLocation, 16> ProtoLocs;
558 ProtoLocs.reserve(NumProtoRefs);
559 for (unsigned I = 0; I != NumProtoRefs; ++I)
Sebastian Redl2c373b92010-10-05 15:59:54 +0000560 ProtoLocs.push_back(ReadSourceLocation(Record, Idx));
Douglas Gregor002b6712010-01-16 15:02:53 +0000561 CD->setProtocolList(ProtoRefs.data(), NumProtoRefs, ProtoLocs.data(),
562 *Reader.getContext());
Chris Lattner487412d2009-04-27 05:27:42 +0000563 CD->setNextClassCategory(cast_or_null<ObjCCategoryDecl>(Reader.GetDecl(Record[Idx++])));
Fariborz Jahanianbf9294f2010-08-23 18:51:39 +0000564 CD->setHasSynthBitfield(Record[Idx++]);
Sebastian Redl2c373b92010-10-05 15:59:54 +0000565 CD->setAtLoc(ReadSourceLocation(Record, Idx));
566 CD->setCategoryNameLoc(ReadSourceLocation(Record, Idx));
Chris Lattner487412d2009-04-27 05:27:42 +0000567}
568
Sebastian Redlb3298c32010-08-18 23:56:48 +0000569void ASTDeclReader::VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *CAD) {
Chris Lattner487412d2009-04-27 05:27:42 +0000570 VisitNamedDecl(CAD);
571 CAD->setClassInterface(cast<ObjCInterfaceDecl>(Reader.GetDecl(Record[Idx++])));
572}
573
Sebastian Redlb3298c32010-08-18 23:56:48 +0000574void ASTDeclReader::VisitObjCPropertyDecl(ObjCPropertyDecl *D) {
Chris Lattner487412d2009-04-27 05:27:42 +0000575 VisitNamedDecl(D);
Sebastian Redl2c373b92010-10-05 15:59:54 +0000576 D->setAtLoc(ReadSourceLocation(Record, Idx));
577 D->setType(GetTypeSourceInfo(Record, Idx));
Chris Lattner487412d2009-04-27 05:27:42 +0000578 // FIXME: stable encoding
579 D->setPropertyAttributes(
580 (ObjCPropertyDecl::PropertyAttributeKind)Record[Idx++]);
Fariborz Jahanian3bf0ded2010-06-22 23:20:40 +0000581 D->setPropertyAttributesAsWritten(
582 (ObjCPropertyDecl::PropertyAttributeKind)Record[Idx++]);
Chris Lattner487412d2009-04-27 05:27:42 +0000583 // FIXME: stable encoding
584 D->setPropertyImplementation(
585 (ObjCPropertyDecl::PropertyControl)Record[Idx++]);
586 D->setGetterName(Reader.ReadDeclarationName(Record, Idx).getObjCSelector());
587 D->setSetterName(Reader.ReadDeclarationName(Record, Idx).getObjCSelector());
588 D->setGetterMethodDecl(
589 cast_or_null<ObjCMethodDecl>(Reader.GetDecl(Record[Idx++])));
590 D->setSetterMethodDecl(
591 cast_or_null<ObjCMethodDecl>(Reader.GetDecl(Record[Idx++])));
592 D->setPropertyIvarDecl(
593 cast_or_null<ObjCIvarDecl>(Reader.GetDecl(Record[Idx++])));
594}
595
Sebastian Redlb3298c32010-08-18 23:56:48 +0000596void ASTDeclReader::VisitObjCImplDecl(ObjCImplDecl *D) {
Argyrios Kyrtzidis067c4072009-07-27 19:04:32 +0000597 VisitObjCContainerDecl(D);
Chris Lattner487412d2009-04-27 05:27:42 +0000598 D->setClassInterface(
599 cast_or_null<ObjCInterfaceDecl>(Reader.GetDecl(Record[Idx++])));
Chris Lattner487412d2009-04-27 05:27:42 +0000600}
601
Sebastian Redlb3298c32010-08-18 23:56:48 +0000602void ASTDeclReader::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
Chris Lattner487412d2009-04-27 05:27:42 +0000603 VisitObjCImplDecl(D);
604 D->setIdentifier(Reader.GetIdentifierInfo(Record, Idx));
605}
606
Sebastian Redlb3298c32010-08-18 23:56:48 +0000607void ASTDeclReader::VisitObjCImplementationDecl(ObjCImplementationDecl *D) {
Chris Lattner487412d2009-04-27 05:27:42 +0000608 VisitObjCImplDecl(D);
609 D->setSuperClass(
610 cast_or_null<ObjCInterfaceDecl>(Reader.GetDecl(Record[Idx++])));
Argyrios Kyrtzidis13257c52010-08-09 10:54:20 +0000611 llvm::tie(D->IvarInitializers, D->NumIvarInitializers)
Alexis Hunt1d792652011-01-08 20:30:50 +0000612 = Reader.ReadCXXCtorInitializers(F, Record, Idx);
Fariborz Jahanianbf9294f2010-08-23 18:51:39 +0000613 D->setHasSynthBitfield(Record[Idx++]);
Chris Lattner487412d2009-04-27 05:27:42 +0000614}
615
616
Sebastian Redlb3298c32010-08-18 23:56:48 +0000617void ASTDeclReader::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) {
Chris Lattner487412d2009-04-27 05:27:42 +0000618 VisitDecl(D);
Sebastian Redl2c373b92010-10-05 15:59:54 +0000619 D->setAtLoc(ReadSourceLocation(Record, Idx));
Chris Lattner487412d2009-04-27 05:27:42 +0000620 D->setPropertyDecl(
621 cast_or_null<ObjCPropertyDecl>(Reader.GetDecl(Record[Idx++])));
Douglas Gregorb1b71e52010-11-17 01:03:52 +0000622 D->PropertyIvarDecl =
623 cast_or_null<ObjCIvarDecl>(Reader.GetDecl(Record[Idx++]));
624 D->IvarLoc = ReadSourceLocation(Record, Idx);
Sebastian Redl2c373b92010-10-05 15:59:54 +0000625 D->setGetterCXXConstructor(Reader.ReadExpr(F));
626 D->setSetterCXXAssignment(Reader.ReadExpr(F));
Chris Lattner487412d2009-04-27 05:27:42 +0000627}
628
Sebastian Redlb3298c32010-08-18 23:56:48 +0000629void ASTDeclReader::VisitFieldDecl(FieldDecl *FD) {
Argyrios Kyrtzidis560ac972009-08-19 01:28:35 +0000630 VisitDeclaratorDecl(FD);
Chris Lattner487412d2009-04-27 05:27:42 +0000631 FD->setMutable(Record[Idx++]);
632 if (Record[Idx++])
Sebastian Redl2c373b92010-10-05 15:59:54 +0000633 FD->setBitWidth(Reader.ReadExpr(F));
Argyrios Kyrtzidis6685e8a2010-07-04 21:44:35 +0000634 if (!FD->getDeclName()) {
635 FieldDecl *Tmpl = cast_or_null<FieldDecl>(Reader.GetDecl(Record[Idx++]));
636 if (Tmpl)
637 Reader.getContext()->setInstantiatedFromUnnamedFieldDecl(FD, Tmpl);
638 }
Chris Lattner487412d2009-04-27 05:27:42 +0000639}
640
Francois Pichet783dd6e2010-11-21 06:08:52 +0000641void ASTDeclReader::VisitIndirectFieldDecl(IndirectFieldDecl *FD) {
642 VisitValueDecl(FD);
643
644 FD->ChainingSize = Record[Idx++];
645 assert(FD->ChainingSize >= 2 && "Anonymous chaining must be >= 2");
646 FD->Chaining = new (*Reader.getContext())NamedDecl*[FD->ChainingSize];
647
648 for (unsigned I = 0; I != FD->ChainingSize; ++I)
649 FD->Chaining[I] = cast<NamedDecl>(Reader.GetDecl(Record[Idx++]));
650}
651
Sebastian Redlb3298c32010-08-18 23:56:48 +0000652void ASTDeclReader::VisitVarDecl(VarDecl *VD) {
Argyrios Kyrtzidis560ac972009-08-19 01:28:35 +0000653 VisitDeclaratorDecl(VD);
Argyrios Kyrtzidisf4bc0d82010-09-08 19:31:22 +0000654 VisitRedeclarable(VD);
Douglas Gregorbf62d642010-12-06 18:36:25 +0000655 VD->SClass = (StorageClass)Record[Idx++];
John McCall8e7d6562010-08-26 03:08:43 +0000656 VD->setStorageClassAsWritten((StorageClass)Record[Idx++]);
Chris Lattner487412d2009-04-27 05:27:42 +0000657 VD->setThreadSpecified(Record[Idx++]);
658 VD->setCXXDirectInitializer(Record[Idx++]);
Douglas Gregor3f324d562010-05-03 18:51:14 +0000659 VD->setExceptionVariable(Record[Idx++]);
Douglas Gregor6fd1b182010-05-15 06:01:05 +0000660 VD->setNRVOVariable(Record[Idx++]);
Chris Lattner487412d2009-04-27 05:27:42 +0000661 if (Record[Idx++])
Sebastian Redl2c373b92010-10-05 15:59:54 +0000662 VD->setInit(Reader.ReadExpr(F));
Argyrios Kyrtzidiscdb8b3f2010-07-04 21:44:00 +0000663
664 if (Record[Idx++]) { // HasMemberSpecializationInfo.
665 VarDecl *Tmpl = cast<VarDecl>(Reader.GetDecl(Record[Idx++]));
666 TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++];
Sebastian Redl2c373b92010-10-05 15:59:54 +0000667 SourceLocation POI = ReadSourceLocation(Record, Idx);
Argyrios Kyrtzidiscdb8b3f2010-07-04 21:44:00 +0000668 Reader.getContext()->setInstantiatedFromStaticDataMember(VD, Tmpl, TSK,POI);
669 }
Chris Lattner487412d2009-04-27 05:27:42 +0000670}
671
Sebastian Redlb3298c32010-08-18 23:56:48 +0000672void ASTDeclReader::VisitImplicitParamDecl(ImplicitParamDecl *PD) {
Chris Lattner487412d2009-04-27 05:27:42 +0000673 VisitVarDecl(PD);
674}
675
Sebastian Redlb3298c32010-08-18 23:56:48 +0000676void ASTDeclReader::VisitParmVarDecl(ParmVarDecl *PD) {
Chris Lattner487412d2009-04-27 05:27:42 +0000677 VisitVarDecl(PD);
678 PD->setObjCDeclQualifier((Decl::ObjCDeclQualifier)Record[Idx++]);
John McCallf3cd6652010-03-12 18:31:32 +0000679 PD->setHasInheritedDefaultArg(Record[Idx++]);
Argyrios Kyrtzidisccde6a02010-07-04 21:44:07 +0000680 if (Record[Idx++]) // hasUninstantiatedDefaultArg.
Sebastian Redl2c373b92010-10-05 15:59:54 +0000681 PD->setUninstantiatedDefaultArg(Reader.ReadExpr(F));
Chris Lattner487412d2009-04-27 05:27:42 +0000682}
683
Sebastian Redlb3298c32010-08-18 23:56:48 +0000684void ASTDeclReader::VisitFileScopeAsmDecl(FileScopeAsmDecl *AD) {
Chris Lattner487412d2009-04-27 05:27:42 +0000685 VisitDecl(AD);
Sebastian Redl2c373b92010-10-05 15:59:54 +0000686 AD->setAsmString(cast<StringLiteral>(Reader.ReadExpr(F)));
Chris Lattner487412d2009-04-27 05:27:42 +0000687}
688
Sebastian Redlb3298c32010-08-18 23:56:48 +0000689void ASTDeclReader::VisitBlockDecl(BlockDecl *BD) {
Chris Lattner487412d2009-04-27 05:27:42 +0000690 VisitDecl(BD);
Sebastian Redl2c373b92010-10-05 15:59:54 +0000691 BD->setBody(cast_or_null<CompoundStmt>(Reader.ReadStmt(F)));
692 BD->setSignatureAsWritten(GetTypeSourceInfo(Record, Idx));
Chris Lattner487412d2009-04-27 05:27:42 +0000693 unsigned NumParams = Record[Idx++];
694 llvm::SmallVector<ParmVarDecl *, 16> Params;
695 Params.reserve(NumParams);
696 for (unsigned I = 0; I != NumParams; ++I)
697 Params.push_back(cast<ParmVarDecl>(Reader.GetDecl(Record[Idx++])));
Douglas Gregord5058122010-02-11 01:19:42 +0000698 BD->setParams(Params.data(), NumParams);
John McCallc63de662011-02-02 13:00:07 +0000699
700 bool capturesCXXThis = Record[Idx++];
701 unsigned numCapturedDecls = Record[Idx++];
702 llvm::SmallVector<VarDecl*, 16> capturedDecls;
703 capturedDecls.reserve(numCapturedDecls);
704 for (unsigned i = 0; i != numCapturedDecls; ++i)
705 capturedDecls.push_back(cast<VarDecl>(Reader.GetDecl(Record[Idx++])));
706 BD->setCapturedDecls(*Reader.getContext(), capturedDecls.begin(),
707 capturedDecls.end(), capturesCXXThis);
Chris Lattner487412d2009-04-27 05:27:42 +0000708}
709
Sebastian Redlb3298c32010-08-18 23:56:48 +0000710void ASTDeclReader::VisitLinkageSpecDecl(LinkageSpecDecl *D) {
Chris Lattnerca025db2010-05-07 21:43:38 +0000711 VisitDecl(D);
712 D->setLanguage((LinkageSpecDecl::LanguageIDs)Record[Idx++]);
713 D->setHasBraces(Record[Idx++]);
714}
715
Sebastian Redlb3298c32010-08-18 23:56:48 +0000716void ASTDeclReader::VisitNamespaceDecl(NamespaceDecl *D) {
Chris Lattnerca025db2010-05-07 21:43:38 +0000717 VisitNamedDecl(D);
Douglas Gregor44e5c1f2010-10-05 20:41:58 +0000718 D->IsInline = Record[Idx++];
Douglas Gregor417e87c2010-10-27 19:49:05 +0000719 D->LBracLoc = ReadSourceLocation(Record, Idx);
720 D->RBracLoc = ReadSourceLocation(Record, Idx);
721 D->NextNamespace = Record[Idx++];
Chris Lattnerca025db2010-05-07 21:43:38 +0000722
Chris Lattnerca025db2010-05-07 21:43:38 +0000723 bool IsOriginal = Record[Idx++];
Argyrios Kyrtzidisdae2a162010-07-03 07:57:53 +0000724 D->OrigOrAnonNamespace.setInt(IsOriginal);
725 D->OrigOrAnonNamespace.setPointer(
Chris Lattnerca025db2010-05-07 21:43:38 +0000726 cast_or_null<NamespaceDecl>(Reader.GetDecl(Record[Idx++])));
727}
728
Sebastian Redlb3298c32010-08-18 23:56:48 +0000729void ASTDeclReader::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) {
Chris Lattnerca025db2010-05-07 21:43:38 +0000730 VisitNamedDecl(D);
Sebastian Redl2c373b92010-10-05 15:59:54 +0000731 D->NamespaceLoc = ReadSourceLocation(Record, Idx);
732 D->setQualifierRange(ReadSourceRange(Record, Idx));
Chris Lattnerca025db2010-05-07 21:43:38 +0000733 D->setQualifier(Reader.ReadNestedNameSpecifier(Record, Idx));
Sebastian Redl2c373b92010-10-05 15:59:54 +0000734 D->IdentLoc = ReadSourceLocation(Record, Idx);
Douglas Gregorf9e43ce2010-09-01 00:08:19 +0000735 D->Namespace = cast<NamedDecl>(Reader.GetDecl(Record[Idx++]));
Chris Lattnerca025db2010-05-07 21:43:38 +0000736}
737
Sebastian Redlb3298c32010-08-18 23:56:48 +0000738void ASTDeclReader::VisitUsingDecl(UsingDecl *D) {
Chris Lattnerca025db2010-05-07 21:43:38 +0000739 VisitNamedDecl(D);
Sebastian Redl2c373b92010-10-05 15:59:54 +0000740 D->setUsingLocation(ReadSourceLocation(Record, Idx));
741 D->setNestedNameRange(ReadSourceRange(Record, Idx));
Chris Lattnerca025db2010-05-07 21:43:38 +0000742 D->setTargetNestedNameDecl(Reader.ReadNestedNameSpecifier(Record, Idx));
Argyrios Kyrtzidis434383d2010-10-15 18:21:24 +0000743 ReadDeclarationNameLoc(D->DNLoc, D->getDeclName(), Record, Idx);
Argyrios Kyrtzidis2703beb2010-11-10 05:40:41 +0000744 D->FirstUsingShadow = cast_or_null<UsingShadowDecl>(Reader.GetDecl(Record[Idx++]));
Chris Lattnerca025db2010-05-07 21:43:38 +0000745 D->setTypeName(Record[Idx++]);
Argyrios Kyrtzidis6685e8a2010-07-04 21:44:35 +0000746 NamedDecl *Pattern = cast_or_null<NamedDecl>(Reader.GetDecl(Record[Idx++]));
747 if (Pattern)
748 Reader.getContext()->setInstantiatedFromUsingDecl(D, Pattern);
Chris Lattnerca025db2010-05-07 21:43:38 +0000749}
750
Sebastian Redlb3298c32010-08-18 23:56:48 +0000751void ASTDeclReader::VisitUsingShadowDecl(UsingShadowDecl *D) {
Chris Lattnerca025db2010-05-07 21:43:38 +0000752 VisitNamedDecl(D);
753 D->setTargetDecl(cast<NamedDecl>(Reader.GetDecl(Record[Idx++])));
Argyrios Kyrtzidis2703beb2010-11-10 05:40:41 +0000754 D->UsingOrNextShadow = cast_or_null<NamedDecl>(Reader.GetDecl(Record[Idx++]));
Argyrios Kyrtzidis6685e8a2010-07-04 21:44:35 +0000755 UsingShadowDecl *Pattern
756 = cast_or_null<UsingShadowDecl>(Reader.GetDecl(Record[Idx++]));
757 if (Pattern)
758 Reader.getContext()->setInstantiatedFromUsingShadowDecl(D, Pattern);
Chris Lattnerca025db2010-05-07 21:43:38 +0000759}
760
Sebastian Redlb3298c32010-08-18 23:56:48 +0000761void ASTDeclReader::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
Chris Lattnerca025db2010-05-07 21:43:38 +0000762 VisitNamedDecl(D);
Sebastian Redl2c373b92010-10-05 15:59:54 +0000763 D->UsingLoc = ReadSourceLocation(Record, Idx);
764 D->NamespaceLoc = ReadSourceLocation(Record, Idx);
765 D->QualifierRange = ReadSourceRange(Record, Idx);
Douglas Gregor01a430132010-09-01 03:07:18 +0000766 D->Qualifier = Reader.ReadNestedNameSpecifier(Record, Idx);
767 D->NominatedNamespace = cast<NamedDecl>(Reader.GetDecl(Record[Idx++]));
768 D->CommonAncestor = cast_or_null<DeclContext>(Reader.GetDecl(Record[Idx++]));
Chris Lattnerca025db2010-05-07 21:43:38 +0000769}
770
Sebastian Redlb3298c32010-08-18 23:56:48 +0000771void ASTDeclReader::VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) {
Chris Lattnerca025db2010-05-07 21:43:38 +0000772 VisitValueDecl(D);
Sebastian Redl2c373b92010-10-05 15:59:54 +0000773 D->setTargetNestedNameRange(ReadSourceRange(Record, Idx));
774 D->setUsingLoc(ReadSourceLocation(Record, Idx));
Chris Lattnerca025db2010-05-07 21:43:38 +0000775 D->setTargetNestedNameSpecifier(Reader.ReadNestedNameSpecifier(Record, Idx));
Argyrios Kyrtzidis434383d2010-10-15 18:21:24 +0000776 ReadDeclarationNameLoc(D->DNLoc, D->getDeclName(), Record, Idx);
Chris Lattnerca025db2010-05-07 21:43:38 +0000777}
778
Sebastian Redlb3298c32010-08-18 23:56:48 +0000779void ASTDeclReader::VisitUnresolvedUsingTypenameDecl(
Chris Lattnerca025db2010-05-07 21:43:38 +0000780 UnresolvedUsingTypenameDecl *D) {
781 VisitTypeDecl(D);
Sebastian Redl2c373b92010-10-05 15:59:54 +0000782 D->TargetNestedNameRange = ReadSourceRange(Record, Idx);
783 D->UsingLocation = ReadSourceLocation(Record, Idx);
784 D->TypenameLocation = ReadSourceLocation(Record, Idx);
Douglas Gregora9aa29c2010-09-01 19:52:22 +0000785 D->TargetNestedNameSpecifier = Reader.ReadNestedNameSpecifier(Record, Idx);
Chris Lattnerca025db2010-05-07 21:43:38 +0000786}
787
Argyrios Kyrtzidis8b200a52010-10-24 17:26:27 +0000788void ASTDeclReader::ReadCXXDefinitionData(
Argyrios Kyrtzidiseb39d9a2010-10-24 17:26:40 +0000789 struct CXXRecordDecl::DefinitionData &Data,
790 const RecordData &Record, unsigned &Idx) {
Argyrios Kyrtzidis8b200a52010-10-24 17:26:27 +0000791 Data.UserDeclaredConstructor = Record[Idx++];
792 Data.UserDeclaredCopyConstructor = Record[Idx++];
793 Data.UserDeclaredCopyAssignment = Record[Idx++];
794 Data.UserDeclaredDestructor = Record[Idx++];
795 Data.Aggregate = Record[Idx++];
796 Data.PlainOldData = Record[Idx++];
797 Data.Empty = Record[Idx++];
798 Data.Polymorphic = Record[Idx++];
799 Data.Abstract = Record[Idx++];
800 Data.HasTrivialConstructor = Record[Idx++];
801 Data.HasTrivialCopyConstructor = Record[Idx++];
802 Data.HasTrivialCopyAssignment = Record[Idx++];
803 Data.HasTrivialDestructor = Record[Idx++];
804 Data.ComputedVisibleConversions = Record[Idx++];
805 Data.DeclaredDefaultConstructor = Record[Idx++];
806 Data.DeclaredCopyConstructor = Record[Idx++];
807 Data.DeclaredCopyAssignment = Record[Idx++];
808 Data.DeclaredDestructor = Record[Idx++];
Anders Carlsson703d6e62011-01-22 18:11:02 +0000809
Argyrios Kyrtzidis8b200a52010-10-24 17:26:27 +0000810 Data.NumBases = Record[Idx++];
Douglas Gregord4c5ed02010-10-29 22:39:52 +0000811 if (Data.NumBases)
812 Data.Bases = Reader.GetCXXBaseSpecifiersOffset(Record[Idx++]);
Argyrios Kyrtzidis8b200a52010-10-24 17:26:27 +0000813 Data.NumVBases = Record[Idx++];
Douglas Gregord4c5ed02010-10-29 22:39:52 +0000814 if (Data.NumVBases)
815 Data.VBases = Reader.GetCXXBaseSpecifiersOffset(Record[Idx++]);
816
Argyrios Kyrtzidis8b200a52010-10-24 17:26:27 +0000817 Reader.ReadUnresolvedSet(Data.Conversions, Record, Idx);
818 Reader.ReadUnresolvedSet(Data.VisibleConversions, Record, Idx);
819 assert(Data.Definition && "Data.Definition should be already set!");
820 Data.FirstFriend
821 = cast_or_null<FriendDecl>(Reader.GetDecl(Record[Idx++]));
822}
823
Argyrios Kyrtzidiseb39d9a2010-10-24 17:26:40 +0000824void ASTDeclReader::InitializeCXXDefinitionData(CXXRecordDecl *D,
825 CXXRecordDecl *DefinitionDecl,
826 const RecordData &Record,
827 unsigned &Idx) {
Argyrios Kyrtzidisad5f95c2010-10-24 17:26:31 +0000828 ASTContext &C = *Reader.getContext();
Argyrios Kyrtzidisa41f6602010-10-20 00:11:15 +0000829
Argyrios Kyrtzidisad5f95c2010-10-24 17:26:31 +0000830 if (D == DefinitionDecl) {
831 D->DefinitionData = new (C) struct CXXRecordDecl::DefinitionData(D);
Argyrios Kyrtzidiseb39d9a2010-10-24 17:26:40 +0000832 ReadCXXDefinitionData(*D->DefinitionData, Record, Idx);
Argyrios Kyrtzidisad5f95c2010-10-24 17:26:31 +0000833 // We read the definition info. Check if there are pending forward
834 // references that need to point to this DefinitionData pointer.
835 ASTReader::PendingForwardRefsMap::iterator
836 FindI = Reader.PendingForwardRefs.find(D);
837 if (FindI != Reader.PendingForwardRefs.end()) {
838 ASTReader::ForwardRefs &Refs = FindI->second;
839 for (ASTReader::ForwardRefs::iterator
840 I = Refs.begin(), E = Refs.end(); I != E; ++I)
841 (*I)->DefinitionData = D->DefinitionData;
842#ifndef NDEBUG
843 // We later check whether PendingForwardRefs is empty to make sure all
844 // pending references were linked.
845 Reader.PendingForwardRefs.erase(D);
846#endif
847 }
848 } else if (DefinitionDecl) {
849 if (DefinitionDecl->DefinitionData) {
850 D->DefinitionData = DefinitionDecl->DefinitionData;
851 } else {
852 // The definition is still initializing.
853 Reader.PendingForwardRefs[DefinitionDecl].push_back(D);
854 }
Argyrios Kyrtzidis2c2167a2010-07-02 11:55:32 +0000855 }
Argyrios Kyrtzidiseb39d9a2010-10-24 17:26:40 +0000856}
857
858void ASTDeclReader::VisitCXXRecordDecl(CXXRecordDecl *D) {
859 VisitRecordDecl(D);
860
861 CXXRecordDecl *DefinitionDecl
862 = cast_or_null<CXXRecordDecl>(Reader.GetDecl(Record[Idx++]));
863 InitializeCXXDefinitionData(D, DefinitionDecl, Record, Idx);
864
865 ASTContext &C = *Reader.getContext();
Argyrios Kyrtzidis2c2167a2010-07-02 11:55:32 +0000866
Argyrios Kyrtzidis95c04ca2010-06-19 19:29:09 +0000867 enum CXXRecKind {
868 CXXRecNotTemplate = 0, CXXRecTemplate, CXXRecMemberSpecialization
869 };
870 switch ((CXXRecKind)Record[Idx++]) {
871 default:
Sebastian Redlb3298c32010-08-18 23:56:48 +0000872 assert(false && "Out of sync with ASTDeclWriter::VisitCXXRecordDecl?");
Argyrios Kyrtzidis95c04ca2010-06-19 19:29:09 +0000873 case CXXRecNotTemplate:
874 break;
875 case CXXRecTemplate:
Argyrios Kyrtzidiscaf82482010-09-13 11:45:25 +0000876 D->TemplateOrInstantiation
877 = cast<ClassTemplateDecl>(Reader.GetDecl(Record[Idx++]));
Argyrios Kyrtzidis95c04ca2010-06-19 19:29:09 +0000878 break;
879 case CXXRecMemberSpecialization: {
880 CXXRecordDecl *RD = cast<CXXRecordDecl>(Reader.GetDecl(Record[Idx++]));
881 TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++];
Sebastian Redl2c373b92010-10-05 15:59:54 +0000882 SourceLocation POI = ReadSourceLocation(Record, Idx);
Argyrios Kyrtzidiscaf82482010-09-13 11:45:25 +0000883 MemberSpecializationInfo *MSI = new (C) MemberSpecializationInfo(RD, TSK);
884 MSI->setPointOfInstantiation(POI);
885 D->TemplateOrInstantiation = MSI;
Argyrios Kyrtzidis95c04ca2010-06-19 19:29:09 +0000886 break;
887 }
888 }
Argyrios Kyrtzidis68431412010-10-14 20:14:38 +0000889
890 // Load the key function to avoid deserializing every method so we can
891 // compute it.
892 if (D->IsDefinition) {
893 CXXMethodDecl *Key
894 = cast_or_null<CXXMethodDecl>(Reader.GetDecl(Record[Idx++]));
895 if (Key)
896 C.KeyFunctions[D] = Key;
897 }
Chris Lattnerca025db2010-05-07 21:43:38 +0000898}
899
Sebastian Redlb3298c32010-08-18 23:56:48 +0000900void ASTDeclReader::VisitCXXMethodDecl(CXXMethodDecl *D) {
Chris Lattnerca025db2010-05-07 21:43:38 +0000901 VisitFunctionDecl(D);
Argyrios Kyrtzidis6685e8a2010-07-04 21:44:35 +0000902 unsigned NumOverridenMethods = Record[Idx++];
903 while (NumOverridenMethods--) {
904 CXXMethodDecl *MD = cast<CXXMethodDecl>(Reader.GetDecl(Record[Idx++]));
905 // Avoid invariant checking of CXXMethodDecl::addOverriddenMethod,
906 // MD may be initializing.
907 Reader.getContext()->addOverriddenMethod(D, MD);
908 }
Chris Lattnerca025db2010-05-07 21:43:38 +0000909}
910
Sebastian Redlb3298c32010-08-18 23:56:48 +0000911void ASTDeclReader::VisitCXXConstructorDecl(CXXConstructorDecl *D) {
Chris Lattnerca025db2010-05-07 21:43:38 +0000912 VisitCXXMethodDecl(D);
Argyrios Kyrtzidis33575162010-07-02 15:58:43 +0000913
914 D->IsExplicitSpecified = Record[Idx++];
915 D->ImplicitlyDefined = Record[Idx++];
Alexis Hunt1d792652011-01-08 20:30:50 +0000916 llvm::tie(D->CtorInitializers, D->NumCtorInitializers)
917 = Reader.ReadCXXCtorInitializers(F, Record, Idx);
Chris Lattnerca025db2010-05-07 21:43:38 +0000918}
919
Sebastian Redlb3298c32010-08-18 23:56:48 +0000920void ASTDeclReader::VisitCXXDestructorDecl(CXXDestructorDecl *D) {
Chris Lattnerca025db2010-05-07 21:43:38 +0000921 VisitCXXMethodDecl(D);
Argyrios Kyrtzidis33575162010-07-02 15:58:43 +0000922
923 D->ImplicitlyDefined = Record[Idx++];
924 D->OperatorDelete = cast_or_null<FunctionDecl>(Reader.GetDecl(Record[Idx++]));
Chris Lattnerca025db2010-05-07 21:43:38 +0000925}
926
Sebastian Redlb3298c32010-08-18 23:56:48 +0000927void ASTDeclReader::VisitCXXConversionDecl(CXXConversionDecl *D) {
Chris Lattnerca025db2010-05-07 21:43:38 +0000928 VisitCXXMethodDecl(D);
Argyrios Kyrtzidis33575162010-07-02 15:58:43 +0000929 D->IsExplicitSpecified = Record[Idx++];
Chris Lattnerca025db2010-05-07 21:43:38 +0000930}
931
Sebastian Redlb3298c32010-08-18 23:56:48 +0000932void ASTDeclReader::VisitAccessSpecDecl(AccessSpecDecl *D) {
Abramo Bagnarad7340582010-06-05 05:09:32 +0000933 VisitDecl(D);
Sebastian Redl2c373b92010-10-05 15:59:54 +0000934 D->setColonLoc(ReadSourceLocation(Record, Idx));
Abramo Bagnarad7340582010-06-05 05:09:32 +0000935}
936
Sebastian Redlb3298c32010-08-18 23:56:48 +0000937void ASTDeclReader::VisitFriendDecl(FriendDecl *D) {
Argyrios Kyrtzidisa95d0192010-07-05 10:38:01 +0000938 VisitDecl(D);
Argyrios Kyrtzidis74d28bd2010-06-29 22:47:00 +0000939 if (Record[Idx++])
Sebastian Redl2c373b92010-10-05 15:59:54 +0000940 D->Friend = GetTypeSourceInfo(Record, Idx);
Argyrios Kyrtzidis74d28bd2010-06-29 22:47:00 +0000941 else
942 D->Friend = cast<NamedDecl>(Reader.GetDecl(Record[Idx++]));
Douglas Gregore0fb32c2010-10-27 20:23:41 +0000943 D->NextFriend = Record[Idx++];
John McCall2c2eb122010-10-16 06:59:13 +0000944 D->UnsupportedFriend = (Record[Idx++] != 0);
Sebastian Redl2c373b92010-10-05 15:59:54 +0000945 D->FriendLoc = ReadSourceLocation(Record, Idx);
Argyrios Kyrtzidis74d28bd2010-06-29 22:47:00 +0000946}
947
Sebastian Redlb3298c32010-08-18 23:56:48 +0000948void ASTDeclReader::VisitFriendTemplateDecl(FriendTemplateDecl *D) {
Argyrios Kyrtzidis165b5812010-07-22 16:04:10 +0000949 VisitDecl(D);
950 unsigned NumParams = Record[Idx++];
951 D->NumParams = NumParams;
952 D->Params = new TemplateParameterList*[NumParams];
953 for (unsigned i = 0; i != NumParams; ++i)
Sebastian Redl2c373b92010-10-05 15:59:54 +0000954 D->Params[i] = Reader.ReadTemplateParameterList(F, Record, Idx);
Argyrios Kyrtzidis165b5812010-07-22 16:04:10 +0000955 if (Record[Idx++]) // HasFriendDecl
956 D->Friend = cast<NamedDecl>(Reader.GetDecl(Record[Idx++]));
957 else
Sebastian Redl2c373b92010-10-05 15:59:54 +0000958 D->Friend = GetTypeSourceInfo(Record, Idx);
959 D->FriendLoc = ReadSourceLocation(Record, Idx);
Chris Lattnerca025db2010-05-07 21:43:38 +0000960}
961
Sebastian Redlb3298c32010-08-18 23:56:48 +0000962void ASTDeclReader::VisitTemplateDecl(TemplateDecl *D) {
Argyrios Kyrtzidis95c04ca2010-06-19 19:29:09 +0000963 VisitNamedDecl(D);
964
Argyrios Kyrtzidis9f2d24a2010-07-08 17:12:57 +0000965 NamedDecl *TemplatedDecl
966 = cast_or_null<NamedDecl>(Reader.GetDecl(Record[Idx++]));
Argyrios Kyrtzidis818c5db2010-06-23 13:48:30 +0000967 TemplateParameterList* TemplateParams
Sebastian Redl2c373b92010-10-05 15:59:54 +0000968 = Reader.ReadTemplateParameterList(F, Record, Idx);
Argyrios Kyrtzidis95c04ca2010-06-19 19:29:09 +0000969 D->init(TemplatedDecl, TemplateParams);
Chris Lattnerca025db2010-05-07 21:43:38 +0000970}
971
Sebastian Redlb3298c32010-08-18 23:56:48 +0000972void ASTDeclReader::VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D) {
Argyrios Kyrtzidisf4bc0d82010-09-08 19:31:22 +0000973 // Initialize CommonOrPrev before VisitTemplateDecl so that getCommonPtr()
974 // can be used while this is still initializing.
Argyrios Kyrtzidis95c04ca2010-06-19 19:29:09 +0000975
Argyrios Kyrtzidisf4bc0d82010-09-08 19:31:22 +0000976 assert(D->CommonOrPrev.isNull() && "getCommonPtr was called earlier on this");
Peter Collingbourne91b25b72010-07-29 16:11:51 +0000977 RedeclarableTemplateDecl *PrevDecl =
978 cast_or_null<RedeclarableTemplateDecl>(Reader.GetDecl(Record[Idx++]));
979 assert((PrevDecl == 0 || PrevDecl->getKind() == D->getKind()) &&
980 "PrevDecl kind mismatch");
981 if (PrevDecl)
982 D->CommonOrPrev = PrevDecl;
Argyrios Kyrtzidis95c04ca2010-06-19 19:29:09 +0000983 if (PrevDecl == 0) {
Argyrios Kyrtzidisf4bc0d82010-09-08 19:31:22 +0000984 D->CommonOrPrev = D->newCommon(*Reader.getContext());
Peter Collingbourne91b25b72010-07-29 16:11:51 +0000985 if (RedeclarableTemplateDecl *RTD
986 = cast_or_null<RedeclarableTemplateDecl>(Reader.GetDecl(Record[Idx++]))) {
987 assert(RTD->getKind() == D->getKind() &&
988 "InstantiatedFromMemberTemplate kind mismatch");
989 D->setInstantiatedFromMemberTemplateImpl(RTD);
990 if (Record[Idx++])
991 D->setMemberSpecialization();
992 }
Peter Collingbourne2bf3d242010-07-29 16:12:01 +0000993
994 RedeclarableTemplateDecl *LatestDecl =
995 cast_or_null<RedeclarableTemplateDecl>(Reader.GetDecl(Record[Idx++]));
Argyrios Kyrtzidis839bbac2010-08-03 17:30:10 +0000996
997 // This decl is a first one and the latest declaration that it points to is
Sebastian Redld44cd6a2010-08-18 23:57:06 +0000998 // in the same AST file. However, if this actually needs to point to a
999 // redeclaration in another AST file, we need to update it by checking
Argyrios Kyrtzidis839bbac2010-08-03 17:30:10 +00001000 // the FirstLatestDeclIDs map which tracks this kind of decls.
1001 assert(Reader.GetDecl(ThisDeclID) == D && "Invalid ThisDeclID ?");
Sebastian Redl2c499f62010-08-18 23:56:43 +00001002 ASTReader::FirstLatestDeclIDMap::iterator I
Argyrios Kyrtzidis839bbac2010-08-03 17:30:10 +00001003 = Reader.FirstLatestDeclIDs.find(ThisDeclID);
1004 if (I != Reader.FirstLatestDeclIDs.end()) {
1005 Decl *NewLatest = Reader.GetDecl(I->second);
1006 assert((LatestDecl->getLocation().isInvalid() ||
1007 NewLatest->getLocation().isInvalid() ||
Argyrios Kyrtzidis54b88e72010-10-20 23:48:40 +00001008 !Reader.SourceMgr.isBeforeInTranslationUnit(
1009 NewLatest->getLocation(),
1010 LatestDecl->getLocation())) &&
Argyrios Kyrtzidis839bbac2010-08-03 17:30:10 +00001011 "The new latest is supposed to come after the previous latest");
1012 LatestDecl = cast<RedeclarableTemplateDecl>(NewLatest);
1013 }
1014
Peter Collingbourne2bf3d242010-07-29 16:12:01 +00001015 assert(LatestDecl->getKind() == D->getKind() && "Latest kind mismatch");
1016 D->getCommonPtr()->Latest = LatestDecl;
Peter Collingbourne91b25b72010-07-29 16:11:51 +00001017 }
Argyrios Kyrtzidisf4bc0d82010-09-08 19:31:22 +00001018
1019 VisitTemplateDecl(D);
1020 D->IdentifierNamespace = Record[Idx++];
Peter Collingbourne91b25b72010-07-29 16:11:51 +00001021}
1022
Sebastian Redlb3298c32010-08-18 23:56:48 +00001023void ASTDeclReader::VisitClassTemplateDecl(ClassTemplateDecl *D) {
Peter Collingbourne91b25b72010-07-29 16:11:51 +00001024 VisitRedeclarableTemplateDecl(D);
1025
1026 if (D->getPreviousDeclaration() == 0) {
Douglas Gregor7e8c4e02010-10-27 22:21:36 +00001027 // This ClassTemplateDecl owns a CommonPtr; read it to keep track of all of
1028 // the specializations.
1029 llvm::SmallVector<serialization::DeclID, 2> SpecIDs;
1030 SpecIDs.push_back(0);
1031
1032 // Specializations.
1033 unsigned Size = Record[Idx++];
1034 SpecIDs[0] += Size;
1035 SpecIDs.append(Record.begin() + Idx, Record.begin() + Idx + Size);
1036 Idx += Size;
Argyrios Kyrtzidis95c04ca2010-06-19 19:29:09 +00001037
Douglas Gregor7e8c4e02010-10-27 22:21:36 +00001038 // Partial specializations.
1039 Size = Record[Idx++];
1040 SpecIDs[0] += Size;
1041 SpecIDs.append(Record.begin() + Idx, Record.begin() + Idx + Size);
1042 Idx += Size;
Argyrios Kyrtzidis95c04ca2010-06-19 19:29:09 +00001043
Douglas Gregor7e8c4e02010-10-27 22:21:36 +00001044 if (SpecIDs[0]) {
1045 typedef serialization::DeclID DeclID;
1046
1047 ClassTemplateDecl::Common *CommonPtr = D->getCommonPtr();
1048 CommonPtr->LazySpecializations
1049 = new (*Reader.getContext()) DeclID [SpecIDs.size()];
1050 memcpy(CommonPtr->LazySpecializations, SpecIDs.data(),
1051 SpecIDs.size() * sizeof(DeclID));
1052 }
1053
Argyrios Kyrtzidis95c04ca2010-06-19 19:29:09 +00001054 // InjectedClassNameType is computed.
Argyrios Kyrtzidis95c04ca2010-06-19 19:29:09 +00001055 }
Chris Lattnerca025db2010-05-07 21:43:38 +00001056}
1057
Sebastian Redlb3298c32010-08-18 23:56:48 +00001058void ASTDeclReader::VisitClassTemplateSpecializationDecl(
Chris Lattnerca025db2010-05-07 21:43:38 +00001059 ClassTemplateSpecializationDecl *D) {
Argyrios Kyrtzidis818c5db2010-06-23 13:48:30 +00001060 VisitCXXRecordDecl(D);
Argyrios Kyrtzidisb4c659b2010-09-13 11:45:32 +00001061
1062 ASTContext &C = *Reader.getContext();
Argyrios Kyrtzidis818c5db2010-06-23 13:48:30 +00001063 if (Decl *InstD = Reader.GetDecl(Record[Idx++])) {
1064 if (ClassTemplateDecl *CTD = dyn_cast<ClassTemplateDecl>(InstD)) {
Argyrios Kyrtzidisb4c659b2010-09-13 11:45:32 +00001065 D->SpecializedTemplate = CTD;
Argyrios Kyrtzidis818c5db2010-06-23 13:48:30 +00001066 } else {
1067 llvm::SmallVector<TemplateArgument, 8> TemplArgs;
Sebastian Redl2c373b92010-10-05 15:59:54 +00001068 Reader.ReadTemplateArgumentList(TemplArgs, F, Record, Idx);
Argyrios Kyrtzidisb4c659b2010-09-13 11:45:32 +00001069 TemplateArgumentList *ArgList
Douglas Gregor1ccc8412010-11-07 23:05:16 +00001070 = TemplateArgumentList::CreateCopy(C, TemplArgs.data(),
1071 TemplArgs.size());
Argyrios Kyrtzidisb4c659b2010-09-13 11:45:32 +00001072 ClassTemplateSpecializationDecl::SpecializedPartialSpecialization *PS
1073 = new (C) ClassTemplateSpecializationDecl::
1074 SpecializedPartialSpecialization();
1075 PS->PartialSpecialization
1076 = cast<ClassTemplatePartialSpecializationDecl>(InstD);
1077 PS->TemplateArgs = ArgList;
1078 D->SpecializedTemplate = PS;
Argyrios Kyrtzidis818c5db2010-06-23 13:48:30 +00001079 }
1080 }
1081
1082 // Explicit info.
Sebastian Redl2c373b92010-10-05 15:59:54 +00001083 if (TypeSourceInfo *TyInfo = GetTypeSourceInfo(Record, Idx)) {
Argyrios Kyrtzidisb4c659b2010-09-13 11:45:32 +00001084 ClassTemplateSpecializationDecl::ExplicitSpecializationInfo *ExplicitInfo
1085 = new (C) ClassTemplateSpecializationDecl::ExplicitSpecializationInfo;
1086 ExplicitInfo->TypeAsWritten = TyInfo;
Sebastian Redl2c373b92010-10-05 15:59:54 +00001087 ExplicitInfo->ExternLoc = ReadSourceLocation(Record, Idx);
1088 ExplicitInfo->TemplateKeywordLoc = ReadSourceLocation(Record, Idx);
Argyrios Kyrtzidisb4c659b2010-09-13 11:45:32 +00001089 D->ExplicitInfo = ExplicitInfo;
Argyrios Kyrtzidis818c5db2010-06-23 13:48:30 +00001090 }
1091
1092 llvm::SmallVector<TemplateArgument, 8> TemplArgs;
Sebastian Redl2c373b92010-10-05 15:59:54 +00001093 Reader.ReadTemplateArgumentList(TemplArgs, F, Record, Idx);
Douglas Gregor1ccc8412010-11-07 23:05:16 +00001094 D->TemplateArgs = TemplateArgumentList::CreateCopy(C, TemplArgs.data(),
1095 TemplArgs.size());
Sebastian Redl2c373b92010-10-05 15:59:54 +00001096 D->PointOfInstantiation = ReadSourceLocation(Record, Idx);
Argyrios Kyrtzidisb4c659b2010-09-13 11:45:32 +00001097 D->SpecializationKind = (TemplateSpecializationKind)Record[Idx++];
Douglas Gregor7e8c4e02010-10-27 22:21:36 +00001098
Argyrios Kyrtzidisc1624e92010-07-20 13:59:40 +00001099 if (D->isCanonicalDecl()) { // It's kept in the folding set.
Argyrios Kyrtzidis87040572010-07-09 21:11:43 +00001100 ClassTemplateDecl *CanonPattern
1101 = cast<ClassTemplateDecl>(Reader.GetDecl(Record[Idx++]));
1102 if (ClassTemplatePartialSpecializationDecl *Partial
Douglas Gregor7e8c4e02010-10-27 22:21:36 +00001103 = dyn_cast<ClassTemplatePartialSpecializationDecl>(D)) {
1104 CanonPattern->getCommonPtr()->PartialSpecializations.InsertNode(Partial);
Argyrios Kyrtzidis87040572010-07-09 21:11:43 +00001105 } else {
Douglas Gregor7e8c4e02010-10-27 22:21:36 +00001106 CanonPattern->getCommonPtr()->Specializations.InsertNode(D);
Argyrios Kyrtzidis87040572010-07-09 21:11:43 +00001107 }
1108 }
Chris Lattnerca025db2010-05-07 21:43:38 +00001109}
1110
Sebastian Redlb3298c32010-08-18 23:56:48 +00001111void ASTDeclReader::VisitClassTemplatePartialSpecializationDecl(
Chris Lattnerca025db2010-05-07 21:43:38 +00001112 ClassTemplatePartialSpecializationDecl *D) {
Argyrios Kyrtzidis818c5db2010-06-23 13:48:30 +00001113 VisitClassTemplateSpecializationDecl(D);
1114
Argyrios Kyrtzidis0e8b3ce2010-09-13 11:45:41 +00001115 ASTContext &C = *Reader.getContext();
Sebastian Redl2c373b92010-10-05 15:59:54 +00001116 D->TemplateParams = Reader.ReadTemplateParameterList(F, Record, Idx);
Argyrios Kyrtzidis0e8b3ce2010-09-13 11:45:41 +00001117
Argyrios Kyrtzidis818c5db2010-06-23 13:48:30 +00001118 unsigned NumArgs = Record[Idx++];
Argyrios Kyrtzidis0e8b3ce2010-09-13 11:45:41 +00001119 if (NumArgs) {
1120 D->NumArgsAsWritten = NumArgs;
1121 D->ArgsAsWritten = new (C) TemplateArgumentLoc[NumArgs];
1122 for (unsigned i=0; i != NumArgs; ++i)
Sebastian Redl2c373b92010-10-05 15:59:54 +00001123 D->ArgsAsWritten[i] = Reader.ReadTemplateArgumentLoc(F, Record, Idx);
Argyrios Kyrtzidis0e8b3ce2010-09-13 11:45:41 +00001124 }
1125
1126 D->SequenceNumber = Record[Idx++];
Argyrios Kyrtzidis818c5db2010-06-23 13:48:30 +00001127
1128 // These are read/set from/to the first declaration.
1129 if (D->getPreviousDeclaration() == 0) {
Argyrios Kyrtzidis0e8b3ce2010-09-13 11:45:41 +00001130 D->InstantiatedFromMember.setPointer(
Argyrios Kyrtzidis818c5db2010-06-23 13:48:30 +00001131 cast_or_null<ClassTemplatePartialSpecializationDecl>(
1132 Reader.GetDecl(Record[Idx++])));
Argyrios Kyrtzidis0e8b3ce2010-09-13 11:45:41 +00001133 D->InstantiatedFromMember.setInt(Record[Idx++]);
Argyrios Kyrtzidis818c5db2010-06-23 13:48:30 +00001134 }
Chris Lattnerca025db2010-05-07 21:43:38 +00001135}
1136
Sebastian Redlb3298c32010-08-18 23:56:48 +00001137void ASTDeclReader::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
Peter Collingbourne91b25b72010-07-29 16:11:51 +00001138 VisitRedeclarableTemplateDecl(D);
Argyrios Kyrtzidis69da4a82010-06-22 09:55:07 +00001139
Peter Collingbourne91b25b72010-07-29 16:11:51 +00001140 if (D->getPreviousDeclaration() == 0) {
Argyrios Kyrtzidis69da4a82010-06-22 09:55:07 +00001141 // This FunctionTemplateDecl owns a CommonPtr; read it.
1142
Argyrios Kyrtzidis39fdf812010-07-06 15:37:09 +00001143 // Read the function specialization declarations.
1144 // FunctionTemplateDecl's FunctionTemplateSpecializationInfos are filled
Argyrios Kyrtzidisf24d5692010-09-13 11:45:48 +00001145 // when reading the specialized FunctionDecl.
Argyrios Kyrtzidis39fdf812010-07-06 15:37:09 +00001146 unsigned NumSpecs = Record[Idx++];
1147 while (NumSpecs--)
1148 Reader.GetDecl(Record[Idx++]);
Argyrios Kyrtzidis69da4a82010-06-22 09:55:07 +00001149 }
Chris Lattnerca025db2010-05-07 21:43:38 +00001150}
1151
Sebastian Redlb3298c32010-08-18 23:56:48 +00001152void ASTDeclReader::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
Argyrios Kyrtzidis95c04ca2010-06-19 19:29:09 +00001153 VisitTypeDecl(D);
1154
1155 D->setDeclaredWithTypename(Record[Idx++]);
1156 D->setParameterPack(Record[Idx++]);
1157
1158 bool Inherited = Record[Idx++];
Sebastian Redl2c373b92010-10-05 15:59:54 +00001159 TypeSourceInfo *DefArg = GetTypeSourceInfo(Record, Idx);
Argyrios Kyrtzidis95c04ca2010-06-19 19:29:09 +00001160 D->setDefaultArgument(DefArg, Inherited);
Chris Lattnerca025db2010-05-07 21:43:38 +00001161}
1162
Sebastian Redlb3298c32010-08-18 23:56:48 +00001163void ASTDeclReader::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) {
Argyrios Kyrtzidisb1d38e32010-06-25 16:25:09 +00001164 VisitVarDecl(D);
1165 // TemplateParmPosition.
1166 D->setDepth(Record[Idx++]);
1167 D->setPosition(Record[Idx++]);
Douglas Gregor0231d8d2011-01-19 20:10:05 +00001168 if (D->isExpandedParameterPack()) {
1169 void **Data = reinterpret_cast<void **>(D + 1);
1170 for (unsigned I = 0, N = D->getNumExpansionTypes(); I != N; ++I) {
1171 Data[2*I] = Reader.GetType(Record[Idx++]).getAsOpaquePtr();
1172 Data[2*I + 1] = GetTypeSourceInfo(Record, Idx);
1173 }
1174 } else {
1175 // Rest of NonTypeTemplateParmDecl.
1176 D->ParameterPack = Record[Idx++];
1177 if (Record[Idx++]) {
1178 Expr *DefArg = Reader.ReadExpr(F);
1179 bool Inherited = Record[Idx++];
1180 D->setDefaultArgument(DefArg, Inherited);
1181 }
1182 }
Chris Lattnerca025db2010-05-07 21:43:38 +00001183}
1184
Sebastian Redlb3298c32010-08-18 23:56:48 +00001185void ASTDeclReader::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) {
Argyrios Kyrtzidis9f2d24a2010-07-08 17:12:57 +00001186 VisitTemplateDecl(D);
1187 // TemplateParmPosition.
1188 D->setDepth(Record[Idx++]);
1189 D->setPosition(Record[Idx++]);
1190 // Rest of TemplateTemplateParmDecl.
Sebastian Redl2c373b92010-10-05 15:59:54 +00001191 TemplateArgumentLoc Arg = Reader.ReadTemplateArgumentLoc(F, Record, Idx);
Argyrios Kyrtzidis9f2d24a2010-07-08 17:12:57 +00001192 bool IsInherited = Record[Idx++];
1193 D->setDefaultArgument(Arg, IsInherited);
Douglas Gregorf5500772011-01-05 15:48:55 +00001194 D->ParameterPack = Record[Idx++];
Chris Lattnerca025db2010-05-07 21:43:38 +00001195}
1196
Sebastian Redlb3298c32010-08-18 23:56:48 +00001197void ASTDeclReader::VisitStaticAssertDecl(StaticAssertDecl *D) {
Argyrios Kyrtzidis2d8891c2010-07-22 17:28:12 +00001198 VisitDecl(D);
Sebastian Redl2c373b92010-10-05 15:59:54 +00001199 D->AssertExpr = Reader.ReadExpr(F);
1200 D->Message = cast<StringLiteral>(Reader.ReadExpr(F));
Chris Lattnerca025db2010-05-07 21:43:38 +00001201}
1202
Mike Stump11289f42009-09-09 15:08:12 +00001203std::pair<uint64_t, uint64_t>
Sebastian Redlb3298c32010-08-18 23:56:48 +00001204ASTDeclReader::VisitDeclContext(DeclContext *DC) {
Chris Lattner487412d2009-04-27 05:27:42 +00001205 uint64_t LexicalOffset = Record[Idx++];
1206 uint64_t VisibleOffset = Record[Idx++];
1207 return std::make_pair(LexicalOffset, VisibleOffset);
1208}
1209
Argyrios Kyrtzidis839bbac2010-08-03 17:30:10 +00001210template <typename T>
Sebastian Redlb3298c32010-08-18 23:56:48 +00001211void ASTDeclReader::VisitRedeclarable(Redeclarable<T> *D) {
Argyrios Kyrtzidis839bbac2010-08-03 17:30:10 +00001212 enum RedeclKind { NoRedeclaration = 0, PointsToPrevious, PointsToLatest };
1213 RedeclKind Kind = (RedeclKind)Record[Idx++];
1214 switch (Kind) {
1215 default:
Sebastian Redlb3298c32010-08-18 23:56:48 +00001216 assert(0 && "Out of sync with ASTDeclWriter::VisitRedeclarable or messed up"
Argyrios Kyrtzidis839bbac2010-08-03 17:30:10 +00001217 " reading");
1218 case NoRedeclaration:
1219 break;
1220 case PointsToPrevious:
1221 D->RedeclLink = typename Redeclarable<T>::PreviousDeclLink(
1222 cast_or_null<T>(Reader.GetDecl(Record[Idx++])));
1223 break;
1224 case PointsToLatest:
1225 D->RedeclLink = typename Redeclarable<T>::LatestDeclLink(
1226 cast_or_null<T>(Reader.GetDecl(Record[Idx++])));
1227 break;
1228 }
1229
1230 assert(!(Kind == PointsToPrevious &&
1231 Reader.FirstLatestDeclIDs.find(ThisDeclID) !=
1232 Reader.FirstLatestDeclIDs.end()) &&
1233 "This decl is not first, it should not be in the map");
1234 if (Kind == PointsToPrevious)
1235 return;
1236
1237 // This decl is a first one and the latest declaration that it points to is in
Sebastian Redld44cd6a2010-08-18 23:57:06 +00001238 // the same AST file. However, if this actually needs to point to a
1239 // redeclaration in another AST file, we need to update it by checking the
Argyrios Kyrtzidis839bbac2010-08-03 17:30:10 +00001240 // FirstLatestDeclIDs map which tracks this kind of decls.
1241 assert(Reader.GetDecl(ThisDeclID) == static_cast<T*>(D) &&
1242 "Invalid ThisDeclID ?");
Sebastian Redl2c499f62010-08-18 23:56:43 +00001243 ASTReader::FirstLatestDeclIDMap::iterator I
Argyrios Kyrtzidis839bbac2010-08-03 17:30:10 +00001244 = Reader.FirstLatestDeclIDs.find(ThisDeclID);
1245 if (I != Reader.FirstLatestDeclIDs.end()) {
1246 Decl *NewLatest = Reader.GetDecl(I->second);
Argyrios Kyrtzidis839bbac2010-08-03 17:30:10 +00001247 D->RedeclLink
1248 = typename Redeclarable<T>::LatestDeclLink(cast_or_null<T>(NewLatest));
1249 }
1250}
1251
Chris Lattner487412d2009-04-27 05:27:42 +00001252//===----------------------------------------------------------------------===//
Chris Lattner8f63ab52009-04-27 06:01:06 +00001253// Attribute Reading
Chris Lattner487412d2009-04-27 05:27:42 +00001254//===----------------------------------------------------------------------===//
1255
Chris Lattner8f63ab52009-04-27 06:01:06 +00001256/// \brief Reads attributes from the current stream position.
Argyrios Kyrtzidis9beef8e2010-10-18 19:20:11 +00001257void ASTReader::ReadAttributes(PerFileData &F, AttrVec &Attrs,
1258 const RecordData &Record, unsigned &Idx) {
1259 for (unsigned i = 0, e = Record[Idx++]; i != e; ++i) {
Chris Lattner8f63ab52009-04-27 06:01:06 +00001260 Attr *New = 0;
Alexis Hunt344393e2010-06-16 23:43:53 +00001261 attr::Kind Kind = (attr::Kind)Record[Idx++];
Sebastian Redl2c373b92010-10-05 15:59:54 +00001262 SourceLocation Loc = ReadSourceLocation(F, Record, Idx);
Chris Lattner8f63ab52009-04-27 06:01:06 +00001263
Alexis Huntdcfba7b2010-08-18 23:23:40 +00001264#include "clang/Serialization/AttrPCHRead.inc"
Chris Lattner8f63ab52009-04-27 06:01:06 +00001265
1266 assert(New && "Unable to decode attribute?");
Alexis Huntdcfba7b2010-08-18 23:23:40 +00001267 Attrs.push_back(New);
Chris Lattner8f63ab52009-04-27 06:01:06 +00001268 }
Chris Lattner8f63ab52009-04-27 06:01:06 +00001269}
1270
1271//===----------------------------------------------------------------------===//
Sebastian Redl2c499f62010-08-18 23:56:43 +00001272// ASTReader Implementation
Chris Lattner8f63ab52009-04-27 06:01:06 +00001273//===----------------------------------------------------------------------===//
Chris Lattner487412d2009-04-27 05:27:42 +00001274
1275/// \brief Note that we have loaded the declaration with the given
1276/// Index.
Mike Stump11289f42009-09-09 15:08:12 +00001277///
Chris Lattner487412d2009-04-27 05:27:42 +00001278/// This routine notes that this declaration has already been loaded,
1279/// so that future GetDecl calls will return this declaration rather
1280/// than trying to load a new declaration.
Sebastian Redl2c499f62010-08-18 23:56:43 +00001281inline void ASTReader::LoadedDecl(unsigned Index, Decl *D) {
Chris Lattner487412d2009-04-27 05:27:42 +00001282 assert(!DeclsLoaded[Index] && "Decl loaded twice?");
1283 DeclsLoaded[Index] = D;
1284}
1285
1286
1287/// \brief Determine whether the consumer will be interested in seeing
1288/// this declaration (via HandleTopLevelDecl).
1289///
1290/// This routine should return true for anything that might affect
1291/// code generation, e.g., inline function definitions, Objective-C
1292/// declarations with metadata, etc.
1293static bool isConsumerInterestedIn(Decl *D) {
Daniel Dunbar865c2a72009-09-17 03:06:44 +00001294 if (isa<FileScopeAsmDecl>(D))
1295 return true;
Chris Lattner487412d2009-04-27 05:27:42 +00001296 if (VarDecl *Var = dyn_cast<VarDecl>(D))
Argyrios Kyrtzidis4ba81b22010-08-05 09:47:59 +00001297 return Var->isFileVarDecl() &&
1298 Var->isThisDeclarationADefinition() == VarDecl::Definition;
Chris Lattner487412d2009-04-27 05:27:42 +00001299 if (FunctionDecl *Func = dyn_cast<FunctionDecl>(D))
1300 return Func->isThisDeclarationADefinition();
Argyrios Kyrtzidis13257c52010-08-09 10:54:20 +00001301 return isa<ObjCProtocolDecl>(D) || isa<ObjCImplementationDecl>(D);
Chris Lattner487412d2009-04-27 05:27:42 +00001302}
1303
Sebastian Redl34627792010-07-20 22:46:15 +00001304/// \brief Get the correct cursor and offset for loading a type.
Sebastian Redl2c499f62010-08-18 23:56:43 +00001305ASTReader::RecordLocation
Sebastian Redl539c5062010-08-18 23:57:32 +00001306ASTReader::DeclCursorForIndex(unsigned Index, DeclID ID) {
Sebastian Redle7c1fe62010-08-13 00:28:03 +00001307 // See if there's an override.
1308 DeclReplacementMap::iterator It = ReplacedDecls.find(ID);
1309 if (It != ReplacedDecls.end())
Sebastian Redl2c373b92010-10-05 15:59:54 +00001310 return RecordLocation(It->second.first, It->second.second);
Sebastian Redle7c1fe62010-08-13 00:28:03 +00001311
Sebastian Redl34627792010-07-20 22:46:15 +00001312 PerFileData *F = 0;
1313 for (unsigned I = 0, N = Chain.size(); I != N; ++I) {
1314 F = Chain[N - I - 1];
1315 if (Index < F->LocalNumDecls)
1316 break;
1317 Index -= F->LocalNumDecls;
1318 }
1319 assert(F && F->LocalNumDecls > Index && "Broken chain");
Sebastian Redl2c373b92010-10-05 15:59:54 +00001320 return RecordLocation(F, F->DeclOffsets[Index]);
Sebastian Redl34627792010-07-20 22:46:15 +00001321}
1322
Sebastian Redlb3298c32010-08-18 23:56:48 +00001323/// \brief Read the declaration at the given offset from the AST file.
Sebastian Redl539c5062010-08-18 23:57:32 +00001324Decl *ASTReader::ReadDeclRecord(unsigned Index, DeclID ID) {
Sebastian Redle7c1fe62010-08-13 00:28:03 +00001325 RecordLocation Loc = DeclCursorForIndex(Index, ID);
Sebastian Redl2c373b92010-10-05 15:59:54 +00001326 llvm::BitstreamCursor &DeclsCursor = Loc.F->DeclsCursor;
Chris Lattner487412d2009-04-27 05:27:42 +00001327 // Keep track of where we are in the stream, then jump back there
1328 // after reading this declaration.
Chris Lattner1de76db2009-04-27 05:58:23 +00001329 SavedStreamPosition SavedPosition(DeclsCursor);
Chris Lattner487412d2009-04-27 05:27:42 +00001330
Argyrios Kyrtzidisd0795b22010-06-28 22:28:35 +00001331 ReadingKindTracker ReadingKind(Read_Decl, *this);
1332
Douglas Gregor1342e842009-07-06 18:54:52 +00001333 // Note that we are loading a declaration record.
Argyrios Kyrtzidisb24355a2010-07-30 10:03:16 +00001334 Deserializing ADecl(this);
Mike Stump11289f42009-09-09 15:08:12 +00001335
Sebastian Redl2c373b92010-10-05 15:59:54 +00001336 DeclsCursor.JumpToBit(Loc.Offset);
Chris Lattner487412d2009-04-27 05:27:42 +00001337 RecordData Record;
Chris Lattner1de76db2009-04-27 05:58:23 +00001338 unsigned Code = DeclsCursor.ReadCode();
Chris Lattner487412d2009-04-27 05:27:42 +00001339 unsigned Idx = 0;
Sebastian Redl2c373b92010-10-05 15:59:54 +00001340 ASTDeclReader Reader(*this, *Loc.F, DeclsCursor, ID, Record, Idx);
Chris Lattner487412d2009-04-27 05:27:42 +00001341
Chris Lattner1de76db2009-04-27 05:58:23 +00001342 Decl *D = 0;
Sebastian Redl539c5062010-08-18 23:57:32 +00001343 switch ((DeclCode)DeclsCursor.ReadRecord(Code, Record)) {
Sebastian Redl539c5062010-08-18 23:57:32 +00001344 case DECL_CONTEXT_LEXICAL:
1345 case DECL_CONTEXT_VISIBLE:
Chris Lattner487412d2009-04-27 05:27:42 +00001346 assert(false && "Record cannot be de-serialized with ReadDeclRecord");
1347 break;
Sebastian Redl539c5062010-08-18 23:57:32 +00001348 case DECL_TRANSLATION_UNIT:
Chris Lattner487412d2009-04-27 05:27:42 +00001349 assert(Index == 0 && "Translation unit must be at index 0");
Chris Lattner8575daa2009-04-27 21:45:14 +00001350 D = Context->getTranslationUnitDecl();
Chris Lattner487412d2009-04-27 05:27:42 +00001351 break;
Sebastian Redl539c5062010-08-18 23:57:32 +00001352 case DECL_TYPEDEF:
John McCall703a3f82009-10-24 08:00:42 +00001353 D = TypedefDecl::Create(*Context, 0, SourceLocation(), 0, 0);
Chris Lattner487412d2009-04-27 05:27:42 +00001354 break;
Sebastian Redl539c5062010-08-18 23:57:32 +00001355 case DECL_ENUM:
Argyrios Kyrtzidis39f0e302010-07-02 11:54:55 +00001356 D = EnumDecl::Create(*Context, Decl::EmptyShell());
Chris Lattner487412d2009-04-27 05:27:42 +00001357 break;
Sebastian Redl539c5062010-08-18 23:57:32 +00001358 case DECL_RECORD:
Argyrios Kyrtzidis39f0e302010-07-02 11:54:55 +00001359 D = RecordDecl::Create(*Context, Decl::EmptyShell());
Chris Lattner487412d2009-04-27 05:27:42 +00001360 break;
Sebastian Redl539c5062010-08-18 23:57:32 +00001361 case DECL_ENUM_CONSTANT:
Chris Lattner8575daa2009-04-27 21:45:14 +00001362 D = EnumConstantDecl::Create(*Context, 0, SourceLocation(), 0, QualType(),
Chris Lattner487412d2009-04-27 05:27:42 +00001363 0, llvm::APSInt());
1364 break;
Sebastian Redl539c5062010-08-18 23:57:32 +00001365 case DECL_FUNCTION:
Mike Stump11289f42009-09-09 15:08:12 +00001366 D = FunctionDecl::Create(*Context, 0, SourceLocation(), DeclarationName(),
Argyrios Kyrtzidis60ed5602009-08-19 01:27:57 +00001367 QualType(), 0);
Chris Lattner487412d2009-04-27 05:27:42 +00001368 break;
Sebastian Redl539c5062010-08-18 23:57:32 +00001369 case DECL_LINKAGE_SPEC:
Chris Lattnerca025db2010-05-07 21:43:38 +00001370 D = LinkageSpecDecl::Create(*Context, 0, SourceLocation(),
1371 (LinkageSpecDecl::LanguageIDs)0,
1372 false);
1373 break;
Sebastian Redl539c5062010-08-18 23:57:32 +00001374 case DECL_NAMESPACE:
Chris Lattnerca025db2010-05-07 21:43:38 +00001375 D = NamespaceDecl::Create(*Context, 0, SourceLocation(), 0);
1376 break;
Sebastian Redl539c5062010-08-18 23:57:32 +00001377 case DECL_NAMESPACE_ALIAS:
Chris Lattnerca025db2010-05-07 21:43:38 +00001378 D = NamespaceAliasDecl::Create(*Context, 0, SourceLocation(),
1379 SourceLocation(), 0, SourceRange(), 0,
1380 SourceLocation(), 0);
1381 break;
Sebastian Redl539c5062010-08-18 23:57:32 +00001382 case DECL_USING:
Abramo Bagnara8de74e92010-08-12 11:46:03 +00001383 D = UsingDecl::Create(*Context, 0, SourceRange(), SourceLocation(),
1384 0, DeclarationNameInfo(), false);
Chris Lattnerca025db2010-05-07 21:43:38 +00001385 break;
Sebastian Redl539c5062010-08-18 23:57:32 +00001386 case DECL_USING_SHADOW:
Chris Lattnerca025db2010-05-07 21:43:38 +00001387 D = UsingShadowDecl::Create(*Context, 0, SourceLocation(), 0, 0);
1388 break;
Sebastian Redl539c5062010-08-18 23:57:32 +00001389 case DECL_USING_DIRECTIVE:
Chris Lattnerca025db2010-05-07 21:43:38 +00001390 D = UsingDirectiveDecl::Create(*Context, 0, SourceLocation(),
1391 SourceLocation(), SourceRange(), 0,
1392 SourceLocation(), 0, 0);
1393 break;
Sebastian Redl539c5062010-08-18 23:57:32 +00001394 case DECL_UNRESOLVED_USING_VALUE:
Chris Lattnerca025db2010-05-07 21:43:38 +00001395 D = UnresolvedUsingValueDecl::Create(*Context, 0, SourceLocation(),
Abramo Bagnara8de74e92010-08-12 11:46:03 +00001396 SourceRange(), 0,
1397 DeclarationNameInfo());
Chris Lattnerca025db2010-05-07 21:43:38 +00001398 break;
Sebastian Redl539c5062010-08-18 23:57:32 +00001399 case DECL_UNRESOLVED_USING_TYPENAME:
Chris Lattnerca025db2010-05-07 21:43:38 +00001400 D = UnresolvedUsingTypenameDecl::Create(*Context, 0, SourceLocation(),
1401 SourceLocation(), SourceRange(),
1402 0, SourceLocation(),
1403 DeclarationName());
1404 break;
Sebastian Redl539c5062010-08-18 23:57:32 +00001405 case DECL_CXX_RECORD:
Argyrios Kyrtzidis39f0e302010-07-02 11:54:55 +00001406 D = CXXRecordDecl::Create(*Context, Decl::EmptyShell());
Chris Lattnerca025db2010-05-07 21:43:38 +00001407 break;
Sebastian Redl539c5062010-08-18 23:57:32 +00001408 case DECL_CXX_METHOD:
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00001409 D = CXXMethodDecl::Create(*Context, 0, DeclarationNameInfo(),
Chris Lattnerca025db2010-05-07 21:43:38 +00001410 QualType(), 0);
1411 break;
Sebastian Redl539c5062010-08-18 23:57:32 +00001412 case DECL_CXX_CONSTRUCTOR:
Chris Lattnerca025db2010-05-07 21:43:38 +00001413 D = CXXConstructorDecl::Create(*Context, Decl::EmptyShell());
1414 break;
Sebastian Redl539c5062010-08-18 23:57:32 +00001415 case DECL_CXX_DESTRUCTOR:
Chris Lattnerca025db2010-05-07 21:43:38 +00001416 D = CXXDestructorDecl::Create(*Context, Decl::EmptyShell());
1417 break;
Sebastian Redl539c5062010-08-18 23:57:32 +00001418 case DECL_CXX_CONVERSION:
Chris Lattnerca025db2010-05-07 21:43:38 +00001419 D = CXXConversionDecl::Create(*Context, Decl::EmptyShell());
1420 break;
Sebastian Redl539c5062010-08-18 23:57:32 +00001421 case DECL_ACCESS_SPEC:
Argyrios Kyrtzidis260b4a82010-09-08 21:32:35 +00001422 D = AccessSpecDecl::Create(*Context, Decl::EmptyShell());
Abramo Bagnarad7340582010-06-05 05:09:32 +00001423 break;
Sebastian Redl539c5062010-08-18 23:57:32 +00001424 case DECL_FRIEND:
Argyrios Kyrtzidis74d28bd2010-06-29 22:47:00 +00001425 D = FriendDecl::Create(*Context, Decl::EmptyShell());
Chris Lattnerca025db2010-05-07 21:43:38 +00001426 break;
Sebastian Redl539c5062010-08-18 23:57:32 +00001427 case DECL_FRIEND_TEMPLATE:
Argyrios Kyrtzidis165b5812010-07-22 16:04:10 +00001428 D = FriendTemplateDecl::Create(*Context, Decl::EmptyShell());
Chris Lattnerca025db2010-05-07 21:43:38 +00001429 break;
Sebastian Redl539c5062010-08-18 23:57:32 +00001430 case DECL_CLASS_TEMPLATE:
Argyrios Kyrtzidisa35c8e42010-06-21 10:57:41 +00001431 D = ClassTemplateDecl::Create(*Context, 0, SourceLocation(),
1432 DeclarationName(), 0, 0, 0);
Chris Lattnerca025db2010-05-07 21:43:38 +00001433 break;
Sebastian Redl539c5062010-08-18 23:57:32 +00001434 case DECL_CLASS_TEMPLATE_SPECIALIZATION:
Argyrios Kyrtzidis39f0e302010-07-02 11:54:55 +00001435 D = ClassTemplateSpecializationDecl::Create(*Context, Decl::EmptyShell());
Chris Lattnerca025db2010-05-07 21:43:38 +00001436 break;
Sebastian Redl539c5062010-08-18 23:57:32 +00001437 case DECL_CLASS_TEMPLATE_PARTIAL_SPECIALIZATION:
Argyrios Kyrtzidis39f0e302010-07-02 11:54:55 +00001438 D = ClassTemplatePartialSpecializationDecl::Create(*Context,
1439 Decl::EmptyShell());
Chris Lattnerca025db2010-05-07 21:43:38 +00001440 break;
Sebastian Redl539c5062010-08-18 23:57:32 +00001441 case DECL_FUNCTION_TEMPLATE:
Argyrios Kyrtzidis69da4a82010-06-22 09:55:07 +00001442 D = FunctionTemplateDecl::Create(*Context, 0, SourceLocation(),
1443 DeclarationName(), 0, 0);
Chris Lattnerca025db2010-05-07 21:43:38 +00001444 break;
Sebastian Redl539c5062010-08-18 23:57:32 +00001445 case DECL_TEMPLATE_TYPE_PARM:
Argyrios Kyrtzidis39f0e302010-07-02 11:54:55 +00001446 D = TemplateTypeParmDecl::Create(*Context, Decl::EmptyShell());
Chris Lattnerca025db2010-05-07 21:43:38 +00001447 break;
Sebastian Redl539c5062010-08-18 23:57:32 +00001448 case DECL_NON_TYPE_TEMPLATE_PARM:
Argyrios Kyrtzidisb1d38e32010-06-25 16:25:09 +00001449 D = NonTypeTemplateParmDecl::Create(*Context, 0, SourceLocation(), 0,0,0,
Douglas Gregorda3cc0d2010-12-23 23:51:58 +00001450 QualType(), false, 0);
Chris Lattnerca025db2010-05-07 21:43:38 +00001451 break;
Douglas Gregor0231d8d2011-01-19 20:10:05 +00001452 case DECL_EXPANDED_NON_TYPE_TEMPLATE_PARM_PACK:
1453 D = NonTypeTemplateParmDecl::Create(*Context, 0, SourceLocation(), 0, 0,
1454 0, QualType(), 0, 0, Record[Idx++],
1455 0);
1456 break;
Sebastian Redl539c5062010-08-18 23:57:32 +00001457 case DECL_TEMPLATE_TEMPLATE_PARM:
Douglas Gregorf5500772011-01-05 15:48:55 +00001458 D = TemplateTemplateParmDecl::Create(*Context, 0, SourceLocation(), 0, 0,
1459 false, 0, 0);
Chris Lattnerca025db2010-05-07 21:43:38 +00001460 break;
Sebastian Redl539c5062010-08-18 23:57:32 +00001461 case DECL_STATIC_ASSERT:
Argyrios Kyrtzidis2d8891c2010-07-22 17:28:12 +00001462 D = StaticAssertDecl::Create(*Context, 0, SourceLocation(), 0, 0);
Chris Lattnerca025db2010-05-07 21:43:38 +00001463 break;
1464
Sebastian Redl539c5062010-08-18 23:57:32 +00001465 case DECL_OBJC_METHOD:
Mike Stump11289f42009-09-09 15:08:12 +00001466 D = ObjCMethodDecl::Create(*Context, SourceLocation(), SourceLocation(),
Douglas Gregor12852d92010-03-08 14:59:44 +00001467 Selector(), QualType(), 0, 0);
Chris Lattner487412d2009-04-27 05:27:42 +00001468 break;
Sebastian Redl539c5062010-08-18 23:57:32 +00001469 case DECL_OBJC_INTERFACE:
Douglas Gregor1c283312010-08-11 12:19:30 +00001470 D = ObjCInterfaceDecl::Create(*Context, 0, SourceLocation(), 0);
Chris Lattner487412d2009-04-27 05:27:42 +00001471 break;
Sebastian Redl539c5062010-08-18 23:57:32 +00001472 case DECL_OBJC_IVAR:
Argyrios Kyrtzidis60ed5602009-08-19 01:27:57 +00001473 D = ObjCIvarDecl::Create(*Context, 0, SourceLocation(), 0, QualType(), 0,
Chris Lattner487412d2009-04-27 05:27:42 +00001474 ObjCIvarDecl::None);
1475 break;
Sebastian Redl539c5062010-08-18 23:57:32 +00001476 case DECL_OBJC_PROTOCOL:
Chris Lattner8575daa2009-04-27 21:45:14 +00001477 D = ObjCProtocolDecl::Create(*Context, 0, SourceLocation(), 0);
Chris Lattner487412d2009-04-27 05:27:42 +00001478 break;
Sebastian Redl539c5062010-08-18 23:57:32 +00001479 case DECL_OBJC_AT_DEFS_FIELD:
Mike Stump11289f42009-09-09 15:08:12 +00001480 D = ObjCAtDefsFieldDecl::Create(*Context, 0, SourceLocation(), 0,
Chris Lattner487412d2009-04-27 05:27:42 +00001481 QualType(), 0);
1482 break;
Sebastian Redl539c5062010-08-18 23:57:32 +00001483 case DECL_OBJC_CLASS:
Chris Lattner8575daa2009-04-27 21:45:14 +00001484 D = ObjCClassDecl::Create(*Context, 0, SourceLocation());
Chris Lattner487412d2009-04-27 05:27:42 +00001485 break;
Sebastian Redl539c5062010-08-18 23:57:32 +00001486 case DECL_OBJC_FORWARD_PROTOCOL:
Chris Lattner8575daa2009-04-27 21:45:14 +00001487 D = ObjCForwardProtocolDecl::Create(*Context, 0, SourceLocation());
Chris Lattner487412d2009-04-27 05:27:42 +00001488 break;
Sebastian Redl539c5062010-08-18 23:57:32 +00001489 case DECL_OBJC_CATEGORY:
Douglas Gregor071676f2010-01-16 16:38:58 +00001490 D = ObjCCategoryDecl::Create(*Context, 0, SourceLocation(),
1491 SourceLocation(), SourceLocation(), 0);
Chris Lattner487412d2009-04-27 05:27:42 +00001492 break;
Sebastian Redl539c5062010-08-18 23:57:32 +00001493 case DECL_OBJC_CATEGORY_IMPL:
Chris Lattner8575daa2009-04-27 21:45:14 +00001494 D = ObjCCategoryImplDecl::Create(*Context, 0, SourceLocation(), 0, 0);
Chris Lattner487412d2009-04-27 05:27:42 +00001495 break;
Sebastian Redl539c5062010-08-18 23:57:32 +00001496 case DECL_OBJC_IMPLEMENTATION:
Chris Lattner8575daa2009-04-27 21:45:14 +00001497 D = ObjCImplementationDecl::Create(*Context, 0, SourceLocation(), 0, 0);
Chris Lattner487412d2009-04-27 05:27:42 +00001498 break;
Sebastian Redl539c5062010-08-18 23:57:32 +00001499 case DECL_OBJC_COMPATIBLE_ALIAS:
Chris Lattner8575daa2009-04-27 21:45:14 +00001500 D = ObjCCompatibleAliasDecl::Create(*Context, 0, SourceLocation(), 0, 0);
Chris Lattner487412d2009-04-27 05:27:42 +00001501 break;
Sebastian Redl539c5062010-08-18 23:57:32 +00001502 case DECL_OBJC_PROPERTY:
Fariborz Jahanianda8ec2b2010-01-21 17:36:00 +00001503 D = ObjCPropertyDecl::Create(*Context, 0, SourceLocation(), 0, SourceLocation(),
John McCall339bb662010-06-04 20:50:08 +00001504 0);
Chris Lattner487412d2009-04-27 05:27:42 +00001505 break;
Sebastian Redl539c5062010-08-18 23:57:32 +00001506 case DECL_OBJC_PROPERTY_IMPL:
Chris Lattner8575daa2009-04-27 21:45:14 +00001507 D = ObjCPropertyImplDecl::Create(*Context, 0, SourceLocation(),
Mike Stump11289f42009-09-09 15:08:12 +00001508 SourceLocation(), 0,
Douglas Gregorb1b71e52010-11-17 01:03:52 +00001509 ObjCPropertyImplDecl::Dynamic, 0,
1510 SourceLocation());
Chris Lattner487412d2009-04-27 05:27:42 +00001511 break;
Sebastian Redl539c5062010-08-18 23:57:32 +00001512 case DECL_FIELD:
Mike Stump11289f42009-09-09 15:08:12 +00001513 D = FieldDecl::Create(*Context, 0, SourceLocation(), 0, QualType(), 0, 0,
Argyrios Kyrtzidis6032ef12009-08-21 00:31:54 +00001514 false);
Chris Lattner487412d2009-04-27 05:27:42 +00001515 break;
Francois Pichet783dd6e2010-11-21 06:08:52 +00001516 case DECL_INDIRECTFIELD:
1517 D = IndirectFieldDecl::Create(*Context, 0, SourceLocation(), 0, QualType(),
1518 0, 0);
1519 break;
Sebastian Redl539c5062010-08-18 23:57:32 +00001520 case DECL_VAR:
Argyrios Kyrtzidis60ed5602009-08-19 01:27:57 +00001521 D = VarDecl::Create(*Context, 0, SourceLocation(), 0, QualType(), 0,
John McCall8e7d6562010-08-26 03:08:43 +00001522 SC_None, SC_None);
Chris Lattner487412d2009-04-27 05:27:42 +00001523 break;
1524
Sebastian Redl539c5062010-08-18 23:57:32 +00001525 case DECL_IMPLICIT_PARAM:
Chris Lattner8575daa2009-04-27 21:45:14 +00001526 D = ImplicitParamDecl::Create(*Context, 0, SourceLocation(), 0, QualType());
Chris Lattner487412d2009-04-27 05:27:42 +00001527 break;
1528
Sebastian Redl539c5062010-08-18 23:57:32 +00001529 case DECL_PARM_VAR:
Mike Stump11289f42009-09-09 15:08:12 +00001530 D = ParmVarDecl::Create(*Context, 0, SourceLocation(), 0, QualType(), 0,
John McCall8e7d6562010-08-26 03:08:43 +00001531 SC_None, SC_None, 0);
Chris Lattner487412d2009-04-27 05:27:42 +00001532 break;
Sebastian Redl539c5062010-08-18 23:57:32 +00001533 case DECL_FILE_SCOPE_ASM:
Chris Lattner8575daa2009-04-27 21:45:14 +00001534 D = FileScopeAsmDecl::Create(*Context, 0, SourceLocation(), 0);
Chris Lattner487412d2009-04-27 05:27:42 +00001535 break;
Sebastian Redl539c5062010-08-18 23:57:32 +00001536 case DECL_BLOCK:
Chris Lattner8575daa2009-04-27 21:45:14 +00001537 D = BlockDecl::Create(*Context, 0, SourceLocation());
Chris Lattner487412d2009-04-27 05:27:42 +00001538 break;
Douglas Gregord4c5ed02010-10-29 22:39:52 +00001539 case DECL_CXX_BASE_SPECIFIERS:
1540 Error("attempt to read a C++ base-specifier record as a declaration");
1541 return 0;
Chris Lattner487412d2009-04-27 05:27:42 +00001542 }
Chris Lattner487412d2009-04-27 05:27:42 +00001543
Sebastian Redlb3298c32010-08-18 23:56:48 +00001544 assert(D && "Unknown declaration reading AST file");
Chris Lattner8f63ab52009-04-27 06:01:06 +00001545 LoadedDecl(Index, D);
1546 Reader.Visit(D);
Chris Lattner487412d2009-04-27 05:27:42 +00001547
1548 // If this declaration is also a declaration context, get the
1549 // offsets for its tables of lexical and visible declarations.
1550 if (DeclContext *DC = dyn_cast<DeclContext>(D)) {
1551 std::pair<uint64_t, uint64_t> Offsets = Reader.VisitDeclContext(DC);
1552 if (Offsets.first || Offsets.second) {
1553 DC->setHasExternalLexicalStorage(Offsets.first != 0);
1554 DC->setHasExternalVisibleStorage(Offsets.second != 0);
Sebastian Redl66c5eef2010-07-27 00:17:23 +00001555 DeclContextInfo Info;
1556 if (ReadDeclContextStorage(DeclsCursor, Offsets, Info))
1557 return 0;
Sebastian Redl4b1f4902010-07-27 18:24:41 +00001558 DeclContextInfos &Infos = DeclContextOffsets[DC];
Sebastian Redld7dce0a2010-08-24 00:50:04 +00001559 // Reading the TU will happen after reading its lexical update blocks,
1560 // so we need to make sure we insert in front. For all other contexts,
1561 // the vector is empty here anyway, so there's no loss in efficiency.
Sebastian Redl4b1f4902010-07-27 18:24:41 +00001562 Infos.insert(Infos.begin(), Info);
Sebastian Redld7dce0a2010-08-24 00:50:04 +00001563
1564 // Now add the pending visible updates for this decl context, if it has
1565 // any.
1566 DeclContextVisibleUpdatesPending::iterator I =
1567 PendingVisibleUpdates.find(ID);
1568 if (I != PendingVisibleUpdates.end()) {
1569 DeclContextVisibleUpdates &U = I->second;
1570 Info.LexicalDecls = 0;
1571 Info.NumLexicalDecls = 0;
1572 for (DeclContextVisibleUpdates::iterator UI = U.begin(), UE = U.end();
1573 UI != UE; ++UI) {
1574 Info.NameLookupTableData = *UI;
1575 Infos.push_back(Info);
1576 }
1577 PendingVisibleUpdates.erase(I);
1578 }
Chris Lattner487412d2009-04-27 05:27:42 +00001579 }
1580 }
1581 assert(Idx == Record.size());
1582
Argyrios Kyrtzidis65ad5692010-10-24 17:26:36 +00001583 // The declaration may have been modified by files later in the chain.
1584 // If this is the case, read the record containing the updates from each file
1585 // and pass it to ASTDeclReader to make the modifications.
1586 DeclUpdateOffsetsMap::iterator UpdI = DeclUpdateOffsets.find(ID);
1587 if (UpdI != DeclUpdateOffsets.end()) {
1588 FileOffsetsTy &UpdateOffsets = UpdI->second;
1589 for (FileOffsetsTy::iterator
1590 I = UpdateOffsets.begin(), E = UpdateOffsets.end(); I != E; ++I) {
1591 PerFileData *F = I->first;
1592 uint64_t Offset = I->second;
1593 llvm::BitstreamCursor &Cursor = F->DeclsCursor;
1594 SavedStreamPosition SavedPosition(Cursor);
1595 Cursor.JumpToBit(Offset);
1596 RecordData Record;
1597 unsigned Code = Cursor.ReadCode();
1598 unsigned RecCode = Cursor.ReadRecord(Code, Record);
1599 (void)RecCode;
1600 assert(RecCode == DECL_UPDATES && "Expected DECL_UPDATES record!");
1601 Reader.UpdateDecl(D, Record);
1602 }
1603 }
1604
Chris Lattner487412d2009-04-27 05:27:42 +00001605 // If we have deserialized a declaration that has a definition the
Argyrios Kyrtzidis903ccd62010-07-07 15:46:26 +00001606 // AST consumer might need to know about, queue it.
1607 // We don't pass it to the consumer immediately because we may be in recursive
1608 // loading, and some declarations may still be initializing.
1609 if (isConsumerInterestedIn(D))
1610 InterestingDecls.push_back(D);
Chris Lattner487412d2009-04-27 05:27:42 +00001611
1612 return D;
1613}
Argyrios Kyrtzidis65ad5692010-10-24 17:26:36 +00001614
1615void ASTDeclReader::UpdateDecl(Decl *D, const RecordData &Record) {
Argyrios Kyrtzidisd170d842010-10-24 17:26:50 +00001616 unsigned Idx = 0;
1617 while (Idx < Record.size()) {
1618 switch ((DeclUpdateKind)Record[Idx++]) {
1619 case UPD_CXX_SET_DEFINITIONDATA: {
1620 CXXRecordDecl *RD = cast<CXXRecordDecl>(D);
1621 CXXRecordDecl *
1622 DefinitionDecl = cast<CXXRecordDecl>(Reader.GetDecl(Record[Idx++]));
1623 assert(!RD->DefinitionData && "DefinitionData is already set!");
1624 InitializeCXXDefinitionData(RD, DefinitionDecl, Record, Idx);
1625 break;
1626 }
Argyrios Kyrtzidise16a5302010-10-24 17:26:54 +00001627
1628 case UPD_CXX_ADDED_IMPLICIT_MEMBER:
1629 cast<CXXRecordDecl>(D)->addedMember(Reader.GetDecl(Record[Idx++]));
1630 break;
Argyrios Kyrtzidis402dbbb2010-10-28 07:38:42 +00001631
1632 case UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION:
1633 // It will be added to the template's specializations set when loaded.
1634 Reader.GetDecl(Record[Idx++]);
Argyrios Kyrtzidisd170d842010-10-24 17:26:50 +00001635 }
1636 }
Argyrios Kyrtzidis65ad5692010-10-24 17:26:36 +00001637}